mockpit 1.3.0 → 3.0.0

package/dist/server/sqlStore.js

@@ -1,4 +1,15 @@
-import { collectAssetIds, collectAttachedIds, DEFAULT_PROJECT, DEFAULT_VARIANT, hashAssetId, HISTORY_LIMIT, htmlSurface, MAX_WORKSPACE_ASSET_BYTES, newId, normalizeSurfaceIds, projectFromCwd, reservedAgent, sameScreen, selectEvictions, slugify, stripNul, summarizeProjects, } from "./types.js";
+import { collectAssetIds, collectAttachedIds, DEFAULT_PROJECT, DEFAULT_VARIANT, hashAssetId, HISTORY_LIMIT, htmlSurface, MAX_WORKSPACE_ASSET_BYTES, isDesignKind, newId, normalizeSurfaceIds, isLive, projectFromCwd, AREA_ORDER_SETTING, DECISION_EDITS_SETTING, reservedAgent, sameScreen, selectEvictions, slugify, stripNul, summarizeProjects, } from "./types.js";
+import { renameSlugRefs } from "./embeds.js";
+import { RULES_SETTING } from "./guidance.js";
+// The settings keyed `<prefix>:<project>`, which a project rename carries.
+const PROJECT_SETTINGS = [
+    "design",
+    AREA_ORDER_SETTING,
+    RULES_SETTING,
+    DECISION_EDITS_SETTING,
+];
+// An optional free-text label: blank means none.
+const label = (v) => stripNul(v ?? "").trim() || null;
 function parseJson(raw, fallback) {
     if (typeof raw !== "string" || !raw)
         return fallback;
@@ -9,12 +20,78 @@ function parseJson(raw, fallback) {
         return fallback;
     }
 }
+// A stored reply in the current names, or null when it already uses them.
+function contractReply(payload) {
+    if (!("mix" in payload) && !("decision" in payload) && !("resolved" in payload))
+        return null;
+    const { mix, decision, resolved, ...rest } = payload;
+    const out = { ...rest };
+    if (mix !== undefined)
+        out.borrowed = mix;
+    const kind = decision?.kind;
+    if (kind === "accept" || kind === "revise") {
+        out.verdict = { ...decision, kind: kind === "accept" ? "use" : "revise" };
+    }
+    if (resolved !== undefined)
+        out.archived = resolved;
+    return out;
+}
+// `surfaces` with every `<mockpit-slot>` tag spelled `<mockpit-embed>`, or null
+// when none has one. Only html is markup; a code or markdown surface may quote
+// the tag as text.
+function slotTagsToEmbed(surfaces) {
+    let changed = false;
+    const out = surfaces.map((s) => {
+        if (s.kind !== "html" || !/<\/?mockpit-slot\b/i.test(s.html))
+            return s;
+        changed = true;
+        return { ...s, html: s.html.replace(/<(\/?)mockpit-slot\b/gi, "<$1mockpit-embed") };
+    });
+    return changed ? out : null;
+}
+// What the post cache may hold by default, in stored surface characters: a
+// Durable Object has 128 MB in all.
+const POST_CACHE_BYTES = 32 * 1024 * 1024;
+const surfaceHeads = (surfaces) => JSON.stringify(surfaces.map((s) => {
+    if (s.kind !== "html")
+        return { kind: s.kind };
+    return {
+        kind: s.kind,
+        ...(s.poster ? { poster: s.poster } : {}),
+        ...(s.poster && s.posterMode ? { posterMode: s.posterMode } : {}),
+        ...(/<mockpit-embed|data-fill/i.test(s.html) ? { marked: true } : {}),
+    };
+}));
+// surfaceHeads in SQL, for the rows written before heads were: it runs without
+// bringing a workspace's bodies into memory, which a Durable Object can't hold.
+const SURFACE_HEADS_SQL = `CASE WHEN json_valid(surfaces) THEN (
+  SELECT json_group_array(json(h)) FROM (
+    SELECT '{"kind":' || json_quote(json_extract(value, '$.kind'))
+      || CASE WHEN json_extract(value, '$.kind') = 'html' AND json_extract(value, '$.poster') <> ''
+           THEN ',"poster":' || json_quote(json_extract(value, '$.poster')) ELSE '' END
+      || CASE WHEN json_extract(value, '$.kind') = 'html'
+             AND (json_extract(value, '$.html') LIKE '%<mockpit-embed%'
+               OR json_extract(value, '$.html') LIKE '%data-fill%')
+           THEN ',"marked":true' ELSE '' END
+      || '}' AS h
+    FROM json_each(surfaces) ORDER BY key
+  )
+) ELSE '[]' END`;
+// Everything a head row needs, spelled out because `SELECT *` reads the bodies.
+const POST_HEAD_COLUMNS = "id, sessionId, designId, state, variant, status, title, head, knobs, slots, createdAt, updatedAt, version, curFrom, curPrompt, curAuthor, description, forkedFrom, copiedFrom, starred, acceptedVersion, hiddenVersions, curSession, amendedAt, rewrites, archiveReason, stayedVersion, archivedAt";
+// Holding every column a head reads, so listing a project's variants never touches
+// a row with a body: those columns sit after `surfaces`, and reaching them through
+// the table walks the body's overflow pages. Any column added to the heads belongs
+// here too (it is built from them), under a new index name so the old one is replaced.
+const POST_HEADS_INDEX = `designId, ${POST_HEAD_COLUMNS.split(", ")
+    .filter((c) => c !== "designId")
+    .join(", ")}`;
 const POST_COLUMNS = `
-  id TEXT PRIMARY KEY, sessionId TEXT NOT NULL, mockId TEXT NOT NULL, state TEXT,
+  id TEXT PRIMARY KEY, sessionId TEXT NOT NULL, designId TEXT NOT NULL, state TEXT,
   variant TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'open', title TEXT NOT NULL,
   surfaces TEXT NOT NULL, knobs TEXT, slots TEXT NOT NULL DEFAULT '[]',
   createdAt TEXT NOT NULL, updatedAt TEXT NOT NULL, version INTEGER NOT NULL,
-  curFrom INTEGER, curPrompt TEXT, curAuthor TEXT, note TEXT`;
+  curFrom INTEGER, curPrompt TEXT, curAuthor TEXT, description TEXT`;
 // Store implementation on SQLite — a Durable Object's `ctx.storage.sql` in the
 // Worker, or node:sqlite via an adapter on Node (see server/sqliteStorage.ts).
 // One workspace = one database, so plain SQL with no tenant columns.
@@ -27,8 +104,47 @@ export class SqlStore {
     // post's surfaces on each call. Stays correct because history is append-only:
     // an asset id once referenced stays referenced until its post is deleted.
     assetRefCache;
-    constructor(sql) {
-        this.sql = sql;
+    // Parsed posts per design, least recently used first. A component is read again
+    // for every embed that shows it, and parsing its bodies each time is what a
+    // page full of embeds would wait on. A statement that writes posts or versions
+    // drops all of it unless `writingPosts` says which posts it touches; the byte
+    // budget keeps a Durable Object's memory bounded.
+    postCache = new Map();
+    postCacheBytes = 0;
+    postCacheLimit;
+    // Past the cache's drop, for a write that patches the cache itself.
+    raw;
+    holdPostDrop = false;
+    constructor(sql, opts = {}) {
+        this.raw = sql;
+        this.postCacheLimit = opts.postCacheBytes ?? POST_CACHE_BYTES;
+        const drop = () => {
+            if (this.holdPostDrop)
+                return;
+            this.postCache.clear();
+            this.postCacheBytes = 0;
+        };
+        this.sql = {
+            exec: (query, ...bindings) => {
+                if (!/^\s*SELECT\b/i.test(query) && /\bpost(s|_versions)\b/i.test(query))
+                    drop();
+                return sql.exec(query, ...bindings);
+            },
+            ...(sql.transactionSync
+                ? {
+                    transactionSync: (fn) => {
+                        try {
+                            return sql.transactionSync(fn);
+                        }
+                        catch (err) {
+                            // Reads inside a rolled-back transaction may have cached its writes.
+                            drop();
+                            throw err;
+                        }
+                    },
+                }
+                : {}),
+        };
         this.atomic(() => this.migrate());
     }
     // On a Durable Object the synchronous writes of one event already commit as a
@@ -56,20 +172,153 @@ export class SqlStore {
                 this.sql.exec(`ALTER TABLE ${table} ADD COLUMN ${name} ${decl}`);
         }
     }
+    // What was called a mock is a design, in the store as everywhere else. First of all
+    // the migrations: every one below it speaks the new names, and a workspace with no
+    // designs table would otherwise read as older than mocks.
+    // The words stored inside JSON and values, once every older migration has written
+    // its own: a kind, what an answer's comment is called, and an archive in a reply.
+    migrateToDesignWords() {
+        const kinds = { page: "screen", sketch: "idea" };
+        for (const [from, to] of Object.entries(kinds)) {
+            this.sql.exec("UPDATE designs SET kind = ? WHERE kind = ?", to, from);
+        }
+        const renameKeys = (o, names) => {
+            let changed = false;
+            for (const [from, to] of Object.entries(names)) {
+                if (from in o) {
+                    o[to] = o[from];
+                    delete o[from];
+                    changed = true;
+                }
+            }
+            return changed;
+        };
+        for (const r of this.sql.exec("SELECT id, asks, draft FROM designs").toArray()) {
+            const asks = parseJson(r.asks, []);
+            let asksChanged = false;
+            for (const ask of asks) {
+                if (renameKeys(ask, { note: "comment", noteImages: "commentImages" }))
+                    asksChanged = true;
+            }
+            if (asksChanged) {
+                this.sql.exec("UPDATE designs SET asks = ? WHERE id = ?", JSON.stringify(asks), r.id);
+            }
+            const draft = parseJson(r.draft, null);
+            if (draft && renameKeys(draft, { notes: "askComments", noteImages: "askCommentImages" })) {
+                this.sql.exec("UPDATE designs SET draft = ? WHERE id = ?", JSON.stringify(draft), r.id);
+            }
+        }
+        for (const r of this.sql
+            .exec("SELECT seq, payload FROM comments WHERE kind = 'reply' AND payload IS NOT NULL")
+            .toArray()) {
+            const payload = parseJson(r.payload, null);
+            if (!payload)
+                continue;
+            let changed = renameKeys(payload, {
+                notes: "askComments",
+                noteImages: "askCommentImages",
+                closed: "archived",
+            });
+            const edited = payload.edited;
+            if (edited) {
+                if (typeof edited.kind === "string" && edited.kind in kinds) {
+                    edited.kind = kinds[edited.kind];
+                    changed = true;
+                }
+                if ("grouped" in edited) {
+                    delete edited.grouped;
+                    changed = true;
+                    // All it said was about grouping, which no longer exists: it would read as a blank line.
+                    if (!Object.keys(edited).length) {
+                        this.sql.exec("DELETE FROM comments WHERE seq = ?", r.seq);
+                        continue;
+                    }
+                }
+            }
+            if (changed) {
+                this.sql.exec("UPDATE comments SET payload = ? WHERE seq = ?", JSON.stringify(payload), r.seq);
+            }
+        }
+        this.sql.exec("INSERT OR REPLACE INTO settings (key, value) VALUES ('designWords', '1')");
+    }
+    // A value, so migrateToDesignWords' renames never reached it, and that one has
+    // already run on every workspace that needs this.
+    migrateAskScopeWord() {
+        for (const r of this.sql.exec("SELECT id, asks FROM designs").toArray()) {
+            const asks = parseJson(r.asks, []);
+            const old = asks.filter((a) => a.scope === "mock");
+            if (!old.length)
+                continue;
+            for (const a of old)
+                a.scope = "design";
+            this.sql.exec("UPDATE designs SET asks = ? WHERE id = ?", JSON.stringify(asks), r.id);
+        }
+        this.sql.exec("INSERT OR REPLACE INTO settings (key, value) VALUES ('askScopeWord', '1')");
+    }
+    renameMocksToDesigns() {
+        if (!this.tables().has("mocks") || this.tables().has("designs"))
+            return;
+        for (const name of [
+            "mockpit_mocks_slug_idx",
+            "mockpit_mocks_updated_at_idx",
+            "mockpit_posts_mock_idx",
+            "mockpit_comments_mock_seq_idx",
+            "mockpit_posts_copies_idx",
+        ]) {
+            this.sql.exec(`DROP INDEX IF EXISTS ${name}`);
+        }
+        this.sql.exec("ALTER TABLE mocks RENAME TO designs");
+        for (const table of ["posts", "comments"]) {
+            if (this.columns(table).has("mockId")) {
+                this.sql.exec(`ALTER TABLE ${table} RENAME COLUMN mockId TO designId`);
+            }
+        }
+        // Steps and copy references are stored as JSON, keyed by the old word.
+        const renamed = (raw) => typeof raw === "string" ? raw.replaceAll('"mock":', '"design":') : raw;
+        for (const r of this.sql.exec("SELECT project, name, steps FROM flows").toArray()) {
+            this.sql.exec("UPDATE flows SET steps = ? WHERE project = ? AND name = ?", renamed(r.steps), r.project, r.name);
+        }
+        // Only the key: a user's text can hold the same letters, escaped inside its string.
+        for (const r of this.sql
+            .exec("SELECT seq, payload FROM comments WHERE payload LIKE '%\"mockId\":%'")
+            .toArray()) {
+            this.sql.exec("UPDATE comments SET payload = ? WHERE seq = ?", r.payload.replace(/(?<!\\)"mockId":/g, '"designId":'), r.seq);
+        }
+        // The same release gave the design's archive fields and a variant's description
+        // their names; the JSON that speaks these words waits for migrateToDesignWords.
+        const designCols = this.columns("designs");
+        if (designCols.has("closedAt")) {
+            this.sql.exec("ALTER TABLE designs RENAME COLUMN closedAt TO archivedAt");
+        }
+        if (designCols.has("closeReason")) {
+            this.sql.exec("ALTER TABLE designs RENAME COLUMN closeReason TO archiveReason");
+        }
+        if (this.columns("posts").has("note")) {
+            this.sql.exec("ALTER TABLE posts RENAME COLUMN note TO description");
+        }
+        if (this.columns("posts").has("copiedFrom")) {
+            for (const r of this.sql
+                .exec("SELECT id, copiedFrom FROM posts WHERE copiedFrom IS NOT NULL")
+                .toArray()) {
+                this.sql.exec("UPDATE posts SET copiedFrom = ? WHERE id = ?", renamed(r.copiedFrom), r.id);
+            }
+        }
+    }
     migrate() {
+        this.renameMocksToDesigns();
         const before = this.tables();
         // Deployed Durable Objects can never be reset, so a workspace written by a
-        // build from before mocks existed is lifted in place (see migrateLegacy).
-        const legacy = before.has("posts") && !before.has("mocks");
+        // build from before designs existed is lifted in place (see migrateLegacy).
+        const legacy = before.has("posts") && !before.has("designs");
         this.sql.exec(`
       CREATE TABLE IF NOT EXISTS sessions (
         id TEXT PRIMARY KEY, agent TEXT NOT NULL, title TEXT, cwd TEXT,
         createdAt TEXT NOT NULL, lastActiveAt TEXT NOT NULL,
         agentSeq INTEGER NOT NULL DEFAULT 0, project TEXT, key TEXT, agentActiveAt TEXT
       );
