npm - @react-router-modules/runtime - Versions diffs - 1.0.0 → 2.0.0 - Mend

@react-router-modules/runtime 1.0.0 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/README.md CHANGED Viewed

@@ -1,6 +1,6 @@
 # @react-router-modules/runtime
-Application assembly layer for the reactive framework. Takes modules and configuration, produces a running app with routing, slots, zones, navigation, and provider wiring.
+Application assembly layer for the modular-react framework (React Router integration). Takes modules and configuration, produces a running app with routing, slots, zones, navigation, and provider wiring.
 ## Installation
@@ -8,6 +8,14 @@ Application assembly layer for the reactive framework. Takes modules and configu
 npm install @react-router-modules/runtime
 ```
+## What's included
+- **Registry**: `createRegistry` — assembles modules into a running app
+- **Zones**: `useZones` (reads zone components from matched route `handle`), `useActiveZones` (merges route zones with active module zones)
+- **Types**: `ModuleRegistry`, `ResolveOptions`, `RegistryConfig`, `ApplicationManifest`
+- **Re-exported from `@modular-react/core`**: `buildSlotsManifest`, `collectDynamicSlotFactories`, `evaluateDynamicSlots`, `buildNavigationManifest`, `validateNoDuplicateIds`, `validateDependencies`, `NavigationGroup`, `NavigationManifest`, `ModuleEntry`, `DynamicSlotFactory`, `SlotFilter`
+- **Re-exported from `@modular-react/react`**: `useNavigation`, `useSlots`, `useRecalculateSlots`, `useModules`, `getModuleMeta`, `ModuleErrorBoundary`, `NavigationContext`, `SlotsContext`, `RecalculateSlotsContext`, `ModulesContext`, `DynamicSlotsProvider`, `createSlotsSignal`
 ## Usage
 ```typescript
