@ixo/openhands-sdk 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,428 @@
+import { type AskTerms, type DoneMeans } from "./terms.ts";
+/**
+ * Our terms, said in the decision engine's language.
+ *
+ * The same contract twice: `AskTerms` is what a poster agreed to; this is
+ * that document translated into the rubric envelope the engine reads. Both
+ * are anchored on the ask's entity — ours at `{id}#done`, theirs at
+ * `{id}#rub` — so anyone can check that the two agree, which is the point of
+ * publishing both.
+ *
+ * **Every rule is a machine's rule, and no rule is dropped.** There is no
+ * person in this loop (plan D6). A rule the engine performs natively —
+ * presence, length, a pattern, an attachment's type or size — is written as
+ * one of its own conditions. Every other rule is written as an
+ * `ExternalSource` (plan D4): a *name* plus the rule's parameters, answered
+ * in-process by the Openhands oracle, which is the only thing that ever acts
+ * on it. The engine only needs the source declared so that a gate can read
+ * `ext.<name>.valid`. The names and the `send` keys are a contract with the
+ * oracle, exact to the letter: `openhands-oracle` `facts-contract.md`, mirrored
+ * in `SOURCE_NAMES` and `SEND_KEYS` below and asserted by `bridge.test.ts`.
+ *
+ * Three of their rules shape everything here:
+ *
+ * - **Operators are typed.** `matches` and `lengthBetween` are for text,
+ *   `mediaTypeIn` and `maxSizeMB` for a file question, `isTrue` for a
+ *   boolean — which is what an `ext.<name>.valid` reads as. Using the wrong
+ *   one does not fail here — their binder marks the whole rubric unusable,
+ *   later, on their server. `bridge.test.ts` runs their binder.
+ * - **`when` is what must hold.** A gate whose condition is false fires
+ *   `onFail`. Ours all say `reject` — the rules the terms spell out and the
+ *   ones the bridge adds of its own accord alike. No gate asks for a person:
+ *   nobody is shown a held claim (there is no review screen, and the campaign
+ *   poster is a key with nobody behind it), so a `review` verdict would leave
+ *   the claimant waiting for ever. The same holds for the *outage* path —
+ *   a source or an AI check that could not answer at all: it says
+ *   `onError: "reject"` (`ON_ERROR`), never `review`.
+ * - **The document cannot carry its own id.** Identity is the hash of the
+ *   exact bytes, so the caller serializes once and hashes what it uploads.
+ */
+/** Which claim form the rules were written against — the form's entity and its proof. */
+export interface FormBinding {
+    protocol: string;
+    proof: string;
+}
+/** What the translation needs to know beyond the terms themselves. */
+export interface BridgeOptions {
+    /**
+     * The cool-off rule the checker used to apply to every cleanup: nothing
+     * paid within `meters` in the last `days` gets paid again. It is emitted as
+     * the `cooldown` source on ordinary cleanups. `null` turns it off.
+     */
+    cooldown?: {
+        meters: number;
+        days: number;
+    } | null;
+}
+/**
+ * What every source and AI check says when it could not answer at all.
+ *
+ * Not `review`. The engine turns an errored fact with `onError: "review"`
+ * into verdict `review` — chain status 5, nothing signed until somebody
+ * looks — and nobody ever looks: there is no review screen, and the
+ * campaign's poster is a key with nobody behind it. A mainnet claim in
+ * collection 8253 sat exactly there, held for ever, because one oracle fact
+ * errored. `reject` is still never an approval (the engine lets an errored
+ * `reject` beat any other verdict), and a refused claimant reads that the
+ * check was unreachable and can submit again; a held one reads nothing.
+ */
+export declare const ON_ERROR: "reject";
+/** The checker's own defaults (`services/worker-agent/src/config.ts`), carried over unchanged. */
+export declare const DEFAULT_COOLDOWN: {
+    readonly meters: 150;
+    readonly days: 7;
+};
+/**
+ * The name every source is declared under.
+ *
+ * The rubric format requires an `endpoint` and a `did:web` `audience` on
+ * every source, and hashes both into the rubric's id. Nothing ever calls
+ * them: the oracle answers by *name*, in-process. So they are one constant,
+ * agreed with the oracle, on a reserved domain that can never resolve.
+ */
+export declare const ORACLE_HOST = "oracle.openhands.invalid";
+/**
+ * The document as bytes, and the name those bytes answer to.
+ *
+ * Their resolver fetches whatever the chain points at and requires
+ * `hex(sha256(the exact bytes served)) === the on-chain proof`, so the text
+ * returned here is the text that must be uploaded — hashing one serialization
+ * and uploading another is the one mistake that cannot be caught by reading
+ * the code.
+ *
+ * **Not a CID.** Our claim ids and terms are CIDv1, and the `#vct` proof is
+ * one too, but a rubric's proof is a bare hex sha256. Two conventions live on
+ * one entity because each side's reader demands its own.
+ */
+export declare function rubricDocument(terms: AskTerms | DoneMeans, binding: FormBinding, options?: BridgeOptions): Promise<{
+    text: string;
+    proof: string;
+}>;
+export interface Translation {
+    /** The document to publish. Serialize ONCE; its bytes are its identity. */
+    envelope: EngineRubric;
+}
+type Condition = Record<string, unknown>;
+/**
+ * What a `send` map may carry: a `$ref` or `ctx.*` string, or a literal
+ * string, number or boolean. Never a list or an object — their schema stops
+ * at scalars — so a point list or a box travels as one JSON string.
+ */
+type SendValue = string | number | boolean;
+export interface EngineGate {
+    "@type": "Gate";
+    code: string;
+    reason?: string;
+    /**
+     * When this is false the gate is **skipped** — neither passed nor failed
+     * (their §A.6). It is how one rubric serves two kinds of claim: a rule
+     * written for a patch is not asked of the site shot rather than failing
+     * against it.
+     */
+    appliesWhen?: Condition;
+    when: Condition;
+    onFail?: "reject" | "review";
+    class: "refuted" | "invalid_evidence" | "out_of_authority" | "insufficient_evidence" | "requires_human_review";
+}
+export interface EngineSource {
+    "@type": "ExternalSource";
+    name: string;
+    endpoint: string;
+    audience: string;
+    send: Record<string, SendValue>;
+    expect: "boolean";
+    onError: "review" | "reject";
+    timeoutMs: number;
+}
+export interface EngineAiCheck {
+    "@type": "AiCheck";
+    name: string;
+    send: Record<string, SendValue>;
+    instructions: string[];
+    expect: "boolean";
+    onError?: "review" | "reject";
+}
+export interface EngineUnique {
+    "@type": "Unique";
+    id: string;
+    by: string[];
+    countPrior: ("approved" | "pending_review" | "queued")[];
+    attachments: boolean;
+    ai: {
+        enabled: boolean;
+    };
+    thresholds: {
+        rejectAtBps: number;
+        reviewAtBps: number;
+    };
+}
+export interface EngineRubric {
+    "@context": {
+        ixo: "https://w3id.org/ixo/ns/protocol/";
+        "@id": "@type";
+        type: "@type";
+        "@protected": true;
+    };
+    type: "ixo:entity#rubric";
+    rubric: {
+        "@type": "Rubric";
+        title?: string;
+        claimSchema: {
+            "@type": "ClaimSchemaBinding";
+            protocol: string;
+            resource: "#vct";
+            proof: string;
+        };
+        sources?: EngineSource[];
+        aiChecks?: EngineAiCheck[];
+        unique?: EngineUnique;
+        gates: EngineGate[];
+    };
+}
+/**
+ * The names the oracle answers to, per gate. Exact: the oracle registers a
+ * handler per name (and per suffix, 2..5, for a rule that repeats within one
+ * rubric) and an unknown name falls through to the package's stock lanes,
+ * which know none of these.
+ */
+export declare const SOURCE_NAMES: {
+    readonly "within-radius": "withinRadius";
+    readonly located: "located";
+    readonly "before-after": "beforeAfter";
+    readonly "daylight-consistent": "daylight";
+    readonly "weather-consistent": "weather";
+    readonly "not-already-mapped": "notAlreadyMapped";
+    readonly "re-measure": "reMeasure";
+    readonly "at-registered-point": "atPoint";
+    readonly "mapped-grid": "mappedGrid";
+};
+/** The cool-off source, emitted from the options rather than from a gate. */
+export declare const COOLDOWN_SOURCE = "cooldown";
+/** The marker source on a site ask, so the claim's `kind` is frozen on the receipt for the oracle's act policy. */
+export declare const SITE_SOURCE = "openhandsSite";
+/** The AI check, per judge criterion: `judge`, then `judge2..`. */
+export declare const JUDGE_NAME = "judge";
+/**
+ * Whether the photograph is evidence at all — asked of every photograph ask,
+ * by the bridge, whatever the terms say.
+ *
+ * **What bought it (mainnet, collections 8253 and 8231, September 2026).** An
+ * AI-generated square of an Italian piazza, reported as Giza, with a garbled
+ * burned-in timestamp and "Made with Google AI" in its own IPTC — approved,
+ * the judges at 98 and 99. One wallet photographing a computer monitor that
+ * was showing litter — moiré, a share icon, a mouse cursor in frame — approved
+ * five times, a cleanup's before and after shot fourteen seconds apart off the
+ * same screen among them. Paper balls on a tiled floor and a wrapper on
+ * somebody's carpet, approved as mapped messes. Every judge was right about
+ * the sentence it was given: the picture did show waste, the size was about a
+ * bagful, nobody's face was in it. No rule asked whether the picture was a
+ * photograph, and `JUDGE_GUIDANCE` told each judge that anything else wrong
+ * with the claim was not its to judge.
+ *
+ * Two facts the oracle reads off the file's own bytes, and one sentence a
+ * model rules on. They are rules "every ask of the shape carries" — like the
+ * cool-off and the duplicate rule — rather than criteria in the terms, for
+ * the reason those are: an ask already posted has its terms frozen, and a
+ * fake photograph is not something a poster should have to remember to
+ * forbid. `#rub` therefore says more than `#done` does, as it already did.
+ *
+ * Three refusals, all `invalid_evidence`:
+ *
+ * - `notMarkedGenerated` — the file itself (IPTC, XMP, trusted Content
+ *   Credentials) says a generator made it. That is the file's own confession.
+ * - the authenticity judge (`realPhotoRule`) — the picture is of a screen, a
+ *   print or a generator's work, or, where the ask is about waste on the
+ *   ground, of somebody's floor.
+ * - `notElsewhere` — the photograph's EXIF GPS is farther than `meters` from
+ *   the point the claim reported. A camera's last fix can be stale and a
+ *   browser's point can come from a cell tower, which is what the width of
+ *   `NOT_ELSEWHERE_FLOOR_METERS` is for: it forgives the instruments, so what
+ *   is left to refuse is another town.
+ *
+ * **None of them holds a claim for a person, because there is no person.**
+ * `onFail: "review"` would give a claim verdict `review` — chain status 5,
+ * nothing signed until somebody looks — and nobody ever looks: there is no review screen, and the campaign's poster
+ * is a key with nobody behind it. A claimant who is refused reads why and can
+ * go and take the photograph again; one who is held reads nothing and waits
+ * for ever. So a screen that cannot be made wide enough to refuse on is not
+ * written at all, and each refusal's `reason` says what to do about it.
+ */
+export declare const PHOTO_CHECKS: {
+    readonly notMarkedGenerated: "notMarkedGenerated";
+    readonly notElsewhere: "notElsewhere";
+};
+/**
+ * How far a photograph's own GPS may sit from the point the claim reported.
+ *
+ * Not the place rule — `within-radius` is that, and it stays as tight as the
+ * poster made it. This compares two readings of the SAME moment that come
+ * from different instruments: the camera's EXIF fix, which can be minutes
+ * stale, and the browser's geolocation (`nowAndHere`), which falls back to
+ * wifi and cell towers when no satellite fix arrives inside its eight
+ * seconds. The two honestly differ by hundreds of metres. This is meant to
+ * catch another city, not another street, so an ask's own radius is used only
+ * when it is WIDER than this — a 150 m cleanup radius would refuse honest
+ * phones all day.
+ */
+export declare const NOT_ELSEWHERE_FLOOR_METERS = 1000;
+/**
+ * The contract's ceiling on one name within one rubric: bare, then `2..5`.
+ *
+ * For an `ext` name it is a wall: the oracle registers exactly those handlers,
+ * and a sixth falls through to the stock lane and is POSTed to a host that can
+ * never resolve. The photograph screens are asked once per photograph and no
+ * claim carries more than two, so they sit under it by construction. For
+ * `judge` it is the contract's word rather than a wall — the stock judge
+ * answers whatever name a rubric declares — and the one judge the bridge adds
+ * of its own accord keeps to it: see where it is emitted.
+ */
+export declare const NAME_CEILING = 5;
+/** The one duplicate rule every photo ask carries. */
+export declare const UNIQUE_RULE_ID = "OH-DUP-1";
+/**
+ * The `send` keys per name, in the order they are written — the contract's
+ * table, verbatim. `bridge.test.ts` asserts the emitted keys against this,
+ * and the oracle's tests assert its handlers against the same document.
+ *
+ * `judge` is the *plain photo* row. An AI check sends what the ask's shape
+ * actually carries, which is more than one photograph on a pair —
+ * `JUDGE_SEND_KEYS` below is that table, and the one `bridge.test.ts` checks
+ * a pair and a site against.
+ */
+export declare const SEND_KEYS: Record<string, readonly string[]>;
+/**
+ * What a judge is sent, per ask shape — the fix for the 1149 patch rejections.
+ *
+ * A patch claim on a site carries four files: the before, the after (which is
+ * also `$photo`), and the bags in `$extraFile`. Sending only `$photo` handed
+ * the model ONE image and asked it whether two photographs showed the same
+ * place — it answered, correctly, that it could not compare one photograph,
+ * and every honest patch was refused. So a pair ask sends the pair, an ask
+ * that expects a second file sends it as `bags`, and a site also says which
+ * `kind` of claim arrived, because the two kinds carry different evidence.
+ *
+ * The keys are the contract's (`facts-contract.md`, amended 2026-09-16), and
+ * the engine's own AI lane forwards every attachment a `send` names as its own
+ * labelled input — a file it cannot read arrives as a descriptor rather than
+ * vanishing (evaluator spec §6.1).
+ */
+export declare const JUDGE_SEND_KEYS: Record<string, readonly string[]>;
+/**
+ * The sentence every judge on a site ask is told first.
+ *
+ * One rubric serves both kinds of claim (the chain allows exactly one), so a
+ * criterion written for a patch is also read against the site photograph and
+ * the other way round. Without this the site judge read "before, after and the
+ * bags" as a rule the wide shot had broken. It says what each kind carries and
+ * that only the kind in front of the model is being ruled on; `$kind` in the
+ * send map is where the model learns which one that is.
+ */
+export declare const SITE_KIND_PREAMBLE = "A claim of kind \"patch\" carries a before photograph, an after photograph and a photograph of the bags; a claim of kind \"site\" carries one wide photograph of the whole area. Rule only on what this claim's kind carries.";
+/**
+ * What every judge is told before the sentence it is ruling on.
+ *
+ * **The wrapper this sits inside is strict on purpose, and that is the
+ * problem.** The oracle's own prompt ends "Do not give benefit of the doubt.
+ * If a rule requires something and you cannot find it, that rule FAILS." That
+ * is the right posture for a rule about a fact and the wrong one for a
+ * judgement of degree: "the photograph supports the amount claimed" gets read
+ * as "prove the amount", and an honest phone photograph of a real pile proves
+ * nothing to that standard. Ask 43910 refused six of six real claims on
+ * testnet, one of them with nothing whatever wrong with it. This paragraph
+ * says what the evidence actually is — a phone, outdoors, one go — and which
+ * way doubt falls, so a rule of degree is read as one.
+ *
+ * **It cannot live in `criterion.text`, twice over.** That field is cut to 300
+ * characters by `parseTerms`, so a paragraph in it would arrive on the model's
+ * wire with its end chopped off; and `toEngineRubric` copies it verbatim into
+ * the reject gate's `reason`, which is the sentence a refused worker reads. A
+ * lecture on how to judge is not an explanation of why somebody was not paid.
+ * `instructions` is neither of those things: it is not part of the frozen
+ * terms, so it is not hashed on chain, and no worker ever sees it.
+ *
+ * **Its second half is about the refusal, not the verdict.** The model's own
+ * `reason` is the only per-claim explanation that ever reaches the person who
+ * did the work, and left to itself the model writes it to an auditor: "it
+ * therefore does not support the reported trailer-sized amount". Somebody who
+ * walked to a ditch and photographed it is owed a sentence they can act on —
+ * what was seen, what fell short, what would have been enough.
+ *
+ * The order of the last two matters. "Never list it as a failed rule" stays
+ * the final sentence, because that is the one protecting the verdict, and the
+ * instruction nearest the end is the one a model is least likely to drop.
+ *
+ * Validated by replaying 18 real claims — the real photographs, the real
+ * prompt: it was never once reported as a failed rule, and the verdicts moved
+ * from 13 of 18 to 16 of 18 agreeing with what a person would have decided.
+ *
+ * **Amended 2026-09-21, two clauses, after the fakes on 8253 and 8231**
+ * (`PHOTO_CHECKS` has the incident). Both were added, nothing was taken out,
+ * and neither has been replayed yet — the 18-claim replay above is of the
+ * paragraph before them, so replay before this is anchored on a live ask.
+ *
+ * - After "still evidence, so rule on what you can see in it": *"That is
+ *   about how well an honest photograph came out, never about what was
+ *   photographed: a picture of a screen, a print or another photograph does
+ *   not become evidence by being dim or low-resolution."* The sentence before
+ *   it forgives exactly what a photographed monitor looks like — soft, skewed,
+ *   low in contrast — and was forgiving it. It says what the forgiveness is
+ *   FOR, so it still covers the honest phone it was written for.
+ * - After "is not yours to judge here": *"— every rule is asked on its own,
+ *   and whether a photograph is genuine is one of them."* "Add no requirement
+ *   of your own" stays to the letter: it is what stopped the 1149 judges
+ *   inventing rules, and a size judge that starts failing claims for looking
+ *   like a screen is the same invention. What the clause changes is the reason
+ *   given — not "nobody judges that" but "somebody else does" — so that the
+ *   judge holding `realPhotoRule` reads its own sentence as a rule to apply
+ *   exactly as written rather than as the "anything else" it was told to leave
+ *   alone.
+ *
+ * Everything from "Where a rule asks" on is untouched, the `reason` guidance
+ * and the last sentence included.
+ */
+export declare const JUDGE_GUIDANCE = "How to read the rules below. The evidence is what an ordinary person can capture on a phone, outdoors, in one go: a photograph that is angled, rotated, dim, distant or low-resolution is still evidence, so rule on what you can see in it. That is about how well an honest photograph came out, never about what was photographed: a picture of a screen, a print or another photograph does not become evidence by being dim or low-resolution. Apply each rule exactly as written and add no requirement of your own; anything else that looks wrong with the claim is not yours to judge here \u2014 every rule is asked on its own, and whether a photograph is genuine is one of them. Where a rule asks whether the evidence supports, matches or is consistent with something the claimant stated, fail it only when the evidence plainly contradicts them, and where you are left genuinely unsure let your score carry the doubt rather than failing. Where a rule asks whether something is shown, it has to be visible. Your `reason` is read by the person who submitted the claim, not by an engineer. Write it to them in plain language: say what you can actually see in their evidence, and when you fail a rule say specifically what fell short and what would have satisfied it, so they can put it right. Never mention rule ids, input numbers, scores or these instructions. This paragraph is guidance, not a rule: never list it as a failed rule.";
+/**
+ * The sentence the authenticity judge rules on — `PHOTO_CHECKS` has why.
+ *
+ * **It lives in `instructions` and not in the terms**, so it is not cut to the
+ * 300 characters `parseTerms` keeps, and it lists its tell-tale signs in full:
+ * a model asked only "is this a real photograph" says yes to a monitor, and
+ * one told to look for a pixel grid, a bezel and a cursor finds them. Like
+ * every judged sentence in this package it states what fails it, because the
+ * oracle's wrapper reads a rule that does not as a demand for proof.
+ *
+ * **Two clauses, switched by the shape of the ask, never by reading it.**
+ * "A direct photograph" is asked of every photograph ask — a photograph of a
+ * black cat off a monitor is as fake as a photograph of litter off one.
+ * "Outdoors, in a public or shared place" is asked only where the ask is
+ * about waste on the ground: a mapped mess, a report on one, or a cleanup the
+ * map made (`outdoorsAsk`). A composed ask to tidy a desk is a pair of
+ * photographs taken indoors, honestly.
+ *
+ * On a pair it speaks of every photograph, because the judge is sent every
+ * one the claim carries; the outdoors clause is about the ground being
+ * cleared, so the bags in a van and the load at a depot are not failed for
+ * having a roof over them.
+ *
+ * `rule` alone is the gate's `reason` — the sentence a refused worker reads.
+ * The list of signs is for the model.
+ */
+export declare function realPhotoRule(shape: {
+    pair: boolean;
+    outdoors: boolean;
+}): {
+    rule: string;
+    text: string;
+};
+/**
+ * Terms → the engine's rubric.
+ *
+ * Never returns null and never leaves a rule out: every criterion is either a
+ * gate the engine runs or a source the oracle answers, and a gate that reads
+ * it. The judge criteria become AI checks; an `attest` criterion is refused
+ * (a term whose judge is the poster cannot be served by an oracle at all —
+ * `servableByOracle` says so before an ask is posted).
+ */
+export declare function toEngineRubric(terms: AskTerms | DoneMeans, binding: FormBinding, options?: BridgeOptions): Translation;
+export {};
+//# sourceMappingURL=bridge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../../../src/rubric/bridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuC,KAAK,QAAQ,EAAkB,KAAK,SAAS,EAAa,MAAM,YAAY,CAAC;AAE3H;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,yFAAyF;AACzF,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,sEAAsE;AACtE,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CACpD;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,EAAG,QAAiB,CAAC;AAE1C,kGAAkG;AAClG,eAAO,MAAM,gBAAgB;;;CAAoC,CAAC;AAElE;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,6BAA6B,CAAC;AAEtD;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAM7J;AAED,MAAM,WAAW,WAAW;IAC1B,2EAA2E;IAC3E,QAAQ,EAAE,YAAY,CAAC;CACxB;AAMD,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEzC;;;;GAIG;AACH,KAAK,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3C,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,SAAS,CAAC;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC7B,KAAK,EAAE,SAAS,GAAG,kBAAkB,GAAG,kBAAkB,GAAG,uBAAuB,GAAG,uBAAuB,CAAC;CAChH;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,gBAAgB,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAChC,MAAM,EAAE,SAAS,CAAC;IAClB,OAAO,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,SAAS,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAChC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,MAAM,EAAE,SAAS,CAAC;IAClB,OAAO,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CAC/B;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,QAAQ,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,UAAU,EAAE,CAAC,UAAU,GAAG,gBAAgB,GAAG,QAAQ,CAAC,EAAE,CAAC;IACzD,WAAW,EAAE,OAAO,CAAC;IACrB,EAAE,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IACzB,UAAU,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1D;AAED,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE;QAAE,GAAG,EAAE,mCAAmC,CAAC;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC;QAAC,YAAY,EAAE,IAAI,CAAA;KAAE,CAAC;IAC5G,IAAI,EAAE,mBAAmB,CAAC;IAC1B,MAAM,EAAE;QACN,OAAO,EAAE,QAAQ,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,WAAW,EAAE;YAAE,OAAO,EAAE,oBAAoB,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC;QAClG,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;QACzB,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;QAC3B,MAAM,CAAC,EAAE,YAAY,CAAC;QACtB,KAAK,EAAE,UAAU,EAAE,CAAC;KACrB,CAAC;CACH;AAID;;;;;GAKG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;CAUf,CAAC;AAEX,6EAA6E;AAC7E,eAAO,MAAM,eAAe,aAAa,CAAC;AAC1C,mHAAmH;AACnH,eAAO,MAAM,WAAW,kBAAkB,CAAC;AAC3C,mEAAmE;AACnE,eAAO,MAAM,UAAU,UAAU,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,YAAY;;;CAGf,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,sDAAsD;AACtD,eAAO,MAAM,cAAc,aAAa,CAAC;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAevD,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAM7D,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,kOAC+L,CAAC;AAE/N;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,eAAO,MAAM,cAAc,m5CACk3C,CAAC;AAE94C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAczG;AAsUD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,GAAE,aAAkB,GAAG,WAAW,CAqV1H"}