@moldesk/registry 0.0.5 → 0.0.6

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { MoldeskError } from "./errors.js";
 export type { MoldeskErrorData } from "./errors.js";
-export { allowedCommandTokens, commandSpecSchema, modelManifestV1Schema, } from "./schema.js";
-export type { AssetSpec, CommandSpec, HardwareRequirements, InputSpec, ModelCategory, ModelManifestV1, ModelStatus, OutputSpec, PlatformId, PostInstallHook, PythonRequirement, PythonRuntimeSpec, DockerRuntimeSpec, RequirementLevel, RuntimeKind, RuntimeSpec, SourceSpec, } from "./schema.js";
+export { allowedCommandTokens, commandSpecSchema, isCloudEligible, modelManifestV1Schema, } from "./schema.js";
+export type { AssetSpec, CloudSpec, CommandSpec, HardwareRequirements, InputSpec, ModelCategory, ModelManifestV1, ModelStatus, OutputSpec, PlatformId, PostInstallHook, PythonRequirement, PythonRuntimeSpec, DockerRuntimeSpec, RequirementLevel, RuntimeKind, RuntimeSpec, SourceSpec, } from "./schema.js";
 export type { LegacyModelManifest } from "./types.js";
 export { getModelsDir, listAvailableModels, loadManifestFile, parseManifest, } from "./loader.js";
 export { detectHostPlatformId, effectiveRuntimeSource, selectPythonRuntime, } from "./runtime-selection.js";

package/dist/index.js

@@ -1,4 +1,4 @@
 export { MoldeskError } from "./errors.js";
-export { allowedCommandTokens, commandSpecSchema, modelManifestV1Schema, } from "./schema.js";
+export { allowedCommandTokens, commandSpecSchema, isCloudEligible, modelManifestV1Schema, } from "./schema.js";
 export { getModelsDir, listAvailableModels, loadManifestFile, parseManifest, } from "./loader.js";
 export { detectHostPlatformId, effectiveRuntimeSource, selectPythonRuntime, } from "./runtime-selection.js";

package/dist/schema.d.ts

@@ -463,6 +463,64 @@ declare const assetSchema: z.ZodObject<{
     sizeBytes?: number | undefined;
     archive?: "none" | "tar.gz" | "tar" | "zip" | undefined;
 }>;
