@ggui-ai/protocol 0.2.0-alpha.4 → 0.3.0-rc.0

package/dist/schemas/mcp.d.ts

@@ -3,7 +3,25 @@
  *
  * These schemas define the validation rules for MCP tool inputs.
  * TypeScript types in types/mcp.ts are derived from these via z.infer.
- * The server handler imports these for runtime validation.
+ *
+ * Two consumption patterns, both anchored here:
+ *
+ *   - **Wired raw shapes** (`*InputShape`): handlers in
+ *     `@ggui-ai/mcp-server-handlers` (and the hosted pod's
+ *     discover / request-credential tools) import the SHAPE directly as
+ *     their `inputSchema` and validate with `z.object(shape)` — unknown
+ *     keys are STRIPPED. The shape is the one authored copy of the
+ *     validation rules AND the agent-facing `.describe()` strings that
+ *     ship via `tools/list`.
+ *
+ *   - **Lifecycle triad** (`ggui_handshake` / `ggui_update`): the
+ *     handlers carry deliberate input divergences (handshake's
+ *     blueprintDraft contract is loose ON PURPOSE so the negotiator can
+ *     repair malformations; update's sessionId is optional for
+ *     in-process dispatch), so they author their own raw shapes. The
+ *     schemas here remain the canonical strict wire contract + the
+ *     `z.infer` source for the published types. `ggui_render` is wired:
+ *     its handler imports {@link renderInputShape}.
  */
 import { z } from 'zod';
 export declare const viewportSchema: z.ZodObject<{
@@ -42,48 +60,76 @@ export declare const interfaceContextSchema: z.ZodObject<{
     }>>;
     reducedMotion: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;
+/**
+ * `ggui_consume` input. The long-poll bound is SPEC §7.3: integer
+ * seconds in `[0, 25]` — the cap dodges infrastructure kill windows
+ * (API-gateway 30s HTTP limits, host MCP clients that abort long tool
+ * calls). Longer waits are the agent's loop, not a server knob.
+ */
+export declare const consumeInputShape: {
+    readonly sessionId: z.ZodString;
+    readonly timeout: z.ZodOptional<z.ZodNumber>;
+};
 export declare const consumeInputSchema: z.ZodObject<{
-    renderId: z.ZodString;
+    sessionId: z.ZodString;
     timeout: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 /**
- * Input schema for `ggui_emit` — emit a stamped delivery on a declared
+ * `ggui_emit` input — emit a stamped delivery on a declared
  * `streamSpec[channel]`.
  */
+export declare const emitInputShape: {
+    readonly sessionId: z.ZodString;
+    readonly channel: z.ZodString;
+    readonly payload: z.ZodUnknown;
+    readonly complete: z.ZodOptional<z.ZodBoolean>;
+};
 export declare const emitInputSchema: z.ZodObject<{
-    renderId: z.ZodString;
+    sessionId: z.ZodString;
     channel: z.ZodString;
     payload: z.ZodUnknown;
     complete: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export declare const getRenderInputSchema: z.ZodObject<{
-    renderId: z.ZodString;
-}, z.core.$strict>;
-export declare const listFeaturedBlueprintsInputSchema: z.ZodObject<{
-    level: z.ZodOptional<z.ZodEnum<{
-        component: "component";
-        primitive: "primitive";
-        composite: "composite";
-        template: "template";
-    }>>;
-    category: z.ZodOptional<z.ZodString>;
-    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    limit: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
+}, z.core.$strip>;
+export declare const getSessionInputShape: {
+    readonly sessionId: z.ZodString;
+};
+export declare const getSessionInputSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * `ggui_list_featured_blueprints` input — intentionally EMPTY. The
+ * pre-launch No-Backcompat scrub deleted the level/category/tags/limit
+ * filters (delete-until-wired); filters re-enter here when a real
+ * consumer passes them.
+ */
+export declare const listFeaturedBlueprintsInputShape: {};
+export declare const listFeaturedBlueprintsInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const searchBlueprintsInputShape: {
+    readonly query: z.ZodString;
+    readonly limit: z.ZodOptional<z.ZodNumber>;
+};
 export declare const searchBlueprintsInputSchema: z.ZodObject<{
     query: z.ZodString;
     limit: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
+}, z.core.$strip>;
+export declare const renderBlueprintInputShape: {
+    readonly blueprintId: z.ZodString;
+};
 export declare const renderBlueprintInputSchema: z.ZodObject<{
     blueprintId: z.ZodString;
-    props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strict>;
-export declare const discoverInputSchema: z.ZodObject<{}, z.core.$strict>;
+}, z.core.$strip>;
+export declare const discoverInputShape: {};
+export declare const discoverInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const requestCredentialInputShape: {
+    readonly serviceId: z.ZodString;
+    readonly reason: z.ZodOptional<z.ZodString>;
+    readonly sessionId: z.ZodOptional<z.ZodString>;
+};
 export declare const requestCredentialInputSchema: z.ZodObject<{
     serviceId: z.ZodString;
     reason: z.ZodOptional<z.ZodString>;
-    renderId: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 /**
  * `ggui_handshake` — three-step suggestion protocol.
  *
@@ -105,10 +151,10 @@ export declare const requestCredentialInputSchema: z.ZodObject<{
  *   - The agent is the contract authority; synth amends only when
  *     validation fails.
  *   - Post-Phase-B the handshake input carries NO `sessionId`. The
- *     server mints `renderId` on the paired `ggui_render`; host
+ *     server mints `sessionId` on the paired `ggui_render`; host
  *     conversation grouping flows via the host-supplied
  *     `_meta["ai.ggui/host-session"]` envelope captured at render
- *     creation (see {@link RenderBase.hostSession}).
+ *     creation (see {@link GguiSessionBase.hostSession}).
  */
 export declare const handshakeInputSchema: z.ZodObject<{
     intent: z.ZodString;
@@ -123,18 +169,19 @@ export declare const handshakeInputSchema: z.ZodObject<{
  *
  * The agent reads `suggestion.origin` to branch the paired render call:
  *
- *   - `cache`  → render `{decision: {kind: 'accept'}}` for cache delivery.
- *   - `agent`  → render `{decision: {kind: 'accept'}}` to gen against the draft.
- *   - `synth`  → render `{decision: {kind: 'accept'}}` to gen against the amended contract.
+ *   - `cache`  → render `{handshakeId, props}` (omit `override`) for cache delivery.
+ *   - `agent`  → render `{handshakeId, props}` (omit `override`) to gen against the draft.
+ *   - `synth`  → render `{handshakeId, props}` (omit `override`) to gen against the amended contract.
  *
- * Any origin → render `{decision: {kind: 'override', blueprintDraft: {...}}}` to
- * discard the suggestion and gen against a fresh draft (mints a new
- * `blueprintId` server-side).
+ * Any origin → render `{handshakeId, props, override: {contract?, variance?}}`
+ * to re-aim the suggestion — `override.contract` gens against a fresh
+ * contract; `override.variance` re-aims the variant axis.
  *
- * Wire-output is intentionally lean. The handler carries `reason`,
- * `target`, `alternatives`, `contractHash`, `serverCapabilities` on
- * its internal `HandshakeOutput` TS shape for telemetry / post-classify
- * tracing — zod strips them before structuredContent serialization.
+ * Wire-output is intentionally lean. The handler carries `target`,
+ * `alternatives`, `contractHash`, `serverCapabilities` on its internal
+ * `HandshakeOutput` TS shape for telemetry / post-classify tracing —
+ * zod strips them before structuredContent serialization. `reason` IS
+ * a wire field (optional, ≤280 chars — see below).
  *
  * `serverCapabilities` reaches the iframe via the `ai.ggui/render`
  * slice meta (see `slice-meta-derivation.ts`), not via this response.
@@ -164,33 +211,120 @@ export declare const handshakeOutputSchema: z.ZodObject<{
  * `ggui_render` — materialises a UI emission. Step 3 of the three-step
  * handshake protocol.
  *
- * The agent commits its decision relative to the prior handshake's
- * suggestion: ACCEPT (use the provisional `blueprintMeta` from
- * step-2 verbatim) or OVERRIDE (mint a fresh blueprintId with a NEW
- * `blueprintDraft`).
+ * The agent commits relative to the prior handshake's suggestion by
+ * PRESENCE of `override` (no discriminated union): omit `override` to
+ * ACCEPT the proposal as-is, or provide `override: {contract?, variance?}`
+ * to re-aim the contract and/or the variant axis (PATCH semantics).
  *
  * Locked decisions:
  *
- *   - `decision` discriminator: `{kind: 'accept'} |
- *     {kind: 'override', blueprintDraft: {...}}`.
- *   - `accept` reuses `handshake.suggestion.blueprintMeta.blueprintId`
- *     exactly; `override` discards the provisional id and mints fresh.
+ *   - ACCEPT (omit `override`) reuses the agreed contract + the proposed
+ *     variance, resolving the proposed `(contractKey, variantKey)`.
+ *   - `override.contract` re-drafts the contract (STRICT — must already
+ *     conform; the server does not repair it) and cold-gens against it.
+ *   - `override.variance` re-aims the variant axis while keeping the
+ *     agreed contract, re-resolving the effective
+ *     `(contractKey, variantKey(newVariance))`.
+ *   - `props` is REQUIRED (pass `{}` when the effective contract declares
+ *     no propsSpec).
  *
  * There is no separate `ggui_commit` — render absorbs that responsibility.
  *
  * Post-Phase-B rename from `ggui_push` — the tool materialises a single
  * render (no stack of N to push onto); the new name reflects what the
  * tool does at the protocol surface.
+ *
+ * WIRED shape — `@ggui-ai/mcp-server-handlers`'s `ggui_render` registers
+ * {@link renderInputShape} as its `inputSchema` and validates with
+ * `z.object(shape)` (unknown top-level keys strip; `infra` / `override`
+ * sub-objects stay `.strict()` so typos inside them surface as clear zod
+ * paths).
  */
+export declare const renderInputShape: {
+    readonly handshakeId: z.ZodString;
+    /**
+     * Runtime prop values for THIS render. Validated against the
+     * effective contract's `propsSpec` — required-field checks + type
+     * checks per spec entry. Validation failures fail the render with a
+     * recoverable `ContractViolationError`.
+     *
+     * REQUIRED — pass `{}` when the effective contract declares no
+     * propsSpec (the field is required, the value may be empty).
+     */
+    readonly props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    /**
+     * Per-render theme override. When set, lands on the committed
+     * render and takes priority over `App.defaultThemeId` at
+     * bootstrap-projection time. Use sparingly — most renders should
+     * inherit the app default.
+     */
+    readonly themeId: z.ZodOptional<z.ZodString>;
+    /**
+     * Typed `infra` envelope. Today carries one field (`model`); future
+     * expansion (temperature, max_tokens, provider hints) lands here
+     * additively. `model` MUST be a provider-prefixed id
+     * (`provider/model-name`); a bound generator may also accept
+     * generator-specific prefixes for alternate transports.
+     *
+     * Strict — extra keys at `infra.*` are not silently dropped, so a
+     * typo (`infra.modelId`) surfaces as a clear zod path instead of a
+     * silent default-model fallback.
+     */
+    readonly infra: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    /**
+     * Re-aim the handshake proposal (PATCH semantics). Omit to ACCEPT the
+     * proposal as-is; provide to re-draft the contract and/or re-aim the
+     * variant axis. At least one of `contract` / `variance` MUST be set —
+     * an empty `override: {}` is rejected.
+     *
+     *   - `contract` — STRICT full re-draft of the contract. The server
+     *     does NOT repair it; it must already conform.
+     *   - `variance` — re-aim the variant axis (persona / aesthetic /
+     *     context / seedPrompt) while keeping the agreed contract. A
+     *     different variance resolves a distinct cached component.
+     */
+    readonly override: z.ZodOptional<z.ZodObject<{
+        contract: z.ZodOptional<z.ZodType<import("..").DataContract, unknown, z.core.$ZodTypeInternals<import("..").DataContract, unknown>>>;
+        variance: z.ZodOptional<z.ZodType<import("..").BlueprintVariance, unknown, z.core.$ZodTypeInternals<import("..").BlueprintVariance, unknown>>>;
+    }, z.core.$strict>>;
+};
 export declare const renderInputSchema: z.ZodObject<{
     handshakeId: z.ZodString;
-    props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    decision: z.ZodType<import("..").PushDecision, unknown, z.core.$ZodTypeInternals<import("..").PushDecision, unknown>>;
-}, z.core.$strict>;
+    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    themeId: z.ZodOptional<z.ZodString>;
+    infra: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    override: z.ZodOptional<z.ZodObject<{
+        contract: z.ZodOptional<z.ZodType<import("..").DataContract, unknown, z.core.$ZodTypeInternals<import("..").DataContract, unknown>>>;
+        variance: z.ZodOptional<z.ZodType<import("..").BlueprintVariance, unknown, z.core.$ZodTypeInternals<import("..").BlueprintVariance, unknown>>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+/**
+ * Reuse outcome for a single `ggui_render` — surfaced on the wire so an
+ * agent or operator can tell whether a stored component was served or a
+ * new one was generated. Counts generation calls only; it carries no
+ * cost or tier semantics.
+ */
+export declare const renderCacheMarkerSchema: z.ZodObject<{
+    hit: z.ZodBoolean;
+    similarity: z.ZodOptional<z.ZodNumber>;
+    cachedBlueprintId: z.ZodOptional<z.ZodString>;
+    llmCallsAvoided: z.ZodNumber;
+    kind: z.ZodOptional<z.ZodEnum<{
+        "full-template": "full-template";
+        cold: "cold";
+    }>>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 /**
- * Wire-output shape — intentionally lean: `{renderId, nextStep?, action}`.
+ * Wire-output shape — `{sessionId, resourceUri, action, contractHash,
+ * cache, nextStep?}`. `contractHash` (data-contract identity) and `cache`
+ * (reuse outcome) are required wire fields on this schema.
  * The handler carries `shortCode`, `codeReady`, `handshakeId`,
- * `decision`, `contract`, `contractHash`, `cache`, `codeUrl`, `codeHash`
+ * `decision`, `contract`, `codeUrl`, `codeHash`
  * on its internal `RenderOutput` TS shape for telemetry / post-classify
  * tracing — zod strips them before structuredContent serialization.
  *
@@ -198,7 +332,7 @@ export declare const renderInputSchema: z.ZodObject<{
  * `expiresAt`) via the single `ai.ggui/render` slice meta, not via this
  * response. There is no clickable `url` field — post-R5 the `/r/`
  * shortCode route was deleted (every host either resolves the
- * `_meta.ui.resourceUri` iframe or reads `{renderId}` via
+ * `_meta.ui.resourceUri` iframe or reads `{sessionId}` via
  * `render-resource/...`). Leaving a dead URL on the wire had the model
  * hallucinating links that resolve nowhere.
  *
@@ -206,7 +340,7 @@ export declare const renderInputSchema: z.ZodObject<{
  * stack of N renders to compose against.
  */
 export declare const renderOutputSchema: z.ZodObject<{
-    renderId: z.ZodString;
+    sessionId: z.ZodString;
     resourceUri: z.ZodString;
     action: z.ZodEnum<{
         replace: "replace";
@@ -215,12 +349,26 @@ export declare const renderOutputSchema: z.ZodObject<{
         update: "update";
         declined: "declined";
     }>;
+    contractHash: z.ZodString;
+    blueprintId: z.ZodString;
+    variantKey: z.ZodString;
+    cache: z.ZodObject<{
+        hit: z.ZodBoolean;
+        similarity: z.ZodOptional<z.ZodNumber>;
+        cachedBlueprintId: z.ZodOptional<z.ZodString>;
+        llmCallsAvoided: z.ZodNumber;
+        kind: z.ZodOptional<z.ZodEnum<{
+            "full-template": "full-template";
+            cold: "cold";
+        }>>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
     nextStep: z.ZodOptional<z.ZodObject<{
         tool: z.ZodLiteral<"ggui_consume">;
         description: z.ZodString;
         example: z.ZodString;
         args: z.ZodObject<{
-            renderId: z.ZodString;
+            sessionId: z.ZodString;
         }, z.core.$strip>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
@@ -252,15 +400,15 @@ export declare const renderOutputSchema: z.ZodObject<{
  * partial patches that would break required fields, type-mismatch
  * values, etc. all reject pre-persist.
  *
- * `renderId` is globally unique; the server tenancy-checks via
+ * `sessionId` is globally unique; the server tenancy-checks via
  * `ctx.appId`.
  */
 export declare const updateInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    renderId: z.ZodString;
+    sessionId: z.ZodString;
     kind: z.ZodLiteral<"replace">;
     props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strict>, z.ZodObject<{
-    renderId: z.ZodString;
+    sessionId: z.ZodString;
     kind: z.ZodLiteral<"merge">;
     patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strict>], "kind">;
@@ -276,7 +424,41 @@ export declare const updateInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
  * acknowledgement.
  */
 export declare const updateOutputSchema: z.ZodObject<{
-    renderId: z.ZodString;
+    sessionId: z.ZodString;
     updated: z.ZodBoolean;
 }, z.core.$strip>;
+/**
+ * `ggui_runtime_declare_tool_catalog` — the host runtime declares its
+ * per-app canonical tool-identity catalog (one row per app).
+ *
+ * The map is `bare tool name → the canonical serverInfo` that the tool's
+ * MCP server announced in its `initialize` reply. ggui folds this into
+ * the handshake step (`canonicalizeToolIdentity`) so a reused blueprint's
+ * `agentCapabilities.tools[*].serverInfo` is rewritten to the canonical
+ * value regardless of whether the inbound contract authored a config-key
+ * name, fabricated one, or omitted it. That makes blueprint reuse
+ * identity-stable across runtimes.
+ *
+ * Keyed by the BARE tool name — the same key the canonicalization step
+ * matches on. `version` is OPTIONAL: it rides along as metadata; tool
+ * identity is `(name)` matched by bare name, never `(name, version)`.
+ *
+ * `appId` is NOT on the input — the handler reads it off `ctx.appId`
+ * resolved by the upstream auth adapter, so a declaration can only ever
+ * write its own app's row. The output echoes the resolved `appId` so the
+ * caller can confirm which app row it wrote.
+ *
+ * REPLACE semantics: each declaration overwrites the app's prior catalog
+ * wholesale (the host re-declares its full current toolset on connect).
+ */
+export declare const declareToolCatalogInputSchema: z.ZodObject<{
+    toolCatalog: z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const declareToolCatalogOutputSchema: z.ZodObject<{
+    saved: z.ZodBoolean;
+    appId: z.ZodString;
+}, z.core.$strict>;
 //# sourceMappingURL=mcp.d.ts.map

package/dist/schemas/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/schemas/mcp.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,cAAc;;;iBAGzB,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUnB,CAAC;AAUjB,eAAO,MAAM,kBAAkB;;;kBAIpB,CAAC;AAEZ;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;kBAOjB,CAAC;AAEZ,eAAO,MAAM,oBAAoB;;kBAEtB,CAAC;AAEZ,eAAO,MAAM,iCAAiC;;;;;;;;;;kBAKnC,CAAC;AAEZ,eAAO,MAAM,2BAA2B;;;kBAG7B,CAAC;AAEZ,eAAO,MAAM,0BAA0B;;;kBAG5B,CAAC;AAEZ,eAAO,MAAM,mBAAmB,iCAAwB,CAAC;AAEzD,eAAO,MAAM,4BAA4B;;;;kBAI9B,CAAC;AAaZ;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,oBAAoB;;;;kBA0BtB,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;iBAgChC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB;;;;kBA4BnB,CAAC;AAEZ;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;iBAkC7B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;4BAa5B,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/schemas/mcp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,cAAc;;;iBAGzB,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUnB,CAAC;AAYjB;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;CAgBpB,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;iBAA8B,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;CAKjB,CAAC;AAEX,eAAO,MAAM,eAAe;;;;;iBAA2B,CAAC;AAExD,eAAO,MAAM,oBAAoB;;CAKvB,CAAC;AAEX,eAAO,MAAM,qBAAqB;;iBAAiC,CAAC;AAEpE;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,IAAc,CAAC;AAE5D,eAAO,MAAM,iCAAiC,gCAE7C,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;CAM7B,CAAC;AAEX,eAAO,MAAM,2BAA2B;;;iBAAuC,CAAC;AAEhF,eAAO,MAAM,yBAAyB;;CAO5B,CAAC;AAEX,eAAO,MAAM,0BAA0B;;iBAAsC,CAAC;AAE9E,eAAO,MAAM,kBAAkB,IAAc,CAAC;AAE9C,eAAO,MAAM,mBAAmB,gCAA+B,CAAC;AAEhE,eAAO,MAAM,2BAA2B;;;;CAI9B,CAAC;AAEX,eAAO,MAAM,4BAA4B;;;;iBAAwC,CAAC;AAalF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,oBAAoB;;;;kBA0BtB,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;iBAgChC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,gBAAgB;;IAO3B;;;;;;;;OAQG;;IAEH;;;;;OAKG;;IAQH;;;;;;;;;;OAUG;;;;IAaH;;;;;;;;;;;OAWG;;;;;CAuBK,CAAC;AAEX,eAAO,MAAM,iBAAiB;;;;;;;;;;;iBAA6B,CAAC;AAE5D;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;iBAyBlC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoD7B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;4BAa5B,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,6BAA6B;;;;;kBAW/B,CAAC;AAEZ,eAAO,MAAM,8BAA8B;;;kBAKhC,CAAC"}