@fncts/http 0.0.0

package/Body/api.d.ts

@@ -0,0 +1,63 @@
+import { IO } from "@fncts/io/IO";
+import { Schema } from "@fncts/schema/Schema/definition";
+import type { BodyError } from "../BodyError.js";
+import type * as Stream_ from "@fncts/io/Stream";
+import { Body } from "./definition.js";
+import { Empty, FormData, Raw, Stream, Uint8Array } from "./definition.js";
+/**
+ * @tsplus static fncts.http.BodyOps empty
+ * @tsplus location "@fncts/http/Body/api"
+ */
+export declare const empty: Empty;
+/**
+ * @tsplus static fncts.http.BodyOps raw
+ * @tsplus location "@fncts/http/Body/api"
+ */
+export declare function raw(body: unknown, options?: {
+    contentType?: string;
+    contentLength?: number;
+}): Body;
+/**
+ * @tsplus static fncts.http.BodyOps uint8Array
+ * @tsplus location "@fncts/http/Body/api"
+ */
+export declare function uint8Array(body: globalThis.Uint8Array, contentType?: string): Body;
+/**
+ * @tsplus static fncts.http.BodyOps text
+ * @tsplus location "@fncts/http/Body/api"
+ */
+export declare function text(body: string, contentType?: string): Body;
+/**
+ * @tsplus static fncts.http.BodyOps json
+ * @tsplus location "@fncts/http/Body/api"
+ */
+export declare function json(body: unknown): IO<never, BodyError, Body>;
+/**
+ * @tsplus static fncts.http.BodyOps jsonSchema
+ * @tsplus location "@fncts/http/Body/api"
+ */
+export declare function jsonSchema<A>(schema: Schema<A>): (body: A) => IO<never, BodyError, Body>;
+/**
+ * @tsplus static fncts.http.BodyOps formData
+ * @tsplus location "@fncts/http/Body/api"
+ */
+export declare function formData(body: globalThis.FormData): Body;
+/**
+ * @tsplus static fncts.http.BodyOps stream
+ * @tsplus location "@fncts/http/Body/api"
+ */
+export declare function stream(body: Stream_.Stream<never, unknown, globalThis.Uint8Array>, options?: {
+    contentType?: string;
+    contentLength?: number;
+}): Body;
+/**
+ * @tsplus pipeable fncts.http.Body match
+ * @tsplus location "@fncts/http/Body/api"
+ */
+export declare function match<A, B, C, D, E>(cases: {
+    Empty: (body: Empty) => A;
+    Raw: (body: Raw) => B;
+    Uint8Array: (body: Uint8Array) => C;
+    FormData: (body: FormData) => D;
+    Stream: (body: Stream) => E;
+}): (body: Body) => A | B | C | D | E;

package/Body/definition.d.ts

@@ -0,0 +1,53 @@
+import type * as Stream_ from "@fncts/io/Stream";
+export declare const BodyTypeId: unique symbol;
+export type BodyTypeId = typeof BodyTypeId;
+export declare const enum BodyTag {
+    Empty = 0,
+    Raw = 1,
+    Uint8Array = 2,
+    FormData = 3,
+    Stream = 4
+}
+/**
+ * @tsplus type fncts.http.Body
+ * @tsplus companion fncts.http.BodyOps
+ */
+export declare abstract class Body {
+    readonly [BodyTypeId]: BodyTypeId;
+    readonly contentType?: string;
+    readonly contentLength?: number;
+}
+export declare class Empty extends Body {
+    readonly _tag = BodyTag.Empty;
+}
+export declare class Raw extends Body {
+    readonly body: unknown;
+    readonly contentType?: string | undefined;
+    readonly contentLength?: number | undefined;
+    readonly _tag = BodyTag.Raw;
+    constructor(body: unknown, contentType?: string | undefined, contentLength?: number | undefined);
+}
+export declare class Uint8Array extends Body {
+    readonly body: globalThis.Uint8Array;
+    readonly contentType: string;
+    readonly _tag = BodyTag.Uint8Array;
+    constructor(body: globalThis.Uint8Array, contentType: string);
+}
+export declare class FormData extends Body {
+    readonly formData: globalThis.FormData;
+    readonly _tag = BodyTag.FormData;
+    constructor(formData: globalThis.FormData);
+}
+export declare class Stream extends Body {
+    readonly stream: Stream_.Stream<never, unknown, globalThis.Uint8Array>;
+    readonly contentType: string;
+    readonly contentLength?: number | undefined;
+    readonly _tag = BodyTag.Stream;
+    constructor(stream: Stream_.Stream<never, unknown, globalThis.Uint8Array>, contentType: string, contentLength?: number | undefined);
+}
+export type ConcreteBody = Empty | Raw | Uint8Array | FormData | Stream;
+/**
+ * @tsplus fluent fncts.http.Body concrete
+ * @tsplus location "@fncts/http/Body/definition"
+ */
+export declare function concrete(self: Body): asserts self is ConcreteBody;

