@ixo/openhands-sdk 0.0.0-stage → 0.2.0

package/dist/esm/rubric/gateMet.js

@@ -0,0 +1,104 @@
+/**
+ * What each gate says when it is met.
+ *
+ * The bridge writes every gate's `reason` in the voice of its failure —
+ * "Nothing was handed over", "No location was reported" — because a reason is
+ * what a rejection quotes. A receipt shows the gates that passed too, and it
+ * was printing those failure sentences beside a pass: "✓ Nothing was handed
+ * over", on the certificate of work that had handed something over. This is
+ * the other half, one sentence per gate, in the voice of the requirement
+ * being met, kept in the package that names the gates so a new one cannot
+ * ship with only half its words (`gateMet.test.ts` reads the bridge to make
+ * sure of that).
+ *
+ * Keyed by the label in a gate's code (`OH-101-LOCATED` is `located`), which
+ * the bridge has never renamed, so it reads the receipts of every ask ever
+ * posted and nothing already published has to be rewritten. Said without the
+ * numbers a reason carries ("20 characters", "within 60 m"), because the
+ * code is all a receipt keeps, and a number guessed is worse than none.
+ */
+export const GATE_MET = {
+    present: "Something was handed over",
+    length: "Long enough for what the ask asked",
+    "names-site": "Names the site the ask named",
+    "reports-status": "States a status or a failure",
+    terms: "Contains the words the ask asked for",
+    "file-type": "The file is the kind the ask asked for",
+    "file-size": "The file is within the size the ask allows",
+    "extra-file": "A second file came with it",
+    "within-radius": "Within the distance the ask set",
+    located: "A location was reported",
+    "before-after": "The two photographs are of the same place, in order",
+    daylight: "The light fits the place and the time",
+    weather: "The weather fits the record for the place and the time",
+    "not-already-mapped": "Nothing already approved on this ask is this close",
+    "re-measure": "A fresh reading agrees with the answer",
+    "at-point": "Within reach of a registered point",
+    "mapped-grid": "Enough was mapped in the target area",
+    kind: "Says whether it is a patch or the whole site",
+    cooldown: "Nowhere this close was paid for recently",
+    site: "The site marker was recorded",
+    "not-generated": "Nothing in the photograph says an AI generator made it",
+    "not-elsewhere": "Taken at the place reported"
+};
+/** Gates whose reason is the rule itself, which reads the same met or not. */
+export const RULE_IS_REASON = new Set(["judged", "real-photo"]);
+/** The label in a gate code this estate wrote: `OH-101-LOCATED` is `located`. */
+export const gateLabel = (code) => /^OH-\d+-([A-Z0-9-]+)$/.exec(code)?.[1]?.toLowerCase() ?? null;
+/**
+ * The sentence a met gate shows: its own met words, or the rule itself for a
+ * judged line. Null for a code this estate did not write, whose reason there
+ * is no way to turn around; the caller says so rather than printing a
+ * failure under a pass.
+ */
+export function metSentence(code, reason) {
+    const label = gateLabel(code);
+    if (!label)
+        return null;
+    if (RULE_IS_REASON.has(label))
+        return reason;
+    return GATE_MET[label] ?? null;
+}
+/**
+ * Each gate in two or three words, for a place that lists the rules at a
+ * glance — the decision trace's chips. Said in the voice of the rule being
+ * met, like `GATE_MET`, and kept beside it so a new gate cannot ship with
+ * its sentence and no label (`gateMet.test.ts` holds the two to each other).
+ *
+ * A judged gate has no label of its own: its rule is a sentence somebody
+ * wrote for that ask, and two words would put words in their mouth. The
+ * trace counts those instead ("2 judged by AI") and the sentences stay in
+ * the full list.
+ */
+export const GATE_SHORT = {
+    present: "Handed over",
+    length: "Long enough",
+    "names-site": "Names the site",
+    "reports-status": "States a status",
+    terms: "Has the words asked for",
+    "file-type": "Right kind of file",
+    "file-size": "Within the size limit",
+    "extra-file": "Second file included",
+    "within-radius": "In the area",
+    located: "Location given",
+    "before-after": "Before, then after",
+    daylight: "Daylight fits",
+    weather: "Weather fits",
+    "not-already-mapped": "Not already mapped",
+    "re-measure": "Re-measured",
+    "at-point": "At the point",
+    "mapped-grid": "Area mapped",
+    kind: "Patch or whole site",
+    cooldown: "Not paid here recently",
+    site: "Site marked",
+    "not-generated": "Not AI-generated",
+    "not-elsewhere": "Taken there"
+};
+/** A gate's label for the trace, or null for a judged gate or a code this estate did not write. */
+export function ruleShort(code) {
+    const label = gateLabel(code);
+    if (!label || RULE_IS_REASON.has(label))
+        return null;
+    return GATE_SHORT[label] ?? null;
+}
+//# sourceMappingURL=gateMet.js.map

