@akterjs/conformance 0.0.0-stage → 0.1.0

package/dist/ledger/ledger.contract.d.mts

@@ -0,0 +1,310 @@
+import { Schema } from "effect";
+declare const EntryId: Schema.brand<Schema.String, "EntryId">;
+declare const Cents: Schema.brand<Schema.Int, "Cents">;
+type Cents = typeof Cents.Type;
+declare const Entry: Schema.Struct<{
+  readonly amount: Schema.brand<Schema.Int, "Cents">;
+  readonly id: Schema.brand<Schema.String, "EntryId">;
+}>;
+type Entry = typeof Entry.Type;
+type Account = typeof Account.Type;
+declare const Account: Schema.Struct<{
+  readonly balance: Schema.brand<Schema.Int, "Cents">;
+  readonly closed: Schema.Boolean;
+}>;
+declare const OverdrawnError_base: Schema.Class<OverdrawnError, Schema.TaggedStruct<"OverdrawnError", {
+  readonly balance: Schema.brand<Schema.Int, "Cents">;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+declare class OverdrawnError extends OverdrawnError_base {}
+/** The patch the later build's `release` declares: it releases twice the approved amount, for holds it started. */
+declare const doubled = "double";
+declare const Ledger: import("@akterjs/effect/contract").Actor<"Ledger", import("@akterjs/effect/contract").DefinitionOf<{
+  readonly callers: {
+    readonly actor: Schema.Struct<{
+      readonly actor: Schema.String;
+      readonly id: Schema.brand<Schema.String, "PrincipalId">;
+      readonly key: Schema.String;
+    }>;
+    readonly service: Schema.Struct<{
+      readonly id: Schema.brand<Schema.String, "PrincipalId">;
+    }>;
+    readonly user: Schema.Struct<{
+      readonly id: Schema.brand<Schema.String, "PrincipalId">;
+    }>;
+  };
+  readonly commands: {
+    readonly approve: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly job: Schema.String;
+      readonly refuse: Schema.Boolean;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly close: import("@akterjs/effect/contract").Command<Schema.Void, Schema.Void, Schema.Never, "service">;
+    readonly crash: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly credit: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.brand<Schema.String, "EntryId">, Schema.Never, "actor">;
+    readonly deposit: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.brand<Schema.String, "EntryId">, Schema.Never, never>;
+    readonly depositLater: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly minutes: Schema.Int;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly hold: import("@akterjs/effect/contract").Command<Schema.Void, Schema.String, Schema.Never, never>;
+    readonly tamper: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly transfer: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly to: Schema.brand<Schema.String, "AccountId">;
+    }>, Schema.brand<Schema.String, "EntryId">, typeof OverdrawnError, never>;
+    readonly withdraw: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.brand<Schema.String, "EntryId">, typeof OverdrawnError, never>;
+  };
+  readonly files: import("@akterjs/effect/contract").FileAccess<"user">;
+  readonly initial: () => {
+    balance: number & import("effect/Brand").Brand<"Cents">;
+    closed: boolean;
+  };
+  readonly key: Schema.brand<Schema.String, "AccountId">;
+  readonly queries: {
+    readonly account: import("@akterjs/effect/contract").Query<Schema.Void, Schema.Struct<{
+      readonly balance: Schema.brand<Schema.Int, "Cents">;
+      readonly closed: Schema.Boolean;
+    }>, Schema.Never, never>;
+    readonly entries: import("@akterjs/effect/contract").Query<Schema.Void, Schema.$Array<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly id: Schema.brand<Schema.String, "EntryId">;
+    }>>, Schema.Never, never>;
+    readonly scribble: import("@akterjs/effect/contract").Query<Schema.Void, Schema.Void, Schema.Never, never>;
+    readonly tables: import("@akterjs/effect/contract").Query<Schema.Void, Schema.$Array<Schema.String>, Schema.Never, never>;
+  };
+  readonly state: Schema.Struct<{
+    readonly balance: Schema.brand<Schema.Int, "Cents">;
+    readonly closed: Schema.Boolean;
+  }>;
+  readonly jobs: {
+    release: import("@akterjs/effect/contract").Job<{}, Schema.brand<Schema.Int, "Cents">, Schema.Never, string>;
+  };
+}>> & import("@akterjs/effect/contract").ActorHistory<import("@akterjs/effect/contract").DefinitionOf<{
+  readonly callers: {
+    readonly actor: Schema.Struct<{
+      readonly actor: Schema.String;
+      readonly id: Schema.brand<Schema.String, "PrincipalId">;
+      readonly key: Schema.String;
+    }>;
+    readonly service: Schema.Struct<{
+      readonly id: Schema.brand<Schema.String, "PrincipalId">;
+    }>;
+    readonly user: Schema.Struct<{
+      readonly id: Schema.brand<Schema.String, "PrincipalId">;
+    }>;
+  };
+  readonly commands: {
+    readonly approve: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly job: Schema.String;
+      readonly refuse: Schema.Boolean;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly close: import("@akterjs/effect/contract").Command<Schema.Void, Schema.Void, Schema.Never, "service">;
+    readonly crash: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly credit: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.brand<Schema.String, "EntryId">, Schema.Never, "actor">;
+    readonly deposit: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.brand<Schema.String, "EntryId">, Schema.Never, never>;
+    readonly depositLater: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly minutes: Schema.Int;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly hold: import("@akterjs/effect/contract").Command<Schema.Void, Schema.String, Schema.Never, never>;
+    readonly tamper: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly transfer: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly to: Schema.brand<Schema.String, "AccountId">;
+    }>, Schema.brand<Schema.String, "EntryId">, typeof OverdrawnError, never>;
+    readonly withdraw: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.brand<Schema.String, "EntryId">, typeof OverdrawnError, never>;
+  };
+  readonly files: import("@akterjs/effect/contract").FileAccess<"user">;
+  readonly initial: () => {
+    balance: number & import("effect/Brand").Brand<"Cents">;
+    closed: boolean;
+  };
+  readonly key: Schema.brand<Schema.String, "AccountId">;
+  readonly queries: {
+    readonly account: import("@akterjs/effect/contract").Query<Schema.Void, Schema.Struct<{
+      readonly balance: Schema.brand<Schema.Int, "Cents">;
+      readonly closed: Schema.Boolean;
+    }>, Schema.Never, never>;
+    readonly entries: import("@akterjs/effect/contract").Query<Schema.Void, Schema.$Array<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly id: Schema.brand<Schema.String, "EntryId">;
+    }>>, Schema.Never, never>;
+    readonly scribble: import("@akterjs/effect/contract").Query<Schema.Void, Schema.Void, Schema.Never, never>;
+    readonly tables: import("@akterjs/effect/contract").Query<Schema.Void, Schema.$Array<Schema.String>, Schema.Never, never>;
+  };
+  readonly state: Schema.Struct<{
+    readonly balance: Schema.brand<Schema.Int, "Cents">;
+    readonly closed: Schema.Boolean;
+  }>;
+  readonly jobs: {
+    release: import("@akterjs/effect/contract").Job<{}, Schema.brand<Schema.Int, "Cents">, Schema.Never, string>;
+  };
+}>>;
+/** The Ledger deployed again with its `release` job patched, over holds the earlier build started. */
+declare const PatchedLedger: import("@akterjs/effect/contract").Actor<"Ledger", import("@akterjs/effect/contract").DefinitionOf<{
+  readonly callers: {
+    readonly actor: Schema.Struct<{
+      readonly actor: Schema.String;
+      readonly id: Schema.brand<Schema.String, "PrincipalId">;
+      readonly key: Schema.String;
+    }>;
+    readonly service: Schema.Struct<{
+      readonly id: Schema.brand<Schema.String, "PrincipalId">;
+    }>;
+    readonly user: Schema.Struct<{
+      readonly id: Schema.brand<Schema.String, "PrincipalId">;
+    }>;
+  };
+  readonly commands: {
+    readonly approve: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly job: Schema.String;
+      readonly refuse: Schema.Boolean;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly close: import("@akterjs/effect/contract").Command<Schema.Void, Schema.Void, Schema.Never, "service">;
+    readonly crash: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly credit: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.brand<Schema.String, "EntryId">, Schema.Never, "actor">;
+    readonly deposit: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.brand<Schema.String, "EntryId">, Schema.Never, never>;
+    readonly depositLater: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly minutes: Schema.Int;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly hold: import("@akterjs/effect/contract").Command<Schema.Void, Schema.String, Schema.Never, never>;
+    readonly tamper: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly transfer: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly to: Schema.brand<Schema.String, "AccountId">;
+    }>, Schema.brand<Schema.String, "EntryId">, typeof OverdrawnError, never>;
+    readonly withdraw: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.brand<Schema.String, "EntryId">, typeof OverdrawnError, never>;
+  };
+  readonly files: import("@akterjs/effect/contract").FileAccess<"user">;
+  readonly initial: () => {
+    balance: number & import("effect/Brand").Brand<"Cents">;
+    closed: boolean;
+  };
+  readonly key: Schema.brand<Schema.String, "AccountId">;
+  readonly queries: {
+    readonly account: import("@akterjs/effect/contract").Query<Schema.Void, Schema.Struct<{
+      readonly balance: Schema.brand<Schema.Int, "Cents">;
+      readonly closed: Schema.Boolean;
+    }>, Schema.Never, never>;
+    readonly entries: import("@akterjs/effect/contract").Query<Schema.Void, Schema.$Array<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly id: Schema.brand<Schema.String, "EntryId">;
+    }>>, Schema.Never, never>;
+    readonly scribble: import("@akterjs/effect/contract").Query<Schema.Void, Schema.Void, Schema.Never, never>;
+    readonly tables: import("@akterjs/effect/contract").Query<Schema.Void, Schema.$Array<Schema.String>, Schema.Never, never>;
+  };
+  readonly state: Schema.Struct<{
+    readonly balance: Schema.brand<Schema.Int, "Cents">;
+    readonly closed: Schema.Boolean;
+  }>;
+  readonly jobs: {
+    release: import("@akterjs/effect/contract").Job<{}, Schema.brand<Schema.Int, "Cents">, Schema.Never, string>;
+  };
+}>> & import("@akterjs/effect/contract").ActorHistory<import("@akterjs/effect/contract").DefinitionOf<{
+  readonly callers: {
+    readonly actor: Schema.Struct<{
+      readonly actor: Schema.String;
+      readonly id: Schema.brand<Schema.String, "PrincipalId">;
+      readonly key: Schema.String;
+    }>;
+    readonly service: Schema.Struct<{
+      readonly id: Schema.brand<Schema.String, "PrincipalId">;
+    }>;
+    readonly user: Schema.Struct<{
+      readonly id: Schema.brand<Schema.String, "PrincipalId">;
+    }>;
+  };
+  readonly commands: {
+    readonly approve: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly job: Schema.String;
+      readonly refuse: Schema.Boolean;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly close: import("@akterjs/effect/contract").Command<Schema.Void, Schema.Void, Schema.Never, "service">;
+    readonly crash: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly credit: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.brand<Schema.String, "EntryId">, Schema.Never, "actor">;
+    readonly deposit: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.brand<Schema.String, "EntryId">, Schema.Never, never>;
+    readonly depositLater: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly minutes: Schema.Int;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly hold: import("@akterjs/effect/contract").Command<Schema.Void, Schema.String, Schema.Never, never>;
+    readonly tamper: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.Void, Schema.Never, never>;
+    readonly transfer: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly to: Schema.brand<Schema.String, "AccountId">;
+    }>, Schema.brand<Schema.String, "EntryId">, typeof OverdrawnError, never>;
+    readonly withdraw: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+    }>, Schema.brand<Schema.String, "EntryId">, typeof OverdrawnError, never>;
+  };
+  readonly files: import("@akterjs/effect/contract").FileAccess<"user">;
+  readonly initial: () => {
+    balance: number & import("effect/Brand").Brand<"Cents">;
+    closed: boolean;
+  };
+  readonly key: Schema.brand<Schema.String, "AccountId">;
+  readonly queries: {
+    readonly account: import("@akterjs/effect/contract").Query<Schema.Void, Schema.Struct<{
+      readonly balance: Schema.brand<Schema.Int, "Cents">;
+      readonly closed: Schema.Boolean;
+    }>, Schema.Never, never>;
+    readonly entries: import("@akterjs/effect/contract").Query<Schema.Void, Schema.$Array<Schema.Struct<{
+      readonly amount: Schema.brand<Schema.Int, "Cents">;
+      readonly id: Schema.brand<Schema.String, "EntryId">;
+    }>>, Schema.Never, never>;
+    readonly scribble: import("@akterjs/effect/contract").Query<Schema.Void, Schema.Void, Schema.Never, never>;
+    readonly tables: import("@akterjs/effect/contract").Query<Schema.Void, Schema.$Array<Schema.String>, Schema.Never, never>;
+  };
+  readonly state: Schema.Struct<{
+    readonly balance: Schema.brand<Schema.Int, "Cents">;
+    readonly closed: Schema.Boolean;
+  }>;
+  readonly jobs: {
+    release: import("@akterjs/effect/contract").Job<{}, Schema.brand<Schema.Int, "Cents">, Schema.Never, string>;
+  };
+}>>;
+export { Account, Cents, Entry, EntryId, Ledger, OverdrawnError, PatchedLedger, doubled };