@@ -22,10 +30,19 @@ const registry = createRegistry<AppDependencies, AppSlots>({
 registry.register(billingModule);
-const { App } = registry.resolve({
+const { App, recalculateSlots } = registry.resolve({
   rootComponent: Layout,
   indexComponent: HomePage,
 });
+// Re-evaluate dynamic slots after auth state changes
+authStore.subscribe((state, prev) => {
+  if (state.isAuthenticated !== prev.isAuthenticated) {
+    recalculateSlots();
+  }
+});
 ```
-See the [main documentation](https://github.com/kibertoad/reactive#readme) for the full guide.
+Modules can contribute conditional slot entries via `dynamicSlots` and trigger re-evaluation from components via `useRecalculateSlots()`. The shell can apply cross-cutting filters via `slotFilter` on `resolve()`.
+See the [main documentation](https://github.com/kibertoad/modular-react#readme) for the full guide.

package/dist/index.d.ts CHANGED Viewed

@@ -1,124 +1,106 @@
-import { Component } from 'react';
-import { Context } from 'react';
+import { buildNavigationManifest } from '@modular-react/core';
+import { buildSlotsManifest } from '@modular-react/core';
+import { collectDynamicSlotFactories } from '@modular-react/core';
+import { createSlotsSignal } from '@modular-react/react';
 import { DataRouter } from 'react-router';
-import { ErrorInfo } from 'react';
-import { JSX } from 'react/jsx-runtime';
-import { JSXElementConstructor } from 'react';
+import { DynamicSlotFactory } from '@modular-react/core';
+import { DynamicSlotsProvider } from '@modular-react/react';
+import { evaluateDynamicSlots } from '@modular-react/core';
+import { getModuleMeta } from '@modular-react/react';
 import { LazyModuleDescriptor } from '@react-router-modules/core';
-import { NavigationItem } from '@react-router-modules/core';
-import { ReactElement } from 'react';
-import { ReactiveModuleDescriptor } from '@react-router-modules/core';
-import { ReactiveService } from '@react-router-modules/core';
-import { ReactNode } from 'react';
-import { ReactPortal } from 'react';
+import { ModuleDescriptor } from '@react-router-modules/core';
+import { ModuleEntry } from '@modular-react/core';
+import { ModuleErrorBoundary } from '@modular-react/react';
+import { ModulesContext } from '@modular-react/react';
+import { NavigationContext } from '@modular-react/react';
+import { NavigationGroup } from '@modular-react/core';
+import { NavigationManifest } from '@modular-react/core';
+import { ReactiveService } from '@modular-react/core';
+import { RecalculateSlotsContext } from '@modular-react/react';
 import { RouteObject } from 'react-router';
+import { SlotFilter } from '@modular-react/core';
 import { SlotMap } from '@react-router-modules/core';
+import { SlotMap as SlotMap_2 } from '@modular-react/core';
 import { SlotMapOf } from '@react-router-modules/core';
+import { SlotMapOf as SlotMapOf_2 } from '@modular-react/core';
+import { SlotsContext } from '@modular-react/react';
+import { SlotsSignal } from '@modular-react/react';
 import { StoreApi } from 'zustand';
+import { useModules } from '@modular-react/react';
+import { useNavigation } from '@modular-react/react';
+import { useRecalculateSlots } from '@modular-react/react';
+import { useSlots } from '@modular-react/react';
+import { validateDependencies } from '@modular-react/core';
+import { validateNoDuplicateIds } from '@modular-react/core';
 import { ZoneMapOf } from '@react-router-modules/core';
-export declare interface ApplicationManifest<TSlots extends SlotMapOf<TSlots> = SlotMap> {
+export declare interface ApplicationManifest<TSlots extends SlotMapOf_2<TSlots> = SlotMap_2> {
     /** The root React component with all providers wired */
     readonly App: React.ComponentType;
     /** The React Router instance — pass to <RouterProvider /> if needed */
     readonly router: DataRouter;
     /** Auto-generated navigation manifest from all modules */
     readonly navigation: NavigationManifest;
-    /** Collected slot contributions from all modules */
+    /** Collected slot contributions from all modules (static base — does not include dynamic) */
     readonly slots: TSlots;
     /** Registered module summaries — use useModules() to access in components */
     readonly modules: readonly ModuleEntry[];
+    /**
+     * Trigger re-evaluation of dynamic slots.
+     *
+     * Call this after a state change that affects `dynamicSlots` or `slotFilter`
+     * results — for example after login, role change, or feature flag update.
+     * Components consuming `useSlots()` will re-render with the new values.
+     *
+     * No-op when no module uses `dynamicSlots` and no `slotFilter` is configured.
+     */
+    readonly recalculateSlots: () => void;
 }
-/**
- * Collects slot contributions from all registered modules.
- * Arrays are concatenated per slot key across modules.
- *
- * When defaults are provided, every key in defaults is guaranteed to exist
- * in the result — even if no module contributes to it.
- */
-export declare function buildSlotsManifest<TSlots extends {
-    [K in keyof TSlots]: readonly unknown[];
-}>(modules: readonly ReactiveModuleDescriptor<any, TSlots>[], defaults?: Partial<{
-    [K in keyof TSlots]: TSlots[K];
-}>): TSlots;
+export { buildNavigationManifest }
-export declare function createRegistry<TSharedDependencies extends Record<string, any>, TSlots extends SlotMapOf<TSlots> = SlotMap>(config: RegistryConfig<TSharedDependencies, TSlots>): ReactiveRegistry<TSharedDependencies, TSlots>;
+export { buildSlotsManifest }
-/**
- * Type-safe accessor for module metadata.
- * Use this when the shell defines a known meta shape and wants to read it
- * without casting every field.
- *
- * Returns undefined if the module has no meta.
- *
- * @example
- * interface JourneyMeta { name: string; category: string; icon: string }
- * const meta = getModuleMeta<JourneyMeta>(mod)
- * if (meta) console.log(meta.name) // typed, no cast
- */
-export declare function getModuleMeta<TMeta extends {
-    [K in keyof TMeta]: unknown;
-}>(entry: ModuleEntry): Readonly<TMeta> | undefined;
+export { collectDynamicSlotFactories }
-/**
- * A summary of a registered module exposed to the shell.
- * Includes the module's identity, metadata, and optional component.
- */
-export declare interface ModuleEntry {
-    /** Unique module identifier */
-    readonly id: string;
-    /** SemVer version string */
-    readonly version: string;
-    /** Catalog metadata (description, icon, category, etc.) */
-    readonly meta?: Readonly<Record<string, unknown>>;
-    /** A React component the shell can render outside of routes */
-    readonly component?: React.ComponentType<any>;
-    /** Zone components contributed when this module is active in a workspace tab */
-    readonly zones?: Readonly<Record<string, React.ComponentType<any>>>;
-}
+export declare function createRegistry<TSharedDependencies extends Record<string, any>, TSlots extends SlotMapOf<TSlots> = SlotMap>(config: RegistryConfig<TSharedDependencies, TSlots>): ModuleRegistry<TSharedDependencies, TSlots>;
-export declare class ModuleErrorBoundary extends Component<Props, State> {
-    state: State;
-    static getDerivedStateFromError(error: Error): State;
-    componentDidCatch(error: Error, info: ErrorInfo): void;
-    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | ReactPortal | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | JSX.Element | null | undefined;
-}
+export { createSlotsSignal }
-export declare const ModulesContext: Context<readonly ModuleEntry[] | null>;
+export { DynamicSlotFactory }
-export declare interface NavigationGroup {
-    readonly group: string;
-    readonly items: readonly NavigationItem[];
-}
+export { DynamicSlotsProvider }
-export declare interface NavigationManifest {
-    /** All navigation items flat */
-    readonly items: readonly NavigationItem[];
-    /** Items grouped by their group key, sorted by order within each group */
-    readonly groups: readonly NavigationGroup[];
-    /** Ungrouped items (no group key) */
-    readonly ungrouped: readonly NavigationItem[];
-}
+export { evaluateDynamicSlots }
-declare interface Props {
-    moduleId: string;
-    fallback?: ReactNode;
-    children: ReactNode;
-}
+export { getModuleMeta }
+export { ModuleEntry }
-export declare interface ReactiveRegistry<TSharedDependencies extends Record<string, any>, TSlots extends SlotMapOf<TSlots> = SlotMap> {
+export { ModuleErrorBoundary }
+export declare interface ModuleRegistry<TSharedDependencies extends Record<string, any>, TSlots extends SlotMapOf<TSlots> = SlotMap> {
     /** Register an eager module */
-    register(module: ReactiveModuleDescriptor<TSharedDependencies, TSlots>): void;
+    register(module: ModuleDescriptor<TSharedDependencies, TSlots>): void;
     /** Register a lazily-loaded module */
     registerLazy(descriptor: LazyModuleDescriptor<TSharedDependencies, TSlots>): void;
     /**
      * Resolve all modules and produce the application manifest.
      * Validates dependencies and builds the route tree.
      */
-    resolve(options?: ResolveOptions): ApplicationManifest<TSlots>;
+    resolve(options?: ResolveOptions<TSharedDependencies, TSlots>): ApplicationManifest<TSlots>;
 }
+export { ModulesContext }
+export { NavigationContext }
+export { NavigationGroup }
+export { NavigationManifest }
+export { RecalculateSlotsContext }
 /**
  * Configuration for creating a registry.
  *
@@ -127,7 +109,7 @@ export declare interface ReactiveRegistry<TSharedDependencies extends Record<str
  * - **services** — plain objects (non-reactive, static references)
  * - **reactiveServices** — external sources with subscribe/getSnapshot (reactive via useSyncExternalStore)
  */
-export declare interface RegistryConfig<TSharedDependencies extends Record<string, any>, TSlots extends SlotMapOf<TSlots> = SlotMap> {
+export declare interface RegistryConfig<TSharedDependencies extends Record<string, any>, TSlots extends SlotMapOf_2<TSlots> = SlotMap_2> {
     /** Zustand stores — state you own and mutate */
     stores?: {
         [K in keyof TSharedDependencies]?: StoreApi<TSharedDependencies[K]>;
@@ -150,13 +132,11 @@ export declare interface RegistryConfig<TSharedDependencies extends Record<strin
     };
 }
-export declare interface ResolveOptions {
+export declare interface ResolveOptions<TSharedDependencies extends Record<string, any> = Record<string, any>, TSlots extends SlotMapOf<TSlots> = SlotMap> {
     /** Root layout component (renders <Outlet /> for child routes) */
     rootComponent?: () => React.JSX.Element;
     /**
      * Pre-built root route — if provided, used instead of auto-creating one.
-     * Use this when you need full control over the root route config
-     * (loader, errorElement, etc.).
      * Mutually exclusive with rootComponent/notFoundComponent/loader.
      */
     rootRoute?: RouteObject;
@@ -167,11 +147,7 @@ export declare interface ResolveOptions {
     /**
      * Called before every route loads — for observability, analytics, feature flags.
      * Runs for ALL routes including public ones like /login.
-     * Throw a `redirect()` from react-router to redirect.
-     * Ignored if rootRoute is provided (configure loader on your root route instead).
-     *
-     * For auth guards, use `authenticatedRoute` instead — it creates a layout route
-     * boundary that only wraps protected routes.
+     * Ignored if rootRoute is provided.
      */
     loader?: (args: {
         request: Request;
@@ -179,34 +155,7 @@ export declare interface ResolveOptions {
     }) => any;
     /**
      * Auth boundary — a pathless layout route that guards module routes and
-     * the index route. Shell routes (login, error pages) sit outside this
-     * boundary and are NOT guarded.
-     *
-     * Follows React Router's recommended layout route pattern:
-     * ```
-     * Root (loader runs for ALL routes — observability, etc.)
-     * ├── shellRoutes (public — /login, /signup)
-     * └── _authenticated (layout — auth guard)
-     *     ├── / (indexComponent)
-     *     └── module routes
-     * ```
-     *
-     * @example
-     * ```ts
-     * registry.resolve({
-     *   authenticatedRoute: {
-     *     loader: async () => {
-     *       const res = await fetch('/api/auth/session')
-     *       if (!res.ok) throw redirect('/login')
-     *       return null
-     *     },
-     *     Component: ShellLayout,
-     *   },
-     *   shellRoutes: () => [
-     *     { path: '/login', Component: LoginPage },
-     *   ],
-     * })
-     * ```
+     * the index route. Shell routes sit outside this boundary.
      */
     authenticatedRoute?: {
         /** Auth guard — throw redirect() to deny access */
@@ -217,50 +166,27 @@ export declare interface ResolveOptions {
         /** Layout component for authenticated pages. Defaults to <Outlet />. */
         Component?: () => React.JSX.Element;
     };
-    /**
-     * Additional routes owned by the shell (login, error pages, onboarding, etc.)
-     * that sit alongside module routes at the root level.
-     *
-     * When `authenticatedRoute` is used, shell routes are NOT guarded — they
-     * are siblings of the auth layout, not children. This is the natural place
-     * for public pages like /login.
-     */
+    /** Additional routes owned by the shell (login, error pages, etc.) */
     shellRoutes?: () => RouteObject[];
     /**
      * Additional React providers to wrap around the app tree.
-     *
-     * **Nesting order:** First element is outermost. `[A, B, C]` produces:
-     * ```tsx
-     * <A>
-     *   <B>
-     *     <C>
-     *       ...app...
-     *     </C>
-     *   </B>
-     * </A>
-     * ```
-     *
-     * Place providers that other providers depend on **first** in the array.
-     * For example, if your data-fetching provider reads from a theme context,
-     * list the theme provider before the data-fetching provider.
-     *
-     * @example
-     * ```ts
-     * providers: [SWRConfigProvider, ThemeProvider, TooltipProvider]
-     * // Produces: <SWRConfigProvider><ThemeProvider><TooltipProvider>...app...</TooltipProvider></ThemeProvider></SWRConfigProvider>
-     * ```
+     * First element is outermost.
      */
     providers?: React.ComponentType<{
         children: React.ReactNode;
     }>[];
+    /**
+     * Global filter applied to the fully resolved slot manifest (static + dynamic)
+     * on every `recalculateSlots()` call.
+     */
+    slotFilter?: (slots: TSlots, deps: TSharedDependencies) => TSlots;
 }
-export declare const SlotsContext: Context<object | null>;
+export { SlotFilter }
-declare interface State {
-    hasError: boolean;
-    error: Error | null;
-}
+export { SlotsContext }
+export { SlotsSignal }
 /**
  * Read zone components from both the matched route hierarchy AND the
@@ -271,60 +197,17 @@ declare interface State {
  * - **Tab-based modules** contribute zones via the `zones` field on their descriptor
  *
  * When both sources provide a value for the same zone key, the module's
- * contribution wins — the assumption is that the active tab's content is more
- * relevant than the underlying route's.
- *
- * @param activeModuleId - The id of the module that is currently active in the
- *   workspace (e.g. the journey tab's moduleId). Pass `null` or `undefined`
- *   when no module tab is active — only route zones are returned.
- *
- * @example
- * // In the shell layout:
- * const activeTab = getActiveTab(interactionId)
- * const moduleId = activeTab?.type === 'native-journey' ? activeTab.journeyId : null
- * const zones = useActiveZones<AppZones>(moduleId)
- * const Panel = zones.contextualPanel
- *
- * return (
- *   <aside>{Panel ? <Panel /> : <DefaultPanel />}</aside>
- * )
+ * contribution wins.
  */
 export declare function useActiveZones<TZones extends ZoneMapOf<TZones>>(activeModuleId?: string | null): Partial<TZones>;
-/**
- * Access the list of registered modules with their metadata and components.
- * Must be used within a <ReactiveApp /> provider tree.
- *
- * Use this to build discovery UIs (directory pages, search, catalogs)
- * and to render module components in workspace tabs or panels.
- *
- * @example
- * const modules = useModules()
- * const journeys = modules.filter(m => m.meta?.category === 'payments')
- *
- * @example
- * const mod = modules.find(m => m.id === activeTab.moduleId)
- * if (mod?.component) return <mod.component {...props} />
- */
-export declare function useModules(): readonly ModuleEntry[];
+export { useModules }
-/**
- * Access the auto-generated navigation manifest from registered modules.
- * Use this in layout components to render sidebar/nav items.
- */
-export declare function useNavigation(): NavigationManifest;
+export { useNavigation }
-/**
- * Access the collected slot contributions from all registered modules.
- * Must be used within a <ReactiveApp /> provider tree.
- *
- * @example
- * const slots = useSlots<AppSlots>()
- * const commands = slots.commands // CommandDefinition[] from all modules
- */
-export declare function useSlots<TSlots extends {
-    [K in keyof TSlots]: readonly unknown[];
-}>(): TSlots;
+export { useRecalculateSlots }
+export { useSlots }
 /**
  * Read zone components contributed by the currently matched route hierarchy.
@@ -357,4 +240,8 @@ export declare function useSlots<TSlots extends {
  */
 export declare function useZones<TZones extends ZoneMapOf<TZones>>(): Partial<TZones>;
+export { validateDependencies }
+export { validateNoDuplicateIds }
 export { }

package/dist/index.js CHANGED Viewed

@@ -1,64 +1,11 @@
 import { Outlet as e, RouterProvider as t, createBrowserRouter as n, createMemoryRouter as r, useMatches as i, useRoutes as a } from "react-router";
-import { jsx as o, jsxs as s } from "react/jsx-runtime";
-import { Component as c, createContext as l, useContext as u, useMemo as d } from "react";
-import { SharedDependenciesContext as f } from "@react-router-modules/core";
-//#region src/validation.ts
-function p(e, t) {
-	let n = /* @__PURE__ */ new Set();
-	for (let t of e) {
-		if (n.has(t.id)) throw Error(`[@react-router-modules/runtime] Duplicate module ID "${t.id}". Each module must have a unique ID.`);
-		n.add(t.id);
-	}
-	for (let e of t) {
-		if (n.has(e.id)) throw Error(`[@react-router-modules/runtime] Duplicate module ID "${e.id}". Each module must have a unique ID.`);
-		n.add(e.id);
-	}
-}
-function m(e, t) {
-	for (let n of e) {
-		if (n.requires) {
-			let e = n.requires.filter((e) => !t.has(e));
-			if (e.length > 0) throw Error(`[@react-router-modules/runtime] Module "${n.id}" requires dependencies not provided by the registry: ${e.map(String).join(", ")}. Available: ${[...t].join(", ") || "(none)"}`);
-		}
-		if (n.optionalRequires) {
-			let e = n.optionalRequires.filter((e) => !t.has(e));
-			e.length > 0 && console.warn(`[@react-router-modules/runtime] Module "${n.id}" has optional dependencies not provided: ${e.map(String).join(", ")}. The module will still load but may have reduced functionality.`);
-		}
-	}
-}
-//#endregion
-//#region src/navigation.ts
-function h(e) {
-	let t = [];
-	for (let n of e) n.navigation && t.push(...n.navigation);
-	let n = [...t].sort((e, t) => {
-		let n = (e.order ?? 999) - (t.order ?? 999);
-		return n === 0 ? e.label.localeCompare(t.label) : n;
-	}), r = /* @__PURE__ */ new Map(), i = [];
-	for (let e of n) if (e.group) {
-		let t = r.get(e.group);
-		t || (t = [], r.set(e.group, t)), t.push(e);
-	} else i.push(e);
-	return {
-		items: n,
-		groups: [...r.entries()].map(([e, t]) => ({
-			group: e,
-			items: t
-		})),
-		ungrouped: i
-	};
-}
-//#endregion
-//#region src/slots.ts
-function g(e, t) {
-	let n = {};
-	if (t) for (let [e, r] of Object.entries(t)) n[e] = Array.isArray(r) ? [...r] : [];
-	for (let t of e) if (t.slots) for (let [e, r] of Object.entries(t.slots)) n[e] || (n[e] = []), Array.isArray(r) && n[e].push(...r);
-	return n;
-}
-//#endregion
+import { buildNavigationManifest as o, buildNavigationManifest as s, buildSlotsManifest as c, buildSlotsManifest as l, collectDynamicSlotFactories as u, collectDynamicSlotFactories as d, evaluateDynamicSlots as f, validateDependencies as p, validateDependencies as m, validateNoDuplicateIds as h, validateNoDuplicateIds as g } from "@modular-react/core";
+import { DynamicSlotsProvider as _, DynamicSlotsProvider as v, ModuleErrorBoundary as y, ModulesContext as b, ModulesContext as x, NavigationContext as S, NavigationContext as C, RecalculateSlotsContext as w, RecalculateSlotsContext as T, SlotsContext as E, SlotsContext as D, createSlotsSignal as O, createSlotsSignal as k, getModuleMeta as A, useModules as j, useModules as M, useNavigation as N, useRecalculateSlots as P, useSlots as F } from "@modular-react/react";
+import { jsx as I } from "react/jsx-runtime";
+import { useMemo as L } from "react";
+import { SharedDependenciesContext as R } from "@react-router-modules/core";
 //#region src/route-builder.tsx
-function _(e, t, n) {
+function z(e, t, n) {
 	if (n?.rootRoute) {
 		let r = [...n.rootRoute.children ?? []];
 		n?.shellRoutes && r.push(...n.shellRoutes());
@@ -73,8 +20,8 @@ function _(e, t, n) {
 			if (!e) throw Error(`[@react-router-modules/runtime] Module "${t.id}" createRoutes() returned a falsy value.`);
 			i.push(...Array.isArray(e) ? e : [e]);
 		}
-		for (let e of t) i.push(y(e));
-		return n?.authenticatedRoute ? r.push(v(n.authenticatedRoute, i)) : r.push(...i), n.rootRoute.children = r, [n.rootRoute];
+		for (let e of t) i.push(V(e));
+		return n?.authenticatedRoute ? r.push(B(n.authenticatedRoute, i)) : r.push(...i), n.rootRoute.children = r, [n.rootRoute];
 	}
 	let r = [];
 	n?.shellRoutes && r.push(...n.shellRoutes());
@@ -89,8 +36,8 @@ function _(e, t, n) {
 		if (!e) throw Error(`[@react-router-modules/runtime] Module "${t.id}" createRoutes() returned a falsy value.`);
 		i.push(...Array.isArray(e) ? e : [e]);
 	}
-	for (let e of t) i.push(y(e));
-	return n?.authenticatedRoute ? r.push(v(n.authenticatedRoute, i)) : r.push(...i), n?.notFoundComponent && r.push({
+	for (let e of t) i.push(V(e));
+	return n?.authenticatedRoute ? r.push(B(n.authenticatedRoute, i)) : r.push(...i), n?.notFoundComponent && r.push({
 		path: "*",
 		Component: n.notFoundComponent
 	}), [{
@@ -100,15 +47,15 @@ function _(e, t, n) {
 		children: r
 	}];
 }
-function v(t, n) {
+function B(t, n) {
 	return {
 		id: "_authenticated",
-		Component: t.Component ?? (() => /* @__PURE__ */ o(e, {})),
+		Component: t.Component ?? (() => /* @__PURE__ */ I(e, {})),
 		loader: t.loader,
 		children: n
 	};
 }
-function y(e) {
+function V(e) {
 	let t = null;
 	return {
 		path: e.basePath.replace(/^\//, "") + "/*",
@@ -128,64 +75,52 @@ function y(e) {
 	};
 }
 //#endregion
-//#region src/navigation-context.tsx
-var b = l(null);
-function x() {
-	let e = u(b);
-	if (!e) throw Error("[@react-router-modules/runtime] useNavigation must be used within a <ReactiveApp />.");
-	return e;
-}
-//#endregion
-//#region src/slots-context.tsx
-var S = l(null);
-function C() {
-	let e = u(S);
-	if (!e) throw Error("[@react-router-modules/runtime] useSlots must be used within a <ReactiveApp />.");
-	return e;
-}
-//#endregion
-//#region src/modules-context.ts
-var w = l(null);
-function T() {
-	let e = u(w);
-	if (!e) throw Error("[@react-router-modules/runtime] useModules must be used within a <ReactiveApp />.");
-	return e;
-}
-function E(e) {
-	return e.meta;
-}
-//#endregion
 //#region src/app.tsx
-function D({ router: e, stores: n, services: r, reactiveServices: i, navigation: a, slots: s, modules: c, providers: l }) {
-	let u = {
+function H({ router: e, stores: n, services: r, reactiveServices: i, navigation: a, slots: o, modules: s, providers: c, dynamicSlotFactories: l, slotFilter: u, slotsSignal: d, recalculateSlots: f }) {
+	let p = {
 		stores: n,
 		services: r,
 		reactiveServices: i
-	};
-	function p() {
-		return d(() => {
-			let n = /* @__PURE__ */ o(f, {
-				value: u,
-				children: /* @__PURE__ */ o(b, {
+	}, m = l.length > 0 || u != null;
+	function h() {
+		return L(() => {
+			let h = /* @__PURE__ */ I(R, {
+				value: p,
+				children: /* @__PURE__ */ I(C, {
 					value: a,
-					children: /* @__PURE__ */ o(S, {
-						value: s,
-						children: /* @__PURE__ */ o(w, {
-							value: c,
-							children: /* @__PURE__ */ o(t, { router: e })
+					children: /* @__PURE__ */ I(T, {
+						value: f,
+						children: m ? /* @__PURE__ */ I(v, {
+							baseSlots: o,
+							factories: l,
+							filter: u,
+							stores: n,
+							services: r,
+							reactiveServices: i,
+							signal: d,
+							children: /* @__PURE__ */ I(x, {
+								value: s,
+								children: /* @__PURE__ */ I(t, { router: e })
+							})
+						}) : /* @__PURE__ */ I(D, {
+							value: o,
+							children: /* @__PURE__ */ I(x, {
+								value: s,
+								children: /* @__PURE__ */ I(t, { router: e })
+							})
 						})
 					})
 				})
 			});
-			if (l) for (let e of [...l].reverse()) n = /* @__PURE__ */ o(e, { children: n });
-			return n;
+			if (c) for (let e of [...c].reverse()) h = /* @__PURE__ */ I(e, { children: h });
+			return h;
 		}, []);
 	}
-	return p.displayName = "ReactiveApp", p;
+	return h.displayName = "ModularApp", h;
 }
 //#endregion
 //#region src/registry.ts
-function O(e) {
+function U(e) {
 	let t = [], i = [], a = !1, o = new Set([
 		...Object.keys(e.stores ?? {}),
 		...Object.keys(e.services ?? {}),
@@ -200,53 +135,59 @@ function O(e) {
 			if (a) throw Error("[@react-router-modules/runtime] Cannot register modules after resolve() has been called.");
 			i.push(e);
 		},
-		resolve(s) {
+		resolve(c) {
 			if (a) throw Error("[@react-router-modules/runtime] resolve() can only be called once.");
-			a = !0, p(t, i), m(t, o);
-			let c = k(e);
+			a = !0, g(t, i), m(t, o);
+			let u = W(e);
 			for (let e of t) try {
-				e.lifecycle?.onRegister?.(c);
+				e.lifecycle?.onRegister?.(u);
 			} catch (t) {
 				throw Error(`[@react-router-modules/runtime] Module "${e.id}" lifecycle.onRegister() failed: ${t instanceof Error ? t.message : String(t)}`, { cause: t });
 			}
-			let l = _(t, i, {
-				rootRoute: s?.rootRoute,
-				rootComponent: s?.rootComponent,
-				indexComponent: s?.indexComponent,
-				notFoundComponent: s?.notFoundComponent,
-				loader: s?.loader,
-				authenticatedRoute: s?.authenticatedRoute,
-				shellRoutes: s?.shellRoutes
-			}), u = typeof document < "u" ? n(l) : r(l), d = h(t), f = g(t, e.slots), v = t.map((e) => ({
+			let f = z(t, i, {
+				rootRoute: c?.rootRoute,
+				rootComponent: c?.rootComponent,
+				indexComponent: c?.indexComponent,
+				notFoundComponent: c?.notFoundComponent,
+				loader: c?.loader,
+				authenticatedRoute: c?.authenticatedRoute,
+				shellRoutes: c?.shellRoutes
+			}), p = typeof document < "u" ? n(f) : r(f), h = s(t), _ = l(t, e.slots), v = d(t), y = c?.slotFilter, b = t.map((e) => ({
 				id: e.id,
 				version: e.version,
 				meta: e.meta,
 				component: e.component,
 				zones: e.zones
-			})), y = {}, b = {}, x = {};
-			if (e.stores) for (let [t, n] of Object.entries(e.stores)) n && (y[t] = n);
-			if (e.services) for (let [t, n] of Object.entries(e.services)) n !== void 0 && (b[t] = n);
-			if (e.reactiveServices) for (let [t, n] of Object.entries(e.reactiveServices)) n && (x[t] = n);
+			})), x = {}, S = {}, C = {};
+			if (e.stores) for (let [t, n] of Object.entries(e.stores)) n && (x[t] = n);
+			if (e.services) for (let [t, n] of Object.entries(e.services)) n !== void 0 && (S[t] = n);
+			if (e.reactiveServices) for (let [t, n] of Object.entries(e.reactiveServices)) n && (C[t] = n);
+			let w = k(), T = v.length > 0 || y != null ? () => w.notify() : () => {};
 			return {
-				App: D({
-					router: u,
-					stores: y,
-					services: b,
-					reactiveServices: x,
-					navigation: d,
-					slots: f,
-					modules: v,
-					providers: s?.providers
+				App: H({
+					router: p,
+					stores: x,
+					services: S,
+					reactiveServices: C,
+					navigation: h,
+					slots: _,
+					modules: b,
+					providers: c?.providers,
+					dynamicSlotFactories: v,
+					slotFilter: y,
+					slotsSignal: w,
+					recalculateSlots: T
 				}),
-				router: u,
-				navigation: d,
-				slots: f,
-				modules: v
+				router: p,
+				navigation: h,
+				slots: _,
+				modules: b,
+				recalculateSlots: T
 			};
 		}
 	};
 }
-function k(e) {
+function W(e) {
 	let t = {};
 	if (e.stores) for (let [n, r] of Object.entries(e.stores)) r && (t[n] = r.getState());
 	if (e.services) for (let [n, r] of Object.entries(e.services)) r !== void 0 && (t[n] = r);
@@ -255,7 +196,7 @@ function k(e) {
 }
 //#endregion
 //#region src/zones.ts
-function A() {
+function G() {
 	let e = i(), t = {};
 	for (let n of e) {
 		let e = n.handle;
@@ -265,8 +206,8 @@ function A() {
 }
 //#endregion
 //#region src/active-zones.ts
-function j(e) {
-	let t = A(), n = T();
+function K(e) {
+	let t = G(), n = M();
 	if (!e) return t;
 	let r = n.find((t) => t.id === e);
 	return r?.zones ? {
@@ -275,51 +216,6 @@ function j(e) {
 	} : t;
 }
 //#endregion
-//#region src/error-boundary.tsx
-var M = class extends c {
-	state = {
-		hasError: !1,
-		error: null
-	};
-	static getDerivedStateFromError(e) {
-		return {
-			hasError: !0,
-			error: e
-		};
-	}
-	componentDidCatch(e, t) {
-		console.error(`[@react-router-modules/runtime] Module "${this.props.moduleId}" encountered an error:`, e, t);
-	}
-	render() {
-		return this.state.hasError ? this.props.fallback ? this.props.fallback : /* @__PURE__ */ s("div", {
-			style: {
-				padding: "1rem",
-				border: "1px solid #e53e3e",
-				borderRadius: "0.5rem",
-				margin: "1rem"
-			},
-			children: [/* @__PURE__ */ s("h3", {
-				style: {
-					color: "#e53e3e",
-					margin: "0 0 0.5rem 0"
-				},
-				children: [
-					"Module \"",
-					this.props.moduleId,
-					"\" encountered an error"
-				]
-			}), /* @__PURE__ */ o("pre", {
-				style: {
-					fontSize: "0.875rem",
-					color: "#718096",
-					whiteSpace: "pre-wrap"
-				},
-				children: this.state.error?.message
-			})]
-		}) : this.props.children;
-	}
-};
-//#endregion
-export { M as ModuleErrorBoundary, w as ModulesContext, S as SlotsContext, g as buildSlotsManifest, O as createRegistry, E as getModuleMeta, j as useActiveZones, T as useModules, x as useNavigation, C as useSlots, A as useZones };
+export { _ as DynamicSlotsProvider, y as ModuleErrorBoundary, b as ModulesContext, S as NavigationContext, w as RecalculateSlotsContext, E as SlotsContext, o as buildNavigationManifest, c as buildSlotsManifest, u as collectDynamicSlotFactories, U as createRegistry, O as createSlotsSignal, f as evaluateDynamicSlots, A as getModuleMeta, K as useActiveZones, j as useModules, N as useNavigation, P as useRecalculateSlots, F as useSlots, G as useZones, p as validateDependencies, h as validateNoDuplicateIds };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.js","names":[],"sources":["../src/validation.ts","../src/navigation.ts","../src/slots.ts","../src/route-builder.tsx","../src/navigation-context.tsx","../src/slots-context.tsx","../src/modules-context.ts","../src/app.tsx","../src/registry.ts","../src/zones.ts","../src/active-zones.ts","../src/error-boundary.tsx"],"sourcesContent":["import type { ReactiveModuleDescriptor, LazyModuleDescriptor } from \"@react-router-modules/core\";\r\n\r\nexport function validateNoDuplicateIds(\r\n modules: ReactiveModuleDescriptor[],\r\n lazyModules: LazyModuleDescriptor[],\r\n): void {\r\n const ids = new Set<string>();\r\n for (const mod of modules) {\r\n if (ids.has(mod.id)) {\r\n throw new Error(\r\n `[@react-router-modules/runtime] Duplicate module ID \"${mod.id}\". Each module must have a unique ID.`,\r\n );\r\n }\r\n ids.add(mod.id);\r\n }\r\n for (const mod of lazyModules) {\r\n if (ids.has(mod.id)) {\r\n throw new Error(\r\n `[@react-router-modules/runtime] Duplicate module ID \"${mod.id}\". Each module must have a unique ID.`,\r\n );\r\n }\r\n ids.add(mod.id);\r\n }\r\n}\r\n\r\nexport function validateDependencies(\r\n modules: ReactiveModuleDescriptor[],\r\n availableKeys: Set<string>,\r\n): void {\r\n for (const mod of modules) {\r\n if (mod.requires) {\r\n const missing = mod.requires.filter((key) => !availableKeys.has(key as string));\r\n if (missing.length > 0) {\r\n throw new Error(\r\n `[@react-router-modules/runtime] Module \"${mod.id}\" requires dependencies not provided by the registry: ` +\r\n `${missing.map(String).join(\", \")}. ` +\r\n `Available: ${[...availableKeys].join(\", \") \|\| \"(none)\"}`,\r\n );\r\n }\r\n }\r\n\r\n if (mod.optionalRequires) {\r\n const missing = mod.optionalRequires.filter((key) => !availableKeys.has(key as string));\r\n if (missing.length > 0) {\r\n console.warn(\r\n `[@react-router-modules/runtime] Module \"${mod.id}\" has optional dependencies not provided: ` +\r\n `${missing.map(String).join(\", \")}. The module will still load but may have reduced functionality.`,\r\n );\r\n }\r\n }\r\n }\r\n}\r\n","import type { ReactiveModuleDescriptor, NavigationItem } from \"@react-router-modules/core\";\r\nimport type { NavigationManifest, NavigationGroup } from \"./types.js\";\r\n\r\nexport function buildNavigationManifest(modules: ReactiveModuleDescriptor[]): NavigationManifest {\r\n const allItems: NavigationItem[] = [];\r\n\r\n for (const mod of modules) {\r\n if (mod.navigation) {\r\n allItems.push(...mod.navigation);\r\n }\r\n }\r\n\r\n // Sort by order (lower first), then by label alphabetically\r\n const sorted = [...allItems].sort((a, b) => {\r\n const orderDiff = (a.order ?? 999) - (b.order ?? 999);\r\n if (orderDiff !== 0) return orderDiff;\r\n return a.label.localeCompare(b.label);\r\n });\r\n\r\n // Group items\r\n const groupMap = new Map<string, NavigationItem[]>();\r\n const ungrouped: NavigationItem[] = [];\r\n\r\n for (const item of sorted) {\r\n if (item.group) {\r\n let group = groupMap.get(item.group);\r\n if (!group) {\r\n group = [];\r\n groupMap.set(item.group, group);\r\n }\r\n group.push(item);\r\n } else {\r\n ungrouped.push(item);\r\n }\r\n }\r\n\r\n const groups: NavigationGroup[] = [...groupMap.entries()].map(([group, items]) => ({\r\n group,\r\n items,\r\n }));\r\n\r\n return { items: sorted, groups, ungrouped };\r\n}\r\n","import type { ReactiveModuleDescriptor } from \"@react-router-modules/core\";\r\n\r\n/*\r\n Collects slot contributions from all registered modules.\r\n * Arrays are concatenated per slot key across modules.\r\n \r\n When defaults are provided, every key in defaults is guaranteed to exist\r\n * in the result — even if no module contributes to it.\r\n /\r\nexport function buildSlotsManifest<TSlots extends { [K in keyof TSlots]: readonly unknown[] }>(\r\n modules: readonly ReactiveModuleDescriptor<any, TSlots>[],\r\n defaults?: Partial<{ [K in keyof TSlots]: TSlots[K] }>,\r\n): TSlots {\r\n const result: Record<string, unknown[]> = {};\r\n\r\n // Initialize from defaults so every declared key exists\r\n if (defaults) {\r\n for (const [key, items] of Object.entries(defaults)) {\r\n result[key] = Array.isArray(items) ? [...items] : [];\r\n }\r\n }\r\n\r\n for (const mod of modules) {\r\n if (!mod.slots) continue;\r\n for (const [key, items] of Object.entries(mod.slots)) {\r\n if (!result[key]) result[key] = [];\r\n if (Array.isArray(items)) {\r\n result[key].push(...items);\r\n }\r\n }\r\n }\r\n\r\n return result as unknown as TSlots;\r\n}\r\n","import { Outlet, useRoutes } from \"react-router\";\r\nimport type { RouteObject } from \"react-router\";\r\nimport type { ReactiveModuleDescriptor, LazyModuleDescriptor } from \"@react-router-modules/core\";\r\n\r\nexport interface RouteBuilderOptions {\r\n /\r\n Pre-built root route. If provided, rootComponent/notFoundComponent/loader\r\n * are ignored — configure them directly on this route instead.\r\n /\r\n rootRoute?: RouteObject;\r\n /* Component for the root layout (renders <Outlet /> for child routes) /\r\n rootComponent?: () => React.JSX.Element;\r\n /* Component for the index route (/) /\r\n indexComponent?: () => React.JSX.Element;\r\n /* Component for the 404 / not-found route /\r\n notFoundComponent?: () => React.JSX.Element;\r\n /\r\n Called before every route loads — for observability, feature flags, etc.\r\n * Runs for ALL routes including public ones.\r\n * Ignored if rootRoute is provided.\r\n /\r\n loader?: (args: { request: Request; params: Record<string, string \| undefined> }) => any;\r\n /\r\n Auth boundary — a pathless layout route that wraps module routes and\r\n * the index route. Shell routes (login, error pages) sit outside this\r\n * boundary and are NOT guarded.\r\n \r\n Follows React Router's recommended layout route pattern.\r\n \r\n When provided, the route tree becomes:\r\n * ```\r\n * Root (loader runs for ALL routes)\r\n * ├── shellRoutes (public — /login, /signup, etc.)\r\n * └── _authenticated (layout — loader guards children)\r\n * ├── / (indexComponent)\r\n * └── module routes\r\n * ```\r\n \r\n When omitted, all routes are direct children of root (no auth boundary).\r\n /\r\n authenticatedRoute?: {\r\n /* Auth guard — throw redirect() to deny access /\r\n loader: (args: { request: Request; params: Record<string, string \| undefined> }) => any;\r\n /* Layout component for authenticated pages. Defaults to <Outlet />. /\r\n Component?: () => React.JSX.Element;\r\n };\r\n /* Additional routes owned by the shell (login, error pages, etc.) /\r\n shellRoutes?: () => RouteObject[];\r\n}\r\n\r\n/\r\n Composes all module route subtrees into a React Router route tree.\r\n * Modules without createRoutes are skipped (headless modules).\r\n /\r\nexport function buildRouteTree(\r\n modules: ReactiveModuleDescriptor[],\r\n lazyModules: LazyModuleDescriptor[],\r\n options?: RouteBuilderOptions,\r\n): RouteObject[] {\r\n // If a custom root route is provided, use it as the base\r\n if (options?.rootRoute) {\r\n const rootChildren: RouteObject[] = [...(options.rootRoute.children ?? [])];\r\n\r\n // Shell-owned routes (login, error pages) — always direct children of root\r\n if (options?.shellRoutes) {\r\n rootChildren.push(...options.shellRoutes());\r\n }\r\n\r\n const protectedChildren: RouteObject[] = [];\r\n\r\n // Add index route if provided\r\n if (options?.indexComponent) {\r\n protectedChildren.push({\r\n index: true,\r\n Component: options.indexComponent,\r\n });\r\n }\r\n\r\n // Eager modules\r\n for (const mod of modules) {\r\n if (!mod.createRoutes) continue;\r\n const routes = mod.createRoutes();\r\n if (!routes) {\r\n throw new Error(\r\n `[@react-router-modules/runtime] Module \"${mod.id}\" createRoutes() returned a falsy value.`,\r\n );\r\n }\r\n protectedChildren.push(...(Array.isArray(routes) ? routes : [routes]));\r\n }\r\n\r\n // Lazy modules\r\n for (const lazyMod of lazyModules) {\r\n protectedChildren.push(createLazyModuleRoute(lazyMod));\r\n }\r\n\r\n if (options?.authenticatedRoute) {\r\n rootChildren.push(\r\n createAuthenticatedLayoutRoute(options.authenticatedRoute, protectedChildren),\r\n );\r\n } else {\r\n rootChildren.push(...protectedChildren);\r\n }\r\n\r\n options.rootRoute.children = rootChildren;\r\n return [options.rootRoute];\r\n }\r\n\r\n // Build root route from options\r\n const rootChildren: RouteObject[] = [];\r\n\r\n // Shell-owned routes (login, error pages) — always direct children of root\r\n if (options?.shellRoutes) {\r\n rootChildren.push(...options.shellRoutes());\r\n }\r\n\r\n const protectedChildren: RouteObject[] = [];\r\n\r\n // Add index route if provided\r\n if (options?.indexComponent) {\r\n protectedChildren.push({\r\n index: true,\r\n Component: options.indexComponent,\r\n });\r\n }\r\n\r\n // Eager modules: call createRoutes\r\n for (const mod of modules) {\r\n if (!mod.createRoutes) continue;\r\n const routes = mod.createRoutes();\r\n if (!routes) {\r\n throw new Error(\r\n `[@react-router-modules/runtime] Module \"${mod.id}\" createRoutes() returned a falsy value.`,\r\n );\r\n }\r\n protectedChildren.push(...(Array.isArray(routes) ? routes : [routes]));\r\n }\r\n\r\n // Lazy modules\r\n for (const lazyMod of lazyModules) {\r\n protectedChildren.push(createLazyModuleRoute(lazyMod));\r\n }\r\n\r\n if (options?.authenticatedRoute) {\r\n rootChildren.push(\r\n createAuthenticatedLayoutRoute(options.authenticatedRoute, protectedChildren),\r\n );\r\n } else {\r\n rootChildren.push(...protectedChildren);\r\n }\r\n\r\n // Not-found catch-all\r\n if (options?.notFoundComponent) {\r\n rootChildren.push({\r\n path: \"\",\r\n Component: options.notFoundComponent,\r\n });\r\n }\r\n\r\n const rootRoute: RouteObject = {\r\n path: \"/\",\r\n Component: options?.rootComponent,\r\n loader: options?.loader,\r\n children: rootChildren,\r\n };\r\n\r\n return [rootRoute];\r\n}\r\n\r\nfunction createAuthenticatedLayoutRoute(\r\n auth: NonNullable<RouteBuilderOptions[\"authenticatedRoute\"]>,\r\n children: RouteObject[],\r\n): RouteObject {\r\n return {\r\n id: \"_authenticated\",\r\n Component: auth.Component ?? (() => <Outlet />),\r\n loader: auth.loader,\r\n children,\r\n };\r\n}\r\n\r\n/*\r\n Creates a catch-all route for a lazily-loaded module.\r\n * On first navigation, the module descriptor is loaded and its routes\r\n * are rendered as descendant routes via useRoutes().\r\n /\r\nfunction createLazyModuleRoute(lazyMod: LazyModuleDescriptor): RouteObject {\r\n // Capture the loaded routes so they're resolved only once\r\n let cachedRoutes: RouteObject[] \| null = null;\r\n\r\n return {\r\n path: lazyMod.basePath.replace(/^\\//, \"\") + \"/\",\r\n lazy: async () => {\r\n if (!cachedRoutes) {\r\n const { default: descriptor } = await lazyMod.load();\r\n if (descriptor.createRoutes) {\r\n const routes = descriptor.createRoutes();\r\n cachedRoutes = Array.isArray(routes) ? routes : [routes];\r\n } else {\r\n cachedRoutes = [];\r\n }\r\n }\r\n const routes = cachedRoutes;\r\n return {\r\n Component: function LazyModule() {\r\n return useRoutes(routes);\r\n },\r\n };\r\n },\r\n };\r\n}\r\n","import { createContext, useContext } from \"react\";\r\nimport type { NavigationManifest } from \"./types.js\";\r\n\r\nexport const NavigationContext = createContext<NavigationManifest \| null>(null);\r\n\r\n/*\r\n Access the auto-generated navigation manifest from registered modules.\r\n * Use this in layout components to render sidebar/nav items.\r\n /\r\nexport function useNavigation(): NavigationManifest {\r\n const nav = useContext(NavigationContext);\r\n if (!nav) {\r\n throw new Error(\r\n \"[@react-router-modules/runtime] useNavigation must be used within a <ReactiveApp />.\",\r\n );\r\n }\r\n return nav;\r\n}\r\n","import { createContext, useContext } from \"react\";\r\n\r\nexport const SlotsContext = createContext<object \| null>(null);\r\n\r\n/\r\n Access the collected slot contributions from all registered modules.\r\n * Must be used within a <ReactiveApp /> provider tree.\r\n \r\n @example\r\n * const slots = useSlots<AppSlots>()\r\n * const commands = slots.commands // CommandDefinition[] from all modules\r\n /\r\nexport function useSlots<TSlots extends { [K in keyof TSlots]: readonly unknown[] }>(): TSlots {\r\n const slots = useContext(SlotsContext);\r\n if (!slots) {\r\n throw new Error(\r\n \"[@react-router-modules/runtime] useSlots must be used within a <ReactiveApp />.\",\r\n );\r\n }\r\n return slots as TSlots;\r\n}\r\n","import { createContext, useContext } from \"react\";\r\nimport type { ModuleEntry } from \"./types.js\";\r\n\r\nexport const ModulesContext = createContext<readonly ModuleEntry[] \| null>(null);\r\n\r\n/\r\n Access the list of registered modules with their metadata and components.\r\n * Must be used within a <ReactiveApp /> provider tree.\r\n \r\n Use this to build discovery UIs (directory pages, search, catalogs)\r\n * and to render module components in workspace tabs or panels.\r\n \r\n @example\r\n * const modules = useModules()\r\n * const journeys = modules.filter(m => m.meta?.category === 'payments')\r\n \r\n @example\r\n * const mod = modules.find(m => m.id === activeTab.moduleId)\r\n * if (mod?.component) return <mod.component {...props} />\r\n /\r\nexport function useModules(): readonly ModuleEntry[] {\r\n const modules = useContext(ModulesContext);\r\n if (!modules) {\r\n throw new Error(\r\n \"[@react-router-modules/runtime] useModules must be used within a <ReactiveApp />.\",\r\n );\r\n }\r\n return modules;\r\n}\r\n\r\n/\r\n Type-safe accessor for module metadata.\r\n * Use this when the shell defines a known meta shape and wants to read it\r\n * without casting every field.\r\n \r\n Returns undefined if the module has no meta.\r\n \r\n @example\r\n * interface JourneyMeta { name: string; category: string; icon: string }\r\n * const meta = getModuleMeta<JourneyMeta>(mod)\r\n * if (meta) console.log(meta.name) // typed, no cast\r\n /\r\nexport function getModuleMeta<TMeta extends { [K in keyof TMeta]: unknown }>(\r\n entry: ModuleEntry,\r\n): Readonly<TMeta> \| undefined {\r\n return entry.meta as Readonly<TMeta> \| undefined;\r\n}\r\n","import { useMemo } from \"react\";\r\nimport { RouterProvider } from \"react-router\";\r\nimport type { DataRouter } from \"react-router\";\r\nimport type { StoreApi } from \"zustand\";\r\nimport type { ReactiveService } from \"@react-router-modules/core\";\r\nimport { SharedDependenciesContext } from \"@react-router-modules/core\";\r\nimport { NavigationContext } from \"./navigation-context.js\";\r\nimport { SlotsContext } from \"./slots-context.js\";\r\nimport { ModulesContext } from \"./modules-context.js\";\r\nimport type { NavigationManifest, ModuleEntry } from \"./types.js\";\r\n\r\ninterface AppProps {\r\n router: DataRouter;\r\n stores: Record<string, StoreApi<unknown>>;\r\n services: Record<string, unknown>;\r\n reactiveServices: Record<string, ReactiveService<unknown>>;\r\n navigation: NavigationManifest;\r\n slots: object;\r\n modules: readonly ModuleEntry[];\r\n providers?: React.ComponentType<{ children: React.ReactNode }>[];\r\n}\r\n\r\nexport function createAppComponent({\r\n router,\r\n stores,\r\n services,\r\n reactiveServices,\r\n navigation,\r\n slots,\r\n modules,\r\n providers,\r\n}: AppProps) {\r\n // All values captured in closure are stable references created once at resolve() time.\r\n // Wrap in a stable object so context consumers don't re-render on parent renders.\r\n const depsValue = { stores, services, reactiveServices };\r\n\r\n function App() {\r\n const tree = useMemo(() => {\r\n let node: React.ReactNode = (\r\n <SharedDependenciesContext value={depsValue}>\r\n <NavigationContext value={navigation}>\r\n <SlotsContext value={slots}>\r\n <ModulesContext value={modules}>\r\n <RouterProvider router={router} />\r\n </ModulesContext>\r\n </SlotsContext>\r\n </NavigationContext>\r\n </SharedDependenciesContext>\r\n );\r\n\r\n // Wrap with user-supplied providers (first element = outermost wrapper)\r\n if (providers) {\r\n for (const Provider of [...providers].reverse()) {\r\n node = <Provider>{node}</Provider>;\r\n }\r\n }\r\n\r\n return node;\r\n }, []);\r\n\r\n return tree;\r\n }\r\n\r\n App.displayName = \"ReactiveApp\";\r\n return App;\r\n}\r\n","import { createBrowserRouter, createMemoryRouter } from \"react-router\";\r\nimport type { RouteObject } from \"react-router\";\r\nimport type { StoreApi } from \"zustand\";\r\nimport type {\r\n ReactiveModuleDescriptor,\r\n LazyModuleDescriptor,\r\n ReactiveService,\r\n SlotMap,\r\n SlotMapOf,\r\n} from \"@react-router-modules/core\";\r\n\r\nimport type {\r\n RegistryConfig,\r\n ApplicationManifest,\r\n NavigationManifest,\r\n ModuleEntry,\r\n} from \"./types.js\";\r\nimport { validateNoDuplicateIds, validateDependencies } from \"./validation.js\";\r\nimport { buildNavigationManifest } from \"./navigation.js\";\r\nimport { buildSlotsManifest } from \"./slots.js\";\r\nimport { buildRouteTree, type RouteBuilderOptions } from \"./route-builder.js\";\r\nimport { createAppComponent } from \"./app.js\";\r\n\r\nexport interface ReactiveRegistry<\r\n TSharedDependencies extends Record<string, any>,\r\n TSlots extends SlotMapOf<TSlots> = SlotMap,\r\n> {\r\n /* Register an eager module /\r\n register(module: ReactiveModuleDescriptor<TSharedDependencies, TSlots>): void;\r\n\r\n /* Register a lazily-loaded module /\r\n registerLazy(descriptor: LazyModuleDescriptor<TSharedDependencies, TSlots>): void;\r\n\r\n /\r\n Resolve all modules and produce the application manifest.\r\n * Validates dependencies and builds the route tree.\r\n /\r\n resolve(options?: ResolveOptions): ApplicationManifest<TSlots>;\r\n}\r\n\r\nexport interface ResolveOptions {\r\n /* Root layout component (renders <Outlet /> for child routes) /\r\n rootComponent?: () => React.JSX.Element;\r\n\r\n /\r\n Pre-built root route — if provided, used instead of auto-creating one.\r\n * Use this when you need full control over the root route config\r\n * (loader, errorElement, etc.).\r\n * Mutually exclusive with rootComponent/notFoundComponent/loader.\r\n /\r\n rootRoute?: RouteObject;\r\n\r\n /* Component for the index route (/) /\r\n indexComponent?: () => React.JSX.Element;\r\n\r\n /* Component for 404 / not-found /\r\n notFoundComponent?: () => React.JSX.Element;\r\n\r\n /\r\n Called before every route loads — for observability, analytics, feature flags.\r\n * Runs for ALL routes including public ones like /login.\r\n * Throw a `redirect()` from react-router to redirect.\r\n * Ignored if rootRoute is provided (configure loader on your root route instead).\r\n \r\n For auth guards, use `authenticatedRoute` instead — it creates a layout route\r\n * boundary that only wraps protected routes.\r\n /\r\n loader?: (args: { request: Request; params: Record<string, string \| undefined> }) => any;\r\n\r\n /\r\n Auth boundary — a pathless layout route that guards module routes and\r\n * the index route. Shell routes (login, error pages) sit outside this\r\n * boundary and are NOT guarded.\r\n \r\n Follows React Router's recommended layout route pattern:\r\n * ```\r\n * Root (loader runs for ALL routes — observability, etc.)\r\n * ├── shellRoutes (public — /login, /signup)\r\n * └── _authenticated (layout — auth guard)\r\n * ├── / (indexComponent)\r\n * └── module routes\r\n * ```\r\n \r\n @example\r\n * ```ts\r\n * registry.resolve({\r\n * authenticatedRoute: {\r\n * loader: async () => {\r\n * const res = await fetch('/api/auth/session')\r\n * if (!res.ok) throw redirect('/login')\r\n * return null\r\n * },\r\n * Component: ShellLayout,\r\n * },\r\n * shellRoutes: () => [\r\n * { path: '/login', Component: LoginPage },\r\n * ],\r\n * })\r\n * ```\r\n /\r\n authenticatedRoute?: {\r\n /* Auth guard — throw redirect() to deny access /\r\n loader: (args: { request: Request; params: Record<string, string \| undefined> }) => any;\r\n /* Layout component for authenticated pages. Defaults to <Outlet />. /\r\n Component?: () => React.JSX.Element;\r\n };\r\n\r\n /\r\n Additional routes owned by the shell (login, error pages, onboarding, etc.)\r\n * that sit alongside module routes at the root level.\r\n \r\n When `authenticatedRoute` is used, shell routes are NOT guarded — they\r\n * are siblings of the auth layout, not children. This is the natural place\r\n * for public pages like /login.\r\n /\r\n shellRoutes?: () => RouteObject[];\r\n\r\n /\r\n Additional React providers to wrap around the app tree.\r\n \r\n Nesting order: First element is outermost. `[A, B, C]` produces:\r\n * ```tsx\r\n * <A>\r\n * <B>\r\n * <C>\r\n * ...app...\r\n * </C>\r\n * </B>\r\n * </A>\r\n * ```\r\n \r\n Place providers that other providers depend on first in the array.\r\n * For example, if your data-fetching provider reads from a theme context,\r\n * list the theme provider before the data-fetching provider.\r\n \r\n @example\r\n * ```ts\r\n * providers: [SWRConfigProvider, ThemeProvider, TooltipProvider]\r\n * // Produces: <SWRConfigProvider><ThemeProvider><TooltipProvider>...app...</TooltipProvider></ThemeProvider></SWRConfigProvider>\r\n * ```\r\n /\r\n providers?: React.ComponentType<{ children: React.ReactNode }>[];\r\n}\r\n\r\nexport function createRegistry<\r\n TSharedDependencies extends Record<string, any>,\r\n TSlots extends SlotMapOf<TSlots> = SlotMap,\r\n>(\r\n config: RegistryConfig<TSharedDependencies, TSlots>,\r\n): ReactiveRegistry<TSharedDependencies, TSlots> {\r\n const modules: ReactiveModuleDescriptor<TSharedDependencies, TSlots>[] = [];\r\n const lazyModules: LazyModuleDescriptor<TSharedDependencies, TSlots>[] = [];\r\n let resolved = false;\r\n\r\n // Collect all available dependency keys from all three buckets\r\n const availableKeys = new Set<string>([\r\n ...Object.keys(config.stores ?? {}),\r\n ...Object.keys(config.services ?? {}),\r\n ...Object.keys(config.reactiveServices ?? {}),\r\n ]);\r\n\r\n return {\r\n register(module) {\r\n if (resolved) {\r\n throw new Error(\r\n \"[@react-router-modules/runtime] Cannot register modules after resolve() has been called.\",\r\n );\r\n }\r\n modules.push(module);\r\n },\r\n\r\n registerLazy(descriptor) {\r\n if (resolved) {\r\n throw new Error(\r\n \"[@react-router-modules/runtime] Cannot register modules after resolve() has been called.\",\r\n );\r\n }\r\n lazyModules.push(descriptor);\r\n },\r\n\r\n resolve(options?: ResolveOptions) {\r\n if (resolved) {\r\n throw new Error(\"[@react-router-modules/runtime] resolve() can only be called once.\");\r\n }\r\n resolved = true;\r\n\r\n // Validate — cast is safe since validation only reads structural properties (id, requires)\r\n validateNoDuplicateIds(\r\n modules as ReactiveModuleDescriptor[],\r\n lazyModules as LazyModuleDescriptor[],\r\n );\r\n validateDependencies(modules as ReactiveModuleDescriptor[], availableKeys);\r\n\r\n // Run onRegister lifecycle hooks\r\n const deps = buildDepsObject<TSharedDependencies>(config);\r\n for (const mod of modules) {\r\n try {\r\n mod.lifecycle?.onRegister?.(deps);\r\n } catch (err) {\r\n throw new Error(\r\n `[@react-router-modules/runtime] Module \"${mod.id}\" lifecycle.onRegister() failed: ${err instanceof Error ? err.message : String(err)}`,\r\n { cause: err },\r\n );\r\n }\r\n }\r\n\r\n // Build route tree\r\n const routeBuilderOptions: RouteBuilderOptions = {\r\n rootRoute: options?.rootRoute,\r\n rootComponent: options?.rootComponent,\r\n indexComponent: options?.indexComponent,\r\n notFoundComponent: options?.notFoundComponent,\r\n loader: options?.loader,\r\n authenticatedRoute: options?.authenticatedRoute,\r\n shellRoutes: options?.shellRoutes,\r\n };\r\n const routes = buildRouteTree(\r\n modules as ReactiveModuleDescriptor[],\r\n lazyModules as LazyModuleDescriptor[],\r\n routeBuilderOptions,\r\n );\r\n\r\n // Create React Router instance (use memory router when DOM is unavailable, e.g. tests)\r\n const router =\r\n typeof document !== \"undefined\" ? createBrowserRouter(routes) : createMemoryRouter(routes);\r\n\r\n // Build navigation, slots, and module entries\r\n const navigation: NavigationManifest = buildNavigationManifest(\r\n modules as ReactiveModuleDescriptor[],\r\n );\r\n const slots = buildSlotsManifest<TSlots>(modules, config.slots);\r\n const moduleEntries: ModuleEntry[] = modules.map((mod) => ({\r\n id: mod.id,\r\n version: mod.version,\r\n meta: mod.meta,\r\n component: mod.component,\r\n zones: mod.zones,\r\n }));\r\n\r\n // Build stores, services, and reactive services maps for the context\r\n const stores: Record<string, StoreApi<unknown>> = {};\r\n const services: Record<string, unknown> = {};\r\n const reactiveServices: Record<string, ReactiveService<unknown>> = {};\r\n\r\n if (config.stores) {\r\n for (const [key, store] of Object.entries(config.stores)) {\r\n if (store) stores[key] = store as StoreApi<unknown>;\r\n }\r\n }\r\n if (config.services) {\r\n for (const [key, service] of Object.entries(config.services)) {\r\n if (service !== undefined) services[key] = service;\r\n }\r\n }\r\n if (config.reactiveServices) {\r\n for (const [key, rs] of Object.entries(config.reactiveServices)) {\r\n if (rs) reactiveServices[key] = rs as ReactiveService<unknown>;\r\n }\r\n }\r\n\r\n // Create App component\r\n const App = createAppComponent({\r\n router,\r\n stores,\r\n services,\r\n reactiveServices,\r\n navigation,\r\n slots,\r\n modules: moduleEntries,\r\n providers: options?.providers,\r\n });\r\n\r\n return { App, router, navigation, slots, modules: moduleEntries };\r\n },\r\n };\r\n}\r\n\r\nfunction buildDepsObject<TSharedDependencies extends Record<string, any>>(\r\n config: RegistryConfig<TSharedDependencies, any>,\r\n): TSharedDependencies {\r\n const deps: Record<string, unknown> = {};\r\n\r\n // For stores, get current state as the deps value\r\n // (lifecycle hooks get a snapshot, components use useStore for reactivity)\r\n if (config.stores) {\r\n for (const [key, store] of Object.entries(config.stores)) {\r\n if (store) {\r\n deps[key] = (store as StoreApi<unknown>).getState();\r\n }\r\n }\r\n }\r\n if (config.services) {\r\n for (const [key, service] of Object.entries(config.services)) {\r\n if (service !== undefined) deps[key] = service;\r\n }\r\n }\r\n // For reactive services, get current snapshot\r\n if (config.reactiveServices) {\r\n for (const [key, rs] of Object.entries(config.reactiveServices)) {\r\n if (rs) {\r\n deps[key] = (rs as ReactiveService<unknown>).getSnapshot();\r\n }\r\n }\r\n }\r\n\r\n return deps as TSharedDependencies;\r\n}\r\n","import { useMatches } from \"react-router\";\r\nimport type { ZoneMapOf } from \"@react-router-modules/core\";\r\n\r\n/\r\n Read zone components contributed by the currently matched route hierarchy.\r\n \r\n Zones are set via React Router's `handle` on individual routes.\r\n * This hook walks all matched routes from root to leaf and returns a merged\r\n * map where the deepest match wins for each zone key.\r\n \r\n @example\r\n * // In the shell layout:\r\n * const zones = useZones<AppZones>()\r\n * const DetailPanel = zones.detailPanel\r\n \r\n return (\r\n * <div className=\"grid\">\r\n * <main><Outlet /></main>\r\n * <aside>{DetailPanel && <DetailPanel />}</aside>\r\n * </div>\r\n * )\r\n \r\n @example\r\n * // In a module's route definition:\r\n * {\r\n * path: ':userId',\r\n * Component: UserDetailPage,\r\n * handle: {\r\n * detailPanel: UserDetailSidebar,\r\n * },\r\n * }\r\n /\r\nexport function useZones<TZones extends ZoneMapOf<TZones>>(): Partial<TZones> {\r\n const matches = useMatches();\r\n const merged: Record<string, unknown> = {};\r\n for (const match of matches) {\r\n const data = (match as any).handle;\r\n if (data && typeof data === \"object\") {\r\n for (const [key, value] of Object.entries(data as Record<string, unknown>)) {\r\n if (value !== undefined) {\r\n merged[key] = value;\r\n }\r\n }\r\n }\r\n }\r\n return merged as Partial<TZones>;\r\n}\r\n","import type { ZoneMapOf } from \"@react-router-modules/core\";\r\nimport { useZones } from \"./zones.js\";\r\nimport { useModules } from \"./modules-context.js\";\r\n\r\n/\r\n Read zone components from both the matched route hierarchy AND the\r\n * currently active module (identified by `activeModuleId`).\r\n \r\n This unifies two zone contribution patterns:\r\n * - Route-based modules contribute zones via React Router's `handle`\r\n * - Tab-based modules contribute zones via the `zones` field on their descriptor\r\n \r\n When both sources provide a value for the same zone key, the module's\r\n * contribution wins — the assumption is that the active tab's content is more\r\n * relevant than the underlying route's.\r\n \r\n @param activeModuleId - The id of the module that is currently active in the\r\n * workspace (e.g. the journey tab's moduleId). Pass `null` or `undefined`\r\n * when no module tab is active — only route zones are returned.\r\n \r\n @example\r\n * // In the shell layout:\r\n * const activeTab = getActiveTab(interactionId)\r\n * const moduleId = activeTab?.type === 'native-journey' ? activeTab.journeyId : null\r\n * const zones = useActiveZones<AppZones>(moduleId)\r\n * const Panel = zones.contextualPanel\r\n \r\n return (\r\n * <aside>{Panel ? <Panel /> : <DefaultPanel />}</aside>\r\n * )\r\n */\r\nexport function useActiveZones<TZones extends ZoneMapOf<TZones>>(\r\n activeModuleId?: string \| null,\r\n): Partial<TZones> {\r\n const routeZones = useZones<TZones>();\r\n const modules = useModules();\r\n\r\n if (!activeModuleId) {\r\n return routeZones;\r\n }\r\n\r\n const activeMod = modules.find((m) => m.id === activeModuleId);\r\n if (!activeMod?.zones) {\r\n return routeZones;\r\n }\r\n\r\n // Module zones override route zones for the same key\r\n return { ...routeZones, ...activeMod.zones } as Partial<TZones>;\r\n}\r\n","import { Component } from \"react\";\r\nimport type { ErrorInfo, ReactNode } from \"react\";\r\n\r\ninterface Props {\r\n moduleId: string;\r\n fallback?: ReactNode;\r\n children: ReactNode;\r\n}\r\n\r\ninterface State {\r\n hasError: boolean;\r\n error: Error \| null;\r\n}\r\n\r\nexport class ModuleErrorBoundary extends Component<Props, State> {\r\n override state: State = { hasError: false, error: null };\r\n\r\n static getDerivedStateFromError(error: Error): State {\r\n return { hasError: true, error };\r\n }\r\n\r\n override componentDidCatch(error: Error, info: ErrorInfo) {\r\n console.error(\r\n `[@react-router-modules/runtime] Module \"${this.props.moduleId}\" encountered an error:`,\r\n error,\r\n info,\r\n );\r\n }\r\n\r\n override render() {\r\n if (this.state.hasError) {\r\n if (this.props.fallback) {\r\n return this.props.fallback;\r\n }\r\n return (\r\n <div\r\n style={{\r\n padding: \"1rem\",\r\n border: \"1px solid #e53e3e\",\r\n borderRadius: \"0.5rem\",\r\n margin: \"1rem\",\r\n }}\r\n >\r\n <h3 style={{ color: \"#e53e3e\", margin: \"0 0 0.5rem 0\" }}>\r\n Module "{this.props.moduleId}" encountered an error\r\n </h3>\r\n <pre style={{ fontSize: \"0.875rem\", color: \"#718096\", whiteSpace: \"pre-wrap\" }}>\r\n {this.state.error?.message}\r\n </pre>\r\n </div>\r\n );\r\n }\r\n return this.props.children;\r\n }\r\n}\r\n"],"mappings":";;;;;AAEA,SAAgB,EACd,GACA,GACM;CACN,IAAM,oBAAM,IAAI,KAAa;AAC7B,MAAK,IAAM,KAAO,GAAS;AACzB,MAAI,EAAI,IAAI,EAAI,GAAG,CACjB,OAAU,MACR,wDAAwD,EAAI,GAAG,uCAChE;AAEH,IAAI,IAAI,EAAI,GAAG;;AAEjB,MAAK,IAAM,KAAO,GAAa;AAC7B,MAAI,EAAI,IAAI,EAAI,GAAG,CACjB,OAAU,MACR,wDAAwD,EAAI,GAAG,uCAChE;AAEH,IAAI,IAAI,EAAI,GAAG;;;AAInB,SAAgB,EACd,GACA,GACM;AACN,MAAK,IAAM,KAAO,GAAS;AACzB,MAAI,EAAI,UAAU;GAChB,IAAM,IAAU,EAAI,SAAS,QAAQ,MAAQ,CAAC,EAAc,IAAI,EAAc,CAAC;AAC/E,OAAI,EAAQ,SAAS,EACnB,OAAU,MACR,2CAA2C,EAAI,GAAG,wDAC7C,EAAQ,IAAI,OAAO,CAAC,KAAK,KAAK,CAAC,eACpB,CAAC,GAAG,EAAc,CAAC,KAAK,KAAK,IAAI,WAClD;;AAIL,MAAI,EAAI,kBAAkB;GACxB,IAAM,IAAU,EAAI,iBAAiB,QAAQ,MAAQ,CAAC,EAAc,IAAI,EAAc,CAAC;AACvF,GAAI,EAAQ,SAAS,KACnB,QAAQ,KACN,2CAA2C,EAAI,GAAG,4CAC7C,EAAQ,IAAI,OAAO,CAAC,KAAK,KAAK,CAAC,kEACrC;;;;;;AC5CT,SAAgB,EAAwB,GAAyD;CAC/F,IAAM,IAA6B,EAAE;AAErC,MAAK,IAAM,KAAO,EAChB,CAAI,EAAI,cACN,EAAS,KAAK,GAAG,EAAI,WAAW;CAKpC,IAAM,IAAS,CAAC,GAAG,EAAS,CAAC,MAAM,GAAG,MAAM;EAC1C,IAAM,KAAa,EAAE,SAAS,QAAQ,EAAE,SAAS;AAEjD,SADI,MAAc,IACX,EAAE,MAAM,cAAc,EAAE,MAAM,GADT;GAE5B,EAGI,oBAAW,IAAI,KAA+B,EAC9C,IAA8B,EAAE;AAEtC,MAAK,IAAM,KAAQ,EACjB,KAAI,EAAK,OAAO;EACd,IAAI,IAAQ,EAAS,IAAI,EAAK,MAAM;AAKpC,EAJK,MACH,IAAQ,EAAE,EACV,EAAS,IAAI,EAAK,OAAO,EAAM,GAEjC,EAAM,KAAK,EAAK;OAEhB,GAAU,KAAK,EAAK;AASxB,QAAO;EAAE,OAAO;EAAQ,QALU,CAAC,GAAG,EAAS,SAAS,CAAC,CAAC,KAAK,CAAC,GAAO,QAAY;GACjF;GACA;GACD,EAAE;EAE6B;EAAW;;;;AChC7C,SAAgB,EACd,GACA,GACQ;CACR,IAAM,IAAoC,EAAE;AAG5C,KAAI,EACF,MAAK,IAAM,CAAC,GAAK,MAAU,OAAO,QAAQ,EAAS,CACjD,GAAO,KAAO,MAAM,QAAQ,EAAM,GAAG,CAAC,GAAG,EAAM,GAAG,EAAE;AAIxD,MAAK,IAAM,KAAO,EACX,OAAI,MACT,MAAK,IAAM,CAAC,GAAK,MAAU,OAAO,QAAQ,EAAI,MAAM,CAElD,CADK,EAAO,OAAM,EAAO,KAAO,EAAE,GAC9B,MAAM,QAAQ,EAAM,IACtB,EAAO,GAAK,KAAK,GAAG,EAAM;AAKhC,QAAO;;;;ACsBT,SAAgB,EACd,GACA,GACA,GACe;AAEf,KAAI,GAAS,WAAW;EACtB,IAAM,IAA8B,CAAC,GAAI,EAAQ,UAAU,YAAY,EAAE,CAAE;AAG3E,EAAI,GAAS,eACX,EAAa,KAAK,GAAG,EAAQ,aAAa,CAAC;EAG7C,IAAM,IAAmC,EAAE;AAG3C,EAAI,GAAS,kBACX,EAAkB,KAAK;GACrB,OAAO;GACP,WAAW,EAAQ;GACpB,CAAC;AAIJ,OAAK,IAAM,KAAO,GAAS;AACzB,OAAI,CAAC,EAAI,aAAc;GACvB,IAAM,IAAS,EAAI,cAAc;AACjC,OAAI,CAAC,EACH,OAAU,MACR,2CAA2C,EAAI,GAAG,0CACnD;AAEH,KAAkB,KAAK,GAAI,MAAM,QAAQ,EAAO,GAAG,IAAS,CAAC,EAAO,CAAE;;AAIxE,OAAK,IAAM,KAAW,EACpB,GAAkB,KAAK,EAAsB,EAAQ,CAAC;AAYxD,SATI,GAAS,qBACX,EAAa,KACX,EAA+B,EAAQ,oBAAoB,EAAkB,CAC9E,GAED,EAAa,KAAK,GAAG,EAAkB,EAGzC,EAAQ,UAAU,WAAW,GACtB,CAAC,EAAQ,UAAU;;CAI5B,IAAM,IAA8B,EAAE;AAGtC,CAAI,GAAS,eACX,EAAa,KAAK,GAAG,EAAQ,aAAa,CAAC;CAG7C,IAAM,IAAmC,EAAE;AAG3C,CAAI,GAAS,kBACX,EAAkB,KAAK;EACrB,OAAO;EACP,WAAW,EAAQ;EACpB,CAAC;AAIJ,MAAK,IAAM,KAAO,GAAS;AACzB,MAAI,CAAC,EAAI,aAAc;EACvB,IAAM,IAAS,EAAI,cAAc;AACjC,MAAI,CAAC,EACH,OAAU,MACR,2CAA2C,EAAI,GAAG,0CACnD;AAEH,IAAkB,KAAK,GAAI,MAAM,QAAQ,EAAO,GAAG,IAAS,CAAC,EAAO,CAAE;;AAIxE,MAAK,IAAM,KAAW,EACpB,GAAkB,KAAK,EAAsB,EAAQ,CAAC;AA0BxD,QAvBI,GAAS,qBACX,EAAa,KACX,EAA+B,EAAQ,oBAAoB,EAAkB,CAC9E,GAED,EAAa,KAAK,GAAG,EAAkB,EAIrC,GAAS,qBACX,EAAa,KAAK;EAChB,MAAM;EACN,WAAW,EAAQ;EACpB,CAAC,EAUG,CAPwB;EAC7B,MAAM;EACN,WAAW,GAAS;EACpB,QAAQ,GAAS;EACjB,UAAU;EACX,CAEiB;;AAGpB,SAAS,EACP,GACA,GACa;AACb,QAAO;EACL,IAAI;EACJ,WAAW,EAAK,oBAAoB,kBAAC,GAAD,EAAU,CAAA;EAC9C,QAAQ,EAAK;EACb;EACD;;AAQH,SAAS,EAAsB,GAA4C;CAEzE,IAAI,IAAqC;AAEzC,QAAO;EACL,MAAM,EAAQ,SAAS,QAAQ,OAAO,GAAG,GAAG;EAC5C,MAAM,YAAY;AAChB,OAAI,CAAC,GAAc;IACjB,IAAM,EAAE,SAAS,MAAe,MAAM,EAAQ,MAAM;AACpD,QAAI,EAAW,cAAc;KAC3B,IAAM,IAAS,EAAW,cAAc;AACxC,SAAe,MAAM,QAAQ,EAAO,GAAG,IAAS,CAAC,EAAO;UAExD,KAAe,EAAE;;GAGrB,IAAM,IAAS;AACf,UAAO,EACL,WAAW,WAAsB;AAC/B,WAAO,EAAU,EAAO;MAE3B;;EAEJ;;;;AC7MH,IAAa,IAAoB,EAAyC,KAAK;AAM/E,SAAgB,IAAoC;CAClD,IAAM,IAAM,EAAW,EAAkB;AACzC,KAAI,CAAC,EACH,OAAU,MACR,uFACD;AAEH,QAAO;;;;ACdT,IAAa,IAAe,EAA6B,KAAK;AAU9D,SAAgB,IAA+E;CAC7F,IAAM,IAAQ,EAAW,EAAa;AACtC,KAAI,CAAC,EACH,OAAU,MACR,kFACD;AAEH,QAAO;;;;AChBT,IAAa,IAAiB,EAA6C,KAAK;AAiBhF,SAAgB,IAAqC;CACnD,IAAM,IAAU,EAAW,EAAe;AAC1C,KAAI,CAAC,EACH,OAAU,MACR,oFACD;AAEH,QAAO;;AAeT,SAAgB,EACd,GAC6B;AAC7B,QAAO,EAAM;;;;ACvBf,SAAgB,EAAmB,EACjC,WACA,WACA,aACA,qBACA,eACA,UACA,YACA,gBACW;CAGX,IAAM,IAAY;EAAE;EAAQ;EAAU;EAAkB;CAExD,SAAS,IAAM;AAwBb,SAvBa,QAAc;GACzB,IAAI,IACF,kBAAC,GAAD;IAA2B,OAAO;cAChC,kBAAC,GAAD;KAAmB,OAAO;eACxB,kBAAC,GAAD;MAAc,OAAO;gBACnB,kBAAC,GAAD;OAAgB,OAAO;iBACrB,kBAAC,GAAD,EAAwB,WAAU,CAAA;OACnB,CAAA;MACJ,CAAA;KACG,CAAA;IACM,CAAA;AAI9B,OAAI,EACF,MAAK,IAAM,KAAY,CAAC,GAAG,EAAU,CAAC,SAAS,CAC7C,KAAO,kBAAC,GAAD,EAAA,UAAW,GAAgB,CAAA;AAItC,UAAO;KACN,EAAE,CAAC;;AAMR,QADA,EAAI,cAAc,eACX;;;;ACgFT,SAAgB,EAId,GAC+C;CAC/C,IAAM,IAAmE,EAAE,EACrE,IAAmE,EAAE,EACvE,IAAW,IAGT,IAAgB,IAAI,IAAY;EACpC,GAAG,OAAO,KAAK,EAAO,UAAU,EAAE,CAAC;EACnC,GAAG,OAAO,KAAK,EAAO,YAAY,EAAE,CAAC;EACrC,GAAG,OAAO,KAAK,EAAO,oBAAoB,EAAE,CAAC;EAC9C,CAAC;AAEF,QAAO;EACL,SAAS,GAAQ;AACf,OAAI,EACF,OAAU,MACR,2FACD;AAEH,KAAQ,KAAK,EAAO;;EAGtB,aAAa,GAAY;AACvB,OAAI,EACF,OAAU,MACR,2FACD;AAEH,KAAY,KAAK,EAAW;;EAG9B,QAAQ,GAA0B;AAChC,OAAI,EACF,OAAU,MAAM,qEAAqE;AASvF,GAPA,IAAW,IAGX,EACE,GACA,EACD,EACD,EAAqB,GAAuC,EAAc;GAG1E,IAAM,IAAO,EAAqC,EAAO;AACzD,QAAK,IAAM,KAAO,EAChB,KAAI;AACF,MAAI,WAAW,aAAa,EAAK;YAC1B,GAAK;AACZ,UAAU,MACR,2CAA2C,EAAI,GAAG,mCAAmC,aAAe,QAAQ,EAAI,UAAU,OAAO,EAAI,IACrI,EAAE,OAAO,GAAK,CACf;;GAcL,IAAM,IAAS,EACb,GACA,GAX+C;IAC/C,WAAW,GAAS;IACpB,eAAe,GAAS;IACxB,gBAAgB,GAAS;IACzB,mBAAmB,GAAS;IAC5B,QAAQ,GAAS;IACjB,oBAAoB,GAAS;IAC7B,aAAa,GAAS;IACvB,CAKA,EAGK,IACJ,OAAO,WAAa,MAAc,EAAoB,EAAO,GAAG,EAAmB,EAAO,EAGtF,IAAiC,EACrC,EACD,EACK,IAAQ,EAA2B,GAAS,EAAO,MAAM,EACzD,IAA+B,EAAQ,KAAK,OAAS;IACzD,IAAI,EAAI;IACR,SAAS,EAAI;IACb,MAAM,EAAI;IACV,WAAW,EAAI;IACf,OAAO,EAAI;IACZ,EAAE,EAGG,IAA4C,EAAE,EAC9C,IAAoC,EAAE,EACtC,IAA6D,EAAE;AAErE,OAAI,EAAO,aACJ,IAAM,CAAC,GAAK,MAAU,OAAO,QAAQ,EAAO,OAAO,CACtD,CAAI,MAAO,EAAO,KAAO;AAG7B,OAAI,EAAO,eACJ,IAAM,CAAC,GAAK,MAAY,OAAO,QAAQ,EAAO,SAAS,CAC1D,CAAI,MAAY,KAAA,MAAW,EAAS,KAAO;AAG/C,OAAI,EAAO,uBACJ,IAAM,CAAC,GAAK,MAAO,OAAO,QAAQ,EAAO,iBAAiB,CAC7D,CAAI,MAAI,EAAiB,KAAO;AAgBpC,UAAO;IAAE,KAXG,EAAmB;KAC7B;KACA;KACA;KACA;KACA;KACA;KACA,SAAS;KACT,WAAW,GAAS;KACrB,CAAC;IAEY;IAAQ;IAAY;IAAO,SAAS;IAAe;;EAEpE;;AAGH,SAAS,EACP,GACqB;CACrB,IAAM,IAAgC,EAAE;AAIxC,KAAI,EAAO,aACJ,IAAM,CAAC,GAAK,MAAU,OAAO,QAAQ,EAAO,OAAO,CACtD,CAAI,MACF,EAAK,KAAQ,EAA4B,UAAU;AAIzD,KAAI,EAAO,eACJ,IAAM,CAAC,GAAK,MAAY,OAAO,QAAQ,EAAO,SAAS,CAC1D,CAAI,MAAY,KAAA,MAAW,EAAK,KAAO;AAI3C,KAAI,EAAO,uBACJ,IAAM,CAAC,GAAK,MAAO,OAAO,QAAQ,EAAO,iBAAiB,CAC7D,CAAI,MACF,EAAK,KAAQ,EAAgC,aAAa;AAKhE,QAAO;;;;ACjRT,SAAgB,IAA8D;CAC5E,IAAM,IAAU,GAAY,EACtB,IAAkC,EAAE;AAC1C,MAAK,IAAM,KAAS,GAAS;EAC3B,IAAM,IAAQ,EAAc;AAC5B,MAAI,KAAQ,OAAO,KAAS,eACrB,IAAM,CAAC,GAAK,MAAU,OAAO,QAAQ,EAAgC,CACxE,CAAI,MAAU,KAAA,MACZ,EAAO,KAAO;;AAKtB,QAAO;;;;ACdT,SAAgB,EACd,GACiB;CACjB,IAAM,IAAa,GAAkB,EAC/B,IAAU,GAAY;AAE5B,KAAI,CAAC,EACH,QAAO;CAGT,IAAM,IAAY,EAAQ,MAAM,MAAM,EAAE,OAAO,EAAe;AAM9D,QALK,GAAW,QAKT;EAAE,GAAG;EAAY,GAAG,EAAU;EAAO,GAJnC;;;;AC7BX,IAAa,IAAb,cAAyC,EAAwB;CAC/D,QAAwB;EAAE,UAAU;EAAO,OAAO;EAAM;CAExD,OAAO,yBAAyB,GAAqB;AACnD,SAAO;GAAE,UAAU;GAAM;GAAO;;CAGlC,kBAA2B,GAAc,GAAiB;AACxD,UAAQ,MACN,2CAA2C,KAAK,MAAM,SAAS,0BAC/D,GACA,EACD;;CAGH,SAAkB;AAuBhB,SAtBI,KAAK,MAAM,WACT,KAAK,MAAM,WACN,KAAK,MAAM,WAGlB,kBAAC,OAAD;GACE,OAAO;IACL,SAAS;IACT,QAAQ;IACR,cAAc;IACd,QAAQ;IACT;aANH,CAQE,kBAAC,MAAD;IAAI,OAAO;KAAE,OAAO;KAAW,QAAQ;KAAgB;cAAvD;KAAyD;KACzC,KAAK,MAAM;KAAS;KAC/B;OACL,kBAAC,OAAD;IAAK,OAAO;KAAE,UAAU;KAAY,OAAO;KAAW,YAAY;KAAY;cAC3E,KAAK,MAAM,OAAO;IACf,CAAA,CACF;OAGH,KAAK,MAAM"}
1	+ {"version":3,"file":"index.js","names":[],"sources":["../src/route-builder.tsx","../src/app.tsx","../src/registry.ts","../src/zones.ts","../src/active-zones.ts"],"sourcesContent":["import { Outlet, useRoutes } from \"react-router\";\nimport type { RouteObject } from \"react-router\";\nimport type { ModuleDescriptor, LazyModuleDescriptor } from \"@react-router-modules/core\";\n\nexport interface RouteBuilderOptions {\n /*\n Pre-built root route. If provided, rootComponent/notFoundComponent/loader\n * are ignored — configure them directly on this route instead.\n /\n rootRoute?: RouteObject;\n /* Component for the root layout (renders <Outlet /> for child routes) /\n rootComponent?: () => React.JSX.Element;\n /* Component for the index route (/) /\n indexComponent?: () => React.JSX.Element;\n /* Component for the 404 / not-found route /\n notFoundComponent?: () => React.JSX.Element;\n /\n Called before every route loads — for observability, feature flags, etc.\n * Runs for ALL routes including public ones.\n * Ignored if rootRoute is provided.\n /\n loader?: (args: { request: Request; params: Record<string, string \| undefined> }) => any;\n /\n Auth boundary — a pathless layout route that wraps module routes and\n * the index route. Shell routes (login, error pages) sit outside this\n * boundary and are NOT guarded.\n \n Follows React Router's recommended layout route pattern.\n \n When provided, the route tree becomes:\n * ```\n * Root (loader runs for ALL routes)\n * ├── shellRoutes (public — /login, /signup, etc.)\n * └── _authenticated (layout — loader guards children)\n * ├── / (indexComponent)\n * └── module routes\n * ```\n \n When omitted, all routes are direct children of root (no auth boundary).\n /\n authenticatedRoute?: {\n /* Auth guard — throw redirect() to deny access /\n loader: (args: { request: Request; params: Record<string, string \| undefined> }) => any;\n /* Layout component for authenticated pages. Defaults to <Outlet />. /\n Component?: () => React.JSX.Element;\n };\n /* Additional routes owned by the shell (login, error pages, etc.) /\n shellRoutes?: () => RouteObject[];\n}\n\n/\n Composes all module route subtrees into a React Router route tree.\n * Modules without createRoutes are skipped (headless modules).\n /\nexport function buildRouteTree(\n modules: ModuleDescriptor[],\n lazyModules: LazyModuleDescriptor[],\n options?: RouteBuilderOptions,\n): RouteObject[] {\n // If a custom root route is provided, use it as the base\n if (options?.rootRoute) {\n const rootChildren: RouteObject[] = [...(options.rootRoute.children ?? [])];\n\n // Shell-owned routes (login, error pages) — always direct children of root\n if (options?.shellRoutes) {\n rootChildren.push(...options.shellRoutes());\n }\n\n const protectedChildren: RouteObject[] = [];\n\n // Add index route if provided\n if (options?.indexComponent) {\n protectedChildren.push({\n index: true,\n Component: options.indexComponent,\n });\n }\n\n // Eager modules\n for (const mod of modules) {\n if (!mod.createRoutes) continue;\n const routes = mod.createRoutes();\n if (!routes) {\n throw new Error(\n `[@react-router-modules/runtime] Module \"${mod.id}\" createRoutes() returned a falsy value.`,\n );\n }\n protectedChildren.push(...(Array.isArray(routes) ? routes : [routes]));\n }\n\n // Lazy modules\n for (const lazyMod of lazyModules) {\n protectedChildren.push(createLazyModuleRoute(lazyMod));\n }\n\n if (options?.authenticatedRoute) {\n rootChildren.push(\n createAuthenticatedLayoutRoute(options.authenticatedRoute, protectedChildren),\n );\n } else {\n rootChildren.push(...protectedChildren);\n }\n\n options.rootRoute.children = rootChildren;\n return [options.rootRoute];\n }\n\n // Build root route from options\n const rootChildren: RouteObject[] = [];\n\n // Shell-owned routes (login, error pages) — always direct children of root\n if (options?.shellRoutes) {\n rootChildren.push(...options.shellRoutes());\n }\n\n const protectedChildren: RouteObject[] = [];\n\n // Add index route if provided\n if (options?.indexComponent) {\n protectedChildren.push({\n index: true,\n Component: options.indexComponent,\n });\n }\n\n // Eager modules: call createRoutes\n for (const mod of modules) {\n if (!mod.createRoutes) continue;\n const routes = mod.createRoutes();\n if (!routes) {\n throw new Error(\n `[@react-router-modules/runtime] Module \"${mod.id}\" createRoutes() returned a falsy value.`,\n );\n }\n protectedChildren.push(...(Array.isArray(routes) ? routes : [routes]));\n }\n\n // Lazy modules\n for (const lazyMod of lazyModules) {\n protectedChildren.push(createLazyModuleRoute(lazyMod));\n }\n\n if (options?.authenticatedRoute) {\n rootChildren.push(\n createAuthenticatedLayoutRoute(options.authenticatedRoute, protectedChildren),\n );\n } else {\n rootChildren.push(...protectedChildren);\n }\n\n // Not-found catch-all\n if (options?.notFoundComponent) {\n rootChildren.push({\n path: \"\",\n Component: options.notFoundComponent,\n });\n }\n\n const rootRoute: RouteObject = {\n path: \"/\",\n Component: options?.rootComponent,\n loader: options?.loader,\n children: rootChildren,\n };\n\n return [rootRoute];\n}\n\nfunction createAuthenticatedLayoutRoute(\n auth: NonNullable<RouteBuilderOptions[\"authenticatedRoute\"]>,\n children: RouteObject[],\n): RouteObject {\n return {\n id: \"_authenticated\",\n Component: auth.Component ?? (() => <Outlet />),\n loader: auth.loader,\n children,\n };\n}\n\n/*\n Creates a catch-all route for a lazily-loaded module.\n * On first navigation, the module descriptor is loaded and its routes\n * are rendered as descendant routes via useRoutes().\n /\nfunction createLazyModuleRoute(lazyMod: LazyModuleDescriptor): RouteObject {\n // Capture the loaded routes so they're resolved only once\n let cachedRoutes: RouteObject[] \| null = null;\n\n return {\n path: lazyMod.basePath.replace(/^\\//, \"\") + \"/\",\n lazy: async () => {\n if (!cachedRoutes) {\n const { default: descriptor } = await lazyMod.load();\n if (descriptor.createRoutes) {\n const routes = descriptor.createRoutes();\n cachedRoutes = Array.isArray(routes) ? routes : [routes];\n } else {\n cachedRoutes = [];\n }\n }\n const routes = cachedRoutes;\n return {\n Component: function LazyModule() {\n return useRoutes(routes);\n },\n };\n },\n };\n}\n","import { useMemo } from \"react\";\nimport { RouterProvider } from \"react-router\";\nimport type { DataRouter } from \"react-router\";\nimport type { StoreApi } from \"zustand\";\nimport type { ReactiveService } from \"@react-router-modules/core\";\nimport { SharedDependenciesContext } from \"@react-router-modules/core\";\nimport type {\n DynamicSlotFactory,\n SlotFilter,\n NavigationManifest,\n ModuleEntry,\n} from \"@modular-react/core\";\nimport {\n NavigationContext,\n SlotsContext,\n RecalculateSlotsContext,\n ModulesContext,\n DynamicSlotsProvider,\n} from \"@modular-react/react\";\nimport type { SlotsSignal } from \"@modular-react/react\";\n\ninterface AppProps {\n router: DataRouter;\n stores: Record<string, StoreApi<unknown>>;\n services: Record<string, unknown>;\n reactiveServices: Record<string, ReactiveService<unknown>>;\n navigation: NavigationManifest;\n slots: object;\n modules: readonly ModuleEntry[];\n providers?: React.ComponentType<{ children: React.ReactNode }>[];\n dynamicSlotFactories: DynamicSlotFactory[];\n slotFilter?: SlotFilter;\n slotsSignal: SlotsSignal;\n recalculateSlots: () => void;\n}\n\nexport function createAppComponent({\n router,\n stores,\n services,\n reactiveServices,\n navigation,\n slots,\n modules,\n providers,\n dynamicSlotFactories,\n slotFilter,\n slotsSignal,\n recalculateSlots,\n}: AppProps) {\n // All values captured in closure are stable references created once at resolve() time.\n // Wrap in a stable object so context consumers don't re-render on parent renders.\n const depsValue = { stores, services, reactiveServices };\n const hasDynamicSlots = dynamicSlotFactories.length > 0 \|\| slotFilter != null;\n\n function App() {\n const tree = useMemo(() => {\n // When dynamic slots exist, use a provider that re-evaluates\n // on recalculateSlots(). Otherwise, use static context for zero overhead.\n const slotsProvider = hasDynamicSlots ? (\n <DynamicSlotsProvider\n baseSlots={slots}\n factories={dynamicSlotFactories}\n filter={slotFilter}\n stores={stores}\n services={services}\n reactiveServices={reactiveServices}\n signal={slotsSignal}\n >\n <ModulesContext value={modules}>\n <RouterProvider router={router} />\n </ModulesContext>\n </DynamicSlotsProvider>\n ) : (\n <SlotsContext value={slots}>\n <ModulesContext value={modules}>\n <RouterProvider router={router} />\n </ModulesContext>\n </SlotsContext>\n );\n\n let node: React.ReactNode = (\n <SharedDependenciesContext value={depsValue}>\n <NavigationContext value={navigation}>\n <RecalculateSlotsContext value={recalculateSlots}>\n {slotsProvider}\n </RecalculateSlotsContext>\n </NavigationContext>\n </SharedDependenciesContext>\n );\n\n // Wrap with user-supplied providers (first element = outermost wrapper)\n if (providers) {\n for (const Provider of [...providers].reverse()) {\n node = <Provider>{node}</Provider>;\n }\n }\n\n return node;\n }, []);\n\n return tree;\n }\n\n App.displayName = \"ModularApp\";\n return App;\n}\n","import { createBrowserRouter, createMemoryRouter } from \"react-router\";\nimport type { RouteObject } from \"react-router\";\nimport type { StoreApi } from \"zustand\";\nimport type {\n ModuleDescriptor,\n LazyModuleDescriptor,\n ReactiveService,\n SlotMap,\n SlotMapOf,\n} from \"@react-router-modules/core\";\nimport {\n buildNavigationManifest,\n buildSlotsManifest,\n collectDynamicSlotFactories,\n validateNoDuplicateIds,\n validateDependencies,\n} from \"@modular-react/core\";\nimport type { SlotFilter, NavigationManifest, ModuleEntry } from \"@modular-react/core\";\nimport { createSlotsSignal } from \"@modular-react/react\";\n\nimport type { RegistryConfig, ApplicationManifest } from \"./types.js\";\nimport { buildRouteTree, type RouteBuilderOptions } from \"./route-builder.js\";\nimport { createAppComponent } from \"./app.js\";\n\nexport interface ModuleRegistry<\n TSharedDependencies extends Record<string, any>,\n TSlots extends SlotMapOf<TSlots> = SlotMap,\n> {\n /** Register an eager module /\n register(module: ModuleDescriptor<TSharedDependencies, TSlots>): void;\n\n /* Register a lazily-loaded module /\n registerLazy(descriptor: LazyModuleDescriptor<TSharedDependencies, TSlots>): void;\n\n /\n Resolve all modules and produce the application manifest.\n * Validates dependencies and builds the route tree.\n /\n resolve(options?: ResolveOptions<TSharedDependencies, TSlots>): ApplicationManifest<TSlots>;\n}\n\nexport interface ResolveOptions<\n TSharedDependencies extends Record<string, any> = Record<string, any>,\n TSlots extends SlotMapOf<TSlots> = SlotMap,\n> {\n /* Root layout component (renders <Outlet /> for child routes) /\n rootComponent?: () => React.JSX.Element;\n\n /\n Pre-built root route — if provided, used instead of auto-creating one.\n * Mutually exclusive with rootComponent/notFoundComponent/loader.\n /\n rootRoute?: RouteObject;\n\n /* Component for the index route (/) /\n indexComponent?: () => React.JSX.Element;\n\n /* Component for 404 / not-found /\n notFoundComponent?: () => React.JSX.Element;\n\n /\n Called before every route loads — for observability, analytics, feature flags.\n * Runs for ALL routes including public ones like /login.\n * Ignored if rootRoute is provided.\n /\n loader?: (args: { request: Request; params: Record<string, string \| undefined> }) => any;\n\n /\n Auth boundary — a pathless layout route that guards module routes and\n * the index route. Shell routes sit outside this boundary.\n /\n authenticatedRoute?: {\n /* Auth guard — throw redirect() to deny access /\n loader: (args: { request: Request; params: Record<string, string \| undefined> }) => any;\n /* Layout component for authenticated pages. Defaults to <Outlet />. /\n Component?: () => React.JSX.Element;\n };\n\n /* Additional routes owned by the shell (login, error pages, etc.) /\n shellRoutes?: () => RouteObject[];\n\n /\n Additional React providers to wrap around the app tree.\n * First element is outermost.\n /\n providers?: React.ComponentType<{ children: React.ReactNode }>[];\n\n /\n Global filter applied to the fully resolved slot manifest (static + dynamic)\n * on every `recalculateSlots()` call.\n /\n slotFilter?: (slots: TSlots, deps: TSharedDependencies) => TSlots;\n}\n\nexport function createRegistry<\n TSharedDependencies extends Record<string, any>,\n TSlots extends SlotMapOf<TSlots> = SlotMap,\n>(\n config: RegistryConfig<TSharedDependencies, TSlots>,\n): ModuleRegistry<TSharedDependencies, TSlots> {\n const modules: ModuleDescriptor<TSharedDependencies, TSlots>[] = [];\n const lazyModules: LazyModuleDescriptor<TSharedDependencies, TSlots>[] = [];\n let resolved = false;\n\n // Collect all available dependency keys from all three buckets\n const availableKeys = new Set<string>([\n ...Object.keys(config.stores ?? {}),\n ...Object.keys(config.services ?? {}),\n ...Object.keys(config.reactiveServices ?? {}),\n ]);\n\n return {\n register(module) {\n if (resolved) {\n throw new Error(\n \"[@react-router-modules/runtime] Cannot register modules after resolve() has been called.\",\n );\n }\n modules.push(module);\n },\n\n registerLazy(descriptor) {\n if (resolved) {\n throw new Error(\n \"[@react-router-modules/runtime] Cannot register modules after resolve() has been called.\",\n );\n }\n lazyModules.push(descriptor);\n },\n\n resolve(options?: ResolveOptions<TSharedDependencies, TSlots>) {\n if (resolved) {\n throw new Error(\"[@react-router-modules/runtime] resolve() can only be called once.\");\n }\n resolved = true;\n\n // Validate — cast is safe since validation only reads structural properties (id, requires)\n validateNoDuplicateIds(modules as ModuleDescriptor[], lazyModules as LazyModuleDescriptor[]);\n validateDependencies(modules as ModuleDescriptor[], availableKeys);\n\n // Run onRegister lifecycle hooks\n const deps = buildDepsObject<TSharedDependencies>(config);\n for (const mod of modules) {\n try {\n mod.lifecycle?.onRegister?.(deps);\n } catch (err) {\n throw new Error(\n `[@react-router-modules/runtime] Module \"${mod.id}\" lifecycle.onRegister() failed: ${err instanceof Error ? err.message : String(err)}`,\n { cause: err },\n );\n }\n }\n\n // Build route tree\n const routeBuilderOptions: RouteBuilderOptions = {\n rootRoute: options?.rootRoute,\n rootComponent: options?.rootComponent,\n indexComponent: options?.indexComponent,\n notFoundComponent: options?.notFoundComponent,\n loader: options?.loader,\n authenticatedRoute: options?.authenticatedRoute,\n shellRoutes: options?.shellRoutes,\n };\n const routes = buildRouteTree(\n modules as ModuleDescriptor[],\n lazyModules as LazyModuleDescriptor[],\n routeBuilderOptions,\n );\n\n // Create React Router instance (use memory router when DOM is unavailable, e.g. tests)\n const router =\n typeof document !== \"undefined\" ? createBrowserRouter(routes) : createMemoryRouter(routes);\n\n // Build navigation, slots, and module entries\n const navigation: NavigationManifest = buildNavigationManifest(modules as ModuleDescriptor[]);\n const slots = buildSlotsManifest<TSlots>(modules, config.slots);\n const dynamicSlotFactories = collectDynamicSlotFactories(modules as ModuleDescriptor[]);\n const slotFilter = options?.slotFilter as SlotFilter \| undefined;\n const moduleEntries: ModuleEntry[] = modules.map((mod) => ({\n id: mod.id,\n version: mod.version,\n meta: mod.meta,\n component: mod.component,\n zones: mod.zones,\n }));\n\n // Build stores, services, and reactive services maps for the context\n const stores: Record<string, StoreApi<unknown>> = {};\n const services: Record<string, unknown> = {};\n const reactiveServices: Record<string, ReactiveService<unknown>> = {};\n\n if (config.stores) {\n for (const [key, store] of Object.entries(config.stores)) {\n if (store) stores[key] = store as StoreApi<unknown>;\n }\n }\n if (config.services) {\n for (const [key, service] of Object.entries(config.services)) {\n if (service !== undefined) services[key] = service;\n }\n }\n if (config.reactiveServices) {\n for (const [key, rs] of Object.entries(config.reactiveServices)) {\n if (rs) reactiveServices[key] = rs as ReactiveService<unknown>;\n }\n }\n\n // Create signal for imperative recalculation of dynamic slots\n const slotsSignal = createSlotsSignal();\n const hasDynamicSlots = dynamicSlotFactories.length > 0 \|\| slotFilter != null;\n const recalculateSlots = hasDynamicSlots ? () => slotsSignal.notify() : () => {};\n\n // Create App component\n const App = createAppComponent({\n router,\n stores,\n services,\n reactiveServices,\n navigation,\n slots,\n modules: moduleEntries,\n providers: options?.providers,\n dynamicSlotFactories,\n slotFilter,\n slotsSignal,\n recalculateSlots,\n });\n\n return { App, router, navigation, slots, modules: moduleEntries, recalculateSlots };\n },\n };\n}\n\nfunction buildDepsObject<TSharedDependencies extends Record<string, any>>(\n config: RegistryConfig<TSharedDependencies, any>,\n): TSharedDependencies {\n const deps: Record<string, unknown> = {};\n\n if (config.stores) {\n for (const [key, store] of Object.entries(config.stores)) {\n if (store) {\n deps[key] = (store as StoreApi<unknown>).getState();\n }\n }\n }\n if (config.services) {\n for (const [key, service] of Object.entries(config.services)) {\n if (service !== undefined) deps[key] = service;\n }\n }\n if (config.reactiveServices) {\n for (const [key, rs] of Object.entries(config.reactiveServices)) {\n if (rs) {\n deps[key] = (rs as ReactiveService<unknown>).getSnapshot();\n }\n }\n }\n\n return deps as TSharedDependencies;\n}\n","import { useMatches } from \"react-router\";\nimport type { ZoneMapOf } from \"@react-router-modules/core\";\n\n/\n Read zone components contributed by the currently matched route hierarchy.\n \n Zones are set via React Router's `handle` on individual routes.\n * This hook walks all matched routes from root to leaf and returns a merged\n * map where the deepest match wins for each zone key.\n \n @example\n * // In the shell layout:\n * const zones = useZones<AppZones>()\n * const DetailPanel = zones.detailPanel\n \n return (\n * <div className=\"grid\">\n * <main><Outlet /></main>\n * <aside>{DetailPanel && <DetailPanel />}</aside>\n * </div>\n * )\n \n @example\n * // In a module's route definition:\n * {\n * path: ':userId',\n * Component: UserDetailPage,\n * handle: {\n * detailPanel: UserDetailSidebar,\n * },\n * }\n /\nexport function useZones<TZones extends ZoneMapOf<TZones>>(): Partial<TZones> {\n const matches = useMatches();\n const merged: Record<string, unknown> = {};\n for (const match of matches) {\n const data = (match as any).handle;\n if (data && typeof data === \"object\") {\n for (const [key, value] of Object.entries(data as Record<string, unknown>)) {\n if (value !== undefined) {\n merged[key] = value;\n }\n }\n }\n }\n return merged as Partial<TZones>;\n}\n","import type { ZoneMapOf } from \"@react-router-modules/core\";\nimport { useModules } from \"@modular-react/react\";\nimport { useZones } from \"./zones.js\";\n\n/\n Read zone components from both the matched route hierarchy AND the\n * currently active module (identified by `activeModuleId`).\n \n This unifies two zone contribution patterns:\n * - Route-based modules contribute zones via React Router's `handle`\n * - Tab-based modules contribute zones via the `zones` field on their descriptor\n \n When both sources provide a value for the same zone key, the module's\n * contribution wins.\n */\nexport function useActiveZones<TZones extends ZoneMapOf<TZones>>(\n activeModuleId?: string \| null,\n): Partial<TZones> {\n const routeZones = useZones<TZones>();\n const modules = useModules();\n\n if (!activeModuleId) {\n return routeZones;\n }\n\n const activeMod = modules.find((m) => m.id === activeModuleId);\n if (!activeMod?.zones) {\n return routeZones;\n }\n\n // Module zones override route zones for the same key\n return { ...routeZones, ...activeMod.zones } as Partial<TZones>;\n}\n"],"mappings":"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"}

package/package.json CHANGED Viewed

@@ -1,10 +1,10 @@
 {
   "name": "@react-router-modules/runtime",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/kibertoad/tanstack-react-modules.git",
-    "directory": "packages/runtime"
+    "url": "git+https://github.com/kibertoad/modular-react.git",
+    "directory": "packages/react-router-runtime"
   },
   "files": [
     "dist"
@@ -24,10 +24,14 @@
   "scripts": {
     "build": "vite build",
     "dev": "vite build --watch",
-    "prepublishOnly": "pnpm build"
+    "test": "vitest run",
+    "prepublishOnly": "pnpm build",
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@react-router-modules/core": "^1.0.1"
+    "@modular-react/core": "workspace:*",
+    "@modular-react/react": "workspace:*",
+    "@react-router-modules/core": "workspace:*"
   },
   "devDependencies": {
     "@types/react": "^19.0.0",
@@ -38,6 +42,7 @@
     "typescript": "^6.0.2",
     "vite": "^8.0.3",
     "vite-plugin-dts": "^4.5.0",
+    "vitest": "^4.1.0",
     "zustand": "^5.0.0"
   },
   "peerDependencies": {