package/dist/esm/rubric/gateMet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateMet.js","sourceRoot":"","sources":["../../../src/rubric/gateMet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAqC;IACxD,OAAO,EAAE,2BAA2B;IACpC,MAAM,EAAE,oCAAoC;IAC5C,YAAY,EAAE,8BAA8B;IAC5C,gBAAgB,EAAE,8BAA8B;IAChD,KAAK,EAAE,sCAAsC;IAC7C,WAAW,EAAE,wCAAwC;IACrD,WAAW,EAAE,4CAA4C;IACzD,YAAY,EAAE,4BAA4B;IAC1C,eAAe,EAAE,iCAAiC;IAClD,OAAO,EAAE,yBAAyB;IAClC,cAAc,EAAE,qDAAqD;IACrE,QAAQ,EAAE,uCAAuC;IACjD,OAAO,EAAE,wDAAwD;IACjE,oBAAoB,EAAE,oDAAoD;IAC1E,YAAY,EAAE,wCAAwC;IACtD,UAAU,EAAE,oCAAoC;IAChD,aAAa,EAAE,sCAAsC;IACrD,IAAI,EAAE,8CAA8C;IACpD,QAAQ,EAAE,0CAA0C;IACpD,IAAI,EAAE,8BAA8B;IACpC,eAAe,EAAE,wDAAwD;IACzE,eAAe,EAAE,6BAA6B;CAC/C,CAAC;AAEF,8EAA8E;AAC9E,MAAM,CAAC,MAAM,cAAc,GAAwB,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC;AAErF,iFAAiF;AACjF,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,IAAY,EAAiB,EAAE,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,IAAI,CAAC;AAEzH;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY,EAAE,MAAc;IACtD,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAC9B,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACxB,IAAI,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,OAAO,MAAM,CAAC;IAC7C,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC;AACjC,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,UAAU,GAAqC;IAC1D,OAAO,EAAE,aAAa;IACtB,MAAM,EAAE,aAAa;IACrB,YAAY,EAAE,gBAAgB;IAC9B,gBAAgB,EAAE,iBAAiB;IACnC,KAAK,EAAE,yBAAyB;IAChC,WAAW,EAAE,oBAAoB;IACjC,WAAW,EAAE,uBAAuB;IACpC,YAAY,EAAE,sBAAsB;IACpC,eAAe,EAAE,aAAa;IAC9B,OAAO,EAAE,gBAAgB;IACzB,cAAc,EAAE,oBAAoB;IACpC,QAAQ,EAAE,eAAe;IACzB,OAAO,EAAE,cAAc;IACvB,oBAAoB,EAAE,oBAAoB;IAC1C,YAAY,EAAE,aAAa;IAC3B,UAAU,EAAE,cAAc;IAC1B,aAAa,EAAE,aAAa;IAC5B,IAAI,EAAE,qBAAqB;IAC3B,QAAQ,EAAE,wBAAwB;IAClC,IAAI,EAAE,aAAa;IACnB,eAAe,EAAE,kBAAkB;IACnC,eAAe,EAAE,aAAa;CAC/B,CAAC;AAEF,mGAAmG;AACnG,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAC9B,IAAI,CAAC,KAAK,IAAI,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACrD,OAAO,UAAU,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC;AACnC,CAAC"}

