@typeonce/effect-machine 0.8.0 → 0.10.0

package/dist/Machine.js

@@ -13,6 +13,7 @@ import { InitialEventTypeId } from "./internal/machine/machine.js";
  * @since 0.4.0
  */
 export const TypeId = "~effect/Machine";
+const ChildMachineLogicTypeId = internal.ChildMachineLogicTypeId;
 /**
  * Type identifier used for the synthetic event passed to startup lifecycle
  * actions.
@@ -142,7 +143,7 @@ export const isFinal = internal.isFinal;
  *
  * Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.idle.from()
  * })
  * ```
@@ -162,10 +163,13 @@ export const defineStates = internal.defineStates;
  * `defineStates` or is passed inline. Call `handle` on the returned definition
  * to implement state behavior with ordinary TypeScript control flow.
  *
- * Schemas in `events` define the public input protocol. Schemas in
- * `internalEvents` are added to the complete handler protocol for invoke
- * results, child emissions, and other machine-local deliveries. Their tags
- * must be disjoint.
+ * `Machine.events` defines the public input protocol. `Machine.internalEvents`
+ * adds raised events and other machine-local deliveries.
+ * `Machine.emittedEvents` defines outward ephemeral notifications, while
+ * `parentEvents` declares the inputs a child may explicitly send to its owning
+ * actor. All descriptors expose deferred constructors while retaining their
+ * schemas opaquely for runtime validation. Public and internal tags must be
+ * disjoint.
  *
  * **Example** (Typed counter machine)
  *
@@ -182,10 +186,11 @@ export const defineStates = internal.defineStates;
  * }) {}
  *
  * const States = Machine.defineStates({ Count })
+ * const Events = Machine.events(Increment)
  *
  * const counter = Machine.make({
  *   states: States.states,
- *   events: [Increment],
+ *   events: Events,
  *   initial: () => States.initial.Count(new Count({ value: 0 }))
  * }).handle({
  *   Count: {
@@ -203,45 +208,58 @@ export const defineStates = internal.defineStates;
  */
 export const make = internal.make;
 /**
- * Constructs an event from a schema owned by a machine's protocol.
+ * Defines a public event protocol and returns deferred constructors for every
+ * statically finite configured event tag.
  *
- * **Details**
- *
- * The schema constructor runs exactly once. The resulting decoded event is
- * trusted by this machine and definitions derived from it with `handle`, so
- * repeated delivery does not decode the same already-constructed value again.
- * Events supplied through ordinary `send` and `plan` calls remain untrusted
- * and continue through full runtime schema validation.
- * Treat the returned event as immutable after construction.
- *
- * The schema must be one of the machine's configured public or internal event
- * schemas, or a case schema belonging to a configured `Schema.TaggedUnion`.
+ * Constructor inputs retain their schema-derived required fields, defaults,
+ * and transformations. Construction is deferred until delivery so failures
+ * enter the machine's `MachineSchemaDecodeError` channel rather than throwing
+ * at the call site.
  *
  * **Example**
  *
  * ```ts
- * import { Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
+ * const Events = Machine.events(Increment, Reset)
+ * const machine = Machine.make({ events: Events, ... })
+ * yield* ref.send(Events.Increment({ by: 1 }))
+ * ```
  *
- * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * class Increment extends Schema.TaggedClass<Increment>("Increment")("Increment", {
- *   by: Schema.Number
- * }) {}
+ * @category constructors
+ * @since 0.10.0
+ */
+export const events = internal.events;
+/**
+ * Defines an internal event protocol and returns deferred constructors for
+ * every statically finite configured event tag.
  *
- * const States = Machine.defineStates({ Idle })
- * const counter = Machine.make({
- *   states: States.states,
- *   events: [Increment],
- *   initial: () => States.initial.Idle.from()
- * }).handle({ Idle: { on: { Increment: () => States.initial.Idle.from() } } })
+ * Use these constructors for raised events and other machine-local deliveries.
+ * Construction failures are reported through the
+ * owning machine's `MachineSchemaDecodeError` channel.
+ *
+ * **Example**
  *
- * const increment = Machine.event(counter, Increment, { by: 1 })
+ * ```ts
+ * const InternalEvents = Machine.internalEvents(Loaded, Failed)
+ * const machine = Machine.make({ internalEvents: InternalEvents, ... })
+ *
+ * // Inside a transition callback:
+ * enqueue.raise(InternalEvents.Loaded({ value }))
  * ```
  *
  * @category constructors
- * @since 0.4.0
+ * @since 0.10.0
  */
