@termwright/protocol 0.2.0 → 0.3.0

package/dist/run-events.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Browser-safe identity and event envelope for one Termwright invocation.
+ *
+ * These identifiers describe orchestration, not framework semantics.  Every
+ * kind has a distinct wire prefix, so an execution id can never be accepted as
+ * an attempt id merely because both happen to contain the same random bits.
+ */
+declare const RUN_ID_KINDS: readonly ["invocation", "run", "project", "shard", "spec", "runner-task", "execution", "attempt", "session", "step", "action", "producer", "event"];
+type RunIdKind = (typeof RUN_ID_KINDS)[number];
+declare const runIdBrand: unique symbol;
+type BrandedRunId<Kind extends RunIdKind> = string & {
+    readonly [runIdBrand]: Kind;
+};
+type InvocationId = BrandedRunId<'invocation'>;
+type RunId = BrandedRunId<'run'>;
+type ProjectId = BrandedRunId<'project'>;
+type ShardId = BrandedRunId<'shard'>;
+type SpecId = BrandedRunId<'spec'>;
+type RunnerTaskId = BrandedRunId<'runner-task'>;
+type ExecutionId = BrandedRunId<'execution'>;
+type AttemptId = BrandedRunId<'attempt'>;
+type SessionId = BrandedRunId<'session'>;
+type StepId = BrandedRunId<'step'>;
+type ActionId = BrandedRunId<'action'>;
+type RunEventProducerId = BrandedRunId<'producer'>;
+type RunEventId = BrandedRunId<'event'>;
+interface RunIdByKind {
+    readonly invocation: InvocationId;
+    readonly run: RunId;
+    readonly project: ProjectId;
+    readonly shard: ShardId;
+    readonly spec: SpecId;
+    readonly 'runner-task': RunnerTaskId;
+    readonly execution: ExecutionId;
+    readonly attempt: AttemptId;
+    readonly session: SessionId;
+    readonly step: StepId;
+    readonly action: ActionId;
+    readonly producer: RunEventProducerId;
+    readonly event: RunEventId;
+}
+/** Validate and brand an id received from an untrusted or persisted source. */
+declare function parseRunId<Kind extends RunIdKind>(kind: Kind, value: unknown): RunIdByKind[Kind];
+/**
+ * Mint a collision-resistant, kind-separated id without importing Node APIs.
+ * `randomUUID` is injectable for deterministic tests and embedded runtimes.
+ */
+declare function createRunId<Kind extends RunIdKind>(kind: Kind, randomUUID?: () => string): RunIdByKind[Kind];
+/** Scoped issuer that detects a broken randomness source before ids escape. */
+declare class RunIdFactory {
+    #private;
+    constructor(randomUUID?: () => string);
+    create<Kind extends RunIdKind>(kind: Kind): RunIdByKind[Kind];
+}
+declare const RUN_EVENT_CLASSES: readonly ["authoritative", "state", "diagnostic"];
+type RunEventClass = (typeof RUN_EVENT_CLASSES)[number];
+declare const RUN_EVENT_VERSION: 2;
+type RunEventJson = null | boolean | number | string | readonly RunEventJson[] | {
+    readonly [key: string]: RunEventJson;
+};
+/** Hierarchical identity carried by every event. */
+interface RunEventIdentity {
+    readonly invocationId: InvocationId;
+    readonly runId?: RunId;
+    readonly projectId?: ProjectId;
+    readonly shardId?: ShardId;
+    readonly specId?: SpecId;
+    readonly runnerTaskId?: RunnerTaskId;
+    readonly executionId?: ExecutionId;
+    readonly attemptId?: AttemptId;
+    readonly sessionId?: SessionId;
+    readonly stepId?: StepId;
+    readonly actionId?: ActionId;
+}
+/** Version 2 is the only accepted event shape; there is no legacy envelope. */
+interface RunEvent<Type extends string = string, Payload extends RunEventJson = RunEventJson> {
+    readonly v: typeof RUN_EVENT_VERSION;
+    readonly eventId: RunEventId;
+    readonly producerId: RunEventProducerId;
+    /** Producer incarnation. A restarted producer increments this value. */
+    readonly epoch: number;
+    /** Strictly increasing within one producer incarnation. */
+    readonly seq: number;
+    readonly eventClass: RunEventClass;
+    readonly type: Type;
+    /** Milliseconds from the producer's monotonic clock. */
+    readonly monotonicTime: number;
+    /** Optional Unix epoch milliseconds, for human correlation only. */
+    readonly wallTime?: number;
+    readonly identity: RunEventIdentity;
+    readonly causedBy?: readonly RunEventId[];
+    readonly payload: Payload;
+}
+interface RunEventLimits {
+    readonly maxEventBytes: number;
+    readonly maxPayloadDepth: number;
+    readonly maxPayloadEntries: number;
+    readonly maxStringBytes: number;
+    readonly maxCauses: number;
+}
+declare const DEFAULT_RUN_EVENT_LIMITS: RunEventLimits;
+type RunEventViolationCode = 'invalid-envelope' | 'invalid-id' | 'invalid-identity' | 'invalid-payload' | 'event-oversized' | 'event-collision' | 'epoch-regression' | 'sequence-regression' | 'monotonic-time-regression' | 'causal-cycle';
+type RunEventValidationResult = {
+    readonly ok: true;
+    readonly value: RunEvent;
+} | {
+    readonly ok: false;
+    readonly code: RunEventViolationCode;
+    readonly detail: string;
+};
+interface CreateRunEventInput<Type extends string, Payload extends RunEventJson> {
+    readonly eventId?: RunEventId;
+    readonly producerId: RunEventProducerId;
+    readonly epoch: number;
+    readonly seq: number;
+    readonly eventClass: RunEventClass;
+    readonly type: Type;
+    readonly monotonicTime: number;
+    readonly wallTime?: number;
+    readonly identity: RunEventIdentity;
+    readonly causedBy?: readonly RunEventId[];
+    readonly payload: Payload;
+    readonly randomUUID?: () => string;
+}
+interface ProduceRunEventInput<Type extends string, Payload extends RunEventJson> {
+    readonly eventClass: RunEventClass;
+    readonly type: Type;
+    readonly identity: RunEventIdentity;
+    readonly causedBy?: readonly RunEventId[];
+    readonly payload: Payload;
+}
+/**
+ * Producer-side constructor owning epoch, sequence, event ids and clock.
+ * Callers therefore cannot accidentally reuse a journal coordinate.
+ */
+declare class RunEventProducer {
+    #private;
+    constructor(options: {
+        readonly producerId: RunEventProducerId;
+        readonly epoch: number;
+        readonly randomUUID?: () => string;
+        readonly monotonicNow?: () => number;
+        readonly wallNow?: () => number;
+    });
+    emit<Type extends string, Payload extends RunEventJson>(input: ProduceRunEventInput<Type, Payload>, limits?: RunEventLimits): RunEvent<Type, Payload>;
+}
+/** Construct and validate one deeply immutable envelope. */
+declare function createRunEvent<Type extends string, Payload extends RunEventJson>(input: CreateRunEventInput<Type, Payload>, limits?: RunEventLimits): RunEvent<Type, Payload>;
+/** Validate, copy and deeply freeze a single untrusted event. */
+declare function validateRunEvent(value: unknown, limits?: RunEventLimits): RunEventValidationResult;
+/** Stateful collision, ordering and causal-DAG validator for merged streams. */
+declare class RunEventStreamValidator {
+    #private;
+    constructor(limits?: RunEventLimits);
+    accept(value: unknown): RunEventValidationResult;
+}
+
+export { type ActionId, type AttemptId, type CreateRunEventInput, DEFAULT_RUN_EVENT_LIMITS, type ExecutionId, type InvocationId, type ProduceRunEventInput, type ProjectId, RUN_EVENT_CLASSES, RUN_EVENT_VERSION, RUN_ID_KINDS, type RunEvent, type RunEventClass, type RunEventId, type RunEventIdentity, type RunEventJson, type RunEventLimits, RunEventProducer, type RunEventProducerId, RunEventStreamValidator, type RunEventValidationResult, type RunEventViolationCode, type RunId, type RunIdByKind, RunIdFactory, type RunIdKind, type RunnerTaskId, type SessionId, type ShardId, type SpecId, type StepId, createRunEvent, createRunId, parseRunId, validateRunEvent };