package/dist/esm/rubric/leg.d.ts

@@ -0,0 +1,106 @@
+import type { AskTerms } from "./terms.ts";
+/**
+ * What the evaluation leg must be worth for the engine to judge for free.
+ *
+ * The engine bills the collection's **owner** for every claim it decides. Their
+ * own billing rule is the way out: *if a reward pot already covers our price,
+ * the owner is never billed at all.* So an ask whose evaluation leg is worth at
+ * least their price costs nobody anything — no subscription, no delegation, no
+ * invoice.
+ *
+ * That only works in a currency their FX values at face. Their precedence
+ * values USD-stables at face and **everything else at real market rate on
+ * every network, testnet included** — so a 0.1 IXO leg is about $0.00018 of
+ * credit against a $0.30 price, and essentially the whole price of every claim
+ * would be invoiced. `upay` is in their registry at `pegUsd: 1`, so PAY is the
+ * only denom this arithmetic works in. `evaluationLegBase` refuses anything
+ * else rather than quietly under-funding a leg.
+ *
+ * The price is per-ask, not a constant: it depends on how many AI-judged rules
+ * the rubric actually carries and whether a photo is screened.
+ *
+ * **The numbers are their published card**, read from `GET /v1/pricing`
+ * (public, no auth) on 2026-08-25:
+ *
+ *   Partner Standard (default) — base $0.30 · AI rule $0.01 · photo $0.10
+ *                              · **agent claim $0.05**
+ *
+ * The agent-claim component is the one the earlier audit missed. It is zero
+ * only on IXO's own relayer; on a partner's — which is us — every claim an
+ * agent submits carries it, and an ask with a quota carries it per spot.
+ */
+export interface EnginePrice {
+    baseUsd: number;
+    aiRuleUsd: number;
+    photoUsd: number;
+    agentClaimUsd: number;
+    /**
+     * AI-judged rules the base already covers.
+     *
+     * Their card charges every AI rule; ours includes the first, because every
+     * checked ask here carries a relevance judge and a base price that does not
+     * cover the standard check is a base price in name only.
+     */
+    includedAiRules?: number;
+}
+/** Their Partner Standard card, as published. Overridable by env at the caller. */
+export declare const PARTNER_STANDARD: EnginePrice;
+export interface LegQuote {
+    /** Base units of `upay`. */
+    base: string;
+    /** The same number as dollars, for anything a person reads. */
+    usd: number;
+    /** How it was reached, so a poster can see what they are paying for. */
+    because: string[];
+}
+/**
+ * What one ask's evaluation leg should hold.
+ *
+ * `spots` is the ask's quota: the engine decides every claim, so a quota of
+ * three is three agent-claim charges even if only one is approved.
+ */
+export declare function evaluationLegQuote(terms: AskTerms | null | undefined, spots?: number, price?: EnginePrice): LegQuote;
+/**
+ * The same quote, or a refusal naming the reason.
+ *
+ * A `uixo` board cannot fund an engine-live ask at all: at market rate the leg
+ * would have to be hundreds of IXO to reach $0.30 of their credit, and the
+ * poster would be paying a checker fee nobody asked for. Refusing is the
+ * honest answer, and it is the whole finding of the engine audit's §13.
+ */
+export declare function evaluationLegFor(denom: string, terms: AskTerms | null | undefined, spots?: number, price?: EnginePrice): LegQuote;
+/**
+ * Our own checker's card — the evaluation leg as a priced service.
+ *
+ * The poster chooses their judge at posting time (themselves, this checker, or
+ * the ixo engine — the chain allows exactly one per claim), and the chosen
+ * judge's card prices the leg. This is ours, and its design argument is the
+ * opposite of a menu of tolls:
+ *
+ * **Everything deterministic rides in the base.** Location, weather, daylight,
+ * re-measuring a URL — these cost us arithmetic and one keyless HTTP call, and
+ * they are the product's differentiator. Priced as add-ons, posters would skip
+ * them and every answer would get worse by default. So the base *includes*
+ * them, plus the standard relevance judge, and the line items are only the
+ * things that genuinely cost per unit: extra AI-judged rules and photo
+ * screening.
+ *
+ * For comparison, read from their public card the same day this was written:
+ * theirs is $0.30 base + $0.01/AI rule + $0.10/photo + $0.05/agent claim, and
+ * their binder defers geo to a human. Same slot, richer checks, a third of the
+ * price — that is the sentence this card exists to make true.
+ */
+export declare const checkerBaseUpay: () => number;
+export declare const checkerAiUpay: () => number;
+export declare const checkerPhotoUpay: () => number;
+export declare const OPENHANDS_CARD: EnginePrice;
+/**
+ * What OUR checker's leg should hold for this ask, in base units of `denom`.
+ *
+ * On a PAY board the card prices it, because the card is in dollars and PAY is
+ * the only denom that honestly wears a dollar face. On anything else the flat
+ * fallback stands — pricing IXO from a USD card would need an exchange rate,
+ * and inventing one is how the engine audit's §13 mistake gets made in reverse.
+ */
+export declare function checkerLegBase(denom: string, terms: AskTerms | null | undefined, flatFallbackBase: number): number;
+//# sourceMappingURL=leg.d.ts.map

