effective-rsc 0.1.0

package/dist/client/call-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client/call-server.js","sources":["../../src/client/call-server.ts"],"sourcesContent":["import { Effect, MutableRef, Schema } from 'effect';\nimport { addTransitionType, startTransition } from 'react';\nimport {\n  createTemporaryReferenceSet,\n  encodeReply,\n  setServerCallback,\n} from 'react-server-dom-rspack/client.browser';\n\nimport { BrowserEffectRunner } from './browser-effect-runner';\nimport { BrowserRenderer } from './browser-renderer';\nimport { FlightClient } from './flight-client';\nimport { NavigationApi } from './navigation-api';\nimport { RouteLoader } from './route-loader';\nimport { RouteRefresher } from './route-refresh';\n\nclass ServerFnCallError extends Schema.TaggedError<ServerFnCallError>()('ServerFnCallError', {\n  cause: Schema.Defect(),\n  message: Schema.String,\n}) {}\n\ntype ServerFnInvocation =\n  | {\n      readonly _tag: 'HistoryEntry';\n      readonly id: string;\n      readonly order: number;\n      readonly url: string;\n    }\n  | { readonly _tag: 'CurrentUrl'; readonly order: number; readonly url: string };\n\ntype ServerFnRefreshSource = 'Response' | 'CurrentRoute';\n\nexport const installCallServer = Effect.gen(function* () {\n  const browserRenderer = yield* BrowserRenderer;\n  const navigationApi = yield* NavigationApi;\n  const run = yield* BrowserEffectRunner;\n  const flightClient = yield* FlightClient;\n  const routeLoader = yield* RouteLoader;\n  const routeRefresher = yield* RouteRefresher;\n  const latestInvocationOrder = MutableRef.make(0);\n  const selectRefreshSource = (invocation: ServerFnInvocation): ServerFnRefreshSource => {\n    if (\n      MutableRef.get(latestInvocationOrder) !== invocation.order ||\n      navigationApi.getTransition() !== null\n    ) {\n      return 'CurrentRoute';\n    }\n\n    const currentEntry = navigationApi.getCurrentEntry();\n    switch (invocation._tag) {\n      case 'HistoryEntry':\n        return currentEntry?.id === invocation.id ? 'Response' : 'CurrentRoute';\n      case 'CurrentUrl':\n        return currentEntry === null && navigationApi.getCurrentUrl() === invocation.url\n          ? 'Response'\n          : 'CurrentRoute';\n    }\n  };\n  const callServer = Effect.fnUntraced(function* (\n    id: string,\n    args: ReadonlyArray<unknown>,\n    invocationResult: PromiseWithResolvers<unknown>,\n  ) {\n    const currentEntry = navigationApi.getCurrentEntry();\n    const order = MutableRef.incrementAndGet(latestInvocationOrder);\n    const invocation: ServerFnInvocation =\n      currentEntry === null\n        ? { _tag: 'CurrentUrl', order, url: navigationApi.getCurrentUrl() }\n        : {\n            _tag: 'HistoryEntry',\n            id: currentEntry.id,\n            order,\n            url: currentEntry.url ?? navigationApi.getCurrentUrl(),\n          };\n    const temporaryReferences = createTemporaryReferenceSet();\n    const body = yield* Effect.tryPromise({\n      try: () => encodeReply(args, { temporaryReferences }),\n      catch: (cause) => new ServerFnCallError({ cause, message: 'Failed to encode arguments.' }),\n    });\n    const resource = yield* flightClient\n      .load({\n        _tag: 'ServerFunction',\n        body,\n        destination: new URL(invocation.url),\n        id,\n        temporaryReferences,\n      })\n      .pipe(\n        Effect.mapError(\n          (cause) => new ServerFnCallError({ cause, message: 'Server Function request failed.' }),\n        ),\n      );\n    if (resource._tag === 'Document') {\n      yield* resource.release;\n      return yield* new ServerFnCallError({\n        cause: new Error('A Server Function response cannot request document navigation.'),\n        message: 'Server Function response was incompatible with Flight.',\n      });\n    }\n    const serverFnResult = resource.payload.serverFnResult;\n    if (serverFnResult === null) {\n      yield* resource.release;\n      return yield* new ServerFnCallError({\n        cause: new Error('The Flight payload omitted the Server Function return value.'),\n        message: 'Server Function response was incomplete.',\n      });\n    }\n    switch (serverFnResult._tag) {\n      case 'Failure':\n        invocationResult.reject(\n          new ServerFnCallError({\n            cause: serverFnResult.error,\n            message: 'Server Function execution failed.',\n          }),\n        );\n        break;\n      case 'Success':\n        invocationResult.resolve(serverFnResult.value);\n        break;\n    }\n    // React registered its Action reactions before the request completed. Registering ERSC's\n    // continuation after settlement lets React close that Action before the refresh Transition.\n    yield* Effect.promise(() =>\n      invocationResult.promise.then(\n        () => undefined,\n        () => undefined,\n      ),\n    );\n    if (selectRefreshSource(invocation) === 'CurrentRoute') {\n      yield* resource.release;\n      yield* routeRefresher.refreshCurrentRoute('server-function');\n      return;\n    }\n\n    yield* routeRefresher.interruptCurrentRouteRefresh;\n    const commitRefresh = routeLoader.prepareRefresh(resource.payload.routeTree);\n    let renderCommitted!: Promise<void>;\n    yield* Effect.sync(() => {\n      startTransition(() => {\n        addTransitionType('server-function');\n        // Do not return the commit Promise from React's Transition Action. React cannot commit the\n        // render until that Action ends.\n        renderCommitted = browserRenderer.refresh(resource.payload.routeTree);\n      });\n    });\n    yield* Effect.all([resource.completed, Effect.promise(() => renderCommitted)], {\n      concurrency: 'unbounded',\n      discard: true,\n    }).pipe(\n      Effect.andThen(Effect.sync(commitRefresh)),\n      Effect.onError(() => resource.release),\n      Effect.forkScoped,\n    );\n  });\n\n  yield* Effect.sync(() => {\n    setServerCallback((id, args) => {\n      const invocationResult = Promise.withResolvers<unknown>();\n      void run(callServer(id, args, invocationResult)).catch(invocationResult.reject);\n      return invocationResult.promise;\n    });\n  });\n});\n"],"names":["Effect","MutableRef","Schema","addTransitionType","startTransition","createTemporaryReferenceSet","encodeReply","setServerCallback","BrowserEffectRunner","BrowserRenderer","FlightClient","NavigationApi","RouteLoader","RouteRefresher","ServerFnCallError","installCallServer","browserRenderer","navigationApi","run","flightClient","routeLoader","routeRefresher","latestInvocationOrder","selectRefreshSource","invocation","currentEntry","callServer","id","args","invocationResult","order","temporaryReferences","body","cause","resource","URL","Error","serverFnResult","undefined","commitRefresh","renderCommitted","Promise"],"mappings":"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"}

package/dist/client/client-router.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from 'effect';
+import { BrowserEffectRunner } from './browser-effect-runner.js';
+import { BrowserRenderer } from './browser-renderer.js';
+import { NavigationApi } from './navigation-api.js';
+import { RouteLoader } from './route-loader.js';
+export declare const installClientRouter: Effect.Effect<void, never, BrowserEffectRunner | BrowserRenderer | NavigationApi | RouteLoader | import("effect/Scope").Scope>;

package/dist/client/client-router.js

@@ -0,0 +1,588 @@
+import { Effect, Exit, MutableRef } from "effect";
+import { addTransitionType, startTransition } from "react";
+import { BrowserEffectRunner } from "./browser-effect-runner.js";
+import { BrowserRenderer } from "./browser-renderer.js";
+import { NavigationApi } from "./navigation-api.js";
+import { NativeDocumentNavigationInfo, isRoutedNavigation, preserveRequestedHash } from "./navigation-routing.js";
+import { RouteLoader } from "./route-loader.js";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const getNavigationTransitionTypes = (event, fromIndex)=>{
+    const types = [
+        'navigation',
+        `navigation-${event.navigationType}`,
+        ...event.hasUAVisualTransition ? [
+            'navigation-ua-visual-transition'
+        ] : []
+    ];
+    if (event.navigationType === 'push') {
+        return [
+            ...types,
+            'navigation-forward'
+        ];
+    }
+    if (event.navigationType !== 'traverse') {
+        return types;
+    }
+    if (fromIndex === null || fromIndex === event.destination.index) {
+        return types;
+    }
+    return [
+        ...types,
+        event.destination.index < fromIndex ? 'navigation-backward' : 'navigation-forward'
+    ];
+};
+const reduceRouterState = (state, event)=>{
+    if (state.visible._tag === 'Navigation' && state.visible.generation === event.generation) {
+        const visible = state.visible;
+        switch(event._tag){
+            case 'RenderRetired':
+                return {
+                    command: visible.flight._tag === 'Streaming' ? {
+                        _tag: 'ReleaseRoute',
+                        resource: visible.flight.resource
+                    } : null,
+                    state: {
+                        ...state,
+                        visible: {
+                            _tag: 'Settled'
+                        }
+                    }
+                };
+            case 'HistoryCommitted':
+                if (visible.entry._tag === 'Committed') {
+                    throw new TypeError('A visible navigation history entry cannot commit twice.');
+                }
+                if (visible.flight._tag === 'Streaming') {
+                    return {
+                        command: null,
+                        state: {
+                            ...state,
+                            visible: {
+                                ...visible,
+                                entry: {
+                                    _tag: 'Committed',
+                                    entry: event.entry
+                                }
+                            }
+                        }
+                    };
+                }
+                return {
+                    command: event.entry === null ? null : {
+                        _tag: 'CacheRoute',
+                        cache: visible.flight.cache,
+                        entry: event.entry
+                    },
+                    state: {
+                        ...state,
+                        visible: {
+                            _tag: 'Settled'
+                        }
+                    }
+                };
+            case 'FlightCompleted':
+                if (visible.flight._tag === 'Completed') {
+                    throw new TypeError('A visible navigation Flight stream cannot complete twice.');
+                }
+                if (visible.entry._tag === 'PendingCommit') {
+                    return {
+                        command: {
+                            _tag: 'ReleaseRoute',
+                            resource: visible.flight.resource
+                        },
+                        state: {
+                            ...state,
+                            visible: {
+                                ...visible,
+                                flight: {
+                                    _tag: 'Completed',
+                                    cache: visible.flight.resource.cache
+                                }
+                            }
+                        }
+                    };
+                }
+                return {
+                    command: visible.entry.entry === null ? {
+                        _tag: 'ReleaseRoute',
+                        resource: visible.flight.resource
+                    } : {
+                        _tag: 'CacheAndReleaseRoute',
+                        entry: visible.entry.entry,
+                        resource: visible.flight.resource
+                    },
+                    state: {
+                        ...state,
+                        visible: {
+                            _tag: 'Settled'
+                        }
+                    }
+                };
+            case 'FlightFailed':
+                if (visible.flight._tag === 'Completed') {
+                    throw new TypeError('A completed visible Flight stream cannot fail.');
+                }
+                return {
+                    command: {
+                        _tag: 'ReleaseRoute',
+                        resource: visible.flight.resource
+                    },
+                    state: {
+                        ...state,
+                        visible: {
+                            _tag: 'Settled'
+                        }
+                    }
+                };
+        }
+    }
+    if (event._tag === 'RenderRetired' || event._tag === 'HistoryCommitted' || event._tag === 'FlightCompleted') {
+        return {
+            command: null,
+            state
+        };
+    }
+    if (event._tag === 'BeginNavigation') {
+        const nextState = {
+            _tag: 'Navigating',
+            candidate: {
+                _tag: 'Loading',
+                generation: event.generation,
+                lifetime: event.lifetime
+            },
+            visible: state.visible
+        };
+        if (state._tag === 'Ready') {
+            return {
+                command: null,
+                state: nextState
+            };
+        }
+        return {
+            command: {
+                _tag: 'SupersedeCandidate',
+                candidate: state.candidate
+            },
+            state: nextState
+        };
+    }
+    if (state._tag === 'Ready' || state.candidate.generation !== event.generation) {
+        switch(event._tag){
+            case 'RouteLoaded':
+                return {
+                    command: {
+                        _tag: 'ReleaseRoute',
+                        resource: event.resource
+                    },
+                    state
+                };
+            case 'RenderScheduled':
+                return {
+                    command: {
+                        _tag: 'DiscardRoute',
+                        rendererNavigation: event.rendererNavigation,
+                        resource: event.resource
+                    },
+                    state
+                };
+            default:
+                return {
+                    command: null,
+                    state
+                };
+        }
+    }
+    switch(event._tag){
+        case 'DocumentLoaded':
+        case 'FlightFailed':
+            if (state.candidate._tag !== 'Loading') {
+                throw new TypeError(`${event._tag} cannot follow ${state.candidate._tag}.`);
+            }
+            return {
+                command: null,
+                state: {
+                    _tag: 'Ready',
+                    visible: state.visible
+                }
+            };
+        case 'RouteLoaded':
+            if (state.candidate._tag !== 'Loading') {
+                throw new TypeError(`RouteLoaded cannot follow ${state.candidate._tag}.`);
+            }
+            return {
+                command: {
+                    _tag: 'PublishRoute',
+                    generation: event.generation,
+                    resource: event.resource
+                },
+                state: {
+                    _tag: 'Navigating',
+                    candidate: {
+                        _tag: 'Publishing',
+                        generation: event.generation,
+                        lifetime: state.candidate.lifetime,
+                        resource: event.resource
+                    },
+                    visible: state.visible
+                }
+            };
+        case 'RenderScheduled':
+            if (state.candidate._tag !== 'Publishing') {
+                throw new TypeError(`RenderScheduled cannot follow ${state.candidate._tag}.`);
+            }
+            if (state.candidate.resource !== event.resource) {
+                throw new TypeError('RenderScheduled must use the published route resource.');
+            }
+            return {
+                command: null,
+                state: {
+                    _tag: 'Navigating',
+                    candidate: {
+                        _tag: 'Rendering',
+                        generation: event.generation,
+                        lifetime: state.candidate.lifetime,
+                        rendererNavigation: event.rendererNavigation,
+                        resource: event.resource
+                    },
+                    visible: state.visible
+                }
+            };
+        case 'RenderCommitted':
+            if (state.candidate._tag !== 'Rendering') {
+                throw new TypeError(`RenderCommitted cannot follow ${state.candidate._tag}.`);
+            }
+            return {
+                command: null,
+                state: {
+                    _tag: 'Ready',
+                    visible: {
+                        _tag: 'Navigation',
+                        entry: {
+                            _tag: 'PendingCommit'
+                        },
+                        flight: {
+                            _tag: 'Streaming',
+                            resource: state.candidate.resource
+                        },
+                        generation: event.generation
+                    }
+                }
+            };
+        case 'NavigationAborted':
+            if (state.candidate._tag === 'Loading') {
+                return {
+                    command: null,
+                    state: {
+                        _tag: 'Ready',
+                        visible: state.visible
+                    }
+                };
+            }
+            if (state.candidate._tag === 'Publishing') {
+                return {
+                    command: {
+                        _tag: 'ReleaseRoute',
+                        resource: state.candidate.resource
+                    },
+                    state: {
+                        _tag: 'Ready',
+                        visible: state.visible
+                    }
+                };
+            }
+            return {
+                command: {
+                    _tag: 'DiscardRoute',
+                    rendererNavigation: state.candidate.rendererNavigation,
+                    resource: state.candidate.resource
+                },
+                state: {
+                    _tag: 'Ready',
+                    visible: state.visible
+                }
+            };
+    }
+};
+const installClientRouter = Effect.gen(function*() {
+    const browserRenderer = yield* BrowserRenderer;
+    const navigationApi = yield* NavigationApi;
+    const routeLoader = yield* RouteLoader;
+    const run = yield* BrowserEffectRunner;
+    const routerState = MutableRef.make({
+        _tag: 'Ready',
+        visible: {
+            _tag: 'Settled'
+        }
+    });
+    const dispatch = (event)=>{
+        const transition = reduceRouterState(MutableRef.get(routerState), event);
+        MutableRef.set(routerState, transition.state);
+        return transition;
+    };
+    const executeRouterCommand = Effect.fnUntraced(function*(command) {
+        if (command === null) {
+            return;
+        }
+        switch(command._tag){
+            case 'SupersedeCandidate':
+                {
+                    const candidate = command.candidate;
+                    yield* Effect.sync(()=>candidate.lifetime.abort());
+                    if (candidate._tag === 'Loading') {
+                        break;
+                    }
+                    if (candidate._tag === 'Publishing') {
+                        yield* candidate.resource.release;
+                        break;
+                    }
+                    yield* Effect.promise(()=>candidate.rendererNavigation.discard()).pipe(Effect.ensuring(candidate.resource.release));
+                    break;
+                }
+            case 'ReleaseRoute':
+                yield* command.resource.release;
+                break;
+            case 'CacheRoute':
+                yield* Effect.sync(()=>command.cache(command.entry));
+                break;
+            case 'CacheAndReleaseRoute':
+                yield* Effect.sync(()=>command.resource.cache(command.entry));
+                yield* command.resource.release;
+                break;
+            case 'DiscardRoute':
+                yield* Effect.promise(()=>command.rendererNavigation.discard()).pipe(Effect.ensuring(command.resource.release));
+                break;
+            default:
+                throw new TypeError(`Cannot execute the ${command._tag} lifecycle command here.`);
+        }
+    });
+    const openDocument = (event, destination)=>{
+        if (event.navigationType === 'traverse') {
+            navigationApi.replaceDocument(destination.href);
+            return;
+        }
+        navigationApi.navigate(destination.href, {
+            history: event.navigationType === 'replace' ? 'replace' : 'push',
+            info: NativeDocumentNavigationInfo
+        });
+    };
+    const onNavigate = (event)=>{
+        if (!isRoutedNavigation(event)) {
+            return;
+        }
+        const destination = new URL(event.destination.url);
+        const generation = Symbol('NavigationGeneration');
+        const lifetime = new AbortController();
+        const navigationSignal = AbortSignal.any([
+            event.signal,
+            lifetime.signal
+        ]);
+        const begin = dispatch({
+            _tag: 'BeginNavigation',
+            generation,
+            lifetime
+        });
+        void run(executeRouterCommand(begin.command)).catch(()=>undefined);
+        // oxlint-disable-next-line effecttsgo/async-function -- Navigation handlers are native Promise boundaries.
+        const handler = async (precommitController)=>{
+            const preparation = Promise.withResolvers();
+            const navigationAction = Effect.gen(function*() {
+                const resource = yield* routeLoader.load({
+                    destination: event.destination,
+                    navigationType: event.navigationType
+                }).pipe(Effect.onError(()=>Effect.sync(()=>{
+                        dispatch({
+                            _tag: 'FlightFailed',
+                            generation
+                        });
+                    })));
+                if (resource._tag === 'Document') {
+                    dispatch({
+                        _tag: 'DocumentLoaded',
+                        generation
+                    });
+                    yield* resource.release;
+                    openDocument(event, destination);
+                    return {
+                        _tag: 'Handled'
+                    };
+                }
+                const resolvedDestination = preserveRequestedHash(destination, resource.resolvedUrl);
+                if (resolvedDestination.origin !== destination.origin) {
+                    dispatch({
+                        _tag: 'DocumentLoaded',
+                        generation
+                    });
+                    yield* resource.release;
+                    openDocument(event, resolvedDestination);
+                    return {
+                        _tag: 'Handled'
+                    };
+                }
+                if (destination.href !== resolvedDestination.href && (precommitController === undefined || event.navigationType === 'traverse')) {
+                    dispatch({
+                        _tag: 'DocumentLoaded',
+                        generation
+                    });
+                    yield* resource.release;
+                    navigationApi.replaceDocument(resolvedDestination.href);
+                    return {
+                        _tag: 'Handled'
+                    };
+                }
+                const transition = dispatch({
+                    _tag: 'RouteLoaded',
+                    generation,
+                    resource
+                });
+                const command = transition.command;
+                if (command?._tag === 'ReleaseRoute') {
+                    yield* command.resource.release;
+                    return {
+                        _tag: 'Handled'
+                    };
+                }
+                if (command?._tag === 'PublishRoute') {
+                    const rendererNavigation = yield* Effect.sync(()=>{
+                        let navigation;
+                        startTransition(()=>{
+                            const fromIndex = navigationApi.getTransition()?.from.index ?? navigationApi.getCurrentEntry()?.index ?? null;
+                            for (const type of getNavigationTransitionTypes(event, fromIndex)){
+                                addTransitionType(type);
+                            }
+                            navigation = browserRenderer.navigate(command.resource.routeTree);
+                        });
+                        return navigation;
+                    });
+                    const scheduled = dispatch({
+                        _tag: 'RenderScheduled',
+                        generation: command.generation,
+                        rendererNavigation,
+                        resource: command.resource
+                    });
+                    if (scheduled.command !== null) {
+                        yield* executeRouterCommand(scheduled.command);
+                        return {
+                            _tag: 'Handled'
+                        };
+                    }
+                    return {
+                        _tag: 'Rendered',
+                        rendererNavigation,
+                        resolvedDestination,
+                        resource: command.resource
+                    };
+                }
+                throw new TypeError('A loaded route must be published or released.');
+            });
+            // oxlint-disable-next-line effecttsgo/async-function -- React Transition Actions are a native Promise boundary.
+            startTransition(async ()=>{
+                await run(navigationAction, {
+                    signal: navigationSignal
+                }).then(preparation.resolve).catch(preparation.reject);
+            });
+            const abortNavigation = Effect.suspend(()=>{
+                const transition = dispatch({
+                    _tag: 'NavigationAborted',
+                    generation
+                });
+                return executeRouterCommand(transition.command);
+            });
+            const outcome = await preparation.promise.catch((cause)=>{
+                if (navigationSignal.aborted) {
+                    return run(abortNavigation.pipe(Effect.as({
+                        _tag: 'Handled'
+                    })));
+                }
+                if (!event.cancelable && event.navigationType === 'traverse') {
+                    navigationApi.reloadDocument();
+                    return {
+                        _tag: 'Handled'
+                    };
+                }
+                throw cause;
+            });
+            if (outcome._tag === 'Handled') {
+                return;
+            }
+            const { rendererNavigation, resolvedDestination, resource } = outcome;
+            const waitForNavigationCommit = Effect.uninterruptibleMask((restore)=>restore(Effect.promise(()=>rendererNavigation.committed)).pipe(Effect.tap(Effect.suspend(()=>{
+                    const transition = dispatch({
+                        _tag: 'RenderCommitted',
+                        generation
+                    });
+                    return executeRouterCommand(transition.command);
+                })), Effect.onExit((exit)=>Exit.isFailure(exit) ? abortNavigation : Effect["void"])));
+            try {
+                await run(waitForNavigationCommit, {
+                    signal: navigationSignal
+                });
+            } catch (cause) {
+                if (navigationSignal.aborted) {
+                    return;
+                }
+                throw cause;
+            }
+            const waitForRenderRetirement = Effect.gen(function*() {
+                yield* Effect.promise(()=>rendererNavigation.retired);
+                const transition = dispatch({
+                    _tag: 'RenderRetired',
+                    generation
+                });
+                yield* executeRouterCommand(transition.command);
+            }).pipe(Effect.ignore);
+            void run(waitForRenderRetirement).catch(()=>undefined);
+            const waitForFlightCompletion = Effect.gen(function*() {
+                const flightExit = yield* Effect.exit(resource.completed);
+                const transition = dispatch({
+                    _tag: Exit.isSuccess(flightExit) ? 'FlightCompleted' : 'FlightFailed',
+                    generation
+                });
+                yield* executeRouterCommand(transition.command);
+            });
+            void run(waitForFlightCompletion).catch(()=>undefined);
+            if (destination.href !== resolvedDestination.href && precommitController !== undefined) {
+                precommitController.redirect(resolvedDestination.href, {
+                    history: 'auto'
+                });
+            }
+            const commitHistory = Effect.suspend(()=>{
+                const transition = dispatch({
+                    _tag: 'HistoryCommitted',
+                    entry: navigationApi.getCurrentEntry(),
+                    generation
+                });
+                return executeRouterCommand(transition.command);
+            });
+            if (precommitController === undefined) {
+                await run(commitHistory);
+            } else {
+                precommitController.addHandler(()=>run(commitHistory));
+            }
+        };
+        event.intercept(event.cancelable ? {
+            precommitHandler: handler
+        } : {
+            // Browsers make some traversals non-cancelable so an application cannot trap users.
+            handler
+        });
+    };
+    yield* Effect.acquireRelease(Effect.sync(()=>navigationApi.subscribe(onNavigate)), (unsubscribe)=>Effect.sync(unsubscribe));
+});
+
+export { installClientRouter };
+
+//# sourceMappingURL=client-router.js.map