mockpit 2.0.0 → 3.0.0

package/dist/server/feedbackBatch.d.ts

@@ -1,5 +1,6 @@
 import { type Decisions } from "./decisions.ts";
-import { type AskOption, type Comment, type CommentAnchor, type Mock, type MockEdit, OTHER_ID, type PartComment, type Post, type Reaction, type Reply, type Store } from "./types.ts";
+import { type StandingView } from "./standings.ts";
+import { type AskOption, type Comment, type CommentAnchor, type Design, type DesignEdit, OTHER_ID, type PartComment, type Post, type Reaction, type Reply, type Store } from "./types.ts";
 export interface VariantRef {
     state: string | null;
     variant: string;
@@ -27,14 +28,40 @@ export interface OtherChoice {
     other: true;
     images?: ImageRef[];
 }
-export interface AnsweredAsk {
+export interface AnsweredAsk extends StandingView {
     ask: string;
     text: string;
     chosen: (AskOption | OtherChoice)[];
+    comment?: string;
+    commentImages?: ImageRef[];
+}
+export interface MoreAnswers {
+    ask: string;
+    text: string;
+    existing: string[];
     note?: string;
-    noteImages?: ImageRef[];
+    like?: string;
+    kept?: string[];
+    hidden?: {
+        label: string;
+        why?: string;
+    }[];
+    answered: {
+        ask: string;
+        text: string;
+        chosen: string[];
+        comment?: string;
+    }[];
 }
-export interface FeedbackReply extends Omit<Reply, "others" | "notes" | "otherImages" | "noteImages"> {
+export interface UpdateRequest {
+    ask: string;
+    text: string;
+    kept: AskOption;
+    inUse: AskOption[];
+}
+export interface FeedbackReply extends Omit<Reply, "others" | "askComments" | "otherImages" | "askCommentImages" | "more" | "standings" | "update"> {
+    more?: MoreAnswers;
+    update?: UpdateRequest;
     seq: number;
     at: string;
     asks: AnsweredAsk[];
@@ -42,25 +69,20 @@ export interface FeedbackReply extends Omit<Reply, "others" | "notes" | "otherIm
     decisions?: Decisions;
 }
 export interface FeedbackBatch {
-    mockId: string | null;
+    designId: string | null;
     project: string | null;
-    mock: string | null;
+    design: string | null;
     title: string | null;
     reply: FeedbackReply | null;
     messages: FeedbackMessage[];
     inUse: InUseRef[];
     archived: VariantRef[];
     handoff?: string;
-    closed?: true;
-    dismissed?: {
-        ask: string;
-        text: string;
-    }[];
-    edited?: MockEdit;
+    edited?: DesignEdit;
 }
 export declare function reactionLine(c: PartComment & {
     reaction: Reaction;
 }): string;
-export declare function groupFeedback(comments: Comment[], mocks: Map<string, Mock>, posts: Map<string, Post[]>, base?: string): FeedbackBatch[];
+export declare function groupFeedback(comments: Comment[], designs: Map<string, Design>, posts: Map<string, Post[]>, base?: string): FeedbackBatch[];
 export declare function buildFeedbackBatches(store: Store, comments: Comment[], base: string): Promise<FeedbackBatch[]>;
 export declare function feedbackImages(batches: FeedbackBatch[]): ImageRef[];

package/dist/server/feedbackBatch.js

@@ -1,10 +1,60 @@
-// The agent-facing shape of feedback: one batch per mock, in delivery order.
+// The agent-facing shape of feedback: one batch per design, in delivery order.
 // The `feedback` verb, the watch long-poll and the write piggyback all return this,
-// so an agent reads one grouped object instead of re-deriving which mock a flat
+// so an agent reads one grouped object instead of re-deriving which design a flat
 // comment list belongs to. Runtime-agnostic (no node imports).
 import { decisionsFor } from "./decisions.js";
+import { ROUTED_NOTE } from "./handoff.js";
+import { standingOf, standingView } from "./standings.js";
 import { builtinAsk, inUseVersion, DEFAULT_VARIANT, OTHER_ID, } from "./types.js";
 const ref = (p) => ({ state: p.state, variant: p.variant });
+function moreAnswers(design, more, sent) {
+    const ask = design.asks.find((a) => a.id === more.ask);
+    if (!ask)
+        return undefined;
+    const st = sent ?? standingOf(design, ask.id);
+    const view = standingView(ask, st);
+    const like = more.like ? ask.options.find((o) => o.id === more.like)?.label : undefined;
+    const labels = (a) => {
+        const ids = a.answer === undefined ? [] : Array.isArray(a.answer) ? a.answer : [a.answer];
+        return [
+            ...ids.map((id) => a.options.find((o) => o.id === id)?.label ?? id),
+            ...(a.other === undefined ? [] : [a.other]),
+        ];
+    };
+    return {
+        ask: ask.id,
+        text: ask.text,
+        // Hidden ones are out: asked again, they'd only fold away.
+        existing: ask.options.filter((o) => !st.hidden.some((h) => h.id === o.id)).map((o) => o.label),
+        ...(more.note ? { note: more.note } : {}),
+        ...(like ? { like } : {}),
+        ...(view?.kept ? { kept: view.kept.map((k) => k.label) } : {}),
+        ...(view?.hidden
+            ? { hidden: view.hidden.map((h) => ({ label: h.label, ...(h.why ? { why: h.why } : {}) })) }
+            : {}),
+        answered: design.asks
+            .filter((a) => a.id !== ask.id && labels(a).length > 0)
+            .map((a) => ({
+            ask: a.id,
+            text: a.text,
+            chosen: labels(a),
+            ...(a.comment ? { comment: a.comment } : {}),
+        })),
+    };
+}
+function updateRequest(design, wanted) {
+    const ask = design.asks.find((a) => a.id === wanted.ask);
+    const kept = ask?.options.find((o) => o.id === wanted.option);
+    if (!ask || !kept)
+        return undefined;
+    const ids = ask.answer === undefined ? [] : [ask.answer].flat();
+    return {
+        ask: ask.id,
+        text: ask.text,
+        kept,
+        inUse: ask.options.filter((o) => ids.includes(o.id)),
+    };
+}
 const REACTION_LEAD = {
     up: "👍",
     down: "👎",
@@ -12,7 +62,7 @@ const REACTION_LEAD = {
 };
 // `👍 part "hero" (variant B, state Mobile)`, `👎 variant B`, `more like this: the page`.
 export function reactionLine(c) {
-    // A mock published without variant names has only "default": naming it is noise.
+    // A design published without variant names has only "default": naming it is noise.
     const named = c.variant && c.variant !== DEFAULT_VARIANT ? c.variant : null;
     // A version is written as agents write it, dark@2.
     const at = c.version ? `@${c.version}` : "";
@@ -31,21 +81,32 @@ export function reactionLine(c) {
     return `${REACTION_LEAD[c.reaction]} ${target}${tail}${note}`;
 }
 const isReaction = (c) => !!c.reaction;
-function answered(reply, mock, posts, base) {
+function answered(reply, design, posts, base) {
     const others = reply.others ?? {};
-    const notes = reply.notes ?? {};
+    const comments = reply.askComments ?? {};
     const refs = (ids) => (ids ?? []).map((id) => ({ id, url: `${base}/a/${encodeURIComponent(id)}` }));
+    const standings = reply.standings ?? {};
     const askIds = new Set([
         ...Object.keys(reply.answers),
         ...Object.keys(others),
-        ...Object.keys(notes),
+        ...Object.keys(comments),
+        // A question whose answers the user only kept or hid is still news: more answers
+        // should follow the kept ones and avoid the hidden.
+        ...Object.keys(standings).filter((id) => id !== reply.more?.ask),
     ]);
     const out = [];
     for (const askId of askIds) {
-        const ask = mock?.asks.find((a) => a.id === askId) ?? (mock && builtinAsk(mock, posts, askId));
+        const ask = design?.asks.find((a) => a.id === askId) ?? (design && builtinAsk(design, posts, askId));
         const answer = reply.answers[askId];
         const ids = answer === undefined ? [] : Array.isArray(answer) ? answer : [answer];
-        const chosen = ids.map((id) => ask?.options.find((o) => o.id === id) ?? { id, label: id });
+        const chosen = ids.map((id) => {
+            const option = ask?.options.find((o) => o.id === id);
+            if (!option)
+                return { id, label: id };
+            // What it brought isn't in any version yet: an agent folding it in needs it here.
+            const brought = design?.answerAdditions.find((a) => Object.entries(option.set ?? {}).some(([k, v]) => a.knob === k && a.value === v));
+            return brought ? { ...option, brought } : option;
+        });
         const otherImages = refs(reply.otherImages?.[askId]);
         if (others[askId] !== undefined)
             chosen.push({
@@ -54,38 +115,44 @@ function answered(reply, mock, posts, base) {
                 other: true,
                 ...(otherImages.length ? { images: otherImages } : {}),
             });
-        const noteImages = refs(reply.noteImages?.[askId]);
+        const commentImages = refs(reply.askCommentImages?.[askId]);
+        const st = standings[askId];
         out.push({
             ask: askId,
             text: ask?.text ?? "",
             chosen,
-            ...(notes[askId] !== undefined ? { note: notes[askId] } : {}),
-            ...(noteImages.length ? { noteImages } : {}),
+            ...(ask && st ? standingView({ ...ask, answer }, st) : {}),
+            ...(comments[askId] !== undefined ? { comment: comments[askId] } : {}),
+            ...(commentImages.length ? { commentImages } : {}),
         });
     }
     return out;
 }
 // Comments arrive in seq order; keep that order both between batches and inside
-// one. A mock gets a fresh batch whenever a second reply arrives for it, so a
+// one. A design gets a fresh batch whenever a second reply arrives for it, so a
 // batch carries at most one reply and nothing is merged away. A comment whose
-// mock is unknown still gets a batch — feedback is never dropped for want of
+// design is unknown still gets a batch — feedback is never dropped for want of
 // context. `base` (origin + base path) makes image URLs absolute.
-export function groupFeedback(comments, mocks, posts, base = "") {
+export function groupFeedback(comments, designs, posts, base = "") {
     const batches = [];
     const open = new Map();
     for (const c of comments) {
-        const key = c.mockId ?? "";
-        const mock = c.mockId ? mocks.get(c.mockId) : undefined;
-        const mockPosts = (c.mockId && posts.get(c.mockId)) || [];
+        // Stored from when a close wrote to this stream. Ending something tells the agent
+        // nothing, so one still ahead of the cursor stays unsaid.
+        if (c.kind === "reply" && c.payload?.archived)
+            continue;
+        const key = c.designId ?? "";
+        const design = c.designId ? designs.get(c.designId) : undefined;
+        const designPosts = (c.designId && posts.get(c.designId)) || [];
         let batch = open.get(key);
-        // An edit says where the mock is now, so it joins whatever batch is open.
+        // An edit says where the design is now, so it joins whatever batch is open.
         const edit = c.kind === "reply" ? c.payload?.edited : undefined;
-        if (!batch || (c.kind === "reply" && !edit && (batch.reply || batch.closed))) {
+        if (!batch || (c.kind === "reply" && !edit && batch.reply)) {
             batch = {
-                mockId: c.mockId,
-                project: mock?.project ?? null,
-                mock: mock?.slug ?? null,
-                title: mock?.title ?? null,
+                designId: c.designId,
+                project: design?.project ?? null,
+                design: design?.slug ?? null,
+                title: design?.title ?? null,
                 reply: null,
                 messages: [],
                 inUse: [],
@@ -98,36 +165,33 @@ export function groupFeedback(comments, mocks, posts, base = "") {
             batch.edited = { ...batch.edited, ...edit };
             continue;
         }
-        if (c.kind === "reply" && c.payload?.closed) {
-            batch.closed = true;
-            batch.dismissed = c.payload.closed.dismissed.map((id) => ({
-                ask: id,
-                text: (mock?.asks.find((a) => a.id === id) ?? (mock && builtinAsk(mock, mockPosts, id)))
-                    ?.text ?? "",
-            }));
-            continue;
-        }
         if (c.kind === "reply" && c.payload) {
-            const { others: _others, notes: _notes, otherImages: _otherImages, noteImages: _noteImages, ...payload } = c.payload;
+            const { others: _others, askComments: _askComments, otherImages: _otherImages, askCommentImages: _askCommentImages, routed, more: asked, standings: _standings, update: wanted, ...payload } = c.payload;
+            const more = asked && design ? moreAnswers(design, asked, c.payload.standings?.[asked.ask]) : undefined;
+            const update = wanted && design ? updateRequest(design, wanted) : undefined;
+            if (routed)
+                batch.handoff = ROUTED_NOTE;
             const reactions = (payload.comments ?? []).filter(isReaction).map(reactionLine);
             batch.reply = {
                 ...payload,
                 comments: (payload.comments ?? []).filter((x) => !x.reaction),
                 seq: c.seq,
                 at: c.createdAt,
-                asks: answered(c.payload, mock, mockPosts, base),
+                asks: answered(c.payload, design, designPosts, base),
                 ...(reactions.length ? { reactions } : {}),
+                ...(more ? { more } : {}),
+                ...(update ? { update } : {}),
             };
-            const decisions = mock ? decisionsFor(mock, mockPosts, c.payload) : null;
+            const decisions = design ? decisionsFor(design, designPosts, c.payload) : null;
             if (decisions)
                 batch.reply.decisions = decisions;
-            batch.inUse = mockPosts
+            batch.inUse = designPosts
                 .filter((p) => p.status === "accepted")
                 .map((p) => ({ ...ref(p), version: inUseVersion(p) }));
-            batch.archived = mockPosts.filter((p) => p.status === "archived").map(ref);
+            batch.archived = designPosts.filter((p) => p.status === "archived").map(ref);
             continue;
         }
-        const post = c.postId ? mockPosts.find((p) => p.id === c.postId) : undefined;
+        const post = c.postId ? designPosts.find((p) => p.id === c.postId) : undefined;
         batch.messages.push({
             seq: c.seq,
             text: c.text,
@@ -142,18 +206,18 @@ export function groupFeedback(comments, mocks, posts, base = "") {
     return batches;
 }
 export async function buildFeedbackBatches(store, comments, base) {
-    const mocks = new Map();
+    const designs = new Map();
     const posts = new Map();
     for (const c of comments) {
-        if (!c.mockId || mocks.has(c.mockId))
+        if (!c.designId || designs.has(c.designId))
             continue;
-        const mock = await store.getMock(c.mockId);
-        if (!mock)
+        const design = await store.getDesign(c.designId);
+        if (!design)
             continue;
-        mocks.set(c.mockId, mock);
-        posts.set(c.mockId, await store.listPosts({ mockId: c.mockId }));
+        designs.set(c.designId, design);
+        posts.set(c.designId, await store.listPosts({ designId: c.designId }));
     }
-    return groupFeedback(comments, mocks, posts, base);
+    return groupFeedback(comments, designs, posts, base);
 }
 // Every image a list of batches carries, in order — what the MCP tiers attach
 // as image content so the model sees what the user attached.
@@ -164,8 +228,8 @@ export function feedbackImages(batches) {
             for (const c of a.chosen)
                 if ("other" in c && c.images)
                     out.push(...c.images);
-            if (a.noteImages)
-                out.push(...a.noteImages);
+            if (a.commentImages)
+                out.push(...a.commentImages);
         }
     }
     return out;

package/dist/server/fills.d.ts

@@ -26,9 +26,13 @@ export interface FillScan {
 }
 export declare function scanFills(html: string): FillScan;
 export declare function slotKnobs(slots: SlotInfo[]): Knobs;
+export declare const cssString: (s: string) => string;
 export declare function slotCss(slots: SlotInfo[]): string;
 export declare function composeFills(html: string, chosen: Record<string, string>): string;
 export declare function slotsInSurfaces(surfaces: Surface[]): SlotInfo[];
+export declare const AS_IS_FILL = "as-is";
+export declare function partOccurrences(html: string, part: string): number;
+export declare function addFill(html: string, part: string, fill: string, markup: string): string;
 export type FillSplice = {
     ok: true;
     surfaces: Surface[];

package/dist/server/fills.js

@@ -165,7 +165,7 @@ export function slotKnobs(slots) {
     }
     return out;
 }
-const cssString = (s) => `"${s.replace(/[\\"]/g, (c) => `\\${c}`).replace(/[\n\r<>]/g, (c) => `\\${c.charCodeAt(0).toString(16)} `)}"`;
+export const cssString = (s) => `"${s.replace(/[\\"]/g, (c) => `\\${c}`).replace(/[\n\r<>]/g, (c) => `\\${c.charCodeAt(0).toString(16)} `)}"`;
 // Shows only the chosen fill of each slot, keyed on the `data-k-<part>`
 // attribute the knob runtime keeps on <html>. The chosen fill is never styled:
 // only the others are hidden, so a fill keeps whatever display the agent gave it.
@@ -254,6 +254,60 @@ function markFill(html, part, fill) {
     const at = m.index + m[0].indexOf("<") + 1 + m[1].length;
     return html.slice(0, at) + add + html.slice(at);
 }
+// The name a plain part's own markup goes by once an answer adds a fill to it.
+export const AS_IS_FILL = "as-is";
+// How many elements declare this part, fills counted once each. A fill can only be
+// added to a part that is one thing or already has fills.
+export function partOccurrences(html, part) {
+    if (scanAll(html).ranges.some((r) => r.part === part))
+        return 1;
+    let n = 0;
+    walkOpenTags(html, (attrs) => {
+        if (attrs["data-part"] === part)
+            n++;
+    });
+    return n;
+}
+function walkOpenTags(html, visit) {
+    TOKEN.lastIndex = 0;
+    let m;
+    while ((m = TOKEN.exec(html))) {
+        if (m[0].startsWith("<!--") || m[1])
+            continue;
+        const tag = m[2].toLowerCase();
+        const end = TOKEN.lastIndex;
+        visit(attributes(m[3] ?? ""), m.index + 1 + m[2].length);
+        TOKEN.lastIndex = end;
+        if (RAW.has(tag)) {
+            const endTag = new RegExp(`</${tag}\\s*>`, "gi");
+            endTag.lastIndex = end;
+            const e = endTag.exec(html);
+            TOKEN.lastIndex = e ? endTag.lastIndex : html.length;
+        }
+    }
+}
+// Adds a fill at render time, leaving the html as it was when it can't: a version
+// without this part has nothing to fill, and one with its own fill of this name
+// already says what that value means.
+export function addFill(html, part, fill, markup) {
+    const ranges = scanAll(html).ranges.filter((r) => r.part === part);
+    if (ranges.some((r) => r.fill === fill))
+        return html;
+    let base = html;
+    if (ranges.length === 0) {
+        const at = [];
+        walkOpenTags(html, (attrs, tagNameEnd) => {
+            if (attrs["data-part"] === part)
+                at.push(tagNameEnd);
+        });
+        if (at.length !== 1)
+            return html;
+        base = `${html.slice(0, at[0])} data-fill="${AS_IS_FILL}" data-fill-default${html.slice(at[0])}`;
+    }
+    const spliced = spliceFills([{ kind: "html", html: base }], { [`${part}#${fill}`]: markup });
+    const surface = spliced.ok ? spliced.surfaces[0] : undefined;
+    return surface?.kind === "html" ? surface.html : html;
+}
 // Replace one fill of a slot, or add it after the slot's last fill, keyed
 // "part#fill". Like spliceParts, every target is located in the original
 // markup and overlapping edits are refused.

package/dist/server/handoff.d.ts

@@ -1,6 +1,9 @@
 import type { Comment, Session } from "./types.ts";
 export declare const HANDOFF_GRACE_MS: number;
-export declare const HANDOFF_NOTE = "Sent to an earlier agent session in this project that has gone quiet; it is yours now. Read the mock before acting.";
+export declare const HANDOFF_NOTE = "Sent to an earlier agent session in this project that has gone quiet; it is yours now. Read the design before acting.";
+export declare const ROUTED_NOTE = "The agent that asked this wasn't listening, so the user sent it to you; it is yours now. Read the design before acting.";
+export declare const OWNER_BUSY_MS: number;
 export declare const ownerActiveAt: (s: Session) => string;
+export declare const sessionName: (s: Session) => string;
 export declare function supersedes(taker: Session, owner: Session, listening: boolean): boolean;
 export declare function handoffReady(comment: Comment, owner: Session, taker: Session, now: number): boolean;

package/dist/server/handoff.js

@@ -1,4 +1,4 @@
-// Orphaned replies: a Send lands on the session that owns the mock, and when
+// Orphaned replies: a Send lands on the session that owns the design, and when
 // that agent restarts into a new session (a new conversation, /clear, a crash)
 // nobody would ever read it. The rule below decides when a newer session may
 // take such a reply instead. Runtime-agnostic (no node imports).
@@ -20,8 +20,14 @@
 // it got before the taker existed goes at once — the user answered, then
 // restarted. A keyed owner always gets the grace: its conversation may resume.
 export const HANDOFF_GRACE_MS = 2 * 60_000;
-export const HANDOFF_NOTE = "Sent to an earlier agent session in this project that has gone quiet; it is yours now. Read the mock before acting.";
+export const HANDOFF_NOTE = "Sent to an earlier agent session in this project that has gone quiet; it is yours now. Read the design before acting.";
+export const ROUTED_NOTE = "The agent that asked this wasn't listening, so the user sent it to you; it is yours now. Read the design before acting.";
+// A waiter stops between a wake and the end of that turn, so an owner that called
+// this recently is working, not gone, and keeps its replies. Same span as "Agent working".
+export const OWNER_BUSY_MS = 5 * 60_000;
 export const ownerActiveAt = (s) => s.agentActiveAt ?? s.lastActiveAt;
+// All the user can recognise a session by: most have no title, and ids mean nothing.
+export const sessionName = (s) => s.cwd?.split(/[\\/]/).filter(Boolean).pop() ?? s.agent;
 export function supersedes(taker, owner, listening) {
     return (owner.id !== taker.id &&
         owner.project !== null &&

package/dist/server/icons.js

@@ -4,7 +4,7 @@
 // imports): it runs inside renderHtmlPage on the Worker too.
 // Served with the server rather than installed per project: lucide (ISC) is
 // what agents reach for by default, mage (Apache-2.0) is what `mockpit init`
-// used to upload as a sprite, so mocks written against it keep rendering.
+// used to upload as a sprite, so designs written against it keep rendering.
 export const BUNDLED_ICON_PREFIXES = ["lucide", "mage"];
 const NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
 export const isIconName = (s) => typeof s === "string" && NAME_RE.test(s);

package/dist/server/index.js

@@ -1,7 +1,9 @@
 import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { compress } from "hono/compress";
 import { createHash } from "node:crypto";
 import { readdir, readFile } from "node:fs/promises";
-import { homedir } from "node:os";
+import { homedir, networkInterfaces } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createApp } from "./app.js";
@@ -40,6 +42,10 @@ for (const name of (await readdir(serverDir)).sort()) {
         renderHash.update(await readFile(join(serverDir, name)));
 }
 renderHash.update(await readFile(join(root, "package-lock.json")).catch(() => pkgJson));
+// Browsers keep a version's document for a year, so a version changed outside
+// the API (a direct store edit) stays stale in them; a new salt on restart
+// re-fetches every document without touching code.
+renderHash.update(process.env.MOCKPIT_RENDER_SALT ?? "");
 const renderRev = renderHash.digest("hex").slice(0, 10);
 const pr = process.env.MOCKPIT_PUBLIC_READ;
 const publicRead = pr === "session" || pr === "full" ? pr : undefined;
@@ -48,7 +54,9 @@ const publicRead = pr === "session" || pr === "full" ? pr : undefined;
 // default lives in ~/.mockpit/, a user-owned dir that survives reinstalls and
 // is writable however the package was installed.
 const dbPath = process.env.MOCKPIT_DB ?? join(homedir(), ".mockpit", "mockpit.db");
-const store = new SqlStore(createSqliteStorage(dbPath));
+// Far past the Durable Object's budget: one lab of inlined pages can be 70 MB,
+// and a design that doesn't fit is re-read and re-parsed on every request.
+const store = new SqlStore(createSqliteStorage(dbPath), { postCacheBytes: 256 * 1024 * 1024 });
 console.log(`mockpit store: SQLite at ${dbPath}`);
 // The event log is on by default, next to the database, so a session can be
 // diagnosed after the fact without having planned to (`scripts/inspect.ts`).
@@ -64,6 +72,27 @@ if (logPath)
 // database never picks up the real ones.
 const rulesPath = dbPath === ":memory:" ? undefined : join(dirname(dbPath), "rules.md");
 const userRules = rulesPath ? () => readFile(rulesPath, "utf8").catch(() => null) : undefined;
+const port = Number(process.env.PORT ?? 8228);
+// MOCKPIT_HOST (or `serve --host`) restricts the listener to one address.
+// Unset keeps the previous behaviour — node's default, every interface — because
+// that is what a container or a LAN-shared instance needs. Set it to 127.0.0.1
+// when the server shares a host with anything you don't want reaching it; that
+// is stronger than the token, which is a single shared secret by design.
+const hostname = process.env.MOCKPIT_HOST || undefined;
+// The addresses a phone might open this server at. Read when asked, since a laptop
+// changes networks while it runs.
+const networkHosts = () => {
+    if (hostname === "127.0.0.1" || hostname === "::1" || hostname === "localhost") {
+        return { localOnly: true, hosts: [] };
+    }
+    if (hostname && hostname !== "0.0.0.0" && hostname !== "::") {
+        return { localOnly: false, hosts: [`${hostname}:${port}`] };
+    }
+    const hosts = Object.values(networkInterfaces())
+        .flat()
+        .flatMap((a) => (a && a.family === "IPv4" && !a.internal ? [`${a.address}:${port}`] : []));
+    return { localOnly: false, hosts: hosts.slice(0, 3) };
+};
 const app = createApp({
     store,
     viewerHtml,
@@ -80,16 +109,16 @@ const app = createApp({
     renderRev,
     // `run` scripts execute in QuickJS inside a worker thread per run.
     executor: createNodeExecutor(),
+    networkHosts,
     log: logPath ? createFileLog(logPath) : undefined,
 });
-const port = Number(process.env.PORT ?? 8228);
-// MOCKPIT_HOST (or `serve --host`) restricts the listener to one address.
-// Unset keeps the previous behaviour — node's default, every interface — because
-// that is what a container or a LAN-shared instance needs. Set it to 127.0.0.1
-// when the server shares a host with anything you don't want reaching it; that
-// is stronger than the token, which is a single shared secret by design.
-const hostname = process.env.MOCKPIT_HOST || undefined;
-serve({ fetch: app.fetch, port, hostname }, (info) => {
+// Cloudflare compresses at its edge; a Node server reached over a network
+// (a tailnet, a LAN) would otherwise send the viewer and every list uncompressed.
+// Hono's filter leaves SSE streams alone.
+const outer = new Hono();
+outer.use(compress());
+outer.all("*", (c) => app.fetch(c.req.raw, c.env));
+serve({ fetch: outer.fetch, port, hostname }, (info) => {
     // Report the address actually bound. Printing "localhost" unconditionally hid
     // the fact that the default listens on every interface.
     const shown = hostname ?? "localhost";

package/dist/server/jump.d.ts

@@ -0,0 +1,21 @@
+import { type JumpRows, type DesignKind } from "./types.ts";
+export type JumpMatch = "title" | "state" | "variant" | "area" | "question" | "description";
+export interface JumpHit {
+    project: string;
+    id: string | null;
+    slug: string | null;
+    title: string;
+    kind: DesignKind | null;
+    width: number | null;
+    area: string | null;
+    match: JumpMatch;
+    text: string | null;
+    state: string | null;
+    variant: string | null;
+    archived: boolean;
+    open: number;
+    designArchived: boolean;
+    inUse: boolean;
+}
+export declare function jumpHits(rows: JumpRows, query: string, project: string | null): JumpHit[];
+export declare function recentHits(rows: JumpRows, ids: string[]): JumpHit[];