@springbrand/eval-harness 0.0.0-stage → 0.1.0-alpha.0

package/README.md

@@ -1,3 +1,77 @@
-# Temporary Holding Version
+# @springbrand/eval-harness
 
-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.
+SP's service contract for Eval-managed ordinary Chats. This package owns only
+wire validation, stable request facts and service route names. Inbox owns Chat
+creation and routing, Severn owns Submission and canonical Session history,
+Workspace owns files, and API owns billing settlements. Eval Project, Dataset,
+Sampling and scoring remain in `eval-platform`.
+
+The Eval Run Worker authenticates with a dedicated service token. Its requests
+include the owning user ID because an SP Inbox is addressed by user. The Chat
+creation facts and each Submission operation key are immutable. Initialization
+receives Eval-provided bundle/resource IDs and their content: material files go
+to the target Chat Workspace; canonical JSON or JSONL context may be imported into
+the Chat Session before the first Submission and need not be copied to Workspace.
+
+The service interface is implemented under `apps/agent/src/eval/`. The Agent
+Worker requires the separately provisioned `EVAL_SP_SERVICE_TOKEN` secret and
+the Run Worker sends it as `X-Eval-Service-Token`. No browser Origin is accepted.
+The Eval Worker uses the independently deployed Eval SP origin. Its user ID is
+part of the Agent Worker path because an SP Inbox is addressed by user.
+That Agent Worker's `API_ORIGIN` and SpaceDO binding must point to the same
+independent Eval SP deployment; the shared SP dev API and database are not used.
+
+| Operation | Agent Worker route |
+| --- | --- |
+| Ensure the ordinary Chat | `PUT /internal/v1/eval-harness/users/{userId}/chats/{chatId}` |
+| Initialize one Data sample's optional Session and materials | `POST /internal/v1/eval-harness/users/{userId}/chats/{chatId}/initialization` |
+| Submit one Prompt | `POST /internal/v1/eval-harness/users/{userId}/chats/{chatId}/submissions` |
+| Recover a Submission by operation key | `GET /internal/v1/eval-harness/users/{userId}/chats/{chatId}/submissions/by-key/{key}` |
+| Stop every unfinished Submission in this Eval Chat | `POST /internal/v1/eval-harness/users/{userId}/chats/{chatId}/submissions/stop` |
+| Observe a Submission | `WS /internal/v1/eval-harness/users/{userId}/chats/{chatId}/submissions/{submissionId}/events` |
+| Collect the complete artifact list and trajectory reference | `GET /internal/v1/eval-harness/users/{userId}/chats/{chatId}/output` |
+| Collect raw resource facts | `GET /internal/v1/eval-harness/users/{userId}/chats/{chatId}/resources/by-key/{key}` |
+| Export: list produced artifacts with size and media type | `GET /internal/v1/eval-harness/users/{userId}/chats/{chatId}/evidence/artifacts` |
+| Export: read one produced file's bytes | `GET /internal/v1/eval-harness/users/{userId}/chats/{chatId}/evidence/files?path=` |
+| Export: page the complete trajectory, oldest first | `GET /internal/v1/eval-harness/users/{userId}/chats/{chatId}/evidence/trajectory?afterSeq=&limit=` |
+| Import: write one evidence file into an Evaluator's own Space | `PUT /internal/v1/eval-harness/users/{userId}/chats/{chatId}/evidence/files?path=` |
+
+The initialization body includes the Data sample and, only when referenced by
+that sample, `initialSession: {bundleId, sessionId, context?: {format, content}}`
+and/or `initialMaterials: {bundleId, materialId, files}`. `content` is canonical
+Session JSON or JSONL; each material file supplies its path, media type and
+base64 bytes. Supplied Session context is imported into the Chat before the Prompt and only
+material files are written to SpaceDO. A sample may specify either source, both,
+or neither. There is no Dataset-level source binding.
+
+An Evaluator is an ordinary Eval Chat with its own Session, Submission and
+Space; its creation facts add only `evaluationId`. It never reads or writes the
+Subject's Space. Eval Platform exports a finished Subject's evidence through the
+read-only export routes and freezes it as a content-addressed bundle, then imports
+that bundle into the Evaluator's own Space under `/evidence` before the first
+Submission. Export routes answer only after the Chat's last Submission ended and
+its whole trajectory was delivered (409 before that). The artifact list covers
+files the Agent produced in its own Space, excluding `/reference`,
+`/initial-materials`, `/userspace`, `/evidence` and uploads; a single file crosses
+one Durable Object RPC, so files over 25 MB are refused with 413. Trajectory pages
+come straight from `trajectory_events` with a forward `afterSeq` cursor
+(`nextAfterSeq` is null after the last page). An import `PUT` carries the raw
+bytes, their `Content-Type` and `X-Eval-Content-Sha256: <hex>`; SP verifies the
+hash, writes `/evidence/<path>` and returns `{path, size, sha256}`. Only an
+Evaluator imports; an identical repeat is a no-op, different content is a 409,
+and imports stop with the Chat's stop latch.
+
+Eval Platform writes the Evaluator instructions into the Prompt; SP submits it
+unchanged. The Evaluator's `output` adds `structuredOutput: {path, content,
+contentHash}` with the raw UTF-8 text of `/output/result.json` in its own Space
+(at most 1 MB, `contentHash` is `sha256:<hex>`); it is omitted when the Evaluator
+wrote no result file.
+The Chat observer WebSocket carries status only. Browser Chat input and writes
+are rejected. SP API provides its account, Agent Config, and billing facts.
+The service-only stop route delegates to the ordinary Chat Submission lifecycle:
+it persists an Eval Chat stop latch, waits for already accepted submit calls,
+interrupts active work, and returns after terminal status is recorded. New
+initialization and Submission requests are rejected after the latch is saved,
+including after a DO restart.
+It refuses a Chat without an Eval binding. Repeating stop after all Submissions
+finish returns `{ "ok": false }` without changing history.

package/dist/index.d.ts

@@ -0,0 +1,180 @@
+import { z } from "zod";
+export declare const EVAL_SERVICE_HEADER = "X-Eval-Service-Token";
+export declare const EVAL_HARNESS_PATH = "/internal/v1/eval-harness";
+export declare const evalEnsureChatSchema: z.ZodObject<{
+    chatId: z.ZodUUID;
+    role: z.ZodEnum<{
+        evaluator: "evaluator";
+        subject: "subject";
+    }>;
+    framework: z.ZodLiteral<"sp">;
+    samplingId: z.ZodString;
+    projectId: z.ZodString;
+    agentConfig: z.ZodObject<{
+        ownerUserId: z.ZodUUID;
+        userAgentId: z.ZodUUID;
+    }, z.core.$strict>;
+    evaluationId: z.ZodOptional<z.ZodString>;
+    runtime: z.ZodOptional<z.ZodObject<{
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const evalMaterialFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    mediaType: z.ZodString;
+    contentBase64: z.ZodBase64;
+}, z.core.$strict>;
+export declare const evalInitialContextSchema: z.ZodObject<{
+    format: z.ZodEnum<{
+        json: "json";
+        jsonl: "jsonl";
+    }>;
+    content: z.ZodString;
+}, z.core.$strict>;
+export declare const evalInitializationSchema: z.ZodObject<{
+    idempotencyKey: z.ZodString;
+    data: z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodObject<{
+        userPrompt: z.ZodString;
+    }, z.core.$strip>>;
+    initialSession: z.ZodOptional<z.ZodObject<{
+        bundleId: z.ZodString;
+        sessionId: z.ZodString;
+        context: z.ZodOptional<z.ZodObject<{
+            format: z.ZodEnum<{
+                json: "json";
+                jsonl: "jsonl";
+            }>;
+            content: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    initialMaterials: z.ZodOptional<z.ZodObject<{
+        bundleId: z.ZodString;
+        materialId: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            mediaType: z.ZodString;
+            contentBase64: z.ZodBase64;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const evalSubmitSchema: z.ZodObject<{
+    idempotencyKey: z.ZodString;
+    prompt: z.ZodString;
+    unattended: z.ZodLiteral<true>;
+    runtime: z.ZodOptional<z.ZodObject<{
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type EvalEnsureChat = z.output<typeof evalEnsureChatSchema>;
+export type EvalInitialization = z.output<typeof evalInitializationSchema>;
+export type EvalSubmit = z.output<typeof evalSubmitSchema>;
+export type EvalSubmissionReceipt = {
+    readonly submissionId: string;
+    readonly status: string;
+    readonly normalizedStatus: "queued" | "running" | "completed" | "failed" | "interrupted" | "cancelled";
+    readonly accepted: boolean;
+    readonly error?: string;
+    readonly retryable?: boolean;
+    readonly createdAt: number;
+    readonly completedAt?: number;
+};
+export declare const evalBillingResourcesSchema: z.ZodObject<{
+    usageEvents: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    billingSettlements: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type EvalBillingResources = z.output<typeof evalBillingResourcesSchema>;
+export declare function projectEvalSubmission(input: {
+    readonly submissionId: string;
+    readonly status: string;
+    readonly accepted: boolean;
+    readonly error?: string;
+    readonly retryable?: boolean;
+    readonly createdAt: number;
+    readonly completedAt?: number;
+}): EvalSubmissionReceipt;
+export type EvalCanonicalContext = {
+    readonly entries: readonly {
+        readonly id: string;
+        readonly message: Readonly<Record<string, unknown>>;
+        readonly createdAt: number;
+    }[];
+};
+/** JSON stores one canonical snapshot; JSONL stores one canonical entry per line. */
+export declare function readEvalCanonicalContext(input: z.output<typeof evalInitialContextSchema>): EvalCanonicalContext;
+/** The one file an Evaluator writes its scored result to, in its own Space. */
+export declare const EVAL_RESULT_FILE = "result.json";
+export declare const EVAL_RESULT_PATH = "/output/result.json";
+export declare const EVAL_RESULT_MAX_BYTES = 1000000;
+/** The Evaluator result file exactly as written; Eval Platform parses and validates it. */
+export type EvalStructuredOutput = {
+    readonly path: string;
+    readonly content: string;
+    readonly contentHash: string;
+};
+/** Reads the result file as raw UTF-8 text; any byte order mark and formatting are kept. */
+export declare function readEvalStructuredOutput(path: string, bytes: Uint8Array): Promise<EvalStructuredOutput>;
+/** The `output` route body; an Evaluator's `structuredOutput` is omitted when it wrote no result file. */
+export type EvalEvidence = {
+    readonly status: "succeeded" | "failed";
+    readonly samplingId: string;
+    readonly evaluationId?: string;
+    readonly artifacts: readonly {
+        readonly artifactId: string;
+        readonly kind: string;
+        readonly path: string;
+    }[];
+    readonly trajectory: {
+        readonly trajectoryId: string;
+        readonly source: "subject" | "evaluator";
+        readonly path: string;
+    };
+    readonly structuredOutput?: EvalStructuredOutput;
+    readonly error?: string;
+};
+export declare function evalMaterialRoot(bundleId: string, materialId: string): string;
+export declare function evalMaterialPath(root: string, path: string): string;
+/** Where imported evidence lives in the Evaluator's own Space. */
+export declare const EVAL_EVIDENCE_ROOT = "/evidence";
+/** One exported or imported file crosses a single Durable Object RPC as bytes. */
+export declare const EVAL_EVIDENCE_FILE_MAX_BYTES = 25000000;
+export declare const EVAL_EVIDENCE_TRAJECTORY_PAGE_MAX = 200;
+export declare const EVAL_EVIDENCE_SHA256_HEADER = "X-Eval-Content-Sha256";
+/** One Subject artifact; its bytes are read separately so the inventory stays small. */
+export declare const evalEvidenceArtifactSchema: z.ZodObject<{
+    path: z.ZodString;
+    size: z.ZodNumber;
+    mediaType: z.ZodString;
+}, z.core.$strict>;
+export type EvalEvidenceArtifact = z.output<typeof evalEvidenceArtifactSchema>;
+export declare const evalEvidenceArtifactsSchema: z.ZodObject<{
+    artifacts: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        size: z.ZodNumber;
+        mediaType: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type EvalEvidenceArtifacts = z.output<typeof evalEvidenceArtifactsSchema>;
+/** Forward pages of the Chat's complete `trajectory_events`, oldest first. */
+export type EvalEvidenceTrajectoryPage = {
+    readonly events: readonly {
+        readonly ingestSeq: number;
+        readonly event: object;
+    }[];
+    /** Pass as `afterSeq` for the next page; null once the last event was returned. */
+    readonly nextAfterSeq: number | null;
+};
+export declare function readEvalTrajectoryPageQuery(params: URLSearchParams): {
+    afterSeq: number;
+    limit: number;
+};
+/** A Space path for one evidence file; `relative` keeps the bundle's own layout below `/evidence`. */
+export declare function evalEvidencePath(relative: string): string;
+/** The receipt for one imported file; identical repeats return the same receipt. */
+export type EvalEvidenceFileReceipt = {
+    readonly path: string;
+    readonly size: number;
+    readonly sha256: string;
+};
+export declare function isEvalSha256(value: string | null): value is string;
+/** Compare creation and operation facts without depending on JSON property order. */
+export declare function stableEvalFacts(value: unknown): string;

package/dist/index.js

@@ -0,0 +1,196 @@
+import { z } from "zod";
+export const EVAL_SERVICE_HEADER = "X-Eval-Service-Token";
+export const EVAL_HARNESS_PATH = "/internal/v1/eval-harness";
+const id = z.string().trim().min(1);
+const uuid = z.uuid();
+export const evalEnsureChatSchema = z.strictObject({
+    chatId: uuid,
+    role: z.enum(["subject", "evaluator"]),
+    framework: z.literal("sp"),
+    samplingId: id,
+    projectId: id,
+    agentConfig: z.strictObject({ ownerUserId: uuid, userAgentId: uuid }),
+    /** Only an Evaluator carries it; the Evaluator still owns an ordinary Chat and its own Space. */
+    evaluationId: id.optional(),
+    runtime: z.strictObject({ timeoutMs: z.number().finite().positive().optional() }).optional(),
+}).superRefine((value, context) => {
+    if ((value.role === "evaluator") !== (value.evaluationId !== undefined)) {
+        context.addIssue({ code: "custom", path: ["evaluationId"], message: "Evaluation ID must match role" });
+    }
+});
+export const evalMaterialFileSchema = z.strictObject({
+    path: z.string().startsWith("/").min(2),
+    mediaType: id,
+    contentBase64: z.base64(),
+});
+export const evalInitialContextSchema = z.strictObject({
+    format: z.enum(["json", "jsonl"]),
+    content: z.string().min(1),
+});
+export const evalInitializationSchema = z.strictObject({
+    idempotencyKey: id,
+    data: z.record(z.string(), z.unknown()).and(z.object({ userPrompt: z.string().trim().min(1) })),
+    initialSession: z.strictObject({
+        bundleId: id,
+        sessionId: id,
+        context: evalInitialContextSchema.optional(),
+    }).optional(),
+    initialMaterials: z.strictObject({
+        bundleId: id,
+        materialId: id,
+        files: z.array(evalMaterialFileSchema).max(500),
+    }).optional(),
+}).superRefine((value, context) => {
+    const session = value.data.initialSession;
+    const materials = value.data.initialMaterials;
+    if (session ? !value.initialSession || session.bundleId !== value.initialSession.bundleId ||
+        session.sessionId !== value.initialSession.sessionId : value.initialSession !== undefined) {
+        context.addIssue({ code: "custom", path: ["initialSession"], message: "Session content must match the Data reference" });
+    }
+    if (materials ? !value.initialMaterials || materials.bundleId !== value.initialMaterials.bundleId ||
+        materials.materialId !== value.initialMaterials.materialId : value.initialMaterials !== undefined) {
+        context.addIssue({ code: "custom", path: ["initialMaterials"], message: "Material content must match the Data reference" });
+    }
+});
+export const evalSubmitSchema = z.strictObject({
+    idempotencyKey: id,
+    prompt: z.string().trim().min(1),
+    unattended: z.literal(true),
+    runtime: z.strictObject({ timeoutMs: z.number().finite().positive().optional() }).optional(),
+});
+export const evalBillingResourcesSchema = z.strictObject({
+    usageEvents: z.array(z.record(z.string(), z.unknown())),
+    billingSettlements: z.array(z.record(z.string(), z.unknown())),
+});
+export function projectEvalSubmission(input) {
+    const normalizedStatus = {
+        pending: "queued",
+        running: "running",
+        completed: "completed",
+        error: "failed",
+        skipped: "failed",
+        aborted: "interrupted",
+    }[input.status];
+    if (!normalizedStatus)
+        throw new Error("Unknown SP Submission status");
+    return { ...input, normalizedStatus: normalizedStatus };
+}
+/** JSON stores one canonical snapshot; JSONL stores one canonical entry per line. */
+export function readEvalCanonicalContext(input) {
+    if (input.content.length > 2_000_000)
+        throw new Error("Initial context is too large");
+    const parsed = input.format === "json"
+        ? JSON.parse(input.content)
+        : { entries: input.content.split(/\r?\n/u).filter((line) => line.trim()).map((line) => JSON.parse(line)) };
+    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.entries)) {
+        throw new Error("Initial context must contain canonical entries");
+    }
+    const entries = parsed.entries;
+    if (entries.length > 10_000)
+        throw new Error("Initial context has too many entries");
+    const seen = new Set();
+    for (const entry of entries) {
+        if (!entry || typeof entry !== "object")
+            throw new Error("Invalid canonical context entry");
+        const row = entry;
+        if (typeof row.id !== "string" || !row.id || seen.has(row.id) ||
+            !Number.isSafeInteger(row.createdAt) || Number(row.createdAt) < 0 ||
+            !row.message || typeof row.message !== "object" || Array.isArray(row.message) ||
+            !["user", "assistant", "toolResult"].includes(row.message.role ?? "")) {
+            throw new Error("Invalid or duplicate canonical context entry");
+        }
+        seen.add(row.id);
+    }
+    if (entries.length > 0 && entries[0].message.role !== "user") {
+        throw new Error("Initial context must begin with a user message");
+    }
+    return { entries: entries };
+}
+/** The one file an Evaluator writes its scored result to, in its own Space. */
+export const EVAL_RESULT_FILE = "result.json";
+export const EVAL_RESULT_PATH = `/output/${EVAL_RESULT_FILE}`;
+export const EVAL_RESULT_MAX_BYTES = 1_000_000;
+/** Reads the result file as raw UTF-8 text; any byte order mark and formatting are kept. */
+export async function readEvalStructuredOutput(path, bytes) {
+    if (bytes.byteLength > EVAL_RESULT_MAX_BYTES)
+        throw new Error(`${EVAL_RESULT_FILE} exceeds ${EVAL_RESULT_MAX_BYTES} bytes`);
+    let content;
+    try {
+        content = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        throw new Error(`${EVAL_RESULT_FILE} is not valid UTF-8`);
+    }
+    const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new Uint8Array(bytes)));
+    const contentHash = `sha256:${[...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+    return { path, content, contentHash };
+}
+export function evalMaterialRoot(bundleId, materialId) {
+    return `/initial-materials/${encodeURIComponent(bundleId)}/${encodeURIComponent(materialId)}`;
+}
+/** Absolute paths below a root; `.`/`..`, `.git`, backslashes and NUL never reach the Space. */
+function evalPathParts(path) {
+    const parts = path.split("/").slice(1);
+    if (!path.startsWith("/") || parts.length === 0 || parts.some((part) => !part || part === "." || part === ".." || part === ".git" || part.includes("\\") || part.includes("\0"))) {
+        return null;
+    }
+    return parts;
+}
+export function evalMaterialPath(root, path) {
+    const parts = evalPathParts(path);
+    if (!parts)
+        throw new Error("Invalid initial material path");
+    return `${root}/${parts.join("/")}`;
+}
+/*
+ * Evidence: a Subject's artifacts and complete trajectory are exported once, then imported into
+ * the Evaluator's own Space under `/evidence`. Neither Chat ever reads the other's Space.
+ */
+/** Where imported evidence lives in the Evaluator's own Space. */
+export const EVAL_EVIDENCE_ROOT = "/evidence";
+/** One exported or imported file crosses a single Durable Object RPC as bytes. */
+export const EVAL_EVIDENCE_FILE_MAX_BYTES = 25_000_000;
+export const EVAL_EVIDENCE_TRAJECTORY_PAGE_MAX = 200;
+export const EVAL_EVIDENCE_SHA256_HEADER = "X-Eval-Content-Sha256";
+/** One Subject artifact; its bytes are read separately so the inventory stays small. */
+export const evalEvidenceArtifactSchema = z.strictObject({
+    path: z.string().startsWith("/").min(2),
+    size: z.number().int().nonnegative(),
+    mediaType: id,
+});
+export const evalEvidenceArtifactsSchema = z.strictObject({
+    artifacts: z.array(evalEvidenceArtifactSchema),
+});
+export function readEvalTrajectoryPageQuery(params) {
+    const afterSeq = Number(params.get("afterSeq") ?? "0");
+    const limit = Number(params.get("limit") ?? String(EVAL_EVIDENCE_TRAJECTORY_PAGE_MAX));
+    if (!Number.isSafeInteger(afterSeq) || afterSeq < 0 ||
+        !Number.isSafeInteger(limit) || limit < 1 || limit > EVAL_EVIDENCE_TRAJECTORY_PAGE_MAX) {
+        throw new Error("Invalid trajectory page");
+    }
+    return { afterSeq, limit };
+}
+/** A Space path for one evidence file; `relative` keeps the bundle's own layout below `/evidence`. */
+export function evalEvidencePath(relative) {
+    const parts = evalPathParts(relative);
+    if (!parts)
+        throw new Error("Invalid evidence path");
+    return `${EVAL_EVIDENCE_ROOT}/${parts.join("/")}`;
+}
+export function isEvalSha256(value) {
+    return value !== null && /^[0-9a-f]{64}$/u.test(value);
+}
+/** Compare creation and operation facts without depending on JSON property order. */
+export function stableEvalFacts(value) {
+    return JSON.stringify(sortFacts(value));
+}
+function sortFacts(value) {
+    if (Array.isArray(value))
+        return value.map(sortFacts);
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .filter(([, item]) => item !== undefined)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => [key, sortFacts(item)]));
+}

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "@springbrand/eval-harness",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0-alpha.0",
+  "description": "SP service contract for Eval-managed Chats: routes, headers and wire schemas.",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  },
+  "dependencies": {
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "scripts": {
+    "build": "tsc --noEmit",
+    "check": "tsc --noEmit",
+    "test": "vitest run",
+    "build:dist": "rm -rf dist && tsc -p tsconfig.build.json"
+  }
 }