@akterjs/conformance 0.0.0-stage → 0.1.0

package/dist/workbench/workbench-calls.pure.d.mts

@@ -0,0 +1,45 @@
+import { Host, Unexpected } from "../ledger/ledger-calls.pure.mjs";
+import { ComputerOp } from "./workbench.contract.mjs";
+import { Effect } from "effect";
+/** The Workbench the computer guarantees run on, whose key every engine under test serves. */
+declare const bench = "bench-1";
+/**
+ * The key a fork of `bench` goes into. Akter Cloud forks only into a key on the parent's own shard, and `bench-250`
+ * hashes to `bench-1`'s shard there.
+ */
+declare const forkedBench = "bench-250";
+declare const ensure: (computer: string) => ComputerOp;
+declare const get: (computer: string) => ComputerOp;
+declare const remove: (computer: string) => ComputerOp;
+declare const stop: (computer: string) => ComputerOp;
+declare const list: ComputerOp;
+/** Starts the calls in one `run` job on the Workbench at `key` and answers the job's id. */
+declare const startedRun: (host: Host, { commandId, key, ops }: {
+  readonly commandId: string;
+  readonly key: string;
+  readonly ops: readonly ComputerOp[];
+}) => Effect.Effect<string, Unexpected>;
+declare const unfinished = "the job had not finished";
+/** What each call of a job answered, once its result has reached the actor. */
+declare const outcomesOf: (host: Host, key: string, job: string) => Effect.Effect<readonly string[], Unexpected>;
+/**
+ * Runs the calls in one `run` job on the Workbench at `key` and answers what each returned, once the job's result has
+ * reached the actor. A call is one activity, so `run` with the same command id after a restart answers the same job.
+ */
+declare const ranAt: (host: Host, key: string, { commandId, ops }: {
+  readonly commandId: string;
+  readonly ops: readonly ComputerOp[];
+}) => Effect.Effect<readonly string[], Unexpected>;
+/** Runs the calls in one `run` job on the suite's Workbench, `bench`, as `ranAt` does. */
+declare const ran: (host: Host, commandId: string, ops: readonly ComputerOp[]) => Effect.Effect<readonly string[], Unexpected>;
+/** A step on `computer` under `key`, outside the job's journal. */
+declare const exec: (computer: string, key: string, command: string) => ComputerOp;
+/** The calls, as one namespace: each takes the host first, and `exec`, which builds a step to run. */
+declare const workbenchHost: {
+  exec: typeof exec;
+  outcomesOf: typeof outcomesOf;
+  ran: typeof ran;
+  ranAt: typeof ranAt;
+  startedRun: typeof startedRun;
+};
+export { bench, ensure, forkedBench, get, list, remove, stop, unfinished, workbenchHost };

package/dist/workbench/workbench-calls.pure.mjs