package/dist/run-events.js

@@ -0,0 +1,27 @@
+import {
+  DEFAULT_RUN_EVENT_LIMITS,
+  RUN_EVENT_CLASSES,
+  RUN_EVENT_VERSION,
+  RUN_ID_KINDS,
+  RunEventProducer,
+  RunEventStreamValidator,
+  RunIdFactory,
+  createRunEvent,
+  createRunId,
+  parseRunId,
+  validateRunEvent
+} from "./chunk-CZK6NNP3.js";
+export {
+  DEFAULT_RUN_EVENT_LIMITS,
+  RUN_EVENT_CLASSES,
+  RUN_EVENT_VERSION,
+  RUN_ID_KINDS,
+  RunEventProducer,
+  RunEventStreamValidator,
+  RunIdFactory,
+  createRunEvent,
+  createRunId,
+  parseRunId,
+  validateRunEvent
+};
+//# sourceMappingURL=run-events.js.map

package/dist/run-events.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/run-journal.d.ts

@@ -0,0 +1,55 @@
+import { InvocationId, RunId, RunEventProducer, RunEventValidationResult, RunEvent } from './run-events.js';
+
+interface RunEventJournalLimits {
+    /** Lossless events are rejected with backpressure at this pending count. */
+    readonly maxAuthoritativeEvents: number;
+    /** Distinct coalescing keys pending between flushes. */
+    readonly maxStateKeys: number;
+    /** Diagnostic events retained; evictions produce an explicit gap event. */
+    readonly maxDiagnosticEvents: number;
+}
+declare const DEFAULT_RUN_EVENT_JOURNAL_LIMITS: RunEventJournalLimits;
+interface RunEventFlushBarrier {
+    readonly token: number;
+    readonly highWaterMark: number;
+}
+type RunEventJournalViolationCode = Extract<RunEventValidationResult, {
+    readonly ok: false;
+}>['code'] | 'stale-run' | 'journal-full' | 'state-key-required' | 'invalid-barrier';
+type RunEventJournalAppendResult = {
+    readonly ok: true;
+    readonly ordinal: number;
+} | {
+    readonly ok: false;
+    readonly code: RunEventJournalViolationCode;
+    readonly detail: string;
+};
+/**
+ * In-memory ordering core used by the first-class Termwright test host.
+ *
+ * Authoritative events are never dropped. State coalescing is explicit and is
+ * stopped by every barrier. Diagnostics are bounded, and every eviction is
+ * represented by a lossless synthetic `journal.diagnostic-gap` event.
+ */
+declare class RunEventJournal {
+    #private;
+    constructor(options: {
+        readonly invocationId: InvocationId;
+        readonly runId: RunId;
+        readonly gapProducer: RunEventProducer;
+        readonly limits?: RunEventJournalLimits;
+    });
+    append(value: unknown, options?: {
+        readonly stateKey?: string;
+    }): RunEventJournalAppendResult;
+    /** Seals current coalescing and diagnostic-gap groups. */
+    barrier(): RunEventFlushBarrier;
+    /**
+     * Deliver everything through the barrier and remove it only after the sink
+     * succeeds. A rejected sink leaves the exact batch available for retry.
+     */
+    flushThrough(barrier: RunEventFlushBarrier, sink: (events: readonly RunEvent[]) => void | Promise<void>): Promise<readonly RunEvent[]>;
+    get pending(): number;
+}
+
+export { DEFAULT_RUN_EVENT_JOURNAL_LIMITS, type RunEventFlushBarrier, RunEventJournal, type RunEventJournalAppendResult, type RunEventJournalLimits, type RunEventJournalViolationCode };

