@qawolf/api-contracts 0.20.0 → 0.24.0

package/dist/v1/runner/identity.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const runnerNameSchema: z.ZodEnum<{
+    node20Basic: "node20Basic";
+    node20WithAndroid: "node20WithAndroid";
+    node20WithIos: "node20WithIos";
+    node20WithPlaywright: "node20WithPlaywright";
+}>;
+export type RunnerNameForPublicApi = z.infer<typeof runnerNameSchema>;
+export declare const runnerIdSchema: z.ZodString;
+/** The shared interactive runner shape. */
+export declare const makeRunnerSchema: () => z.ZodObject<{
+    gpuAccelerated: z.ZodBoolean;
+    id: z.ZodString;
+    runnerName: z.ZodEnum<{
+        node20Basic: "node20Basic";
+        node20WithAndroid: "node20WithAndroid";
+        node20WithIos: "node20WithIos";
+        node20WithPlaywright: "node20WithPlaywright";
+    }>;
+}, z.core.$strip>;
+//# sourceMappingURL=identity.d.ts.map

package/dist/v1/runner/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../../src/v1/runner/identity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB;;;;;EAK3B,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEtE,eAAO,MAAM,cAAc,aAOxB,CAAC;AAEJ,2CAA2C;AAC3C,eAAO,MAAM,gBAAgB;;;;;;;;;iBAazB,CAAC"}

package/dist/v1/runner/identity.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export const runnerNameSchema = z.enum([
+    "node20Basic",
+    "node20WithAndroid",
+    "node20WithIos",
+    "node20WithPlaywright",
+]);
+export const runnerIdSchema = z
+    .string()
+    .min(1)
+    .max(63)
+    .regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, "A runner id may contain only lowercase letters, digits and dashes, and must start and end with a letter or digit.");
+/** The shared interactive runner shape. */
+export const makeRunnerSchema = () => z.object({
+    gpuAccelerated: z
+        .boolean()
+        .describe("Whether the runner was placed on GPU hardware. Chosen by QA Wolf from the team's configuration and what the fleet can provide, not requested."),
+    id: runnerIdSchema.describe("The runner's id, as supplied when launching it."),
+    runnerName: runnerNameSchema.describe("The image requested when the runner was launched. QA Wolf may place it on faster hardware, reported in gpuAccelerated."),
+});
+//# sourceMappingURL=identity.js.map

package/dist/v1/runner/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.js","sourceRoot":"","sources":["../../../src/v1/runner/identity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,IAAI,CAAC;IACrC,aAAa;IACb,mBAAmB;IACnB,eAAe;IACf,sBAAsB;CACvB,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC;KAC5B,MAAM,EAAE;KACR,GAAG,CAAC,CAAC,CAAC;KACN,GAAG,CAAC,EAAE,CAAC;KACP,KAAK,CACJ,iCAAiC,EACjC,mHAAmH,CACpH,CAAC;AAEJ,2CAA2C;AAC3C,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAG,EAAE,CACnC,CAAC,CAAC,MAAM,CAAC;IACP,cAAc,EAAE,CAAC;SACd,OAAO,EAAE;SACT,QAAQ,CACP,+IAA+I,CAChJ;IACH,EAAE,EAAE,cAAc,CAAC,QAAQ,CACzB,iDAAiD,CAClD;IACD,UAAU,EAAE,gBAAgB,CAAC,QAAQ,CACnC,wHAAwH,CACzH;CACF,CAAC,CAAC"}

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

