@fragno-dev/core 0.1.8 → 0.1.9

package/src/api/fragment-instantiation.ts

@@ -1,766 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-import { type FragnoRouteConfig, type HTTPMethod, type RequestThisContext } from "./api";
-import { FragnoApiError } from "./error";
-import { getMountRoute } from "./internal/route";
-import { addRoute, createRouter, findRoute } from "rou3";
-import { RequestInputContext, type RequestBodyType } from "./request-input-context";
-import type { ExtractPathParams } from "./internal/path";
-import { RequestOutputContext } from "./request-output-context";
-import {
-  type AnyFragnoRouteConfig,
-  type AnyRouteOrFactory,
-  type FlattenRouteFactories,
-  resolveRouteFactories,
-} from "./route";
-import {
-  RequestMiddlewareInputContext,
-  RequestMiddlewareOutputContext,
-  type FragnoMiddlewareCallback,
-} from "./request-middleware";
-import type { FragmentDefinition, RouteHandler } from "./fragment-builder";
-import { MutableRequestState } from "./mutable-request-state";
-import type { RouteHandlerInputOptions } from "./route-handler-input-options";
-import type { ExtractRouteByPath, ExtractRoutePath } from "../client/client";
-import { type FragnoResponse, parseFragnoResponse } from "./fragno-response";
-import type { InferOrUnknown } from "../util/types-util";
-
-export interface FragnoPublicConfig {
-  mountRoute?: string;
-}
-
-export type FetcherConfig =
-  | { type: "options"; options: RequestInit }
-  | { type: "function"; fetcher: typeof fetch };
-
-export interface FragnoPublicClientConfig {
-  mountRoute?: string;
-  baseUrl?: string;
-  fetcherConfig?: FetcherConfig;
-}
-
-type AstroHandlers = {
-  ALL: (req: Request) => Promise<Response>;
-};
-
-type ReactRouterHandlers = {
-  loader: (args: { request: Request }) => Promise<Response>;
-  action: (args: { request: Request }) => Promise<Response>;
-};
-
-type SolidStartHandlers = {
-  GET: (args: { request: Request }) => Promise<Response>;
-  POST: (args: { request: Request }) => Promise<Response>;
-  PUT: (args: { request: Request }) => Promise<Response>;
-  DELETE: (args: { request: Request }) => Promise<Response>;
-  PATCH: (args: { request: Request }) => Promise<Response>;
-  HEAD: (args: { request: Request }) => Promise<Response>;
-  OPTIONS: (args: { request: Request }) => Promise<Response>;
-};
-
-type TanStackStartHandlers = SolidStartHandlers;
-
-type StandardHandlers = {
-  GET: (req: Request) => Promise<Response>;
-  POST: (req: Request) => Promise<Response>;
-  PUT: (req: Request) => Promise<Response>;
-  DELETE: (req: Request) => Promise<Response>;
-  PATCH: (req: Request) => Promise<Response>;
-  HEAD: (req: Request) => Promise<Response>;
-  OPTIONS: (req: Request) => Promise<Response>;
-};
-
-type HandlersByFramework = {
-  astro: AstroHandlers;
-  "react-router": ReactRouterHandlers;
-  "next-js": StandardHandlers;
-  "svelte-kit": StandardHandlers;
-  "solid-start": SolidStartHandlers;
-  "tanstack-start": TanStackStartHandlers;
-};
-
-// Not actually a symbol, since we might be dealing with multiple instances of this code.
-export const instantiatedFragmentFakeSymbol = "$fragno-instantiated-fragment" as const;
-
-type FullstackFrameworks = keyof HandlersByFramework;
-
-export interface FragnoInstantiatedFragment<
-  TRoutes extends readonly AnyFragnoRouteConfig[] = [],
-  TDeps = {},
-  TServices extends Record<string, unknown> = Record<string, unknown>,
-  TAdditionalContext extends Record<string, unknown> = {},
-> {
-  [instantiatedFragmentFakeSymbol]: typeof instantiatedFragmentFakeSymbol;
-
-  config: FragnoFragmentSharedConfig<TRoutes>;
-  deps: TDeps;
-  services: TServices;
-  additionalContext?: TAdditionalContext;
-  handlersFor: <T extends FullstackFrameworks>(framework: T) => HandlersByFramework[T];
-  handler: (req: Request) => Promise<Response>;
-  mountRoute: string;
-  callRoute: <TMethod extends HTTPMethod, TPath extends ExtractRoutePath<TRoutes, TMethod>>(
-    method: TMethod,
-    path: TPath,
-    inputOptions?: RouteHandlerInputOptions<
-      TPath,
-      ExtractRouteByPath<TRoutes, TPath, TMethod>["inputSchema"]
-    >,
-  ) => Promise<
-    FragnoResponse<
-      InferOrUnknown<NonNullable<ExtractRouteByPath<TRoutes, TPath, TMethod>["outputSchema"]>>
-    >
-  >;
-  callRouteRaw: <TMethod extends HTTPMethod, TPath extends ExtractRoutePath<TRoutes, TMethod>>(
-    method: TMethod,
-    path: TPath,
-    inputOptions?: RouteHandlerInputOptions<
-      TPath,
-      ExtractRouteByPath<TRoutes, TPath, TMethod>["inputSchema"]
-    >,
-  ) => Promise<Response>;
-  withMiddleware: (
-    handler: FragnoMiddlewareCallback<TRoutes, TDeps, TServices>,
-  ) => FragnoInstantiatedFragment<TRoutes, TDeps, TServices, TAdditionalContext>;
-}
-
-export interface FragnoFragmentSharedConfig<
-  TRoutes extends readonly FragnoRouteConfig<
-    HTTPMethod,
-    string,
-    StandardSchemaV1 | undefined,
-    StandardSchemaV1 | undefined,
-    string,
-    string
-  >[],
-> {
-  name: string;
-  routes: TRoutes;
-}
-
-export type AnyFragnoFragmentSharedConfig = FragnoFragmentSharedConfig<
-  readonly AnyFragnoRouteConfig[]
->;
-
-export function createFragment<
-  const TConfig,
-  const TDeps,
-  const TServices extends Record<string, unknown>,
-  const TRoutesOrFactories extends readonly AnyRouteOrFactory[],
-  const TAdditionalContext extends Record<string, unknown>,
-  const TRequiredInterfaces extends Record<string, unknown>,
-  const TProvidedInterfaces extends Record<string, unknown>,
-  const TOptions extends FragnoPublicConfig,
-  const TThisContext extends RequestThisContext = RequestThisContext,
->(
-  fragmentBuilder: {
-    definition: FragmentDefinition<
-      TConfig,
-      TDeps,
-      TServices,
-      TAdditionalContext,
-      TRequiredInterfaces,
-      TProvidedInterfaces,
-      TThisContext
-    >;
-    $requiredOptions: TOptions;
-  },
-  config: TConfig,
-  routesOrFactories: TRoutesOrFactories,
-  options: TOptions,
-  interfaceImplementations?: TRequiredInterfaces,
-): FragnoInstantiatedFragment<
-  FlattenRouteFactories<TRoutesOrFactories>,
-  TDeps & TRequiredInterfaces,
-  TServices & TProvidedInterfaces & TRequiredInterfaces,
-  TAdditionalContext
-> {
-  type TRoutes = FlattenRouteFactories<TRoutesOrFactories>;
-
-  const definition = fragmentBuilder.definition;
-
-  // Validate required services are satisfied
-  if (definition.usedServices) {
-    for (const [serviceName, serviceMeta] of Object.entries(definition.usedServices)) {
-      const implementation = interfaceImplementations?.[serviceName];
-      if (serviceMeta.required && !implementation) {
-        throw new Error(
-          `Fragment '${definition.name}' requires service '${serviceMeta.name}' but it was not provided`,
-        );
-      }
-    }
-  }
-
-  const dependencies = definition.dependencies?.(config, options) ?? ({} as TDeps);
-
-  // Merge interface implementations into dependencies
-  const depsWithInterfaces = {
-    ...dependencies,
-    ...interfaceImplementations,
-  } as TDeps & TRequiredInterfaces;
-
-  const servicesFromWithServices =
-    definition.services?.(config, options, depsWithInterfaces) ?? ({} as TServices);
-
-  // Handle providedServices - can be:
-  // 1. A function that returns all services
-  // 2. An object where each value is a factory function
-  // 3. undefined
-  let providedServicesResolved: TProvidedInterfaces | undefined;
-
-  if (typeof definition.providedServices === "function") {
-    // Case 1: It's a function, call it to get the services
-    providedServicesResolved = definition.providedServices(config, options, depsWithInterfaces);
-  } else if (definition.providedServices && typeof definition.providedServices === "object") {
-    // Case 2: It's an object where each value might be a factory function
-    providedServicesResolved = {} as TProvidedInterfaces;
-    for (const [serviceName, serviceOrFactory] of Object.entries(definition.providedServices)) {
-      if (typeof serviceOrFactory === "function") {
-        // Call the factory function
-        (providedServicesResolved as Record<string, unknown>)[serviceName] = serviceOrFactory(
-          config,
-          options,
-          depsWithInterfaces,
-        );
-      } else {
-        // It's already a resolved service
-        (providedServicesResolved as Record<string, unknown>)[serviceName] = serviceOrFactory;
-      }
-    }
-  }
-
-  const services = {
-    ...servicesFromWithServices,
-    ...providedServicesResolved,
-    ...interfaceImplementations,
-  } as TServices & TProvidedInterfaces & TRequiredInterfaces;
-
-  const context = { config, deps: depsWithInterfaces, services };
-  const routes = resolveRouteFactories(context, routesOrFactories);
-
-  const mountRoute = getMountRoute({
-    name: definition.name,
-    mountRoute: options.mountRoute,
-  });
-
-  const router =
-    createRouter<
-      FragnoRouteConfig<
-        HTTPMethod,
-        string,
-        StandardSchemaV1 | undefined,
-        StandardSchemaV1 | undefined,
-        string,
-        string,
-        RequestThisContext
-      >
-    >();
-
-  let middlewareHandler:
-    | FragnoMiddlewareCallback<
-        FlattenRouteFactories<TRoutesOrFactories>,
-        TDeps & TRequiredInterfaces,
-        TServices & TProvidedInterfaces & TRequiredInterfaces
-      >
-    | undefined;
-
-  // Store the handler wrapper if provided (e.g., for database support)
-  const handlerWrapper = definition.createHandlerWrapper?.(options);
-
-  for (const routeConfig of routes) {
-    addRoute(router, routeConfig.method.toUpperCase(), routeConfig.path, routeConfig);
-  }
-
-  const fragment: FragnoInstantiatedFragment<
-    FlattenRouteFactories<TRoutesOrFactories>,
-    TDeps & TRequiredInterfaces,
-    TServices & TProvidedInterfaces & TRequiredInterfaces,
-    TAdditionalContext & TOptions
-  > = {
-    [instantiatedFragmentFakeSymbol]: instantiatedFragmentFakeSymbol,
-    mountRoute,
-    config: {
-      name: definition.name,
-      routes,
-    },
-    services,
-    deps: depsWithInterfaces,
-    additionalContext: {
-      ...definition.additionalContext,
-      ...options,
-    } as TAdditionalContext & TOptions,
-    withMiddleware: (handler) => {
-      if (middlewareHandler) {
-        throw new Error("Middleware already set");
-      }
-
-      middlewareHandler = handler;
-
-      return fragment;
-    },
-    callRoute: async <TMethod extends HTTPMethod, TPath extends ExtractRoutePath<TRoutes, TMethod>>(
-      method: TMethod,
-      path: TPath,
-      inputOptions?: RouteHandlerInputOptions<
-        TPath,
-        ExtractRouteByPath<TRoutes, TPath, TMethod>["inputSchema"]
-      >,
-    ): Promise<
-      FragnoResponse<
-        InferOrUnknown<NonNullable<ExtractRouteByPath<TRoutes, TPath, TMethod>["outputSchema"]>>
-      >
-    > => {
-      const response = await fragment.callRouteRaw(method, path, inputOptions);
-      return parseFragnoResponse(response);
-    },
-    callRouteRaw: async <
-      TMethod extends HTTPMethod,
-      TPath extends ExtractRoutePath<TRoutes, TMethod>,
-    >(
-      method: TMethod,
-      path: TPath,
-      inputOptions?: RouteHandlerInputOptions<
-        TPath,
-        ExtractRouteByPath<TRoutes, TPath, TMethod>["inputSchema"]
-      >,
-    ): Promise<Response> => {
-      // Find the route configuration
-      const route = routes.find((r) => r.method === method && r.path === path);
-
-      if (!route) {
-        return Response.json(
-          {
-            error: `Route ${method} ${path} not found`,
-            code: "ROUTE_NOT_FOUND",
-          },
-          { status: 404 },
-        );
-      }
-
-      const {
-        pathParams = {} as ExtractPathParams<TPath>,
-        body,
-        query,
-        headers,
-      } = inputOptions || {};
-
-      // Convert query to URLSearchParams if needed
-      const searchParams =
-        query instanceof URLSearchParams
-          ? query
-          : query
-            ? new URLSearchParams(query)
-            : new URLSearchParams();
-
-      // Convert headers to Headers if needed
-      const requestHeaders =
-        headers instanceof Headers ? headers : headers ? new Headers(headers) : new Headers();
-
-      // Construct RequestInputContext
-      const inputContext = new RequestInputContext({
-        path: route.path,
-        method: route.method,
-        pathParams,
-        searchParams,
-        headers: requestHeaders,
-        parsedBody: body,
-        inputSchema: route.inputSchema,
-        shouldValidateInput: true, // Enable validation for production use
-      });
-
-      // Construct RequestOutputContext
-      const outputContext = new RequestOutputContext(route.outputSchema);
-
-      // Call the route handler (wrap with handlerWrapper if provided)
-      try {
-        let response: Response;
-        const thisContext: RequestThisContext = {};
-
-        if (handlerWrapper) {
-          // Wrapper handles binding the this context internally for database fragments
-          // Safe: wrapper knows how to handle the specific this type (DatabaseRequestThisContext)
-          const wrappedHandler = handlerWrapper(route.handler as unknown as RouteHandler);
-          response = await wrappedHandler.call(thisContext, inputContext, outputContext);
-        } else {
-          // For standard fragments, bind to an empty RequestThisContext
-          // Safe: we know route.handler expects RequestThisContext for standard fragments
-          response = await (route.handler as RouteHandler).call(
-            thisContext,
-            inputContext,
-            outputContext,
-          );
-        }
-        return response;
-      } catch (error) {
-        console.error("Error in callRoute handler", error);
-
-        if (error instanceof FragnoApiError) {
-          return error.toResponse();
-        }
-
-        return Response.json(
-          { error: "Internal server error", code: "INTERNAL_SERVER_ERROR" },
-          { status: 500 },
-        );
-      }
-    },
-    handlersFor: <T extends FullstackFrameworks>(framework: T): HandlersByFramework[T] => {
-      const handler = fragment.handler;
-
-      // LLMs hallucinate these values sometimes, solution isn't obvious so we throw this error
-      // @ts-expect-error TS2367
-      if (framework === "h3" || framework === "nuxt") {
-        throw new Error(`To get handlers for h3, use the 'fromWebHandler' utility function:
-          import { fromWebHandler } from "h3";
-          export default fromWebHandler(myFragment().handler);`);
-      }
-      const allHandlers = {
-        astro: { ALL: handler },
-        "react-router": {
-          loader: ({ request }: { request: Request }) => handler(request),
-          action: ({ request }: { request: Request }) => handler(request),
-        },
-        "next-js": {
-          GET: handler,
-          POST: handler,
-          PUT: handler,
-          DELETE: handler,
-          PATCH: handler,
-          HEAD: handler,
-          OPTIONS: handler,
-        },
-        "svelte-kit": {
-          GET: handler,
-          POST: handler,
-          PUT: handler,
-          DELETE: handler,
-          PATCH: handler,
-          HEAD: handler,
-          OPTIONS: handler,
-        },
-        "solid-start": {
-          GET: ({ request }: { request: Request }) => handler(request),
-          POST: ({ request }: { request: Request }) => handler(request),
-          PUT: ({ request }: { request: Request }) => handler(request),
-          DELETE: ({ request }: { request: Request }) => handler(request),
-          PATCH: ({ request }: { request: Request }) => handler(request),
-          HEAD: ({ request }: { request: Request }) => handler(request),
-          OPTIONS: ({ request }: { request: Request }) => handler(request),
-        },
-        "tanstack-start": {
-          GET: ({ request }: { request: Request }) => handler(request),
-          POST: ({ request }: { request: Request }) => handler(request),
-          PUT: ({ request }: { request: Request }) => handler(request),
-          DELETE: ({ request }: { request: Request }) => handler(request),
-          PATCH: ({ request }: { request: Request }) => handler(request),
-          HEAD: ({ request }: { request: Request }) => handler(request),
-          OPTIONS: ({ request }: { request: Request }) => handler(request),
-        },
-      } satisfies HandlersByFramework;
-
-      return allHandlers[framework];
-    },
-    handler: async (req: Request) => {
-      const url = new URL(req.url);
-      const pathname = url.pathname;
-
-      const matchRoute = pathname.startsWith(mountRoute) ? pathname.slice(mountRoute.length) : null;
-
-      if (matchRoute === null) {
-        return Response.json(
-          {
-            error:
-              `Fragno: Route for '${definition.name}' not found. Is the fragment mounted on the right route? ` +
-              `Expecting: '${mountRoute}'.`,
-            code: "ROUTE_NOT_FOUND",
-          },
-          { status: 404 },
-        );
-      }
-
-      const route = findRoute(router, req.method, matchRoute);
-
-      if (!route) {
-        return Response.json(
-          { error: `Fragno: Route for '${definition.name}' not found`, code: "ROUTE_NOT_FOUND" },
-          { status: 404 },
-        );
-      }
-
-      const { handler, inputSchema, outputSchema, path } = route.data;
-
-      const outputContext = new RequestOutputContext(outputSchema);
-
-      // Create mutable request state that can be modified by middleware
-      // Clone the request to read body as both text and JSON without consuming original stream
-      let requestBody: RequestBodyType = undefined;
-      let rawBody: string | undefined = undefined;
-
-      if (req.body instanceof ReadableStream) {
-        // Clone request to make sure we don't consume body stream
-        const clonedReq = req.clone();
-
-        // Get raw text
-        rawBody = await clonedReq.text();
-
-        // Parse JSON if body is not empty
-        if (rawBody) {
-          try {
-            requestBody = JSON.parse(rawBody);
-          } catch {
-            // If JSON parsing fails, keep body as undefined
-            // This handles cases where body is not JSON
-            requestBody = undefined;
-          }
-        }
-      }
-
-      const requestState = new MutableRequestState({
-        pathParams: route.params ?? {},
-        searchParams: url.searchParams,
-        body: requestBody,
-        headers: new Headers(req.headers),
-      });
-
-      if (middlewareHandler) {
-        const middlewareInputContext = new RequestMiddlewareInputContext(routes, {
-          method: req.method as HTTPMethod,
-          path,
-          request: req,
-          state: requestState,
-        });
-
-        const middlewareOutputContext = new RequestMiddlewareOutputContext(
-          depsWithInterfaces,
-          services,
-        );
-
-        try {
-          const middlewareResult = await middlewareHandler(
-            middlewareInputContext,
-            middlewareOutputContext,
-          );
-          if (middlewareResult !== undefined) {
-            return middlewareResult;
-          }
-        } catch (error) {
-          console.error("Error in middleware", error);
-
-          if (error instanceof FragnoApiError) {
-            // TODO: If a validation error occurs in middleware (when calling `await input.valid()`)
-            //       the processing is short-circuited and a potential `catch` block around the call
-            //       to `input.valid()` in the actual handler will not be executed.
-            return error.toResponse();
-          }
-
-          return Response.json(
-            { error: "Internal server error", code: "INTERNAL_SERVER_ERROR" },
-            { status: 500 },
-          );
-        }
-      }
-
-      const inputContext = await RequestInputContext.fromRequest({
-        request: req,
-        method: req.method,
-        path,
-        pathParams: (route.params ?? {}) as ExtractPathParams<typeof path>,
-        inputSchema,
-        state: requestState,
-        rawBody,
-      });
-
-      try {
-        // Apply handler wrapper if provided (e.g., for database support)
-        // Safe cast: handler wrapper preserves handler signature
-        const actualHandler = handlerWrapper
-          ? (handlerWrapper(handler as RouteHandler) as typeof handler)
-          : handler;
-
-        // Create base this context (empty object for standard fragments)
-        // Database fragments will provide their own context via handler wrapper
-        const thisContext = {} as RequestThisContext;
-        const result = await actualHandler.call(thisContext, inputContext, outputContext);
-        return result;
-      } catch (error) {
-        console.error("Error in handler", error);
-
-        if (error instanceof FragnoApiError) {
-          return error.toResponse();
-        }
-
-        return Response.json(
-          { error: "Internal server error", code: "INTERNAL_SERVER_ERROR" },
-          { status: 500 },
-        );
-      }
-    },
-  };
-
-  return fragment;
-}
-
-/**
- * Builder class for fluent fragment instantiation API
- */
-export class FragmentInstantiationBuilder<
-  TConfig,
-  TDeps,
-  TServices extends Record<string, unknown>,
-  TRoutesOrFactories extends readonly AnyRouteOrFactory[],
-  TAdditionalContext extends Record<string, unknown>,
-  TRequiredInterfaces extends Record<string, unknown>,
-  TProvidedInterfaces extends Record<string, unknown>,
-  TOptions extends FragnoPublicConfig,
-  TThisContext extends RequestThisContext,
-> {
-  #fragmentBuilder: {
-    definition: FragmentDefinition<
-      TConfig,
-      TDeps,
-      TServices,
-      TAdditionalContext,
-      TRequiredInterfaces,
-      TProvidedInterfaces,
-      TThisContext
-    >;
-    $requiredOptions: TOptions;
-  };
-  #config?: TConfig;
-  #routes?: TRoutesOrFactories;
-  #options?: TOptions;
-  #services?: TRequiredInterfaces;
-
-  constructor(fragmentBuilder: {
-    definition: FragmentDefinition<
-      TConfig,
-      TDeps,
-      TServices,
-      TAdditionalContext,
-      TRequiredInterfaces,
-      TProvidedInterfaces,
-      TThisContext
-    >;
-    $requiredOptions: TOptions;
-  }) {
-    this.#fragmentBuilder = fragmentBuilder;
-  }
-
-  /**
-   * Set the configuration for the fragment
-   */
-  withConfig(config: TConfig): this {
-    this.#config = config;
-    return this;
-  }
-
-  /**
-   * Set the routes for the fragment
-   */
-  withRoutes<const TNewRoutes extends readonly AnyRouteOrFactory[]>(
-    routes: TNewRoutes,
-  ): FragmentInstantiationBuilder<
-    TConfig,
-    TDeps,
-    TServices,
-    TNewRoutes,
-    TAdditionalContext,
-    TRequiredInterfaces,
-    TProvidedInterfaces,
-    TOptions,
-    TThisContext
-  > {
-    this.#routes = routes as unknown as TRoutesOrFactories;
-    // Safe cast: We're changing the route type parameter
-    return this as unknown as FragmentInstantiationBuilder<
-      TConfig,
-      TDeps,
-      TServices,
-      TNewRoutes,
-      TAdditionalContext,
-      TRequiredInterfaces,
-      TProvidedInterfaces,
-      TOptions,
-      TThisContext
-    >;
-  }
-
-  /**
-   * Set the options for the fragment (e.g., mountRoute, databaseAdapter)
-   */
-  withOptions(options: TOptions): this {
-    this.#options = options;
-    return this;
-  }
-
-  /**
-   * Provide implementations for services that this fragment uses
-   */
-  withServices(services: TRequiredInterfaces): this {
-    this.#services = services;
-    return this;
-  }
-
-  /**
-   * Build and return the instantiated fragment
-   */
-  build(): FragnoInstantiatedFragment<
-    FlattenRouteFactories<TRoutesOrFactories>,
-    TDeps & TRequiredInterfaces,
-    TServices & TProvidedInterfaces & TRequiredInterfaces,
-    TAdditionalContext
-  > {
-    return createFragment(
-      this.#fragmentBuilder,
-      this.#config ?? ({} as TConfig),
-      this.#routes ?? ([] as const as unknown as TRoutesOrFactories),
-      this.#options ?? ({} as TOptions),
-      this.#services,
-    );
-  }
-}
-
-/**
- * Create a fluent builder for instantiating a fragment
- *
- * @example
- * ```ts
- * const fragment = instantiateFragment(myFragmentBuilder)
- *   .withConfig({ apiKey: "key" })
- *   .withRoutes([route1, route2])
- *   .withOptions({ mountRoute: "/api" })
- *   .build();
- * ```
- */
-export function instantiateFragment<
-  TConfig,
-  TDeps,
-  TServices extends Record<string, unknown>,
-  TAdditionalContext extends Record<string, unknown>,
-  TRequiredInterfaces extends Record<string, unknown>,
-  TProvidedInterfaces extends Record<string, unknown>,
-  TOptions extends FragnoPublicConfig,
-  TThisContext extends RequestThisContext = RequestThisContext,
->(fragmentBuilder: {
-  definition: FragmentDefinition<
-    TConfig,
-    TDeps,
-    TServices,
-    TAdditionalContext,
-    TRequiredInterfaces,
-    TProvidedInterfaces,
-    TThisContext
-  >;
-  $requiredOptions: TOptions;
-}): FragmentInstantiationBuilder<
-  TConfig,
-  TDeps,
-  TServices,
-  readonly [],
-  TAdditionalContext,
-  TRequiredInterfaces,
-  TProvidedInterfaces,
-  TOptions,
-  TThisContext
-> {
-  return new FragmentInstantiationBuilder(fragmentBuilder);
-}