@moldesk/registry 0.0.1 → 0.0.2

package/dist/schema.js

@@ -0,0 +1,337 @@
+import { z } from "zod";
+const kebabCase = z
+    .string()
+    .min(1)
+    .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "must be lowercase kebab-case");
+const sha256Hex = z
+    .string()
+    .regex(/^[0-9a-fA-F]{64}$/, "must be a 64-char hex SHA-256");
+const dockerDigest = z
+    .string()
+    .regex(/^sha256:[0-9a-fA-F]{64}$/, "must be `sha256:<64 hex>`");
+const httpsUrl = z.string().url("must be a valid URL").refine((v) => v.startsWith("https://"), "must use https protocol");
+const safeVersionSegment = z
+    .string()
+    .min(1)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._+-]*$/, "must be a safe single path segment");
+const semver = z
+    .string()
+    .regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/, "must be a semantic version");
+function isSafeRelativeTarget(target) {
+    if (!target || target.length === 0)
+        return false;
+    if (target.includes("\\"))
+        return false;
+    if (target.startsWith("/") || /^[A-Za-z]:/.test(target))
+        return false;
+    const parts = target.split("/");
+    for (const part of parts) {
+        if (part === "" || part === "." || part === "..")
+            return false;
+    }
+    return true;
+}
+function isSafeRelativeGlob(glob) {
+    if (!glob || glob.includes("\\") || glob.startsWith("/") || /^[A-Za-z]:/.test(glob))
+        return false;
+    return glob.split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}
+const safeTarget = z
+    .string()
+    .min(1)
+    .refine(isSafeRelativeTarget, "must be a safe path relative to the model assets directory (no absolute paths, .., or backslashes)");
+const modelStatus = z.enum(["available", "beta", "planned"]);
+const runtimeKind = z.enum(["python", "docker"]);
+const requirementLevel = z.enum(["required", "recommended", "unsupported"]);
+const category = z.enum(["sequence-design", "structure-prediction", "docking", "other"]);
+const platformId = z.enum(["darwin-arm64", "linux-x64"]);
+/** Closed enum of named, non-shell post-install fixups. Never a free-form command
+ * string — this keeps the manifest from becoming a generic shell escape hatch. */
+const postInstallHookSchema = z.enum(["boltz-fix-macos-libomp"]);
+const cudaSchema = z
+    .object({
+    level: requirementLevel,
+    // Minimum driver-supported CUDA version, e.g. "12.1" — compared against the
+    // driver's max-supported CUDA (not the local CUDA toolkit) as a major.minor
+    // floor, not a semver range.
+    minDriverCudaVersion: z
+        .string()
+        .regex(/^\d+\.\d+$/, "must be a major.minor CUDA version, e.g. \"12.1\"")
+        .optional(),
+})
+    .strict();
+const sourceSchema = z
+    .object({
+    repository: httpsUrl,
+    revision: z
+        .string()
+        .regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i, "must be a full immutable commit digest"),
+})
+    .strict();
+const pythonRequirementSchema = z
+    .object({
+    name: z.string().min(1),
+    version: z.string().min(1).optional(),
+    source: z.string().min(1).optional(),
+    revision: z.string().min(1).optional(),
+    // Optional PEP 508 extras, e.g. ["cuda"] for `boltz[cuda]`. Valid with either a
+    // PyPI version pin or a git source+revision pin (pip/uv both support
+    // `name[extra] @ git+url@rev`).
+    extras: z.array(z.string().min(1)).min(1).optional(),
+    // sha256 hex digests of the expected wheel/sdist artifact(s), enforced natively
+    // by uv/pip's hash-checking install mode when present.
+    hashes: z.array(sha256Hex).min(1).optional(),
+})
+    .strict();
+const pythonRuntimeSchema = z
+    .object({
+    kind: z.literal("python"),
+    python: z.string().min(1),
+    installer: z.literal("uv"),
+    estimatedDownloadBytes: z.number().int().nonnegative().optional(),
+    estimatedDiskBytes: z.number().int().nonnegative().optional(),
+    requirements: z.array(pythonRequirementSchema).min(1),
+    // When present, this runtime entry only applies to hosts matching one of these
+    // platforms; absent means it applies unconditionally (legacy single-runtime
+    // manifests, e.g. ProteinMPNN/LigandMPNN, always match this way).
+    platforms: z.array(platformId).min(1).optional(),
+    // Per-entry source override, falling back to the manifest-level `source` when
+    // absent — needed when different platforms build from genuinely different repos.
+    source: sourceSchema.optional(),
+    postInstall: z.array(postInstallHookSchema).min(1).optional(),
+    // Per-platform-runtime-entry accelerator requirements, same shape as the
+    // manifest-level `hardware.nvidiaGpu`/`hardware.cuda`/`hardware.minVramGb`, so a
+    // single manifest can declare CUDA on one platform and MPS (no CUDA) on another.
+    nvidiaGpu: requirementLevel.optional(),
+    cuda: cudaSchema.optional(),
+    minVramGb: z.number().positive().optional(),
+    // Additional PEP-503-style pip/uv package indexes, ADDED alongside the default
+    // PyPI index (never replacing it — a manifest never loses access to ordinary
+    // packages like pandas/scipy just because it needs a CUDA-specific extra
+    // index). Maps to `UV_EXTRA_INDEX_URL`. For a pinned build whose exact wheels
+    // (e.g. a CUDA-specific PyTorch build) live on a PEP-503-compatible extra
+    // index rather than default PyPI.
+    extraIndexUrls: z.array(httpsUrl).min(1).max(4).optional(),
+    // Flat `--find-links` wheel-listing pages (not PEP-503 indexes — a single page
+    // listing wheel files directly, e.g. PyTorch Geometric's CUDA extension wheel
+    // pages). Maps to `UV_FIND_LINKS`. Kept structurally distinct from
+    // `extraIndexUrls` because the two have different pip/uv semantics and mixing
+    // them up silently breaks resolution (this is exactly what an earlier version
+    // of this schema got wrong for DiffDock-L).
+    findLinks: z.array(httpsUrl).min(1).max(4).optional(),
+    // Package names (matching a `requirements[].name`) that must resolve to a
+    // prebuilt wheel and must never be built from source, mapped to `--only-binary
+    // <name>` on every install invocation. Exists so an ABI-sensitive CUDA
+    // extension package (torch-scatter, torch-sparse, …) can never silently fall
+    // back to a from-source sdist build if wheel resolution ever fails for some
+    // reason — install fails closed instead.
+    binaryOnly: z.array(z.string().min(1)).min(1).optional(),
+    // Requirements installed first, each in its own `uv pip install` invocation, in
+    // array order, before anything in `requirements` — for a package (e.g. a pinned
+    // `setuptools` version) that a later requirement's own source build depends on
+    // being fully resolved beforehand, not just present somewhere in the same
+    // resolver graph.
+    preInstall: z.array(pythonRequirementSchema).min(1).optional(),
+    // Names (matching `requirements[].name`) deferred to their own final install
+    // invocation, strictly after every other requirement (including `preInstall`)
+    // has finished installing — for a package whose own build process imports an
+    // earlier dependency (e.g. an unpackaged git build that imports `torch` at
+    // setup time to select CUDA architecture flags), which a single combined
+    // resolver invocation cannot reliably sequence.
+    buildAfter: z.array(z.string().min(1)).min(1).optional(),
+    // PyTorch build selection for uv's native `--torch-backend` (mapped to
+    // `UV_TORCH_BACKEND`), which routes torch-ecosystem packages to the matching
+    // official PyTorch index. A closed enum, never a free-form index URL or pip
+    // argument fragment — extend it only alongside a manifest that actually pins
+    // and verifies that backend's wheels.
+    torchBackend: z.enum(["cpu", "cu126"]).optional(),
+})
+    .strict();
+const dockerRuntimeSchema = z
+    .object({
+    kind: z.literal("docker"),
+    image: z.string().min(1),
+    digest: dockerDigest,
+    gpu: z.enum(["none", "optional", "required"]),
+    estimatedDownloadBytes: z.number().int().nonnegative().optional(),
+    estimatedDiskBytes: z.number().int().nonnegative().optional(),
+})
+    .strict();
+const runtimeSpecSchema = z.discriminatedUnion("kind", [
+    pythonRuntimeSchema,
+    dockerRuntimeSchema,
+]);
+const hardwareSchema = z
+    .object({
+    platforms: z.array(platformId).min(1).optional(),
+    minRamGb: z.number().positive().optional(),
+    minDiskGb: z.number().positive().optional(),
+    nvidiaGpu: requirementLevel.optional(),
+    minVramGb: z.number().positive().optional(),
+    cuda: cudaSchema.optional(),
+})
+    .strict();
+const assetSchema = z
+    .object({
+    id: z.string().min(1),
+    url: httpsUrl,
+    source: z.string().min(1).optional(),
+    license: z.string().min(1).optional(),
+    sha256: sha256Hex,
+    target: safeTarget,
+    sizeBytes: z.number().int().nonnegative().optional(),
+    archive: z.enum(["none", "tar.gz", "tar", "zip"]).optional(),
+})
+    .strict();
+const inputSpecSchema = z
+    .object({
+    formats: z.array(z.string().min(1)).min(1),
+    required: z.boolean(),
+})
+    .strict();
+const outputSpecSchema = z
+    .object({
+    id: z.string().min(1),
+    glob: z.string().min(1),
+    required: z.boolean(),
+})
+    .strict()
+    .refine((v) => isSafeRelativeGlob(v.glob), {
+    message: "must be a safe path relative to the staged output directory",
+    path: ["glob"],
+});
+const adapterVerificationSchema = z
+    .object({
+    lastVerifiedAt: z.string().datetime({ offset: true }),
+    platforms: z.array(z.string().min(1)).min(1),
+    notes: z.string().optional(),
+})
+    .strict();
+export const allowedCommandTokens = ["{{input}}", "{{outputDir}}", "{{modelDir}}", "{{assetsDir}}"];
+const allowedCommandTokenSet = new Set(allowedCommandTokens);
+function hasOnlyAllowedCommandTokens(value) {
+    let remainder = value;
+    for (const token of allowedCommandTokenSet)
+        remainder = remainder.split(token).join("");
+    return !remainder.includes("{{") && !remainder.includes("}}");
+}
+const commandValue = z
+    .string()
+    .refine((v) => !v.includes("\0"), "must not contain a NUL byte")
+    .refine(hasOnlyAllowedCommandTokens, "contains an unsupported command template token");
+export const commandSpecSchema = z
+    .object({
+    executable: z
+        .string()
+        .min(1)
+        .refine((v) => !v.includes("\0"), "must not contain a NUL byte")
+        .refine((v) => !v.includes("{{"), "executable must not contain template tokens"),
+    args: z.array(commandValue),
+    env: z.record(z.string().min(1), commandValue).optional(),
+})
+    .strict();
+export const modelManifestV1Schema = z
+    .object({
+    schemaVersion: z.literal(1),
+    name: kebabCase,
+    displayName: z.string().min(1),
+    modelVersion: safeVersionSegment,
+    adapterVersion: semver,
+    description: z.string().min(1),
+    category,
+    status: modelStatus,
+    license: z.string().min(1).optional(),
+    homepage: httpsUrl.optional(),
+    source: sourceSchema.optional(),
+    adapterVerification: adapterVerificationSchema.optional(),
+    runtimes: z.array(runtimeSpecSchema).min(1),
+    hardware: hardwareSchema,
+    assets: z.array(assetSchema).optional(),
+    input: inputSpecSchema,
+    outputs: z.array(outputSpecSchema).min(1),
+})
+    .strict()
+    .superRefine((val, ctx) => {
+    if (val.hardware.minVramGb !== undefined && val.hardware.nvidiaGpu === undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "hardware.nvidiaGpu must be set (\"required\" or \"recommended\") whenever minVramGb is specified",
+            path: ["hardware", "nvidiaGpu"],
+        });
+    }
+    for (const [runtimeIndex, runtime] of val.runtimes.entries()) {
+        if (runtime.kind !== "python")
+            continue;
+        if (runtime.minVramGb !== undefined && runtime.nvidiaGpu === undefined) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "nvidiaGpu must be set (\"required\" or \"recommended\") whenever this runtime entry's minVramGb is specified",
+                path: ["runtimes", runtimeIndex, "nvidiaGpu"],
+            });
+        }
+        if (runtime.buildAfter) {
+            const requirementNames = new Set(runtime.requirements.map((r) => r.name));
+            for (const deferredName of runtime.buildAfter) {
+                if (!requirementNames.has(deferredName)) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `buildAfter references "${deferredName}", which is not in this runtime entry's requirements`,
+                        path: ["runtimes", runtimeIndex, "buildAfter"],
+                    });
+                }
+            }
+        }
+    }
+    const names = new Set();
+    for (const out of val.outputs) {
+        if (names.has(out.id)) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate output id "${out.id}"`, path: ["outputs"] });
+        }
+        names.add(out.id);
+    }
+    if (val.assets) {
+        const assetIds = new Set();
+        const targets = new Set();
+        for (const a of val.assets) {
+            if (assetIds.has(a.id)) {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate asset id "${a.id}"`, path: ["assets"] });
+            }
+            assetIds.add(a.id);
+            if (targets.has(a.target)) {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate asset target "${a.target}"`, path: ["assets"] });
+            }
+            targets.add(a.target);
+        }
+    }
+    if (val.status === "available") {
+        if (!val.source) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "available models require source provenance",
+                path: ["source"],
+            });
+        }
+        if (!val.adapterVerification) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "available models require adapter verification metadata",
+                path: ["adapterVerification"],
+            });
+        }
+        for (const [runtimeIndex, runtime] of val.runtimes.entries()) {
+            if (runtime.kind !== "python")
+                continue;
+            for (const [requirementIndex, requirement] of runtime.requirements.entries()) {
+                const pinnedPackage = requirement.version !== undefined;
+                const pinnedSource = requirement.source !== undefined && requirement.revision !== undefined;
+                if (!pinnedPackage && !pinnedSource) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: "available models require every Python dependency to be pinned by version or source revision",
+                        path: ["runtimes", runtimeIndex, "requirements", requirementIndex],
+                    });
+                }
+            }
+        }
+    }
+});

package/dist/schema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schema.test.js

@@ -0,0 +1,335 @@
+import { describe, expect, it } from "vitest";
+import { MoldeskError } from "./errors.js";
+import { parseManifest } from "./loader.js";
+import { commandSpecSchema } from "./schema.js";
+function baseManifest() {
+    return {
+        schemaVersion: 1,
+        name: "test-model",
+        displayName: "Test Model",
+        modelVersion: "1.0.0",
+        adapterVersion: "0.1.0",
+        description: "A test model",
+        category: "other",
+        status: "planned",
+        runtimes: [
+            { kind: "python", python: "3.11", installer: "uv", requirements: [{ name: "torch" }] },
+        ],
+        hardware: { platforms: ["darwin-arm64"] },
+        input: { formats: [".pdb"], required: true },
+        outputs: [{ id: "out", glob: "*.fa", required: true }],
+    };
+}
+describe("parseManifest", () => {
+    it("accepts a minimal valid v1 manifest", () => {
+        const m = parseManifest(baseManifest(), "test/manifest.yaml");
+        expect(m.name).toBe("test-model");
+        expect(m.modelVersion).toBe("1.0.0");
+    });
+    it("rejects unknown schema versions with a typed error", () => {
+        try {
+            parseManifest({ ...baseManifest(), schemaVersion: 99 }, "test/manifest.yaml");
+            expect.unreachable();
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(MoldeskError);
+            const e = error;
+            expect(e.code).toBe("UNKNOWN_SCHEMA_VERSION");
+            expect(e.message).toContain("test/manifest.yaml");
+            expect(e.remediation).toMatch(/schemaVersion/i);
+        }
+    });
+    it("rejects legacy top-level version without modelVersion", () => {
+        const raw = baseManifest();
+        delete raw["modelVersion"];
+        raw["version"] = "1.0.0";
+        try {
+            parseManifest(raw, "models/x/manifest.yaml");
+            expect.unreachable();
+        }
+        catch (error) {
+            const e = error;
+            expect(e.code).toBe("INVALID_MANIFEST");
+            expect(e.message).toContain("modelVersion");
+            expect(e.details?.["field"]).toBe("version");
+        }
+    });
+    it.each(["modelVersion", "adapterVersion"])("rejects missing %s", (field) => {
+        const raw = baseManifest();
+        delete raw[field];
+        expect(() => parseManifest(raw, "m.yaml")).toThrowError(MoldeskError);
+    });
+    it("rejects unsafe model versions and invalid adapter semver", () => {
+        expect(() => parseManifest({ ...baseManifest(), modelVersion: "../../escape" }, "m.yaml")).toThrowError(MoldeskError);
+        expect(() => parseManifest({ ...baseManifest(), adapterVersion: "latest" }, "m.yaml")).toThrowError(MoldeskError);
+    });
+    it("rejects unsafe asset target paths", () => {
+        for (const target of ["../evil.bin", "/abs/path.bin", "a\\b.bin", "a/./b.bin"]) {
+            const raw = baseManifest();
+            raw["assets"] = [
+                { id: "w", url: "https://example.com/w.bin", sha256: "a".repeat(64), target },
+            ];
+            try {
+                parseManifest(raw, "m.yaml");
+                expect.unreachable(`target ${target} should fail`);
+            }
+            catch (error) {
+                expect(error.code).toBe("INVALID_MANIFEST");
+            }
+        }
+    });
+    it("rejects duplicate model-relevant ids conservatively", () => {
+        const raw = baseManifest();
+        raw["outputs"] = [
+            { id: "dup", glob: "*.a", required: true },
+            { id: "dup", glob: "*.b", required: false },
+        ];
+        expect(() => parseManifest(raw, "m.yaml")).toThrowError(MoldeskError);
+    });
+    it("rejects unknown keys in high-risk runtime sections", () => {
+        const raw = baseManifest();
+        raw["runtimes"] = [
+            { kind: "python", python: "3.11", installer: "uv", requirements: [{ name: "torch" }], installScript: "curl | sh" },
+        ];
+        try {
+            parseManifest(raw, "m.yaml");
+            expect.unreachable();
+        }
+        catch (error) {
+            const e = error;
+            expect(e.code).toBe("INVALID_MANIFEST");
+            expect(e.message).toContain("m.yaml");
+        }
+    });
+    it("accepts only known command tokens without applying shell restrictions", () => {
+        const valid = {
+            executable: "/Applications/MoleculeDesk (Preview)/python#1",
+            args: ["--input={{input}}", "{{outputDir}}"],
+            env: { MODEL_DIR: "{{modelDir}}" },
+        };
+        expect(commandSpecSchema.parse(valid)).toEqual(valid);
+        expect(() => commandSpecSchema.parse({ executable: "tool", args: ["{{unknown}}"] })).toThrow();
+        expect(() => commandSpecSchema.parse({ executable: "tool", args: ["{{input"] })).toThrow();
+        expect(() => commandSpecSchema.parse({ executable: "{{modelDir}}/tool", args: [] })).toThrow();
+    });
+    it("validates output globs by path segment", () => {
+        expect(() => parseManifest({ ...baseManifest(), outputs: [{ id: "out", glob: "foo..bar/*.cif", required: true }] }, "m.yaml")).not.toThrow();
+        for (const glob of ["../*.cif", "/tmp/*.cif", "dir\\*.cif", "dir//*.cif"]) {
+            expect(() => parseManifest({ ...baseManifest(), outputs: [{ id: "out", glob, required: true }] }, "m.yaml")).toThrowError(MoldeskError);
+        }
+    });
+    it("requires provenance, verification, and pinned dependencies for available models", () => {
+        expect(() => parseManifest({ ...baseManifest(), status: "available" }, "m.yaml")).toThrowError(MoldeskError);
+        const available = baseManifest();
+        available["status"] = "available";
+        available["source"] = {
+            repository: "https://example.com/model.git",
+            revision: "a".repeat(40),
+        };
+        available["adapterVerification"] = {
+            lastVerifiedAt: "2026-09-07T00:00:00Z",
+            platforms: ["darwin-arm64"],
+        };
+        available["runtimes"] = [
+            { kind: "python", python: "3.11", installer: "uv", requirements: [{ name: "torch", version: "2.2.1" }] },
+        ];
+        expect(() => parseManifest(available, "m.yaml")).not.toThrow();
+    });
+    it("requires nvidiaGpu whenever minVramGb is set", () => {
+        const raw = baseManifest();
+        raw["hardware"] = { platforms: ["darwin-arm64"], minVramGb: 16 };
+        expect(() => parseManifest(raw, "m.yaml")).toThrowError(MoldeskError);
+        raw["hardware"] = { platforms: ["darwin-arm64"], minVramGb: 16, nvidiaGpu: "recommended" };
+        expect(() => parseManifest(raw, "m.yaml")).not.toThrow();
+    });
+    it("validates cuda.minDriverCudaVersion as major.minor", () => {
+        const raw = baseManifest();
+        raw["hardware"] = {
+            platforms: ["darwin-arm64"],
+            nvidiaGpu: "required",
+            cuda: { level: "required", minDriverCudaVersion: "12.1" },
+        };
+        expect(() => parseManifest(raw, "m.yaml")).not.toThrow();
+        raw["hardware"] = {
+            platforms: ["darwin-arm64"],
+            nvidiaGpu: "required",
+            cuda: { level: "required", minDriverCudaVersion: "12.1.0" },
+        };
+        expect(() => parseManifest(raw, "m.yaml")).toThrowError(MoldeskError);
+    });
+    it("accepts per-platform python runtime fields: platforms, source override, postInstall, accelerator, hashes", () => {
+        const raw = baseManifest();
+        raw["runtimes"] = [
+            {
+                kind: "python",
+                python: "3.11",
+                installer: "uv",
+                platforms: ["darwin-arm64"],
+                source: { repository: "https://github.com/example/darwin-fork", revision: "a".repeat(40) },
+                postInstall: ["boltz-fix-macos-libomp"],
+                nvidiaGpu: "unsupported",
+                requirements: [{ name: "torch", version: "2.6.0", hashes: ["b".repeat(64)] }],
+            },
+            {
+                kind: "python",
+                python: "3.11",
+                installer: "uv",
+                platforms: ["linux-x64"],
+                source: { repository: "https://github.com/example/official", revision: "c".repeat(40) },
+                nvidiaGpu: "required",
+                cuda: { level: "required", minDriverCudaVersion: "12.1" },
+                minVramGb: 16,
+                requirements: [{ name: "torch", version: "2.2.1" }],
+            },
+        ];
+        expect(() => parseManifest(raw, "m.yaml")).not.toThrow();
+        const parsed = parseManifest(raw, "m.yaml");
+        expect(parsed.runtimes).toHaveLength(2);
+    });
+    it("rejects an unlisted postInstall value", () => {
+        const raw = baseManifest();
+        raw["runtimes"] = [
+            {
+                kind: "python",
+                python: "3.11",
+                installer: "uv",
+                postInstall: ["curl-pipe-sh"],
+                requirements: [{ name: "torch" }],
+            },
+        ];
+        expect(() => parseManifest(raw, "m.yaml")).toThrowError(MoldeskError);
+    });
+    it("still rejects unknown keys on a python runtime entry (.strict())", () => {
+        const raw = baseManifest();
+        raw["runtimes"] = [
+            {
+                kind: "python",
+                python: "3.11",
+                installer: "uv",
+                requirements: [{ name: "torch" }],
+                platforms: ["darwin-arm64"],
+                extraField: "not allowed",
+            },
+        ];
+        expect(() => parseManifest(raw, "m.yaml")).toThrowError(MoldeskError);
+    });
+    it("accepts a python runtime entry's extraIndexUrls and findLinks (kept structurally distinct)", () => {
+        const raw = baseManifest();
+        raw["runtimes"] = [
+            {
+                kind: "python",
+                python: "3.10",
+                installer: "uv",
+                extraIndexUrls: ["https://download.pytorch.org/whl/cu117"],
+                findLinks: ["https://data.pyg.org/whl/torch-1.13.1+cu117.html"],
+                binaryOnly: ["torch", "torch-scatter"],
+                requirements: [{ name: "torch", version: "1.13.1+cu117", hashes: ["b".repeat(64)] }],
+            },
+        ];
+        const parsed = parseManifest(raw, "m.yaml");
+        expect(parsed.runtimes[0]).toMatchObject({
+            extraIndexUrls: ["https://download.pytorch.org/whl/cu117"],
+            findLinks: ["https://data.pyg.org/whl/torch-1.13.1+cu117.html"],
+            binaryOnly: ["torch", "torch-scatter"],
+        });
+    });
+    it("rejects a non-https extraIndexUrls/findLinks URL", () => {
+        const raw = baseManifest();
+        raw["runtimes"] = [
+            { kind: "python", python: "3.11", installer: "uv", extraIndexUrls: ["http://insecure.example/whl"], requirements: [{ name: "torch" }] },
+        ];
+        expect(() => parseManifest(raw, "m.yaml")).toThrowError(MoldeskError);
+        const raw2 = baseManifest();
+        raw2["runtimes"] = [
+            { kind: "python", python: "3.11", installer: "uv", findLinks: ["http://insecure.example/whl"], requirements: [{ name: "torch" }] },
+        ];
+        expect(() => parseManifest(raw2, "m.yaml")).toThrowError(MoldeskError);
+    });
+    it("accepts a known torchBackend and rejects anything outside the closed enum", () => {
+        const raw = baseManifest();
+        raw["runtimes"] = [
+            { kind: "python", python: "3.11", installer: "uv", torchBackend: "cu126", requirements: [{ name: "torch", version: "2.7.1+cu126" }] },
+        ];
+        expect(parseManifest(raw, "m.yaml").runtimes[0]).toMatchObject({ torchBackend: "cu126" });
+        for (const bad of ["auto", "cu999", "--index-url https://evil.example", "https://download.pytorch.org/whl/cu126", ""]) {
+            const rawBad = baseManifest();
+            rawBad["runtimes"] = [
+                { kind: "python", python: "3.11", installer: "uv", torchBackend: bad, requirements: [{ name: "torch" }] },
+            ];
+            expect(() => parseManifest(rawBad, "m.yaml")).toThrowError(MoldeskError);
+        }
+    });
+    it("rejects an empty extraIndexUrls array", () => {
+        const raw = baseManifest();
+        raw["runtimes"] = [
+            { kind: "python", python: "3.11", installer: "uv", extraIndexUrls: [], requirements: [{ name: "torch" }] },
+        ];
+        expect(() => parseManifest(raw, "m.yaml")).toThrowError(MoldeskError);
+    });
+    it("accepts preInstall requirements and a buildAfter list referencing a real requirement", () => {
+        const raw = baseManifest();
+        raw["runtimes"] = [
+            {
+                kind: "python",
+                python: "3.10",
+                installer: "uv",
+                preInstall: [{ name: "setuptools", version: "69.5.1" }],
+                buildAfter: ["openfold"],
+                requirements: [
+                    { name: "torch", version: "1.13.1+cu117" },
+                    { name: "openfold", source: "https://github.com/aqlaboratory/openfold", revision: "a".repeat(40) },
+                ],
+            },
+        ];
+        const parsed = parseManifest(raw, "m.yaml");
+        expect(parsed.runtimes[0]).toMatchObject({ buildAfter: ["openfold"] });
+    });
+    it("rejects a buildAfter entry that does not match any requirement name", () => {
+        const raw = baseManifest();
+        raw["runtimes"] = [
+            {
+                kind: "python",
+                python: "3.10",
+                installer: "uv",
+                buildAfter: ["not-a-real-requirement"],
+                requirements: [{ name: "torch", version: "1.13.1+cu117" }],
+            },
+        ];
+        expect(() => parseManifest(raw, "m.yaml")).toThrowError(MoldeskError);
+    });
+    it("rejects a python requirement with an invalid hash shape", () => {
+        const raw = baseManifest();
+        raw["runtimes"] = [
+            { kind: "python", python: "3.11", installer: "uv", requirements: [{ name: "torch", hashes: ["not-a-hash"] }] },
+        ];
+        expect(() => parseManifest(raw, "m.yaml")).toThrowError(MoldeskError);
+    });
+    it("requires nvidiaGpu on a runtime entry whenever that entry sets minVramGb", () => {
+        const raw = baseManifest();
+        raw["runtimes"] = [
+            { kind: "python", python: "3.11", installer: "uv", minVramGb: 16, requirements: [{ name: "torch" }] },
+        ];
+        expect(() => parseManifest(raw, "m.yaml")).toThrowError(MoldeskError);
+        raw["runtimes"] = [
+            { kind: "python", python: "3.11", installer: "uv", minVramGb: 16, nvidiaGpu: "required", requirements: [{ name: "torch" }] },
+        ];
+        expect(() => parseManifest(raw, "m.yaml")).not.toThrow();
+    });
+    it("existing single-runtime manifests with no platforms field still validate unmodified", () => {
+        const m = parseManifest(baseManifest(), "test/manifest.yaml");
+        expect(m.runtimes).toHaveLength(1);
+        expect(m.runtimes[0].platforms).toBeUndefined();
+    });
+    it("corrupt fixtures name manifest, field, and remediation", () => {
+        try {
+            parseManifest({ schemaVersion: 1, name: "Bad Name!" }, "models/bad/manifest.yaml");
+            expect.unreachable();
+        }
+        catch (error) {
+            const e = error;
+            expect(e.message).toContain("models/bad/manifest.yaml");
+            expect(e.remediation).toBeTruthy();
+            expect(e.details?.["manifestPath"]).toBe("models/bad/manifest.yaml");
+        }
+    });
+});