package/Body.d.ts

@@ -0,0 +1,2 @@
+export * from "./Body/definition.js";
+export * from "./Body/api.js";

package/BodyError.d.ts

@@ -0,0 +1,30 @@
+import { ParseFailure } from "@fncts/schema/ParseFailure";
+export declare const BodyErrorTypeId: unique symbol;
+export type BodyErrorTypeId = typeof BodyErrorTypeId;
+export declare const enum BodyErrorTag {
+    JsonError = 0,
+    SchemaError = 1
+}
+/**
+ * @tsplus type fncts.http.BodyError
+ * @tsplus concrete fncts.http.BodyErrorOps
+ */
+export declare abstract class BodyError {
+    readonly [BodyErrorTypeId]: BodyErrorTypeId;
+}
+export declare class JsonError extends BodyError {
+    readonly error: unknown;
+    readonly _tag = BodyErrorTag.JsonError;
+    constructor(error: unknown);
+}
+export declare class SchemaError extends BodyError {
+    readonly error: ParseFailure;
+    readonly _tag = BodyErrorTag.SchemaError;
+    constructor(error: ParseFailure);
+}
+export type Concrete = JsonError | SchemaError;
+/**
+ * @tsplus fluent fncts.http.BodyError concrete
+ * @tsplus location "@fncts/http/BodyError"
+ */
+export declare function concrete(self: BodyError): asserts self is Concrete;

package/Headers.d.ts

@@ -0,0 +1,42 @@
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+export declare const HeadersTypeId: unique symbol;
+export type HeadersTypeId = typeof HeadersTypeId;
+/**
+ * @tsplus type fncts.http.Headers
+ * @tsplus companion fncts.http.HeadersOps
+ */
+export declare class Headers {
+    readonly backing: HashMap<string, string>;
+    readonly [HeadersTypeId]: HeadersTypeId;
+    constructor(backing: HashMap<string, string>);
+    set(key: string, value: string): Headers;
+    remove(key: string): Headers;
+    get(key: string): Maybe<string>;
+    unsafeGet(key: string): string | undefined;
+    setAll(input: Headers.Input): Headers;
+    toHeadersInit(): Array<[string, string]>;
+}
+export declare namespace Headers {
+    type Input = Readonly<Record<string, string>> | Iterable<readonly [string, string]>;
+}
+/**
+ * @tsplus static fncts.http.HeadersOps isHeaders
+ * @tsplus location "@fncts/http/Headers"
+ */
+export declare function isHeaders(u: unknown): u is Headers;
+/**
+ * @tsplus static fncts.http.HeadersOps empty
+ * @tsplus location "@fncts/http/Headers"
+ */
+export declare const empty: Headers;
+/**
+ * @tsplus static fncts.http.HeadersOps fromHeaders
+ * @tsplus location "@fncts/http/Headers"
+ */
+export declare function fromHeaders(headers: globalThis.Headers): Headers;
+/**
+ * @tsplus static fncts.http.HeadersOps __call
+ * @tsplus location "@fncts/http/Headers"
+ */
+export declare function make(input: Headers.Input): Headers;

package/HttpApp.d.ts

