@qawolf/api-contracts 0.42.0 → 0.48.0

package/dist/v1/index.d.ts

@@ -2,6 +2,7 @@ import type { z } from "zod";
 export { type AgentSessionStatus, agentSessionStatusSchema, } from "./agent/status.js";
 export { type AuthConfigResponse, authConfigResponse } from "./auth/config.js";
 export type { AnyPublicApiContract, PublicApiContract, PublicApiContractKind, } from "./definition.js";
+export { type EmailDirection, emailDirectionSchema } from "./email/resource.js";
 export { type IdentityResponse, identityResponse } from "./identity/index.js";
 export { type IdentityOrganizationsResponse, identityOrganizationsResponse, } from "./identity/organizations.js";
 export { type PublicIdSchema, type PublicIdSchemas, defaultIdSchemas, } from "./ids.js";
@@ -82,6 +83,164 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             url: z.ZodURL;
         }, z.core.$strip>;
     };
+    email: {
+        find: {
+            readonly description: "List the workspace's inbox, or its sent mail, newest first. Read a message body with email.get.";
+            readonly input: z.ZodObject<{
+                cursor: z.ZodOptional<z.ZodString>;
+                limit: z.ZodDefault<z.ZodNumber>;
+                address: z.ZodOptional<z.ZodEmail>;
+                createdAfter: z.ZodOptional<z.ZodISODateTime>;
+                direction: z.ZodDefault<z.ZodEnum<{
+                    inbound: "inbound";
+                    outbound: "outbound";
+                }>>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "email.find";
+            readonly output: z.ZodObject<{
+                emails: z.ZodArray<z.ZodObject<{
+                    createdAt: z.ZodISODateTime;
+                    direction: z.ZodEnum<{
+                        inbound: "inbound";
+                        outbound: "outbound";
+                    }>;
+                    from: z.ZodObject<{
+                        address: z.ZodString;
+                        name: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>;
+                    id: z.ZodString;
+                    subject: z.ZodOptional<z.ZodString>;
+                    to: z.ZodArray<z.ZodObject<{
+                        address: z.ZodString;
+                        name: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    url: z.ZodURL;
+                }, z.core.$strip>>;
+                nextCursor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        };
+        get: {
+            readonly description: "Read one email of the workspace, with its plain text and HTML bodies. Use it to pull a sign-in code or a verification link out of a message.";
+            readonly input: z.ZodObject<{
+                id: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "email.get";
+            readonly output: z.ZodObject<{
+                attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    fileName: z.ZodString;
+                    index: z.ZodNumber;
+                    type: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                bcc: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    address: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                cc: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    address: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                html: z.ZodOptional<z.ZodString>;
+                links: z.ZodArray<z.ZodString>;
+                replyTo: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    address: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                text: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodISODateTime;
+                direction: z.ZodEnum<{
+                    inbound: "inbound";
+                    outbound: "outbound";
+                }>;
+                from: z.ZodObject<{
+                    address: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                id: z.ZodString;
+                subject: z.ZodOptional<z.ZodString>;
+                to: z.ZodArray<z.ZodObject<{
+                    address: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+        getAttachment: {
+            readonly description: "Read one attachment of a workspace email as base64 content, by file name or by position. email.get lists both.";
+            readonly input: z.ZodObject<{
+                fileName: z.ZodOptional<z.ZodString>;
+                id: z.ZodString;
+                index: z.ZodOptional<z.ZodNumber>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "email.getAttachment";
+            readonly output: z.ZodObject<{
+                contentBase64: z.ZodString;
+                fileName: z.ZodString;
+                index: z.ZodNumber;
+                type: z.ZodOptional<z.ZodString>;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+        listAddresses: {
+            readonly description: "List the workspace's inbox addresses, alphabetical. A flow can sign up with a plus-suffixed form of any of them, and email.find reads what arrives.";
+            readonly input: z.ZodObject<{
+                cursor: z.ZodOptional<z.ZodString>;
+                limit: z.ZodDefault<z.ZodNumber>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "email.listAddresses";
+            readonly output: z.ZodObject<{
+                addresses: z.ZodArray<z.ZodObject<{
+                    address: z.ZodString;
+                    isDefault: z.ZodBoolean;
+                    url: z.ZodURL;
+                }, z.core.$strip>>;
+                nextCursor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        };
+        send: {
+            readonly description: "Send an email from one of the workspace's inbox addresses, for example to exercise a flow that reacts to incoming mail. Returns the sent email; read it back with email.get.";
+            readonly input: z.ZodObject<{
+                attachments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBase64>>;
+                bcc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+                cc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+                from: z.ZodOptional<z.ZodEmail>;
+                html: z.ZodOptional<z.ZodString>;
+                inReplyTo: z.ZodOptional<z.ZodString>;
+                replyTo: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+                subject: z.ZodString;
+                text: z.ZodOptional<z.ZodString>;
+                to: z.ZodArray<z.ZodEmail>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "email.send";
+            readonly output: z.ZodObject<{
+                createdAt: z.ZodISODateTime;
+                direction: z.ZodEnum<{
+                    inbound: "inbound";
+                    outbound: "outbound";
+                }>;
+                from: z.ZodObject<{
+                    address: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                id: z.ZodString;
+                subject: z.ZodOptional<z.ZodString>;
+                to: z.ZodArray<z.ZodObject<{
+                    address: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+    };
     environment: {
         create: {
             readonly description: "Create an environment on the caller's team and return it in the environment.get shape.";
@@ -961,6 +1120,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 filePath: z.ZodOptional<z.ZodString>;
                 files: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                 id: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.evaluateSnippet";
@@ -984,6 +1144,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             readonly description: "Report whether a runner is running under this id on the caller's team. This is a lookup: it never starts a runner, and it does not reset a runner's inactivity clock the way reading its journal does. An id that is not running is a success with `running: false` rather than an error, so this is how to check a runner is still there before addressing it.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "runner.get";
@@ -998,6 +1159,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             readonly input: z.ZodObject<{
                 id: z.ZodString;
                 selector: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.highlightSelector";
@@ -1026,6 +1188,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 npmDependencies: z.ZodRecord<z.ZodString, z.ZodString>;
                 packageName: z.ZodString;
                 packageVersion: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.importPackage";
@@ -1054,6 +1217,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                     variableName: z.ZodString;
                     what: z.ZodLiteral<"variable">;
                 }, z.core.$strip>], "what">;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "runner.inspect";
@@ -1094,6 +1258,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                     text: z.ZodString;
                     what: z.ZodLiteral<"elements">;
                 }, z.core.$strip>], "by">], "what">;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "runner.inspectMobile";
@@ -1283,6 +1448,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                     android: "android";
                     ios: "ios";
                 }>>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.launch";
@@ -1299,6 +1465,27 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 outcome: z.ZodLiteral<"success">;
             }, z.core.$strip>;
         };
+        list: {
+            readonly description: "List the runners running on the caller's team right now. A team API key already names the team and sends nothing; a credential bound to no single workspace names one in `workspaceId`. A runner that was terminated, or that terminated on its own after inactivity, is not listed, because the run system keeps no record of a runner once it is gone. This is a lookup: it never starts a runner, and it does not reset a runner's inactivity clock the way reading its journal does. It is how to find a runner launched from another machine or in an earlier session, when the id it was launched under is no longer at hand.";
+            readonly input: z.ZodObject<{
+                workspaceId: z.ZodOptional<WorkspaceId>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "runner.list";
+            readonly output: z.ZodObject<{
+                outcome: z.ZodLiteral<"success">;
+                runners: z.ZodArray<z.ZodObject<{
+                    gpuAccelerated: z.ZodBoolean;
+                    id: z.ZodString;
+                    runnerName: z.ZodEnum<{
+                        basic: "basic";
+                        playwright: "playwright";
+                        android: "android";
+                        ios: "ios";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
         performAction: {
             readonly description: "Perform one raw browser action on an interactive runner: click, double_click, move, drag, scroll, keypress, type, or navigate. Coordinates are whole pixels on the runner's virtual desktop, in the same space as `runner.takeScreenshot`. One action per request, and the runner serves one at a time. The action shapes follow the computer-use vocabulary, minus `screenshot` (use `runner.takeScreenshot`) and `wait` (delay on the caller's side). A success means the action took effect. `action-failed`, with a reason, if it reached the runner and did not take effect. On a runner image with a browser, the first action on a runner that has never run anything starts its browser and waits for it, so it can take up to a minute to answer — no `runner.runFlow` is needed before acting; if the browser is still starting when the wait runs out, the answer is `screen-not-ready` and retrying converges. On a mobile runner, the same `screen-needs-a-run` and `screen-not-ready` outcomes mean no Appium session has started yet, or it did not answer this instant; `runner.runFlow` is what starts one, same as a browser. `screen-needs-a-run` if the browser could not be started that way — usually a runner whose runs all finished without starting its desktop; call `runner.runFlow` with a flow that opens a browser. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. A `navigate` does not go through the screen, so a screen that is not ready does not stop it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `action-not-supported-on-mobile` if the runner is a mobile device and this action has no touchscreen equivalent: `double_click`, `scroll`, `move`, `keypress` and `navigate`, and a `click` whose `button` is not `left`, are all pointer-device concepts a touchscreen has nothing to offer for. `click` taps, `drag` swipes between its path's first and last point, and `type` types into whatever the last tap focused. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may have stopped answering mid-action. This does not mean the action was not performed — take a screenshot before repeating it.";
             readonly input: z.ZodObject<{
@@ -1338,6 +1525,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                     type: z.ZodLiteral<"type">;
                 }, z.core.$strict>], "type">;
                 id: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.performAction";
@@ -1364,6 +1552,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 baselinePath: z.ZodString;
                 id: z.ZodString;
                 screenshotPath: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.promoteSnapshot";
@@ -1386,6 +1575,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                 tail: z.ZodOptional<z.ZodNumber>;
                 id: z.ZodString;
                 stream: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "runner.readJournal";
@@ -1424,6 +1614,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
                     startLine: z.ZodInt;
                 }, z.core.$strip>>;
                 unchangedFiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.runFlow";
@@ -1459,6 +1650,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             readonly description: "Stop what a runner is currently executing, leaving the runner up and its browser on whatever page the run reached. Succeeds whether or not anything was running, and `wasRunning` says which. This is the counterpart of `runner.terminate`, which ends the runner itself. The run stops where it is, so the journal's `run-status` settles it as stopped rather than passed or failed. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. The stop may still have landed, but stopping a runner that is already idle does nothing, so retrying is safe.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.stopRun";
@@ -1476,6 +1668,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             readonly description: "Take one screenshot of an interactive runner's screen. On a runner with a browser the image is the whole virtual desktop, browser window and all. On a mobile runner it is the device's own screen, re-encoded to JPEG on the pod so this contract reads one image format regardless of runner family. `screen-needs-a-run` if the runner's virtual desktop has never started. Waiting will not change this and retrying is pointless — call `runner.runFlow` with a flow that opens a browser, then ask for the screen again. On a runner image with a browser that has never run anything, any `runner.performAction` also starts the browser itself. Evaluating a snippet does not start the desktop. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "runner.takeScreenshot";
@@ -1496,6 +1689,7 @@ export declare const makeContractsV1: <EnvironmentId extends PublicIdSchema, Flo
             readonly description: "End an interactive runner on the caller's team, and the pod it runs on with it. Terminating a runner that is not running succeeds and reports `wasRunning: false`. This ends the runner: use `runner.stopRun` to stop what a runner is currently executing while leaving the runner up.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
+                workspaceId: z.ZodOptional<WorkspaceId>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.terminate";
@@ -1608,6 +1802,164 @@ export declare const publicContractsV1: {
             url: z.ZodURL;
         }, z.core.$strip>;
     };
+    email: {
+        find: {
+            readonly description: "List the workspace's inbox, or its sent mail, newest first. Read a message body with email.get.";
+            readonly input: z.ZodObject<{
+                cursor: z.ZodOptional<z.ZodString>;
+                limit: z.ZodDefault<z.ZodNumber>;
+                address: z.ZodOptional<z.ZodEmail>;
+                createdAfter: z.ZodOptional<z.ZodISODateTime>;
+                direction: z.ZodDefault<z.ZodEnum<{
+                    inbound: "inbound";
+                    outbound: "outbound";
+                }>>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "email.find";
+            readonly output: z.ZodObject<{
+                emails: z.ZodArray<z.ZodObject<{
+                    createdAt: z.ZodISODateTime;
+                    direction: z.ZodEnum<{
+                        inbound: "inbound";
+                        outbound: "outbound";
+                    }>;
+                    from: z.ZodObject<{
+                        address: z.ZodString;
+                        name: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>;
+                    id: z.ZodString;
+                    subject: z.ZodOptional<z.ZodString>;
+                    to: z.ZodArray<z.ZodObject<{
+                        address: z.ZodString;
+                        name: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    url: z.ZodURL;
+                }, z.core.$strip>>;
+                nextCursor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        };
+        get: {
+            readonly description: "Read one email of the workspace, with its plain text and HTML bodies. Use it to pull a sign-in code or a verification link out of a message.";
+            readonly input: z.ZodObject<{
+                id: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "email.get";
+            readonly output: z.ZodObject<{
+                attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    fileName: z.ZodString;
+                    index: z.ZodNumber;
+                    type: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                bcc: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    address: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                cc: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    address: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                html: z.ZodOptional<z.ZodString>;
+                links: z.ZodArray<z.ZodString>;
+                replyTo: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    address: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                text: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodISODateTime;
+                direction: z.ZodEnum<{
+                    inbound: "inbound";
+                    outbound: "outbound";
+                }>;
+                from: z.ZodObject<{
+                    address: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                id: z.ZodString;
+                subject: z.ZodOptional<z.ZodString>;
+                to: z.ZodArray<z.ZodObject<{
+                    address: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+        getAttachment: {
+            readonly description: "Read one attachment of a workspace email as base64 content, by file name or by position. email.get lists both.";
+            readonly input: z.ZodObject<{
+                fileName: z.ZodOptional<z.ZodString>;
+                id: z.ZodString;
+                index: z.ZodOptional<z.ZodNumber>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "email.getAttachment";
+            readonly output: z.ZodObject<{
+                contentBase64: z.ZodString;
+                fileName: z.ZodString;
+                index: z.ZodNumber;
+                type: z.ZodOptional<z.ZodString>;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+        listAddresses: {
+            readonly description: "List the workspace's inbox addresses, alphabetical. A flow can sign up with a plus-suffixed form of any of them, and email.find reads what arrives.";
+            readonly input: z.ZodObject<{
+                cursor: z.ZodOptional<z.ZodString>;
+                limit: z.ZodDefault<z.ZodNumber>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "email.listAddresses";
+            readonly output: z.ZodObject<{
+                addresses: z.ZodArray<z.ZodObject<{
+                    address: z.ZodString;
+                    isDefault: z.ZodBoolean;
+                    url: z.ZodURL;
+                }, z.core.$strip>>;
+                nextCursor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        };
+        send: {
+            readonly description: "Send an email from one of the workspace's inbox addresses, for example to exercise a flow that reacts to incoming mail. Returns the sent email; read it back with email.get.";
+            readonly input: z.ZodObject<{
+                attachments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBase64>>;
+                bcc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+                cc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+                from: z.ZodOptional<z.ZodEmail>;
+                html: z.ZodOptional<z.ZodString>;
+                inReplyTo: z.ZodOptional<z.ZodString>;
+                replyTo: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+                subject: z.ZodString;
+                text: z.ZodOptional<z.ZodString>;
+                to: z.ZodArray<z.ZodEmail>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "write";
+            readonly name: "email.send";
+            readonly output: z.ZodObject<{
+                createdAt: z.ZodISODateTime;
+                direction: z.ZodEnum<{
+                    inbound: "inbound";
+                    outbound: "outbound";
+                }>;
+                from: z.ZodObject<{
+                    address: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                id: z.ZodString;
+                subject: z.ZodOptional<z.ZodString>;
+                to: z.ZodArray<z.ZodObject<{
+                    address: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                url: z.ZodURL;
+            }, z.core.$strip>;
+        };
+    };
     environment: {
         create: {
             readonly description: "Create an environment on the caller's team and return it in the environment.get shape.";
@@ -2487,6 +2839,7 @@ export declare const publicContractsV1: {
                 filePath: z.ZodOptional<z.ZodString>;
                 files: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                 id: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.evaluateSnippet";
@@ -2510,6 +2863,7 @@ export declare const publicContractsV1: {
             readonly description: "Report whether a runner is running under this id on the caller's team. This is a lookup: it never starts a runner, and it does not reset a runner's inactivity clock the way reading its journal does. An id that is not running is a success with `running: false` rather than an error, so this is how to check a runner is still there before addressing it.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "runner.get";
@@ -2524,6 +2878,7 @@ export declare const publicContractsV1: {
             readonly input: z.ZodObject<{
                 id: z.ZodString;
                 selector: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.highlightSelector";
@@ -2552,6 +2907,7 @@ export declare const publicContractsV1: {
                 npmDependencies: z.ZodRecord<z.ZodString, z.ZodString>;
                 packageName: z.ZodString;
                 packageVersion: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.importPackage";
@@ -2580,6 +2936,7 @@ export declare const publicContractsV1: {
                     variableName: z.ZodString;
                     what: z.ZodLiteral<"variable">;
                 }, z.core.$strip>], "what">;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "runner.inspect";
@@ -2620,6 +2977,7 @@ export declare const publicContractsV1: {
                     text: z.ZodString;
                     what: z.ZodLiteral<"elements">;
                 }, z.core.$strip>], "by">], "what">;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "runner.inspectMobile";
@@ -2809,6 +3167,7 @@ export declare const publicContractsV1: {
                     android: "android";
                     ios: "ios";
                 }>>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.launch";
@@ -2825,6 +3184,27 @@ export declare const publicContractsV1: {
                 outcome: z.ZodLiteral<"success">;
             }, z.core.$strip>;
         };
+        list: {
+            readonly description: "List the runners running on the caller's team right now. A team API key already names the team and sends nothing; a credential bound to no single workspace names one in `workspaceId`. A runner that was terminated, or that terminated on its own after inactivity, is not listed, because the run system keeps no record of a runner once it is gone. This is a lookup: it never starts a runner, and it does not reset a runner's inactivity clock the way reading its journal does. It is how to find a runner launched from another machine or in an earlier session, when the id it was launched under is no longer at hand.";
+            readonly input: z.ZodObject<{
+                workspaceId: z.ZodOptional<PublicIdSchema>;
+            }, z.core.$strip>;
+            readonly kind: "read";
+            readonly name: "runner.list";
+            readonly output: z.ZodObject<{
+                outcome: z.ZodLiteral<"success">;
+                runners: z.ZodArray<z.ZodObject<{
+                    gpuAccelerated: z.ZodBoolean;
+                    id: z.ZodString;
+                    runnerName: z.ZodEnum<{
+                        basic: "basic";
+                        playwright: "playwright";
+                        android: "android";
+                        ios: "ios";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        };
         performAction: {
             readonly description: "Perform one raw browser action on an interactive runner: click, double_click, move, drag, scroll, keypress, type, or navigate. Coordinates are whole pixels on the runner's virtual desktop, in the same space as `runner.takeScreenshot`. One action per request, and the runner serves one at a time. The action shapes follow the computer-use vocabulary, minus `screenshot` (use `runner.takeScreenshot`) and `wait` (delay on the caller's side). A success means the action took effect. `action-failed`, with a reason, if it reached the runner and did not take effect. On a runner image with a browser, the first action on a runner that has never run anything starts its browser and waits for it, so it can take up to a minute to answer — no `runner.runFlow` is needed before acting; if the browser is still starting when the wait runs out, the answer is `screen-not-ready` and retrying converges. On a mobile runner, the same `screen-needs-a-run` and `screen-not-ready` outcomes mean no Appium session has started yet, or it did not answer this instant; `runner.runFlow` is what starts one, same as a browser. `screen-needs-a-run` if the browser could not be started that way — usually a runner whose runs all finished without starting its desktop; call `runner.runFlow` with a flow that opens a browser. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. A `navigate` does not go through the screen, so a screen that is not ready does not stop it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `action-not-supported-on-mobile` if the runner is a mobile device and this action has no touchscreen equivalent: `double_click`, `scroll`, `move`, `keypress` and `navigate`, and a `click` whose `button` is not `left`, are all pointer-device concepts a touchscreen has nothing to offer for. `click` taps, `drag` swipes between its path's first and last point, and `type` types into whatever the last tap focused. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may have stopped answering mid-action. This does not mean the action was not performed — take a screenshot before repeating it.";
             readonly input: z.ZodObject<{
@@ -2864,6 +3244,7 @@ export declare const publicContractsV1: {
                     type: z.ZodLiteral<"type">;
                 }, z.core.$strict>], "type">;
                 id: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.performAction";
@@ -2890,6 +3271,7 @@ export declare const publicContractsV1: {
                 baselinePath: z.ZodString;
                 id: z.ZodString;
                 screenshotPath: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.promoteSnapshot";
@@ -2912,6 +3294,7 @@ export declare const publicContractsV1: {
                 tail: z.ZodOptional<z.ZodNumber>;
                 id: z.ZodString;
                 stream: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "runner.readJournal";
@@ -2950,6 +3333,7 @@ export declare const publicContractsV1: {
                     startLine: z.ZodInt;
                 }, z.core.$strip>>;
                 unchangedFiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.runFlow";
@@ -2985,6 +3369,7 @@ export declare const publicContractsV1: {
             readonly description: "Stop what a runner is currently executing, leaving the runner up and its browser on whatever page the run reached. Succeeds whether or not anything was running, and `wasRunning` says which. This is the counterpart of `runner.terminate`, which ends the runner itself. The run stops where it is, so the journal's `run-status` settles it as stopped rather than passed or failed. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. The stop may still have landed, but stopping a runner that is already idle does nothing, so retrying is safe.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.stopRun";
@@ -3002,6 +3387,7 @@ export declare const publicContractsV1: {
             readonly description: "Take one screenshot of an interactive runner's screen. On a runner with a browser the image is the whole virtual desktop, browser window and all. On a mobile runner it is the device's own screen, re-encoded to JPEG on the pod so this contract reads one image format regardless of runner family. `screen-needs-a-run` if the runner's virtual desktop has never started. Waiting will not change this and retrying is pointless — call `runner.runFlow` with a flow that opens a browser, then ask for the screen again. On a runner image with a browser that has never run anything, any `runner.performAction` also starts the browser itself. Evaluating a snippet does not start the desktop. `screen-not-ready` if the runner has a screen that cannot serve this instant. Retry in a second or two: the desktop restarts when a run changes the display size, and it serves one see-or-act request at a time, so a screenshot or action already in flight is the usual reason. Do not submit a run to clear this — a run may restart the display and discard what is on it. `runner-has-no-screen` if this runner is not one that runs a browser on a virtual desktop. Nothing about it can be seen or driven, and retrying will never help — launch a `playwright` runner instead. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "read";
             readonly name: "runner.takeScreenshot";
@@ -3022,6 +3408,7 @@ export declare const publicContractsV1: {
             readonly description: "End an interactive runner on the caller's team, and the pod it runs on with it. Terminating a runner that is not running succeeds and reports `wasRunning: false`. This ends the runner: use `runner.stopRun` to stop what a runner is currently executing while leaving the runner up.";
             readonly input: z.ZodObject<{
                 id: z.ZodString;
+                workspaceId: z.ZodOptional<PublicIdSchema>;
             }, z.core.$strip>;
             readonly kind: "write";
             readonly name: "runner.terminate";

package/dist/v1/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/v1/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,EACL,KAAK,kBAAkB,EACvB,wBAAwB,GACzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC/E,YAAY,EACV,oBAAoB,EACpB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC9E,OAAO,EACL,KAAK,6BAA6B,EAClC,6BAA6B,GAC9B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,gBAAgB,GACjB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACzD,cAAc,sBAAsB,CAAC;AAKrC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAe5D,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,iBAAiB,EAEvB,MAAM,UAAU,CAAC;AA8BlB,MAAM,MAAM,cAAc,CAAC,GAAG,SAAS,oBAAoB,IAAI,CAAC,CAAC,KAAK,CACpE,GAAG,CAAC,OAAO,CAAC,CACb,CAAC;AAEF,MAAM,MAAM,eAAe,CAAC,GAAG,SAAS,oBAAoB,IAAI,CAAC,CAAC,KAAK,CACrE,GAAG,CAAC,QAAQ,CAAC,CACd,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAC1B,aAAa,SAAS,cAAc,EACpC,MAAM,SAAS,cAAc,EAC7B,KAAK,SAAS,cAAc,EAC5B,YAAY,SAAS,cAAc,GAAG,cAAc,EACpD,OAAO,SAAS,cAAc,GAAG,cAAc,EAC/C,WAAW,SAAS,cAAc,GAAG,cAAc,EACnD,QAAQ,SAAS,cAAc,GAAG,cAAc,EAChD,aAAa,SAAS,cAAc,GAAG,cAAc,EAErD,KAAK,iBAAiB,CACpB,aAAa,EACb,MAAM,EACN,KAAK,EACL,YAAY,EACZ,OAAO,EACP,WAAW,EACX,QAAQ,EACR,aAAa,CACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+DF,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/v1/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,EACL,KAAK,kBAAkB,EACvB,wBAAwB,GACzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC/E,YAAY,EACV,oBAAoB,EACpB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,cAAc,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC9E,OAAO,EACL,KAAK,6BAA6B,EAClC,6BAA6B,GAC9B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,gBAAgB,GACjB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACzD,cAAc,sBAAsB,CAAC;AAKrC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAoB5D,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,iBAAiB,EAEvB,MAAM,UAAU,CAAC;AA+BlB,MAAM,MAAM,cAAc,CAAC,GAAG,SAAS,oBAAoB,IAAI,CAAC,CAAC,KAAK,CACpE,GAAG,CAAC,OAAO,CAAC,CACb,CAAC;AAEF,MAAM,MAAM,eAAe,CAAC,GAAG,SAAS,oBAAoB,IAAI,CAAC,CAAC,KAAK,CACrE,GAAG,CAAC,QAAQ,CAAC,CACd,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAC1B,aAAa,SAAS,cAAc,EACpC,MAAM,SAAS,cAAc,EAC7B,KAAK,SAAS,cAAc,EAC5B,YAAY,SAAS,cAAc,GAAG,cAAc,EACpD,OAAO,SAAS,cAAc,GAAG,cAAc,EAC/C,WAAW,SAAS,cAAc,GAAG,cAAc,EACnD,QAAQ,SAAS,cAAc,GAAG,cAAc,EAChD,aAAa,SAAS,cAAc,GAAG,cAAc,EAErD,KAAK,iBAAiB,CACpB,aAAa,EACb,MAAM,EACN,KAAK,EACL,YAAY,EACZ,OAAO,EACP,WAAW,EACX,QAAQ,EACR,aAAa,CACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEF,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoC,CAAC"}