@treeseed/sdk 0.13.0-rc.11 → 0.13.0-rc.111

package/dist/deployment/ai-mode.d.ts

@@ -0,0 +1,454 @@
+import { z } from 'zod';
+export declare const AI_MODE_INTERNAL_PATH: string;
+export declare const aiModeSchema: z.ZodEnum<["awake", "sleep"]>;
+export type AiMode = z.infer<typeof aiModeSchema>;
+export declare const aiModeFingerprintSchema: z.ZodObject<{
+    inferenceRuntimeDigest: z.ZodString;
+    trainingRuntimeDigest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    inferenceRuntimeDigest: string;
+    trainingRuntimeDigest: string;
+}, {
+    inferenceRuntimeDigest: string;
+    trainingRuntimeDigest: string;
+}>;
+export type AiModeFingerprint = z.infer<typeof aiModeFingerprintSchema>;
+export declare const aiModeRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.ai-mode-request/v1">;
+    target: z.ZodEnum<["awake", "sleep"]>;
+    idempotencyKey: z.ZodString;
+    drainTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: "treeseed.ai-mode-request/v1";
+    target: "awake" | "sleep";
+    idempotencyKey: string;
+    drainTimeoutSeconds: number;
+}, {
+    schemaVersion: "treeseed.ai-mode-request/v1";
+    target: "awake" | "sleep";
+    idempotencyKey: string;
+    drainTimeoutSeconds?: number | undefined;
+}>;
+export declare const aiModeTransitionStepSchema: z.ZodObject<{
+    id: z.ZodEnum<["close-inference", "drain-inference", "stop-vllm", "start-training", "open-training", "close-training", "drain-training", "stop-training", "start-vllm", "warm-vllm", "open-inference", "rollback"]>;
+    state: z.ZodEnum<["pending", "running", "succeeded", "skipped", "failed"]>;
+    completedAt: z.ZodNullable<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+    state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+    completedAt: string | null;
+}, {
+    id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+    state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+    completedAt: string | null;
+}>;
+export declare const aiModeTransitionReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.ai-mode-transition-receipt/v1">;
+    transitionId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    resource: z.ZodLiteral<"ai-gpu">;
+    requestedBy: z.ZodEnum<["operator", "ai-lab"]>;
+    from: z.ZodEnum<["awake", "sleep"]>;
+    to: z.ZodEnum<["awake", "sleep"]>;
+    state: z.ZodEnum<["planned", "running", "succeeded", "postponed", "rolled-back", "degraded"]>;
+    reason: z.ZodNullable<z.ZodEnum<["active-inference", "active-training", "transition-failed", "recovery-failed"]>>;
+    fingerprint: z.ZodObject<{
+        inferenceRuntimeDigest: z.ZodString;
+        trainingRuntimeDigest: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        inferenceRuntimeDigest: string;
+        trainingRuntimeDigest: string;
+    }, {
+        inferenceRuntimeDigest: string;
+        trainingRuntimeDigest: string;
+    }>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<["close-inference", "drain-inference", "stop-vllm", "start-training", "open-training", "close-training", "drain-training", "stop-training", "start-vllm", "warm-vllm", "open-inference", "rollback"]>;
+        state: z.ZodEnum<["pending", "running", "succeeded", "skipped", "failed"]>;
+        completedAt: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+        state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+        completedAt: string | null;
+    }, {
+        id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+        state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+        completedAt: string | null;
+    }>, "many">;
+    startedAt: z.ZodString;
+    completedAt: z.ZodNullable<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    resource: "ai-gpu";
+    state: "degraded" | "running" | "succeeded" | "planned" | "postponed" | "rolled-back";
+    schemaVersion: "treeseed.ai-mode-transition-receipt/v1";
+    steps: {
+        id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+        state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+        completedAt: string | null;
+    }[];
+    completedAt: string | null;
+    idempotencyKey: string;
+    transitionId: string;
+    requestedBy: "operator" | "ai-lab";
+    from: "awake" | "sleep";
+    to: "awake" | "sleep";
+    reason: "active-inference" | "active-training" | "transition-failed" | "recovery-failed" | null;
+    fingerprint: {
+        inferenceRuntimeDigest: string;
+        trainingRuntimeDigest: string;
+    };
+    startedAt: string;
+}, {
+    resource: "ai-gpu";
+    state: "degraded" | "running" | "succeeded" | "planned" | "postponed" | "rolled-back";
+    schemaVersion: "treeseed.ai-mode-transition-receipt/v1";
+    steps: {
+        id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+        state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+        completedAt: string | null;
+    }[];
+    completedAt: string | null;
+    idempotencyKey: string;
+    transitionId: string;
+    requestedBy: "operator" | "ai-lab";
+    from: "awake" | "sleep";
+    to: "awake" | "sleep";
+    reason: "active-inference" | "active-training" | "transition-failed" | "recovery-failed" | null;
+    fingerprint: {
+        inferenceRuntimeDigest: string;
+        trainingRuntimeDigest: string;
+    };
+    startedAt: string;
+}>;
+export declare const aiModeStatusSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.ai-mode-status/v1">;
+    resource: z.ZodLiteral<"ai-gpu">;
+    available: z.ZodBoolean;
+    mode: z.ZodEnum<["awake", "sleep", "transitioning-awake", "transitioning-sleep", "degraded", "unavailable"]>;
+    fingerprint: z.ZodNullable<z.ZodObject<{
+        inferenceRuntimeDigest: z.ZodString;
+        trainingRuntimeDigest: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        inferenceRuntimeDigest: string;
+        trainingRuntimeDigest: string;
+    }, {
+        inferenceRuntimeDigest: string;
+        trainingRuntimeDigest: string;
+    }>>;
+    activeTransition: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"treeseed.ai-mode-transition-receipt/v1">;
+        transitionId: z.ZodString;
+        idempotencyKey: z.ZodString;
+        resource: z.ZodLiteral<"ai-gpu">;
+        requestedBy: z.ZodEnum<["operator", "ai-lab"]>;
+        from: z.ZodEnum<["awake", "sleep"]>;
+        to: z.ZodEnum<["awake", "sleep"]>;
+        state: z.ZodEnum<["planned", "running", "succeeded", "postponed", "rolled-back", "degraded"]>;
+        reason: z.ZodNullable<z.ZodEnum<["active-inference", "active-training", "transition-failed", "recovery-failed"]>>;
+        fingerprint: z.ZodObject<{
+            inferenceRuntimeDigest: z.ZodString;
+            trainingRuntimeDigest: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            inferenceRuntimeDigest: string;
+            trainingRuntimeDigest: string;
+        }, {
+            inferenceRuntimeDigest: string;
+            trainingRuntimeDigest: string;
+        }>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodEnum<["close-inference", "drain-inference", "stop-vllm", "start-training", "open-training", "close-training", "drain-training", "stop-training", "start-vllm", "warm-vllm", "open-inference", "rollback"]>;
+            state: z.ZodEnum<["pending", "running", "succeeded", "skipped", "failed"]>;
+            completedAt: z.ZodNullable<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+            state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+            completedAt: string | null;
+        }, {
+            id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+            state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+            completedAt: string | null;
+        }>, "many">;
+        startedAt: z.ZodString;
+        completedAt: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        resource: "ai-gpu";
+        state: "degraded" | "running" | "succeeded" | "planned" | "postponed" | "rolled-back";
+        schemaVersion: "treeseed.ai-mode-transition-receipt/v1";
+        steps: {
+            id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+            state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+            completedAt: string | null;
+        }[];
+        completedAt: string | null;
+        idempotencyKey: string;
+        transitionId: string;
+        requestedBy: "operator" | "ai-lab";
+        from: "awake" | "sleep";
+        to: "awake" | "sleep";
+        reason: "active-inference" | "active-training" | "transition-failed" | "recovery-failed" | null;
+        fingerprint: {
+            inferenceRuntimeDigest: string;
+            trainingRuntimeDigest: string;
+        };
+        startedAt: string;
+    }, {
+        resource: "ai-gpu";
+        state: "degraded" | "running" | "succeeded" | "planned" | "postponed" | "rolled-back";
+        schemaVersion: "treeseed.ai-mode-transition-receipt/v1";
+        steps: {
+            id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+            state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+            completedAt: string | null;
+        }[];
+        completedAt: string | null;
+        idempotencyKey: string;
+        transitionId: string;
+        requestedBy: "operator" | "ai-lab";
+        from: "awake" | "sleep";
+        to: "awake" | "sleep";
+        reason: "active-inference" | "active-training" | "transition-failed" | "recovery-failed" | null;
+        fingerprint: {
+            inferenceRuntimeDigest: string;
+            trainingRuntimeDigest: string;
+        };
+        startedAt: string;
+    }>>;
+    lastReceipt: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"treeseed.ai-mode-transition-receipt/v1">;
+        transitionId: z.ZodString;
+        idempotencyKey: z.ZodString;
+        resource: z.ZodLiteral<"ai-gpu">;
+        requestedBy: z.ZodEnum<["operator", "ai-lab"]>;
+        from: z.ZodEnum<["awake", "sleep"]>;
+        to: z.ZodEnum<["awake", "sleep"]>;
+        state: z.ZodEnum<["planned", "running", "succeeded", "postponed", "rolled-back", "degraded"]>;
+        reason: z.ZodNullable<z.ZodEnum<["active-inference", "active-training", "transition-failed", "recovery-failed"]>>;
+        fingerprint: z.ZodObject<{
+            inferenceRuntimeDigest: z.ZodString;
+            trainingRuntimeDigest: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            inferenceRuntimeDigest: string;
+            trainingRuntimeDigest: string;
+        }, {
+            inferenceRuntimeDigest: string;
+            trainingRuntimeDigest: string;
+        }>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodEnum<["close-inference", "drain-inference", "stop-vllm", "start-training", "open-training", "close-training", "drain-training", "stop-training", "start-vllm", "warm-vllm", "open-inference", "rollback"]>;
+            state: z.ZodEnum<["pending", "running", "succeeded", "skipped", "failed"]>;
+            completedAt: z.ZodNullable<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+            state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+            completedAt: string | null;
+        }, {
+            id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+            state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+            completedAt: string | null;
+        }>, "many">;
+        startedAt: z.ZodString;
+        completedAt: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        resource: "ai-gpu";
+        state: "degraded" | "running" | "succeeded" | "planned" | "postponed" | "rolled-back";
+        schemaVersion: "treeseed.ai-mode-transition-receipt/v1";
+        steps: {
+            id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+            state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+            completedAt: string | null;
+        }[];
+        completedAt: string | null;
+        idempotencyKey: string;
+        transitionId: string;
+        requestedBy: "operator" | "ai-lab";
+        from: "awake" | "sleep";
+        to: "awake" | "sleep";
+        reason: "active-inference" | "active-training" | "transition-failed" | "recovery-failed" | null;
+        fingerprint: {
+            inferenceRuntimeDigest: string;
+            trainingRuntimeDigest: string;
+        };
+        startedAt: string;
+    }, {
+        resource: "ai-gpu";
+        state: "degraded" | "running" | "succeeded" | "planned" | "postponed" | "rolled-back";
+        schemaVersion: "treeseed.ai-mode-transition-receipt/v1";
+        steps: {
+            id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+            state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+            completedAt: string | null;
+        }[];
+        completedAt: string | null;
+        idempotencyKey: string;
+        transitionId: string;
+        requestedBy: "operator" | "ai-lab";
+        from: "awake" | "sleep";
+        to: "awake" | "sleep";
+        reason: "active-inference" | "active-training" | "transition-failed" | "recovery-failed" | null;
+        fingerprint: {
+            inferenceRuntimeDigest: string;
+            trainingRuntimeDigest: string;
+        };
+        startedAt: string;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    resource: "ai-gpu";
+    schemaVersion: "treeseed.ai-mode-status/v1";
+    available: boolean;
+    mode: "degraded" | "awake" | "sleep" | "transitioning-awake" | "transitioning-sleep" | "unavailable";
+    fingerprint: {
+        inferenceRuntimeDigest: string;
+        trainingRuntimeDigest: string;
+    } | null;
+    activeTransition: {
+        resource: "ai-gpu";
+        state: "degraded" | "running" | "succeeded" | "planned" | "postponed" | "rolled-back";
+        schemaVersion: "treeseed.ai-mode-transition-receipt/v1";
+        steps: {
+            id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+            state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+            completedAt: string | null;
+        }[];
+        completedAt: string | null;
+        idempotencyKey: string;
+        transitionId: string;
+        requestedBy: "operator" | "ai-lab";
+        from: "awake" | "sleep";
+        to: "awake" | "sleep";
+        reason: "active-inference" | "active-training" | "transition-failed" | "recovery-failed" | null;
+        fingerprint: {
+            inferenceRuntimeDigest: string;
+            trainingRuntimeDigest: string;
+        };
+        startedAt: string;
+    } | null;
+    lastReceipt: {
+        resource: "ai-gpu";
+        state: "degraded" | "running" | "succeeded" | "planned" | "postponed" | "rolled-back";
+        schemaVersion: "treeseed.ai-mode-transition-receipt/v1";
+        steps: {
+            id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+            state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+            completedAt: string | null;
+        }[];
+        completedAt: string | null;
+        idempotencyKey: string;
+        transitionId: string;
+        requestedBy: "operator" | "ai-lab";
+        from: "awake" | "sleep";
+        to: "awake" | "sleep";
+        reason: "active-inference" | "active-training" | "transition-failed" | "recovery-failed" | null;
+        fingerprint: {
+            inferenceRuntimeDigest: string;
+            trainingRuntimeDigest: string;
+        };
+        startedAt: string;
+    } | null;
+}, {
+    resource: "ai-gpu";
+    schemaVersion: "treeseed.ai-mode-status/v1";
+    available: boolean;
+    mode: "degraded" | "awake" | "sleep" | "transitioning-awake" | "transitioning-sleep" | "unavailable";
+    fingerprint: {
+        inferenceRuntimeDigest: string;
+        trainingRuntimeDigest: string;
+    } | null;
+    activeTransition: {
+        resource: "ai-gpu";
+        state: "degraded" | "running" | "succeeded" | "planned" | "postponed" | "rolled-back";
+        schemaVersion: "treeseed.ai-mode-transition-receipt/v1";
+        steps: {
+            id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+            state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+            completedAt: string | null;
+        }[];
+        completedAt: string | null;
+        idempotencyKey: string;
+        transitionId: string;
+        requestedBy: "operator" | "ai-lab";
+        from: "awake" | "sleep";
+        to: "awake" | "sleep";
+        reason: "active-inference" | "active-training" | "transition-failed" | "recovery-failed" | null;
+        fingerprint: {
+            inferenceRuntimeDigest: string;
+            trainingRuntimeDigest: string;
+        };
+        startedAt: string;
+    } | null;
+    lastReceipt: {
+        resource: "ai-gpu";
+        state: "degraded" | "running" | "succeeded" | "planned" | "postponed" | "rolled-back";
+        schemaVersion: "treeseed.ai-mode-transition-receipt/v1";
+        steps: {
+            id: "close-inference" | "drain-inference" | "stop-vllm" | "start-training" | "open-training" | "close-training" | "drain-training" | "stop-training" | "start-vllm" | "warm-vllm" | "open-inference" | "rollback";
+            state: "pending" | "failed" | "running" | "succeeded" | "skipped";
+            completedAt: string | null;
+        }[];
+        completedAt: string | null;
+        idempotencyKey: string;
+        transitionId: string;
+        requestedBy: "operator" | "ai-lab";
+        from: "awake" | "sleep";
+        to: "awake" | "sleep";
+        reason: "active-inference" | "active-training" | "transition-failed" | "recovery-failed" | null;
+        fingerprint: {
+            inferenceRuntimeDigest: string;
+            trainingRuntimeDigest: string;
+        };
+        startedAt: string;
+    } | null;
+}>;
+export declare const aiModeInternalControlSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.ai-mode-internal-control/v1">;
+    transport: z.ZodLiteral<"mtls">;
+    clientCommonName: z.ZodLiteral<"client-ai-lab-mode">;
+    method: z.ZodLiteral<"POST">;
+    path: z.ZodLiteral<string>;
+    urlEnvironment: z.ZodLiteral<"TREESEED_AI_MODE_URL">;
+    credentialFiles: z.ZodObject<{
+        certificateAuthority: z.ZodLiteral<"/run/secrets/ai-mode-ca">;
+        certificate: z.ZodLiteral<"/run/secrets/ai-mode-client-cert">;
+        privateKey: z.ZodLiteral<"/run/secrets/ai-mode-client-key">;
+    }, "strict", z.ZodTypeAny, {
+        certificateAuthority: "/run/secrets/ai-mode-ca";
+        certificate: "/run/secrets/ai-mode-client-cert";
+        privateKey: "/run/secrets/ai-mode-client-key";
+    }, {
+        certificateAuthority: "/run/secrets/ai-mode-ca";
+        certificate: "/run/secrets/ai-mode-client-cert";
+        privateKey: "/run/secrets/ai-mode-client-key";
+    }>;
+    requestSchema: z.ZodLiteral<"treeseed.ai-mode-request/v1">;
+    receiptSchema: z.ZodLiteral<"treeseed.ai-mode-transition-receipt/v1">;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    schemaVersion: "treeseed.ai-mode-internal-control/v1";
+    transport: "mtls";
+    clientCommonName: "client-ai-lab-mode";
+    method: "POST";
+    urlEnvironment: "TREESEED_AI_MODE_URL";
+    credentialFiles: {
+        certificateAuthority: "/run/secrets/ai-mode-ca";
+        certificate: "/run/secrets/ai-mode-client-cert";
+        privateKey: "/run/secrets/ai-mode-client-key";
+    };
+    requestSchema: "treeseed.ai-mode-request/v1";
+    receiptSchema: "treeseed.ai-mode-transition-receipt/v1";
+}, {
+    path: string;
+    schemaVersion: "treeseed.ai-mode-internal-control/v1";
+    transport: "mtls";
+    clientCommonName: "client-ai-lab-mode";
+    method: "POST";
+    urlEnvironment: "TREESEED_AI_MODE_URL";
+    credentialFiles: {
+        certificateAuthority: "/run/secrets/ai-mode-ca";
+        certificate: "/run/secrets/ai-mode-client-cert";
+        privateKey: "/run/secrets/ai-mode-client-key";
+    };
+    requestSchema: "treeseed.ai-mode-request/v1";
+    receiptSchema: "treeseed.ai-mode-transition-receipt/v1";
+}>;
+export type AiModeRequest = z.infer<typeof aiModeRequestSchema>;
+export type AiModeTransitionReceipt = z.infer<typeof aiModeTransitionReceiptSchema>;
+export type AiModeStatus = z.infer<typeof aiModeStatusSchema>;

