@vibes.diy/api-svc 14.3.84 → 14.3.85

package/intern/mercury-first-build.js

@@ -0,0 +1,808 @@
+import { Result, exception2Result } from "@adviser/cement";
+import { type } from "arktype";
+import { lazyType } from "@vibes.diy/api-types/lazy-type";
+import { KNOWN_VALUES_DIRECT_CONTROLS } from "./agent-session-instruction.js";
+import { addressWordsSentence } from "./instruction-variant.js";
+import { capRetryDelayMs, parseRetryAfterMs, readFailureBody, waitMs } from "../public/provider-errors.js";
+export const MERCURY_FIRST_BUILD_MODEL = "inception/mercury-2.5";
+export const MERCURY_FIRST_BUILD_REASONING = { effort: "none" };
+export const MERCURY_CALL_DEADLINE_MS = 8_000;
+export const MERCURY_CALL_ATTEMPTS = 2;
+export const MERCURY_TRANSIENT_RETRIES = 3;
+export const MERCURY_TRANSIENT_BACKOFF_MS = 400;
+const MERCURY_TRANSIENT_MAX_WAIT_MS = 2_000;
+const MERCURY_TRANSIENT_STATUSES = new Set([429, 502, 503, 504]);
+class MercuryTransientError extends Error {
+    retryAfterMs;
+    constructor(message, retryAfterMs) {
+        super(message);
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+export const MERCURY_ARCHETYPES = ["personal", "group", "publish", "intake", "open", "toy"];
+export const MERCURY_FLAGS = [
+    "ai",
+    "composer",
+    "imageGen",
+    "backend",
+    "calendar",
+    "audio",
+    "threeD",
+    "charts",
+    "boardGame",
+    "sensitive",
+];
+export const MERCURY_BRIEF_FIELDS = ["opening", "access", "seed", "look", "pairs", "icon"];
+export const MERCURY_SHAPE_SYSTEM = `You classify a person's one-message request for a small web app before a build brief is written. Return only JSON.
+
+archetype, exactly one:
+- personal: one person's own tool ("for me", "my", "private", a tracker, a log, a list, a journal) with no other people named.
+- group: the person names other people who use it with them (we, our, friends, family, team, club, kids, housemates, partner, members, a foursome).
+- publish: the person writes and other people only read (a blog, menu, gallery, portfolio, schedule, zine, "everyone can read").
+- intake: strangers or customers submit something without signing up and the person sees the submissions (orders, bookings, requests, sign-ups, replies, reports from the public).
+- open: anyone with the link joins in and adds their own bit (a shared wall, canvas, feed, leaderboard game, community board, swap board, "anyone can post").
+- toy: a game, simulator, visual, sound or generator that keeps little or nothing (scores at most).
+Tie-breaks: group means other people open the app on their own devices; a calculator, splitter or tool used on one phone "with friends" at the table is personal. toy is for games, simulators and visual or sound toys; a tool that analyzes, estimates, designs, counts, tracks or logs stores records and is personal. A "feed of information" pulled from the internet is personal with backend true. A test or nonsense phrase is still a request: make the most playful literal app of it (a "squash bloom soothsayer" is a fortune teller about squash) and classify that.
+
+coreAction: the one thing the person does most in this app, as a short verb phrase in their own words ("tap once per glass", "paste the group chat", "lasso cows"). It becomes the biggest control on the first screen.
+kind: 2-6 word noun phrase for the app in the person's own nouns. who: who it is for, 2-8 words.
+recordNames: 1-5 short singular record type names the app stores (toys may have just "score" or none).
+flags, each true only when the request itself needs it:
+- ai: the app must read, write or judge free text or photos with a language model (extract facts from pasted words, answer questions, generate text, chat, analyze a picture, suggest recipes).
+- composer: ai is true AND the person types or pastes their own words or photos as the way records get in.
+- imageGen: the app generates pictures.
+- backend: server work the page cannot do: scheduled reminders or digests, a live feed pulled from outside, secret dealing, email.
+- calendar: dates on a calendar, bookings by slot, recurring events, paystub periods.
+- audio: sound or music playback or synthesis.
+- threeD: 3D graphics, a simulator, a world you move through.
+- charts: heatmaps, graphs, statistics views.
+- boardGame: a turn-based card or board game.
+- sensitive: health, money of real people, kids, or the word private.`;
+export function mercuryShapeSchema() {
+    return {
+        type: "object",
+        additionalProperties: false,
+        required: ["archetype", "coreAction", "kind", "who", "recordNames", ...MERCURY_FLAGS],
+        properties: {
+            archetype: { type: "string", enum: [...MERCURY_ARCHETYPES] },
+            coreAction: { type: "string" },
+            kind: { type: "string" },
+            who: { type: "string" },
+            recordNames: { type: "array", items: { type: "string" } },
+            ...Object.fromEntries(MERCURY_FLAGS.map((f) => [f, { type: "boolean" }])),
+        },
+    };
+}
+export function mercuryNonce() {
+    return String(1000 + Math.floor(Math.random() * 9000));
+}
+export function mercuryShapeMessages(o) {
+    return [
+        { role: "system", content: [{ type: "text", text: MERCURY_SHAPE_SYSTEM }] },
+        {
+            role: "user",
+            content: [
+                { type: "text", text: `Person's words: "${o.personWords}"\n(variant #${o.nonce}: a seed for wording, never written)` },
+            ],
+        },
+    ];
+}
+const shapeParsed = lazyType(() => type({
+    archetype: type.enumerated(...MERCURY_ARCHETYPES),
+    coreAction: "string",
+    kind: "string",
+    who: "string",
+    recordNames: "string[]",
+    ai: "boolean",
+    composer: "boolean",
+    imageGen: "boolean",
+    backend: "boolean",
+    calendar: "boolean",
+    audio: "boolean",
+    threeD: "boolean",
+    charts: "boolean",
+    boardGame: "boolean",
+    sensitive: "boolean",
+}));
+export function parseMercuryShape(raw) {
+    const p = shapeParsed(raw);
+    if (p instanceof type.errors)
+        return Result.Err(`mercury shape: ${p.summary}`);
+    if (p.coreAction.trim().length === 0)
+        return Result.Err("mercury shape: empty coreAction");
+    return Result.Ok({
+        archetype: p.archetype,
+        coreAction: p.coreAction.trim(),
+        kind: p.kind.trim(),
+        who: p.who.trim(),
+        recordNames: p.recordNames,
+        flags: {
+            ai: p.ai,
+            composer: p.composer,
+            imageGen: p.imageGen,
+            backend: p.backend,
+            calendar: p.calendar,
+            audio: p.audio,
+            threeD: p.threeD,
+            charts: p.charts,
+            boardGame: p.boardGame,
+            sensitive: p.sensitive,
+        },
+    });
+}
+const COMPOSER_WORDS = /paste|photo|picture|own words|however they|repl(y|ies)|in their words|type in|jot/;
+const BACKEND_WORDS = /remind|notif|email|digest|schedul|every (day|week|morning|monday)|nag|feed|sync|server|secret|deal|webhook|cron|poll/;
+const PRIVATE_WORDS = /\b(private|just for me|only me|for myself)\b/;
+const MULTIPLAYER_WORDS = /\b(friends? can join|multiplayer|same world)\b/;
+export function fixMercuryShape(shape, personWords) {
+    const m = personWords.toLowerCase();
+    const composer = shape.flags.ai && shape.flags.composer && COMPOSER_WORDS.test(m);
+    const backend = shape.flags.backend && BACKEND_WORDS.test(m);
+    const archetype = PRIVATE_WORDS.test(m) && (shape.archetype === "open" || shape.archetype === "publish")
+        ? "personal"
+        : shape.archetype === "toy" && MULTIPLAYER_WORDS.test(m)
+            ? "open"
+            : shape.archetype;
+    return {
+        ...shape,
+        archetype,
+        recordNames: shape.recordNames
+            .map((r) => r.trim())
+            .filter((r) => r.length > 0)
+            .slice(0, 5),
+        flags: { ...shape.flags, composer, backend },
+    };
+}
+export const MERCURY_EXEMPLAR_FIELD = `## How to read this field
+
+Every brief has the same parts, in this order. Below, each part is shown as a SPREAD of alternatives, side by side. Each row is tagged with the ownership archetype it fits:
+
+- [personal]  one person's own tool: private, records keyed to their own object so a friend could be let in later.
+- [group]     a named set of people (friends, family, team, club, housemates): the owner invites them by handle, members read and write; the invite screen is part of this first build.
+- [publish]   the owner writes, everyone reads: a blog, menu, gallery, zine, schedule.
+- [intake]    strangers submit without signing in (orders, bookings, requests, RSVPs); the owner sees and manages what came in.
+- [open]      anyone with the link joins and writes their own bit: a shared wall, a canvas, a leaderboard game. Each person edits what they made.
+- [toy]       a game or visual that keeps little or nothing: scores or a save slot at most.
+
+Pick the rows that match the archetype you were given. Take every noun from the person's own words.
+
+## 1. Opening — one sentence: what it is and who it is for
+
+- [personal] A glaze test notebook for a home potter.
+- [personal] A sourdough starter log for one baker's kitchen.
+- [group]    A tool library for one neighbourhood block, shared by the households on it.
+- [group]    A setlist planner for a four-piece cover band.
+- [publish]  A taco truck menu board the owner updates from their phone and customers read.
+- [publish]  A micro-poetry zine where one editor posts and everyone reads.
+- [intake]   An appointment book for a dog grooming salon: clients book without signing up, the groomer sees every slot.
+- [intake]   A repair drop-off form for a bike shop, with the owner's queue on the other side.
+- [open]     A lost-and-found board for a music festival that anyone with the link can post to.
+- [open]     A wedding photo wall where every guest drops pictures from their phone.
+- [toy]      A hex-grid pong game with a slow-motion ball and a local best score.
+- [toy]      A kaleidoscope you steer with the mouse, with nothing saved.
+
+## 2. Ownership and access — who owns what, who gets in, who sees what
+
+- [personal] Each signed-in person has their own notebook object (keyed on their handle, named for the app, renameable in settings); glazes and tiles carry the notebook id so a studio mate could be let in later. The creator reads and writes it alone.
+- [personal] The person's own starter log is ready on arrival. Feedings belong to that log; rules key on its creator, so the entries stay theirs, shaped so a housemate could be admitted later.
+- [group]    Each signed-in person starts with their own block library object. Households are let in with the platform's HandleInput invite screen, which writes a membership into the library; members read every tool and write their own loans. The library list shows shared ones with ViewerTag.
+- [group]    The owner's band object holds memberships for the other three players, written by the HandleInput invite screen. Any member adds songs and reorders the set; the creator manages members and deletes songs.
+- [publish]  The owner's menu object is keyed on their handle. Menu items are written by the owner and readable by everyone, signed in or not. Shaped so a co-owner could be let in later.
+- [publish]  One editor owns the zine; poem records are creator-writable and world-readable. Readers see the issues.
+- [intake]   Two sides. Clients book anonymously: anyone, signed in or not, can create a booking record on the salon object and reads back the confirmation they just made. The groomer, signed in as the salon's owner, reads and updates every booking.
+- [intake]   Drop-off requests are created by visitors without accounts; each request is readable by the shop owner (and staff let in later by membership). The public form page shows the visitor their own request.
+- [open]     The owner creates the board and names it for the app. Any visitor with the link reads the whole board and writes their own posts; each poster edits or removes what they wrote, keyed on the record's creator. The board creator can remove anything.
+- [open]     Anyone with the link uploads photos to the wall; everyone reads; a photo is deletable by whoever posted it or the couple who own the wall.
+- [toy]      Each signed-in player keeps a best score record keyed on their handle; a shared Top Scores list shows everyone's best with ViewerTag.
+- [toy]      The toy keeps its state in memory: it opens instantly, with no sign-in and no records.
+
+## 3. Seed cast — seed.json demo with a named cast, counts and dates near today
+
+- [personal] seed.json demo: the owner's notebook plus 5 glazes (Tenmoku, Shino, Celadon, Chun blue, Ash) and 9 tiles fired between 2026-09-20 and 2026-10-05, two rated 5.
+- [personal] seed.json demo: one starter "Gus" born 2026-03-02 with 10 feedings over the last two weeks, rise heights between 3 and 7 cm.
+- [group]    seed.json demo: the owner's library "Maple Street Tools" with the owner's own membership plus @priya and @tomas, 8 tools (a ladder, a tile saw, a pressure washer...), two loans out due this week and one returned.
+- [group]    seed.json demo: the band "Low Tide" with the owner's membership and three members (@dee, @marco, @sun), 14 songs with keys and bpm, one setlist for a gig dated 2026-10-18.
+- [publish]  seed.json demo: the owner's menu with 6 items across tacos, sides and drinks, one marked sold out, and a note of the day dated 2026-10-07.
+- [intake]   seed.json demo: the owner's salon with 7 bookings spread over 2026-10-07 to 2026-10-11 in mixed statuses, dog names like Biscuit and Juno.
+- [open]     seed.json demo: the festival board with 9 posts from five handles, five lost and four found, two already resolved, dated across the last three days.
+- [toy]      seed.json demo: 6 score records from a small cast including the owner so the Top Scores list opens filled.
+
+## 4. Look note — one short line: background, accent, card shape, mood
+
+- [personal] Earthy studio: oatmeal background, iron-red accents, chunky rounded tile cards.
+- [personal] Flour-dusted kitchen: warm white, rye brown, a tall rising bar as the hero number.
+- [group]    Workshop pegboard: plywood tones, safety-orange accents, square tool cards with big status chips.
+- [group]    Backstage: near-black, amber stage light accents, setlist rows like gaffer-tape strips.
+- [publish]  Street-food bright: chalkboard dark with chalk-white type and chili-red price tags.
+- [intake]   Clean salon: pale mint, charcoal type, generous slot buttons easy to tap one-handed.
+- [open]     Festival poster: cream paper, bold two-colour print, pinned-note cards with torn edges.
+- [toy]      Neon arcade: deep navy, electric cyan ball, glowing hex outlines.
+
+## 5. Titles, addresses and icon
+
+- pairs: Glaze Ledger / glaze-ledger, Tile Book / tile-book, Kiln Notes / kiln-notes — icon: a glazed test tile beside a small kiln
+- pairs: Block Tools / block-tools, Maple Street Shelf / maple-street-shelf, Borrow Board / borrow-board — icon: a hand drill inside a house outline
+- pairs: Truck Board / truck-board, Taco Today / taco-today, Menu Chalk / menu-chalk — icon: a chalkboard with a taco drawn on it
+- pairs: Groom Book / groom-book, Salon Slots / salon-slots, Paws Diary / paws-diary — icon: a dog brush beside a clock face
+- pairs: Festival Finds / festival-finds, Lost Tent / lost-tent, Found It / found-it — icon: a tent peg tied with a ribbon
+- pairs: Hex Pong / hex-pong, Slow Rally / slow-rally, Honey Paddle / honey-paddle — icon: a hexagonal paddle and a glowing ball`;
+export const MERCURY_BRIEF_RULES = `You write the settled parts of a build brief for a small web app (React, a local-first database, access rules). The brief is read by a builder, who works out the records, screens and mechanics from the person's own words. Write plain, concrete prose in the app's own nouns, as unformatted text in each JSON string.
+
+The decisions already made are given in the user message; follow them (archetype, record names, capabilities). The access part matches the archetype: who owns the object, who else is let in, what visitors see. The seed part starts with "seed.json demo:" and gives a named cast, counts and dates near today, using the given record names. Take from the field the SHAPE of a part (its length and how a cast, a look or a title is named); every noun comes from the person's words. Each pair is a Title Case title of two or three words and a kebab-case address made from it.`;
+const FIELD_BOUNDS = {
+    opening: [15, 200],
+    access: [60, 600],
+    seed: [60, 650],
+    look: [15, 150],
+    icon: [8, 100],
+};
+export function mercuryBriefSchema(fields) {
+    return {
+        type: "object",
+        additionalProperties: false,
+        required: [...fields],
+        properties: Object.fromEntries(fields.map((f) => [
+            f,
+            f === "pairs"
+                ? {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["title", "slug"],
+                        properties: { title: { type: "string" }, slug: { type: "string" } },
+                    },
+                }
+                : { type: "string" },
+        ])),
+    };
+}
+function capabilityDecisions(shape) {
+    return [
+        `AI text features: ${shape.flags.ai ? "yes (callAI)" : "none; the app works from its own records"}`,
+        `generated pictures: ${shape.flags.imageGen ? "yes (ImgGen)" : "none"}`,
+        ...(shape.flags.composer
+            ? [
+                "the records come in through a sentence composer (Add and Ask); name it as the front door and leave its mechanics to the builder",
+            ]
+            : []),
+    ];
+}
+export function mercuryBriefMessages(o) {
+    const s = o.shape;
+    const decisions = [
+        `archetype: ${s.archetype}`,
+        `core action: ${s.coreAction}`,
+        `kind: ${s.kind}`,
+        `for: ${s.who}`,
+        `records: ${s.recordNames.length === 0 ? "(you choose, at most three)" : s.recordNames.join(", ")}`,
+        ...capabilityDecisions(s),
+        ...(s.archetype === "toy"
+            ? [
+                `saved: ${s.recordNames.length > 0 ? "best scores or a save slot per signed-in player, and nothing else" : "the toy keeps its state in memory; the access part says it opens with no sign-in and no records"}`,
+            ]
+            : []),
+    ];
+    const user = [
+        `Person's words: "${o.personWords}"`,
+        `Today is ${o.today}.`,
+        "",
+        "Decisions:",
+        ...decisions.map((d) => `- ${d}`),
+        "",
+        `Follow the rows tagged [${s.archetype}] in each part of the field. Return JSON with these keys: ${o.fields.join(", ")}` +
+            (o.fields.includes("pairs") ? " (pairs: an array of three {title, slug} candidates)" : "") +
+            ".",
+        ...(o.fields.includes("pairs") && o.words.length > 0 ? [addressWordsSentence(o.words).trim()] : []),
+        `(variant #${o.nonce}: a seed for wording, never written)`,
+    ].join("\n");
+    return [
+        { role: "system", content: [{ type: "text", text: `${MERCURY_BRIEF_RULES}\n\n${MERCURY_EXEMPLAR_FIELD}` }] },
+        { role: "user", content: [{ type: "text", text: user }] },
+    ];
+}
+const FIELD_LABEL = /^\s*(?:\*\*)?(opening|access|seed|look|icon|preamble)(?:\*\*)?\s*:\s*/i;
+const FENCED = /^```[a-zA-Z]*\n([\s\S]*?)\n?```$/;
+export function cleanMercuryText(text) {
+    const t = text.trim();
+    const fenced = FENCED.exec(t);
+    return (fenced === null ? t : fenced[1].trim()).replace(FIELD_LABEL, "").trim();
+}
+function stem(name) {
+    return name
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .toLowerCase()
+        .split(/[\s_-]+/)
+        .filter((w) => w.length > 2)
+        .map((w) => w.replace(/s$/, ""));
+}
+function mentions(name, text) {
+    const lower = text.toLowerCase();
+    return stem(name).every((w) => lower.includes(w));
+}
+const TAG_LEAK = /\[(personal|group|publish|intake|open|toy)\]|archetype/i;
+const NONCE_LEAK = /variant|#\d{4}/i;
+const MARKUP = /```|^\s*#/m;
+const AI_LEAK = /\bcallai\b|\bAI\b|language model/;
+const pairShape = lazyType(() => type({ title: "string", slug: "string" }).array());
+function kebab(s) {
+    return s
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+export function gateMercuryPairs(raw) {
+    const parsed = pairShape(raw);
+    if (parsed instanceof type.errors)
+        return Result.Err("pairs-shape");
+    const pairs = parsed
+        .map((p) => {
+        const title = p.title.trim().replace(/^["*]+|["*]+$/g, "");
+        const slug = kebab(p.slug.trim().length > 0 ? p.slug : title);
+        return { title, slug };
+    })
+        .filter((p) => p.title.length > 0 && p.slug.length > 0);
+    const words = pairs.map((p) => p.title.split(/\s+/).length);
+    if (pairs.length !== 3)
+        return Result.Err("pairs-count");
+    if (new Set(pairs.map((p) => p.title.toLowerCase())).size !== 3)
+        return Result.Err("pairs-duplicate");
+    if (new Set(pairs.map((p) => p.slug)).size !== 3)
+        return Result.Err("pairs-duplicate");
+    if (words.some((n) => n < 1 || n > 4))
+        return Result.Err("pairs-length");
+    return Result.Ok(pairs);
+}
+export function gateMercuryField(o) {
+    const t = cleanMercuryText(o.value);
+    const a = o.shape.archetype;
+    if (o.field === "seed" && a === "toy" && o.shape.recordNames.length === 0)
+        return [];
+    const [lo, hi] = FIELD_BOUNDS[o.field];
+    const fails = [];
+    if (t.length === 0)
+        fails.push("empty");
+    else if (t.length < lo)
+        fails.push("short");
+    else if (t.length > hi)
+        fails.push("long");
+    if (NONCE_LEAK.test(t))
+        fails.push("nonce");
+    if (MARKUP.test(t))
+        fails.push("markup");
+    if (TAG_LEAK.test(t))
+        fails.push("tag-leak");
+    if (o.field !== "look" && o.field !== "icon" && o.shape.flags.ai === false && AI_LEAK.test(t))
+        fails.push("ai-leak");
+    if (o.field === "seed" && t.toLowerCase().includes("seed") === false)
+        fails.push("seed-word");
+    if (o.field === "seed" && o.shape.recordNames.length > 0 && o.shape.recordNames.some((r) => mentions(r, t)) === false)
+        fails.push("seed-no-record");
+    if (o.field === "access") {
+        if (a === "group" && /invite|member/i.test(t) === false)
+            fails.push("access-no-invite");
+        if (a === "personal" && /invite screen (is|ships)|members (read|can)/i.test(t))
+            fails.push("access-personal-invites");
+        if (a === "toy" && o.shape.recordNames.length > 0 && /nothing is saved|no records/i.test(t))
+            fails.push("toy-contradiction");
+        if ((a === "publish" || a === "intake") && /read|see|visitor|customer|client|anyone|everyone|public/i.test(t) === false)
+            fails.push("access-no-readers");
+    }
+    return fails;
+}
+export const MERCURY_ACCESS_TAIL = {
+    personal: "Rules key on the object's creator; records carry the object id so someone could be let in later. The invite screen waits for a later build.",
+    group: "Memberships are written by the platform's HandleInput invite screen, which is part of this first build; shared objects show who made them with ViewerTag.",
+    publish: "The owner writes; everything they publish is readable by anyone with the link, signed in or not. Shaped so a co-owner could be let in later.",
+    intake: "Every visitor writes their own submissions into the shared list, signed in or not, and edits only their own; the signed-in owner reads and manages all of them. Shaped so staff could be let in later.",
+    open: "Everyone with the link writes the shared records — posts, votes, entries — and edits only their own; the owner can remove anything.",
+    toy: "",
+};
+const TAIL_ALREADY_SAID = {
+    personal: /invite screen waits|later build|no invite screen/i,
+    group: /HandleInput/,
+    publish: /readable by anyone|anyone with the link/i,
+};
+export function mercuryAccessLine(shape, access) {
+    const said = TAIL_ALREADY_SAID[shape.archetype];
+    const tail = said !== undefined && said.test(access) ? "" : MERCURY_ACCESS_TAIL[shape.archetype];
+    return `${access} ${tail}`.trim();
+}
+const CAPABILITY_NAMES = [
+    ["ai", "AI text (callAI)"],
+    ["composer", "a sentence composer (Add and Ask) as the front door"],
+    ["imageGen", "generated pictures (ImgGen)"],
+    ["backend", "server work (backend.js)"],
+    ["calendar", "calendar dates"],
+    ["audio", "sound"],
+    ["threeD", "3D graphics"],
+    ["charts", "charts"],
+    ["boardGame", "a turn-based board or card game"],
+    ["sensitive", "private records"],
+];
+const FLAG_SKILLS = [
+    ["ai", "callai"],
+    ["imageGen", "image-gen"],
+    ["backend", "backend"],
+    ["calendar", "calendar"],
+    ["audio", "web-audio"],
+    ["threeD", "three-js"],
+    ["charts", "d3"],
+    ["boardGame", "board-games"],
+];
+export function mercurySkills(shape) {
+    return ["access", "fireproof", ...FLAG_SKILLS.filter(([f]) => shape.flags[f]).map(([, skill]) => skill)];
+}
+export function mercuryNature(shape) {
+    const a = shape.archetype;
+    if (a === "open" || a === "toy" || a === "publish")
+        return "open";
+    return shape.flags.sensitive ? "sensitive" : "collaborative";
+}
+export function mercuryWorkflowLine(shape) {
+    const caps = CAPABILITY_NAMES.filter(([f]) => shape.flags[f]).map(([, name]) => name);
+    return [
+        `Archetype: ${shape.archetype}.`,
+        `Core action: "${shape.coreAction}".`,
+        ...(shape.recordNames.length === 0 ? [] : [`Records: ${shape.recordNames.join(", ")}.`]),
+        ...(caps.length === 0 ? [] : [`Capabilities: ${caps.join(", ")}.`]),
+    ].join(" ");
+}
+export function assembleMercuryCreateVibe(o) {
+    const s = o.shape;
+    const keepsNothing = s.archetype === "toy" && s.recordNames.length === 0;
+    const access = cleanMercuryText(o.fields.access);
+    const seed = keepsNothing ? "" : cleanMercuryText(o.fields.seed);
+    const parts = [
+        cleanMercuryText(o.fields.opening),
+        keepsNothing && access.length === 0 ? "" : mercuryAccessLine(s, access),
+        mercuryWorkflowLine(s),
+        seed.length === 0 ? "" : `${seed} ${KNOWN_VALUES_DIRECT_CONTROLS}`,
+        `The person asked: "${o.personWords}".`,
+    ];
+    const look = cleanMercuryText(o.fields.look);
+    const icon = cleanMercuryText(o.fields.icon);
+    const nature = mercuryNature(s);
+    return {
+        prompt: o.personWords,
+        enrichedPrompt: parts.filter((p) => p.length > 0).join("\n\n"),
+        skills: mercurySkills(s),
+        pairs: o.fields.pairs.map((p) => ({ title: p.title, slug: p.slug })),
+        ...(icon.length === 0 ? {} : { iconDescription: icon }),
+        ...(look.length === 0 ? {} : { textureNote: look }),
+        nature,
+        ...(nature === "sensitive" ? { privacySensitive: true } : {}),
+    };
+}
+export const MERCURY_PREAMBLE_SYSTEM = `You speak to the person who asked for an app, just before it is built. Write two or three plain sentences in their own words: what you are making for them, its core action, and the big control on its first screen that does it. That is the whole promise — the builder works out everything else after you speak. Start with "I'm making" or "I'm building", and write it as plain sentences to the person.`;
+export function mercuryPreambleMessages(o) {
+    const user = [
+        `Person's words: "${o.personWords}"`,
+        `Core action: ${o.shape.coreAction}`,
+        "",
+        "What is being built:",
+        o.enrichedPrompt,
+        "",
+        `Write the preamble. (variant #${o.nonce}: a seed for wording, never written)`,
+    ].join("\n");
+    return [
+        { role: "system", content: [{ type: "text", text: MERCURY_PREAMBLE_SYSTEM }] },
+        { role: "user", content: [{ type: "text", text: user }] },
+    ];
+}
+const preambleParsed = lazyType(() => type({ preamble: "string" }));
+export function mercuryPreambleSchema() {
+    return {
+        type: "object",
+        additionalProperties: false,
+        required: ["preamble"],
+        properties: { preamble: { type: "string" } },
+    };
+}
+export function gateMercuryPreamble(o) {
+    const t = cleanMercuryText(o.text);
+    const fails = [];
+    if (t.length === 0)
+        fails.push("empty");
+    else if (t.length < 60)
+        fails.push("short");
+    else if (t.length > 480)
+        fails.push("long");
+    if (/variant|#\d{4}|```|^\s*#|\bbrief\b|seed\.json/im.test(t))
+        fails.push("markup");
+    if ((t.match(/[.!?](\s|$)/g) ?? []).length > 3)
+        fails.push("too-many-sentences");
+    const briefWords = new Set(o.enrichedPrompt.toLowerCase().match(/[a-z]{5,}/g) ?? []);
+    const shared = new Set((t.toLowerCase().match(/[a-z]{5,}/g) ?? []).filter((w) => briefWords.has(w)));
+    if (shared.size < 3)
+        fails.push("unanchored");
+    return fails;
+}
+const completionBody = lazyType(() => type({
+    "model?": "string",
+    choices: type({ message: { content: "string | null" } }).array(),
+    "usage?": { prompt_tokens: "number", completion_tokens: "number", "total_tokens?": "number", "cost?": "number" },
+}));
+async function withDeadline(call, timeoutMs) {
+    const abort = new AbortController();
+    const timer = setTimeout(function expire() {
+        abort.abort();
+    }, timeoutMs);
+    return Promise.resolve()
+        .then(function invoke() {
+        return call(abort.signal);
+    })
+        .then(function settle(reply) {
+        return abort.signal.aborted ? { timedOut: true } : { timedOut: false, reply };
+    }, function failed(e) {
+        if (abort.signal.aborted)
+            return { timedOut: true };
+        return { timedOut: false, reply: Result.Err(e instanceof Error ? e : new Error(String(e))) };
+    })
+        .finally(function disarm() {
+        clearTimeout(timer);
+    });
+}
+async function requestMercury(vctx, o, signal) {
+    const req = {
+        model: MERCURY_FIRST_BUILD_MODEL,
+        stream: false,
+        max_tokens: o.maxTokens,
+        reasoning: { ...MERCURY_FIRST_BUILD_REASONING },
+        response_format: { type: "json_schema", json_schema: { name: o.name, strict: true, schema: o.schema } },
+        messages: o.messages,
+    };
+    const rRes = await exception2Result(() => vctx.llmRequest({ ...req, headers: vctx.params.llm.headers }, { signal }));
+    if (rRes.isErr())
+        return Result.Err(rRes.Err());
+    const res = rRes.Ok();
+    if (res.ok === false) {
+        const { snippet } = await readFailureBody(res);
+        const message = `mercury ${o.name}: status ${res.status}${snippet.length === 0 ? "" : ` ${snippet.slice(0, 200)}`}`;
+        return MERCURY_TRANSIENT_STATUSES.has(res.status)
+            ? Result.Err(new MercuryTransientError(message, parseRetryAfterMs(res.headers)))
+            : Result.Err(message);
+    }
+    const rBody = await exception2Result(() => res.json());
+    if (rBody.isErr())
+        return Result.Err(`mercury ${o.name}: body: ${rBody.Err().message}`);
+    const body = completionBody(rBody.Ok());
+    if (body instanceof type.errors)
+        return Result.Err(`mercury ${o.name}: reply: ${body.summary}`);
+    const content = body.choices[0]?.message.content;
+    if (content === undefined || content === null || content.trim().length === 0)
+        return Result.Err(`mercury ${o.name}: empty reply`);
+    const rJson = exception2Result(() => JSON.parse(cleanMercuryText(content)));
+    if (rJson.isErr())
+        return Result.Err(`mercury ${o.name}: JSON: ${rJson.Err().message}`);
+    const u = body.usage;
+    return Result.Ok({
+        json: rJson.Ok(),
+        ...(body.model === undefined ? {} : { servedModel: body.model }),
+        ...(u === undefined
+            ? {}
+            : {
+                usage: {
+                    prompt_tokens: u.prompt_tokens,
+                    completion_tokens: u.completion_tokens,
+                    total_tokens: u.total_tokens ?? u.prompt_tokens + u.completion_tokens,
+                    ...(u.cost === undefined ? {} : { cost: u.cost }),
+                },
+            }),
+    });
+}
+async function mercuryCall(vctx, o) {
+    const startedAt = Date.now();
+    const usage = [];
+    let servedModel;
+    let lastError = "no attempt";
+    let transientRetries = 0;
+    for (let attempt = 0; attempt < MERCURY_CALL_ATTEMPTS; attempt++) {
+        const ask = o.request();
+        const r = await withDeadline((signal) => requestMercury(vctx, { name: o.call, schema: ask.schema, messages: ask.messages, maxTokens: o.maxTokens }, signal), o.deadlineMs);
+        if (r.timedOut) {
+            lastError = `mercury ${o.call}: timed out after ${o.deadlineMs}ms`;
+            transientRetries = 0;
+            continue;
+        }
+        if (r.reply.isErr()) {
+            const err = r.reply.Err();
+            lastError = err.message;
+            if (err instanceof MercuryTransientError && transientRetries < MERCURY_TRANSIENT_RETRIES) {
+                transientRetries += 1;
+                await waitMs(Math.min(capRetryDelayMs(err.retryAfterMs, MERCURY_TRANSIENT_BACKOFF_MS * transientRetries), MERCURY_TRANSIENT_MAX_WAIT_MS));
+                attempt -= 1;
+                continue;
+            }
+            transientRetries = 0;
+            continue;
+        }
+        const reply = r.reply.Ok();
+        if (reply.usage !== undefined)
+            usage.push(reply.usage);
+        if (reply.servedModel !== undefined)
+            servedModel = reply.servedModel;
+        const accepted = o.accept(reply.json);
+        if (accepted.isOk()) {
+            await recordMercuryRow(vctx, {
+                ...o.row,
+                record: {
+                    call: o.call,
+                    ok: true,
+                    attempts: attempt + 1,
+                    elapsedMs: Date.now() - startedAt,
+                    ...(servedModel === undefined ? {} : { servedModel }),
+                    usage,
+                },
+            });
+            return accepted;
+        }
+        lastError = `mercury ${o.call}: ${accepted.Err().message}`;
+        transientRetries = 0;
+    }
+    vctx.logger.Warn().Any("event", { chatId: o.row.chatId, call: o.call, error: lastError }).Msg("mercury-first-build-call-failed");
+    await recordMercuryRow(vctx, {
+        ...o.row,
+        record: {
+            call: o.call,
+            ok: false,
+            attempts: MERCURY_CALL_ATTEMPTS,
+            elapsedMs: Date.now() - startedAt,
+            ...(servedModel === undefined ? {} : { servedModel }),
+            usage,
+            error: lastError,
+        },
+    });
+    return Result.Err(lastError);
+}
+async function recordMercuryRow(vctx, o) {
+    const zero = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+    const model = o.record.servedModel ?? MERCURY_FIRST_BUILD_MODEL;
+    const rInsert = await exception2Result(() => vctx.sql.db.insert(vctx.sql.tables.promptContexts).values({
+        userId: o.userId,
+        chatId: o.chatId,
+        promptId: vctx.sthis.nextId(12).str,
+        nethash: vctx.netHash(),
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0,
+        ref: {
+            type: "prompt.usage.sql",
+            usage: { given: o.record.usage.map((u) => ({ ...u, model })), calculated: zero },
+            model: MERCURY_FIRST_BUILD_MODEL,
+            step: "first-mercury",
+            mercury: {
+                call: o.record.call,
+                ok: o.record.ok,
+                attempts: o.record.attempts,
+                elapsedMs: o.record.elapsedMs,
+                ...(o.record.servedModel === undefined ? {} : { servedModel: o.record.servedModel }),
+                ...(o.record.error === undefined ? {} : { error: o.record.error.slice(0, 300) }),
+            },
+        },
+        created: new Date().toISOString(),
+    }));
+    if (rInsert.isErr())
+        vctx.logger.Warn().Err(rInsert).Str("chatId", o.chatId).Msg("mercury-first-build-row-failed");
+}
+function owedBriefFields(gated) {
+    return MERCURY_BRIEF_FIELDS.filter((f) => (f === "pairs" ? gated.pairs === undefined : gated.texts.has(f) === false));
+}
+const replyObject = lazyType(() => type("Record<string, unknown>"));
+function acceptBriefFields(json, o) {
+    const parsed = replyObject(json);
+    const body = parsed instanceof type.errors ? {} : parsed;
+    const failed = [];
+    for (const f of o.owed) {
+        const v = body[f];
+        if (f === "pairs") {
+            const pairs = gateMercuryPairs(v);
+            if (pairs.isOk())
+                o.into.pairs = pairs.Ok();
+            else
+                failed.push(`pairs:${pairs.Err().message}`);
+            continue;
+        }
+        const fails = typeof v === "string" ? gateMercuryField({ field: f, value: v, shape: o.shape }) : ["not-a-string"];
+        if (fails.length === 0 && typeof v === "string")
+            o.into.texts.set(f, v);
+        else
+            failed.push(`${f}:${fails.join("+")}`);
+    }
+    return failed;
+}
+export async function runMercuryFirstBuild(vctx, args) {
+    return exception2Result(() => pipeline(vctx, args));
+}
+async function pipeline(vctx, args) {
+    if (args.personWords.trim().length === 0)
+        return Result.Err("mercury: no words to brief from");
+    if (vctx.billing.enforceEnabled) {
+        const rCheck = await vctx.billing.checkCredits({ userId: args.userId });
+        if (rCheck.isOk() && rCheck.Ok().allowed === false)
+            return Result.Err("mercury: no credits remaining");
+    }
+    const startedAt = Date.now();
+    const row = { chatId: args.chatId, userId: args.userId };
+    const deadlineMs = args.deadlineMs ?? MERCURY_CALL_DEADLINE_MS;
+    const nonce = args.nonce ?? mercuryNonce;
+    const today = args.today ?? new Date().toISOString().slice(0, 10);
+    const rShape = await mercuryCall(vctx, {
+        call: "shape",
+        row,
+        deadlineMs,
+        maxTokens: 400,
+        request: () => ({
+            schema: mercuryShapeSchema(),
+            messages: mercuryShapeMessages({ personWords: args.personWords, nonce: nonce() }),
+        }),
+        accept: (json) => {
+            const parsed = parseMercuryShape(json);
+            return parsed.isErr() ? parsed : Result.Ok(fixMercuryShape(parsed.Ok(), args.personWords));
+        },
+    });
+    if (rShape.isErr())
+        return Result.Err(rShape);
+    const shape = rShape.Ok();
+    const gated = { texts: new Map() };
+    const rBrief = await mercuryCall(vctx, {
+        call: "brief",
+        row,
+        deadlineMs,
+        maxTokens: 1600,
+        request: () => {
+            const owed = owedBriefFields(gated);
+            return {
+                schema: mercuryBriefSchema(owed),
+                messages: mercuryBriefMessages({
+                    personWords: args.personWords,
+                    shape,
+                    fields: owed,
+                    words: args.words,
+                    today,
+                    nonce: nonce(),
+                }),
+            };
+        },
+        accept: (json) => {
+            const failed = acceptBriefFields(json, { owed: owedBriefFields(gated), shape, into: gated });
+            return failed.length === 0 ? Result.Ok(true) : Result.Err(`gate ${failed.join(", ")}`);
+        },
+    });
+    if (rBrief.isErr())
+        return Result.Err(rBrief);
+    const input = assembleMercuryCreateVibe({
+        personWords: args.personWords,
+        shape,
+        fields: {
+            opening: gated.texts.get("opening") ?? "",
+            access: gated.texts.get("access") ?? "",
+            seed: gated.texts.get("seed") ?? "",
+            look: gated.texts.get("look") ?? "",
+            icon: gated.texts.get("icon") ?? "",
+            pairs: gated.pairs ?? [],
+        },
+    });
+    const enrichedPrompt = input.enrichedPrompt ?? "";
+    const rPreamble = await mercuryCall(vctx, {
+        call: "preamble",
+        row,
+        deadlineMs,
+        maxTokens: 300,
+        request: () => ({
+            schema: mercuryPreambleSchema(),
+            messages: mercuryPreambleMessages({ personWords: args.personWords, shape, enrichedPrompt, nonce: nonce() }),
+        }),
+        accept: (json) => {
+            const p = preambleParsed(json);
+            if (p instanceof type.errors)
+                return Result.Err(p.summary);
+            const fails = gateMercuryPreamble({ text: p.preamble, enrichedPrompt });
+            return fails.length === 0 ? Result.Ok(cleanMercuryText(p.preamble)) : Result.Err(`gate ${fails.join("+")}`);
+        },
+    });
+    if (rPreamble.isErr())
+        return Result.Err(rPreamble);
+    return Result.Ok({ input, preamble: rPreamble.Ok(), shape, elapsedMs: Date.now() - startedAt });
+}
+//# sourceMappingURL=mercury-first-build.js.map