@@ -0,0 +1,46 @@
+import { IO, FIO, UIO } from "@fncts/io/IO";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { Middleware } from "./Middleware.js";
+import type { ServerResponse } from "./ServerResponse.js";
+import type { ResponseError } from "@fncts/http/ResponseError";
+import { type Runtime } from "@fncts/io/IO";
+import { ServerRequest } from "./ServerRequest.js";
+/**
+ * @tsplus type fncts.http.HttpApp
+ */
+export interface HttpApp<R, E, A> extends IO<R | ServerRequest, E, A> {
+}
+/**
+ * @tsplus type fncts.http.HttpAppOps
+ */
+export interface HttpAppOps {
+}
+export declare const HttpApp: HttpAppOps;
+export declare namespace HttpApp {
+    type Default<R, E> = HttpApp<R, E, ServerResponse>;
+}
+/**
+ * @tsplus pipeable fncts.http.HttpApp toHandled
+ * @tsplus location "@fncts/http/HttpApp"
+ */
+export declare function toHandled<E, RH>(handleResponse: (request: ServerRequest, exit: Exit<E | ResponseError, ServerResponse>) => IO<RH, never, any>, middleware?: Middleware): <R>(self: HttpApp.Default<R, E>) => HttpApp.Default<Exclude<RH, import("@fncts/io/Scope.js").Scope> | Exclude<R, import("@fncts/io/Scope.js").Scope>, ResponseError | E>;
+export type PreResponseHandler = (request: ServerRequest, response: ServerResponse) => FIO<ResponseError, ServerResponse>;
+/**
+ * @tsplus static fncts.http.HttpAppOps currentPreResponseHandlers
+ * @tsplus location "@fncts/http/HttpApp"
+ */
+export declare const currentPreResponseHandlers: import("@fncts/io/FiberRef.js").FiberRef.WithPatch<import("@fncts/base/data/Maybe.js").Maybe<PreResponseHandler>, (_: import("@fncts/base/data/Maybe.js").Maybe<PreResponseHandler>) => import("@fncts/base/data/Maybe.js").Maybe<PreResponseHandler>>;
+/**
+ * @tsplus static fncts.http.HttpAppOps appendPreResponseHandler
+ * @tsplus location "@fncts/http/HttpApp"
+ */
+export declare function appendPreResponseHandler(handler: PreResponseHandler): UIO<void>;
+/**
+ * @tsplus pipeable fncts.http.HttpApp withPreResponseHandler
+ * @tsplus location "@fncts/http/HttpApp"
+ */
+export declare function withPreResponseHandler(handler: PreResponseHandler): <R, E, A>(self: HttpApp<R, E, A>) => HttpApp<R, E, A>;
+export declare function toWebHandlerRuntime<R>(runtime: Runtime<R>): <E>(self: HttpApp.Default<import("@fncts/io/Scope.js").Scope | R, E>) => (request: Request) => Promise<Response>;
+export declare function toWebHandler<E>(self: HttpApp.Default<Scope, E>): (request: Request) => Promise<Response>;

package/IncomingMessage/api.d.ts

@@ -0,0 +1,19 @@
+import { Schema } from "@fncts/schema/Schema/definition";
+import { IO } from "@fncts/io/IO";
+import { ParseFailure } from "@fncts/schema/ParseFailure";
+import type { IncomingMessage } from "./definition.js";
+/**
+ * @tsplus pipeable fncts.http.IncomingMessage schemaBodyJson
+ * @tsplus location "@fncts/http/IncomingMessage/api"
+ */
+export declare function schemaBodyJson<A>(schema: Schema<A>): <E>(self: IncomingMessage<E>) => IO<never, E | ParseFailure, A>;
+/**
+ * @tsplus pipeable fncts.http.IncomingMessage schemaBodyUrlParams
+ * @tsplus location "@fncts/http/IncomingMessage/api"
+ */
+export declare function schemaBodyUrlParams<A>(schema: Schema<A>): <E>(self: IncomingMessage<E>) => IO<never, E | ParseFailure, A>;
+/**
+ * @tsplus pipeable fncts.http.IncomingMessage schemaHeaders
+ * @tsplus location "@fncts/http/IncomingMessage/api"
+ */
+export declare function schemaHeaders<A>(schema: Schema<A>): <E>(self: IncomingMessage<E>) => IO<never, E | ParseFailure, A>;