@@ -0,0 +1,75 @@
+import { ada, nothing } from "../ledger/ledger-calls.pure.mjs";
+import { decodeReply } from "../ledger/ledger-checks.pure.mjs";
+import { ComputerOp, Workbench } from "./workbench.contract.mjs";
+import { Effect, Option, Record, Schema } from "effect";
+// src/workbench/workbench-calls.pure.ts
+/** The Workbench the computer guarantees run on, whose key every engine under test serves. */
+const bench = "bench-1";
+/**
+* The key a fork of `bench` goes into. Akter Cloud forks only into a key on the parent's own shard, and `bench-250`
+* hashes to `bench-1`'s shard there.
+*/
+const forkedBench = "bench-250";
+const encodeOps = Schema.encodeEffect(Schema.fromJsonString(Workbench.commands.run.payload));
+const { Ensure, Exec, Get, List, Remove, Stop } = ComputerOp.cases;
+const ensure = (computer) => Ensure.make({ computer });
+const get = (computer) => Get.make({ computer });
+const remove = (computer) => Remove.make({ computer });
+const stop = (computer) => Stop.make({ computer });
+const list = List.make({});
+/** Starts the calls in one `run` job on the Workbench at `key` and answers the job's id. */
+const startedRun = (host, { commandId, key, ops }) => Effect.gen(function* startRun() {
+	const payload = yield* encodeOps({ ops });
+	const sent = yield* host.command({
+		actor: "Workbench",
+		commandId,
+		key,
+		member: "run",
+		payload,
+		principal: ada
+	});
+	return yield* Effect.flatten(decodeReply(Workbench.commands.run, sent));
+});
+const unfinished = "the job had not finished";
+/** What each call of a job answered, once its result has reached the actor. */
+const outcomesOf = (host, key, job) => Effect.gen(function* readOutcomes() {
+	yield* host.drain;
+	const reply = yield* host.query({
+		actor: "Workbench",
+		key,
+		member: "runs",
+		payload: nothing,
+		principal: ada
+	});
+	const runs = yield* Effect.flatten(decodeReply(Workbench.queries.runs, reply));
+	return Option.getOrElse(Record.get(runs, job), () => [unfinished]);
+});
+/**
+* Runs the calls in one `run` job on the Workbench at `key` and answers what each returned, once the job's result has
+* reached the actor. A call is one activity, so `run` with the same command id after a restart answers the same job.
+*/
+const ranAt = (host, key, { commandId, ops }) => Effect.flatMap(startedRun(host, {
+	commandId,
+	key,
+	ops
+}), (job) => outcomesOf(host, key, job));
+/** Runs the calls in one `run` job on the suite's Workbench, `bench`, as `ranAt` does. */
+const ran = (host, commandId, ops) => ranAt(host, bench, {
+	commandId,
+	ops
+});
+/** A step on `computer` under `key`, outside the job's journal. */
+const exec = (computer, key, command) => Exec.make({
+	command,
+	computer,
+	key
+});
+/** The calls, as one namespace: each takes the host first, and `exec`, which builds a step to run. */
+const workbenchHost = {
+	exec,
+	outcomesOf,
+	ran,
+	ranAt,
+	startedRun
+};
+export { bench, ensure, forkedBench, get, list, remove, stop, unfinished, workbenchHost };

package/dist/workbench/workbench.actor.d.mts

@@ -0,0 +1,4 @@
+import { Layer } from "effect";
+/** The Workbench and its job on the engine's job runtime, whose activities reach the computers the engine bound. */
+declare const WorkbenchLive: Layer.Layer<import("@akterjs/effect/contract").ActorHandlers<"Workbench">, never, never>;
+export { WorkbenchLive };

package/dist/workbench/workbench.actor.mjs