package/dist/deployment/ai-mode.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+const AI_MODE_INTERNAL_PATH = `${["", "v1"].join("/")}/ai/mode`;
+const aiModeSchema = z.enum(["awake", "sleep"]);
+const aiModeFingerprintSchema = z.object({
+  inferenceRuntimeDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+  trainingRuntimeDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/u)
+}).strict();
+const aiModeRequestSchema = z.object({
+  schemaVersion: z.literal("treeseed.ai-mode-request/v1"),
+  target: aiModeSchema,
+  idempotencyKey: z.string().min(1).max(128).regex(/^[A-Za-z0-9._:-]+$/u),
+  drainTimeoutSeconds: z.number().int().min(1).max(3600).default(900)
+}).strict();
+const aiModeTransitionStepSchema = z.object({
+  id: z.enum(["close-inference", "drain-inference", "stop-vllm", "start-training", "open-training", "close-training", "drain-training", "stop-training", "start-vllm", "warm-vllm", "open-inference", "rollback"]),
+  state: z.enum(["pending", "running", "succeeded", "skipped", "failed"]),
+  completedAt: z.string().datetime().nullable()
+}).strict();
+const aiModeTransitionReceiptSchema = z.object({
+  schemaVersion: z.literal("treeseed.ai-mode-transition-receipt/v1"),
+  transitionId: z.string().uuid(),
+  idempotencyKey: z.string().min(1).max(128),
+  resource: z.literal("ai-gpu"),
+  requestedBy: z.enum(["operator", "ai-lab"]),
+  from: aiModeSchema,
+  to: aiModeSchema,
+  state: z.enum(["planned", "running", "succeeded", "postponed", "rolled-back", "degraded"]),
+  reason: z.enum(["active-inference", "active-training", "transition-failed", "recovery-failed"]).nullable(),
+  fingerprint: aiModeFingerprintSchema,
+  steps: z.array(aiModeTransitionStepSchema),
+  startedAt: z.string().datetime(),
+  completedAt: z.string().datetime().nullable()
+}).strict();
+const aiModeStatusSchema = z.object({
+  schemaVersion: z.literal("treeseed.ai-mode-status/v1"),
+  resource: z.literal("ai-gpu"),
+  available: z.boolean(),
+  mode: z.enum(["awake", "sleep", "transitioning-awake", "transitioning-sleep", "degraded", "unavailable"]),
+  fingerprint: aiModeFingerprintSchema.nullable(),
+  activeTransition: aiModeTransitionReceiptSchema.nullable(),
+  lastReceipt: aiModeTransitionReceiptSchema.nullable()
+}).strict();
+const aiModeInternalControlSchema = z.object({
+  schemaVersion: z.literal("treeseed.ai-mode-internal-control/v1"),
+  transport: z.literal("mtls"),
+  clientCommonName: z.literal("client-ai-lab-mode"),
+  method: z.literal("POST"),
+  path: z.literal(AI_MODE_INTERNAL_PATH),
+  urlEnvironment: z.literal("TREESEED_AI_MODE_URL"),
+  credentialFiles: z.object({
+    certificateAuthority: z.literal("/run/secrets/ai-mode-ca"),
+    certificate: z.literal("/run/secrets/ai-mode-client-cert"),
+    privateKey: z.literal("/run/secrets/ai-mode-client-key")
+  }).strict(),
+  requestSchema: z.literal("treeseed.ai-mode-request/v1"),
+  receiptSchema: z.literal("treeseed.ai-mode-transition-receipt/v1")
+}).strict();
+export {
+  AI_MODE_INTERNAL_PATH,
+  aiModeFingerprintSchema,
+  aiModeInternalControlSchema,
+  aiModeRequestSchema,
+  aiModeSchema,
+  aiModeStatusSchema,
+  aiModeTransitionReceiptSchema,
+  aiModeTransitionStepSchema
+};