@@ -0,0 +1,45 @@
+import { z } from "zod";
+export declare const makeLaunchRunnerContract: () => {
+    readonly description: "Launch an interactive runner on the caller's team under an id the caller chooses. Launching the same id again returns the runner already running rather than starting a second one, and the same id with a different runnerName is refused. A runner is not permanent: it terminates on its own after a period of inactivity, and launching the same id after that starts and bills a new runner — so read `outcome` to tell which happened.";
+    readonly input: z.ZodObject<{
+        id: z.ZodString;
+        runnerName: z.ZodOptional<z.ZodEnum<{
+            node20Basic: "node20Basic";
+            node20WithAndroid: "node20WithAndroid";
+            node20WithIos: "node20WithIos";
+            node20WithPlaywright: "node20WithPlaywright";
+        }>>;
+    }, z.core.$strip>;
+    readonly kind: "write";
+    readonly name: "runner.launch";
+    readonly output: z.ZodObject<{
+        gpuAccelerated: z.ZodBoolean;
+        id: z.ZodString;
+        runnerName: z.ZodEnum<{
+            node20Basic: "node20Basic";
+            node20WithAndroid: "node20WithAndroid";
+            node20WithIos: "node20WithIos";
+            node20WithPlaywright: "node20WithPlaywright";
+        }>;
+        outcome: z.ZodEnum<{
+            launched: "launched";
+            "already-running": "already-running";
+        }>;
+    }, z.core.$strip>;
+};
+export declare const makeStopRunnerContract: () => {
+    readonly description: "Stop an interactive runner on the caller's team. Stopping a runner that is not running succeeds and reports `not-running`, so a retry needs no special handling.";
+    readonly input: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+    readonly kind: "write";
+    readonly name: "runner.stop";
+    readonly output: z.ZodObject<{
+        id: z.ZodString;
+        outcome: z.ZodEnum<{
+            stopped: "stopped";
+            "not-running": "not-running";
+        }>;
+    }, z.core.$strip>;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/v1/runner/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCpC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;CA0BlC,CAAC"}

package/dist/v1/runner/index.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { makeRunnerSchema, runnerIdSchema, runnerNameSchema, } from "./identity.js";
+export const makeLaunchRunnerContract = () => {
+    const input = z.object({
+        id: runnerIdSchema.describe("Id to launch the runner under, chosen by the caller. Launching the same id again returns the runner already running under it."),
+        runnerName: runnerNameSchema
+            .optional()
+            .describe("Image to run. Defaults to the standard web image, node20WithPlaywright."),
+    });
+    const output = makeRunnerSchema().extend({
+        outcome: z
+            .enum(["launched", "already-running"])
+            .describe("`launched` if this call started the runner. `already-running` if a runner was already running under this id and was returned unchanged — no second runner was started."),
+    });
+    return {
+        description: "Launch an interactive runner on the caller's team under an id the caller chooses. Launching the same id again returns the runner already running rather than starting a second one, and the same id with a different runnerName is refused. A runner is not permanent: it terminates on its own after a period of inactivity, and launching the same id after that starts and bills a new runner — so read `outcome` to tell which happened.",
+        input,
+        kind: "write",
+        name: "runner.launch",
+        output,
+    };
+};
+export const makeStopRunnerContract = () => {
+    const input = z.object({
+        id: runnerIdSchema.describe("Id of the runner to stop."),
+    });
+    const output = z.object({
+        id: runnerIdSchema.describe("Id of the runner the call addressed."),
+        outcome: z
+            .enum(["stopped", "not-running"])
+            .describe("`stopped` if the runner was running and has been stopped. `not-running` if no running runner has this id — it was already stopped, was never launched, or terminated on its own after inactivity; these are not distinguished, because the run system keeps no record of a runner once it is gone."),
+    });
+    return {
+        description: "Stop an interactive runner on the caller's team. Stopping a runner that is not running succeeds and reports `not-running`, so a retry needs no special handling.",
+        input,
+        kind: "write",
+        name: "runner.stop",
+        output,
+    };
+};
+//# sourceMappingURL=index.js.map

package/dist/v1/runner/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/v1/runner/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,gBAAgB,GACjB,MAAM,eAAe,CAAC;AAEvB,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAG,EAAE;IAC3C,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC;QACrB,EAAE,EAAE,cAAc,CAAC,QAAQ,CACzB,+HAA+H,CAChI;QACD,UAAU,EAAE,gBAAgB;aACzB,QAAQ,EAAE;aACV,QAAQ,CACP,yEAAyE,CAC1E;KACJ,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,gBAAgB,EAAE,CAAC,MAAM,CAAC;QACvC,OAAO,EAAE,CAAC;aACP,IAAI,CAAC,CAAC,UAAU,EAAE,iBAAiB,CAAC,CAAC;aACrC,QAAQ,CACP,wKAAwK,CACzK;KACJ,CAAC,CAAC;IAEH,OAAO;QACL,WAAW,EACT,8aAA8a;QAChb,KAAK;QACL,IAAI,EAAE,OAAO;QACb,IAAI,EAAE,eAAe;QACrB,MAAM;KAMP,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,EAAE;IACzC,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC;QACrB,EAAE,EAAE,cAAc,CAAC,QAAQ,CAAC,2BAA2B,CAAC;KACzD,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;QACtB,EAAE,EAAE,cAAc,CAAC,QAAQ,CAAC,sCAAsC,CAAC;QACnE,OAAO,EAAE,CAAC;aACP,IAAI,CAAC,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;aAChC,QAAQ,CACP,oSAAoS,CACrS;KACJ,CAAC,CAAC;IAEH,OAAO;QACL,WAAW,EACT,kKAAkK;QACpK,KAAK;QACL,IAAI,EAAE,OAAO;QACb,IAAI,EAAE,aAAa;QACnB,MAAM;KAMP,CAAC;AACJ,CAAC,CAAC"}

package/dist/v1/runner/journal.d.ts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+/**
+ * The wire shapes of a runner's journal: what a read asks for and what it
+ * answers with. One definition serves the writer, the server and the client,
+ * so an entry cannot come to mean different things along the way.
+ */
+/** One appended line in one stream's NDJSON file. */
+export type JournalEntry<Payload> = {
+    payload: Payload;
+    /** Wall clock at append, ISO 8601 in UTC. */
+    recordedAt: string;
+    /** Monotonic per stream, starting at 1; the read cursor. */
+    sequence: number;
+};
+/**
+ * zod treats an `unknown` field as an optional key, so without the refinement a
+ * line missing `payload` would parse to an entry whose payload is undefined
+ * under a type promising one.
+ */
+export declare const journalEntrySchema: z.ZodPipe<z.ZodObject<{
+    payload: z.ZodUnknown;
+    recordedAt: z.ZodISODateTime;
+    sequence: z.ZodNumber;
+}, z.core.$strip>, z.ZodTransform<JournalEntry<unknown>, {
+    payload: unknown;
+    recordedAt: string;
+    sequence: number;
+}>>;
+export declare const knownJournalStreams: readonly ["console", "recorder", "run-events", "run-logs", "run-status"];
+export type KnownJournalStream = (typeof knownJournalStreams)[number];
+/**
+ * An open set, so a later change can add a stream without breaking consumers;
+ * the `string & {}` arm keeps the known names as completions. An unwritten
+ * stream reads as empty, never as an error.
+ */
+export type JournalStream = KnownJournalStream | (string & {});
+/**
+ * A stream name doubles as a directory name under the journal root, so it is
+ * bounded in shape and length: outside this, a name could address a path
+ * outside the journal or fail at the filesystem with ENAMETOOLONG.
+ */
+export declare const maxJournalStreamNameLength = 64;
+export declare const journalStreamSchema: z.ZodString;
+/**
+ * A wire type, so the filters are optional fields rather than our usual
+ * `| undefined`: JSON has no undefined, and omission is the only way a client
+ * can not-supply one.
+ *
+ * The filters compose in one order: `runId` restricts, `sinceSequence` cuts
+ * strictly-after, `tail` keeps the newest N of what remains. With neither
+ * `sinceSequence` nor `tail`, the read starts from the oldest available entry.
+ */
+export type ReadJournalRequest = {
+    /** Restrict run-scoped streams (run-events, run-logs, run-status) to one run. */
+    runId?: string;
+    /** Entries strictly after this sequence. Omitted: from the oldest available. */
+    sinceSequence?: number;
+    stream: JournalStream;
+    /** Keep only the newest N of whatever the other filters matched. */
+    tail?: number;
+};
+/** `runId` is compared against every scanned entry, so it is bounded. */
+export declare const readJournalRequestSchema: z.ZodObject<{
+    runId: z.ZodOptional<z.ZodString>;
+    sinceSequence: z.ZodOptional<z.ZodNumber>;
+    stream: z.ZodString;
+    tail: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ReadJournalResponse = {
+    /** Exactly what {@link readJournalResponseSchema} parses to, so not readonly. */
+    entries: JournalEntry<unknown>[];
+    /**
+     * True when a `tail` read stopped at its scan budget with older history it
+     * never looked at: page forwards with `sinceSequence`, or narrow the filters.
+     * False means everything matching the request is in `entries`. Never set by
+     * the response's own entry cap, which `nextSequence` already reports.
+     */
+    hasUnsearchedHistory: boolean;
+    /**
+     * The cursor to continue from: the highest sequence this read examined, so a
+     * filtered read that matched nothing still advances.
+     */
+    nextSequence: number;
+    /**
+     * The oldest sequence still on disk, or 0 when the stream holds nothing. A
+     * `sinceSequence` below this means the size cap truncated history away.
+     */
+    oldestAvailableSequence: number;
+};
+export declare const readJournalResponseSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodPipe<z.ZodObject<{
+        payload: z.ZodUnknown;
+        recordedAt: z.ZodISODateTime;
+        sequence: z.ZodNumber;
+    }, z.core.$strip>, z.ZodTransform<JournalEntry<unknown>, {
+        payload: unknown;
+        recordedAt: string;
+        sequence: number;
+    }>>>;
+    hasUnsearchedHistory: z.ZodBoolean;
+    nextSequence: z.ZodNumber;
+    oldestAvailableSequence: z.ZodNumber;
+}, z.core.$strip>;
+//# sourceMappingURL=journal.d.ts.map

package/dist/v1/runner/journal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal.d.ts","sourceRoot":"","sources":["../../../src/v1/runner/journal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AAEH,qDAAqD;AACrD,MAAM,MAAM,YAAY,CAAC,OAAO,IAAI;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;GAgB5B,CAAC;AAEJ,eAAO,MAAM,mBAAmB,0EAMtB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtE;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,kBAAkB,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAE7C,eAAO,MAAM,mBAAmB,aAGE,CAAC;AAEnC;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,iFAAiF;IACjF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,aAAa,CAAC;IACtB,oEAAoE;IACpE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,yEAAyE;AACzE,eAAO,MAAM,wBAAwB;;;;;iBAKK,CAAC;AAE3C,MAAM,MAAM,mBAAmB,GAAG;IAChC,iFAAiF;IACjF,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC;IACjC;;;;;OAKG;IACH,oBAAoB,EAAE,OAAO,CAAC;IAC9B;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,uBAAuB,EAAE,MAAM,CAAC;CACjC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;iBAKK,CAAC"}

package/dist/v1/runner/journal.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+/**
+ * zod treats an `unknown` field as an optional key, so without the refinement a
+ * line missing `payload` would parse to an entry whose payload is undefined
+ * under a type promising one.
+ */
+export const journalEntrySchema = z
+    .object({
+    payload: z.unknown(),
+    recordedAt: z.iso.datetime(),
+    sequence: z.number().int().positive(),
+})
+    .refine((entry) => "payload" in entry, {
+    error: "A journal entry must carry a payload key.",
+    path: ["payload"],
+})
+    .transform((entry) => ({
+    payload: entry.payload,
+    recordedAt: entry.recordedAt,
+    sequence: entry.sequence,
+}));
+export const knownJournalStreams = [
+    "console",
+    "recorder",
+    "run-events",
+    "run-logs",
+    "run-status",
+];
+/**
+ * A stream name doubles as a directory name under the journal root, so it is
+ * bounded in shape and length: outside this, a name could address a path
+ * outside the journal or fail at the filesystem with ENAMETOOLONG.
+ */
+export const maxJournalStreamNameLength = 64;
+export const journalStreamSchema = z
+    .string()
+    .max(maxJournalStreamNameLength)
+    .regex(/^[a-z][a-z0-9-]{0,63}$/);
+/** `runId` is compared against every scanned entry, so it is bounded. */
+export const readJournalRequestSchema = z.object({
+    runId: z.string().min(1).max(128).optional(),
+    sinceSequence: z.number().int().nonnegative().optional(),
+    stream: journalStreamSchema,
+    tail: z.number().int().positive().optional(),
+});
+export const readJournalResponseSchema = z.object({
+    entries: z.array(journalEntrySchema),
+    hasUnsearchedHistory: z.boolean(),
+    nextSequence: z.number().int().nonnegative(),
+    oldestAvailableSequence: z.number().int().nonnegative(),
+});
+//# sourceMappingURL=journal.js.map

package/dist/v1/runner/journal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal.js","sourceRoot":"","sources":["../../../src/v1/runner/journal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC;KAChC,MAAM,CAAC;IACN,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;IACpB,UAAU,EAAE,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE;IAC5B,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;CACtC,CAAC;KACD,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,IAAI,KAAK,EAAE;IACrC,KAAK,EAAE,2CAA2C;IAClD,IAAI,EAAE,CAAC,SAAS,CAAC;CAClB,CAAC;KACD,SAAS,CACR,CAAC,KAAK,EAAyB,EAAE,CAAC,CAAC;IACjC,OAAO,EAAE,KAAK,CAAC,OAAO;IACtB,UAAU,EAAE,KAAK,CAAC,UAAU;IAC5B,QAAQ,EAAE,KAAK,CAAC,QAAQ;CACzB,CAAC,CACH,CAAC;AAEJ,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,SAAS;IACT,UAAU;IACV,YAAY;IACZ,UAAU;IACV,YAAY;CACJ,CAAC;AAWX;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,CAAC;AAE7C,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC;KACjC,MAAM,EAAE;KACR,GAAG,CAAC,0BAA0B,CAAC;KAC/B,KAAK,CAAC,wBAAwB,CAAC,CAAC;AAqBnC,yEAAyE;AACzE,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE;IAC5C,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;IACxD,MAAM,EAAE,mBAAmB;IAC3B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;CAC7C,CAAyC,CAAC;AAwB3C,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC;IACpC,oBAAoB,EAAE,CAAC,CAAC,OAAO,EAAE;IACjC,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IAC5C,uBAAuB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;CACxD,CAA0C,CAAC"}

package/dist/v1/runner/payloadSize.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+/**
+ * How much file content one request may carry, counted as UTF-8 bytes of every
+ * path and content. A bound on content rather than on the encoded request,
+ * because it is the half a client can apply while collecting — escaping can
+ * inflate the encoding severalfold, which
+ * {@link maxRunnerRequestEncodedByteLength} bounds on the way out.
+ */
+export declare const maxRunFilesByteLength: number;
+/**
+ * The largest request, JSON-encoded, that may be sent to a runner. Checked
+ * against the fully assembled request, so an oversized one is refused with a
+ * reason rather than failing opaquely in transport.
+ */
+export declare const maxRunnerRequestEncodedByteLength: number;
+/** UTF-8 bytes these files would carry. Compare against {@link maxRunFilesByteLength}. */
+export declare function runFilesByteLength(files: RunFiles): number;
+/**
+ * The files of one request, keyed by path: each path shippable, and all of the
+ * contents together inside the content cap. A record rather than an array of
+ * `{ path, content }` pairs: duplicates become unrepresentable, and the CLI can
+ * derive a flag from a record of strings but not from an array of objects.
+ */
+export declare const runFilesSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+/** Every file of one request, keyed by its path. */
+export type RunFiles = Record<string, string>;
+//# sourceMappingURL=payloadSize.d.ts.map

package/dist/v1/runner/payloadSize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payloadSize.d.ts","sourceRoot":"","sources":["../../../src/v1/runner/payloadSize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,QAAkB,CAAC;AAErD;;;;GAIG;AACH,eAAO,MAAM,iCAAiC,QAAkB,CAAC;AAEjE,0FAA0F;AAC1F,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAM1D;AAOD;;;;;GAKG;AACH,eAAO,MAAM,cAAc,uCAgBvB,CAAC;AAEL,oDAAoD;AACpD,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC"}

package/dist/v1/runner/payloadSize.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { isShippableRunFilePath, runFilePathRefusal } from "./files.js";
+/**
+ * How much file content one request may carry, counted as UTF-8 bytes of every
+ * path and content. A bound on content rather than on the encoded request,
+ * because it is the half a client can apply while collecting — escaping can
+ * inflate the encoding severalfold, which
+ * {@link maxRunnerRequestEncodedByteLength} bounds on the way out.
+ */
+export const maxRunFilesByteLength = 4 * 1024 * 1024;
+/**
+ * The largest request, JSON-encoded, that may be sent to a runner. Checked
+ * against the fully assembled request, so an oversized one is refused with a
+ * reason rather than failing opaquely in transport.
+ */
+export const maxRunnerRequestEncodedByteLength = 9 * 1024 * 1024;
+/** UTF-8 bytes these files would carry. Compare against {@link maxRunFilesByteLength}. */
+export function runFilesByteLength(files) {
+    return Object.entries(files).reduce((total, [path, content]) => total + utf8ByteLength(content) + utf8ByteLength(path), 0);
+}
+/** UTF-8 byte counts, so a non-Latin project is not undercounted severalfold. */
+function utf8ByteLength(text) {
+    return Buffer.byteLength(text, "utf8");
+}
+/**
+ * The files of one request, keyed by path: each path shippable, and all of the
+ * contents together inside the content cap. A record rather than an array of
+ * `{ path, content }` pairs: duplicates become unrepresentable, and the CLI can
+ * derive a flag from a record of strings but not from an array of objects.
+ */
+export const runFilesSchema = z
+    .record(z.string(), z.string())
+    // As a refinement, not a key schema: a key schema's message reaches the
+    // caller as a bare "invalid key in record".
+    .superRefine((files, refinementContext) => {
+    for (const path of Object.keys(files)) {
+        if (isShippableRunFilePath(path))
+            continue;
+        refinementContext.addIssue({
+            code: "custom",
+            message: runFilePathRefusal,
+            path: [path],
+        });
+    }
+})
+    .refine((files) => runFilesByteLength(files) <= maxRunFilesByteLength, {
+    error: `The files in one request may carry at most ${maxRunFilesByteLength} bytes in total.`,
+});
+//# sourceMappingURL=payloadSize.js.map

package/dist/v1/runner/payloadSize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payloadSize.js","sourceRoot":"","sources":["../../../src/v1/runner/payloadSize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAExE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;AAErD;;;;GAIG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;AAEjE,0FAA0F;AAC1F,MAAM,UAAU,kBAAkB,CAAC,KAAe;IAChD,OAAO,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,CACjC,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,EAAE,CACzB,KAAK,GAAG,cAAc,CAAC,OAAO,CAAC,GAAG,cAAc,CAAC,IAAI,CAAC,EACxD,CAAC,CACF,CAAC;AACJ,CAAC;AAED,iFAAiF;AACjF,SAAS,cAAc,CAAC,IAAY;IAClC,OAAO,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AACzC,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC;KAC5B,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;IAC/B,wEAAwE;IACxE,4CAA4C;KAC3C,WAAW,CAAC,CAAC,KAAK,EAAE,iBAAiB,EAAE,EAAE;IACxC,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACtC,IAAI,sBAAsB,CAAC,IAAI,CAAC;YAAE,SAAS;QAC3C,iBAAiB,CAAC,QAAQ,CAAC;YACzB,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,kBAAkB;YAC3B,IAAI,EAAE,CAAC,IAAI,CAAC;SACb,CAAC,CAAC;IACL,CAAC;AACH,CAAC,CAAC;KACD,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,kBAAkB,CAAC,KAAK,CAAC,IAAI,qBAAqB,EAAE;IACrE,KAAK,EAAE,8CAA8C,qBAAqB,kBAAkB;CAC7F,CAAC,CAAC"}

package/dist/v1/runner/performAction.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+/** How much of a failure reason this API passes on. */
+export declare const maxActionErrorMessageLength = 1000;
+export declare const makePerformActionOnRunnerContract: () => {
+    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). `performed` if the action took effect. `action-failed`, with a reason, if it reached the runner and did not take effect. `screen-needs-a-run` if the runner has not run anything yet, so its virtual desktop has never started. Waiting will not change this and retrying is pointless — call `runner.runFlow` on the runner, then ask for the screen again. 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. A `navigate` does not go through the screen, so a screen that is not ready does not stop it — but it still needs the runner to have run something, and until then it answers `action-failed` rather than `screen-needs-a-run`. `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 `node20WithPlaywright` 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 have stopped answering mid-action. This does not mean the action was not performed — take a screenshot before repeating it.";
+    readonly input: z.ZodObject<{
+        action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            button: z.ZodLiteral<"left" | "right" | "wheel" | "back" | "forward">;
+            type: z.ZodLiteral<"click">;
+            x: z.ZodInt;
+            y: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"double_click">;
+            x: z.ZodInt;
+            y: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            scroll_x: z.ZodInt;
+            scroll_y: z.ZodInt;
+            type: z.ZodLiteral<"scroll">;
+            x: z.ZodInt;
+            y: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"move">;
+            x: z.ZodInt;
+            y: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            path: z.ZodArray<z.ZodObject<{
+                x: z.ZodInt;
+                y: z.ZodInt;
+            }, z.core.$strict>>;
+            type: z.ZodLiteral<"drag">;
+        }, z.core.$strict>, z.ZodObject<{
+            keys: z.ZodArray<z.ZodString>;
+            type: z.ZodLiteral<"keypress">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"navigate">;
+            url: z.ZodURL;
+        }, z.core.$strict>, z.ZodObject<{
+            text: z.ZodString;
+            type: z.ZodLiteral<"type">;
+        }, z.core.$strict>], "type">;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    readonly kind: "write";
+    readonly name: "runner.performAction";
+    readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        outcome: z.ZodLiteral<"performed">;
+    }, z.core.$strip>, z.ZodObject<{
+        errorMessage: z.ZodString;
+        outcome: z.ZodLiteral<"action-failed">;
+    }, z.core.$strip>, z.ZodObject<{
+        outcome: z.ZodLiteral<"screen-needs-a-run">;
+    }, z.core.$strip>, z.ZodObject<{
+        outcome: z.ZodLiteral<"screen-not-ready">;
+    }, z.core.$strip>, z.ZodObject<{
+        outcome: z.ZodLiteral<"runner-has-no-screen">;
+    }, z.core.$strip>, z.ZodObject<{
+        outcome: z.ZodLiteral<"runner-unreachable">;
+    }, z.core.$strip>], "outcome">;
+};
+//# sourceMappingURL=performAction.d.ts.map

package/dist/v1/runner/performAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performAction.d.ts","sourceRoot":"","sources":["../../../src/v1/runner/performAction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqBxB,uDAAuD;AACvD,eAAO,MAAM,2BAA2B,OAAQ,CAAC;AAEjD,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmC7C,CAAC"}

package/dist/v1/runner/performAction.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { browserActionSchema } from "./browserAction.js";
+import { runnerIdSchema } from "./identity.js";
+import { runnerHasNoScreenDescription, runnerHasNoScreenSchema, runnerScreenNeedsARunSchema, runnerScreenNotReadySchema, screenNeedsARunDescription, screenNotReadyDescription, } from "./screen.js";
+import { runnerUnreachableSchema } from "./unreachable.js";
+// Not the shared retryable wording: the action may have taken effect before its
+// answer was lost.
+const unreachableDescription = "`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.";
+/** How much of a failure reason this API passes on. */
+export const maxActionErrorMessageLength = 1_000;
+export const makePerformActionOnRunnerContract = () => {
+    const input = z.object({
+        action: browserActionSchema.describe("The action to perform. Coordinates are pixels on the screenshot's own coordinate space."),
+        id: runnerIdSchema.describe("Id of the runner to act on."),
+    });
+    const output = z.discriminatedUnion("outcome", [
+        z.object({ outcome: z.literal("performed") }),
+        z.object({
+            errorMessage: z
+                .string()
+                .max(maxActionErrorMessageLength)
+                .describe("What stopped the action from taking effect."),
+            outcome: z.literal("action-failed"),
+        }),
+        runnerScreenNeedsARunSchema,
+        runnerScreenNotReadySchema,
+        runnerHasNoScreenSchema,
+        runnerUnreachableSchema,
+    ]);
+    return {
+        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). \`performed\` if the action took effect. \`action-failed\`, with a reason, if it reached the runner and did not take effect. ${screenNeedsARunDescription} ${screenNotReadyDescription} A \`navigate\` does not go through the screen, so a screen that is not ready does not stop it — but it still needs the runner to have run something, and until then it answers \`action-failed\` rather than \`screen-needs-a-run\`. ${runnerHasNoScreenDescription} ${unreachableDescription}`,
+        input,
+        kind: "write",
+        name: "runner.performAction",
+        output,
+    };
+};
+//# sourceMappingURL=performAction.js.map

