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

package/src/Matcher.test.ts

@@ -2,20 +2,28 @@ import { assert, describe, it } from "vitest";
 import * as Cause from "effect/Cause";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
 import * as Latch from "effect/Latch";
 import * as Fiber from "effect/Fiber";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Ref from "effect/Ref";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Result from "effect/Result";
+import * as Context from "effect/Context";
 import { Fx } from "@typed/fx";
+import type { RefSubject } from "@typed/fx/RefSubject";
 import { Navigation } from "@typed/navigation";
 import * as Matcher from "./Matcher.js";
 import * as Route from "./Route.js";
 import { ServerRouter } from "./Router.js";
 
+/** Runs a fully-scoped Effect in tests; `as any` avoids R-channel mismatch with `Effect.runPromise`. */
+const runEff = (eff: Effect.Effect<unknown, unknown, unknown>) => Effect.runPromise(eff as any);
+
 class TestError extends Data.TaggedError("TestError")<{ readonly message: string }> {}
 
+class OtherError extends Data.TaggedError("OtherError")<{ readonly message: string }> {}
+
 describe("typed/router/Matcher", () => {
   it("type check for match options inference", () => {
     const route = Route.Parse("type");
@@ -38,8 +46,7 @@ describe("typed/router/Matcher", () => {
         layout: ({ content }) => Fx.map(content, (n) => `wrapped:${n}`),
       });
 
-      const fx = Matcher.run(matcher);
-      const values = yield* Fx.collectAll(Fx.take(fx, 1));
+      const values = yield* Fx.collectAll(Fx.take(matcher, 1));
 
       assert.deepStrictEqual(values, ["wrapped:42"]);
     }).pipe(
@@ -53,11 +60,9 @@ describe("typed/router/Matcher", () => {
       const users = Route.Join(Route.Parse("users"), Route.Param("id"));
       const about = Route.Parse("about");
 
-      const fx = Matcher.run(
-        Matcher.empty
-          .match(users, (params) => Fx.map(params, ({ id }) => `users:${id}`))
-          .match(about, "about"),
-      );
+      const fx = Matcher.empty
+        .match(users, (params) => Fx.map(params, ({ id }) => `users:${id}`))
+        .match(about, "about");
 
       const values: Array<string> = [];
       const first = Latch.makeUnsafe();
@@ -93,14 +98,14 @@ describe("typed/router/Matcher", () => {
   it("fails with RouteNotFound when no route matches", () =>
     Effect.gen(function* () {
       const route = Route.Parse("about");
-      const fx = Matcher.run(Matcher.empty.match(route, "about"));
+      const fx = Matcher.empty.match(route, () => "about");
 
-      const result = yield* Fx.collectAll(Fx.take(fx, 1)).pipe(
-        Effect.as("matched" as const),
+      const path = yield* Fx.collectAll(Fx.take(fx, 1)).pipe(
+        Effect.as("" as const),
         Effect.catchTag("RouteNotFound", (e) => Effect.succeed(e.path)),
       );
 
-      assert.strictEqual(result, "/nope");
+      assert.strictEqual(path, "/nope");
     }).pipe(
       Effect.provide(ServerRouter({ url: "http://localhost/nope" })),
       Effect.scoped,
@@ -116,7 +121,7 @@ describe("typed/router/Matcher", () => {
         Fx.unwrap(Ref.update(mounts, (n) => n + 1).pipe(Effect.as(Fx.map(params, ({ id }) => id)))),
       );
 
-      const fx = Matcher.run(matcher);
+      const fx = matcher;
 
       const values: Array<string> = [];
       const first = Latch.makeUnsafe();
@@ -155,22 +160,20 @@ describe("typed/router/Matcher", () => {
       const users = Route.Join(Route.Parse("users"), Route.Param("id"));
       const calls = yield* Ref.make<ReadonlyArray<string>>([]);
 
-      const fx = Matcher.run(
-        Matcher.empty
-          .match(
-            users,
-            () => Ref.update(calls, (entries) => [...entries, "g1"]).pipe(Effect.as(Option.none())),
-            "skip",
-          )
-          .match(
-            users,
-            (input) =>
-              Ref.update(calls, (entries) => [...entries, "g2"]).pipe(
-                Effect.as(Option.some({ ...input, ok: true as const })),
-              ),
-            (params) => Fx.map(params, (p) => p.ok),
-          ),
-      );
+      const fx = Matcher.empty
+        .match(
+          users,
+          () => Ref.update(calls, (entries) => [...entries, "g1"]).pipe(Effect.as(Option.none())),
+          "skip",
+        )
+        .match(
+          users,
+          (input) =>
+            Ref.update(calls, (entries) => [...entries, "g2"]).pipe(
+              Effect.as(Option.some({ ...input, ok: true as const })),
+            ),
+          (params) => Fx.map(params, (p) => p.ok),
+        );
 
       const values = yield* Fx.collectAll(Fx.take(fx, 1));
       assert.deepStrictEqual(values, [true]);
@@ -184,11 +187,9 @@ describe("typed/router/Matcher", () => {
   it("accumulates guard failures when no guard matches", () =>
     Effect.gen(function* () {
       const users = Route.Join(Route.Parse("users"), Route.Param("id"));
-      const fx = Matcher.run(
-        Matcher.empty
-          .match(users, () => Effect.fail("g1"), "ok")
-          .match(users, () => Effect.fail("g2"), "ok"),
-      );
+      const fx = Matcher.empty
+        .match(users, () => Effect.fail("g1"), "ok")
+        .match(users, () => Effect.fail("g2"), "ok");
 
       const result = yield* Fx.collectAll(Fx.take(fx, 1)).pipe(
         Effect.as(0),
@@ -207,22 +208,20 @@ describe("typed/router/Matcher", () => {
       const mounts = yield* Ref.make(0);
       const layouts = yield* Ref.make(0);
 
-      const sharedLayer = Layer.effectServices(
-        Ref.update(mounts, (n) => n + 1).pipe(Effect.as(ServiceMap.empty())),
+      const sharedLayer = Layer.effectContext(
+        Ref.update(mounts, (n) => n + 1).pipe(Effect.as(Context.empty())),
       );
 
       const users = Route.Join(Route.Parse("users"), Route.Param("id"));
       const about = Route.Parse("about");
 
-      const fx = Matcher.run(
-        Matcher.empty
-          .match(users, (params) => Fx.map(params, ({ id }) => `users:${id}`))
-          .match(about, "about")
-          .provide(sharedLayer)
-          .layout(({ content }) =>
-            Fx.unwrap(Ref.update(layouts, (n) => n + 1).pipe(Effect.as(content))),
-          ),
-      );
+      const fx = Matcher.empty
+        .match(users, (params) => Fx.map(params, ({ id }) => `users:${id}`))
+        .match(about, "about")
+        .provide(sharedLayer)
+        .layout(({ content }) =>
+          Fx.unwrap(Ref.update(layouts, (n) => n + 1).pipe(Effect.as(content))),
+        );
 
       const values: Array<string> = [];
       const first = Latch.makeUnsafe();
@@ -263,7 +262,7 @@ describe("typed/router/Matcher", () => {
   it("ignores trailing slashes", () =>
     Effect.gen(function* () {
       const about = Route.Parse("about");
-      const fx = Matcher.run(Matcher.empty.match(about, "about"));
+      const fx = Matcher.empty.match(about, "about");
 
       const values = yield* Fx.collectAll(Fx.take(fx, 1));
       assert.deepStrictEqual(values, ["about"]);
@@ -276,7 +275,7 @@ describe("typed/router/Matcher", () => {
   it("is case insensitive", () =>
     Effect.gen(function* () {
       const about = Route.Parse("about");
-      const fx = Matcher.run(Matcher.empty.match(about, "about"));
+      const fx = Matcher.empty.match(about, "about");
 
       const values = yield* Fx.collectAll(Fx.take(fx, 1));
       assert.deepStrictEqual(values, ["about"]);
@@ -290,15 +289,13 @@ describe("typed/router/Matcher", () => {
     Effect.gen(function* () {
       const users = Route.Join(Route.Parse("users"), Route.Param("id"));
 
-      const fx = Matcher.run(
-        Matcher.empty
-          .match(users, () => Effect.fail("guard1-error"), "never")
-          .match(
-            users,
-            (input) => Effect.succeed(Option.some({ ...input, ok: true as const })),
-            "matched",
-          ),
-      );
+      const fx = Matcher.empty
+        .match(users, () => Effect.fail("guard1-error"), "never")
+        .match(
+          users,
+          (input) => Effect.succeed(Option.some({ ...input, ok: true as const })),
+          "matched",
+        );
 
       const values = yield* Fx.collectAll(Fx.take(fx, 1));
       assert.deepStrictEqual(values, ["matched"]);
@@ -312,11 +309,9 @@ describe("typed/router/Matcher", () => {
     Effect.gen(function* () {
       const users = Route.Join(Route.Parse("users"), Route.Param("id"));
 
-      const fx = Matcher.run(
-        Matcher.empty
-          .match(users, () => Effect.succeed(Option.none()), "never1")
-          .match(users, () => Effect.succeed(Option.none()), "never2"),
-      );
+      const fx = Matcher.empty
+        .match(users, () => Effect.succeed(Option.none()), "never1")
+        .match(users, () => Effect.succeed(Option.none()), "never2");
 
       const result = yield* Fx.collectAll(Fx.take(fx, 1)).pipe(
         Effect.as("matched" as const),
@@ -338,7 +333,7 @@ describe("typed/router/Matcher", () => {
         .match(about, Fx.fail(new TestError({ message: "fail" })))
         .catch(() => Fx.succeed("recovered"));
 
-      const fx = Matcher.run(matcher);
+      const fx = matcher;
       const values = yield* Fx.collectAll(Fx.take(fx, 1));
 
       assert.deepStrictEqual(values, ["recovered"]);
@@ -356,7 +351,7 @@ describe("typed/router/Matcher", () => {
         .match(about, Fx.fail(new TestError({ message: "fail" })))
         .catchTag("TestError", () => Fx.succeed("recovered"));
 
-      const fx = Matcher.run(matcher);
+      const fx = matcher;
       const values = yield* Fx.collectAll(Fx.take(fx, 1));
 
       assert.deepStrictEqual(values, ["recovered"]);
@@ -385,14 +380,294 @@ describe("typed/router/Matcher", () => {
           ),
         );
 
-      const fx = Matcher.run(matcher);
+      const fx = matcher;
       const values = yield* Fx.collectAll(Fx.take(fx, 1));
 
       assert.deepStrictEqual(values, ["recovered"]);
-    }).pipe(Effect.provide(ServerRouter({ url: "http://localhost/about" }))));
+    }).pipe(
+      Effect.provide(ServerRouter({ url: "http://localhost/about" })),
+      Effect.scoped,
+      Effect.runPromise,
+    ));
 
-  // TODO: Matcher.catchCause function test times out - may need investigation
-  // The Matcher.catchCause() method tests pass, so basic catch functionality is verified
+  describe("function Matcher.catch* and error origins", () => {
+    it("Matcher.catchCause (function) recovers defect from Effect.sync throw in inner handler Fx", () =>
+      runEff(
+        Effect.gen(function* () {
+          const about = Route.Parse("about");
+          const inner = Matcher.empty.match(about, () =>
+            Fx.unwrap(
+              Effect.sync(() => {
+                throw new Error("sync-boom");
+              }),
+            ),
+          );
+          const handler = (causeRef: RefSubject.RefSubject<Cause.Cause<unknown>>) =>
+            Fx.unwrap(
+              Effect.gen(function* () {
+                const cause = yield* causeRef;
+                if (Cause.hasFails(cause)) {
+                  return Fx.fromEffect(Effect.failCause(cause));
+                }
+                return Fx.succeed("recovered-sync");
+              }),
+            );
+          const wide = inner as any;
+          const a = yield* Fx.collectAll(Fx.take(Matcher.catchCause(handler)(wide), 1));
+          const b = yield* Fx.collectAll(Fx.take(Matcher.catchCause(wide, handler), 1));
+          assert.deepStrictEqual(a, ["recovered-sync"]);
+          assert.deepStrictEqual(b, ["recovered-sync"]);
+        }).pipe(Effect.provide(ServerRouter({ url: "http://localhost/about" })), Effect.scoped),
+      ));
+
+    it("RouteGuardError from failed guards is recoverable at Effect boundary (mapEffect failure)", () =>
+      runEff(
+        Effect.gen(function* () {
+          const users = Route.Join(Route.Parse("users"), Route.Param("id"));
+          const inner = Matcher.empty
+            .match(users, () => Effect.fail("g1"), "a")
+            .match(users, () => Effect.fail("g2"), "b");
+          const recovered = yield* Fx.collectAll(Fx.take(inner, 1)).pipe(
+            Effect.as("" as const),
+            Effect.catchTag("RouteGuardError" as const, () =>
+              Effect.succeed("recovered-guard" as const),
+            ),
+          );
+          assert.strictEqual(recovered, "recovered-guard");
+        }).pipe(Effect.provide(ServerRouter({ url: "http://localhost/users/1" })), Effect.scoped),
+      ));
+
+    it("Matcher.catchTag (function, curried) recovers inner Fx TestError", () =>
+      runEff(
+        Effect.gen(function* () {
+          const about = Route.Parse("about");
+          const inner = Matcher.empty.match(about, Fx.fail(new TestError({ message: "inner" })));
+          const fx = (Matcher.catchTag as any)("TestError", () => Fx.succeed("recovered-fx"))(
+            inner,
+          );
+          const values = yield* Fx.collectAll(Fx.take(fx, 1));
+          assert.deepStrictEqual(values, ["recovered-fx"]);
+        }).pipe(Effect.provide(ServerRouter({ url: "http://localhost/about" })), Effect.scoped),
+      ));
+
+    it("Matcher.catch (function) recovers typed fail from inner stream", () =>
+      runEff(
+        Effect.gen(function* () {
+          const about = Route.Parse("about");
+          const inner = Matcher.empty.match(about, Fx.fail(new TestError({ message: "x" })));
+          const fx = Matcher.catch(() => Fx.succeed("recovered-catch-fn"))(inner as any);
+          const values = yield* Fx.collectAll(Fx.take(fx, 1));
+          assert.deepStrictEqual(values, ["recovered-catch-fn"]);
+        }).pipe(Effect.provide(ServerRouter({ url: "http://localhost/about" })), Effect.scoped),
+      ));
+
+    it("function Matcher.catchCause recovers OtherError from inner Fx (typed fail path)", () =>
+      runEff(
+        Effect.gen(function* () {
+          const about = Route.Parse("about");
+          const inner = Matcher.empty.match(about, Fx.fail(new OtherError({ message: "o" })));
+          const fx = Matcher.catchCause((causeRef) =>
+            Fx.unwrap(
+              Effect.gen(function* () {
+                const cause = yield* causeRef;
+                const fr = Cause.findFail(cause);
+                if (Result.isFailure(fr)) {
+                  return Fx.fromEffect(Effect.failCause(fr.failure));
+                }
+                const err = fr.success.error as OtherError;
+                assert.strictEqual(err._tag, "OtherError");
+                return Fx.succeed("from-outer-cause");
+              }),
+            ),
+          )(inner as any);
+          const values = yield* Fx.collectAll(Fx.take(fx, 1));
+          assert.deepStrictEqual(values, ["from-outer-cause"]);
+        }).pipe(Effect.provide(ServerRouter({ url: "http://localhost/about" })), Effect.scoped),
+      ));
+
+    it("stacked function catchTag then catchTag: inner recovers TestError, outer does not see failure", () =>
+      runEff(
+        Effect.gen(function* () {
+          const about = Route.Parse("about");
+          const inner = Matcher.empty.match(about, Fx.fail(new TestError({ message: "t" })));
+          const wrapped = (Matcher.catchTag as any)("TestError", () => Fx.succeed("inner-ok"))(
+            inner,
+          );
+          const fx = (Matcher.catchTag as any)("RouteNotFound", () => Fx.succeed("should-not-run"))(
+            wrapped,
+          );
+          const values = yield* Fx.collectAll(Fx.take(fx, 1));
+          assert.deepStrictEqual(values, ["inner-ok"]);
+        }).pipe(Effect.provide(ServerRouter({ url: "http://localhost/about" })), Effect.scoped),
+      ));
+
+    it("multiple layout calls compose outermost layout last", () =>
+      runEff(
+        Effect.gen(function* () {
+          const about = Route.Parse("about");
+          const fx = Matcher.empty
+            .match(about, Fx.succeed("core"))
+            .layout(({ content }) => Fx.map(content, (s) => `L1:${s}`))
+            .layout(({ content }) => Fx.map(content, (s) => `L2:${s}`));
+          const values = yield* Fx.collectAll(Fx.take(fx, 1));
+          assert.deepStrictEqual(values, ["L2:L1:core"]);
+        }).pipe(Effect.provide(ServerRouter({ url: "http://localhost/about" })), Effect.scoped),
+      ));
+
+    it("multiple layout calls keep inner layout mounted once when params update on same route", () =>
+      runEff(
+        Effect.gen(function* () {
+          const l1 = yield* Ref.make(0);
+          const l2 = yield* Ref.make(0);
+          const users = Route.Join(Route.Parse("users"), Route.Param("id"));
+          const fx = Matcher.empty
+            .match(users, (params) => Fx.map(params, ({ id }) => id))
+            .layout(({ content }) =>
+              Fx.unwrap(
+                Ref.update(l1, (n) => n + 1).pipe(Effect.as(Fx.map(content, (s) => `A:${s}`))),
+              ),
+            )
+            .layout(({ content }) =>
+              Fx.unwrap(
+                Ref.update(l2, (n) => n + 1).pipe(Effect.as(Fx.map(content, (s) => `B:${s}`))),
+              ),
+            );
+          const values: Array<string> = [];
+          const first = Latch.makeUnsafe();
+          const done = Latch.makeUnsafe();
+          const fiber = yield* Effect.forkChild(
+            Fx.observe(fx, (value) =>
+              Effect.sync(() => values.push(value)).pipe(
+                Effect.flatMap(() => {
+                  if (values.length === 1) return first.open;
+                  if (values.length === 2) return done.open;
+                  return Effect.void;
+                }),
+              ),
+            ),
+          );
+          yield* Effect.yieldNow;
+          yield* first.await;
+          yield* Navigation.navigate("http://localhost/users/2");
+          yield* done.await;
+          yield* Fiber.interrupt(fiber);
+          assert.deepStrictEqual(values, ["B:A:1", "B:A:2"]);
+          assert.strictEqual(yield* Ref.get(l1), 1);
+          assert.strictEqual(yield* Ref.get(l2), 1);
+        }).pipe(Effect.provide(ServerRouter({ url: "http://localhost/users/1" })), Effect.scoped),
+      ));
+
+    it("chained provide layers merge services for handler", () =>
+      runEff(
+        Effect.gen(function* () {
+          class SvcA extends Context.Service<SvcA, { readonly n: number }>()("SvcA") {}
+          class SvcB extends Context.Service<SvcB, { readonly s: string }>()("SvcB") {}
+          const about = Route.Parse("about");
+          const fx = Matcher.empty
+            .match(about, () =>
+              Fx.unwrap(
+                Effect.gen(function* () {
+                  const a = yield* SvcA;
+                  const b = yield* SvcB;
+                  return Fx.succeed(`${a.n}:${b.s}`);
+                }),
+              ),
+            )
+            .provide(Layer.succeed(SvcA, { n: 7 }))
+            .provide(Layer.succeed(SvcB, { s: "z" }));
+          const values = yield* Fx.collectAll(Fx.take(fx, 1));
+          assert.deepStrictEqual(values, ["7:z"]);
+        }).pipe(Effect.provide(ServerRouter({ url: "http://localhost/about" })), Effect.scoped),
+      ));
+
+    it("route dependencies plus matcher provide both available to handler", () =>
+      runEff(
+        Effect.gen(function* () {
+          class RouteSvc extends Context.Service<RouteSvc, { readonly x: number }>()("RouteSvc") {}
+          class MatcherSvc extends Context.Service<MatcherSvc, { readonly y: string }>()(
+            "MatcherSvc",
+          ) {}
+          const about = Route.Parse("about");
+          const fx = Matcher.empty
+            .match(about, {
+              handler: Effect.gen(function* () {
+                const x = yield* RouteSvc;
+                const y = yield* MatcherSvc;
+                return `${x.x}:${y.y}`;
+              }),
+              dependencies: [Layer.succeed(RouteSvc, { x: 3 })],
+            } as any)
+            .provide(Layer.succeed(MatcherSvc, { y: "q" }));
+          const values = yield* Fx.collectAll(Fx.take(fx, 1));
+          assert.deepStrictEqual(values, ["3:q"]);
+        }).pipe(Effect.provide(ServerRouter({ url: "http://localhost/about" })), Effect.scoped),
+      ));
+
+    it("guard fail then none then success: first succeeding guard wins, prior fail/none not surfaced", () =>
+      runEff(
+        Effect.gen(function* () {
+          const order = yield* Ref.make<ReadonlyArray<string>>([]);
+          const users = Route.Join(Route.Parse("users"), Route.Param("id"));
+          const fx = Matcher.empty
+            .match(
+              users,
+              () =>
+                Ref.update(order, (xs) => [...xs, "fail"]).pipe(
+                  Effect.flatMap(() => Effect.fail("g1")),
+                ),
+              "skip1",
+            )
+            .match(
+              users,
+              () => Ref.update(order, (xs) => [...xs, "none"]).pipe(Effect.as(Option.none())),
+              "skip2",
+            )
+            .match(
+              users,
+              () =>
+                Ref.update(order, (xs) => [...xs, "ok"]).pipe(
+                  Effect.as(Option.some({ ok: true as const })),
+                ),
+              "hit",
+            );
+          const values = yield* Fx.collectAll(Fx.take(fx, 1));
+          assert.deepStrictEqual(values, ["hit"]);
+          assert.deepStrictEqual(yield* Ref.get(order), ["fail", "none", "ok"]);
+        }).pipe(Effect.provide(ServerRouter({ url: "http://localhost/users/1" })), Effect.scoped),
+      ));
+
+    it("RouteGuardError with layout on matcher: recover at Effect boundary; no wrap prefix on mapEffect failure", () =>
+      runEff(
+        Effect.gen(function* () {
+          const users = Route.Join(Route.Parse("users"), Route.Param("id"));
+          const about = Route.Parse("about");
+          const inner = Matcher.empty
+            .match(users, () => Effect.fail("g"), "x")
+            .match(about, Fx.succeed("ok"))
+            .layout(({ content }) => Fx.map(content, (s) => `wrap:${s}`));
+          const recovered = yield* Fx.collectAll(Fx.take(inner, 1)).pipe(
+            Effect.as("" as const),
+            Effect.catchTag("RouteGuardError" as const, () =>
+              Effect.succeed("guard-fallback" as const),
+            ),
+          );
+          assert.strictEqual(recovered, "guard-fallback");
+        }).pipe(Effect.provide(ServerRouter({ url: "http://localhost/users/1" })), Effect.scoped),
+      ));
+
+    it("instance catchTag only wraps handler errors; RouteGuardError from guards needs Effect.catchTag on collect", () =>
+      runEff(
+        Effect.gen(function* () {
+          const users = Route.Join(Route.Parse("users"), Route.Param("id"));
+          const inner = (Matcher.empty.match(users, () => Effect.fail("g"), "x") as any).catchTag(
+            "RouteGuardError",
+            () => Fx.succeed("never"),
+          );
+          const exited = yield* Fx.collectAll(Fx.take(inner, 1)).pipe(Effect.exit);
+          assert.isTrue(Exit.isFailure(exited));
+        }).pipe(Effect.provide(ServerRouter({ url: "http://localhost/users/1" })), Effect.scoped),
+      ));
+  });
 
   it("layout receives updated params when staying on same route", () =>
     Effect.gen(function* () {
@@ -405,7 +680,7 @@ describe("typed/router/Matcher", () => {
           Fx.unwrap(Ref.update(layoutMounts, (n) => n + 1).pipe(Effect.as(content))),
         );
 
-      const fx = Matcher.run(matcher);
+      const fx = matcher;
 
       const values: Array<string> = [];
       const first = Latch.makeUnsafe();
@@ -441,7 +716,7 @@ describe("typed/router/Matcher", () => {
 
   it("per-route dependencies option provides services to handler", () =>
     Effect.gen(function* () {
-      class Counter extends ServiceMap.Service<Counter, { readonly value: number }>()("Counter") {}
+      class Counter extends Context.Service<Counter, { readonly value: number }>()("Counter") {}
 
       const counterLayer = Layer.succeed(Counter, { value: 42 });
       const about = Route.Parse("about");
@@ -456,7 +731,7 @@ describe("typed/router/Matcher", () => {
         dependencies: [counterLayer],
       });
 
-      const fx = Matcher.run(matcher);
+      const fx = matcher;
       const values = yield* Fx.collectAll(Fx.take(fx, 1));
 
       assert.deepStrictEqual(values, [42]);
@@ -472,8 +747,8 @@ describe("typed/router/Matcher", () => {
       const about = Route.Parse("about");
       const other = Route.Parse("other");
 
-      const layerWithFinalizer = Layer.effectServices(
-        Effect.acquireRelease(Effect.succeed(ServiceMap.empty()), () => Ref.set(finalized, true)),
+      const layerWithFinalizer = Layer.effectContext(
+        Effect.acquireRelease(Effect.succeed(Context.empty()), () => Ref.set(finalized, true)),
       );
 
       const matcher = Matcher.empty
@@ -483,7 +758,7 @@ describe("typed/router/Matcher", () => {
         })
         .match(other, "other");
 
-      const fx = Matcher.run(matcher);
+      const fx = matcher;
       const values = yield* Fx.collectAll(Fx.take(fx, 1));
 
       assert.deepStrictEqual(values, ["other"]);