package/IncomingMessage/definition.d.ts

@@ -0,0 +1,21 @@
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { IO } from "@fncts/io/IO";
+import { Stream } from "@fncts/io/Stream";
+import type { Headers } from "../Headers.js";
+import type { UrlParams } from "../UrlParams.js";
+export declare const IncomingMessageTypeId: unique symbol;
+export type IncomingMessageTypeId = typeof IncomingMessageTypeId;
+/**
+ * @tsplus type fncts.http.IncomingMessage
+ * @tsplus companion fncts.http.IncomingMessageOps
+ */
+export declare abstract class IncomingMessage<E> {
+    readonly [IncomingMessageTypeId]: IncomingMessageTypeId;
+    abstract readonly headers: Headers;
+    abstract readonly remoteAddress: Maybe<string>;
+    abstract readonly json: IO<never, E, unknown>;
+    abstract readonly text: IO<never, E, string>;
+    abstract readonly urlParamsBody: IO<never, E, UrlParams>;
+    abstract readonly arrayBuffer: IO<never, E, ArrayBuffer>;
+    abstract readonly stream: Stream<never, E, Uint8Array>;
+}

package/IncomingMessage.d.ts

@@ -0,0 +1,2 @@
+export * from "./IncomingMessage/definition.js";
+export * from "./IncomingMessage/api.js";

package/Method.d.ts

@@ -0,0 +1,2 @@
+export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+export declare function hasBody(method: Method): boolean;

package/Middleware.d.ts

@@ -0,0 +1,24 @@
+import type { HttpApp } from "@fncts/http/HttpApp";
+/**
+ * @tsplus type fncts.http.Middleware
+ */
+export interface Middleware {
+    <R, E>(self: HttpApp.Default<R, E>): HttpApp.Default<any, any>;
+}
+/**
+ * @tsplus type fncts.http.MiddlewareOps
+ */
+export interface MiddlewareOps {
+}
+export declare const Middleware: MiddlewareOps;
+export declare namespace Middleware {
+    interface Applied<R, E, A extends HttpApp.Default<any, any>> {
+        (self: HttpApp.Default<R, E>): A;
+    }
+}
+/**
+ * @tsplus static fncts.http.MiddlewareOps __call
+ * @tsplus static fncts.http.MiddlewareOps make
+ * @tsplus location "@fncts/http/Middleware"
+ */
+export declare function make<M extends Middleware>(middleware: M): M;

package/QueryParams.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @tsplus type fncts.http.QueryParams
+ * @tsplus companion fncts.http.QueryParams
+ */
+export interface QueryParams {
+    [param: string]: string;
+}

package/RequestError.d.ts

@@ -0,0 +1,10 @@
+import type { ServerRequest } from "./ServerRequest";
+export declare const RequestErrorTypeId: unique symbol;
+export type RequestErrorTypeId = typeof RequestErrorTypeId;
+export declare class RequestError {
+    readonly request: ServerRequest;
+    readonly reason: "Transport" | "Decode";
+    readonly error: unknown;
+    readonly [RequestErrorTypeId]: RequestErrorTypeId;
+    constructor(request: ServerRequest, reason: "Transport" | "Decode", error: unknown);
+}

package/ResponseError.d.ts

@@ -0,0 +1,14 @@
+import { ServerRequest } from "@fncts/http/ServerRequest";
+import { ServerResponse } from "@fncts/http/ServerResponse";
+export declare const ResponseErrorTypeId: unique symbol;
+export type ResponseErrorTypeId = typeof ResponseErrorTypeId;
+export declare class ResponseError extends Error {
+    readonly request: ServerRequest;
+    readonly response: ServerResponse;
+    readonly reason: "Decode";
+    readonly error: unknown;
+    readonly [ResponseErrorTypeId]: ResponseErrorTypeId;
+    constructor(request: ServerRequest, response: ServerResponse, reason: "Decode", error: unknown);
+    get methodAndUrl(): string;
+    get message(): string;
+}

package/Route/api.d.ts

