@typeonce/effect-machine 0.29.0 → 0.31.0

package/dist/unstable/reactivity/AtomMachine.js

@@ -48,6 +48,7 @@ export const inspection = internal.inspection;
 export const childEmissions = internal.childEmissions;
 const InvalidSelectorPathTypeId = "~effect/reactivity/AtomMachine/InvalidSelectorPath";
 const SelectorProjectionTypeId = "~effect/reactivity/AtomMachine/SelectorProjection";
+const InvalidCanEventTypeId = "~effect/reactivity/AtomMachine/InvalidCanEvent";
 /**
  * Selects the typed value for an active state path.
  *
@@ -159,6 +160,33 @@ export const selectSnapshotChild = dual(2, internal.selectSnapshotChild);
  * @since 0.4.0
  */
 export const matches = dual(2, internal.matches);
+/**
+ * Reactively tests whether a concrete event would be accepted by a running
+ * machine.
+ *
+ * Declare the returned projection once, then apply it to compatible machine
+ * bridges. Repeated applications to the same bridge return the same atom. An
+ * event atom is read reactively when acceptance depends on a changing payload.
+ *
+ * Startup remains in the source `AsyncResult`. Active snapshots use
+ * {@link Machine.can}; done and stopped snapshots produce `false`, while
+ * runtime and schema failures remain in the typed failure channel.
+ *
+ * **Example**
+ *
+ * ```ts
+ * const submitAllowed = AtomMachine.can(AuthEvents.Submitted())
+ * const canSubmitAtom = submitAllowed(authMachineAtom)
+ *
+ * const submitEvent = Atom.map(draftAtom, (draft) =>
+ *   AuthEvents.Submitted({ draft }))
+ * const reactiveSubmitAllowed = AtomMachine.can(submitEvent)
+ * ```
+ *
+ * @category combinators
+ * @since 0.31.0
+ */
+export const can = internal.can;
 /**
  * Returns whether a state path is active in a directly owned child.
  *
@@ -257,6 +285,26 @@ export const familyChild = internal.familyChild;
  * @since 0.4.0
  */
 export const make = internal.make;
