mockpit 1.3.0 → 2.0.0

package/dist/server/sqlStore.js

@@ -1,4 +1,10 @@
-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, isMockKind, newId, normalizeSurfaceIds, projectFromCwd, AREA_ORDER_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];
+// 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,6 +15,35 @@ 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.closed = 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;
+}
 const POST_COLUMNS = `
   id TEXT PRIMARY KEY, sessionId TEXT NOT NULL, mockId TEXT NOT NULL, state TEXT,
   variant TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'open', title TEXT NOT NULL,
@@ -69,7 +104,7 @@ export class SqlStore {
       );
       CREATE TABLE IF NOT EXISTS mocks (
         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 'sketch', 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 '[]'
@@ -108,7 +143,18 @@ export class SqlStore {
             key: "TEXT",
             agentActiveAt: "TEXT",
         });
-        this.addMissing("mocks", { widths: "TEXT NOT NULL DEFAULT '[]'", resolvedAt: "TEXT" });
+        // The close column's first name.
+        const mockCols = this.columns("mocks");
+        if (mockCols.has("resolvedAt") && !mockCols.has("closedAt")) {
+            this.sql.exec("ALTER TABLE mocks RENAME COLUMN resolvedAt TO closedAt");
+        }
+        this.addMissing("mocks", {
+            widths: "TEXT NOT NULL DEFAULT '[]'",
+            closedAt: "TEXT",
+            area: "TEXT",
+            source: "TEXT",
+            situations: "TEXT NOT NULL DEFAULT '{}'",
+        });
         if (legacy)
             this.migrateLegacy();
         // After the legacy lift, which rebuilds posts from POST_COLUMNS alone.
@@ -124,8 +170,57 @@ export class SqlStore {
         if (!pinned) {
             this.sql.exec("UPDATE posts SET acceptedVersion = version WHERE status = 'accepted'");
         }
+        if (this.settingSync("sketchKind") !== "1")
+            this.migrateToSketches();
+        if (this.settingSync("contractTerms") !== "1")
+            this.migrateToContractTerms();
         this.createIndexes();
     }
+    // The agent contract renamed what replies and drafts store (mix → borrowed,
+    // decision → verdict with accept → use, resolved → closed) 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 mocks 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 mocks 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);
@@ -336,7 +431,7 @@ export class SqlStore {
                 draft = {
                     version: 1,
                     answers: {},
-                    mix: {},
+                    borrowed: {},
                     tuned: {},
                     comments: [],
                     updatedAt: c.createdAt,
@@ -352,6 +447,33 @@ export class SqlStore {
         }
         this.sql.exec("DELETE FROM comments WHERE draft = 1");
     }
+    // A mock 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 mocks").toArray()) {
+            projectOf.set(r.id, r.project);
+        }
+        const used = new Set();
+        for (const r of this.sql.exec("SELECT mockId, slots FROM posts").toArray()) {
+            const project = projectOf.get(r.mockId);
+            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.mock}`);
+            }
+        }
+        for (const r of this.sql
+            .exec("SELECT id, project, slug FROM mocks WHERE kind = 'component'")
+            .toArray()) {
+            if (used.has(`${r.project}\u0000${r.slug}`))
+                continue;
+            this.sql.exec("UPDATE mocks 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;
@@ -412,14 +534,17 @@ export class SqlStore {
             project: r.project,
             slug: r.slug,
             title: r.title,
-            kind: (r.kind === "page" ? "page" : "component"),
+            kind: isMockKind(r.kind) ? r.kind : "sketch",
+            area: r.area ?? null,
+            source: r.source ?? null,
             states: parseJson(r.states, []),
+            situations: parseJson(r.situations, {}),
             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,
+            closedAt: r.closedAt ?? null,
             createdAt: r.createdAt,
             updatedAt: r.updatedAt,
         };
@@ -612,18 +737,21 @@ export class SqlStore {
             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: isMockKind(input.kind) ? input.kind : "sketch",
+            area: label(input.area),
+            source: label(input.source),
             states: (input.states ?? []).map((s) => stripNul(s)),
+            situations: {},
             asks: [],
             knobs: input.knobs ?? {},
             widths: input.widths ?? [],
             draft: null,
             sessionId: input.sessionId ?? null,
-            resolvedAt: null,
+            closedAt: null,
             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);
+        this.sql.exec("INSERT INTO mocks (id, project, slug, title, kind, area, source, states, asks, knobs, widths, draft, sessionId, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, '[]', ?, ?, NULL, ?, ?, ?)", mock.id, mock.project, mock.slug, mock.title, mock.kind, mock.area, mock.source, JSON.stringify(mock.states), JSON.stringify(mock.knobs), JSON.stringify(mock.widths), mock.sessionId, mock.createdAt, mock.updatedAt);
         return mock;
     }
     async updateMock(id, patch) {
@@ -634,15 +762,18 @@ export class SqlStore {
             ...mock,
             ...(patch.title !== undefined && { title: stripNul(patch.title).trim() || mock.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.situations !== undefined && { situations: patch.situations }),
             ...(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.closedAt !== undefined && { closedAt: patch.closedAt }),
             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 mocks SET title = ?, kind = ?, area = ?, source = ?, states = ?, situations = ?, asks = ?, knobs = ?, widths = ?, sessionId = ?, closedAt = ?, updatedAt = ? WHERE id = ?", next.title, next.kind, next.area, next.source, JSON.stringify(next.states), JSON.stringify(next.situations), JSON.stringify(next.asks), JSON.stringify(next.knobs), JSON.stringify(next.widths), next.sessionId, next.closedAt, next.updatedAt, id);
         if (patch.asks !== undefined)
             this.invalidateAssetRefs();
         return next;
@@ -665,6 +796,92 @@ export class SqlStore {
         this.invalidateAssetRefs();
         return true;
     }
+    async renameMock(id, slug) {
+        const to = slugify(stripNul(slug));
+        return this.atomic(() => {
+            const rows = this.sql.exec("SELECT * FROM mocks WHERE id = ?", id).toArray();
+            if (rows.length === 0)
+                return null;
+            const mock = this.rowToMock(rows[0]);
+            const from = mock.slug;
+            if (to === from)
+                return mock;
+            const taken = this.sql
+                .exec("SELECT id FROM mocks WHERE project = ? AND slug = ?", mock.project, to)
+                .toArray();
+            if (taken.length > 0)
+                return null;
+            const updatedAt = new Date().toISOString();
+            this.sql.exec("UPDATE mocks 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 mockId IN (SELECT id FROM mocks WHERE project = ?)", mock.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(mock.project)) {
+                if (!flow.steps.some((x) => x.mock === from))
+                    continue;
+                this.writeFlow(flow, flow.steps.map((x) => (x.mock === from ? { ...x, mock: to } : x)));
+            }
+            return { ...mock, 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 mocks WHERE project = ?", target)
+                .one().n;
+            if (occupied > 0)
+                return false;
+            // A project with no mocks has nothing a leftover flow could walk.
+            this.sql.exec("DELETE FROM flows WHERE project = ?", target);
+            this.sql.exec("UPDATE mocks 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
@@ -985,8 +1202,8 @@ export class SqlStore {
             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);
+            if (input.closedAt !== undefined) {
+                this.sql.exec("UPDATE mocks SET closedAt = ?, updatedAt = ? WHERE id = ?", input.closedAt, input.closedAt, input.mockId);
             }
             for (const { id, version } of input.accept) {
                 this.sql.exec("UPDATE posts SET status = 'accepted', acceptedVersion = ? WHERE id = ? AND mockId = ?", version, id, input.mockId);
@@ -994,9 +1211,6 @@ export class SqlStore {
             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.drop ?? []) {
-                this.sql.exec("UPDATE posts SET status = 'dropped', acceptedVersion = NULL WHERE id = ? AND mockId = ?", id, input.mockId);
-            }
             this.invalidateAssetRefs();
             return comment;
         });

package/dist/server/types.d.ts

@@ -68,6 +68,7 @@ export interface HtmlSurface {
     kind: "html";
     html: string;
     kits?: string[];
+    poster?: string;
 }
 export interface MarkdownSurface {
     kind: "markdown";
@@ -196,9 +197,12 @@ export interface PadValue {
     y: number;
 }
 export type KnobValue = number | boolean | string | PadValue | SpringKnob | EasingKnob;
-export type MockKind = "page" | "component";
-export type PostStatus = "open" | "accepted" | "archived" | "dropped";
-export declare const isLive: (status: PostStatus) => boolean;
+export type MockKind = "page" | "component" | "sketch";
+export declare const isMockKind: (k: unknown) => k is MockKind;
+export type PostStatus = "open" | "accepted" | "archived";
+export type VariantStatus = "open" | "inUse" | "archived";
+export declare const variantStatus: (status: PostStatus) => VariantStatus;
+export declare const isLive: (status: PostStatus | VariantStatus) => boolean;
 export declare const inUseVersion: (post: Pick<Post, "status" | "version" | "acceptedVersion">) => number;
 export declare function postAtVersion(post: Post, version: number): Post | null;
 export declare function versionAt(post: Pick<Post, "version" | "history">, n: number): number;
@@ -208,6 +212,7 @@ export interface AskOption {
     variant?: string;
     version?: number;
     set?: Record<string, KnobValue>;
+    recommended?: true;
 }
 export type AskAnswer = string | string[];
 export declare const optionState: (ask: Pick<Ask, "state">, mock: {
@@ -247,9 +252,14 @@ export interface PartComment {
     anchor?: PartCommentAnchor;
     reaction?: Reaction;
     variant?: string;
+    version?: number;
+    borrow?: {
+        from: string;
+        part?: string;
+    };
 }
-export interface ReplyDecision {
-    kind: "accept" | "revise" | "drop";
+export interface ReplyVerdict {
+    kind: "use" | "revise";
     state: string | null;
     variant: string;
     version?: number;
@@ -257,7 +267,7 @@ export interface ReplyDecision {
 export interface Draft {
     version: number;
     answers: Record<string, AskAnswer>;
-    mix: Record<string, string>;
+    borrowed: Record<string, string>;
     tuned: Record<string, KnobValue>;
     comments: PartComment[];
     others?: Record<string, string>;
@@ -270,7 +280,7 @@ export interface Reply {
     mockId: string;
     version: number;
     answers: Record<string, AskAnswer>;
-    mix: Record<string, string>;
+    borrowed: Record<string, string>;
     tuned: Record<string, KnobValue>;
     comments: PartComment[];
     others?: Record<string, string>;
@@ -278,27 +288,40 @@ export interface Reply {
     otherImages?: Record<string, string[]>;
     noteImages?: Record<string, string[]>;
     text?: string;
-    decision?: ReplyDecision;
-    resolved?: {
+    verdict?: ReplyVerdict;
+    closed?: {
         dismissed: string[];
     };
+    edited?: MockEdit;
+}
+export interface MockEdit {
+    kind?: MockKind;
+    area?: string | null;
 }
+export declare const AREA_ORDER_SETTING = "areaOrder";
 export interface Mock {
     id: string;
     project: string;
     slug: string;
     title: string;
     kind: MockKind;
+    area: string | null;
+    source: string | null;
     states: string[];
+    situations: Record<string, string[]>;
     asks: Ask[];
     knobs: Knobs;
     widths: number[];
     draft: Draft | null;
     sessionId: string | null;
-    resolvedAt: string | null;
+    closedAt: string | null;
     createdAt: string;
     updatedAt: string;
 }
+export declare const NORMAL_SITUATION = "Normal";
+export declare const situationKey: (state: string, situation: string) => string;
+export declare function momentOf(situations: Record<string, string[]>, state: string | null): string | null;
+export declare const momentsOf: (states: string[], situations: Record<string, string[]>) => string[];
 export interface Embed {
     slug: string;
     variant: string;
@@ -506,6 +529,8 @@ export interface CreateMockInput {
     slug: string;
     title?: string;
     kind?: MockKind;
+    area?: string | null;
+    source?: string | null;
     states?: string[];
     knobs?: Knobs;
     widths?: number[];
@@ -514,12 +539,15 @@ export interface CreateMockInput {
 export interface UpdateMockInput {
     title?: string;
     kind?: MockKind;
+    area?: string | null;
+    source?: string | null;
     states?: string[];
+    situations?: Record<string, string[]>;
     asks?: Ask[];
     knobs?: Knobs;
     widths?: number[];
     sessionId?: string | null;
-    resolvedAt?: string | null;
+    closedAt?: string | null;
 }
 export interface CreatePostInput {
     sessionId: string;
@@ -577,8 +605,7 @@ export interface CommitReplyInput {
         version: number;
     }[];
     archive: string[];
-    drop?: string[];
-    resolvedAt?: string;
+    closedAt?: string;
     keepDraft?: true;
 }
 export interface PostQuery {
@@ -604,6 +631,8 @@ export interface Store {
     createMock(input: CreateMockInput): Promise<Mock>;
     updateMock(id: string, patch: UpdateMockInput): Promise<Mock | null>;
     removeMock(id: string): Promise<boolean>;
+    renameMock(id: string, slug: string): Promise<Mock | null>;
+    renameProject(from: string, to: string): Promise<boolean>;
     listFlows(project: string): Promise<Flow[]>;
     placeFlowStep(project: string, name: string, screen: FlowStep, step: number): Promise<Flow | null>;
     putDraft(mockId: string, draft: Draft | null): Promise<Mock | null>;
@@ -655,16 +684,16 @@ export declare const htmlSurface: (html: string, kits?: unknown) => HtmlSurface;
 export declare const askAnswered: (a: Pick<Ask, "answer" | "other" | "note">) => boolean;
 export declare const openAsks: (mock: Pick<Mock, "asks">) => Ask[];
 export declare function builtinAskIds(mock: Pick<Mock, "asks" | "states"> & {
-    resolvedAt?: string | null;
+    closedAt?: string | null;
 }, posts: Pick<Post, "mock" | "state" | "variant" | "status">[], mockId: string): string[];
 export declare const builtinAskCount: (mock: Pick<Mock, "asks" | "states"> & {
-    resolvedAt?: string | null;
+    closedAt?: string | null;
 }, posts: Pick<Post, "mock" | "state" | "variant" | "status">[], mockId: string) => number;
 export declare const openCount: (mock: Pick<Mock, "id" | "asks" | "states"> & {
-    resolvedAt?: string | null;
+    closedAt?: string | null;
 }, posts: Pick<Post, "mock" | "state" | "variant" | "status">[]) => number;
 export declare function draftedCount(mock: Pick<Mock, "id" | "asks" | "states" | "draft"> & {
-    resolvedAt?: string | null;
+    closedAt?: string | null;
 }, posts: Pick<Post, "mock" | "state" | "variant" | "status">[]): number | null;
 export declare const BUILTIN_ASK_ID = "variant";
 export declare function builtinAsk(mock: Pick<Mock, "states">, posts: Pick<Post, "state" | "variant">[], id: string): Ask | undefined;

package/dist/server/types.js

@@ -9,9 +9,8 @@
 // build their `kind` enums from it, so a kind can't be added to the model
 // without the MCP tier advertising it too (the gap that left `json`/`code`
 // publishable over CLI/REST but invisible to MCP). The per-kind FIELD schemas
-// in postSurfaces.ts and mcpSpec.ts are still hand-written; test/mcpSpec.test.ts
-// guards that every kind here round-trips through both the MCP schema and the
-// validator with its fields, so neither half can silently fall behind.
+// in postSurfaces.ts and mcpSpec.ts are still hand-written: a kind added here
+// needs its fields in both, or one half silently falls behind.
 export const SURFACE_KINDS = [
     "html",
     "diff",
@@ -51,8 +50,10 @@ export function isSurfaceKind(kind) {
 export function isSandboxedSurfaceKind(kind) {
     return isSurfaceKind(kind) && SURFACE_KIND_METADATA[kind].sandboxed;
 }
+export const isMockKind = (k) => k === "page" || k === "component" || k === "sketch";
+export const variantStatus = (status) => status === "accepted" ? "inUse" : status;
 // Still in the running: what the user can choose between.
-export const isLive = (status) => status === "open" || status === "accepted";
+export const isLive = (status) => status === "open" || status === "accepted" || status === "inUse";
 // The version a variant is resolved at when nothing names one: the version in
 // use when accepted, else its latest.
 export const inUseVersion = (post) => post.status === "accepted" ? (post.acceptedVersion ?? post.version) : post.version;
@@ -94,6 +95,25 @@ export const OTHER_ID = "other";
 // for a reviewer on a phone who would rather not type: like, dislike, or
 // "more like this". Rides as a part comment, so it travels in the one reply.
 export const REACTIONS = ["up", "down", "more"];
+// The settings key prefix of a project's area order (`areaOrder:<project>`): a
+// JSON array of area names, the order Home lists them in.
+export const AREA_ORDER_SETTING = "areaOrder";
+// The state's own render, when a state has situations.
+export const NORMAL_SITUATION = "Normal";
+// The state a situation is stored as: what feedback, decisions and export name.
+export const situationKey = (state, situation) => `${state} · ${situation}`;
+// The state a situation belongs to, or the state itself.
+export function momentOf(situations, state) {
+    if (state === null)
+        return null;
+    for (const [moment, names] of Object.entries(situations)) {
+        if (names.some((n) => situationKey(moment, n) === state))
+            return moment;
+    }
+    return state;
+}
+// The states that are moments of the mock, not situations of one.
+export const momentsOf = (states, situations) => states.filter((st) => momentOf(situations, st) === st);
 export const sameScreen = (a, b) => a.mock === b.mock && a.state === b.state;
 export const HISTORY_LIMIT = 20;
 // "user" is the reserved trust label for genuine human comments. A session
@@ -190,14 +210,14 @@ export const htmlSurface = (html, kits) => ({
 // answers it too ("Neither, because…").
 export const askAnswered = (a) => a.answer !== undefined || a.other !== undefined || a.note !== undefined;
 export const openAsks = (mock) => mock.asks.filter((a) => !askAnswered(a) && !a.dismissed);
-// How many built-in "Which one?" asks the viewer shows: one mock-wide when every
+// How many built-in "Which variant?" questions the viewer shows: one mock-wide when every
 // state needs one and the live names line up, else one per needing state. Same
 // rule as viewer/src/logic.ts builtinAsks, so Home, `read` and `pending` count
 // the question the user actually sees. Answering it archives the losers, which
 // is what makes it stop counting.
 export function builtinAskIds(mock, posts, mockId) {
-    // Resolving closed the choice along with every other open question.
-    if (mock.resolvedAt)
+    // Closing the mock closed the choice along with every other open question.
+    if (mock.closedAt)
         return [];
     const live = (state) => posts
         .filter((p) => p.mock === mockId && p.state === state && isLive(p.status))
@@ -236,7 +256,7 @@ export function draftedCount(mock, posts) {
     };
     return open.filter(said).length;
 }
-// The viewer's built-in "Which one?" for variants no agent ask binds: `variant`
+// The viewer's built-in "Which variant?" for variants no agent ask binds: `variant`
 // mock-wide, `variant:<state>` per state. Never stored; synthesized from the
 // variants so a reply answering it validates, flips and reads like any ask. An
 // option's id is the variant name, so the viewer needs no id mapping.
@@ -257,7 +277,7 @@ export function builtinAsk(mock, posts, id) {
         return undefined;
     return {
         id,
-        text: "Which one?",
+        text: "Which variant?",
         scope: state === null ? "mock" : "state",
         ...(state === null ? {} : { state }),
         options: names.map((v) => ({ id: v, label: v, variant: v })),
@@ -306,7 +326,7 @@ export function surfacesByteLength(surfaces) {
     let n = 0;
     for (const p of surfaces) {
         if (p.kind === "html")
-            n += p.html.length;
+            n += p.html.length + (p.poster?.length ?? 0);
         else if (p.kind === "diff") {
             n += p.patch?.length ?? 0;
             for (const f of p.files ?? [])
@@ -334,7 +354,8 @@ export function surfacesByteLength(surfaces) {
     }
     return n;
 }
-// Collect the asset ids an ordered surfaces list references (image surfaces).
+// Collect the asset ids an ordered surfaces list references (image surfaces
+// and html posters).
 // Used to keep referenced assets out of eviction's first wave. Assets embedded
 // by raw URL inside html markup are invisible here — touch-on-serve keeps those
 // warm instead.
@@ -342,6 +363,8 @@ export function collectAssetIds(surfaces, out) {
     for (const p of surfaces) {
         if (p.kind === "image")
             out.add(p.assetId);
+        else if (p.kind === "html" && p.poster)
+            out.add(p.poster);
     }
 }
 // The images a draft, a reply or a sent ask carries (all keep the user's