@rotorsoft/act 0.9.0 → 0.11.0

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 "./projection-builder.js";
 export * from "./slice-builder.js";
 export * from "./state-builder.js";
 export * from "./types/index.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,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/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"}

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

@@ -81,6 +81,14 @@ export type StateBuilder<S extends Schema, N extends string = string> = {
         };
     };
 };
+/** 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>;
+};
+/** 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>;
+};
 /**
  * Builder interface for defining actions (commands) on a state.
  *
@@ -98,24 +106,27 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
      * 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
+     * (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.
+     *
      * @template K - Action name (string literal type)
      * @template AX - Action payload schema type
-     * @param action - The action name (should be unique within this state)
-     * @param schema - Zod schema for the action payload
+     * @param entry - Single-key record `{ ActionName: schema }`
      * @returns An object with `.given()` and `.emit()` for further configuration
      *
      * @example Simple action without invariants
      * ```typescript
-     * .on("increment", z.object({ by: z.number() }))
+     * .on({ increment: z.object({ by: z.number() }) })
      *   .emit((action) => ["Incremented", { amount: action.by }])
      * ```
      *
      * @example Action with business rules
      * ```typescript
-     * .on("withdraw", z.object({ amount: z.number() }))
+     * .on({ withdraw: z.object({ amount: z.number() }) })
      *   .given([
      *     (_, snap) => snap.state.balance >= 0 || "Account closed",
      *     (_, snap, action) => snap.state.balance >= action.amount || "Insufficient funds"
@@ -123,17 +134,14 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
      *   .emit((action) => ["Withdrawn", { amount: action.amount }])
      * ```
      *
-     * @example Action emitting multiple events
+     * @example Action with shorthand (variable name matches action name)
      * ```typescript
-     * .on("completeOrder", z.object({ orderId: z.string() }))
-     *   .emit((action) => [
-     *     ["OrderCompleted", { orderId: action.orderId }],
-     *     ["InventoryReserved", { orderId: action.orderId }],
-     *     ["PaymentProcessed", { orderId: action.orderId }]
-     *   ])
+     * const OpenTicket = z.object({ title: z.string() });
+     * .on({ OpenTicket })
+     *   .emit((action) => ["TicketOpened", { title: action.title }])
      * ```
      */
