@ixo/openhands-sdk 0.0.0-stage → 0.1.0

package/dist/cjs/rubric/claimForm.d.ts

@@ -0,0 +1,142 @@
+/**
+ * What an Openhands claim looks like, declared once for the whole network.
+ *
+ * The evals-engine binds every rule to a form and refuses rules that mention a
+ * field the form never declared — not leniently, the whole rubric goes
+ * unusable. So this is the contract that makes our terms machine-checkable by
+ * anyone, and it has to describe what our claims *actually* contain.
+ *
+ * It is a **path manifest**, which is the engine's own name for this: a
+ * SurveyJS-shaped document whose question names are paths into a stored JSON
+ * body rather than answers to a questionnaire (their `catalog.ts`). Nobody
+ * fills this in. Two things write our claim bodies —
+ * `app/submit/[id]/page.tsx` (a person handing over work) and
+ * `services/worker-agent/src/proof.ts` (an agent sealing its own) — and the
+ * fields below are the union of both, so one form covers both species.
+ *
+ * **The kinds are load-bearing.** The engine's binder checks operator legality
+ * against them (`bind.ts` `OPERATOR_KINDS`): `lengthBetween` only applies to
+ * `text`, `containsAll` only to `multichoice`, and so on. Getting a kind wrong
+ * here does not fail here — it fails later, as an unusable rubric, on somebody
+ * else's server. `file` is declared `text` on purpose: our claims carry a CID
+ * *string* pointing at a stored object, not a SurveyJS upload, and the
+ * engine's resolver lane resolves no attachments at all. The `file`-kind
+ * questions (`photo` and its siblings, v3) are the same objects again as
+ * SurveyJS file answers, which is the shape an oracle's attachment tools do
+ * read.
+ *
+ * **Changing this document changes its CID**, which is the proof every rubric
+ * pins in `claimSchema.proof` — so an edit here silently unbinds every rubric
+ * published before it (the engine calls that form drift and fails closed).
+ * Add fields; do not rename or remove them.
+ */
+/**
+ * The `alsoKnownAs` the publishing script finds the entity by.
+ *
+ * **The version lives in the name, and that is the whole migration story.**
+ * A rubric pins this form's bytes by their hash, so editing the document
+ * below would not update the form — it would silently unbind every rubric
+ * published against it (their binder calls that form drift and fails closed).
+ * A new field therefore means a new name, a new entity, and new asks binding
+ * to it while old asks keep resolving the old one, untouched, forever.
+ */
+export declare const FORM_NAME = "Openhands claim form v3";
+export declare const CLAIM_FORM: {
+    readonly "@context": {
+        readonly ixo: "https://w3id.org/ixo/ns/protocol/";
+    };
+    readonly type: "ixo:entity#surveyTemplate";
+    readonly question: {
+        readonly pages: readonly [{
+            readonly elements: readonly [{
+                readonly type: "comment";
+                readonly name: "deliverable";
+                readonly title: "The work handed over";
+                readonly isRequired: true;
+            }, {
+                readonly type: "text";
+                readonly name: "task";
+                readonly title: "The ask this answers";
+            }, {
+                readonly type: "text";
+                readonly name: "file";
+                readonly title: "Attached file (content address)";
+            }, {
+                readonly type: "text";
+                readonly name: "mediaType";
+                readonly title: "What kind of file it is";
+            }, {
+                readonly type: "text";
+                readonly name: "submitter";
+                readonly title: "Who handed it over";
+            }, {
+                readonly type: "text";
+                readonly name: "worker";
+                readonly title: "Which agent produced it";
+            }, {
+                readonly type: "text";
+                readonly inputType: "datetime-local";
+                readonly name: "ts";
+                readonly title: "When it was sealed";
+            }, {
+                readonly type: "text";
+                readonly name: "collectionId";
+                readonly title: "The ask's collection id";
+            }, {
+                readonly type: "text";
+                readonly inputType: "number";
+                readonly name: "v";
+                readonly title: "Envelope version";
+            }, {
+                readonly type: "text";
+                readonly inputType: "number";
+                readonly name: "location.lat";
+                readonly title: "Reported latitude";
+            }, {
+                readonly type: "text";
+                readonly inputType: "number";
+                readonly name: "location.lon";
+                readonly title: "Reported longitude";
+            }, {
+                readonly type: "text";
+                readonly inputType: "number";
+                readonly name: "location.accuracyMeters";
+                readonly title: "Reported accuracy in metres";
+            }, {
+                readonly type: "text";
+                readonly inputType: "datetime-local";
+                readonly name: "location.at";
+                readonly title: "When the location was taken";
+            }, {
+                readonly type: "file";
+                readonly name: "photo";
+                readonly title: "The photograph";
+                readonly storeDataAsText: false;
+                readonly allowMultiple: false;
+            }, {
+                readonly type: "file";
+                readonly name: "beforePhoto";
+                readonly title: "Before the work";
+                readonly storeDataAsText: false;
+                readonly allowMultiple: false;
+            }, {
+                readonly type: "file";
+                readonly name: "afterPhoto";
+                readonly title: "After the work";
+                readonly storeDataAsText: false;
+                readonly allowMultiple: false;
+            }, {
+                readonly type: "file";
+                readonly name: "extraFile";
+                readonly title: "The second file";
+                readonly storeDataAsText: false;
+                readonly allowMultiple: false;
+            }, {
+                readonly type: "text";
+                readonly name: "kind";
+                readonly title: "What kind of claim this is";
+            }];
+        }];
+    };
+};
+//# sourceMappingURL=claimForm.d.ts.map