package/dist/deployment/canonical.d.ts

@@ -0,0 +1,2 @@
+export declare function canonicalDeploymentJson(value: unknown): string;
+export declare function deploymentDigest(value: unknown): string;

package/dist/deployment/canonical.js

@@ -0,0 +1,17 @@
+import { createHash } from "node:crypto";
+function normalized(value) {
+  if (Array.isArray(value)) return value.map(normalized);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalized(entry)]));
+}
+function canonicalDeploymentJson(value) {
+  return `${JSON.stringify(normalized(value))}
+`;
+}
+function deploymentDigest(value) {
+  return `sha256:${createHash("sha256").update(canonicalDeploymentJson(value)).digest("hex")}`;
+}
+export {
+  canonicalDeploymentJson,
+  deploymentDigest
+};

package/dist/deployment/catalog.d.ts

@@ -0,0 +1,16 @@
+import { type ComponentRelease, type HostConfiguration, type ReleaseCatalog } from './schemas.js';
+export interface MixedTrackResolution {
+    components: ComponentRelease[];
+    warnings: string[];
+}
+export declare function resolveMixedTrackCatalog(input: {
+    host: HostConfiguration;
+    stable: ReleaseCatalog;
+    development?: ReleaseCatalog;
+}): MixedTrackResolution;
+export declare function collectHostAliases(components: readonly ComponentRelease[], overrides?: Record<string, string>): Map<string, {
+    componentId: string;
+    serviceId: string;
+    endpointId: string;
+    port: number;
+}>;