@@ -0,0 +1,107 @@
+import { ComputerOp, Workbench } from "./workbench.contract.mjs";
+import { ComputerLimitError } from "@akterjs/effect/contract/errors";
+import { Array, Cause, Effect, Exit, Layer, Option, Predicate, Record, Schema, String as String$1 } from "effect";
+import { Akter } from "@akterjs/effect/contract";
+import { Akter as Akter$1 } from "@akterjs/effect";
+import { Activity } from "effect/workflow";
+import { ComputerName, ExecRan } from "@akterjs/effect/contract/computer";
+// src/workbench/workbench.actor.ts
+const memoryMib = 1024;
+/** Every failure a computer call can answer, by tag. */
+const failures = [
+	"ActorUnavailableError",
+	"CallerNotAllowedError",
+	"ComputerHeldError",
+	"ComputerLostError",
+	"ComputerNotFoundError",
+	"ComputersUnavailableError",
+	"InvalidRequestError",
+	"SecretUnavailableError",
+	"UnauthenticatedError"
+];
+const isLimit = Schema.is(ComputerLimitError);
+const isRan = Schema.is(ExecRan);
+const specOf = (computer) => ({
+	egress: [],
+	image: "node:24-bookworm",
+	name: ComputerName.make(computer),
+	size: {
+		memoryMib,
+		vcpu: 1
+	}
+});
+const stepOf = (result) => {
+	if (!isRan(result)) return "unknown";
+	return `exit ${Option.getOrElse(Option.map(Option.fromUndefinedOr(result.exitCode), String), () => "none")}: ${result.stdout}`;
+};
+/** An engine may answer before the machine is up, so `starting` and `running` read the same: `up`. */
+const upStates = ["running", "starting"];
+const stateOf = ({ state }) => {
+	if (Array.contains(upStates, state)) return "up";
+	return state;
+};
+const holdOf = (hold) => Record.getSomes({ hold: Option.fromUndefinedOr(hold) });
+const namesOf = (computers) => `[${Array.join(Array.sort(Array.map(computers, ({ name }) => name), String$1.Order), ",")}]`;
+/** What one call answered, as the suite compares it: a state, a step's exit and output, names, or `removed`. */
+const called = (client, op) => ComputerOp.match(op, {
+	Ensure: ({ computer }) => Effect.map(client.ensure(specOf(computer)), stateOf),
+	Exec: ({ command, computer, key }) => Effect.map(client.exec(computer, {
+		command,
+		key
+	}), stepOf),
+	Get: ({ computer }) => Effect.map(client.get(computer), stateOf),
+	List: () => Effect.map(client.list, namesOf),
+	Pause: ({ computer, hold }) => Effect.map(client.pause(computer, holdOf(hold)), stateOf),
+	Remove: ({ computer }) => Effect.as(client.remove(computer), "removed"),
+	Resume: ({ computer, hold }) => Effect.map(client.resume(computer, holdOf(hold)), stateOf),
+	Step: () => Effect.die("a durable step runs in the job, not in an activity"),
+	Stop: ({ computer }) => Effect.map(client.stop(computer), stateOf)
+});
+/** A failure by its tag; a limit with the limit and its maximum, which the suite checks against what was made. */
+const failureOf = (failure) => {
+	if (isLimit(failure)) return `ComputerLimitError ${failure.limit} ${String(failure.maximum)}`;
+	return Option.getOrElse(Array.findFirst(failures, (tag) => Predicate.isTagged(failure, tag)), () => "unexpected failure");
+};
+const attempted = (key, op) => Effect.flatMap(Workbench.computer(key), (client) => called(client, op));
+const answered = (key, op) => Effect.match(attempted(key, op), {
+	onFailure: failureOf,
+	onSuccess: (outcome) => outcome
+});
+const isStep = Schema.is(ComputerOp.cases.Step);
+const timeoutOf = (timeoutSeconds) => Record.getSomes({ timeoutSeconds: Option.fromUndefinedOr(timeoutSeconds) });
+/** A durable step, made by the job itself: it journals its own start and outcome. */
+const stepped = (key, { command, computer, name, timeoutSeconds }) => Effect.match(Effect.flatMap(Workbench.computer(key), (computers) => computers.step(computer, {
+	command,
+	name,
+	...timeoutOf(timeoutSeconds)
+})), {
+	onFailure: failureOf,
+	onSuccess: stepOf
+});
+/**
+* Makes each call in its own activity, so a job resumed after a restart reads back the calls it already made, and each
+* `Step` as a durable step of the job.
+*/
+const RunLive = Workbench.jobs.run.toLayer(({ key, ops }) => Effect.forEach(ops, (op, index) => {
+	if (isStep(op)) return stepped(key, op);
+	return Activity.make({
+		execute: answered(key, op),
+		name: `call-${String(index)}`,
+		success: Schema.String
+	});
+}));
+const outcomesOf = (result) => Exit.match(result, {
+	onFailure: (cause) => [`job failed: ${Cause.pretty(cause)}`],
+	onSuccess: (outcomes) => outcomes
+});
+const WorkbenchHandlers = Workbench.toLayer({
+	commands: { run: (_bench, { ops }) => Effect.flatMap(Akter.actorKey, (key) => Akter.start(Workbench.jobs.run, {
+		key,
+		ops
+	})) },
+	queries: { runs: (bench) => Effect.succeed(bench.runs) },
+	results: { run: (bench, result, job) => Workbench.update({ runs: Record.set(bench.runs, job.id, outcomesOf(result)) }) }
+});
+/** The Workbench and its job on the engine's job runtime, whose activities reach the computers the engine bound. */
+const WorkbenchLive = Layer.merge(WorkbenchHandlers, RunLive).pipe(Layer.provide(Akter$1.jobs));
+export { WorkbenchLive };

package/dist/workbench/workbench.contract.d.mts