package/dist/esm/rubric/leg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leg.d.ts","sourceRoot":"","sources":["../../../src/rubric/leg.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,mFAAmF;AACnF,eAAO,MAAM,gBAAgB,EAAE,WAAmF,CAAC;AAKnH,MAAM,WAAW,QAAQ;IACvB,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,GAAG,EAAE,MAAM,CAAC;IACZ,wEAAwE;IACxE,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,EAAE,KAAK,SAAI,EAAE,KAAK,GAAE,WAA8B,GAAG,QAAQ,CAgCjI;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,EAAE,KAAK,SAAI,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,QAAQ,CAO5H;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AAQH,eAAO,MAAM,eAAe,QAAO,MAAuH,CAAC;AAC3J,eAAO,MAAM,aAAa,QAAO,MAAkH,CAAC;AACpJ,eAAO,MAAM,gBAAgB,QAAO,MAAwH,CAAC;AAE7J,eAAO,MAAM,cAAc,EAAE,WAa5B,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,EAAE,gBAAgB,EAAE,MAAM,GAAG,MAAM,CA0BlH"}

package/dist/esm/rubric/leg.js

@@ -0,0 +1,138 @@
+import { givenConfig } from "../given.js";
+import { hasEnv, strictBase } from "../envRead.js";
+/** Their Partner Standard card, as published. Overridable by env at the caller. */
+export const PARTNER_STANDARD = { baseUsd: 0.3, aiRuleUsd: 0.01, photoUsd: 0.1, agentClaimUsd: 0.05 };
+/** 1 PAY = 1 USD, six decimals — the whole reason this arithmetic closes. */
+const MICRO = 1_000_000;
+/**
+ * What one ask's evaluation leg should hold.
+ *
+ * `spots` is the ask's quota: the engine decides every claim, so a quota of
+ * three is three agent-claim charges even if only one is approved.
+ */
+export function evaluationLegQuote(terms, spots = 1, price = PARTNER_STANDARD) {
+    const criteria = (terms?.criteria ?? []);
+    const aiRules = criteria.filter((one) => one?.kind === "judge").length;
+    /* A pair is two screens per spot, because the judge looks at both. */
+    const deliverableType = terms?.deliverable?.type;
+    const photos = deliverableType === "photo-pair" ? spots * 2 : deliverableType === "photo" ? spots : 0;
+    const because = [`base $${price.baseUsd.toFixed(2)}`];
+    let usd = price.baseUsd;
+    const chargedAiRules = Math.max(0, aiRules - (price.includedAiRules ?? 0));
+    if (chargedAiRules > 0) {
+        usd += chargedAiRules * price.aiRuleUsd;
+        because.push(`${chargedAiRules} AI-judged ${chargedAiRules === 1 ? "rule" : "rules"} at $${price.aiRuleUsd.toFixed(2)}`);
+    }
+    if (photos > 0) {
+        usd += photos * price.photoUsd;
+        because.push(`${photos} ${photos === 1 ? "photo" : "photos"} screened at $${price.photoUsd.toFixed(2)}`);
+    }
+    if (price.agentClaimUsd > 0) {
+        usd += spots * price.agentClaimUsd;
+        because.push(`${spots} agent ${spots === 1 ? "claim" : "claims"} at $${price.agentClaimUsd.toFixed(2)} (partner relayer)`);
+    }
+    /* Rounded up to the cent. A leg a fraction under their price is a leg that
+       invoices somebody, which is the one outcome this whole function exists to
+       avoid — so the rounding goes their way, deliberately. The inner rounding
+       is not decoration: `0.10 + 0.02` is `0.12000000000000001` in floats, and a
+       bare ceil turns that dust into a real extra cent on every ask. Genuine
+       fractions of a cent still round up; noise does not. */
+    const cents = Math.ceil(Math.round(usd * 10_000) / 100);
+    return { base: String(cents * (MICRO / 100)), usd: cents / 100, because };
+}
+/**
+ * The same quote, or a refusal naming the reason.
+ *
+ * A `uixo` board cannot fund an engine-live ask at all: at market rate the leg
+ * would have to be hundreds of IXO to reach $0.30 of their credit, and the
+ * poster would be paying a checker fee nobody asked for. Refusing is the
+ * honest answer, and it is the whole finding of the engine audit's §13.
+ */
+export function evaluationLegFor(denom, terms, spots = 1, price) {
+    if (denom !== "upay") {
+        throw new Error(`an engine-live ask must pay its evaluation leg in PAY, not ${denom}. Their FX values everything except USD-stables at market rate, so a ${denom} leg cannot cover their price`);
+    }
+    return evaluationLegQuote(terms, spots, price);
+}
+/**
+ * Our own checker's card — the evaluation leg as a priced service.
+ *
+ * The poster chooses their judge at posting time (themselves, this checker, or
+ * the ixo engine — the chain allows exactly one per claim), and the chosen
+ * judge's card prices the leg. This is ours, and its design argument is the
+ * opposite of a menu of tolls:
+ *
+ * **Everything deterministic rides in the base.** Location, weather, daylight,
+ * re-measuring a URL — these cost us arithmetic and one keyless HTTP call, and
+ * they are the product's differentiator. Priced as add-ons, posters would skip
+ * them and every answer would get worse by default. So the base *includes*
+ * them, plus the standard relevance judge, and the line items are only the
+ * things that genuinely cost per unit: extra AI-judged rules and photo
+ * screening.
+ *
+ * For comparison, read from their public card the same day this was written:
+ * theirs is $0.30 base + $0.01/AI rule + $0.10/photo + $0.05/agent claim, and
+ * their binder defers geo to a human. Same slot, richer checks, a third of the
+ * price — that is the sentence this card exists to make true.
+ */
+/* Read strictly: a mis-set variable used to become NaN, and a NaN base prices
+   every leg on the network at "NaN" — the composer's bill, the funding
+   target, the escrow the pass asks the chain for. Anything that is not a
+   whole, non-negative number of base units falls to the card's own figure. */
+/* Each price reads its variable by its literal name (`strictBase`, envRead.ts → network.ts).
+   They are getters so the card is read when it is priced, not when this
+   module loads — and so `configure({ checkerBaseUpay })` reaches it. */
+export const checkerBaseUpay = () => givenConfig().checkerBaseUpay ?? strictBase(hasEnv() ? process.env.QI_CHECKER_BASE_UPAY : undefined, 100_000);
+export const checkerAiUpay = () => givenConfig().checkerAiUpay ?? strictBase(hasEnv() ? process.env.QI_CHECKER_AI_UPAY : undefined, 10_000);
+export const checkerPhotoUpay = () => givenConfig().checkerPhotoUpay ?? strictBase(hasEnv() ? process.env.QI_CHECKER_PHOTO_UPAY : undefined, 50_000);
+export const OPENHANDS_CARD = {
+    get baseUsd() {
+        return checkerBaseUpay() / MICRO;
+    },
+    get aiRuleUsd() {
+        return checkerAiUpay() / MICRO;
+    },
+    get photoUsd() {
+        return checkerPhotoUpay() / MICRO;
+    },
+    /* We are our own relayer; nobody skims our claims. */
+    agentClaimUsd: 0,
+    includedAiRules: 1
+};
+/**
+ * What OUR checker's leg should hold for this ask, in base units of `denom`.
+ *
+ * On a PAY board the card prices it, because the card is in dollars and PAY is
+ * the only denom that honestly wears a dollar face. On anything else the flat
+ * fallback stands — pricing IXO from a USD card would need an exchange rate,
+ * and inventing one is how the engine audit's §13 mistake gets made in reverse.
+ */
+export function checkerLegBase(denom, terms, flatFallbackBase) {
+    if (denom !== "upay")
+        return flatFallbackBase;
+    /*
+     * **Never below what the checker says it will take.**
+     *
+     * The card is our estimate of the work; the checker's own minimum is a
+     * refusal. The Openhands oracle answers any evaluation leg under its floor
+     * with a 402 at register, and an ask it will not register is judged by
+     * nobody and says so to nobody — the claims simply sit.
+     *
+     * This used to return the card's quote alone and discard `flatFallbackBase`
+     * on PAY. That was harmless while the card priced above the floor. It stopped
+     * being harmless the day the floor rose to 350000: OPENHANDS_CARD reads its
+     * base from `QI_CHECKER_BASE_UPAY` through a dynamic `process.env[name]`,
+     * which Next.js does not inline, so in the browser the composer priced every
+     * ask at the 100000 default — about 130000 a leg — while displaying the
+     * oracle's live 350000 beside it. Every ask posted through the UI was
+     * refused at register.
+     *
+     * Callers already pass the checker's price as the fallback — the composer
+     * the live /v1/info minimum, the scripts CHECK_REWARD_BASE — so taking the
+     * larger of the two makes the leg honest in every runtime, whether or not
+     * the card's env reached it.
+     */
+    const quoted = Number(evaluationLegQuote(terms, 1, OPENHANDS_CARD).base);
+    return Math.max(quoted, flatFallbackBase);
+}
+//# sourceMappingURL=leg.js.map

