@cat-factory/contracts 0.275.0 → 0.276.0

package/dist/routes/public-board.d.ts

@@ -0,0 +1,369 @@
+import { ContractNoBody } from '@toad-contracts/valibot';
+/**
+ * List the repositories this workspace can back a service with.
+ *
+ * The discovery half of service creation, and what makes it usable with no browser: the create
+ * takes a provider repo id, and nothing on this surface served one. `read` scope, like every other
+ * discovery endpoint here (`/pipelines`, `/task-types`): it names what the workspace has already
+ * connected, and an integration must be able to see what it is about to ask for without holding the
+ * credential that could change it.
+ */
+export declare const listPublicReposContract: {
+    readonly method: "get";
+    readonly pathResolver: () => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly repos: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly repoId: import("valibot").NumberSchema<undefined>;
+                readonly provider: import("valibot").StringSchema<undefined>;
+                readonly owner: import("valibot").StringSchema<undefined>;
+                readonly name: import("valibot").StringSchema<undefined>;
+                readonly defaultBranch: import("valibot").StringSchema<undefined>;
+                readonly private: import("valibot").BooleanSchema<undefined>;
+                readonly monorepo: import("valibot").BooleanSchema<undefined>;
+                readonly serviceId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly linkedElsewhere: import("valibot").BooleanSchema<undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    };
+} & {
+    readonly minScope: "read";
+};
+/**
+ * Create a board service, optionally backed by a repository: the last act of board setup that had
+ * no headless counterpart, so a deployment that could provision its own keys and enrol its own
+ * webhook still had to open the app once to have anywhere to file work.
+ *
+ * Delegates to the SAME service methods the app's own "import a repository" button and drag-drop
+ * call, so every guard holds identically: a whole-repo repository that already backs a service in
+ * this account is MOUNTED here rather than duplicated, a monorepo must name its subdirectory, and a
+ * subdirectory another service already claims is refused.
+ */
+export declare const createPublicServiceContract: {
+    readonly method: "post";
+    readonly pathResolver: () => string;
+    readonly requestBodySchema: import("valibot").ObjectSchema<{
+        readonly title: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>, undefined>;
+        readonly description: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MaxLengthAction<string, 2000, undefined>]>, undefined>;
+        readonly type: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["service", "frontend", "library", "document"], undefined>, undefined>;
+        readonly repo: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+            readonly repoId: import("valibot").NumberSchema<undefined>;
+            readonly directory: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MaxLengthAction<string, 400, undefined>]>, undefined>;
+            readonly monorepo: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 201: import("valibot").ObjectSchema<{
+            readonly serviceId: import("valibot").StringSchema<undefined>;
+            readonly title: import("valibot").StringSchema<undefined>;
+            readonly description: import("valibot").StringSchema<undefined>;
+            readonly type: import("valibot").PicklistSchema<["frontend", "service", "library", "document", "api", "database", "queue", "integration", "external", "environment"], undefined>;
+            readonly status: import("valibot").PicklistSchema<["planned", "ready", "in_progress", "blocked", "pr_ready", "done"], undefined>;
+        }, undefined>;
+    };
+} & {
+    readonly minScope: "admin";
+};
+/**
+ * Declare that this task must wait for another one. Idempotent: an edge that already exists is
+ * returned as-is rather than toggled off, which is what separates this from the app's own toggle
+ * and what lets a provisioning integration re-run without inverting the graph it declared last time.
+ */
+export declare const addPublicTaskDependencyContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        taskId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ taskId }: {
+        taskId: string;
+    }) => string;
+    readonly requestBodySchema: import("valibot").ObjectSchema<{
+        readonly dependsOnTaskId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly taskId: import("valibot").StringSchema<undefined>;
+            readonly serviceId: import("valibot").StringSchema<undefined>;
+            readonly title: import("valibot").StringSchema<undefined>;
+            readonly description: import("valibot").StringSchema<undefined>;
+            readonly taskType: import("valibot").UnionSchema<[import("valibot").PicklistSchema<readonly ["feature", "bug", "document", "spike", "review", "ralph", "recurring"], undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, "Consumer id must be <namespace>:<name> (lowercase a-z0-9, dash-separated)">]>], undefined>;
+            readonly status: import("valibot").PicklistSchema<["planned", "ready", "in_progress", "blocked", "pr_ready", "done"], undefined>;
+            readonly progress: import("valibot").NumberSchema<undefined>;
+            readonly runId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly pullRequestUrl: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly dependsOn: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly autoStartDependents: import("valibot").BooleanSchema<undefined>;
+        }, undefined>;
+    };
+} & {
+    readonly minScope: "write";
+};
+/** Drop a dependency edge. Idempotent, for the same reason the add is. */
+export declare const removePublicTaskDependencyContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        taskId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ taskId }: {
+        taskId: string;
+    }) => string;
+    readonly requestBodySchema: import("valibot").ObjectSchema<{
+        readonly dependsOnTaskId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly taskId: import("valibot").StringSchema<undefined>;
+            readonly serviceId: import("valibot").StringSchema<undefined>;
+            readonly title: import("valibot").StringSchema<undefined>;
+            readonly description: import("valibot").StringSchema<undefined>;
+            readonly taskType: import("valibot").UnionSchema<[import("valibot").PicklistSchema<readonly ["feature", "bug", "document", "spike", "review", "ralph", "recurring"], undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, "Consumer id must be <namespace>:<name> (lowercase a-z0-9, dash-separated)">]>], undefined>;
+            readonly status: import("valibot").PicklistSchema<["planned", "ready", "in_progress", "blocked", "pr_ready", "done"], undefined>;
+            readonly progress: import("valibot").NumberSchema<undefined>;
+            readonly runId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly pullRequestUrl: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly dependsOn: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly autoStartDependents: import("valibot").BooleanSchema<undefined>;
+        }, undefined>;
+    };
+} & {
+    readonly minScope: "write";
+};
+/** The requirements documents attached to a task, in the order the agents read them. */
+export declare const listPublicTaskDocumentsContract: {
+    readonly method: "get";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        taskId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ taskId }: {
+        taskId: string;
+    }) => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly documents: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly source: import("valibot").PicklistSchema<["confluence", "notion", "github", "figma", "zeplin", "linear", "upload"], undefined>;
+                readonly externalId: import("valibot").StringSchema<undefined>;
+                readonly title: import("valibot").StringSchema<undefined>;
+                readonly url: import("valibot").StringSchema<undefined>;
+                readonly excerpt: import("valibot").StringSchema<undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    };
+} & {
+    readonly minScope: "read";
+};
+/**
+ * Attach a requirements document to an EXISTING task: the same two forms creation takes, at the
+ * moment a spec actually arrives.
+ */
+export declare const attachPublicTaskDocumentContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        taskId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ taskId }: {
+        taskId: string;
+    }) => string;
+    readonly requestBodySchema: import("valibot").ObjectSchema<{
+        readonly document: import("valibot").VariantSchema<"kind", [import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"source", undefined>;
+            readonly source: import("valibot").PicklistSchema<["confluence", "notion", "github", "figma", "zeplin", "linear"], undefined>;
+            readonly ref: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 500, undefined>]>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"upload", undefined>;
+            readonly title: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+            readonly content: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 100000, undefined>]>;
+        }, undefined>], undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 201: import("valibot").ObjectSchema<{
+            readonly source: import("valibot").PicklistSchema<["confluence", "notion", "github", "figma", "zeplin", "linear", "upload"], undefined>;
+            readonly externalId: import("valibot").StringSchema<undefined>;
+            readonly title: import("valibot").StringSchema<undefined>;
+            readonly url: import("valibot").StringSchema<undefined>;
+            readonly excerpt: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+} & {
+    readonly minScope: "write";
+};
+/**
+ * Detach a document from a task, naming it by the `(source, externalId)` pair the list serves.
+ *
+ * A POST rather than a `DELETE .../documents/{id}`: a document's identity is two values, one of
+ * which is a free-form external id that is a path for some sources (`docs/adr/0001.md`), so
+ * addressing it in a path segment would need escaping rules a caller has to get right to reach its
+ * own document.
+ */
+export declare const detachPublicTaskDocumentContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        taskId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ taskId }: {
+        taskId: string;
+    }) => string;
+    readonly requestBodySchema: import("valibot").ObjectSchema<{
+        readonly source: import("valibot").PicklistSchema<["confluence", "notion", "github", "figma", "zeplin", "linear", "upload"], undefined>;
+        readonly externalId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 500, undefined>]>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 204: typeof ContractNoBody;
+    };
+} & {
+    readonly minScope: "write";
+};
+//# sourceMappingURL=public-board.d.ts.map