+/**
+ * Opt-in remote execution capability. Versioned independently of the manifest so the cloud contract
+ * can evolve without a manifest schema bump. Every value here must come from a live validation of
+ * that model on that image; a manifest without this block is never run in the cloud. Reuses the
+ * manifest's own `assets`, `runtimes` and `source`; it adds only what the cloud path cannot derive.
+ */
+declare const cloudSpecSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    platform: z.ZodLiteral<"linux-x64">;
+    images: z.ZodObject<{
+        /** Generic CUDA worker image used for inference. */
+        gpu: z.ZodString;
+        /** Generic CPU worker image used only to prepare assets on a network volume. */
+        cpu: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        cpu: string;
+        gpu: string;
+    }, {
+        cpu: string;
+        gpu: string;
+    }>;
+    minVramGb: z.ZodNumber;
+    minRamGb: z.ZodNumber;
+    /** Container disk for one ephemeral job: runtime environment, inputs and outputs (and assets when ephemeral). */
+    ephemeralDiskGb: z.ZodNumber;
+    /** Persistent network volume holding the raw object cache plus materialized assets. */
+    volumeGb: z.ZodNumber;
+    /** Bump when the on-volume asset layout changes; invalidates persistent caches. */
+    assetLayoutRevision: z.ZodString;
+    /** True when assets can be prepared on a CPU-only Pod without Python or CUDA. */
+    cpuAssetPreparation: z.ZodBoolean;
+}, "strict", z.ZodTypeAny, {
+    minVramGb: number;
+    minRamGb: number;
+    schemaVersion: 1;
+    platform: "linux-x64";
+    images: {
+        cpu: string;
+        gpu: string;
+    };
+    ephemeralDiskGb: number;
+    volumeGb: number;
+    assetLayoutRevision: string;
+    cpuAssetPreparation: boolean;
+}, {
+    minVramGb: number;
+    minRamGb: number;
+    schemaVersion: 1;
+    platform: "linux-x64";
+    images: {
+        cpu: string;
+        gpu: string;
+    };
+    ephemeralDiskGb: number;
+    volumeGb: number;
+    assetLayoutRevision: string;
+    cpuAssetPreparation: boolean;
+}>;
 declare const inputSpecSchema: z.ZodObject<{
     formats: z.ZodArray<z.ZodString, "many">;
     required: z.ZodBoolean;
@@ -786,6 +844,58 @@ export declare const modelManifestV1Schema: z.ZodEffects<z.ZodObject<{
         sizeBytes?: number | undefined;
         archive?: "none" | "tar.gz" | "tar" | "zip" | undefined;
     }>, "many">>;
+    cloud: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        platform: z.ZodLiteral<"linux-x64">;
+        images: z.ZodObject<{
+            /** Generic CUDA worker image used for inference. */
+            gpu: z.ZodString;
+            /** Generic CPU worker image used only to prepare assets on a network volume. */
+            cpu: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            cpu: string;
+            gpu: string;
+        }, {
+            cpu: string;
+            gpu: string;
+        }>;
+        minVramGb: z.ZodNumber;
+        minRamGb: z.ZodNumber;
+        /** Container disk for one ephemeral job: runtime environment, inputs and outputs (and assets when ephemeral). */
+        ephemeralDiskGb: z.ZodNumber;
+        /** Persistent network volume holding the raw object cache plus materialized assets. */
+        volumeGb: z.ZodNumber;
+        /** Bump when the on-volume asset layout changes; invalidates persistent caches. */
+        assetLayoutRevision: z.ZodString;
+        /** True when assets can be prepared on a CPU-only Pod without Python or CUDA. */
+        cpuAssetPreparation: z.ZodBoolean;
+    }, "strict", z.ZodTypeAny, {
+        minVramGb: number;
+        minRamGb: number;
+        schemaVersion: 1;
+        platform: "linux-x64";
+        images: {
+            cpu: string;
+            gpu: string;
+        };
+        ephemeralDiskGb: number;
+        volumeGb: number;
+        assetLayoutRevision: string;
+        cpuAssetPreparation: boolean;
+    }, {
+        minVramGb: number;
+        minRamGb: number;
+        schemaVersion: 1;
+        platform: "linux-x64";
+        images: {
+            cpu: string;
+            gpu: string;
+        };
+        ephemeralDiskGb: number;
+        volumeGb: number;
+        assetLayoutRevision: string;
+        cpuAssetPreparation: boolean;
+    }>>;
     input: z.ZodObject<{
         formats: z.ZodArray<z.ZodString, "many">;
         required: z.ZodBoolean;
@@ -914,6 +1024,20 @@ export declare const modelManifestV1Schema: z.ZodEffects<z.ZodObject<{
         sizeBytes?: number | undefined;
         archive?: "none" | "tar.gz" | "tar" | "zip" | undefined;
     }[] | undefined;
+    cloud?: {
+        minVramGb: number;
+        minRamGb: number;
+        schemaVersion: 1;
+        platform: "linux-x64";
+        images: {
+            cpu: string;
+            gpu: string;
+        };
+        ephemeralDiskGb: number;
+        volumeGb: number;
+        assetLayoutRevision: string;
+        cpuAssetPreparation: boolean;
+    } | undefined;
 }, {
     status: "available" | "beta" | "planned";
     name: string;
@@ -1011,6 +1135,20 @@ export declare const modelManifestV1Schema: z.ZodEffects<z.ZodObject<{
         sizeBytes?: number | undefined;
         archive?: "none" | "tar.gz" | "tar" | "zip" | undefined;
     }[] | undefined;
+    cloud?: {
+        minVramGb: number;
+        minRamGb: number;
+        schemaVersion: 1;
+        platform: "linux-x64";
+        images: {
+            cpu: string;
+            gpu: string;
+        };
+        ephemeralDiskGb: number;
+        volumeGb: number;
+        assetLayoutRevision: string;
+        cpuAssetPreparation: boolean;
+    } | undefined;
 }>, {
     status: "available" | "beta" | "planned";
     name: string;
@@ -1108,6 +1246,20 @@ export declare const modelManifestV1Schema: z.ZodEffects<z.ZodObject<{
         sizeBytes?: number | undefined;
         archive?: "none" | "tar.gz" | "tar" | "zip" | undefined;
     }[] | undefined;
+    cloud?: {
+        minVramGb: number;
+        minRamGb: number;
+        schemaVersion: 1;
+        platform: "linux-x64";
+        images: {
+            cpu: string;
+            gpu: string;
+        };
+        ephemeralDiskGb: number;
+        volumeGb: number;
+        assetLayoutRevision: string;
+        cpuAssetPreparation: boolean;
+    } | undefined;
 }, {
     status: "available" | "beta" | "planned";
     name: string;
@@ -1205,6 +1357,20 @@ export declare const modelManifestV1Schema: z.ZodEffects<z.ZodObject<{
         sizeBytes?: number | undefined;
         archive?: "none" | "tar.gz" | "tar" | "zip" | undefined;
     }[] | undefined;
+    cloud?: {
+        minVramGb: number;
+        minRamGb: number;
+        schemaVersion: 1;
+        platform: "linux-x64";
+        images: {
+            cpu: string;
+            gpu: string;
+        };
+        ephemeralDiskGb: number;
+        volumeGb: number;
+        assetLayoutRevision: string;
+        cpuAssetPreparation: boolean;
+    } | undefined;
 }>;
 export type ModelStatus = z.infer<typeof modelStatus>;
 export type RuntimeKind = z.infer<typeof runtimeKind>;