package/dist/esm/rubric/leg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"leg.js","sourceRoot":"","sources":["../../../src/rubric/leg.ts"],"names":[],"mappings":"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"}

package/dist/esm/rubric/publish.d.ts

@@ -0,0 +1,39 @@
+import { type BridgeOptions, type FormBinding } from "./bridge.ts";
+import type { AskTerms, DoneMeans } from "./terms.ts";
+/**
+ * Putting the engine's copy of an ask's rules where its resolver can fetch it.
+ *
+ * The upload itself belongs to whoever calls this — the app has one store
+ * client and the worker another — so this owns only the part that must not
+ * vary: the same bytes are hashed and stored, and the address they end up at
+ * is the one the chain will point to.
+ *
+ * **Best effort, always.** An ask that could not publish a rubric is an ask
+ * the engine has no rules for, which is exactly what every ask was until
+ * today. An ask that fails to post because a file server was busy is a person
+ * not getting paid. The first is a missing convenience, the second is a bug.
+ * The one rubric that is *refused* rather than missed is an ask with an
+ * `attest` criterion: the poster judges those, and no oracle can.
+ */
+/** Where the bytes went. `proof` is a hex sha256 — not a CID (see `rubricDocument`). */
+export interface PublishedRubric {
+    url: string;
+    proof: string;
+}
+/** Uploads the exact bytes and answers with their public address, or null. */
+export type UploadText = (text: string, contentType: string) => Promise<{
+    url: string;
+} | null>;
+export declare function publishEngineRubric(terms: AskTerms | DoneMeans | null | undefined, binding: FormBinding | null, upload: UploadText, options?: BridgeOptions): Promise<PublishedRubric | null>;
+/** The `#rub` resource, ready for a `MsgCreateEntity`. Shape only — no SDK here. */
+export declare const engineRubricResource: (published: PublishedRubric) => {
+    type: string;
+    id: string;
+    description: string;
+    mediaType: string;
+    serviceEndpoint: string;
+    proof: string;
+    encrypted: string;
+    right: string;
+};
+//# sourceMappingURL=publish.d.ts.map

