npm - devchain-cli - Versions diffs - 0.25.0 → 0.26.1 - Mend

devchain-cli 0.25.0 → 0.26.1

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 (653) hide show

package/dist/server/modules/remotes/contract/host-routes.d.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import type { GitFence } from '../git-coordinator/git-coordinator.dto';
 export declare const CONTROL_TIMEOUT_MS = 15000;
 export declare const REPLICA_TIMEOUT_MS = 120000;
 export declare const RUNTIME_TIMEOUT_MS = 5000;
@@ -524,8 +525,1799 @@ type ProjectParams = {
 type FolderParams = {
     folderId: string;
 };
+type FencedParams = {
+    gitFence?: GitFence;
+};
 type NoParams = Record<string, never>;
+export declare const HostProviderUsageSettingsSchema: z.ZodObject<{
+    revision: z.ZodString;
+    settings: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        runningMaxAgeMin: z.ZodNumber;
+        openProjectMaxAgeMin: z.ZodNumber;
+        hoverMaxAgeSec: z.ZodNumber;
+        tokenCheckMinutes: z.ZodUnion<[z.ZodLiteral<0>, z.ZodNumber]>;
+    }, "strict", z.ZodTypeAny, {
+        enabled: boolean;
+        runningMaxAgeMin: number;
+        openProjectMaxAgeMin: number;
+        hoverMaxAgeSec: number;
+        tokenCheckMinutes: number;
+    }, {
+        enabled: boolean;
+        runningMaxAgeMin: number;
+        openProjectMaxAgeMin: number;
+        hoverMaxAgeSec: number;
+        tokenCheckMinutes: number;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    revision: string;
+    settings: {
+        enabled: boolean;
+        runningMaxAgeMin: number;
+        openProjectMaxAgeMin: number;
+        hoverMaxAgeSec: number;
+        tokenCheckMinutes: number;
+    };
+}, {
+    revision: string;
+    settings: {
+        enabled: boolean;
+        runningMaxAgeMin: number;
+        openProjectMaxAgeMin: number;
+        hoverMaxAgeSec: number;
+        tokenCheckMinutes: number;
+    };
+}>;
+export type HostProviderUsageSettings = z.infer<typeof HostProviderUsageSettingsSchema>;
+export declare const HostProviderUsageSettingsStatusSchema: z.ZodObject<{
+    appliedRevision: z.ZodNullable<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    appliedRevision: string | null;
+}, {
+    appliedRevision: string | null;
+}>;
+export type HostProviderUsageSettingsStatus = z.infer<typeof HostProviderUsageSettingsStatusSchema>;
 export declare const hostRoutes: {
+    readonly gitCoordinatorStatus: {
+        readonly method: "GET";
+        readonly path: (params: ProjectParams) => string;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                owner: z.ZodEnum<["vm", "home"]>;
+                generation: z.ZodNumber;
+                homeName: z.ZodNullable<z.ZodString>;
+                homeWrites: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                checkpoint: z.ZodNullable<z.ZodObject<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }>>;
+                confirmedWrites: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "writeId">, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }>>>;
+                vmHolds: z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    holdId: z.ZodEffects<z.ZodString, string, string>;
+                    pid: z.ZodNumber;
+                    processStartTime: z.ZodString;
+                }, "holdId"> & {
+                    startedAt: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>>;
+                transition: z.ZodNullable<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                    kind: z.ZodLiteral<"handover">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["draining", "vm-receiving", "home-sending", "published"]>;
+                    lease: z.ZodNumber;
+                    sequences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }>, z.ZodObject<{
+                    kind: z.ZodLiteral<"reclaim">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["sending", "unguarding", "index", "publishing"]>;
+                    lease: z.ZodNull;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }>]>>;
+                closed: z.ZodOptional<z.ZodBoolean>;
+            } & {
+                worktreeBranches: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                worktreeBranches: string[];
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                worktreeBranches: string[];
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }>;
+        };
+    };
+    readonly gitCoordinatorIndex: {
+        readonly method: "GET";
+        readonly path: (params: ProjectParams) => string;
+        readonly timeoutMs: 120000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                indexBase64: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                indexBase64: string;
+            }, {
+                indexBase64: string;
+            }>;
+        };
+    };
+    readonly homeWriteBegin: {
+        readonly method: "POST";
+        readonly path: (params: ProjectParams) => string;
+        readonly body: z.ZodObject<{
+            expectedGeneration: z.ZodNumber;
+            transitionId: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+        } & {
+            writeId: z.ZodEffects<z.ZodString, string, string>;
+            homeName: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            expectedGeneration: number;
+            transitionId: string | null;
+            writeId: string;
+            homeName: string;
+        }, {
+            expectedGeneration: number;
+            transitionId: string | null;
+            writeId: string;
+            homeName: string;
+        }>;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                owner: z.ZodEnum<["vm", "home"]>;
+                generation: z.ZodNumber;
+                homeName: z.ZodNullable<z.ZodString>;
+                homeWrites: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                checkpoint: z.ZodNullable<z.ZodObject<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }>>;
+                confirmedWrites: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "writeId">, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }>>>;
+                vmHolds: z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    holdId: z.ZodEffects<z.ZodString, string, string>;
+                    pid: z.ZodNumber;
+                    processStartTime: z.ZodString;
+                }, "holdId"> & {
+                    startedAt: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>>;
+                transition: z.ZodNullable<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                    kind: z.ZodLiteral<"handover">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["draining", "vm-receiving", "home-sending", "published"]>;
+                    lease: z.ZodNumber;
+                    sequences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }>, z.ZodObject<{
+                    kind: z.ZodLiteral<"reclaim">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["sending", "unguarding", "index", "publishing"]>;
+                    lease: z.ZodNull;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }>]>>;
+                closed: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }>;
+        };
+    };
+    readonly homeWriteEnd: {
+        readonly method: "POST";
+        readonly path: (params: ProjectParams) => string;
+        readonly body: z.ZodObject<{
+            expectedGeneration: z.ZodNumber;
+            transitionId: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+        } & {
+            writeId: z.ZodEffects<z.ZodString, string, string>;
+            refsDigest: z.ZodString;
+            indexBase64: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            expectedGeneration: number;
+            transitionId: string | null;
+            writeId: string;
+            refsDigest: string;
+            indexBase64: string;
+        }, {
+            expectedGeneration: number;
+            transitionId: string | null;
+            writeId: string;
+            refsDigest: string;
+            indexBase64: string;
+        }>;
+        readonly timeoutMs: 120000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                owner: z.ZodEnum<["vm", "home"]>;
+                generation: z.ZodNumber;
+                homeName: z.ZodNullable<z.ZodString>;
+                homeWrites: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                checkpoint: z.ZodNullable<z.ZodObject<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }>>;
+                confirmedWrites: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "writeId">, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }>>>;
+                vmHolds: z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    holdId: z.ZodEffects<z.ZodString, string, string>;
+                    pid: z.ZodNumber;
+                    processStartTime: z.ZodString;
+                }, "holdId"> & {
+                    startedAt: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>>;
+                transition: z.ZodNullable<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                    kind: z.ZodLiteral<"handover">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["draining", "vm-receiving", "home-sending", "published"]>;
+                    lease: z.ZodNumber;
+                    sequences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }>, z.ZodObject<{
+                    kind: z.ZodLiteral<"reclaim">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["sending", "unguarding", "index", "publishing"]>;
+                    lease: z.ZodNull;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }>]>>;
+                closed: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }>;
+        };
+    };
+    readonly handoverBegin: {
+        readonly method: "POST";
+        readonly path: (params: ProjectParams) => string;
+        readonly body: z.ZodObject<{
+            expectedGeneration: z.ZodNumber;
+            transitionId: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+        } & {
+            id: z.ZodEffects<z.ZodString, string, string>;
+            homeName: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            expectedGeneration: number;
+            transitionId: string | null;
+            homeName: string;
+        }, {
+            id: string;
+            expectedGeneration: number;
+            transitionId: string | null;
+            homeName: string;
+        }>;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                owner: z.ZodEnum<["vm", "home"]>;
+                generation: z.ZodNumber;
+                homeName: z.ZodNullable<z.ZodString>;
+                homeWrites: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                checkpoint: z.ZodNullable<z.ZodObject<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }>>;
+                confirmedWrites: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "writeId">, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }>>>;
+                vmHolds: z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    holdId: z.ZodEffects<z.ZodString, string, string>;
+                    pid: z.ZodNumber;
+                    processStartTime: z.ZodString;
+                }, "holdId"> & {
+                    startedAt: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>>;
+                transition: z.ZodNullable<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                    kind: z.ZodLiteral<"handover">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["draining", "vm-receiving", "home-sending", "published"]>;
+                    lease: z.ZodNumber;
+                    sequences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }>, z.ZodObject<{
+                    kind: z.ZodLiteral<"reclaim">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["sending", "unguarding", "index", "publishing"]>;
+                    lease: z.ZodNull;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }>]>>;
+                closed: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }>;
+        };
+    };
+    readonly handoverRenew: {
+        readonly method: "POST";
+        readonly path: (params: ProjectParams) => string;
+        readonly body: z.ZodObject<{
+            expectedGeneration: z.ZodNumber;
+            transitionId: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+        }, "strict", z.ZodTypeAny, {
+            expectedGeneration: number;
+            transitionId: string | null;
+        }, {
+            expectedGeneration: number;
+            transitionId: string | null;
+        }>;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                owner: z.ZodEnum<["vm", "home"]>;
+                generation: z.ZodNumber;
+                homeName: z.ZodNullable<z.ZodString>;
+                homeWrites: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                checkpoint: z.ZodNullable<z.ZodObject<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }>>;
+                confirmedWrites: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "writeId">, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }>>>;
+                vmHolds: z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    holdId: z.ZodEffects<z.ZodString, string, string>;
+                    pid: z.ZodNumber;
+                    processStartTime: z.ZodString;
+                }, "holdId"> & {
+                    startedAt: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>>;
+                transition: z.ZodNullable<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                    kind: z.ZodLiteral<"handover">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["draining", "vm-receiving", "home-sending", "published"]>;
+                    lease: z.ZodNumber;
+                    sequences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }>, z.ZodObject<{
+                    kind: z.ZodLiteral<"reclaim">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["sending", "unguarding", "index", "publishing"]>;
+                    lease: z.ZodNull;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }>]>>;
+                closed: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }>;
+        };
+    };
+    readonly handoverAbort: {
+        readonly method: "POST";
+        readonly path: (params: ProjectParams) => string;
+        readonly body: z.ZodObject<{
+            expectedGeneration: z.ZodNumber;
+            transitionId: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+        }, "strict", z.ZodTypeAny, {
+            expectedGeneration: number;
+            transitionId: string | null;
+        }, {
+            expectedGeneration: number;
+            transitionId: string | null;
+        }>;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                owner: z.ZodEnum<["vm", "home"]>;
+                generation: z.ZodNumber;
+                homeName: z.ZodNullable<z.ZodString>;
+                homeWrites: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                checkpoint: z.ZodNullable<z.ZodObject<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }>>;
+                confirmedWrites: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "writeId">, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }>>>;
+                vmHolds: z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    holdId: z.ZodEffects<z.ZodString, string, string>;
+                    pid: z.ZodNumber;
+                    processStartTime: z.ZodString;
+                }, "holdId"> & {
+                    startedAt: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>>;
+                transition: z.ZodNullable<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                    kind: z.ZodLiteral<"handover">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["draining", "vm-receiving", "home-sending", "published"]>;
+                    lease: z.ZodNumber;
+                    sequences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }>, z.ZodObject<{
+                    kind: z.ZodLiteral<"reclaim">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["sending", "unguarding", "index", "publishing"]>;
+                    lease: z.ZodNull;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }>]>>;
+                closed: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }>;
+        };
+    };
+    readonly handoverPhase: {
+        readonly method: "POST";
+        readonly path: (params: ProjectParams) => string;
+        readonly body: z.ZodEffects<z.ZodObject<{
+            expectedGeneration: z.ZodNumber;
+            transitionId: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+        } & {
+            phase: z.ZodEnum<["draining", "vm-receiving", "home-sending", "published"]>;
+            writeId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        }, "strict", z.ZodTypeAny, {
+            phase: "draining" | "vm-receiving" | "home-sending" | "published";
+            expectedGeneration: number;
+            transitionId: string | null;
+            writeId?: string | undefined;
+        }, {
+            phase: "draining" | "vm-receiving" | "home-sending" | "published";
+            expectedGeneration: number;
+            transitionId: string | null;
+            writeId?: string | undefined;
+        }>, {
+            phase: "draining" | "vm-receiving" | "home-sending" | "published";
+            expectedGeneration: number;
+            transitionId: string | null;
+            writeId?: string | undefined;
+        }, {
+            phase: "draining" | "vm-receiving" | "home-sending" | "published";
+            expectedGeneration: number;
+            transitionId: string | null;
+            writeId?: string | undefined;
+        }>;
+        readonly timeoutMs: 120000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                owner: z.ZodEnum<["vm", "home"]>;
+                generation: z.ZodNumber;
+                homeName: z.ZodNullable<z.ZodString>;
+                homeWrites: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                checkpoint: z.ZodNullable<z.ZodObject<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }>>;
+                confirmedWrites: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "writeId">, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }>>>;
+                vmHolds: z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    holdId: z.ZodEffects<z.ZodString, string, string>;
+                    pid: z.ZodNumber;
+                    processStartTime: z.ZodString;
+                }, "holdId"> & {
+                    startedAt: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>>;
+                transition: z.ZodNullable<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                    kind: z.ZodLiteral<"handover">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["draining", "vm-receiving", "home-sending", "published"]>;
+                    lease: z.ZodNumber;
+                    sequences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }>, z.ZodObject<{
+                    kind: z.ZodLiteral<"reclaim">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["sending", "unguarding", "index", "publishing"]>;
+                    lease: z.ZodNull;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }>]>>;
+                closed: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }>;
+        };
+    };
+    readonly handoverComplete: {
+        readonly method: "POST";
+        readonly path: (params: ProjectParams) => string;
+        readonly body: z.ZodObject<{
+            expectedGeneration: z.ZodNumber;
+            transitionId: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+        }, "strict", z.ZodTypeAny, {
+            expectedGeneration: number;
+            transitionId: string | null;
+        }, {
+            expectedGeneration: number;
+            transitionId: string | null;
+        }>;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                owner: z.ZodEnum<["vm", "home"]>;
+                generation: z.ZodNumber;
+                homeName: z.ZodNullable<z.ZodString>;
+                homeWrites: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                checkpoint: z.ZodNullable<z.ZodObject<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }>>;
+                confirmedWrites: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "writeId">, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }>>>;
+                vmHolds: z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    holdId: z.ZodEffects<z.ZodString, string, string>;
+                    pid: z.ZodNumber;
+                    processStartTime: z.ZodString;
+                }, "holdId"> & {
+                    startedAt: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>>;
+                transition: z.ZodNullable<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                    kind: z.ZodLiteral<"handover">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["draining", "vm-receiving", "home-sending", "published"]>;
+                    lease: z.ZodNumber;
+                    sequences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }>, z.ZodObject<{
+                    kind: z.ZodLiteral<"reclaim">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["sending", "unguarding", "index", "publishing"]>;
+                    lease: z.ZodNull;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }>]>>;
+                closed: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }>;
+        };
+    };
+    readonly gitCoordinatorClose: {
+        readonly method: "POST";
+        readonly path: (params: ProjectParams) => string;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                owner: z.ZodEnum<["vm", "home"]>;
+                generation: z.ZodNumber;
+                homeName: z.ZodNullable<z.ZodString>;
+                homeWrites: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                checkpoint: z.ZodNullable<z.ZodObject<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }>>;
+                confirmedWrites: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "writeId">, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }>>>;
+                vmHolds: z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    holdId: z.ZodEffects<z.ZodString, string, string>;
+                    pid: z.ZodNumber;
+                    processStartTime: z.ZodString;
+                }, "holdId"> & {
+                    startedAt: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>>;
+                transition: z.ZodNullable<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                    kind: z.ZodLiteral<"handover">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["draining", "vm-receiving", "home-sending", "published"]>;
+                    lease: z.ZodNumber;
+                    sequences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }>, z.ZodObject<{
+                    kind: z.ZodLiteral<"reclaim">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["sending", "unguarding", "index", "publishing"]>;
+                    lease: z.ZodNull;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }>]>>;
+                closed: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }>;
+        };
+    };
+    readonly gitCoordinatorReopen: {
+        readonly method: "POST";
+        readonly path: (params: ProjectParams) => string;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                owner: z.ZodEnum<["vm", "home"]>;
+                generation: z.ZodNumber;
+                homeName: z.ZodNullable<z.ZodString>;
+                homeWrites: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                checkpoint: z.ZodNullable<z.ZodObject<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                }>>;
+                confirmedWrites: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    writeId: z.ZodEffects<z.ZodString, string, string>;
+                    generation: z.ZodNumber;
+                    refsDigest: z.ZodString;
+                    at: z.ZodNumber;
+                }, "writeId">, "strip", z.ZodTypeAny, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }>>>;
+                vmHolds: z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+                    holdId: z.ZodEffects<z.ZodString, string, string>;
+                    pid: z.ZodNumber;
+                    processStartTime: z.ZodString;
+                }, "holdId"> & {
+                    startedAt: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>>;
+                transition: z.ZodNullable<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                    kind: z.ZodLiteral<"handover">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["draining", "vm-receiving", "home-sending", "published"]>;
+                    lease: z.ZodNumber;
+                    sequences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }, {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                }>, z.ZodObject<{
+                    kind: z.ZodLiteral<"reclaim">;
+                    id: z.ZodEffects<z.ZodString, string, string>;
+                    phase: z.ZodEnum<["sending", "unguarding", "index", "publishing"]>;
+                    lease: z.ZodNull;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }, {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                }>]>>;
+                closed: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }, {
+                generation: number;
+                owner: "home" | "vm";
+                homeName: string | null;
+                homeWrites: Record<string, number>;
+                checkpoint: {
+                    at: number;
+                    generation: number;
+                    writeId: string;
+                    refsDigest: string;
+                } | null;
+                vmHolds: Record<string, {
+                    startedAt: number;
+                    pid: number;
+                    processStartTime: string;
+                }>;
+                transition: {
+                    id: string;
+                    kind: "handover";
+                    phase: "draining" | "vm-receiving" | "home-sending" | "published";
+                    lease: number;
+                    sequences?: Record<string, number> | undefined;
+                } | {
+                    id: string;
+                    kind: "reclaim";
+                    phase: "index" | "sending" | "unguarding" | "publishing";
+                    lease: null;
+                } | null;
+                closed?: boolean | undefined;
+                confirmedWrites?: Record<string, {
+                    at: number;
+                    generation: number;
+                    refsDigest: string;
+                }> | undefined;
+            }>;
+        };
+    };
     readonly listTranscripts: {
         readonly method: "POST";
         readonly path: (_params: NoParams) => string;
@@ -25176,6 +26968,66 @@ export declare const hostRoutes: {
             }>;
         };
     };