@@ -0,0 +1,220 @@
+import { Schema } from "effect";
+/** One call a `run` job makes to the actor's computers, in order. */
+declare const ComputerOp: Schema.TaggedUnion<{
+  readonly Ensure: Schema.TaggedStruct<"Ensure", {
+    computer: Schema.String;
+  }>;
+  readonly Exec: Schema.TaggedStruct<"Exec", {
+    readonly computer: Schema.String;
+    readonly command: Schema.String;
+    readonly key: Schema.String;
+  }>;
+  readonly Get: Schema.TaggedStruct<"Get", {
+    computer: Schema.String;
+  }>;
+  readonly List: Schema.TaggedStruct<"List", {}>;
+  readonly Pause: Schema.TaggedStruct<"Pause", {
+    computer: Schema.String;
+    hold: Schema.optionalKey<Schema.String>;
+  }>;
+  readonly Remove: Schema.TaggedStruct<"Remove", {
+    computer: Schema.String;
+  }>;
+  readonly Resume: Schema.TaggedStruct<"Resume", {
+    computer: Schema.String;
+    hold: Schema.optionalKey<Schema.String>;
+  }>;
+  readonly Step: Schema.TaggedStruct<"Step", {
+    readonly computer: Schema.String;
+    readonly command: Schema.String;
+    readonly name: Schema.String;
+    readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+  }>;
+  readonly Stop: Schema.TaggedStruct<"Stop", {
+    computer: Schema.String;
+  }>;
+}>;
+type ComputerOp = typeof ComputerOp.Type;
+/**
+ * The suite's actor for computer guarantees. `run` starts a job that makes its calls to the actor's computers, each
+ * in an activity or, for a `Step`, as a durable step of the job, and records what each answered; `runs` reads those
+ * records back.
+ */
+declare const Workbench: import("@akterjs/effect/contract").Actor<"Workbench", import("@akterjs/effect/contract").DefinitionOf<{
+  readonly commands: {
+    run: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly ops: Schema.$Array<Schema.TaggedUnion<{
+        readonly Ensure: Schema.TaggedStruct<"Ensure", {
+          computer: Schema.String;
+        }>;
+        readonly Exec: Schema.TaggedStruct<"Exec", {
+          readonly computer: Schema.String;
+          readonly command: Schema.String;
+          readonly key: Schema.String;
+        }>;
+        readonly Get: Schema.TaggedStruct<"Get", {
+          computer: Schema.String;
+        }>;
+        readonly List: Schema.TaggedStruct<"List", {}>;
+        readonly Pause: Schema.TaggedStruct<"Pause", {
+          computer: Schema.String;
+          hold: Schema.optionalKey<Schema.String>;
+        }>;
+        readonly Remove: Schema.TaggedStruct<"Remove", {
+          computer: Schema.String;
+        }>;
+        readonly Resume: Schema.TaggedStruct<"Resume", {
+          computer: Schema.String;
+          hold: Schema.optionalKey<Schema.String>;
+        }>;
+        readonly Step: Schema.TaggedStruct<"Step", {
+          readonly computer: Schema.String;
+          readonly command: Schema.String;
+          readonly name: Schema.String;
+          readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+        }>;
+        readonly Stop: Schema.TaggedStruct<"Stop", {
+          computer: Schema.String;
+        }>;
+      }>>;
+    }>, Schema.String, Schema.Never, never>;
+  };
+  readonly initial: () => {
+    runs: {};
+  };
+  readonly jobs: {
+    run: import("@akterjs/effect/contract").Job<{
+      readonly key: Schema.String;
+      readonly ops: Schema.$Array<Schema.TaggedUnion<{
+        readonly Ensure: Schema.TaggedStruct<"Ensure", {
+          computer: Schema.String;
+        }>;
+        readonly Exec: Schema.TaggedStruct<"Exec", {
+          readonly computer: Schema.String;
+          readonly command: Schema.String;
+          readonly key: Schema.String;
+        }>;
+        readonly Get: Schema.TaggedStruct<"Get", {
+          computer: Schema.String;
+        }>;
+        readonly List: Schema.TaggedStruct<"List", {}>;
+        readonly Pause: Schema.TaggedStruct<"Pause", {
+          computer: Schema.String;
+          hold: Schema.optionalKey<Schema.String>;
+        }>;
+        readonly Remove: Schema.TaggedStruct<"Remove", {
+          computer: Schema.String;
+        }>;
+        readonly Resume: Schema.TaggedStruct<"Resume", {
+          computer: Schema.String;
+          hold: Schema.optionalKey<Schema.String>;
+        }>;
+        readonly Step: Schema.TaggedStruct<"Step", {
+          readonly computer: Schema.String;
+          readonly command: Schema.String;
+          readonly name: Schema.String;
+          readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+        }>;
+        readonly Stop: Schema.TaggedStruct<"Stop", {
+          computer: Schema.String;
+        }>;
+      }>>;
+    }, Schema.$Array<Schema.String>, Schema.Never, never>;
+  };
+  readonly key: Schema.String;
+  readonly queries: {
+    runs: import("@akterjs/effect/contract").Query<Schema.Void, Schema.$Record<Schema.String, Schema.$Array<Schema.String>>, Schema.Never, never>;
+  };
+  readonly state: Schema.Struct<{
+    readonly runs: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
+  }>;
+}>> & import("@akterjs/effect/contract").ActorHistory<import("@akterjs/effect/contract").DefinitionOf<{
+  readonly commands: {
+    run: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly ops: Schema.$Array<Schema.TaggedUnion<{
+        readonly Ensure: Schema.TaggedStruct<"Ensure", {
+          computer: Schema.String;
+        }>;
+        readonly Exec: Schema.TaggedStruct<"Exec", {
+          readonly computer: Schema.String;
+          readonly command: Schema.String;
+          readonly key: Schema.String;
+        }>;
+        readonly Get: Schema.TaggedStruct<"Get", {
+          computer: Schema.String;
+        }>;
+        readonly List: Schema.TaggedStruct<"List", {}>;
+        readonly Pause: Schema.TaggedStruct<"Pause", {
+          computer: Schema.String;
+          hold: Schema.optionalKey<Schema.String>;
+        }>;
+        readonly Remove: Schema.TaggedStruct<"Remove", {
+          computer: Schema.String;
+        }>;
+        readonly Resume: Schema.TaggedStruct<"Resume", {
+          computer: Schema.String;
+          hold: Schema.optionalKey<Schema.String>;
+        }>;
+        readonly Step: Schema.TaggedStruct<"Step", {
+          readonly computer: Schema.String;
+          readonly command: Schema.String;
+          readonly name: Schema.String;
+          readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+        }>;
+        readonly Stop: Schema.TaggedStruct<"Stop", {
+          computer: Schema.String;
+        }>;
+      }>>;
+    }>, Schema.String, Schema.Never, never>;
+  };
+  readonly initial: () => {
+    runs: {};
+  };
+  readonly jobs: {
+    run: import("@akterjs/effect/contract").Job<{
+      readonly key: Schema.String;
+      readonly ops: Schema.$Array<Schema.TaggedUnion<{
+        readonly Ensure: Schema.TaggedStruct<"Ensure", {
+          computer: Schema.String;
+        }>;
+        readonly Exec: Schema.TaggedStruct<"Exec", {
+          readonly computer: Schema.String;
+          readonly command: Schema.String;
+          readonly key: Schema.String;
+        }>;
+        readonly Get: Schema.TaggedStruct<"Get", {
+          computer: Schema.String;
+        }>;
+        readonly List: Schema.TaggedStruct<"List", {}>;
+        readonly Pause: Schema.TaggedStruct<"Pause", {
+          computer: Schema.String;
+          hold: Schema.optionalKey<Schema.String>;
+        }>;
+        readonly Remove: Schema.TaggedStruct<"Remove", {
+          computer: Schema.String;
+        }>;
+        readonly Resume: Schema.TaggedStruct<"Resume", {
+          computer: Schema.String;
+          hold: Schema.optionalKey<Schema.String>;
+        }>;
+        readonly Step: Schema.TaggedStruct<"Step", {
+          readonly computer: Schema.String;
+          readonly command: Schema.String;
+          readonly name: Schema.String;
+          readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+        }>;
+        readonly Stop: Schema.TaggedStruct<"Stop", {
+          computer: Schema.String;
+        }>;
+      }>>;
+    }, Schema.$Array<Schema.String>, Schema.Never, never>;
+  };
+  readonly key: Schema.String;
+  readonly queries: {
+    runs: import("@akterjs/effect/contract").Query<Schema.Void, Schema.$Record<Schema.String, Schema.$Array<Schema.String>>, Schema.Never, never>;
+  };
+  readonly state: Schema.Struct<{
+    readonly runs: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
+  }>;
+}>>;
+export { ComputerOp, Workbench };