-export const event = internal.event;
+export const internalEvents = internal.internalEvents;
+/**
+ * Defines the ephemeral notifications a machine may publish to external
+ * observers. Emitted events are separate from actor input and are never sent
+ * implicitly to a parent actor. Observe them through `MachineRef.emissions` or
+ * the AtomMachine emission stream adapters.
+ *
+ * @category constructors
+ * @since 0.10.0
+ */
+export const emittedEvents = internal.emittedEvents;
 /**
  * Encodes a decoded machine snapshot into a normalized data representation.
  *
@@ -275,7 +293,7 @@ export const event = internal.event;
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -319,7 +337,7 @@ export const encodeSnapshot = internal.encodeSnapshot;
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -336,147 +354,37 @@ export const encodeSnapshot = internal.encodeSnapshot;
  */
 export const decodeSnapshot = internal.decodeSnapshot;
 /**
- * Creates an invoked child process configuration for an active state.
+ * Preserves inference for a state-owned invocation configuration.
  *
- * **When to use**
- *
- * Use to run a child process while a machine remains in a state. Successful
- * outputs are sent directly to the parent machine as events; `void` sends
- * nothing. Unrecovered child failures fail the owning machine. Active
- * snapshots can optionally be mapped to progress events.
- *
- * **Gotchas**
+ * Use `effect` for one-shot work, `after` for a cancellable timer, `logic` for
+ * reusable process logic, or `child` for a complete child machine. `onDone` is
+ * required whenever the source can complete with an output, while `onFailure`
+ * is required only when the source has a typed failure channel.
  *
- * Invoked child processes run while their owning state is active and are
- * stopped before the state exits. An unrecovered child failure fails the owning
- * machine; recover inside the child Effect when failure should become an event.
- * The `id` is a state-local lifecycle key, not a communication address. To
- * send events to the invocation, pass a typed `childAddress` as `address`.
- * The `src` callback is intentionally independent from its parent state. When
- * construction depends on the typed state, lifecycle event, or runtime, use
- * the state config factory form `invoke: (context) => Machine.invoke(...)` and
- * close over that context from `src`.
- *
- * **Example** (Effect output as a parent event)
+ * This constructor is an identity at runtime, but preserves lifecycle callback
+ * inference through published declarations. Effects and durations may be
+ * supplied directly or derived from the owning state's entry context. Dynamic
+ * Effect sources infer the owner context, output, error, and service channels
+ * together without a return annotation. Logic invocations require both a
+ * lifecycle `id` and a typed communication `address`. Child descriptors already
+ * own their identity, so `id` and `address` must not be repeated.
  *
  * ```ts
- * import { Effect, Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class Loaded extends Schema.TaggedClass<Loaded>("Loaded")("Loaded", {
- *   value: Schema.String
- * }) {}
- *
- * const load = Machine.invoke({
+ * invoke: Machine.invoke({
  *   id: "load",
- *   src: () => Machine.effect(Effect.succeed(new Loaded({ value: "ready" })))
+ *   effect: Effect.tryPromise({
+ *     try: () => fetch("/api/data").then((response) => response.json()),
+ *     catch: (cause) => new LoadError({ cause })
+ *   }),
+ *   onDone: ({ output, target }) => target.full.Ready({ data: output }),
+ *   onFailure: ({ error, target }) => target.full.Failed({ error })
  * })
  * ```
  *
- * @see {@link effect} for one-shot child effects.
- * @see {@link spawn} for children whose lifetime is controlled by actions.
- * @category constructors
- * @since 0.4.0
- */
-export const invoke = internal.invoke;
-/**
- * Invokes one Effect and maps its typed outcome into machine-local events.
- *
- * **Details**
- *
- * This is the high-level one-shot counterpart to `invoke`. Success and typed
- * failure values are mapped independently, so callers do not need to recover
- * an Effect into a common event union by hand. Defects and interruption remain
- * failures of the owning machine.
- *
- * Declare mapped outcomes in `internalEvents` unless they are also legitimate
- * public commands.
- *
- * **Example**
- *
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class Loaded extends Schema.TaggedClass<Loaded>("Loaded")("Loaded", {
- *   value: Schema.String
- * }) {}
- *
- * const load = Machine.invokeEffect({
- *   id: "load",
- *   effect: Effect.succeed("ready"),
- *   onSuccess: (value) => new Loaded({ value })
- * })
- * ```
- *
- * @see {@link invoke} for arbitrary child process logic.
- * @see {@link after} for a state-scoped delayed event.
- * @category constructors
- * @since 0.4.0
- */
-export const invokeEffect = internal.invokeEffect;
-/**
- * Creates a cancellable state-scoped delayed event.
- *
- * The timer starts when its owning state is entered and is interrupted when
- * that state exits. The delayed value should normally be declared in
- * `internalEvents`.
- *
- * **Example**
- *
- * ```ts
- * import { Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class TimedOut extends Schema.TaggedClass<TimedOut>("TimedOut")("TimedOut", {}) {}
- *
- * const timeout = Machine.after("5 seconds", new TimedOut({}))
- * ```
- *
- * @category constructors
- * @since 0.4.0
- */
-export const after = internal.after;
-/**
- * Constructs another tagged case from compatible source fields.
- *
- * The target must be one tagged struct or tagged class whose discriminator is
- * supplied by its constructor. Union wrappers are rejected because their
- * `make` operation cannot select a member after the source discriminator has
- * been discarded. Missing or incompatible required target fields must be
- * supplied by the patch, and the target schema's normal `make` validation
- * remains authoritative at runtime.
- *
  * @category constructors
- * @since 0.4.0
+ * @since 0.9.0
  */