@@ -1218,9 +1384,14 @@ export type DockerRuntimeSpec = z.infer<typeof dockerRuntimeSchema>;
 export type RuntimeSpec = z.infer<typeof runtimeSpecSchema>;
 export type HardwareRequirements = z.infer<typeof hardwareSchema>;
 export type AssetSpec = z.infer<typeof assetSchema>;
+export type CloudSpec = z.infer<typeof cloudSpecSchema>;
 export type InputSpec = z.infer<typeof inputSpecSchema>;
 export type OutputSpec = z.infer<typeof outputSpecSchema>;
 export type SourceSpec = z.infer<typeof sourceSchema>;
 export type ModelManifestV1 = z.infer<typeof modelManifestV1Schema>;
 export type CommandSpec = z.infer<typeof commandSpecSchema>;
+/** A manifest is cloud-eligible only by declaring a `cloud` block; there is no implicit eligibility. */
+export declare function isCloudEligible(manifest: ModelManifestV1): manifest is ModelManifestV1 & {
+    cloud: CloudSpec;
+};
 export {};

package/dist/schema.js

@@ -183,6 +183,43 @@ const assetSchema = z
     archive: z.enum(["none", "tar.gz", "tar", "zip"]).optional(),
 })
     .strict();
+/** Registry/name reference pinned by digest (`ghcr.io/org/img@sha256:<64 hex>`); a bare tag is never accepted. */
+const digestPinnedImage = z
+    .string()
+    .regex(/^[a-z0-9]+(?:[._-][a-z0-9]+)*(?::\d+)?(?:\/[a-z0-9]+(?:[._-][a-z0-9]+)*)+@sha256:[0-9a-f]{64}$/, "must be a lowercase image reference pinned by digest, e.g. registry.example/org/image@sha256:<64 hex>");
+const cloudAssetLayoutRevision = z
+    .string()
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,31}$/, "must be a short safe token, e.g. \"1\"");
+/**
+ * Opt-in remote execution capability. Versioned independently of the manifest so the cloud contract
+ * can evolve without a manifest schema bump. Every value here must come from a live validation of
+ * that model on that image; a manifest without this block is never run in the cloud. Reuses the
+ * manifest's own `assets`, `runtimes` and `source`; it adds only what the cloud path cannot derive.
+ */
+const cloudSpecSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    platform: z.literal("linux-x64"),
+    images: z
+        .object({
+        /** Generic CUDA worker image used for inference. */
+        gpu: digestPinnedImage,
+        /** Generic CPU worker image used only to prepare assets on a network volume. */
+        cpu: digestPinnedImage,
+    })
+        .strict(),
+    minVramGb: z.number().positive(),
+    minRamGb: z.number().positive(),
+    /** Container disk for one ephemeral job: runtime environment, inputs and outputs (and assets when ephemeral). */
+    ephemeralDiskGb: z.number().int().positive(),
+    /** Persistent network volume holding the raw object cache plus materialized assets. */
+    volumeGb: z.number().int().positive(),
+    /** Bump when the on-volume asset layout changes; invalidates persistent caches. */
+    assetLayoutRevision: cloudAssetLayoutRevision,
+    /** True when assets can be prepared on a CPU-only Pod without Python or CUDA. */
+    cpuAssetPreparation: z.boolean(),
+})
+    .strict();
 const inputSpecSchema = z
     .object({
     formats: z.array(z.string().min(1)).min(1),
@@ -247,6 +284,7 @@ export const modelManifestV1Schema = z
     runtimes: z.array(runtimeSpecSchema).min(1),
     hardware: hardwareSchema,
     assets: z.array(assetSchema).optional(),
+    cloud: cloudSpecSchema.optional(),
     input: inputSpecSchema,
     outputs: z.array(outputSpecSchema).min(1),
 })