-      CREATE TABLE IF NOT EXISTS mocks (
+      CREATE TABLE IF NOT EXISTS designs (
         id TEXT PRIMARY KEY, project TEXT NOT NULL, slug TEXT NOT NULL, title TEXT NOT NULL,
-        kind TEXT NOT NULL DEFAULT 'component', states TEXT NOT NULL DEFAULT '[]',
+        kind TEXT NOT NULL DEFAULT 'idea', states TEXT NOT NULL DEFAULT '[]',
         asks TEXT NOT NULL DEFAULT '[]', knobs TEXT NOT NULL DEFAULT '{}', draft TEXT,
         sessionId TEXT, createdAt TEXT NOT NULL, updatedAt TEXT NOT NULL,
         widths TEXT NOT NULL DEFAULT '[]'
@@ -83,7 +332,7 @@ export class SqlStore {
       );
       CREATE TABLE IF NOT EXISTS comments (
         seq INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL,
-        sessionId TEXT NOT NULL, mockId TEXT, postId TEXT,
+        sessionId TEXT NOT NULL, designId TEXT, postId TEXT,
         author TEXT NOT NULL, text TEXT NOT NULL, createdAt TEXT NOT NULL,
         kind TEXT NOT NULL DEFAULT 'comment', anchor TEXT, anchors TEXT NOT NULL DEFAULT '[]',
         postVersion INTEGER, viewport INTEGER, payload TEXT
@@ -108,39 +357,158 @@ export class SqlStore {
             key: "TEXT",
             agentActiveAt: "TEXT",
         });
-        this.addMissing("mocks", { widths: "TEXT NOT NULL DEFAULT '[]'", resolvedAt: "TEXT" });
+        // The close column's first name.
+        const designCols = this.columns("designs");
+        if (designCols.has("resolvedAt") && !designCols.has("archivedAt")) {
+            this.sql.exec("ALTER TABLE designs RENAME COLUMN resolvedAt TO archivedAt");
+        }
+        this.addMissing("designs", {
+            widths: "TEXT NOT NULL DEFAULT '[]'",
+            archivedAt: "TEXT",
+            archiveReason: "TEXT",
+            area: "TEXT",
+            source: "TEXT",
+            shortlist: "INTEGER NOT NULL DEFAULT 0",
+            notes: "TEXT",
+            stateOutlines: "TEXT NOT NULL DEFAULT '{}'",
+            answerAdditions: "TEXT NOT NULL DEFAULT '[]'",
+            standings: "TEXT NOT NULL DEFAULT '{}'",
+            sets: "TEXT NOT NULL DEFAULT '[]'",
+        });
+        this.migrateSituations();
+        // Before the legacy lift, whose history rows are written with every column.
+        this.addMissing("post_versions", { sessionId: "TEXT", amendedAt: "TEXT" });
         if (legacy)
             this.migrateLegacy();
         // After the legacy lift, which rebuilds posts from POST_COLUMNS alone.
         const pinned = this.columns("posts").has("acceptedVersion");
+        const dated = this.columns("posts").has("archivedAt");
         this.addMissing("posts", {
-            note: "TEXT",
+            description: "TEXT",
             forkedFrom: "TEXT",
+            copiedFrom: "TEXT",
+            // Inert: kept answers (`Design.standings`) took over from the star.
             starred: "INTEGER NOT NULL DEFAULT 0",
             acceptedVersion: "INTEGER",
             hiddenVersions: "TEXT",
+            curSession: "TEXT",
+            amendedAt: "TEXT",
+            rewrites: "INTEGER NOT NULL DEFAULT 0",
+            archiveReason: "TEXT",
+            stayedVersion: "INTEGER",
+            archivedAt: "TEXT",
         });
         // Before the pin, accepted meant "its latest": freeze that as the version in use.
         if (!pinned) {
             this.sql.exec("UPDATE posts SET acceptedVersion = version WHERE status = 'accepted'");
         }
+        for (const table of ["posts", "post_versions"]) {
+            if (this.columns(table).has("head"))
+                continue;
+            this.addMissing(table, { head: "TEXT" });
+            this.sql.exec(`UPDATE ${table} SET head = ${SURFACE_HEADS_SQL}`);
+        }
+        if (this.settingSync("sketchKind") !== "1")
+            this.migrateToSketches();
+        if (this.settingSync("contractTerms") !== "1")
+            this.migrateToContractTerms();
+        if (this.settingSync("designWords") !== "1")
+            this.migrateToDesignWords();
+        if (this.settingSync("askScopeWord") !== "1")
+            this.migrateAskScopeWord();
+        // The day it went was never kept, and the design's last change is the nearest thing.
+        // Frozen now, or the next reason or draft on the design would move it to that day.
+        if (!dated) {
+            this.sql.exec("UPDATE posts SET archivedAt = (SELECT updatedAt FROM designs WHERE designs.id = posts.designId) WHERE status = 'archived'");
+        }
         this.createIndexes();
     }
+    // A situation was already a state of its own, filed in `states` under the name
+    // feedback gave it ("Writing · Couldn't save"), with its asks, comments and posts
+    // there too, so those keep that name and only the map that set it apart goes. The
+    // column itself stays on a workspace that has it, empty: nothing reads it any more,
+    // and new workspaces never get one.
+    migrateSituations() {
+        if (!this.columns("designs").has("situations"))
+            return;
+        for (const r of this.sql
+            .exec("SELECT id, states, situations FROM designs WHERE situations != '{}'")
+            .toArray()) {
+            const states = parseJson(r.states, []);
+            const map = parseJson(r.situations, {});
+            for (const [state, names] of Object.entries(map)) {
+                for (const name of names) {
+                    const key = `${state} · ${name}`;
+                    if (!states.includes(key))
+                        states.push(key);
+                }
+            }
+            this.sql.exec("UPDATE designs SET states = ?, situations = '{}' WHERE id = ?", JSON.stringify(states), r.id);
+        }
+    }
+    // The agent contract renamed what replies and drafts store (mix → borrowed,
+    // decision → verdict with accept → use, resolved → archived) and retired drop
+    // and the `<mockpit-slot>` embed alias. Stored data is rewritten once, here,
+    // so nothing past the store reads an old name: a dropped variant is archived
+    // (both were hidden from the choice and restorable), a drop verdict loses its
+    // verdict (the variant's archived status says the rest), and every stored
+    // version spells its embeds `<mockpit-embed>` so it still renders them.
+    migrateToContractTerms() {
+        this.sql.exec("UPDATE posts SET status = 'archived', acceptedVersion = NULL WHERE status = 'dropped'");
+        for (const r of this.sql
+            .exec("SELECT seq, payload FROM comments WHERE kind = 'reply' AND payload IS NOT NULL")
+            .toArray()) {
+            const payload = parseJson(r.payload, null);
+            const next = payload && contractReply(payload);
+            if (next) {
+                this.sql.exec("UPDATE comments SET payload = ? WHERE seq = ?", JSON.stringify(next), r.seq);
+            }
+        }
+        for (const r of this.sql
+            .exec("SELECT id, draft FROM designs WHERE draft IS NOT NULL")
+            .toArray()) {
+            const draft = parseJson(r.draft, null);
+            if (!draft || !("mix" in draft))
+                continue;
+            const { mix, ...rest } = draft;
+            this.sql.exec("UPDATE designs SET draft = ? WHERE id = ?", JSON.stringify({ ...rest, borrowed: mix ?? {} }), r.id);
+        }
+        for (const r of this.sql
+            .exec("SELECT id, surfaces FROM posts WHERE surfaces LIKE '%mockpit-slot%'")
+            .toArray()) {
+            const surfaces = slotTagsToEmbed(parseJson(r.surfaces, []));
+            if (surfaces) {
+                this.sql.exec("UPDATE posts SET surfaces = ? WHERE id = ?", JSON.stringify(surfaces), r.id);
+            }
+        }
+        for (const r of this.sql
+            .exec("SELECT postId, version, surfaces FROM post_versions WHERE surfaces LIKE '%mockpit-slot%'")
+            .toArray()) {
+            const surfaces = slotTagsToEmbed(parseJson(r.surfaces, []));
+            if (surfaces) {
+                this.sql.exec("UPDATE post_versions SET surfaces = ? WHERE postId = ? AND version = ?", JSON.stringify(surfaces), r.postId, r.version);
+            }
+        }
+        this.sql.exec("INSERT OR REPLACE INTO settings (key, value) VALUES ('contractTerms', '1')");
+    }
     createIndexes() {
         this.sql.exec(`
-      CREATE UNIQUE INDEX IF NOT EXISTS mockpit_mocks_slug_idx ON mocks (project, slug);
-      CREATE INDEX IF NOT EXISTS mockpit_mocks_updated_at_idx ON mocks (updatedAt DESC);
-      CREATE INDEX IF NOT EXISTS mockpit_posts_mock_idx ON posts (mockId, state, variant);
+      CREATE UNIQUE INDEX IF NOT EXISTS mockpit_designs_slug_idx ON designs (project, slug);
+      CREATE INDEX IF NOT EXISTS mockpit_designs_updated_at_idx ON designs (updatedAt DESC);
+      CREATE INDEX IF NOT EXISTS mockpit_posts_design_idx ON posts (designId, state, variant);
       CREATE INDEX IF NOT EXISTS mockpit_posts_session_created_at_idx ON posts (sessionId, createdAt);
+      CREATE INDEX IF NOT EXISTS mockpit_posts_copies_idx ON posts (designId, state, variant, status, copiedFrom) WHERE copiedFrom IS NOT NULL;
+      CREATE INDEX IF NOT EXISTS mockpit_posts_heads_idx ON posts (${POST_HEADS_INDEX});
+      CREATE INDEX IF NOT EXISTS mockpit_post_versions_heads_idx ON post_versions (postId, version, head);
       CREATE INDEX IF NOT EXISTS mockpit_comments_session_seq_idx ON comments (sessionId, seq);
-      CREATE INDEX IF NOT EXISTS mockpit_comments_mock_seq_idx ON comments (mockId, seq);
+      CREATE INDEX IF NOT EXISTS mockpit_comments_design_seq_idx ON comments (designId, seq);
       CREATE INDEX IF NOT EXISTS mockpit_comments_post_seq_idx ON comments (postId, seq);
       CREATE INDEX IF NOT EXISTS mockpit_comments_id_idx ON comments (id);
       CREATE INDEX IF NOT EXISTS mockpit_assets_session_idx ON assets (sessionId);
       CREATE INDEX IF NOT EXISTS mockpit_sessions_key_idx ON sessions (key);
     `);
     }
-    // --- in-place migration of a pre-mock workspace ---
+    // --- in-place migration of a pre-design workspace ---
     migrateLegacy() {
         this.addMissing("comments", {
             anchor: "TEXT",
@@ -149,7 +517,7 @@ export class SqlStore {
             draft: "INTEGER NOT NULL DEFAULT 0",
             postVersion: "INTEGER",
             viewport: "INTEGER",
-            mockId: "TEXT",
+            designId: "TEXT",
             payload: "TEXT",
         });
         this.migrateToSurfaces();
@@ -157,7 +525,7 @@ export class SqlStore {
         this.migrateSurfaceIds();
         this.migrateToItems();
         this.migrateToVersions();
-        this.migrateToMocks();
+        this.migrateToDesigns();
         this.sql.exec(`
       DROP TABLE IF EXISTS trace_steps;
       DROP INDEX IF EXISTS mockpit_comments_post_draft_idx;
@@ -284,11 +652,11 @@ export class SqlStore {
             }
         }
     }
-    // Every (project, item slug) becomes one single-state mock; its posts become
-    // the mock's variants with state null. Unsent operator drafts become the
-    // mock's draft so they are still there to send; decisions become plain
+    // Every (project, item slug) becomes one single-state design; its posts become
+    // the design's variants with state null. Unsent operator drafts become the
+    // design's draft so they are still there to send; decisions become plain
     // comments (they were already delivered).
-    migrateToMocks() {
+    migrateToDesigns() {
         const rows = this.sql.exec("SELECT * FROM posts ORDER BY createdAt ASC, rowid ASC").toArray();
         const groups = new Map();
         for (const r of rows) {
@@ -299,13 +667,13 @@ export class SqlStore {
             else
                 groups.set(key, [r]);
         }
-        const mockOf = new Map();
+        const designOf = new Map();
         const variantOf = new Map();
         for (const group of groups.values()) {
             const first = group[0];
             const latest = group.reduce((a, b) => b.updatedAt > a.updatedAt ? b : a);
             const id = newId();
-            this.sql.exec("INSERT INTO mocks (id, project, slug, title, kind, states, asks, knobs, draft, sessionId, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, '[]', '[]', '{}', NULL, ?, ?, ?)", id, first.project || DEFAULT_PROJECT, first.slug || slugify(first.title), first.title, group.some((r) => r.kind === "page") ? "page" : "component", latest.sessionId, first.createdAt, latest.updatedAt);
+            this.sql.exec("INSERT INTO designs (id, project, slug, title, kind, states, asks, knobs, draft, sessionId, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, '[]', '[]', '{}', NULL, ?, ?, ?)", id, first.project || DEFAULT_PROJECT, first.slug || slugify(first.title), first.title, group.some((r) => r.kind === "page") ? "page" : "component", latest.sessionId, first.createdAt, latest.updatedAt);
             const used = new Set();
             for (const r of group) {
                 const base = r.variant || DEFAULT_VARIANT;
@@ -313,52 +681,79 @@ export class SqlStore {
                 for (let n = 2; used.has(variant); n++)
                     variant = `${base}-${n}`;
                 used.add(variant);
-                mockOf.set(r.id, id);
+                designOf.set(r.id, id);
                 variantOf.set(r.id, variant);
             }
         }
         this.sql.exec(`CREATE TABLE posts_next (${POST_COLUMNS})`);
         for (const r of rows) {
             const id = r.id;
-            this.sql.exec("INSERT INTO posts_next (id, sessionId, mockId, state, variant, status, title, surfaces, knobs, slots, createdAt, updatedAt, version, curFrom, curPrompt, curAuthor) VALUES (?, ?, ?, NULL, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?)", id, r.sessionId, mockOf.get(id), variantOf.get(id), r.status || "open", r.title, r.surfaces, r.slots || "[]", r.createdAt, r.updatedAt, r.version, r.curFrom ?? null, r.curPrompt ?? null, r.curAuthor ?? null);
+            this.sql.exec("INSERT INTO posts_next (id, sessionId, designId, state, variant, status, title, surfaces, knobs, slots, createdAt, updatedAt, version, curFrom, curPrompt, curAuthor) VALUES (?, ?, ?, NULL, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?)", id, r.sessionId, designOf.get(id), variantOf.get(id), r.status || "open", r.title, r.surfaces, r.slots || "[]", r.createdAt, r.updatedAt, r.version, r.curFrom ?? null, r.curPrompt ?? null, r.curAuthor ?? null);
         }
         this.sql.exec("DROP TABLE posts");
         this.sql.exec("ALTER TABLE posts_next RENAME TO posts");
-        this.sql.exec("UPDATE comments SET mockId = (SELECT mockId FROM posts WHERE posts.id = comments.postId) WHERE mockId IS NULL");
+        this.sql.exec("UPDATE comments SET designId = (SELECT designId FROM posts WHERE posts.id = comments.postId) WHERE designId IS NULL");
         this.sql.exec("UPDATE comments SET text = (CASE kind WHEN 'accept' THEN 'Accepted' WHEN 'revise' THEN 'Revise' ELSE 'Dropped' END) || (CASE WHEN text = '' THEN '' ELSE ': ' || text END), kind = 'comment' WHERE kind IN ('accept', 'revise', 'drop')");
         const drafts = new Map();
         for (const c of this.sql
-            .exec("SELECT * FROM comments WHERE draft = 1 AND mockId IS NOT NULL ORDER BY seq ASC")
+            .exec("SELECT * FROM comments WHERE draft = 1 AND designId IS NOT NULL ORDER BY seq ASC")
             .toArray()) {
-            const mockId = c.mockId;
-            let draft = drafts.get(mockId);
+            const designId = c.designId;
+            let draft = drafts.get(designId);
             if (!draft) {
                 draft = {
                     version: 1,
                     answers: {},
-                    mix: {},
+                    borrowed: {},
                     tuned: {},
                     comments: [],
                     updatedAt: c.createdAt,
                 };
-                drafts.set(mockId, draft);
+                drafts.set(designId, draft);
             }
             draft.version = Math.max(draft.version, c.postVersion ?? 1);
             draft.comments.push({ part: null, state: null, text: c.text });
             draft.updatedAt = c.createdAt;
         }
-        for (const [mockId, draft] of drafts) {
-            this.sql.exec("UPDATE mocks SET draft = ? WHERE id = ?", JSON.stringify(draft), mockId);
+        for (const [designId, draft] of drafts) {
+            this.sql.exec("UPDATE designs SET draft = ? WHERE id = ?", JSON.stringify(draft), designId);
         }
         this.sql.exec("DELETE FROM comments WHERE draft = 1");
     }
+    // A design no one declared used to be a component. Keep that only where it acts
+    // as one, embedded somewhere or a step of a flow; the rest become sketches.
+    migrateToSketches() {
+        const projectOf = new Map();
+        for (const r of this.sql.exec("SELECT id, project FROM designs").toArray()) {
+            projectOf.set(r.id, r.project);
+        }
+        const used = new Set();
+        for (const r of this.sql.exec("SELECT designId, slots FROM posts").toArray()) {
+            const project = projectOf.get(r.designId);
+            for (const e of parseJson(r.slots, []))
+                used.add(`${project}\u0000${e.slug}`);
+        }
+        for (const r of this.sql.exec("SELECT project, steps FROM flows").toArray()) {
+            for (const x of parseJson(r.steps, [])) {
+                used.add(`${r.project}\u0000${x.design}`);
+            }
+        }
+        for (const r of this.sql
+            .exec("SELECT id, project, slug FROM designs WHERE kind = 'component'")
+            .toArray()) {
+            if (used.has(`${r.project}\u0000${r.slug}`))
+                continue;
+            this.sql.exec("UPDATE designs SET kind = 'sketch' WHERE id = ?", r.id);
+        }
+        this.sql.exec("INSERT OR REPLACE INTO settings (key, value) VALUES ('sketchKind', '1')");
+    }
     settingSync(key) {
         const rows = this.sql.exec("SELECT value FROM settings WHERE key = ?", key).toArray();
         return rows.length ? rows[0].value : null;
     }
     // --- rows ---
     insertVersion(postId, v) {
-        this.sql.exec("INSERT OR REPLACE INTO post_versions (postId, version, title, surfaces, at, fromVersion, prompt, author) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", postId, v.version, v.title, JSON.stringify(v.surfaces ?? []), v.at, v.from ?? null, v.prompt ?? null, v.author ?? null);
+        this.sql.exec("INSERT OR REPLACE INTO post_versions (postId, version, title, surfaces, head, at, fromVersion, prompt, author, sessionId, amendedAt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", postId, v.version, v.title, JSON.stringify(v.surfaces ?? []), surfaceHeads(v.surfaces ?? []), v.at, v.from ?? null, v.prompt ?? null, v.author ?? null, v.publishedBy ?? null, v.amendedAt ?? null);
     }
     rowToVersion(r) {
         return {
@@ -370,9 +765,11 @@ export class SqlStore {
             ...(r.fromVersion == null ? {} : { from: r.fromVersion }),
             ...(r.prompt == null ? {} : { prompt: r.prompt }),
             ...(r.author == null ? {} : { author: r.author }),
+            ...(r.sessionId == null ? {} : { publishedBy: r.sessionId }),
+            ...(r.amendedAt == null ? {} : { amendedAt: r.amendedAt }),
         };
     }
-    historiesFor(ids) {
+    historiesFor(ids, weigh) {
         const out = new Map();
         if (ids.length === 0)
             return out;
@@ -384,12 +781,13 @@ export class SqlStore {
             let list = out.get(id);
             if (!list)
                 out.set(id, (list = []));
+            weigh?.(r.surfaces.length);
             list.push(this.rowToVersion(r));
         }
         return out;
     }
-    rowsToPosts(rows) {
-        const histories = this.historiesFor(rows.map((r) => r.id));
+    rowsToPosts(rows, weigh) {
+        const histories = this.historiesFor(rows.map((r) => r.id), weigh);
         return rows.map((r) => this.rowToPost(r, histories.get(r.id) ?? []));
     }
     rowToSession(r) {
@@ -406,20 +804,29 @@ export class SqlStore {
             keyed: r.key != null,
         };
     }
-    rowToMock(r) {
+    rowToDesign(r) {
         return {
             id: r.id,
             project: r.project,
             slug: r.slug,
             title: r.title,
-            kind: (r.kind === "page" ? "page" : "component"),
+            kind: isDesignKind(r.kind) ? r.kind : "idea",
+            area: r.area ?? null,
+            source: r.source ?? null,
             states: parseJson(r.states, []),
             asks: parseJson(r.asks, []),
             knobs: parseJson(r.knobs, {}),
             widths: parseJson(r.widths, []),
             draft: parseJson(r.draft, null),
             sessionId: r.sessionId ?? null,
-            resolvedAt: r.resolvedAt ?? null,
+            shortlist: !!r.shortlist,
+            archivedAt: r.archivedAt ?? null,
+            archiveReason: r.archiveReason ?? null,
+            notes: parseJson(r.notes, null),
+            stateOutlines: parseJson(r.stateOutlines, {}),
+            answerAdditions: parseJson(r.answerAdditions, []),
+            standings: parseJson(r.standings, {}),
+            sets: parseJson(r.sets, []),
             createdAt: r.createdAt,
             updatedAt: r.updatedAt,
         };
@@ -430,7 +837,7 @@ export class SqlStore {
         return {
             id: r.id,
             sessionId: r.sessionId,
-            mock: r.mockId,
+            design: r.designId,
             state: r.state ?? null,
             variant: r.variant,
             status: (r.status || "open"),
@@ -441,18 +848,24 @@ export class SqlStore {
             version: r.version,
             history,
             ...(knobs ? { knobs } : {}),
-            ...(r.note == null ? {} : { note: r.note }),
+            ...(r.description == null ? {} : { description: r.description }),
             // The column keeps its first name, from when embeds were called slots.
             embeds: parseJson(r.slots, []),
             ...(r.forkedFrom == null ? {} : { forkedFrom: parseJson(r.forkedFrom, null) }),
-            ...(r.starred ? { starred: true } : {}),
+            ...(r.copiedFrom == null ? {} : { copiedFrom: parseJson(r.copiedFrom, null) }),
             ...(r.status === "accepted" && r.acceptedVersion != null
                 ? { acceptedVersion: r.acceptedVersion }
                 : {}),
             ...(hidden.length ? { hiddenVersions: hidden } : {}),
+            ...(r.archiveReason == null ? {} : { archiveReason: r.archiveReason }),
+            ...(r.stayedVersion == null ? {} : { stayedVersion: r.stayedVersion }),
+            ...(r.archivedAt == null ? {} : { archivedAt: r.archivedAt }),
             ...(r.curFrom == null ? {} : { from: r.curFrom }),
             ...(r.curPrompt == null ? {} : { prompt: r.curPrompt }),
             ...(r.curAuthor == null ? {} : { author: r.curAuthor }),
+            ...(r.curSession == null ? {} : { publishedBy: r.curSession }),
+            ...(r.amendedAt == null ? {} : { amendedAt: r.amendedAt }),
+            ...(r.rewrites ? { rewrites: r.rewrites } : {}),
         };
     }
     // The BLOB comes back as an ArrayBuffer (real DO) or a Uint8Array
@@ -478,7 +891,7 @@ export class SqlStore {
             id: r.id,
             seq: r.seq,
             sessionId: r.sessionId,
-            mockId: r.mockId ?? null,
+            designId: r.designId ?? null,
             postId: r.postId ?? null,
             author: r.author,
             text: r.text,
@@ -541,11 +954,18 @@ export class SqlStore {
         this.atomic(() => {
             this.sql.exec("DELETE FROM comments WHERE sessionId = ?", id);
             this.sql.exec("DELETE FROM post_versions WHERE postId IN (SELECT id FROM posts WHERE sessionId = ?)", id);
+            const drawn = JSON.stringify(this.sql
+                .exec("SELECT DISTINCT designId FROM posts WHERE sessionId = ?", id)
+                .toArray()
+                .map((r) => r.designId));
             this.sql.exec("DELETE FROM posts WHERE sessionId = ?", id);
-            // A mock left with no variants has nothing to show.
-            this.sql.exec("DELETE FROM comments WHERE mockId IN (SELECT id FROM mocks WHERE id NOT IN (SELECT mockId FROM posts))");
-            this.sql.exec("DELETE FROM mocks WHERE id NOT IN (SELECT mockId FROM posts)");
-            this.sql.exec("UPDATE mocks SET sessionId = NULL WHERE sessionId = ?", id);
+            // A design left with no variants has nothing to show, unless it was declared ahead
+            // of being drawn, which only goes with the session that planned it. One this
+            // session drew is not a plan, whoever wrote to it last: it would come back as one.
+            const emptied = "id NOT IN (SELECT designId FROM posts) AND (kind = 'idea' OR sessionId = ? OR id IN (SELECT value FROM json_each(?)))";
+            this.sql.exec(`DELETE FROM comments WHERE designId IN (SELECT id FROM designs WHERE ${emptied})`, id, drawn);
+            this.sql.exec(`DELETE FROM designs WHERE ${emptied}`, id, drawn);
+            this.sql.exec("UPDATE designs SET sessionId = NULL WHERE sessionId = ?", id);
             // Posts are gone, so the referenced set reflects survivors only: drop this
             // session's own assets except any a surviving surface still points at
             // (assets are content-addressed and may be shared across sessions).
@@ -583,81 +1003,130 @@ export class SqlStore {
             this.invalidateAssetRefs();
         this.sql.exec("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", stripNul(key), stripNul(value));
     }
-    // --- projects / mocks ---
+    // --- projects / designs ---
     async listProjects() {
-        return summarizeProjects(await this.listMocks(), await this.listSessions(), await this.listPosts());
+        return summarizeProjects(await this.listDesigns(), await this.listSessions());
+    }
+    // Spelled out because `SELECT *` on posts reads the bodies, the very cost search avoids.
+    async listJumpRows() {
+        return {
+            designs: this.sql
+                .exec("SELECT id, project, slug, title, kind, area, states, asks, widths, archivedAt, updatedAt FROM designs")
+                .toArray()
+                .map((r) => ({
+                id: r.id,
+                project: r.project,
+                slug: r.slug,
+                title: r.title,
+                kind: r.kind,
+                area: r.area ?? null,
+                states: parseJson(r.states, []),
+                asks: parseJson(r.asks, []),
+                widths: parseJson(r.widths, []),
+                archivedAt: r.archivedAt ?? null,
+                updatedAt: r.updatedAt,
+            })),
+            variants: this.sql
+                .exec("SELECT designId, state, variant, description, status FROM posts")
+                .toArray()
+                .map((r) => ({
+                designId: r.designId,
+                state: r.state ?? null,
+                variant: r.variant,
+                description: r.description ?? null,
+                status: r.status,
+            })),
+        };
     }
-    async listMocks(project) {
+    async listDesigns(project) {
         const rows = project === undefined
-            ? this.sql.exec("SELECT * FROM mocks ORDER BY updatedAt DESC, rowid DESC").toArray()
+            ? this.sql.exec("SELECT * FROM designs ORDER BY updatedAt DESC, rowid DESC").toArray()
             : this.sql
-                .exec("SELECT * FROM mocks WHERE project = ? ORDER BY updatedAt DESC, rowid DESC", project)
+                .exec("SELECT * FROM designs WHERE project = ? ORDER BY updatedAt DESC, rowid DESC", project)
                 .toArray();
-        return rows.map((r) => this.rowToMock(r));
+        return rows.map((r) => this.rowToDesign(r));
     }
-    async getMock(id) {
-        const rows = this.sql.exec("SELECT * FROM mocks WHERE id = ?", id).toArray();
-        return rows.length > 0 ? this.rowToMock(rows[0]) : null;
+    async getDesign(id) {
+        const rows = this.sql.exec("SELECT * FROM designs WHERE id = ?", id).toArray();
+        return rows.length > 0 ? this.rowToDesign(rows[0]) : null;
     }
-    async findMock(project, slug) {
+    async findDesign(project, slug) {
         const rows = this.sql
-            .exec("SELECT * FROM mocks WHERE project = ? AND slug = ?", project, slug)
+            .exec("SELECT * FROM designs WHERE project = ? AND slug = ?", project, slug)
             .toArray();
-        return rows.length > 0 ? this.rowToMock(rows[0]) : null;
+        return rows.length > 0 ? this.rowToDesign(rows[0]) : null;
     }
-    async createMock(input) {
+    async createDesign(input) {
         const now = new Date().toISOString();
-        const mock = {
+        const design = {
             id: newId(),
             project: stripNul(input.project).trim() || DEFAULT_PROJECT,
             slug: slugify(stripNul(input.slug)),
             title: stripNul(input.title)?.trim() || input.slug,
-            kind: input.kind === "page" ? "page" : "component",
+            kind: isDesignKind(input.kind) ? input.kind : "idea",
+            area: label(input.area),
+            source: label(input.source),
             states: (input.states ?? []).map((s) => stripNul(s)),
             asks: [],
             knobs: input.knobs ?? {},
             widths: input.widths ?? [],
             draft: null,
             sessionId: input.sessionId ?? null,
-            resolvedAt: null,
+            shortlist: !!input.shortlist,
+            archivedAt: null,
+            archiveReason: null,
+            notes: null,
+            stateOutlines: {},
+            answerAdditions: [],
+            standings: {},
+            sets: [],
             createdAt: now,
             updatedAt: now,
         };
-        this.sql.exec("INSERT INTO mocks (id, project, slug, title, kind, states, asks, knobs, widths, draft, sessionId, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?, '[]', ?, ?, NULL, ?, ?, ?)", mock.id, mock.project, mock.slug, mock.title, mock.kind, JSON.stringify(mock.states), JSON.stringify(mock.knobs), JSON.stringify(mock.widths), mock.sessionId, mock.createdAt, mock.updatedAt);
-        return mock;
+        this.sql.exec("INSERT INTO designs (id, project, slug, title, kind, area, source, states, asks, knobs, widths, draft, sessionId, shortlist, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, '[]', ?, ?, NULL, ?, ?, ?, ?)", design.id, design.project, design.slug, design.title, design.kind, design.area, design.source, JSON.stringify(design.states), JSON.stringify(design.knobs), JSON.stringify(design.widths), design.sessionId, design.shortlist ? 1 : 0, design.createdAt, design.updatedAt);
+        return design;
     }
-    async updateMock(id, patch) {
-        const mock = await this.getMock(id);
-        if (!mock)
+    async updateDesign(id, patch) {
+        const design = await this.getDesign(id);
+        if (!design)
             return null;
         const next = {
-            ...mock,
-            ...(patch.title !== undefined && { title: stripNul(patch.title).trim() || mock.title }),
+            ...design,
+            ...(patch.title !== undefined && { title: stripNul(patch.title).trim() || design.title }),
             ...(patch.kind !== undefined && { kind: patch.kind }),
+            ...(patch.area !== undefined && { area: label(patch.area) }),
+            ...(patch.source !== undefined && { source: label(patch.source) }),
             ...(patch.states !== undefined && { states: patch.states.map((s) => stripNul(s)) }),
             ...(patch.asks !== undefined && { asks: patch.asks }),
             ...(patch.knobs !== undefined && { knobs: patch.knobs }),
             ...(patch.widths !== undefined && { widths: patch.widths }),
             ...(patch.sessionId !== undefined && { sessionId: patch.sessionId }),
-            ...(patch.resolvedAt !== undefined && { resolvedAt: patch.resolvedAt }),
+            ...(patch.archivedAt !== undefined && { archivedAt: patch.archivedAt }),
+            ...(patch.archivedAt === null && { archiveReason: null }),
+            ...(patch.archiveReason !== undefined && { archiveReason: patch.archiveReason }),
+            ...(patch.notes !== undefined && { notes: patch.notes }),
+            ...(patch.stateOutlines !== undefined && { stateOutlines: patch.stateOutlines }),
+            ...(patch.answerAdditions !== undefined && { answerAdditions: patch.answerAdditions }),
+            ...(patch.standings !== undefined && { standings: patch.standings }),
+            ...(patch.sets !== undefined && { sets: patch.sets }),
             updatedAt: new Date().toISOString(),
         };
-        this.sql.exec("UPDATE mocks SET title = ?, kind = ?, states = ?, asks = ?, knobs = ?, widths = ?, sessionId = ?, resolvedAt = ?, updatedAt = ? WHERE id = ?", next.title, next.kind, JSON.stringify(next.states), JSON.stringify(next.asks), JSON.stringify(next.knobs), JSON.stringify(next.widths), next.sessionId, next.resolvedAt, next.updatedAt, id);
+        this.sql.exec("UPDATE designs SET title = ?, kind = ?, area = ?, source = ?, states = ?, asks = ?, knobs = ?, widths = ?, sessionId = ?, archivedAt = ?, archiveReason = ?, notes = ?, stateOutlines = ?, answerAdditions = ?, standings = ?, sets = ?, updatedAt = ? WHERE id = ?", next.title, next.kind, next.area, next.source, JSON.stringify(next.states), JSON.stringify(next.asks), JSON.stringify(next.knobs), JSON.stringify(next.widths), next.sessionId, next.archivedAt, next.archiveReason, next.notes ? JSON.stringify(next.notes) : null, JSON.stringify(next.stateOutlines), JSON.stringify(next.answerAdditions), JSON.stringify(next.standings), JSON.stringify(next.sets), next.updatedAt, id);
         if (patch.asks !== undefined)
             this.invalidateAssetRefs();
         return next;
     }
-    async removeMock(id) {
-        const mock = await this.getMock(id);
-        if (!mock)
+    async removeDesign(id) {
+        const design = await this.getDesign(id);
+        if (!design)
             return false;
         this.atomic(() => {
-            this.sql.exec("DELETE FROM comments WHERE mockId = ?", id);
-            this.sql.exec("DELETE FROM post_versions WHERE postId IN (SELECT id FROM posts WHERE mockId = ?)", id);
-            this.sql.exec("DELETE FROM posts WHERE mockId = ?", id);
-            this.sql.exec("DELETE FROM mocks WHERE id = ?", id);
-            for (const flow of this.flowsOf(mock.project)) {
-                const steps = flow.steps.filter((x) => x.mock !== mock.slug);
+            this.sql.exec("DELETE FROM comments WHERE designId = ?", id);
+            this.sql.exec("DELETE FROM post_versions WHERE postId IN (SELECT id FROM posts WHERE designId = ?)", id);
+            this.sql.exec("DELETE FROM posts WHERE designId = ?", id);
+            this.sql.exec("DELETE FROM designs WHERE id = ?", id);
+            for (const flow of this.flowsOf(design.project)) {
+                const steps = flow.steps.filter((x) => x.design !== design.slug);
                 if (steps.length !== flow.steps.length)
                     this.writeFlow(flow, steps);
             }
@@ -665,6 +1134,124 @@ export class SqlStore {
         this.invalidateAssetRefs();
         return true;
     }
+    async nameFirstState(id, state) {
+        const name = stripNul(state);
+        const design = await this.getDesign(id);
+        if (!design || design.states.length > 0)
+            return null;
+        const updatedAt = new Date().toISOString();
+        this.atomic(() => {
+            this.sql.exec("UPDATE posts SET state = ? WHERE designId = ? AND state IS NULL", name, id);
+            this.sql.exec("UPDATE designs SET states = ?, updatedAt = ? WHERE id = ?", JSON.stringify([name]), updatedAt, id);
+            for (const r of this.sql
+                .exec("SELECT id, copiedFrom FROM posts WHERE copiedFrom IS NOT NULL AND designId IN (SELECT id FROM designs WHERE project = ?)", design.project)
+                .toArray()) {
+                const from = parseJson(r.copiedFrom, null);
+                if (from?.design !== id || from.state !== null)
+                    continue;
+                this.sql.exec("UPDATE posts SET copiedFrom = ? WHERE id = ?", JSON.stringify({ ...from, state: name }), r.id);
+            }
+            for (const flow of this.flowsOf(design.project)) {
+                if (!flow.steps.some((x) => x.design === design.slug && x.state === null))
+                    continue;
+                this.writeFlow(flow, flow.steps.map((x) => x.design === design.slug && x.state === null ? { ...x, state: name } : x));
+            }
+            if (design.draft) {
+                const comments = design.draft.comments.map((c) => c.state === null ? { ...c, state: name } : c);
+                this.sql.exec("UPDATE designs SET draft = ? WHERE id = ?", JSON.stringify({ ...design.draft, comments }), id);
+            }
+        });
+        // Copies elsewhere changed too, so nothing cached can be patched one post at a time.
+        this.postCache.clear();
+        this.postCacheBytes = 0;
+        return this.getDesign(id);
+    }
+    async renameDesign(id, slug) {
+        const to = slugify(stripNul(slug));
+        return this.atomic(() => {
+            const rows = this.sql.exec("SELECT * FROM designs WHERE id = ?", id).toArray();
+            if (rows.length === 0)
+                return null;
+            const design = this.rowToDesign(rows[0]);
+            const from = design.slug;
+            if (to === from)
+                return design;
+            const taken = this.sql
+                .exec("SELECT id FROM designs WHERE project = ? AND slug = ?", design.project, to)
+                .toArray();
+            if (taken.length > 0)
+                return null;
+            const updatedAt = new Date().toISOString();
+            this.sql.exec("UPDATE designs SET slug = ?, updatedAt = ? WHERE id = ?", to, updatedAt, id);
+            // History is rewritten too: embeds resolve by slug at render time, so an
+            // old version left naming the old slug would show its components missing.
+            const rewrite = (raw) => {
+                let changed = false;
+                const next = parseJson(raw, []).map((x) => {
+                    if (x.kind !== "html")
+                        return x;
+                    const html = renameSlugRefs(x.html, from, to);
+                    if (html === x.html)
+                        return x;
+                    changed = true;
+                    return { ...x, html };
+                });
+                return changed ? JSON.stringify(next) : null;
+            };
+            const posts = this.sql
+                .exec("SELECT id, surfaces, slots FROM posts WHERE designId IN (SELECT id FROM designs WHERE project = ?)", design.project)
+                .toArray();
+            for (const r of posts) {
+                const postId = r.id;
+                const surfaces = rewrite(r.surfaces);
+                if (surfaces)
+                    this.sql.exec("UPDATE posts SET surfaces = ? WHERE id = ?", surfaces, postId);
+                const embeds = parseJson(r.slots, []);
+                if (embeds.some((e) => e.slug === from)) {
+                    this.sql.exec("UPDATE posts SET slots = ? WHERE id = ?", JSON.stringify(embeds.map((e) => (e.slug === from ? { ...e, slug: to } : e))), postId);
+                }
+                for (const v of this.sql
+                    .exec("SELECT version, surfaces FROM post_versions WHERE postId = ?", postId)
+                    .toArray()) {
+                    const old = rewrite(v.surfaces);
+                    if (!old)
+                        continue;
+                    this.sql.exec("UPDATE post_versions SET surfaces = ? WHERE postId = ? AND version = ?", old, postId, v.version);
+                }
+            }
+            for (const flow of this.flowsOf(design.project)) {
+                if (!flow.steps.some((x) => x.design === from))
+                    continue;
+                this.writeFlow(flow, flow.steps.map((x) => (x.design === from ? { ...x, design: to } : x)));
+            }
+            return { ...design, slug: to, updatedAt };
+        });
+    }
+    async renameProject(from, to) {
+        const target = stripNul(to).trim();
+        return this.atomic(() => {
+            const occupied = this.sql
+                .exec("SELECT COUNT(*) AS n FROM designs WHERE project = ?", target)
+                .one().n;
+            if (occupied > 0)
+                return false;
+            // A project with no designs has nothing a leftover flow could walk.
+            this.sql.exec("DELETE FROM flows WHERE project = ?", target);
+            this.sql.exec("UPDATE designs SET project = ? WHERE project = ?", target, from);
+            this.sql.exec("UPDATE sessions SET project = ? WHERE project = ?", target, from);
+            this.sql.exec("UPDATE flows SET project = ? WHERE project = ?", target, from);
+            for (const prefix of PROJECT_SETTINGS) {
+                const value = this.settingSync(`${prefix}:${from}`);
+                if (value === null)
+                    continue;
+                this.sql.exec("INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)", `${prefix}:${target}`, value);
+                this.sql.exec("DELETE FROM settings WHERE key = ?", `${prefix}:${from}`);
+                if (prefix === "design")
+                    this.invalidateAssetRefs();
+            }
+            return true;
+        });
+    }
     // --- flows ---
     flowsOf(project) {
         return this.sql
@@ -692,7 +1279,7 @@ export class SqlStore {
         return this.flowsOf(project);
     }
     async placeFlowStep(project, name, screen, step) {
-        const clean = { mock: stripNul(screen.mock), state: stripNul(screen.state) };
+        const clean = { design: stripNul(screen.design), state: stripNul(screen.state) };
         const label = stripNul(name);
         return this.atomic(() => {
             const now = new Date().toISOString();
@@ -711,24 +1298,27 @@ export class SqlStore {
             return this.writeFlow(flow, steps);
         });
     }
-    async putDraft(mockId, draft) {
-        const mock = await this.getMock(mockId);
-        if (!mock)
+    async putDraft(designId, draft) {
+        const design = await this.getDesign(designId);
+        if (!design)
             return null;
-        this.sql.exec("UPDATE mocks SET draft = ? WHERE id = ?", draft ? JSON.stringify(draft) : null, mockId);
+        this.sql.exec("UPDATE designs SET draft = ? WHERE id = ?", draft ? JSON.stringify(draft) : null, designId);
         this.invalidateAssetRefs();
-        return { ...mock, draft };
+        return { ...design, draft };
     }
-    touchMock(mockId, at) {
-        this.sql.exec("UPDATE mocks SET updatedAt = ? WHERE id = ?", at, mockId);
+    touchDesign(designId, at) {
+        this.sql.exec("UPDATE designs SET updatedAt = ? WHERE id = ?", at, designId);
     }
     // --- posts ---
     async listPosts(query = {}) {
+        if (query.designId !== undefined && query.sessionId === undefined) {
+            return this.postsOfDesign(query.designId).slice();
+        }
         const clauses = [];
         const params = [];
-        if (query.mockId !== undefined) {
-            clauses.push("mockId = ?");
-            params.push(query.mockId);
+        if (query.designId !== undefined) {
+            clauses.push("designId = ?");
+            params.push(query.designId);
         }
         if (query.sessionId !== undefined) {
             clauses.push("sessionId = ?");
@@ -740,6 +1330,129 @@ export class SqlStore {
             .toArray();
         return this.rowsToPosts(rows);
     }
+    async listPostHeads(project) {
+        const scope = project === undefined ? "" : "WHERE designId IN (SELECT id FROM designs WHERE project = ?)";
+        const args = project === undefined ? [] : [project];
+        const history = new Map();
+        for (const r of this.sql
+            .exec(`SELECT postId, version, head FROM post_versions WHERE postId IN (SELECT id FROM posts ${scope}) ORDER BY version ASC`, ...args)
+            .toArray()) {
+            const id = r.postId;
+            let list = history.get(id);
+            if (!list)
+                history.set(id, (list = []));
+            list.push({ version: r.version, surfaces: parseJson(r.head, []) });
+        }
+        return this.sql
+            .exec(`SELECT ${POST_HEAD_COLUMNS} FROM posts ${scope} ORDER BY createdAt ASC, rowid ASC`, ...args)
+            .toArray()
+            .map((r) => ({
+            ...this.rowToPost(r, []),
+            surfaces: parseJson(r.head, []),
+            history: history.get(r.id) ?? [],
+        }));
+    }
+    // Every open design screen asks, and a project's posts can be hundreds of MB:
+    // the index holds each column read here, so no row with a body is touched.
+    async listCopies(project) {
+        return this.sql
+            .exec("SELECT designId, state, variant, status, copiedFrom FROM posts WHERE copiedFrom IS NOT NULL AND designId IN (SELECT id FROM designs WHERE project = ?)", project)
+            .toArray()
+            .filter((r) => isLive(r.status))
+            .map((r) => ({
+            design: r.designId,
+            state: r.state,
+            variant: r.variant,
+            copiedFrom: parseJson(r.copiedFrom, null),
+        }));
+    }
+    postsOfDesign(designId) {
+        const hit = this.postCache.get(designId);
+        if (hit) {
+            this.postCache.delete(designId);
+            this.postCache.set(designId, hit);
+            return hit.posts;
+        }
+        const rows = this.sql
+            .exec("SELECT * FROM posts WHERE designId = ? ORDER BY createdAt ASC, rowid ASC", designId)
+            .toArray();
+        let bytes = 0;
+        for (const r of rows)
+            bytes += r.surfaces.length;
+        const posts = this.rowsToPosts(rows, (n) => (bytes += n));
+        if (bytes > this.postCacheLimit)
+            return posts;
+        this.postCache.set(designId, { posts, bytes });
+        this.postCacheBytes += bytes;
+        this.trimPostCache();
+        return posts;
+    }
+    trimPostCache() {
+        for (const [id, entry] of this.postCache) {
+            if (this.postCacheBytes <= this.postCacheLimit)
+                break;
+            this.postCache.delete(id);
+            this.postCacheBytes -= entry.bytes;
+        }
+    }
+    // A synchronous write to these posts of one design, re-reading just them after:
+    // a publish into a big lab would otherwise leave the viewer's next read parsing
+    // every design in it.
+    writingPosts(designId, ids, write) {
+        this.holdPostDrop = true;
+        let out;
+        try {
+            out = write();
+        }
+        catch (err) {
+            const entry = this.postCache.get(designId);
+            if (entry) {
+                this.postCache.delete(designId);
+                this.postCacheBytes -= entry.bytes;
+            }
+            throw err;
+        }
+        finally {
+            this.holdPostDrop = false;
+        }
+        const entry = this.postCache.get(designId);
+        if (entry) {
+            const weigh = (p) => p
+                ? [p.surfaces, ...p.history.map((h) => h.surfaces)].reduce((n, x) => n + JSON.stringify(x).length, 0)
+                : 0;
+            for (const id of ids) {
+                const rows = this.sql.exec("SELECT * FROM posts WHERE id = ?", id).toArray();
+                const fresh = rows.length ? this.rowsToPosts(rows)[0] : null;
+                const stale = entry.posts.find((p) => p.id === id);
+                const change = weigh(fresh) - weigh(stale);
+                entry.bytes += change;
+                this.postCacheBytes += change;
+                if (!fresh)
+                    entry.posts = entry.posts.filter((p) => p.id !== id);
+                else if (stale)
+                    entry.posts = entry.posts.map((p) => (p.id === id ? fresh : p));
+                else
+                    entry.posts = [...entry.posts, fresh];
+            }
+            this.trimPostCache();
+        }
+        return out;
+    }
+    cachedPost(id) {
+        for (const { posts } of this.postCache.values()) {
+            const hit = posts.find((p) => p.id === id);
+            if (hit)
+                return hit;
+        }
+        return null;
+    }
+    // For a write that leaves the bodies alone, so the size stands. Archiving
+    // through a lab would otherwise re-read every design in it after each ×.
+    recache(post) {
+        const entry = this.postCache.get(post.design);
+        if (entry)
+            entry.posts = entry.posts.map((p) => (p.id === post.id ? post : p));
+    }
     async countPostsBySession() {
         const counts = new Map();
         for (const row of this.sql
@@ -753,22 +1466,25 @@ export class SqlStore {
         const rows = this.sql.exec("SELECT * FROM posts WHERE id = ?", id).toArray();
         return rows.length > 0 ? this.rowsToPosts(rows)[0] : null;
     }
-    async findPost(mockId, state, variant) {
+    async findPost(designId, state, variant) {
+        const cached = this.postCache.get(designId);
+        if (cached)
+            return cached.posts.find((p) => p.state === state && p.variant === variant) ?? null;
         const rows = this.sql
-            .exec("SELECT * FROM posts WHERE mockId = ? AND state IS ? AND variant = ? ORDER BY createdAt ASC LIMIT 1", mockId, state, variant)
+            .exec("SELECT * FROM posts WHERE designId = ? AND state IS ? AND variant = ? ORDER BY createdAt ASC LIMIT 1", designId, state, variant)
             .toArray();
         return rows.length > 0 ? this.rowsToPosts(rows)[0] : null;
     }
     async createPost(input) {
         if (!(await this.getSession(input.sessionId)))
             return null;
-        if (!(await this.getMock(input.mock)))
+        if (!(await this.getDesign(input.design)))
             return null;
         const now = new Date().toISOString();
         const post = {
             id: newId(),
             sessionId: input.sessionId,
-            mock: input.mock,
+            design: input.design,
             state: input.state === null ? null : stripNul(input.state),
             variant: stripNul(input.variant)?.trim() || DEFAULT_VARIANT,
             status: "open",
@@ -779,16 +1495,20 @@ export class SqlStore {
             version: 1,
             history: [],
             ...(input.knobs ? { knobs: input.knobs } : {}),
-            ...(stripNul(input.note ?? "").trim() ? { note: stripNul(input.note ?? "").trim() } : {}),
+            ...(stripNul(input.description ?? "").trim()
+                ? { description: stripNul(input.description ?? "").trim() }
+                : {}),
             embeds: input.embeds ?? [],
             ...(input.forkedFrom ? { forkedFrom: input.forkedFrom } : {}),
+            ...(input.copiedFrom ? { copiedFrom: input.copiedFrom } : {}),
             ...(input.from === undefined ? {} : { from: input.from }),
             ...(input.prompt === undefined ? {} : { prompt: stripNul(input.prompt) }),
             ...(input.author === undefined ? {} : { author: stripNul(input.author) }),
+            publishedBy: input.publishedBy ?? input.sessionId,
         };
-        this.sql.exec("INSERT INTO posts (id, sessionId, mockId, state, variant, status, title, surfaces, knobs, slots, createdAt, updatedAt, version, curFrom, curPrompt, curAuthor, note, forkedFrom) VALUES (?, ?, ?, ?, ?, 'open', ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?)", post.id, post.sessionId, post.mock, post.state, post.variant, post.title, JSON.stringify(post.surfaces), post.knobs ? JSON.stringify(post.knobs) : null, JSON.stringify(post.embeds), post.createdAt, post.updatedAt, post.from ?? null, post.prompt ?? null, post.author ?? null, post.note ?? null, post.forkedFrom ? JSON.stringify(post.forkedFrom) : null);
+        this.writingPosts(post.design, [post.id], () => this.sql.exec("INSERT INTO posts (id, sessionId, designId, state, variant, status, title, surfaces, head, knobs, slots, createdAt, updatedAt, version, curFrom, curPrompt, curAuthor, description, forkedFrom, copiedFrom, curSession) VALUES (?, ?, ?, ?, ?, 'open', ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?)", post.id, post.sessionId, post.design, post.state, post.variant, post.title, JSON.stringify(post.surfaces), surfaceHeads(post.surfaces), post.knobs ? JSON.stringify(post.knobs) : null, JSON.stringify(post.embeds), post.createdAt, post.updatedAt, post.from ?? null, post.prompt ?? null, post.author ?? null, post.description ?? null, post.forkedFrom ? JSON.stringify(post.forkedFrom) : null, post.copiedFrom ? JSON.stringify(post.copiedFrom) : null, post.publishedBy ?? null));
         this.touch(input.sessionId);
-        this.touchMock(post.mock, now);
+        this.touchDesign(post.design, now);
         this.addAssetRefs(post.surfaces);
         return post;
     }
@@ -807,6 +1527,8 @@ export class SqlStore {
                 ...(post.from === undefined ? {} : { from: post.from }),
                 ...(post.prompt === undefined ? {} : { prompt: post.prompt }),
                 ...(post.author === undefined ? {} : { author: post.author }),
+                ...(post.publishedBy === undefined ? {} : { publishedBy: post.publishedBy }),
+                ...(post.amendedAt === undefined ? {} : { amendedAt: post.amendedAt }),
             };
             // The version in use is kept past the limit: export and embeds resolve to it.
             const pin = post.acceptedVersion ?? -1;
@@ -817,7 +1539,9 @@ export class SqlStore {
             const title = patch.title !== undefined ? stripNul(patch.title).trim() || post.title : post.title;
             const surfaces = patch.surfaces !== undefined ? normalizeSurfaceIds(patch.surfaces) : post.surfaces;
             const knobs = patch.knobs === undefined ? post.knobs : (patch.knobs ?? undefined);
-            const note = patch.note === undefined ? post.note : stripNul(patch.note).trim() || undefined;
+            const description = patch.description === undefined
+                ? post.description
+                : stripNul(patch.description).trim() || undefined;
             const embeds = patch.embeds ?? post.embeds;
             const state = patch.state === undefined ? post.state : patch.state;
             const version = post.version + 1;
@@ -826,22 +1550,27 @@ export class SqlStore {
             const from = patch.from ?? post.version;
             const prompt = stripNul(patch.prompt ?? "");
             const author = patch.author === undefined ? null : stripNul(patch.author);
-            this.sql.exec("UPDATE posts SET title = ?, surfaces = ?, knobs = ?, note = ?, slots = ?, state = ?, updatedAt = ?, version = ?, curFrom = ?, curPrompt = ?, curAuthor = ? WHERE id = ? AND version = ?", title, JSON.stringify(surfaces), knobs ? JSON.stringify(knobs) : null, note ?? null, JSON.stringify(embeds), state, updatedAt, version, from, prompt, author, id, post.version);
-            const affected = this.sql.exec("SELECT changes() AS n").one().n;
-            if (affected > 0) {
+            const publishedBy = patch.publishedBy ?? null;
+            const wrote = this.writingPosts(post.design, [id], () => {
+                this.sql.exec("UPDATE posts SET title = ?, surfaces = ?, head = ?, knobs = ?, description = ?, slots = ?, state = ?, updatedAt = ?, version = ?, curFrom = ?, curPrompt = ?, curAuthor = ?, curSession = ?, amendedAt = NULL WHERE id = ? AND version = ?", title, JSON.stringify(surfaces), surfaceHeads(surfaces), knobs ? JSON.stringify(knobs) : null, description ?? null, JSON.stringify(embeds), state, updatedAt, version, from, prompt, author, publishedBy, id, post.version);
+                if (this.sql.exec("SELECT changes() AS n").one().n === 0)
+                    return false;
                 this.insertVersion(id, archived);
                 this.sql.exec("DELETE FROM post_versions WHERE postId = ? AND version <= ? AND version != ?", id, version - 1 - HISTORY_LIMIT, pin);
+                return true;
+            });
+            if (wrote) {
                 this.touch(post.sessionId);
-                this.touchMock(post.mock, updatedAt);
+                this.touchDesign(post.design, updatedAt);
                 if (patch.surfaces !== undefined)
                     this.addAssetRefs(surfaces);
-                const { knobs: _knobs, note: _note, author: _author, ...rest } = post;
+                const { knobs: _knobs, description: _description, author: _author, publishedBy: _by, amendedAt: _amended, ...rest } = post;
                 return {
                     ...rest,
                     title,
                     surfaces,
                     ...(knobs ? { knobs } : {}),
-                    ...(note ? { note } : {}),
+                    ...(description ? { description } : {}),
                     embeds,
                     state,
                     version,
@@ -850,11 +1579,116 @@ export class SqlStore {
                     from,
                     prompt,
                     ...(author === null ? {} : { author }),
+                    ...(publishedBy === null ? {} : { publishedBy }),
                 };
             }
         }
         return null;
     }
+    async amendPost(id, version, patch) {
+        const post = await this.getPost(id);
+        if (!post || post.version !== version)
+            return null;
+        const title = patch.title !== undefined ? stripNul(patch.title).trim() || post.title : post.title;
+        const surfaces = patch.surfaces !== undefined ? normalizeSurfaceIds(patch.surfaces) : post.surfaces;
+        const knobs = patch.knobs === undefined ? post.knobs : (patch.knobs ?? undefined);
+        const description = patch.description === undefined
+            ? post.description
+            : stripNul(patch.description).trim() || undefined;
+        const embeds = patch.embeds ?? post.embeds;
+        const from = patch.from ?? post.from;
+        const prompt = patch.prompt === undefined ? post.prompt : stripNul(patch.prompt);
+        const author = patch.author === undefined ? post.author : stripNul(patch.author);
+        const amendedAt = new Date().toISOString();
+        const rewrites = (post.rewrites ?? 0) + 1;
+        const wrote = this.writingPosts(post.design, [id], () => {
+            this.sql.exec("UPDATE posts SET title = ?, surfaces = ?, head = ?, knobs = ?, description = ?, slots = ?, curFrom = ?, curPrompt = ?, curAuthor = ?, amendedAt = ?, rewrites = ? WHERE id = ? AND version = ?", title, JSON.stringify(surfaces), surfaceHeads(surfaces), knobs ? JSON.stringify(knobs) : null, description ?? null, JSON.stringify(embeds), from ?? null, prompt ?? null, author ?? null, amendedAt, rewrites, id, version);
+            return this.sql.exec("SELECT changes() AS n").one().n > 0;
+        });
+        if (!wrote)
+            return null;
+        this.touch(post.sessionId);
+        this.touchDesign(post.design, amendedAt);
+        // The surfaces it replaced may have held the only reference to an asset.
+        this.invalidateAssetRefs();
+        const { knobs: _knobs, description: _description, from: _from, prompt: _prompt, author: _author, ...rest } = post;
+        return {
+            ...rest,
+            title,
+            surfaces,
+            ...(knobs ? { knobs } : {}),
+            ...(description ? { description } : {}),
+            embeds,
+            ...(from === undefined ? {} : { from }),
+            ...(prompt === undefined ? {} : { prompt }),
+            ...(author === undefined ? {} : { author }),
+            amendedAt,
+            rewrites,
+        };
+    }
+    async setPosterOnce(id, version, poster, mode) {
+        const post = await this.getPost(id);
+        if (!post || post.version !== version)
+            return false;
+        const at = post.surfaces.findIndex((s) => s.kind === "html");
+        const page = post.surfaces[at];
+        if (!page || page.kind !== "html" || page.poster)
+            return false;
+        const surfaces = post.surfaces.map((s, i) => i === at ? { ...page, poster, ...(mode ? { posterMode: mode } : {}) } : s);
+        const wrote = this.writingPosts(post.design, [id], () => {
+            this.sql.exec("UPDATE posts SET surfaces = ?, head = ? WHERE id = ? AND version = ?", JSON.stringify(surfaces), surfaceHeads(surfaces), id, version);
+            return this.sql.exec("SELECT changes() AS n").one().n > 0;
+        });
+        if (wrote)
+            this.invalidateAssetRefs();
+        return wrote;
+    }
+    async withdrawVersion(id, version, embeds) {
+        const post = await this.getPost(id);
+        if (!post || post.version !== version)
+            return null;
+        const previous = post.history.at(-1);
+        const now = new Date().toISOString();
+        if (!previous) {
+            this.writingPosts(post.design, [id], () => this.atomic(() => {
+                // Only the agent can have written on a version the user never touched;
+                // its messages stay in the design's thread.
+                this.sql.exec("UPDATE comments SET postId = NULL WHERE postId = ?", id);
+                this.sql.exec("DELETE FROM post_versions WHERE postId = ?", id);
+                this.sql.exec("DELETE FROM posts WHERE id = ?", id);
+            }));
+            this.touchDesign(post.design, now);
+            this.invalidateAssetRefs();
+            return { post: null };
+        }
+        const rewrites = (post.rewrites ?? 0) + 1;
+        const hidden = (post.hiddenVersions ?? []).filter((v) => v !== version);
+        this.writingPosts(post.design, [id], () => this.atomic(() => {
+            this.sql.exec("UPDATE posts SET title = ?, surfaces = ?, head = ?, slots = ?, updatedAt = ?, version = ?, curFrom = ?, curPrompt = ?, curAuthor = ?, curSession = ?, amendedAt = ?, rewrites = ?, hiddenVersions = ? WHERE id = ? AND version = ?", previous.title, JSON.stringify(previous.surfaces), surfaceHeads(previous.surfaces), JSON.stringify(embeds), previous.at, previous.version, previous.from ?? null, previous.prompt ?? null, previous.author ?? null, previous.publishedBy ?? null, previous.amendedAt ?? null, rewrites, hidden.length ? JSON.stringify(hidden) : null, id, version);
+            this.sql.exec("DELETE FROM post_versions WHERE postId = ? AND version = ?", id, previous.version);
+        }));
+        this.touchDesign(post.design, now);
+        this.invalidateAssetRefs();
+        const { from: _from, prompt: _prompt, author: _author, publishedBy: _by, amendedAt: _amended, hiddenVersions: _hidden, ...rest } = post;
+        return {
+            post: {
+                ...rest,
+                title: previous.title,
+                surfaces: previous.surfaces,
+                embeds,
+                updatedAt: previous.at,
+                version: previous.version,
+                history: post.history.slice(0, -1),
+                ...(previous.from === undefined ? {} : { from: previous.from }),
+                ...(previous.prompt === undefined ? {} : { prompt: previous.prompt }),
+                ...(previous.author === undefined ? {} : { author: previous.author }),
+                ...(previous.publishedBy === undefined ? {} : { publishedBy: previous.publishedBy }),
+                ...(previous.amendedAt === undefined ? {} : { amendedAt: previous.amendedAt }),
+                ...(hidden.length ? { hiddenVersions: hidden } : {}),
+                rewrites,
+            },
+        };
+    }
     async removePost(id) {
         if (!(await this.getPost(id)))
             return false;
@@ -867,24 +1701,61 @@ export class SqlStore {
         return true;
     }
     async setPostStatus(id, status, acceptedVersion) {
-        const post = await this.getPost(id);
+        const post = this.cachedPost(id) ?? (await this.getPost(id));
         if (!post)
             return null;
         const pin = status === "accepted" ? (acceptedVersion ?? post.version) : null;
-        this.sql.exec("UPDATE posts SET status = ?, acceptedVersion = ? WHERE id = ?", status, pin, id);
-        const { acceptedVersion: _, ...rest } = post;
-        return pin === null ? { ...rest, status } : { ...rest, status, acceptedVersion: pin };
+        // A reason says why it left, and a stay was about the version once in use.
+        const reason = status === "archived" ? (post.archiveReason ?? null) : null;
+        // Archiving what's already archived keeps the day it went.
+        const archivedAt = status === "archived"
+            ? ((post.status === "archived" ? post.archivedAt : undefined) ?? new Date().toISOString())
+            : null;
+        this.raw.exec("UPDATE posts SET status = ?, acceptedVersion = ?, archiveReason = ?, stayedVersion = NULL, archivedAt = ? WHERE id = ?", status, pin, reason, archivedAt, id);
+        const { acceptedVersion: _, archiveReason: _reason, stayedVersion: _stayed, archivedAt: _archivedAt, ...rest } = post;
+        const next = {
+            ...rest,
+            status,
+            ...(pin === null ? {} : { acceptedVersion: pin }),
+            ...(reason === null ? {} : { archiveReason: reason }),
+            ...(archivedAt === null ? {} : { archivedAt }),
+        };
+        this.recache(next);
+        return pin !== null && next.hiddenVersions?.includes(pin)
+            ? this.setVersionHidden(id, pin, false)
+            : next;
     }
-    async setPostStarred(id, starred) {
-        const post = await this.getPost(id);
+    async setPostArchived(id, archivedAt, reason) {
+        const post = this.cachedPost(id) ?? (await this.getPost(id));
+        if (!post)
+            return null;
+        this.raw.exec("UPDATE posts SET status = 'archived', acceptedVersion = NULL, archiveReason = ?, stayedVersion = NULL, archivedAt = ? WHERE id = ?", reason, archivedAt, id);
+        const { acceptedVersion: _, archiveReason: _reason, stayedVersion: _stayed, ...rest } = post;
+        const next = {
+            ...rest,
+            status: "archived",
+            archivedAt,
+            ...(reason === null ? {} : { archiveReason: reason }),
+        };
+        this.recache(next);
+        return next;
+    }
+    async setForkedFrom(id, from) {
+        const post = this.cachedPost(id) ?? (await this.getPost(id));
         if (!post)
             return null;
-        this.sql.exec("UPDATE posts SET starred = ? WHERE id = ?", starred ? 1 : 0, id);
-        const { starred: _, ...rest } = post;
-        return starred ? { ...rest, starred: true } : rest;
+        this.raw.exec("UPDATE posts SET forkedFrom = ? WHERE id = ?", from ? JSON.stringify(from) : null, id);
+        const { forkedFrom: _, ...rest } = post;
+        const next = from ? { ...rest, forkedFrom: from } : rest;
+        this.recache(next);
+        return next;
+    }
+    async bumpRewrites(designId) {
+        const ids = (await this.listPosts({ designId })).map((p) => p.id);
+        this.writingPosts(designId, ids, () => this.sql.exec("UPDATE posts SET rewrites = rewrites + 1 WHERE designId = ?", designId));
     }
     async setVersionHidden(id, version, hidden) {
-        const post = await this.getPost(id);
+        const post = this.cachedPost(id) ?? (await this.getPost(id));
         if (!post)
             return null;
         const set = new Set(post.hiddenVersions ?? []);
@@ -893,9 +1764,46 @@ export class SqlStore {
         else
             set.delete(version);
         const list = [...set].sort((a, b) => a - b);
-        this.sql.exec("UPDATE posts SET hiddenVersions = ? WHERE id = ?", list.length ? JSON.stringify(list) : null, id);
+        this.raw.exec("UPDATE posts SET hiddenVersions = ? WHERE id = ?", list.length ? JSON.stringify(list) : null, id);
         const { hiddenVersions: _, ...rest } = post;
-        return list.length ? { ...rest, hiddenVersions: list } : rest;
+        const next = list.length ? { ...rest, hiddenVersions: list } : rest;
+        this.recache(next);
+        return next;
+    }
+    async deleteOldVersions(id, versions) {
+        const post = await this.getPost(id);
+        if (!post)
+            return null;
+        const gone = new Set(versions.filter((v) => v !== post.version));
+        const hidden = (post.hiddenVersions ?? []).filter((v) => !gone.has(v));
+        this.writingPosts(post.design, [id], () => this.atomic(() => {
+            for (const v of gone) {
+                this.sql.exec("DELETE FROM post_versions WHERE postId = ? AND version = ?", id, v);
+            }
+            this.sql.exec("UPDATE posts SET hiddenVersions = ? WHERE id = ?", hidden.length ? JSON.stringify(hidden) : null, id);
+        }));
+        this.touchDesign(post.design, new Date().toISOString());
+        this.invalidateAssetRefs();
+        return this.getPost(id);
+    }
+    async setPostReason(id, reason) {
+        const post = this.cachedPost(id) ?? (await this.getPost(id));
+        if (!post)
+            return null;
+        this.raw.exec("UPDATE posts SET archiveReason = ? WHERE id = ?", reason, id);
+        const { archiveReason: _, ...rest } = post;
+        const next = reason ? { ...rest, archiveReason: reason } : rest;
+        this.recache(next);
+        return next;
+    }
+    async setPostStayed(id, version) {
+        const post = this.cachedPost(id) ?? (await this.getPost(id));
+        if (!post)
+            return null;
+        this.raw.exec("UPDATE posts SET stayedVersion = ? WHERE id = ?", version, id);
+        const next = { ...post, stayedVersion: version };
+        this.recache(next);
+        return next;
     }
     // --- comments ---
     async listComments(query) {
@@ -905,9 +1813,9 @@ export class SqlStore {
             clauses.push("sessionId = ?");
             params.push(query.sessionId);
         }
-        if (query.mockId !== undefined) {
-            clauses.push("mockId = ?");
-            params.push(query.mockId);
+        if (query.designId !== undefined) {
+            clauses.push("designId = ?");
+            params.push(query.designId);
         }
         if (query.postId !== undefined) {
             clauses.push("postId = ?");
@@ -928,7 +1836,7 @@ export class SqlStore {
         const comment = {
             id: newId(),
             sessionId: input.sessionId,
-            mockId: input.mockId ?? null,
+            designId: input.designId ?? null,
             postId: input.postId ?? null,
             author: stripNul(input.author).trim() || "user",
             text: stripNul(input.text),
@@ -940,7 +1848,7 @@ export class SqlStore {
             viewport: input.viewport ?? null,
             ...(input.payload ? { payload: input.payload } : {}),
         };
-        this.sql.exec("INSERT INTO comments (id, sessionId, mockId, postId, author, text, createdAt, kind, anchor, anchors, postVersion, viewport, payload) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", comment.id, comment.sessionId, comment.mockId, comment.postId, comment.author, comment.text, comment.createdAt, comment.kind, comment.anchor ? JSON.stringify(comment.anchor) : null, JSON.stringify(comment.anchors), comment.postVersion, comment.viewport, comment.payload ? JSON.stringify(comment.payload) : null);
+        this.sql.exec("INSERT INTO comments (id, sessionId, designId, postId, author, text, createdAt, kind, anchor, anchors, postVersion, viewport, payload) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", comment.id, comment.sessionId, comment.designId, comment.postId, comment.author, comment.text, comment.createdAt, comment.kind, comment.anchor ? JSON.stringify(comment.anchor) : null, JSON.stringify(comment.anchors), comment.postVersion, comment.viewport, comment.payload ? JSON.stringify(comment.payload) : null);
         const seq = this.sql.exec("SELECT last_insert_rowid() AS seq").one().seq;
         this.touch(input.sessionId);
         return { ...comment, seq };
@@ -952,7 +1860,7 @@ export class SqlStore {
         return this.insertComment({
             ...input,
             postId: post?.id ?? null,
-            mockId: input.mockId ?? post?.mock ?? null,
+            designId: input.designId ?? post?.design ?? null,
             postVersion: input.postVersion ?? post?.version ?? null,
         });
     }
@@ -967,15 +1875,41 @@ export class SqlStore {
         this.touch(comment.sessionId);
         return comment;
     }
+    async listDecisionSources(project) {
+        const variants = this.sql
+            .exec("SELECT designId, state, variant, status, version, acceptedVersion FROM posts WHERE designId IN (SELECT id FROM designs WHERE project = ?) ORDER BY createdAt ASC, rowid ASC", project)
+            .toArray()
+            .map((r) => ({
+            designId: r.designId,
+            state: r.state ?? null,
+            variant: r.variant,
+            status: r.status,
+            version: r.version,
+            acceptedVersion: r.acceptedVersion ?? null,
+        }));
+        // A close or a move from Home is a reply too, and decides nothing.
+        const decidedAt = {};
+        for (const r of this.sql
+            .exec(`SELECT designId, MAX(createdAt) AS at FROM comments
+         WHERE kind = 'reply' AND designId IN (SELECT id FROM designs WHERE project = ?)
+           AND json_extract(payload, '$.archived') IS NULL
+           AND json_extract(payload, '$.edited') IS NULL
+         GROUP BY designId`, project)
+            .toArray()) {
+            decidedAt[r.designId] = r.at;
+        }
+        return { variants, decidedAt };
+    }
     async commitReply(input) {
         if (!(await this.getSession(input.sessionId)))
             return null;
-        if (!(await this.getMock(input.mockId)))
+        if (!(await this.getDesign(input.designId)))
             return null;
-        return this.atomic(() => {
+        const moved = [...input.accept.map((x) => x.id), ...input.archive, ...(input.release ?? [])];
+        return this.writingPosts(input.designId, moved, () => this.atomic(() => {
             const comment = this.insertComment({
                 sessionId: input.sessionId,
-                mockId: input.mockId,
+                designId: input.designId,
                 author: "user",
                 text: input.text,
                 kind: "reply",
@@ -983,23 +1917,37 @@ export class SqlStore {
                 payload: input.payload,
             });
             this.sql.exec(input.keepDraft
-                ? "UPDATE mocks SET asks = ? WHERE id = ?"
-                : "UPDATE mocks SET asks = ?, draft = NULL WHERE id = ?", JSON.stringify(input.asks), input.mockId);
-            if (input.resolvedAt !== undefined) {
-                this.sql.exec("UPDATE mocks SET resolvedAt = ?, updatedAt = ? WHERE id = ?", input.resolvedAt, input.resolvedAt, input.mockId);
+                ? "UPDATE designs SET asks = ? WHERE id = ?"
+                : "UPDATE designs SET asks = ?, draft = NULL WHERE id = ?", JSON.stringify(input.asks), input.designId);
+            if (input.standings) {
+                this.sql.exec("UPDATE designs SET standings = ? WHERE id = ?", JSON.stringify(input.standings), input.designId);
+            }
+            if (input.owner) {
+                this.sql.exec("UPDATE designs SET sessionId = ? WHERE id = ?", input.owner, input.designId);
             }
             for (const { id, version } of input.accept) {
-                this.sql.exec("UPDATE posts SET status = 'accepted', acceptedVersion = ? WHERE id = ? AND mockId = ?", version, id, input.mockId);
+                // Picking an older version is passing on the newer ones. Otherwise they'd read
+                // as unruled-on, and the viewer would move straight back to them.
+                this.sql.exec("UPDATE posts SET status = 'accepted', acceptedVersion = ?, archiveReason = NULL, stayedVersion = CASE WHEN ? < version THEN version ELSE NULL END, archivedAt = NULL WHERE id = ? AND designId = ?", version, version, id, input.designId);
+                // An answer's whole page stays hidden until it is chosen; now it's a version.
+                const hiddenRow = this.sql
+                    .exec("SELECT hiddenVersions FROM posts WHERE id = ?", id)
+                    .toArray()[0];
+                const hidden = parseJson(hiddenRow?.hiddenVersions, []);
+                if (hidden.includes(version)) {
+                    const left = hidden.filter((v) => v !== version);
+                    this.sql.exec("UPDATE posts SET hiddenVersions = ? WHERE id = ?", left.length ? JSON.stringify(left) : null, id);
+                }
             }
-            for (const id of input.archive) {
-                this.sql.exec("UPDATE posts SET status = 'archived', acceptedVersion = NULL WHERE id = ? AND mockId = ?", id, input.mockId);
+            for (const id of input.release ?? []) {
+                this.sql.exec("UPDATE posts SET status = 'open', acceptedVersion = NULL, stayedVersion = NULL WHERE id = ? AND designId = ? AND status = 'accepted'", id, input.designId);
             }
-            for (const id of input.drop ?? []) {
-                this.sql.exec("UPDATE posts SET status = 'dropped', acceptedVersion = NULL WHERE id = ? AND mockId = ?", id, input.mockId);
+            for (const id of input.archive) {
+                this.sql.exec("UPDATE posts SET status = 'archived', acceptedVersion = NULL, archivedAt = ? WHERE id = ? AND designId = ?", new Date().toISOString(), id, input.designId);
             }
             this.invalidateAssetRefs();
             return comment;
-        });
+        }));
     }
     // --- assets ---
     referencedAssetIds() {
@@ -1013,7 +1961,7 @@ export class SqlStore {
             collectAssetIds(parseJson(r.surfaces, []), out);
         }
         // The user's attachments: in a draft, in a sent reply, on an answered ask.
-        for (const r of this.sql.exec("SELECT asks, draft FROM mocks").toArray()) {
+        for (const r of this.sql.exec("SELECT asks, draft FROM designs").toArray()) {
             collectAttachedIds(parseJson(r.draft, null), out);
             for (const ask of parseJson(r.asks, []))
                 collectAttachedIds(ask, out);