package/dist/ledger/ledger.contract.mjs

@@ -0,0 +1,112 @@
+import { Schema } from "effect";
+import { Akter } from "@akterjs/effect/contract";
+// src/ledger/ledger.contract.ts
+const AccountId = Schema.String.pipe(Schema.brand("AccountId"));
+const EntryId = Schema.String.pipe(Schema.brand("EntryId"));
+const Cents = Schema.Int.pipe(Schema.brand("Cents"));
+const openingCents = 0;
+const Entry = Schema.Struct({
+	amount: Cents,
+	id: EntryId
+});
+const Account = Schema.Struct({
+	balance: Cents,
+	closed: Schema.Boolean
+});
+const Service = Schema.Struct({ id: Akter.PrincipalId });
+var OverdrawnError = class extends Schema.TaggedError()("OverdrawnError", { balance: Cents }) {};
+/** Everything the Ledger declares but its `release` job, which the two builds below declare with different patches. */
+const ledgerOptions = {
+	callers: {
+		actor: Akter.ActorPrincipal,
+		service: Service,
+		user: Akter.Principal
+	},
+	commands: {
+		approve: Akter.command({
+			payload: {
+				amount: Cents,
+				job: Schema.String,
+				refuse: Schema.Boolean
+			},
+			success: Schema.Void
+		}),
+		close: Akter.command({
+			callers: ["service"],
+			success: Schema.Void
+		}),
+		crash: Akter.command({
+			payload: { amount: Cents },
+			success: Schema.Void
+		}),
+		credit: Akter.command({
+			callers: ["actor"],
+			payload: { amount: Cents },
+			success: EntryId
+		}),
+		deposit: Akter.command({
+			payload: { amount: Cents },
+			success: EntryId
+		}),
+		depositLater: Akter.command({
+			payload: {
+				amount: Cents,
+				minutes: Schema.Int
+			},
+			success: Schema.Void
+		}),
+		hold: Akter.command({ success: Schema.String }),
+		tamper: Akter.command({
+			payload: { amount: Cents },
+			success: Schema.Void
+		}),
+		transfer: Akter.command({
+			error: OverdrawnError,
+			payload: {
+				amount: Cents,
+				to: AccountId
+			},
+			success: EntryId
+		}),
+		withdraw: Akter.command({
+			error: OverdrawnError,
+			payload: { amount: Cents },
+			success: EntryId
+		})
+	},
+	files: Akter.fileAccess({ callers: ["user"] }),
+	initial: () => ({
+		balance: Cents.make(openingCents),
+		closed: false
+	}),
+	key: AccountId,
+	queries: {
+		account: Akter.query({ success: Account }),
+		entries: Akter.query({ success: Schema.Array(Entry) }),
+		scribble: Akter.query({ success: Schema.Void }),
+		tables: Akter.query({ success: Schema.Array(Schema.String) })
+	},
+	state: Account
+};
+/** The patch the later build's `release` declares: it releases twice the approved amount, for holds it started. */
+const doubled = "double";
+const noPatches = [];
+const doubling = [doubled];
+const Ledger = Akter.make("Ledger", {
+	...ledgerOptions,
+	jobs: { release: Akter.job({
+		patches: noPatches,
+		payload: {},
+		success: Cents
+	}) }
+});
+/** The Ledger deployed again with its `release` job patched, over holds the earlier build started. */
+const PatchedLedger = Akter.make("Ledger", {
+	...ledgerOptions,
+	jobs: { release: Akter.job({
+		patches: doubling,
+		payload: {},
+		success: Cents
+	}) }
+});
+export { Account, Cents, Entry, EntryId, Ledger, OverdrawnError, PatchedLedger, doubled };

