@rotorsoft/act 1.32.29 → 1.33.0

package/dist/@types/builders/projection-builder.d.ts

@@ -1,146 +1,5 @@
-/**
- * @module projection-builder
- * @category Builders
- *
- * Fluent builder for composing projection handlers — read-model updaters
- * that react to events and update external state (databases, caches, etc.).
- *
- * Projections differ from slices: they don't contain states, don't dispatch
- * actions, and are pure side-effect handlers routed to a named stream.
- */
-import type { ZodType } from "zod";
-import { type FoldConfig } from "../internal/index.js";
-import type { BatchHandler, CacheEntry, Committed, EventRegister, FoldOptions, ReactionResolver, Schema, Schemas, State } from "../types/index.js";
-/**
- * A self-contained projection grouping read-model update handlers.
- * Projections are composed into an Act orchestrator via `act().withProjection(projection)`.
- *
- * @template TEvents - Event schemas handled by this projection
- */
-export type Projection<TEvents extends Schemas> = {
-    readonly _tag: "Projection";
-    readonly events: EventRegister<TEvents>;
-    readonly target?: string;
-    readonly batchHandler?: BatchHandler<TEvents>;
-    /**
-     * State-fold spec from `.of()`. The builder only records intent — the
-     * orchestrator resolves the REGISTRY-MERGED full state at
-     * `act().build()` and synthesizes the batch handler there, so the
-     * fold always covers every reducer of the state, including partials
-     * merged by slices the projection never saw.
-     * @internal
-     */
-    readonly fold?: {
-        readonly name: string;
-        readonly flush: (rows: ReadonlyArray<CacheEntry<any>>) => Promise<void>;
-        readonly config: FoldConfig;
-    };
-};
-/**
- * The `.of()` continuation: state projections flush the cache layer
- * outward — the rows ARE the streams' {@link CacheEntry} values, one
- * per dirty stream per flush round. Must be an idempotent upsert keyed
- * on `stream` (guard with `event_id` for order safety when a rebuild
- * races a live worker).
- */
-type FoldFlush<TState extends Schema, TE extends Schemas> = {
-    flush: (handler: (rows: ReadonlyArray<CacheEntry<TState>>) => Promise<void>) => {
-        build: () => Projection<TE>;
-    };
-};
-/**
- * `.of()` accepts the partials of ONE state (same name, enforced at the
- * type level via `TName`) purely for typing and event registration —
- * the fold itself always runs on the registry-merged full state,
- * resolved at `act().build()`. Passing every partial is required: the
- * orchestrator validates completeness at build and throws on missing
- * events.
- */
-type OfSignatures = {
-    <TS1 extends Schema, TE1 extends Schemas, TA1 extends Schemas, TN extends string>(s1: State<TS1, TE1, TA1, TN>, options?: FoldOptions): FoldFlush<TS1, TE1>;
-    <TS1 extends Schema, TE1 extends Schemas, TA1 extends Schemas, TS2 extends Schema, TE2 extends Schemas, TA2 extends Schemas, TN extends string>(s1: State<TS1, TE1, TA1, TN>, s2: State<TS2, TE2, TA2, TN>, options?: FoldOptions): FoldFlush<TS1 & TS2, TE1 & TE2>;
-    <TS1 extends Schema, TE1 extends Schemas, TA1 extends Schemas, TS2 extends Schema, TE2 extends Schemas, TA2 extends Schemas, TS3 extends Schema, TE3 extends Schemas, TA3 extends Schemas, TN extends string>(s1: State<TS1, TE1, TA1, TN>, s2: State<TS2, TE2, TA2, TN>, s3: State<TS3, TE3, TA3, TN>, options?: FoldOptions): FoldFlush<TS1 & TS2 & TS3, TE1 & TE2 & TE3>;
-    <TS1 extends Schema, TE1 extends Schemas, TA1 extends Schemas, TS2 extends Schema, TE2 extends Schemas, TA2 extends Schemas, TS3 extends Schema, TE3 extends Schemas, TA3 extends Schemas, TS4 extends Schema, TE4 extends Schemas, TA4 extends Schemas, TN extends string>(s1: State<TS1, TE1, TA1, TN>, s2: State<TS2, TE2, TA2, TN>, s3: State<TS3, TE3, TA3, TN>, s4: State<TS4, TE4, TA4, TN>, options?: FoldOptions): FoldFlush<TS1 & TS2 & TS3 & TS4, TE1 & TE2 & TE3 & TE4>;
-};
-/** Helper: a single-key record mapping an event name to its Zod schema. */
-type EventEntry<TKey extends string = string, TData extends Schema = Schema> = {
-    [P in TKey]: ZodType<TData>;
-};
-/** Infer the handler-result type after registering one event. */
-type DoResult<TEvents extends Schemas, TKey extends string, TData extends Schema, TTarget extends string | undefined = undefined> = ProjectionBuilder<TEvents & {
-    [P in TKey]: TData;
-}, TTarget, true> & {
-    to: (resolver: ReactionResolver<TEvents & {
-        [P in TKey]: TData;
-    }, TKey> | string) => ProjectionBuilder<TEvents & {
-        [P in TKey]: TData;
-    }, TTarget, true>;
-};
-/**
- * Fluent builder interface for composing projections.
- *
- * When a static target is provided via `projection("target")`, the builder
- * exposes a `.batch()` method for registering a batch handler that processes
- * all events in a single call.
- *
- * @template TEvents - Event schemas
- * @template TTarget - Static target string or undefined
- */
-export type ProjectionBuilder<TEvents extends Schemas, TTarget extends string | undefined = undefined, THasHandlers extends boolean = false> = {
-    /**
-     * Begins defining a projection handler for a specific event.
-     *
-     * Pass a `{ EventName: schema }` record — use shorthand `{ EventName }`
-     * when the variable name matches the event name. The key becomes the
-     * event name, the value the Zod schema.
-     */
-    on: <TKey extends string, TData extends Schema>(entry: EventEntry<TKey, TData>) => {
-        do: (handler: (event: Committed<TEvents & {
-            [P in TKey]: TData;
-        }, TKey>, stream: string) => Promise<void>) => DoResult<TEvents, TKey, TData, TTarget>;
-    };
-    /**
-     * Builds and returns the Projection data structure.
-     */
-    build: () => Projection<TEvents>;
-    /**
-     * The registered event schemas and their reaction maps.
-     */
-    readonly events: EventRegister<TEvents>;
-} & (TTarget extends string ? {
-    /**
-     * Registers a batch handler that processes all events in a single call.
-     *
-     * Only available on projections with a static target (`projection("target")`).
-     * The handler receives a discriminated union of all declared events,
-     * enabling bulk DB operations in a single transaction.
-     *
-     * When defined, the batch handler is always called — even for a single event.
-     * Individual `.do()` handlers serve as fallback for projections without `.batch()`.
-     */
-    batch: (handler: BatchHandler<TEvents>) => {
-        build: () => Projection<TEvents>;
-    };
-} & (THasHandlers extends false ? {
-    /**
-     * Declares a state projection: fold every event of the given
-     * state through its own reducers and flush one row per stream —
-     * the queryable list of the aggregates themselves.
-     *
-     * The state is the filter: the projection consumes exactly the
-     * state's event register, so in a multi-state app only that
-     * state's streams are folded — and every event of a folded
-     * stream reaches the reducer. Write amplification tracks the
-     * distinct stream count, not the event count; `app.reset`
-     * rebuilds in O(streams) upserts.
-     *
-     * The fluent chain enforces the shape: `.of()` is only offered
-     * before any `.on()` handler, and narrows to `.flush()` +
-     * `.build()` — a projection either folds a state or declares
-     * handlers, never both.
-     */
-    of: OfSignatures;
-} : {}) : {});
+import type { ProjectionBuilder } from "../types/builders.js";
+import type { Schemas } from "../types/index.js";
 /**
  * Creates a new projection builder with a static target stream.
  *
@@ -156,5 +15,4 @@ export declare function projection<TEvents extends Schemas = {}>(target: string)
  * Use per-handler `.to()` to route events to different streams.
  */
 export declare function projection<TEvents extends Schemas = {}>(target?: undefined): ProjectionBuilder<TEvents, undefined>;