package/dist/routes/public-board.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-board.d.ts","sourceRoot":"","sources":["../../src/routes/public-board.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqB,MAAM,yBAAyB,CAAA;AAsC3E;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOnC,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQvC,CAAA;AAID;;;;GAIG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAS3C,CAAA;AAED,0EAA0E;AAC1E,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAS9C,CAAA;AAID,wFAAwF;AACxF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ3C,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAS5C,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAS5C,CAAA"}

package/dist/routes/public-board.js

@@ -0,0 +1,112 @@
+import { ContractNoBody, defineApiContract } from '@toad-contracts/valibot';
+import { attachPublicTaskDocumentSchema, createPublicServiceSchema, detachPublicTaskDocumentSchema, publicAttachedDocumentListSchema, publicAttachedDocumentSchema, publicRepoListSchema, publicTaskDependencySchema, } from '../public-board.js';
+import { publicServiceSchema, publicTaskSchema } from '../public-api.js';
+import { errorResponses, singleStringParam, withMinScope } from './_shared.js';
+// ---------------------------------------------------------------------------
+// Board PROVISIONING and the two task relationships that outlive a create call, on `/api/v1`.
+//
+// Their own file rather than more of `public-api.ts`, which had grown to carry the whole surface:
+// these are one cohesive addition (what a headless deployment needs to SET UP and RELATE the board
+// it drives, as opposed to what it needs to run one task) and they share a scope argument that is
+// worth stating once.
+//
+// **Scope.** Service creation is `admin`; the task-level writes are `write`.
+//
+// The split follows what each act CHANGES rather than how destructive it feels. Creating a service
+// is board STRUCTURE, which is what `admin` already covers on this surface for keys and the
+// outbound webhook, and it is the rung a provisioning integration holds anyway. Attaching a
+// document, declaring an ordering: those edit ONE task the caller can already create, edit and
+// start with a `write` key, so putting them a rung higher would mean handing an integration that
+// files tickets a credential that can also merge pull requests and delete tasks.
+//
+// Where the two readings were close, the REVERSIBLE one wins (ADR 0034): a scope can be relaxed
+// later and never tightened, because narrowing what a live key may do is a break however small.
+// ---------------------------------------------------------------------------
+const taskIdParams = singleStringParam('taskId');
+// ---- provisioning: the repositories, and the services they back --------------
+/**
+ * List the repositories this workspace can back a service with.
+ *
+ * The discovery half of service creation, and what makes it usable with no browser: the create
+ * takes a provider repo id, and nothing on this surface served one. `read` scope, like every other
+ * discovery endpoint here (`/pipelines`, `/task-types`): it names what the workspace has already
+ * connected, and an integration must be able to see what it is about to ask for without holding the
+ * credential that could change it.
+ */
+export const listPublicReposContract = withMinScope('read', defineApiContract({
+    method: 'get',
+    pathResolver: () => '/api/v1/repos',
+    responsesByStatusCode: { 200: publicRepoListSchema, ...errorResponses },
+}));
+/**
+ * Create a board service, optionally backed by a repository: the last act of board setup that had
+ * no headless counterpart, so a deployment that could provision its own keys and enrol its own
+ * webhook still had to open the app once to have anywhere to file work.
+ *
+ * Delegates to the SAME service methods the app's own "import a repository" button and drag-drop
+ * call, so every guard holds identically: a whole-repo repository that already backs a service in
+ * this account is MOUNTED here rather than duplicated, a monorepo must name its subdirectory, and a
+ * subdirectory another service already claims is refused.
+ */
+export const createPublicServiceContract = withMinScope('admin', defineApiContract({
+    method: 'post',
+    pathResolver: () => '/api/v1/services',
+    requestBodySchema: createPublicServiceSchema,
+    responsesByStatusCode: { 201: publicServiceSchema, ...errorResponses },
+}));
+// ---- task ordering ----------------------------------------------------------
+/**
+ * Declare that this task must wait for another one. Idempotent: an edge that already exists is
+ * returned as-is rather than toggled off, which is what separates this from the app's own toggle
+ * and what lets a provisioning integration re-run without inverting the graph it declared last time.
+ */
+export const addPublicTaskDependencyContract = withMinScope('write', defineApiContract({
+    method: 'post',
+    requestPathParamsSchema: taskIdParams,
+    pathResolver: ({ taskId }) => `/api/v1/tasks/${taskId}/dependencies`,
+    requestBodySchema: publicTaskDependencySchema,
+    responsesByStatusCode: { 200: publicTaskSchema, ...errorResponses },
+}));
+/** Drop a dependency edge. Idempotent, for the same reason the add is. */
+export const removePublicTaskDependencyContract = withMinScope('write', defineApiContract({
+    method: 'post',
+    requestPathParamsSchema: taskIdParams,
+    pathResolver: ({ taskId }) => `/api/v1/tasks/${taskId}/dependencies/remove`,
+    requestBodySchema: publicTaskDependencySchema,
+    responsesByStatusCode: { 200: publicTaskSchema, ...errorResponses },
+}));
+// ---- a task's documents, after it exists -------------------------------------
+/** The requirements documents attached to a task, in the order the agents read them. */
+export const listPublicTaskDocumentsContract = withMinScope('read', defineApiContract({
+    method: 'get',
+    requestPathParamsSchema: taskIdParams,
+    pathResolver: ({ taskId }) => `/api/v1/tasks/${taskId}/documents`,
+    responsesByStatusCode: { 200: publicAttachedDocumentListSchema, ...errorResponses },
+}));
+/**
+ * Attach a requirements document to an EXISTING task: the same two forms creation takes, at the
+ * moment a spec actually arrives.
+ */
+export const attachPublicTaskDocumentContract = withMinScope('write', defineApiContract({
+    method: 'post',
+    requestPathParamsSchema: taskIdParams,
+    pathResolver: ({ taskId }) => `/api/v1/tasks/${taskId}/documents`,
+    requestBodySchema: attachPublicTaskDocumentSchema,
+    responsesByStatusCode: { 201: publicAttachedDocumentSchema, ...errorResponses },
+}));
+/**
+ * Detach a document from a task, naming it by the `(source, externalId)` pair the list serves.
+ *
+ * A POST rather than a `DELETE .../documents/{id}`: a document's identity is two values, one of
+ * which is a free-form external id that is a path for some sources (`docs/adr/0001.md`), so
+ * addressing it in a path segment would need escaping rules a caller has to get right to reach its
+ * own document.
+ */
+export const detachPublicTaskDocumentContract = withMinScope('write', defineApiContract({
+    method: 'post',
+    requestPathParamsSchema: taskIdParams,
+    pathResolver: ({ taskId }) => `/api/v1/tasks/${taskId}/documents/detach`,
+    requestBodySchema: detachPublicTaskDocumentSchema,
+    responsesByStatusCode: { 204: ContractNoBody, ...errorResponses },
+}));
+//# sourceMappingURL=public-board.js.map

