@moldesk/core 0.0.4 → 0.0.6

package/dist/run-lifecycle.js

@@ -0,0 +1,178 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { validateParams } from "@moldesk/adapters";
+import { getSystemReport, runDir, stageCompanionInputs, } from "@moldesk/runtime";
+import { MoldeskError } from "./errors.js";
+import { digest, sha256File } from "./hash.js";
+import { generateRunReport } from "./run-report.js";
+import { VERSION } from "./version.js";
+export function toErrorInfo(error, fallbackCode) {
+    if (error instanceof MoldeskError)
+        return { code: error.code, message: error.message };
+    return { code: fallbackCode, message: error instanceof Error ? error.message : String(error) };
+}
+export function writeRunRecord(runDirPath, record) {
+    const file = path.join(runDirPath, "run.json");
+    const temporary = `${file}.tmp-${process.pid}-${randomUUID()}`;
+    fs.writeFileSync(temporary, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temporary, file);
+}
+/**
+ * Step 3 shared by local and cloud runs: applies platform-dependent adapter defaults (an explicit
+ * `--param` always wins), then validates. Rejects with INVALID_RUN_PARAMS before any run directory exists.
+ */
+export function prepareRunParams(adapter, manifestName, installed, params) {
+    // Platform-dependent defaults (e.g. Boltz's `accelerator`) come from the adapter,
+    // not a static `ParamDescriptor.default`, since the right value depends on which
+    // platform-specific runtime entry was actually installed. Pre-seed `supplied` with
+    // them (as strings, since `validateParams` coerces from `--param` strings) for any
+    // key the caller didn't explicitly pass — an explicit `--param` always wins.
+    const dynamicDefaults = adapter.resolveParamDefaults?.({ manifestName, installed }) ?? {};
+    const suppliedParams = { ...(params ?? {}) };
+    for (const [key, value] of Object.entries(dynamicDefaults)) {
+        if (suppliedParams[key] === undefined)
+            suppliedParams[key] = String(value);
+    }
+    const { effective, errors } = validateParams(adapter.params ?? [], suppliedParams);
+    if (errors.length > 0) {
+        throw new MoldeskError({
+            code: "INVALID_RUN_PARAMS",
+            message: errors.join("; "),
+            remediation: "Fix the listed --param values and retry.",
+            details: { errors },
+        });
+    }
+    return { suppliedParams, effectiveParams: effective };
+}
+/** Allocates the run ID and its `input/` and `output/` directories. */
+export function allocateRunDirectory(paths) {
+    const runId = `${new Date().toISOString().replace(/[:.]/g, "-")}-${randomUUID()}`;
+    const runDirPath = runDir(runId, { MOLDESK_HOME: paths.home });
+    const inputDir = path.join(runDirPath, "input");
+    const outputDir = path.join(runDirPath, "output");
+    fs.mkdirSync(inputDir, { recursive: true });
+    fs.mkdirSync(outputDir, { recursive: true });
+    return { runId, runDirPath, inputDir, outputDir };
+}
+/**
+ * Copies and hashes the job input (and declared companion inputs), captures hardware, and writes
+ * the initial `preparing` record. A failure here finalizes `run.json` as failed/cancelled instead
+ * of rejecting, since the run directory already exists.
+ */
+export async function createRunSnapshot(params) {
+    const { dirs, manifest, adapter, resolvedInputPath } = params;
+    const inputRecords = [];
+    let hardware;
+    const buildRecord = (system, startedAt) => ({
+        schemaVersion: 1,
+        id: dirs.runId,
+        status: "preparing",
+        model: manifest.name,
+        modelVersion: manifest.modelVersion,
+        adapterVersion: manifest.adapterVersion,
+        moldeskVersion: VERSION,
+        runtime: params.runtime,
+        installationFingerprint: params.installationFingerprint,
+        manifestSha256: digest(manifest),
+        hardware: system,
+        input: inputRecords,
+        parameters: { supplied: params.suppliedParams, effective: params.effectiveParams },
+        command: { executable: "", args: [], cwd: dirs.runDirPath },
+        startedAt,
+        outputs: [],
+        logs: { stdout: path.join(dirs.runDirPath, "stdout.log"), stderr: path.join(dirs.runDirPath, "stderr.log") },
+    });
+    try {
+        hardware = await getSystemReport();
+        // --- Step 5: copy/snapshot the original input. ---
+        const storedInputPath = path.join(dirs.inputDir, path.basename(resolvedInputPath));
+        fs.copyFileSync(resolvedInputPath, storedInputPath);
+        const inputSha256 = await sha256File(storedInputPath);
+        inputRecords.push({ originalPath: resolvedInputPath, storedPath: storedInputPath, sha256: inputSha256, role: "job" });
+        // Models whose job file references separate companion files (e.g. DiffDock-L's
+        // protein PDB + ligand file) declare them via `resolveCompanionInputs`, given the
+        // *original* (pre-copy) resolved job path so relative references resolve against
+        // where the job file actually lives. Absent means unchanged single-file behavior.
+        const companionRefs = await adapter.resolveCompanionInputs?.(resolvedInputPath) ?? [];
+        const stagedCompanions = companionRefs.length > 0
+            ? stageCompanionInputs({ jobFilePath: resolvedInputPath, refs: companionRefs, inputDir: dirs.inputDir })
+            : [];
+        for (const staged of stagedCompanions) {
+            inputRecords.push({
+                originalPath: staged.originalPath,
+                storedPath: staged.storedPath,
+                sha256: await sha256File(staged.storedPath),
+                role: staged.id,
+            });
+        }
+        const companionInputs = stagedCompanions.map((staged) => ({ id: staged.id, path: staged.storedPath }));
+        const startedAt = new Date().toISOString();
+        const record = buildRecord(hardware, startedAt);
+        // --- Step 6: write the initial record. From this point, every path below finalizes run.json. ---
+        writeRunRecord(dirs.runDirPath, record);
+        return { ok: true, record, startedAt, storedInputPath, companionInputs };
+    }
+    catch (error) {
+        // If hardware capture itself failed, retry once; a second failure leaves no record to finalize
+        // and propagates (no fabricated hardware report).
+        hardware ??= await getSystemReport();
+        const startedAt = new Date().toISOString();
+        const record = buildRecord(hardware, startedAt);
+        record.status = params.signal?.aborted ? "cancelled" : "failed";
+        record.error = toErrorInfo(error, "RUN_SNAPSHOT_FAILED");
+        const finishedAt = new Date().toISOString();
+        record.finishedAt = finishedAt;
+        record.durationMs = Date.parse(finishedAt) - Date.parse(startedAt);
+        writeRunRecord(dirs.runDirPath, record);
+        return { ok: false, record };
+    }
+}
+/** Checksums and sizes the adapter's collected outputs (spec step 12). */
+export async function collectRunOutputs(adapter, context) {
+    const collected = await adapter.collectOutputs(context);
+    return Promise.all(collected.map(async (output) => ({
+        id: output.id,
+        path: output.path,
+        sha256: await sha256File(output.path),
+        sizeBytes: fs.statSync(output.path).size,
+    })));
+}
+/** Derived report, final atomic `run.json` write, and the post-finalization `--output` copy. */
+export async function finalizeRun(params) {
+    const { adapter, context, runDirPath, record, startedAt, signal, visualize, outputDir } = params;
+    // --- Derived report. Deliberately outside the execution try/catch: describing or exporting a
+    // report can only ever add a warning, never change the model's outcome or error. ---
+    if (record.status === "succeeded" && visualize !== false) {
+        const report = await generateRunReport({ adapter, context, runDirPath, record, signal });
+        if (report.artifact)
+            record.artifacts = [report.artifact];
+        if (report.warning)
+            record.warnings = [...(record.warnings ?? []), report.warning];
+    }
+    // --- Step 13: write the final record atomically. ---
+    const finishedAt = new Date().toISOString();
+    record.finishedAt = finishedAt;
+    record.durationMs = Date.parse(finishedAt) - Date.parse(startedAt);
+    writeRunRecord(runDirPath, record);
+    const result = { status: record.status, record };
+    // --- --output: a distinct, post-finalization copy step; never changes the run's own status. ---
+    if (result.status === "succeeded" && outputDir) {
+        try {
+            fs.mkdirSync(outputDir, { recursive: true });
+            for (const output of record.outputs) {
+                const target = path.join(outputDir, path.basename(output.path));
+                fs.copyFileSync(output.path, target, fs.constants.COPYFILE_EXCL);
+            }
+            // The report is self-contained; copy it under a name that cannot collide with outputs.
+            for (const artifact of record.artifacts ?? []) {
+                fs.copyFileSync(artifact.path, path.join(outputDir, `moldesk-report-${record.id}.html`), fs.constants.COPYFILE_EXCL);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            result.exportError = { code: "OUTPUT_COLLISION", message };
+        }
+    }
+    return result;
+}

package/dist/run.d.ts

@@ -1,6 +1,7 @@
 import { type RuntimeKind } from "@moldesk/registry";
 import { type MoldeskPaths, type RuntimeProvider, type SystemReport } from "@moldesk/runtime";
-import { type RunArtifact, type RunWarning } from "./run-report.js";
+import type { CloudRunDeps, CloudRunOptions } from "./cloud/run.js";
+import type { RunArtifact, RunWarning } from "./run-report.js";
 /**
  * `runModel` only rejects for usage errors discovered before a run directory
  * is allocated (unknown model, not installed, invalid input/params — spec
@@ -24,6 +25,16 @@ export interface RunModelOptions {
     runtimeProvider?: RuntimeProvider;
     /** Create the offline molecular report for a successful run when the adapter describes one. Default true. */
     visualize?: boolean;
+    /** `"local"` (default) runs on this machine; `"runpod"` runs on rented compute and requires `cloud`. */
+    compute?: "local" | "runpod";
+    /** Approved quote and limits for a remote run. Rejected for local runs. */
+    cloud?: CloudRunOptions;
+    /** Injected for tests; defaults to the production Runpod wiring. */
+    cloudDeps?: CloudRunDeps;
+    onProgress?: (event: {
+        stage: string;
+        message?: string;
+    }) => void;
 }
 export interface RunRecord {
     schemaVersion: 1;
@@ -83,6 +94,47 @@ export interface RunRecord {
     artifacts?: RunArtifact[];
     /** Nonfatal problems, e.g. the report could not be created. They never change `status`. */
     warnings?: RunWarning[];
+    /** Present only for remote runs. `hardware` above stays the local client's; the machine that ran inference is here. */
+    compute?: RunCompute;
+}
+export interface RunCompute {
+    provider: string;
+    cachePolicy: "ephemeral" | "persistent";
+    quoteId: string;
+    /** Last pipeline stage reached, e.g. "running" or "collecting". */
+    stage: string;
+    datacenterId: string;
+    gpuId: string;
+    /** Provider resource IDs that were created for this run (pods and volumes). */
+    resources: Array<{
+        role: "cpu" | "gpu" | "volume";
+        providerId: string;
+    }>;
+    /** What actually ran inference, reported by the worker. */
+    hardware?: {
+        name: string;
+        memoryMb?: number;
+        driverVersion?: string;
+        cudaVersion?: string;
+    };
+    /** POSIX command and cwd on the worker; `record.command.cwd` stays the local run directory. */
+    remoteCommand?: {
+        executable: string;
+        args: string[];
+        cwd: string;
+    };
+    pythonVersion?: string;
+    dependencyFreeze?: string[];
+    sourceRevision?: string;
+    cleanup: "confirmed" | "pending";
+    /** Warnings the user explicitly acknowledged before approval, e.g. "lifetime-risk". */
+    acknowledgedRisks?: string[];
+    workerLogCursor?: number;
+    /** `complete: false` means the worker evicted log chunks before they could be fetched (bounded tail). */
+    logs?: {
+        complete: boolean;
+        lostChunks: number;
+    };
 }
 export type { RunArtifact, RunWarning };
 export interface RunModelResult {
@@ -93,5 +145,13 @@ export interface RunModelResult {
         code: string;
         message: string;
     };
+    /** Remote runs only: paid resources could not be confirmed deleted. The scientific result is still valid. */
+    cleanupPending?: {
+        code: "CLOUD_CLEANUP_PENDING";
+        resources: Array<{
+            role: "cpu" | "gpu" | "volume";
+            providerId: string;
+        }>;
+    };
 }
 export declare function runModel(modelName: string, inputPath: string, options?: RunModelOptions): Promise<RunModelResult>;

package/dist/run.js

@@ -1,30 +1,39 @@
-import { randomUUID } from "node:crypto";
-import fs from "node:fs";
 import path from "node:path";
-import { getAdapter, validateParams } from "@moldesk/adapters";
+import { getAdapter } from "@moldesk/adapters";
 import { listAvailableModels } from "@moldesk/registry";
-import { getMoldeskPaths, getSystemReport, redactEnv, runDir, stageCompanionInputs, PythonRuntimeProvider, } from "@moldesk/runtime";
+import { getMoldeskPaths, redactEnv, PythonRuntimeProvider, } from "@moldesk/runtime";
 import { MoldeskError } from "./errors.js";
-import { digest, sha256File } from "./hash.js";
 import { listInstalledModels } from "./install-state.js";
-import { generateRunReport } from "./run-report.js";
-import { VERSION } from "./version.js";
+import { allocateRunDirectory, collectRunOutputs, createRunSnapshot, finalizeRun, prepareRunParams, toErrorInfo, writeRunRecord } from "./run-lifecycle.js";
 function runFailure(code, message, remediation, details) {
     return new MoldeskError({ code, message, remediation, details });
 }
-function toErrorInfo(error, fallbackCode) {
-    if (error instanceof MoldeskError)
-        return { code: error.code, message: error.message };
-    return { code: fallbackCode, message: error instanceof Error ? error.message : String(error) };
-}
-function writeRunRecord(runDirPath, record) {
-    const file = path.join(runDirPath, "run.json");
-    const temporary = `${file}.tmp-${process.pid}-${randomUUID()}`;
-    fs.writeFileSync(temporary, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600 });
-    fs.renameSync(temporary, file);
-}
 export async function runModel(modelName, inputPath, options = {}) {
     const paths = options.paths ?? getMoldeskPaths();
+    // --- Remote execution is dispatched before any local installation lookup: it never needs one. ---
+    if (options.compute === "runpod") {
+        if (!options.cloud) {
+            throw runFailure("CLOUD_OPTIONS_REQUIRED", "Cloud execution needs an approved quote.", "Pass --cache-policy, --max-budget and --max-lifetime and approve the quote.");
+        }
+        if (options.runtime === "docker") {
+            throw runFailure("CLOUD_RUNTIME_UNSUPPORTED", "The docker runtime is not supported for cloud execution.", "Use the python runtime.");
+        }
+        const { runCloudModel } = await import("./cloud/run.js");
+        const { createRunpodCloudDeps } = await import("./cloud/deps.js");
+        const deps = options.cloudDeps ?? (await createRunpodCloudDeps({ paths }));
+        return runCloudModel(modelName, inputPath, {
+            params: options.params,
+            outputDir: options.outputDir,
+            signal: options.signal,
+            onLog: options.onLog,
+            visualize: options.visualize,
+            cloud: options.cloud,
+            onProgress: options.onProgress,
+        }, { ...deps, paths });
+    }
+    if (options.cloud || options.cloudDeps) {
+        throw runFailure("CLOUD_OPTIONS_WITHOUT_CLOUD", "Cloud options were given for a local run.", "Add --compute runpod, or remove the cloud options.");
+    }
     // --- Step 1: load and validate manifest. No run directory yet: a failure here rejects. ---
     const manifest = listAvailableModels().find((entry) => entry.name === modelName);
     if (!manifest) {
@@ -52,75 +61,25 @@ export async function runModel(modelName, inputPath, options = {}) {
     }
     const resolvedInputPath = path.resolve(inputPath);
     await adapter.validateInput(resolvedInputPath);
-    // Platform-dependent defaults (e.g. Boltz's `accelerator`) come from the adapter,
-    // not a static `ParamDescriptor.default`, since the right value depends on which
-    // platform-specific runtime entry was actually installed. Pre-seed `supplied` with
-    // them (as strings, since `validateParams` coerces from `--param` strings) for any
-    // key the caller didn't explicitly pass — an explicit `--param` always wins.
-    const dynamicDefaults = adapter.resolveParamDefaults?.({ manifestName: manifest.name, installed }) ?? {};
-    const suppliedParams = { ...(options.params ?? {}) };
-    for (const [key, value] of Object.entries(dynamicDefaults)) {
-        if (suppliedParams[key] === undefined)
-            suppliedParams[key] = String(value);
-    }
-    const { effective: effectiveParams, errors: paramErrors } = validateParams(adapter.params ?? [], suppliedParams);
-    if (paramErrors.length > 0) {
-        throw runFailure("INVALID_RUN_PARAMS", paramErrors.join("; "), "Fix the listed --param values and retry.", { errors: paramErrors });
-    }
+    const { effectiveParams } = prepareRunParams(adapter, manifest.name, { runtime: installed.runtime }, options.params);
     // --- Step 4: allocate run ID and directory. From here on, every outcome resolves. ---
-    const runId = `${new Date().toISOString().replace(/[:.]/g, "-")}-${randomUUID()}`;
-    const runDirPath = runDir(runId, { MOLDESK_HOME: paths.home });
-    const inputDir = path.join(runDirPath, "input");
-    const outputDir = path.join(runDirPath, "output");
-    fs.mkdirSync(inputDir, { recursive: true });
-    fs.mkdirSync(outputDir, { recursive: true });
-    // --- Step 5: copy/snapshot the original input. ---
-    const storedInputPath = path.join(inputDir, path.basename(resolvedInputPath));
-    fs.copyFileSync(resolvedInputPath, storedInputPath);
-    const inputSha256 = await sha256File(storedInputPath);
-    const inputRecords = [
-        { originalPath: resolvedInputPath, storedPath: storedInputPath, sha256: inputSha256, role: "job" },
-    ];
-    // Models whose job file references separate companion files (e.g. DiffDock-L's
-    // protein PDB + ligand file) declare them via `resolveCompanionInputs`, given the
-    // *original* (pre-copy) resolved job path so relative references resolve against
-    // where the job file actually lives. Absent means unchanged single-file behavior.
-    const companionRefs = await adapter.resolveCompanionInputs?.(resolvedInputPath) ?? [];
-    const stagedCompanions = companionRefs.length > 0
-        ? stageCompanionInputs({ jobFilePath: resolvedInputPath, refs: companionRefs, inputDir })
-        : [];
-    for (const staged of stagedCompanions) {
-        inputRecords.push({
-            originalPath: staged.originalPath,
-            storedPath: staged.storedPath,
-            sha256: await sha256File(staged.storedPath),
-            role: staged.id,
-        });
-    }
-    const companionInputs = stagedCompanions.map((staged) => ({ id: staged.id, path: staged.storedPath }));
-    const hardware = await getSystemReport();
-    const startedAt = new Date().toISOString();
-    const record = {
-        schemaVersion: 1,
-        id: runId,
-        status: "preparing",
-        model: manifest.name,
-        modelVersion: manifest.modelVersion,
-        adapterVersion: manifest.adapterVersion,
-        moldeskVersion: VERSION,
+    const dirs = allocateRunDirectory(paths);
+    const { runDirPath, outputDir } = dirs;
+    // --- Steps 5-6: snapshot inputs and write the initial record. ---
+    const snapshot = await createRunSnapshot({
+        dirs,
+        manifest,
+        adapter,
         runtime: installed.runtime.kind,
         installationFingerprint: installed.runtime.fingerprint,
-        manifestSha256: digest(manifest),
-        hardware,
-        input: inputRecords,
-        parameters: { supplied: options.params ?? {}, effective: effectiveParams },
-        command: { executable: "", args: [], cwd: runDirPath },
-        startedAt,
-        outputs: [],
-        logs: { stdout: path.join(runDirPath, "stdout.log"), stderr: path.join(runDirPath, "stderr.log") },
-    };
-    // --- Step 6: write the initial record. From this point, every path below finalizes run.json. ---
-    writeRunRecord(runDirPath, record);
+        resolvedInputPath,
+        suppliedParams: options.params ?? {},
+        effectiveParams,
+        signal: options.signal,
+    });
+    if (!snapshot.ok)
+        return { status: snapshot.record.status, record: snapshot.record };
+    const { record, startedAt, storedInputPath, companionInputs } = snapshot;
     const runContext = {
         manifestName: manifest.name,
         inputPath: storedInputPath,
@@ -175,14 +134,8 @@ export async function runModel(modelName, inputPath, options = {}) {
             };
         }
         else {
-            const collected = await adapter.collectOutputs(runContext);
             // --- Step 12: checksum + size each output. ---
-            record.outputs = await Promise.all(collected.map(async (output) => ({
-                id: output.id,
-                path: output.path,
-                sha256: await sha256File(output.path),
-                sizeBytes: fs.statSync(output.path).size,
-            })));
+            record.outputs = await collectRunOutputs(adapter, runContext);
             record.status = "succeeded";
         }
     }
@@ -190,38 +143,14 @@ export async function runModel(modelName, inputPath, options = {}) {
         record.status = options.signal?.aborted ? "cancelled" : "failed";
         record.error = toErrorInfo(error, "RUN_EXECUTION_FAILED");
     }
-    // --- Derived report. Deliberately outside the try/catch above: describing or exporting a
-    // report can only ever add a warning, never change the model's outcome or error. ---
-    if (record.status === "succeeded" && options.visualize !== false) {
-        const report = await generateRunReport({ adapter, context: runContext, runDirPath, record, signal: options.signal });
-        if (report.artifact)
-            record.artifacts = [report.artifact];
-        if (report.warning)
-            record.warnings = [report.warning];
-    }
-    // --- Step 13: write the final record atomically. ---
-    const finishedAt = new Date().toISOString();
-    record.finishedAt = finishedAt;
-    record.durationMs = Date.parse(finishedAt) - Date.parse(startedAt);
-    writeRunRecord(runDirPath, record);
-    const result = { status: record.status, record };
-    // --- --output: a distinct, post-finalization copy step; never changes the run's own status. ---
-    if (result.status === "succeeded" && options.outputDir) {
-        try {
-            fs.mkdirSync(options.outputDir, { recursive: true });
-            for (const output of record.outputs) {
-                const target = path.join(options.outputDir, path.basename(output.path));
-                fs.copyFileSync(output.path, target, fs.constants.COPYFILE_EXCL);
-            }
-            // The report is self-contained; copy it under a name that cannot collide with outputs.
-            for (const artifact of record.artifacts ?? []) {
-                fs.copyFileSync(artifact.path, path.join(options.outputDir, `moldesk-report-${record.id}.html`), fs.constants.COPYFILE_EXCL);
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            result.exportError = { code: "OUTPUT_COLLISION", message };
-        }
-    }
-    return result;
+    return finalizeRun({
+        adapter,
+        context: runContext,
+        runDirPath,
+        record,
+        startedAt,
+        signal: options.signal,
+        visualize: options.visualize,
+        outputDir: options.outputDir,
+    });
 }

package/dist/run.test.js

@@ -1,11 +1,23 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { getMoldeskPaths } from "@moldesk/runtime";
 import { listAvailableModels } from "@moldesk/registry";
 import { createInstallationPlan, installModel } from "./installation.js";
 import { runModel } from "./run.js";
+const hashFailure = vi.hoisted(() => ({ message: undefined }));
+vi.mock("./hash.js", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        sha256File: async (file) => {
+            if (hashFailure.message)
+                throw new Error(hashFailure.message);
+            return actual.sha256File(file);
+        },
+    };
+});
 const homes = [];
 function tempPaths() {
     // Intentionally includes a space to exercise the "paths containing spaces" requirement.
@@ -14,6 +26,7 @@ function tempPaths() {
     return getMoldeskPaths({ MOLDESK_HOME: home });
 }
 afterEach(() => {
+    hashFailure.message = undefined;
     for (const home of homes.splice(0))
         fs.rmSync(home, { recursive: true, force: true });
 });
@@ -171,6 +184,39 @@ describe("runModel", () => {
         expect(result.record.error?.message).toContain("simulated runtime crash");
         expect(result.record.finishedAt).toBeDefined();
     });
+    it("finalizes run.json as failed when input snapshotting throws after the run directory is allocated", async () => {
+        const paths = tempPaths();
+        await installFixture(paths);
+        const inputPath = writeInputFixture(paths.home);
+        let executed = false;
+        hashFailure.message = "simulated hashing failure";
+        const result = await runModel("proteinmpnn", inputPath, {
+            paths,
+            runtimeProvider: fakeProvider(() => {
+                executed = true;
+                throw new Error("must not execute");
+            }),
+        });
+        expect(executed).toBe(false);
+        expect(result.status).toBe("failed");
+        expect(result.record.error).toEqual({ code: "RUN_SNAPSHOT_FAILED", message: "simulated hashing failure" });
+        expect(result.record.finishedAt).toBeDefined();
+        const onDisk = JSON.parse(fs.readFileSync(path.join(result.record.command.cwd, "run.json"), "utf8"));
+        expect(onDisk.status).toBe("failed");
+        expect(onDisk.error.code).toBe("RUN_SNAPSHOT_FAILED");
+        expect(onDisk.finishedAt).toBeDefined();
+    });
+    it("dispatches remote runs before any local installation lookup and rejects mixed or incomplete options", async () => {
+        const paths = tempPaths();
+        const inputPath = writeInputFixture(paths.home);
+        const cloud = { cachePolicy: "ephemeral", maxBudgetUsd: 1, maxLifetimeSeconds: 60, quote: {}, approval: { quoteId: "q", approvedAt: "t", acknowledged: ["lifetime-risk"] } };
+        await expect(runModel("proteinmpnn", inputPath, { paths, compute: "runpod" })).rejects.toMatchObject({ code: "CLOUD_OPTIONS_REQUIRED" });
+        await expect(runModel("proteinmpnn", inputPath, { paths, compute: "runpod", cloud, runtime: "docker" })).rejects.toMatchObject({ code: "CLOUD_RUNTIME_UNSUPPORTED" });
+        await expect(runModel("proteinmpnn", inputPath, { paths, cloud })).rejects.toMatchObject({ code: "CLOUD_OPTIONS_WITHOUT_CLOUD" });
+        // Nothing is installed here, yet the remote path is reached (it fails on its own missing backend, not MODEL_NOT_INSTALLED).
+        await expect(runModel("proteinmpnn", inputPath, { paths, compute: "runpod", cloud, cloudDeps: { provider: {} } })).rejects.toMatchObject({ code: "CLOUD_BACKEND_MISSING" });
+        expect(fs.existsSync(paths.runs)).toBe(false);
+    });
     it("writes status:running with the real pid before execute() resolves", async () => {
         const paths = tempPaths();
         await installFixture(paths);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moldesk/core",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Shared engine logic for MoleculeDesk (CLI + desktop)",
   "license": "MIT",
   "type": "module",
@@ -19,18 +19,22 @@
     "dist"
   ],
   "dependencies": {
-    "@moldesk/adapters": "0.0.4",
-    "@moldesk/runtime": "0.0.4",
-    "@moldesk/visualizer": "0.0.4",
-    "@moldesk/registry": "0.0.4"
+    "better-sqlite3": "~12.11.1",
+    "@moldesk/adapters": "0.0.6",
+    "@moldesk/registry": "0.0.6",
+    "@moldesk/visualizer": "0.0.6",
+    "@moldesk/runtime": "0.0.6"
   },
   "devDependencies": {
+    "esbuild": "^0.25",
+    "@types/better-sqlite3": "^9.6.0",
     "typescript": "^5.6.3",
     "vitest": "^3.0.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run"
+    "test": "vitest run",
+    "build:worker": "node scripts/build-worker.mjs"
   }
 }