mockpit 2.0.0 → 3.1.0

package/dist/server/types.js

@@ -50,13 +50,42 @@ 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 isDesignKind = (k) => k === "screen" || k === "component" || k === "idea";
 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;
+export const newestVisible = (post) => {
+    const hidden = post.hiddenVersions ?? [];
+    const visible = [post.version, ...post.history.map((h) => h.version)].filter((v) => !hidden.includes(v));
+    return visible.length ? Math.max(...visible) : post.version;
+};
+// What stands for one line of versions: the newest wins until the user presses Use
+// this, and then only their pick does. A version they hid doesn't win.
+export const currentVersion = (post) => post.status === "accepted" ? inUseVersion(post) : newestVisible(post);
+// A newer version than the one in use, which asks before it takes over. Unset until
+// the agent publishes past what the user picked or last chose to stay on.
+export const changedTo = (post) => {
+    if (post.status !== "accepted")
+        return undefined;
+    const newest = newestVisible(post);
+    return newest > Math.max(inUseVersion(post), post.stayedVersion ?? 0) ? newest : undefined;
+};
+// The variant the agent would pick for a state, read off its questions. Parallel
+// variants arrive within minutes of each other, so none of them is "the newest", and
+// this is the only thing that says one of them leads.
+export const recommendedVariant = (asks, state) => {
+    for (const a of asks) {
+        if (a.state !== undefined && a.state !== state)
+            continue;
+        const pick = a.options.find((o) => o.recommended && o.variant);
+        if (pick)
+            return pick.variant;
+    }
+    return undefined;
+};
 // 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) {