package/dist/deployment/catalog.js

@@ -0,0 +1,48 @@
+import { componentReleaseSchema, hostConfigurationSchema, releaseCatalogSchema } from "./schemas.js";
+function resolveMixedTrackCatalog(input) {
+  const host = hostConfigurationSchema.parse(input.host);
+  const stable = releaseCatalogSchema.parse(input.stable);
+  const development = input.development ? releaseCatalogSchema.parse(input.development) : void 0;
+  if (stable.track !== "stable" || stable.stableBase !== null) throw new Error("The base catalog must be stable and self-contained.");
+  if (development && (development.track !== "development" || development.stableBase?.catalogDigest !== stable.catalogDigest)) throw new Error("Development catalog is not bound to the selected stable catalog.");
+  const stableComponents = new Map(stable.components.map((component) => [component.componentId, component]));
+  const developmentComponents = new Map(development?.components.map((component) => [component.componentId, component]) ?? []);
+  const components = [];
+  const warnings = [];
+  for (const [componentId, selection] of Object.entries(host.components).sort(([left], [right]) => left.localeCompare(right))) {
+    if (!selection.enabled) continue;
+    const selected = selection.track === "development" ? developmentComponents.get(componentId) : stableComponents.get(componentId);
+    if (!selected) throw new Error(`No ${selection.track} release is available for enabled component ${componentId}.`);
+    componentReleaseSchema.parse(selected);
+    if (selected.track === "development" && selected.stableBase?.compatibilityId !== stable.compatibilityId) throw new Error(`Development component ${componentId} is incompatible with stable base ${stable.compatibilityId}.`);
+    components.push(selected);
+    if (selection.track === "development") warnings.push(`${componentId} follows the continuous development track.`);
+  }
+  return { components, warnings };
+}
+function collectHostAliases(components, overrides = {}) {
+  const endpoints = /* @__PURE__ */ new Map();
+  for (const component of components) for (const service of component.runtime.services) for (const endpoint of service.endpoints) {
+    if (endpoint.visibility === "host") endpoints.set(`${component.componentId}.${service.id}.${endpoint.id}`, endpoint);
+  }
+  for (const [key, alias] of Object.entries(overrides)) {
+    const endpoint = endpoints.get(key);
+    if (!endpoint) throw new Error(`Alias override ${key} does not identify an accepted host endpoint.`);
+    if (!endpoint.aliasOverride) throw new Error(`Host endpoint ${key} does not permit alias overrides.`);
+    if (!/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)*\.localhost$/u.test(alias)) throw new Error(`Alias override ${key} must use the .localhost namespace.`);
+  }
+  const aliases = /* @__PURE__ */ new Map();
+  for (const component of components) for (const service of component.runtime.services) for (const endpoint of service.endpoints) {
+    if (endpoint.visibility !== "host") continue;
+    const key = `${component.componentId}.${service.id}.${endpoint.id}`;
+    const alias = overrides[key] ?? endpoint.defaultAlias;
+    if (!alias?.endsWith(".localhost")) throw new Error(`Host endpoint ${key} requires a .localhost alias.`);
+    if (aliases.has(alias)) throw new Error(`Duplicate host alias ${alias}.`);
+    aliases.set(alias, { componentId: component.componentId, serviceId: service.id, endpointId: endpoint.id, port: endpoint.port });
+  }
+  return aliases;
+}
+export {
+  collectHostAliases,
+  resolveMixedTrackCatalog
+};