package/dist/routes/public-board.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-board.js","sourceRoot":"","sources":["../../src/routes/public-board.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC3E,OAAO,EACL,8BAA8B,EAC9B,yBAAyB,EACzB,8BAA8B,EAC9B,gCAAgC,EAChC,4BAA4B,EAC5B,oBAAoB,EACpB,0BAA0B,GAC3B,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACxE,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAE9E,8EAA8E;AAC9E,8FAA8F;AAC9F,EAAE;AACF,kGAAkG;AAClG,mGAAmG;AACnG,kGAAkG;AAClG,sBAAsB;AACtB,EAAE;AACF,6EAA6E;AAC7E,EAAE;AACF,mGAAmG;AACnG,4FAA4F;AAC5F,4FAA4F;AAC5F,+FAA+F;AAC/F,iGAAiG;AACjG,iFAAiF;AACjF,EAAE;AACF,gGAAgG;AAChG,gGAAgG;AAChG,8EAA8E;AAE9E,MAAM,YAAY,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAA;AAEhD,iFAAiF;AAEjF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,YAAY,CACjD,MAAM,EACN,iBAAiB,CAAC;IAChB,MAAM,EAAE,KAAK;IACb,YAAY,EAAE,GAAG,EAAE,CAAC,eAAe;IACnC,qBAAqB,EAAE,EAAE,GAAG,EAAE,oBAAoB,EAAE,GAAG,cAAc,EAAE;CACxE,CAAC,CACH,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,YAAY,CACrD,OAAO,EACP,iBAAiB,CAAC;IAChB,MAAM,EAAE,MAAM;IACd,YAAY,EAAE,GAAG,EAAE,CAAC,kBAAkB;IACtC,iBAAiB,EAAE,yBAAyB;IAC5C,qBAAqB,EAAE,EAAE,GAAG,EAAE,mBAAmB,EAAE,GAAG,cAAc,EAAE;CACvE,CAAC,CACH,CAAA;AAED,gFAAgF;AAEhF;;;;GAIG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,YAAY,CACzD,OAAO,EACP,iBAAiB,CAAC;IAChB,MAAM,EAAE,MAAM;IACd,uBAAuB,EAAE,YAAY;IACrC,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,iBAAiB,MAAM,eAAe;IACpE,iBAAiB,EAAE,0BAA0B;IAC7C,qBAAqB,EAAE,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE;CACpE,CAAC,CACH,CAAA;AAED,0EAA0E;AAC1E,MAAM,CAAC,MAAM,kCAAkC,GAAG,YAAY,CAC5D,OAAO,EACP,iBAAiB,CAAC;IAChB,MAAM,EAAE,MAAM;IACd,uBAAuB,EAAE,YAAY;IACrC,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,iBAAiB,MAAM,sBAAsB;IAC3E,iBAAiB,EAAE,0BAA0B;IAC7C,qBAAqB,EAAE,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG,cAAc,EAAE;CACpE,CAAC,CACH,CAAA;AAED,iFAAiF;AAEjF,wFAAwF;AACxF,MAAM,CAAC,MAAM,+BAA+B,GAAG,YAAY,CACzD,MAAM,EACN,iBAAiB,CAAC;IAChB,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,YAAY;IACrC,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,iBAAiB,MAAM,YAAY;IACjE,qBAAqB,EAAE,EAAE,GAAG,EAAE,gCAAgC,EAAE,GAAG,cAAc,EAAE;CACpF,CAAC,CACH,CAAA;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,YAAY,CAC1D,OAAO,EACP,iBAAiB,CAAC;IAChB,MAAM,EAAE,MAAM;IACd,uBAAuB,EAAE,YAAY;IACrC,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,iBAAiB,MAAM,YAAY;IACjE,iBAAiB,EAAE,8BAA8B;IACjD,qBAAqB,EAAE,EAAE,GAAG,EAAE,4BAA4B,EAAE,GAAG,cAAc,EAAE;CAChF,CAAC,CACH,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,YAAY,CAC1D,OAAO,EACP,iBAAiB,CAAC;IAChB,MAAM,EAAE,MAAM;IACd,uBAAuB,EAAE,YAAY;IACrC,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,iBAAiB,MAAM,mBAAmB;IACxE,iBAAiB,EAAE,8BAA8B;IACjD,qBAAqB,EAAE,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,cAAc,EAAE;CAClE,CAAC,CACH,CAAA"}

