effect-machine 0.10.0 → 0.12.0

package/v3/dist/machine.js

@@ -1,11 +1,10 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { Inspector } from "./inspection.js";
-import { getTag } from "./internal/utils.js";
+import { getTag, makeReply, stubSystem } from "./internal/utils.js";
 import { ProvisionValidationError, SlotProvisionError } from "./errors.js";
-import { persist } from "./persistence/persistent-machine.js";
 import { emitWithTimestamp } from "./internal/inspection.js";
 import { MachineContextTag } from "./slot.js";
-import { findTransitions, invalidateIndex } from "./internal/transition.js";
+import { findTransitions, invalidateIndex, resolveTransition, runTransitionHandler, shouldPostpone } from "./internal/transition.js";
 import { createActor } from "./actor.js";
 import { Cause, Effect, Exit, Option, Scope } from "effect";
 //#region src/machine.ts
@@ -14,6 +13,8 @@ var machine_exports = /* @__PURE__ */ __exportAll({
 	Machine: () => Machine,
 	findTransitions: () => findTransitions,
 	make: () => make,
+	replay: () => replay,
+	reply: () => reply,
 	spawn: () => spawn
 });
 const emitTaskInspection = (input) => Effect.flatMap(Effect.serviceOptional(Inspector).pipe(Effect.option), (inspector) => Option.isNone(inspector) ? Effect.void : emitWithTimestamp(inspector.value, (timestamp) => ({
@@ -42,9 +43,6 @@ var BuiltMachine = class {
 	get initial() {
 		return this._inner.initial;
 	}
-	persist(config) {
-		return this._inner.persist(config);
-	}
 };
 /**
 * Machine definition with fluent builder API.
@@ -72,6 +70,7 @@ var Machine = class Machine {
 	/** @internal */ _slots;
 	stateSchema;
 	eventSchema;
+	/** @internal */ _replySchemas;
 	/**
 	* Context tag for accessing machine state/event/self in slot handlers.
 	* Uses shared module-level tag for all machines.
@@ -98,6 +97,9 @@ var Machine = class Machine {
 	get effectsSchema() {
 		return this._effectsSchema;
 	}
+	get replySchemas() {
+		return this._replySchemas;
+	}
 	/** @internal */
 	constructor(initial, stateSchema, eventSchema, guardsSchema, effectsSchema) {
 		this.initial = initial;
@@ -112,6 +114,7 @@ var Machine = class Machine {
 		this._effectHandlers = /* @__PURE__ */ new Map();
 		this.stateSchema = stateSchema;
 		this.eventSchema = eventSchema;
+		this._replySchemas = eventSchema?._replySchemas ?? /* @__PURE__ */ new Map();
 		this._slots = {
 			guards: this._guardsSchema !== void 0 ? this._guardsSchema._createSlots((name, params) => Effect.flatMap(Effect.serviceOptional(this.Context).pipe(Effect.orDie), (ctx) => {
 				const handler = this._guardHandlers.get(name);
@@ -374,6 +377,7 @@ var Machine = class Machine {
 			result._spawnEffects = [...this._spawnEffects];
 			result._backgroundEffects = [...this._backgroundEffects];
 			result._postponeRules = [...this._postponeRules];
+			result._replySchemas = this._replySchemas;
 			const anyHandlers = handlers;
 			if (this._guardsSchema !== void 0) for (const name of Object.keys(this._guardsSchema.definitions)) result._guardHandlers.set(name, anyHandlers[name]);
 			if (this._effectsSchema !== void 0) for (const name of Object.keys(this._effectsSchema.definitions)) result._effectHandlers.set(name, anyHandlers[name]);
@@ -381,10 +385,6 @@ var Machine = class Machine {
 		}
 		return new BuiltMachine(this);
 	}
-	/** @internal Persist from raw Machine — prefer BuiltMachine.persist() */
-	persist(config) {
-		return persist(config)(this);
-	}
 	static make(config) {
 		return new Machine(config.initial, config.state, config.event, config.guards, config.effects);
 	}
@@ -404,11 +404,69 @@ var TransitionScope = class {
 	}
 };
 const make = Machine.make;
-const spawn = Effect.fn("effect-machine.spawn")(function* (built, id) {
-	const actor = yield* createActor(id ?? `actor-${Math.random().toString(36).slice(2)}`, built._inner);
+/**
+* Spawn an actor from a built machine.
+*
+* Options:
+* - `id` — custom actor ID (default: random)
+* - `hydrate` — restore from a previously-saved state snapshot.
+*   The actor starts in the hydrated state and re-runs spawn effects
+*   for that state (timers, scoped resources, etc.). Transition history
+*   is not replayed — only the current state's entry effects run.
+*
+* Persistence is composed in userland by observing `actor.changes`
+* and saving snapshots to your own storage.
+*/
+const spawn = Effect.fn("effect-machine.spawn")(function* (built, idOrOptions) {
+	const opts = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+	const actor = yield* createActor(opts?.id ?? `actor-${Math.random().toString(36).slice(2)}`, built._inner, { initialState: opts?.hydrate });
 	const maybeScope = yield* Effect.serviceOption(Scope.Scope);
 	if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, actor.stop);
 	return actor;
 });
+const replay = Effect.fn("effect-machine.replay")(function* (built, events, options) {
+	const machine = built._inner;
+	let state = options?.from ?? machine.initial;
+	const hasPostponeRules = machine.postponeRules.length > 0;
+	const postponed = [];
+	const dummySend = Effect.fn("effect-machine.replay.send")((_event) => Effect.void);
+	const self = {
+		send: dummySend,
+		cast: dummySend,
+		spawn: () => Effect.die("spawn not supported in replay")
+	};
+	for (const event of events) {
+		if (machine.finalStates.has(state._tag)) break;
+		if (hasPostponeRules && shouldPostpone(machine, state._tag, event._tag)) {
+			postponed.push(event);
+			continue;
+		}
+		const transition = resolveTransition(machine, state, event);
+		if (transition !== void 0) {
+			const result = yield* runTransitionHandler(machine, transition, state, event, self, stubSystem, "replay");
+			const previousTag = state._tag;
+			state = result.newState;
+			if ((state._tag !== previousTag || transition.reenter === true) && postponed.length > 0) {
+				let drainTag = previousTag;
+				while (state._tag !== drainTag && postponed.length > 0) {
+					if (machine.finalStates.has(state._tag)) break;
+					drainTag = state._tag;
+					const drained = postponed.splice(0);
+					for (const postponedEvent of drained) {
+						if (machine.finalStates.has(state._tag)) break;
+						if (shouldPostpone(machine, state._tag, postponedEvent._tag)) {
+							postponed.push(postponedEvent);
+							continue;
+						}
+						const pTransition = resolveTransition(machine, state, postponedEvent);
+						if (pTransition !== void 0) state = (yield* runTransitionHandler(machine, pTransition, state, postponedEvent, self, stubSystem, "replay")).newState;
+					}
+				}
+			}
+		}
+	}
+	return state;
+});
+const reply = makeReply;
 //#endregion
-export { BuiltMachine, Machine, findTransitions, machine_exports, make, spawn };
+export { BuiltMachine, Machine, findTransitions, machine_exports, make, replay, reply, spawn };

package/v3/dist/schema.d.ts

@@ -1,7 +1,17 @@
-import { FullEventBrand, FullStateBrand } from "./internal/brands.js";
+import { FullEventBrand, FullStateBrand, ReplyTypeBrand } from "./internal/brands.js";
 import { Schema } from "effect";
 
 //#region src/schema.d.ts
+declare const ReplySchemaSymbol: unique symbol;
+type ReplySchemaSymbol = typeof ReplySchemaSymbol;
+/**
+ * Fields annotated with a reply schema.
+ * Structurally identical to Schema.Struct.Fields at runtime,
+ * but carries the reply schema type at compile time.
+ */
+type ReplyFields<F extends Schema.Struct.Fields, RS extends Schema.Schema.Any> = F & {
+  readonly [ReplySchemaSymbol]: RS;
+};
 /**
  * Extract the TypeScript type from a TaggedStruct schema
  */
@@ -12,20 +22,23 @@ type TaggedStructType<Tag extends string, Fields extends Schema.Struct.Fields> =
 type VariantSchemas<D extends Record<string, Schema.Struct.Fields>> = { readonly [K in keyof D & string]: Schema.TaggedStruct<K, D[K]> };
 /**
  * Build union type from variant schemas.
- * Used for constraining fluent method type params.
+ * Reply-bearing variants carry ReplyTypeBrand<R> for ask() inference.
  */
-type VariantsUnion<D extends Record<string, Schema.Struct.Fields>> = { [K in keyof D & string]: TaggedStructType<K, D[K]> }[keyof D & string];
+type VariantsUnion<D extends Record<string, Schema.Struct.Fields>> = { [K in keyof D & string]: TaggedStructType<K, D[K]> & (D[K] extends {
+  readonly [ReplySchemaSymbol]: Schema.Schema<infer R, infer _I, infer _RR>;
+} ? ReplyTypeBrand<R> : unknown) }[keyof D & string];
 /**
- * Check if fields are empty (no required properties)
+ * Check if fields are empty (no required string properties).
+ * Symbol keys (like ReplySchemaSymbol) are metadata, not payload fields.
  */
-type IsEmptyFields<Fields extends Schema.Struct.Fields> = keyof Fields extends never ? true : false;
+type IsEmptyFields<Fields extends Schema.Struct.Fields> = string & keyof Fields extends never ? true : false;
 /**
- * Constructor functions for each variant.
- * Empty structs: plain values with `_tag`: `State.Idle`
- * Non-empty structs require args: `State.Loading({ url })`
- *
- * Each variant also has a `derive` method for constructing from a source object.
+ * Resolve the reply brand for a variant's fields.
+ * If fields carry ReplySchemaSymbol, adds ReplyTypeBrand<R>.
  */
+type VariantReplyBrand<Fields extends Schema.Struct.Fields> = Fields extends {
+  readonly [ReplySchemaSymbol]: Schema.Schema<infer R, infer _I, infer _RR>;
+} ? ReplyTypeBrand<R> : unknown;
 /**
  * Constructor functions for each variant.
  * Empty structs: plain values with `_tag`: `State.Idle`
@@ -33,10 +46,11 @@ type IsEmptyFields<Fields extends Schema.Struct.Fields> = keyof Fields extends n
  *
  * Each variant also has a `derive` method for constructing from a source object.
  * The source type uses `object` to accept branded state types without index signature issues.
+ * Reply-bearing variants carry ReplyTypeBrand<R> for ask() type inference.
  */
-type VariantConstructors<D extends Record<string, Schema.Struct.Fields>, Brand> = { readonly [K in keyof D & string]: IsEmptyFields<D[K]> extends true ? TaggedStructType<K, D[K]> & Brand & {
+type VariantConstructors<D extends Record<string, Schema.Struct.Fields>, Brand> = { readonly [K in keyof D & string]: IsEmptyFields<D[K]> extends true ? TaggedStructType<K, D[K]> & Brand & VariantReplyBrand<D[K]> & {
   readonly derive: (source: object) => TaggedStructType<K, D[K]> & Brand;
-} : ((args: Schema.Struct.Constructor<D[K]>) => TaggedStructType<K, D[K]> & Brand) & {
+} : ((args: Schema.Struct.Constructor<D[K]>) => TaggedStructType<K, D[K]> & Brand & VariantReplyBrand<D[K]>) & {
   readonly derive: (source: object, partial?: Partial<Schema.Struct.Constructor<D[K]>>) => TaggedStructType<K, D[K]> & Brand;
   readonly _tag: K;
 } };
@@ -56,6 +70,11 @@ interface MachineSchemaBase<D extends Record<string, Schema.Struct.Fields>, Bran
    * Per-variant schemas for fine-grained operations
    */
   readonly variants: VariantSchemas<D>;
+  /**
+   * Reply schemas per variant tag. Only populated for event schemas
+   * with variants defined via `Event.reply()`.
+   */
+  readonly _replySchemas: ReadonlyMap<string, Schema.Schema.Any>;
   /**
    * Type guard: `OrderState.$is("Pending")(value)`
    */
@@ -116,26 +135,8 @@ type MachineEventSchema<D extends Record<string, Schema.Struct.Fields>> = Schema
  * ```
  */
 declare const State: <const D extends Record<string, Schema.Struct.Fields>>(definition: D) => MachineStateSchema<D>;
-/**
- * Create a schema-first Event definition.
- *
- * The schema's definition type D creates a unique brand, preventing
- * accidental use of constructors from different event schemas
- * (unless they have identical definitions).
- *
- * @example
- * ```ts
- * const OrderEvent = MachineSchema.Event({
- *   Ship: { trackingId: Schema.String },
- *   Cancel: {},
- * })
- *
- * type OrderEvent = typeof OrderEvent.Type
- *
- * // Construct
- * const e = OrderEvent.Ship({ trackingId: "abc" })
- * ```
- */
-declare const Event: <const D extends Record<string, Schema.Struct.Fields>>(definition: D) => MachineEventSchema<D>;
+declare const Event: (<const D extends Record<string, Schema.Struct.Fields>>(definition: D) => MachineEventSchema<D>) & {
+  reply: <F extends Schema.Struct.Fields, RS extends Schema.Schema.Any>(fields: F, replySchema: RS) => ReplyFields<F, RS>;
+};
 //#endregion
-export { Event, MachineEventSchema, MachineStateSchema, State, VariantsUnion };
+export { Event, MachineEventSchema, MachineStateSchema, ReplyFields, ReplySchemaSymbol, State, VariantsUnion };

package/v3/dist/schema.js

@@ -38,15 +38,21 @@ import { Schema } from "effect";
 *
 * @module
 */
+const ReplySchemaSymbol = Symbol.for("effect-machine/ReplySchema");
 /**
 * Build a schema-first definition from a record of tag -> fields
 */
 const buildMachineSchema = (definition) => {
 	const variants = {};
 	const constructors = {};
+	const replySchemas = /* @__PURE__ */ new Map();
 	for (const tag of Object.keys(definition)) {
 		const fields = definition[tag];
 		if (fields === void 0) continue;
+		if (ReplySchemaSymbol in fields) {
+			const rs = fields[ReplySchemaSymbol];
+			if (rs !== void 0) replySchemas.set(tag, rs);
+		}
 		variants[tag] = Schema.TaggedStruct(tag, fields);
 		const fieldNames = new Set(Object.keys(fields));
 		if (fieldNames.size > 0) {
@@ -93,6 +99,7 @@ const buildMachineSchema = (definition) => {
 		variants,
 		constructors,
 		_definition: definition,
+		_replySchemas: replySchemas,
 		$is,
 		$match
 	};
@@ -102,10 +109,11 @@ const buildMachineSchema = (definition) => {
 * Builds the schema object with variants, constructors, $is, and $match.
 */
 const createMachineSchema = (definition) => {
-	const { schema, variants, constructors, _definition, $is, $match } = buildMachineSchema(definition);
+	const { schema, variants, constructors, _definition, _replySchemas, $is, $match } = buildMachineSchema(definition);
 	return Object.assign(Object.create(schema), {
 		variants,
 		_definition,
+		_replySchemas,
 		$is,
 		$match,
 		...constructors
@@ -148,11 +156,15 @@ const State = (definition) => createMachineSchema(definition);
 * accidental use of constructors from different event schemas
 * (unless they have identical definitions).
 *
+* Use `Event.reply(fields, replySchema)` to define events that support
+* typed `ask()` replies.
+*
 * @example
 * ```ts
-* const OrderEvent = MachineSchema.Event({
+* const OrderEvent = Event({
 *   Ship: { trackingId: Schema.String },
 *   Cancel: {},
+*   GetTotal: Event.reply({}, Schema.Number),
 * })
 *
 * type OrderEvent = typeof OrderEvent.Type
@@ -161,6 +173,20 @@ const State = (definition) => createMachineSchema(definition);
 * const e = OrderEvent.Ship({ trackingId: "abc" })
 * ```
 */
-const Event = (definition) => createMachineSchema(definition);
+const EventImpl = (definition) => createMachineSchema(definition);
+/**
+* Annotate event fields with a reply schema.
+* Events defined with `Event.reply(fields, replySchema)` enable typed `ask()`.
+*/
+const replyFieldsFn = (fields, replySchema) => {
+	const annotated = { ...fields };
+	Object.defineProperty(annotated, ReplySchemaSymbol, {
+		value: replySchema,
+		enumerable: false,
+		writable: false
+	});
+	return annotated;
+};
+const Event = Object.assign(EventImpl, { reply: replyFieldsFn });
 //#endregion
 export { Event, State };

package/dist/persistence/adapter.d.ts

@@ -1,135 +0,0 @@
-import { DuplicateActorError } from "../errors.js";
-import { PersistentActorRef } from "./persistent-actor.js";
-import { Effect, Option, Schema, ServiceMap } from "effect";
-import * as effect_Cause0 from "effect/Cause";
-
-//#region src/persistence/adapter.d.ts
-/**
- * Metadata for a persisted actor.
- * Used for discovery and filtering during bulk restore.
- */
-interface ActorMetadata {
-  readonly id: string;
-  /** User-provided identifier for the machine type */
-  readonly machineType: string;
-  readonly createdAt: number;
-  readonly lastActivityAt: number;
-  readonly version: number;
-  /** Current state _tag value */
-  readonly stateTag: string;
-}
-/**
- * Result of a bulk restore operation.
- * Contains both successfully restored actors and failures.
- */
-interface RestoreResult<S extends {
-  readonly _tag: string;
-}, E extends {
-  readonly _tag: string;
-}, R = never> {
-  readonly restored: ReadonlyArray<PersistentActorRef<S, E, R>>;
-  readonly failed: ReadonlyArray<RestoreFailure>;
-}
-/**
- * A single restore failure with actor ID and error details.
- */
-interface RestoreFailure {
-  readonly id: string;
-  readonly error: PersistenceError | DuplicateActorError;
-}
-/**
- * Snapshot of actor state at a point in time
- */
-interface Snapshot<S> {
-  readonly state: S;
-  readonly version: number;
-  readonly timestamp: number;
-}
-/**
- * Persisted event with metadata
- */
-interface PersistedEvent<E> {
-  readonly event: E;
-  readonly version: number;
-  readonly timestamp: number;
-}
-/**
- * Adapter for persisting actor state and events.
- *
- * Implementations handle serialization and storage of snapshots and event journals.
- * Schema parameters ensure type-safe serialization/deserialization.
- * Schemas must have no context requirements (use Schema<S, SI, never>).
- */
-interface PersistenceAdapter {
-  /**
-   * Save a snapshot of actor state.
-   * Implementations should use optimistic locking — fail if version mismatch.
-   */
-  readonly saveSnapshot: <S>(id: string, snapshot: Snapshot<S>, schema: Schema.Codec<S, unknown, never, never>) => Effect.Effect<void, PersistenceError | VersionConflictError>;
-  /**
-   * Load the latest snapshot for an actor.
-   * Returns None if no snapshot exists.
-   */
-  readonly loadSnapshot: <S>(id: string, schema: Schema.Codec<S, unknown, never, never>) => Effect.Effect<Option.Option<Snapshot<S>>, PersistenceError>;
-  /**
-   * Append an event to the actor's event journal.
-   */
-  readonly appendEvent: <E>(id: string, event: PersistedEvent<E>, schema: Schema.Codec<E, unknown, never, never>) => Effect.Effect<void, PersistenceError>;
-  /**
-   * Load events from the journal, optionally after a specific version.
-   */
-  readonly loadEvents: <E>(id: string, schema: Schema.Codec<E, unknown, never, never>, afterVersion?: number) => Effect.Effect<ReadonlyArray<PersistedEvent<E>>, PersistenceError>;
-  /**
-   * Delete all persisted data for an actor (snapshot + events).
-   */
-  readonly deleteActor: (id: string) => Effect.Effect<void, PersistenceError>;
-  /**
-   * List all persisted actor metadata.
-   * Optional — adapters without registry support can omit this.
-   */
-  readonly listActors?: () => Effect.Effect<ReadonlyArray<ActorMetadata>, PersistenceError>;
-  /**
-   * Save or update actor metadata.
-   * Called on spawn and state transitions.
-   * Optional — adapters without registry support can omit this.
-   */
-  readonly saveMetadata?: (metadata: ActorMetadata) => Effect.Effect<void, PersistenceError>;
-  /**
-   * Delete actor metadata.
-   * Called when actor is deleted.
-   * Optional — adapters without registry support can omit this.
-   */
-  readonly deleteMetadata?: (id: string) => Effect.Effect<void, PersistenceError>;
-  /**
-   * Load metadata for a specific actor by ID.
-   * Returns None if no metadata exists.
-   * Optional — adapters without registry support can omit this.
-   */
-  readonly loadMetadata?: (id: string) => Effect.Effect<Option.Option<ActorMetadata>, PersistenceError>;
-}
-declare const PersistenceError_base: Schema.ErrorClass<PersistenceError, Schema.TaggedStruct<"PersistenceError", {
-  readonly operation: Schema.String;
-  readonly actorId: Schema.String;
-  readonly cause: Schema.optional<Schema.Unknown>;
-  readonly message: Schema.optional<Schema.String>;
-}>, effect_Cause0.YieldableError>;
-/**
- * Error type for persistence operations
- */
-declare class PersistenceError extends PersistenceError_base {}
-declare const VersionConflictError_base: Schema.ErrorClass<VersionConflictError, Schema.TaggedStruct<"VersionConflictError", {
-  readonly actorId: Schema.String;
-  readonly expectedVersion: Schema.Number;
-  readonly actualVersion: Schema.Number;
-}>, effect_Cause0.YieldableError>;
-/**
- * Version conflict error — snapshot version doesn't match expected
- */
-declare class VersionConflictError extends VersionConflictError_base {}
-declare const PersistenceAdapterTag_base: ServiceMap.ServiceClass<PersistenceAdapterTag, "effect-machine/src/persistence/adapter/PersistenceAdapterTag", PersistenceAdapter>;
-/**
- * PersistenceAdapter service tag
- */
-declare class PersistenceAdapterTag extends PersistenceAdapterTag_base {}
-//#endregion
-export { ActorMetadata, PersistedEvent, PersistenceAdapter, PersistenceAdapterTag, PersistenceError, RestoreFailure, RestoreResult, Snapshot, VersionConflictError };

package/dist/persistence/adapter.js

@@ -1,25 +0,0 @@
-import { Schema, ServiceMap } from "effect";
-//#region src/persistence/adapter.ts
-/**
-* Error type for persistence operations
-*/
-var PersistenceError = class extends Schema.TaggedErrorClass()("PersistenceError", {
-	operation: Schema.String,
-	actorId: Schema.String,
-	cause: Schema.optional(Schema.Unknown),
-	message: Schema.optional(Schema.String)
-}) {};
-/**
-* Version conflict error — snapshot version doesn't match expected
-*/
-var VersionConflictError = class extends Schema.TaggedErrorClass()("VersionConflictError", {
-	actorId: Schema.String,
-	expectedVersion: Schema.Number,
-	actualVersion: Schema.Number
-}) {};
-/**
-* PersistenceAdapter service tag
-*/
-var PersistenceAdapterTag = class extends ServiceMap.Service()("effect-machine/src/persistence/adapter/PersistenceAdapterTag") {};
-//#endregion
-export { PersistenceAdapterTag, PersistenceError, VersionConflictError };

package/dist/persistence/adapters/in-memory.d.ts

@@ -1,32 +0,0 @@
-import { PersistenceAdapter, PersistenceAdapterTag } from "../adapter.js";
-import { Effect, Layer } from "effect";
-
-//#region src/persistence/adapters/in-memory.d.ts
-/**
- * Create an in-memory persistence adapter effect.
- * Returns the adapter directly for custom layer composition.
- */
-declare const makeInMemoryPersistenceAdapter: Effect.Effect<PersistenceAdapter, never, never>;
-/**
- * In-memory persistence adapter layer.
- * Data is not persisted across process restarts.
- *
- * NOTE: Each `Effect.provide(InMemoryPersistenceAdapter)` creates a NEW adapter
- * with empty storage. For tests that need persistent storage across multiple
- * runPromise calls, use `makeInMemoryPersistenceAdapter` with a shared scope.
- *
- * @example
- * ```ts
- * const program = Effect.gen(function* () {
- *   const system = yield* ActorSystemService;
- *   const actor = yield* system.spawn("my-actor", persistentMachine);
- *   // ...
- * }).pipe(
- *   Effect.provide(InMemoryPersistenceAdapter),
- *   Effect.provide(ActorSystemDefault),
- * );
- * ```
- */
-declare const InMemoryPersistenceAdapter: Layer.Layer<PersistenceAdapterTag>;
-//#endregion
-export { InMemoryPersistenceAdapter, makeInMemoryPersistenceAdapter };