@@ -0,0 +1,37 @@
+import { Schema } from "@fncts/schema/Schema/definition";
+import { IO } from "@fncts/io/IO";
+import { ParseFailure } from "@fncts/schema/ParseFailure";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { Method } from "../Method.js";
+import type { PathInput, Route } from "./definition.js";
+import { RouteContext } from "./definition.js";
+/**
+ * @tsplus static fncts.http.RouteContextOps params
+ * @tsplus location "@fncts/http/Route/api"
+ */
+export declare const params: import("@fncts/io/IO.js").IO<RouteContext, never, Readonly<Record<string, string | undefined>>>;
+/**
+ * @tsplus static fncts.http.RouteContextOps searchParams
+ * @tsplus location "@fncts/http/Route/api"
+ */
+export declare const searchParams: import("@fncts/io/IO.js").IO<RouteContext, never, Readonly<Record<string, string>>>;
+/**
+ * @tsplus static fncts.http.RouteContextOps schemaParams
+ * @tsplus location "@fncts/http/Route/api"
+ */
+export declare function schemaParams<A>(schema: Schema<A>): IO<RouteContext, ParseFailure, A>;
+/**
+ * @tsplus static fncts.http.RouteContextOps schemaPathParams
+ * @tsplus location "@fncts/http/Route/api"
+ */
+export declare function schemaPathParams<A>(schema: Schema<A>): IO<RouteContext, ParseFailure, A>;
+/**
+ * @tsplus static fncts.http.RouteContextOps schemaSearchParams
+ * @tsplus location "@fncts/http/Route/api"
+ */
+export declare function schemaSearchParams<A>(schema: Schema<A>): IO<RouteContext, ParseFailure, A>;
+/**
+ * @tsplus static fncts.http.RouteOps __call
+ * @tsplus location "@fncts/http/Route/api"
+ */
+export declare function make<R, E>(method: Method, path: PathInput, handler: Route.Handler<R, E>, prefix?: Maybe<string>): Route<R, E>;

package/Route/definition.d.ts

@@ -0,0 +1,35 @@
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { IO } from "@fncts/io/IO";
+import type { Method } from "../Method.js";
+import type { ServerRequest } from "../ServerRequest";
+import type { ServerResponse } from "../ServerResponse.js";
+export declare const RouteTypeId: unique symbol;
+export type RouteTypeId = typeof RouteTypeId;
+export type PathInput = `/${string}` | "*";
+export declare abstract class Route<R, E> {
+    readonly [RouteTypeId]: RouteTypeId;
+    abstract readonly method: Method | "*";
+    abstract readonly path: PathInput;
+    abstract readonly handler: Route.Handler<R, E>;
+    abstract readonly prefix: Maybe<string>;
+}
+export declare namespace Route {
+    type Handler<R, E> = IO<R | ServerRequest | RouteContext, E, ServerResponse>;
+}
+export declare const RouteContextTypeId: unique symbol;
+export type RouteContextTypeId = typeof RouteContextTypeId;
+/**
+ * @tsplus type fncts.http.RouteContext
+ * @tsplus companion fncts.http.RouteContextOps
+ */
+export declare abstract class RouteContext {
+    readonly [RouteContextTypeId]: RouteContextTypeId;
+    abstract readonly route: Route<unknown, unknown>;
+    abstract readonly params: Readonly<Record<string, string | undefined>>;
+    abstract readonly searchParams: Readonly<Record<string, string>>;
+}
+/**
+ * @tsplus static fncts.http.RouteContextOps Tag
+ * @tsplus location "@fncts/http/Route/definition"
+ */
+export declare const RouteContextTag: import("@fncts/base/data/Tag.js").Tag<RouteContext, RouteContext>;

package/Route/internal.d.ts