+    readonly worktrees: {
+        readonly method: "GET";
+        readonly path: (params: ProjectParams) => string;
+        readonly timeoutMs: 60000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                lanes: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    path: z.ZodString;
+                    branch: z.ZodString;
+                    dirty: z.ZodBoolean;
+                }, "strip", z.ZodTypeAny, {
+                    dirty: boolean;
+                    path: string;
+                    name: string;
+                    branch: string;
+                }, {
+                    dirty: boolean;
+                    path: string;
+                    name: string;
+                    branch: string;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                lanes: {
+                    dirty: boolean;
+                    path: string;
+                    name: string;
+                    branch: string;
+                }[];
+            }, {
+                lanes: {
+                    dirty: boolean;
+                    path: string;
+                    name: string;
+                    branch: string;
+                }[];
+            }>;
+        };
+    };
+    readonly laneAdmission: {
+        readonly method: "POST";
+        readonly path: (params: ProjectParams) => string;
+        readonly body: z.ZodObject<{
+            frozen: z.ZodBoolean;
+        }, "strict", z.ZodTypeAny, {
+            frozen: boolean;
+        }, {
+            frozen: boolean;
+        }>;
+        readonly timeoutMs: 60000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                frozen: z.ZodBoolean;
+            }, "strict", z.ZodTypeAny, {
+                frozen: boolean;
+            }, {
+                frozen: boolean;
+            }>;
+        };
+    };
     readonly freeze: {
         readonly method: "POST";
         readonly path: (params: ProjectParams) => string;
@@ -25199,11 +27051,18 @@ export declare const hostRoutes: {
         readonly body: z.ZodObject<{
             homeName: z.ZodString;
             reason: z.ZodEnum<["disconnect", "cancelled-connect", "pc-git"]>;
+        } & {
+            expectedGeneration: z.ZodNumber;
+            transitionId: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
         }, "strict", z.ZodTypeAny, {
             reason: "disconnect" | "cancelled-connect" | "pc-git";
+            expectedGeneration: number;
+            transitionId: string | null;
             homeName: string;
         }, {
             reason: "disconnect" | "cancelled-connect" | "pc-git";
+            expectedGeneration: number;
+            transitionId: string | null;
             homeName: string;
         }>;
         readonly timeoutMs: 15000;
@@ -25222,9 +27081,16 @@ export declare const hostRoutes: {
         readonly path: (params: ProjectParams) => string;
         readonly body: z.ZodObject<{
             refreshIndex: z.ZodDefault<z.ZodBoolean>;
+        } & {
+            expectedGeneration: z.ZodNumber;
+            transitionId: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
         }, "strict", z.ZodTypeAny, {
+            expectedGeneration: number;
+            transitionId: string | null;
             refreshIndex: boolean;
         }, {
+            expectedGeneration: number;
+            transitionId: string | null;
             refreshIndex?: boolean | undefined;
         }>;
         readonly timeoutMs: 15000;
@@ -25244,33 +27110,6 @@ export declare const hostRoutes: {
             }>;
         };
     };
-    readonly refreshGitIndex: {
-        readonly method: "POST";
-        readonly path: (params: ProjectParams) => string;
-        readonly body: z.ZodObject<{
-            since: z.ZodNullable<z.ZodString>;
-        }, "strict", z.ZodTypeAny, {
-            since: string | null;
-        }, {
-            since: string | null;
-        }>;
-        readonly timeoutMs: 120000;
-        readonly statuses: {
-            readonly 200: z.ZodObject<{
-                head: z.ZodNullable<z.ZodString>;
-                refreshed: z.ZodBoolean;
-                warning: z.ZodNullable<z.ZodString>;
-            }, "strip", z.ZodTypeAny, {
-                warning: string | null;
-                head: string | null;
-                refreshed: boolean;
-            }, {
-                warning: string | null;
-                head: string | null;
-                refreshed: boolean;
-            }>;
-        };
-    };
     readonly thaw: {
         readonly method: "POST";
         readonly path: (params: ProjectParams) => string;
@@ -25330,13 +27169,13 @@ export declare const hostRoutes: {
                 finalizedBatchIds: z.ZodArray<z.ZodString, "many">;
                 cancelledBatchIds: z.ZodArray<z.ZodString, "many">;
             }, "strip", z.ZodTypeAny, {
-                outcome: "settled" | "forced";
+                outcome: "forced" | "settled";
                 waitedMs: number;
                 closedSegments: number;
                 finalizedBatchIds: string[];
                 cancelledBatchIds: string[];
             }, {
-                outcome: "settled" | "forced";
+                outcome: "forced" | "settled";
                 waitedMs: number;
                 closedSegments: number;
                 finalizedBatchIds: string[];
@@ -25441,7 +27280,7 @@ export declare const hostRoutes: {
     };
     readonly syncFolders: {
         readonly method: "POST";
-        readonly path: (_params: NoParams) => string;
+        readonly path: (params: FencedParams) => string;
         readonly body: z.ZodEffects<z.ZodObject<{
             projectId: z.ZodString;
             kind: z.ZodEnum<["code", "git"]>;
@@ -25559,7 +27398,7 @@ export declare const hostRoutes: {
     };
     readonly syncFolderType: {
         readonly method: "PATCH";
-        readonly path: ({ folderId }: FolderParams) => string;
+        readonly path: (params: FolderParams & FencedParams) => string;
         readonly body: z.ZodEffects<z.ZodObject<{
             type: z.ZodOptional<z.ZodEnum<["sendonly", "receiveonly", "sendreceive"]>>;
             paused: z.ZodOptional<z.ZodBoolean>;
@@ -25632,7 +27471,7 @@ export declare const hostRoutes: {
     };
     readonly syncRemoveFolder: {
         readonly method: "DELETE";
-        readonly path: ({ folderId }: FolderParams) => string;
+        readonly path: (params: FolderParams & FencedParams) => string;
         readonly timeoutMs: 15000;
         readonly statuses: {
             readonly 204: "none";
@@ -25640,7 +27479,7 @@ export declare const hostRoutes: {
     };
     readonly syncScan: {
         readonly method: "POST";
-        readonly path: (params: FolderParams) => string;
+        readonly path: (params: FolderParams & FencedParams) => string;
         readonly timeoutMs: number;
         readonly statuses: {
             readonly 204: "none";
@@ -25648,7 +27487,7 @@ export declare const hostRoutes: {
     };
     readonly syncRevert: {
         readonly method: "POST";
-        readonly path: (params: FolderParams) => string;
+        readonly path: (params: FolderParams & FencedParams) => string;
         readonly timeoutMs: 15000;
         readonly statuses: {
             readonly 204: "none";
@@ -25656,7 +27495,7 @@ export declare const hostRoutes: {
     };
     readonly syncOverride: {
         readonly method: "POST";
-        readonly path: (params: FolderParams) => string;
+        readonly path: (params: FolderParams & FencedParams) => string;
         readonly timeoutMs: 15000;
         readonly statuses: {
             readonly 204: "none";
@@ -25931,6 +27770,23 @@ export declare const hostRoutes: {
             }>;
         };
     };
+    readonly syncRemoteNeedThrough: {
+        readonly method: "GET";
+        readonly path: (params: FolderParams & {
+            deviceId: string;
+            sequence: number;
+        }) => string;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                names: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                names: string[];
+            }, {
+                names: string[];
+            }>;
+        };
+    };
     readonly syncInspect: {
         readonly method: "POST";
         readonly path: (_params: NoParams) => string;
@@ -26760,6 +28616,7 @@ export declare const hostRoutes: {
             gid: z.ZodOptional<z.ZodNumber>;
             version: z.ZodString;
             port: z.ZodNumber;
+            nonce: z.ZodOptional<z.ZodString>;
             providerAuth: z.ZodObject<Pick<{
                 env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
                 files: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -26813,6 +28670,7 @@ export declare const hostRoutes: {
                     contentBase64: string;
                 }[];
             };
+            nonce?: string | undefined;
             uid?: number | undefined;
             gid?: number | undefined;
         }, {
@@ -26828,6 +28686,7 @@ export declare const hostRoutes: {
                     contentBase64: string;
                 }[] | undefined;
             };
+            nonce?: string | undefined;
             uid?: number | undefined;
             gid?: number | undefined;
         }>;
@@ -26944,10 +28803,13 @@ export declare const hostRoutes: {
         readonly path: (_params: NoParams) => string;
         readonly body: z.ZodObject<{
             version: z.ZodEffects<z.ZodString, string, string>;
+            npmRegistry: z.ZodOptional<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
             version: string;
+            npmRegistry?: string | undefined;
         }, {
             version: string;
+            npmRegistry?: string | undefined;
         }>;
         readonly timeoutMs: 15000;
         readonly statuses: {
@@ -26955,6 +28817,221 @@ export declare const hostRoutes: {
             readonly 409: "error-code";
         };
     };
+    readonly sharedVmRoster: {
+        readonly method: "GET";
+        readonly path: (_params: NoParams) => string;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                instances: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                    user: z.ZodString;
+                    port: z.ZodNumber;
+                    version: z.ZodNullable<z.ZodString>;
+                    connectedCount: z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"unknown">]>;
+                    connectedProjectIds: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodLiteral<"unknown">]>>>;
+                }, "strip", z.ZodTypeAny, {
+                    user: string;
+                    version: string | null;
+                    port: number;
+                    connectedCount: number | "unknown";
+                    connectedProjectIds: string[] | "unknown";
+                }, {
+                    user: string;
+                    version: string | null;
+                    port: number;
+                    connectedCount: number | "unknown";
+                    connectedProjectIds?: string[] | "unknown" | undefined;
+                }>, {
+                    user: string;
+                    version: string | null;
+                    port: number;
+                    connectedCount: number | "unknown";
+                    connectedProjectIds: string[] | "unknown";
+                }, {
+                    user: string;
+                    version: string | null;
+                    port: number;
+                    connectedCount: number | "unknown";
+                    connectedProjectIds?: string[] | "unknown" | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                instances: {
+                    user: string;
+                    version: string | null;
+                    port: number;
+                    connectedCount: number | "unknown";
+                    connectedProjectIds: string[] | "unknown";
+                }[];
+            }, {
+                instances: {
+                    user: string;
+                    version: string | null;
+                    port: number;
+                    connectedCount: number | "unknown";
+                    connectedProjectIds?: string[] | "unknown" | undefined;
+                }[];
+            }>;
+        };
+    };
+    readonly sharedVmNotify: {
+        readonly method: "POST";
+        readonly path: (_params: NoParams) => string;
+        readonly body: z.ZodObject<{
+            action: z.ZodEnum<["reset", "destroy", "forced"]>;
+            message: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            action: "destroy" | "reset" | "forced";
+            message?: string | undefined;
+        }, {
+            action: "destroy" | "reset" | "forced";
+            message?: string | undefined;
+        }>;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                results: z.ZodArray<z.ZodObject<{
+                    user: z.ZodString;
+                    delivered: z.ZodBoolean;
+                }, "strip", z.ZodTypeAny, {
+                    user: string;
+                    delivered: boolean;
+                }, {
+                    user: string;
+                    delivered: boolean;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                results: {
+                    user: string;
+                    delivered: boolean;
+                }[];
+            }, {
+                results: {
+                    user: string;
+                    delivered: boolean;
+                }[];
+            }>;
+        };
+    };
+    readonly sharedVmNotices: {
+        readonly method: "GET";
+        readonly path: (_params: NoParams) => string;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                notices: z.ZodArray<z.ZodObject<{
+                    action: z.ZodEnum<["reset", "destroy", "forced"]>;
+                    message: z.ZodOptional<z.ZodString>;
+                } & {
+                    fromUser: z.ZodString;
+                    at: z.ZodString;
+                } & {
+                    id: z.ZodString;
+                }, "strict", z.ZodTypeAny, {
+                    at: string;
+                    id: string;
+                    action: "destroy" | "reset" | "forced";
+                    fromUser: string;
+                    message?: string | undefined;
+                }, {
+                    at: string;
+                    id: string;
+                    action: "destroy" | "reset" | "forced";
+                    fromUser: string;
+                    message?: string | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                notices: {
+                    at: string;
+                    id: string;
+                    action: "destroy" | "reset" | "forced";
+                    fromUser: string;
+                    message?: string | undefined;
+                }[];
+            }, {
+                notices: {
+                    at: string;
+                    id: string;
+                    action: "destroy" | "reset" | "forced";
+                    fromUser: string;
+                    message?: string | undefined;
+                }[];
+            }>;
+        };
+    };
+    readonly sharedVmDismiss: {
+        readonly method: "POST";
+        readonly path: (_params: NoParams) => string;
+        readonly body: z.ZodObject<{
+            id: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+        }, {
+            id: string;
+        }>;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 204: "none";
+        };
+    };
+    readonly sharedVmAbandon: {
+        readonly method: "POST";
+        readonly path: (_params: NoParams) => string;
+        readonly body: z.ZodObject<{
+            projectId: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            projectId: string;
+        }, {
+            projectId: string;
+        }>;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 204: "none";
+        };
+    };
+    readonly sharedVmFence: {
+        readonly method: "POST";
+        readonly path: (_params: NoParams) => string;
+        readonly body: z.ZodObject<{
+            mode: z.ZodEnum<["set", "clear"]>;
+            operationId: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            mode: "set" | "clear";
+            operationId: string;
+        }, {
+            mode: "set" | "clear";
+            operationId: string;
+        }>;
+        readonly timeoutMs: 15000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                fence: z.ZodNullable<z.ZodObject<{
+                    ownerUser: z.ZodString;
+                    operationId: z.ZodString;
+                    expiresAt: z.ZodString;
+                }, "strict", z.ZodTypeAny, {
+                    operationId: string;
+                    expiresAt: string;
+                    ownerUser: string;
+                }, {
+                    operationId: string;
+                    expiresAt: string;
+                    ownerUser: string;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                fence: {
+                    operationId: string;
+                    expiresAt: string;
+                    ownerUser: string;
+                } | null;
+            }, {
+                fence: {
+                    operationId: string;
+                    expiresAt: string;
+                    ownerUser: string;
+                } | null;
+            }>;
+        };
+    };
     readonly hostUpdateStatus: {
         readonly method: "GET";
         readonly path: (_params: NoParams) => string;
@@ -27312,6 +29389,74 @@ export declare const hostRoutes: {
             }>;
         };
     };
+    readonly getProviderUsageSettingsStatus: {
+        readonly method: "GET";
+        readonly path: (_params: NoParams) => string;
+        readonly timeoutMs: 3000;
+        readonly statuses: {
+            readonly 200: z.ZodObject<{
+                appliedRevision: z.ZodNullable<z.ZodString>;
+            }, "strict", z.ZodTypeAny, {
+                appliedRevision: string | null;
+            }, {
+                appliedRevision: string | null;
+            }>;
+        };
+    };
+    readonly putProviderUsageSettings: {
+        readonly method: "PUT";
+        readonly path: (_params: NoParams) => string;
+        readonly body: z.ZodObject<{
+            revision: z.ZodString;
+            settings: z.ZodObject<{
+                enabled: z.ZodBoolean;
+                runningMaxAgeMin: z.ZodNumber;
+                openProjectMaxAgeMin: z.ZodNumber;
+                hoverMaxAgeSec: z.ZodNumber;
+                tokenCheckMinutes: z.ZodUnion<[z.ZodLiteral<0>, z.ZodNumber]>;
+            }, "strict", z.ZodTypeAny, {
+                enabled: boolean;
+                runningMaxAgeMin: number;
+                openProjectMaxAgeMin: number;
+                hoverMaxAgeSec: number;
+                tokenCheckMinutes: number;
+            }, {
+                enabled: boolean;
+                runningMaxAgeMin: number;
+                openProjectMaxAgeMin: number;
+                hoverMaxAgeSec: number;
+                tokenCheckMinutes: number;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            revision: string;
+            settings: {
+                enabled: boolean;
+                runningMaxAgeMin: number;
+                openProjectMaxAgeMin: number;
+                hoverMaxAgeSec: number;
+                tokenCheckMinutes: number;
+            };
+        }, {
+            revision: string;
+            settings: {
+                enabled: boolean;
+                runningMaxAgeMin: number;
+                openProjectMaxAgeMin: number;
+                hoverMaxAgeSec: number;
+                tokenCheckMinutes: number;
+            };
+        }>;
+        readonly timeoutMs: 3000;
+        readonly statuses: {
+            readonly 202: z.ZodObject<{
+                revision: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                revision: string;
+            }, {
+                revision: string;
+            }>;
+        };
+    };
     readonly getSkillSettingsStatus: {
         readonly method: "GET";
         readonly path: (_params: NoParams) => string;