package/dist/run-journal.js

@@ -0,0 +1,10 @@
+import {
+  DEFAULT_RUN_EVENT_JOURNAL_LIMITS,
+  RunEventJournal
+} from "./chunk-ZZIYHDJ4.js";
+import "./chunk-CZK6NNP3.js";
+export {
+  DEFAULT_RUN_EVENT_JOURNAL_LIMITS,
+  RunEventJournal
+};
+//# sourceMappingURL=run-journal.js.map

package/dist/run-journal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/run-state.d.ts

@@ -0,0 +1,38 @@
+/** Closed first-class lifecycle vocabulary for a Termwright run. */
+declare const RUN_STATES: readonly ["requested", "collecting", "scheduled", "running", "cancelling", "finalizing", "passed", "passed-with-skips", "failed", "skipped", "cancelled", "infrastructure-failed", "crashed", "incomplete", "flaky"];
+type RunState = (typeof RUN_STATES)[number];
+declare const TERMINAL_RUN_STATES: readonly ["passed", "passed-with-skips", "failed", "skipped", "cancelled", "infrastructure-failed", "crashed", "incomplete", "flaky"];
+type TerminalRunState = (typeof TERMINAL_RUN_STATES)[number];
+/** Executable transition graph; consumers must not duplicate this table. */
+declare const RUN_STATE_TRANSITIONS: Readonly<{
+    readonly requested: readonly ["collecting", "cancelling", "infrastructure-failed"];
+    readonly collecting: readonly ["scheduled", "cancelling", "infrastructure-failed", "incomplete"];
+    readonly scheduled: readonly ["running", "cancelling", "finalizing", "infrastructure-failed", "incomplete"];
+    readonly running: readonly ["cancelling", "finalizing", "infrastructure-failed", "crashed", "incomplete"];
+    readonly cancelling: readonly ["finalizing", "cancelled", "infrastructure-failed", "incomplete"];
+    readonly finalizing: readonly ["passed", "passed-with-skips", "failed", "skipped", "cancelled", "infrastructure-failed", "crashed", "incomplete", "flaky"];
+    readonly passed: readonly [];
+    readonly 'passed-with-skips': readonly [];
+    readonly failed: readonly [];
+    readonly skipped: readonly [];
+    readonly cancelled: readonly [];
+    readonly 'infrastructure-failed': readonly [];
+    readonly crashed: readonly [];
+    readonly incomplete: readonly [];
+    readonly flaky: readonly [];
+}>;
+declare function isRunState(value: unknown): value is RunState;
+declare function isTerminalRunState(value: RunState): value is TerminalRunState;
+declare function canTransitionRunState(from: RunState, to: RunState): boolean;
+type RunStateTransitionResult = {
+    readonly ok: true;
+    readonly from: RunState;
+    readonly to: RunState;
+} | {
+    readonly ok: false;
+    readonly code: 'invalid-run-state' | 'illegal-run-transition';
+    readonly detail: string;
+};
+declare function validateRunStateTransition(from: unknown, to: unknown): RunStateTransitionResult;
+
+export { RUN_STATES, RUN_STATE_TRANSITIONS, type RunState, type RunStateTransitionResult, TERMINAL_RUN_STATES, type TerminalRunState, canTransitionRunState, isRunState, isTerminalRunState, validateRunStateTransition };