package/dist/v1/runner/performAction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"performAction.js","sourceRoot":"","sources":["../../../src/v1/runner/performAction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EACL,4BAA4B,EAC5B,uBAAuB,EACvB,2BAA2B,EAC3B,0BAA0B,EAC1B,0BAA0B,EAC1B,yBAAyB,GAC1B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,gFAAgF;AAChF,mBAAmB;AACnB,MAAM,sBAAsB,GAC1B,mQAAmQ,CAAC;AAEtQ,uDAAuD;AACvD,MAAM,CAAC,MAAM,2BAA2B,GAAG,KAAK,CAAC;AAEjD,MAAM,CAAC,MAAM,iCAAiC,GAAG,GAAG,EAAE;IACpD,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC;QACrB,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAClC,yFAAyF,CAC1F;QACD,EAAE,EAAE,cAAc,CAAC,QAAQ,CAAC,6BAA6B,CAAC;KAC3D,CAAC,CAAC;IAEH,MAAM,MAAM,GAAG,CAAC,CAAC,kBAAkB,CAAC,SAAS,EAAE;QAC7C,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;QAC7C,CAAC,CAAC,MAAM,CAAC;YACP,YAAY,EAAE,CAAC;iBACZ,MAAM,EAAE;iBACR,GAAG,CAAC,2BAA2B,CAAC;iBAChC,QAAQ,CAAC,6CAA6C,CAAC;YAC1D,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,eAAe,CAAC;SACpC,CAAC;QACF,2BAA2B;QAC3B,0BAA0B;QAC1B,uBAAuB;QACvB,uBAAuB;KACxB,CAAC,CAAC;IAEH,OAAO;QACL,WAAW,EAAE,gkBAAgkB,0BAA0B,IAAI,yBAAyB,yOAAyO,4BAA4B,IAAI,sBAAsB,EAAE;QACr6B,KAAK;QACL,IAAI,EAAE,OAAO;QACb,IAAI,EAAE,sBAAsB;QAC5B,MAAM;KAMP,CAAC;AACJ,CAAC,CAAC"}

