@modular-vue/journeys 1.0.0 → 1.2.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Igor Savin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Igor Savin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,137 +1,149 @@
-# @modular-vue/journeys
-
-Vue 3 journeys for `@modular-vue`. Journeys are typed, serializable workflows
-that compose multiple modules: a journey declares entry/exit transitions between
-modules and owns shared state, while the modules stay journey-unaware.
-
-This package is the Vue binding over the framework-neutral
-[`@modular-frontend/journeys-engine`](../journeys-engine). It re-exports the
-engine's authoring surface (`defineJourney`, handles, persistence, transition
-helpers) and adds the Vue-specific pieces: the provider, the composables, the
-outlet, and the registry plugin.
-
-The React binding is [`@modular-react/journeys`](../journeys); the two are kept
-at parity, and its README carries the long-form guides (authoring patterns,
-invoke/resume, persistence) that apply to both.
-
-## Installation
-
-```bash
-npm install @modular-vue/journeys
-```
-
-## What's included
-
-- **`<JourneyProvider :runtime="…">`** — provides the journey runtime to
-  descendant journey hosts and mounts `<ModuleExitProvider>` so module exits
-  fired outside a step reach the shell's `onModuleExit`.
-- **`<JourneyOutlet :instance-id="…">`** — renders the current step of a running
-  instance: mount-kind checks, loading, error boundary + policy, terminal, idle
-  preload, and abandon-on-unmount. Walks the active call chain to the leaf by
-  default.
-- **`<JourneyHost :handle="…" :input="…">`** — mounts a journey in one line:
-  starts it on mount, renders its step, ends + forgets the instance on unmount.
-  Outlet props pass through as attrs, in either spelling (`:on-finished` and
-  `:onFinished` both reach the outlet); the default scoped slot receives
-  `{ instanceId, instance, stepIndex, outlet }` for chrome.
-- **`useJourneyHost(handle, input, options?)`** — the lifecycle without the
-  rendering. Returns `{ instanceId, instance, stepIndex }` as refs, plus the
-  plain `runtime` it resolved at setup — the one `instanceId` is valid on.
-- **`useJourneySync(id, port, options?)`** — keeps a journey and the URL in step
-  both ways: the journey advances and the URL follows; Back/Forward drive
-  `rewindTo` / `goForward`. You supply a small `JourneySyncPort` for vue-router.
-- **`useJourneyState(id)` / `useJourneyInstance(id)`** — subscribe to one
-  journey instance; return a reactive ref of its `state` (or full snapshot).
-- **`useActiveLeafJourneyState(rootId)` / `useActiveLeafJourneyInstance(rootId)`**
-  — walk the `activeChildId` chain and track the deepest active leaf, so a
-  parent host reads the child sub-flow's state without knowing the depth.
-- **`<ModuleTab>`** — renders a single module entry outside a route and forwards
-  its exits to the shell. The non-journey counterpart to the outlet.
-- **`useWaitForExit(exit, channels)`** — for step components that wait on an
-  async backend event: races a push `subscribe` channel, a `poll` channel, and a
-  `timeout` arm with first-wins-latched dispatch.
-- **`journeysPlugin(options?)`** — pass to `createRegistry({ plugins: [...] })`
-  to contribute `registerJourney(...)`, validate journey contracts against
-  registered modules, produce the `JourneyRuntime` on
-  `manifest.extensions.journeys`, and wrap the provider stack in
-  `<JourneyProvider>`.
-
-## Usage
-
-```ts
-// app-shared: register the plugin and journeys
-import { createRegistry } from "@modular-vue/runtime";
-import { journeysPlugin, defineJourney } from "@modular-vue/journeys";
-
-const registry = createRegistry<AppDeps, AppSlots>({ stores, services, slots });
-const journeys = journeysPlugin();
-registry.use(journeys);
-
-registry.registerJourney(checkoutJourney, {
-  nav: { label: "Checkout", group: "flows" },
-});
-```
-
-```vue
-<!-- a host component reading the active leaf's state -->
-<script setup lang="ts">
-import { useActiveLeafJourneyInstance } from "@modular-vue/journeys";
-
-const props = defineProps<{ rootId: string }>();
-const leaf = useActiveLeafJourneyInstance(props.rootId);
-</script>
-
-<template>
-  <span>{{ leaf?.step?.moduleId }} — {{ leaf?.status }}</span>
-</template>
-```
-
-```vue
-<!-- a journey route: mounted, deep-linked, cleaned up -->
-<script setup lang="ts">
-import { useRoute, useRouter } from "vue-router";
-import { JourneyOutlet, useJourneyHost, useJourneySync } from "@modular-vue/journeys";
-import type { JourneySyncPort } from "@modular-vue/journeys";
-import { checkoutHandle } from "@app/journeys-checkout";
-
-const props = defineProps<{ cartId: string }>();
-const router = useRouter();
-const route = useRoute();
-
-const { instanceId, stepIndex } = useJourneyHost(checkoutHandle, { cartId: props.cartId });
-
-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 });
-</script>
-
-<template>
-  <p>Step {{ stepIndex + 1 }}</p>
-  <JourneyOutlet v-if="instanceId" :instance-id="instanceId" />
-</template>
-```
-
-`useJourneyHost` starts the journey on mount and ends + forgets it on unmount;
-`useJourneySync` owns the URL. Neither knows about the other, and `instanceId`
-is `null` for the first render (the journey is started from `onMounted`, so the
-start is guaranteed to be paired with an unmount that ends it).
-
-A URL cannot navigate a journey to an arbitrary step — a step is derived from
-state, so the only positions a location can select are ones the journey has
-already been to. See
-[Deep-linking steps](../journeys/README.md#deep-linking-steps---usejourneysync)
-in the React README for the full model; the reconciler is the same code.
-
-## Reactivity
-
-The composables mirror the React hooks but return Vue refs. A single-instance
-composable subscribes at setup and pushes fresh snapshots into a `shallowRef` on
-every runtime change; the leaf-walking composables re-subscribe as the active
-chain grows (a parent invokes a child) or shrinks (a child terminates and the
-parent resumes). Read `.value` at the call site, or bind directly in templates.
+# @modular-vue/journeys
+
+Vue 3 journeys for `@modular-vue`. Journeys are typed, serializable workflows
+that compose multiple modules: a journey declares entry/exit transitions between
+modules and owns shared state, while the modules stay journey-unaware.
+
+This package is the Vue binding over the framework-neutral
+[`@modular-frontend/journeys-engine`](../journeys-engine). It re-exports the
+engine's authoring surface (`defineJourney`, handles, persistence, transition
+helpers) and adds the Vue-specific pieces: the provider, the composables, the
+outlet, and the registry plugin.
+
+The React binding is [`@modular-react/journeys`](../journeys); the two are kept
+at parity, and its README carries the long-form guides (authoring patterns,
+invoke/resume, persistence) that apply to both.
+
+## Installation
+
+```bash
+npm install @modular-vue/journeys
+```
+
+## What's included
+
+- **`<JourneyProvider :runtime="…">`** — provides the journey runtime to
+  descendant journey hosts and mounts `<ModuleExitProvider>` so module exits
+  fired outside a step reach the shell's `onModuleExit`.
+- **`<JourneyOutlet :instance-id="…">`** — renders the current step of a running
+  instance: mount-kind checks, loading, error boundary + policy, terminal, idle
+  preload, and abandon-on-unmount. Walks the active call chain to the leaf by
+  default.
+- **`<JourneyHost :handle="…" :input="…">`** — mounts a journey in one line:
+  starts it on mount, renders its step, ends + forgets the instance on unmount.
+  Outlet props pass through as attrs, in either spelling (`:on-finished` and
+  `:onFinished` both reach the outlet); the default scoped slot receives
+  `{ instanceId, instance, runtime, stepIndex, outlet }` for chrome. `outlet` is
+  a functional component — render it with `<component :is="outlet" />`, or spell
+  it yourself as `<JourneyOutlet :instance-id="instanceId" :runtime="runtime" />`.
+- **`useJourneyHost(handle, input, options?)`** — the lifecycle without the
+  rendering. Returns `{ instanceId, instance, stepIndex }` as refs, plus the
+  plain `runtime` it resolved at setup — the one `instanceId` is valid on.
+- **`useJourneySync(id, port, options?)`** — keeps a journey and the URL in step
+  both ways: the journey advances and the URL follows; Back/Forward drive
+  `rewindTo` / `goForward`. You supply a small `JourneySyncPort` for vue-router.
+- **`useJourneyState(id)` / `useJourneyInstance(id)`** — subscribe to one
+  journey instance; return a reactive ref of its `state` (or full snapshot).
+- **`useActiveLeafJourneyState(rootId)` / `useActiveLeafJourneyInstance(rootId)`**
+  — walk the `activeChildId` chain and track the deepest active leaf, so a
+  parent host reads the child sub-flow's state without knowing the depth.
+- **`<ModuleTab>`** — renders a single module entry outside a route and forwards
+  its exits to the shell. The non-journey counterpart to the outlet.
+- **`useWaitForExit(exit, channels)`** — for step components that wait on an
+  async backend event: races a push `subscribe` channel, a `poll` channel, and a
+  `timeout` arm with first-wins-latched dispatch.
+- **`journeysPlugin(options?)`** — pass to `createRegistry({ plugins: [...] })`
+  to contribute `registerJourney(...)`, validate journey contracts against
+  registered modules, produce the `JourneyRuntime` on
+  `manifest.extensions.journeys`, and wrap the provider stack in
+  `<JourneyProvider>`. In the router-owning install path it also threads the
+  runtime app-wide via its `appProvides` hook, so `app.use(manifest)` provides
+  `journeyKey` with no shell wiring.
+- **`createPiniaJourneyPersistence(options)`** — a `JourneyPersistence` backed
+  by a Pinia store you own (keyed like `createWebStoragePersistence`), so
+  in-flight journeys live in your Pinia tree and resume across a modal
+  close/reopen. Structural store shape — takes no `pinia` dependency.
+- **`provideJourneyRuntime(app, runtime, options?)`** — the app-level twin of
+  `<JourneyProvider>` (analog of `provideNavigation` / `provideSlots`), for
+  wiring a hand-built runtime without the plugin. Usually unnecessary — the
+  plugin auto-threads via `app.use(manifest)`.
+
+## Usage
+
+```ts
+// app-shared: register the plugin and journeys
+import { createRegistry } from "@modular-vue/runtime";
+import { journeysPlugin, defineJourney } from "@modular-vue/journeys";
+
+const registry = createRegistry<AppDeps, AppSlots>({ stores, services, slots });
+const journeys = journeysPlugin();
+registry.use(journeys);
+
+registry.registerJourney(checkoutJourney, {
+  nav: { label: "Checkout", group: "flows" },
+});
+```
+
+```vue
+<!-- a host component reading the active leaf's state -->
+<script setup lang="ts">
+import { useActiveLeafJourneyInstance } from "@modular-vue/journeys";
+
+const props = defineProps<{ rootId: string }>();
+const leaf = useActiveLeafJourneyInstance(props.rootId);
+</script>
+
+<template>
+  <span>{{ leaf?.step?.moduleId }} — {{ leaf?.status }}</span>
+</template>
+```
+
+```vue
+<!-- a journey route: mounted, deep-linked, cleaned up -->
+<script setup lang="ts">
+import { useRoute, useRouter } from "vue-router";
+import { JourneyOutlet, useJourneyHost, useJourneySync } from "@modular-vue/journeys";
+import type { JourneySyncPort } from "@modular-vue/journeys";
+import { checkoutHandle } from "@app/journeys-checkout";
+
+const props = defineProps<{ cartId: string }>();
+const router = useRouter();
+const route = useRoute();
+
+const { instanceId, stepIndex } = useJourneyHost(checkoutHandle, { cartId: props.cartId });
+
+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 });
+</script>
+
+<template>
+  <p>Step {{ stepIndex + 1 }}</p>
+  <JourneyOutlet v-if="instanceId" :instance-id="instanceId" />
+</template>
+```
+
+`useJourneyHost` starts the journey on mount and ends + forgets it on unmount;
+`useJourneySync` owns the URL. Neither knows about the other, and `instanceId`
+is `null` for the first render (the journey is started from `onMounted`, so the
+start is guaranteed to be paired with an unmount that ends it).
+
+A URL cannot navigate a journey to an arbitrary step — a step is derived from
+state, so the only positions a location can select are ones the journey has
+already been to. See
+[Deep-linking steps](../journeys/README.md#deep-linking-steps---usejourneysync)
+in the React README for the full model; the reconciler is the same code.
+
+## Reactivity
+
+The composables mirror the React hooks but return Vue refs. A single-instance
+composable subscribes at setup and pushes fresh snapshots into a `shallowRef` on
+every runtime change; the leaf-walking composables re-subscribe as the active
+chain grows (a parent invokes a child) or shrinks (a child terminates and the
+parent resumes). Read `.value` at the call site, or bind directly in templates.

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-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 { App, Component, ComputedRef, FunctionalComponent, InjectionKey, MaybeRefOrGetter, PropType, ShallowRef, VNode } from "vue";
+import { ModuleExitEvent, ModuleExitHandler, VueAppProvidingPlugin } 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, SyncJourneyPersistence as SyncJourneyPersistence$1, 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
@@ -502,10 +502,27 @@ interface JourneyHostSlotProps {
   /** 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.
+   * The runtime the host started the instance on — the same value
+   * {@link JourneyHostState.runtime} exposes. Pass it to a hand-placed
+   * `<JourneyOutlet :instance-id="instanceId" :runtime="runtime" />` when you'd
+   * rather render the outlet yourself than use {@link JourneyHostSlotProps.outlet}
+   * (the idiomatic-Vue path), so the outlet resolves the *same* runtime the host
+   * pinned rather than whatever a nearer provider hands out.
    */
-  readonly outlet: VNode;
+  readonly runtime: JourneyRuntime$1;
+  /**
+   * The `<JourneyOutlet>` for this instance as a **functional component**,
+   * already bound to the host's pinned runtime and every outlet attribute passed
+   * to `<JourneyHost>`. Render it with `<component :is="outlet" />` in a template
+   * (or `h(outlet)` in a render function) — it is a component, not a raw VNode,
+   * so `:is` mounts it cleanly. Its identity is stable across host re-renders, so
+   * `:is` patches the outlet in place instead of remounting it on every step.
+   *
+   * Equivalent to spelling `<JourneyOutlet :instance-id="instanceId"
+   * :runtime="runtime" />` yourself with the slot's `instanceId` / `runtime` —
+   * use whichever reads better in your chrome.
+   */
+  readonly outlet: FunctionalComponent;
 }
 /**
  * Mount a journey in one line:
@@ -523,7 +540,8 @@ interface JourneyHostSlotProps {
  * 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:
+ * For chrome around the step, use the default scoped slot. The slot's `outlet`
+ * is a functional component, so `<component :is="outlet" />` renders it:
  *
  * ```vue
  * <JourneyHost :handle="checkoutHandle" :input="{ cartId }" @finished="goToReceipt">
@@ -535,6 +553,17 @@ interface JourneyHostSlotProps {
  * </JourneyHost>
  * ```
  *
+ * Or render the outlet yourself from the slot's `instanceId` + `runtime` — the
+ * more idiomatic-Vue spelling, equivalent to the `outlet` above:
+ *
+ * ```vue
+ * <template #default="{ stepIndex, instanceId, runtime }">
+ *   <Layout title="Checkout" :step="stepIndex">
+ *     <JourneyOutlet :instance-id="instanceId" :runtime="runtime" />
+ *   </Layout>
+ * </template>
+ * ```
+ *
  * 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.
@@ -593,8 +622,8 @@ declare const JourneyHost: import("vue").DefineComponent<import("vue").ExtractPr
     default: undefined;
   };
 }>> & Readonly<{}>, {
-  input: any;
   runtime: JourneyRuntime$1;
+  input: any;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 //#endregion
 //#region src/use-journey-sync.d.ts
@@ -756,9 +785,9 @@ declare const ModuleTab: import("vue").DefineComponent<import("vue").ExtractProp
     default: undefined;
   };
 }>> & Readonly<{}>, {
+  onExit: (event: ModuleTabExitEvent) => void;
   entry: string;
   tabId: string;
-  onExit: (event: ModuleTabExitEvent) => void;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 //#endregion
 //#region src/use-wait-for-exit.d.ts
@@ -890,6 +919,143 @@ interface WaitForExitChannels<TExits extends ExitPointMap> {
  */
 declare function useWaitForExit<TExits extends ExitPointMap>(exit: MaybeRefOrGetter<ExitFn<TExits>>, channels: MaybeRefOrGetter<WaitForExitChannels<TExits>>): void;
 //#endregion
+//#region src/provide-journey-runtime.d.ts
+interface ProvideJourneyRuntimeOptions {
+  /**
+   * Shell-wide fallback dispatcher for module exits fired outside a journey
+   * step — the app-level equivalent of `<JourneyProvider :onModuleExit>`.
+   */
+  readonly onModuleExit?: (event: ModuleExitEvent) => void;
+}
+/**
+ * App-level twin of `<JourneyProvider>`: install the journey runtime on a Vue
+ * `App` via `app.provide` so `<JourneyOutlet>` and the instance composables
+ * resolve it from context without a wrapping component in the render tree. The
+ * journeys analog of `@modular-vue/vue`'s `provideNavigation` / `provideSlots`
+ * standalone helpers.
+ *
+ * **You usually do not need to call this.** When the registry is built with
+ * `journeysPlugin()`, the plugin's `appProvides` hook already threads the
+ * runtime app-wide through `app.use(manifest)` (the router-owning `resolve()` /
+ * `installModularApp` path) — `<JourneyOutlet>` resolves `journeyKey` with no
+ * shell wiring. This helper is the explicit escape hatch for the cases that
+ * bypass that:
+ *
+ *   - a shell that constructs a `JourneyRuntime` by hand (no `journeysPlugin()`),
+ *   - installing the same runtime on a second app (SSR, multiple roots),
+ *   - overriding the app-wide runtime for a subtree that mounts its own app.
+ *
+ * ```ts
+ * // Hand-wired runtime, no plugin:
+ * const runtime = createJourneyRuntime(registered, { modules });
+ * provideJourneyRuntime(app, runtime, { onModuleExit: (e) => reportExit(e) });
+ * ```
+ *
+ * A local `<JourneyProvider :runtime>` mounted lower in the tree still wins for
+ * its subtree (component-level `inject` shadows the app-level provide), so this
+ * only supplies the default when no nearer provider is present.
+ */
+declare function provideJourneyRuntime(app: App, runtime: JourneyRuntime$1, options?: ProvideJourneyRuntimeOptions): void;
+//#endregion
+//#region src/pinia-persistence.d.ts
+/**
+ * The minimal structural slice of a Pinia store this adapter needs: read the
+ * reactive `$state` and mutate it through `$patch`. A real Pinia store (option
+ * or setup) satisfies this, but the shape is intentionally structural so this
+ * package takes **no** `pinia` dependency — the caller brings their own store.
+ *
+ * This is the load-bearing design choice behind decision D3
+ * (`docs/vue-support-tracker.md`): "do not take a Pinia dependency in runtime
+ * packages". The adapter is a thin bridge over a store the consumer already
+ * owns, not a reason for every `@modular-vue/journeys` consumer to pull Pinia.
+ */
+interface PiniaJourneyPersistenceStore {
+  /**
+   * The store's reactive state object (`store.$state`). Typed as `object`
+   * rather than `Record<string, unknown>` so a concrete Pinia store — whose
+   * `$state` is an interface without an index signature — is structurally
+   * assignable without the caller casting. The adapter narrows internally.
+   */
+  readonly $state: object;
+  /** Apply a mutation to `$state` (`store.$patch((s) => { … })`). */
+  $patch(mutator: (state: any) => void): void;
+}
+interface PiniaJourneyPersistenceOptions<TInput> {
+  /**
+   * Compute the persistence key from the journey id and starting input.
+   * Must be deterministic — `runtime.start()` probes this key to find an
+   * existing instance and achieve start-means-resume idempotency.
+   */
+  readonly keyFor: (ctx: {
+    journeyId: string;
+    input: TInput;
+  }) => string;
+  /**
+   * The Pinia store that owns the serialized-journey record, or a lazy getter
+   * returning it (or `null`). The getter is invoked on every call, mirroring
+   * `createWebStoragePersistence`'s `storage` option — pass a getter when the
+   * store is created inside a Pinia scope resolved after this adapter is
+   * constructed, or `null` to force the no-op (server / no-store) path.
+   */
+  readonly store: PiniaJourneyPersistenceStore | (() => PiniaJourneyPersistenceStore | null);
+  /**
+   * Property on the store's `$state` that holds the
+   * `Record<string, SerializedJourney<TState>>` map. Defaults to `"journeys"`.
+   * The property is created on first `save` if absent.
+   */
+  readonly stateKey?: string;
+  /**
+   * When true (default), stored blobs are deep-cloned on both `save` and
+   * `load`, so `load` returns a plain object detached from the store: callers
+   * mutating it cannot corrupt the reactive state, and a mutated source blob
+   * cannot corrupt what was persisted. The clone is a structural JSON round-trip
+   * (`JSON.parse(JSON.stringify(...))`), which matches the `SerializedJourney`
+   * contract the engine persists — plain JSON — but, like any storage adapter,
+   * drops `undefined` fields and cannot carry `Date` / `Map` / `Set`. Journey
+   * blobs are already JSON by construction, so this only bites if a custom
+   * persistence layer routes non-serializable state through here.
+   *
+   * When false, the clone is skipped. Note Pinia still wraps stored state in a
+   * reactive proxy, so `load` never returns the exact reference passed to
+   * `save`; instead it returns the **live** store entry (mutations to it are
+   * visible on the next `load` and to Pinia devtools). Use only when you have
+   * verified nobody mutates the loaded blob out from under the store.
+   */
+  readonly clone?: boolean;
+}
+/**
+ * `JourneyPersistence` backed by a Pinia store — the Vue-ecosystem analog of
+ * `createWebStoragePersistence`, keeping journey state inside the app's
+ * existing Pinia store tree instead of a parallel storage mechanism.
+ *
+ * Because the record lives in Pinia, in-flight journeys participate in the
+ * app's Pinia devtools / timeline, and a single `store.$reset()` (or clearing
+ * the record) drops every persisted journey through one path the app already
+ * owns.
+ *
+ * Semantics match the stock adapters exactly: `keyFor` derives the key,
+ * `load` returns the stored blob (or `null`), `save` writes it, `remove`
+ * deletes it — so `runtime.start()` resumes an in-flight instance for the same
+ * `keyFor(input)` rather than minting a fresh one.
+ *
+ * Pure-client-safe like the web-storage adapter: pass `store` as a getter that
+ * returns `null` under SSR and all four methods no-op, so the runtime mints a
+ * fresh instance server-side.
+ *
+ * ```ts
+ * // A tiny store whose only job is to hold serialized journeys.
+ * const useJourneyStore = defineStore("journeys", {
+ *   state: () => ({ journeys: {} as Record<string, SerializedJourney<WizardState>> }),
+ * });
+ *
+ * export const wizardPersistence = createPiniaJourneyPersistence<{ frameId: string }, WizardState>({
+ *   keyFor: ({ journeyId, input }) => `journey:${input.frameId}:${journeyId}`,
+ *   store: () => useJourneyStore(),
+ * });
+ * ```
+ */
+declare function createPiniaJourneyPersistence<TInput, TState>(options: PiniaJourneyPersistenceOptions<TInput>): SyncJourneyPersistence$1<TState, TInput>;
+//#endregion
 //#region src/plugin.d.ts
 /**
  * Methods the journeys plugin contributes to the registry. Registered plugins
@@ -990,7 +1156,7 @@ interface JourneysPluginOptions<TNavItem extends NavigationItemBase = JourneyDef
  * `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>;
+declare function journeysPlugin<TNavItem extends NavigationItemBase = JourneyDefaultNavItem>(options?: JourneysPluginOptions<TNavItem>): RegistryPlugin<"journeys", JourneysPluginExtension, JourneyRuntime$2> & VueAppProvidingPlugin<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 };
+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 PiniaJourneyPersistenceOptions, type PiniaJourneyPersistenceStore, type ProvideJourneyRuntimeOptions, 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, createPiniaJourneyPersistence, createWebStoragePersistence, defaultStepPath, defineJourney, defineJourneyHandle, defineJourneyPersistence, defineTransition, invoke, isAnnotatedTransition, isJourneySystemAbort, isTerminalSentinel, journeyKey, journeyStepPath, journeysPlugin, provideJourneyRuntime, resolveJourneySyncAction, satisfies, selectModule, selectModuleOrDefault, useActiveLeafJourneyInstance, useActiveLeafJourneyState, useCallChain, useInstanceSnapshot, useJourneyCallStack, useJourneyContext, useJourneyHost, useJourneyInstance, useJourneyState, useJourneySync, useLeafId, useWaitForExit, validateJourneyContracts, validateJourneyDefinition, validateJourneyGraph };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/provider.ts","../src/use-journey-state.ts","../src/instance-hooks.ts","../src/mount-adapter.ts","../src/outlet.ts","../src/journey-host.ts","../src/use-journey-sync.ts","../src/module-tab.ts","../src/use-wait-for-exit.ts","../src/plugin.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/provider.ts","../src/use-journey-state.ts","../src/instance-hooks.ts","../src/mount-adapter.ts","../src/outlet.ts","../src/journey-host.ts","../src/use-journey-sync.ts","../src/module-tab.ts","../src/use-wait-for-exit.ts","../src/provide-journey-runtime.ts","../src/pinia-persistence.ts","../src/plugin.ts"],"mappings":"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"}