@@ -65,7 +94,7 @@ export function postAtVersion(post, version) {
     const old = post.history.find((h) => h.version === version);
     if (!old)
         return null;
-    const { from: _f, prompt: _p, author: _a, ...rest } = post;
+    const { from: _f, prompt: _p, author: _a, contract: _c, system: _s, ...rest } = post;
     return {
         ...rest,
         version: old.version,
@@ -75,9 +104,11 @@ export function postAtVersion(post, version) {
         ...(old.from === undefined ? {} : { from: old.from }),
         ...(old.prompt === undefined ? {} : { prompt: old.prompt }),
         ...(old.author === undefined ? {} : { author: old.author }),
+        ...(old.contract === undefined ? {} : { contract: old.contract }),
+        ...(old.system === undefined ? {} : { system: old.system }),
     };
 }
-// The variant's newest version not after mock version `n` — what the stage
+// The variant's newest version not after design 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)];
@@ -85,12 +116,16 @@ export function versionAt(post, 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;
+// design's first (`ask` accepts version options without a state only while the
+// design has one).
+export const optionState = (ask, design) => ask.state ?? design.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";
+// As far as a block's text is carried: the frame clips to it, the host and the
+// server re-clip, so it also bounds what one comment can repeat back to an agent.
+export const PARAGRAPH_TEXT_MAX = 600;
+export const PARAGRAPHS_MAX = 500;
 // A one-tap verdict on a part (or, with part null, on the variant itself),
 // 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.
@@ -98,23 +133,13 @@ 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;
+// The user's hand edits to a project's decision list (`decisions:<project>`).
+export const DECISION_EDITS_SETTING = "decisions";
+export const MAX_NOTES = 4000;
+// Declared and not drawn yet: a screen or component the agent planned, which its next
+// publish fills. An undeclared design with nothing in it is no plan, only empty.
+export const isPlanned = (design, variants) => design.kind !== "idea" && variants === 0;
+export const sameScreen = (a, b) => a.design === b.design && 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
@@ -134,7 +159,7 @@ export function stripNul(s) {
 // budget the store evicts down to. One Durable Object holds the whole workspace, so
 // the budget sits well under its ~10 GB SQLite ceiling.
 export const MAX_ASSET_BYTES = 5 * 1024 * 1024;
-// What the user may attach to a write-in or a note: raster formats a model can
+// What the user may attach to a write-in or a comment: raster formats a model can
 // read. SVG is active content, so it is never attachable.
 export const ATTACHABLE_IMAGE_TYPES = new Set([
     "image/png",
@@ -146,7 +171,7 @@ export const MAX_ASK_IMAGES = 6;
 export const MAX_WORKSPACE_ASSET_BYTES = 2 * 1024 * 1024 * 1024;
 // Short, unguessable id: 8 random bytes (64 bits) as 11 url-safe base64 chars.
 // These double as bearer capabilities: in publicRead mode `/s/:id` and
-// `/api/mocks/:id` are reachable without the workspace token, so the id IS the
+// `/api/designs/:id` are reachable without the workspace token, so the id IS the
 // share secret and must resist enumeration. btoa is a global in both Node and
 // Workers.
 export const newId = () => {
@@ -178,7 +203,7 @@ export function normalizeSurfaceIds(surfaces) {
 // Fallback project for sessions that never declared one (bare `curl` publishes).
 export const DEFAULT_PROJECT = "workspace";
 export const DEFAULT_VARIANT = "default";
-// Stable, url-safe slug derived from a title. Empty input yields "mock" so a
+// Stable, url-safe slug derived from a title. Empty input yields "design" so a
 // slug is never the empty string.
 export function slugify(input) {
     const slug = input
@@ -189,7 +214,7 @@ export function slugify(input) {
         .replace(/^-+|-+$/g, "")
         .slice(0, 60)
         .replace(/-+$/g, "");
-    return slug || "mock";
+    return slug || "design";
 }
 // Last path segment of a working directory, for sessions that never declared a
 // project. Handles both separators so a Windows cwd resolves the same way.
@@ -206,68 +231,40 @@ export const htmlSurface = (html, kits) => ({
         ? { kits: kits.filter((k) => typeof k === "string") }
         : {}),
 });
-// An open ask is one no reply has answered yet: a write-in or a note alone
+// An open ask is one no reply has answered yet: a write-in or a comment 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) && !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 && isLive(p.status))
-        .map((p) => p.variant);
-    const needs = (state) => {
-        const names = live(state);
-        if (names.length < 2)
-            return false;
-        return !mock.asks.some((a) => (a.scope === "mock" || (a.scope === "state" && a.state === state)) &&
-            names.every((n) => a.options.some((o) => o.variant === n)));
-    };
-    const states = mock.states.length ? mock.states : [null];
-    const needing = states.filter(needs);
-    if (!needing.length)
-        return [];
-    const key = (state) => [...live(state)].sort().join("\n");
-    const first = key(needing[0]);
-    return needing.length === states.length && states.every((st) => key(st) === first)
-        ? [BUILTIN_ASK_ID]
-        : needing.map((st) => (st === null ? BUILTIN_ASK_ID : `${BUILTIN_ASK_ID}:${st}`));
-}
-export const builtinAskCount = (mock, posts, mockId) => builtinAskIds(mock, posts, mockId).length;
-export const openCount = (mock, posts) => openAsks(mock).length + builtinAskCount(mock, posts, mock.id);
+export const askAnswered = (a) => a.answer !== undefined || a.other !== undefined || a.comment !== undefined;
+export const openAsks = (design) => design.asks.filter((a) => !askAnswered(a) && !a.dismissed);
+// Questions an agent asked that wait on the user. The built-in "Which variant?"
+// is not one: no agent is waiting on it, and being shown several designs owes
+// nobody an answer.
+export const openCount = (design) => openAsks(design).length;
 // How many of the open asks the user's unsent draft already speaks for (a
-// pick, a write-in or a note), so Home can show a started mock as "draft 2/4";
+// pick, a write-in or a comment), so Home can show a started design as "draft 2/4";
 // null when there is no draft. A count only: the draft's content stays private.
-export function draftedCount(mock, posts) {
-    const d = mock.draft;
+export function draftedCount(design) {
+    const d = design.draft;
     if (!d)
         return null;
-    const open = [...openAsks(mock).map((a) => a.id), ...builtinAskIds(mock, posts, mock.id)];
     const said = (id) => {
         const a = d.answers[id];
         const picked = Array.isArray(a) ? a.length > 0 : a !== undefined;
-        return picked || d.others?.[id] !== undefined || d.notes?.[id] !== undefined;
+        return picked || d.others?.[id] !== undefined || d.askComments?.[id] !== undefined;
     };
-    return open.filter(said).length;
+    return openAsks(design).filter((a) => said(a.id)).length;
 }
 // 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
+// design-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.
 export const BUILTIN_ASK_ID = "variant";
-export function builtinAsk(mock, posts, id) {
+export function builtinAsk(design, posts, id) {
     let state = null;
     if (id !== BUILTIN_ASK_ID) {
         if (!id.startsWith(`${BUILTIN_ASK_ID}:`))
             return undefined;
         state = id.slice(BUILTIN_ASK_ID.length + 1);
-        if (!mock.states.includes(state))
+        if (!design.states.includes(state))
             return undefined;
     }
     const names = [
@@ -278,7 +275,7 @@ export function builtinAsk(mock, posts, id) {
     return {
         id,
         text: "Which variant?",
-        scope: state === null ? "mock" : "state",
+        scope: state === null ? "design" : "state",
         ...(state === null ? {} : { state }),
         options: names.map((v) => ({ id: v, label: v, variant: v })),
         at: "",
@@ -286,9 +283,9 @@ export function builtinAsk(mock, posts, id) {
 }
 // Per-project rollup for the projects list. Pure, so every store agrees on
 // what "open" and "lastActiveAt" mean.
-export function summarizeProjects(mocks, sessions, posts = []) {
+export function summarizeProjects(designs, sessions) {
     const byProject = new Map();
-    for (const m of mocks) {
+    for (const m of designs) {
         const list = byProject.get(m.project);
         if (list)
             list.push(m);
@@ -308,12 +305,12 @@ export function summarizeProjects(mocks, sessions, posts = []) {
     return [...names]
         .map((name) => {
         const list = byProject.get(name) ?? [];
-        const lastMock = list.reduce((max, m) => (m.updatedAt > max ? m.updatedAt : max), "");
+        const lastDesign = list.reduce((max, m) => (m.updatedAt > max ? m.updatedAt : max), "");
         return {
             name,
-            mocks: list.length,
-            open: list.reduce((n, m) => n + openCount(m, posts), 0),
-            lastActiveAt: [lastMock, sessionActive.get(name) ?? ""].sort().pop() ?? "",
+            designs: list.length,
+            open: list.reduce((n, m) => n + openCount(m), 0),
+            lastActiveAt: [lastDesign, sessionActive.get(name) ?? ""].sort().pop() ?? "",
             sessions: sessionCounts.get(name) ?? 0,
         };
     })
@@ -368,9 +365,9 @@ export function collectAssetIds(surfaces, out) {
     }
 }
 // The images a draft, a reply or a sent ask carries (all keep the user's
-// attachments in otherImages / noteImages).
+// attachments in otherImages / askCommentImages).
 export function collectAttachedIds(holder, out) {
-    for (const map of [holder?.otherImages, holder?.noteImages]) {
+    for (const map of [holder?.otherImages, holder?.askCommentImages]) {
         if (!map || typeof map !== "object")
             continue;
         for (const ids of Array.isArray(map) ? [map] : Object.values(map)) {