package/dist/v1/runner/readJournal.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+export declare const makeReadRunnerJournalContract: () => {
+    readonly description: "Read a window of one of an interactive runner's journal streams — the newest few, everything after a cursor, or everything belonging to one run. This is how a flow run's outcome and output are followed: `run-status` settles it, `run-logs` and `run-events` carry what it produced, and `recorder` carries the browser actions the runner recorded. A read counts as activity, so working through history does not get the runner reaped underneath you. `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<{
+        runId: z.ZodOptional<z.ZodString>;
+        sinceSequence: z.ZodOptional<z.ZodNumber>;
+        tail: z.ZodOptional<z.ZodNumber>;
+        id: z.ZodString;
+        stream: z.ZodString;
+    }, z.core.$strip>;
+    readonly kind: "read";
+    readonly name: "runner.readJournal";
+    readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        entries: z.ZodArray<z.ZodPipe<z.ZodObject<{
+            payload: z.ZodUnknown;
+            recordedAt: z.ZodISODateTime;
+            sequence: z.ZodNumber;
+        }, z.core.$strip>, z.ZodTransform<import("./journal.js").JournalEntry<unknown>, {
+            payload: unknown;
+            recordedAt: string;
+            sequence: number;
+        }>>>;
+        hasUnsearchedHistory: z.ZodBoolean;
+        nextSequence: z.ZodNumber;
+        oldestAvailableSequence: z.ZodNumber;
+        outcome: z.ZodLiteral<"read">;
+    }, z.core.$strip>, z.ZodObject<{
+        outcome: z.ZodLiteral<"runner-unreachable">;
+    }, z.core.$strip>], "outcome">;
+};
+//# sourceMappingURL=readJournal.d.ts.map