@@ -0,0 +1,17 @@
+import { Maybe, Nothing } from "@fncts/base/data/Maybe/definition";
+import type { Method } from "../Method.js";
+import type { PathInput } from "./definition";
+import { Route, RouteContext } from "./definition.js";
+export declare class RouteImpl<R, E> extends Route<R, E> {
+    readonly method: Method | "*";
+    readonly path: PathInput;
+    readonly handler: Route.Handler<R, E>;
+    readonly prefix: Maybe<string>;
+    constructor(method: Method | "*", path: PathInput, handler: Route.Handler<R, E>, prefix?: Maybe<string>);
+}
+export declare class RouteContextImpl extends RouteContext {
+    readonly route: Route<unknown, unknown>;
+    readonly params: Readonly<Record<string, string | undefined>>;
+    readonly searchParams: Readonly<Record<string, string>>;
+    constructor(route: Route<unknown, unknown>, params: Readonly<Record<string, string | undefined>>, searchParams: Readonly<Record<string, string>>);
+}

package/Route.d.ts

@@ -0,0 +1,2 @@
+export * from "./Route/definition.js";
+export * from "./Route/api.js";

package/RouteNotFound.d.ts

@@ -0,0 +1,8 @@
+import type { ServerRequest } from "./ServerRequest.js";
+export declare const RouteNotFoundTypeId: unique symbol;
+export type RouteNotFoundTypeId = typeof RouteNotFoundTypeId;
+export declare class RouteNotFound extends Error {
+    readonly request: ServerRequest;
+    constructor(request: ServerRequest);
+    get message(): string;
+}

package/Router/api.d.ts

@@ -0,0 +1,96 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Tag } from "@fncts/base/data/Tag/definition";
+import type { HttpApp } from "../HttpApp.js";
+import type { Method } from "../Method.js";
+import type { PathInput, Route } from "../Route.js";
+import type { Router } from "./definition.js";
+/**
+ * @tsplus static fncts.http.RouterOps empty
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare const empty: Router<never, never>;
+export declare function route(method: Method | "*"): <R1, E1>(path: PathInput, handler: Route.Handler<R1, E1>) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1>;
+/**
+ * @tsplus pipeable fncts.http.Router get
+ * @tsplus static fncts.http.RouterOps get
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare const get: <R1, E1>(path: PathInput, handler: Route.Handler<R1, E1>) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1>;
+/**
+ * @tsplus pipeable fncts.http.Router post
+ * @tsplus static fncts.http.RouterOps post
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare const post: <R1, E1>(path: PathInput, handler: Route.Handler<R1, E1>) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1>;
+/**
+ * @tsplus pipeable fncts.http.Router put
+ * @tsplus static fncts.http.RouterOps put
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare const put: <R1, E1>(path: PathInput, handler: Route.Handler<R1, E1>) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1>;
+/**
+ * @tsplus pipeable fncts.http.Router patch
+ * @tsplus static fncts.http.RouterOps patch
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare const patch: <R1, E1>(path: PathInput, handler: Route.Handler<R1, E1>) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1>;
+/**
+ * @tsplus pipeable fncts.http.Router del
+ * @tsplus static fncts.http.RouterOps del
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare const del: <R1, E1>(path: PathInput, handler: Route.Handler<R1, E1>) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1>;
+/**
+ * @tsplus pipeable fncts.http.Router head
+ * @tsplus static fncts.http.RouterOps head
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare const head: <R1, E1>(path: PathInput, handler: Route.Handler<R1, E1>) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1>;
+/**
+ * @tsplus pipeable fncts.http.Router options
+ * @tsplus static fncts.http.RouterOps options
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare const options: <R1, E1>(path: PathInput, handler: Route.Handler<R1, E1>) => <R, E>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E | E1>;
+/**
+ * @tsplus pipeable fncts.http.Router use
+ * @tsplus static fncts.http.RouterOps use
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare function use<R, E, R1, E1>(f: (self: Route.Handler<R, E>) => HttpApp.Default<R1, E1>, __tsplusTrace?: string): (self: Router<R, E>) => Router<Router.ExcludeProvided<R1>, E1>;
+/**
+ * @tsplus static fncts.http.RouterOps from
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare function from<R extends Route<any, any>>(routes: Iterable<R>): Router<R extends Route<infer Env, infer _> ? Env : never, R extends Route<infer _, infer E> ? E : never>;
+/**
+ * @tsplus pipeable fncts.http.Router concat
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare function concat<R1, E1>(that: Router<R1, E1>): <R, E>(self: Router<R, E>) => Router<R | R1, E | E1>;
+/**
+ * @tsplus pipeable fncts.http.Router prefixAll
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare function prefixAll(prefix: PathInput): <R, E>(self: Router<R, E>) => Router<R, E>;
+/**
+ * @tsplus pipeable fncts.http.Router mount
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare function mount<R1, E1>(path: `/${string}`, that: Router<R1, E1>): <R, E>(self: Router<R, E>) => Router<R | R1, E | E1>;
+/**
+ * @tsplus pipeable fncts.http.Router catchAll
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare function catchAll<E, R1, E1>(f: (e: E) => Route.Handler<R1, E1>, __tsplusTrace?: string): <R>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E1>;
+/**
+ * @tsplus pipeable fncts.http.Router catchAllCause
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare function catchAllCause<E, R1, E1>(f: (e: Cause<E>) => Route.Handler<R1, E1>, __tsplusTrace?: string): <R>(self: Router<R, E>) => Router<R | Router.ExcludeProvided<R1>, E1>;
+/**
+ * @tsplus pipeable fncts.http.Router provideService
+ * @tsplus location "@fncts/http/Router/api"
+ */
+export declare function provideService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string): <R, E>(self: Router<R, E>) => Router<Exclude<R, T>, E>;