package/dist/routes/public-evidence.d.ts

@@ -458,6 +458,7 @@ export declare const listPublicRunArtifactsContract: {
             readonly artifacts: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                 readonly artifactId: import("valibot").StringSchema<undefined>;
                 readonly kind: import("valibot").PicklistSchema<["screenshot", "reference"], undefined>;
+                readonly scope: import("valibot").PicklistSchema<["run", "task"], undefined>;
                 readonly view: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                 readonly contentType: import("valibot").StringSchema<undefined>;
                 readonly byteSize: import("valibot").NumberSchema<undefined>;

package/dist/routes/public-evidence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public-evidence.d.ts","sourceRoot":"","sources":["../../src/routes/public-evidence.ts"],"names":[],"mappings":"AAyBA;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQtC,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQvC,CAAA;AAED,oGAAoG;AACpG,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ1C,CAAA"}
+{"version":3,"file":"public-evidence.d.ts","sourceRoot":"","sources":["../../src/routes/public-evidence.ts"],"names":[],"mappings":"AAyBA;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQtC,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQvC,CAAA;AAED,oGAAoG;AACpG,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ1C,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/contracts",
-  "version": "0.275.0",
+  "version": "0.276.0",
   "description": "Valibot wire contract shared between the Agent Architecture Board frontend and backend.",
   "repository": {
     "type": "git",

package/dist/gate-parking.d.ts

@@ -1,30 +0,0 @@
-/**
- * Built-in gate kinds whose poll never times out because they are waiting on a HUMAN, so a step
- * carrying one can park the run indefinitely.
- *
- * Membership is equivalent to the gate's `pollExhaustion: 'rearm'` declaration, and
- * `@cat-factory/gates`' `human-wait-parity.test.ts` fails the build if the two ever disagree: a new
- * built-in gate that waits on a human cannot ship without being classified here.
- *
- * Only BUILT-IN gates are covered. A deployment that registers its own unbounded-wait gate is not
- * seen by the static rule (reading a registered gate's `pollExhaustion` means invoking its factory
- * with an engine context, which a request-time admission check has no business doing), so the run
- * is admitted and the park is answered in the app. Stated rather than silently assumed: see
- * ADR 0032.
- */
-export declare const HUMAN_WAIT_GATE_KINDS: ReadonlySet<string>;
-/**
- * Every gate kind the platform itself ships, human-wait and bounded alike.
- *
- * What it is FOR is the negative: a gate step whose kind is NOT in here was registered by the
- * DEPLOYMENT through the public `GateRegistry` seam, and the note above is why nothing outside
- * `@cat-factory/gates` can then say whether it ever ends on its own. That is a fact worth
- * REPORTING rather than one to silently assume either way — a run sitting on such a gate with an
- * empty public decision list is either mid-probe or waiting on a person forever, and only the
- * deployment that registered it knows which.
- *
- * Pinned by the same drift guard as {@link HUMAN_WAIT_GATE_KINDS}, derived from the built-in
- * registry, so a new built-in cannot ship without landing here.
- */
-export declare const BUILTIN_GATE_KINDS: ReadonlySet<string>;
-//# sourceMappingURL=gate-parking.d.ts.map

package/dist/gate-parking.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gate-parking.d.ts","sourceRoot":"","sources":["../src/gate-parking.ts"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,MAAM,CAIpD,CAAA;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAMjD,CAAA"}

package/dist/gate-parking.js

@@ -1,58 +0,0 @@
-// Which polling-GATE kinds park the run on a human, and are therefore a static park surface a
-// start path can refuse on.
-//
-// A gate is normally the opposite of a park: it probes a provider, escalates to a helper agent on a
-// negative verdict, and settles itself. One gate kind is different. `human-review` declares
-// `pollExhaustion: 'rearm'` with an effectively unbounded attempt budget, which is the engine's way
-// of saying "there is no deadline for a human reviewer": running out of polls is not a verdict, so
-// the step re-arms and the run waits indefinitely for a person on the PR.
-//
-// That makes it a human park in exactly the sense the public API's admission rule cares about, and
-// it is STATIC: the kind sits in the pipeline's step chain at save time, unlike an agent-raised
-// decision or a judge `park` disposition, which only exist once a run is under way.
-//
-// This lives in `contracts` rather than beside either consumer because the two packages that must
-// agree cannot see each other: `@cat-factory/server`'s public-API admission reads it, and
-// `@cat-factory/gates` (which owns the gate definitions and therefore the `pollExhaustion` values)
-// pins it with a drift guard. A shared constant is the only shape in which those two cannot
-// disagree. The same reasoning as `BUILTIN_GATABLE_KINDS` in `agent-gating.ts`.
-/**
- * Built-in gate kinds whose poll never times out because they are waiting on a HUMAN, so a step
- * carrying one can park the run indefinitely.
- *
- * Membership is equivalent to the gate's `pollExhaustion: 'rearm'` declaration, and
- * `@cat-factory/gates`' `human-wait-parity.test.ts` fails the build if the two ever disagree: a new
- * built-in gate that waits on a human cannot ship without being classified here.
- *
- * Only BUILT-IN gates are covered. A deployment that registers its own unbounded-wait gate is not
- * seen by the static rule (reading a registered gate's `pollExhaustion` means invoking its factory
- * with an engine context, which a request-time admission check has no business doing), so the run
- * is admitted and the park is answered in the app. Stated rather than silently assumed: see
- * ADR 0032.
- */
-export const HUMAN_WAIT_GATE_KINDS = new Set([
-    // Waits for a real human code review on the PR. `pollExhaustion: 'rearm'`, an effectively
-    // infinite attempt budget, and a notification (not a timeout) as the nudge.
-    'human-review',
-]);
-/**
- * Every gate kind the platform itself ships, human-wait and bounded alike.
- *
- * What it is FOR is the negative: a gate step whose kind is NOT in here was registered by the
- * DEPLOYMENT through the public `GateRegistry` seam, and the note above is why nothing outside
- * `@cat-factory/gates` can then say whether it ever ends on its own. That is a fact worth
- * REPORTING rather than one to silently assume either way — a run sitting on such a gate with an
- * empty public decision list is either mid-probe or waiting on a person forever, and only the
- * deployment that registered it knows which.
- *
- * Pinned by the same drift guard as {@link HUMAN_WAIT_GATE_KINDS}, derived from the built-in
- * registry, so a new built-in cannot ship without landing here.
- */
-export const BUILTIN_GATE_KINDS = new Set([
-    'ci',
-    'conflicts',
-    'post-release-health',
-    'human-review',
-    'doc-quality',
-]);
-//# sourceMappingURL=gate-parking.js.map

package/dist/gate-parking.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gate-parking.js","sourceRoot":"","sources":["../src/gate-parking.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,4BAA4B;AAC5B,EAAE;AACF,oGAAoG;AACpG,4FAA4F;AAC5F,oGAAoG;AACpG,mGAAmG;AACnG,0EAA0E;AAC1E,EAAE;AACF,mGAAmG;AACnG,gGAAgG;AAChG,oFAAoF;AACpF,EAAE;AACF,kGAAkG;AAClG,0FAA0F;AAC1F,mGAAmG;AACnG,4FAA4F;AAC5F,gFAAgF;AAEhF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAwB,IAAI,GAAG,CAAS;IACxE,0FAA0F;IAC1F,4EAA4E;IAC5E,cAAc;CACf,CAAC,CAAA;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAwB,IAAI,GAAG,CAAS;IACrE,IAAI;IACJ,WAAW;IACX,qBAAqB;IACrB,cAAc;IACd,aAAa;CACd,CAAC,CAAA"}