@fragno-dev/core 0.1.7 → 0.1.8

package/dist/api-BFrUCIsF.d.ts

@@ -0,0 +1,963 @@
+import { ReadableAtom, Store } from "nanostores";
+import { FetcherStore, MutatorStore } from "@nanostores/query";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/api/internal/path.d.ts
+type SplitPath<T extends string> = T extends `${infer First}/${infer Rest}` ? First extends "" ? SplitPath<Rest> : [First, ...SplitPath<Rest>] : T extends "" ? [] : [T];
+type ExtractParam<T extends string> = T extends `:${infer Name}` ? Name : T extends `**:${infer Name}` ? Name : T extends "**" ? "**" : never;
+type ExtractParamsFromSegments<T extends readonly string[]> = T extends readonly [infer First, ...infer Rest] ? First extends string ? Rest extends readonly string[] ? ExtractParam<First> | ExtractParamsFromSegments<Rest> : ExtractParam<First> : never : never;
+/**
+ * Type helper to extract path parameters from a const string path
+ *
+ * Supports:
+ * - Regular paths: "/path" -> never
+ * - Named parameters: "/path/:name" -> "name"
+ * - Wildcard paths: "/path/foo/**" -> "**"
+ * - Named wildcard paths: "/path/foo/**:name" -> "name"
+ * - String (narrows): string -> never
+ */
+type ExtractPathParams<T extends string, ValueType = string> = ExtractParamsFromSegments<SplitPath<T>> extends never ? Record<string, never> : Record<ExtractParamsFromSegments<SplitPath<T>>, ValueType>;
+/**
+ * Same as @see ExtractPathParams, but returns `Record<string, ValueType>` when a string is
+ * passed in.
+ */
+type ExtractPathParamsOrWiden<T extends string, ValueType = string> = string extends T ? Record<string, ValueType> : ExtractPathParams<T, ValueType>;
+/**
+ * Same as @see ExtractPathParamsOrWiden, but returns `undefined` when no path parameters in the
+ * const.
+ */
+type MaybeExtractPathParamsOrWiden<T extends string, ValueType = string> = HasPathParams<T> extends true ? ExtractPathParamsOrWiden<T, ValueType> : undefined;
+type ExtractPathParamNames<T extends string> = ExtractParamsFromSegments<SplitPath<T>>;
+type HasPathParams<T extends string> = ExtractPathParamNames<T> extends never ? false : true;
+/**
+ * Creates a query parameters type where the specified keys are hints (optional)
+ * and additional string keys are also allowed.
+ *
+ * This allows for flexible query parameter typing where:
+ * - All hinted parameters are optional
+ * - Additional parameters beyond the hints are allowed
+ * - Values can be of any specified type (defaults to string)
+ *
+ * @example
+ * ```ts
+ * type MyQuery = QueryParamsHint<"page" | "limit", string>;
+ * // Allows: { page?: string, limit?: string, [key: string]: string }
+ *
+ * const query1: MyQuery = {}; // Valid - no params required
+ * const query2: MyQuery = { page: "1" }; // Valid - hinted param
+ * const query3: MyQuery = { page: "1", sort: "asc" }; // Valid - additional param
+ * ```
+ */
+type QueryParamsHint<TQueryParameters extends string, ValueType = string> = Partial<Record<TQueryParameters, ValueType>> & Record<string, ValueType | undefined>;
+//#endregion
+//#region src/api/mutable-request-state.d.ts
+/**
+ * Holds mutable request state that can be modified by middleware and consumed by handlers.
+ *
+ * This class provides a structural way for middleware to modify request data:
+ * - Path parameters can be modified
+ * - Query/search parameters can be modified
+ * - Request body can be overridden
+ * - Request headers can be modified
+ *
+ * @example
+ * ```typescript
+ * // In middleware
+ * const state = new MutableRequestState({
+ *   pathParams: { id: "123" },
+ *   searchParams: new URLSearchParams("?role=user"),
+ *   body: { name: "John" },
+ *   headers: new Headers()
+ * });
+ *
+ * // Modify query parameters
+ * state.searchParams.set("role", "admin");
+ *
+ * // Override body
+ * state.setBody({ name: "Jane" });
+ *
+ * // Modify headers
+ * state.headers.set("X-Custom", "value");
+ * ```
+ */
+declare class MutableRequestState {
+  #private;
+  constructor(config: {
+    pathParams: Record<string, string>;
+    searchParams: URLSearchParams;
+    body: RequestBodyType;
+    headers: Headers;
+  });
+  /**
+   * Path parameters extracted from the route.
+   * Can be modified directly (e.g., `state.pathParams.id = "456"`).
+   */
+  get pathParams(): Record<string, string>;
+  /**
+   * URLSearchParams for query parameters.
+   * Can be modified using URLSearchParams API (e.g., `state.searchParams.set("key", "value")`).
+   */
+  get searchParams(): URLSearchParams;
+  /**
+   * Request headers.
+   * Can be modified using Headers API (e.g., `state.headers.set("X-Custom", "value")`).
+   */
+  get headers(): Headers;
+  /**
+   * Get the current body value.
+   * Returns the override if set, otherwise the initial body.
+   */
+  get body(): RequestBodyType;
+  /**
+   * Override the request body.
+   * This allows middleware to replace the body that will be seen by the handler.
+   *
+   * @param body - The new body value
+   *
+   * @example
+   * ```typescript
+   * // In middleware
+   * state.setBody({ modifiedField: "new value" });
+   * ```
+   */
+  setBody(body: RequestBodyType): void;
+  /**
+   * Check if the body has been overridden by middleware.
+   */
+  get hasBodyOverride(): boolean;
+}
+//#endregion
+//#region src/api/request-input-context.d.ts
+type RequestBodyType = unknown | FormData | Blob | null | undefined;
+declare class RequestInputContext<TPath extends string = string, TInputSchema extends StandardSchemaV1 | undefined = undefined> {
+  #private;
+  constructor(config: {
+    path: TPath;
+    method: string;
+    pathParams: ExtractPathParams<TPath>;
+    searchParams: URLSearchParams;
+    parsedBody: RequestBodyType;
+    rawBody?: string;
+    headers: Headers;
+    request?: Request;
+    inputSchema?: TInputSchema;
+    shouldValidateInput?: boolean;
+  });
+  /**
+   * Create a RequestContext from a Request object for server-side handling
+   */
+  static fromRequest<TPath extends string, TInputSchema extends StandardSchemaV1 | undefined = undefined>(config: {
+    request: Request;
+    method: string;
+    path: TPath;
+    pathParams: ExtractPathParams<TPath>;
+    inputSchema?: TInputSchema;
+    shouldValidateInput?: boolean;
+    state: MutableRequestState;
+    rawBody?: string;
+  }): Promise<RequestInputContext<TPath, TInputSchema>>;
+  /**
+   * Create a RequestContext for server-side rendering contexts (no Request object)
+   */
+  static fromSSRContext<TPath extends string, TInputSchema extends StandardSchemaV1 | undefined = undefined>(config: {
+    method: "GET";
+    path: TPath;
+    pathParams: ExtractPathParams<TPath>;
+    searchParams?: URLSearchParams;
+    headers?: Headers;
+  } | {
+    method: Exclude<HTTPMethod, "GET">;
+    path: TPath;
+    pathParams: ExtractPathParams<TPath>;
+    searchParams?: URLSearchParams;
+    headers?: Headers;
+    body: RequestBodyType;
+    inputSchema?: TInputSchema;
+  }): RequestInputContext<TPath, TInputSchema>;
+  /**
+   * The HTTP method as string (e.g., `GET`, `POST`)
+   */
+  get method(): string;
+  /**
+   * The matched route path (e.g., `/users/:id`)
+   * @remarks `string`
+   */
+  get path(): TPath;
+  /**
+   * Extracted path parameters as object (e.g., `{ id: '123' }`)
+   * @remarks `Record<string, string>`
+   */
+  get pathParams(): ExtractPathParams<TPath>;
+  /**
+   * [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams) object for query parameters
+   * @remarks `URLSearchParams`
+   */
+  get query(): URLSearchParams;
+  /**
+   * [Headers](https://developer.mozilla.org/en-US/docs/Web/API/Headers) object for request headers
+   * @remarks `Headers`
+   */
+  get headers(): Headers;
+  get rawBody(): string | undefined;
+  /**
+   * Input validation context (only if inputSchema is defined)
+   * @remarks `InputContext`
+   */
+  get input(): TInputSchema extends undefined ? undefined : {
+    schema: TInputSchema;
+    valid: () => Promise<TInputSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TInputSchema> : unknown>;
+  };
+}
+//#endregion
+//#region src/http/http-status.d.ts
+/**
+ * @module
+ * HTTP Status utility.
+ *
+ * Modified from honojs/hono
+ * Original source: https://github.com/honojs/hono/blob/0e3db674ad3f40be215a55a18062dd8e387ce525/src/utils/http-status.ts
+ * License: MIT
+ * Date obtained: August 28 2025
+ * Copyright (c) 2021-present Yusuke Wada and Hono contributors
+ *
+ */
+type InfoStatusCode = 100 | 101 | 102 | 103;
+type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+type DeprecatedStatusCode = 305 | 306;
+type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
+type ClientErrorStatusCode = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
+type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+/**
+ * If you want to use an unofficial status, use `UnofficialStatusCode`.
+ */
+type StatusCode = InfoStatusCode | SuccessStatusCode | RedirectStatusCode | ClientErrorStatusCode | ServerErrorStatusCode;
+type ContentlessStatusCode = 101 | 204 | 205 | 304;
+//#endregion
+//#region src/api/internal/response-stream.d.ts
+/**
+ * @module
+ * Stream utility.
+ *
+ * Modified from honojs/hono
+ * Original source: https://github.com/honojs/hono/blob/0e3db674ad3f40be215a55a18062dd8e387ce525/src/utils/stream.ts
+ * License: MIT
+ * Date obtained: August 28 2025
+ * Copyright (c) 2021-present Yusuke Wada and Hono contributors
+ */
+type Error$1<Message extends string> = {
+  __errorMessage: Message;
+};
+declare class ResponseStream<TArray> {
+  #private;
+  /**
+   * Whether the stream has been aborted.
+   */
+  get aborted(): boolean;
+  /**
+   * Whether the stream has been closed normally.
+   */
+  get closed(): boolean;
+  /**
+   * The readable stream that the response is piped to.
+   */
+  get responseReadable(): ReadableStream;
+  constructor(writable: WritableStream, readable: ReadableStream);
+  writeRaw(input: Uint8Array | string): Promise<void>;
+  write(input: TArray extends (infer U)[] ? U : Error$1<"To use a streaming response, outputSchema must be an array.">): Promise<void>;
+  sleep(ms: number): Promise<unknown>;
+  close(): Promise<void>;
+  onAbort(listener: () => void | Promise<void>): void;
+  /**
+   * Abort the stream.
+   * You can call this method when stream is aborted by external event.
+   */
+  abort(): void;
+}
+//#endregion
+//#region src/util/types-util.d.ts
+type InferOr<T, U$1> = T extends NonNullable<StandardSchemaV1> ? StandardSchemaV1.InferOutput<T> : T extends undefined ? U$1 : U$1;
+type InferOrUnknown<T> = InferOr<T, unknown>;
+//#endregion
+//#region src/api/request-output-context.d.ts
+interface ResponseInit<T extends StatusCode = StatusCode> {
+  headers?: HeadersInit;
+  status?: T;
+  statusText?: string;
+}
+declare abstract class OutputContext<const TOutput, const TErrorCode extends string> {
+  /**
+   * Creates an error response.
+   *
+   * Shortcut for `throw new FragnoApiError(...)`
+   */
+  error: ({
+    message,
+    code
+  }: {
+    message: string;
+    code: TErrorCode;
+  }, initOrStatus?: ResponseInit | StatusCode, headers?: HeadersInit) => Response;
+  empty: (initOrStatus?: ResponseInit<ContentlessStatusCode> | ContentlessStatusCode, headers?: HeadersInit) => Response;
+  json: (object: TOutput, initOrStatus?: ResponseInit | StatusCode, headers?: HeadersInit) => Response;
+  jsonStream: (cb: (stream: ResponseStream<TOutput>) => void | Promise<void>, {
+    onError,
+    headers
+  }?: {
+    onError?: (error: Error, stream: ResponseStream<TOutput>) => void | Promise<void>;
+    headers?: HeadersInit;
+  }) => Response;
+}
+declare class RequestOutputContext<const TOutputSchema extends StandardSchemaV1 | undefined = undefined, const TErrorCode extends string = string> extends OutputContext<InferOrUnknown<TOutputSchema>, TErrorCode> {
+  #private;
+  constructor(outputSchema?: TOutputSchema);
+}
+//#endregion
+//#region src/api/error.d.ts
+declare class FragnoApiError extends Error {
+  #private;
+  constructor({
+    message,
+    code
+  }: {
+    message: string;
+    code: string;
+  }, status: StatusCode);
+  get status(): StatusCode;
+  get code(): string;
+  toResponse(): Response;
+}
+declare class FragnoApiValidationError extends FragnoApiError {
+  #private;
+  constructor(message: string, issues: readonly StandardSchemaV1.Issue[]);
+  get issues(): readonly StandardSchemaV1.Issue[];
+  toResponse(): Response;
+}
+//#endregion
+//#region src/api/route-handler-input-options.d.ts
+/**
+ * Options for calling a route handler
+ */
+type RouteHandlerInputOptions<TPath extends string, TInputSchema extends StandardSchemaV1 | undefined> = {
+  pathParams?: ExtractPathParams<TPath>;
+  query?: URLSearchParams | Record<string, string>;
+  headers?: Headers | Record<string, string>;
+} & (TInputSchema extends undefined ? {
+  body?: never;
+} : {
+  body: InferOr<TInputSchema, unknown>;
+});
+//#endregion
+//#region src/api/fragment-builder.d.ts
+/**
+ * Metadata for a service dependency
+ */
+interface ServiceMetadata {
+  /** Name of the service */
+  name: string;
+  /** Whether this service is required (false means optional) */
+  required: boolean;
+}
+type RouteHandler = (this: RequestThisContext, inputContext: RequestInputContext, outputContext: RequestOutputContext) => Promise<Response>;
+interface FragmentDefinition<TConfig$1, TDeps$1 = {}, TServices$1 = {}, TAdditionalContext extends Record<string, unknown> = {}, TUsedServices$1 = {}, TProvidedServices$1 = {}, TThisContext$1 extends RequestThisContext = RequestThisContext> {
+  name: string;
+  dependencies?: (config: TConfig$1, options: FragnoPublicConfig) => TDeps$1;
+  services?: (config: TConfig$1, options: FragnoPublicConfig, deps: TDeps$1 & TUsedServices$1) => TServices$1;
+  additionalContext?: TAdditionalContext;
+  createHandlerWrapper?: (options: FragnoPublicConfig) => (handler: (this: TThisContext$1, ...args: Parameters<RouteHandler>) => ReturnType<RouteHandler>) => RouteHandler;
+  /** Services that this fragment uses (can be required or optional) */
+  usedServices?: { [K in keyof TUsedServices$1]: ServiceMetadata };
+  /** Services that this fragment provides to other fragments (can be a factory function or direct object) */
+  providedServices?: { [K in keyof TProvidedServices$1]: TProvidedServices$1[K] } | ((config: TConfig$1, options: FragnoPublicConfig, deps: TDeps$1 & TUsedServices$1) => TProvidedServices$1);
+}
+declare class FragmentBuilder<const TConfig$1, const TDeps$1 = {}, const TServices$1 = {}, const TAdditionalContext extends Record<string, unknown> = {}, const TUsedServices$1 = {}, const TProvidedServices$1 = {}, const TThisContext$1 extends RequestThisContext = RequestThisContext> {
+  #private;
+  constructor(definition: FragmentDefinition<TConfig$1, TDeps$1, TServices$1, TAdditionalContext, TUsedServices$1, TProvidedServices$1, TThisContext$1>);
+  get definition(): FragmentDefinition<TConfig$1, TDeps$1, TServices$1, TAdditionalContext, TUsedServices$1, TProvidedServices$1, TThisContext$1>;
+  get $requiredOptions(): FragnoPublicConfig;
+  withDependencies<TNewDeps>(fn: (context: {
+    config: TConfig$1;
+    fragnoConfig: FragnoPublicConfig;
+  } & TAdditionalContext) => TNewDeps): FragmentBuilder<TConfig$1, TNewDeps, {}, TAdditionalContext, TUsedServices$1, TProvidedServices$1, TThisContext$1>;
+  /**
+   * Declare that this fragment uses a service.
+   * By default, the service is required. Pass { optional: true } to make it optional.
+   *
+   * @example
+   * ```ts
+   * // Required service
+   * defineFragment("my-fragment")
+   *   .usesService<"email", IEmailService>("email")
+   *   .providesService(({ deps, define }) => define({
+   *     sendWelcome: () => deps.email.send(...)
+   *   }))
+   *
+   * // Optional service
+   * defineFragment("my-fragment")
+   *   .usesService<"email", IEmailService>("email", { optional: true })
+   *   .providesService(({ deps, define }) => define({
+   *     sendWelcome: () => {
+   *       if (deps.email) {
+   *         deps.email.send(...)
+   *       }
+   *     }
+   *   }))
+   * ```
+   */
+  usesService<TServiceName extends string, TService>(serviceName: TServiceName, options?: {
+    optional?: false;
+  }): FragmentBuilder<TConfig$1, TDeps$1, TServices$1, TAdditionalContext, TUsedServices$1 & { [K in TServiceName]: TService }, TProvidedServices$1, TThisContext$1>;
+  usesService<TServiceName extends string, TService>(serviceName: TServiceName, options: {
+    optional: true;
+  }): FragmentBuilder<TConfig$1, TDeps$1, TServices$1, TAdditionalContext, TUsedServices$1 & { [K in TServiceName]: TService | undefined }, TProvidedServices$1, TThisContext$1>;
+  /**
+   * Define services for this fragment (unnamed) using a callback.
+   * Use the `defineService` function from the callback context for proper typing (optional).
+   */
+  providesService<TNewServices>(fn: (context: {
+    config: TConfig$1;
+    fragnoConfig: FragnoPublicConfig;
+    deps: TDeps$1 & TUsedServices$1;
+    defineService: <T>(services: T) => T;
+  }) => TNewServices): FragmentBuilder<TConfig$1, TDeps$1, TNewServices, TAdditionalContext, TUsedServices$1, TProvidedServices$1, TThisContext$1>;
+  /**
+   * Define services for this fragment (unnamed) using a direct object.
+   */
+  providesService<TNewServices>(services: TNewServices): FragmentBuilder<TConfig$1, TDeps$1, TNewServices, TAdditionalContext, TUsedServices$1, TProvidedServices$1, TThisContext$1>;
+  /**
+   * Provide a named service using a callback.
+   * Use the `defineService` function from the callback context for proper typing (optional).
+   *
+   * @example
+   * ```ts
+   * interface IEmailService {
+   *   send(to: string, subject: string, body: string): Promise<void>;
+   * }
+   *
+   * defineFragment("email-fragment")
+   *   .providesService<"email", IEmailService>("email", ({ defineService }) => defineService({
+   *     send: async (to, subject, body) => {
+   *       // implementation
+   *     }
+   *   }))
+   * ```
+   */
+  providesService<TServiceName extends string, TService>(serviceName: TServiceName, fn: (context: {
+    config: TConfig$1;
+    fragnoConfig: FragnoPublicConfig;
+    deps: TDeps$1 & TUsedServices$1;
+    defineService: <T>(services: T) => T;
+  }) => TService): FragmentBuilder<TConfig$1, TDeps$1, TServices$1, TAdditionalContext, TUsedServices$1, TProvidedServices$1 & { [K in TServiceName]: TService }, TThisContext$1>;
+  /**
+   * Provide a named service using a direct object.
+   */
+  providesService<TServiceName extends string, TService>(serviceName: TServiceName, service: TService): FragmentBuilder<TConfig$1, TDeps$1, TServices$1, TAdditionalContext, TUsedServices$1, TProvidedServices$1 & { [K in TServiceName]: TService }, TThisContext$1>;
+}
+declare function defineFragment<TConfig$1 = {}>(name: string): FragmentBuilder<TConfig$1, {}, {}, {}, {}, {}, RequestThisContext>;
+//#endregion
+//#region src/api/route.d.ts
+type AnyFragnoRouteConfig = FragnoRouteConfig<HTTPMethod, string, any, any, any, any, any>;
+type AnyFragmentBuilder = {
+  readonly definition: FragmentDefinition<any, any, any, any, any, any, any>;
+};
+interface RouteFactoryContext<TConfig$1, TDeps$1, TServices$1> {
+  config: TConfig$1;
+  deps: TDeps$1;
+  services: TServices$1;
+}
+type RouteFactory<TConfig$1, TDeps$1, TServices$1, TRoutes$1 extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string, RequestThisContext>[]> = (context: RouteFactoryContext<TConfig$1, TDeps$1, TServices$1>) => TRoutes$1;
+type AnyRouteOrFactory = AnyFragnoRouteConfig | RouteFactory<any, any, any, any>;
+type FlattenRouteFactories<T extends readonly AnyRouteOrFactory[]> = T extends readonly [infer First, ...infer Rest extends readonly AnyRouteOrFactory[]] ? First extends RouteFactory<any, any, any, infer TRoutes> ? [...TRoutes, ...FlattenRouteFactories<Rest>] : [First, ...FlattenRouteFactories<Rest>] : [];
+declare function resolveRouteFactories<TConfig$1, TDeps$1, TServices$1, const TRoutesOrFactories extends readonly AnyRouteOrFactory[]>(context: RouteFactoryContext<TConfig$1, TDeps$1, TServices$1>, routesOrFactories: TRoutesOrFactories): FlattenRouteFactories<TRoutesOrFactories>;
+declare function defineRoute<const TMethod extends HTTPMethod, const TPath extends string, const TOutputSchema extends StandardSchemaV1 | undefined, const TErrorCode extends string = string, const TQueryParameters extends string = string, const TThisContext$1 extends RequestThisContext = RequestThisContext>(config: FragnoRouteConfig<TMethod, TPath, undefined, TOutputSchema, TErrorCode, TQueryParameters, TThisContext$1> & {
+  inputSchema?: undefined;
+}): FragnoRouteConfig<TMethod, TPath, undefined, TOutputSchema, TErrorCode, TQueryParameters, TThisContext$1>;
+declare function defineRoute<const TMethod extends HTTPMethod, const TPath extends string, const TInputSchema extends StandardSchemaV1, const TOutputSchema extends StandardSchemaV1 | undefined, const TErrorCode extends string = string, const TQueryParameters extends string = string, const TThisContext$1 extends RequestThisContext = RequestThisContext>(config: FragnoRouteConfig<TMethod, TPath, TInputSchema, TOutputSchema, TErrorCode, TQueryParameters, TThisContext$1> & {
+  inputSchema: TInputSchema;
+}): FragnoRouteConfig<TMethod, TPath, TInputSchema, TOutputSchema, TErrorCode, TQueryParameters, TThisContext$1>;
+type GetDefinition<T> = T extends {
+  definition: unknown;
+} ? T["definition"] : never;
+type ExtractFragmentConfig<T> = GetDefinition<T> extends FragmentDefinition<infer TConfig, any, any, any, any, any> ? TConfig : never;
+type ExtractFragmentDeps<T> = GetDefinition<T> extends FragmentDefinition<any, infer TDeps, any, any, infer TUsedServices, any> ? TDeps & TUsedServices : never;
+type OmitThisParameter<T> = T extends ((this: infer _This, ...args: infer A) => infer R) ? (...args: A) => R : T;
+type BoundServicesLocal<T> = { [K in keyof T]: T[K] extends ((...args: never[]) => unknown) ? OmitThisParameter<T[K]> : T[K] extends Record<string, unknown> ? BoundServicesLocal<T[K]> : T[K] };
+type ExtractFragmentServices<T> = T extends {
+  $types: {
+    services: infer S;
+    providedServices: infer P;
+  };
+} ? BoundServicesLocal<S & P> : GetDefinition<T> extends FragmentDefinition<any, any, infer TServices, any, any, infer TProvidedServices> ? TServices & TProvidedServices : never;
+type ExtractThisContext<T> = GetDefinition<T> extends FragmentDefinition<any, any, any, any, any, any, infer TThisContext> ? TThisContext : RequestThisContext;
+declare function defineRoutes<const TFragmentBuilder extends AnyFragmentBuilder>(fragmentBuilder: TFragmentBuilder): {
+  create: <const TRoutes$1 extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string, ExtractThisContext<TFragmentBuilder>>[]>(fn: (context: RouteFactoryContext<ExtractFragmentConfig<TFragmentBuilder>, ExtractFragmentDeps<TFragmentBuilder>, ExtractFragmentServices<TFragmentBuilder>> & {
+    defineRoute: <const TMethod extends HTTPMethod, const TPath extends string, const TInputSchema extends StandardSchemaV1 | undefined, const TOutputSchema extends StandardSchemaV1 | undefined, const TErrorCode extends string = string, const TQueryParameters extends string = string>(config: FragnoRouteConfig<TMethod, TPath, TInputSchema, TOutputSchema, TErrorCode, TQueryParameters, ExtractThisContext<TFragmentBuilder>>) => FragnoRouteConfig<TMethod, TPath, TInputSchema, TOutputSchema, TErrorCode, TQueryParameters, ExtractThisContext<TFragmentBuilder>>;
+  }) => TRoutes$1) => RouteFactory<ExtractFragmentConfig<TFragmentBuilder>, ExtractFragmentDeps<TFragmentBuilder>, ExtractFragmentServices<TFragmentBuilder>, TRoutes$1>;
+};
+declare function defineRoutes<const TFragmentBuilder extends AnyFragmentBuilder>(): {
+  create: <const TRoutes$1 extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string, ExtractThisContext<TFragmentBuilder>>[]>(fn: (context: RouteFactoryContext<ExtractFragmentConfig<TFragmentBuilder>, ExtractFragmentDeps<TFragmentBuilder>, ExtractFragmentServices<TFragmentBuilder>> & {
+    defineRoute: <const TMethod extends HTTPMethod, const TPath extends string, const TInputSchema extends StandardSchemaV1 | undefined, const TOutputSchema extends StandardSchemaV1 | undefined, const TErrorCode extends string = string, const TQueryParameters extends string = string>(config: FragnoRouteConfig<TMethod, TPath, TInputSchema, TOutputSchema, TErrorCode, TQueryParameters, ExtractThisContext<TFragmentBuilder>>) => FragnoRouteConfig<TMethod, TPath, TInputSchema, TOutputSchema, TErrorCode, TQueryParameters, ExtractThisContext<TFragmentBuilder>>;
+  }) => TRoutes$1) => RouteFactory<ExtractFragmentConfig<TFragmentBuilder>, ExtractFragmentDeps<TFragmentBuilder>, ExtractFragmentServices<TFragmentBuilder>, TRoutes$1>;
+};
+declare function defineRoutes<TConfig$1 = {}, TDeps$1 = {}, TServices$1 = {}>(): {
+  create: <const TRoutes$1 extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string, RequestThisContext>[]>(fn: (context: RouteFactoryContext<TConfig$1, TDeps$1, TServices$1> & {
+    defineRoute: typeof defineRoute;
+  }) => TRoutes$1) => RouteFactory<TConfig$1, TDeps$1, TServices$1, TRoutes$1>;
+};
+//#endregion
+//#region src/client/client-error.d.ts
+type FragnoErrorOptions = {
+  cause?: Error | unknown;
+};
+/**
+ * Base error class for all Fragno client errors.
+ */
+declare abstract class FragnoClientError<TCode extends string = string> extends Error {
+  #private;
+  constructor(message: string, code: TCode, options?: FragnoErrorOptions);
+  get code(): TCode | (string & {});
+}
+declare class FragnoClientFetchError extends FragnoClientError<"NO_BODY" | "NETWORK_ERROR" | "ABORT_ERROR"> {
+  constructor(message: string, code: "NO_BODY" | "NETWORK_ERROR" | "ABORT_ERROR", options?: FragnoErrorOptions);
+  static fromUnknownFetchError(error: unknown): FragnoClientFetchError;
+}
+/**
+ * Error thrown when a network request fails (e.g., no internet connection, DNS failure).
+ */
+declare class FragnoClientFetchNetworkError extends FragnoClientFetchError {
+  constructor(message?: string, options?: FragnoErrorOptions);
+}
+/**
+ * Error thrown when a request is aborted (e.g., user cancels request, timeout).
+ */
+declare class FragnoClientFetchAbortError extends FragnoClientFetchError {
+  constructor(message?: string, options?: FragnoErrorOptions);
+}
+/**
+ * Error thrown when the API result is unexpected, e.g. no json is returned.
+ */
+declare class FragnoClientUnknownApiError extends FragnoClientError<"UNKNOWN_API_ERROR"> {
+  #private;
+  constructor(message: string | undefined, status: StatusCode, options?: FragnoErrorOptions);
+  get status(): StatusCode;
+}
+declare class FragnoClientApiError<TErrorCode extends string = string> extends FragnoClientError<TErrorCode> {
+  #private;
+  constructor({
+    message,
+    code
+  }: {
+    message: string;
+    code: TErrorCode;
+  }, status: StatusCode, options?: FragnoErrorOptions);
+  get status(): StatusCode;
+  /**
+   * The error code returned by the API.
+   *
+   * 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 & {});
+  static fromResponse<TErrorCode extends string = string>(response: Response): Promise<FragnoClientApiError<TErrorCode> | FragnoClientUnknownApiError>;
+}
+//#endregion
+//#region src/client/client.d.ts
+/**
+ * Symbols used to identify hook types
+ */
+declare const GET_HOOK_SYMBOL: unique symbol;
+declare const MUTATOR_HOOK_SYMBOL: unique symbol;
+declare const STORE_SYMBOL: unique symbol;
+/**
+ * Extract only GET routes from a library config's routes array
+ */
+type ExtractGetRoutes<T extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string>[]> = { [K in keyof T]: T[K] extends FragnoRouteConfig<infer Method, infer Path, infer Input, infer Output, infer ErrorCode, infer QueryParams> ? Method extends "GET" ? FragnoRouteConfig<Method, Path, Input, Output, ErrorCode, QueryParams> : never : never }[number][];
+/**
+ * Extract the path from a route configuration for a given method
+ */
+type ExtractRoutePath<T extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string>[], TExpectedMethod extends HTTPMethod = HTTPMethod> = { [K in keyof T]: T[K] extends FragnoRouteConfig<infer Method, infer Path, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string> ? Method extends TExpectedMethod ? Path : never : never }[number];
+type ExtractGetRoutePaths<T extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string>[]> = ExtractRoutePath<T, "GET">;
+type ExtractNonGetRoutePaths<T extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string>[]> = ExtractRoutePath<T, NonGetHTTPMethod>;
+/**
+ * Extract the route configuration type(s) for a given path from a routes array.
+ * Optionally narrow by HTTP method via the third type parameter.
+ *
+ * Defaults to extracting all methods for the matching path, producing a union
+ * if multiple methods exist for the same path.
+ */
+type ExtractRouteByPath<TRoutes$1 extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string>[], TPath extends string, TMethod extends HTTPMethod = HTTPMethod> = { [K in keyof TRoutes$1]: TRoutes$1[K] extends FragnoRouteConfig<infer M, TPath, infer Input, infer Output, infer ErrorCode, infer QueryParams> ? M extends TMethod ? FragnoRouteConfig<M, TPath, Input, Output, ErrorCode, QueryParams> : never : never }[number];
+/**
+ * Extract the output schema type for a specific route path from a routes array
+ */
+type ExtractOutputSchemaForPath<TRoutes$1 extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined>[], TPath extends string> = { [K in keyof TRoutes$1]: TRoutes$1[K] extends FragnoRouteConfig<infer Method, TPath, StandardSchemaV1 | undefined, infer Output> ? Method extends "GET" ? Output : never : never }[number];
+/**
+ * Check if a path exists as a GET route in the routes array
+ */
+type IsValidGetRoutePath<TRoutes$1 extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string>[], TPath extends string> = TPath extends ExtractGetRoutePaths<TRoutes$1> ? true : false;
+/**
+ * Utility type to ensure only valid GET route paths can be used
+ */
+type ValidateGetRoutePath<TRoutes$1 extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string>[], TPath extends string> = TPath extends ExtractGetRoutePaths<TRoutes$1> ? TPath : `Error: Path '${TPath}' is not a valid GET route. Available GET routes: ${ExtractGetRoutePaths<TRoutes$1>}`;
+/**
+ * Helper type to check if a routes array has any GET routes
+ */
+type HasGetRoutes<T extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string>[]> = ExtractGetRoutePaths<T> extends never ? false : true;
+type ObjectContainingStoreField<T extends object> = T extends Store ? T : { [K in keyof T]: T[K] extends Store ? { [P in K]: T[P] } & Partial<Omit<T, K>> : never }[keyof T] extends never ? never : T;
+type FragnoStoreData<T extends object> = {
+  obj: T;
+  [STORE_SYMBOL]: true;
+};
+type FragnoClientHookData<TMethod extends HTTPMethod, TPath extends string, TOutputSchema extends StandardSchemaV1, TErrorCode extends string, TQueryParameters extends string> = {
+  route: FragnoRouteConfig<TMethod, TPath, StandardSchemaV1 | undefined, TOutputSchema, TErrorCode, TQueryParameters>;
+  query(args?: {
+    path?: MaybeExtractPathParamsOrWiden<TPath, string>;
+    query?: Record<TQueryParameters, string | undefined>;
+  }): Promise<StandardSchemaV1.InferOutput<TOutputSchema>>;
+  store(args?: {
+    path?: MaybeExtractPathParamsOrWiden<TPath, string | ReadableAtom<string>>;
+    query?: Record<TQueryParameters, string | undefined | ReadableAtom<string | undefined>>;
+  }): FetcherStore<StandardSchemaV1.InferOutput<TOutputSchema>, FragnoClientError<TErrorCode>>;
+  [GET_HOOK_SYMBOL]: true;
+} & {
+  readonly _outputSchema?: TOutputSchema;
+};
+type FragnoClientMutatorData<TMethod extends NonGetHTTPMethod, TPath extends string, TInputSchema extends StandardSchemaV1 | undefined, TOutputSchema extends StandardSchemaV1 | undefined, TErrorCode extends string, TQueryParameters extends string> = {
+  route: FragnoRouteConfig<TMethod, TPath, TInputSchema, TOutputSchema, TErrorCode, TQueryParameters>;
+  mutateQuery(args?: {
+    body?: InferOr<TInputSchema, undefined>;
+    path?: MaybeExtractPathParamsOrWiden<TPath, string>;
+    query?: Record<TQueryParameters, string | undefined>;
+  }): Promise<InferOr<TOutputSchema, undefined>>;
+  mutatorStore: MutatorStore<{
+    body?: InferOr<TInputSchema, undefined>;
+    path?: MaybeExtractPathParamsOrWiden<TPath, string | ReadableAtom<string>>;
+    query?: Record<TQueryParameters, string | undefined | ReadableAtom<string | undefined>>;
+  }, InferOr<TOutputSchema, undefined>, FragnoClientError<TErrorCode>>;
+  [MUTATOR_HOOK_SYMBOL]: true;
+} & {
+  readonly _inputSchema?: TInputSchema;
+  readonly _outputSchema?: TOutputSchema;
+};
+declare function buildUrl<TPath extends string>(config: {
+  baseUrl?: string;
+  mountRoute: string;
+  path: TPath;
+}, params: {
+  pathParams?: Record<string, string | ReadableAtom<string>>;
+  queryParams?: Record<string, string | undefined | ReadableAtom<string | undefined>>;
+}): string;
+/**
+ * This method returns an array, which can be passed directly to nanostores.
+ *
+ * The returned array is always: path, pathParams (In order they appear in the path), queryParams (In alphabetical order)
+ * Missing pathParams are replaced with "<missing>".
+ * Atoms with undefined values are wrapped in computed atoms that map undefined to "" to avoid nanoquery treating the key as incomplete.
+ * @param path
+ * @param params
+ * @returns
+ */
+declare function getCacheKey<TMethod extends HTTPMethod, TPath extends string>(method: TMethod, path: TPath, params?: {
+  pathParams?: Record<string, string | ReadableAtom<string>>;
+  queryParams?: Record<string, string | undefined | ReadableAtom<string | undefined>>;
+}): (string | ReadableAtom<string>)[];
+declare function isGetHook<TPath extends string, TOutputSchema extends StandardSchemaV1, TErrorCode extends string, TQueryParameters extends string>(hook: unknown): hook is FragnoClientHookData<"GET", TPath, TOutputSchema, TErrorCode, TQueryParameters>;
+declare function isMutatorHook<TMethod extends NonGetHTTPMethod, TPath extends string, TInputSchema extends StandardSchemaV1 | undefined, TOutputSchema extends StandardSchemaV1 | undefined, TErrorCode extends string, TQueryParameters extends string>(hook: unknown): hook is FragnoClientMutatorData<TMethod, TPath, TInputSchema, TOutputSchema, TErrorCode, TQueryParameters>;
+declare function isStore<TStore extends Store>(obj: unknown): obj is FragnoStoreData<TStore>;
+type OnErrorRetryFn = (opts: {
+  error: unknown;
+  key: string;
+  retryCount: number;
+}) => number | undefined;
+type CreateHookOptions = {
+  /**
+   * A function that will be called when an error occurs. Implements an exponential backoff strategy
+   * when left undefined. When null, retries will be disabled. The number returned (> 0) by the
+   * callback will determine in how many ms to retry next.
+   */
+  onErrorRetry?: OnErrorRetryFn | null;
+};
+type OnInvalidateFn<TPath extends string> = (invalidate: <TInnerPath extends string>(method: HTTPMethod, path: TInnerPath, params: {
+  pathParams?: MaybeExtractPathParamsOrWiden<TInnerPath, string>;
+  queryParams?: Record<string, string>;
+}) => void, params: {
+  pathParams: MaybeExtractPathParamsOrWiden<TPath, string>;
+  queryParams?: Record<string, string>;
+}) => void;
+type CacheLine = {
+  data: unknown;
+  error: unknown;
+  retryCount: number;
+  created: number;
+  expires: number;
+};
+declare class ClientBuilder<TRoutes$1 extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string>[], TFragmentConfig extends FragnoFragmentSharedConfig<TRoutes$1>> {
+  #private;
+  constructor(publicConfig: FragnoPublicClientConfig, fragmentConfig: TFragmentConfig);
+  get cacheEntries(): Readonly<Record<string, CacheLine>>;
+  createStore<const T extends object>(obj: T): FragnoStoreData<T>;
+  /**
+   * Build a URL for a custom backend call using the configured baseUrl and mountRoute.
+   * Useful for fragment authors who need to make custom fetch calls.
+   */
+  buildUrl<TPath extends string>(path: TPath, params?: {
+    path?: MaybeExtractPathParamsOrWiden<TPath, string>;
+    query?: Record<string, string>;
+  }): string;
+  /**
+   * Get the configured fetcher function for custom backend calls.
+   * Returns fetch with merged options applied.
+   */
+  getFetcher(): {
+    fetcher: typeof fetch;
+    defaultOptions: RequestInit | undefined;
+  };
+  createHook<TPath extends ExtractGetRoutePaths<TFragmentConfig["routes"]>>(path: ValidateGetRoutePath<TFragmentConfig["routes"], TPath>, options?: CreateHookOptions): FragnoClientHookData<"GET", TPath, NonNullable<ExtractRouteByPath<TFragmentConfig["routes"], TPath>["outputSchema"]>, NonNullable<ExtractRouteByPath<TFragmentConfig["routes"], TPath>["errorCodes"]>[number], NonNullable<ExtractRouteByPath<TFragmentConfig["routes"], TPath>["queryParameters"]>[number]>;
+  createMutator<TPath extends ExtractNonGetRoutePaths<TFragmentConfig["routes"]>>(method: NonGetHTTPMethod, path: TPath, onInvalidate?: OnInvalidateFn<TPath>): FragnoClientMutatorData<NonGetHTTPMethod,
+  // TODO: This can be any Method, but should be related to TPath
+  TPath, ExtractRouteByPath<TFragmentConfig["routes"], TPath>["inputSchema"], ExtractRouteByPath<TFragmentConfig["routes"], TPath>["outputSchema"], NonNullable<ExtractRouteByPath<TFragmentConfig["routes"], TPath>["errorCodes"]>[number], NonNullable<ExtractRouteByPath<TFragmentConfig["routes"], TPath>["queryParameters"]>[number]>;
+}
+declare function createClientBuilder<TConfig$1, TDeps$1, TServices$1 extends Record<string, unknown>, const TRoutesOrFactories extends readonly AnyRouteOrFactory[], const TAdditionalContext extends Record<string, unknown>>(fragmentBuilder: {
+  definition: FragmentDefinition<TConfig$1, TDeps$1, TServices$1, TAdditionalContext>;
+}, publicConfig: FragnoPublicClientConfig, routesOrFactories: TRoutesOrFactories, authorFetcherConfig?: FetcherConfig): ClientBuilder<FlattenRouteFactories<TRoutesOrFactories>, FragnoFragmentSharedConfig<FlattenRouteFactories<TRoutesOrFactories>>>;
+//#endregion
+//#region src/api/request-middleware.d.ts
+type FragnoMiddlewareCallback<TRoutes$1 extends readonly AnyFragnoRouteConfig[], TDeps$1, TServices$1 extends Record<string, unknown>> = (inputContext: RequestMiddlewareInputContext<TRoutes$1>, outputContext: RequestMiddlewareOutputContext<TDeps$1, TServices$1>) => Promise<Response | undefined> | Response | undefined;
+interface RequestMiddlewareOptions {
+  path: string;
+  method: HTTPMethod;
+  request: Request;
+  state: MutableRequestState;
+}
+declare class RequestMiddlewareOutputContext<const TDeps$1, const TServices$1 extends Record<string, unknown>> extends OutputContext<unknown, string> {
+  #private;
+  constructor(deps: TDeps$1, services: TServices$1);
+  get deps(): TDeps$1;
+  get services(): TServices$1;
+}
+declare class RequestMiddlewareInputContext<const TRoutes$1 extends readonly AnyFragnoRouteConfig[]> {
+  #private;
+  constructor(routes: TRoutes$1, options: RequestMiddlewareOptions);
+  get path(): string;
+  get method(): HTTPMethod;
+  get pathParams(): Record<string, string>;
+  get queryParams(): URLSearchParams;
+  get headers(): Headers;
+  get inputSchema(): StandardSchemaV1 | undefined;
+  get outputSchema(): StandardSchemaV1 | undefined;
+  /**
+   * Access to the mutable request state.
+   * Use this to modify query parameters, path parameters, or request body.
+   *
+   * @example
+   * ```typescript
+   * // Modify body
+   * requestState.setBody({ modified: true });
+   *
+   * // Query params are already accessible via queryParams getter
+   * // Path params are already accessible via pathParams getter
+   * ```
+   */
+  get requestState(): MutableRequestState;
+  ifMatchesRoute: <const TMethod extends HTTPMethod, const TPath extends ExtractRoutePath<TRoutes$1>, const TRoute extends ExtractRouteByPath<TRoutes$1, TPath, TMethod> = ExtractRouteByPath<TRoutes$1, TPath, TMethod>>(method: TMethod, path: TPath, handler: (...args: Parameters<TRoute["handler"]>) => Promise<Response | undefined | void> | Response | undefined | void) => Promise<Response | undefined>;
+}
+//#endregion
+//#region src/api/fragno-response.d.ts
+/**
+ * Discriminated union representing all possible Fragno response types
+ */
+type FragnoResponse<T> = {
+  type: "empty";
+  status: number;
+  headers: Headers;
+} | {
+  type: "error";
+  status: number;
+  headers: Headers;
+  error: {
+    message: string;
+    code: string;
+  };
+} | {
+  type: "json";
+  status: number;
+  headers: Headers;
+  data: T;
+} | {
+  type: "jsonStream";
+  status: number;
+  headers: Headers;
+  stream: AsyncGenerator<T extends unknown[] ? T[number] : T>;
+};
+//#endregion
+//#region src/api/fragment-instantiation.d.ts
+interface FragnoPublicConfig {
+  mountRoute?: string;
+}
+type FetcherConfig = {
+  type: "options";
+  options: RequestInit;
+} | {
+  type: "function";
+  fetcher: typeof fetch;
+};
+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;
+};
+declare const instantiatedFragmentFakeSymbol: "$fragno-instantiated-fragment";
+type FullstackFrameworks = keyof HandlersByFramework;
+interface FragnoInstantiatedFragment<TRoutes$1 extends readonly AnyFragnoRouteConfig[] = [], TDeps$1 = {}, TServices$1 extends Record<string, unknown> = Record<string, unknown>, TAdditionalContext extends Record<string, unknown> = {}> {
+  [instantiatedFragmentFakeSymbol]: typeof instantiatedFragmentFakeSymbol;
+  config: FragnoFragmentSharedConfig<TRoutes$1>;
+  deps: TDeps$1;
+  services: TServices$1;
+  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$1, TMethod>>(method: TMethod, path: TPath, inputOptions?: RouteHandlerInputOptions<TPath, ExtractRouteByPath<TRoutes$1, TPath, TMethod>["inputSchema"]>) => Promise<FragnoResponse<InferOrUnknown<NonNullable<ExtractRouteByPath<TRoutes$1, TPath, TMethod>["outputSchema"]>>>>;
+  callRouteRaw: <TMethod extends HTTPMethod, TPath extends ExtractRoutePath<TRoutes$1, TMethod>>(method: TMethod, path: TPath, inputOptions?: RouteHandlerInputOptions<TPath, ExtractRouteByPath<TRoutes$1, TPath, TMethod>["inputSchema"]>) => Promise<Response>;
+  withMiddleware: (handler: FragnoMiddlewareCallback<TRoutes$1, TDeps$1, TServices$1>) => FragnoInstantiatedFragment<TRoutes$1, TDeps$1, TServices$1, TAdditionalContext>;
+}
+interface FragnoFragmentSharedConfig<TRoutes$1 extends readonly FragnoRouteConfig<HTTPMethod, string, StandardSchemaV1 | undefined, StandardSchemaV1 | undefined, string, string>[]> {
+  name: string;
+  routes: TRoutes$1;
+}
+type AnyFragnoFragmentSharedConfig = FragnoFragmentSharedConfig<readonly AnyFragnoRouteConfig[]>;
+declare function createFragment<const TConfig$1, const TDeps$1, const TServices$1 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$1 extends RequestThisContext = RequestThisContext>(fragmentBuilder: {
+  definition: FragmentDefinition<TConfig$1, TDeps$1, TServices$1, TAdditionalContext, TRequiredInterfaces, TProvidedInterfaces, TThisContext$1>;
+  $requiredOptions: TOptions;
+}, config: TConfig$1, routesOrFactories: TRoutesOrFactories, options: TOptions, interfaceImplementations?: TRequiredInterfaces): FragnoInstantiatedFragment<FlattenRouteFactories<TRoutesOrFactories>, TDeps$1 & TRequiredInterfaces, TServices$1 & TProvidedInterfaces & TRequiredInterfaces, TAdditionalContext>;
+/**
+ * Builder class for fluent fragment instantiation API
+ */
+declare class FragmentInstantiationBuilder<TConfig$1, TDeps$1, TServices$1 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$1 extends RequestThisContext> {
+  #private;
+  constructor(fragmentBuilder: {
+    definition: FragmentDefinition<TConfig$1, TDeps$1, TServices$1, TAdditionalContext, TRequiredInterfaces, TProvidedInterfaces, TThisContext$1>;
+    $requiredOptions: TOptions;
+  });
+  /**
+   * Set the configuration for the fragment
+   */
+  withConfig(config: TConfig$1): this;
+  /**
+   * Set the routes for the fragment
+   */
+  withRoutes<const TNewRoutes extends readonly AnyRouteOrFactory[]>(routes: TNewRoutes): FragmentInstantiationBuilder<TConfig$1, TDeps$1, TServices$1, TNewRoutes, TAdditionalContext, TRequiredInterfaces, TProvidedInterfaces, TOptions, TThisContext$1>;
+  /**
+   * Set the options for the fragment (e.g., mountRoute, databaseAdapter)
+   */
+  withOptions(options: TOptions): this;
+  /**
+   * Provide implementations for services that this fragment uses
+   */
+  withServices(services: TRequiredInterfaces): this;
+  /**
+   * Build and return the instantiated fragment
+   */
+  build(): FragnoInstantiatedFragment<FlattenRouteFactories<TRoutesOrFactories>, TDeps$1 & TRequiredInterfaces, TServices$1 & TProvidedInterfaces & TRequiredInterfaces, TAdditionalContext>;
+}
+/**
+ * Create a fluent builder for instantiating a fragment
+ *
+ * @example
+ * ```ts
+ * const fragment = instantiateFragment(myFragmentBuilder)
+ *   .withConfig({ apiKey: "key" })
+ *   .withRoutes([route1, route2])
+ *   .withOptions({ mountRoute: "/api" })
+ *   .build();
+ * ```
+ */
+declare function instantiateFragment<TConfig$1, TDeps$1, TServices$1 extends Record<string, unknown>, TAdditionalContext extends Record<string, unknown>, TRequiredInterfaces extends Record<string, unknown>, TProvidedInterfaces extends Record<string, unknown>, TOptions extends FragnoPublicConfig, TThisContext$1 extends RequestThisContext = RequestThisContext>(fragmentBuilder: {
+  definition: FragmentDefinition<TConfig$1, TDeps$1, TServices$1, TAdditionalContext, TRequiredInterfaces, TProvidedInterfaces, TThisContext$1>;
+  $requiredOptions: TOptions;
+}): FragmentInstantiationBuilder<TConfig$1, TDeps$1, TServices$1, readonly [], TAdditionalContext, TRequiredInterfaces, TProvidedInterfaces, TOptions, TThisContext$1>;
+//#endregion
+//#region src/api/api.d.ts
+type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+type NonGetHTTPMethod = Exclude<HTTPMethod, "GET">;
+type PathError<T extends string, TMessage extends string> = T & [`Error: ${TMessage}`];
+/**
+ * A valid path string that:
+ * - Is non-empty
+ * - Starts with "/"
+ * - Is not just "/"
+ * - Does not end with "/"
+ */
+type ValidPath<T extends string = string> = T extends `/${infer Rest}` ? Rest extends "" ? PathError<T, "Path cannot be just '/'."> : T extends `${string}/` ? PathError<T, "Path cannot end with '/'."> : T : PathError<T, "Path must start with '/'.">;
+/**
+ * Base ServiceContext interface. Can be augmented by packages like @fragno-dev/db.
+ */
+interface RequestThisContext {}
+interface FragnoRouteConfig<TMethod extends HTTPMethod, TPath extends string, TInputSchema extends StandardSchemaV1 | undefined, TOutputSchema extends StandardSchemaV1 | undefined, TErrorCode extends string = string, TQueryParameters extends string = string, TThisContext$1 extends RequestThisContext = RequestThisContext> {
+  method: TMethod;
+  path: TPath;
+  inputSchema?: TInputSchema;
+  outputSchema?: TOutputSchema;
+  errorCodes?: readonly TErrorCode[];
+  queryParameters?: readonly TQueryParameters[];
+  handler(this: TThisContext$1, inputCtx: RequestInputContext<TPath, TInputSchema>, outputCtx: RequestOutputContext<TOutputSchema, TErrorCode>): Promise<Response>;
+}
+declare function addRoute<TMethod extends HTTPMethod, TPath extends string, TOutputSchema extends StandardSchemaV1 | undefined, TErrorCode extends string = string, TQueryParameters extends string = string, TThisContext$1 extends RequestThisContext = RequestThisContext>(route: FragnoRouteConfig<TMethod, ValidPath<TPath>, undefined, TOutputSchema, TErrorCode, TQueryParameters, TThisContext$1> & {
+  inputSchema?: undefined;
+}): FragnoRouteConfig<TMethod, TPath, undefined, TOutputSchema, TErrorCode, TQueryParameters, TThisContext$1>;
+declare function addRoute<TMethod extends HTTPMethod, TPath extends string, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1 | undefined, TErrorCode extends string = string, TQueryParameters extends string = string, TThisContext$1 extends RequestThisContext = RequestThisContext>(route: FragnoRouteConfig<TMethod, ValidPath<TPath>, TInputSchema, TOutputSchema, TErrorCode, TQueryParameters, TThisContext$1> & {
+  inputSchema: TInputSchema;
+}): FragnoRouteConfig<TMethod, TPath, TInputSchema, TOutputSchema, TErrorCode, TQueryParameters, TThisContext$1>;
+//#endregion
+export { ExtractThisContext as $, HasGetRoutes as A, FragnoClientApiError as B, ExtractNonGetRoutePaths as C, FragnoClientHookData as D, ExtractRoutePath as E, createClientBuilder as F, FragnoClientUnknownApiError as G, FragnoClientFetchAbortError as H, getCacheKey as I, AnyFragnoRouteConfig as J, FragnoErrorOptions as K, isGetHook as L, ObjectContainingStoreField as M, ValidateGetRoutePath as N, FragnoClientMutatorData as O, buildUrl as P, ExtractFragmentServices as Q, isMutatorHook as R, ExtractGetRoutes as S, ExtractRouteByPath as T, FragnoClientFetchError as U, FragnoClientError as V, FragnoClientFetchNetworkError as W, ExtractFragmentConfig as X, AnyRouteOrFactory as Y, ExtractFragmentDeps as Z, FragnoResponse as _, ExtractPathParamsOrWiden as _t, ValidPath as a, resolveRouteFactories as at, CreateHookOptions as b, QueryParamsHint as bt, FetcherConfig as c, RouteHandler as ct, FragnoInstantiatedFragment as d, FragnoApiError as dt, FlattenRouteFactories as et, FragnoPublicClientConfig as f, FragnoApiValidationError as ft, instantiatedFragmentFakeSymbol as g, RequestInputContext as gt, instantiateFragment as h, InferOrUnknown as ht, RequestThisContext as i, defineRoutes as it, IsValidGetRoutePath as j, FragnoStoreData as k, FragmentInstantiationBuilder as l, defineFragment as lt, createFragment as m, InferOr as mt, HTTPMethod as n, RouteFactoryContext as nt, addRoute as o, FragmentBuilder as ot, FragnoPublicConfig as p, RequestOutputContext as pt, AnyFragmentBuilder as q, NonGetHTTPMethod as r, defineRoute as rt, AnyFragnoFragmentSharedConfig as s, FragmentDefinition as st, FragnoRouteConfig as t, RouteFactory as tt, FragnoFragmentSharedConfig as u, RouteHandlerInputOptions as ut, CacheLine as v, HasPathParams as vt, ExtractOutputSchemaForPath as w, ExtractGetRoutePaths as x, ClientBuilder as y, MaybeExtractPathParamsOrWiden as yt, isStore as z };
+//# sourceMappingURL=api-BFrUCIsF.d.ts.map