package/Router/definition.d.ts

@@ -0,0 +1,28 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Scope } from "@fncts/io/Scope/definition";
+import type { HttpApp } from "../HttpApp.js";
+import type { Route, RouteContext } from "../Route.js";
+import type { RouteNotFound } from "../RouteNotFound.js";
+import type { ServerRequest } from "../ServerRequest.js";
+import type { ServerResponse } from "@fncts/http/ServerResponse";
+import { External } from "@fncts/io/IO";
+export declare const RouterTypeId: unique symbol;
+export type RouterTypeId = typeof RouterTypeId;
+/**
+ * @tsplus type fncts.http.Router
+ * @tsplus companion fncts.http.RouterOps
+ */
+export declare abstract class Router<R, E> extends External<Exclude<R, RouteContext>, E | RouteNotFound, ServerResponse> implements HttpApp.Default<Exclude<R, RouteContext>, E | RouteNotFound> {
+    readonly [RouterTypeId]: RouterTypeId;
+    abstract readonly routes: Conc<Route<R, E>>;
+    abstract readonly mounts: Conc<Readonly<{
+        prefix: string;
+        httpApp: HttpApp.Default<R, E>;
+        options?: {
+            readonly inclduePrefix?: boolean;
+        };
+    }>>;
+}
+export declare namespace Router {
+    type ExcludeProvided<A> = Exclude<A, RouteContext | ServerRequest | Scope>;
+}

package/Router/internal.d.ts

@@ -0,0 +1,26 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { HttpApp } from "../HttpApp.js";
+import type { ServerResponse } from "../ServerResponse.js";
+import { IO } from "@fncts/io/IO";
+import { type Route, RouteContext } from "../Route.js";
+import { RouteNotFound } from "../RouteNotFound.js";
+import { Router } from "./definition.js";
+export declare class RouterInternal<R, E> extends Router<R, E> {
+    readonly routes: Conc<Route<R, E>>;
+    readonly mounts: Conc<Readonly<{
+        prefix: string;
+        httpApp: HttpApp.Default<R, E>;
+        options?: {
+            readonly inclduePrefix?: boolean;
+        };
+    }>>;
+    readonly httpApp: IO<Exclude<R, RouteContext>, E | RouteNotFound, ServerResponse>;
+    constructor(routes: Conc<Route<R, E>>, mounts: Conc<Readonly<{
+        prefix: string;
+        httpApp: HttpApp.Default<R, E>;
+        options?: {
+            readonly inclduePrefix?: boolean;
+        };
+    }>>);
+    get toIO(): IO<Exclude<R, RouteContext>, RouteNotFound | E, ServerResponse>;
+}

package/Router.d.ts

@@ -0,0 +1,2 @@
+export * from "./Router/definition.js";
+export * from "./Router/api.js";