mockpit 1.2.0 → 2.0.0

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,15 +197,27 @@ export interface PadValue {
     y: number;
 }
 export type KnobValue = number | boolean | string | PadValue | SpringKnob | EasingKnob;
-export type MockKind = "page" | "component";
+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;
 export interface AskOption {
     id: string;
     label: string;
     variant?: string;
+    version?: number;
     set?: Record<string, KnobValue>;
+    recommended?: true;
 }
 export type AskAnswer = string | string[];
+export declare const optionState: (ask: Pick<Ask, "state">, mock: {
+    states: string[];
+}) => string | null;
 export interface Ask {
     id: string;
     text: string;
@@ -213,11 +226,13 @@ export interface Ask {
     part?: string;
     options: AskOption[];
     multi?: boolean;
+    after?: string;
     answer?: AskAnswer;
     other?: string;
     note?: string;
     otherImages?: string[];
     noteImages?: string[];
+    dismissed?: true;
     at: string;
 }
 export declare const OTHER_ID = "other";
@@ -237,16 +252,22 @@ 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;
 }
 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>;
@@ -259,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>;
@@ -267,26 +288,45 @@ export interface Reply {
     otherImages?: Record<string, string[]>;
     noteImages?: Record<string, string[]>;
     text?: string;
-    decision?: ReplyDecision;
+    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;
+    closedAt: string | null;
     createdAt: string;
     updatedAt: string;
 }
