@modular-vue/journeys 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,996 @@
+import { Component, ComputedRef, InjectionKey, MaybeRefOrGetter, PropType, ShallowRef, VNode } from "vue";
+import { ModuleExitEvent, ModuleExitHandler } from "@modular-vue/vue";
+import { AbandonCtx, AnnotatedTransitionHandler, AnyJourneyDefinition, ChildOutcome, EntryExitWildcardMap, EntryInputOf, EntryNamesOf, EntryTransitions, ExitCtx, ExitNamesOf, ExitNamesPairedWithEntry, ExitOnlyWildcardMap, ExitOutputOf, InstanceId, InstanceId as InstanceId$1, InvokeSpec, JourneyDefinition, JourneyDefinition as JourneyDefinition$1, JourneyDefinitionSummary, JourneyHandle, JourneyHandle as JourneyHandle$1, JourneyHydrationError, JourneyInstance, JourneyInstance as JourneyInstance$1, JourneyNavContribution, JourneyNavContribution as JourneyNavContribution$1, JourneyPersistence, JourneyRegisterOptions, JourneyRegisterOptions as JourneyRegisterOptions$1, JourneyRuntime, JourneyRuntime as JourneyRuntime$1, JourneyRuntimeOptions, JourneyStatus, JourneyStep, JourneyStep as JourneyStep$1, JourneyStepFor, JourneySync, JourneySyncAction, JourneySyncCallbackCtx, JourneySyncOptions, JourneySyncOptions as JourneySyncOptions$1, JourneySyncPort, JourneySyncPort as JourneySyncPort$1, JourneySystemAbortReason, JourneySystemAbortReasonCode, JourneyValidationError, MaybePromise, MemoryPersistence, MemoryPersistenceOptions, ModuleTypeMap, ParentLink, PendingInvoke, RegisteredJourney, ResumeBounceCounter, ResumeHandler, ResumeMap, SelectModuleCases, SelectModuleCasesPartial, SerializedJourney, StepRef, StepSpec, SyncJourneyPersistence, TerminalCtx, TerminalOutcome, TerminalOutcome as TerminalOutcome$1, TerminalSentinel, TransitionEvent, TransitionMap, TransitionResult, UnknownJourneyError, WebStoragePersistenceOptions, WildcardEntryInputOf, WildcardEntryNamesOf, WildcardExitNamesOf, WildcardExitOutputForEntry, WildcardExitOutputOf, WildcardTransitionMap, createJourneyRuntime, createJourneySync, createMemoryJourneySyncPort, createMemoryPersistence, createWebStoragePersistence, defaultStepPath, defineJourney, defineJourneyHandle, defineJourneyPersistence, defineTransition, invoke, isAnnotatedTransition, isTerminalSentinel, journeyStepPath, resolveJourneySyncAction, selectModule, selectModuleOrDefault, validateJourneyContracts, validateJourneyDefinition, validateJourneyGraph } from "@modular-frontend/journeys-engine";
+import { ExitFn, ExitPointMap, ExitPointSchema, JourneyRuntime as JourneyRuntime$2, ModuleDescriptor, ModuleTypeMap as ModuleTypeMap$1, NavigationItemBase, RegistryPlugin, RuntimeMountAdapter, SemverParseError, UiComponent, compareVersions, isJourneySystemAbort, satisfies } from "@modular-frontend/core";
+
+//#region src/provider.d.ts
+/**
+ * Shell-level context read by `<JourneyOutlet>` (PR-31) and the instance
+ * composables so callers don't have to thread `runtime` through every
+ * container that hosts a journey. Analog of the React `JourneyContext` value.
+ *
+ * `onModuleExit` is still surfaced here for consumers that introspect the
+ * provider value. The actual dispatch flows through `<ModuleExitProvider>`
+ * from `@modular-vue/vue`, which `<JourneyProvider>` mounts automatically.
+ * Prefer consuming `useModuleExit` / `useModuleExitDispatcher` from the vue
+ * package directly in new code.
+ */
+interface JourneyProviderValue {
+  /** Journey runtime — usually `manifest.journeys`. */
+  readonly runtime: JourneyRuntime$1;
+  /**
+   * Optional fallback invoked by module hosts (`<ModuleRoute>`, tabs) after
+   * any local `onExit` prop has run. Wiring this at the provider level gives a
+   * shell global telemetry / tab-close forwarding without threading the
+   * callback through every host.
+   */
+  readonly onModuleExit?: (event: ModuleExitEvent) => void;
+}
+/**
+ * Injection key holding the current {@link JourneyProviderValue}, or `null`
+ * when no `<JourneyProvider>` is mounted. Exported so tests and advanced hosts
+ * can provide the context directly.
+ */
+declare const journeyKey: InjectionKey<JourneyProviderValue>;
+/**
+ * Provides the journey runtime to descendant journey hosts, and composes over
+ * `<ModuleExitProvider>` so module hosts (`<ModuleRoute>`, anything using
+ * `useModuleExit`) see the shell's `onModuleExit` dispatcher without needing a
+ * second provider.
+ *
+ * Authored with `defineComponent` + a render function (no SFC compiler in the
+ * package build; see decision D4). The `runtime` is provided by identity at
+ * setup — matching the modules / navigation contexts (PR-10), it is resolved
+ * once from the manifest and does not swap on the same mount, and it is left
+ * un-proxied so identity checks against `manifest.journeys` hold. The
+ * `onModuleExit` handler is forwarded through the live `props` into
+ * `<ModuleExitProvider>` on every render, and the provided context value reads
+ * it through a getter, so a swapped handler reaches both descendant hosts and
+ * consumers that introspect `useJourneyContext().onModuleExit` (parity with the
+ * React provider, which rebuilds its value object each render).
+ *
+ * Existing journey consumers do not need to change — `onModuleExit` keeps
+ * firing for every module exit emitted outside a journey step.
+ */
+declare const JourneyProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  /** Journey runtime — usually `manifest.journeys`. */runtime: {
+    type: PropType<JourneyRuntime$1>;
+    required: true;
+  }; /** Shell-wide fallback dispatcher for module exits fired outside a step. */
+  onModuleExit: {
+    type: PropType<ModuleExitHandler>;
+    default: undefined;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  /** Journey runtime — usually `manifest.journeys`. */runtime: {
+    type: PropType<JourneyRuntime$1>;
+    required: true;
+  }; /** Shell-wide fallback dispatcher for module exits fired outside a step. */
+  onModuleExit: {
+    type: PropType<ModuleExitHandler>;
+    default: undefined;
+  };
+}>> & Readonly<{}>, {
+  onModuleExit: ModuleExitHandler;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/** Read the current provider value, or `null` when none is mounted. */
+declare function useJourneyContext(): JourneyProviderValue | null;
+//#endregion
+//#region src/use-journey-state.d.ts
+/**
+ * Sugar over {@link useJourneyInstance}: returns a `ComputedRef` of the
+ * instance's `state` (or `null` when the runtime / id / instance is
+ * unavailable). `TState` is the journey's state type — pass it at the call
+ * site.
+ *
+ * The React analog returns a plain `TState | null`; the Vue port returns a
+ * `ComputedRef` so it stays reactive in templates and `watch` (the PR-23
+ * convention for reactive-source composables). Read `.value` at the call site.
+ *
+ * Prefer {@link useJourneyInstance} when the host needs more than `state`
+ * (`step` / `status` / `terminalPayload`).
+ */
+declare function useJourneyState<TState>(instanceId: MaybeRefOrGetter<InstanceId$1 | null>): ComputedRef<TState | null>;
+/**
+ * Subscribe to a journey instance and return a `ShallowRef` of its full
+ * snapshot (`status`, `step`, `state`, `terminalPayload`, …), or `null` when
+ * no `<JourneyProvider>` is mounted or the id is unknown. Tearing-free via the
+ * `shallowRef` bridge in {@link useInstanceSnapshot}. The primitive of which
+ * {@link useJourneyState} is sugar; symmetric with
+ * {@link useActiveLeafJourneyInstance} for the leaf-walking case.
+ */
+declare function useJourneyInstance(instanceId: MaybeRefOrGetter<InstanceId$1 | null>): ShallowRef<JourneyInstance$1 | null>;
+/**
+ * Sugar over {@link useActiveLeafJourneyInstance}: returns a `ComputedRef` of
+ * the leaf instance's `state` as `TState`. `.value` is `null` when no
+ * provider, the root id is unknown, or the leaf has been forgotten.
+ *
+ * Prefer {@link useActiveLeafJourneyInstance} when the leaf can be any of
+ * several journeys — typing this composable as `<ParentState | ChildState>`
+ * leaves the caller without a discriminator, whereas the instance form gives a
+ * typed `inst.journeyId` to switch on.
+ */
+declare function useActiveLeafJourneyState<TState>(rootInstanceId: MaybeRefOrGetter<InstanceId$1 | null>): ComputedRef<TState | null>;
+/**
+ * Walks `activeChildId` from `rootInstanceId` down to the deepest descendant
+ * and returns a `ShallowRef` of that leaf's full `JourneyInstance`. The
+ * recommended primitive when the host doesn't know the leaf's depth (a parent
+ * that may or may not be in an invoked sub-flow) — pair with `inst.journeyId`
+ * as a discriminator instead of typing the state composable as a union and
+ * asserting manually. Re-subscribes as the chain grows (parent invokes a
+ * child, grandchild starts) or shrinks (child terminates and parent resumes).
+ *
+ * `.value` is `null` under the same conditions as {@link useJourneyInstance}.
+ */
+declare function useActiveLeafJourneyInstance(rootInstanceId: MaybeRefOrGetter<InstanceId$1 | null>): ShallowRef<JourneyInstance$1 | null>;
+//#endregion
+//#region src/instance-hooks.d.ts
+/**
+ * Subscribe to a single instance and return a `ShallowRef` of its current
+ * snapshot, or `null` when runtime / id is missing or the instance has been
+ * forgotten. The Vue analog of the React `useInstanceSnapshot` (which uses
+ * `useSyncExternalStore`): a `watchEffect` seeds the ref, subscribes, and
+ * re-subscribes whenever `instanceId` changes.
+ *
+ * `instanceId` accepts a plain value, a ref, or a getter. Reactive ids are
+ * the point of the leaf-walking composables: `useActiveLeafJourneyInstance`
+ * feeds a `ComputedRef` leaf id here, so the snapshot re-subscribes as the
+ * active chain grows (parent invokes a child) or shrinks (child terminates).
+ * The subscribe callback reads the *current* id so an in-flight notification
+ * that arrives after an id swap still resolves against the live instance.
+ *
+ * The `watchEffect` uses the default (pre) flush: the initial subscription is
+ * established synchronously at setup, runtime events push snapshots into the
+ * `shallowRef` synchronously (matching React's tearing-free reads), and only
+ * re-subscription on an id change is deferred to the next tick — so a
+ * changing-leaf test awaits `nextTick()` before the swap is observed.
+ */
+declare function useInstanceSnapshot(runtime: JourneyRuntime$1 | null, instanceId: MaybeRefOrGetter<InstanceId$1 | null>): ShallowRef<JourneyInstance$1 | null>;
+/**
+ * Walk `activeChildId` from `rootId` down to the deepest descendant, returning
+ * a `ShallowRef` of the full chain. Subscribes to every instance in the chain
+ * and re-subscribes as the chain grows / shrinks. Pass `enabled: false` to
+ * short-circuit the walk (collapses to `[rootId]`) — used by the outlet's
+ * `leafOnly` opt-out (PR-31). Null `runtime` / `rootId` yields an empty chain
+ * so callers can invoke this composable unconditionally even before a runtime
+ * is mounted.
+ *
+ * The dynamic per-instance subscriptions are managed by hand (as in the React
+ * source) rather than through Vue reactivity, since they rewire on runtime
+ * events, not on tracked dependencies. The `watchEffect` only re-runs — tearing
+ * down and rebuilding the whole chain — when `rootId` or `enabled` change.
+ */
+declare function useCallChain(runtime: JourneyRuntime$1 | null, rootId: MaybeRefOrGetter<InstanceId$1 | null>, enabled: MaybeRefOrGetter<boolean>): ShallowRef<readonly InstanceId$1[]>;
+/**
+ * Last id in the active chain — `rootId` when no child is in flight, `null`
+ * when runtime / rootId are missing. Returns a `ComputedRef` that tracks the
+ * chain, so feeding it to {@link useInstanceSnapshot} re-subscribes the
+ * snapshot as the leaf moves.
+ */
+declare function useLeafId(runtime: JourneyRuntime$1 | null, rootId: MaybeRefOrGetter<InstanceId$1 | null>, enabled: MaybeRefOrGetter<boolean>): ComputedRef<InstanceId$1 | null>;
+//#endregion
+//#region src/mount-adapter.d.ts
+/**
+ * Adapt a {@link JourneyRuntime} to the generic
+ * {@link RuntimeMountAdapter} shape so other packages can embed journeys
+ * without depending on this package directly. Today the only consumer is
+ * `@modular-vue/compositions` (zones with `kind: "journey"`):
+ *
+ * ```ts
+ * import { createJourneyMountAdapter } from "@modular-vue/journeys";
+ *
+ * const manifest = registry.resolveManifest();
+ * manifest.extensions.compositions.registerMountAdapter(
+ *   "journey",
+ *   createJourneyMountAdapter(manifest.extensions.journeys),
+ * );
+ * ```
+ *
+ * The wiring happens once after `resolveManifest()` and before mounting the
+ * app, so the composition outlet finds the adapter the first time a zone
+ * returns a `kind: "journey"` resolution. If the wiring is omitted, the
+ * zone renders its `errorComponent` with a clear "no adapter registered"
+ * message instead of throwing (see `CompositionOutlet`).
+ *
+ * The Vue analog of `@modular-react/journeys`'s `createJourneyMountAdapter`.
+ *
+ * Deviation from the React source, and why: React returns the bare
+ * `JourneyOutlet` as `Outlet` and lets it read the journey runtime from the
+ * `<JourneyProvider>` context that the journeys plugin threads app-wide. The
+ * Vue `<CompositionOutlet>` renders `adapter.Outlet` with only
+ * `{ instanceId, loadingFallback }` (no `runtime`), so the Vue adapter binds
+ * the runtime it was handed into a thin wrapper component. This makes the
+ * adapter self-contained — it mounts instances against exactly the runtime
+ * passed to `createJourneyMountAdapter`, whether or not a `<JourneyProvider>`
+ * sits above the composition outlet — rather than depending on an ambient
+ * context that must happen to hold the same runtime.
+ */
+declare function createJourneyMountAdapter(runtime: JourneyRuntime$1): RuntimeMountAdapter;
+//#endregion
+//#region src/outlet.d.ts
+type JourneyStepErrorPolicy = "abort" | "retry" | "ignore";
+interface JourneyOutletNotFoundProps {
+  readonly moduleId: string;
+  readonly entry: string;
+}
+interface JourneyOutletErrorProps {
+  readonly moduleId: string;
+  readonly error: unknown;
+}
+/**
+ * Renders the current step of a journey instance. Host-agnostic — works in a
+ * tab, modal, route element, or plain `<div>`. On unmount while active, the
+ * instance is abandoned (deferred by a microtask so a same-tick handoff to a
+ * sibling outlet — outlet A unmounts, outlet B mounts against the same instance
+ * — does not tear the instance down: the deferred check consults the record's
+ * listener count and skips `end()` when another outlet is still subscribed).
+ *
+ * The Vue analog of the React `<JourneyOutlet>`. Authored with `defineComponent`
+ * + a render function (no SFC compiler in the package build; see decision D4).
+ * The instance snapshots come from the reactive `useInstanceSnapshot` /
+ * `useLeafId` composables (PR-30), so the outlet re-renders as the active call
+ * chain shifts (parent invokes a child, child terminates) and as the leaf's own
+ * step advances. Error-message prefixes are `[@modular-vue/journeys]`.
+ */
+declare const JourneyOutlet: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  /**
+   * Runtime to drive the outlet against. Optional when a `<JourneyProvider>`
+   * is mounted above — the outlet reads the runtime from context in that
+   * case. Explicit prop overrides context, so one outlet can reach a
+   * different runtime when needed.
+   */
+  runtime: {
+    type: PropType<JourneyRuntime$1>;
+    default: undefined;
+  };
+  instanceId: {
+    type: PropType<InstanceId$1>;
+    required: true;
+  };
+  /**
+   * Module descriptors the outlet resolves step components against. Optional —
+   * when omitted, the outlet pulls the descriptors the runtime was constructed
+   * with (the common case).
+   */
+  modules: {
+    type: PropType<Readonly<Record<string, ModuleDescriptor<any, any, any, any>>>>;
+    default: undefined;
+  }; /** Rendered while the instance is in `loading` status. */
+  loadingFallback: {
+    type: PropType<VNode | (() => VNode)>;
+    default: undefined;
+  };
+  onFinished: {
+    type: PropType<(outcome: TerminalOutcome$1) => void>;
+    default: undefined;
+  };
+  onStepError: {
+    type: PropType<(err: unknown, ctx: {
+      step: JourneyStep$1;
+    }) => JourneyStepErrorPolicy>;
+    default: undefined;
+  };
+  /**
+   * When `false`, the outlet renders the instance you handed it directly, even
+   * if it has a child journey in flight. Set this when you compose two outlets
+   * to render parent and child side-by-side. When `true` (the default), the
+   * outlet walks the active call chain down to the leaf and renders the leaf.
+   */
+  leafOnly: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  /**
+   * Cap on `retry` responses before the outlet falls back to `abort`. The
+   * counter increments on every retry and is never reset. Default: 2.
+   */
+  retryLimit: {
+    type: NumberConstructor;
+    default: number;
+  };
+  /**
+   * Rendered when the current step points at a module/entry that is not
+   * registered with the runtime. Defaults to a plain red notice.
+   */
+  notFoundComponent: {
+    type: PropType<Component>;
+    default: undefined;
+  };
+  /**
+   * Rendered when a step component throws. Defaults to a plain red notice with
+   * the error message. Receives the raw error so shells can route it through
+   * their own reporting.
+   */
+  errorComponent: {
+    type: PropType<Component>;
+    default: undefined;
+  };
+  /**
+   * Speculatively prefetch the chunks for entries reachable from the current
+   * step during idle time after mount. `"precise"` (default, alias `true`)
+   * reads declared `targets` from annotated handlers; `"aggressive"` preloads
+   * every entry referenced as a transition source or annotated target;
+   * `false` opts out. No effect for eager entries; SSR is a no-op.
+   */
+  preload: {
+    type: PropType<boolean | "precise" | "aggressive">;
+    default: string;
+  };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  /**
+   * Runtime to drive the outlet against. Optional when a `<JourneyProvider>`
+   * is mounted above — the outlet reads the runtime from context in that
+   * case. Explicit prop overrides context, so one outlet can reach a
+   * different runtime when needed.
+   */
+  runtime: {
+    type: PropType<JourneyRuntime$1>;
+    default: undefined;
+  };
+  instanceId: {
+    type: PropType<InstanceId$1>;
+    required: true;
+  };
+  /**
+   * Module descriptors the outlet resolves step components against. Optional —
+   * when omitted, the outlet pulls the descriptors the runtime was constructed
+   * with (the common case).
+   */
+  modules: {
+    type: PropType<Readonly<Record<string, ModuleDescriptor<any, any, any, any>>>>;
+    default: undefined;
+  }; /** Rendered while the instance is in `loading` status. */
+  loadingFallback: {
+    type: PropType<VNode | (() => VNode)>;
+    default: undefined;
+  };
+  onFinished: {
+    type: PropType<(outcome: TerminalOutcome$1) => void>;
+    default: undefined;
+  };
+  onStepError: {
+    type: PropType<(err: unknown, ctx: {
+      step: JourneyStep$1;
+    }) => JourneyStepErrorPolicy>;
+    default: undefined;
+  };
+  /**
+   * When `false`, the outlet renders the instance you handed it directly, even
+   * if it has a child journey in flight. Set this when you compose two outlets
+   * to render parent and child side-by-side. When `true` (the default), the
+   * outlet walks the active call chain down to the leaf and renders the leaf.
+   */
+  leafOnly: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  /**
+   * Cap on `retry` responses before the outlet falls back to `abort`. The
+   * counter increments on every retry and is never reset. Default: 2.
+   */
+  retryLimit: {
+    type: NumberConstructor;
+    default: number;
+  };
+  /**
+   * Rendered when the current step points at a module/entry that is not
+   * registered with the runtime. Defaults to a plain red notice.
+   */
+  notFoundComponent: {
+    type: PropType<Component>;
+    default: undefined;
+  };
+  /**
+   * Rendered when a step component throws. Defaults to a plain red notice with
+   * the error message. Receives the raw error so shells can route it through
+   * their own reporting.
+   */
+  errorComponent: {
+    type: PropType<Component>;
+    default: undefined;
+  };
+  /**
+   * Speculatively prefetch the chunks for entries reachable from the current
+   * step during idle time after mount. `"precise"` (default, alias `true`)
+   * reads declared `targets` from annotated handlers; `"aggressive"` preloads
+   * every entry referenced as a transition source or annotated target;
+   * `false` opts out. No effect for eager entries; SSR is a no-op.
+   */
+  preload: {
+    type: PropType<boolean | "precise" | "aggressive">;
+    default: string;
+  };
+}>> & Readonly<{}>, {
+  runtime: JourneyRuntime$1;
+  modules: Readonly<Record<string, ModuleDescriptor<any, any, any, any>>>;
+  loadingFallback: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+  }> | (() => VNode);
+  onFinished: (outcome: TerminalOutcome$1) => void;
+  onStepError: (err: unknown, ctx: {
+    step: JourneyStep$1;
+  }) => JourneyStepErrorPolicy;
+  leafOnly: boolean;
+  retryLimit: number;
+  notFoundComponent: Component;
+  errorComponent: Component;
+  preload: boolean | "precise" | "aggressive";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/**
+ * Returns a reactive `ShallowRef` of the call stack for an outlet's instance —
+ * root at index 0, the active leaf at the end, intermediate parents in between.
+ * Useful for shells that render layered presentations (parent underneath, child
+ * in a modal): mount the parent outlet with `leafOnly={false}` and the child
+ * outlet against `chain.value[chain.value.length - 1]`. Returns a ref (not a
+ * plain array) per the PR-30 reactive-source convention.
+ */
+declare function useJourneyCallStack(runtime: JourneyRuntime$1, rootId: InstanceId$1): ShallowRef<readonly InstanceId$1[]>;
+//#endregion
+//#region src/journey-host.d.ts
+interface UseJourneyHostOptions {
+  /**
+   * Runtime to start the journey on. Optional when a `<JourneyProvider>` is
+   * mounted above — the composable reads the runtime from context in that case.
+   */
+  readonly runtime?: JourneyRuntime$1;
+}
+interface JourneyHostState {
+  /**
+   * The instance this host owns. `null` until the component is mounted — the
+   * journey is started from `onMounted`, so it does not exist during the first
+   * render. `<JourneyHost>` renders `loadingFallback` for that frame.
+   */
+  readonly instanceId: ShallowRef<InstanceId$1 | null>;
+  readonly instance: ShallowRef<JourneyInstance$1 | null>;
+  /**
+   * The runtime this host resolved at setup — the one `instanceId` is
+   * meaningful to, and the one the host's own `<JourneyOutlet>` is given.
+   * Already `toRaw`-unwrapped.
+   *
+   * Normally identical to whatever a `<JourneyProvider>` above you would hand
+   * out, so a hand-placed outlet can keep resolving from context. It is
+   * exposed for the case where those two could differ: a shell that swaps its
+   * provider value mid-flight. The host does not follow such a swap (see
+   * "read once, at setup"), so this is the runtime to use if you want to be
+   * certain you are talking about the same journey the host started.
+   */
+  readonly runtime: JourneyRuntime$1;
+  /**
+   * How many steps the user has completed — `history.length`, so `0` on the
+   * first step. Rewinds when the journey does.
+   *
+   * There is deliberately no `stepCount` here. The total is not knowable from
+   * a running instance: a journey's next step is computed by a transition
+   * handler from live state, so nothing short of walking the transition graph
+   * can count the steps ahead — and a hand-passed total is exactly the
+   * duplicated flow encoding this API exists to remove. Deriving it from the
+   * graph is tracked separately.
+   */
+  readonly stepIndex: ComputedRef<number>;
+}
+/**
+ * Own a journey instance for the lifetime of a component: start it on mount,
+ * end and forget it on unmount. The Vue analog of the React
+ * `useJourneyHost`.
+ *
+ * This is the lifecycle half of "mount a journey"; `useJourneySync` is the URL
+ * half, and `<JourneyOutlet>` is the rendering half. {@link JourneyHost}
+ * packages the first and the last together.
+ *
+ * **`handle`, `input` and `runtime` are read once, at setup**, and are
+ * therefore plain values rather than the `MaybeRefOrGetter` the reactive
+ * composables in this package take. Changing them cannot restart the journey:
+ * silently abandoning a half-finished flow because a prop changed is never
+ * what the caller meant. To run a different journey — or to run it on a
+ * different runtime — remount: `<JourneyHost :key="journeyId" …>`. The React
+ * binding pins its runtime the same way.
+ *
+ * **Start means resume, when persistence is configured.** `runtime.start()`
+ * with a `persistence` adapter returns the in-flight instance for the same
+ * `keyFor(input)` rather than minting a new one, so a host that remounts (a
+ * route change, a tab switch) picks the journey back up where it was. Without
+ * persistence every mount starts a fresh instance.
+ */
+declare function useJourneyHost<TInput>(handle: JourneyHandle$1<string, TInput, unknown>, input: TInput, options?: UseJourneyHostOptions): JourneyHostState;
+interface JourneyHostSlotProps {
+  readonly instanceId: InstanceId$1;
+  readonly instance: JourneyInstance$1;
+  /** See {@link JourneyHostState.stepIndex}. */
+  readonly stepIndex: number;
+  /**
+   * The `<JourneyOutlet>` for this instance, already built with every outlet
+   * attribute passed to `<JourneyHost>`. Place it inside your chrome.
+   */
+  readonly outlet: VNode;
+}
+/**
+ * Mount a journey in one line:
+ * `<JourneyHost :handle="checkoutHandle" :input="{ cartId }" />`.
+ *
+ * Starts the journey on mount, renders its current step, and ends + forgets
+ * the instance on unmount — the wrapper every journey host ends up writing.
+ * The Vue analog of the React `<JourneyHost>`.
+ *
+ * **Outlet props pass through as attributes.** `inheritAttrs: false` plus an
+ * attrs spread onto the inner `<JourneyOutlet>` means every outlet prop
+ * (`onFinished`, `onStepError`, `errorComponent`, `preload`, …) works on
+ * `<JourneyHost>` without this component re-declaring — and drifting from —
+ * the outlet's prop list. `loadingFallback` is the one attr the host also
+ * reads itself, to cover the render before the instance exists — which is why
+ * it has to accept both spellings; see {@link readLoadingFallback}.
+ *
+ * For chrome around the step, use the default scoped slot:
+ *
+ * ```vue
+ * <JourneyHost :handle="checkoutHandle" :input="{ cartId }" @finished="goToReceipt">
+ *   <template #default="{ stepIndex, outlet }">
+ *     <Layout title="Checkout" :step="stepIndex">
+ *       <component :is="outlet" />
+ *     </Layout>
+ *   </template>
+ * </JourneyHost>
+ * ```
+ *
+ * To deep-link the steps, call `useJourneySync` in the same component — the
+ * host owns the instance, the sync owns the URL, and neither knows about the
+ * other.
+ *
+ * See {@link useJourneyHost} for the lifecycle rules (the instance is fixed
+ * for the host's lifetime; `start` resumes when persistence is configured).
+ */
+declare const JourneyHost: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  handle: {
+    type: PropType<JourneyHandle$1<string, any, any>>;
+    required: true;
+  };
+  /**
+   * The journey's `input`. Typed `any` because a `defineComponent` prop
+   * list cannot carry the handle's `TInput` through — reach for
+   * {@link useJourneyHost} in a `<script setup>` block when you want the
+   * input checked against the handle.
+   */
+  input: {
+    type: PropType<any>;
+    default: undefined;
+  };
+  /**
+   * Runtime to start the journey on, forwarded to the outlet. Optional when
+   * a `<JourneyProvider>` is mounted above.
+   */
+  runtime: {
+    type: PropType<JourneyRuntime$1>;
+    default: undefined;
+  };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>[] | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  handle: {
+    type: PropType<JourneyHandle$1<string, any, any>>;
+    required: true;
+  };
+  /**
+   * The journey's `input`. Typed `any` because a `defineComponent` prop
+   * list cannot carry the handle's `TInput` through — reach for
+   * {@link useJourneyHost} in a `<script setup>` block when you want the
+   * input checked against the handle.
+   */
+  input: {
+    type: PropType<any>;
+    default: undefined;
+  };
+  /**
+   * Runtime to start the journey on, forwarded to the outlet. Optional when
+   * a `<JourneyProvider>` is mounted above.
+   */
+  runtime: {
+    type: PropType<JourneyRuntime$1>;
+    default: undefined;
+  };
+}>> & Readonly<{}>, {
+  input: any;
+  runtime: JourneyRuntime$1;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/use-journey-sync.d.ts
+interface UseJourneySyncOptions extends JourneySyncOptions$1 {
+  /**
+   * Runtime to sync against. Optional when a `<JourneyProvider>` is mounted
+   * above — the composable reads the runtime from context in that case. Read
+   * once at setup, matching how the other composables in this package resolve
+   * their runtime.
+   */
+  readonly runtime?: JourneyRuntime$1;
+}
+/**
+ * Keep a journey instance and the browser URL in step, in both directions:
+ * the journey advances and the URL follows; the user presses Back or Forward
+ * and the journey follows.
+ *
+ * The reconciler itself is framework- and router-neutral and lives in
+ * `@modular-frontend/journeys-engine`; this composable is the Vue lifetime
+ * wrapper around it, and the exact analog of the React `useJourneySync`. See
+ * `createJourneySync` in the engine for the full semantics (push-vs-replace
+ * rules, what a location can and cannot select, why the design is
+ * event-sourced rather than a diff).
+ *
+ * Supply a {@link JourneySyncPort} for vue-router. It is the only router-aware
+ * code in the picture:
+ *
+ * ```ts
+ * const router = useRouter();
+ * const route = useRoute();
+ * const port: JourneySyncPort = {
+ *   read: () => String(route.params.step ?? ""),
+ *   push: (path) => void router.push({ name: "checkout", params: { step: path } }),
+ *   replace: (path) => void router.replace({ name: "checkout", params: { step: path } }),
+ *   go: (delta) => router.go(delta),
+ *   subscribe: (listener) => router.afterEach(() => listener()),
+ * };
+ *
+ * useJourneySync(instanceId, port, { stepToPath: (step) => step.entry });
+ * ```
+ *
+ * Conventions:
+ *
+ * - **`instanceId` accepts a plain value, a ref, or a getter**, and may be
+ *   `null` — the composable no-ops until an id arrives, so it can be called at
+ *   setup before the instance exists (as it must be under `useJourneyHost`,
+ *   which starts the journey on mount). The sync re-attaches when the id
+ *   changes.
+ * - **`port` and `options` may be plain, refs, or getters.** Both are read
+ *   through a live holder rather than re-creating the reconciler, because
+ *   re-creating it re-runs its initial reconcile — and that reconcile
+ *   navigates. Pass a getter when the port itself depends on reactive state.
+ *   Two things are read once rather than live: `port.subscribe`, called when
+ *   the sync is created (so the subscription belongs to the port current at
+ *   that moment), and `options.stepToPath`, captured then too (the engine
+ *   needs a stable step->path mapping to resolve already-stamped history
+ *   frames). Both are invisible for the normal case — a port over a stable
+ *   router with a fixed mapping — but a port that subscribes to a *different*
+ *   source later, or a mapping that changes, will not take effect until the
+ *   sync is re-created. `onUnresolved`/`onBlocked` remain live. Change
+ *   `instanceId` (or remount) to re-attach.
+ * - **The composable never starts or ends the instance.** It only navigates
+ *   within a journey that is already running. Pair it with
+ *   {@link JourneyHost}, which owns the lifecycle.
+ */
+declare function useJourneySync(instanceId: MaybeRefOrGetter<InstanceId$1 | null>, port: MaybeRefOrGetter<JourneySyncPort$1>, options?: MaybeRefOrGetter<UseJourneySyncOptions>): void;
+//#endregion
+//#region src/module-tab.d.ts
+/**
+ * Exit event fired by a module rendered inside a `<ModuleTab>`.
+ *
+ * Alias for {@link ModuleExitEvent} from `@modular-vue/vue` — kept as a named
+ * export for the workspace-tab entry point so existing imports keep compiling.
+ * Both types have the same shape.
+ */
+type ModuleTabExitEvent = ModuleExitEvent;
+/**
+ * Host for a single module instance rendered outside any route — in a tab,
+ * modal, or panel. Default exit behavior delegates to the `onExit` callback
+ * provided by the shell; the module itself stays journey-unaware. The Vue
+ * analog of the React `<ModuleTab>`.
+ *
+ * Authored with `defineComponent` + a render function (no SFC compiler in the
+ * package build; see decision D4). The exit binding is created once at setup
+ * via `useModuleExit` (Vue composables must run synchronously in `setup`),
+ * reading the current module id / resolved entry through getters so a host that
+ * swaps `module`/`entry` on the same instance still emits the right event.
+ *
+ * `inheritAttrs` is disabled and `input` is read from `attrs` so the component
+ * can tell "no `input` prop" apart from an explicit `input={undefined}` — Vue
+ * collapses both to `undefined` for a *declared* prop (an explicit `undefined`
+ * triggers the prop default), so the presence check has to look at the raw
+ * attrs bag, the analog of the React source's `"input" in props`.
+ */
+declare const ModuleTab: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  /** Full module descriptor — the shell looks this up by id. */module: {
+    type: PropType<ModuleDescriptor<any, any, any, any>>;
+    required: true;
+  };
+  /**
+   * Entry point name on the module. If omitted and the module exposes exactly
+   * one entry, that entry is used automatically. If the module exposes several
+   * entries, the name must be supplied — passing an unknown name renders an
+   * error notice. If `entry` is omitted and the module has no entry points,
+   * the component falls back to the legacy `component` field; passing `entry`
+   * to such a module instead renders the error notice so misconfiguration is
+   * surfaced.
+   */
+  entry: {
+    type: StringConstructor;
+    default: undefined;
+  }; /** Opaque tab id threaded through to `onExit` for the shell to close it. */
+  tabId: {
+    type: StringConstructor;
+    default: undefined;
+  };
+  /**
+   * Called when the module emits an exit. Runs *before* the provider's global
+   * `onExit` dispatcher (via `<ModuleExitProvider>`, typically composed under
+   * `<JourneyProvider>`), so the shell can close the tab first and let the
+   * provider hook forward to analytics / routing.
+   */
+  onExit: {
+    type: PropType<(event: ModuleTabExitEvent) => void>;
+    default: undefined;
+  };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  /** Full module descriptor — the shell looks this up by id. */module: {
+    type: PropType<ModuleDescriptor<any, any, any, any>>;
+    required: true;
+  };
+  /**
+   * Entry point name on the module. If omitted and the module exposes exactly
+   * one entry, that entry is used automatically. If the module exposes several
+   * entries, the name must be supplied — passing an unknown name renders an
+   * error notice. If `entry` is omitted and the module has no entry points,
+   * the component falls back to the legacy `component` field; passing `entry`
+   * to such a module instead renders the error notice so misconfiguration is
+   * surfaced.
+   */
+  entry: {
+    type: StringConstructor;
+    default: undefined;
+  }; /** Opaque tab id threaded through to `onExit` for the shell to close it. */
+  tabId: {
+    type: StringConstructor;
+    default: undefined;
+  };
+  /**
+   * Called when the module emits an exit. Runs *before* the provider's global
+   * `onExit` dispatcher (via `<ModuleExitProvider>`, typically composed under
+   * `<JourneyProvider>`), so the shell can close the tab first and let the
+   * provider hook forward to analytics / routing.
+   */
+  onExit: {
+    type: PropType<(event: ModuleTabExitEvent) => void>;
+    default: undefined;
+  };
+}>> & Readonly<{}>, {
+  entry: string;
+  tabId: string;
+  onExit: (event: ModuleTabExitEvent) => void;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/use-wait-for-exit.d.ts
+/**
+ * Exit names whose schema declares a `void` output. The named-exit form
+ * of {@link WaitForExitTimeoutChannel} narrows to these so a deadline
+ * dispatching `resolve(name)` without an output is sound. Exits that
+ * require a payload must use the function form
+ * (`fire: (resolve) => resolve("name", payload)`).
+ */
+type VoidExitName<TExits extends ExitPointMap> = { [K in keyof TExits & string]: TExits[K] extends ExitPointSchema<infer T> ? [T] extends [void] ? K : never : never }[keyof TExits & string];
+/**
+ * One channel that races against the others. `resolve` is the wrapped exit
+ * dispatcher: calling it fires the named exit if no other channel has fired
+ * yet, and is a no-op otherwise. The subscriber returns its own teardown,
+ * which the composable calls **immediately** when any channel wins (not just on
+ * unmount) so the losing channels stop doing wakeups between dispatch and
+ * unmount.
+ *
+ * @example
+ * ```ts
+ * subscribe: (resolve) => {
+ *   const handler = (msg: WsFrame) => {
+ *     if (msg.type === "process-ready") resolve("ready", { process: msg.payload });
+ *   };
+ *   ws.on("message", handler);
+ *   return () => ws.off("message", handler);
+ * }
+ * ```
+ */
+type WaitForExitSubscribeChannel<TExits extends ExitPointMap> = (resolve: ExitFn<TExits>) => () => void;
+/**
+ * Periodic check that fires when the answer is ready. The interval is torn
+ * down the moment any channel wins, so `check` is not invoked again after
+ * settle. `check` itself should still cancel its own outstanding async
+ * work on unmount where applicable (e.g. via `AbortController`).
+ *
+ * @example
+ * ```ts
+ * poll: {
+ *   intervalMs: 3000,
+ *   check: async (resolve) => {
+ *     const process = await api.getTranslationProcess(projectId);
+ *     if (process) resolve("ready", { process });
+ *   },
+ * }
+ * ```
+ */
+interface WaitForExitPollChannel<TExits extends ExitPointMap> {
+  readonly intervalMs: number;
+  readonly check: (resolve: ExitFn<TExits>) => void | Promise<void>;
+}
+/**
+ * Deadline arm. The simple form fires a named exit; the function form runs
+ * arbitrary code (e.g. dispatches a different exit based on `input`). Pass
+ * `0` or a negative `ms` to disable the timeout for a render without
+ * conditionally calling the composable.
+ *
+ * @example
+ * ```ts
+ * // Named form — exit must have a `void` output schema.
+ * timeout: { ms: 60_000, fire: "timedOut" }
+ *
+ * // Function form — choose the exit (and its payload) at deadline time.
+ * timeout: {
+ *   ms: 60_000,
+ *   fire: (resolve) => resolve("failed", { reason: "deadline-exceeded" }),
+ * }
+ * ```
+ */
+type WaitForExitTimeoutChannel<TExits extends ExitPointMap> = {
+  readonly ms: number;
+} & ({
+  readonly fire: VoidExitName<TExits>;
+} | {
+  readonly fire: (resolve: ExitFn<TExits>) => void;
+});
+interface WaitForExitChannels<TExits extends ExitPointMap> {
+  /** Push channel — websocket, SSE, push notification, server-sent intent. */
+  readonly subscribe?: WaitForExitSubscribeChannel<TExits>;
+  /** Polling fallback. Omit when the push channel is reliable. */
+  readonly poll?: WaitForExitPollChannel<TExits>;
+  /** Deadline arm. Omit when no fallback is needed. */
+  readonly timeout?: WaitForExitTimeoutChannel<TExits>;
+}
+/**
+ * Wait for one of several async channels to fire and dispatch a journey
+ * exit when the first one resolves. Encapsulates the cancellation latch,
+ * channel teardown, and first-wins coordination so step components stay
+ * declarative. The Vue analog of the React `useWaitForExit` hook.
+ *
+ * Channel callbacks (`subscribe`, `poll.check`, `timeout.fire`) and the
+ * `exit` dispatcher are captured live, so changing their identity between
+ * renders does NOT restart the wait. The wait restarts on changes to scalar
+ * configuration (`poll.intervalMs`, `timeout.ms`, the timeout's named-exit
+ * form) so a deadline that genuinely shifts mid-wait is honored.
+ *
+ * Both `exit` and `channels` accept a plain value, a ref, or a getter
+ * ({@link MaybeRefOrGetter}) — because `setup` runs once, a caller whose
+ * channel configuration changes on the same instance should pass a getter (or
+ * a ref) so the wait re-arms on scalar changes and picks up the latest
+ * callbacks; plain values still work for hosts whose configuration is fixed for
+ * the mount. This mirrors how the React hook re-reads its props on re-render.
+ *
+ * Conventions:
+ *
+ * - At least one of `subscribe`, `poll`, `timeout` should be present.
+ *   With none, the composable is a no-op until the component unmounts.
+ *
+ * - `resolve(name, output)` is the *latched* exit dispatcher. The latch
+ *   is local to one arm cycle; the runtime's step-token mechanism is the
+ *   global backstop (an exit dispatched after the step has advanced is
+ *   dropped by the runtime even if the local latch were missing).
+ *
+ * - The composable does not own the journey-level "what does each exit mean"
+ *   decision. That lives in the journey's `transitions` map. It only marshals
+ *   the channels.
+ *
+ * - **First-wins teardown is immediate.** When any channel calls `resolve`,
+ *   the *other* channels' teardowns run before the exit dispatches. A subscribe
+ *   that synchronously calls `resolve` during setup still has its `unsubscribe`
+ *   invoked; poll / timeout are not armed at all in that case.
+ *
+ * - The arm cycle is monolithic: changing any scalar dep (`pollInterval`,
+ *   `timeoutMs`, the timeout's named-exit form) tears down *all* live channels
+ *   and re-arms them. Callers that need independent per-channel lifecycles
+ *   should split into multiple `useWaitForExit` calls or manage that channel
+ *   themselves.
+ */
+declare function useWaitForExit<TExits extends ExitPointMap>(exit: MaybeRefOrGetter<ExitFn<TExits>>, channels: MaybeRefOrGetter<WaitForExitChannels<TExits>>): void;
+//#endregion
+//#region src/plugin.d.ts
+/**
+ * Methods the journeys plugin contributes to the registry. Registered plugins
+ * type-intersect with the base registry so shells call
+ * `registry.registerJourney(...)` with full type support. The neutral analog
+ * of the React `JourneysPluginExtension`.
+ */
+interface JourneysPluginExtension {
+  /**
+   * Register a journey definition. The structural shape is validated
+   * immediately (missing `id` / `version` / `transitions` etc.); module-level
+   * contracts are validated at `resolveManifest()` / `resolve()` time.
+   *
+   * `options.persistence` is typed against the journey's state, and
+   * `options.nav.buildInput` is typed against the journey's input — pass a
+   * typed definition and both are checked end-to-end.
+   */
+  registerJourney<TModules extends ModuleTypeMap$1, TState, TInput, TOutput = unknown>(definition: JourneyDefinition$1<TModules, TState, TInput, TOutput>, options?: JourneyRegisterOptions$1<TState, TInput>): void;
+}
+/**
+ * Default shape the journeys plugin emits for each `nav`-carrying journey.
+ * When {@link JourneysPluginOptions.buildNavItem} is provided, the plugin
+ * hands this default (plus the journey's id and buildInput factory) to the
+ * adapter so apps can reshape the item into their narrowed `TNavItem`.
+ */
+interface JourneyDefaultNavItem extends NavigationItemBase {
+  readonly label: string;
+  /**
+   * Always empty for a journey launcher — the dispatchable action lives in
+   * {@link JourneyDefaultNavItem.action}, so there is no URL to follow. An
+   * empty string keeps the structural `NavigationItemBase.to` satisfied
+   * without suggesting the shell should treat this item as a link.
+   */
+  readonly to: "";
+  readonly icon?: string | UiComponent<{
+    className?: string;
+  }>;
+  readonly group?: string;
+  readonly order?: number;
+  readonly hidden?: boolean;
+  readonly meta?: unknown;
+  readonly action: {
+    readonly kind: "journey-start";
+    readonly journeyId: string;
+    readonly buildInput?: (ctx?: unknown) => unknown;
+  };
+}
+/**
+ * Signature for the optional typed adapter that reshapes the plugin's default
+ * nav item into the app's narrowed `TNavItem`. The adapter is called once per
+ * `nav`-carrying journey at manifest time.
+ */
+type JourneyNavItemBuilder<TNavItem extends NavigationItemBase> = (defaults: JourneyDefaultNavItem, raw: JourneyNavContribution$1<unknown> & {
+  readonly journeyId: string;
+}) => TNavItem;
+interface JourneysPluginOptions<TNavItem extends NavigationItemBase = JourneyDefaultNavItem> {
+  /**
+   * Enable verbose transition / rollback logging in the runtime. Defaults to
+   * `false`; plugins propagate the registry-level debug flag when set.
+   */
+  readonly debug?: boolean;
+  /**
+   * Forwarded onto `<JourneyProvider>` as the shell-wide `onModuleExit`
+   * handler. Use it as a default place to close tabs / forward analytics when
+   * a module exit isn't consumed by an explicit prop. Reuses the upstream
+   * `ModuleExitHandler` so the full `ModuleExitEvent` (incl. `routeId`) stays
+   * in sync with `@modular-vue/vue`.
+   */
+  readonly onModuleExit?: ModuleExitHandler;
+  /**
+   * Optional adapter that reshapes the plugin's default nav item into the
+   * app's narrowed `TNavItem`. Apps that use a typed `NavigationItem` alias
+   * (typed label union, typed action union, typed meta bag) should supply this
+   * so contributed items land in `manifest.navigation` with the correct
+   * narrowed type. When omitted, the plugin emits items as
+   * {@link JourneyDefaultNavItem} and the framework widens them to `TNavItem`
+   * at the assembly boundary.
+   */
+  readonly buildNavItem?: JourneyNavItemBuilder<TNavItem>;
+}
+/**
+ * Creates the journeys plugin. Pass to `registry.use(journeysPlugin())` (or
+ * `createRegistry({ plugins: [...] })`) to enable journey registration and
+ * outlet rendering without the runtime packages depending on
+ * `@modular-vue/journeys` directly. The Vue analog of the React
+ * `journeysPlugin`; the only framework-specific piece is `providers()`, which
+ * contributes a Vue `<JourneyProvider>` instead of a React one.
+ *
+ * The plugin:
+ *   - contributes `registerJourney(...)` onto the registry (type-safe)
+ *   - validates contracts against registered modules at resolve time
+ *   - produces a `JourneyRuntime` on `manifest.extensions.journeys` (also
+ *     surfaced as the `manifest.journeys` convenience alias)
+ *   - wraps the provider stack in `<JourneyProvider :runtime="…" />`
+ *
+ * **Instantiate per registry.** The returned object closes over a
+ * journey-registration list; passing the same instance to two
+ * `createRegistry()` calls causes them to share that list. Call
+ * `journeysPlugin()` once per registry.
+ */
+declare function journeysPlugin<TNavItem extends NavigationItemBase = JourneyDefaultNavItem>(options?: JourneysPluginOptions<TNavItem>): RegistryPlugin<"journeys", JourneysPluginExtension, JourneyRuntime$2>;
+//#endregion
+export { type AbandonCtx, type AnnotatedTransitionHandler, type AnyJourneyDefinition, type ChildOutcome, type EntryExitWildcardMap, type EntryInputOf, type EntryNamesOf, type EntryTransitions, type ExitCtx, type ExitNamesOf, type ExitNamesPairedWithEntry, type ExitOnlyWildcardMap, type ExitOutputOf, type InstanceId, type InvokeSpec, type JourneyDefaultNavItem, type JourneyDefinition, type JourneyDefinitionSummary, type JourneyHandle, JourneyHost, type JourneyHostSlotProps, type JourneyHostState, JourneyHydrationError, type JourneyInstance, type JourneyNavContribution, type JourneyNavItemBuilder, JourneyOutlet, type JourneyOutletErrorProps, type JourneyOutletNotFoundProps, type JourneyPersistence, JourneyProvider, type JourneyProviderValue, type JourneyRegisterOptions, type JourneyRuntime, type JourneyRuntimeOptions, type JourneyStatus, type JourneyStep, type JourneyStepErrorPolicy, type JourneyStepFor, type JourneySync, type JourneySyncAction, type JourneySyncCallbackCtx, type JourneySyncOptions, type JourneySyncPort, type JourneySystemAbortReason, type JourneySystemAbortReasonCode, JourneyValidationError, type JourneysPluginExtension, type JourneysPluginOptions, type MaybePromise, type MemoryPersistence, type MemoryPersistenceOptions, ModuleTab, type ModuleTabExitEvent, type ModuleTypeMap, type ParentLink, type PendingInvoke, type RegisteredJourney, type ResumeBounceCounter, type ResumeHandler, type ResumeMap, type SelectModuleCases, type SelectModuleCasesPartial, SemverParseError, type SerializedJourney, type StepRef, type StepSpec, type SyncJourneyPersistence, type TerminalCtx, type TerminalOutcome, type TerminalSentinel, type TransitionEvent, type TransitionMap, type TransitionResult, UnknownJourneyError, type UseJourneyHostOptions, type UseJourneySyncOptions, type WaitForExitChannels, type WaitForExitPollChannel, type WaitForExitSubscribeChannel, type WaitForExitTimeoutChannel, type WebStoragePersistenceOptions, type WildcardEntryInputOf, type WildcardEntryNamesOf, type WildcardExitNamesOf, type WildcardExitOutputForEntry, type WildcardExitOutputOf, type WildcardTransitionMap, compareVersions, createJourneyMountAdapter, createJourneyRuntime, createJourneySync, createMemoryJourneySyncPort, createMemoryPersistence, createWebStoragePersistence, defaultStepPath, defineJourney, defineJourneyHandle, defineJourneyPersistence, defineTransition, invoke, isAnnotatedTransition, isJourneySystemAbort, isTerminalSentinel, journeyKey, journeyStepPath, journeysPlugin, resolveJourneySyncAction, satisfies, selectModule, selectModuleOrDefault, useActiveLeafJourneyInstance, useActiveLeafJourneyState, useCallChain, useInstanceSnapshot, useJourneyCallStack, useJourneyContext, useJourneyHost, useJourneyInstance, useJourneyState, useJourneySync, useLeafId, useWaitForExit, validateJourneyContracts, validateJourneyDefinition, validateJourneyGraph };
+//# sourceMappingURL=index.d.ts.map