@@ -282,6 +320,39 @@ export const modelManifestV1Schema = z
             }
         }
     }
+    if (val.cloud) {
+        const cloud = val.cloud;
+        const remoteRuntimes = val.runtimes.filter((runtime) => runtime.kind === "python" && (runtime.platforms === undefined || runtime.platforms.includes(cloud.platform)));
+        if (remoteRuntimes.length === 0) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `cloud requires a python runtime entry that applies to ${cloud.platform}`,
+                path: ["cloud", "platform"],
+            });
+        }
+        for (const runtime of remoteRuntimes) {
+            if (runtime.minVramGb !== undefined && cloud.minVramGb < runtime.minVramGb) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `cloud.minVramGb (${cloud.minVramGb}) must be at least the ${cloud.platform} runtime's minVramGb (${runtime.minVramGb})`,
+                    path: ["cloud", "minVramGb"],
+                });
+            }
+        }
+        // Lower bound only: compressed asset bytes alone must fit. Extraction and runtime headroom
+        // come from live measurement, not from this check.
+        const assetBytes = (val.assets ?? []).reduce((total, asset) => total + (asset.sizeBytes ?? 0), 0);
+        const GIB = 1024 ** 3;
+        for (const field of ["ephemeralDiskGb", "volumeGb"]) {
+            if (cloud[field] * GIB < assetBytes) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `cloud.${field} (${cloud[field]} GB) is smaller than the manifest's declared asset bytes (${(assetBytes / GIB).toFixed(2)} GiB)`,
+                    path: ["cloud", field],
+                });
+            }
+        }
+    }
     const names = new Set();
     for (const out of val.outputs) {
         if (names.has(out.id)) {
@@ -335,3 +406,7 @@ export const modelManifestV1Schema = z
         }
     }
 });
+/** A manifest is cloud-eligible only by declaring a `cloud` block; there is no implicit eligibility. */
+export function isCloudEligible(manifest) {
+    return manifest.cloud !== undefined;
+}

package/dist/schema.test.js

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
 import { MoldeskError } from "./errors.js";
 import { parseManifest } from "./loader.js";
-import { commandSpecSchema } from "./schema.js";
+import { commandSpecSchema, isCloudEligible } from "./schema.js";
 function baseManifest() {
     return {
         schemaVersion: 1,
@@ -333,3 +333,60 @@ describe("parseManifest", () => {
         }
     });
 });
