@micacms/runtime 0.4.1 → 0.5.0-rc.2

package/dist/services/staging.js

@@ -1,488 +1,225 @@
 /**
- * Content staging: the orchestration between "saved" and "published".
+ * The staging service on a Git working tree. Autosave has already written the
+ * files; Publish commits the reviewed paths.
  *
- * Two implementations of one service, because the two deployment shapes have
- * genuinely different draft workspaces:
- *
- *   - working tree  (`staging-local.ts`): the checkout is the draft. Autosave
- *     writes files the Astro dev server can hot-reload, which is the whole
- *     value of local mode; Recent changes is `git status`, and Publish is a
- *     real commit and push through the developer's own Git.
- *   - draft store   (this file): the repository is remote and writing through
- *     its API would already be a commit, so saves accumulate in SQLite and
- *     Publish turns the whole set into one provider-side commit.
- *
- * The editor sees one API either way. What differs is only what Saved means —
- * and the two must stay visibly different words in the UI, because in neither
- * mode does Saved imply that a change is in Git.
- */
-import { MANIFEST_PATH, ORDER_FILE, collectionEntryPath, entryLayout, entryTitle, isValidSlug, readCollection, readCollectionEntry, readSingleton, relativizeMedia, resolveSlugField, singletonPath, toContentChange, validateFields, } from "@micacms/core";
-import { ApiError, badRequest } from "../lib/errors.js";
-/**
- * Reads one document from the repository (`published`) and from the pending
- * workspace (`staged`) — the whole of a before/after comparison, shared by
- * both staging implementations since a `ContentSource` is all it needs.
- *
- * An order target compares the collection's ordering rather than a document:
- * each side becomes `{ order: [{ slug, title }] }`, in position order.
- */
-export async function compareSources(model, published, staged, target) {
-    if (target.kind === "singleton") {
-        const def = model.singletons[target.name];
-        if (!def)
-            throw badRequest(`There is no singleton called "${target.name}".`);
-        return {
-            before: await readSingleton(published, def, target.name),
-            after: await readSingleton(staged, def, target.name),
-        };
-    }
-    const def = model.collections[target.collection];
-    if (!def)
-        throw badRequest(`There is no collection called "${target.collection}".`);
-    if (target.kind === "entry") {
-        const from = target.from ?? target.slug;
-        for (const slug of [target.slug, from]) {
-            if (!isValidSlug(slug))
-                throw badRequest(`"${slug}" is not a slug.`);
-        }
-        const before = await readCollectionEntry(published, def, target.collection, from);
-        const after = await readCollectionEntry(staged, def, target.collection, target.slug);
-        if (from === target.slug)
-            return { before, after };
-        // A rename: colocated media paths name the entry's folder, so they are
-        // compared in the on-disk form, where a moved file keeps its path.
-        return {
-            before: before && onDisk(def, target.collection, from, before),
-            after: after && onDisk(def, target.collection, target.slug, after),
-        };
-    }
-    const ordering = async (source) => {
-        const entries = await readCollection(source, def, target.collection);
-        if (entries.length === 0)
-            return null;
-        return {
-            order: entries.map((entry) => ({ slug: entry.slug, title: entryTitle(def, entry.data) })),
-        };
-    };
-    return { before: await ordering(published), after: await ordering(staged) };
-}
-/* ------------------------------------------------------------------ *
- * Understanding a change set
- * ------------------------------------------------------------------ */
-/**
- * Annotates a change set with owners and validates the entries it touches.
- *
- * One pass on purpose: naming a change and validating it both need the same
- * read of the same entries, and content trees are small enough to read the
- * affected collections whole.
- *
- * Validation is scoped to *changed* documents. Content that was already in
- * the repository is not this publication's problem — refusing
- * to publish a fixed typo because somebody once hand-committed a broken entry
- * elsewhere would make the editor hostage to history it cannot touch.
+ *   - Every Git operation is limited to an explicit path set, so other work in
+ *     the same checkout is never swept in.
+ *   - Only the reviewed files are published, as the editor saw them. Drafts of
+ *     other entries stay drafts.
+ *   - When the push fails, the commit stays as `committed-pending-push`; a
+ *     retry pushes and never commits again.
  */
