@fragno-dev/core 0.2.0 → 0.2.2

package/src/api/fragment-services.test.ts

@@ -1,4 +1,5 @@
 import { describe, test, expect, expectTypeOf } from "vitest";
+
 import { defineFragment } from "./fragment-definition-builder";
 import { instantiate } from "./fragment-instantiator";
 

package/src/api/internal/path-runtime.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "vitest";
+
 import { buildPath, extractPathParams, matchPathParams } from "./path";
 
 describe("extractPathParams (runtime names)", () => {

package/src/api/internal/path-type.test.ts

@@ -1,4 +1,7 @@
 import { test, expect, expectTypeOf } from "vitest";
+
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
 import type {
   ExtractPathParams,
   ExtractPathParamNames,
@@ -9,7 +12,6 @@ import type {
   MaybeExtractPathParamsOrWiden,
   QueryParamsHint,
 } from "./path";
-import type { StandardSchemaV1 } from "@standard-schema/spec";
 
 // Type-only tests using expectTypeOf from vitest
 test("ExtractPathParams type tests", () => {

package/src/api/internal/route.test.ts

@@ -1,4 +1,5 @@
 import { test, expect } from "vitest";
+
 import { getMountRoute } from "./route";
 
 test("getMountRoute - default mount route", () => {

package/src/api/request-context-storage.ts

@@ -28,6 +28,13 @@ export class RequestContextStorage<TRequestStorage> {
     return this.#storage.run(data, callback);
   }
 
+  /**
+   * Check whether a store is currently active.
+   */
+  hasStore(): boolean {
+    return this.#storage.getStore() !== undefined;
+  }
+
   /**
    * Get the current stored data from AsyncLocalStorage.
    * @throws an error if called outside of a run() callback.

package/src/api/request-input-context.test.ts

@@ -1,8 +1,10 @@
 import { test, expect, describe } from "vitest";
-import { RequestInputContext } from "./request-input-context";
-import { FragnoApiValidationError } from "./api";
+
 import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+import { FragnoApiValidationError } from "./api";
 import { MutableRequestState } from "./mutable-request-state";
+import { RequestInputContext } from "./request-input-context";
 
 // Mock schema implementations for testing
 const createMockSchema = (shouldPass: boolean, returnValue?: unknown): StandardSchemaV1 => ({

package/src/api/request-input-context.ts

@@ -1,6 +1,7 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type { ExtractPathParams } from "./internal/path";
+
 import { FragnoApiValidationError, type HTTPMethod } from "./api";
+import type { ExtractPathParams } from "./internal/path";
 import type { MutableRequestState } from "./mutable-request-state";
 
 export type RequestBodyType =

package/src/api/request-middleware.test.ts

@@ -1,9 +1,11 @@
 import { test, expect, describe, expectTypeOf } from "vitest";
-import { defineFragment } from "./fragment-definition-builder";
-import { instantiate } from "./fragment-instantiator";
-import { defineRoute, defineRoutes } from "./route";
+
 import { z } from "zod";
+
 import { FragnoApiValidationError } from "./error";
+import { defineFragment } from "./fragment-definition-builder";
+import { instantiate } from "./fragment-instantiator";
+import { defineRoute } from "./route";
 
 describe("Request Middleware", () => {
   test("middleware can intercept and return early", async () => {
@@ -276,11 +278,10 @@ describe("Request Middleware", () => {
     expect(middlewareCalled).toBe(true);
   });
 
-  test("ifMatchesRoute - supports internal linked fragment routes", async () => {
+  test("ifMatchesRoute - supports internal routes", async () => {
     const config = {};
 
-    const internalDef = defineFragment("internal").build();
-    const internalRoutes = defineRoutes(internalDef).create(({ defineRoute }) => [
+    const internalRoutes = [
       defineRoute({
         method: "GET",
         path: "/status",
@@ -288,16 +289,10 @@ describe("Request Middleware", () => {
           return json({ ok: true });
         },
       }),
-    ]);
+    ] as const;
 
     const definition = defineFragment<typeof config>("test-lib")
-      .withLinkedFragment("_fragno_internal", ({ config, options }) => {
-        return instantiate(internalDef)
-          .withConfig(config)
-          .withOptions(options)
-          .withRoutes([internalRoutes])
-          .build();
-      })
+      .withInternalRoutes(internalRoutes)
       .build();
 
     const instance = instantiate(definition)

package/src/api/request-middleware.ts

@@ -1,11 +1,12 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
+
 import type { ExtractRouteByPath, ExtractRoutePath } from "../client/client";
 import type { HTTPMethod } from "./api";
 import type { ExtractPathParams } from "./internal/path";
-import type { AnyFragnoRouteConfig } from "./route";
+import { MutableRequestState } from "./mutable-request-state";
 import { RequestInputContext } from "./request-input-context";
 import { OutputContext, RequestOutputContext } from "./request-output-context";
-import { MutableRequestState } from "./mutable-request-state";
+import type { AnyFragnoRouteConfig } from "./route";
 
 export type FragnoMiddlewareCallback<
   TRoutes extends readonly AnyFragnoRouteConfig[],

package/src/api/request-output-context.test.ts

@@ -1,7 +1,9 @@
 import { test, expect, describe, vi } from "vitest";
-import { RequestOutputContext } from "./request-output-context";
+
 import type { StandardSchemaV1 } from "@standard-schema/spec";
+
 import { ResponseStream } from "./internal/response-stream";
+import { RequestOutputContext } from "./request-output-context";
 
 // Mock schema implementations for testing
 const createMockSchema = (shouldPass: boolean, returnValue?: unknown): StandardSchemaV1 => ({

package/src/api/request-output-context.ts

@@ -1,7 +1,8 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
+
 import type { ContentlessStatusCode, StatusCode } from "../http/http-status";
-import { ResponseStream } from "./internal/response-stream";
 import type { InferOrUnknown } from "../util/types-util";
+import { ResponseStream } from "./internal/response-stream";
 
 export type ResponseData = string | ArrayBuffer | ReadableStream | Uint8Array<ArrayBuffer>;
 

package/src/api/route-caller.test.ts

@@ -0,0 +1,195 @@
+import { describe, expect, expectTypeOf, test } from "vitest";
+
+import { z } from "zod";
+
+import type { FragnoResponse } from "./fragno-response";
+import { defineRoute } from "./route";
+import { createRouteCaller } from "./route-caller";
+
+describe("createRouteCaller", () => {
+  test("replaces inherited content-type with application/json for object bodies", async () => {
+    let capturedRequest: Request | null = null;
+
+    const callRoute = createRouteCaller<{
+      callRoute: (
+        method: "POST",
+        path: "/test",
+        input: { body: { hello: string } },
+      ) => Promise<unknown>;
+    }>({
+      baseUrl: "https://example.com/app",
+      baseHeaders: {
+        "content-type": "application/x-www-form-urlencoded",
+      },
+      fetch: async (request) => {
+        capturedRequest = request;
+        return new Response(JSON.stringify({ ok: true }), {
+          headers: { "content-type": "application/json" },
+        });
+      },
+    });
+
+    await callRoute("POST", "/test", {
+      body: { hello: "world" },
+    });
+
+    if (!capturedRequest) {
+      throw new Error("Expected fetch to receive a request.");
+    }
+
+    const request = capturedRequest as Request;
+    expect(request.headers.get("content-type")).toBe("application/json");
+    expect(await request.text()).toBe('{"hello":"world"}');
+  });
+
+  test("keeps an explicit application/octet-stream content-type for binary bodies", async () => {
+    let capturedRequest: Request | null = null;
+
+    const callRoute = createRouteCaller<{
+      callRoute: (
+        method: "POST",
+        path: "/binary",
+        input: { body: ArrayBuffer; headers: HeadersInit },
+      ) => Promise<unknown>;
+    }>({
+      baseUrl: "https://example.com/app",
+      baseHeaders: {
+        "content-type": "multipart/form-data; boundary=---original",
+      },
+      fetch: async (request) => {
+        capturedRequest = request;
+        return new Response(JSON.stringify({ ok: true }), {
+          headers: { "content-type": "application/json" },
+        });
+      },
+    });
+
+    await callRoute("POST", "/binary", {
+      body: new Uint8Array([1, 2, 3]).buffer,
+      headers: {
+        "content-type": "application/octet-stream",
+      },
+    });
+
+    if (!capturedRequest) {
+      throw new Error("Expected fetch to receive a request.");
+    }
+
+    const request = capturedRequest as Request;
+    expect(request.headers.get("content-type")).toBe("application/octet-stream");
+    expect(new Uint8Array(await request.arrayBuffer())).toEqual(new Uint8Array([1, 2, 3]));
+  });
+
+  test("infers route-specific inputs and outputs from fragment routes", async () => {
+    const routes = [
+      defineRoute({
+        method: "GET",
+        path: "/threads",
+        outputSchema: z.object({
+          threads: z.array(z.object({ id: z.string() })),
+          hasNextPage: z.boolean(),
+        }),
+        handler: async (_ctx, { json }) =>
+          json({ threads: [{ id: "thread-1" }], hasNextPage: false }),
+      }),
+      defineRoute({
+        method: "GET",
+        path: "/threads/:threadId/messages",
+        outputSchema: z.object({
+          messages: z.array(z.object({ id: z.string(), threadId: z.string() })),
+          cursor: z.string().optional(),
+          hasNextPage: z.boolean(),
+        }),
+        handler: async ({ pathParams, query }, { json }) =>
+          json({
+            messages: [{ id: "message-1", threadId: pathParams.threadId }],
+            cursor: query.get("cursor") ?? undefined,
+            hasNextPage: false,
+          }),
+      }),
+      defineRoute({
+        method: "POST",
+        path: "/threads/:threadId/reply",
+        inputSchema: z.object({ text: z.string() }),
+        outputSchema: z.object({ ok: z.boolean() }),
+        handler: async (_ctx, { json }) => json({ ok: true }),
+      }),
+    ] as const;
+
+    type FakeFragment = {
+      routes: typeof routes;
+    };
+
+    const callRoute = createRouteCaller<FakeFragment>({
+      baseUrl: "https://example.com/app",
+      mountRoute: "/api",
+      fetch: async (request) => {
+        const url = new URL(request.url);
+
+        if (url.pathname === "/api/threads") {
+          return Response.json({
+            threads: [{ id: "thread-1" }],
+            hasNextPage: false,
+          });
+        }
+
+        if (url.pathname === "/api/threads/thread-1/messages") {
+          return Response.json({
+            messages: [{ id: "message-1", threadId: "thread-1" }],
+            cursor: url.searchParams.get("cursor") ?? undefined,
+            hasNextPage: false,
+          });
+        }
+
+        if (url.pathname === "/api/threads/thread-1/reply") {
+          const body = (await request.json()) as { text: string };
+          return Response.json({ ok: body.text === "hello" });
+        }
+
+        return Response.json({ message: "Not found", code: "NOT_FOUND" }, { status: 404 });
+      },
+    });
+
+    const listResponse = await callRoute("GET", "/threads", {
+      query: { cursor: "cursor-1" },
+    });
+    const messagesResponse = await callRoute("GET", "/threads/:threadId/messages", {
+      pathParams: { threadId: "thread-1" },
+      query: { cursor: "cursor-1" },
+    });
+    const replyResponse = await callRoute("POST", "/threads/:threadId/reply", {
+      pathParams: { threadId: "thread-1" },
+      body: { text: "hello" },
+    });
+
+    expectTypeOf<Extract<typeof listResponse, { type: "json" }>["data"]>().toEqualTypeOf<{
+      threads: { id: string }[];
+      hasNextPage: boolean;
+    }>();
+    expectTypeOf<Extract<typeof messagesResponse, { type: "json" }>["data"]>().toEqualTypeOf<{
+      messages: { id: string; threadId: string }[];
+      cursor?: string | undefined;
+      hasNextPage: boolean;
+    }>();
+    expectTypeOf<Extract<typeof replyResponse, { type: "json" }>["data"]>().toEqualTypeOf<{
+      ok: boolean;
+    }>();
+    expectTypeOf<typeof listResponse>().toExtend<FragnoResponse<unknown>>();
+
+    expect(listResponse.type).toBe("json");
+    if (listResponse.type === "json") {
+      expect(listResponse.data.threads[0]?.id).toBe("thread-1");
+    }
+
+    expect(messagesResponse.type).toBe("json");
+    if (messagesResponse.type === "json") {
+      expect(messagesResponse.data.messages[0]?.threadId).toBe("thread-1");
+      expect(messagesResponse.data.cursor).toBe("cursor-1");
+    }
+
+    expect(replyResponse.type).toBe("json");
+    if (replyResponse.type === "json") {
+      expect(replyResponse.data.ok).toBe(true);
+    }
+  });
+});

package/src/api/route-caller.ts

@@ -0,0 +1,167 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+import type { ExtractRouteByPath, ExtractRoutePath } from "../client/client";
+import type { InferOrUnknown } from "../util/types-util";
+import type { HTTPMethod } from "./api";
+import type { FragnoResponse } from "./fragno-response";
+import { parseFragnoResponse } from "./fragno-response";
+import { buildPath, type ExtractPathParams } from "./internal/path";
+import type { AnyFragnoRouteConfig } from "./route";
+import type { RouteHandlerInputOptions } from "./route-handler-input-options";
+
+export type RouteCallerConfig = {
+  baseUrl: string | URL;
+  mountRoute?: string;
+  baseHeaders?: HeadersInit;
+  fetch: (request: Request) => Promise<Response>;
+  redirect?: RequestRedirect;
+};
+
+type ArrayBufferViewOfArrayBuffer = ArrayBufferView & { buffer: ArrayBuffer };
+
+type FragmentLike = {
+  routes?: readonly AnyFragnoRouteConfig[];
+  callRoute?: (...args: never[]) => Promise<unknown>;
+};
+
+type RouteCallerPath<
+  TRoutes extends readonly AnyFragnoRouteConfig[],
+  TMethod extends HTTPMethod,
+> = [ExtractRoutePath<TRoutes, TMethod>] extends [never]
+  ? string
+  : ExtractRoutePath<TRoutes, TMethod>;
+
+type RouteCallerMatch<
+  TRoutes extends readonly AnyFragnoRouteConfig[],
+  TMethod extends HTTPMethod,
+  TPath extends string,
+> = [ExtractRouteByPath<TRoutes, TPath, TMethod>] extends [never]
+  ? AnyFragnoRouteConfig
+  : ExtractRouteByPath<TRoutes, TPath, TMethod>;
+
+export type RouteCallerForFragment<TFragment extends FragmentLike> = TFragment extends {
+  routes: infer TRoutes extends readonly AnyFragnoRouteConfig[];
+}
+  ? <TMethod extends HTTPMethod, TPath extends RouteCallerPath<TRoutes, TMethod>>(
+      method: TMethod,
+      path: TPath,
+      inputOptions?: RouteHandlerInputOptions<
+        TPath,
+        RouteCallerMatch<TRoutes, TMethod, TPath>["inputSchema"]
+      >,
+    ) => Promise<
+      FragnoResponse<
+        InferOrUnknown<NonNullable<RouteCallerMatch<TRoutes, TMethod, TPath>["outputSchema"]>>
+      >
+    >
+  : TFragment extends { callRoute: (...args: never[]) => Promise<unknown> }
+    ? TFragment["callRoute"]
+    : never;
+
+function isArrayBufferView(value: unknown): value is ArrayBufferViewOfArrayBuffer {
+  return ArrayBuffer.isView(value) && value.buffer instanceof ArrayBuffer;
+}
+
+function buildMountedPath(mountRoute: string, pathname: string): string {
+  const normalizedMount =
+    mountRoute === "/" ? "" : mountRoute.endsWith("/") ? mountRoute.slice(0, -1) : mountRoute;
+  const pathPart = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  if (!normalizedMount) {
+    return pathPart;
+  }
+  const mountPart = normalizedMount.startsWith("/") ? normalizedMount : `/${normalizedMount}`;
+  return `${mountPart}${pathPart}`;
+}
+
+export function createRouteCaller<TFragment extends FragmentLike>(
+  config: RouteCallerConfig,
+): RouteCallerForFragment<TFragment> {
+  const { baseUrl, fetch } = config;
+  const mountRoute = config.mountRoute ?? "";
+  const baseHeaders = config.baseHeaders ? new Headers(config.baseHeaders) : undefined;
+  const redirect = config.redirect ?? "manual";
+
+  const callRoute = async <TPath extends string>(
+    method: HTTPMethod,
+    path: TPath,
+    inputOptions?: RouteHandlerInputOptions<TPath, StandardSchemaV1 | undefined>,
+  ): Promise<FragnoResponse<unknown>> => {
+    const headers = baseHeaders ? new Headers(baseHeaders) : new Headers();
+    const explicitHeaders = inputOptions?.headers
+      ? inputOptions.headers instanceof Headers
+        ? inputOptions.headers
+        : new Headers(inputOptions.headers)
+      : null;
+
+    if (explicitHeaders) {
+      for (const [key, value] of explicitHeaders.entries()) {
+        headers.set(key, value);
+      }
+    }
+
+    const hasExplicitContentType = explicitHeaders?.has("content-type") ?? false;
+
+    const searchParams =
+      inputOptions?.query instanceof URLSearchParams
+        ? new URLSearchParams(inputOptions.query)
+        : new URLSearchParams();
+
+    if (inputOptions?.query && !(inputOptions.query instanceof URLSearchParams)) {
+      for (const [key, value] of Object.entries(inputOptions.query)) {
+        if (value !== undefined) {
+          searchParams.set(key, value);
+        }
+      }
+    }
+
+    const pathParams = (inputOptions?.pathParams ?? {}) as ExtractPathParams<TPath>;
+    const pathname = buildPath(path, pathParams);
+    const url = new URL(buildMountedPath(mountRoute, pathname), baseUrl);
+    url.search = searchParams.toString();
+
+    let body: BodyInit | undefined;
+    if (inputOptions && "body" in inputOptions) {
+      const rawBody = (inputOptions as { body?: unknown }).body;
+
+      if (rawBody instanceof FormData || rawBody instanceof Blob) {
+        body = rawBody;
+        if (!hasExplicitContentType) {
+          headers.delete("content-type");
+        }
+      } else if (rawBody instanceof ReadableStream) {
+        body = rawBody;
+        if (!hasExplicitContentType) {
+          headers.delete("content-type");
+        }
+      } else if (rawBody instanceof ArrayBuffer) {
+        body = rawBody;
+        if (!hasExplicitContentType) {
+          headers.delete("content-type");
+        }
+      } else if (isArrayBufferView(rawBody)) {
+        body = rawBody;
+        if (!hasExplicitContentType) {
+          headers.delete("content-type");
+        }
+      } else if (rawBody !== undefined) {
+        body = JSON.stringify(rawBody);
+        if (!hasExplicitContentType) {
+          headers.set("content-type", "application/json");
+        }
+      }
+    }
+
+    const response = await fetch(
+      new Request(url, {
+        method,
+        headers,
+        body,
+        redirect,
+      }),
+    );
+
+    return parseFragnoResponse(response);
+  };
+
+  return callRoute as RouteCallerForFragment<TFragment>;
+}

package/src/api/route-handler-input-options.ts

@@ -1,6 +1,7 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type { ExtractPathParams } from "./internal/path";
+
 import type { InferOr } from "../util/types-util";
+import type { ExtractPathParams } from "./internal/path";
 
 /**
  * Options for calling a route handler

package/src/api/route.test.ts

@@ -1,8 +1,10 @@
 import { test, expect, expectTypeOf, describe } from "vitest";
-import { defineRoute, defineRoutes } from "./route";
-import { defineFragment } from "./fragment-definition-builder";
+
 import { z } from "zod";
 
+import { defineFragment } from "./fragment-definition-builder";
+import { defineRoute, defineRoutes } from "./route";
+
 describe("defineRoute", () => {
   test("defineRoute no inputSchema", () => {
     const route = defineRoute({

package/src/api/route.ts

@@ -1,9 +1,10 @@
 // oxlint-disable no-explicit-any
 
 import type { StandardSchemaV1 } from "@standard-schema/spec";
+
 import type { FragnoRouteConfig, HTTPMethod, RequestThisContext } from "./api";
-import type { FragmentDefinition } from "./fragment-definition-builder";
 import type { BoundServices } from "./bind-services";
+import type { FragmentDefinition } from "./fragment-definition-builder";
 
 export type AnyFragnoRouteConfig = FragnoRouteConfig<HTTPMethod, string, any, any, any, any, any>;
 

package/src/api/shared-types.ts

@@ -1,6 +1,7 @@
-import type { HTTPMethod } from "./api";
 import type { StandardSchemaV1 } from "@standard-schema/spec";
 
+import type { HTTPMethod } from "./api";
+
 /**
  * Public configuration for Fragno fragments on the server side.
  */

package/src/client/client-builder.test.ts

@@ -1,9 +1,11 @@
 import { test, expect, expectTypeOf, describe } from "vitest";
+
 import { z } from "zod";
-import { createClientBuilder } from "./client";
-import { defineRoute } from "../api/route";
+
 import { defineFragment } from "../api/fragment-definition-builder";
+import { defineRoute } from "../api/route";
 import type { FragnoPublicClientConfig } from "../api/shared-types";
+import { createClientBuilder } from "./client";
 
 // Test route configurations
 const testFragment = defineFragment("test-fragment").build();

package/src/client/client-error.test.ts

@@ -1,7 +1,8 @@
 import { test, expect, describe } from "vitest";
-import { FragnoClientApiError, FragnoClientUnknownApiError } from "./client-error";
+
 import { FragnoApiError } from "../api/error";
 import { RequestOutputContext } from "../api/request-output-context";
+import { FragnoClientApiError, FragnoClientUnknownApiError } from "./client-error";
 
 describe("Error Conversion", () => {
   test("should convert API error to client error", async () => {

package/src/client/client-error.ts

@@ -112,7 +112,7 @@ export class FragnoClientApiError<
    * The type is `TErrorCode` (the set of known error codes for this route), but may also be a string
    * for forward compatibility with future error codes.
    */
-  get code(): TErrorCode | (string & {}) {
+  override get code(): TErrorCode | (string & {}) {
     return super.code as TErrorCode | (string & {});
   }
 

package/src/client/client-types.test.ts

@@ -1,18 +1,22 @@
 import { test, expectTypeOf, describe } from "vitest";
+
 import { z } from "zod";
+
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
 import { type FragnoRouteConfig, type HTTPMethod } from "../api/api";
-import { defineRoute } from "../api/route";
+import { type AnyFragnoRouteConfig, defineRoute } from "../api/route";
 import type {
   ExtractGetRoutes,
   ExtractGetRoutePaths,
   ExtractOutputSchemaForPath,
   ExtractRouteByPath,
+  ExtractRoutePath,
   IsValidGetRoutePath,
   ValidateGetRoutePath,
   HasGetRoutes,
   FragnoClientMutatorData,
 } from "./client";
-import type { StandardSchemaV1 } from "@standard-schema/spec";
 
 // Test route configurations for type testing
 const _testRoutes = [
@@ -150,12 +154,12 @@ test("ExtractOutputSchemaForPath type tests", () => {
 
   // Note: Routes without output schema have complex type inference, skipping direct test
 
-  // Should be never for non-existent path
+  // Non-existent paths currently widen to unknown, while routes without an output schema stay optional.
   type NonExistentSchema = ExtractOutputSchemaForPath<typeof _testRoutes, "/nonexistent">;
-  expectTypeOf<NonExistentSchema>().toEqualTypeOf<never>();
+  expectTypeOf<NonExistentSchema>().toEqualTypeOf<unknown>();
 
   type PathWithNoSchema = ExtractOutputSchemaForPath<typeof _testRoutes, "/home">;
-  expectTypeOf<PathWithNoSchema>().toEqualTypeOf<StandardSchemaV1<unknown, unknown> | undefined>();
+  expectTypeOf<PathWithNoSchema>().toEqualTypeOf<StandardSchemaV1<unknown, unknown>>();
 });
 
 test("IsValidGetRoutePath type tests", () => {
@@ -343,6 +347,16 @@ test("GET route with outputSchema", () => {
   expectTypeOf<ConstPaths>().toEqualTypeOf<"/test">();
 });
 
+test("route extraction falls back gracefully for widened route types", () => {
+  type BroadRoutes = readonly AnyFragnoRouteConfig[];
+
+  expectTypeOf<ExtractRoutePath<BroadRoutes, "POST">>().toEqualTypeOf<string>();
+  expectTypeOf<ExtractGetRoutePaths<BroadRoutes>>().toEqualTypeOf<string>();
+  expectTypeOf<
+    ExtractRouteByPath<BroadRoutes, "/users/:id", "POST">
+  >().toExtend<AnyFragnoRouteConfig>();
+});
+
 describe("ExtractRouteByPath", () => {
   const _fragmentConfig = {
     name: "test-fragment",