+/**
+ * Specializes a machine definition into a reusable bridge constructor.
+ *
+ * The returned function preserves the machine's startup input arity and exact
+ * bridge type. Every call creates a fresh `MachineAtom`; it does not cache by
+ * input or start the machine before an `AtomRegistry` reads or mounts it.
+ *
+ * **Example**
+ *
+ * ```ts
+ * const makeSearchMachine = AtomMachine.factory(searchMachine)
+ * const search = makeSearchMachine({ query: "effect" })
+ *
+ * type SearchMachineAtom = ReturnType<typeof makeSearchMachine>
+ * ```
+ *
+ * @category constructors
+ * @since 0.30.0
+ */
+export const factory = internal.factory;
 /**
  * Creates a lazy atom bridge from a decoded logical snapshot.
  *
@@ -269,11 +317,12 @@ export const make = internal.make;
  */
 export const resume = internal.resume;
 /**
- * Creates an `AtomMachine` factory that owns a shared Effect runtime.
+ * Binds `AtomMachine` constructors to a shared Effect runtime.
  *
  * Use this when an application runs many machines from the same service layer.
- * The returned factory keeps runtime provisioning at the composition boundary,
- * while every call to `make` still creates an independent machine bridge.
+ * The returned interface keeps runtime provisioning at the composition seam,
+ * while every call to `make` or a specialized `factory` still creates an
+ * independent machine bridge.
  *
  * @category constructors
  * @since 0.4.0

package/dist/unstable/reactivity/AtomMachine.js.map

@@ -1 +1 @@
-{"version":3,"file":"AtomMachine.js","sourceRoot":"","sources":["../../../src/unstable/reactivity/AtomMachine.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAMtC,OAAO,KAAK,QAAQ,MAAM,gCAAgC,CAAA;AAK1D;;;;;GAKG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AAE9D;;;;;GAKG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AAMpE,MAAM,0BAA0B,GAAG,qDAAqD,CAAA;AAoIxF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,SAAS,GAE+C,QAAQ,CAAC,SAAS,CAAA;AAEvF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GAE+D,QAAQ,CAAC,UAAU,CAAA;AAEzG;;;;;GAKG;AACH,MAAM,CAAC,MAAM,cAAc,GAMvB,QAAQ,CAAC,cAAc,CAAA;AAwJ3B,MAAM,yBAAyB,GAAG,oDAAoD,CAAA;AACtF,MAAM,wBAAwB,GAAG,mDAAmD,CAAA;AA0BpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,CAAC,MAAM,MAAM,GA0Cf,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;AAE5B;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,cAAc,GA0CvB,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,cAAc,CAAC,CAAA;AAEpC;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,WAAW,GAsCpB,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAA;AAEjC;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAoC5B,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,mBAAmB,CAAC,CAAA;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,MAAM,OAAO,GAsChB,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;AAE7B;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,YAAY,GA2BrB,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAA;AAElC,MAAM,uBAAuB,GAAG,kDAAkD,CAAA;AAkJlF,MAAM,yBAAyB,GAAG,oDAAoD,CAAA;AAyFtF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,MAAM,GAkBgE,QAAQ,CAAC,MAAa,CAAA;AAEzG;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,WAAW,GAYqC,QAAQ,CAAC,WAAkB,CAAA;AAExF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,MAAM,IAAI,GAqDb,QAAQ,CAAC,IAAI,CAAA;AAEjB;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,MAAM,GASf,QAAQ,CAAC,MAAM,CAAA;AAEnB;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,IAAI,GAEoB,QAAQ,CAAC,IAAI,CAAA"}
+{"version":3,"file":"AtomMachine.js","sourceRoot":"","sources":["../../../src/unstable/reactivity/AtomMachine.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAMtC,OAAO,KAAK,QAAQ,MAAM,gCAAgC,CAAA;AAK1D;;;;;GAKG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AAE9D;;;;;GAKG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AAMpE,MAAM,0BAA0B,GAAG,qDAAqD,CAAA;AAoIxF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,SAAS,GAE+C,QAAQ,CAAC,SAAS,CAAA;AAEvF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GAE+D,QAAQ,CAAC,UAAU,CAAA;AAEzG;;;;;GAKG;AACH,MAAM,CAAC,MAAM,cAAc,GAMvB,QAAQ,CAAC,cAAc,CAAA;AAwJ3B,MAAM,yBAAyB,GAAG,oDAAoD,CAAA;AACtF,MAAM,wBAAwB,GAAG,mDAAmD,CAAA;AACpF,MAAM,qBAAqB,GAAG,gDAAgD,CAAA;AAkD9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,CAAC,MAAM,MAAM,GA0Cf,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;AAE5B;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,cAAc,GA0CvB,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,cAAc,CAAC,CAAA;AAEpC;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,WAAW,GAsCpB,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAA;AAEjC;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAoC5B,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,mBAAmB,CAAC,CAAA;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,MAAM,OAAO,GAsChB,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,GAAG,GAGZ,QAAQ,CAAC,GAAG,CAAA;AAEhB;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,YAAY,GA2BrB,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAA;AAElC,MAAM,uBAAuB,GAAG,kDAAkD,CAAA;AAkJlF,MAAM,yBAAyB,GAAG,oDAAoD,CAAA;AAyGtF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,MAAM,GAkBgE,QAAQ,CAAC,MAAa,CAAA;AAEzG;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,WAAW,GAYqC,QAAQ,CAAC,WAAkB,CAAA;AAExF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,MAAM,IAAI,GAqDb,QAAQ,CAAC,IAAI,CAAA;AAEjB;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,OAAO,GAM+C,QAAQ,CAAC,OAAO,CAAA;AAEnF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,MAAM,GASf,QAAQ,CAAC,MAAM,CAAA;AAEnB;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,IAAI,GAEoB,QAAQ,CAAC,IAAI,CAAA"}

package/docs/effect-atom-react.md

@@ -48,7 +48,7 @@ import { createContext, type ReactNode, useContext } from "react"
 import { AuthMachine, type AuthMachineInput } from "../machines/auth-machine"
 import { MachineAtoms } from "../lib/atom-runtime"
 
-const makeAuthMachine = (input: AuthMachineInput) => MachineAtoms.make(AuthMachine, input)
+const makeAuthMachine = MachineAtoms.factory(AuthMachine)
 type AuthMachineAtom = ReturnType<typeof makeAuthMachine>
 
 const AuthMachineContext = createContext<AuthMachineAtom | null>(null)
@@ -183,6 +183,53 @@ function SubmitButton() {
 `useAtomSet` mounts the writable atom and does not subscribe the component to
 its value.
 
+## Query concrete event acceptance
+
+`AtomMachine.can` turns one concrete event input into a reusable machine
+projection. Declare the projection once, then apply it to the React-owned
+machine. Repeated applications to the same machine return the same atom:
+
+```tsx
+import { AtomMachine } from "@typeonce/effect-machine/reactivity"
+import { useAtomSet, useAtomSuspense } from "@effect/atom-react"
+import { AuthEvents } from "../machines/auth-machine"
+
+const submitAllowed = AtomMachine.can(AuthEvents.Submitted())
+
+function SubmitButton() {
+  const machine = useAuthMachine()
+  const canSubmit = useAtomSuspense(submitAllowed(machine)).value
+  const send = useAtomSet(machine.send)
+
+  return (
+    <button
+      disabled={!canSubmit}
+      onClick={() => send(AuthEvents.Submitted())}
+    >
+      Continue
+    </button>
+  )
+}
+```
+
+Startup still suspends, startup and runtime failures reach the error boundary,
+and invalid event input for an active machine remains a
+`MachineSchemaDecodeError`. Done and stopped machines return `false`.
+
+When acceptance depends on a changing payload, project an event atom instead:
+
+```ts
+import { Atom } from "effect/unstable/reactivity"
+
+const submitEvent = Atom.map(draftAtom, (draft) =>
+  AuthEvents.Submitted({ draft }))
+
+const submitAllowed = AtomMachine.can(submitEvent)
+```
+
+Changes to `draftAtom` recompute acceptance. The event atom contains the event
+input itself rather than an `AsyncResult`.
+
 ## Whole-result and custom selections
 
 Reading the full result is correct when a component renders the complete

package/docs/machine-review.md

@@ -71,7 +71,8 @@ Use `useMachineAtom` when one React subtree owns the workflow, including a
 machine with startup input:
 
 ```tsx
-const machine = useMachineAtom(() => machineAtoms.make(processMachine, input))
+const makeProcessMachine = machineAtoms.factory(processMachine)
+const machine = useMachineAtom(() => makeProcessMachine(input))
 ```
 
 Pass the stable machine through props or Context. Startup input is captured

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typeonce/effect-machine",
-  "version": "0.29.0",
+  "version": "0.31.0",
   "description": "Schema-first state machines and statecharts for Effect",
   "author": "Sandro Maglione",
   "repository": {

package/src/Machine.ts

@@ -9301,6 +9301,120 @@ export const enabled: <
   state: Machine.Snapshot<States>
 ) => ReadonlyArray<Machine.TagOf<Events[number]>> = internal.enabled as any
 
+/**
+ * Tests whether a concrete event would select at least one transition from a
+ * decoded snapshot.
+ *
+ * **Details**
+ *
+ * Required handlers are accepted from their structural eligibility.
+ * Declinable handlers run their resolver only far enough to decide whether
+ * they accept the event. Any commands, emissions, or raised events collected
+ * during that check are discarded.
+ *
+ * Event input is decoded through the machine's public event protocol. Invalid
+ * input fails with `MachineSchemaDecodeError`. Final snapshots and valid events
+ * with no accepting handler return `false`.
+ *
+ * **Gotchas**
+ *
+ * This query does not execute transitions or stabilize the resulting machine.
+ * It does not run entry, exit, always, completion, child lifecycle, or command
+ * effects. A `true` result therefore describes event acceptance only.
+ *
+ * **Example**
+ *
+ * ```ts
+ * const canCheckout = Machine.can(checkoutMachine)
+ *
+ * const canSubmit = yield* canCheckout(snapshot, {
+ *   _tag: "SubmitOrder"
+ * })
+ * ```
+ *
+ * @category getters
+ * @since 0.30.0
+ */
+export const can: {
+  <
+    const States extends Machine.StateSchemas,
+    const Events extends ReadonlyArray<Machine.TaggedSchema>,
+    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
+    const Input extends Schema.Top = typeof Schema.Void,
+    UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>,
+    E = never,
+    R = never,
+    InitialE = never,
+    InitialR = never,
+    FinalStates extends Machine.StateIdentifier<States> = never,
+    Output = never,
+    OutputStates extends Machine.StateIdentifier<States> = never,
+    InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+  >(
+    machine:
+      & Machine<
+        States,
+        Events,
+        Input,
+        UnhandledStates,
+        E,
+        R,
+        InitialE,
+        InitialR,
+        FinalStates,
+        Output,
+        Emits,
+        OutputStates,
+        InputEvents,
+        ParentEvents
+      >
+      & EnsureExecutable<States, UnhandledStates, OutputStates>
+      & Machine.RootCompatible<ParentEvents>
+  ): (
+    state: Machine.Snapshot<States>,
+    event: Machine.EventInputOf<InputEvents>
+  ) => Effect.Effect<boolean, MachineSchemaDecodeError>
+  <
+    const States extends Machine.StateSchemas,
+    const Events extends ReadonlyArray<Machine.TaggedSchema>,
+    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
+    const Input extends Schema.Top = typeof Schema.Void,
+    UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>,
+    E = never,
+    R = never,
+    InitialE = never,
+    InitialR = never,
+    FinalStates extends Machine.StateIdentifier<States> = never,
+    Output = never,
+    OutputStates extends Machine.StateIdentifier<States> = never,
+    InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+  >(
+    machine:
+      & Machine<
+        States,
+        Events,
+        Input,
+        UnhandledStates,
+        E,
+        R,
+        InitialE,
+        InitialR,
+        FinalStates,
+        Output,
+        Emits,
+        OutputStates,
+        InputEvents,
+        ParentEvents
+      >
+      & EnsureExecutable<States, UnhandledStates, OutputStates>
+      & Machine.RootCompatible<ParentEvents>,
+    state: Machine.Snapshot<States>,
+    event: Machine.EventInputOf<InputEvents>
+  ): Effect.Effect<boolean, MachineSchemaDecodeError>
+} = internal.can as any
+
 /**
  * Plans the next state snapshot synchronously.
  *

package/src/internal/machine/atom.ts

@@ -79,6 +79,8 @@ const preparedByMachineAtom = new WeakMap<
   Atom.Atom<AsyncResult.AsyncResult<Machine.Prepared<any, any, any, any, any, any, any>, any>>
 >()
 
+const machineByMachineAtom = new WeakMap<object, Machine.Machine.Any>()
+
 type WeakFamilyEntry<Value extends object> = {
   readonly ref: WeakRef<Value>
 }
@@ -422,7 +424,8 @@ const makeChildSelector = <StartError>(
 }
 
 const makeFromRefAtom = <State, Event, Error, Output, StartError, Emitted>(
-  ref: Atom.Atom<AsyncResult.AsyncResult<Machine.MachineRef<State, Event, Error, Output, Emitted>, StartError>>
+  ref: Atom.Atom<AsyncResult.AsyncResult<Machine.MachineRef<State, Event, Error, Output, Emitted>, StartError>>,
+  machine: Machine.Machine.Any
 ): MachineAtom<State, Event, Error, Output, StartError, Emitted> => {
   const snapshot = Atom.readable((
     get
@@ -498,7 +501,7 @@ const makeFromRefAtom = <State, Event, Error, Output, StartError, Emitted>(
   const optionalRef = Atom.mapResult(ref, Option.some)
   const child = makeChildSelector<StartError>(optionalRef as any)
 
-  return {
+  const result = {
     ref,
     snapshot,
     state: Atom.mapResult(snapshot, (snapshot) => snapshot.state),
@@ -507,6 +510,8 @@ const makeFromRefAtom = <State, Event, Error, Output, StartError, Emitted>(
     stop,
     child
   }
+  machineByMachineAtom.set(result, machine)
+  return result
 }
 
 type SnapshotNode<State> = State extends Machine.Machine.AtomicSnapshot<string, unknown> ?
@@ -716,6 +721,57 @@ export const matchesChild = <
       Option.exists((snapshot) => Option.isSome(Topology.getSnapshotByPath(snapshot, path)))
     ).pipe(Atom.withEquality(Equal.equals)))
 
+export const can = (event: unknown) => {
+  const byBridge = new WeakMap<object, Atom.Atom<AsyncResult.AsyncResult<boolean, any>>>()
+  return (self: MachineAtom<any, any, any, any, any, any>): Atom.Atom<AsyncResult.AsyncResult<boolean, any>> => {
+    const cached = byBridge.get(self)
+    if (cached !== undefined) return cached
+
+    const machine = machineByMachineAtom.get(self)
+    const query: (
+      state: Machine.Machine.Snapshot<any>,
+      event: unknown
+    ) => Effect.Effect<boolean, Machine.MachineSchemaDecodeError> = machine === undefined
+      ? () => Effect.die(new Error("AtomMachine.can requires a machine atom created by AtomMachine"))
+      : internalMachine.can(machine) as (
+        state: Machine.Machine.Snapshot<any>,
+        event: unknown
+      ) => Effect.Effect<boolean, Machine.MachineSchemaDecodeError>
+
+    const result = Atom.readable((get): AsyncResult.AsyncResult<boolean, any> => {
+      const current = get(self.snapshot)
+      const previous = get.self<AsyncResult.AsyncResult<boolean, any>>()
+      if (AsyncResult.isInitial(current)) {
+        return AsyncResult.initial(current.waiting)
+      } else if (AsyncResult.isFailure(current)) {
+        return AsyncResult.failureWithPrevious(current.cause, {
+          previous,
+          waiting: current.waiting
+        })
+      } else if (current.value.status === "error") {
+        return AsyncResult.failureWithPrevious(current.value.cause, {
+          previous,
+          waiting: current.waiting
+        })
+      } else if (current.value.status !== "active") {
+        return AsyncResult.success(false, { waiting: current.waiting })
+      }
+
+      const input = Atom.isAtom(event) ? get(event) : event
+      const exit = Effect.runSyncExit(query(current.value.state, input))
+      return exit._tag === "Success"
+        ? AsyncResult.success(exit.value, { waiting: current.waiting })
+        : AsyncResult.failureWithPrevious(exit.cause, {
+          previous,
+          waiting: current.waiting
+        })
+    }).pipe(Atom.withEquality(Equal.equals))
+
+    byBridge.set(self, result)
+    return result
+  }
+}
+
 type MachineResumeRequirementsOf<M extends Machine.Machine.Any> = MachineResumeRequirements<
   Machine.Machine.Services<M>,
   Machine.Machine.Event<M>,
@@ -796,11 +852,14 @@ export const make: {
 } = ((machine: Machine.Machine.Any, ...args: ReadonlyArray<unknown>) => {
   const prepared = Atom.make(() => internalMachine.prepare(machine as any, ...(args as [])))
   const ref = Atom.make((get) => startPreparedMachineAtomEffect(get, prepared as any))
-  const result = makeFromRefAtom(ref as any)
+  const result = makeFromRefAtom(ref as any, machine)
   preparedByMachineAtom.set(result, prepared as any)
   return result
 }) as any
 
+export const factory =
+  ((machine: Machine.Machine.Any) => (...args: ReadonlyArray<unknown>) => (make as any)(machine, ...args)) as any
+
 export const resume: {
   <M extends Machine.Machine.Any>(
     machine:
@@ -812,7 +871,7 @@ export const resume: {
   ): ResumedMachineAtomOf<M, never>
 } = ((machine: Machine.Machine.Any, snapshot: Machine.Machine.Snapshot<any>) => {
   const ref = Atom.make((get) => resumeMachineAtomEffect(get, machine, snapshot))
-  return makeFromRefAtom(ref as any)
+  return makeFromRefAtom(ref as any, machine)
 }) as any
 
 const makeWithRuntime = (
@@ -822,7 +881,7 @@ const makeWithRuntime = (
 ): MachineAtom<any, any, any, any, any, any> => {
   const prepared = runtime.atom(() => internalMachine.prepare(machine as any, ...(args as [])))
   const ref = runtime.atom((get) => startPreparedMachineAtomEffect(get, prepared as any))
-  const result = makeFromRefAtom(ref as any)
+  const result = makeFromRefAtom(ref as any, machine)
   preparedByMachineAtom.set(result, prepared as any)
   return result
 }
@@ -833,7 +892,7 @@ const resumeWithRuntime = (
   snapshot: Machine.Machine.Snapshot<any>
 ): MachineAtom<any, any, any, any, any, any> => {
   const ref = runtime.atom((get) => resumeMachineAtomEffect(get, machine, snapshot))
-  return makeFromRefAtom(ref as any)
+  return makeFromRefAtom(ref as any, machine)
 }
 
 type FamilyBridge = MachineAtom<any, never, any, any, any, any> | ChildMachineAtom<any, any>
@@ -901,19 +960,25 @@ export const familyChild = (
 
 export const bind = <Services, RuntimeError>(
   runtime: Atom.AtomRuntime<Services, RuntimeError>
-): Bound<Services, RuntimeError> => ({
-  make:
+): Bound<Services, RuntimeError> => {
+  const makeBound =
     ((machine: Machine.Machine.Any, ...args: ReadonlyArray<unknown>) =>
       makeWithRuntime(runtime, machine, args)) as Bound<
         Services,
         RuntimeError
-      >["make"],
-  resume:
-    ((machine: Machine.Machine.Any, snapshot: Machine.Machine.Snapshot<any>) =>
-      resumeWithRuntime(runtime, machine, snapshot)) as Bound<Services, RuntimeError>["resume"],
-  family: ((machine: Machine.Machine.Any, options: FamilyOptions) =>
-    makeFamily(
-      (input) => makeWithRuntime(runtime, machine, [input]),
-      options
-    )) as Bound<Services, RuntimeError>["family"]
-})
+      >["make"]
+  return {
+    make: makeBound,
+    factory:
+      ((machine: Machine.Machine.Any) => (...args: ReadonlyArray<unknown>) =>
+        (makeBound as any)(machine, ...args)) as Bound<Services, RuntimeError>["factory"],
+    resume:
+      ((machine: Machine.Machine.Any, snapshot: Machine.Machine.Snapshot<any>) =>
+        resumeWithRuntime(runtime, machine, snapshot)) as Bound<Services, RuntimeError>["resume"],
+    family: ((machine: Machine.Machine.Any, options: FamilyOptions) =>
+      makeFamily(
+        (input) => makeWithRuntime(runtime, machine, [input]),
+        options
+      )) as Bound<Services, RuntimeError>["family"]
+  }
+}

package/src/internal/machine/machine.ts

@@ -2176,6 +2176,8 @@ export const enabled = <
   state: Machine.Snapshot<States>
 ): ReadonlyArray<Machine.TagOf<Events[number]>> => internalPlanner.enabled(machine as any, state)
 
+export const can = internalPlanner.can
+
 export const plan: <
   const States extends Machine.StateSchemas,
   const Events extends ReadonlyArray<Machine.TaggedSchema>,

package/src/internal/machine/planner.ts

@@ -1876,6 +1876,17 @@ export const enabled = <
   return tags
 }
 
+const canSync = (
+  machine: Machine.Any,
+  state: Machine.Snapshot<any>,
+  event: unknown
+): boolean => {
+  const decodedEvent = decodeEventSync(machine, event)
+  if (isFinalState(machine, state)) return false
+  const configuration = normalizeConfigurationSync(machine, state)
+  return selectEventTransitions(machine, configuration, decodedEvent as any).length > 0
+}
+
 const microstep = <
   const States extends Machine.StateSchemas,
   const Events extends ReadonlyArray<Machine.TaggedSchema>,
@@ -2300,6 +2311,20 @@ const planningEffect = <A>(thunk: () => A): Effect.Effect<A, InfiniteTransitionE
     }
   })
 
+const schemaEffect = <A>(thunk: () => A): Effect.Effect<A, MachineSchemaDecodeError> =>
+  Effect.suspend(() => {
+    try {
+      return Effect.succeed(thunk())
+    } catch (error) {
+      return error instanceof MachineSchemaDecodeError ? Effect.fail(error) : Effect.die(error)
+    }
+  })
+
+export const can = (...args: readonly [Machine.Any] | readonly [Machine.Any, Machine.Snapshot<any>, unknown]) => {
+  const query = (state: Machine.Snapshot<any>, event: unknown) => schemaEffect(() => canSync(args[0], state, event))
+  return args.length === 1 ? query : query(args[1], args[2])
+}
+
 export const plan = (machine: Machine.Any, state: Machine.Snapshot<any>, event: unknown) =>
   planningEffect(() => planSync(machine as any, state, event as any))
 

package/src/unstable/reactivity/AtomMachine.ts

@@ -358,6 +358,7 @@ type ChildSnapshot<Child extends Machine.ChildMachine.Any> = Machine.Machine.Sna
 
 const InvalidSelectorPathTypeId = "~effect/reactivity/AtomMachine/InvalidSelectorPath"
 const SelectorProjectionTypeId = "~effect/reactivity/AtomMachine/SelectorProjection"
+const InvalidCanEventTypeId = "~effect/reactivity/AtomMachine/InvalidCanEvent"
 
 type SelectorProjectionKind =
   | "select"
@@ -374,6 +375,30 @@ interface SelectorProjection<Kind extends SelectorProjectionKind, Path extends s
   }
 }
 
+type EnsureCanEvent<AcceptedEvent, Input> = [Input] extends [AcceptedEvent] ? unknown : {
+  readonly [InvalidCanEventTypeId]: {
+    readonly input: Input
+    readonly accepted: AcceptedEvent
+  }
+}
+
+interface CanProjection<Input> {
+  <
+    State extends Machine.Machine.AtomicSnapshot<string, unknown>,
+    AcceptedEvent,
+    Error,
+    Output,
+    StartError,
+    Emitted
+  >(
+    self:
+      & MachineAtom<State, AcceptedEvent, Error, Output, StartError, Emitted>
+      & EnsureCanEvent<AcceptedEvent, Input>
+  ): Atom.Atom<
+    AsyncResult.AsyncResult<boolean, StartError | Error | Machine.MachineSchemaDecodeError>
+  >
+}
+
 type EnsureSelectorPath<State, Path extends string> = [Path] extends [SnapshotIdentifier<State>] ? unknown : {
   readonly [InvalidSelectorPathTypeId]: Path
 }
@@ -695,6 +720,37 @@ export const matches: {
   ): Atom.Atom<AsyncResult.AsyncResult<boolean, StartError | Error>>
 } = dual(2, internal.matches)
 
+/**
+ * Reactively tests whether a concrete event would be accepted by a running
+ * machine.
+ *
+ * Declare the returned projection once, then apply it to compatible machine
+ * bridges. Repeated applications to the same bridge return the same atom. An
+ * event atom is read reactively when acceptance depends on a changing payload.
+ *
+ * Startup remains in the source `AsyncResult`. Active snapshots use
+ * {@link Machine.can}; done and stopped snapshots produce `false`, while
+ * runtime and schema failures remain in the typed failure channel.
+ *
+ * **Example**
+ *
+ * ```ts
+ * const submitAllowed = AtomMachine.can(AuthEvents.Submitted())
+ * const canSubmitAtom = submitAllowed(authMachineAtom)
+ *
+ * const submitEvent = Atom.map(draftAtom, (draft) =>
+ *   AuthEvents.Submitted({ draft }))
+ * const reactiveSubmitAllowed = AtomMachine.can(submitEvent)
+ * ```
+ *
+ * @category combinators
+ * @since 0.31.0
+ */
+export const can: {
+  <Input>(event: Atom.Atom<Input>): CanProjection<Input>
+  <const Input>(event: Input): CanProjection<Input>
+} = internal.can
+
 /**
  * Returns whether a state path is active in a directly owned child.
  *
@@ -906,7 +962,7 @@ type ResumedMachineAtomOf<M extends Machine.Machine.Any, RuntimeError> = Machine
 >
 
 /**
- * An `AtomMachine` factory with one owned Effect runtime.
+ * `AtomMachine` constructors bound to one owned Effect runtime.
  *
  * @category models
  * @since 0.4.0
@@ -929,6 +985,22 @@ export interface Bound<Services, RuntimeError = never> {
     ...args: MachineInputArgsOf<M>
   ) => MachineAtomOf<M, RuntimeError>
 
+  /**
+   * Specializes a machine definition into a reusable bridge constructor.
+   *
+   * Every call creates an independent machine bridge. Startup remains lazy
+   * and begins only when an `AtomRegistry` reads or mounts the bridge.
+   *
+   * @since 0.30.0
+   */
+  readonly factory: <M extends Machine.Machine.Any>(
+    machine:
+      & M
+      & EnsureBoundRequirements<Services, NoInfer<M>>
+      & EnsureMachineExecutable<NoInfer<M>>
+      & Machine.Machine.RootCompatible<Machine.Machine.ParentEvents<NoInfer<M>>>
+  ) => (...args: MachineInputArgsOf<M>) => MachineAtomOf<M, RuntimeError>
+
   /** Creates a lazy bridge from a decoded logical snapshot. */
   readonly resume: <M extends Machine.Machine.Any>(
     machine:
@@ -1140,6 +1212,33 @@ export const make: {
   >
 } = internal.make
 
+/**
+ * Specializes a machine definition into a reusable bridge constructor.
+ *
+ * The returned function preserves the machine's startup input arity and exact
+ * bridge type. Every call creates a fresh `MachineAtom`; it does not cache by
+ * input or start the machine before an `AtomRegistry` reads or mounts it.
+ *
+ * **Example**
+ *
+ * ```ts
+ * const makeSearchMachine = AtomMachine.factory(searchMachine)
+ * const search = makeSearchMachine({ query: "effect" })
+ *
+ * type SearchMachineAtom = ReturnType<typeof makeSearchMachine>
+ * ```
+ *
+ * @category constructors
+ * @since 0.30.0
+ */
+export const factory: <M extends Machine.Machine.Any>(
+  machine:
+    & M
+    & EnsureNoExternalRequirements<MachineRequirementsOf<NoInfer<M>>>
+    & EnsureMachineExecutable<NoInfer<M>>
+    & Machine.Machine.RootCompatible<Machine.Machine.ParentEvents<NoInfer<M>>>
+) => (...args: MachineInputArgsOf<M>) => MachineAtomOf<M, never> = internal.factory
+
 /**
  * Creates a lazy atom bridge from a decoded logical snapshot.
  *
@@ -1162,11 +1261,12 @@ export const resume: {
 } = internal.resume
 
 /**
- * Creates an `AtomMachine` factory that owns a shared Effect runtime.
+ * Binds `AtomMachine` constructors to a shared Effect runtime.
  *
  * Use this when an application runs many machines from the same service layer.
- * The returned factory keeps runtime provisioning at the composition boundary,
- * while every call to `make` still creates an independent machine bridge.
+ * The returned interface keeps runtime provisioning at the composition seam,
+ * while every call to `make` or a specialized `factory` still creates an
+ * independent machine bridge.
  *
  * @category constructors
  * @since 0.4.0