-export {};
 //# sourceMappingURL=projection-builder.d.ts.map

package/dist/@types/builders/projection-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"projection-builder.d.ts","sourceRoot":"","sources":["../../../src/builders/projection-builder.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"projection-builder.d.ts","sourceRoot":"","sources":["../../../src/builders/projection-builder.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGV,iBAAiB,EAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EASV,OAAO,EAER,MAAM,mBAAmB,CAAC;AA8M3B;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,OAAO,SAAS,OAAO,GAAG,EAAE,EACrD,MAAM,EAAE,MAAM,GACb,iBAAiB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;AACtC;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,OAAO,SAAS,OAAO,GAAG,EAAE,EACrD,MAAM,CAAC,EAAE,SAAS,GACjB,iBAAiB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC"}

package/dist/@types/builders/slice-builder.d.ts

@@ -5,77 +5,8 @@
  * Fluent builder for composing partial states with scoped reactions into
  * self-contained functional slices (vertical slice architecture).
  */
-import type { DEFAULT_LANE } from "../ports.js";
-import type { Actor, EventRegister, LaneConfig, Schema, SchemaRegister, Schemas, State } from "../types/index.js";
-import type { BuilderBase } from "./builder-base.js";
-import type { Projection } from "./projection-builder.js";
-/**
- * A self-contained functional slice grouping partial states with their
- * scoped reactions. Slices are composed into an Act orchestrator via
- * `act().withSlice(slice)`.
- *
- * @template TSchemaReg - Schema register for states
- * @template TEvents - Event schemas from this slice's states
- * @template TActions - Action schemas from this slice's states
- * @template TStateMap - Map of state names to state schemas
- * @template TActor - Actor type extending base Actor
- */
-export type Slice<TSchemaReg extends SchemaRegister<TActions>, TEvents extends Schemas, TActions extends Schemas, TStateMap extends Record<string, Schema> = {}, TActor extends Actor = Actor, TLanes extends string = typeof DEFAULT_LANE> = {
-    readonly _tag: "Slice";
-    readonly states: Map<string, State<any, any, any>>;
-    readonly events: EventRegister<TEvents>;
-    readonly projections: ReadonlyArray<Projection<any>>;
-    /**
-     * Drain lanes declared on this slice via `.withLane(...)`.
-     * `act().withSlice(slice)` merges these into the Act's lane set so
-     * `.to({lane})` is statically checked at the slice's call site against
-     * the lanes the slice itself declared.
-     */
-    readonly lanes: ReadonlyArray<LaneConfig>;
-    /** @internal phantom field for type-level state schema tracking */
-    readonly _S?: TSchemaReg;
-    /** @internal phantom field for type-level state name tracking */
-    readonly _M?: TStateMap;
-    /** @internal phantom field for type-level actor tracking */
-    readonly _TActor?: TActor;
-    /** @internal phantom field for type-level lane union tracking */
-    readonly _TLanes?: TLanes;
-};
-/**
- * Fluent builder interface for composing functional slices.
- *
- * Provides a chainable API for registering states and projections,
- * and defining reactions scoped to the slice's own events.
- *
- * @template TSchemaReg - Schema register for states
- * @template TEvents - Event schemas
- * @template TActions - Action schemas
- * @template TStateMap - Map of state names to state schemas
- * @template TActor - Actor type extending base Actor
- */
-export interface SliceBuilder<TSchemaReg extends SchemaRegister<TActions>, TEvents extends Schemas, TActions extends Schemas, TStateMap extends Record<string, Schema> = {}, TActor extends Actor = Actor, TLanes extends string = typeof DEFAULT_LANE> extends BuilderBase<SliceBuilder<TSchemaReg, TEvents, TActions, TStateMap, TActor, TLanes>, TEvents, TActions, TActor, TLanes> {
-    /**
-     * Registers a state definition with the slice.
-     *
-     * Include every state whose actions your reaction handlers need to
-     * dispatch. Duplicate registrations (same state in multiple slices)
-     * are handled automatically at composition time.
-     */
-    withState: <TNewState extends Schema, TNewEvents extends Schemas, TNewActions extends Schemas, TNewName extends string = string>(state: State<TNewState, TNewEvents, TNewActions, TNewName>) => SliceBuilder<TSchemaReg & {
-        [K in keyof TNewActions]: TNewState;
-    }, TEvents & TNewEvents, TActions & TNewActions, TStateMap & {
-        [K in TNewName]: TNewState;
-    }, TActor, TLanes>;
-    /**
-     * Declares a drain lane on this slice. Merged into the
-     * parent Act's lane set by `act().withSlice(slice)`.
-     */
-    withLane: <const TConfig extends LaneConfig>(config: TConfig) => SliceBuilder<TSchemaReg, TEvents, TActions, TStateMap, TActor, TLanes | TConfig["name"]>;
-    /**
-     * Builds and returns the Slice data structure.
-     */
-    build: () => Slice<TSchemaReg, TEvents, TActions, TStateMap, TActor, TLanes>;
-}
+import type { SliceBuilder } from "../types/builders.js";
+import type { Actor, Schema, SchemaRegister, Schemas } from "../types/index.js";
 /**
  * Creates a new slice builder for composing partial states with scoped reactions.
  *

package/dist/@types/builders/slice-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slice-builder.d.ts","sourceRoot":"","sources":["../../../src/builders/slice-builder.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"slice-builder.d.ts","sourceRoot":"","sources":["../../../src/builders/slice-builder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAqB,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAC5E,OAAO,KAAK,EACV,KAAK,EAGL,MAAM,EACN,cAAc,EACd,OAAO,EAER,MAAM,mBAAmB,CAAC;AAM3B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,KAAK,CAEnB,UAAU,SAAS,cAAc,CAAC,QAAQ,CAAC,GAAG,EAAE,EAChD,OAAO,SAAS,OAAO,GAAG,EAAE,EAC5B,QAAQ,SAAS,OAAO,GAAG,EAAE,EAC7B,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,EAC7C,MAAM,SAAS,KAAK,GAAG,KAAK,KACzB,YAAY,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,CA+ClE"}

package/dist/@types/builders/state-builder.d.ts

@@ -1,378 +1,5 @@
-/**
- * @module state-builder
- * @category Builders
- *
- * Fluent interface for defining a strongly-typed state machine using Zod schemas.
- */
-import type { ZodType } from "zod";
-import { type AutoclosePolicy } from "../internal/index.js";
-import type { ActionHandler, ActionOptions, Actor, AutocloseArchiver, Committed, Invariant, PatchHandlers, Schema, Schemas, Snapshot, State, ZodTypes } from "../types/index.js";
-/**
- * Builder interface for defining a state with event sourcing.
- *
- * Provides a fluent API to configure the initial state, event types,
- * and event handlers (reducers) before moving to action configuration.
- *
- * @template TState - State schema type
- * @template TName - State name literal type
- *
- * @see {@link state} for usage examples
- * @see {@link ActionBuilder} for action configuration
- */
-export type StateBuilder<TState extends Schema, TName extends string = string> = {
-    /**
-     * Defines the initial state for new state instances.
-     *
-     * The init function is called when a new stream is created (first event).
-     * It can accept initial data or return a default state.
-     *
-     * @param init - Function returning the initial state
-     * @returns A builder with `.emits()` to declare event types
-     *
-     * @example
-     * ```typescript
-     * .init(() => ({ count: 0, created: new Date() }))
-     * ```
-     */
-    init: (init: () => Readonly<TState>) => {
-        /**
-         * Declares the event types that this state can emit.
-         *
-         * Events represent facts that have happened - they should be named in past tense.
-         * Each event is defined with a Zod schema for type safety and runtime validation.
-         *
-         * @template TEvents - Event schemas type
-         * @param events - Object mapping event names to Zod schemas
-         * @returns An ActionBuilder (with optional `.patch()` to override specific reducers)
-         *
-         * @example
-         * ```typescript
-         * .emits({
-         *   Incremented: z.object({ amount: z.number() }),
-         *   Decremented: z.object({ amount: z.number() }),
-         *   Reset: z.object({})
-         * })
-         * ```
-         */
-        emits: <TEvents extends Schemas>(events: ZodTypes<TEvents>) => ActionBuilder<TState, TEvents, {}, TName> & {
-            /**
-             * Overrides specific event reducers. Events without a custom patch
-             * default to passthrough: `({ data }) => data` (event data merges
-             * into state).
-             *
-             * @param patch - Partial map of event names to patch handler functions
-             * @returns An ActionBuilder for defining actions
-             *
-             * @example Only override the events that need custom logic
-             * ```typescript
-             * .emits({ TicketOpened, TicketClosed, TicketResolved })
-             * .patch({
-             *   TicketOpened: ({ data }) => {
-             *     const { message, messageId, userId, ...other } = data;
-             *     return { ...other, userId, messages: { [messageId]: { ... } } };
-             *   },
-             * })
-             * // TicketClosed and TicketResolved use passthrough
-             * ```
-             */
-            patch: (patch: Partial<PatchHandlers<TState, TEvents>>) => ActionBuilder<TState, TEvents, {}, TName>;
-        };
-    };
-};
-/** Helper: a single-key record mapping a state name to its Zod schema. */
-type StateEntry<TKey extends string = string, TState extends Schema = Schema> = {
-    [P in TKey]: ZodType<TState>;
-};
-/** Helper: a single-key record mapping an action name to its Zod schema. */
-type ActionEntry<TKey extends string = string, TNewActions extends Schema = Schema> = {
-    [P in TKey]: ZodType<TNewActions>;
-};
-/**
- * Builder interface for defining actions (commands) on a state.
- *
- * Actions represent user/system intents to modify state. Each action is validated
- * against a schema, can have business rule invariants, and must emit one or more events.
- *
- * @template TState - State schema type
- * @template TEvents - Event schemas type
- * @template TActions - Action schemas type
- * @template TName - State name literal type
- * @template TSnap - `true` once `.snap(...)` has been called. Gates the
- *   `.autocloses({ keep })` rolling-window option — a windowed close is
- *   meaningless without snapshots, so `keep` only typechecks after
- *   `.snap` in the chain.
- *
- * @see {@link state} for complete usage examples
- */
-export type ActionBuilder<TState extends Schema, TEvents extends Schemas, TActions extends Schemas, TName extends string = string, TSnap extends boolean = false> = {
-    /**
-     * Defines an action (command) that can be executed on this state.
-     *
-     * Actions represent intents to change state - they should be named in imperative form
-     * (e.g., "CreateUser", "IncrementCounter", "PlaceOrder"). Actions are validated against
-     * their schema and must emit at least one event.
-     *
-     * Pass a `{ ActionName: schema }` record — use shorthand `{ ActionName }`
-     * when the variable name matches the action name. The key becomes the
-     * action name, the value the Zod schema.
-     *
-     * Pass an optional second argument to declare a per-action retry
-     * policy — the orchestrator retries this action on
-     * {@link ConcurrencyError} up to `maxRetries` extra times, applying
-     * `backoff` between attempts when set. Omit the argument to keep the
-     * current single-attempt behavior (`ConcurrencyError` surfaces on
-     * first conflict).
-     *
-     * @template TKey - Action name (string literal type)
-     * @template TNewActions - Action payload schema type
-     * @param entry - Single-key record `{ ActionName: schema }`
-     * @param options - Optional per-action retry policy
-     *   ({@link ActionOptions}).
-     * @returns An object with `.given()` and `.emit()` for further configuration
-     *
-     * @example Simple action without invariants
-     * ```typescript
-     * .on({ increment: z.object({ by: z.number() }) })
-     *   .emit((action) => ["Incremented", { amount: action.by }])
-     * ```
-     */
-    on: <TKey extends string, TNewActions extends Schema>(entry: ActionEntry<TKey, TNewActions>, options?: ActionOptions) => {
-        /**
-         * Adds business rule invariants that must hold before the action can execute.
-         *
-         * Invariants are checked after loading the current state but before emitting
-         * events. Each invariant pairs a `description` with a `valid(state, actor?)`
-         * predicate — when a predicate returns `false`, the action throws
-         * `InvariantError` carrying the description. All invariants must pass for
-         * the action to succeed.
-         *
-         * @param rules - Array of {@link Invariant} objects (`{ description, valid }`)
-         * @returns An object with `.emit()` to finalize the action
-         *
-         * @example
-         * ```typescript
-         * .given([
-         *   { description: "Must be active", valid: (state) => state.status === "active" },
-         *   { description: "Must be the owner", valid: (state, actor) => state.ownerId === actor?.id }
-         * ])
-         * ```
-         */
-        given: (rules: Invariant<TState>[]) => {
-            /**
-             * Defines the action handler that emits events.
-             *
-             * The handler receives the action payload and current state snapshot,
-             * and must return one or more events to emit. Events are applied to state
-             * via the patch handlers defined earlier.
-             *
-             * Pass a string event name for passthrough: the action payload becomes
-             * the event data directly.
-             *
-             * @param handler - Function that returns events to emit, or event name string for passthrough
-             * @returns The ActionBuilder for chaining more actions
-             *
-             * @example Custom handler
-             * ```typescript
-             * .emit((action, snapshot) => {
-             *   const newBalance = snapshot.state.balance + action.amount;
-             *   return ["Deposited", { amount: action.amount, newBalance }];
-             * })
-             * ```
-             */
-            emit: {
-                /** Custom handler — receives `(action, snapshot)` and returns one
-                 *  or more `[EventName, data]` tuples (or `undefined`). */
-                (handler: ActionHandler<TState, TEvents, {
-                    [P in TKey]: TNewActions;
-                }, TKey>): ActionBuilder<TState, TEvents, TActions & {
-                    [P in TKey]: TNewActions;
-                }, TName, TSnap>;
-                /** Passthrough — the action payload becomes the event data
-                 *  directly. Must reference an event declared in `.emits()`. */
-                (event_name: keyof TEvents & string): ActionBuilder<TState, TEvents, TActions & {
-                    [P in TKey]: TNewActions;
-                }, TName, TSnap>;
-            };
-        };
-        /**
-         * Defines the action handler that emits events. Same two overloads as
-         * the post-`.given()` form above:
-         *
-         * - **Function** — receives `(action, snapshot)` and returns one or
-         *   more `[EventName, data]` tuples (or `undefined`).
-         * - **String** — passthrough: the action payload becomes the event
-         *   data directly. Must reference an event declared in `.emits()`.
-         *
-         * The two overloads are kept separate (rather than merged into a
-         * `handler | string` union) so that TS contextual typing of the
-         * function alternative isn't degraded by considering the string
-         * branch — under the union form `TState` could collapse to its
-         * `Schema` constraint inside the callback.
-         *
-         * @example Passthrough (action payload = event data)
-         * ```typescript
-         * .emit("Incremented")
-         * ```
-         */
-        emit: {
-            (handler: ActionHandler<TState, TEvents, {
-                [P in TKey]: TNewActions;
-            }, TKey>): ActionBuilder<TState, TEvents, TActions & {
-                [P in TKey]: TNewActions;
-            }, TName, TSnap>;
-            (event_name: keyof TEvents & string): ActionBuilder<TState, TEvents, TActions & {
-                [P in TKey]: TNewActions;
-            }, TName, TSnap>;
-        };
-    };
-    /**
-     * Defines a snapshotting strategy to optimize state reconstruction.
-     *
-     * Snapshots store the current state at a point in time, allowing faster state loading
-     * by avoiding replaying all events from the beginning. The snap function is called
-     * after each event is applied and should return `true` when a snapshot should be taken.
-     *
-     * @param snap - Predicate function that returns true when a snapshot should be taken
-     * @returns The ActionBuilder for chaining
-     *
-     * @example Snapshot every 10 events
-     * ```typescript
-     * .snap((snapshot) => snapshot.patches >= 10)
-     * ```
-     */
-    snap: (snap: (snapshot: Snapshot<TState, TEvents>) => boolean) => ActionBuilder<TState, TEvents, TActions, TName, true>;
-    /**
-     * Declares the disclosure predicate for `sensitive(...)`-marked event
-     * fields. Gates external reads: returning `true` allows the actor to see
-     * plaintext on the event; returning `false` substitutes `"[REDACTED]"`.
-     * When absent, the framework default-denies on every external read —
-     * fail-safe.
-     *
-     * One predicate per state. A second `.discloses(...)` call replaces the
-     * first (same shape as snapshots being state-level, not per-event).
-     *
-     * The predicate receives the full event including merged PII so it can
-     * branch on the payload itself (e.g.
-     * `event.data.ownerId === actor.id`). Reducers, projections, and
-     * reactions are unaffected — they follow separate visibility rules.
-     *
-     * @param disclose - Predicate `(event, actor) => boolean`. `true` =
-     *   plaintext, `false` = `"[REDACTED]"` substitution.
-     * @returns The ActionBuilder for chaining.
-     *
-     * @example Owner-or-admin disclosure
-     * ```typescript
-     * state({ User: userSchema })
-     *   .init(() => ({ ... }))
-     *   .emits({ UserRegistered: z.object({ email: sensitive(z.string()) }) })
-     *   .discloses((event, actor) =>
-     *     actor.id === event.stream || actor.roles?.includes("admin"))
-     * ```
-     */
-    discloses: (disclose: (event: Committed<TEvents, keyof TEvents & string>, actor: Actor) => boolean) => ActionBuilder<TState, TEvents, TActions, TName, TSnap>;
-    /**
-     * Declares the online close predicate for this state. The
-     * orchestrator's autoclose cycle iterates the state's streams once
-     * per tick and calls the predicate per candidate; truthy results are
-     * scheduled for atomic truncate-and-seed via `Store.truncate` on the
-     * next batch.
-     *
-     * One predicate per state. A second `.autocloses(...)` call replaces
-     * the first (same shape as `.snap` / `.discloses` — state-level, not
-     * per-event). Absent → the state opts out of online close entirely;
-     * the cycle skips it and pays zero per-tick cost for it.
-     *
-     * Pass a declarative {@link AutoclosePolicy} object literal covering the
-     * three operational pressure points (`after`, `is`, `reaches`). Top-level
-     * fields combine with AND; an optional `or: {...}` block opens an
-     * alternative OR path. Validated via Zod at build time; misconfiguration
-     * throws before `act().build()` completes.
-     *
-     * Under the hood this compiles to a synthesized reaction that runs
-     * on a per-aggregate synthetic stream: it defers to `head.created + the
-     * policy's min after` while the cooldown holds and closes the stream once
-     * the policy matches. There is no background sweep.
-     *
-     * **The function-predicate form was removed.** `.autocloses` no
-     * longer accepts `(stream, head, count) => boolean`; an opaque predicate has
-     * no derivable due-time or terminal event to react to. For conditions the
-     * declarative form can't express, call `app.close(...)` from your own logic.
-     *
-     * @param policy The declarative {@link AutoclosePolicy} bag.
-     * @returns The ActionBuilder for chaining.
-     *
-     * @example Declarative — cooldown after terminal (a Ticket closes
-     *   90 days after resolution).
-     * ```typescript
-     * .autocloses({ is: "TicketResolved", after: { days: 90 } })
-     * ```
-     */
-    autocloses: (policy: [TSnap] extends [true] ? AutoclosePolicy : Omit<AutoclosePolicy, "keep"> & {
-        /** Rolling-window retention requires `.snap(...)` earlier in
-         *  the builder chain — a windowed close prunes behind a real
-         *  snapshot, so a state that never snapshots has nothing to
-         *  prune behind. */
-        keep?: never;
-    }) => ActionBuilder<TState, TEvents, TActions, TName, TSnap>;
-    /**
-     * Declares the archiver the online close cycle runs **before**
-     * truncating a stream this state's `.autocloses(...)` predicate
-     * accepted. Hosts use it to write events to durable storage (S3,
-     * an analytics warehouse, cold tier) before the tombstone lands,
-     * so the truncate doesn't lose history that the operator still
-     * needs.
-     *
-     * Threads into `CloseTarget.archive` via the same plumbing
-     * `app.close({ stream, archive })` already uses — the cycle holds
-     * the stream's guard while the archiver runs, and a thrown
-     * archiver leaves the stream guarded but un-truncated. No partial
-     * truncate state, no data loss. It is not retried automatically;
-     * `app.close([{ stream, archive }])` resumes the guarded stream.
-     *
-     * One archiver per state. A second `.archives(...)` call replaces
-     * the first (same shape as `.snap` / `.discloses` /
-     * `.autocloses`). Absent → the cycle truncates without an archive
-     * step.
-     *
-     * @param archive `(stream, head) => Promise<void>`. Runs while
-     *   the stream is locked against new writes; the truncate runs
-     *   immediately after a successful resolve.
-     * @returns The ActionBuilder for chaining.
-     *
-     * @example Archive to S3 before truncate.
-     * ```typescript
-     * state({ Ticket: ticketSchema })
-     *   .emits({ TicketOpened, TicketResolved })
-     *   // ...
-     *   .autocloses({ is: "TicketResolved" })
-     *   .archives(async (stream) => {
-     *     const events = await loadEvents(stream);
-     *     await s3.upload(`tickets/${stream}.jsonl`, events);
-     *   })
-     * ```
-     */
-    archives: (archive: AutocloseArchiver<TEvents>) => ActionBuilder<TState, TEvents, TActions, TName, TSnap>;
-    /**
-     * Finalizes and builds the state definition.
-     *
-     * Call this method after defining all actions, invariants, and patches to create
-     * the complete State object that can be registered with Act.
-     *
-     * @returns The complete strongly-typed State definition
-     *
-     * @example
-     * ```typescript
-     * const Counter = state({ Counter: schema })
-     *   .init(() => ({ count: 0 }))
-     *   .emits({ Incremented: z.object({ amount: z.number() }) })
-     *   .patch({ Incremented: ({ data }, state) => ({ count: state.count + data.amount }) })
-     *   .on({ increment: z.object({ by: z.number() }) })
-     *     .emit((action) => ["Incremented", { amount: action.by }])
-     *   .build(); // Returns State<TState, TEvents, TActions, TName>
-     * ```
-     */
-    build: () => State<TState, TEvents, TActions, TName>;
-};
+import type { StateBuilder, StateEntry } from "../types/builders.js";
+import type { Schema } from "../types/index.js";
 /**
  * Creates a new state definition with event sourcing capabilities.
  *
@@ -417,5 +44,4 @@ export type ActionBuilder<TState extends Schema, TEvents extends Schemas, TActio
  * @see {@link https://rotorsoft.github.io/act-root/docs/examples/calculator | Calculator Example}
  */
 export declare function state<TName extends string, TState extends Schema>(entry: StateEntry<TName, TState>): StateBuilder<TState, TName>;
-export {};
 //# sourceMappingURL=state-builder.d.ts.map

package/dist/@types/builders/state-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state-builder.d.ts","sourceRoot":"","sources":["../../../src/builders/state-builder.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"state-builder.d.ts","sourceRoot":"","sources":["../../../src/builders/state-builder.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAGV,YAAY,EACZ,UAAU,EACX,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAYV,MAAM,EAKP,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,KAAK,CAAC,KAAK,SAAS,MAAM,EAAE,MAAM,SAAS,MAAM,EAC/D,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,GAC/B,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,CAmD7B"}