-export interface Slot {
+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;
     version: number;
+    pinned?: true;
 }
 export interface PostVersion {
     version: number;
@@ -297,6 +337,10 @@ export interface PostVersion {
     prompt?: string;
     author?: string;
 }
+export interface ForkRef {
+    variant: string;
+    version: number;
+}
 export interface Post {
     id: string;
     sessionId: string;
@@ -311,11 +355,28 @@ export interface Post {
     version: number;
     history: PostVersion[];
     knobs?: Knobs;
-    slots: Slot[];
+    note?: string;
+    embeds: Embed[];
+    forkedFrom?: ForkRef;
+    starred?: true;
+    acceptedVersion?: number;
+    hiddenVersions?: number[];
     from?: number;
     prompt?: string;
     author?: string;
 }
+export interface FlowStep {
+    mock: string;
+    state: string | null;
+}
+export interface Flow {
+    project: string;
+    name: string;
+    steps: FlowStep[];
+    createdAt: string;
+    updatedAt: string;
+}
+export declare const sameScreen: (a: FlowStep, b: FlowStep) => boolean;
 export interface ProjectSummary {
     name: string;
     mocks: number;
@@ -468,17 +529,25 @@ export interface CreateMockInput {
     slug: string;
     title?: string;
     kind?: MockKind;
+    area?: string | null;
+    source?: string | null;
     states?: string[];
     knobs?: Knobs;
+    widths?: number[];
     sessionId?: string | null;
 }
 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;
+    closedAt?: string | null;
 }
 export interface CreatePostInput {
     sessionId: string;
@@ -488,7 +557,9 @@ export interface CreatePostInput {
     title?: string;
     surfaces: Surface[];
     knobs?: Knobs;
-    slots?: Slot[];
+    note?: string;
+    embeds?: Embed[];
+    forkedFrom?: ForkRef;
     from?: number;
     prompt?: string;
     author?: string;
@@ -497,7 +568,8 @@ export interface UpdatePostInput {
     title?: string;
     surfaces?: Surface[];
     knobs?: Knobs | null;
-    slots?: Slot[];
+    note?: string;
+    embeds?: Embed[];
     from?: number;
     prompt?: string;
     author?: string;
@@ -528,8 +600,13 @@ export interface CommitReplyInput {
     text: string;
     payload: Reply;
     asks: Ask[];
-    accept: string[];
+    accept: {
+        id: string;
+        version: number;
+    }[];
     archive: string[];
+    closedAt?: string;
+    keepDraft?: true;
 }
 export interface PostQuery {
     mockId?: string;
@@ -554,6 +631,10 @@ 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>;
     listPosts(query?: PostQuery): Promise<Post[]>;
     countPostsBySession(): Promise<Map<string, number>>;
@@ -562,7 +643,9 @@ export interface Store {
     createPost(input: CreatePostInput): Promise<Post | null>;
     updatePost(id: string, patch: UpdatePostInput): Promise<Post | null>;
     removePost(id: string): Promise<boolean>;
-    setPostStatus(id: string, status: PostStatus): Promise<Post | null>;
+    setPostStatus(id: string, status: PostStatus, acceptedVersion?: number): Promise<Post | null>;
+    setPostStarred(id: string, starred: boolean): Promise<Post | null>;
+    setVersionHidden(id: string, version: number, hidden: boolean): Promise<Post | null>;
     listComments(query: CommentQuery): Promise<Comment[]>;
     createComment(input: CreateCommentInput): Promise<Comment | null>;
     removeComment(id: string): Promise<Comment | null>;
@@ -600,10 +683,18 @@ export declare function projectFromCwd(cwd: string | null | undefined): string |
 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">, posts: Pick<Post, "mock" | "state" | "variant" | "status">[], mockId: string): string[];
-export declare const builtinAskCount: (mock: Pick<Mock, "asks" | "states">, posts: Pick<Post, "mock" | "state" | "variant" | "status">[], mockId: string) => number;
-export declare const openCount: (mock: Pick<Mock, "id" | "asks" | "states">, posts: Pick<Post, "mock" | "state" | "variant" | "status">[]) => number;
-export declare function draftedCount(mock: Pick<Mock, "id" | "asks" | "states" | "draft">, posts: Pick<Post, "mock" | "state" | "variant" | "status">[]): number | null;
+export declare function builtinAskIds(mock: Pick<Mock, "asks" | "states"> & {
+    closedAt?: string | null;
+}, posts: Pick<Post, "mock" | "state" | "variant" | "status">[], mockId: string): string[];
+export declare const builtinAskCount: (mock: Pick<Mock, "asks" | "states"> & {
+    closedAt?: string | null;
+}, posts: Pick<Post, "mock" | "state" | "variant" | "status">[], mockId: string) => number;
+export declare const openCount: (mock: Pick<Mock, "id" | "asks" | "states"> & {
+    closedAt?: string | null;
+}, posts: Pick<Post, "mock" | "state" | "variant" | "status">[]) => number;
+export declare function draftedCount(mock: Pick<Mock, "id" | "asks" | "states" | "draft"> & {
+    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;
 export declare function summarizeProjects(mocks: Mock[], sessions: Session[], posts?: Post[]): ProjectSummary[];

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,6 +50,44 @@ 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" || 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;
+// A variant as it stood at one of its versions (current or retained), or null
+// when that version is gone.
+export function postAtVersion(post, version) {
+    if (version === post.version)
+        return post;
+    const old = post.history.find((h) => h.version === version);
+    if (!old)
+        return null;
+    const { from: _f, prompt: _p, author: _a, ...rest } = post;
+    return {
+        ...rest,
+        version: old.version,
+        title: old.title,
+        surfaces: old.surfaces,
+        updatedAt: old.at,
+        ...(old.from === undefined ? {} : { from: old.from }),
+        ...(old.prompt === undefined ? {} : { prompt: old.prompt }),
+        ...(old.author === undefined ? {} : { author: old.author }),
+    };
+}
+// The variant's newest version not after mock version `n` — what the stage
+// showed when a draft or reply was bound to n (the viewer's frameVersion).
+export function versionAt(post, n) {
+    const versions = [post.version, ...post.history.map((h) => h.version)];
+    const fit = versions.filter((v) => v <= n);
+    return fit.length ? Math.max(...fit) : Math.min(...versions);
+}
+// The state a version option names a version in: the ask's state, else the
+// mock's first (`ask` accepts version options without a state only while the
+// mock has one).
+export const optionState = (ask, mock) => ask.state ?? mock.states[0] ?? null;
 // The viewer's write-in option on every ask. Reserved, so a delivered
 // `{id: "other", other: true}` choice never shadows an option the agent declared.
 export const OTHER_ID = "other";
@@ -58,6 +95,26 @@ 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
 // agent with that name could otherwise have its programmatic comments delivered
@@ -152,15 +209,18 @@ export const htmlSurface = (html, kits) => ({
 // An open ask is one no reply has answered yet: a write-in or a note alone
 // 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));
-// How many built-in "Which one?" asks the viewer shows: one mock-wide when every
+export const openAsks = (mock) => mock.asks.filter((a) => !askAnswered(a) && !a.dismissed);
+// 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) {
+    // 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 && p.status !== "archived")
+        .filter((p) => p.mock === mockId && p.state === state && isLive(p.status))
         .map((p) => p.variant);
     const needs = (state) => {
         const names = live(state);
@@ -196,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.
@@ -217,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 })),
@@ -266,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 ?? [])
@@ -294,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.
@@ -302,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

package/dist/server/viewerRequest.d.ts

@@ -0,0 +1,2 @@
+export declare const VIEWER_CLIENT = "viewer";
+export declare function isViewerRequest(request: Request): boolean;

package/dist/server/viewerRequest.js

@@ -0,0 +1,14 @@
+// Whether a request comes from the trusted viewer, the page this server
+// served: only it may act as the user (drafts, replies, user comments).
+// Fetch Metadata says so directly, but browsers omit it on plain http away
+// from localhost (a LAN or tailnet address), where the viewer then looked
+// like any other client and every draft call failed. The viewer also names
+// itself with a custom header, which a cross-origin caller cannot send: that
+// header forces a CORS preflight, and this server answers none, so a sandboxed
+// surface (opaque origin) or another site is refused by the browser itself.
+export const VIEWER_CLIENT = "viewer";
+export function isViewerRequest(request) {
+    if (request.headers.get("sec-fetch-site") === "same-origin")
+        return true;
+    return request.headers.get("x-mockpit-client") === VIEWER_CLIENT;
+}