-    on: <K extends string, AX extends Schema>(action: K, schema: ZodType<AX>) => {
+    on: <K extends string, AX extends Schema>(entry: ActionEntry<K, AX>) => {
         /**
          * Adds business rule invariants that must hold before the action can execute.
          *
@@ -261,11 +269,11 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
      *
      * @example
      * ```typescript
-     * const Counter = state("Counter", schema)
+     * 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 }) })
-     *   .on("increment", z.object({ by: z.number() }))
+     *   .on({ increment: z.object({ by: z.number() }) })
      *     .emit((action) => ["Incremented", { amount: action.by }])
      *   .build(); // Returns State<S, E, A, N>
      * ```
@@ -289,8 +297,7 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
  * 6. Snapshotting strategy via `.snap()`
  *
  * @template S - Zod schema type defining the shape of the state
- * @param name - Unique identifier for this state type (e.g., "Counter", "User", "Order")
- * @param state - Zod schema defining the structure 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
@@ -298,7 +305,7 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
  * import { state } from "@rotorsoft/act";
  * import { z } from "zod";
  *
- * const Counter = state("Counter", z.object({ count: z.number() }))
+ * const Counter = state({ Counter: z.object({ count: z.number() }) })
  *   .init(() => ({ count: 0 }))
  *   .emits({
  *     Incremented: z.object({ amount: z.number() })
@@ -306,18 +313,18 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
  *   .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();
  * ```
  *
  * @example State with multiple events and invariants
  * ```typescript
- * const BankAccount = state("BankAccount", z.object({
+ * const BankAccount = state({ BankAccount: z.object({
  *   balance: z.number(),
  *   currency: z.string(),
  *   status: z.enum(["open", "closed"])
- * }))
+ * }) })
  *   .init(() => ({ balance: 0, currency: "USD", status: "open" }))
  *   .emits({
  *     Deposited: z.object({ amount: z.number() }),
@@ -329,19 +336,19 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
  *     Withdrawn: (event, state) => ({ balance: state.balance - event.data.amount }),
  *     Closed: () => ({ status: "closed", balance: 0 })
  *   })
- *   .on("deposit", z.object({ amount: z.number() }))
+ *   .on({ deposit: z.object({ amount: z.number() }) })
  *     .given([
  *       (_, snap) => snap.state.status === "open" || "Account must be open"
  *     ])
  *     .emit((action) => ["Deposited", { amount: action.amount }])
- *   .on("withdraw", z.object({ amount: z.number() }))
+ *   .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 }])
- *   .on("close", z.object({}))
+ *   .on({ close: z.object({}) })
  *     .given([
  *       (_, snap) => snap.state.status === "open" || "Already closed",
  *       (_, snap) => snap.state.balance === 0 || "Balance must be zero"
@@ -352,11 +359,11 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
  *
  * @example State with snapshotting
  * ```typescript
- * const User = state("User", z.object({
+ * const User = state({ User: z.object({
  *   name: z.string(),
  *   email: z.string(),
  *   loginCount: z.number()
- * }))
+ * }) })
  *   .init((data) => ({ ...data, loginCount: 0 }))
  *   .emits({
  *     UserCreated: z.object({ name: z.string(), email: z.string() }),
@@ -366,9 +373,9 @@ export type ActionBuilder<S extends Schema, E extends Schemas, A extends Schemas
  *     UserCreated: (event) => event.data,
  *     UserLoggedIn: (_, state) => ({ loginCount: state.loginCount + 1 })
  *   })
- *   .on("createUser", z.object({ name: z.string(), email: z.string() }))
+ *   .on({ createUser: z.object({ name: z.string(), email: z.string() }) })
  *     .emit((action) => ["UserCreated", action])
- *   .on("login", z.object({}))
+ *   .on({ login: z.object({}) })
  *     .emit(() => ["UserLoggedIn", {}])
  *   .snap((snap) => snap.patches >= 10) // Snapshot every 10 events
  *   .build();
@@ -379,5 +386,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>(name: N, state: ZodType<S>): StateBuilder<S, N>;
+export declare function state<N extends string, S extends Schema>(entry: StateEntry<N, S>): StateBuilder<S, N>;
+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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"}

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

@@ -187,7 +187,7 @@ export type Committed<E extends Schemas, K extends keyof E> = Message<E, K> & Co
  *
  * @example Using snapshot in action handler
  * ```typescript
- * .on("increment", z.object({ by: z.number() }))
+ * .on({ increment: z.object({ by: z.number() }) })
  *   .emit((action, snapshot) => {
  *     console.log("Current count:", snapshot.state.count);
  *     console.log("Events applied:", snapshot.patches);

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

@@ -83,7 +83,7 @@ import type { Patch, Schema } from "./types/index.js";
  * import { state } from "@rotorsoft/act";
  * import { z } from "zod";
  *
- * const Counter = state("Counter", z.object({ count: z.number() }))
+ * const Counter = state({ Counter: z.object({ count: z.number() }) })
  *   .init(() => ({ count: 0 }))
  *   .emits({ Incremented: z.object({ by: z.number() }) })
  *   .patch({
@@ -166,10 +166,10 @@ export declare const patch: <S extends Schema>(original: Readonly<S>, patches: R
  * import { state } from "@rotorsoft/act";
  * import { z } from "zod";
  *
- * const Counter = state("Counter", z.object({ count: z.number() }))
+ * const Counter = state({ Counter: z.object({ count: z.number() }) })
  *   .init(() => ({ count: 0 }))
  *   .emits({ Incremented: z.object({ by: z.number().positive() }) })
- *   .on("increment", z.object({ by: z.number() }))
+ *   .on({ increment: z.object({ by: z.number() }) })
  *     .emit((action) => {
  *       // validate() is called automatically before this runs
  *       // action.by is guaranteed to be a number

package/dist/index.cjs

@@ -53,10 +53,12 @@ __export(index_exports, {
   dispose: () => dispose,
   disposeAndExit: () => disposeAndExit,
   extend: () => extend,
+  isProjection: () => isProjection,
   isSlice: () => isSlice,
   logger: () => logger,
   patch: () => patch,
   port: () => port,
+  projection: () => projection,
   sleep: () => sleep,
   slice: () => slice,
   state: () => state,
@@ -1428,6 +1430,70 @@ var _this_ = ({ stream }) => ({
 });
 var _void_ = () => void 0;
 
+// src/projection-builder.ts
+function isProjection(x) {
+  return x != null && x._tag === "Projection";
+}
+function projection(target, events = {}) {
+  const defaultResolver = target ? { target } : void 0;
+  const builder = {
+    on: (entry) => {
+      const keys = Object.keys(entry);
+      if (keys.length !== 1) throw new Error(".on() requires exactly one key");
+      const event = keys[0];
+      const schema = entry[event];
+      if (!(event in events)) {
+        events[event] = {
+          schema,
+          reactions: /* @__PURE__ */ new Map()
+        };
+      }
+      return {
+        do: (handler) => {
+          const reaction = {
+            handler,
+            resolver: defaultResolver ?? _this_,
+            options: {
+              blockOnError: true,
+              maxRetries: 3
+            }
+          };
+          const register = events[event];
+          const name = handler.name || `${event}_${register.reactions.size}`;
+          register.reactions.set(name, reaction);
+          const nextBuilder = projection(
+            target,
+            events
+          );
+          return {
+            ...nextBuilder,
+            to(resolver) {
+              register.reactions.set(name, {
+                ...reaction,
+                resolver: typeof resolver === "string" ? { target: resolver } : resolver
+              });
+              return nextBuilder;
+            },
+            void() {
+              register.reactions.set(name, {
+                ...reaction,
+                resolver: _void_
+              });
+              return nextBuilder;
+            }
+          };
+        }
+      };
+    },
+    build: () => ({
+      _tag: "Projection",
+      events
+    }),
+    events
+  };
+  return builder;
+}
+
 // src/slice-builder.ts
 function isSlice(x) {
   return x != null && x._tag === "Slice";
@@ -1486,6 +1552,25 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
 }) {
   const builder = {
     with: ((input) => {
+      if (isProjection(input)) {
+        for (const eventName of Object.keys(input.events)) {
+          const projRegister = input.events[eventName];
+          const existing = registry.events[eventName];
+          if (!existing) {
+            registry.events[eventName] = {
+              schema: projRegister.schema,
+              reactions: new Map(projRegister.reactions)
+            };
+          } else {
+            for (const [name, reaction] of projRegister.reactions) {
+              let key = name;
+              while (existing.reactions.has(key)) key = `${key}_p`;
+              existing.reactions.set(key, reaction);
+            }
+          }
+        }
+        return act(states, registry);
+      }
       if (isSlice(input)) {
         for (const s of input.states.values()) {
           registerState(s, states, registry.actions, registry.events);
@@ -1546,7 +1631,11 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
 }
 
 // src/state-builder.ts
-function state(name, state2) {
+function state(entry) {
+  const keys = Object.keys(entry);
+  if (keys.length !== 1) throw new Error("state() requires exactly one key");
+  const name = keys[0];
+  const stateSchema = entry[name];
   return {
     init(init) {
       return {
@@ -1556,7 +1645,7 @@ function state(name, state2) {
               return action_builder({
                 events,
                 actions: {},
-                state: state2,
+                state: stateSchema,
                 name,
                 init,
                 patch: patch2,
@@ -1571,7 +1660,11 @@ function state(name, state2) {
 }
 function action_builder(state2) {
   return {
-    on(action2, schema) {
+    on(entry) {
+      const keys = Object.keys(entry);
+      if (keys.length !== 1) throw new Error(".on() requires exactly one key");
+      const action2 = keys[0];
+      const schema = entry[action2];
       if (action2 in state2.actions)
         throw new Error(`Duplicate action "${action2}"`);
       const actions = { ...state2.actions, [action2]: schema };
@@ -1625,10 +1718,12 @@ function action_builder(state2) {
   dispose,
   disposeAndExit,
   extend,
+  isProjection,
   isSlice,
   logger,
   patch,
   port,
+  projection,
   sleep,
   slice,
   state,