foldkit 0.157.0 → 0.158.0

package/dist/experimental/machine/machine.js

@@ -1,5 +1,36 @@
-import { Array, Match, Option, Predicate, Record, pipe } from 'effect';
-const makeEdge = (target, build, commands) => {
+import { Array, Function, HashMap, HashSet, Match, Option, Predicate, Record, pipe, } from 'effect';
+const ForStatesTypeId = Symbol('foldkit/Machine/ForStates');
+/** Selects source state tags for a shared transition map. The `on` handler's
+ * `state` is narrowed to the union of the selected variants, and its `message`
+ * is narrowed by the map key.
+ *
+ * Add the resulting fragment to a Machine definition's `shared` array. Shared
+ * transitions are defaults: a state-local transition for the same Message
+ * replaces the shared transition. Defining the same state/Message pair in two
+ * shared fragments throws when the Machine is defined.
+ *
+ * @example
+ * ```ts
+ * shared: [
+ *   forStates(['Editing', 'Reviewing']).on({
+ *     ClickedCancel: to('Cancelled', ({ state }) => ({
+ *       model: CheckoutState.Cancelled({ draftId: state.draftId }),
+ *     })),
+ *   }),
+ * ]
+ * ```
+ *
+ * @experimental Ships from `foldkit/experimental/machine`; expect breaking changes while the API settles.
+ */
+export const forStates = sourceTags => ({
+    on: transitions => ({
+        _tag: 'ForStates',
+        [ForStatesTypeId]: ForStatesTypeId,
+        sourceTags,
+        on: transitions,
+    }),
+});
+const makeEdge = (target, handler) => {
     const narrowGuardValue = (input) => {
         /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
         return input;
@@ -7,58 +38,64 @@ const makeEdge = (target, build, commands) => {
     return {
         _tag: 'Edge',
         target,
-        build: input => build(narrowGuardValue(input)),
-        maybeCommands: commands === undefined
-            ? Option.none()
-            : Option.some(input => commands(narrowGuardValue(input))),
+        handler: input => handler(narrowGuardValue(input)),
     };
 };
 /**
  * Declares a transition Edge to the state variant named by `target`. The
- * `build` callback receives an {@link EdgeInput} whose state and Message are
- * narrowed to the variants the Edge sits under in the transition table, and
- * must return the target variant. Optional `commands` attach transition-time
- * effects.
+ * `handler` receives an {@link EdgeInput} whose state and Message are narrowed
+ * to the variants the Edge sits under in a state-local or shared transition
+ * map, and returns an `Update.Return` record whose `model` is the target
+ * variant and whose optional `commands` are transition-time effects. When the
+ * Machine declares a context, the input also contains that context for the
+ * current transition.
  *
- * The `commands` callback may return Commands whose Effects need services. The
- * requirements they carry flow into the Machine's `R` through {@link define}.
+ * The handler's `commands` field may contain Commands whose Effects need
+ * services. The requirements they carry flow into the Machine's `R` through
+ * {@link define}.
  *
- * Only meaningful inside a {@link TransitionTable}: the source and trigger
- * types flow in from the table position contextually.
+ * Only meaningful inside a Machine definition's state-local or shared
+ * transition map: the source and trigger types flow in from that position
+ * contextually.
  *
  * @experimental Ships from `foldkit/experimental/machine`; expect breaking changes while the API settles.
  */
-export const to = (target, build, commands) => makeEdge(target, build, commands);
+export const to = (target, handler) => makeEdge(target, handler);
 /**
  * Guards an Edge. Guard lists run in order, and the first guard that passes
  * fires its Edge. A guard either resolves the state and Message to an
  * `Option` (returning `Option.some` passes, and the wrapped value flows into
- * the Edge's build and commands callbacks as `guardValue`) or returns a
+ * the Edge's handler as `guardValue`) or returns a
  * plain boolean when there is nothing to extract (returning `true` passes,
  * and `guardValue` is `void`).
  *
- * The state and Message parameters are `NoInfer` so they resolve from the
- * guard list's table position alone.
+ * When the Machine declares a context, the guard receives it as a third
+ * parameter and its Edge handler receives it in {@link EdgeInput}. The state,
+ * Message, and context parameters are `NoInfer` so they resolve from the guard
+ * list's transition-map position alone.
  *
  * @experimental Ships from `foldkit/experimental/machine`; expect breaking changes while the API settles.
  */
-export const when = (guard, target, build, commands) => ({
-    _tag: 'When',
-    guard: (state, message) => {
-        const result = guard(state, message);
+export const when = (guard, target, handler) => {
+    const normalizeGuard = (state, message, ...context) => {
+        const result = guard(state, message, ...context);
         if (Predicate.isBoolean(result)) {
             return result ? Option.some(undefined) : Option.none();
         }
         else {
             return result;
         }
-    },
-    edge: makeEdge(target, build, commands),
-});
+    };
+    return {
+        _tag: 'When',
+        guard: normalizeGuard,
+        edge: makeEdge(target, handler),
+    };
+};
 /**
- * The unconditional fallback at the end of a guard list. Its edge may carry
- * Commands whose Effects need services, threading their requirements into the
- * Machine's `R` the same way {@link to} and {@link when} do.
+ * The unconditional fallback at the end of a guard list. Its Edge handler may
+ * return Commands whose Effects need services, threading their requirements
+ * into the Machine's `R` the same way {@link to} and {@link when} do.
  *
  * @experimental Ships from `foldkit/experimental/machine`; expect breaking changes while the API settles.
  */
@@ -66,209 +103,322 @@ export const otherwise = (edge) => ({
     _tag: 'Otherwise',
     edge,
 });
-const isGuardList = (edgeOrGuardedEdges) => globalThis.Array.isArray(edgeOrGuardedEdges);
-const extractLiteralTag = (tagField) => {
-    if (Predicate.hasProperty(tagField, 'literal') &&
-        Predicate.isString(tagField.literal)) {
-        return Option.some(tagField.literal);
-    }
-    else if (Predicate.hasProperty(tagField, 'schema')) {
-        return extractLiteralTag(tagField.schema);
+/**
+ * Declares that a Message is intentionally ignored when every preceding
+ * {@link when} guard declines. Evaluation stops at this fallback, and
+ * {@link Machine.step} reports `ExplicitlyIgnored`. Edges listed after it are
+ * reported by {@link Machine.deadTransitions} as `ShadowedByIgnore`.
+ *
+ * @experimental Ships from `foldkit/experimental/machine`; expect breaking changes while the API settles.
+ */
+export const ignore = () => ({ _tag: 'Ignore' });
+const transitionFoldedMachine = (config, model, state, message) => {
+    const readContext = config.context;
+    if (readContext !== undefined) {
+        return config.machine.transition(state, message, readContext(model));
     }
     else {
-        return Option.none();
+        return config.machine.transition(state, message);
     }
 };
-const extractMemberTag = (member) => pipe(Option.some(member), Option.filter(Predicate.hasProperty('fields')), Option.map(struct => struct.fields), Option.filter(Predicate.hasProperty('_tag')), Option.flatMap(fields => extractLiteralTag(fields._tag)));
-/**
- * Compiles a declarative transition table into a {@link Machine}.
+/** Folds a Machine state field into an enclosing Model. Any transition-time
+ * Commands pass through unchanged.
  *
- * Two stages: the first takes the state and Message union Schemas and fixes
- * the type parameters, the second takes the initial state and the transition
- * table. The split is what lets TypeScript narrow `state` and `message`
- * inside every Edge from its table position: a single-call form checks the
- * table while the type parameters are still being inferred, and the
- * narrowing collapses.
+ * When `read` returns `None`, the fold returns the original Model without
+ * running a transition. For a contextual Machine, `context` is read only when
+ * the Machine state is present and is supplied to that transition.
  *
- * The Machine is not a runtime: `transition` has the same shape as a Foldkit
- * `update` branch and returns `[nextState, commands]`, so the machine state
- * lives in the Model and the Foldkit runtime never learns the Machine
- * exists. Messages that match no Edge leave the state unchanged; use `step`
- * when the `Ignored` outcome should be observable.
- *
- * Because every Edge names a literal target tag, the Edge set is plain data:
- * `reachableFrom`, `unreachableStates`, `deadTransitions`, and `toMermaid`
- * all read it directly.
- *
- * The Machine's requirements `R` are the services its edge Commands need, and
- * flow into `transition` and `step`. `R` defaults to `never`. When every edge
- * Command shares one service, `R` is inferred from the table. When edges need
- * distinct services `R` cannot be inferred to their union, so supply it on the
- * second call: `define(schemas)<UploadsClient | SaveClient>({ ... })`.
- *
- * @example An edge Command that needs a service
  * ```ts
- * const machine = define({ state: DialogState, message: DialogMessage })({
- *   initial: Idle(),
- *   states: {
- *     Idle: {
- *       on: {
- *         ClickedSubmit: to('Uploading', () => Uploading(), () => [Presign()]),
- *       },
- *     },
- *   },
+ * const foldUpload = Machine.fold({
+ *   machine: uploadMachine,
+ *   read: (model: Model) => Option.some(model.upload),
+ *   write: (model, nextUpload) =>
+ *     evo(model, { upload: () => nextUpload }),
+ *   context: model => model.uploadQueues,
  * })
- * // Commands on the return from machine.transition(...) require UploadsClient.
+ *
+ * // Data-first in update
+ * foldUpload(model, message)
+ *
+ * // Data-last in a composed update
+ * Update.combine(model, [foldUpload(message), recordUploadAttempt])
  * ```
  *
  * @experimental Ships from `foldkit/experimental/machine`; expect breaking changes while the API settles.
  */
-export const define = (schemas) => (definition) => {
-    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
-    const looseStates = definition.states;
-    const initialTag = definition.initial._tag;
-    const stateTags = pipe(schemas.state.members, Array.map(member => Option.getOrThrowWith(extractMemberTag(member), () => new Error('Machine.define: every member of the state union Schema must be a Struct with a literal _tag field'))), 
+export const fold = (config) => Function.dual(2, (model, message) => {
+    const maybeState = config.read(model);
+    if (Option.isNone(maybeState)) {
+        return { model };
+    }
+    const transition = transitionFoldedMachine(config, model, maybeState.value, message);
+    const nextModel = config.write(model, transition.model);
+    if (transition.commands === undefined) {
+        return { model: nextModel };
+    }
+    else {
+        return { model: nextModel, commands: transition.commands };
+    }
+});
+const emptyLooseRecord = () => {
     /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
-    tags => tags);
-    const makeEdgeSummary = (from, messageTag, target, guard) => ({ from, messageTag, target, guard });
-    const summarizeEntry = (from, messageTag, edgeOrGuardedEdges) => isGuardList(edgeOrGuardedEdges)
-        ? Array.map(edgeOrGuardedEdges, (guardedEdge, position) => guardedEdge._tag === 'When'
-            ? makeEdgeSummary(from, messageTag, guardedEdge.edge.target, {
-                _tag: 'When',
-                position,
-            })
-            : makeEdgeSummary(from, messageTag, guardedEdge.edge.target, {
-                _tag: 'Otherwise',
-                position,
-            }))
-        : [
-            makeEdgeSummary(from, messageTag, edgeOrGuardedEdges.target, {
-                _tag: 'Unguarded',
-            }),
-        ];
-    const edges = pipe(Record.toEntries(looseStates), Array.flatMap(([sourceTag, stateEntry]) => pipe(Record.toEntries(stateEntry.on), Array.flatMap(([messageTag, edgeOrGuardedEdges]) => summarizeEntry(sourceTag, messageTag, edgeOrGuardedEdges)))));
-    const selectFromGuardList = (guardedEdges, state, message) => Array.matchLeft(guardedEdges, {
-        onEmpty: () => Option.none(),
-        onNonEmpty: (guardedEdge, rest) => {
-            if (guardedEdge._tag === 'When') {
-                const maybeGuardValue = guardedEdge.guard(state, message);
-                if (Option.isSome(maybeGuardValue)) {
-                    return Option.some({
-                        edge: guardedEdge.edge,
-                        guardValue: maybeGuardValue.value,
-                    });
-                }
-                else {
-                    return selectFromGuardList(rest, state, message);
-                }
+    return {};
+};
+const addSharedTransition = (explicitStates, expanded, sourceTag, messageTag, transition) => {
+    const sharedMessageTags = pipe(HashMap.get(expanded.messageTagsByState, sourceTag), Option.getOrElse(() => HashSet.empty()));
+    if (HashSet.has(sharedMessageTags, messageTag)) {
+        throw new Error(`Machine.define: shared transitions overlap for state "${sourceTag}" and Message "${messageTag}"`);
+    }
+    const nextMessageTagsByState = pipe(expanded.messageTagsByState, HashMap.set(sourceTag, HashSet.add(sharedMessageTags, messageTag)));
+    const isStateLocal = pipe(Record.get(explicitStates, sourceTag), Option.exists(stateEntry => Record.has(stateEntry.on, messageTag)));
+    if (isStateLocal) {
+        return {
+            states: expanded.states,
+            messageTagsByState: nextMessageTagsByState,
+        };
+    }
+    const stateEntry = pipe(Record.get(expanded.states, sourceTag), Option.getOrElse(() => ({
+        on: emptyLooseRecord(),
+    })));
+    return {
+        states: pipe(expanded.states, Record.set(sourceTag, {
+            on: Record.set(stateEntry.on, messageTag, transition),
+        })),
+        messageTagsByState: nextMessageTagsByState,
+    };
+};
+const expandSharedTransitions = (explicitStates, shared) => pipe(shared, Array.reduce({
+    states: explicitStates,
+    messageTagsByState: HashMap.empty(),
+}, (expanded, fragment) => pipe(Array.dedupe(fragment.sourceTags), Array.reduce(expanded, (nextExpanded, sourceTag) => pipe(Record.toEntries(fragment.on), Array.reduce(nextExpanded, (nextStateExpanded, [messageTag, transition]) => addSharedTransition(explicitStates, nextStateExpanded, sourceTag, messageTag, transition)))))), result => result.states);
+const isGuardList = (edgeOrGuardedEdges) => Array.isArray(edgeOrGuardedEdges);
+const extractLiteralTag = (tagField) => {
+    if (Predicate.hasProperty(tagField, 'literal') &&
+        Predicate.isString(tagField.literal)) {
+        return Option.some(tagField.literal);
+    }
+    else if (Predicate.hasProperty(tagField, 'schema')) {
+        return extractLiteralTag(tagField.schema);
+    }
+    else {
+        return Option.none();
+    }
+};
+const extractMemberTag = (member) => pipe(Option.some(member), Option.filter(Predicate.hasProperty('fields')), Option.map(struct => struct.fields), Option.filter(Predicate.hasProperty('_tag')), Option.flatMap(fields => extractLiteralTag(fields._tag)));
+const flattenUnionMembers = (members) => Array.flatMap(members, member => {
+    if (Predicate.hasProperty(member, 'members') &&
+        Array.isArray(member.members)) {
+        return flattenUnionMembers(member.members);
+    }
+    else {
+        return [member];
+    }
+});
+export function define(schemas) {
+    return defineImplementation(schemas);
+}
+function defineImplementation(schemas) {
+    return (definition) => {
+        /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
+        const explicitStates = definition.states;
+        /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
+        const shared = (definition.shared ?? []);
+        const looseStates = expandSharedTransitions(explicitStates, shared);
+        const hasContext = Predicate.hasProperty(schemas, 'context');
+        const initialTag = definition.initial._tag;
+        const stateTags = pipe(schemas.state.members, flattenUnionMembers, Array.map(member => Option.getOrThrowWith(extractMemberTag(member), () => new Error('Machine.define: every member of the state union Schema must be a Struct with a literal _tag field'))), 
+        /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
+        tags => tags);
+        const makeEdgeSummary = (from, messageTag, target, guard) => ({ from, messageTag, target, guard });
+        const summarizeEntry = (from, messageTag, edgeOrGuardedEdges) => isGuardList(edgeOrGuardedEdges)
+            ? Array.flatMap(edgeOrGuardedEdges, (guardedEdge, position) => Match.value(guardedEdge).pipe(Match.withReturnType(), Match.tagsExhaustive({
+                When: guardedWhen => [
+                    makeEdgeSummary(from, messageTag, guardedWhen.edge.target, {
+                        _tag: 'When',
+                        position,
+                    }),
+                ],
+                Otherwise: guardedOtherwise => [
+                    makeEdgeSummary(from, messageTag, guardedOtherwise.edge.target, {
+                        _tag: 'Otherwise',
+                        position,
+                    }),
+                ],
+                Ignore: () => [],
+            })))
+            : [
+                makeEdgeSummary(from, messageTag, edgeOrGuardedEdges.target, {
+                    _tag: 'Unguarded',
+                }),
+            ];
+        const edges = pipe(Record.toEntries(looseStates), Array.flatMap(([sourceTag, stateEntry]) => pipe(Record.toEntries(stateEntry.on), Array.flatMap(([messageTag, edgeOrGuardedEdges]) => summarizeEntry(sourceTag, messageTag, edgeOrGuardedEdges)))));
+        const messageAlphabet = pipe(Record.values(looseStates), Array.flatMap(stateEntry => Record.keys(stateEntry.on)), HashSet.fromIterable);
+        const runGuard = (guardedEdge, state, message, context) => {
+            if (hasContext) {
+                return guardedEdge.guard(state, message, context);
             }
             else {
-                return Option.some({
-                    edge: guardedEdge.edge,
+                return guardedEdge.guard(state, message);
+            }
+        };
+        const selectFromGuardList = (guardedEdges, state, message, context) => Array.matchLeft(guardedEdges, {
+            onEmpty: () => ({
+                _tag: 'IgnoredEdge',
+                reason: 'GuardsFellThrough',
+            }),
+            onNonEmpty: (guardedEdge, rest) => Match.value(guardedEdge).pipe(Match.withReturnType(), Match.tagsExhaustive({
+                When: guardedWhen => {
+                    const maybeGuardValue = runGuard(guardedWhen, state, message, context);
+                    if (Option.isSome(maybeGuardValue)) {
+                        return {
+                            _tag: 'SelectedEdge',
+                            edge: guardedWhen.edge,
+                            guardValue: maybeGuardValue.value,
+                        };
+                    }
+                    else {
+                        return selectFromGuardList(rest, state, message, context);
+                    }
+                },
+                Otherwise: guardedOtherwise => ({
+                    _tag: 'SelectedEdge',
+                    edge: guardedOtherwise.edge,
                     guardValue: undefined,
-                });
+                }),
+                Ignore: () => ({
+                    _tag: 'IgnoredEdge',
+                    reason: 'ExplicitlyIgnored',
+                }),
+            })),
+        });
+        const chooseEdge = (edgeOrGuardedEdges, state, message, context) => isGuardList(edgeOrGuardedEdges)
+            ? selectFromGuardList(edgeOrGuardedEdges, state, message, context)
+            : {
+                _tag: 'SelectedEdge',
+                edge: edgeOrGuardedEdges,
+                guardValue: undefined,
+            };
+        const makeRuntimeEdgeInput = (state, message, guardValue, context) => {
+            if (hasContext) {
+                return { state, message, guardValue, context };
             }
-        },
-    });
-    const chooseEdge = (edgeOrGuardedEdges, state, message) => isGuardList(edgeOrGuardedEdges)
-        ? selectFromGuardList(edgeOrGuardedEdges, state, message)
-        : Option.some({ edge: edgeOrGuardedEdges, guardValue: undefined });
-    const makeTransitioned = (state, message, selectedEdge) => ({
-        _tag: 'Transitioned',
-        from: state._tag,
-        target: selectedEdge.edge.target,
-        messageTag: message._tag,
-        state: selectedEdge.edge.build({
+            else {
+                return { state, message, guardValue };
+            }
+        };
+        const makeTransitioned = (state, message, selectedEdge, context) => {
+            const edgeInput = makeRuntimeEdgeInput(state, message, selectedEdge.guardValue, context);
+            const edgeUpdate = selectedEdge.edge.handler(edgeInput);
+            return {
+                _tag: 'Transitioned',
+                from: state._tag,
+                target: selectedEdge.edge.target,
+                messageTag: message._tag,
+                state: edgeUpdate.model,
+                commands: edgeUpdate.commands ?? [],
+            };
+        };
+        const makeIgnored = (state, message, reason) => ({
+            _tag: 'Ignored',
+            stateTag: state._tag,
+            messageTag: message._tag,
             state,
-            message,
-            guardValue: selectedEdge.guardValue,
-        }),
-        commands: Option.match(selectedEdge.edge.maybeCommands, {
-            onNone: () => [],
-            onSome: buildCommands => buildCommands({
-                state,
-                message,
-                guardValue: selectedEdge.guardValue,
-            }),
-        }),
-    });
-    const makeIgnored = (state, message) => ({
-        _tag: 'Ignored',
-        stateTag: state._tag,
-        messageTag: message._tag,
-        state,
-    });
-    const step = (state, message) => pipe(Record.get(looseStates, state._tag), Option.flatMap(stateEntry => Record.get(stateEntry.on, message._tag)), Option.flatMap(edgeOrGuardedEdges => chooseEdge(edgeOrGuardedEdges, state, message)), Option.match({
-        onNone: () => makeIgnored(state, message),
-        onSome: selectedEdge => makeTransitioned(state, message, selectedEdge),
-    }));
-    const transition = (state, message) => {
-        const result = step(state, message);
-        if (result._tag === 'Transitioned') {
-            return { model: result.state, commands: result.commands };
-        }
-        else {
-            return { model: result.state };
-        }
-    };
-    const targetsFrom = (tag) => pipe(edges, Array.filter(edgeSummary => edgeSummary.from === tag), Array.map(edgeSummary => edgeSummary.target));
-    const reachableFromRoots = (roots) => {
-        const visit = (frontier, visited) => Array.matchLeft(frontier, {
-            onEmpty: () => visited,
-            onNonEmpty: (head, tail) => visited.has(head)
-                ? visit(tail, visited)
-                : visit([...tail, ...targetsFrom(head)], new Set([...visited, head])),
+            reason,
         });
-        return visit(roots, new Set());
-    };
-    const reachableFrom = (tag) => reachableFromRoots([tag]);
-    const unreachableStates = (extraRoots = []) => {
-        const reachable = reachableFromRoots([initialTag, ...extraRoots]);
-        return Array.filter(stateTags, stateTag => !reachable.has(stateTag));
-    };
-    const makeDeadTransition = (edge, reason) => ({ edge, reason });
-    const guardPosition = (edgeSummary) => edgeSummary.guard._tag === 'Unguarded'
-        ? Option.none()
-        : Option.some(edgeSummary.guard.position);
-    const shadowedEdges = () => pipe(edges, Array.groupBy(edgeSummary => `${edgeSummary.from}|${edgeSummary.messageTag}`), Record.values, Array.flatMap(group => {
-        const maybeOtherwisePosition = pipe(group, Array.findFirst(edgeSummary => edgeSummary.guard._tag === 'Otherwise'), Option.flatMap(guardPosition));
-        return Option.match(maybeOtherwisePosition, {
+        const step = (state, message, ...contextArguments) => {
+            const context = pipe(contextArguments, Array.head, Option.getOrUndefined);
+            return pipe(Record.get(looseStates, state._tag), Option.flatMap(stateEntry => Record.get(stateEntry.on, message._tag)), Option.match({
+                onNone: () => makeIgnored(state, message, HashSet.has(messageAlphabet, message._tag)
+                    ? 'NotApplicable'
+                    : 'OutOfAlphabet'),
+                onSome: edgeOrGuardedEdges => {
+                    const selection = chooseEdge(edgeOrGuardedEdges, state, message, context);
+                    return Match.value(selection).pipe(Match.withReturnType(), Match.tagsExhaustive({
+                        SelectedEdge: selectedEdge => makeTransitioned(state, message, selectedEdge, context),
+                        IgnoredEdge: ignoredEdge => makeIgnored(state, message, ignoredEdge.reason),
+                    }));
+                },
+            }));
+        };
+        const transition = (state, message, ...contextArguments) => {
+            const result = step(state, message, ...contextArguments);
+            return Match.value(result).pipe(Match.withReturnType(), Match.tagsExhaustive({
+                Transitioned: transitioned => ({
+                    model: transitioned.state,
+                    commands: transitioned.commands,
+                }),
+                Ignored: ignored => ({ model: ignored.state }),
+            }));
+        };
+        const makeDeadTransition = (edge, reason) => ({ edge, reason });
+        const isPositionedEdgeGuard = (guard) => guard._tag !== 'Unguarded';
+        const isGuardListFallback = (guardedEdge) => guardedEdge._tag !== 'When';
+        const fallbackToShadowingReason = (fallback) => Match.value(fallback).pipe(Match.withReturnType(), Match.tagsExhaustive({
+            Otherwise: () => 'ShadowedByOtherwise',
+            Ignore: () => 'ShadowedByIgnore',
+        }));
+        const maybeGuardPosition = (edgeSummary) => pipe(edgeSummary.guard, Option.liftPredicate(isPositionedEdgeGuard), Option.map(guard => guard.position));
+        const groupEdgesByMessageTag = (edgesFromState) => pipe(edgesFromState, Array.groupBy(edgeSummary => edgeSummary.messageTag), Record.values);
+        const edgesAfterGuardPosition = (edgeGroup, guardPosition) => Array.filter(edgeGroup, edgeSummary => pipe(maybeGuardPosition(edgeSummary), Option.exists(position => position > guardPosition)));
+        const guardListAt = (from, messageTag) => pipe(Record.get(looseStates, from), Option.flatMap(stateEntry => Record.get(stateEntry.on, messageTag)), Option.flatMap(Option.liftPredicate(isGuardList)));
+        const firstGuardListFallback = (guardedEdges) => pipe(guardedEdges, Array.findFirstWithIndex(isGuardListFallback), Option.map(([fallback, position]) => ({
+            position,
+            reason: fallbackToShadowingReason(fallback),
+        })));
+        const firstFallbackInEdgeGroup = (edgeGroup) => pipe(edgeGroup, Array.head, Option.flatMap(edgeSummary => guardListAt(edgeSummary.from, edgeSummary.messageTag)), Option.flatMap(firstGuardListFallback));
+        const shadowedTransitionsInGroup = (edgeGroup) => pipe(firstFallbackInEdgeGroup(edgeGroup), Option.match({
             onNone: () => [],
-            onSome: otherwisePosition => pipe(group, Array.filter(edgeSummary => Option.match(guardPosition(edgeSummary), {
-                onNone: () => false,
-                onSome: position => position > otherwisePosition,
-            })), Array.map(edgeSummary => makeDeadTransition(edgeSummary, 'ShadowedByOtherwise'))),
-        });
-    }));
-    const deadTransitions = (extraRoots = []) => {
-        const reachable = reachableFromRoots([initialTag, ...extraRoots]);
-        const unreachableSourceEdges = pipe(edges, Array.filter(edgeSummary => !reachable.has(edgeSummary.from)), Array.map(edgeSummary => makeDeadTransition(edgeSummary, 'UnreachableSource')));
-        return [...unreachableSourceEdges, ...shadowedEdges()];
-    };
-    const toMermaid = () => {
-        const guardLabel = (guard) => Match.value(guard).pipe(Match.tagsExhaustive({
-            Unguarded: () => '',
-            When: ({ position }) => ` [when ${position + 1}]`,
-            Otherwise: () => ' [otherwise]',
+            onSome: fallback => pipe(edgesAfterGuardPosition(edgeGroup, fallback.position), Array.map(edgeSummary => makeDeadTransition(edgeSummary, fallback.reason))),
         }));
-        const stateLines = Array.map(stateTags, stateTag => `  ${stateTag}`);
-        const transitionLines = Array.map(edges, edgeSummary => `  ${edgeSummary.from} --> ${edgeSummary.target}: ${edgeSummary.messageTag}${guardLabel(edgeSummary.guard)}`);
-        return Array.join([
-            'stateDiagram-v2',
-            ...stateLines,
-            `  [*] --> ${initialTag}`,
-            ...transitionLines,
-        ], '\n');
+        const edgeGroups = pipe(edges, Array.groupBy(edgeSummary => edgeSummary.from), Record.values, Array.flatMap(groupEdgesByMessageTag));
+        const shadowedTransitions = pipe(edgeGroups, Array.flatMap(shadowedTransitionsInGroup));
+        const shadowedEdgeSet = pipe(shadowedTransitions, Array.map(shadowedTransition => shadowedTransition.edge), HashSet.fromIterable);
+        const selectableEdges = Array.filter(edges, edgeSummary => !HashSet.has(shadowedEdgeSet, edgeSummary));
+        const targetsFrom = (tag) => pipe(selectableEdges, Array.filter(edgeSummary => edgeSummary.from === tag), Array.map(edgeSummary => edgeSummary.target));
+        const reachableFromRoots = (roots) => {
+            const visit = (frontier, visited) => Array.matchLeft(frontier, {
+                onEmpty: () => visited,
+                onNonEmpty: (head, tail) => visited.has(head)
+                    ? visit(tail, visited)
+                    : visit([...tail, ...targetsFrom(head)], new Set([...visited, head])),
+            });
+            return visit(roots, new Set());
+        };
+        const reachableFrom = (tag) => reachableFromRoots([tag]);
+        const unreachableStates = (extraRoots = []) => {
+            const reachable = reachableFromRoots([initialTag, ...extraRoots]);
+            return Array.filter(stateTags, stateTag => !reachable.has(stateTag));
+        };
+        const deadTransitions = (extraRoots = []) => {
+            const reachable = reachableFromRoots([initialTag, ...extraRoots]);
+            const unreachableSourceEdges = pipe(selectableEdges, Array.filter(edgeSummary => !reachable.has(edgeSummary.from)), Array.map(edgeSummary => makeDeadTransition(edgeSummary, 'UnreachableSource')));
+            return Array.flatten([unreachableSourceEdges, shadowedTransitions]);
+        };
+        const toMermaid = () => {
+            const guardLabel = (guard) => Match.value(guard).pipe(Match.tagsExhaustive({
+                Unguarded: () => '',
+                When: ({ position }) => ` [when ${position + 1}]`,
+                Otherwise: () => ' [otherwise]',
+            }));
+            const stateLines = Array.map(stateTags, stateTag => `  ${stateTag}`);
+            const transitionLines = Array.map(edges, edgeSummary => `  ${edgeSummary.from} --> ${edgeSummary.target}: ${edgeSummary.messageTag}${guardLabel(edgeSummary.guard)}`);
+            return Array.join([
+                'stateDiagram-v2',
+                ...stateLines,
+                `  [*] --> ${initialTag}`,
+                ...transitionLines,
+            ], '\n');
+        };
+        return {
+            initial: definition.initial,
+            stateTags,
+            edges,
+            transition,
+            step,
+            reachableFrom,
+            unreachableStates,
+            deadTransitions,
+            toMermaid,
+        };
     };
-    return {
-        initial: definition.initial,
-        stateTags,
-        edges,
-        transition,
-        step,
-        reachableFrom,
-        unreachableStates,
-        deadTransitions,
-        toMermaid,
-    };
-};
+}

package/dist/runtime/browserListeners.d.ts

@@ -1,4 +1,10 @@
-import { RoutingConfig } from './runtime.js';
+import { UrlRequest } from '../navigation/urlRequest.js';
+import { Url } from '../url/index.js';
+/** Configuration for URL routing with handlers for URL requests and URL changes. */
+export type RoutingConfig<Message> = Readonly<{
+    onUrlRequest: (request: UrlRequest) => Message;
+    onUrlChange: (url: Url) => Message;
+}>;
 export declare const addNavigationEventListeners: <Message>(dispatch: (message: Message) => void, routingConfig: RoutingConfig<Message>) => (() => void);
 export declare const addLinkClickListener: <Message>(dispatch: (message: Message) => void, routingConfig: RoutingConfig<Message>) => (() => void);
 //# sourceMappingURL=browserListeners.d.ts.map