@typed/router 1.0.0-beta.2 → 1.0.0-beta.4

package/src/Matcher.ts

@@ -3,7 +3,7 @@ import type * as Arr from "effect/Array";
 import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
-import { interrupt, isSuccess } from "effect/Exit";
+import { interrupt } from "effect/Exit";
 import { dual, identity } from "effect/Function";
 import * as Result from "effect/Result";
 import * as Layer from "effect/Layer";
@@ -12,12 +12,12 @@ import { type Pipeable, pipeArguments } from "effect/Pipeable";
 import * as Schema from "effect/Schema";
 import { makeFormatterDefault } from "effect/SchemaIssue";
 import * as Scope from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 import * as Stream from "effect/Stream";
 import type { ExcludeTag, ExtractTag, NoInfer, Tags } from "effect/Types";
 import { exit } from "@typed/fx/Fx";
 import { mapEffect } from "@typed/fx/Fx/combinators/mapEffect";
-import { provideServices } from "@typed/fx/Fx/combinators/provide";
+import { provideContext } from "@typed/fx/Fx/combinators/provide";
 import { skipRepeats } from "@typed/fx/Fx/combinators/skipRepeats";
 import { switchMap } from "@typed/fx/Fx/combinators/switchMap";
 import { unwrap } from "@typed/fx/Fx/combinators/unwrap";
@@ -25,7 +25,7 @@ import { fromEffect, never } from "@typed/fx/Fx/constructors/fromEffect";
 import { succeed } from "@typed/fx/Fx/constructors/succeed";
 import type * as Fx from "@typed/fx/Fx/Fx";
 import { fromStream } from "@typed/fx/Fx/stream";
-import { isFx } from "@typed/fx/Fx/TypeId";
+import { FxTypeId, isFx } from "@typed/fx/Fx/TypeId";
 import { RefSubject } from "@typed/fx/RefSubject";
 import { CurrentPath, Navigation } from "@typed/navigation/Navigation";
 import type { MatchAst, RouteAst } from "./AST.js";
@@ -33,6 +33,7 @@ import * as AST from "./AST.js";
 import { CurrentRoute } from "./CurrentRoute.js";
 import { Join, make as makeRoute, type Route } from "./Route.js";
 import type { Router } from "./Router.js";