package/dist/ledger/plain-ledger.actor.d.mts

@@ -0,0 +1,4 @@
+import { Ledgers } from "./ledger.actor.mjs";
+/** The plain SDK's Ledgers, for `conformanceOf({ engine, ledgers: plainLedgers, skip })`: every engine must pass the suite on both SDKs. */
+declare const plainLedgers: Ledgers;
+export { plainLedgers };

package/dist/ledger/plain-ledger.actor.mjs

@@ -0,0 +1,214 @@
+import "./ledger-calls.pure.mjs";
+import { doubled } from "./ledger.contract.mjs";
+import { Array, Effect, Layer } from "effect";
+import { Akter } from "@akterjs/effect";
+import { Akter as Akter$1 } from "@akterjs/sdk";
+import { engineOf } from "@akterjs/sdk/engine";
+import { z } from "zod";
+// src/ledger/plain-ledger.actor.ts
+/** The plain SDK's Ledger: the wire contract of the Effect Ledger in `ledger.contract.ts`, so one suite checks both SDKs. */
+const Cents = z.number().int();
+const Amount = z.object({ amount: Cents });
+const Later = z.object({
+	amount: Cents,
+	minutes: z.number().int()
+});
+const Approving = z.object({
+	amount: Cents,
+	job: z.string(),
+	refuse: z.boolean()
+});
+const Release = z.object({});
+const Transfer = z.object({
+	amount: Cents,
+	to: z.string()
+});
+const EntryId = z.string();
+const OverdrawnError = Akter$1.error("OverdrawnError", z.object({ balance: Cents }));
+const Account = z.object({
+	balance: Cents,
+	closed: z.boolean()
+});
+const Entries = z.array(z.object({
+	amount: Cents,
+	id: EntryId
+}));
+const TableNames = z.array(z.object({ name: z.string() }));
+const TableList = z.array(z.string()).readonly();
+/** Everything the plain Ledger declares but its `release` job, which the two builds below declare with different patches. */
+const ledgerOptions = {
+	callers: {
+		actor: Akter$1.ActorPrincipal,
+		service: z.object({ id: z.string() }),
+		user: Akter$1.Principal
+	},
+	commands: {
+		approve: Akter$1.command({ payload: Approving }),
+		close: Akter$1.command({ callers: ["service"] }),
+		crash: Akter$1.command({ payload: Amount }),
+		credit: Akter$1.command({
+			callers: ["actor"],
+			payload: Amount,
+			success: EntryId
+		}),
+		deposit: Akter$1.command({
+			payload: Amount,
+			success: EntryId
+		}),
+		depositLater: Akter$1.command({ payload: Later }),
+		hold: Akter$1.command({ success: z.string() }),
+		tamper: Akter$1.command({ payload: Amount }),
+		transfer: Akter$1.command({
+			errors: [OverdrawnError],
+			payload: Transfer,
+			success: EntryId
+		}),
+		withdraw: Akter$1.command({
+			errors: [OverdrawnError],
+			payload: Amount,
+			success: EntryId
+		})
+	},
+	files: Akter$1.fileAccess({ callers: ["user"] }),
+	initial: () => ({
+		balance: 0,
+		closed: false
+	}),
+	key: z.string(),
+	queries: {
+		account: Akter$1.query({ success: Account }),
+		entries: Akter$1.query({ success: Entries }),
+		scribble: Akter$1.query(),
+		tables: Akter$1.query({ success: TableList })
+	},
+	state: Account
+};
+const noPatches = [];
+const doubling = [doubled];
+const Ledger = Akter$1.make("Ledger", {
+	...ledgerOptions,
+	jobs: { release: Akter$1.job({
+		patches: noPatches,
+		payload: Release,
+		success: Cents
+	}) }
+});
+/** The Ledger deployed again with its `release` job patched, over holds the earlier build started. */
+const PatchedLedger = Akter$1.make("Ledger", {
+	...ledgerOptions,
+	jobs: { release: Akter$1.job({
+		patches: doubling,
+		payload: Release,
+		success: Cents
+	}) }
+});
+const lowestBalance = 0;
+const millisPerMinute = 6e4;
+const scribbled = 1;
+const insert = (sql, id, amount) => sql`INSERT INTO entries (id, amount) VALUES (${id}, ${amount})`;
+/** Records an entry and moves the balance, as the Effect Ledger's `record` does. */
+const record = (ctx, balance, amount) => {
+	const id = ctx.id();
+	insert(ctx.sql, id, amount);
+	ctx.update({ balance });
+	return id;
+};
+const withdrawal = (ctx, amount) => {
+	const balance = ctx.state.balance - amount;
+	const id = record(ctx, balance, amount);
+	if (balance < lowestBalance) throw new OverdrawnError({ balance });
+	return id;
+};
+/** Reads the engine's journal, then writes the engine's state table, which no handler may do. */
+const tamperWith = (sql) => Array.appendAll(sql`SELECT count(*) AS commands FROM akter_commands`, sql`UPDATE akter_state SET value = value`);
+const tableNames = (sql) => Array.map(TableNames.parse(sql`SELECT name FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'akter_%' AND name NOT LIKE 'sqlite_%' ORDER BY name`), (row) => row.name);
+/** Signals the held job, then throws after the signal when `refuse` is set, so the command rolls back with it. */
+const approve = (ctx, { amount, job, refuse }) => {
+	ctx.signal(job, "approval", amount);
+	if (refuse) throw new Error("the approval was refused after signalling");
+};
+/** Waits for the approved amount and returns it, so its result records the entry. */
+const release = (_payload, steps) => Effect.runPromise(Effect.map(Effect.promise(() => steps.waitFor("approval")), (value) => Cents.parse(value)));
+const twice = 2;
+/** The later build's release: twice the approved amount, but only for a hold this build started. */
+const doublingRelease = (payload, steps) => Effect.runPromise(Effect.map(Effect.promise(() => release(payload, steps)), (amount) => {
+	if (steps.patched("double")) return amount * twice;
+	return amount;
+}));
+const released = (ctx, result) => {
+	if (result.outcome === "success") record(ctx, ctx.state.balance + result.value, result.value);
+};
+/** The build the suite opens first: the Ledger without patches. */
+const firstBuild = {
+	job: release,
+	ledger: Ledger
+};
+const plainLedgerLayer = (migrations, { job, ledger } = firstBuild) => {
+	const implemented = ledger.implement({
+		commands: {
+			approve,
+			close: (ctx) => {
+				ctx.update({ closed: true });
+			},
+			crash: (ctx, { amount }) => {
+				record(ctx, ctx.state.balance + amount, amount);
+				throw new Error("the handler crashed after writing");
+			},
+			credit: (ctx, { amount }) => record(ctx, ctx.state.balance + amount, amount),
+			deposit: (ctx, { amount }) => record(ctx, ctx.state.balance + amount, amount),
+			depositLater: (ctx, { amount, minutes }) => {
+				ctx.schedule(minutes * millisPerMinute, Ledger.commands.deposit, { amount });
+			},
+			hold: (ctx) => ctx.start(ledger.jobs.release, {}),
+			tamper: (ctx, { amount }) => {
+				record(ctx, ctx.state.balance + amount, amount);
+				tamperWith(ctx.sql);
+			},
+			transfer: (ctx, { amount, to }) => {
+				ctx.send(Ledger.commands.credit, to, { amount });
+				return withdrawal(ctx, amount);
+			},
+			withdraw: (ctx, { amount }) => withdrawal(ctx, amount)
+		},
+		files: { authorize: (ctx, { access }) => access === "read" || ctx.principal.id === "ada" && !ctx.state.closed },
+		jobs: { release: job },
+		migrations,
+		queries: {
+			account: (ctx) => ({
+				balance: ctx.state.balance,
+				closed: ctx.state.closed
+			}),
+			entries: (ctx) => Entries.parse(ctx.sql`SELECT id, amount FROM entries ORDER BY rowid`),
+			scribble: (ctx) => {
+				insert(ctx.sql, "query", scribbled);
+			},
+			tables: (ctx) => tableNames(ctx.sql)
+		},
+		results: { release: released }
+	});
+	return engineOf(Akter$1.app([implemented])).layer.pipe(Layer.provide(Akter.jobs));
+};
+const createEntries = "CREATE TABLE entries (id TEXT PRIMARY KEY, amount INTEGER NOT NULL)";
+const createNotes = "CREATE TABLE notes (id TEXT PRIMARY KEY, text TEXT NOT NULL)";
+const entriesVersion = 1;
+const notesVersion = 2;
+const reservedVersion = 3;
+const plainLedgerIntruding = (prefix) => plainLedgerLayer({
+	[entriesVersion]: createEntries,
+	[notesVersion]: createNotes,
+	[reservedVersion]: `CREATE TABLE "${prefix}intruder" (id TEXT PRIMARY KEY)`
+});
+/** The plain SDK's Ledgers, for `conformanceOf({ engine, ledgers: plainLedgers, skip })`: every engine must pass the suite on both SDKs. */
+const plainLedgers = {
+	intruding: plainLedgerIntruding,
+	live: plainLedgerLayer({ [entriesVersion]: createEntries }),
+	patched: plainLedgerLayer({ [entriesVersion]: createEntries }, {
+		job: doublingRelease,
+		ledger: PatchedLedger
+	}),
+	withNotes: plainLedgerLayer({
+		[entriesVersion]: createEntries,
+		[notesVersion]: createNotes
+	})
+};
+export { plainLedgers };

package/dist/rejected.errors.d.mts

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+declare const RejectedError_base: Schema.Class<RejectedError, Schema.TaggedStruct<"RejectedError", {
+  readonly reason: Schema.Unknown;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class RejectedError extends RejectedError_base {}
+export {};

package/dist/rejected.errors.mjs

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+// src/rejected.errors.ts
+var RejectedError = class extends Schema.TaggedError()("RejectedError", { reason: Schema.Unknown }) {};
+export { RejectedError };