@rotorsoft/act 0.13.0 → 0.15.0

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

@@ -1,24 +1,27 @@
 import type { Projection } from "./projection-builder.js";
-import type { Committed, Dispatcher, EventRegister, ReactionOptions, ReactionResolver, Schema, SchemaRegister, Schemas, Snapshot, State } from "./types/index.js";
+import type { Actor, 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().withSlice(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
+ * @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<S extends SchemaRegister<A>, E extends Schemas, A extends Schemas, M extends Record<string, Schema> = {}> = {
+export type Slice<TSchemaReg extends SchemaRegister<TActions>, TEvents extends Schemas, TActions extends Schemas, TStateMap extends Record<string, Schema> = {}, TActor extends Actor = Actor> = {
     readonly _tag: "Slice";
     readonly states: Map<string, State<any, any, any>>;
-    readonly events: EventRegister<E>;
+    readonly events: EventRegister<TEvents>;
     readonly projections: ReadonlyArray<Projection<any>>;
     /** @internal phantom field for type-level state schema tracking */
-    readonly _S?: S;
+    readonly _S?: TSchemaReg;
     /** @internal phantom field for type-level state name tracking */
-    readonly _M?: M;
+    readonly _M?: TStateMap;
+    /** @internal phantom field for type-level actor tracking */
+    readonly _TActor?: TActor;
 };
 /**
  * Fluent builder interface for composing functional slices.
@@ -26,12 +29,13 @@ export type Slice<S extends SchemaRegister<A>, E extends Schemas, A extends Sche
  * Provides a chainable API for registering states and projections,
  * and defining reactions scoped to the slice's own events.
  *
- * @template S - Schema register for states
- * @template E - Event schemas
- * @template A - Action schemas
- * @template M - Map of state names to state schemas
+ * @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 type SliceBuilder<S extends SchemaRegister<A>, E extends Schemas, A extends Schemas, M extends Record<string, Schema> = {}> = {
+export type SliceBuilder<TSchemaReg extends SchemaRegister<TActions>, TEvents extends Schemas, TActions extends Schemas, TStateMap extends Record<string, Schema> = {}, TActor extends Actor = Actor> = {
     /**
      * Registers a state definition with the slice.
      *
@@ -39,35 +43,35 @@ export type SliceBuilder<S extends SchemaRegister<A>, E extends Schemas, A exten
      * dispatch. Duplicate registrations (same state in multiple slices)
      * are handled automatically at composition time.
      */
-    withState: <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;
-    }>;
+    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>;
     /**
      * Embeds a built Projection within this slice. The projection's events
      * must be a subset of events from states already registered via
      * `.withState()`. Projection handlers preserve their `(event, stream)`
      * signature and do not receive a Dispatcher.
      */
-    withProjection: <EP extends Schemas>(projection: [Exclude<keyof EP, keyof E>] extends [never] ? Projection<EP> : never) => SliceBuilder<S, E, A, M>;
+    withProjection: <TNewEvents extends Schemas>(projection: [Exclude<keyof TNewEvents, keyof TEvents>] extends [never] ? Projection<TNewEvents> : never) => SliceBuilder<TSchemaReg, TEvents, TActions, TStateMap, TActor>;
     /**
      * 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<Schema, E> | 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>;
+    on: <TKey extends keyof TEvents>(event: TKey) => {
+        do: (handler: (event: Committed<TEvents, TKey>, stream: string, app: Dispatcher<TActions, TActor>) => Promise<Snapshot<Schema, TEvents> | void>, options?: Partial<ReactionOptions>) => SliceBuilder<TSchemaReg, TEvents, TActions, TStateMap, TActor> & {
+            to: (resolver: ReactionResolver<TEvents, TKey> | string) => SliceBuilder<TSchemaReg, TEvents, TActions, TStateMap, TActor>;
+            void: () => SliceBuilder<TSchemaReg, TEvents, TActions, TStateMap, TActor>;
         };
     };
     /**
      * Builds and returns the Slice data structure.
      */
-    build: () => Slice<S, E, A, M>;
+    build: () => Slice<TSchemaReg, TEvents, TActions, TStateMap, TActor>;
     /**
      * The registered event schemas and their reaction maps.
      */
-    readonly events: EventRegister<E>;
+    readonly events: EventRegister<TEvents>;
 };
 /**
  * Creates a new slice builder for composing partial states with scoped reactions.
@@ -102,5 +106,5 @@ export type SliceBuilder<S extends SchemaRegister<A>, E extends Schemas, A exten
  * @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>, projections?: Projection<any>[]): SliceBuilder<S, E, A, M>;
+export declare function slice<TSchemaReg extends SchemaRegister<TActions> = {}, TEvents extends Schemas = {}, TActions extends Schemas = {}, TStateMap extends Record<string, Schema> = {}, TActor extends Actor = Actor>(states?: Map<string, State<any, any, any>>, actions?: Record<string, any>, events?: EventRegister<TEvents>, projections?: Projection<any>[]): SliceBuilder<TSchemaReg, TEvents, TActions, TStateMap, TActor>;
 //# sourceMappingURL=slice-builder.d.ts.map

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

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

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

@@ -12,12 +12,13 @@ import { ActionHandler, Invariant, PatchHandlers, Schema, Schemas, Snapshot, Sta
  * Provides a fluent API to configure the initial state, event types,
  * and event handlers (reducers) before moving to action configuration.
  *
- * @template S - State schema type
+ * @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<S extends Schema, N extends string = string> = {
+export type StateBuilder<TState extends Schema, TName extends string = string> = {
     /**
      * Defines the initial state for new state instances.
      *
@@ -37,16 +38,16 @@ export type StateBuilder<S extends Schema, N extends string = string> = {
      * .init((data) => ({ ...data, createdAt: new Date() }))
      * ```
      */
-    init: (init: () => Readonly<S>) => {
+    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 E - Event schemas type
+         * @template TEvents - Event schemas type
          * @param events - Object mapping event names to Zod schemas
-         * @returns A builder with `.patch()` to define event handlers
+         * @returns An ActionBuilder (with optional `.patch()` to override specific reducers)
          *
          * @example
          * ```typescript
@@ -57,37 +58,38 @@ export type StateBuilder<S extends Schema, N extends string = string> = {
          * })
          * ```
          */
-        emits: <E extends Schemas>(events: ZodTypes<E>) => {
+        emits: <TEvents extends Schemas>(events: ZodTypes<TEvents>) => ActionBuilder<TState, TEvents, {}, TName> & {
             /**
-             * Defines how each event updates (patches) the state.
+             * Overrides specific event reducers. Events without a custom patch
+             * default to passthrough: `({ data }) => data` (event data merges
+             * into state).
              *
-             * Patch handlers are reducers - pure functions that take an event and current state,
-             * and return the changes to apply. Return partial state objects; unchanged fields
-             * are preserved automatically.
-             *
-             * @param patch - Object mapping event names to patch handler functions
+             * @param patch - Partial map of event names to patch handler functions
              * @returns An ActionBuilder for defining actions
              *
-             * @example
+             * @example Only override the events that need custom logic
              * ```typescript
+             * .emits({ TicketOpened, TicketClosed, TicketResolved })
              * .patch({
-             *   Incremented: (event, state) => ({ count: state.count + event.data.amount }),
-             *   Decremented: (event, state) => ({ count: state.count - event.data.amount }),
-             *   Reset: () => ({ count: 0 })
+             *   TicketOpened: ({ data }) => {
+             *     const { message, messageId, userId, ...other } = data;
+             *     return { ...other, userId, messages: { [messageId]: { ... } } };
+             *   },
              * })
+             * // TicketClosed and TicketResolved use passthrough
              * ```
              */
-            patch: (patch: PatchHandlers<S, E>) => ActionBuilder<S, E, {}, N>;
+            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<K extends string = string, S extends Schema = Schema> = {
-    [P in K]: ZodType<S>;
+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<K extends string = string, AX extends Schema = Schema> = {
-    [P in K]: ZodType<AX>;
+type ActionEntry<TKey extends string = string, TNewActions extends Schema = Schema> = {
+    [P in TKey]: ZodType<TNewActions>;
 };
 /**
  * Builder interface for defining actions (commands) on a state.
@@ -95,13 +97,14 @@ type ActionEntry<K extends string = string, AX extends Schema = Schema> = {
  * 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 S - State schema type
- * @template E - Event schemas type
- * @template A - Action schemas type
+ * @template TState - State schema type
+ * @template TEvents - Event schemas type
+ * @template TActions - Action schemas type
+ * @template TName - State name literal type
  *
  * @see {@link state} for complete usage examples
  */
-export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas, N extends string = string> = {
+export type ActionBuilder<TState extends Schema, TEvents extends Schemas, TActions extends Schemas, TName extends string = string> = {
     /**
      * Defines an action (command) that can be executed on this state.
      *
@@ -113,8 +116,8 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
      * when the variable name matches the action name. The key becomes the
      * action name, the value the Zod schema.
      *
-     * @template K - Action name (string literal type)
-     * @template AX - Action payload schema type
+     * @template TKey - Action name (string literal type)
+     * @template TNewActions - Action payload schema type
      * @param entry - Single-key record `{ ActionName: schema }`
      * @returns An object with `.given()` and `.emit()` for further configuration
      *
@@ -141,7 +144,7 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
      *   .emit((action) => ["TicketOpened", { title: action.title }])
      * ```
      */
-    on: <K extends string, AX extends Schema>(entry: ActionEntry<K, AX>) => {
+    on: <TKey extends string, TNewActions extends Schema>(entry: ActionEntry<TKey, TNewActions>) => {
         /**
          * Adds business rule invariants that must hold before the action can execute.
          *
@@ -160,7 +163,7 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
          * ])
          * ```
          */
-        given: (rules: Invariant<S>[]) => {
+        given: (rules: Invariant<TState>[]) => {
             /**
              * Defines the action handler that emits events.
              *
@@ -168,22 +171,30 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
              * and must return one or more events to emit. Events are applied to state
              * via the patch handlers defined earlier.
              *
-             * @param handler - Function that returns events to emit
+             * 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
+             * @example Custom handler
              * ```typescript
              * .emit((action, snapshot) => {
              *   const newBalance = snapshot.state.balance + action.amount;
              *   return ["Deposited", { amount: action.amount, newBalance }];
              * })
              * ```
+             *
+             * @example Passthrough (action payload = event data)
+             * ```typescript
+             * .emit("TicketAssigned")
+             * ```
              */
-            emit: (handler: ActionHandler<S, E, {
-                [P in K]: AX;
-            }, K>) => ActionBuilder<S, E, A & {
-                [P in K]: AX;
-            }, N>;
+            emit: (handler: ActionHandler<TState, TEvents, {
+                [P in TKey]: TNewActions;
+            }, TKey> | (keyof TEvents & string)) => ActionBuilder<TState, TEvents, TActions & {
+                [P in TKey]: TNewActions;
+            }, TName>;
         };
         /**
          * Defines the action handler that emits events.
@@ -192,9 +203,17 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
          * and must return one or more events to emit. Return a single event as
          * `["EventName", data]` or multiple events as an array of event tuples.
          *
-         * @param handler - Function that returns events to emit
+         * 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 Passthrough (action payload = event data)
+         * ```typescript
+         * .emit("Incremented")
+         * ```
+         *
          * @example Single event
          * ```typescript
          * .emit((action) => ["Incremented", { amount: action.by }])
@@ -207,25 +226,12 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
          *   ["LogUpdated", { message: `Incremented by ${action.by}` }]
          * ])
          * ```
-         *
-         * @example Conditional events
-         * ```typescript
-         * .emit((action, snapshot) => {
-         *   if (snapshot.state.count + action.by >= 100) {
-         *     return [
-         *       ["Incremented", { amount: action.by }],
-         *       ["MilestoneReached", { milestone: 100 }]
-         *     ];
-         *   }
-         *   return ["Incremented", { amount: action.by }];
-         * })
-         * ```
          */
-        emit: (handler: ActionHandler<S, E, {
-            [P in K]: AX;
-        }, K>) => ActionBuilder<S, E, A & {
-            [P in K]: AX;
-        }, N>;
+        emit: (handler: ActionHandler<TState, TEvents, {
+            [P in TKey]: TNewActions;
+        }, TKey> | (keyof TEvents & string)) => ActionBuilder<TState, TEvents, TActions & {
+            [P in TKey]: TNewActions;
+        }, TName>;
     };
     /**
      * Defines a snapshotting strategy to optimize state reconstruction.
@@ -258,7 +264,7 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
      * })
      * ```
      */
-    snap: (snap: (snapshot: Snapshot<S, E>) => boolean) => ActionBuilder<S, E, A, N>;
+    snap: (snap: (snapshot: Snapshot<TState, TEvents>) => boolean) => ActionBuilder<TState, TEvents, TActions, TName>;
     /**
      * Finalizes and builds the state definition.
      *
@@ -272,13 +278,13 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
      * const Counter = state({ Counter: schema })
      *   .init(() => ({ count: 0 }))
      *   .emits({ Incremented: z.object({ amount: z.number() }) })
-     *   .patch({ Incremented: (event, state) => ({ count: state.count + event.data.amount }) })
+     *   .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<S, E, A, N>
+     *   .build(); // Returns State<TState, TEvents, TActions, TName>
      * ```
      */
-    build: () => State<S, E, A, N>;
+    build: () => State<TState, TEvents, TActions, TName>;
 };
 /**
  * Creates a new state definition with event sourcing capabilities.
@@ -290,17 +296,17 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
  *
  * The state builder provides a fluent API for defining:
  * 1. Initial state via `.init()`
- * 2. Event types via `.emits()`
- * 3. Event handlers (reducers) via `.patch()`
- * 4. Actions (commands) via `.on()` → `.emit()`
+ * 2. Event types via `.emits()` — all events default to passthrough (`({ data }) => data`)
+ * 3. Custom event reducers via `.patch()` (optional — only for events that need custom logic)
+ * 4. Actions (commands) via `.on()` → `.emit()` — pass an event name string for passthrough
  * 5. Business rules (invariants) via `.given()`
  * 6. Snapshotting strategy via `.snap()`
  *
- * @template S - Zod schema type defining the shape of the state
+ * @template TState - Zod schema type defining the shape of the state
  * @param entry - Single-key record mapping state name to Zod schema (e.g., `{ Counter: z.object({ count: z.number() }) }`)
  * @returns A StateBuilder instance for fluent API configuration
  *
- * @example Basic counter state
+ * @example Basic counter state (with custom patch)
  * ```typescript
  * import { state } from "@rotorsoft/act";
  * import { z } from "zod";
@@ -310,14 +316,25 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
  *   .emits({
  *     Incremented: z.object({ amount: z.number() })
  *   })
- *   .patch({
- *     Incremented: (event, state) => ({ count: state.count + event.data.amount })
+ *   .patch({  // optional — only for events needing custom reducers
+ *     Incremented: ({ data }, state) => ({ count: state.count + data.amount })
  *   })
  *   .on({ increment: z.object({ by: z.number() }) })
  *     .emit((action) => ["Incremented", { amount: action.by }])
  *   .build();
  * ```
  *
+ * @example Passthrough state (no custom patch or emit needed)
+ * ```typescript
+ * const DigitBoard = state({ DigitBoard: z.object({ digit: z.string() }) })
+ *   .init(() => ({ digit: "" }))
+ *   .emits({ DigitCounted: z.object({ digit: z.string() }) })
+ *   // no .patch() — passthrough is the default (event data merges into state)
+ *   .on({ CountDigit: z.object({ digit: z.string() }) })
+ *     .emit("DigitCounted")  // string passthrough — action payload becomes event data
+ *   .build();
+ * ```
+ *
  * @example State with multiple events and invariants
  * ```typescript
  * const BankAccount = state({ BankAccount: z.object({
@@ -331,29 +348,29 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
  *     Withdrawn: z.object({ amount: z.number() }),
  *     Closed: z.object({})
  *   })
- *   .patch({
- *     Deposited: (event, state) => ({ balance: state.balance + event.data.amount }),
- *     Withdrawn: (event, state) => ({ balance: state.balance - event.data.amount }),
+ *   .patch({  // only override events needing custom logic
+ *     Deposited: ({ data }, state) => ({ balance: state.balance + data.amount }),
+ *     Withdrawn: ({ data }, state) => ({ balance: state.balance - data.amount }),
  *     Closed: () => ({ status: "closed", balance: 0 })
  *   })
  *   .on({ deposit: z.object({ amount: z.number() }) })
  *     .given([
  *       (_, snap) => snap.state.status === "open" || "Account must be open"
  *     ])
- *     .emit((action) => ["Deposited", { amount: action.amount }])
+ *     .emit("Deposited")  // passthrough — action payload { amount } becomes event data
  *   .on({ withdraw: z.object({ amount: z.number() }) })
  *     .given([
  *       (_, snap) => snap.state.status === "open" || "Account must be open",
  *       (_, snap, action) =>
  *         snap.state.balance >= action.amount || "Insufficient funds"
  *     ])
- *     .emit((action) => ["Withdrawn", { amount: action.amount }])
+ *     .emit("Withdrawn")
  *   .on({ close: z.object({}) })
  *     .given([
  *       (_, snap) => snap.state.status === "open" || "Already closed",
  *       (_, snap) => snap.state.balance === 0 || "Balance must be zero"
  *     ])
- *     .emit(() => ["Closed", {}])
+ *     .emit("Closed")
  *   .build();
  * ```
  *
@@ -369,14 +386,14 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
  *     UserCreated: z.object({ name: z.string(), email: z.string() }),
  *     UserLoggedIn: z.object({})
  *   })
- *   .patch({
- *     UserCreated: (event) => event.data,
+ *   .patch({  // only override events needing custom logic
  *     UserLoggedIn: (_, state) => ({ loginCount: state.loginCount + 1 })
  *   })
+ *   // UserCreated uses passthrough — event data merges into state
  *   .on({ createUser: z.object({ name: z.string(), email: z.string() }) })
- *     .emit((action) => ["UserCreated", action])
+ *     .emit("UserCreated")  // passthrough
  *   .on({ login: z.object({}) })
- *     .emit(() => ["UserLoggedIn", {}])
+ *     .emit("UserLoggedIn")
  *   .snap((snap) => snap.patches >= 10) // Snapshot every 10 events
  *   .build();
  * ```
@@ -386,6 +403,6 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
  * @see {@link https://rotorsoft.github.io/act-root/docs/intro | Getting Started Guide}
  * @see {@link https://rotorsoft.github.io/act-root/docs/examples/calculator | Calculator Example}
  */
-export declare function state<N extends string, S extends Schema>(entry: StateEntry<N, S>): StateBuilder<S, N>;
+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/state-builder.d.ts.map

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