@ixo/openhands-sdk 0.0.0-stage → 0.1.0

package/dist/cjs/rubric/terms.js

@@ -0,0 +1,777 @@
+"use strict";
+/**
+ * What would count as done — derived from the ask itself, before the work
+ * exists. Shared deliberately: the agent that judges work and the app that
+ * posts it must read a sentence the same way, or a poster is promised one
+ * thing and a worker is held to another.
+ *
+ * This half is pure and tiny because the browser loads it. The judging half
+ * lived in ./verdict.ts until the oracle migration retired the in-repo checker;
+ * the receipt shape it wrote survives in ./receipt.ts for the readers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requiresPoster = exports.askSentence = exports.KIND_BADGE = exports.criterionText = exports.distanceWords = exports.DEFAULT_CONFIDENCE = exports.CALL_LIMITS = exports.CALL_SLUG = exports.CALL_LEGS = exports.CLAIM_KINDS = exports.DELIVERABLE_TYPES = exports.gatePhrase = void 0;
+exports.firstUrl = firstUrl;
+exports.matchSkill = matchSkill;
+exports.matchHuman = matchHuman;
+exports.hostOf = hostOf;
+exports.requiredTerms = requiredTerms;
+exports.deriveRubric = deriveRubric;
+exports.doneMeansSentence = doneMeansSentence;
+exports.servableByOracle = servableByOracle;
+exports.normalizeTerms = normalizeTerms;
+exports.callOf = callOf;
+exports.parseTerms = parseTerms;
+exports.inferDeliverable = inferDeliverable;
+exports.deriveTerms = deriveTerms;
+exports.addCriterion = addCriterion;
+/** Evidence no text-only worker can produce: no camera, no hands, no address. */
+const PHYSICAL = /\b(photo|photograph|picture|snap|image of|screenshot|screen shot|selfie|video|film|scan|handwritten|sticky note|poster|in person|visit|go to|walk|drive|deliver|pick up|drop off|knock|doorstep|on ?site|meet|queue|shelf|receipt)\b/i;
+const URL_PATTERN = /\bhttps?:\/\/[^\s"'<>)]+|\b(?:[a-z0-9-]+\.)+(?:com|org|net|io|dev|app|earth|xyz|co|ai|me|so|sh|eu|uk|de)(?:\/[^\s"'<>)]*)?/i;
+const CHECK_WORDS = /\b(check|verify|confirm|test|load|loads|loading|status|up|down|reachable|online|responds?|working|works|broken|404|uptime|ssl|redirect)\b/i;
+const READ_WORDS = /\b(summari[sz]e|summary|tl;?dr|says?|saying|price|cost|how many|how much|find|extract|list|mentions?|headline|title of)\b/i;
+/*
+ * Verbs and deliverable nouns both, on purpose: "Submit a recipe" and "Write a
+ * recipe" are the same job, and the first phrasing matched nothing — an ask a
+ * worker could plainly do was declined as "needs hands, a camera, or a person".
+ * A noun earns its place here only when it is unambiguously a text artifact;
+ * anything that might mean an errand ("email", "letter", "story") stays out,
+ * because the screen that says *no* honestly is worth more than one that says
+ * *yes* hopefully.
+ */
+const WRITE_WORDS = /\b(write|draft|compose|rewrite|word|wording|haiku|poem|tagline|slogan|strapline|headline|caption|name|title|summar(?:y|ise|ize)|one[- ]liner|sentence|paragraph|blurb|description|copy|recipe|joke|riddle|translation|tips|list of)\b/i;
+const ANSWER_WORDS = /^(what|why|how|when|who|which|where|does|do|is|are|can|should|explain|define)\b/i;
+const QUOTED_SPAN = /["“”'']([^"“”'']{3,60})["“”'']/g;
+/** The instruction with its quoted terms lifted out — what the screens should read. */
+const withoutQuoted = (text) => text.replace(QUOTED_SPAN, " ");
+function firstUrl(text) {
+    const match = text.match(URL_PATTERN);
+    if (!match?.[0])
+        return null;
+    const raw = match[0].replace(/[.,;:]+$/, "");
+    return raw.startsWith("http") ? raw : `https://${raw}`;
+}
+function matchSkill(title) {
+    /*
+     * Screen the instruction, not the quoted material. A phrase in quotes is a
+     * word the deliverable must contain, not a description of the errand —
+     * "photograph the receipt" wants hands, while `write a line using "receipt"`
+     * wants a sentence, and the difference is exactly the quotation marks.
+     */
+    if (PHYSICAL.test(withoutQuoted(title)))
+        return null;
+    const url = firstUrl(title);
+    if (url && CHECK_WORDS.test(title))
+        return { skill: "url-check", url };
+    if (url && READ_WORDS.test(title))
+        return { skill: "read", url };
+    if (WRITE_WORDS.test(title))
+        return { skill: "write" };
+    if (ANSWER_WORDS.test(title) || title.trim().endsWith("?"))
+        return { skill: "answer" };
+    return null;
+}
+/**
+ * Work a machine here cannot do, but a person plainly can — the other half of
+ * the same reading. `matchSkill` says "not mine"; this says whether that is
+ * because nobody could do it, or because it wants eyes, hands, or somewhere to
+ * stand. An agent that can tell those apart can buy the second kind.
+ *
+ * The physical words that disqualify a text-only worker are exactly what
+ * qualifies a person, so this deliberately does not screen them out. What it
+ * will not do is decide whether the errand is *allowed* — `checkAsk` runs
+ * first, always, and refuses what it refuses regardless of who would do it.
+ */
+/* `map|mapping|survey|trace` are here because mapping is the clearest case of
+   the distinction this function exists to draw: no agent can walk a
+   neighbourhood and record what is there, and a person plainly can. Without
+   them the hiring hand reads a mapping ask as work nobody can do. */
+const OBSERVE = /\b(look|see|watch|check|read|tell|say|says|describe|count|photograph|photo|picture|film|video|visit|go to|walk|ask|find out|confirm|verify|map|mapping|survey|trace)\b/i;
+const QUESTION = /^(what|which|how many|how much|is|are|does|do|who|where|when)\b/i;
+function matchHuman(title) {
+    const text = title.trim();
+    if (!text || matchSkill(text))
+        return false;
+    return QUESTION.test(text) || OBSERVE.test(text) || text.endsWith("?");
+}
+function hostOf(url) {
+    if (!url)
+        return "the page";
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return url.replace(/^https?:\/\//, "").split("/")[0] ?? url;
+    }
+}
+/** Terms an ask demands verbatim — quoted phrases are the only unambiguous signal. */
+function requiredTerms(title) {
+    const terms = [];
+    for (const match of title.matchAll(QUOTED_SPAN)) {
+        const term = match[1]?.trim();
+        if (term)
+            terms.push(term);
+    }
+    return terms.slice(0, 5);
+}
+/**
+ * The terms an ask implies. A brain may propose richer gates when one is
+ * configured; this is the floor, and it needs no key — so an ask can always
+ * say what it means, even with nothing but the sentence.
+ */
+function deriveRubric(title) {
+    const match = matchSkill(title);
+    if (!match)
+        return null;
+    const terms = requiredTerms(title);
+    const gates = [{ id: "non-empty" }];
+    if (match.skill === "url-check" && match.url) {
+        gates.push({ id: "mentions-url", url: match.url }, { id: "reports-status" }, { id: "re-measure", url: match.url });
+    }
+    else if (match.skill === "read" && match.url) {
+        gates.push({ id: "min-length", chars: 80 }, { id: "mentions-url", url: match.url });
+    }
+    else if (match.skill === "write") {
+        gates.push({ id: "min-length", chars: 20 });
+    }
+    else {
+        gates.push({ id: "min-length", chars: 40 });
+    }
+    if (terms.length)
+        gates.push({ id: "mentions-terms", terms });
+    return { v: 1, task: title, gates };
+}
+const PHRASES = {
+    "non-empty": () => "hands over actual work",
+    "min-length": (gate) => `is at least ${gate.chars} characters`,
+    "mentions-url": (gate) => `names ${hostOf(gate.url)}`,
+    "reports-status": () => "reports what the site answered",
+    "mentions-terms": (gate) => `uses ${gate.terms.map((term) => `"${term}"`).join(" and ")}`,
+    /* Third person on purpose: a poster reads this on their own compose screen,
+       where "I" would sound like them rather than the agent doing the checking. */
+    "re-measure": () => "matches what the reviewer measures",
+    "file-type": (gate) => `is ${describeAccept(gate.accept)}`,
+    "max-bytes": (gate) => `is under ${describeBytes(gate.bytes)}`,
+    "with-file": (gate) => `comes with a file under ${describeBytes(gate.bytes)}`,
+    /* Both of these are read by somebody about to walk somewhere, so they say
+       what to do rather than what will be measured. */
+    located: () => "says where it is",
+    "not-already-mapped": (gate) => `is more than ${gate.metres} m from anything already mapped`,
+    "at-registered-point": (gate) => `takes the waste to one of ${gate.points.length} named places`,
+    /* Names the source, because a worker should know before starting that the
+       proof is public and not a matter of anyone's opinion. */
+    /* "reported" is doing real work in this sentence: a poster reading it
+       should understand exactly how much it proves. And the target is named
+       when it has a name — "the target" is only honest when nothing better is
+       known. */
+    /* Says what it checks and, just as importantly, what it does not: a poster
+       reading this should not think we have verified the description. */
+    "before-after": () => "shows the same place before and after, visibly cleaner",
+    "weather-consistent": () => "does not contradict the weather recorded there",
+    "daylight-consistent": () => "does not contradict whether it was light there",
+    "within-radius": (gate) => {
+        const one = gate;
+        return `reports a location within ${(0, exports.distanceWords)(one.meters)} of ${one.place || "the target"}`;
+    },
+    "mapped-grid": (gate) => {
+        const one = gate;
+        const where = one.place ? `to ${one.place}` : "to the target area";
+        return `adds at least ${one.minFeatures} ${one.tag === "highway" ? "road segments" : "buildings"} ${where} within ${one.days} days, verified on OpenStreetMap`;
+    }
+};
+function describeAccept(accept) {
+    if (accept === "image/*")
+        return "an image";
+    if (accept === "video/*")
+        return "a video";
+    if (accept === "audio/*")
+        return "audio";
+    if (accept === "application/pdf")
+        return "a PDF";
+    return `of type ${accept}`;
+}
+function describeBytes(bytes) {
+    if (bytes >= 1_048_576)
+        return `${Math.round(bytes / 1_048_576)} MB`;
+    if (bytes >= 1024)
+        return `${Math.round(bytes / 1024)} kB`;
+    return `${bytes} bytes`;
+}
+/** One phrase per gate, for a chip or a list. Own keys only — see `isGate`. */
+const gatePhrase = (gate) => (Object.hasOwn(PHRASES, gate.id) ? PHRASES[gate.id](gate) : `meets the "${String(gate.id)}" rule`);
+exports.gatePhrase = gatePhrase;
+/** The readback: what a poster is shown before they commit money to an ask. */
+function doneMeansSentence(rubric) {
+    return rubric.gates.map(exports.gatePhrase).join(" · ");
+}
+// ------------------------------------------------------------- the ask, v2
+/**
+ * Terms v2 — the anatomy of an ask.
+ *
+ * v1 could only say "these gates must pass", which confined the product to
+ * work a regular expression can judge. Real asks want a photo of a notice
+ * board, a translation that reads naturally, a logo someone likes. So an ask
+ * now names three things: what gets handed over, what makes it complete, and
+ * who rules.
+ *
+ * The load-bearing idea is that **every criterion wears its kind**, and the
+ * kind is a promise about who can honestly judge it:
+ *
+ * - `measure` — a machine checks it, deterministically, replayable by anyone.
+ * - `judge`   — a model rules on a written sentence, with the evidence frozen
+ *               first and its reasoning published (see BD11 in the V build
+ *               plan). Auditable, not bit-reproducible.
+ * - `attest`  — only a person can say. No machine may claim it did.
+ *
+ * That last kind is the honest one. A system that cannot say "this cannot be
+ * machine-judged" will eventually pretend it judged something it did not, and
+ * a poster will be told their taste was verified by a regular expression.
+ */
+/**
+ * What an ask can ask for.
+ *
+ * **The list is the source and the type derives from it**, rather than a type
+ * beside a hand-copied array. `parseTerms` validates against this list, and
+ * when `photo-pair` was added to the type and not to that copy, every cleanup
+ * ask ever posted read as *"the terms could not be read"* — a checker
+ * declining to judge work against a document it thought was malformed, which
+ * is the correct behaviour on a bad document and a silent outage on a good
+ * one. It cost a live smoke to find. One list now.
+ *
+ * `photo-pair` is the cleanup shape: two photographs of one place, before and
+ * after. It is its own type rather than "two photos" because everything
+ * downstream treats it differently — the submission envelope carries two cids,
+ * the checker freezes both for the judge, and the leg is priced for two
+ * screens.
+ */
+exports.DELIVERABLE_TYPES = ["url", "text", "photo", "photo-pair", "mess-report", "field-report", "commitment", "file", "answer"];
+/**
+ * The kinds of claim an ask can take, where it takes more than one.
+ *
+ * Only a site does: a `patch` (before, after, the bags) which is judged and
+ * held, and the `site` shot which shows the whole area clear and releases
+ * every held patch. The claim says which in its own `kind` field. An ordinary
+ * cleanup's envelope says `pair` and nothing reads it — one kind of claim
+ * needs no vocabulary, and a criterion on such an ask is about the only
+ * claim there is.
+ *
+ * **The list is the source and the type derives from it**, as with
+ * `DELIVERABLE_TYPES` and for the same reason: the parser validates against
+ * this array and the bridge writes it into the rubric, so a kind added in one
+ * place cannot go missing in the other.
+ */
+exports.CLAIM_KINDS = ["patch", "site"];
+exports.CALL_LEGS = ["entries", "prize", "runnersUp"];
+/** A call's slug: what its page and its tag are named by. */
+exports.CALL_SLUG = /^[a-z][a-z0-9-]{2,39}$/;
+/** The limits a call is read with, and written to. */
+exports.CALL_LIMITS = {
+    title: 160,
+    lede: 500,
+    poster: 80,
+    blocks: 8,
+    paragraphs: 8,
+    paragraph: 1500,
+    url: 2048,
+    alt: 300,
+    caption: 300,
+    items: 6,
+    steps: 8,
+    stepTitle: 120,
+    stepText: 300,
+    source: 2000,
+    csv: 4000,
+    note: 300,
+    name: 120,
+    start: 1500,
+    lines: 5
+};
+exports.DEFAULT_CONFIDENCE = 0.7;
+/**
+ * A distance as a person says it: metres up to a kilometre, kilometres past
+ * it. "Within 18000 m of Ljubljana" is a sentence a machine wrote; the gate
+ * still measures the metres.
+ */
+const distanceWords = (metres) => (metres >= 1000 ? `${Number((metres / 1000).toFixed(1))} km` : `${metres} m`);
+exports.distanceWords = distanceWords;
+const criterionText = (criterion) => criterion.kind === "measure" ? (0, exports.gatePhrase)(criterion.gate) : criterion.text;
+exports.criterionText = criterionText;
+/** What a reader is promised about who checked this line. */
+exports.KIND_BADGE = {
+    measure: "automated check",
+    judge: "AI review",
+    /* Named, not pronouned. "You decide" was written from the poster's chair,
+       and the line's biggest audience reads it from the worker's — where "you"
+       is exactly the person it is not. */
+    attest: "the poster decides"
+};
+/** The readback for a v2 ask — the contract, in one line. */
+const askSentence = (terms) => terms.criteria.map(exports.criterionText).join(" · ");
+exports.askSentence = askSentence;
+/**
+ * An ask whose judge cannot rule on all of it is a trap: the chain allows
+ * exactly one verdict per claim, so there is no "the oracle does its half and
+ * the poster does the rest". Any `attest` criterion therefore forces the
+ * poster to hold the pen.
+ */
+const requiresPoster = (terms) => terms.criteria.some((criterion) => criterion.kind === "attest");
+exports.requiresPoster = requiresPoster;
+/**
+ * Whether a given checker can serve this ask in full. The evaluator calls this
+ * before accepting work and declines out loud when it cannot — the same
+ * honesty the keyless worker already practises when a skill needs a brain.
+ */
+function servableByOracle(terms, options) {
+    if ((0, exports.requiresPoster)(terms))
+        return { ok: false, reason: "has a requirement only a person can review" };
+    if (!options.canJudge && terms.criteria.some((criterion) => criterion.kind === "judge"))
+        return { ok: false, reason: "has requirements for AI review, but no model is configured" };
+    return { ok: true };
+}
+const nextId = (index) => `c${index + 1}`;
+/**
+ * One shape for every consumer. A v1 rubric is a v2 ask whose criteria are all
+ * machine-checked and whose judge was never written down — which is exactly
+ * what a v1 ask was. Nothing in flight has to be migrated: the stored bytes
+ * stay as they are, and identity is still the hash of those bytes.
+ */
+function normalizeTerms(doc) {
+    if (doc.v === 2)
+        return doc;
+    return {
+        v: 2,
+        task: doc.task,
+        deliverable: { type: "text", prompt: doc.task },
+        criteria: doc.gates.map((gate, index) => ({ id: nextId(index), kind: "measure", gate })),
+        judge: { kind: "poster" }
+    };
+}
+/*
+ * A gate off the wire is checked field by field, in the shape the checker will
+ * read it. This used to check only that the id was a known word, so a gate
+ * published as `{id: "mentions-terms"}` reached `runGate` and threw on the
+ * `.filter` of a list that was not there — one ask's terms, and the checker's
+ * whole pass down with it — and `{id: "constructor"}` passed because `in`
+ * sees what `Object.prototype` declares, handing `criterionText` a function
+ * to call. Malformed is absent, as with everything else this parser reads.
+ *
+ * Strings are bounded because every one of them is rendered: a place label
+ * or a required phrase the size of a page is not a term, it is a payload.
+ */
+const GATE_TEXT_MAX = 200;
+const GATE_URL_MAX = 2048;
+const GATE_LIST_MAX = 20;
+const finite = (value) => typeof value === "number" && Number.isFinite(value);
+const positive = (value) => finite(value) && value > 0;
+const nonNegative = (value) => finite(value) && value >= 0;
+const latitude = (value) => finite(value) && Math.abs(value) <= 90;
+const longitude = (value) => finite(value) && Math.abs(value) <= 180;
+const shortText = (value, max = GATE_TEXT_MAX) => typeof value === "string" && value.trim().length > 0 && value.length <= max;
+const optionalText = (value) => value === undefined || shortText(value);
+const isPoint = (value) => {
+    const point = value;
+    return Boolean(point) && typeof point === "object" && latitude(point.lat) && longitude(point.lon) && optionalText(point.label);
+};
+const isGate = (value) => {
+    const gate = value;
+    if (!gate || typeof gate !== "object" || typeof gate.id !== "string" || !Object.hasOwn(PHRASES, gate.id))
+        return false;
+    switch (gate.id) {
+        case "non-empty":
+        case "reports-status":
+        case "located":
+        case "weather-consistent":
+        case "daylight-consistent":
+        case "before-after":
+            return true;
+        case "min-length":
+            return positive(gate.chars);
+        case "max-bytes":
+        case "with-file":
+            return positive(gate.bytes);
+        case "mentions-url":
+        case "re-measure":
+            return shortText(gate.url, GATE_URL_MAX);
+        case "file-type":
+            return shortText(gate.accept);
+        case "mentions-terms":
+            return Array.isArray(gate.terms) && gate.terms.length > 0 && gate.terms.length <= GATE_LIST_MAX && gate.terms.every((term) => shortText(term));
+        case "not-already-mapped":
+            return positive(gate.metres);
+        case "within-radius":
+            return latitude(gate.lat) && longitude(gate.lon) && positive(gate.meters) && optionalText(gate.place);
+        case "at-registered-point":
+            return Array.isArray(gate.points) && gate.points.length > 0 && gate.points.length <= GATE_LIST_MAX && gate.points.every(isPoint) && positive(gate.metres);
+        case "mapped-grid": {
+            const box = gate.box;
+            return (Boolean(box) &&
+                typeof box === "object" &&
+                latitude(box.south) &&
+                latitude(box.north) &&
+                longitude(box.west) &&
+                longitude(box.east) &&
+                (gate.tag === "building" || gate.tag === "highway") &&
+                nonNegative(gate.minEdits) &&
+                nonNegative(gate.minFeatures) &&
+                positive(gate.days) &&
+                optionalText(gate.place));
+        }
+    }
+    return false;
+};
+const isCriterion = (value) => {
+    const criterion = value;
+    if (!criterion || typeof criterion.id !== "string" || !criterion.id)
+        return false;
+    if (criterion.kind === "measure")
+        return isGate(criterion.gate);
+    if (criterion.kind === "judge" || criterion.kind === "attest")
+        return typeof criterion.text === "string" && criterion.text.trim().length > 0;
+    return false;
+};
+/*
+ * Terms come off the wire, and the wire belongs to whoever posted the ask —
+ * which on the board is usually a stranger. Every string below ends up on the
+ * page where somebody decides whether to do the work, and one of them is the
+ * heading. They are testimony about what "done" means, not evidence of
+ * anything, so they are cut to a size a page can hold and stripped of the
+ * characters that let a sentence pretend to be two.
+ *
+ * Cut rather than refused: a poster who wrote a very long task still has an
+ * ask, and refusing it outright would hide work somebody could do. The full
+ * document is at its own content address either way.
+ */
+const TASK_MAX = 500;
+const PROMPT_MAX = 500;
+const CRITERION_MAX = 300;
+const CRITERIA_MAX = 20;
+const trim = (raw, max) => {
+    // eslint-disable-next-line no-control-regex -- stripping them is the point
+    const text = raw.replace(/[\u0000-\u001f\u007f\u2028\u2029]/g, " ").replace(/\s+/g, " ").trim();
+    return text.length <= max ? text : `${text.slice(0, max)}…`;
+};
+/**
+ * One criterion, as the parser hands it on: the sentence cut to a size a page
+ * can hold, and `appliesTo` kept only when it names a kind we know.
+ *
+ * An unrecognised kind is **dropped, not obeyed and not fatal** — the same
+ * posture as `publish` and `revisitOf` below, and the safe direction: the
+ * criterion then applies to every claim, which is the rule as it stood before
+ * the field existed. Obeying it would let a word off the wire turn a gate off
+ * (a condition that can never hold is a rule that never runs), and refusing
+ * the whole document would leave an otherwise good ask unjudgeable.
+ *
+ * Rebuilt by spread rather than field by field on purpose: an older document
+ * carries keys this version never heard of, and the round-trip guard compares
+ * bytes — so the keys that are there keep both their values and their order.
+ */
+const readCriterion = (criterion) => {
+    const read = criterion.kind === "measure" ? criterion : { ...criterion, text: trim(criterion.text, CRITERION_MAX) };
+    const scope = read.appliesTo;
+    if (scope === undefined || exports.CLAIM_KINDS.includes(scope))
+        return read;
+    const { appliesTo: _unknownKind, ...rest } = read;
+    return rest;
+};
+/**
+ * Read terms off the wire. Anything that fails to parse is treated as absent
+ * rather than repaired: a checker that guesses at malformed terms is judging
+ * work against a document nobody agreed to.
+ */
+/**
+ * The follow-on an approved answer spawns, read with the same suspicion as
+ * everything else off the wire. Malformed is absent, not repaired: a chain
+ * that half-parses would spawn an ask nobody wrote.
+ */
+function chainOf(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    if (typeof raw.task !== "string" || !raw.task.trim())
+        return null;
+    if (!raw.deliverable || !exports.DELIVERABLE_TYPES.includes(raw.deliverable.type) || typeof raw.deliverable.prompt !== "string")
+        return null;
+    if (raw.target?.mode !== "fixed" || typeof raw.target.base !== "string" || !/^[1-9][0-9]{0,18}$/.test(raw.target.base))
+        return null;
+    if (raw.funding !== "poster" && raw.funding !== "crowd")
+        return null;
+    return {
+        chain: {
+            task: trim(raw.task, TASK_MAX),
+            deliverable: { type: raw.deliverable.type, prompt: trim(raw.deliverable.prompt, PROMPT_MAX) },
+            target: { mode: "fixed", base: raw.target.base },
+            funding: raw.funding,
+            ...(raw.atAnswersPlace === true ? { atAnswersPlace: true } : {})
+        }
+    };
+}
+/*
+ * A call, read with the same suspicion — and stricter, because every string in
+ * it is rendered and some of it is fetched (a picture's address). One field
+ * out of shape and the whole call is absent: a call half-read would draw a
+ * brief nobody wrote. Nothing is trimmed, so what a writer built within these
+ * limits reads back byte for byte; the builders (`call.ts`) refuse anything
+ * this would refuse.
+ */
+// eslint-disable-next-line no-control-regex -- refusing them is the point
+const ONE_LINE_BAD = /[\u0000-\u001f\u007f\u2028\u2029]/;
+// eslint-disable-next-line no-control-regex -- a CSV and a diagram's source keep their line breaks, nothing else
+const MANY_LINES_BAD = /[\u0000-\u0009\u000b-\u001f\u007f\u2028\u2029]/;
+const line = (value, max) => typeof value === "string" && value.trim().length > 0 && value.length <= max && !ONE_LINE_BAD.test(value);
+const lines = (value, max) => typeof value === "string" && value.trim().length > 0 && value.length <= max && !MANY_LINES_BAD.test(value);
+const maybe = (value, max) => value === undefined || line(value, max);
+const https = (value) => {
+    if (!line(value, exports.CALL_LIMITS.url) || !value.startsWith("https://"))
+        return false;
+    try {
+        return new URL(value).protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+};
+const someOf = (value, max, each) => Array.isArray(value) && value.length > 0 && value.length <= max && value.every(each);
+const date = (value) => typeof value === "string" && value.length <= 40 && Number.isFinite(Date.parse(value));
+const amount = (value) => finite(value) && value >= 0 && value <= 1_000_000;
+const whole = (value, low, high) => Number.isInteger(value) && value >= low && value <= high;
+function blockOf(raw) {
+    const block = raw;
+    if (!block || typeof block !== "object")
+        return null;
+    const L = exports.CALL_LIMITS;
+    const picture = (one) => {
+        const it = one;
+        return Boolean(it) && https(it.url) && line(it.alt, L.alt) && maybe(it.caption, L.caption);
+    };
+    const file = (one) => {
+        const it = one;
+        return Boolean(it) && https(it.url) && line(it.name, L.name) && maybe(it.note, L.note);
+    };
+    const step = (one) => {
+        const it = one;
+        return Boolean(it) && line(it.title, L.stepTitle) && maybe(it.text, L.stepText);
+    };
+    const paragraph = (one) => line(one, L.paragraph);
+    const withCaption = (value, caption) => (caption === undefined ? value : { ...value, caption: caption });
+    const withNote = (value, note) => (note === undefined ? value : { ...value, note: note });
+    switch (block.kind) {
+        case "story":
+            return someOf(block.paragraphs, L.paragraphs, paragraph) ? { kind: "story", paragraphs: [...block.paragraphs] } : null;
+        case "cover":
+            return https(block.url) && line(block.alt, L.alt) && maybe(block.caption, L.caption) ? withCaption({ kind: "cover", url: block.url, alt: block.alt }, block.caption) : null;
+        case "pictures":
+            return someOf(block.items, L.items, picture) ? { kind: "pictures", items: block.items.map((one) => withCaption({ url: one.url, alt: one.alt }, one.caption)) } : null;
+        case "diagram":
+            if (!line(block.title, L.title) || !someOf(block.steps, L.steps, step) || !(block.source === undefined || lines(block.source, L.source)))
+                return null;
+            return {
+                kind: "diagram",
+                title: block.title,
+                steps: block.steps.map((one) => (one.text === undefined ? { title: one.title } : { title: one.title, text: one.text })),
+                ...(block.source === undefined ? {} : { source: block.source })
+            };
+        case "data":
+            return line(block.title, L.title) && lines(block.csv, L.csv) && maybe(block.note, L.note) ? withNote({ kind: "data", title: block.title, csv: block.csv }, block.note) : null;
+        case "files":
+            return someOf(block.items, L.items, file) ? { kind: "files", items: block.items.map((one) => withNote({ url: one.url, name: one.name }, one.note)) } : null;
+        case "start":
+            return lines(block.prompt, L.start) ? { kind: "start", prompt: block.prompt } : null;
+    }
+    return null;
+}
+function callOf(raw) {
+    const call = raw;
+    if (!call || typeof call !== "object")
+        return null;
+    const L = exports.CALL_LIMITS;
+    if (typeof call.slug !== "string" || !exports.CALL_SLUG.test(call.slug))
+        return null;
+    if (!exports.CALL_LEGS.includes(call.leg))
+        return null;
+    if (!line(call.title, L.title) || !line(call.lede, L.lede) || !line(call.poster, L.poster))
+        return null;
+    if (!Array.isArray(call.points) || call.points.length === 0 || call.points.length > L.lines || !call.points.every((one) => finite(one) && one >= 0 && one <= 100))
+        return null;
+    const money = call.money;
+    if (!money || typeof money !== "object")
+        return null;
+    if (!amount(money.prize) || !whole(money.runnersN, 0, 5) || !amount(money.runnersEach) || !amount(money.entryEach) || !whole(money.entryUpTo, 1, 10_000))
+        return null;
+    if (!date(call.closes) || !date(call.drop) || !date(call.pick))
+        return null;
+    let legs;
+    if (call.legs !== undefined) {
+        const raw = call.legs;
+        if (!raw || typeof raw !== "object")
+            return null;
+        legs = {};
+        for (const name of exports.CALL_LEGS) {
+            const id = raw[name];
+            if (id === undefined)
+                continue;
+            if (typeof id !== "string" || !/^\d{1,12}$/.test(id))
+                return null;
+            legs[name] = id;
+        }
+    }
+    if (!Array.isArray(call.blocks) || call.blocks.length > L.blocks)
+        return null;
+    const blocks = call.blocks.map(blockOf);
+    if (blocks.some((block) => block === null))
+        return null;
+    return {
+        call: {
+            slug: call.slug,
+            leg: call.leg,
+            title: call.title,
+            lede: call.lede,
+            poster: call.poster,
+            points: [...call.points],
+            money: { prize: money.prize, runnersN: money.runnersN, runnersEach: money.runnersEach, entryEach: money.entryEach, entryUpTo: money.entryUpTo },
+            closes: call.closes,
+            drop: call.drop,
+            pick: call.pick,
+            ...(legs ? { legs } : {}),
+            blocks: blocks
+        }
+    };
+}
+/** Where the waste may go, cleaned of anything that is not a coordinate. */
+function disposalOf(raw) {
+    if (!raw || !Array.isArray(raw.points) || !(Number(raw.metres) > 0))
+        return null;
+    const points = raw.points
+        .filter((one) => Number.isFinite(Number(one?.lat)) && Number.isFinite(Number(one?.lon)))
+        .slice(0, 20)
+        .map((one) => ({ lat: Number(one.lat), lon: Number(one.lon), ...(one.label ? { label: trim(String(one.label), 60) } : {}) }));
+    return { disposal: { points, metres: Math.floor(Number(raw.metres)) } };
+}
+function parseTerms(value) {
+    const doc = value;
+    if (!doc || typeof doc !== "object")
+        return null;
+    if (doc.v === 1) {
+        if (typeof doc.task !== "string" || !Array.isArray(doc.gates) || !doc.gates.every(isGate))
+            return null;
+        return normalizeTerms({ v: 1, task: trim(doc.task, TASK_MAX), gates: doc.gates });
+    }
+    if (doc.v !== 2)
+        return null;
+    if (typeof doc.task !== "string" || !doc.task)
+        return null;
+    const deliverable = doc.deliverable;
+    if (!deliverable || !exports.DELIVERABLE_TYPES.includes(deliverable.type) || typeof deliverable.prompt !== "string")
+        return null;
+    if (!Array.isArray(doc.criteria) || doc.criteria.length === 0 || !doc.criteria.every(isCriterion))
+        return null;
+    if (new Set(doc.criteria.map((criterion) => criterion.id)).size !== doc.criteria.length)
+        return null;
+    const judge = doc.judge;
+    if (!judge || (judge.kind !== "poster" && judge.kind !== "oracle"))
+        return null;
+    if (judge.kind === "oracle" && !judge.address)
+        return null;
+    /*
+     * **Rebuilt field by field, so anything new has to be named here too.**
+     *
+     * `campaign` and `followUp` were added to the type and not to this object,
+     * so every ask lost them the moment a checker parsed its terms — and the
+     * checker is the only thing that reads `followUp`. An approved cleanup
+     * therefore never bought its re-visit, silently, on terms that plainly asked
+     * for one. The same shape that made `photo-pair` unparseable a few hours
+     * earlier: a second place that has to agree with the type and does not
+     * announce when it stops.
+     */
+    return {
+        v: 2,
+        task: trim(doc.task, TASK_MAX),
+        deliverable: { ...deliverable, prompt: trim(deliverable.prompt, PROMPT_MAX) },
+        ...(typeof doc.campaign === "string" && doc.campaign ? { campaign: trim(doc.campaign, 64) } : {}),
+        ...(typeof doc.series === "string" && /^[a-z0-9-]{1,64}$/.test(doc.series) ? { series: doc.series } : {}),
+        ...(chainOf(doc.chain) ?? {}),
+        ...(callOf(doc.call) ?? {}),
+        ...(doc.followUp && Number(doc.followUp.days) > 0 && doc.followUp.pay
+            ? {
+                followUp: {
+                    days: Math.floor(Number(doc.followUp.days)),
+                    pay: String(doc.followUp.pay),
+                    ...(Number(doc.followUp.daysMin) > 0 && Number(doc.followUp.daysMax) >= Number(doc.followUp.daysMin)
+                        ? { daysMin: Math.floor(Number(doc.followUp.daysMin)), daysMax: Math.floor(Number(doc.followUp.daysMax)) }
+                        : {})
+                }
+            }
+            : {}),
+        ...(typeof doc.revisitOf === "string" && /^\d+$/.test(doc.revisitOf) ? { revisitOf: doc.revisitOf } : {}),
+        /* Named here or dropped here — the rule this comment block is about. Only
+           the one literal value: an unknown publishing mode must read as "no", not
+           as something permissive nobody defined. */
+        ...(doc.publish === "on-approval" ? { publish: "on-approval" } : {}),
+        ...(typeof doc.clears === "string" && /^bafk[a-z2-7]{20,}$/.test(doc.clears) ? { clears: doc.clears } : {}),
+        /* A site takes patch claims and holds them; the checker branches on this
+           and on nothing else, so losing it here turns a site back into a
+           one-person cleanup that pays the first patch and never splits. It was
+           lost here, exactly as `campaign` and `followUp` were before it. */
+        ...(doc.site === true ? { site: true } : {}),
+        ...(disposalOf(doc.disposal) ?? {}),
+        criteria: doc.criteria.slice(0, CRITERIA_MAX).map(readCriterion),
+        judge,
+        /* Named here or dropped here. The one literal: anything else is nobody's mark. */
+        ...(doc.via === "mcp" ? { via: "mcp" } : {})
+    };
+}
+const PHOTO_WORDS = /\b(photo|photograph|picture|snap|selfie|image of|screenshot|screen shot)\b/i;
+const FILE_WORDS = /\b(video|film|footage|recording|scan|pdf|document|file|upload)\b/i;
+/**
+ * What an ask is asking for, read off its own sentence. The deliverable is
+ * what decides which box a worker is shown — and on a phone, `photo` is the
+ * difference between a file picker and the camera opening.
+ */
+function inferDeliverable(title) {
+    const match = matchSkill(title);
+    if (PHOTO_WORDS.test(title))
+        return { type: "photo", prompt: title };
+    if (FILE_WORDS.test(title))
+        return { type: "file", prompt: title };
+    if (match?.skill === "url-check")
+        return { type: "url", prompt: title };
+    if (match?.skill === "write" || match?.skill === "read")
+        return { type: "text", prompt: title };
+    if (match?.skill === "answer" || title.trim().endsWith("?"))
+        return { type: "answer", prompt: title };
+    return { type: "text", prompt: title };
+}
+/** The gates a deliverable implies on its own — a file's shape, not its content. */
+function deliverableGates(deliverable) {
+    if (deliverable.type === "photo")
+        return [{ id: "file-type", accept: "image/*" }, { id: "max-bytes", bytes: 10_485_760 }];
+    if (deliverable.type === "file")
+        return [{ id: "max-bytes", bytes: 26_214_400 }];
+    return [];
+}
+/**
+ * The floor, in v2 clothing — what an ask means when nothing else is said.
+ *
+ * Note what this deliberately does NOT do: it never invents a `judge`
+ * criterion. Everything derived here is machine-checkable, because a criterion
+ * the poster did not write is a criterion nobody agreed to. Judged criteria
+ * come from a person or from A1's draft-and-edit, never from a regex.
+ */
+function deriveTerms(title, judge = { kind: "poster" }) {
+    const deliverable = inferDeliverable(title);
+    const v1 = deriveRubric(title);
+    const inherited = v1 ? normalizeTerms(v1).criteria : [{ id: "c1", kind: "measure", gate: { id: "non-empty" } }];
+    const extra = deliverableGates(deliverable);
+    const criteria = [
+        ...inherited,
+        ...extra.map((gate, index) => ({ id: nextId(inherited.length + index), kind: "measure", gate }))
+    ];
+    return { v: 2, task: title, deliverable, criteria, judge };
+}
+/** Append a criterion, keeping ids unique and stable for everything already there. */
+function addCriterion(terms, criterion) {
+    const used = new Set(terms.criteria.map((existing) => existing.id));
+    let index = terms.criteria.length;
+    while (used.has(nextId(index)))
+        index += 1;
+    return { ...terms, criteria: [...terms.criteria, { ...criterion, id: nextId(index) }] };
+}
+//# sourceMappingURL=terms.js.map