package/dist/v1/runner/readJournal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readJournal.d.ts","sourceRoot":"","sources":["../../../src/v1/runner/readJournal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBxB,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBzC,CAAC"}

package/dist/v1/runner/readJournal.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { runnerIdSchema } from "./identity.js";
+import { journalStreamSchema, knownJournalStreams, readJournalRequestSchema, readJournalResponseSchema, } from "./journal.js";
+import { retryableRunnerUnreachableDescription, runnerUnreachableSchema, } from "./unreachable.js";
+export const makeReadRunnerJournalContract = () => {
+    const input = readJournalRequestSchema.extend({
+        id: runnerIdSchema.describe("Id of the runner to read the journal of."),
+        stream: journalStreamSchema.describe(`The stream to read. QA Wolf writes ${knownJournalStreams.join(", ")}; an unwritten stream reads as empty rather than as an error.`),
+    });
+    const output = z.discriminatedUnion("outcome", [
+        readJournalResponseSchema.extend({ outcome: z.literal("read") }),
+        runnerUnreachableSchema,
+    ]);
+    return {
+        description: `Read a window of one of an interactive runner's journal streams — the newest few, everything after a cursor, or everything belonging to one run. This is how a flow run's outcome and output are followed: \`run-status\` settles it, \`run-logs\` and \`run-events\` carry what it produced, and \`recorder\` carries the browser actions the runner recorded. A read counts as activity, so working through history does not get the runner reaped underneath you. ${retryableRunnerUnreachableDescription}`,
+        input,
+        kind: "read",
+        name: "runner.readJournal",
+        output,
+    };
+};
+//# sourceMappingURL=readJournal.js.map

