@rotorsoft/act 0.7.0 → 0.9.0

package/dist/@types/act-builder.d.ts

@@ -5,12 +5,13 @@
  * Fluent builder for composing event-sourced applications.
  */
 import { Act } from "./act.js";
-import type { EventRegister, ReactionHandler, ReactionOptions, ReactionResolver, Registry, Schema, SchemaRegister, Schemas, State } from "./types/index.js";
+import { type Slice } from "./slice-builder.js";
+import type { Committed, Dispatcher, EventRegister, ReactionOptions, ReactionResolver, Registry, Schema, SchemaRegister, Schemas, Snapshot, State } from "./types/index.js";
 /**
  * Fluent builder interface for composing event-sourced applications.
  *
  * Provides a chainable API for:
- * - Registering states via `.with()`
+ * - Registering states or slices via `.with()`
  * - Defining event reactions via `.on()` → `.do()` → `.to()` or `.void()`
  * - Building the orchestrator via `.build()`
  *
@@ -21,41 +22,33 @@ import type { EventRegister, ReactionHandler, ReactionOptions, ReactionResolver,
  * @see {@link act} for usage examples
  * @see {@link Act} for the built orchestrator API
  */
-export type ActBuilder<S extends SchemaRegister<A>, E extends Schemas, A extends Schemas> = {
+export type ActBuilder<S extends SchemaRegister<A>, E extends Schemas, A extends Schemas, M extends Record<string, Schema> = {}> = {
     /**
-     * Registers a state definition with the builder.
+     * Registers a state definition or a slice with the builder.
      *
-     * States define aggregates that process actions and emit events. Each state
-     * registration adds its actions and events to the orchestrator's registry.
-     * State names, action names, and event names must be unique across the application.
+     * When receiving a State, it registers the state's actions and events.
+     * When receiving a Slice, it merges all the slice's states and reactions.
+     * State names, action names, and event names must be unique across the application
+     * (partial states with the same name are merged automatically).
      *
-     * @template SX - State schema type
-     * @template EX - Event schemas type for this state
-     * @template AX - Action schemas type for this state
-     * @param state - The state definition to register
-     * @returns The builder with updated type information for chaining
+     * @throws {Error} If duplicate action or event names are detected
      *
-     * @throws {Error} If a state with duplicate action or event names is registered
-     *
-     * @example Register single state
+     * @example Register a state
      * ```typescript
-     * const app = act()
-     *   .with(Counter)
-     *   .build();
+     * const app = act().with(Counter).build();
      * ```
      *
-     * @example Register multiple states
+     * @example Register a slice
      * ```typescript
-     * const app = act()
-     *   .with(User)
-     *   .with(Order)
-     *   .with(Inventory)
-     *   .build();
+     * const CounterSlice = slice().with(Counter).on("Incremented").do(log).void().build();
+     * const app = act().with(CounterSlice).build();
      * ```
      */
-    with: <SX extends Schema, EX extends Schemas, AX extends Schemas>(state: State<SX, EX, AX>) => ActBuilder<S & {
+    with: (<SX extends Schema, EX extends Schemas, AX extends Schemas, NX extends string = string>(state: State<SX, EX, AX, NX>) => ActBuilder<S & {
         [K in keyof AX]: SX;
-    }, E & EX, A & AX>;
+    }, E & EX, A & AX, M & {
+        [K in NX]: SX;
+    }>) & (<SX extends SchemaRegister<AX>, EX extends Schemas, AX extends Schemas, MX extends Record<string, Schema>>(slice: Slice<SX, EX, AX, MX>) => ActBuilder<S & SX, E & EX, A & AX, M & MX>);
     /**
      * Begins defining a reaction to a specific event.
      *
@@ -93,128 +86,34 @@ export type ActBuilder<S extends SchemaRegister<A>, E extends Schemas, A extends
          * @param options.blockOnError - Block this stream if handler fails (default: true)
          * @param options.maxRetries - Maximum retry attempts on failure (default: 3)
          * @returns The builder with `.to()` and `.void()` methods for routing configuration
-         *
-         * @example Side effect only (void)
-         * ```typescript
-         * .on("UserCreated")
-         *   .do(async (event) => {
-         *     await analytics.track("user_created", event.data);
-         *   })
-         *   .void()
-         * ```
-         *
-         * @example Trigger another action
-         * ```typescript
-         * .on("OrderPlaced")
-         *   .do(async (event) => {
-         *     return ["reduceStock", { amount: event.data.items.length }];
-         *   })
-         *   .to("inventory-1")
-         * ```
-         *
-         * @example With retry configuration
-         * ```typescript
-         * .on("PaymentProcessed")
-         *   .do(async (event) => {
-         *     await externalAPI.notify(event.data);
-         *   }, {
-         *     blockOnError: false,  // Don't block on failure
-         *     maxRetries: 5         // Retry up to 5 times
-         *   })
-         *   .void()
-         * ```
          */
-        do: (handler: ReactionHandler<E, K>, options?: Partial<ReactionOptions>) => ActBuilder<S, E, A> & {
+        do: (handler: (event: Committed<E, K>, stream: string, app: Dispatcher<A>) => Promise<Snapshot<E, Schema> | void>, options?: Partial<ReactionOptions>) => ActBuilder<S, E, A, M> & {
             /**
              * Routes the reaction to a specific target stream.
              *
-             * Use this when the reaction triggers an action on a specific state instance.
-             * You can provide either a static stream name (string) or a resolver function
-             * that dynamically determines the target based on the event.
-             *
              * @param resolver - Target stream name (string) or resolver function
              * @returns The builder for chaining
-             *
-             * @example Static target stream
-             * ```typescript
-             * .on("OrderPlaced")
-             *   .do(async (event) => ["reduceStock", { amount: 10 }])
-             *   .to("inventory-main")
-             * ```
-             *
-             * @example Dynamic target based on event data
-             * ```typescript
-             * .on("OrderPlaced")
-             *   .do(async (event) => ["reduceStock", { amount: 10 }])
-             *   .to((event) => ({
-             *     target: `inventory-${event.data.warehouseId}`
-             *   }))
-             * ```
-             *
-             * @example Source and target routing
-             * ```typescript
-             * .on("UserLoggedIn")
-             *   .do(async (event) => ["incrementCount", {}])
-             *   .to(({ stream }) => ({
-             *     source: stream,           // React to events from this user stream
-             *     target: `stats-${stream}` // Update corresponding stats stream
-             *   }))
-             * ```
              */
-            to: (resolver: ReactionResolver<E, K> | string) => ActBuilder<S, E, A>;
+            to: (resolver: ReactionResolver<E, K> | string) => ActBuilder<S, E, A, M>;
             /**
              * Marks the reaction as void (side-effect only, no target stream).
              *
-             * Use this when the reaction doesn't trigger any actions - it only performs
-             * side effects like logging, sending notifications, or updating external systems.
-             *
              * @returns The builder for chaining
-             *
-             * @example
-             * ```typescript
-             * .on("UserCreated")
-             *   .do(async (event) => {
-             *     await sendEmail(event.data.email, "Welcome!");
-             *     await logger.info("User created", event.data);
-             *   })
-             *   .void()  // No target stream
-             * ```
              */
-            void: () => ActBuilder<S, E, A>;
+            void: () => ActBuilder<S, E, A, M>;
         };
     };
     /**
      * Builds and returns the Act orchestrator instance.
      *
-     * This finalizes the builder configuration and creates the orchestrator that
-     * can execute actions, load state, and process reactions.
-     *
      * @param drainLimit - Deprecated parameter, no longer used
      * @returns The Act orchestrator instance
      *
-     * @example
-     * ```typescript
-     * const app = act()
-     *   .with(Counter)
-     *   .with(User)
-     *   .on("UserCreated")
-     *     .do(sendWelcomeEmail)
-     *     .void()
-     *   .build();
-     *
-     * // Now use the app
-     * await app.do("createUser", target, payload);
-     * await app.drain();
-     * ```
-     *
      * @see {@link Act} for available orchestrator methods
      */
-    build: (drainLimit?: number) => Act<S, E, A>;
+    build: (drainLimit?: number) => Act<S, E, A, M>;
     /**
      * The registered event schemas and their reaction maps.
-     *
-     * This is an internal registry maintained by the builder. Generally, you don't
-     * need to access this directly.
      */
     readonly events: EventRegister<E>;
 };
@@ -227,8 +126,8 @@ export type ActBuilder<S extends SchemaRegister<A>, E extends Schemas, A extends
  * - Processing reactions (event handlers)
  * - Coordinating event-driven workflows
  *
- * Use the fluent API to register states with `.with()`, define event reactions with `.on()`,
- * and build the orchestrator with `.build()`.
+ * Use the fluent API to register states or slices with `.with()`, define event
+ * reactions with `.on()`, and build the orchestrator with `.build()`.
  *
  * @template S - State schema register type
  * @template E - Event schemas type
@@ -251,115 +150,28 @@ export type ActBuilder<S extends SchemaRegister<A>, E extends Schemas, A extends
  * const app = act()
  *   .with(Counter)
  *   .build();
- *
- * // Execute action
- * await app.do("increment",
- *   { stream: "counter1", actor: { id: "user1", name: "Alice" } },
- *   { by: 5 }
- * );
- *
- * // Load current state
- * const snapshot = await app.load(Counter, "counter1");
- * console.log(snapshot.state.count); // 5
  * ```
  *
- * @example Application with reactions
+ * @example Application with slices (vertical slice architecture)
  * ```typescript
- * const User = state("User", z.object({ name: z.string(), email: z.string() }))
- *   .init((data) => data)
- *   .emits({ UserCreated: z.object({ name: z.string(), email: z.string() }) })
- *   .patch({ UserCreated: (event) => event.data })
- *   .on("createUser", z.object({ name: z.string(), email: z.string() }))
- *     .emit((action) => ["UserCreated", action])
- *   .build();
- *
- * const app = act()
- *   .with(User)
- *   .on("UserCreated")
- *     .do(async (event) => {
- *       // Send welcome email
- *       await sendEmail(event.data.email, "Welcome!");
- *       logger.info(`Sent welcome email to ${event.data.email}`);
- *     })
- *     .void() // No target stream, just side effects
- *   .build();
- *
- * // Create user (triggers email sending via reaction)
- * await app.do("createUser",
- *   { stream: "user-123", actor: { id: "admin", name: "Admin" } },
- *   { name: "Alice", email: "alice@example.com" }
- * );
- *
- * // Process reactions
- * await app.drain();
- * ```
- *
- * @example Multi-state application with event correlation
- * ```typescript
- * const Order = state("Order", z.object({ items: z.array(z.string()), total: z.number() }))
- *   .init((data) => data)
- *   .emits({ OrderPlaced: z.object({ items: z.array(z.string()), total: z.number() }) })
- *   .patch({ OrderPlaced: (event) => event.data })
- *   .on("placeOrder", z.object({ items: z.array(z.string()), total: z.number() }))
- *     .emit((action) => ["OrderPlaced", action])
- *   .build();
+ * import { act, slice, state } from "@rotorsoft/act";
  *
- * const Inventory = state("Inventory", z.object({ stock: z.number() }))
- *   .init(() => ({ stock: 100 }))
- *   .emits({ StockReduced: z.object({ amount: z.number() }) })
- *   .patch({ StockReduced: (event, state) => ({ stock: state.stock - event.data.amount }) })
- *   .on("reduceStock", z.object({ amount: z.number() }))
- *     .emit((action) => ["StockReduced", { amount: action.amount }])
- *   .build();
- *
- * const app = act()
- *   .with(Order)
- *   .with(Inventory)
- *   .on("OrderPlaced")
- *     .do(async (event) => {
- *       // Reduce inventory for each item
- *       return ["reduceStock", { amount: event.data.items.length }];
- *     })
- *     .to("inventory-1") // Target specific inventory stream
- *   .build();
- *
- * await app.do("placeOrder",
- *   { stream: "order-1", actor: { id: "user1", name: "Alice" } },
- *   { items: ["item1", "item2"], total: 100 }
- * );
- *
- * // Process reaction (reduces inventory)
- * await app.drain();
- * ```
- *
- * @example Partial state definitions (same name, merged via .with())
- * ```typescript
- * const TicketCreation = state("Ticket", TicketSchema)
- *   .init(() => initialTicket)
- *   .emits({ TicketOpened: ..., TicketClosed: ... })
- *   .patch({ TicketOpened: ..., TicketClosed: ... })
- *   .on("OpenTicket", ...).emit(...)
- *   .on("CloseTicket", ...).emit(...)
- *   .build();
- *
- * const TicketMessaging = state("Ticket", TicketSchema)
- *   .init(() => initialTicket)
- *   .emits({ MessageAdded: ... })
- *   .patch({ MessageAdded: ... })
- *   .on("AddMessage", ...).emit(...)
+ * const CounterSlice = slice()
+ *   .with(Counter)
+ *   .on("Incremented")
+ *     .do(async (event) => { console.log("incremented!"); })
+ *     .void()
  *   .build();
  *
- * // Partials with same name are merged automatically
  * const app = act()
- *   .with(TicketCreation)
- *   .with(TicketMessaging)
+ *   .with(CounterSlice)
  *   .build();
  * ```
  *
  * @see {@link ActBuilder} for available builder methods
  * @see {@link Act} for orchestrator API methods
  * @see {@link state} for defining states
- * @see {@link https://rotorsoft.github.io/act-root/docs/intro | Documentation}
+ * @see {@link slice} for defining slices
  */
-export declare function act<S extends SchemaRegister<A> = {}, E extends Schemas = {}, A extends Schemas = {}>(states?: Map<string, State<any, any, any>>, registry?: Registry<S, E, A>): ActBuilder<S, E, A>;
+export declare function act<S extends SchemaRegister<A> = {}, E extends Schemas = {}, A extends Schemas = {}, M extends Record<string, Schema> = {}>(states?: Map<string, State<any, any, any>>, registry?: Registry<S, E, A>): ActBuilder<S, E, A, M>;
 //# sourceMappingURL=act-builder.d.ts.map

package/dist/@types/act-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"act-builder.d.ts","sourceRoot":"","sources":["../../src/act-builder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,KAAK,EACV,aAAa,EAEb,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,QAAQ,EACR,MAAM,EACN,cAAc,EACd,OAAO,EACP,KAAK,EACN,MAAM,kBAAkB,CAAC;AAU1B;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,UAAU,CACpB,CAAC,SAAS,cAAc,CAAC,CAAC,CAAC,EAC3B,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,OAAO,IACf;IACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,IAAI,EAAE,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,SAAS,OAAO,EAAE,EAAE,SAAS,OAAO,EAC9D,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,KACrB,UAAU,CAAC,CAAC,GAAG;SAAG,CAAC,IAAI,MAAM,EAAE,GAAG,EAAE;KAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAC7D;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,EAAE,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,EACpB,KAAK,EAAE,CAAC,KACL;QACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA2CG;QACH,EAAE,EAAE,CACF,OAAO,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EAC9B,OAAO,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,KAC/B,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG;YACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAmCG;YACH,EAAE,EAAE,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,KAAK,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;YACvE;;;;;;;;;;;;;;;;;eAiBG;YACH,IAAI,EAAE,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;SACjC,CAAC;KACH,CAAC;IACF;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,KAAK,EAAE,CAAC,UAAU,CAAC,EAAE,MAAM,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC7C;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;CACnC,CAAC;AAIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8IG;AACH,wBAAgB,GAAG,CAEjB,CAAC,SAAS,cAAc,CAAC,CAAC,CAAC,GAAG,EAAE,EAChC,CAAC,SAAS,OAAO,GAAG,EAAE,EACtB,CAAC,SAAS,OAAO,GAAG,EAAE,EAEtB,MAAM,GAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAa,EACrD,QAAQ,GAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAGzB,GACA,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CA0HrB"}
+{"version":3,"file":"act-builder.d.ts","sourceRoot":"","sources":["../../src/act-builder.ts"],"names":[],"mappings":"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"}

package/dist/@types/act.d.ts

@@ -23,7 +23,7 @@ import type { Committed, Drain, DrainOptions, Lease, Query, Registry, Schema, Sc
  * @template E Schemas for events
  * @template A Schemas for actions
  */
-export declare class Act<S extends SchemaRegister<A>, E extends Schemas, A extends Schemas> {
+export declare class Act<S extends SchemaRegister<A>, E extends Schemas, A extends Schemas, M extends Record<string, Schema> = Record<string, never>> {
     readonly registry: Registry<S, E, A>;
     private readonly _states;
     private _emitter;
@@ -156,34 +156,36 @@ export declare class Act<S extends SchemaRegister<A>, E extends Schemas, A exten
      * @see {@link Snapshot} for return value structure
      * @see {@link ValidationError}, {@link InvariantError}, {@link ConcurrencyError}
      */
-    do<K extends keyof A>(action: K, target: Target, payload: Readonly<A[K]>, reactingTo?: Committed<E, keyof E>, skipValidation?: boolean): Promise<Snapshot<S[K], E>[]>;
+    do<K extends keyof A>(action: K, target: Target, payload: Readonly<A[K]>, reactingTo?: Committed<E, string & keyof E>, skipValidation?: boolean): Promise<Snapshot<S[K], E>[]>;
     /**
      * Loads the current state snapshot for a specific stream.
      *
      * Reconstructs the current state by replaying events from the event store.
      * Uses snapshots when available to optimize loading performance.
      *
+     * Accepts either a State definition object or a state name string. When
+     * using a string, the merged state (from partial states registered via
+     * `.with()`) is resolved by name.
+     *
      * @template SX - State schema type
      * @template EX - Event schemas type
      * @template AX - Action schemas type
-     * @param state - The state definition to load
+     * @param state - The state definition or state name to load
      * @param stream - The stream ID (state instance identifier)
      * @param callback - Optional callback invoked with the loaded snapshot
      * @returns The current state snapshot for the stream
      *
-     * @example Load current state
+     * @example Load by state definition
      * ```typescript
      * const snapshot = await app.load(Counter, "counter-1");
      * console.log(snapshot.state.count);    // Current count
-     * console.log(snapshot.version);        // Number of events applied
      * console.log(snapshot.patches);        // Events since last snapshot
      * ```
      *
-     * @example With callback
+     * @example Load by state name (useful with partial states)
      * ```typescript
-     * const snapshot = await app.load(User, "user-123", (snap) => {
-     *   console.log("Loaded user:", snap.state.name);
-     * });
+     * const snapshot = await app.load("Ticket", "ticket-123");
+     * console.log(snapshot.state.title);    // Merged state from all partials
      * ```
      *
      * @example Load multiple states
@@ -197,6 +199,7 @@ export declare class Act<S extends SchemaRegister<A>, E extends Schemas, A exten
      * @see {@link Snapshot} for snapshot structure
      */
     load<SX extends Schema, EX extends Schemas, AX extends Schemas>(state: State<SX, EX, AX>, stream: string, callback?: (snapshot: Snapshot<SX, EX>) => void): Promise<Snapshot<SX, EX>>;
+    load<K extends keyof M & string>(name: K, stream: string, callback?: (snapshot: Snapshot<M[K], E>) => void): Promise<Snapshot<M[K], E>>;
     /**
      * Queries the event store for events matching a filter.
      *
@@ -356,7 +359,7 @@ export declare class Act<S extends SchemaRegister<A>, E extends Schemas, A exten
      * @see {@link correlate} for dynamic stream discovery
      * @see {@link start_correlations} for automatic correlation
      */
-    drain<E extends Schemas>({ streamLimit, eventLimit, leaseMillis, }?: DrainOptions): Promise<Drain<E>>;
+    drain({ streamLimit, eventLimit, leaseMillis, }?: DrainOptions): Promise<Drain<E>>;
     /**
      * Discovers and registers new streams dynamically based on reaction resolvers.
      *

package/dist/@types/act.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"act.d.ts","sourceRoot":"","sources":["../../src/act.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"act.d.ts","sourceRoot":"","sources":["../../src/act.ts"],"names":[],"mappings":"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"}

package/dist/@types/index.d.ts

@@ -8,6 +8,7 @@ export * from "./act-builder.js";
 export * from "./act.js";
 export * from "./config.js";
 export * from "./ports.js";
+export * from "./slice-builder.js";
 export * from "./state-builder.js";
 export * from "./types/index.js";
 export * from "./utils.js";

package/dist/@types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,CAAC;AAEtB;;;;GAIG;AACH,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,CAAC;AAEtB;;;;GAIG;AACH,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/dist/@types/merge.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @module merge
+ * @category Builders
+ *
+ * Shared utilities for merging partial states across builders.
+ */
+import { type ZodType } from "zod";
+import type { Schema, State } from "./types/index.js";
+/**
+ * Unwraps wrapper types (ZodOptional, ZodNullable, ZodDefault, ZodReadonly)
+ * to find the base type name, e.g. `z.string().optional()` -> `"ZodString"`.
+ */
+export declare function baseTypeName(zodType: ZodType): string;
+/**
+ * Merges two Zod schemas. If both are ZodObject instances, checks for
+ * overlapping shape keys with incompatible base types (throws descriptive
+ * error), then merges via `.extend()`. Falls back to keeping existing
+ * schema if either is not a ZodObject.
+ */
+export declare function mergeSchemas(existing: ZodType, incoming: ZodType, stateName: string): ZodType;
+/**
+ * Merges two init functions by spreading both results together.
+ * Each partial only provides its own defaults.
+ */
+export declare function mergeInits<S extends Schema>(existing: () => Readonly<S>, incoming: () => Readonly<S>): () => Readonly<S>;
+/**
+ * Registers a state into a states map and action/event registries,
+ * merging with existing same-name states (partial state support).
+ */
+export declare function registerState(state: State<any, any, any>, states: Map<string, State<any, any, any>>, actions: Record<string, any>, events: Record<string, any>): void;
+export declare const _this_: ({ stream }: {
+    stream: string;
+}) => {
+    source: string;
+    target: string;
+};
+export declare const _void_: () => undefined;
+//# sourceMappingURL=merge.d.ts.map

package/dist/@types/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/merge.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,KAAK,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEtD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAMrD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,OAAO,EACjB,QAAQ,EAAE,OAAO,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAkBT;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACzC,QAAQ,EAAE,MAAM,QAAQ,CAAC,CAAC,CAAC,EAC3B,QAAQ,EAAE,MAAM,QAAQ,CAAC,CAAC,CAAC,GAC1B,MAAM,QAAQ,CAAC,CAAC,CAAC,CAEnB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAC3B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EACzC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC1B,IAAI,CAoDN;AAGD,eAAO,MAAM,MAAM,GAAI,YAAY;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE;;;CAGnD,CAAC;AAGH,eAAO,MAAM,MAAM,iBAAkB,CAAC"}

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

@@ -0,0 +1,107 @@
+import type { Committed, Dispatcher, EventRegister, ReactionOptions, ReactionResolver, Schema, SchemaRegister, Schemas, Snapshot, State } from "./types/index.js";
+/**
+ * A self-contained functional slice grouping partial states with their
+ * scoped reactions. Slices are composed into an Act orchestrator via
+ * `act().with(slice)`.
+ *
+ * @template S - Schema register for states
+ * @template E - Event schemas from this slice's states
+ * @template A - Action schemas from this slice's states
+ * @template M - Map of state names to state schemas
+ */
+export type Slice<S extends SchemaRegister<A>, E extends Schemas, A extends Schemas, M extends Record<string, Schema> = {}> = {
+    readonly _tag: "Slice";
+    readonly states: Map<string, State<any, any, any>>;
+    readonly events: EventRegister<E>;
+    /** @internal phantom field for type-level state schema tracking */
+    readonly _S?: S;
+    /** @internal phantom field for type-level state name tracking */
+    readonly _M?: M;
+};
+/**
+ * Type guard for distinguishing Slice from State objects.
+ */
+export declare function isSlice(x: any): x is Slice<any, any, any, any>;
+/**
+ * Fluent builder interface for composing functional slices.
+ *
+ * Provides a chainable API for registering states and defining reactions,
+ * scoped to the slice's own events. Include all states whose actions your
+ * handlers need via `.with()` — the `app` parameter in `.do()` handlers
+ * is typed with every action registered in the slice.
+ *
+ * @template S - Schema register for states
+ * @template E - Event schemas
+ * @template A - Action schemas
+ * @template M - Map of state names to state schemas
+ */
+export type SliceBuilder<S extends SchemaRegister<A>, E extends Schemas, A extends Schemas, M extends Record<string, Schema> = {}> = {
+    /**
+     * Registers a partial 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.
+     */
+    with: <SX extends Schema, EX extends Schemas, AX extends Schemas, NX extends string = string>(state: State<SX, EX, AX, NX>) => SliceBuilder<S & {
+        [K in keyof AX]: SX;
+    }, E & EX, A & AX, M & {
+        [K in NX]: SX;
+    }>;
+    /**
+     * Begins defining a reaction scoped to this slice's events.
+     */
+    on: <K extends keyof E>(event: K) => {
+        do: (handler: (event: Committed<E, K>, stream: string, app: Dispatcher<A>) => Promise<Snapshot<E, Schema> | void>, options?: Partial<ReactionOptions>) => SliceBuilder<S, E, A, M> & {
+            to: (resolver: ReactionResolver<E, K> | string) => SliceBuilder<S, E, A, M>;
+            void: () => SliceBuilder<S, E, A, M>;
+        };
+    };
+    /**
+     * Builds and returns the Slice data structure.
+     */
+    build: () => Slice<S, E, A, M>;
+    /**
+     * The registered event schemas and their reaction maps.
+     */
+    readonly events: EventRegister<E>;
+};
+/**
+ * Creates a new slice builder for composing partial states with scoped reactions.
+ *
+ * Slices enable vertical slice architecture by grouping related states and
+ * reactions into self-contained feature modules. Reactions defined in a slice
+ * are type-scoped to events from that slice's states only.
+ *
+ * Include all states whose actions your handlers dispatch via `.with()`.
+ * When multiple slices share the same state, duplicates are merged
+ * automatically at `act().with(slice)` composition time.
+ *
+ * @example Single-state slice with typed dispatch
+ * ```typescript
+ * const CounterSlice = slice()
+ *   .with(Counter)
+ *   .on("Incremented")
+ *     .do(async (event, _stream, app) => {
+ *       await app.do("reset", target, {});
+ *     })
+ *     .void()
+ *   .build();
+ * ```
+ *
+ * @example Cross-state dispatch (include both states)
+ * ```typescript
+ * const CreationSlice = slice()
+ *   .with(TicketCreation)
+ *   .with(TicketOperations) // handler can dispatch AssignTicket
+ *   .on("TicketOpened").do(async (event, _stream, app) => {
+ *     await app.do("AssignTicket", target, payload, event);
+ *   })
+ *   .build();
+ * ```
+ *
+ * @see {@link SliceBuilder} for builder methods
+ * @see {@link Slice} for the output type
+ */
+export declare function slice<S extends SchemaRegister<A> = {}, E extends Schemas = {}, A extends Schemas = {}, M extends Record<string, Schema> = {}>(states?: Map<string, State<any, any, any>>, actions?: Record<string, any>, events?: EventRegister<E>): SliceBuilder<S, E, A, M>;
+//# sourceMappingURL=slice-builder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slice-builder.d.ts","sourceRoot":"","sources":["../../src/slice-builder.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,SAAS,EACT,UAAU,EACV,aAAa,EAGb,eAAe,EACf,gBAAgB,EAChB,MAAM,EACN,cAAc,EACd,OAAO,EACP,QAAQ,EACR,KAAK,EACN,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;;GASG;AACH,MAAM,MAAM,KAAK,CACf,CAAC,SAAS,cAAc,CAAC,CAAC,CAAC,EAC3B,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,OAAO,EAEjB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,IACnC;IACF,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IAClC,mEAAmE;IACnE,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAChB,iEAAiE;IACjE,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;CACjB,CAAC;AAEF;;GAEG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAE9D;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,YAAY,CACtB,CAAC,SAAS,cAAc,CAAC,CAAC,CAAC,EAC3B,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,OAAO,EAEjB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,IACnC;IACF;;;;;;OAMG;IACH,IAAI,EAAE,CACJ,EAAE,SAAS,MAAM,EACjB,EAAE,SAAS,OAAO,EAClB,EAAE,SAAS,OAAO,EAClB,EAAE,SAAS,MAAM,GAAG,MAAM,EAE1B,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,KACzB,YAAY,CACf,CAAC,GAAG;SAAG,CAAC,IAAI,MAAM,EAAE,GAAG,EAAE;KAAE,EAC3B,CAAC,GAAG,EAAE,EACN,CAAC,GAAG,EAAE,EACN,CAAC,GAAG;SAAG,CAAC,IAAI,EAAE,GAAG,EAAE;KAAE,CACtB,CAAC;IACF;;OAEG;IACH,EAAE,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,EACpB,KAAK,EAAE,CAAC,KACL;QACH,EAAE,EAAE,CACF,OAAO,EAAE,CACP,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EACtB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,KACf,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,EACxC,OAAO,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,KAC/B,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG;YAC9B,EAAE,EAAE,CACF,QAAQ,EAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,KACtC,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;YAC9B,IAAI,EAAE,MAAM,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;SACtC,CAAC;KACH,CAAC;IACF;;OAEG;IACH,KAAK,EAAE,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/B;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;CACnC,CAAC;AAIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,KAAK,CAEnB,CAAC,SAAS,cAAc,CAAC,CAAC,CAAC,GAAG,EAAE,EAChC,CAAC,SAAS,OAAO,GAAG,EAAE,EACtB,CAAC,SAAS,OAAO,GAAG,EAAE,EACtB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,EAErC,MAAM,GAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAa,EACrD,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,EACjC,MAAM,GAAE,aAAa,CAAC,CAAC,CAA0B,GAChD,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAkE1B"}