package/dist/cjs/rubric/claimForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claimForm.d.ts","sourceRoot":"","sources":["../../../src/rubric/claimForm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,4BAA4B,CAAC;AAEnD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEb,CAAC"}

package/dist/cjs/rubric/claimForm.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * What an Openhands claim looks like, declared once for the whole network.
+ *
+ * The evals-engine binds every rule to a form and refuses rules that mention a
+ * field the form never declared — not leniently, the whole rubric goes
+ * unusable. So this is the contract that makes our terms machine-checkable by
+ * anyone, and it has to describe what our claims *actually* contain.
+ *
+ * It is a **path manifest**, which is the engine's own name for this: a
+ * SurveyJS-shaped document whose question names are paths into a stored JSON
+ * body rather than answers to a questionnaire (their `catalog.ts`). Nobody
+ * fills this in. Two things write our claim bodies —
+ * `app/submit/[id]/page.tsx` (a person handing over work) and
+ * `services/worker-agent/src/proof.ts` (an agent sealing its own) — and the
+ * fields below are the union of both, so one form covers both species.
+ *
+ * **The kinds are load-bearing.** The engine's binder checks operator legality
+ * against them (`bind.ts` `OPERATOR_KINDS`): `lengthBetween` only applies to
+ * `text`, `containsAll` only to `multichoice`, and so on. Getting a kind wrong
+ * here does not fail here — it fails later, as an unusable rubric, on somebody
+ * else's server. `file` is declared `text` on purpose: our claims carry a CID
+ * *string* pointing at a stored object, not a SurveyJS upload, and the
+ * engine's resolver lane resolves no attachments at all. The `file`-kind
+ * questions (`photo` and its siblings, v3) are the same objects again as
+ * SurveyJS file answers, which is the shape an oracle's attachment tools do
+ * read.
+ *
+ * **Changing this document changes its CID**, which is the proof every rubric
+ * pins in `claimSchema.proof` — so an edit here silently unbinds every rubric
+ * published before it (the engine calls that form drift and fails closed).
+ * Add fields; do not rename or remove them.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAIM_FORM = exports.FORM_NAME = void 0;
+/**
+ * The `alsoKnownAs` the publishing script finds the entity by.
+ *
+ * **The version lives in the name, and that is the whole migration story.**
+ * A rubric pins this form's bytes by their hash, so editing the document
+ * below would not update the form — it would silently unbind every rubric
+ * published against it (their binder calls that form drift and fails closed).
+ * A new field therefore means a new name, a new entity, and new asks binding
+ * to it while old asks keep resolving the old one, untouched, forever.
+ */
+exports.FORM_NAME = "Openhands claim form v3";
+exports.CLAIM_FORM = {
+    "@context": { ixo: "https://w3id.org/ixo/ns/protocol/" },
+    type: "ixo:entity#surveyTemplate",
+    question: {
+        pages: [
+            {
+                elements: [
+                    /* The work itself, and the only field both writers always carry.
+                       Nearly every rule we publish reads this one. */
+                    { type: "comment", name: "deliverable", title: "The work handed over", isRequired: true },
+                    /* What was asked. The worker agent copies the ask's title in; a
+                       browser submission leaves it out, which is why it is optional. */
+                    { type: "text", name: "task", title: "The ask this answers" },
+                    /* A hosted artifact: a CID string, not an upload — see the note
+                       above about `file` kinds and the resolver lane. */
+                    { type: "text", name: "file", title: "Attached file (content address)" },
+                    { type: "text", name: "mediaType", title: "What kind of file it is" },
+                    /* Who and when. `submitter` is on browser envelopes, `worker` on the
+                       agent's; both are ixo addresses, and the chain is the authority on
+                       which one actually signed. */
+                    { type: "text", name: "submitter", title: "Who handed it over" },
+                    { type: "text", name: "worker", title: "Which agent produced it" },
+                    { type: "text", inputType: "datetime-local", name: "ts", title: "When it was sealed" },
+                    /* Which ask this belongs to, and the envelope version. */
+                    { type: "text", name: "collectionId", title: "The ask's collection id" },
+                    { type: "text", inputType: "number", name: "v", title: "Envelope version" },
+                    /*
+                     * Where the submitter says they were (v2). Dotted names are paths
+                     * into the stored body — the engine's own path-manifest convention,
+                     * and the reason a nested field needs no new machinery.
+                     *
+                     * Client-assisted by nature: a browser's geolocation or a photo's
+                     * EXIF, either of which a determined person can set. Nothing here
+                     * pretends otherwise, and no rule that reads these may approve a
+                     * claim on their strength alone.
+                     */
+                    { type: "text", inputType: "number", name: "location.lat", title: "Reported latitude" },
+                    { type: "text", inputType: "number", name: "location.lon", title: "Reported longitude" },
+                    { type: "text", inputType: "number", name: "location.accuracyMeters", title: "Reported accuracy in metres" },
+                    { type: "text", inputType: "datetime-local", name: "location.at", title: "When the location was taken" },
+                    /*
+                     * The same files, as file answers (v3).
+                     *
+                     * `file`, `before`, `after` and `extra` stay exactly what they were —
+                     * CID strings our own readers parse. An oracle's attachment tools
+                     * see none of them: what they recognise is a SurveyJS file answer,
+                     * `[{ name, type, content }]` with an https `content`. So every
+                     * writer now puts the same object beside its CID in that shape,
+                     * and these four are what the stock media-type, size, image and
+                     * duplicate lanes read. `storeDataAsText: false` is the SurveyJS
+                     * flag for "content is a URL, not the bytes".
+                     */
+                    { type: "file", name: "photo", title: "The photograph", storeDataAsText: false, allowMultiple: false },
+                    { type: "file", name: "beforePhoto", title: "Before the work", storeDataAsText: false, allowMultiple: false },
+                    { type: "file", name: "afterPhoto", title: "After the work", storeDataAsText: false, allowMultiple: false },
+                    { type: "file", name: "extraFile", title: "The second file", storeDataAsText: false, allowMultiple: false },
+                    /* What kind of claim this is — `patch` and `site` on a shared site,
+                       `pair` for a one-person cleanup — where the writer knows it. A
+                       rule reads it to decide whether a payout is held or released. */
+                    { type: "text", name: "kind", title: "What kind of claim this is" }
+                ]
+            }
+        ]
+    }
+};
+//# sourceMappingURL=claimForm.js.map