package/dist/v1/runner/readJournal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readJournal.js","sourceRoot":"","sources":["../../../src/v1/runner/readJournal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,qCAAqC,EACrC,uBAAuB,GACxB,MAAM,kBAAkB,CAAC;AAE1B,MAAM,CAAC,MAAM,6BAA6B,GAAG,GAAG,EAAE;IAChD,MAAM,KAAK,GAAG,wBAAwB,CAAC,MAAM,CAAC;QAC5C,EAAE,EAAE,cAAc,CAAC,QAAQ,CAAC,0CAA0C,CAAC;QACvE,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAClC,sCAAsC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,+DAA+D,CACpI;KACF,CAAC,CAAC;IAEH,MAAM,MAAM,GAAG,CAAC,CAAC,kBAAkB,CAAC,SAAS,EAAE;QAC7C,yBAAyB,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAChE,uBAAuB;KACxB,CAAC,CAAC;IAEH,OAAO;QACL,WAAW,EAAE,wcAAwc,qCAAqC,EAAE;QAC5f,KAAK;QACL,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,oBAAoB;QAC1B,MAAM;KAMP,CAAC;AACJ,CAAC,CAAC"}

package/dist/v1/runner/runFlow.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export declare const makeRunFlowOnRunnerContract: () => {
+    readonly description: "Run a flow on an interactive runner. Answers as soon as the run is accepted, with the id to follow it by — nothing waits for the run to finish. Which browser or device the run needs is read from the flow file's own execution target, so it is not supplied here; when it does not match what the runner is, the call answers `runner-target-mismatch` rather than failing partway through the run. `runner-unreachable` means the answer did not arrive, which is NOT the same as the run not having started: the runner may have accepted it and been too slow to say so, and resubmitting would start a second run that is billed and journalled alongside the first. Read the runner's `run-status` journal stream before resubmitting, and use the newest run id there if one appeared.";
+    readonly input: z.ZodObject<{
+        entryPointPath: z.ZodString;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        files: z.ZodRecord<z.ZodString, z.ZodString>;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    readonly kind: "write";
+    readonly name: "runner.runFlow";
+    readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        outcome: z.ZodLiteral<"submitted">;
+        runId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        outcome: z.ZodLiteral<"runner-unreachable">;
+    }, z.core.$strip>, z.ZodObject<{
+        outcome: z.ZodLiteral<"runner-target-mismatch">;
+        requiredRunnerName: z.ZodEnum<{
+            node20Basic: "node20Basic";
+            node20WithAndroid: "node20WithAndroid";
+            node20WithIos: "node20WithIos";
+            node20WithPlaywright: "node20WithPlaywright";
+        }>;
+        runnerName: z.ZodEnum<{
+            node20Basic: "node20Basic";
+            node20WithAndroid: "node20WithAndroid";
+            node20WithIos: "node20WithIos";
+            node20WithPlaywright: "node20WithPlaywright";
+        }>;
+    }, z.core.$strip>], "outcome">;
+};
+//# sourceMappingURL=runFlow.d.ts.map

package/dist/v1/runner/runFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runFlow.d.ts","sourceRoot":"","sources":["../../../src/v1/runner/runFlow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DvC,CAAC"}