npm - @zgeoff/imp-client - Versions diffs - 0.0.0 - Mend

@zgeoff/imp-client 0.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,2265 @@
+import { ORPCError, isDefinedError, safe } from "@orpc/client";
+import * as z from "zod";
+import { ContractRouterClient } from "@orpc/contract";
+//#region ../api/src/checkpoint-schema.d.ts
+declare const CheckpointSchema: z.ZodObject<{
+  id: z.ZodString;
+  label: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodDate;
+  sizeBytes: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+type Checkpoint = z.infer<typeof CheckpointSchema>;
+//#endregion
+//#region ../api/src/exec-protocol.d.ts
+declare const DETACH_REASONS: readonly ['taken_over', 'slow', 'lost'];
+type DetachReason = (typeof DETACH_REASONS)[number];
+//#endregion
+//#region ../api/src/image-schema.d.ts
+declare const ImageSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  ref: z.ZodString;
+  digest: z.ZodString;
+  createdAt: z.ZodDate;
+  sizeBytes: z.ZodInt;
+}, z.core.$strip>;
+type Image = z.infer<typeof ImageSchema>;
+//#endregion
+//#region ../api/src/imp-contract.d.ts
+declare const impContract: {
+  imps: {
+    create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodOptional<z.ZodString>;
+      image: z.ZodOptional<z.ZodString>;
+      vcpus: z.ZodOptional<z.ZodInt>;
+      memoryMib: z.ZodOptional<z.ZodInt>;
+      httpPort: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      image: z.ZodString;
+      state: z.ZodEnum<{
+        creating: "creating";
+        error: "error";
+        running: "running";
+        sleeping: "sleeping";
+        stopped: "stopped";
+      }>;
+      vcpus: z.ZodInt;
+      memoryMib: z.ZodInt;
+      ip: z.ZodIPv4;
+      slot: z.ZodInt;
+      port: z.ZodInt;
+      httpPort: z.ZodInt;
+      url: z.ZodURL;
+      createdAt: z.ZodDate;
+      lastActiveAt: z.ZodDate;
+      ramMib: z.ZodOptional<z.ZodInt>;
+      rssMib: z.ZodOptional<z.ZodInt>;
+      sleptAt: z.ZodOptional<z.ZodDate>;
+      holdUntil: z.ZodOptional<z.ZodDate>;
+      error: z.ZodOptional<z.ZodString>;
+      sessions: z.ZodOptional<z.ZodInt>;
+      coldBootReason: z.ZodOptional<z.ZodString>;
+      outdated: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        firecracker: "firecracker";
+        impd: "impd";
+        kernel: "kernel";
+      }>>>>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      image: z.ZodString;
+      state: z.ZodEnum<{
+        creating: "creating";
+        error: "error";
+        running: "running";
+        sleeping: "sleeping";
+        stopped: "stopped";
+      }>;
+      vcpus: z.ZodInt;
+      memoryMib: z.ZodInt;
+      ip: z.ZodIPv4;
+      slot: z.ZodInt;
+      port: z.ZodInt;
+      httpPort: z.ZodInt;
+      url: z.ZodURL;
+      createdAt: z.ZodDate;
+      lastActiveAt: z.ZodDate;
+      ramMib: z.ZodOptional<z.ZodInt>;
+      rssMib: z.ZodOptional<z.ZodInt>;
+      sleptAt: z.ZodOptional<z.ZodDate>;
+      holdUntil: z.ZodOptional<z.ZodDate>;
+      error: z.ZodOptional<z.ZodString>;
+      sessions: z.ZodOptional<z.ZodInt>;
+      coldBootReason: z.ZodOptional<z.ZodString>;
+      outdated: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        firecracker: "firecracker";
+        impd: "impd";
+        kernel: "kernel";
+      }>>>>;
+    }, z.core.$strip>>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    get: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      image: z.ZodString;
+      state: z.ZodEnum<{
+        creating: "creating";
+        error: "error";
+        running: "running";
+        sleeping: "sleeping";
+        stopped: "stopped";
+      }>;
+      vcpus: z.ZodInt;
+      memoryMib: z.ZodInt;
+      ip: z.ZodIPv4;
+      slot: z.ZodInt;
+      port: z.ZodInt;
+      httpPort: z.ZodInt;
+      url: z.ZodURL;
+      createdAt: z.ZodDate;
+      lastActiveAt: z.ZodDate;
+      ramMib: z.ZodOptional<z.ZodInt>;
+      rssMib: z.ZodOptional<z.ZodInt>;
+      sleptAt: z.ZodOptional<z.ZodDate>;
+      holdUntil: z.ZodOptional<z.ZodDate>;
+      error: z.ZodOptional<z.ZodString>;
+      sessions: z.ZodOptional<z.ZodInt>;
+      coldBootReason: z.ZodOptional<z.ZodString>;
+      outdated: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        firecracker: "firecracker";
+        impd: "impd";
+        kernel: "kernel";
+      }>>>>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    destroy: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    start: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      image: z.ZodString;
+      state: z.ZodEnum<{
+        creating: "creating";
+        error: "error";
+        running: "running";
+        sleeping: "sleeping";
+        stopped: "stopped";
+      }>;
+      vcpus: z.ZodInt;
+      memoryMib: z.ZodInt;
+      ip: z.ZodIPv4;
+      slot: z.ZodInt;
+      port: z.ZodInt;
+      httpPort: z.ZodInt;
+      url: z.ZodURL;
+      createdAt: z.ZodDate;
+      lastActiveAt: z.ZodDate;
+      ramMib: z.ZodOptional<z.ZodInt>;
+      rssMib: z.ZodOptional<z.ZodInt>;
+      sleptAt: z.ZodOptional<z.ZodDate>;
+      holdUntil: z.ZodOptional<z.ZodDate>;
+      error: z.ZodOptional<z.ZodString>;
+      sessions: z.ZodOptional<z.ZodInt>;
+      coldBootReason: z.ZodOptional<z.ZodString>;
+      outdated: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        firecracker: "firecracker";
+        impd: "impd";
+        kernel: "kernel";
+      }>>>>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    stop: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      image: z.ZodString;
+      state: z.ZodEnum<{
+        creating: "creating";
+        error: "error";
+        running: "running";
+        sleeping: "sleeping";
+        stopped: "stopped";
+      }>;
+      vcpus: z.ZodInt;
+      memoryMib: z.ZodInt;
+      ip: z.ZodIPv4;
+      slot: z.ZodInt;
+      port: z.ZodInt;
+      httpPort: z.ZodInt;
+      url: z.ZodURL;
+      createdAt: z.ZodDate;
+      lastActiveAt: z.ZodDate;
+      ramMib: z.ZodOptional<z.ZodInt>;
+      rssMib: z.ZodOptional<z.ZodInt>;
+      sleptAt: z.ZodOptional<z.ZodDate>;
+      holdUntil: z.ZodOptional<z.ZodDate>;
+      error: z.ZodOptional<z.ZodString>;
+      sessions: z.ZodOptional<z.ZodInt>;
+      coldBootReason: z.ZodOptional<z.ZodString>;
+      outdated: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        firecracker: "firecracker";
+        impd: "impd";
+        kernel: "kernel";
+      }>>>>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    sleep: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      image: z.ZodString;
+      state: z.ZodEnum<{
+        creating: "creating";
+        error: "error";
+        running: "running";
+        sleeping: "sleeping";
+        stopped: "stopped";
+      }>;
+      vcpus: z.ZodInt;
+      memoryMib: z.ZodInt;
+      ip: z.ZodIPv4;
+      slot: z.ZodInt;
+      port: z.ZodInt;
+      httpPort: z.ZodInt;
+      url: z.ZodURL;
+      createdAt: z.ZodDate;
+      lastActiveAt: z.ZodDate;
+      ramMib: z.ZodOptional<z.ZodInt>;
+      rssMib: z.ZodOptional<z.ZodInt>;
+      sleptAt: z.ZodOptional<z.ZodDate>;
+      holdUntil: z.ZodOptional<z.ZodDate>;
+      error: z.ZodOptional<z.ZodString>;
+      sessions: z.ZodOptional<z.ZodInt>;
+      coldBootReason: z.ZodOptional<z.ZodString>;
+      outdated: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        firecracker: "firecracker";
+        impd: "impd";
+        kernel: "kernel";
+      }>>>>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    wake: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+      restartError: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      image: z.ZodString;
+      state: z.ZodEnum<{
+        creating: "creating";
+        error: "error";
+        running: "running";
+        sleeping: "sleeping";
+        stopped: "stopped";
+      }>;
+      vcpus: z.ZodInt;
+      memoryMib: z.ZodInt;
+      ip: z.ZodIPv4;
+      slot: z.ZodInt;
+      port: z.ZodInt;
+      httpPort: z.ZodInt;
+      url: z.ZodURL;
+      createdAt: z.ZodDate;
+      lastActiveAt: z.ZodDate;
+      ramMib: z.ZodOptional<z.ZodInt>;
+      rssMib: z.ZodOptional<z.ZodInt>;
+      sleptAt: z.ZodOptional<z.ZodDate>;
+      holdUntil: z.ZodOptional<z.ZodDate>;
+      error: z.ZodOptional<z.ZodString>;
+      sessions: z.ZodOptional<z.ZodInt>;
+      coldBootReason: z.ZodOptional<z.ZodString>;
+      outdated: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        firecracker: "firecracker";
+        impd: "impd";
+        kernel: "kernel";
+      }>>>>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    hold: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+      seconds: z.ZodInt;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      image: z.ZodString;
+      state: z.ZodEnum<{
+        creating: "creating";
+        error: "error";
+        running: "running";
+        sleeping: "sleeping";
+        stopped: "stopped";
+      }>;
+      vcpus: z.ZodInt;
+      memoryMib: z.ZodInt;
+      ip: z.ZodIPv4;
+      slot: z.ZodInt;
+      port: z.ZodInt;
+      httpPort: z.ZodInt;
+      url: z.ZodURL;
+      createdAt: z.ZodDate;
+      lastActiveAt: z.ZodDate;
+      ramMib: z.ZodOptional<z.ZodInt>;
+      rssMib: z.ZodOptional<z.ZodInt>;
+      sleptAt: z.ZodOptional<z.ZodDate>;
+      holdUntil: z.ZodOptional<z.ZodDate>;
+      error: z.ZodOptional<z.ZodString>;
+      sessions: z.ZodOptional<z.ZodInt>;
+      coldBootReason: z.ZodOptional<z.ZodString>;
+      outdated: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        firecracker: "firecracker";
+        impd: "impd";
+        kernel: "kernel";
+      }>>>>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    url: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      local: z.ZodURL;
+      tailnet: z.ZodNullable<z.ZodURL>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    fork: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      source: z.ZodString;
+      name: z.ZodString;
+      checkpoint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      image: z.ZodString;
+      state: z.ZodEnum<{
+        creating: "creating";
+        error: "error";
+        running: "running";
+        sleeping: "sleeping";
+        stopped: "stopped";
+      }>;
+      vcpus: z.ZodInt;
+      memoryMib: z.ZodInt;
+      ip: z.ZodIPv4;
+      slot: z.ZodInt;
+      port: z.ZodInt;
+      httpPort: z.ZodInt;
+      url: z.ZodURL;
+      createdAt: z.ZodDate;
+      lastActiveAt: z.ZodDate;
+      ramMib: z.ZodOptional<z.ZodInt>;
+      rssMib: z.ZodOptional<z.ZodInt>;
+      sleptAt: z.ZodOptional<z.ZodDate>;
+      holdUntil: z.ZodOptional<z.ZodDate>;
+      error: z.ZodOptional<z.ZodString>;
+      sessions: z.ZodOptional<z.ZodInt>;
+      coldBootReason: z.ZodOptional<z.ZodString>;
+      outdated: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        firecracker: "firecracker";
+        impd: "impd";
+        kernel: "kernel";
+      }>>>>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+  };
+  checkpoints: {
+    create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+      label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      label: z.ZodOptional<z.ZodString>;
+      createdAt: z.ZodDate;
+      sizeBytes: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      label: z.ZodOptional<z.ZodString>;
+      createdAt: z.ZodDate;
+      sizeBytes: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strip>>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    restore: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+      checkpoint: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      image: z.ZodString;
+      state: z.ZodEnum<{
+        creating: "creating";
+        error: "error";
+        running: "running";
+        sleeping: "sleeping";
+        stopped: "stopped";
+      }>;
+      vcpus: z.ZodInt;
+      memoryMib: z.ZodInt;
+      ip: z.ZodIPv4;
+      slot: z.ZodInt;
+      port: z.ZodInt;
+      httpPort: z.ZodInt;
+      url: z.ZodURL;
+      createdAt: z.ZodDate;
+      lastActiveAt: z.ZodDate;
+      ramMib: z.ZodOptional<z.ZodInt>;
+      rssMib: z.ZodOptional<z.ZodInt>;
+      sleptAt: z.ZodOptional<z.ZodDate>;
+      holdUntil: z.ZodOptional<z.ZodDate>;
+      error: z.ZodOptional<z.ZodString>;
+      sessions: z.ZodOptional<z.ZodInt>;
+      coldBootReason: z.ZodOptional<z.ZodString>;
+      outdated: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        firecracker: "firecracker";
+        impd: "impd";
+        kernel: "kernel";
+      }>>>>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    delete: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+      checkpoint: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+  };
+  images: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      ref: z.ZodString;
+      digest: z.ZodString;
+      createdAt: z.ZodDate;
+      sizeBytes: z.ZodInt;
+    }, z.core.$strip>>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    add: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      ref: z.ZodString;
+      name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      ref: z.ZodString;
+      digest: z.ZodString;
+      createdAt: z.ZodDate;
+      sizeBytes: z.ZodInt;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    build: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      contextDir: z.ZodString;
+      name: z.ZodString;
+      dockerfile: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      ref: z.ZodString;
+      digest: z.ZodString;
+      createdAt: z.ZodDate;
+      sizeBytes: z.ZodInt;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    delete: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+  };
+  exec: {
+    ticket: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      ticket: z.ZodString;
+      expiresAt: z.ZodDate;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+  };
+  sessions: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      pid: z.ZodInt;
+      argv: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+      state: z.ZodEnum<{
+        exited: "exited";
+        running: "running";
+      }>;
+      attached: z.ZodBoolean;
+      cols: z.ZodInt;
+      rows: z.ZodInt;
+      startedAt: z.ZodDate;
+      exit: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        code: z.ZodNullable<z.ZodInt>;
+        signal: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>>>;
+    }, z.core.$strip>>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+    kill: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+      name: z.ZodString;
+      session: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+  };
+  system: {
+    info: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+      version: z.ZodString;
+      ramBudgetMib: z.ZodInt;
+      ramUsedMib: z.ZodInt;
+      ramReservedMib: z.ZodInt;
+      ramCommittedMib: z.ZodInt;
+      awakeCount: z.ZodInt;
+      impCount: z.ZodInt;
+      sessionCount: z.ZodInt;
+      firecrackerVersion: z.ZodNullable<z.ZodString>;
+      guestKernel: z.ZodObject<{
+        version: z.ZodNullable<z.ZodString>;
+        sha256: z.ZodString;
+      }, z.core.$strip>;
+      systemDrive: z.ZodObject<{
+        sha256: z.ZodString;
+      }, z.core.$strip>;
+      storage: z.ZodObject<{
+        backend: z.ZodEnum<{
+          xfs: "xfs";
+          zfs: "zfs";
+        }>;
+        usedBytes: z.ZodInt;
+        availableBytes: z.ZodInt;
+      }, z.core.$strip>;
+      tailscale: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        state: z.ZodNullable<z.ZodString>;
+        hostname: z.ZodNullable<z.ZodString>;
+        ip: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            checkpoint: "checkpoint";
+            image: "image";
+            imp: "imp";
+            session: "session";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+        }, z.core.$strip>;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+    }>, Record<never, never>>;
+  };
+};
+type ImpContract = typeof impContract;
+//#endregion
+//#region ../api/src/imp-schema.d.ts
+declare const ImpStateSchema: z.ZodEnum<{
+  creating: "creating";
+  error: "error";
+  running: "running";
+  sleeping: "sleeping";
+  stopped: "stopped";
+}>;
+type ImpState = z.infer<typeof ImpStateSchema>;
+declare const ImpSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  image: z.ZodString;
+  state: z.ZodEnum<{
+    creating: "creating";
+    error: "error";
+    running: "running";
+    sleeping: "sleeping";
+    stopped: "stopped";
+  }>;
+  vcpus: z.ZodInt;
+  memoryMib: z.ZodInt;
+  ip: z.ZodIPv4;
+  slot: z.ZodInt;
+  port: z.ZodInt;
+  httpPort: z.ZodInt;
+  url: z.ZodURL;
+  createdAt: z.ZodDate;
+  lastActiveAt: z.ZodDate;
+  ramMib: z.ZodOptional<z.ZodInt>;
+  rssMib: z.ZodOptional<z.ZodInt>;
+  sleptAt: z.ZodOptional<z.ZodDate>;
+  holdUntil: z.ZodOptional<z.ZodDate>;
+  error: z.ZodOptional<z.ZodString>;
+  sessions: z.ZodOptional<z.ZodInt>;
+  coldBootReason: z.ZodOptional<z.ZodString>;
+  outdated: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+    agent: "agent";
+    firecracker: "firecracker";
+    impd: "impd";
+    kernel: "kernel";
+  }>>>>;
+}, z.core.$strip>;
+type Imp = z.infer<typeof ImpSchema>;
+//#endregion
+//#region ../api/src/session-schema.d.ts
+declare const SessionSchema: z.ZodObject<{
+  name: z.ZodString;
+  pid: z.ZodInt;
+  argv: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+  state: z.ZodEnum<{
+    exited: "exited";
+    running: "running";
+  }>;
+  attached: z.ZodBoolean;
+  cols: z.ZodInt;
+  rows: z.ZodInt;
+  startedAt: z.ZodDate;
+  exit: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+    code: z.ZodNullable<z.ZodInt>;
+    signal: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type Session = z.infer<typeof SessionSchema>;
+//#endregion
+//#region ../api/src/system-info-schema.d.ts
+declare const SystemInfoSchema: z.ZodObject<{
+  version: z.ZodString;
+  ramBudgetMib: z.ZodInt;
+  ramUsedMib: z.ZodInt;
+  ramReservedMib: z.ZodInt;
+  ramCommittedMib: z.ZodInt;
+  awakeCount: z.ZodInt;
+  impCount: z.ZodInt;
+  sessionCount: z.ZodInt;
+  firecrackerVersion: z.ZodNullable<z.ZodString>;
+  guestKernel: z.ZodObject<{
+    version: z.ZodNullable<z.ZodString>;
+    sha256: z.ZodString;
+  }, z.core.$strip>;
+  systemDrive: z.ZodObject<{
+    sha256: z.ZodString;
+  }, z.core.$strip>;
+  storage: z.ZodObject<{
+    backend: z.ZodEnum<{
+      xfs: "xfs";
+      zfs: "zfs";
+    }>;
+    usedBytes: z.ZodInt;
+    availableBytes: z.ZodInt;
+  }, z.core.$strip>;
+  tailscale: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    state: z.ZodNullable<z.ZodString>;
+    hostname: z.ZodNullable<z.ZodString>;
+    ip: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type SystemInfo = z.infer<typeof SystemInfoSchema>;
+//#endregion
+//#region src/check-server.d.ts
+export declare const CLIENT_VERSION: string;
+interface ServerCheck {
+  readonly clientVersion: string;
+  readonly serverVersion: string;
+  readonly compatible: boolean;
+}
+//#endregion
+//#region src/exec/open-exec-session.d.ts
+interface ExecStart {
+  readonly name: string;
+  readonly argv: readonly string[];
+  readonly tty: boolean;
+  readonly env?: Readonly<Record<string, string>>;
+  readonly cwd?: string;
+  readonly cols?: number;
+  readonly rows?: number;
+  readonly session?: string;
+}
+interface ExecAttach {
+  readonly name: string;
+  readonly session: string;
+  readonly cols?: number;
+  readonly rows?: number;
+}
+interface ExecStarted {
+  readonly pid: number;
+  readonly session: string | null;
+  readonly created: boolean;
+}
+type ExecOutcome = {
+  readonly kind: 'exit';
+  readonly code: number | null;
+  readonly signal: string | null;
+} | {
+  readonly kind: 'failed';
+  readonly code: string | null;
+  readonly message: string;
+  readonly data?: unknown;
+} | {
+  readonly kind: 'unauthorized';
+  readonly ticketRefused?: boolean;
+} | {
+  readonly kind: 'unreachable';
+  readonly detail: string;
+} | {
+  readonly kind: 'detached';
+  readonly reason: DetachReason;
+} | {
+  readonly kind: 'closed';
+  readonly reason: string;
+  readonly closeCode?: number;
+} | {
+  readonly kind: 'bad_message';
+  readonly detail: string;
+} | {
+  readonly kind: 'local_error';
+  readonly error: unknown;
+};
+interface ExecSessionOptions {
+  readonly baseUrl: string;
+  readonly token: string | null;
+  readonly ticket?: string;
+  readonly start: ExecStart | ExecAttach;
+  readonly onStarted: (started: ExecStarted) => void;
+  readonly onOutput: (channel: 'stdout' | 'stderr', data: Uint8Array) => void;
+  readonly connect: (url: string, headers: Readonly<Record<string, string>>) => WebSocket;
+  readonly fetch?: (request: Request) => Promise<Response>;
+}
+interface ExecSession {
+  readonly outcome: Promise<ExecOutcome>;
+  readonly isStarted: () => boolean;
+  readonly sendStdin: (data: Uint8Array) => boolean;
+  readonly waitForDrain: () => Promise<void>;
+  readonly closeStdin: () => void;
+  readonly resize: (cols: number, rows: number) => void;
+  readonly sendSignal: (signal: string) => void;
+  readonly stop: () => void;
+}
+export declare function openExecSession(options: Readonly<ExecSessionOptions>): ExecSession;
+//#endregion
+//#region src/exec/open-exec.d.ts
+interface ExecOptions {
+  readonly tty?: boolean;
+  readonly env?: Readonly<Record<string, string>>;
+  readonly cwd?: string;
+  readonly cols?: number;
+  readonly rows?: number;
+  readonly session?: string;
+  readonly signal?: Readonly<AbortSignal>;
+  readonly maxUnreadBytes?: number;
+}
+interface ExecExit {
+  readonly code: number | null;
+  readonly signal: string | null;
+}
+interface ExecHandle {
+  readonly started: Promise<ExecStarted>;
+  readonly stdout: ReadableStream<Uint8Array>;
+  readonly stderr: ReadableStream<Uint8Array>;
+  readonly exit: Promise<ExecExit>;
+  readonly write: (data: string | Uint8Array) => Promise<void>;
+  readonly closeStdin: () => Promise<void>;
+  readonly resize: (cols: number, rows: number) => void;
+  readonly sendSignal: (signal: string) => void;
+  readonly close: () => void;
+}
+export declare const CONSOLE_SHELL: string;
+type AttachOptions = Pick<ExecOptions, 'cols' | 'rows' | 'signal' | 'maxUnreadBytes'>;
+type ConsoleOptions = Omit<ExecOptions, 'tty'>;
+interface RunResult extends ExecExit {
+  readonly stdout: Uint8Array;
+  readonly stderr: Uint8Array;
+}
+interface RunOptions extends Omit<ExecOptions, 'tty' | 'cols' | 'rows'> {
+  readonly stdin?: string | Uint8Array;
+}
+//#endregion
+//#region src/require-awake.d.ts
+interface RequireAwakeOptions {
+  readonly restartError?: boolean;
+  readonly retryUnavailable?: {
+    readonly attempts: number;
+    readonly delayMs: number;
+  };
+  readonly signal?: Readonly<AbortSignal>;
+}
+//#endregion
+//#region src/create-imp-client.d.ts
+type RpcClient = ContractRouterClient<ImpContract>;
+interface ImpClientOptions {
+  readonly url: string;
+  readonly token?: string;
+  readonly fetch?: (request: Request) => Promise<Response>;
+}
+interface ImpClient extends RpcClient {
+  readonly requireAwake: (name: string, options?: RequireAwakeOptions) => Promise<Imp>;
+  readonly checkServer: () => Promise<ServerCheck>;
+  readonly openExec: (name: string, argv: readonly string[], options?: ExecOptions) => Promise<ExecHandle>;
+  readonly run: (name: string, argv: readonly string[], options?: RunOptions) => Promise<RunResult>;
+  readonly openConsole: (name: string, options?: ConsoleOptions) => Promise<ExecHandle>;
+  readonly openAttach: (name: string, session: string, options?: AttachOptions) => Promise<ExecHandle>;
+}
+export declare function createImpClient(options: Readonly<ImpClientOptions>): ImpClient;
+//#endregion
+//#region src/exec/exec-error.d.ts
+type ExecClientErrorCode = 'UNAUTHORIZED' | 'UNREACHABLE' | 'RESTARTING' | 'CONNECTION_CLOSED' | 'DETACHED' | 'BAD_MESSAGE' | 'CLOSED' | 'OUTPUT_OVERFLOW' | 'LOCAL_ERROR';
+export declare class ExecError extends Error {
+  readonly code: string;
+  readonly data: unknown;
+  constructor(code: string, message: string, options?: Readonly<{
+    data?: unknown;
+    cause?: unknown;
+  }>);
+}
+//#endregion
+export { type AttachOptions, type Checkpoint, type ConsoleOptions, type DetachReason, type ExecClientErrorCode, type ExecExit, type ExecHandle, type ExecOptions, type ExecOutcome, type ExecSession, type ExecSessionOptions, type ExecStarted, type Image, type Imp, type ImpClient, type ImpClientOptions, type ImpState, ORPCError, type RequireAwakeOptions, type RunOptions, type RunResult, type ServerCheck, type Session, type SystemInfo, isDefinedError, safe };