-export const retag = internal.retag;
-/**
- * Creates an invoked child process from a complete statechart machine.
- *
- * **When to use**
- *
- * Use when a state should own another statechart machine and communicate with
- * it through typed child events, emissions, snapshots, or terminal output.
- *
- * **Details**
- *
- * Child emissions are delivered directly to the parent as events. Active
- * snapshots and terminal output can be mapped to parent events. The owning
- * state controls the child lifetime.
- *
- * **Gotchas**
- *
- * Active invoked machines must have unique child addresses. A machine starts
- * after its owning state's entry actions, so those actions cannot send events
- * to a newly entered child. Unrecovered child failures fail the parent.
- *
- * @see {@link invoke} for invoking lower-level process logic.
- * @see {@link sendTo} for sending events to the invoked machine.
- * @category constructors
- * @since 0.4.0
- */
-export const invokeMachine = internal.invokeMachine;
+export const invoke = ((config) => config);
 /**
  * Plans the initial state for a machine without executing actor commands.
  *
@@ -505,7 +413,7 @@ export const invokeMachine = internal.invokeMachine;
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -553,10 +461,9 @@ export const transitionDefinitions = internal.transitionDefinitions;
  *
  * **Details**
  *
- * Static `invoke`, `invokeEffect`, `after`, and `invokeMachine` descriptors
- * expose stable ownership and lifecycle metadata without serializing runtime
- * values. Function-valued invoke factories are represented as dynamic and are
- * never evaluated during inspection.
+ * Static inline invocation definitions expose stable ownership and lifecycle
+ * metadata without serializing runtime values. Function-valued sources are
+ * represented as dynamic and are never evaluated during inspection.
  *
  * @category getters
  * @since 0.4.0
@@ -611,7 +518,7 @@ export const enabled = internal.enabled;
  * const States = Machine.defineStates({ Off, On })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [Toggle],
+ *   events: Machine.events(Toggle),
  *   initial: () => States.initial.Off.from()
  * }).handle({ Off: { on: { Toggle: () => States.initial.On.from() } }, On: {} })
  *
@@ -627,49 +534,6 @@ export const enabled = internal.enabled;
  * @since 0.4.0
  */
 export const plan = internal.plan;