+import { Sink } from "@typed/fx";
 
 export type Layout<Params, A, E, R, B, E2, R2> = (
   params: LayoutParams<Params, A, E, R>,
@@ -57,7 +58,7 @@ export type AnyLayer =
   | Layer.Layer<never, any, never>
   | Layer.Layer<never, never, any>;
 
-export type AnyServiceMap = ServiceMap.ServiceMap<any> | ServiceMap.ServiceMap<never>;
+export type AnyServiceMap = Context.Context<any> | Context.Context<never>;
 export type AnyDependency = AnyLayer | AnyServiceMap;
 type AnyLayout = Layout<any, any, any, any, any, any, any>;
 type AnyCatch = CatchHandler<any, any, any, any>;
@@ -67,7 +68,7 @@ type AnyMatchHandler = (params: RefSubject.RefSubject<any>) => Fx.Fx<any, any, a
 export type DependencyProvided<D> =
   D extends Layer.Layer<infer Provided, any, any>
     ? Provided
-    : D extends ServiceMap.ServiceMap<infer Provided>
+    : D extends Context.Context<infer Provided>
       ? Provided
       : never;
 export type DependencyError<D> = D extends Layer.Layer<any, infer E, any> ? E : never;
@@ -149,7 +150,10 @@ type ComputeMatchResult<E2, R2, D, LB, LE2, LR2, C, GE, GR> = ApplyCatch<
   C
 >;
 
-export interface Matcher<A, E = never, R = never> extends Pipeable {
+export interface Matcher<A, E = never, R = never>
+  extends
+    Fx.Fx<A, E | RouteNotFound | RouteDecodeError | RouteGuardError, R | Router | Scope.Scope>,
+    Pipeable {
   readonly cases: ReadonlyArray<MatchAst>;
 
   // Overload 1: match(route, handler) - function handler (must be first for inference)
@@ -274,13 +278,11 @@ export interface Matcher<A, E = never, R = never> extends Pipeable {
   >;
 
   readonly provideService: <Id, S>(
-    tag: ServiceMap.Service<Id, S>,
+    tag: Context.Service<Id, S>,
     service: S,
   ) => Matcher<A, E, Exclude<R, Id>>;
 
-  readonly provideServices: <R2>(
-    services: ServiceMap.ServiceMap<R2>,
-  ) => Matcher<A, E, Exclude<R, R2>>;
+  readonly provideContext: <R2>(services: Context.Context<R2>) => Matcher<A, E, Exclude<R, R2>>;
 
   readonly catchCause: <B, E2, R2>(f: CatchHandler<E, B, E2, R2>) => Matcher<A | B, E2, R | R2>;
 
@@ -431,6 +433,15 @@ function parseMatchArgs(args: [unknown, ...Array<unknown>]): ParsedMatch {
 }
 
 class MatcherImpl<A, E, R> implements Matcher<A, E, R> {
+  readonly [FxTypeId]: Fx.Fx.Variance<
+    A,
+    E | RouteNotFound | RouteDecodeError | RouteGuardError,
+    R | Scope.Scope | Router
+  > = {
+    _A: identity,
+    _E: identity,
+    _R: identity,
+  };
   readonly cases: ReadonlyArray<MatchAst>;
   constructor(cases: ReadonlyArray<MatchAst>) {
     this.cases = cases;
@@ -569,12 +580,12 @@ class MatcherImpl<A, E, R> implements Matcher<A, E, R> {
     >;
   }
 
-  provideService<Id, S>(tag: ServiceMap.Service<Id, S>, service: S): Matcher<A, E, Exclude<R, Id>> {
-    return this.provideServices(ServiceMap.make(tag, service));
+  provideService<Id, S>(tag: Context.Service<Id, S>, service: S): Matcher<A, E, Exclude<R, Id>> {
+    return this.provideContext(Context.make(tag, service));
   }
 
-  provideServices<R2>(services: ServiceMap.ServiceMap<R2>): Matcher<A, E, Exclude<R, R2>> {
-    return this.provide(Layer.succeedServices(services));
+  provideContext<R2>(services: Context.Context<R2>): Matcher<A, E, Exclude<R, R2>> {
+    return this.provide(Layer.succeedContext(services));
   }
 
   catchCause<B, E2, R2>(f: CatchHandler<E, B, E2, R2>): Matcher<A | B, E2, R | R2> {
@@ -660,118 +671,13 @@ class MatcherImpl<A, E, R> implements Matcher<A, E, R> {
   pipe() {
     return pipeArguments(this, arguments);
   }
-}
-
-function normalizeHandler<Params, B, E2 = never, R2 = never>(
-  handler: MatchHandler<Params, B, E2, R2>,
-): (params: RefSubject.RefSubject<Params>) => Fx.Fx<B, E2, R2> {
-  if (isMatchHandlerFn(handler)) return (params) => toFx(handler(params));
-  return () => toFx(handler);
-}
-
-function toFx<A, E, R>(
-  value: Fx.Fx<A, E, R> | Stream.Stream<A, E, R> | Effect.Effect<A, E, R> | A,
-): Fx.Fx<A, E, R> {
-  if (isFx(value)) return value;
-  if (Stream.isStream(value)) return fromStream(value);
-  if (Effect.isEffect(value)) return fromEffect(value);
-  return succeed(value);
-}
-
-export const empty: Matcher<never> = new MatcherImpl([]);
-export const match = empty.match.bind(empty);
-
-/**
- * Merge multiple matchers into one. Each matcher's layouts and provide apply only to its own routes.
- * Use this so directory layouts (e.g. api/_layout) and directory dependencies apply only to routes under that directory.
- */
-export function merge<const Matchers extends ReadonlyArray<Matcher.Any>>(
-  ...matchers: Matchers
-): Matcher<
-  Matcher.MergeSuccess<Matchers>,
-  Matcher.MergeError<Matchers>,
-  Matcher.MergeServices<Matchers>
-> {
-  if (matchers.length === 0) {
-    return empty as unknown as Matcher<
-      Matcher.MergeSuccess<Matchers>,
-      Matcher.MergeError<Matchers>,
-      Matcher.MergeServices<Matchers>
-    >;
-  }
-  if (matchers.length === 1) {
-    return matchers[0] as unknown as Matcher<
-      Matcher.MergeSuccess<Matchers>,
-      Matcher.MergeError<Matchers>,
-      Matcher.MergeServices<Matchers>
-    >;
-  }
-  const first = matchers[0] as MatcherImpl<
-    Matcher.MergeSuccess<Matchers>,
-    Matcher.MergeError<Matchers>,
-    Matcher.MergeServices<Matchers>
-  >;
-  const rest = matchers.slice(1) as ReadonlyArray<
-    Matcher<
-      Matcher.MergeSuccess<Matchers>,
-      Matcher.MergeError<Matchers>,
-      Matcher.MergeServices<Matchers>
-    >
-  >;
-  return first.merge(...rest) as unknown as Matcher<
-    Matcher.MergeSuccess<Matchers>,
-    Matcher.MergeError<Matchers>,
-    Matcher.MergeServices<Matchers>
-  >;
-}
 
-export class RouteGuardError extends Schema.ErrorClass<RouteGuardError>(
-  "@typed/router/RouteGuardError",
-)({
-  _tag: Schema.tag("RouteGuardError"),
-  path: Schema.String,
-  causes: Schema.Array(Schema.Unknown),
-}) {}
-
-export class RouteNotFound extends Schema.ErrorClass<RouteNotFound>("@typed/router/RouteNotFound")({
-  _tag: Schema.tag("RouteNotFound"),
-  path: Schema.String,
-}) {}
-
-export class RouteDecodeError extends Schema.ErrorClass<RouteDecodeError>(
-  "@typed/router/RouteDecodeError",
-)({
-  _tag: Schema.tag("RouteDecodeError"),
-  path: Schema.String,
-  cause: Schema.String,
-}) {}
-
-/**
- * @internal
- */
-export type CompiledEntry = {
-  readonly route: Route.Any;
-  readonly guard: AnyGuard;
-  readonly handler: AnyMatchHandler;
-  readonly layers: ReadonlyArray<AnyLayer>;
-  readonly layouts: ReadonlyArray<AnyLayout>;
-  readonly catches: ReadonlyArray<AnyCatch>;
-  readonly decode: (input: unknown) => Effect.Effect<any, Schema.SchemaError, any>;
-};
-
-export function run<M extends Matcher.Any>(
-  matcher: M,
-): Fx.Fx<
-  Matcher.Success<M>,
-  Matcher.Error<M> | RouteNotFound | RouteDecodeError | RouteGuardError,
-  Matcher.Services<M> | Router | CurrentRoute | Scope.Scope
-> {
-  return unwrap(
-    Effect.gen(function* () {
+  run<RSink>(sink: Sink.Sink<A, E | RouteNotFound | RouteDecodeError | RouteGuardError, RSink>) {
+    return Effect.gen({ self: this }, function* () {
       const fiberId = yield* Effect.fiberId;
       const rootScope = yield* Effect.scope;
       const current = yield* CurrentRoute;
-      const prefixed = matcher.prefix(current.route);
+      const prefixed = this.prefix(current.route);
       const entries = compile(prefixed.cases);
       const router = findMyWay.make<ReadonlyArray<CompiledEntry>>({
         ignoreTrailingSlash: true,
@@ -798,11 +704,11 @@ export function run<M extends Matcher.Any>(
       let currentState: {
         entry: CompiledEntry;
         params: RefSubject.RefSubject<any>;
-        fx: Fx.Fx<Matcher.Success<M>, Matcher.Error<M>, Matcher.Services<M> | Scope.Scope | Router>;
+        fx: Fx.Fx<A, E, R | Scope.Scope | Router>;
         scope: Scope.Closeable;
       } | null = null;
 
-      return CurrentPath.pipe(
+      const stream = CurrentPath.pipe(
         mapEffect(
           Effect.fn(function* (path) {
             const result = router.find("GET", path);
@@ -831,7 +737,7 @@ export function run<M extends Matcher.Any>(
               const prepared = yield* layerManager.prepare(entry.layers);
               const guardExit = yield* entry
                 .guard(params)
-                .pipe(Effect.provideServices(prepared.services), Effect.exit);
+                .pipe(Effect.provideContext(prepared.services), Effect.exit);
 
               if (Exit.isFailure(guardExit)) {
                 guardCauses.push(guardExit.cause);
@@ -870,15 +776,13 @@ export function run<M extends Matcher.Any>(
             const scope = yield* Scope.fork(rootScope);
             const paramsRef = yield* RefSubject.make(matchedParams).pipe(Scope.provide(scope));
 
-            const preparedServices = matchedPrepared.services as ServiceMap.ServiceMap<any>;
-            const handlerServices = ServiceMap.merge(
+            const preparedServices = matchedPrepared.services as Context.Context<any>;
+            const handlerServices = Context.merge(
               preparedServices,
-              ServiceMap.make(Scope.Scope, scope),
+              Context.make(Scope.Scope, scope),
             );
 
-            const handlerFx = matchedEntry
-              .handler(paramsRef)
-              .pipe(provideServices(handlerServices));
+            const handlerFx = matchedEntry.handler(paramsRef).pipe(provideContext(handlerServices));
             const withLayouts = yield* layoutManager.apply(
               matchedEntry.layouts,
               matchedParams,
@@ -905,10 +809,109 @@ export function run<M extends Matcher.Any>(
         skipRepeats,
         switchMap(identity),
       );
-    }),
-  );
+
+      return yield* stream.run(sink);
+    });
+  }
+}
+
+function normalizeHandler<Params, B, E2 = never, R2 = never>(
+  handler: MatchHandler<Params, B, E2, R2>,
+): (params: RefSubject.RefSubject<Params>) => Fx.Fx<B, E2, R2> {
+  if (isMatchHandlerFn(handler)) return (params) => toFx(handler(params));
+  return () => toFx(handler);
+}
+
+function toFx<A, E, R>(
+  value: Fx.Fx<A, E, R> | Stream.Stream<A, E, R> | Effect.Effect<A, E, R> | A,
+): Fx.Fx<A, E, R> {
+  if (isFx(value)) return value;
+  if (Stream.isStream(value)) return fromStream(value);
+  if (Effect.isEffect(value)) return fromEffect(value);
+  return succeed(value);
+}
+
+export const empty: Matcher<never> = new MatcherImpl([]);
+export const match = empty.match.bind(empty);
+
+/**
+ * Merge multiple matchers into one. Each matcher's layouts and provide apply only to its own routes.
+ * Use this so directory layouts (e.g. api/_layout) and directory dependencies apply only to routes under that directory.
+ */
+export function merge<const Matchers extends ReadonlyArray<Matcher.Any>>(
+  ...matchers: Matchers
+): Matcher<
+  Matcher.MergeSuccess<Matchers>,
+  Matcher.MergeError<Matchers>,
+  Matcher.MergeServices<Matchers>
+> {
+  if (matchers.length === 0) {
+    return empty as unknown as Matcher<
+      Matcher.MergeSuccess<Matchers>,
+      Matcher.MergeError<Matchers>,
+      Matcher.MergeServices<Matchers>
+    >;
+  }
+  if (matchers.length === 1) {
+    return matchers[0] as unknown as Matcher<
+      Matcher.MergeSuccess<Matchers>,
+      Matcher.MergeError<Matchers>,
+      Matcher.MergeServices<Matchers>
+    >;
+  }
+  const first = matchers[0] as MatcherImpl<
+    Matcher.MergeSuccess<Matchers>,
+    Matcher.MergeError<Matchers>,
+    Matcher.MergeServices<Matchers>
+  >;
+  const rest = matchers.slice(1) as ReadonlyArray<
+    Matcher<
+      Matcher.MergeSuccess<Matchers>,
+      Matcher.MergeError<Matchers>,
+      Matcher.MergeServices<Matchers>
+    >
+  >;
+  return first.merge(...rest) as unknown as Matcher<
+    Matcher.MergeSuccess<Matchers>,
+    Matcher.MergeError<Matchers>,
+    Matcher.MergeServices<Matchers>
+  >;
 }
 
+export class RouteGuardError extends Schema.ErrorClass<RouteGuardError>(
+  "@typed/router/RouteGuardError",
+)({
+  _tag: Schema.tag("RouteGuardError"),
+  path: Schema.String,
+  causes: Schema.Array(Schema.Unknown),
+}) {}
+
+export class RouteNotFound extends Schema.ErrorClass<RouteNotFound>("@typed/router/RouteNotFound")({
+  _tag: Schema.tag("RouteNotFound"),
+  path: Schema.String,
+}) {}
+
+export class RouteDecodeError extends Schema.ErrorClass<RouteDecodeError>(
+  "@typed/router/RouteDecodeError",
+)({
+  _tag: Schema.tag("RouteDecodeError"),
+  path: Schema.String,
+  cause: Schema.String,
+}) {}
+
+/**
+ * @internal
+ */
+export type CompiledEntry = {
+  readonly route: Route.Any;
+  readonly guard: AnyGuard;
+  readonly handler: AnyMatchHandler;
+  readonly layers: ReadonlyArray<AnyLayer>;
+  readonly layouts: ReadonlyArray<AnyLayout>;
+  readonly catches: ReadonlyArray<AnyCatch>;
+  readonly decode: (input: unknown) => Effect.Effect<any, Schema.SchemaError, any>;
+};
+
 type InputSucces<T> = [Matcher.Success<T> | Fx.Fx.Success<T>] extends [infer A] ? A : never;
 type InputError<T> = [Matcher.Error<T> | Fx.Fx.Error<T>] extends [infer E] ? E : never;
 type InputServices<T> = [Matcher.Services<T> | Fx.Fx.Services<T>] extends [infer R] ? R : never;
@@ -943,13 +946,8 @@ export const catchCause: {
     const eff = Effect.gen(function* () {
       const fiberId = yield* Effect.fiberId;
       const rootScope = yield* Effect.scope;
-      const fx = isFx(input) ? input : run(input);
       const manager = makeCatchManager(rootScope, fiberId);
-      const result = yield* manager.apply(
-        [f],
-        fx,
-        ServiceMap.empty() as ServiceMap.ServiceMap<any>,
-      );
+      const result = yield* manager.apply([f], input, Context.empty() as Context.Context<any>);
       return result as Fx.Fx<A | B, E2, R | R2 | Router | Scope.Scope>;
     });
     return unwrap(eff);
@@ -960,6 +958,11 @@ export const catch_: {
   <I extends Fx.Fx.Any | Matcher.Any, B, E2, R2>(
     f: (e: InputError<I>) => Fx.Fx<B, E2, R2>,
   ): (input: I) => Fx.Fx<InputSucces<I> | B, E2, InputServices<I> | R2 | Router | Scope.Scope>;
+
+  <I extends Fx.Fx.Any | Matcher.Any, B, E2, R2>(
+    input: I,
+    f: (e: InputError<I>) => Fx.Fx<B, E2, R2>,
+  ): Fx.Fx<InputSucces<I> | B, E2, InputServices<I> | R2 | Router | Scope.Scope>;
 } = dual(
   2,
   <I extends Fx.Fx.Any | Matcher.Any, B, E2, R2>(
@@ -1082,7 +1085,7 @@ function isServiceMap(dep: AnyDependency): dep is AnyServiceMap {
 }
 
 function toSingleLayer(dep: AnyDependency): AnyLayer {
-  if (isServiceMap(dep)) return Layer.succeedServices(dep);
+  if (isServiceMap(dep)) return Layer.succeedContext(dep);
   return dep;
 }
 
@@ -1092,26 +1095,27 @@ function normalizeDependencies(
   return dependencies.map(toSingleLayer);
 }
 
-type NormalizeLayer<T extends AnyDependency> = 
-  T extends Layer.Layer<infer A, infer E, infer R> ? Layer.Layer<A, E, R> : T extends ServiceMap.ServiceMap<infer R> ? Layer.Layer<R> : never
-    
-type NormalizeLayers<T extends ReadonlyArray<AnyDependency>> ={
-  [K in keyof T]: NormalizeLayer<T[K]>
-}
+type NormalizeLayer<T extends AnyDependency> =
+  T extends Layer.Layer<infer A, infer E, infer R>
+    ? Layer.Layer<A, E, R>
+    : T extends Context.Context<infer R>
+      ? Layer.Layer<R>
+      : never;
+
+type NormalizeLayers<T extends ReadonlyArray<AnyDependency>> = {
+  [K in keyof T]: NormalizeLayer<T[K]>;
+};
 
-type ToLayer<T> = 
-  T extends ReadonlyArray<AnyLayer> ? Layer.Layer<
-    Layer.Success<T[number]>,
-    Layer.Error<T[number]>,
-    Layer.Services<T[number]>
-  > : never
+type ToLayer<T> =
+  T extends ReadonlyArray<AnyLayer>
+    ? Layer.Layer<Layer.Success<T[number]>, Layer.Error<T[number]>, Layer.Services<T[number]>>
+    : never;
 
-type NormalizeDeps<T extends AnyDependency | ReadonlyArray<AnyDependency>> =
-  T extends AnyDependency
+type NormalizeDeps<T extends AnyDependency | ReadonlyArray<AnyDependency>> = T extends AnyDependency
   ? NormalizeLayer<T>
   : T extends ReadonlyArray<AnyDependency>
-  ? ToLayer<NormalizeLayers<T>>
-  : never
+    ? ToLayer<NormalizeLayers<T>>
+    : never;
 
 /**
  * Normalize dependency input (ServiceMap | Layer | Array of either) into a single Layer.
@@ -1241,18 +1245,18 @@ export function makeLayerManager(memoMap: Layer.MemoMap, rootScope: Scope.Scope,
           : ((cachedDesiredSet = new Set(desired)), (cachedOrder = desired), cachedDesiredSet);
       const removed = order.filter((layer) => !desiredSet.has(layer));
       const added: Array<AnyLayer> = [];
-      let services = ServiceMap.empty();
+      let services = Context.empty();
 
       for (const layer of desired) {
         const existing = states.get(layer);
         if (existing) {
-          services = ServiceMap.merge(services, existing.services);
+          services = Context.merge(services, existing.services);
           continue;
         }
 
         const scope = yield* Scope.fork(rootScope);
         const buildExit = yield* Layer.buildWithMemoMap(layer, memoMap, scope).pipe(
-          Effect.provideServices(services),
+          Effect.provideContext(services),
           Effect.exit,
         );
 
@@ -1270,7 +1274,7 @@ export function makeLayerManager(memoMap: Layer.MemoMap, rootScope: Scope.Scope,
         }
 
         const servicesForLayer = buildExit.value;
-        services = ServiceMap.merge(services, servicesForLayer);
+        services = Context.merge(services, servicesForLayer);
         states.set(layer, { scope, services: servicesForLayer });
         added.push(layer);
       }
@@ -1336,7 +1340,7 @@ export function makeLayoutManager(rootScope: Scope.Scope, fiberId: number) {
     layouts: ReadonlyArray<AnyLayout>,
     paramsValue: any,
     inner: Fx.Fx<any, any, any>,
-    services: ServiceMap.ServiceMap<any>,
+    services: Context.Context<any>,
   ) =>
     Effect.gen(function* () {
       let current = inner;
@@ -1350,7 +1354,7 @@ export function makeLayoutManager(rootScope: Scope.Scope, fiberId: number) {
             eq: (left, right) => left === right,
           }).pipe(Scope.provide(scope));
           const fx = layout({ params, content: content.pipe(switchMap(identity)) }).pipe(
-            provideServices(ServiceMap.merge(services, ServiceMap.make(Scope.Scope, scope))),
+            provideContext(Context.merge(services, Context.make(Scope.Scope, scope))),
           );
           states.set(layout, { params, content, fx, scope });
           current = fx;
@@ -1409,7 +1413,7 @@ export function makeCatchManager(rootScope: Scope.Scope, fiberId: number) {
   const apply = (
     catches: ReadonlyArray<AnyCatch>,
     inner: Fx.Fx<any, any, any>,
-    services: ServiceMap.ServiceMap<any>,
+    services: Context.Context<any>,
   ) =>
     Effect.gen(function* () {
       let current = inner;
@@ -1425,14 +1429,14 @@ export function makeCatchManager(rootScope: Scope.Scope, fiberId: number) {
             eq: (left, right) => left === right,
           }).pipe(Scope.provide(scope));
           const fallback = catcher(causes).pipe(
-            provideServices(ServiceMap.merge(services, ServiceMap.make(Scope.Scope, scope))),
+            provideContext(Context.merge(services, Context.make(Scope.Scope, scope))),
           );
           const fx = content.pipe(
             switchMap(identity),
             exit,
             mapEffect(
               Effect.fn(function* (e) {
-                if (isSuccess(e)) return succeed(e.value);
+                if (Exit.isSuccess(e)) return succeed(e.value);
                 yield* RefSubject.set(causes, e.cause);
                 return fallback;
               }),

package/src/test-utils/matcherBrowserHarness.ts

@@ -0,0 +1,22 @@
+import * as Effect from "effect/Effect";
+import { BrowserRouter, Router } from "../Router.js";
+import { Scope } from "effect";
+
+/**
+ * Build an absolute URL for the Vitest browser page origin (same pattern as in-memory tests using http://localhost/...).
+ */
+export const absoluteUrl = (
+  path: string,
+  win: Window & typeof globalThis = globalThis.window,
+): string => {
+  const normalized = path.startsWith("/") ? path : `/${path}`;
+  return new URL(normalized, win.location.origin).href;
+};
+
+/**
+ * Run an effect with {@link BrowserRouter} scoped over the real (or test) `window`.
+ */
+export const runWithBrowserRouter = <A, E>(
+  effect: Effect.Effect<A, E, Router | Scope.Scope>,
+  win: Window & typeof globalThis = globalThis.window,
+): Promise<A> => effect.pipe(Effect.provide(BrowserRouter(win)), Effect.scoped, Effect.runPromise);