effect-machine 0.9.0 → 0.11.0

package/dist-v3/persistence/persistent-machine.d.ts

@@ -1,105 +0,0 @@
-import { EventBrand, StateBrand } from "../internal/brands.js";
-import { Machine } from "../machine.js";
-import { Schedule, Schema } from "effect";
-
-//#region src-v3/persistence/persistent-machine.d.ts
-type BrandedState = {
-  readonly _tag: string;
-} & StateBrand;
-type BrandedEvent = {
-  readonly _tag: string;
-} & EventBrand;
-/**
- * Configuration for persistence behavior (after resolution).
- * Schemas are required at runtime - the persist function ensures this.
- *
- * Note: Schema types S and E should match the structural shape of the machine's
- * state and event types (without brands). The schemas don't know about brands.
- */
-interface PersistenceConfig<S, E, SSI = unknown, ESI = unknown> {
-  /**
-   * Schedule controlling when snapshots are taken.
-   * Input is the new state after each transition.
-   *
-   * Examples:
-   * - Schedule.forever — snapshot every transition
-   * - Schedule.spaced("5 seconds") — debounced snapshots
-   * - Schedule.recurs(100) — every N transitions
-   */
-  readonly snapshotSchedule: Schedule.Schedule<unknown, S>;
-  /**
-   * Whether to journal events for replay capability.
-   * When true, all events are appended to the event log.
-   */
-  readonly journalEvents: boolean;
-  /**
-   * Schema for serializing/deserializing state.
-   * Always present at runtime (resolved from config or machine).
-   */
-  readonly stateSchema: Schema.Schema<S, SSI, never>;
-  /**
-   * Schema for serializing/deserializing events.
-   * Always present at runtime (resolved from config or machine).
-   */
-  readonly eventSchema: Schema.Schema<E, ESI, never>;
-  /**
-   * User-provided identifier for the machine type.
-   * Used for filtering actors in restoreAll.
-   * Optional — defaults to "unknown" if not provided.
-   */
-  readonly machineType?: string;
-}
-/**
- * Machine with persistence configuration attached.
- * Spawn auto-detects this and returns PersistentActorRef.
- */
-interface PersistentMachine<S extends {
-  readonly _tag: string;
-}, E extends {
-  readonly _tag: string;
-}, R = never> {
-  readonly _tag: "PersistentMachine";
-  readonly machine: Machine<S, E, R>;
-  readonly persistence: PersistenceConfig<S, E>;
-}
-/**
- * Type guard to check if a value is a PersistentMachine
- */
-declare const isPersistentMachine: (value: unknown) => value is PersistentMachine<{
-  readonly _tag: string;
-}, {
-  readonly _tag: string;
-}, unknown>;
-/**
- * Attach persistence configuration to a machine.
- *
- * Schemas are read from the machine - must use `Machine.make({ state, event, initial })`.
- *
- * @example
- * ```ts
- * const orderMachine = Machine.make({
- *   state: OrderState,
- *   event: OrderEvent,
- *   initial: OrderState.Idle(),
- * }).pipe(
- *   Machine.on(OrderState.Idle, OrderEvent.Submit, ({ event }) =>
- *     OrderState.Pending({ orderId: event.orderId })
- *   ),
- *   Machine.final(OrderState.Paid),
- *   Machine.persist({
- *     snapshotSchedule: Schedule.forever,
- *     journalEvents: true,
- *   }),
- * );
- * ```
- */
-interface WithPersistenceConfig {
-  readonly snapshotSchedule: Schedule.Schedule<unknown, {
-    readonly _tag: string;
-  }>;
-  readonly journalEvents: boolean;
-  readonly machineType?: string;
-}
-declare const persist: (config: WithPersistenceConfig) => <S extends BrandedState, E extends BrandedEvent, R>(machine: Machine<S, E, R>) => PersistentMachine<S, E, R>;
-//#endregion
-export { PersistenceConfig, PersistentMachine, WithPersistenceConfig, isPersistentMachine, persist };

package/dist-v3/persistence/persistent-machine.js

@@ -1,22 +0,0 @@
-import { MissingSchemaError } from "../errors.js";
-//#region src-v3/persistence/persistent-machine.ts
-/**
-* Type guard to check if a value is a PersistentMachine
-*/
-const isPersistentMachine = (value) => typeof value === "object" && value !== null && "_tag" in value && value._tag === "PersistentMachine";
-const persist = (config) => (machine) => {
-	const stateSchema = machine.stateSchema;
-	const eventSchema = machine.eventSchema;
-	if (stateSchema === void 0 || eventSchema === void 0) throw new MissingSchemaError({ operation: "persist" });
-	return {
-		_tag: "PersistentMachine",
-		machine,
-		persistence: {
-			...config,
-			stateSchema,
-			eventSchema
-		}
-	};
-};
-//#endregion
-export { isPersistentMachine, persist };