-/**
- * Creates a one-shot child process from an Effect.
- *
- * **When to use**
- *
- * Use when you need side effects that produce one typed output or error.
- *
- * **Details**
- *
- * The Effect may run arbitrary side effects. Its success value is the process
- * output, its typed error is preserved, and its services are inferred. When
- * invoked, the output is sent to the owning machine as an event unless it is
- * `void`.
- *
- * **Gotchas**
- *
- * This process has no incoming event protocol. Its Effect runs once. Use
- * `transition` for a process that receives events over time and `logic` for
- * direct machine-local communication or intermediate snapshots.
- *
- * **Example** (Recover a child failure as output)
- *
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class LoadFailed extends Schema.TaggedClass<LoadFailed>("LoadFailed")("LoadFailed", {
- *   reason: Schema.String
- * }) {}
- *
- * const load = Machine.effect(
- *   Effect.fail("unavailable").pipe(
- *     Effect.catch((reason) => Effect.succeed(new LoadFailed({ reason })))
- *   )
- * )
- * ```
- *
- * @see {@link transition} for event-driven state.
- * @see {@link logic} for direct control over intermediate snapshots.
- * @category constructors
- * @since 0.4.0
- */
-export const effect = internal.effect;
 /**
  * Creates advanced stateful process logic from explicit initialization and
  * execution methods.
@@ -691,9 +555,9 @@ export const effect = internal.effect;
  * This is the low-level process constructor. Parent messages sent directly
  * through its scope are intentionally `unknown` because the logic does not know
  * which machine will eventually own it. Prefer typed output, typed child
- * addresses, or invoke snapshot mapping when possible.
+ * addresses, or invocation lifecycle transitions when possible.
  *
- * @see {@link effect} for one-shot work.
+ * Use an inline `invoke` with an `effect` source for one-shot work.
  * @see {@link transition} for event-driven state.
  * @category constructors
  * @since 0.4.0
@@ -724,7 +588,7 @@ export const logic = internal.logic;
  * )
  * ```
  *
- * @see {@link effect} for one-shot work.
+ * Use an inline `invoke` with an `effect` source for one-shot work.
  * @see {@link logic} for direct process lifecycle control.
  * @category constructors
  * @since 0.4.0
@@ -823,7 +687,7 @@ export const watch = internal.watch;
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -849,8 +713,8 @@ export const start = internal.start;
  * entry or transition actions, re-deliver raised or emitted events, or
  * re-evaluate historical completion and eventless transitions. Active-state
  * invokes start once in ancestor and document order with {@link InitialEvent};
- * delayed invokes restart their complete duration and invoked machines start
- * from their own initial state.
+ * timer invocations restart their complete duration and child-machine
+ * invocations start from their own initial state.
  *
  * Only logical state, completion, and history metadata are resumed. Queues,
  * scopes, subscriptions, fibers, spawned children, invoke progress, and prior
@@ -873,7 +737,7 @@ export const start = internal.start;
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *

package/dist/Machine.js.map

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

package/dist/internal/machine/activities.d.ts

@@ -4,8 +4,6 @@
  * @since 0.4.0
  */
 /** @internal */