package/dist/workbench/workbench.contract.mjs

@@ -0,0 +1,54 @@
+import { Schema } from "effect";
+import { Akter } from "@akterjs/effect/contract";
+// src/workbench/workbench.contract.ts
+const Named = { computer: Schema.String };
+const Held = {
+	...Named,
+	hold: Schema.optionalKey(Schema.String)
+};
+/** One call a `run` job makes to the actor's computers, in order. */
+const ComputerOp = Schema.TaggedUnion({
+	Ensure: Named,
+	Exec: {
+		...Named,
+		command: Schema.String,
+		key: Schema.String
+	},
+	Get: Named,
+	List: {},
+	Pause: Held,
+	Remove: Named,
+	Resume: Held,
+	Step: {
+		...Named,
+		command: Schema.String,
+		name: Schema.String,
+		timeoutSeconds: Schema.optionalKey(Schema.Int)
+	},
+	Stop: Named
+});
+/** Each finished `run` job's outcomes, one per call, by the job's id. */
+const Runs = Schema.Record(Schema.String, Schema.Array(Schema.String));
+/**
+* The suite's actor for computer guarantees. `run` starts a job that makes its calls to the actor's computers, each
+* in an activity or, for a `Step`, as a durable step of the job, and records what each answered; `runs` reads those
+* records back.
+*/
+const Workbench = Akter.make("Workbench", {
+	commands: { run: Akter.command({
+		payload: { ops: Schema.Array(ComputerOp) },
+		success: Schema.String
+	}) },
+	initial: () => ({ runs: {} }),
+	jobs: { run: Akter.job({
+		payload: {
+			key: Schema.String,
+			ops: Schema.Array(ComputerOp)
+		},
+		success: Schema.Array(Schema.String)
+	}) },
+	key: Schema.String,
+	queries: { runs: Akter.query({ success: Runs }) },
+	state: Schema.Struct({ runs: Runs })
+});
+export { ComputerOp, Workbench };