package/dist/run-state.js

@@ -0,0 +1,19 @@
+import {
+  RUN_STATES,
+  RUN_STATE_TRANSITIONS,
+  TERMINAL_RUN_STATES,
+  canTransitionRunState,
+  isRunState,
+  isTerminalRunState,
+  validateRunStateTransition
+} from "./chunk-ODOJRXL6.js";
+export {
+  RUN_STATES,
+  RUN_STATE_TRANSITIONS,
+  TERMINAL_RUN_STATES,
+  canTransitionRunState,
+  isRunState,
+  isTerminalRunState,
+  validateRunStateTransition
+};
+//# sourceMappingURL=run-state.js.map

package/dist/run-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/test-provider.d.ts

@@ -0,0 +1,22 @@
+/** Versioned declaration metadata shared by test providers and the native host. */
+declare const TERMWRIGHT_PROVIDER_VERSION: 1;
+interface TermwrightProviderMarker {
+    readonly id: string;
+    readonly version: typeof TERMWRIGHT_PROVIDER_VERSION;
+}
+type TermwrightProviderDeclaredMode = 'run' | 'skip' | 'todo';
+interface TermwrightProviderDeclaration {
+    readonly mode: TermwrightProviderDeclaredMode;
+    readonly exclusive: boolean;
+}
+interface TermwrightProviderTaskMeta {
+    readonly termwright?: {
+        readonly provider?: unknown;
+        readonly declaration?: unknown;
+    };
+}
+declare function termwrightProvider(id: string): TermwrightProviderMarker;
+declare function hasTermwrightProvider(meta: unknown): meta is TermwrightProviderTaskMeta;
+declare function termwrightProviderDeclaration(meta: unknown): TermwrightProviderDeclaration | undefined;
+
+export { TERMWRIGHT_PROVIDER_VERSION, type TermwrightProviderDeclaration, type TermwrightProviderDeclaredMode, type TermwrightProviderMarker, type TermwrightProviderTaskMeta, hasTermwrightProvider, termwrightProvider, termwrightProviderDeclaration };