-export declare const ActivityMetadataTypeId: unique symbol;
-/** @internal */
 export type StaticActivityMetadata = {
     readonly type: "process";
 } | {
@@ -16,8 +14,7 @@ export type StaticActivityMetadata = {
     };
 } | {
     readonly type: "timer";
-    readonly duration: string;
-    readonly event: string;
+    readonly duration: string | "dynamic";
 } | {
     readonly type: "machine";
     readonly child: {
@@ -26,13 +23,10 @@ export type StaticActivityMetadata = {
     };
 };
 /** @internal */
-export type ActivityDefinition<Source extends string = string> = ({
+export type ActivityDefinition<Source extends string = string> = {
     readonly source: Source;
     readonly id: string;
-} & StaticActivityMetadata) | {
-    readonly source: Source;
-    readonly type: "dynamic";
-};
+} & StaticActivityMetadata;
 interface InspectableMachine {
     readonly handlers: unknown;
     readonly stateNodes: {
@@ -46,9 +40,8 @@ interface InspectableMachine {
 /**
  * Collects state-owned activity descriptions without executing user code.
  *
- * Function-valued invoke definitions depend on an entry context and are
- * therefore represented as dynamic. Static descriptors are returned in state
- * definition order and descriptor array order.
+ * Source factories are inspected without execution. Static descriptors are
+ * returned in state definition order and descriptor array order.
  *
  * @internal
  */

package/dist/internal/machine/activities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"activities.d.ts","sourceRoot":"","sources":["../../../src/internal/machine/activities.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,gBAAgB;AAChB,eAAO,MAAM,sBAAsB,EAAE,OAAO,MAAsD,CAAA;AAElG,gBAAgB;AAChB,MAAM,MAAM,sBAAsB,GAC9B;IACA,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CACzB,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAA;QAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAA;KACrC,CAAA;CACF,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE;QACd,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;QACnB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;KAClC,CAAA;CACF,CAAA;AAEH,gBAAgB;AAChB,MAAM,MAAM,kBAAkB,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,IACzD,CAAC;IACD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CACpB,GAAG,sBAAsB,CAAC,GACzB;IACA,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CACzB,CAAA;AAOH,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,UAAU,EAAE;QACnB,QAAQ,CAAC,MAAM,EAAE;YACf,MAAM,IAAI,QAAQ,CAAC;gBAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;aAAE,CAAC,CAAA;SAC9C,CAAA;KACF,CAAA;CACF;AA0BD;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,kBAAkB,KAAG,aAAa,CAAC,kBAAkB,CAejG,CAAA"}
+{"version":3,"file":"activities.d.ts","sourceRoot":"","sources":["../../../src/internal/machine/activities.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,gBAAgB;AAChB,MAAM,MAAM,sBAAsB,GAC9B;IACA,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CACzB,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAA;QAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAA;KACrC,CAAA;CACF,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;CACtC,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE;QACd,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;QACnB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;KAClC,CAAA;CACF,CAAA;AAEH,gBAAgB;AAChB,MAAM,MAAM,kBAAkB,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,IAAI;IAC/D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CACpB,GAAG,sBAAsB,CAAA;AAE1B,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,UAAU,EAAE;QACnB,QAAQ,CAAC,MAAM,EAAE;YACf,MAAM,IAAI,QAAQ,CAAC;gBAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;aAAE,CAAC,CAAA;SAC9C,CAAA;KACF,CAAA;CACF;AAwDD;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,kBAAkB,KAAG,aAAa,CAAC,kBAAkB,CAajG,CAAA"}

package/dist/internal/machine/activities.js

@@ -3,28 +3,61 @@
  *
  * @since 0.4.0
  */
-/** @internal */
-export const ActivityMetadataTypeId = Symbol.for("effect/Machine/ActivityMetadata");
+import * as Duration from "effect/Duration";
 const isObject = (value) => (typeof value === "object" && value !== null) || typeof value === "function";
 const getProperty = (value, key) => isObject(value) ? Reflect.get(value, key) : undefined;
-const hasActivityMetadata = (value) => isObject(value) && typeof getProperty(value, "id") === "string" &&
-    isObject(getProperty(value, ActivityMetadataTypeId));
 const appendStaticDefinition = (definitions, source, descriptor) => {
-    if (!hasActivityMetadata(descriptor)) {
+    if (!isObject(descriptor))
+        return;
+    const child = getProperty(descriptor, "child");
+    if (isObject(child)) {
+        const id = getProperty(child, "id");
+        if (typeof id !== "string")
+            return;
+        const machine = getProperty(child, "machine");
+        const machineId = getProperty(machine, "id");
+        definitions.push({
+            source,
+            id,
+            type: "machine",
+            child: { id, machineId: typeof machineId === "string" ? machineId : null }
+        });
+        return;
+    }
+    const id = getProperty(descriptor, "id");
+    if (typeof id !== "string")
+        return;
+    if (Reflect.has(descriptor, "effect")) {
+        definitions.push({
+            source,
+            id,
+            type: "effect",
+            outcomes: {
+                success: "dynamic",
+                failure: Reflect.has(descriptor, "onFailure") ? "dynamic" : "none"
+            }
+        });
         return;
     }
-    definitions.push({
-        source,
-        id: descriptor.id,
-        ...descriptor[ActivityMetadataTypeId]
-    });
+    if (Reflect.has(descriptor, "after")) {
+        const after = getProperty(descriptor, "after");
+        definitions.push({
+            source,
+            id,
+            type: "timer",
+            duration: typeof after === "function" ? "dynamic" : Duration.format(Duration.fromInputUnsafe(after))
+        });
+        return;
+    }
+    if (Reflect.has(descriptor, "logic")) {
+        definitions.push({ source, id, type: "process" });
+    }
 };
 /**
  * Collects state-owned activity descriptions without executing user code.
  *
- * Function-valued invoke definitions depend on an entry context and are
- * therefore represented as dynamic. Static descriptors are returned in state
- * definition order and descriptor array order.
+ * Source factories are inspected without execution. Static descriptors are
+ * returned in state definition order and descriptor array order.
  *
  * @internal
  */
@@ -32,10 +65,7 @@ export const activityDefinitions = (machine) => {
     const definitions = [];
     for (const node of machine.stateNodes.byPath.values()) {
         const invoke = getProperty(getProperty(machine.handlers, node.path), "invoke");
-        if (typeof invoke === "function") {
-            definitions.push({ source: node.path, type: "dynamic" });
-        }
-        else if (Array.isArray(invoke)) {
+        if (Array.isArray(invoke)) {
             for (const descriptor of invoke) {
                 appendStaticDefinition(definitions, node.path, descriptor);
             }

package/dist/internal/machine/activities.js.map

@@ -1 +1 @@
-{"version":3,"file":"activities.js","sourceRoot":"","sources":["../../../src/internal/machine/activities.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,gBAAgB;AAChB,MAAM,CAAC,MAAM,sBAAsB,GAAkB,MAAM,CAAC,GAAG,CAAC,iCAAiC,CAAC,CAAA;AAoDlG,MAAM,QAAQ,GAAG,CAAC,KAAc,EAAmB,EAAE,CACnD,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC,IAAI,OAAO,KAAK,KAAK,UAAU,CAAA;AAE9E,MAAM,WAAW,GAAG,CAAC,KAAc,EAAE,GAAgB,EAAW,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;AAExH,MAAM,mBAAmB,GAAG,CAAC,KAAc,EAA+B,EAAE,CAC1E,QAAQ,CAAC,KAAK,CAAC,IAAI,OAAO,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,QAAQ;IAC/D,QAAQ,CAAC,WAAW,CAAC,KAAK,EAAE,sBAAsB,CAAC,CAAC,CAAA;AAEtD,MAAM,sBAAsB,GAAG,CAC7B,WAAsC,EACtC,MAAc,EACd,UAAmB,EACb,EAAE;IACR,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,EAAE,CAAC;QACrC,OAAM;IACR,CAAC;IACD,WAAW,CAAC,IAAI,CAAC;QACf,MAAM;QACN,EAAE,EAAE,UAAU,CAAC,EAAE;QACjB,GAAG,UAAU,CAAC,sBAAsB,CAAC;KACtC,CAAC,CAAA;AACJ,CAAC,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,OAA2B,EAAqC,EAAE;IACpG,MAAM,WAAW,GAA8B,EAAE,CAAA;IACjD,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;QACtD,MAAM,MAAM,GAAG,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAA;QAC9E,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;YACjC,WAAW,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAA;QAC1D,CAAC;aAAM,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YACjC,KAAK,MAAM,UAAU,IAAI,MAAM,EAAE,CAAC;gBAChC,sBAAsB,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;YAC5D,CAAC;QACH,CAAC;aAAM,CAAC;YACN,sBAAsB,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QACxD,CAAC;IACH,CAAC;IACD,OAAO,WAAW,CAAA;AACpB,CAAC,CAAA"}
+{"version":3,"file":"activities.js","sourceRoot":"","sources":["../../../src/internal/machine/activities.ts"],"names":[],"mappings":"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"}