@rotorsoft/act 0.8.0 → 0.10.0

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

@@ -1,10 +1,18 @@
+/**
+ * @module act-builder
+ * @category Builders
+ *
+ * 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 Projection } from "./projection-builder.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()`
  *
@@ -15,43 +23,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, M extends Record<string, Schema> = Record<string, never>> = {
+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.
-     *
-     * 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.
+     * Registers a state definition or a slice with the builder.
      *
-     * @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
+     * 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).
      *
-     * @throws {Error} If a state with duplicate action or event names is registered
+     * @throws {Error} If duplicate action or event names are detected
      *
-     * @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, NX extends string = string>(state: State<SX, EX, AX, NX>) => 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, 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>) & (<EX extends Schemas>(projection: Projection<EX>) => ActBuilder<S, E & EX, A, M>);
     /**
      * Begins defining a reaction to a specific event.
      *
@@ -89,92 +87,19 @@ 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, M> & {
+        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, 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, M>;
         };
@@ -182,35 +107,14 @@ export type ActBuilder<S extends SchemaRegister<A>, E extends Schemas, A extends
     /**
      * 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, 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>;
 };
@@ -223,8 +127,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
@@ -240,122 +144,35 @@ export type ActBuilder<S extends SchemaRegister<A>, E extends Schemas, A extends
  *   .init(() => ({ count: 0 }))
  *   .emits({ Incremented: z.object({ amount: z.number() }) })
  *   .patch({ Incremented: (event, state) => ({ count: state.count + event.data.amount }) })
- *   .on("increment", z.object({ by: z.number() }))
+ *   .on({ increment: z.object({ by: z.number() }) })
  *     .emit((action) => ["Incremented", { amount: action.by }])
  *   .build();
  *
  * 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
- * ```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();
- *
- * 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())
+ * @example Application with slices (vertical slice architecture)
  * ```typescript
- * const TicketCreation = state("Ticket", TicketSchema)
- *   .init(() => initialTicket)
- *   .emits({ TicketOpened: ..., TicketClosed: ... })
- *   .patch({ TicketOpened: ..., TicketClosed: ... })
- *   .on("OpenTicket", ...).emit(...)
- *   .on("CloseTicket", ...).emit(...)
- *   .build();
+ * import { act, slice, state } from "@rotorsoft/act";
  *
- * 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 = {}, 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":"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"}
+{"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

@@ -156,7 +156,7 @@ 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.
      *
@@ -359,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,8 @@ export * from "./act-builder.js";
 export * from "./act.js";
 export * from "./config.js";
 export * from "./ports.js";
+export * from "./projection-builder.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,yBAAyB,CAAC;AACxC,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/projection-builder.d.ts

@@ -0,0 +1,123 @@
+/**
+ * @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 { Committed, EventRegister, ReactionResolver, Schema, Schemas } from "./types/index.js";
+/**
+ * A self-contained projection grouping read-model update handlers.
+ * Projections are composed into an Act orchestrator via `act().with(projection)`.
+ *
+ * @template E - Event schemas handled by this projection
+ */
+export type Projection<E extends Schemas> = {
+    readonly _tag: "Projection";
+    readonly events: EventRegister<E>;
+};
+/**
+ * Type guard for distinguishing Projection from State and Slice objects.
+ */
+export declare function isProjection(x: any): x is Projection<any>;
+/** Helper: a single-key record mapping an event name to its Zod schema. */
+type EventEntry<K extends string = string, D extends Schema = Schema> = {
+    [P in K]: ZodType<D>;
+};
+/** Infer the handler-result type after registering one event. */
+type DoResult<E extends Schemas, K extends string, D extends Schema> = ProjectionBuilder<E & {
+    [P in K]: D;
+}> & {
+    to: (resolver: ReactionResolver<E & {
+        [P in K]: D;
+    }, K> | string) => ProjectionBuilder<E & {
+        [P in K]: D;
+    }>;
+    void: () => ProjectionBuilder<E & {
+        [P in K]: D;
+    }>;
+};
+/**
+ * Fluent builder interface for composing projections.
+ *
+ * Provides a chainable API for registering event handlers that update
+ * read models. Unlike slices, projections have no `.with()` for states
+ * and handlers do not receive a `Dispatcher`.
+ *
+ * When a default target is provided via `projection("target")`, all
+ * handlers inherit that resolver. Per-handler `.to()` or `.void()` can
+ * still override it.
+ *
+ * @template E - Event schemas
+ */
+export type ProjectionBuilder<E extends Schemas> = {
+    /**
+     * 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: <K extends string, D extends Schema>(entry: EventEntry<K, D>) => {
+        do: (handler: (event: Committed<E & {
+            [P in K]: D;
+        }, K>, stream: string) => Promise<void>) => DoResult<E, K, D>;
+    };
+    /**
+     * Builds and returns the Projection data structure.
+     */
+    build: () => Projection<E>;
+    /**
+     * The registered event schemas and their reaction maps.
+     */
+    readonly events: EventRegister<E>;
+};
+/**
+ * Creates a new projection builder for composing read-model update handlers.
+ *
+ * Projections enable separation of read-model concerns from command handling.
+ * Each `.on({ Event }).do(handler)` call registers a handler that updates
+ * a projection (database table, cache, etc.) in response to events.
+ *
+ * Pass a target stream name to `projection("target")` so every handler
+ * inherits that resolver automatically. Omit it and use per-handler
+ * `.to()` / `.void()` when handlers route to different streams.
+ *
+ * @param target - Optional default target stream for all handlers
+ *
+ * @example Default target (all handlers routed to "tickets")
+ * ```typescript
+ * const TicketProjection = projection("tickets")
+ *   .on({ TicketOpened })
+ *     .do(async ({ stream, data }) => {
+ *       await db.insert(tickets).values({ id: stream, ...data });
+ *     })
+ *   .on({ TicketClosed })
+ *     .do(async ({ stream, data }) => {
+ *       await db.update(tickets).set(data).where(eq(tickets.id, stream));
+ *     })
+ *   .build();
+ * ```
+ *
+ * @example Per-handler routing
+ * ```typescript
+ * const MultiProjection = projection()
+ *   .on({ OrderPlaced })
+ *     .do(async (event) => { ... })
+ *     .to("orders")
+ *   .on({ PaymentReceived })
+ *     .do(async (event) => { ... })
+ *     .to("payments")
+ *   .build();
+ * ```
+ *
+ * @see {@link ProjectionBuilder} for builder methods
+ * @see {@link Projection} for the output type
+ */
+export declare function projection<E extends Schemas = {}>(target?: string, events?: EventRegister<E>): ProjectionBuilder<E>;
+export {};
+//# sourceMappingURL=projection-builder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"projection-builder.d.ts","sourceRoot":"","sources":["../../src/projection-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEnC,OAAO,KAAK,EACV,SAAS,EACT,aAAa,EAGb,gBAAgB,EAChB,MAAM,EACN,OAAO,EACR,MAAM,kBAAkB,CAAC;AAE1B;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,OAAO,IAAI;IAC1C,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;CACnC,CAAC;AAEF;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,UAAU,CAAC,GAAG,CAAC,CAEzD;AAED,2EAA2E;AAC3E,KAAK,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;KACrE,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CACrB,CAAC;AAEF,iEAAiE;AACjE,KAAK,QAAQ,CACX,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,MAAM,IACd,iBAAiB,CAAC,CAAC,GAAG;KAAG,CAAC,IAAI,CAAC,GAAG,CAAC;CAAE,CAAC,GAAG;IAC3C,EAAE,EAAE,CACF,QAAQ,EAAE,gBAAgB,CAAC,CAAC,GAAG;SAAG,CAAC,IAAI,CAAC,GAAG,CAAC;KAAE,EAAE,CAAC,CAAC,GAAG,MAAM,KACxD,iBAAiB,CAAC,CAAC,GAAG;SAAG,CAAC,IAAI,CAAC,GAAG,CAAC;KAAE,CAAC,CAAC;IAC5C,IAAI,EAAE,MAAM,iBAAiB,CAAC,CAAC,GAAG;SAAG,CAAC,IAAI,CAAC,GAAG,CAAC;KAAE,CAAC,CAAC;CACpD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,OAAO,IAAI;IACjD;;;;;;OAMG;IACH,EAAE,EAAE,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EACrC,KAAK,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,KACpB;QACH,EAAE,EAAE,CACF,OAAO,EAAE,CACP,KAAK,EAAE,SAAS,CAAC,CAAC,GAAG;aAAG,CAAC,IAAI,CAAC,GAAG,CAAC;SAAE,EAAE,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,KACX,OAAO,CAAC,IAAI,CAAC,KACf,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;KACxB,CAAC;IACF;;OAEG;IACH,KAAK,EAAE,MAAM,UAAU,CAAC,CAAC,CAAC,CAAC;IAC3B;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;CACnC,CAAC;AAIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,OAAO,GAAG,EAAE,EAC/C,MAAM,CAAC,EAAE,MAAM,EACf,MAAM,GAAE,aAAa,CAAC,CAAC,CAA0B,GAChD,iBAAiB,CAAC,CAAC,CAAC,CAyEtB"}