package/dist/test-provider.js

@@ -0,0 +1,32 @@
+// src/test-provider.ts
+var TERMWRIGHT_PROVIDER_VERSION = 1;
+function termwrightProvider(id) {
+  if (id === "") throw new TypeError("a Termwright provider id cannot be empty");
+  return { id, version: TERMWRIGHT_PROVIDER_VERSION };
+}
+function hasTermwrightProvider(meta) {
+  if (typeof meta !== "object" || meta === null) return false;
+  const termwright = meta["termwright"];
+  if (typeof termwright !== "object" || termwright === null) return false;
+  const provider = termwright["provider"];
+  if (typeof provider !== "object" || provider === null) return false;
+  const record = provider;
+  return record["version"] === TERMWRIGHT_PROVIDER_VERSION && typeof record["id"] === "string" && record["id"] !== "";
+}
+function termwrightProviderDeclaration(meta) {
+  if (!hasTermwrightProvider(meta)) return void 0;
+  const declaration = meta.termwright?.declaration;
+  if (typeof declaration !== "object" || declaration === null) return void 0;
+  const record = declaration;
+  const mode = record["mode"];
+  if (mode !== "run" && mode !== "skip" && mode !== "todo") return void 0;
+  if (typeof record["exclusive"] !== "boolean") return void 0;
+  return { mode, exclusive: record["exclusive"] };
+}
+export {
+  TERMWRIGHT_PROVIDER_VERSION,
+  hasTermwrightProvider,
+  termwrightProvider,
+  termwrightProviderDeclaration
+};
+//# sourceMappingURL=test-provider.js.map

