@moldesk/adapters 0.0.0-stage → 0.0.3

package/dist/outputs.js

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import path from "node:path";
+import { MoldeskError } from "@moldesk/registry";
+function segmentPattern(segment) {
+    const escaped = segment.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${escaped}$`);
+}
+/**
+ * Matches a manifest output glob (segment-wise `*` wildcards, e.g. "seqs/*.fa")
+ * against files under `root`. Uses `lstat`, never `stat`, at every level — a
+ * symlink (whether an intermediate directory-like entry or the final matched
+ * file) is never followed or trusted as a legitimate output. A model process
+ * could in principle write a symlink pointing outside `outputDir`; collecting
+ * and checksumming whatever that symlink resolves to would silently break
+ * output confinement, so any symlink is simply excluded from matching rather
+ * than resolved.
+ */
+function matchGlob(root, glob) {
+    let candidates = [root];
+    for (const segment of glob.split("/")) {
+        const pattern = segmentPattern(segment);
+        const next = [];
+        for (const dir of candidates) {
+            // A prior segment's `*` wildcard matches any entry name, files included —
+            // only descend into it here if it's actually a real (non-symlink)
+            // directory. Without this check, a stray file (or a directory-symlink)
+            // sitting alongside the expected subdirectory would make `readdirSync`
+            // throw ENOTDIR instead of simply not matching.
+            let stat;
+            try {
+                stat = fs.lstatSync(dir);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isDirectory())
+                continue;
+            for (const entry of fs.readdirSync(dir)) {
+                if (pattern.test(entry))
+                    next.push(path.join(dir, entry));
+            }
+        }
+        candidates = next;
+    }
+    return candidates
+        .filter((entry) => {
+        let stat;
+        try {
+            stat = fs.lstatSync(entry);
+        }
+        catch {
+            return false;
+        }
+        return stat.isFile();
+    })
+        .sort();
+}
+/**
+ * Resolves manifest-declared output globs against a run's output directory.
+ * Throws `MISSING_REQUIRED_OUTPUT` if any `required` output has no matches —
+ * a nonzero exit code alone is not sufficient (spec §4.4).
+ */
+export function collectGlobOutputs(outputDir, outputs) {
+    const collected = [];
+    for (const output of outputs) {
+        const matches = matchGlob(outputDir, output.glob);
+        if (matches.length === 0 && output.required) {
+            throw new MoldeskError({
+                code: "MISSING_REQUIRED_OUTPUT",
+                message: `Required output "${output.id}" (glob "${output.glob}") produced no files in ${outputDir}.`,
+                remediation: "Check stdout.log/stderr.log in the run directory for the underlying failure.",
+                details: { id: output.id, glob: output.glob, outputDir },
+            });
+        }
+        for (const match of matches)
+            collected.push({ id: output.id, path: match });
+    }
+    return collected;
+}

package/dist/outputs.test.d.ts

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

package/dist/outputs.test.js

@@ -0,0 +1,69 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { collectGlobOutputs } from "./outputs.js";
+const dirs = [];
+function tempDir() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "moldesk-outputs-test-"));
+    dirs.push(dir);
+    return dir;
+}
+afterEach(() => {
+    for (const dir of dirs.splice(0))
+        fs.rmSync(dir, { recursive: true, force: true });
+});
+describe("collectGlobOutputs", () => {
+    it("matches a single-segment glob", () => {
+        const outputDir = tempDir();
+        fs.writeFileSync(path.join(outputDir, "summary.json"), "{}");
+        const outputs = collectGlobOutputs(outputDir, [{ id: "summary", glob: "summary.json", required: true }]);
+        expect(outputs).toEqual([{ id: "summary", path: path.join(outputDir, "summary.json") }]);
+    });
+    it("matches every file for a multi-match glob, one CollectedOutput per file", () => {
+        const outputDir = tempDir();
+        const complexDir = path.join(outputDir, "complex_0");
+        fs.mkdirSync(complexDir, { recursive: true });
+        fs.writeFileSync(path.join(complexDir, "rank1_confidence0.85.sdf"), "");
+        fs.writeFileSync(path.join(complexDir, "rank2_confidence-1.23.sdf"), "");
+        const outputs = collectGlobOutputs(outputDir, [{ id: "ranked_poses", glob: "*/rank*_confidence*.sdf", required: true }]);
+        expect(outputs.map((o) => o.id)).toEqual(["ranked_poses", "ranked_poses"]);
+    });
+    it("does not throw ENOTDIR when a stray file sits alongside the expected subdirectory at a wildcard-matched level", () => {
+        const outputDir = tempDir();
+        const complexDir = path.join(outputDir, "complex_0");
+        fs.mkdirSync(complexDir, { recursive: true });
+        fs.writeFileSync(path.join(complexDir, "rank1.sdf"), "");
+        // A sidecar file directly under outputDir — the `*` in `*/rank1.sdf` also
+        // matches this filename, and a naive matcher would try to readdir it.
+        fs.writeFileSync(path.join(outputDir, "poses_summary.json"), "{}");
+        const outputs = collectGlobOutputs(outputDir, [{ id: "top_pose", glob: "*/rank1.sdf", required: true }]);
+        expect(outputs).toEqual([{ id: "top_pose", path: path.join(complexDir, "rank1.sdf") }]);
+    });
+    it("throws MISSING_REQUIRED_OUTPUT for a required output with no matches, even when an unrelated stray file exists", () => {
+        const outputDir = tempDir();
+        fs.writeFileSync(path.join(outputDir, "some-unrelated-file.txt"), "not a pose");
+        expect(() => collectGlobOutputs(outputDir, [{ id: "top_pose", glob: "*/rank1.sdf", required: true }])).toThrowError(expect.objectContaining({ code: "MISSING_REQUIRED_OUTPUT" }));
+    });
+    it("does not throw for a non-required output with no matches", () => {
+        const outputDir = tempDir();
+        const outputs = collectGlobOutputs(outputDir, [{ id: "optional", glob: "optional.json", required: false }]);
+        expect(outputs).toEqual([]);
+    });
+    it("rejects a symlinked output file pointing outside outputDir instead of following it", () => {
+        const outputDir = tempDir();
+        const outsideDir = tempDir();
+        const secretPath = path.join(outsideDir, "secret.sdf");
+        fs.writeFileSync(secretPath, "secret");
+        fs.symlinkSync(secretPath, path.join(outputDir, "rank1.sdf"));
+        expect(() => collectGlobOutputs(outputDir, [{ id: "top_pose", glob: "rank1.sdf", required: true }])).toThrowError(expect.objectContaining({ code: "MISSING_REQUIRED_OUTPUT" }));
+    });
+    it("rejects a symlinked directory reached through a wildcard segment instead of descending into it", () => {
+        const outputDir = tempDir();
+        const outsideDir = tempDir();
+        fs.mkdirSync(path.join(outsideDir, "escaped"), { recursive: true });
+        fs.writeFileSync(path.join(outsideDir, "escaped", "rank1.sdf"), "outside content");
+        fs.symlinkSync(path.join(outsideDir, "escaped"), path.join(outputDir, "complex_0"));
+        expect(() => collectGlobOutputs(outputDir, [{ id: "top_pose", glob: "*/rank1.sdf", required: true }])).toThrowError(expect.objectContaining({ code: "MISSING_REQUIRED_OUTPUT" }));
+    });
+});

package/dist/params.d.ts

@@ -0,0 +1,13 @@
+import type { ParamDescriptor } from "./index.js";
+export interface ParamValidationResult {
+    effective: Record<string, unknown>;
+    errors: string[];
+}
+/**
+ * Validates and normalizes `--param key=value` input against an adapter's
+ * declared params. Rejects unknown keys, coerces by declared type, enforces
+ * min/max/enum, and fills defaults for missing non-required params.
+ * Collects every error rather than stopping at the first, so the CLI can
+ * report all problems in one pass.
+ */
+export declare function validateParams(descriptors: ParamDescriptor[], supplied: Record<string, string>): ParamValidationResult;

package/dist/params.js

@@ -0,0 +1,69 @@
+function coerce(descriptor, raw, errors) {
+    switch (descriptor.type) {
+        case "string":
+            if (descriptor.enum && !descriptor.enum.includes(raw)) {
+                errors.push(`--param ${descriptor.name}: "${raw}" is not one of ${descriptor.enum.join(", ")}.`);
+            }
+            return raw;
+        case "number": {
+            const value = Number(raw);
+            if (!Number.isFinite(value)) {
+                errors.push(`--param ${descriptor.name}: "${raw}" is not a number.`);
+                return undefined;
+            }
+            if (descriptor.min !== undefined && value < descriptor.min) {
+                errors.push(`--param ${descriptor.name}: ${value} is below the minimum of ${descriptor.min}.`);
+            }
+            if (descriptor.max !== undefined && value > descriptor.max) {
+                errors.push(`--param ${descriptor.name}: ${value} is above the maximum of ${descriptor.max}.`);
+            }
+            if (descriptor.enum && !descriptor.enum.includes(value)) {
+                errors.push(`--param ${descriptor.name}: ${value} is not one of ${descriptor.enum.join(", ")}.`);
+            }
+            return value;
+        }
+        case "boolean": {
+            if (raw === "true" || raw === "1")
+                return true;
+            if (raw === "false" || raw === "0")
+                return false;
+            errors.push(`--param ${descriptor.name}: "${raw}" is not a boolean (use true/false).`);
+            return undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+/**
+ * Validates and normalizes `--param key=value` input against an adapter's
+ * declared params. Rejects unknown keys, coerces by declared type, enforces
+ * min/max/enum, and fills defaults for missing non-required params.
+ * Collects every error rather than stopping at the first, so the CLI can
+ * report all problems in one pass.
+ */
+export function validateParams(descriptors, supplied) {
+    const errors = [];
+    const byName = new Map(descriptors.map((descriptor) => [descriptor.name, descriptor]));
+    for (const key of Object.keys(supplied)) {
+        if (!byName.has(key)) {
+            errors.push(`Unknown parameter "${key}". Accepted parameters: ${descriptors.map((d) => d.name).join(", ") || "(none)"}.`);
+        }
+    }
+    const effective = {};
+    for (const descriptor of descriptors) {
+        const raw = supplied[descriptor.name];
+        if (raw === undefined) {
+            if (descriptor.required) {
+                errors.push(`Missing required parameter "${descriptor.name}".`);
+            }
+            else if (descriptor.default !== undefined) {
+                effective[descriptor.name] = descriptor.default;
+            }
+            continue;
+        }
+        const value = coerce(descriptor, raw, errors);
+        if (value !== undefined)
+            effective[descriptor.name] = value;
+    }
+    return { effective, errors };
+}

package/dist/params.test.d.ts

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

package/dist/params.test.js

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { validateParams } from "./params.js";
+const descriptors = [
+    { name: "count", type: "number", default: 1, min: 1, max: 10 },
+    { name: "mode", type: "string", enum: ["fast", "slow"], required: true },
+    { name: "verbose", type: "boolean", default: false },
+];
+describe("validateParams", () => {
+    it("fills defaults for missing non-required params", () => {
+        const { effective, errors } = validateParams(descriptors, { mode: "fast" });
+        expect(errors).toEqual([]);
+        expect(effective).toEqual({ count: 1, mode: "fast", verbose: false });
+    });
+    it("coerces declared types", () => {
+        const { effective, errors } = validateParams(descriptors, { count: "5", mode: "slow", verbose: "true" });
+        expect(errors).toEqual([]);
+        expect(effective).toEqual({ count: 5, mode: "slow", verbose: true });
+    });
+    it("rejects an unknown parameter", () => {
+        const { errors } = validateParams(descriptors, { mode: "fast", bogus: "1" });
+        expect(errors.some((e) => e.includes('Unknown parameter "bogus"'))).toBe(true);
+    });
+    it("reports a missing required parameter", () => {
+        const { errors } = validateParams(descriptors, {});
+        expect(errors.some((e) => e.includes('Missing required parameter "mode"'))).toBe(true);
+    });
+    it("enforces min/max/enum and collects every error in one pass", () => {
+        const { errors } = validateParams(descriptors, { count: "999", mode: "medium" });
+        expect(errors.length).toBeGreaterThanOrEqual(2);
+        expect(errors.some((e) => e.includes("above the maximum"))).toBe(true);
+        expect(errors.some((e) => e.includes("is not one of"))).toBe(true);
+    });
+    it("rejects a non-numeric value for a number param", () => {
+        const { errors } = validateParams(descriptors, { count: "abc", mode: "fast" });
+        expect(errors.some((e) => e.includes("is not a number"))).toBe(true);
+    });
+    it("rejects a non-boolean value for a boolean param", () => {
+        const { errors } = validateParams(descriptors, { mode: "fast", verbose: "maybe" });
+        expect(errors.some((e) => e.includes("is not a boolean"))).toBe(true);
+    });
+});

package/dist/planned.d.ts

@@ -0,0 +1 @@
+export declare function plannedAdapterOperation(modelName: string, operation: string): never;

package/dist/planned.js

@@ -0,0 +1,9 @@
+import { MoldeskError } from "@moldesk/registry";
+export function plannedAdapterOperation(modelName, operation) {
+    throw new MoldeskError({
+        code: "ADAPTER_NOT_IMPLEMENTED",
+        message: `Model adapter "${modelName}" cannot ${operation} yet.`,
+        remediation: `The model is listed as planned. Wait until its install/run vertical slice is verified and marked available.`,
+        details: { modelName, operation },
+    });
+}

package/dist/proteinmpnn/index.d.ts

@@ -0,0 +1,2 @@
+import type { ModelAdapterDefinition } from "../index.js";
+export declare const proteinmpnnAdapter: ModelAdapterDefinition;

package/dist/proteinmpnn/index.js

@@ -0,0 +1,84 @@
+import fs from "node:fs";
+import path from "node:path";
+import { MoldeskError } from "@moldesk/registry";
+import { runCommand } from "@moldesk/runtime";
+import { collectGlobOutputs } from "../outputs.js";
+/** Pinned to the manifest's modelVersion; protein_mpnn_run.py loads `<path_to_model_weights>/<model_name>.pt`. */
+const MODEL_NAME = "v_48_020";
+/** protein_mpnn_run.py writes `<out_folder>/seqs/<pdb_name>.fa` (verified against the pinned source revision). */
+const OUTPUTS = [{ id: "sequences", glob: "seqs/*.fa", required: true }];
+const PARAMS = [
+    { name: "num_seq_per_target", type: "number", default: 1, min: 1, description: "Number of sequences to generate per target" },
+    // Upstream parses this as a space-separated string of temperatures, not a single float.
+    { name: "sampling_temp", type: "string", default: "0.1", description: "Sampling temperature(s), e.g. \"0.1\" or \"0.1 0.2\"" },
+    { name: "seed", type: "number", default: 0, description: "Random seed; 0 picks a random seed" },
+    { name: "batch_size", type: "number", default: 1, min: 1, description: "Batch size" },
+    { name: "ca_only", type: "boolean", default: false, description: "Parse CA-only structures and use CA-only models" },
+];
+export const proteinmpnnAdapter = {
+    modelName: "proteinmpnn",
+    params: PARAMS,
+    async validateInput(inputPath) {
+        if (!fs.existsSync(inputPath)) {
+            throw new MoldeskError({
+                code: "INVALID_RUN_INPUT",
+                message: `Input file not found: ${inputPath}.`,
+                remediation: "Provide a path to an existing .pdb file.",
+            });
+        }
+        if (path.extname(inputPath).toLowerCase() !== ".pdb") {
+            throw new MoldeskError({
+                code: "INVALID_RUN_INPUT",
+                message: `ProteinMPNN requires a .pdb input file, got "${path.extname(inputPath) || "(no extension)"}".`,
+                remediation: "Provide a .pdb structure file.",
+            });
+        }
+    },
+    async installPlan(_context) {
+        return {
+            steps: [
+                { id: "source", description: "Fetch the pinned ProteinMPNN source revision" },
+                { id: "checkpoint", description: "Download and checksum the ProteinMPNN checkpoint" },
+                { id: "python", description: "Create an isolated managed Python 3.11 environment" },
+                { id: "dependencies", description: "Install pinned Python dependencies" },
+                { id: "verify", description: "Verify source, checkpoint, and Python imports" },
+            ],
+        };
+    },
+    async command(context) {
+        const params = context.params;
+        const args = [
+            path.join(context.modelDir, "source", "protein_mpnn_run.py"),
+            "--pdb_path", context.inputPath,
+            "--out_folder", context.outputDir,
+            "--path_to_model_weights", path.join(context.assetsDir, "vanilla_model_weights"),
+            "--model_name", MODEL_NAME,
+        ];
+        if (params.num_seq_per_target !== undefined)
+            args.push("--num_seq_per_target", String(params.num_seq_per_target));
+        if (params.sampling_temp !== undefined)
+            args.push("--sampling_temp", String(params.sampling_temp));
+        if (params.seed !== undefined)
+            args.push("--seed", String(params.seed));
+        if (params.batch_size !== undefined)
+            args.push("--batch_size", String(params.batch_size));
+        if (params.ca_only === true)
+            args.push("--ca_only");
+        return { executable: context.runtimeExecutable, args };
+    },
+    async collectOutputs(context) {
+        return collectGlobOutputs(context.outputDir, OUTPUTS);
+    },
+    async verifyInstallation(context) {
+        const requiredFiles = [
+            path.join(context.modelDir, "source", "protein_mpnn_run.py"),
+            path.join(context.assetsDir, "vanilla_model_weights", "v_48_020.pt"),
+        ];
+        const missing = requiredFiles.filter((file) => !fs.existsSync(file));
+        if (missing.length > 0)
+            return { passed: false, output: `Missing ${missing.join(", ")}` };
+        const python = path.join(context.modelDir, ".venv", "bin", "python");
+        const result = await (context.runner ?? runCommand)(python, ["-c", "import numpy, torch"], { timeoutMs: 120_000 });
+        return { passed: result.code === 0, output: (result.code === 0 ? result.stdout : result.stderr).trim() };
+    },
+};

package/dist/proteinmpnn/index.test.d.ts

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

package/dist/proteinmpnn/index.test.js

@@ -0,0 +1,101 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { proteinmpnnAdapter } from "./index.js";
+const dirs = [];
+function tempDir() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "moldesk-proteinmpnn-test-"));
+    dirs.push(dir);
+    return dir;
+}
+afterEach(() => {
+    for (const dir of dirs.splice(0))
+        fs.rmSync(dir, { recursive: true, force: true });
+});
+describe("proteinmpnnAdapter.validateInput", () => {
+    it("accepts an existing .pdb file", async () => {
+        const dir = tempDir();
+        const input = path.join(dir, "structure.pdb");
+        fs.writeFileSync(input, "ATOM\n");
+        await expect(proteinmpnnAdapter.validateInput(input)).resolves.toBeUndefined();
+    });
+    it("rejects a missing file", async () => {
+        await expect(proteinmpnnAdapter.validateInput(path.join(tempDir(), "missing.pdb"))).rejects.toMatchObject({
+            code: "INVALID_RUN_INPUT",
+        });
+    });
+    it("rejects a non-.pdb extension", async () => {
+        const dir = tempDir();
+        const input = path.join(dir, "structure.txt");
+        fs.writeFileSync(input, "ATOM\n");
+        await expect(proteinmpnnAdapter.validateInput(input)).rejects.toMatchObject({ code: "INVALID_RUN_INPUT" });
+    });
+});
+describe("proteinmpnnAdapter.command", () => {
+    it("builds the expected executable/args shape", async () => {
+        const spec = await proteinmpnnAdapter.command({
+            manifestName: "proteinmpnn",
+            inputPath: "/run/input/structure.pdb",
+            outputDir: "/run/output",
+            modelDir: "/models/proteinmpnn",
+            assetsDir: "/models/proteinmpnn/assets",
+            params: { num_seq_per_target: 2, sampling_temp: "0.1", seed: 0, batch_size: 1, ca_only: true },
+            runtimeExecutable: "/models/proteinmpnn/.venv/bin/python",
+        });
+        expect(spec.executable).toBe("/models/proteinmpnn/.venv/bin/python");
+        expect(spec.args).toContain("--pdb_path");
+        expect(spec.args).toContain("/run/input/structure.pdb");
+        expect(spec.args).toContain("--out_folder");
+        expect(spec.args).toContain("/run/output");
+        expect(spec.args).toContain("--path_to_model_weights");
+        expect(spec.args).toContain(path.join("/models/proteinmpnn/assets", "vanilla_model_weights"));
+        expect(spec.args).toContain("--num_seq_per_target");
+        expect(spec.args).toContain("2");
+        expect(spec.args).toContain("--ca_only");
+    });
+    it("omits --ca_only when false", async () => {
+        const spec = await proteinmpnnAdapter.command({
+            manifestName: "proteinmpnn",
+            inputPath: "/run/input/structure.pdb",
+            outputDir: "/run/output",
+            modelDir: "/models/proteinmpnn",
+            assetsDir: "/models/proteinmpnn/assets",
+            params: { num_seq_per_target: 1, sampling_temp: "0.1", seed: 0, batch_size: 1, ca_only: false },
+            runtimeExecutable: "/models/proteinmpnn/.venv/bin/python",
+        });
+        expect(spec.args).not.toContain("--ca_only");
+    });
+});
+describe("proteinmpnnAdapter.collectOutputs", () => {
+    it("collects generated .fa files from the seqs/ subdirectory", async () => {
+        const dir = tempDir();
+        const outputDir = path.join(dir, "output");
+        fs.mkdirSync(path.join(outputDir, "seqs"), { recursive: true });
+        fs.writeFileSync(path.join(outputDir, "seqs", "structure.fa"), ">structure\nMKV\n");
+        const outputs = await proteinmpnnAdapter.collectOutputs({
+            manifestName: "proteinmpnn",
+            inputPath: path.join(dir, "input", "structure.pdb"),
+            outputDir,
+            modelDir: dir,
+            assetsDir: path.join(dir, "assets"),
+            params: {},
+            runtimeExecutable: "python",
+        });
+        expect(outputs).toEqual([{ id: "sequences", path: path.join(outputDir, "seqs", "structure.fa") }]);
+    });
+    it("throws MISSING_REQUIRED_OUTPUT when no .fa files were produced", async () => {
+        const dir = tempDir();
+        const outputDir = path.join(dir, "output");
+        fs.mkdirSync(outputDir, { recursive: true });
+        await expect(proteinmpnnAdapter.collectOutputs({
+            manifestName: "proteinmpnn",
+            inputPath: path.join(dir, "input", "structure.pdb"),
+            outputDir,
+            modelDir: dir,
+            assetsDir: path.join(dir, "assets"),
+            params: {},
+            runtimeExecutable: "python",
+        })).rejects.toMatchObject({ code: "MISSING_REQUIRED_OUTPUT" });
+    });
+});

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "@moldesk/adapters",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.3",
+  "description": "Thin model-specific adapters for MoleculeDesk (translation/verification only)",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pooriyapfn/moldesk.git",
+    "directory": "packages/adapters"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "yaml": "^2.5.1",
+    "@moldesk/registry": "0.0.3",
+    "@moldesk/runtime": "0.0.3"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/validate-catalog.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.