@originkit/ai-engine 0.1.0

package/dist/benchmark/prompt.js

@@ -0,0 +1,883 @@
+import { HOUSE_RULES, recipesFor } from "./domain.js";
+/*
+ * Two passes, and the model only pays for the second if it needs it.
+ *
+ * Pass one shows the prop schema and nothing else: a couple of thousand tokens.
+ * Most requests are answerable that way, and those models never see the file.
+ * Only a model that declines gets pass two, which carries the source.
+ *
+ * The alternative — offering both up front — charges every model the file's
+ * full input cost on every run whether or not anyone uses it, and forces an
+ * output ceiling big enough to rewrite it, which OpenRouter reserves against
+ * your balance before the request even runs.
+ *
+ * Stable prefix first, variable last: the cacheable layout from the docs.
+ */
+export function buildSystem(entry, values) {
+    return [
+        "You edit React component props. You never write code.",
+        "",
+        "Return ONLY a JSON object mapping prop names to new values. No prose, no",
+        "markdown fence. Include only the props you are changing. Every key must",
+        "exist in the schema and every value must satisfy its type, range or enum.",
+        "",
+        "If the request cannot be satisfied by changing props alone, decline — and",
+        "say what would be needed, so the next step is obvious:",
+        '{"error": "requires code change",',
+        ' "needs": ["propName - one line on what it would control"]}',
+        "",
+        "Name only props that do not exist yet and that would make the request",
+        "answerable. Two or three at most. A refusal that names nothing leaves the",
+        "reader to guess what the component is missing.",
+        "",
+        "Do not guess. A prop that is not in the schema below does not exist, and",
+        "inventing one is worse than declining.",
+        "",
+        "Changing colour, size, speed, text, opacity, or any other quality that",
+        "already has a schema key is a prop patch of those keys.",
+        "",
+        "A gradient, a second colour, a palette, or any other look the schema has",
+        "no knob for cannot be faked by patching an existing key. Decline, name",
+        "the new prop(s), and the next step will add them to the file.",
+        "",
+        `COMPONENT: ${entry.name}`,
+        "SCHEMA:",
+        JSON.stringify(entry.props, null, 2),
+        "",
+        "CURRENT VALUES:",
+        JSON.stringify(values, null, 2),
+    ].join("\n");
+}
+/*
+ * Pass two. The model is given the source and returns a complete file.
+ * SEARCH/REPLACE is still accepted if a model emits it (older answers, habit),
+ * but nothing in the prompt asks for it or forbids a rewrite.
+ */
+export const PROPS_MARKER = "///NEW-PROPS";
+export const SEARCH = "<<<<<<< SEARCH";
+export const DIVIDER = "=======";
+export const REPLACE = ">>>>>>> REPLACE";
+/** Output ceiling for a whole-file rewrite. File size is the floor; the
+ *  multiplier is reasoning headroom. Capped at 32k so a small balance does
+ *  not 402 on the reservation. */
+export function rewriteMaxTokens(source) {
+    const approx = Math.ceil(source.length / 4);
+    return Math.min(32768, Math.max(8192, Math.round(approx * 2.5) + 1024));
+}
+/* Above this, a whole-file rewrite stops being possible rather than merely
+ * expensive.
+ *
+ * Re-emitting the file costs roughly `length / 4` output tokens, and models
+ * stop well before their advertised ceiling on a long verbatim copy. Measured:
+ * a 93KB component asked of a cheap model produced 29,658 tokens and stopped
+ * with finishReason "stop" — not "length", so no token budget could have
+ * rescued it. The answer arrived truncated mid-expression every time, and the
+ * repair round that followed truncated in the same place at the same price.
+ *
+ * A file this size has to be edited in PLACE. `sourceFromAnswer` already reads
+ * SEARCH/REPLACE blocks — this only asks for them. */
+const REWRITE_MAX_CHARS = 40_000;
+export function tooBigToRewrite(source) {
+    return source.length > REWRITE_MAX_CHARS;
+}
+/** Did this answer stop mid-file rather than finish? */
+export function wasCutOff(finishReason, error) {
+    if (finishReason === "length")
+        return true;
+    /* Size is a poor proxy and finishReason is an unreliable one — a 27KB file
+     * truncated with reason "stop". What is never ambiguous is the parser
+     * reaching the end of the text with a construct still open. */
+    return !!error && /end of file|unexpected end|unterminated/i.test(error);
+}
+export function buildEditSystem(name, source, needs, 
+/** Force in-place edits — used after a rewrite came back truncated. */
+forceEdits) {
+    const edits = forceEdits || tooBigToRewrite(source);
+    return [
+        "Rewrite this React component so the result already does what the user",
+        "asked. Fulfil the request. You may change any part of the file.",
+        "",
+        ...(edits
+            ? [
+                ...(forceEdits
+                    ? [
+                        "EDIT THIS FILE IN PLACE. Do not return it in full. Everything",
+                        "you do not touch must stay exactly as it is — a rewrite that",
+                        "re-derives the file loses the edits earlier turns already made",
+                        "and drifts the component away from what it is.",
+                    ]
+                    : [
+                        "This file is TOO LARGE to return in full — an attempt would be",
+                        "cut off mid-expression and the turn wasted.",
+                    ]),
+                "Return ONLY the parts you are changing, as one or more",
+                "search/replace blocks:",
+                "",
+                SEARCH,
+                "  the exact existing lines, copied character for character",
+                DIVIDER,
+                "  what they become",
+                REPLACE,
+                "",
+                "Each SEARCH must appear EXACTLY ONCE in the file — include enough",
+                "surrounding lines to make it unique. Copy whitespace exactly; a",
+                "block that does not match is a failed turn, not a near miss.",
+                "Emit as many blocks as the change needs. No prose, no fence.",
+            ]
+            : [
+                "Return the COMPLETE file and nothing else. No prose, no markdown fence.",
+                "The first character is an import or a keyword.",
+            ]),
+        "",
+        "Imports may only come from: react, three, motion, ogl.",
+        "",
+        `If you added any new prop, finish with a line reading exactly ${PROPS_MARKER}`,
+        "followed by a JSON object MAPPING EACH PROP NAME to its spec. Every prop is",
+        "a top-level key of that object — never nested inside another prop's spec,",
+        "and never a bare spec on its own. Complete example, two new props:",
+        '  {"spinDirection":{"type":"enum","values":["cw","ccw"],"default":"cw","desc":"one line"},',
+        '   "spinSpeed":{"type":"number","min":0,"max":20,"default":4,"desc":"one line"}}',
+        "",
+        "A spec is one of:",
+        '  {"type":"number","min":0,"max":10,"default":1,"desc":"one line"}',
+        '  {"type":"enum","values":["a","b"],"default":"a","desc":"one line"}',
+        '  {"type":"boolean","default":false,"desc":"one line"}',
+        '  {"type":"color","default":"#RRGGBB","desc":"one line"}',
+        '  {"type":"string","default":"text","desc":"one line"}',
+        '  {"type":"json","default":["#FF3B30","#00E5FF","#FFD60A"],"desc":"a LIST, never a settings object"}',
+        "Every default must match what your edited code actually defaults to, and",
+        "must sit inside its own range.",
+        "",
+        "AN EXISTING PROP'S RANGE IS NOT A CEILING ON THE RESULT. If the request",
+        "needs a value the current min/max cannot express — `rounded` capped at 60",
+        "on a 180px card that has to become a circle — re-declare that prop here",
+        "with a range wide enough to do it, and set its default to the value the",
+        "request asked for. Implementing it fully is the job; stopping at the old",
+        "limit produces a file that compiles and a render nobody can tell apart",
+        "from the one before it. You may only WIDEN a range, never narrow it.",
+        "A new prop's default is the behaviour THIS REQUEST ASKED FOR, not the old",
+        "one. Adding `isCircle` with default false to answer \"make it a circle\"",
+        "leaves the component exactly as it was and makes the reader ask twice.",
+        "A `colors` (or palette) default of [\"#FFFFFF\"] or a single hex is the old",
+        "look. Default to at least two different colours so the preview changes.",
+        "EVERY NUMBER YOU HAD TO CHOOSE BECOMES A PROP. Building a feature means",
+        "inventing values, and every one of those is a decision the user will want",
+        "to change. They get a slider for each, so they can tune it themselves",
+        "instead of paying for another turn to nudge a number. That is the point of",
+        "the props: they are the deliverable, not paperwork about it.",
+        "  LOOK — radius, count, size, opacity, tilt, colour, spacing, thickness.",
+        "  MOTION — speed, duration, delay, easing, damping, direction, stagger,",
+        "  amplitude. EVERYTHING IN THIS CATALOG ANIMATES, so if what you added",
+        "  moves, fades, springs or transitions, its timing is a knob too. A pulse",
+        "  nobody can slow down is half a feature, and 'too fast' is the single",
+        "  most common thing anyone says about an animation.",
+        "  Asked for a Saturn-like ring, `ringEnabled` alone is not enough. The ring",
+        "  has an inner radius, an outer radius, a particle count or density, an",
+        "  opacity, a tilt, a colour and — since it rotates — a spin speed. You",
+        "  chose every one of those to draw it, so declare every one. Seven knobs is",
+        "  a feature; one toggle is a light switch.",
+        "  A hover or state change you add has a duration and an easing. Expose",
+        "  both: a transition that cannot be retimed is a transition nobody can fix.",
+        "",
+        "ANYTHING YOU ANIMATE NEEDS AN EASING, NOT JUST A DURATION. A duration on",
+        "its own is a linear ramp — full speed from the first frame and a dead stop",
+        "on the last — which is why an added click or hover effect so often feels",
+        "like it snaps in and snaps out. Declare the curve as an enum:",
+        '  {"type":"enum","values":["linear","ease-in","ease-out","ease-in-out"],',
+        '   "default":"ease-out","desc":"one line"}',
+        "and APPLY it to the 0..1 progress before you use that progress for a",
+        "radius, an alpha or an offset. Ease-out for anything responding to a click",
+        "or a hover; ease-in for something leaving.",
+        "Expose the parameters that change how it LOOKS or how it MOVES. Do not",
+        "declare internals nobody would reach for.",
+        "",
+        "ONE PROP PER KNOB. NEVER A SETTINGS OBJECT. Declaring a single `ring` prop",
+        "of type json holding {innerRadius, outerRadius, colorInner, opacity, …}",
+        "is nine knobs the user cannot touch: it renders as one box of raw JSON",
+        "they have to hand-edit, instead of nine sliders and colour pickers. It is",
+        "the same as declaring nothing.",
+        "",
+        "USE FLAT NAMES. One prop per value, no dots, each read straight into the",
+        "code where its literal used to be:",
+        '  {"ringInnerRadius":{"type":"number","min":1,"max":4,"default":1.3,"desc":"one line"},',
+        '   "ringOuterRadius":{"type":"number","min":1,"max":6,"default":2.3,"desc":"one line"},',
+        '   "ringColorInner":{"type":"color","default":"#D2B48C","desc":"one line"},',
+        '   "ringOpacity":{"type":"number","min":0,"max":100,"default":85,"desc":"one line"},',
+        '   "ringSpinSpeed":{"type":"number","min":0,"max":10,"default":2,"desc":"one line"}}',
+        "",
+        "A dotted name like \"ring.innerRadius\" is nested into an object before the",
+        "component is rendered — and that object REPLACES whatever the component",
+        "would otherwise use for `ring`. So if you declare ring.innerRadius and",
+        "ring.opacity but the code also reads ring.colors, `colors` arrives",
+        "undefined and the component falls back to its old value. The change",
+        "appears and then silently reverts, which is worse than never making it.",
+        "Only use dotted names when you declare EVERY field the code reads off that",
+        "object. Otherwise keep them flat — flat is always safe.",
+        "",
+        "`json` is for a genuine LIST — an array of colours, a set of points. Never",
+        "for a bag of unrelated settings.",
+        "",
+        "AND EVERY PROP YOU DECLARE MUST BE READ BY THE CODE. Declaring a prop and",
+        "leaving the value hard-coded produces a control that does nothing — the",
+        "worst possible outcome, because it looks like the feature was delivered.",
+        "If you write a ring at radius 1.4 and then declare ringInnerRadius with a",
+        "default of 1.4, the 1.4 in the code must become ringInnerRadius. A prop",
+        "whose name does not appear in the file is not a prop.",
+        "",
+        "These two rules point the same way: the literal you invented is the",
+        "default, and the name you gave it is the prop. Declaring fewer props to",
+        "stay safe is the wrong lesson — declare every knob the feature has, and",
+        "wire every one of them.",
+        "STRICT JSON: double quotes on every key and every string, no trailing",
+        "commas, no comments. A JS object literal is not JSON and will be refused.",
+        ...(needs?.length
+            ? [
+                "",
+                "The props pass already named what it thinks is missing. Add these",
+                "unless the source shows a better answer:",
+                ...needs.map((n) => `  - ${n}`),
+            ]
+            : []),
+        "",
+        `COMPONENT: ${name}`,
+        "CURRENT SOURCE:",
+        source,
+        "",
+        "Change the file so the request is already visible when it renders.",
+        "Returning this source unchanged fails the turn.",
+    ].join("\n");
+}
+/* The user turn: the instruction, with any maths it needs attached to it.
+ *
+ * Recipes live HERE, not in the system prompt. They change with what was asked,
+ * and one varying line in the system prompt means the whole cached block misses
+ * — which for a 4,500-token source is the difference between paying 0.006/M and
+ * 0.03/M on every turn. */
+export function buildUser(instruction, source = "") {
+    const recipes = recipesFor(instruction, source);
+    return recipes ? `${recipes}\n\n${instruction}` : instruction;
+}
+/** True when every `needs` entry is just an existing knob to turn.
+ *  "color - make it red" is that. "color - support for a gradient" is not:
+ *  `color` exists, the gradient does not, and treating it as a prop patch
+ *  is what blocked adding the missing look. */
+export function needsAlreadyInSchema(needs, props) {
+    if (!needs?.length)
+        return false;
+    const keys = Object.keys(props);
+    const newLook = /\b(gradient|palett|multi-?colou?rs?|second colou?r|color2|new |add a |missing)\b/i;
+    return needs.every((n) => {
+        if (newLook.test(n))
+            return false;
+        const head = n.trim().split(/[\s:.—–-]/)[0] ?? "";
+        return keys.includes(head);
+    });
+}
+const IDLE_HEX = /^(#fff|#ffffff|#000|#000000)$/i;
+function asHexes(v) {
+    if (!Array.isArray(v))
+        return [];
+    return v.filter((x) => typeof x === "string" && x.startsWith("#"));
+}
+/** When a rewrite adds a colour-list prop defaulted to `["#FFFFFF"]`, the
+ *  preview stays the old burst. Seed the session (and the spec default) with
+ *  the current colour plus two more so the asked look is on screen without
+ *  another turn. */
+export function seedVisibleNewProps(ask, current, fresh) {
+    const wantsMany = /multi|gradient|palett|colou?rs\b/i.test(ask);
+    const now = typeof current.color === "string" && current.color.startsWith("#") && !IDLE_HEX.test(current.color)
+        ? current.color
+        : "#FF3B30";
+    const list = [now, "#00E5FF", "#FFD60A"].filter((hex, i, all) => all.findIndex((h) => h.toLowerCase() === hex.toLowerCase()) === i);
+    while (list.length < 3)
+        list.push(list.length === 1 ? "#00E5FF" : "#FFD60A");
+    const props = {};
+    const values = {};
+    for (const [k, spec] of Object.entries(fresh)) {
+        let next = spec;
+        let val = spec.default;
+        const colourName = /colou?r|palett|gradient/i.test(k);
+        if (wantsMany && (spec.type === "json" || colourName) && spec.type !== "number") {
+            const hexes = asHexes(spec.default);
+            const unique = new Set(hexes.map((h) => h.toLowerCase()));
+            if (hexes.length < 2 || unique.size < 2) {
+                val = list;
+                next = { ...spec, default: list };
+            }
+        }
+        props[k] = next;
+        values[k] = val;
+    }
+    return { props, values };
+}
+/** Follow-up after the rewritten file fails to compile. One retry. */
+export function buildEditRepairUser(error, source, 
+/** Keep the answer in search/replace form — see below. */
+edits) {
+    return [
+        `That file did not work: ${error}`,
+        "",
+        "CURRENT SOURCE (before your answer):",
+        source,
+        "",
+        /* A repair must answer in the SAME shape the attempt was asked for.
+         *
+         * Asking for the complete file here silently converts an in-place turn into
+         * a whole-file rewrite: the caller forced search/replace precisely so the
+         * parts nobody asked about could not change, and the repair then re-derives
+         * all of them anyway. Measured: an edit that emitted one correct block and
+         * one elided body was "repaired" by re-emitting the entire component.
+         *
+         * It is also the more likely repair to work. The fault is usually in one
+         * block — an elision, a mismatched search — and rewriting 7,000 tokens to
+         * fix twenty is a fresh roll of the dice, not a correction. */
+        ...(edits
+            ? [
+                "Return CORRECTED search/replace blocks in the same format, and only",
+                "the blocks that change. Never write `...` or `// unchanged` inside a",
+                "REPLACE body — every line you emit is written into the file exactly",
+                "as you type it, so an elision becomes a syntax error.",
+            ]
+            : [
+                "Return the COMPLETE corrected file. It must differ from CURRENT SOURCE",
+                "and already do what was asked. No prose, no markdown fence.",
+            ]),
+    ].join("\n");
+}
+/*
+ * Near-JSON, made strict.
+ *
+ * Models write JavaScript object literals, not JSON — single-quoted strings,
+ * trailing commas, unquoted keys. Measured failure: a props pass suggested
+ * `['monochrome','gradient','multicolor']` in prose and the edit pass echoed
+ * that array verbatim into the declared block, which then failed to parse at
+ * the first apostrophe and cost the turn its props.
+ *
+ * A repair, not a parser. It only runs AFTER strict parsing has failed, and
+ * whatever it produces still goes through validateSchema — so a mangled result
+ * is refused exactly as before. The alternative is throwing away a correct
+ * answer over a quote character.
+ */
+export function repairJson(text) {
+    return (text
+        // Line and block comments, which models add to explain a field.
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/(^|[^:])\/\/[^\n]*/g, "$1")
+        // 'single quoted' -> "double quoted". Skips anything containing a double
+        // quote or a backslash, where a naive swap would corrupt the payload.
+        .replace(/'([^'"\\\n]*)'/g, '"$1"')
+        // Unquoted keys: { type: "number" } -> { "type": "number" }
+        .replace(/([{,]\s*)([A-Za-z_$][\w$]*)\s*:/g, '$1"$2":')
+        // Trailing commas before a close.
+        .replace(/,(\s*[}\]])/g, "$1")
+        .trim());
+}
+const SPEC_TYPES = new Set(["number", "enum", "boolean", "color", "string", "json"]);
+/* What a model calls a type versus what PropSpec calls it.
+ *
+ * Measured: a declared `colors` prop came back as `"type":"array"`, which is
+ * not a PropSpec type, so it was not recognised as a spec at all and was lost
+ * along with everything nested near it. PropSpec's `json` covers arrays and
+ * objects both; "array" is the obvious word for it and the model reached for
+ * the obvious word. Renaming is not guessing — every one of these is the same
+ * type under a different name. */
+const TYPE_ALIAS = {
+    array: "json",
+    object: "json",
+    int: "number",
+    integer: "number",
+    float: "number",
+    bool: "boolean",
+    hex: "color",
+    text: "string",
+};
+const canonicalType = (t) => typeof t === "string" ? (TYPE_ALIAS[t.toLowerCase()] ?? t.toLowerCase()) : t;
+const looksLikeSpec = (v) => !!v &&
+    typeof v === "object" &&
+    !Array.isArray(v) &&
+    SPEC_TYPES.has(canonicalType(v.type));
+/** Close whatever the model left open. Brackets inside strings are ignored, so
+ *  a `desc` containing a brace cannot throw the count off. */
+function balance(text) {
+    const stack = [];
+    let inStr = false;
+    let esc = false;
+    for (const ch of text) {
+        if (inStr) {
+            if (esc)
+                esc = false;
+            else if (ch === "\\")
+                esc = true;
+            else if (ch === '"')
+                inStr = false;
+            continue;
+        }
+        if (ch === '"')
+            inStr = true;
+        else if (ch === "{" || ch === "[")
+            stack.push(ch === "{" ? "}" : "]");
+        else if (ch === "}" || ch === "]")
+            stack.pop();
+    }
+    return text + stack.reverse().join("");
+}
+const tryParse = (t) => {
+    try {
+        return JSON.parse(t);
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Turn whatever the model emitted after ///NEW-PROPS into a name -> spec object.
+ *
+ * Three real failures, all measured, all repaired here rather than lost:
+ *
+ *   - JS instead of JSON: single quotes, unquoted keys, trailing commas.
+ *   - Unbalanced braces, from a spec left open.
+ *   - A sibling prop nested INSIDE another prop's spec. `colorScheme` came back
+ *     carrying `colors` as one of its own fields; a spec cannot contain a spec,
+ *     so a nested one is unambiguously a sibling that was mis-nested.
+ *
+ * A bare spec with no prop name is refused, not guessed: the name is the one
+ * piece of information that cannot be recovered from the block. Whatever comes
+ * out still goes through validateSchema, which is what actually decides.
+ */
+export function repairPropsBlock(text) {
+    const parsed = tryParse(text) ?? tryParse(repairJson(text)) ?? tryParse(balance(repairJson(text)));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return { ok: false, error: "the block is not a JSON object" };
+    }
+    if (looksLikeSpec(parsed)) {
+        return {
+            ok: false,
+            error: "returned a bare spec with no prop name — the block must map a name to a spec",
+        };
+    }
+    const out = {};
+    for (const [name, spec] of Object.entries(parsed)) {
+        if (!looksLikeSpec(spec)) {
+            out[name] = spec;
+            continue;
+        }
+        const own = {};
+        for (const [field, value] of Object.entries(spec)) {
+            // A spec inside a spec is a sibling in the wrong place.
+            if (looksLikeSpec(value))
+                out[field] = { ...value, type: canonicalType(value.type) };
+            else
+                own[field] = value;
+        }
+        own.type = canonicalType(own.type);
+        out[name] = own;
+    }
+    return { ok: true, json: JSON.stringify(out) };
+}
+/** Pull the edit blocks and the optional new-prop JSON out of an answer. */
+export function parseEdits(body) {
+    const marker = body.indexOf(`\n${PROPS_MARKER}`);
+    const head = marker === -1 ? body : body.slice(0, marker);
+    const props = marker === -1 ? null : body.slice(marker + PROPS_MARKER.length + 1).trim() || null;
+    const edits = [];
+    const lines = head.split("\n");
+    let i = 0;
+    while (i < lines.length) {
+        if (lines[i].trim() !== SEARCH) {
+            i++;
+            continue;
+        }
+        const div = lines.indexOf(DIVIDER, i + 1);
+        const end = lines.indexOf(REPLACE, div + 1);
+        // An unterminated block is dropped rather than guessed at: half an edit is
+        // worse than none, and applyEdits would report a mismatch nobody can act on.
+        if (div === -1 || end === -1)
+            break;
+        edits.push({
+            search: lines.slice(i + 1, div).join("\n"),
+            replace: lines.slice(div + 1, end).join("\n"),
+        });
+        i = end + 1;
+    }
+    return { edits, props };
+}
+/**
+ * Apply edit blocks to a source file.
+ *
+ * Exact match first. Failing that, two fallbacks, both unique-or-fail:
+ *   1. each line trimmed — recovers the wrong-indent copy.
+ *   2. whitespace / trailing `;` / trailing `...` stripped — recovers
+ *      `createLinearGradient(0,0,X,0)` vs `(0, 0, X, 0)` and a SEARCH that
+ *      ends in an ellipsis. Anything looser would start matching code the
+ * model did not mean, and a wrong edit that compiles is the worst outcome
+ * available here — worse than a failed turn, because nobody sees it.
+ *
+ * Never partially applies. An edit that misses fails the whole turn, naming
+ * which block and why.
+ */
+export function applyEdits(source, edits) {
+    if (!edits.length)
+        return { ok: false, error: "no edit blocks in the answer" };
+    let code = source;
+    for (const [n, e] of edits.entries()) {
+        if (!e.search.trim())
+            return { ok: false, error: `edit ${n + 1}: empty SEARCH block` };
+        const hits = code.split(e.search).length - 1;
+        if (hits === 1) {
+            code = code.replace(e.search, () => e.replace);
+            continue;
+        }
+        if (hits > 1) {
+            return {
+                ok: false,
+                error: `edit ${n + 1}: SEARCH matches ${hits} places — it must be unique`,
+            };
+        }
+        const found = matchByTrimmedLines(code, e.search) ?? matchByNormalizedLines(code, e.search);
+        if (found === null) {
+            const first = e.search.split("\n")[0].trim().slice(0, 60);
+            return { ok: false, error: `edit ${n + 1}: SEARCH not found — "${first}…"` };
+        }
+        if (found === -2) {
+            return {
+                ok: false,
+                error: `edit ${n + 1}: SEARCH matches several places once indentation is ignored`,
+            };
+        }
+        const lines = code.split("\n");
+        const count = e.search.split("\n").length;
+        lines.splice(found, count, ...e.replace.split("\n"));
+        code = lines.join("\n");
+    }
+    if (code === source)
+        return { ok: false, error: "the edits changed nothing" };
+    return { ok: true, code, applied: edits.length };
+}
+/** Source from an edit-pass answer. SEARCH/REPLACE still applies when that is
+ *  the shape of the answer; otherwise the body is the new file. An unchanged
+ *  copy of the input is a miss — the preview would not move. */
+export function sourceFromAnswer(previous, body) {
+    const trimmed = body.trim();
+    if (!trimmed)
+        return { ok: false, error: "empty file in the answer" };
+    const protocol = trimmed.startsWith(SEARCH) || trimmed.includes(`\n${SEARCH}`);
+    if (protocol) {
+        const { edits } = parseEdits(body);
+        if (edits.length) {
+            /* Report the miss, do not fall through.
+             *
+             * Falling through treats the SEARCH/REPLACE text ITSELF as the new file:
+             * it is not equal to `previous`, so the unchanged guard passes it, and
+             * the turn dies at compile with a syntax error pointing at `<<<<<<<`.
+             * The real fault is that a block did not match — which is a copying
+             * problem the next turn can fix, and a syntax error is not. Zero parsed
+             * blocks still falls through: that is a whole file that merely mentions
+             * the marker. */
+            return applyEdits(previous, edits);
+        }
+    }
+    const marker = body.indexOf(`\n${PROPS_MARKER}`);
+    const code = (marker === -1 ? trimmed : body.slice(0, marker).trim());
+    if (!code)
+        return { ok: false, error: "empty file in the answer" };
+    const same = code.replace(/\r\n/g, "\n").trim() === previous.replace(/\r\n/g, "\n").trim();
+    if (same)
+        return { ok: false, error: "the file was returned unchanged" };
+    return { ok: true, code, applied: 1 };
+}
+const COLOUR_DRAW = /addColorStop|fillStyle|strokeStyle|#(?:[0-9a-fA-F]{3,8})\b|rgba?\(|hsla?\(/;
+function colourDrawLines(source) {
+    return source.split("\n").filter((l) => COLOUR_DRAW.test(l)).join("\n");
+}
+/** Colour asks that only add `color2` / a midpoint and leave every paint
+ *  line on the old `cStar` compile and "succeed" — the preview does not
+ *  move. Fail those so Iterate can repair instead of showing a new knob
+ *  that does nothing. */
+export function withColourDrawCheck(ask, before, result) {
+    if (!result.ok)
+        return result;
+    if (!/colou?r|hue|tint|shade|gradient|palett|warmer|cooler/i.test(ask)) {
+        return result;
+    }
+    if (colourDrawLines(before) !== colourDrawLines(result.code))
+        return result;
+    return {
+        ok: false,
+        error: "the fill/stroke/gradient lines did not change, so the preview is identical. A new colour variable that is never painted is not a change — edit every addColorStop / fillStyle / rgba that currently uses the old colour.",
+    };
+}
+/** Line index of the single trimmed-equal run, null for none, -2 for several. */
+function matchByTrimmedLines(code, search) {
+    return matchRun(code.split("\n").map((l) => l.trim()), search.split("\n").map((l) => l.trim()));
+}
+/** Same uniqueness rule, after compacting spaces so a paraphrased call still
+ *  hits the one real line. A SEARCH line that compactifies to empty (bare
+ *  `...`) is refused — that is abbreviation, not a match. */
+function matchByNormalizedLines(code, search) {
+    const needle = search.split("\n").map(compactLine);
+    if (needle.some((l) => !l))
+        return null;
+    return matchRun(code.split("\n").map(compactLine), needle);
+}
+function compactLine(s) {
+    return s
+        .trim()
+        .replace(/\s*(?:\.{3}|…)\s*$/, "")
+        .replace(/;+\s*$/, "")
+        .replace(/\s+/g, "");
+}
+function matchRun(hay, needle) {
+    let at = null;
+    for (let i = 0; i + needle.length <= hay.length; i++) {
+        let hit = true;
+        for (let j = 0; j < needle.length; j++) {
+            if (hay[i + j] !== needle[j]) {
+                hit = false;
+                break;
+            }
+        }
+        if (!hit)
+            continue;
+        if (at !== null)
+            return -2;
+        at = i;
+    }
+    return at;
+}
+/*
+ * A heading the model glued to the front of its answer.
+ *
+ * The prompt forbids one, but models write `PROPS: {...}` anyway — an earlier
+ * prompt that numbered the options "1. PROPS" got exactly that back. Mistaking
+ * a labelled patch for a broken file turns a correct answer into a failed one,
+ * which is the kind of measurement error this benchmark exists to avoid.
+ *
+ * Both parts are optional and both are anchored, so real source is untouched:
+ * `const code: string = "x"` does not start with the word "code".
+ */
+const LABEL = /^(?:form\s+[ab]\b\s*[-–—:]?\s*)?(?:(?:props|code|json|patch)\s*:\s*)?/i;
+export function unfence(raw) {
+    const m = 
+    // A properly closed fence, opener and closer on their own lines.
+    raw.match(/^\s*```(?:[a-z]*)?\s*\n([\s\S]*?)\n?\s*```\s*$/) ??
+        // A closed fence with something either side of it.
+        raw.match(/```(?:[a-z]*)?\s*([\s\S]*?)```/) ??
+        /* An opener that was never closed.
+         *
+         * Measured on a real code-mode answer: the model wrote ```tsx, then the
+         * whole 40KB file, then simply stopped — no closing fence, and not a
+         * truncation (finish_reason was not "length"). Without this branch the
+         * opener survives into the source, JS reads the leading backticks as a
+         * template literal, and the parse dies at the first stray backtick in a
+         * comment 8 lines down. The reported error then points at a line the model
+         * never touched, which is a very expensive thing to debug — and the answer
+         * itself was fine. */
+        raw.match(/^\s*```(?:[a-z]*)?[ \t]*\n([\s\S]*)$/);
+    return m ? { body: m[1].trim(), fenced: true } : { body: raw.trim(), fenced: false };
+}
+const HEX = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i;
+function checkValue(k, v, s) {
+    switch (s.type) {
+        case "number":
+            if (typeof v !== "number" || Number.isNaN(v))
+                return `${k}: not a number`;
+            return v < s.min || v > s.max ? `${k}: ${v} outside ${s.min}..${s.max}` : null;
+        case "enum":
+            return s.values.includes(v) ? null : `${k}: ${JSON.stringify(v)} not in enum`;
+        case "boolean":
+            return typeof v === "boolean" ? null : `${k}: not a boolean`;
+        case "color":
+            return typeof v === "string" && HEX.test(v) ? null : `${k}: not a hex colour`;
+        case "string":
+            return typeof v === "string" ? null : `${k}: not a string`;
+        case "json":
+            return Array.isArray(v) === Array.isArray(s.default) && typeof v === typeof s.default
+                ? null
+                : `${k}: wrong shape`;
+    }
+}
+export function validate(raw, schema) {
+    const out = {
+        json: false, schema: false, types: false, refused: false, patch: null, issues: [],
+    };
+    // Models fence their JSON despite being told not to. Strip it — measure the
+    // patch, not the formatting. `json` still reflects the unfenced parse.
+    const { body, fenced } = unfence(raw);
+    // Same stripping as routeOf: the two must agree on what the body is, or a
+    // labelled patch routes as props here and then fails to parse.
+    const text = body.replace(LABEL, "").trim();
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+        out.json = !fenced;
+        if (fenced)
+            out.issues.push("wrapped in a markdown fence");
+    }
+    catch {
+        out.issues.push("not valid JSON");
+        return out;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        out.issues.push("not a JSON object");
+        return out;
+    }
+    const obj = parsed;
+    /* A refusal, optionally carrying the props it would take to say yes.
+     *
+     * `needs` is allowed alongside `error` — anything else next to `error` is a
+     * model mixing a decline with a patch, which is neither, so it falls through
+     * to the normal checks and fails as a hallucinated key. */
+    if ("error" in obj && Object.keys(obj).every((k) => k === "error" || k === "needs")) {
+        out.refused = true;
+        out.schema = true;
+        out.types = true;
+        if (Array.isArray(obj.needs)) {
+            out.needs = obj.needs.filter((n) => typeof n === "string");
+        }
+        return out;
+    }
+    const unknown = Object.keys(obj).filter((k) => !(k in schema));
+    out.schema = unknown.length === 0;
+    if (unknown.length)
+        out.issues.push(`hallucinated keys: ${unknown.join(", ")}`);
+    const bad = Object.entries(obj)
+        .filter(([k]) => k in schema)
+        .map(([k, v]) => checkValue(k, v, schema[k]))
+        .filter(Boolean);
+    out.types = bad.length === 0;
+    out.issues.push(...bad);
+    out.patch = obj;
+    return out;
+}
+/** The diff view: how the component would be written before and after.
+ *  Dot-paths are re-nested so this reads as real JSX, and key order comes
+ *  from the schema so before/after stay line-aligned. */
+export function toJsx(name, flat) {
+    const out = [`<${name}`];
+    let group = null;
+    for (const [k, v] of Object.entries(flat)) {
+        const dot = k.indexOf(".");
+        const prefix = dot === -1 ? null : k.slice(0, dot);
+        if (prefix !== group) {
+            if (group)
+                out.push("  }}");
+            if (prefix)
+                out.push(`  ${prefix}={{`);
+            group = prefix;
+        }
+        if (prefix)
+            out.push(`    ${k.slice(dot + 1)}: ${JSON.stringify(v)},`);
+        else if (typeof v === "string")
+            out.push(`  ${k}="${v}"`);
+        else
+            out.push(`  ${k}={${JSON.stringify(v)}}`);
+    }
+    if (group)
+        out.push("  }}");
+    out.push("/>");
+    return out.join("\n");
+}
+/*
+ * ── Sections ──────────────────────────────────────────────────────────────
+ *
+ * A different question from the rest of this file. Everything above measures a
+ * model against a component that already exists: patch its props, or edit its
+ * source. A section starts from a sentence and a blank file, so there is no
+ * schema to show, nothing to refuse, and the first turn is always code.
+ *
+ * Styling is Tailwind, which is only true because the preview says so: the
+ * stage is an iframe carrying Tailwind's browser build. The app's own CSS is
+ * compiled from ITS source at build time, so a class a model invents at
+ * runtime does not exist in it — a section styled with `className` would
+ * render unstyled on this page and the model would be blamed for it. The
+ * iframe is what makes this instruction honest.
+ */
+const SECTION_RULES = [
+    "Rules, in the order they get things wrong:",
+    "  - Return the WHOLE file and nothing else. No prose, no markdown fence, no",
+    "    explanation before or after. The first character is an import or a",
+    "    keyword.",
+    "  - One default export, a component taking NO required props. It is rendered",
+    "    as <Section /> and nothing is passed to it.",
+    "  - Style with Tailwind utility classes. No CSS files, no styled-components,",
+    "    no <style> tag, no Tailwind config — utilities only, plus inline style",
+    "    for values Tailwind cannot express (a computed transform, a gradient",
+    "    stop you animate).",
+    "  - Imports may only come from: react, motion, three, ogl, lucide-react.",
+    "    Most sections need only react and lucide-react. ANY OTHER IMPORT IS",
+    "    REPLACED BY AN EMPTY PLACEHOLDER at render time — the page still loads,",
+    "    but whatever you imported draws nothing. Inline SVG never has that",
+    "    problem.",
+    "  - NO REMOTE ASSETS. No <img src=\"http…\">, no icon package, no web font, no",
+    "    fetch. The preview cannot load them. Draw icons and imagery as inline",
+    "    SVG, CSS gradients or shapes.",
+    "  - Full-bleed and responsive: the root fills its container's width and",
+    "    reads correctly from 360px to 1440px. Never set a fixed page width.",
+    "  - Real copy, real numbers, real names. Lorem ipsum and `Feature one` are",
+    "    the difference between a section and a wireframe.",
+    "  - Semantic HTML: <section>, one <h1>/<h2> in order, <button> for actions,",
+    "    <a href=\"#\"> for links that go nowhere yet, alt text on meaningful",
+    "    imagery and aria-hidden on decoration.",
+    "  - Dark by default — the stage's background is #0f0f10. Paint your own",
+    "    background on the root rather than inheriting it.",
+    "",
+    "ONE EXCEPTION. If the request explicitly asks for a standalone HTML page —",
+    "an index.html, a single self-contained file — return that document instead,",
+    "complete from <!doctype html>, and none of the TSX rules above apply: it is",
+    "rendered as its own page, so it carries its own <style> and its own script.",
+    "Everything about remote assets still holds — nothing loads from a network.",
+].join("\n");
+/** The edit rules for a source that turned out to be a whole HTML document.
+ *  Short on purpose: the TSX rules would be actively wrong here, and a model
+ *  reading instructions that contradict the file in front of it starts
+ *  rewriting the file into what the instructions describe. */
+const HTML_RULES = [
+    "This file is a standalone HTML document. Keep it one:",
+    "  - Everything inline. No external CSS, JS, fonts or images — nothing loads",
+    "    from a network in the preview.",
+    "  - Keep the document valid and self-contained; do not convert it to a",
+    "    framework component.",
+].join("\n");
+/*
+ * Which of the two things the answer is.
+ *
+ * The page asks for a TSX component and most requests get one. But "recreate
+ * this as a single self-contained index.html" is a real request people make,
+ * and a model that obeys it is not wrong — it was told to. The stage is an
+ * iframe either way, so a whole document is if anything easier to render than
+ * a component; failing the turn over it would be the tool refusing an answer
+ * it can display.
+ */
+export const isHtmlDoc = (source) => /^\s*(<!doctype\s+html|<html[\s>])/i.test(source);
+/** Turn one: there is no file yet, so the model writes one. Every line of this
+ *  prompt is stable, which makes the whole system block cacheable across every
+ *  section a model is ever asked for. */
+export function buildSectionSystem() {
+    return [
+        "You write one self-contained React section component — a hero, a pricing",
+        "table, a footer, whatever the request names — as a single TSX file.",
+        "",
+        SECTION_RULES,
+        "",
+        HOUSE_RULES,
+    ].join("\n");
+}
+/*
+ * Turn two onward. Same contract as create: the whole file.
+ */
+export function buildSectionEditSystem(source) {
+    const html = isHtmlDoc(source);
+    return [
+        html
+            ? "Rewrite this HTML page so it already does what the user asked. You may change any part of the file."
+            : "Rewrite this React section so it already does what the user asked. You may change any part of the file.",
+        "",
+        html ? HTML_RULES : SECTION_RULES,
+        "",
+        "CURRENT SOURCE:",
+        source,
+        "",
+        "Change the file so the request is already visible. Returning it unchanged fails.",
+    ].join("\n");
+}
+//# sourceMappingURL=prompt.js.map