package/dist/cjs/rubric/claimForm.js.map

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

package/dist/cjs/rubric/claimFormResource.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The claim form a rubric is bound to, anchored on the ask itself at `#vct`.
+ *
+ * The engine resolves the form from the SAME entity as the rubric: it walks
+ * the ask's own linked resources for an id ending `#vct` (`resolveClaimForm`
+ * in their `lib/rubric/form.ts`), fetches `serviceEndpoint`, and compares the
+ * resource's `proof` — as a string, never recomputed — with the rubric's
+ * pinned `claimSchema.proof`. So every ask has to carry the form's address
+ * and proof itself, or the rubric it just published is unusable. Both values
+ * are the ones `scripts/publish-vct.ts` printed (`NEXT_PUBLIC_VCT_URL`,
+ * `NEXT_PUBLIC_VCT_PROOF`).
+ *
+ * Shape only, no SDK — the worker wraps it in `LinkedResource.fromPartial`;
+ * the browser package builds the same resource itself in
+ * `packages/openhands-sdk/src/chain/ask.ts`, the way `#rub` is built twice too.
+ */
+export interface ClaimFormRef {
+    url: string;
+    proof: string;
+}
+/** The ref when both halves are set, else null — an ask never posts a half address. */
+export declare const claimFormRef: (url?: string | null, proof?: string | null) => ClaimFormRef | null;
+/** The `#vct` resource, ready for a `MsgCreateEntity`. */
+export declare const claimFormResource: (form: ClaimFormRef) => {
+    type: string;
+    id: string;
+    description: string;
+    mediaType: string;
+    serviceEndpoint: string;
+    proof: string;
+    encrypted: string;
+    right: string;
+};
+//# sourceMappingURL=claimFormResource.d.ts.map