-export async function analyseChanges(model, source, changes, 
-/** The repository's side. When given, renamed entries are detected. */
-published) {
-    const owners = changes.map((change) => classifyPath(model, change.path));
-    /* ------------------------------------------------------- reading */
-    const collectionsToRead = new Set();
-    for (const owner of owners) {
-        if (owner.kind === "entry" || owner.kind === "order")
-            collectionsToRead.add(owner.collection);
-    }
-    const problems = [];
-    const titles = new Map();
-    const entriesByCollection = new Map();
-    for (const name of collectionsToRead) {
-        const def = model.collections[name];
-        try {
-            const entries = await readCollection(source, def, name);
-            const bySlug = new Map(entries.map((entry) => [entry.slug, entry.data]));
-            entriesByCollection.set(name, bySlug);
-            for (const [slug, data] of bySlug)
-                titles.set(`${name}/${slug}`, entryTitle(def, data));
-        }
-        catch (error) {
-            // The collection cannot be read at all — a malformed file, possibly one
-            // this change set did not touch. Publication needs the whole picture,
-            // so the honest answer is the error, at the path it names.
-            const path = error.path ?? name;
-            problems.push({
-                path,
-                label: def.label,
-                issues: [{ path: "", message: error.message }],
-            });
-        }
-    }
-    if (published) {
-        await detectRenames(model, published, source, changes, owners, entriesByCollection);
-    }
-    /* ---------------------------------------------------- validation */
-    const validated = new Set();
-    for (const owner of owners) {
-        if (owner.kind === "entry") {
-            const key = `${owner.collection}/${owner.slug}`;
-            if (validated.has(key))
+import { MANIFEST_PATH, memorySource } from "@micacms/core";
+import { ApiError, badRequest, notFound } from "../lib/errors.js";
+import { developerPolicy } from "../workspace/developer.js";
+import { GitError } from "../workspace/git.js";
+import { createWorkspaceLocks } from "../workspace/locks.js";
+import { aheadOfUpstream, commitPaths, currentBranch, discardChange, headRevision, headSource, listTreeChanges, locateTree, } from "../workspace/tree.js";
+import { analyseChanges, compareSources, describeProblems, flattenProblems, } from "./changes.js";
+export function createWorkingTreeStagingService(deps) {
+    const { model, files, contentRoot, logger } = deps;
+    const policy = deps.policy ?? developerPolicy({ publishEnabled: deps.publishEnabled, logger });
+    const locks = deps.locks ?? createWorkspaceLocks();
+    const analyse = async (tree, treeChanges) => {
+        const { changes, validation } = await analyseChanges(model, files, treeChanges, headSource(tree));
+        // The field validator cannot see a merge conflict: the file holds Git's conflict format.
+        for (const change of treeChanges) {
+            if (!change.conflicted)
                 continue;
-            validated.add(key);
-            const def = model.collections[owner.collection];
-            // Absent means the change set deletes this entry; there is nothing left
-            // to validate, which is exactly right.
-            const data = entriesByCollection.get(owner.collection)?.get(owner.slug);
-            if (!data)
-                continue;
-            const result = validateFields(def.fields, data, "storage");
-            if (!result.ok) {
-                problems.push({
-                    path: entryDataPath(def, owner.collection, owner.slug),
-                    label: labelEntry(def, owner.slug, titles.get(key)),
-                    issues: result.issues,
-                });
-            }
-        }
-        if (owner.kind === "singleton" && !validated.has(`singleton:${owner.name}`)) {
-            validated.add(`singleton:${owner.name}`);
-            const def = model.singletons[owner.name];
-            const dataPath = singletonPath(def.fields, owner.name);
-            try {
-                const data = await readSingleton(source, def, owner.name);
-                if (data === null)
-                    continue;
-                const result = validateFields(def.fields, data, "storage");
-                if (!result.ok) {
-                    problems.push({ path: dataPath, label: def.label, issues: result.issues });
-                }
-            }
-            catch (error) {
-                problems.push({
-                    path: error.path ?? dataPath,
-                    label: def.label,
-                    issues: [{ path: "", message: error.message }],
-                });
-            }
-        }
-    }
-    /* ---------------------------------------------------- annotation */
-    const annotated = changes.map((change, index) => {
-        const owner = owners[index];
-        if (owner.kind === "entry") {
-            const def = model.collections[owner.collection];
-            return {
-                ...change,
-                owner: { ...owner, label: labelEntry(def, owner.slug, titles.get(`${owner.collection}/${owner.slug}`)) },
-            };
+            validation.problems.push({
+                path: change.path,
+                label: change.path,
+                issues: [
+                    { path: "", message: "This file has a Git merge conflict. Resolve it with your Git tools." },
+                ],
+            });
         }
-        return { ...change, owner };
-    });
-    return {
-        changes: annotated,
-        validation: { ok: problems.length === 0, problems },
+        validation.ok = validation.problems.length === 0;
+        return { changes, validation };
     };
-}
-/**
- * Which piece of content a file belongs to.
- *
- * The path layout is the model's own (`layout.ts`), so this is a reading of
- * it, not a second convention: `collection/slug/…` or `collection/slug.json`,
- * `singleton.json` or `singleton/…`, and the shared `media/` directory.
- */
-export function classifyPath(model, path) {
-    const segments = path.split("/");
-    const head = segments[0] ?? "";
-    const collection = model.collections[head];
-    if (collection && segments.length > 1) {
-        if (segments.length === 2 && segments[1] === ORDER_FILE) {
-            return { kind: "order", collection: head, label: `${collection.label}: order` };
-        }
-        if (entryLayout(collection.fields) === "directory") {
-            const slug = segments[1];
-            if (segments.length >= 3 && isValidSlug(slug)) {
-                return { kind: "entry", collection: head, slug, label: slug };
-            }
-        }
-        else if (segments.length === 2 && segments[1].endsWith(".json")) {
-            const slug = segments[1].slice(0, -".json".length);
-            if (isValidSlug(slug))
-                return { kind: "entry", collection: head, slug, label: slug };
-        }
-    }
-    const singletonDir = model.singletons[head];
-    if (singletonDir && segments.length > 1) {
-        return { kind: "singleton", name: head, label: singletonDir.label };
-    }
-    if (head.endsWith(".json")) {
-        const name = head.slice(0, -".json".length);
-        const singleton = model.singletons[name];
-        if (singleton && segments.length === 1) {
-            return { kind: "singleton", name, label: singleton.label };
-        }
-    }
-    if (head === "media")
-        return { kind: "media", label: "Shared media" };
-    return { kind: "other", label: path };
-}
-/** Content share that two versions of an entry need to count as one moved entry, as in Git. */
-const RENAME_SIMILARITY = 0.5;
-/**
- * Marks entries that a pending rename moved, in place in `owners`.
- *
- * A rename is a deleted and a created entry in one collection. The change set
- * holds only files and an entry has no identity but its slug, so the pairs are
- * found by content, like Git's rename detection: the published version of the
- * deleted entry against the staged version of the created one.
- *
- * An order file whose only change is the renamed slug joins the renamed entry:
- * it is part of the same edit, and discarding one without the other would
- * leave the order naming a slug that does not exist.
- */
-async function detectRenames(model, published, source, changes, owners, staged) {
-    const kinds = new Map();
-    owners.forEach((owner, index) => {
-        if (owner.kind !== "entry")
-            return;
-        const bySlug = kinds.get(owner.collection) ?? new Map();
-        kinds.set(owner.collection, bySlug);
-        const set = bySlug.get(owner.slug) ?? new Set();
-        bySlug.set(owner.slug, set);
-        set.add(changes[index].kind);
-    });
-    for (const [name, bySlug] of kinds) {
-        const after = staged.get(name);
-        if (!after)
-            continue;
-        const only = (kind) => [...bySlug].filter(([, set]) => set.size === 1 && set.has(kind)).map(([slug]) => slug);
-        const deleted = only("delete").filter((slug) => !after.has(slug));
-        const created = only("create").filter((slug) => after.has(slug));
-        if (deleted.length === 0 || created.length === 0)
-            continue;
-        const def = model.collections[name];
-        let before;
-        try {
-            const entries = await readCollection(published, def, name);
-            before = new Map(entries.map((entry) => [entry.slug, entry.data]));
-        }
-        catch {
-            // A published side that cannot be read only costs the pairing.
-            continue;
-        }
-        const candidates = [];
-        for (const from of deleted) {
-            const old = before.get(from);
-            if (!old)
-                continue;
-            for (const to of created) {
-                if (before.has(to))
-                    continue;
-                const score = similarity(def, onDisk(def, name, from, old), onDisk(def, name, to, after.get(to)));
-                if (score >= RENAME_SIMILARITY)
-                    candidates.push({ from, to, score });
-            }
-        }
-        const renamedTo = new Map();
-        const paired = new Set();
-        for (const { from, to } of candidates.sort((a, b) => b.score - a.score)) {
-            if (renamedTo.has(from) || paired.has(to))
-                continue;
-            renamedTo.set(from, to);
-            paired.add(to);
-        }
-        if (renamedTo.size === 0)
-            continue;
-        const renamedFrom = new Map([...renamedTo].map(([from, to]) => [to, from]));
-        const orderMovesOnlySlugs = await onlyRenamedInOrder(published, source, name, renamedTo);
-        const [firstFrom, firstTo] = [...renamedTo][0];
-        owners.forEach((owner, index) => {
-            if (owner.kind === "order" && owner.collection === name && orderMovesOnlySlugs) {
-                owners[index] = {
-                    kind: "entry",
-                    collection: name,
-                    slug: firstTo,
-                    label: firstTo,
-                    renamedFrom: firstFrom,
-                };
-            }
-            if (owner.kind !== "entry" || owner.collection !== name)
-                return;
-            const to = renamedTo.get(owner.slug);
-            if (to)
-                owners[index] = { ...owner, slug: to, label: to, renamedFrom: owner.slug };
-            const from = renamedFrom.get(owner.slug);
-            if (from)
-                owners[index] = { ...owner, renamedFrom: from };
-        });
-    }
-}
-/** True when a collection's staged order is the published one with the renamed slugs replaced. */
-async function onlyRenamedInOrder(published, staged, name, renamedTo) {
-    const path = `${name}/${ORDER_FILE}`;
-    const parse = (raw) => {
-        try {
-            return raw === null ? null : JSON.parse(raw);
-        }
-        catch {
-            return null;
-        }
+    const locate = async () => deps.tree ?? locateTree(contentRoot);
+    const located = async () => {
+        const tree = await locate();
+        if ("reason" in tree)
+            throw badRequest(tree.reason);
+        return tree;
     };
-    const before = parse(await published.read(path));
-    const after = parse(await staged.read(path));
-    if (!Array.isArray(before) || !Array.isArray(after))
-        return false;
-    const expected = before.map((slug) => typeof slug === "string" ? (renamedTo.get(slug) ?? slug) : slug);
-    return canonical(expected) === canonical(after);
-}
-/** The share of non-empty fields, the slug aside, that two versions of an entry agree on. */
-function similarity(def, a, b) {
-    const slugKey = resolveSlugField(def);
-    let compared = 0;
-    let equal = 0;
-    for (const key of Object.keys(def.fields)) {
-        if (key === slugKey || (isEmpty(a[key]) && isEmpty(b[key])))
-            continue;
-        compared += 1;
-        if (canonical(a[key]) === canonical(b[key]))
-            equal += 1;
-    }
-    return compared === 0 ? 0 : equal / compared;
-}
-/** Entry data with media paths as the files store them: relative to the entry, where it has a folder. */
-function onDisk(def, collection, slug, data) {
-    return entryLayout(def.fields) === "directory"
-        ? relativizeMedia(def.fields, data, collectionEntryPath(def.fields, collection, slug))
-        : data;
-}
-function isEmpty(value) {
-    return value === undefined || value === null || value === "" || (Array.isArray(value) && value.length === 0);
-}
-/** JSON with sorted keys, so two equal objects compare equal. */
-function canonical(value) {
-    return JSON.stringify(value ?? null, (_key, entry) => {
-        if (entry === null || typeof entry !== "object" || Array.isArray(entry))
-            return entry;
-        const record = entry;
-        return Object.fromEntries(Object.keys(record).sort().map((key) => [key, record[key]]));
-    });
-}
-function labelEntry(def, slug, title) {
-    return `${def.labelSingular ?? def.label}: ${title ?? slug}`;
-}
-function entryDataPath(def, collection, slug) {
-    const base = collectionEntryPath(def.fields, collection, slug);
-    return entryLayout(def.fields) === "directory" ? `${base}/index.json` : base;
-}
-export function createDraftStagingService(deps) {
-    const { model, drafts, repository, overlay } = deps;
-    // One publication at a time. Not a lock on editing — saves keep landing in
-    // the draft store — just a refusal to run two commits of the same set.
-    let publishing = false;
-    const statusOf = async () => {
-        const rows = await drafts.list();
-        const summary = rows.map(toContentChange);
-        const { changes, validation } = await analyseChanges(model, overlay, summary, repository);
-        return { rows, changes, validation };
+    const publishable = async () => {
+        const availability = policy.publishAvailability();
+        if (!availability.enabled)
+            throw badRequest(availability.reason);
+        return located();
+    };
+    /** The key that keeps an entry's files together: a publication never splits one. */
+    const groupOf = (change) => {
+        const owner = change.owner;
+        if (owner.kind === "entry")
+            return `entry:${owner.collection}/${owner.slug}`;
+        if (owner.kind === "singleton")
+            return `singleton:${owner.name}`;
+        if (owner.kind === "order")
+            return `order:${owner.collection}`;
+        return `file:${change.path}`;
+    };
+    const withRevisions = async (changes) => Promise.all(changes.map(async (change) => ({
+        ...change,
+        revision: change.kind === "delete" ? null : await files.revision(change.path),
+    })));
+    /** Refused for the developer's checkout: Mica never fetches or merges there. */
+    const managedOnly = (action) => {
+        if (action === undefined)
+            throw notFound("This is the developer's checkout; Git there is theirs.");
+        return action;
     };
     return {
         async status() {
-            const { rows, changes, validation } = await statusOf();
+            const tree = await locate();
+            const sync = policy.syncStatus?.() ?? null;
+            if ("reason" in tree) {
+                return {
+                    owner: policy.owner,
+                    publish: { enabled: false, reason: tree.reason },
+                    head: null,
+                    branch: null,
+                    ahead: null,
+                    changes: [],
+                    validation: emptyValidation(),
+                    sync,
+                };
+            }
+            const { changes, validation, head, branch } = await locks.tree.read(async () => {
+                const analysed = await analyse(tree, await listTreeChanges(tree));
+                return {
+                    ...analysed,
+                    changes: await withRevisions(analysed.changes),
+                    head: await headRevision(tree),
+                    branch: await currentBranch(tree),
+                };
+            });
             return {
-                workspace: "draft-store",
-                publish: { enabled: true },
-                baseRevision: await drafts.base(),
-                branch: null,
-                ahead: null,
+                owner: policy.owner,
+                publish: policy.publishAvailability(),
+                head,
+                branch,
+                ahead: await aheadOfUpstream(tree),
                 changes,
                 validation,
-                updatedAt: rows.reduce((latest, row) => (latest === null || row.updatedAt > latest ? row.updatedAt : latest), null),
+                sync,
             };
         },
         async publish(input) {
             const message = input.message.trim();
             if (!message)
                 throw badRequest("A publication needs a commit message.");
-            if (publishing) {
-                throw new ApiError("conflict", "A publication is already running. Wait for it to finish.");
-            }
-            publishing = true;
-            try {
-                const snapshot = await drafts.list();
-                if (snapshot.length === 0)
-                    throw badRequest("There is nothing to publish.");
-                /**
-                 * The model drift gate: refuse, name the drift, require a restart.
-                 * The staged set was validated against the model this
-                 * process read at startup; a manifest that moved since may disagree,
-                 * and publishing content the new model rejects would hand the next
-                 * build a broken tree.
-                 */
-                const manifestNow = await repository.revision(MANIFEST_PATH);
-                if (manifestNow !== deps.schemaRevision) {
-                    throw new ApiError("conflict", "The content model changed in the repository after this server started. " +
-                        "Restart Mica to load the new model, then review the pending changes and " +
-                        "publish again.");
-                }
-                const { validation } = await statusOf();
-                if (!validation.ok) {
-                    throw new ApiError("validation_failed", describeProblems(validation.problems), {
-                        issues: flattenProblems(validation.problems),
-                    });
-                }
-                const changes = snapshot.map((row) => row.kind === "write"
-                    ? {
-                        type: "write",
-                        path: row.path,
-                        contents: row.text ? new TextDecoder().decode(row.contents) : row.contents,
+            const reviewed = Object.keys(input.paths);
+            if (reviewed.length === 0)
+                throw badRequest("Choose at least one change to publish.");
+            const tree = await publishable();
+            // One publication at a time from sync to push: no sync can run in
+            // between, and no second commit can stack up.
+            return locks.remote.run(async () => {
+                await policy.prepare(tree);
+                const revision = await locks.tree.write(async () => {
+                    const pending = await withRevisions((await analyse(tree, await listTreeChanges(tree))).changes);
+                    const byPath = new Map(pending.map((change) => [change.path, change]));
+                    // The review gate refuses a file saved again since the review, a
+                    // reviewed file that is no longer pending, or another file of a
+                    // reviewed entry. Drafts of other entries never block a publication.
+                    const reviewedGroups = new Set(reviewed.map((path) => byPath.get(path)).flatMap((change) => (change ? [groupOf(change)] : [])));
+                    const stale = [
+                        ...reviewed.filter((path) => byPath.get(path)?.revision !== input.paths[path] || !byPath.has(path)),
+                        ...pending
+                            .filter((change) => reviewedGroups.has(groupOf(change)) && !(change.path in input.paths))
+                            .map((change) => change.path),
+                    ];
+                    if (stale.length > 0) {
+                        throw new ApiError("conflict", "Some of these changes were edited after you reviewed them. Review them again, then publish.");
+                    }
+                    // The model drift gate: validation used the model that this process started with.
+                    if ((await files.revision(MANIFEST_PATH)) !== deps.schemaRevision) {
+                        throw new ApiError("conflict", "The content model changed after this server started. Restart Mica to load " +
+                            "the new model, then review the pending changes and publish again.");
+                    }
+                    const selected = (await listTreeChanges(tree)).filter((change) => change.path in input.paths);
+                    const { validation } = await analyse(tree, selected);
+                    if (!validation.ok) {
+                        throw new ApiError("validation_failed", describeProblems(validation.problems), {
+                            issues: flattenProblems(validation.problems),
+                        });
+                    }
+                    try {
+                        const revision = await commitPaths(tree, reviewed, message, policy.commitAuthor(input.author));
+                        logger.info("Published", { revision, files: reviewed.length, owner: policy.owner });
+                        return revision;
+                    }
+                    catch (error) {
+                        if (error instanceof GitError) {
+                            // Git's message is the actionable part: no identity, a hook that
+                            // refused, a rebase in progress.
+                            throw new ApiError("conflict", `Git refused the commit: ${error.message}`);
+                        }
+                        throw error;
                     }
-                    : { type: "delete", path: row.path });
-                // The per-path gate: every file this publication writes or removes,
-                // expected to be as it was when first staged. A branch that moved on
-                // other paths sails through, which is the point.
-                const result = await repository.commit({
-                    message,
-                    changes,
-                    expect: Object.fromEntries(snapshot.map((row) => [row.path, row.baseRevision])),
-                    author: input.author,
                 });
-                await drafts.clearPublished(snapshot.map(({ path, version }) => ({ path, version })));
-                // An autosave that landed while the commit ran survives — re-based
-                // onto what the repository now holds, so the next publication's gate
-                // is the commit that just happened rather than a stale ancestor.
-                const survivors = await drafts.list();
-                for (const row of survivors) {
-                    await drafts.rebase(row.path, await repository.revision(row.path));
+                return policy.push(tree, revision);
+            });
+        },
+        async push() {
+            const tree = await publishable();
+            return locks.remote.run(async () => {
+                const revision = await headRevision(tree);
+                if (revision === null)
+                    throw badRequest("There is no commit to push yet.");
+                return policy.push(tree, revision);
+            });
+        },
+        async discard(requested) {
+            const tree = await located();
+            return locks.tree.write(async () => {
+                // Discard is destructive, so it reaches only paths that the change list names.
+                const current = new Map((await listTreeChanges(tree)).map((change) => [change.path, change]));
+                const discarded = [];
+                for (const path of requested) {
+                    const change = current.get(path);
+                    if (!change)
+                        continue;
+                    await discardChange(tree, change);
+                    discarded.push(path);
                 }
-                if (survivors.length > 0)
-                    await drafts.setBase(await repository.head());
-                return { state: "published", revision: result.revision };
-            }
-            finally {
-                publishing = false;
-            }
+                return { discarded };
+            });
         },
-        async discard(paths) {
-            return { discarded: await drafts.discard(paths) };
+        async compare(target, against = "head") {
+            const tree = await locate();
+            if (against === "origin" && !policy.upstreamRef)
+                throw badRequest("There is no website version to compare with here.");
+            // Without a repository nothing is published, so "before" is an empty source.
+            const published = "reason" in tree
+                ? memorySource({}, "unpublished")
+                : headSource(tree, against === "origin" ? policy.upstreamRef : "HEAD");
+            return locks.tree.read(() => compareSources(model, published, files, target));
         },
-        async push() {
-            // A provider commit is already on the branch; there is no second step.
-            throw badRequest("Publications here are single repository commits. There is nothing to push.");
+        async sync() {
+            await managedOnly(policy.sync)();
         },
-        async compare(target) {
-            // "Before" is the repository the drafts have not touched; "after" is the
-            // overlay every other read already goes through.
-            return compareSources(model, repository, overlay, target);
+        async resolve(group, choice) {
+            await managedOnly(policy.resolve)(group, choice);
+        },
+        async repository() {
+            const tree = await locate();
+            const described = (await policy.describe?.()) ?? null;
+            return {
+                owner: policy.owner,
+                branch: "reason" in tree ? null : await currentBranch(tree),
+                head: "reason" in tree ? null : await headRevision(tree),
+                url: described?.url ?? null,
+                cloneBytes: described?.cloneBytes ?? null,
+                sync: policy.syncStatus?.() ?? null,
+            };
         },
     };
 }
-/* ------------------------------------------------------------------ */
-export function describeProblems(problems) {
-    const names = problems.map((problem) => problem.label);
-    const listed = names.slice(0, 3).join(", ") + (names.length > 3 ? ", …" : "");
-    return `The pending changes cannot be published until they are valid: ${listed}.`;
-}
-/** Field issues with the file path folded in, for the flat API envelope. */
-export function flattenProblems(problems) {
-    return problems.flatMap((problem) => problem.issues.map((issue) => ({
-        path: issue.path ? `${problem.path}: ${issue.path}` : problem.path,
-        message: issue.message,
-    })));
+function emptyValidation() {
+    return { ok: true, problems: [] };
 }
 //# sourceMappingURL=staging.js.map