package/dist/esm/rubric/publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../../../src/rubric/publish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AACnF,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;;;;;;;;;GAcG;AAEH,wFAAwF;AACxF,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf;AAED,8EAA8E;AAC9E,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAAC;AAEhG,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,GAAG,IAAI,GAAG,SAAS,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAYvM;AAED,oFAAoF;AACpF,eAAO,MAAM,oBAAoB,GAAI,WAAW,eAAe;;;;;;;;;CAW7D,CAAC"}

package/dist/esm/rubric/publish.js

@@ -0,0 +1,29 @@
+import { rubricDocument } from "./bridge.js";
+export async function publishEngineRubric(terms, binding, upload, options = {}) {
+    /* No terms, or no published claim form to bind them to, means there is
+       nothing true to say — so nothing is said. */
+    if (!terms || !binding?.protocol || !binding?.proof)
+        return null;
+    try {
+        const { text, proof } = await rubricDocument(terms, binding, options);
+        const stored = await upload(text, "application/ld+json");
+        return stored ? { url: stored.url, proof } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The `#rub` resource, ready for a `MsgCreateEntity`. Shape only — no SDK here. */
+export const engineRubricResource = (published) => ({
+    type: "rubric",
+    id: "{id}#rub",
+    description: "The same terms, in the evals-engine's rubric format",
+    mediaType: "application/ld+json",
+    serviceEndpoint: published.url,
+    /* Hex sha256 of the exact stored bytes — their resolver recomputes it and
+       fails closed on a mismatch. */
+    proof: published.proof,
+    encrypted: "false",
+    right: ""
+});
+//# sourceMappingURL=publish.js.map

package/dist/esm/rubric/publish.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.js","sourceRoot":"","sources":["../../../src/rubric/publish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAwC,MAAM,aAAa,CAAC;AA4BnF,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,KAA8C,EAAE,OAA2B,EAAE,MAAkB,EAAE,UAAyB,EAAE;IACpK;mDAC+C;IAC/C,IAAI,CAAC,KAAK,IAAI,CAAC,OAAO,EAAE,QAAQ,IAAI,CAAC,OAAO,EAAE,KAAK;QAAE,OAAO,IAAI,CAAC;IAEjE,IAAI,CAAC;QACH,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QACtE,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC;QACzD,OAAO,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IACpD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,oFAAoF;AACpF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,SAA0B,EAAE,EAAE,CAAC,CAAC;IACnE,IAAI,EAAE,QAAQ;IACd,EAAE,EAAE,UAAU;IACd,WAAW,EAAE,qDAAqD;IAClE,SAAS,EAAE,qBAAqB;IAChC,eAAe,EAAE,SAAS,CAAC,GAAG;IAC9B;qCACiC;IACjC,KAAK,EAAE,SAAS,CAAC,KAAK;IACtB,SAAS,EAAE,OAAO;IAClB,KAAK,EAAE,EAAE;CACV,CAAC,CAAC"}

package/dist/esm/rubric/reanchor.d.ts

@@ -0,0 +1,79 @@
+import type { EngineRubric } from "./bridge.ts";
+/**
+ * The pure half of re-anchoring an ask's `#rub` (`scripts/reanchor-rubric.ts`).
+ *
+ * An ask's rubric is hashed into its entity at posting, and the only way a
+ * live ask ever reads a newer bridge is for its owner to swap that one linked
+ * resource. Two questions decide whether a swap is safe, and both are answered
+ * here without a network: WHICH resource is the ask's rubric, exactly as the
+ * chain stores its id, and WHAT the swap would change about how a claim is
+ * judged.
+ */
+export interface StoredResource {
+    id: string;
+    type?: string;
+    proof?: string;
+    serviceEndpoint?: string;
+    mediaType?: string;
+    description?: string;
+    encrypted?: string;
+    right?: string;
+}
+/**
+ * The one resource on an entity that answers to a fragment, with its id AS
+ * STORED.
+ *
+ * The chain keeps whatever id the entity was minted with: the literal
+ * `{id}#rub` on every ask this estate posted, the expanded `did:…#rub` on an
+ * entity somebody else's tooling made. `MsgDeleteLinkedResource` matches the
+ * stored string exactly, so the id is read and carried, never rebuilt. Two
+ * resources answering to one fragment is an entity nobody should guess about.
+ */
+export declare function resourceByFragment<T extends StoredResource>(resources: readonly T[] | null | undefined, entityDid: string, fragment: string): T | null;
+export interface NamedDiff {
+    added: string[];
+    removed: string[];
+    /** Same name, different body — a source whose `send` moved, a judge whose instructions were reworded. */
+    changed: string[];
+    unchanged: string[];
+}
+export interface GateDiff extends NamedDiff {
+    /** Same code and same rule, different `reason` text only. Harmless to a decision. */
+    reworded: string[];
+    /** Codes both rubrics carry whose order relative to each other differs. The first failed gate is terminal, so order is meaning. */
+    reordered: string[];
+}
+export interface RubricDiff {
+    sources: NamedDiff;
+    aiChecks: NamedDiff;
+    gates: GateDiff;
+    /** The form binding and the duplicate rule, which a re-anchor must never touch. */
+    claimSchemaSame: boolean;
+    uniqueSame: boolean;
+    /** Why this swap must not be signed. Empty means it may. */
+    refusals: string[];
+}
+/**
+ * What swapping `before` for `after` changes.
+ *
+ * **Existing gate codes must not move.** A code is what a decision already on
+ * the ledger names as its reason, what the app's refusal screens are keyed by,
+ * and what the oracle's receipts quote; a re-anchor that renumbered `OH-103`
+ * would make yesterday's refusals point at today's different rule. So a code
+ * the old rubric carries must still be there, read the same fact, fail the same
+ * way, and sit in the same order relative to the other old codes. New codes may
+ * appear anywhere.
+ */
+export declare function diffRubric(before: EngineRubric, after: EngineRubric): RubricDiff;
+/**
+ * Where two bodies of the same name differ: the top-level keys, and for a list
+ * the positions — `instructions[0]` is the guidance every judge shares,
+ * `instructions[1]` would be the poster's own sentence, and which of the two
+ * moved is the whole question a person reading the diff has.
+ */
+export declare function whereChanged(before: object, after: object): string[];
+/** True when the swap would change nothing a decision reads — the bytes may still differ (a title, key order). */
+export declare const sameRules: (diff: RubricDiff) => boolean;
+/** The diff as a person reads it in a terminal. */
+export declare function describeDiff(diff: RubricDiff): string[];
+//# sourceMappingURL=reanchor.d.ts.map

package/dist/esm/rubric/reanchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reanchor.d.ts","sourceRoot":"","sources":["../../../src/rubric/reanchor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;GASG;AAEH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,cAAc,EAAE,SAAS,EAAE,SAAS,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,CAMtJ;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,yGAAyG;IACzG,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,QAAS,SAAQ,SAAS;IACzC,qFAAqF;IACrF,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,mIAAmI;IACnI,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,SAAS,CAAC;IACnB,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,EAAE,QAAQ,CAAC;IAChB,mFAAmF;IACnF,eAAe,EAAE,OAAO,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;IACpB,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAuBD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,UAAU,CAqChF;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAapE;AAED,kHAAkH;AAClH,eAAO,MAAM,SAAS,GAAI,MAAM,UAAU,KAAG,OAGX,CAAC;AAInC,mDAAmD;AACnD,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CAkBvD"}