package/dist/cjs/rubric/claimFormResource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claimFormResource.d.ts","sourceRoot":"","sources":["../../../src/rubric/claimFormResource.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf;AAED,uFAAuF;AACvF,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,GAAG,IAAI,EAAE,QAAQ,MAAM,GAAG,IAAI,KAAG,YAAY,GAAG,IAAwF,CAAC;AAElL,0DAA0D;AAC1D,eAAO,MAAM,iBAAiB,GAAI,MAAM,YAAY;;;;;;;;;CAYlD,CAAC"}

package/dist/cjs/rubric/claimFormResource.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * The claim form a rubric is bound to, anchored on the ask itself at `#vct`.
+ *
+ * The engine resolves the form from the SAME entity as the rubric: it walks
+ * the ask's own linked resources for an id ending `#vct` (`resolveClaimForm`
+ * in their `lib/rubric/form.ts`), fetches `serviceEndpoint`, and compares the
+ * resource's `proof` — as a string, never recomputed — with the rubric's
+ * pinned `claimSchema.proof`. So every ask has to carry the form's address
+ * and proof itself, or the rubric it just published is unusable. Both values
+ * are the ones `scripts/publish-vct.ts` printed (`NEXT_PUBLIC_VCT_URL`,
+ * `NEXT_PUBLIC_VCT_PROOF`).
+ *
+ * Shape only, no SDK — the worker wraps it in `LinkedResource.fromPartial`;
+ * the browser package builds the same resource itself in
+ * `packages/openhands-sdk/src/chain/ask.ts`, the way `#rub` is built twice too.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claimFormResource = exports.claimFormRef = void 0;
+/** The ref when both halves are set, else null — an ask never posts a half address. */
+const claimFormRef = (url, proof) => (url?.trim() && proof?.trim() ? { url: url.trim(), proof: proof.trim() } : null);
+exports.claimFormRef = claimFormRef;
+/** The `#vct` resource, ready for a `MsgCreateEntity`. */
+const claimFormResource = (form) => ({
+    /* The same type the form's own entity carries (`scripts/publish-vct.ts`).
+       The engine finds this by id suffix alone; the type is for people. */
+    type: "surveyTemplate",
+    id: "{id}#vct",
+    description: "The claim form this ask's rubric is bound to",
+    mediaType: "application/ld+json",
+    serviceEndpoint: form.url,
+    /* The form's CID, verbatim — compared as a string, never recomputed. */
+    proof: form.proof,
+    encrypted: "false",
+    right: ""
+});
+exports.claimFormResource = claimFormResource;
+//# sourceMappingURL=claimFormResource.js.map

package/dist/cjs/rubric/claimFormResource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claimFormResource.js","sourceRoot":"","sources":["../../../src/rubric/claimFormResource.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAOH,uFAAuF;AAChF,MAAM,YAAY,GAAG,CAAC,GAAmB,EAAE,KAAqB,EAAuB,EAAE,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAArK,QAAA,YAAY,gBAAyJ;AAElL,0DAA0D;AACnD,MAAM,iBAAiB,GAAG,CAAC,IAAkB,EAAE,EAAE,CAAC,CAAC;IACxD;2EACuE;IACvE,IAAI,EAAE,gBAAgB;IACtB,EAAE,EAAE,UAAU;IACd,WAAW,EAAE,8CAA8C;IAC3D,SAAS,EAAE,qBAAqB;IAChC,eAAe,EAAE,IAAI,CAAC,GAAG;IACzB,wEAAwE;IACxE,KAAK,EAAE,IAAI,CAAC,KAAK;IACjB,SAAS,EAAE,OAAO;IAClB,KAAK,EAAE,EAAE;CACV,CAAC,CAAC;AAZU,QAAA,iBAAiB,qBAY3B"}

package/dist/cjs/rubric/compose.d.ts

