@wjarka/cezarion 0.16.0-dev.1505 → 0.16.0-pr929.1508

package/dist/ci-wait/controller.d.ts

@@ -50,17 +50,11 @@ export declare function ciToolRoutes(capabilities: Map<string, Capability>): imp
     "/api/v1/tools/ci-wait": {
         $post: {
             output: {
-                prUrl: string;
-                repository: string;
-                prNumber: number;
-                headSha: string;
-                waitId: string;
-                registeredAt: string;
-                deadline: string;
-                phase: "delivered" | "parked" | "registered" | "wake-pending" | "withdrawn";
+                code: 'capability_revoked';
+                message: string;
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 401;
             input: {
                 json: {
                     pr: string;
@@ -69,11 +63,11 @@ export declare function ciToolRoutes(capabilities: Map<string, Capability>): imp
             };
         } | {
             output: {
-                code: 'capability_revoked';
+                code: "authentication" | "capability_revoked" | "capacity" | "command_failed" | "finish_requested" | "generation_mismatch" | "gh_missing" | "human_ask_pending" | "human_ask_unanswered" | "inaccessible_pr" | "invalid_request" | "malformed_data" | "manager_disposed" | "output_limit" | "persistence" | "query_timeout" | "registration_aborted" | "root_finish_pending" | "run_cancelled" | "run_missing" | "run_not_running" | "run_stopping" | "session_closed" | "session_replaced" | "turn_changed" | "unauthorized" | "unavailable" | "unsupported_host" | "wait_conflict" | "worker_execution_stopped" | "worker_wait_pending";
                 message: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 503;
             input: {
                 json: {
                     pr: string;
@@ -82,11 +76,17 @@ export declare function ciToolRoutes(capabilities: Map<string, Capability>): imp
             };
         } | {
             output: {
-                code: "authentication" | "capability_revoked" | "capacity" | "command_failed" | "finish_requested" | "generation_mismatch" | "gh_missing" | "human_ask_pending" | "human_ask_unanswered" | "inaccessible_pr" | "invalid_request" | "malformed_data" | "manager_disposed" | "output_limit" | "persistence" | "query_timeout" | "registration_aborted" | "root_finish_pending" | "run_cancelled" | "run_missing" | "run_not_running" | "run_stopping" | "session_closed" | "session_replaced" | "turn_changed" | "unauthorized" | "unavailable" | "unsupported_host" | "wait_conflict" | "worker_execution_stopped" | "worker_wait_pending";
-                message: string;
+                prUrl: string;
+                repository: string;
+                prNumber: number;
+                headSha: string;
+                waitId: string;
+                registeredAt: string;
+                deadline: string;
+                phase: "delivered" | "parked" | "registered" | "wake-pending" | "withdrawn";
             };
             outputFormat: "json";
-            status: 503;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
             input: {
                 json: {
                     pr: string;
@@ -99,13 +99,11 @@ export declare function ciToolRoutes(capabilities: Map<string, Capability>): imp
     "/api/v1/tools/preview-stop": {
         $post: {
             output: {
-                ok: boolean;
-                code: "adopted" | "approval_required" | "headless" | "invalid_input" | "not_registered" | "port_held" | "port_in_use" | "preview_disabled" | "restarted" | "stopped" | "unavailable" | "worktree_missing";
+                code: 'capability_revoked';
                 message: string;
-                hint: string;
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 401;
             input: {
                 json: {
                     port: number;
@@ -114,11 +112,13 @@ export declare function ciToolRoutes(capabilities: Map<string, Capability>): imp
             };
         } | {
             output: {
-                code: 'capability_revoked';
+                ok: boolean;
+                code: "adopted" | "approval_required" | "headless" | "invalid_input" | "not_registered" | "port_held" | "port_in_use" | "preview_disabled" | "restarted" | "stopped" | "unavailable" | "worktree_missing";
                 message: string;
+                hint: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
             input: {
                 json: {
                     port: number;
@@ -131,13 +131,11 @@ export declare function ciToolRoutes(capabilities: Map<string, Capability>): imp
     "/api/v1/tools/preview-serve": {
         $post: {
             output: {
-                ok: boolean;
-                code: "cezar_port" | "cwd_outside_worktree" | "headless" | "invalid_input" | "port_held" | "preview_disabled" | "registered" | "replaced" | "too_many" | "unavailable" | "worktree_missing";
+                code: 'capability_revoked';
                 message: string;
-                hint: string;
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 401;
             input: {
                 json: {
                     command: string;
@@ -149,11 +147,13 @@ export declare function ciToolRoutes(capabilities: Map<string, Capability>): imp
             };
         } | {
             output: {
-                code: 'capability_revoked';
+                ok: boolean;
+                code: "cezar_port" | "cwd_outside_worktree" | "headless" | "invalid_input" | "port_held" | "preview_disabled" | "registered" | "replaced" | "too_many" | "unavailable" | "worktree_missing";
                 message: string;
+                hint: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
             input: {
                 json: {
                     command: string;

package/dist/contract/index.d.ts

@@ -26,3 +26,5 @@ export * from './conversations.ts';
 export * from './ci-wait.ts';
 export * from './artifacts.ts';
 export * from './discovery.ts';
+export * from './live.ts';
+export * from './live-coordination.ts';

package/dist/contract/index.js

@@ -1410,6 +1410,9 @@ var previewClientMessageSchema = z12.discriminatedUnion("t", [
   /** Never spawns anything: a silent port answers with `needs-approval`. */
   z12.object({
     t: z12.literal("open"),
+    /** Automatic reconnects may reclaim only this pane's last ownership. */
+    viewerId: z12.string().min(1).max(128).optional(),
+    resume: z12.boolean().optional(),
     target: z12.union([z12.object({ port }), z12.object({ url: z12.string().min(1).max(2048) })])
   }),
   /** The owner's explicit approval; the only message that runs a registered command. */
@@ -2643,6 +2646,8 @@ var fsBrowseResponseSchema = z16.object({
 var launchKeyResponseSchema = z16.object({
   key: z16.string()
 });
+var checkoutProgressParamsSchema = z16.object({ checkoutId: z16.string().min(1).max(128) });
+var checkoutProgressResponseSchema = z16.object({ progress: checkoutProgressEventSchema.nullable() });
 
 // ../contract/src/skills.ts
 import { z as z17 } from "zod";
@@ -3282,6 +3287,81 @@ var fileLinkResultSchema = z22.union([
 var artifactListSchema = z22.object({ artifacts: z22.array(publishedArtifactSchema).max(64) }).strict();
 var fileLinkQuerySchema = z22.object({ path: pathSchema, raw: z22.literal("1").optional() }).strict();
 var artifactParamsSchema = z22.object({ id: z22.uuid(), artifactId: z22.uuid() });
+
+// ../contract/src/live.ts
+import { z as z23 } from "zod";
+var LIVE_RUN_LIMIT = 32;
+var LIVE_EVENT_LIMIT = 256;
+var LIVE_BYTE_LIMIT = 1024 * 1024;
+var liveRunDemandSchema = z23.object({
+  projectId: z23.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/),
+  runId: runIdParamSchema.shape.id,
+  cursor: runHistoryCursorSchema.optional(),
+  afterSeq: z23.number().int().nonnegative().safe()
+});
+var liveRunsRequestSchema = z23.object({
+  runs: z23.array(liveRunDemandSchema).min(1).max(LIVE_RUN_LIMIT)
+}).refine(({ runs }) => new Set(runs.map((r) => `${r.projectId}/${r.runId}`)).size === runs.length, {
+  message: "duplicate run demand"
+});
+var identity = liveRunDemandSchema.pick({ projectId: true, runId: true });
+var liveRunErrorSchema = identity.extend({
+  type: z23.enum(["error", "reset"]),
+  status: z23.union([z23.literal(400), z23.literal(404), z23.literal(409), z23.literal(413), z23.literal(503)]),
+  error: z23.string()
+});
+var liveRunBatchSchema = identity.extend({
+  type: z23.literal("batch"),
+  events: z23.array(runHistoryEventSchema).max(LIVE_EVENT_LIMIT),
+  cursor: runHistoryCursorSchema,
+  afterSeq: z23.number().int().nonnegative(),
+  hasMore: z23.boolean()
+});
+var liveRunBatchResultSchema = z23.union([liveRunBatchSchema, liveRunErrorSchema]);
+var liveRunBatchResponseSchema = z23.object({
+  generation: z23.string(),
+  results: z23.array(liveRunBatchResultSchema)
+});
+var liveRunFrameSchema = z23.union([
+  z23.object({ type: z23.literal("ready"), generation: z23.string() }),
+  z23.object({ type: z23.literal("ping") }),
+  identity.extend({ type: z23.literal("event"), name: z23.enum(["run-event", "ui-event"]), event: runHistoryEventSchema }),
+  liveRunErrorSchema
+]);
+
+// ../contract/src/live-coordination.ts
+import { z as z24 } from "zod";
+var LIVE_PROTOCOL = 1;
+var LIVE_WORKER_NAME = "cezar-live-v1";
+var LEASE_MS = 15e3;
+var RENEW_MS = 5e3;
+function allowedLiveRead(path) {
+  if (!path.startsWith("/api/v1/") || path.includes("#") || /[\\\r\n]/.test(path)) return false;
+  return /^\/api\/v1\/(?:workspace\/(?:runs-index|skills-update)|p\/[a-zA-Z0-9_-]+\/(?:runs\/[a-zA-Z0-9._-]+\/(?:changes|commits)|github(?:\/(?:checks|ref-status))?))(?:\?[^#]*)?$/.test(path);
+}
+var liveDemandSchema = z24.discriminatedUnion("kind", [
+  z24.object({ kind: z24.literal("workspace") }),
+  liveRunDemandSchema.extend({ kind: z24.literal("run") }),
+  z24.object({ kind: z24.literal("topic"), topic: z24.string().min(1).max(128) }),
+  z24.object({ kind: z24.literal("read"), path: z24.string().max(4096).refine(allowedLiveRead), intervalMs: z24.number().int().min(1e3).max(3e5) })
+]);
+var liveEntrySchema = z24.object({ id: z24.string().min(1).max(128), demand: liveDemandSchema });
+var envelope = z24.object({ version: z24.literal(LIVE_PROTOCOL), documentId: z24.string().min(1).max(128), epoch: z24.number().int().nonnegative() });
+var ownerInputSchema = z24.discriminatedUnion("type", [
+  envelope.extend({ type: z24.literal("sync"), entries: z24.array(liveEntrySchema).max(64) }).refine((value) => new Set(value.entries.map((e) => e.id)).size === value.entries.length),
+  envelope.extend({ type: z24.literal("ack"), id: z24.string(), seq: z24.number().int().nonnegative() }),
+  envelope.extend({ type: z24.literal("refresh"), id: z24.string() })
+]);
+var wireFrameSchema = z24.object({ event: z24.string(), data: z24.string(), id: z24.string() });
+var ownerOutputSchema = z24.discriminatedUnion("type", [
+  z24.object({ type: z24.literal("unavailable"), version: z24.literal(LIVE_PROTOCOL), epoch: z24.number(), reason: z24.string() }),
+  z24.object({ type: z24.literal("hello"), version: z24.literal(LIVE_PROTOCOL) }),
+  z24.object({ type: z24.literal("alive"), version: z24.literal(LIVE_PROTOCOL), epoch: z24.number() }),
+  z24.object({ type: z24.literal("frame"), version: z24.literal(LIVE_PROTOCOL), epoch: z24.number(), id: z24.string(), frame: z24.union([wireFrameSchema, liveRunFrameSchema]) }),
+  z24.object({ type: z24.literal("value"), version: z24.literal(LIVE_PROTOCOL), epoch: z24.number(), id: z24.string(), value: z24.unknown(), error: z24.string().optional() }),
+  z24.object({ type: z24.literal("reset"), version: z24.literal(LIVE_PROTOCOL), epoch: z24.number(), id: z24.string(), reason: z24.string() })
+]);
+var runKey = (run) => `${run.projectId}/${run.runId}`;
 export {
   ARCHIVED_RUNS_PAGE_DEFAULT,
   ARCHIVED_RUNS_PAGE_MAX,
@@ -3293,12 +3373,19 @@ export {
   EFFORT_LEVELS,
   FILE_ATTACHMENT_MEDIA_TYPES,
   GITHUB_SEARCH_MAX,
+  LEASE_MS,
+  LIVE_BYTE_LIMIT,
+  LIVE_EVENT_LIMIT,
+  LIVE_PROTOCOL,
+  LIVE_RUN_LIMIT,
+  LIVE_WORKER_NAME,
   MODEL_DISCOVERY_RUNNERS,
   PROJECT_TAGS_MAX,
   PROJECT_TAG_MAX_LENGTH,
   PROJECT_WEBHOOK_TOKEN_MAX_LENGTH,
   PROJECT_WEBHOOK_URL_MAX_LENGTH,
   REFERENCE_STATUS_MAX,
+  RENEW_MS,
   RUNS_SEARCH_PER_PROJECT_MAX,
   RUN_HISTORY_PAGE_ITEMS,
   SCHEDULE_HOURS_OPTIONS,
@@ -3327,6 +3414,7 @@ export {
   agentProfileSchema,
   agentProfileSelectionsResponseSchema,
   agentProfilesResponseSchema,
+  allowedLiveRead,
   apiRunSchema,
   applicationUpdateInputSchema,
   applicationUpdateResponseSchema,
@@ -3375,6 +3463,8 @@ export {
   changedFileSchema,
   changesPayloadSchema,
   checkoutProgressEventSchema,
+  checkoutProgressParamsSchema,
+  checkoutProgressResponseSchema,
   checkoutProjectInputSchema,
   ciPrIdentitySchema,
   ciPrUrlSchema,
@@ -3469,6 +3559,15 @@ export {
   isValidTimeZone,
   isoWeekday,
   launchKeyResponseSchema,
+  liveDemandSchema,
+  liveEntrySchema,
+  liveRunBatchResponseSchema,
+  liveRunBatchResultSchema,
+  liveRunBatchSchema,
+  liveRunDemandSchema,
+  liveRunErrorSchema,
+  liveRunFrameSchema,
+  liveRunsRequestSchema,
   localTimeZone,
   logEntrySchema,
   logEntrySourceSchema,
@@ -3489,6 +3588,8 @@ export {
   openProjectInSchema,
   openTargetSchema,
   openTargetsResponseSchema,
+  ownerInputSchema,
+  ownerOutputSchema,
   parseCron,
   parseEffort,
   parsedWorkflowSchema,
@@ -3562,6 +3663,7 @@ export {
   runHistoryQuerySchema,
   runIdParamSchema,
   runIndexEntrySchema,
+  runKey,
   runRecordSchema,
   runRelationshipsSchema,
   runStatusSchema,
@@ -3607,6 +3709,7 @@ export {
   updateProjectInputSchema,
   updateProjectResponseSchema,
   userMcpListingSchema,
+  wireFrameSchema,
   workerBackendSchema,
   workerCancelWaitRequestSchema,
   workerCancelWaitResultSchema,

package/dist/contract/live-coordination.d.ts

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+import { liveRunFrameSchema } from './live.ts';
+export declare const LIVE_PROTOCOL = 1;
+export declare const LIVE_WORKER_NAME = "cezar-live-v1";
+export declare const LEASE_MS = 15000;
+export declare const RENEW_MS = 5000;
+/** Only periodic public cockpit GET families; never arbitrary URLs or mutation execution. */
+export declare function allowedLiveRead(path: string): boolean;
+export declare const liveDemandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"workspace">;
+}, z.core.$strip>, z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    afterSeq: z.ZodNumber;
+    kind: z.ZodLiteral<"run">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"topic">;
+    topic: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"read">;
+    path: z.ZodString;
+    intervalMs: z.ZodNumber;
+}, z.core.$strip>], "kind">;
+export type LiveDemand = z.infer<typeof liveDemandSchema>;
+export declare const liveEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    demand: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"workspace">;
+    }, z.core.$strip>, z.ZodObject<{
+        projectId: z.ZodString;
+        runId: z.ZodString;
+        cursor: z.ZodOptional<z.ZodString>;
+        afterSeq: z.ZodNumber;
+        kind: z.ZodLiteral<"run">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"topic">;
+        topic: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"read">;
+        path: z.ZodString;
+        intervalMs: z.ZodNumber;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+export declare const ownerInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    documentId: z.ZodString;
+    epoch: z.ZodNumber;
+    type: z.ZodLiteral<"sync">;
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        demand: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"workspace">;
+        }, z.core.$strip>, z.ZodObject<{
+            projectId: z.ZodString;
+            runId: z.ZodString;
+            cursor: z.ZodOptional<z.ZodString>;
+            afterSeq: z.ZodNumber;
+            kind: z.ZodLiteral<"run">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"topic">;
+            topic: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"read">;
+            path: z.ZodString;
+            intervalMs: z.ZodNumber;
+        }, z.core.$strip>], "kind">;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    documentId: z.ZodString;
+    epoch: z.ZodNumber;
+    type: z.ZodLiteral<"ack">;
+    id: z.ZodString;
+    seq: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    documentId: z.ZodString;
+    epoch: z.ZodNumber;
+    type: z.ZodLiteral<"refresh">;
+    id: z.ZodString;
+}, z.core.$strip>], "type">;
+export type OwnerInput = z.infer<typeof ownerInputSchema>;
+export declare const wireFrameSchema: z.ZodObject<{
+    event: z.ZodString;
+    data: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const ownerOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"unavailable">;
+    version: z.ZodLiteral<1>;
+    epoch: z.ZodNumber;
+    reason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"hello">;
+    version: z.ZodLiteral<1>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"alive">;
+    version: z.ZodLiteral<1>;
+    epoch: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"frame">;
+    version: z.ZodLiteral<1>;
+    epoch: z.ZodNumber;
+    id: z.ZodString;
+    frame: z.ZodUnion<readonly [z.ZodObject<{
+        event: z.ZodString;
+        data: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"ready">;
+        generation: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"ping">;
+    }, z.core.$strip>, z.ZodObject<{
+        projectId: z.ZodString;
+        runId: z.ZodString;
+        type: z.ZodLiteral<"event">;
+        name: z.ZodEnum<{
+            "run-event": "run-event";
+            "ui-event": "ui-event";
+        }>;
+        event: z.ZodObject<{
+            seq: z.ZodNumber;
+            ts: z.ZodString;
+            stepId: z.ZodOptional<z.ZodString>;
+            type: z.ZodString;
+        }, z.core.$catchall<z.ZodAny>>;
+    }, z.core.$strip>, z.ZodObject<{
+        projectId: z.ZodString;
+        runId: z.ZodString;
+        type: z.ZodEnum<{
+            error: "error";
+            reset: "reset";
+        }>;
+        status: z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<404>, z.ZodLiteral<409>, z.ZodLiteral<413>, z.ZodLiteral<503>]>;
+        error: z.ZodString;
+    }, z.core.$strip>]>]>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"value">;
+    version: z.ZodLiteral<1>;
+    epoch: z.ZodNumber;
+    id: z.ZodString;
+    value: z.ZodUnknown;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reset">;
+    version: z.ZodLiteral<1>;
+    epoch: z.ZodNumber;
+    id: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>], "type">;
+export type OwnerOutput = z.infer<typeof ownerOutputSchema>;
+export type LiveFrame = z.infer<typeof wireFrameSchema> | z.infer<typeof liveRunFrameSchema>;
+export declare const runKey: (run: {
+    projectId: string;
+    runId: string;
+}) => string;

package/dist/contract/live.d.ts

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+export declare const LIVE_RUN_LIMIT = 32;
+export declare const LIVE_EVENT_LIMIT = 256;
+export declare const LIVE_BYTE_LIMIT: number;
+export declare const liveRunDemandSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    afterSeq: z.ZodNumber;
+}, z.core.$strip>;
+export type LiveRunDemand = z.infer<typeof liveRunDemandSchema>;
+export declare const liveRunsRequestSchema: z.ZodObject<{
+    runs: z.ZodArray<z.ZodObject<{
+        projectId: z.ZodString;
+        runId: z.ZodString;
+        cursor: z.ZodOptional<z.ZodString>;
+        afterSeq: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LiveRunsRequest = z.infer<typeof liveRunsRequestSchema>;
+export declare const liveRunErrorSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    type: z.ZodEnum<{
+        error: "error";
+        reset: "reset";
+    }>;
+    status: z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<404>, z.ZodLiteral<409>, z.ZodLiteral<413>, z.ZodLiteral<503>]>;
+    error: z.ZodString;
+}, z.core.$strip>;
+export declare const liveRunBatchSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    type: z.ZodLiteral<"batch">;
+    events: z.ZodArray<z.ZodObject<{
+        seq: z.ZodNumber;
+        ts: z.ZodString;
+        stepId: z.ZodOptional<z.ZodString>;
+        type: z.ZodString;
+    }, z.core.$catchall<z.ZodAny>>>;
+    cursor: z.ZodString;
+    afterSeq: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+export type LiveRunBatch = z.infer<typeof liveRunBatchSchema>;
+export declare const liveRunBatchResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    type: z.ZodLiteral<"batch">;
+    events: z.ZodArray<z.ZodObject<{
+        seq: z.ZodNumber;
+        ts: z.ZodString;
+        stepId: z.ZodOptional<z.ZodString>;
+        type: z.ZodString;
+    }, z.core.$catchall<z.ZodAny>>>;
+    cursor: z.ZodString;
+    afterSeq: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    type: z.ZodEnum<{
+        error: "error";
+        reset: "reset";
+    }>;
+    status: z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<404>, z.ZodLiteral<409>, z.ZodLiteral<413>, z.ZodLiteral<503>]>;
+    error: z.ZodString;
+}, z.core.$strip>]>;
+export type LiveRunBatchResult = z.infer<typeof liveRunBatchResultSchema>;
+export declare const liveRunBatchResponseSchema: z.ZodObject<{
+    generation: z.ZodString;
+    results: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        projectId: z.ZodString;
+        runId: z.ZodString;
+        type: z.ZodLiteral<"batch">;
+        events: z.ZodArray<z.ZodObject<{
+            seq: z.ZodNumber;
+            ts: z.ZodString;
+            stepId: z.ZodOptional<z.ZodString>;
+            type: z.ZodString;
+        }, z.core.$catchall<z.ZodAny>>>;
+        cursor: z.ZodString;
+        afterSeq: z.ZodNumber;
+        hasMore: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        projectId: z.ZodString;
+        runId: z.ZodString;
+        type: z.ZodEnum<{
+            error: "error";
+            reset: "reset";
+        }>;
+        status: z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<404>, z.ZodLiteral<409>, z.ZodLiteral<413>, z.ZodLiteral<503>]>;
+        error: z.ZodString;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+export type LiveRunBatchResponse = z.infer<typeof liveRunBatchResponseSchema>;
+export declare const liveRunFrameSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"ready">;
+    generation: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+}, z.core.$strip>, z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    type: z.ZodLiteral<"event">;
+    name: z.ZodEnum<{
+        "run-event": "run-event";
+        "ui-event": "ui-event";
+    }>;
+    event: z.ZodObject<{
+        seq: z.ZodNumber;
+        ts: z.ZodString;
+        stepId: z.ZodOptional<z.ZodString>;
+        type: z.ZodString;
+    }, z.core.$catchall<z.ZodAny>>;
+}, z.core.$strip>, z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    type: z.ZodEnum<{
+        error: "error";
+        reset: "reset";
+    }>;
+    status: z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<404>, z.ZodLiteral<409>, z.ZodLiteral<413>, z.ZodLiteral<503>]>;
+    error: z.ZodString;
+}, z.core.$strip>]>;
+export type LiveRunFrame = z.infer<typeof liveRunFrameSchema>;

package/dist/contract/preview.d.ts

@@ -120,6 +120,8 @@ export declare const previewKeyTypeSchema: z.ZodEnum<{
 /** Client to server. A whitelist: a message outside it is dropped and logged once per connection. */
 export declare const previewClientMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     t: z.ZodLiteral<"open">;
+    viewerId: z.ZodOptional<z.ZodString>;
+    resume: z.ZodOptional<z.ZodBoolean>;
     target: z.ZodUnion<readonly [z.ZodObject<{
         port: z.ZodNumber;
     }, z.core.$strip>, z.ZodObject<{

package/dist/contract/projects.d.ts

@@ -248,3 +248,20 @@ export declare const launchKeyResponseSchema: z.ZodObject<{
     key: z.ZodString;
 }, z.core.$strip>;
 export type LaunchKeyResponse = z.infer<typeof launchKeyResponseSchema>;
+export declare const checkoutProgressParamsSchema: z.ZodObject<{
+    checkoutId: z.ZodString;
+}, z.core.$strip>;
+export declare const checkoutProgressResponseSchema: z.ZodObject<{
+    progress: z.ZodNullable<z.ZodObject<{
+        checkoutId: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        phase: z.ZodEnum<{
+            cloning: "cloning";
+            done: "done";
+            error: "error";
+        }>;
+        line: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CheckoutProgressResponse = z.infer<typeof checkoutProgressResponseSchema>;