package/dist/test-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/test-provider.ts"],"sourcesContent":["/** Versioned declaration metadata shared by test providers and the native host. */\n\nexport const TERMWRIGHT_PROVIDER_VERSION = 1 as const;\n\nexport interface TermwrightProviderMarker {\n  readonly id: string;\n  readonly version: typeof TERMWRIGHT_PROVIDER_VERSION;\n}\n\nexport type TermwrightProviderDeclaredMode = 'run' | 'skip' | 'todo';\n\nexport interface TermwrightProviderDeclaration {\n  readonly mode: TermwrightProviderDeclaredMode;\n  readonly exclusive: boolean;\n}\n\nexport interface TermwrightProviderTaskMeta {\n  readonly termwright?: {\n    readonly provider?: unknown;\n    readonly declaration?: unknown;\n  };\n}\n\nexport function termwrightProvider(id: string): TermwrightProviderMarker {\n  if (id === '') throw new TypeError('a Termwright provider id cannot be empty');\n  return { id, version: TERMWRIGHT_PROVIDER_VERSION };\n}\n\nexport function hasTermwrightProvider(meta: unknown): meta is TermwrightProviderTaskMeta {\n  if (typeof meta !== 'object' || meta === null) return false;\n  const termwright = (meta as Record<string, unknown>)['termwright'];\n  if (typeof termwright !== 'object' || termwright === null) return false;\n  const provider = (termwright as Record<string, unknown>)['provider'];\n  if (typeof provider !== 'object' || provider === null) return false;\n  const record = provider as Record<string, unknown>;\n  return (\n    record['version'] === TERMWRIGHT_PROVIDER_VERSION &&\n    typeof record['id'] === 'string' &&\n    record['id'] !== ''\n  );\n}\n\nexport function termwrightProviderDeclaration(\n  meta: unknown,\n): TermwrightProviderDeclaration | undefined {\n  if (!hasTermwrightProvider(meta)) return undefined;\n  const declaration = meta.termwright?.declaration;\n  if (typeof declaration !== 'object' || declaration === null) return undefined;\n  const record = declaration as Record<string, unknown>;\n  const mode = record['mode'];\n  if (mode !== 'run' && mode !== 'skip' && mode !== 'todo') return undefined;\n  if (typeof record['exclusive'] !== 'boolean') return undefined;\n  return { mode, exclusive: record['exclusive'] };\n}\n"],"mappings":";AAEO,IAAM,8BAA8B;AAqBpC,SAAS,mBAAmB,IAAsC;AACvE,MAAI,OAAO,GAAI,OAAM,IAAI,UAAU,0CAA0C;AAC7E,SAAO,EAAE,IAAI,SAAS,4BAA4B;AACpD;AAEO,SAAS,sBAAsB,MAAmD;AACvF,MAAI,OAAO,SAAS,YAAY,SAAS,KAAM,QAAO;AACtD,QAAM,aAAc,KAAiC,YAAY;AACjE,MAAI,OAAO,eAAe,YAAY,eAAe,KAAM,QAAO;AAClE,QAAM,WAAY,WAAuC,UAAU;AACnE,MAAI,OAAO,aAAa,YAAY,aAAa,KAAM,QAAO;AAC9D,QAAM,SAAS;AACf,SACE,OAAO,SAAS,MAAM,+BACtB,OAAO,OAAO,IAAI,MAAM,YACxB,OAAO,IAAI,MAAM;AAErB;AAEO,SAAS,8BACd,MAC2C;AAC3C,MAAI,CAAC,sBAAsB,IAAI,EAAG,QAAO;AACzC,QAAM,cAAc,KAAK,YAAY;AACrC,MAAI,OAAO,gBAAgB,YAAY,gBAAgB,KAAM,QAAO;AACpE,QAAM,SAAS;AACf,QAAM,OAAO,OAAO,MAAM;AAC1B,MAAI,SAAS,SAAS,SAAS,UAAU,SAAS,OAAQ,QAAO;AACjE,MAAI,OAAO,OAAO,WAAW,MAAM,UAAW,QAAO;AACrD,SAAO,EAAE,MAAM,WAAW,OAAO,WAAW,EAAE;AAChD;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@termwright/protocol",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "termwright semantic protocol: schemas, limits, roles, framing, handshake",
   "license": "MIT",
   "repository": {
@@ -10,12 +10,40 @@
   },
   "type": "module",
   "engines": {
-    "node": ">=22"
+    "node": "^22.0.0 || ^24.0.0"
   },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./contract": {
+      "types": "./dist/contract.d.ts",
+      "import": "./dist/contract.js"
+    },
+    "./capability-graph": {
+      "types": "./dist/capability-graph.d.ts",
+      "import": "./dist/capability-graph.js"
+    },
+    "./action-model": {
+      "types": "./dist/action-model.d.ts",
+      "import": "./dist/action-model.js"
+    },
+    "./run-events": {
+      "types": "./dist/run-events.d.ts",
+      "import": "./dist/run-events.js"
+    },
+    "./run-journal": {
+      "types": "./dist/run-journal.d.ts",
+      "import": "./dist/run-journal.js"
+    },
+    "./run-state": {
+      "types": "./dist/run-state.d.ts",
+      "import": "./dist/run-state.js"
+    },
+    "./test-provider": {
+      "types": "./dist/test-provider.d.ts",
+      "import": "./dist/test-provider.js"
     }
   },
   "files": [
@@ -25,9 +53,9 @@
     "zod": "^4.0.0"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --sourcemap",
+    "build": "tsup src/index.ts src/contract.ts src/capability-graph.ts src/action-model.ts src/run-events.ts src/run-journal.ts src/run-state.ts src/test-provider.ts --format esm --dts --sourcemap --clean",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:hostile": "vitest run --config vitest.hostile.config.ts"
+    "test": "pnpm --dir ../.. test -- -- --run packages/protocol",
+    "test:hostile": "pnpm --dir ../.. test -- -- --run packages/protocol"
   }
 }