@@ -0,0 +1,99 @@
+import { type AskTerms } from "./terms.ts";
+/**
+ * The ask form's one mapping: fields in, terms and a title out.
+ *
+ * The composer stopped being a sentence with blanks and became a form — but
+ * everything downstream (the minted title, the published terms, the checker's
+ * leg) still speaks the sentence's language. This file is where the form
+ * becomes that language, kept pure so the equivalence is a test rather than a
+ * hope: a form with nothing optional produces exactly what `deriveTerms`
+ * produces for the bare task, and a before-and-after form with a place is
+ * measured by exactly the gates `cleanupTerms` builds — id for id — while
+ * keeping the poster's own words (the cleanup builder is the campaign's, and
+ * titles everything "Clean up …").
+ *
+ * The judge is always returned as `{ kind: "poster" }` — who actually rules
+ * is decided at publish time, the same override the composer has always done.
+ * Titles carry the place's *name*; the gate carries the coordinates. Nothing
+ * here geocodes, for the reason `deriveTerms` refuses to: a name is a
+ * courtesy, coordinates are the contract.
+ */
+export interface AskForm {
+    task: string;
+    /** Where the work must happen; label is frozen into title and gate alike. */
+    place?: {
+        lat: number;
+        lon: number;
+        metres?: number;
+        label?: string;
+    };
+    /**
+     * **They say where it is.** The other location block, and the opposite one:
+     * `place` is the poster choosing a spot and a radius before anyone goes;
+     * this is the poster choosing nothing and the worker reporting the exact
+     * coordinates as part of the answer. A mapping ask, a found mess, a
+     * delivery that lands where it lands — all of them need the position and
+     * none of them can name it in advance.
+     *
+     * The two compose: an ask can want somebody inside 400 m of a square AND
+     * the precise spot they stood.
+     */
+    pin?: boolean;
+    /** What the proof looks like. Absent means whatever the task implies. */
+    proof?: "text" | "photo" | "pair" | "file";
+    /**
+     * **A place the ask names, which therefore needs a geofence.** The caller
+     * found it in the sentence — a draft's `placeName`, or `GET /api/place?from=`
+     * — and passing it here makes `place` required: an ask that says "the
+     * noticeboard in Smokuč" and gates nothing on Smokuč is a promise the
+     * checker cannot keep (Peter's rule, 2026-10-06). The caller decides when a
+     * named place binds: the composer and the MCP pass it for camera work.
+     */
+    namedPlace?: string;
+    /**
+     * A written answer is required. Alone, it IS the answer — and outranks a
+     * camera the sentence implied, the way *A file* does. Beside an attachment
+     * it is the note that must come with it: the claim's `deliverable` text,
+     * held to the same `min-length` the sentence path uses.
+     */
+    words?: boolean;
+    /**
+     * A file with the photograph or the pair. The claim's primary file is the
+     * camera's; this is the second one, riding beside it in the envelope. Only
+     * meaningful with a camera deliverable — a file alone is `proof: "file"`.
+     */
+    withFile?: boolean;
+    /**
+     * Words the answer has to contain, as the poster wrote them.
+     *
+     * `deriveTerms` already lifts quoted phrases out of a sentence; this is the
+     * same gate said deliberately rather than inferred, for the poster who
+     * wants a reference number or a product name in the answer and would
+     * otherwise have to phrase their whole ask around getting one.
+     */
+    mentions?: string[];
+    /** The campaign tag the receipt wall gathers by. */
+    campaign?: string;
+    /** The poster's name for a batch of the same job, so the board shows it as one card. */
+    series?: string;
+    /** Buy a look back later — before-and-after asks only. */
+    followUp?: {
+        days: number;
+        pay: string;
+    };
+    /** What each approved answer opens — the `+ Then` chip, terms.chain's form. */
+    then?: {
+        task: string;
+        deliverable: "photo-pair" | "photo" | "text";
+        /** The follow-on's full bill, base units. */
+        targetBase: number;
+        funding: "poster" | "crowd";
+        atAnswersPlace?: boolean;
+    };
+}
+export declare const CAMPAIGN_TAG: RegExp;
+export declare function formTerms(form: AskForm): {
+    terms: AskTerms;
+    title: string;
+};
+//# sourceMappingURL=compose.d.ts.map

package/dist/cjs/rubric/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../../src/rubric/compose.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4C,KAAK,QAAQ,EAA8D,MAAM,YAAY,CAAC;AAEjJ;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,KAAK,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE;;;;;;;;;;OAUG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;IAC3C;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wFAAwF;IACxF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,+EAA+E;IAC/E,IAAI,CAAC,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,YAAY,GAAG,OAAO,GAAG,MAAM,CAAC;QAC7C,6CAA6C;QAC7C,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC;QAC5B,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B,CAAC;CACH;AAED,eAAO,MAAM,YAAY,QAAsB,CAAC;AAmFhD,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAiJ3E"}