package/package.json

@@ -1,6 +1,89 @@
 {
   "name": "@akterjs/conformance",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "The test suite every Akter engine must pass: the local engine here and the production engine on Akter Cloud.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rika-Labs/akter.git",
+    "directory": "packages/conformance"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "imports": {
+    "#src/*": "./src/*"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/engine-conformance.suite.d.mts",
+      "default": "./dist/engine-conformance.suite.mjs"
+    },
+    "./client": {
+      "types": "./dist/client-contract.suite.d.mts",
+      "default": "./dist/client-contract.suite.mjs"
+    },
+    "./computers": {
+      "types": "./dist/workbench/computer-conformance.suite.d.mts",
+      "default": "./dist/workbench/computer-conformance.suite.mjs"
+    },
+    "./fork": {
+      "types": "./dist/fork/fork-conformance.suite.d.mts",
+      "default": "./dist/fork/fork-conformance.suite.mjs"
+    },
+    "./plain": {
+      "types": "./dist/ledger/plain-ledger.actor.d.mts",
+      "default": "./dist/ledger/plain-ledger.actor.mjs"
+    },
+    "./tally": {
+      "types": "./dist/tally.actor.d.mts",
+      "default": "./dist/tally.actor.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "devDependencies": {
+    "@akterjs/client": "0.1.0",
+    "@akterjs/effect": "0.1.0",
+    "@akterjs/sdk": "0.1.0",
+    "@effect/platform-node": "4.1.2",
+    "@effect/vitest": "4.1.2",
+    "effect": "4.1.2",
+    "publint": "0.3.25",
+    "tsdown": "0.23.5",
+    "vitest": "5.1.0",
+    "zod": "4.6.7"
+  },
+  "peerDependencies": {
+    "@akterjs/client": "0.1.0",
+    "@akterjs/effect": "0.1.0",
+    "@akterjs/sdk": "0.1.0",
+    "@effect/vitest": "4.1.2",
+    "effect": "4.1.2",
+    "vitest": "5.1.0",
+    "zod": "4.6.7"
+  },
+  "peerDependenciesMeta": {
+    "@akterjs/client": {
+      "optional": true
+    },
+    "@akterjs/sdk": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "typecheck": "effect-tsgo tsrs --noEmit -p tsconfig.json",
+    "lint": "effect-tsgo --tsrs-lint oxlint -c ../../oxlint.config.ts --type-aware --tsconfig tsconfig.json src tests",
+    "test": "vitest run",
+    "test:bun": "bunx --bun vitest run",
+    "build": "tsdown"
+  }
 }