+describe("cloud capability block", () => {
+    const DIGEST = "a".repeat(64);
+    const cloud = () => ({
+        schemaVersion: 1,
+        platform: "linux-x64",
+        images: {
+            gpu: `registry.example/moldesk/worker-gpu@sha256:${DIGEST}`,
+            cpu: `registry.example/moldesk/worker-cpu@sha256:${DIGEST}`,
+        },
+        minVramGb: 24,
+        minRamGb: 32,
+        ephemeralDiskGb: 40,
+        volumeGb: 40,
+        assetLayoutRevision: "1",
+        cpuAssetPreparation: true,
+    });
+    const withCloud = (block, extra = {}) => ({ ...baseManifest(), ...extra, cloud: block });
+    it("accepts a complete block and marks the model eligible; absence means ineligible", () => {
+        const eligible = parseManifest(withCloud(cloud()), "x/manifest.yaml");
+        expect(isCloudEligible(eligible)).toBe(true);
+        expect(eligible.cloud?.images.gpu).toContain("@sha256:");
+        expect(isCloudEligible(parseManifest(baseManifest(), "x/manifest.yaml"))).toBe(false);
+    });
+    it("rejects tag-only or malformed image references", () => {
+        for (const gpu of ["registry.example/moldesk/worker:latest", "worker@sha256:" + DIGEST, `Registry.Example/x@sha256:${DIGEST}`, `registry.example/x@sha256:${"a".repeat(63)}`]) {
+            expect(() => parseManifest(withCloud({ ...cloud(), images: { ...cloud().images, gpu } }), "x/manifest.yaml")).toThrow(/pinned by digest/);
+        }
+    });
+    it("is strict: unknown keys, other platforms and missing fields are rejected", () => {
+        expect(() => parseManifest(withCloud({ ...cloud(), command: "rm -rf /" }), "x/manifest.yaml")).toThrow();
+        expect(() => parseManifest(withCloud({ ...cloud(), platform: "darwin-arm64" }), "x/manifest.yaml")).toThrow();
+        const { volumeGb: _omit, ...missing } = cloud();
+        expect(() => parseManifest(withCloud(missing), "x/manifest.yaml")).toThrow();
+        expect(() => parseManifest(withCloud({ ...cloud(), minVramGb: 0 }), "x/manifest.yaml")).toThrow();
+        expect(() => parseManifest(withCloud({ ...cloud(), schemaVersion: 2 }), "x/manifest.yaml")).toThrow();
+    });
+    it("requires a python runtime entry that applies to linux-x64", () => {
+        const darwinOnly = {
+            runtimes: [{ kind: "python", python: "3.11", installer: "uv", platforms: ["darwin-arm64"], requirements: [{ name: "torch" }] }],
+        };
+        expect(() => parseManifest(withCloud(cloud(), darwinOnly), "x/manifest.yaml")).toThrow(/python runtime entry that applies to linux-x64/);
+    });
+    it("requires cloud.minVramGb to cover the linux runtime's own floor", () => {
+        const runtimes = [
+            { kind: "python", python: "3.11", installer: "uv", platforms: ["linux-x64"], nvidiaGpu: "required", minVramGb: 40, requirements: [{ name: "torch" }] },
+        ];
+        expect(() => parseManifest(withCloud(cloud(), { runtimes }), "x/manifest.yaml")).toThrow(/cloud\.minVramGb \(24\)/);
+        expect(parseManifest(withCloud({ ...cloud(), minVramGb: 40 }, { runtimes }), "x/manifest.yaml").cloud?.minVramGb).toBe(40);
+    });
+    it("rejects disk or volume sizes smaller than the declared asset bytes", () => {
+        const GIB = 1024 ** 3;
+        const assets = [{ id: "w", url: "https://example.com/w.bin", sha256: "b".repeat(64), target: "w.bin", sizeBytes: 50 * GIB }];
+        expect(() => parseManifest(withCloud({ ...cloud(), volumeGb: 60 }, { assets }), "x/manifest.yaml")).toThrow(/cloud\.ephemeralDiskGb \(40 GB\)/);
+        expect(() => parseManifest(withCloud({ ...cloud(), ephemeralDiskGb: 60 }, { assets }), "x/manifest.yaml")).toThrow(/cloud\.volumeGb \(40 GB\)/);
+        expect(parseManifest(withCloud({ ...cloud(), ephemeralDiskGb: 60, volumeGb: 60 }, { assets }), "x/manifest.yaml").cloud?.volumeGb).toBe(60);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moldesk/registry",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Model manifest loading and resolution for MoleculeDesk",
   "license": "MIT",
   "type": "module",