effect-start 0.17.0 → 0.17.2

package/dist/RouteBody.d.ts

@@ -0,0 +1,53 @@
+import * as Effect from "effect/Effect";
+import type * as Stream from "effect/Stream";
+import type * as Utils from "effect/Utils";
+import * as Entity from "./Entity.ts";
+import * as Route from "./Route.ts";
+import type * as Values from "./Values.ts";
+export type Format = "text" | "html" | "json" | "bytes" | "*";
+type UnwrapStream<T> = T extends Stream.Stream<infer V, any, any> ? V : T;
+type YieldError<T> = T extends Utils.YieldWrap<Effect.Effect<any, infer E, any>> ? E : never;
+type YieldContext<T> = T extends Utils.YieldWrap<Effect.Effect<any, any, infer R>> ? R : never;
+export type GeneratorHandler<B, A, Y> = (context: Values.Simplify<B>, next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<UnwrapStream<A>>) => Generator<Y, A | Entity.Entity<A>, unknown>;
+export type HandlerInput<B, A, E, R> = A | Entity.Entity<A> | Effect.Effect<A | Entity.Entity<A>, E, R> | ((context: Values.Simplify<B>, next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<UnwrapStream<A>>) => Effect.Effect<A | Entity.Entity<A>, E, R> | Generator<Utils.YieldWrap<Effect.Effect<unknown, E, R>>, A | Entity.Entity<A>, unknown>);
+export declare function handle<B, A, Y extends Utils.YieldWrap<Effect.Effect<any, any, any>>>(handler: GeneratorHandler<B, A, Y>): Route.Route.Handler<B, A, YieldError<Y>, YieldContext<Y>>;
+export declare function handle<B, A, E, R>(handler: HandlerInput<B, A, E, R>): Route.Route.Handler<B, A, E, R>;
+export interface BuildReturn<Value, F extends Format> {
+    <D extends Route.RouteDescriptor.Any, B, I extends Route.Route.Tuple, A extends F extends "json" ? Value : Value | Stream.Stream<Value, any, any>, Y extends Utils.YieldWrap<Effect.Effect<any, any, any>>>(handler: GeneratorHandler<NoInfer<D & B & Route.ExtractBindings<I> & {
+        format: F;
+    }>, A, Y>): (self: Route.RouteSet.RouteSet<D, B, I>) => Route.RouteSet.RouteSet<D, B, [
+        ...I,
+        Route.Route.Route<{
+            format: F;
+        }, {}, A, YieldError<Y>, YieldContext<Y>>
+    ]>;
+    <D extends Route.RouteDescriptor.Any, B, I extends Route.Route.Tuple, A extends F extends "json" ? Value : Value | Stream.Stream<Value, any, any>, E = never, R = never>(handler: HandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & {
+        format: F;
+    }>, A, E, R>): (self: Route.RouteSet.RouteSet<D, B, I>) => Route.RouteSet.RouteSet<D, B, [
+        ...I,
+        Route.Route.Route<{
+            format: F;
+        }, {}, A, E, R>
+    ]>;
+}
+export declare function build<Value, F extends Format>(descriptors: {
+    format: F;
+}): BuildReturn<Value, F>;
+export type RenderValue = string | Uint8Array | Stream.Stream<string | Uint8Array, any, any>;
+export declare function render<D extends Route.RouteDescriptor.Any, B extends {}, I extends Route.Route.Tuple, A extends RenderValue, Y extends Utils.YieldWrap<Effect.Effect<any, any, any>>>(handler: GeneratorHandler<NoInfer<D & B & Route.ExtractBindings<I> & {
+    format: "*";
+}>, A, Y>): (self: Route.RouteSet.RouteSet<D, B, I>) => Route.RouteSet.RouteSet<D, B, [
+    ...I,
+    Route.Route.Route<{
+        format: "*";
+    }, {}, A, YieldError<Y>, YieldContext<Y>>
+]>;
+export declare function render<D extends Route.RouteDescriptor.Any, B extends {}, I extends Route.Route.Tuple, A extends RenderValue, E = never, R = never>(handler: HandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & {
+    format: "*";
+}>, A, E, R>): (self: Route.RouteSet.RouteSet<D, B, I>) => Route.RouteSet.RouteSet<D, B, [
+    ...I,
+    Route.Route.Route<{
+        format: "*";
+    }, {}, A, E, R>
+]>;
+export {};

package/dist/RouteBody.js

@@ -0,0 +1,67 @@
+import * as Effect from "effect/Effect";
+import * as Entity from "./Entity.js";
+import * as Route from "./Route.js";
+const formatToContentType = {
+    text: "text/plain; charset=utf-8",
+    html: "text/html; charset=utf-8",
+    json: "application/json",
+    bytes: "application/octet-stream",
+    "*": undefined,
+};
+export function handle(handler) {
+    if (typeof handler === "function") {
+        return (context, next) => {
+            const result = handler(context, next);
+            const effect = Effect.isEffect(result)
+                ? result
+                : Effect.gen(function* () {
+                    return yield* result;
+                });
+            return Effect.map(effect, normalizeToEntity);
+        };
+    }
+    if (Effect.isEffect(handler)) {
+        return (_context, _next) => Effect.map(handler, normalizeToEntity);
+    }
+    if (Entity.isEntity(handler)) {
+        return (_context, _next) => Effect.succeed(handler);
+    }
+    return (_context, _next) => Effect.succeed(normalizeToEntity(handler));
+}
+function normalizeToEntity(value) {
+    if (Entity.isEntity(value)) {
+        return value;
+    }
+    return Entity.make(value, { status: 200 });
+}
+export function build(descriptors) {
+    return (function (handler) {
+        return function (self) {
+            const contentType = formatToContentType[descriptors.format];
+            const baseHandler = handle(handler);
+            const wrappedHandler = (ctx, next) => Effect.map(baseHandler(ctx, next), (entity) => entity.headers["content-type"]
+                ? entity
+                : Entity.make(entity.body, {
+                    status: entity.status,
+                    url: entity.url,
+                    headers: { ...entity.headers, "content-type": contentType },
+                }));
+            const route = Route.make(wrappedHandler, descriptors);
+            const items = [
+                ...Route.items(self),
+                route,
+            ];
+            return Route.set(items, Route.descriptor(self));
+        };
+    });
+}
+export function render(handler) {
+    return function (self) {
+        const route = Route.make(handle(handler), { format: "*" });
+        const items = [
+            ...Route.items(self),
+            route,
+        ];
+        return Route.set(items, Route.descriptor(self));
+    };
+}

package/dist/RouteHook.d.ts

@@ -0,0 +1,12 @@
+import * as Effect from "effect/Effect";
+import type * as Utils from "effect/Utils";
+import * as Route from "./Route.ts";
+export type FilterResult<BOut, E, R> = {
+    context: BOut;
+} | Effect.Effect<{
+    context: BOut;
+}, E, R>;
+export type FilterHandlerInput<BIn, BOut, E, R> = FilterResult<BOut, E, R> | ((context: BIn) => FilterResult<BOut, E, R> | Generator<Utils.YieldWrap<Effect.Effect<unknown, E, R>>, {
+    context: BOut;
+}, unknown>);
+export declare function filter<D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple, BOut extends {}, E = never, R = never, BIn = D & SB & Route.ExtractBindings<P>>(filterHandler: FilterHandlerInput<BIn, BOut, E, R>): (self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [...P, Route.Route.Route<{}, BOut, unknown, E, R>]>;

package/dist/RouteHook.js

@@ -0,0 +1,45 @@
+import * as Effect from "effect/Effect";
+import * as Entity from "./Entity.js";
+import * as Route from "./Route.js";
+export function filter(filterHandler) {
+    const normalized = normalizeFilterHandler(filterHandler);
+    return function (self) {
+        const route = Route.make((context, next) => Effect.gen(function* () {
+            const filterResult = yield* normalized(context);
+            const mergedContext = filterResult
+                ? { ...context, ...filterResult.context }
+                : context;
+            return yield* Entity.resolve(next(mergedContext));
+        }));
+        return Route.set([
+            ...Route.items(self),
+            route,
+        ], Route.descriptor(self));
+    };
+}
+function isGenerator(value) {
+    return (typeof value === "object"
+        && value !== null
+        && Symbol.iterator in value
+        && typeof value.next === "function");
+}
+function normalizeFilterHandler(handler) {
+    if (typeof handler === "function") {
+        return (context) => {
+            const result = handler(context);
+            if (Effect.isEffect(result)) {
+                return result;
+            }
+            if (isGenerator(result)) {
+                return Effect.gen(function* () {
+                    return yield* result;
+                });
+            }
+            return Effect.succeed(result);
+        };
+    }
+    if (Effect.isEffect(handler)) {
+        return (_context) => handler;
+    }
+    return (_context) => Effect.succeed(handler);
+}

package/dist/RouteHttp.d.ts

@@ -0,0 +1,21 @@
+import * as FiberId from "effect/FiberId";
+import * as Runtime from "effect/Runtime";
+import * as Http from "./Http.ts";
+import * as Route from "./Route.ts";
+import * as RouteBody from "./RouteBody.ts";
+import * as RouteMount from "./RouteMount.ts";
+import * as RouteTree from "./RouteTree.ts";
+export { currentSpanNameGenerator, currentTracerDisabledWhen, parentSpanFromHeaders, withSpanNameGenerator, withTracerDisabledWhen, } from "./RouteHttpTracer.ts";
+type UnboundedRouteWithMethod = Route.Route.With<{
+    method: RouteMount.RouteMount.Method;
+    format?: RouteBody.Format;
+}>;
+/**
+ * A synthetic fiber used to tag interruptions caused by client disconnects.
+ * Number stands for HTTP status 499 "Client Closed Request".
+ * This is what @effect/platform does to signal request cancelation.
+ */
+export declare const clientAbortFiberId: FiberId.Runtime;
+export declare const toWebHandlerRuntime: <R>(runtime: Runtime.Runtime<R>) => (routes: Iterable<UnboundedRouteWithMethod>) => Http.WebHandler;
+export declare const toWebHandler: (routes: Iterable<UnboundedRouteWithMethod>) => Http.WebHandler;
+export declare function walkHandles(tree: RouteTree.RouteTree, runtime?: Runtime.Runtime<never>): Generator<[path: string, handler: Http.WebHandler]>;

package/dist/RouteHttp.js

@@ -0,0 +1,260 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as FiberId from "effect/FiberId";
+import * as FiberRef from "effect/FiberRef";
+import * as HashSet from "effect/HashSet";
+import * as Option from "effect/Option";
+import * as Runtime from "effect/Runtime";
+import * as Stream from "effect/Stream";
+import * as ContentNegotiation from "./ContentNegotiation.js";
+import * as Entity from "./Entity.js";
+import * as Route from "./Route.js";
+import * as RouteHttpTracer from "./RouteHttpTracer.js";
+import * as RouteTree from "./RouteTree.js";
+import * as StreamExtra from "./StreamExtra.js";
+export { currentSpanNameGenerator, currentTracerDisabledWhen, parentSpanFromHeaders, withSpanNameGenerator, withTracerDisabledWhen, } from "./RouteHttpTracer.js";
+// Used to match Accept headers against available route formats.
+// text/* matches any text type (text/plain, text/event-stream, text/markdown, etc.)
+const formatToMediaType = {
+    text: "text/*",
+    html: "text/html",
+    json: "application/json",
+    bytes: "application/octet-stream",
+};
+// Used after content negotiation to determine which format was selected.
+const mediaTypeToFormat = {
+    "text/*": "text",
+    "text/html": "html",
+    "application/json": "json",
+    "application/octet-stream": "bytes",
+};
+/**
+ * A synthetic fiber used to tag interruptions caused by client disconnects.
+ * Number stands for HTTP status 499 "Client Closed Request".
+ * This is what @effect/platform does to signal request cancelation.
+ */
+export const clientAbortFiberId = FiberId.runtime(-499, 0);
+const isClientAbort = (cause) => Cause.isInterruptedOnly(cause)
+    && HashSet.some(Cause.interruptors(cause), (id) => id === clientAbortFiberId);
+const getStatusFromCause = (cause) => {
+    const failure = Cause.failureOption(cause);
+    if (failure._tag === "Some") {
+        const error = failure.value;
+        if (error._tag === "ParseError" || error._tag === "RequestBodyError") {
+            return 400;
+        }
+    }
+    return 500;
+};
+function streamResponse(stream, headers, status, runtime) {
+    const encoder = new TextEncoder();
+    const byteStream = stream.pipe(Stream.map((chunk) => typeof chunk === "string"
+        ? encoder.encode(chunk)
+        : chunk), Stream.catchAll((error) => Stream.fail(error instanceof Error ? error : new Error(String(error)))));
+    return new Response(Stream.toReadableStreamRuntime(byteStream, runtime), { status, headers: headers });
+}
+function toResponse(entity, format, runtime) {
+    const contentType = Entity.type(entity);
+    const status = entity.status ?? 200;
+    const headers = { ...entity.headers, "content-type": contentType };
+    if (StreamExtra.isStream(entity.body)) {
+        return Effect.succeed(streamResponse(entity.body, headers, status, runtime));
+    }
+    if (format === "json") {
+        return Effect.map(entity.json, (data) => new Response(JSON.stringify(data), { status, headers }));
+    }
+    if (format === "text" || format === "html") {
+        return Effect.map(entity.text, (text) => new Response(text, { status, headers }));
+    }
+    if (format === "bytes") {
+        return Effect.map(entity.bytes, (bytes) => new Response(bytes, { status, headers }));
+    }
+    return Effect.succeed(streamResponse(entity.stream, headers, status, runtime));
+}
+function determineSelectedFormat(accept, routes) {
+    const formats = routes
+        .filter((r) => Route.descriptor(r).method !== "*")
+        .map((r) => Route.descriptor(r).format)
+        .filter((f) => Boolean(f) && f !== "*");
+    const uniqueFormats = [...new Set(formats)];
+    const mediaTypes = uniqueFormats
+        .map((f) => formatToMediaType[f])
+        .filter(Boolean);
+    if (mediaTypes.length === 0) {
+        return undefined;
+    }
+    if (!accept) {
+        return uniqueFormats[0];
+    }
+    const negotiated = ContentNegotiation.media(accept, mediaTypes);
+    if (negotiated.length > 0) {
+        return mediaTypeToFormat[negotiated[0]];
+    }
+    return undefined;
+}
+export const toWebHandlerRuntime = (runtime) => {
+    const runFork = Runtime.runFork(runtime);
+    return (routes) => {
+        const grouped = Object.groupBy(routes, (route) => Route.descriptor(route).method?.toUpperCase() ?? "*");
+        const wildcards = grouped["*"] ?? [];
+        const methodGroups = {
+            GET: undefined,
+            POST: undefined,
+            PUT: undefined,
+            PATCH: undefined,
+            DELETE: undefined,
+            HEAD: undefined,
+            OPTIONS: undefined,
+        };
+        for (const method in grouped) {
+            if (method !== "*") {
+                methodGroups[method] = grouped[method];
+            }
+        }
+        return (request) => {
+            const method = request.method.toUpperCase();
+            const accept = request.headers.get("accept");
+            const methodRoutes = methodGroups[method] ?? [];
+            if (methodRoutes.length === 0 && wildcards.length === 0) {
+                return Promise.resolve(Response.json({ status: 405, message: "method not allowed" }, {
+                    status: 405,
+                }));
+            }
+            const allRoutes = [...wildcards, ...methodRoutes];
+            const selectedFormat = determineSelectedFormat(accept, allRoutes);
+            const hasSpecificFormatRoutes = allRoutes.some((r) => {
+                const format = Route.descriptor(r).format;
+                return format && format !== "*";
+            });
+            const hasWildcardFormatRoutes = allRoutes.some((r) => Route.descriptor(r).format === "*");
+            if (selectedFormat === undefined
+                && hasSpecificFormatRoutes
+                && !hasWildcardFormatRoutes) {
+                return Promise.resolve(Response.json({ status: 406, message: "not acceptable" }, {
+                    status: 406,
+                }));
+            }
+            const createChain = (initialContext) => {
+                let index = 0;
+                let currentContext = initialContext;
+                let routePathSet = false;
+                const runNext = (passedContext) => {
+                    if (passedContext !== undefined) {
+                        currentContext = passedContext;
+                    }
+                    if (index >= allRoutes.length) {
+                        return Effect.succeed(Entity.make({ status: 404, message: "route not found" }, { status: 404 }));
+                    }
+                    const route = allRoutes[index++];
+                    const descriptor = Route.descriptor(route);
+                    const format = descriptor.format;
+                    const handler = route.handler;
+                    if (format && format !== "*" && format !== selectedFormat) {
+                        return runNext();
+                    }
+                    currentContext = { ...currentContext, ...descriptor };
+                    const nextArg = (ctx) => Entity.effect(Effect.suspend(() => runNext(ctx)));
+                    const routePath = descriptor["path"];
+                    if (!routePathSet && routePath !== undefined) {
+                        routePathSet = true;
+                        return Effect.flatMap(Effect.currentSpan.pipe(Effect.option), (spanOption) => {
+                            if (Option.isSome(spanOption)) {
+                                spanOption.value.attribute("http.route", routePath);
+                            }
+                            return handler(currentContext, nextArg);
+                        });
+                    }
+                    return handler(currentContext, nextArg);
+                };
+                return runNext();
+            };
+            const effect = Effect.withFiberRuntime((fiber) => {
+                const tracerDisabled = !fiber.getFiberRef(FiberRef.currentTracerEnabled)
+                    || fiber.getFiberRef(RouteHttpTracer.currentTracerDisabledWhen)(request);
+                const url = new URL(request.url);
+                const innerEffect = Effect.gen(function* () {
+                    const result = yield* createChain({ request, selectedFormat });
+                    const entity = Entity.isEntity(result)
+                        ? result
+                        : Entity.make(result, { status: 200 });
+                    if (entity.status === 404 && entity.body === undefined) {
+                        return Response.json({ status: 406, message: "not acceptable" }, {
+                            status: 406,
+                        });
+                    }
+                    return yield* toResponse(entity, selectedFormat, runtime);
+                });
+                if (tracerDisabled) {
+                    return innerEffect;
+                }
+                const spanNameGenerator = fiber.getFiberRef(RouteHttpTracer.currentSpanNameGenerator);
+                return Effect.useSpan(spanNameGenerator(request), {
+                    parent: Option.getOrUndefined(RouteHttpTracer.parentSpanFromHeaders(request.headers)),
+                    kind: "server",
+                    captureStackTrace: false,
+                }, (span) => {
+                    span.attribute("http.request.method", request.method);
+                    span.attribute("url.full", url.toString());
+                    span.attribute("url.path", url.pathname);
+                    const query = url.search.slice(1);
+                    if (query !== "") {
+                        span.attribute("url.query", query);
+                    }
+                    span.attribute("url.scheme", url.protocol.slice(0, -1));
+                    const userAgent = request.headers.get("user-agent");
+                    if (userAgent !== null) {
+                        span.attribute("user_agent.original", userAgent);
+                    }
+                    return Effect.flatMap(Effect.exit(Effect.withParentSpan(innerEffect, span)), (exit) => {
+                        if (exit._tag === "Success") {
+                            span.attribute("http.response.status_code", exit.value.status);
+                        }
+                        return exit;
+                    });
+                });
+            });
+            return new Promise((resolve) => {
+                const fiber = runFork(effect.pipe(Effect.scoped, Effect.catchAllCause((cause) => Effect.gen(function* () {
+                    yield* Effect.logError(cause);
+                    const status = getStatusFromCause(cause);
+                    return Response.json({ status, message: Cause.pretty(cause) }, {
+                        status,
+                    });
+                }))));
+                request.signal?.addEventListener("abort", () => {
+                    fiber.unsafeInterruptAsFork(clientAbortFiberId);
+                }, { once: true });
+                fiber.addObserver((exit) => {
+                    if (exit._tag === "Success") {
+                        resolve(exit.value);
+                    }
+                    else if (isClientAbort(exit.cause)) {
+                        resolve(Response.json({ status: 499, message: "client closed request" }, {
+                            status: 499,
+                        }));
+                    }
+                    else {
+                        const status = getStatusFromCause(exit.cause);
+                        resolve(Response.json({ status, message: Cause.pretty(exit.cause) }, {
+                            status,
+                        }));
+                    }
+                });
+            });
+        };
+    };
+};
+export const toWebHandler = toWebHandlerRuntime(Runtime.defaultRuntime);
+export function* walkHandles(tree, runtime = Runtime.defaultRuntime) {
+    const pathGroups = new Map();
+    for (const route of RouteTree.walk(tree)) {
+        const path = Route.descriptor(route).path;
+        const group = pathGroups.get(path) ?? [];
+        group.push(route);
+        pathGroups.set(path, group);
+    }
+    const toHandler = toWebHandlerRuntime(runtime);
+    for (const [path, routes] of pathGroups) {
+        yield [path, toHandler(routes)];
+    }
+}

package/dist/RouteHttpTracer.d.ts

@@ -0,0 +1,10 @@
+import * as Effect from "effect/Effect";
+import * as FiberRef from "effect/FiberRef";
+import * as Option from "effect/Option";
+import type * as Predicate from "effect/Predicate";
+import * as Tracer from "effect/Tracer";
+export declare const currentTracerDisabledWhen: FiberRef.FiberRef<Predicate.Predicate<Request>>;
+export declare const withTracerDisabledWhen: <A, E, R>(effect: Effect.Effect<A, E, R>, predicate: Predicate.Predicate<Request>) => Effect.Effect<A, E, R>;
+export declare const currentSpanNameGenerator: FiberRef.FiberRef<(request: Request) => string>;
+export declare const withSpanNameGenerator: <A, E, R>(effect: Effect.Effect<A, E, R>, f: (request: Request) => string) => Effect.Effect<A, E, R>;
+export declare const parentSpanFromHeaders: (headers: Headers) => Option.Option<Tracer.ExternalSpan>;

package/dist/RouteHttpTracer.js

@@ -0,0 +1,62 @@
+import * as Effect from "effect/Effect";
+import * as FiberRef from "effect/FiberRef";
+import * as GlobalValue from "effect/GlobalValue";
+import * as Option from "effect/Option";
+import * as Tracer from "effect/Tracer";
+export const currentTracerDisabledWhen = GlobalValue.globalValue(Symbol.for("effect-start/RouteHttp/tracerDisabledWhen"), () => FiberRef.unsafeMake(() => false));
+export const withTracerDisabledWhen = (effect, predicate) => Effect.locally(effect, currentTracerDisabledWhen, predicate);
+export const currentSpanNameGenerator = GlobalValue.globalValue(Symbol.for("effect-start/RouteHttp/spanNameGenerator"), () => FiberRef.unsafeMake((request) => `http.server ${request.method}`));
+export const withSpanNameGenerator = (effect, f) => Effect.locally(effect, currentSpanNameGenerator, f);
+const w3cTraceparent = (headers) => {
+    const header = headers.get("traceparent");
+    if (header === null)
+        return Option.none();
+    const parts = header.split("-");
+    if (parts.length < 4)
+        return Option.none();
+    const [_version, traceId, spanId, flags] = parts;
+    if (!traceId || !spanId)
+        return Option.none();
+    return Option.some(Tracer.externalSpan({
+        spanId,
+        traceId,
+        sampled: flags === "01",
+    }));
+};
+const b3Single = (headers) => {
+    const header = headers.get("b3");
+    if (header === null)
+        return Option.none();
+    const parts = header.split("-");
+    if (parts.length < 2)
+        return Option.none();
+    const [traceId, spanId, sampledStr] = parts;
+    if (!traceId || !spanId)
+        return Option.none();
+    return Option.some(Tracer.externalSpan({
+        spanId,
+        traceId,
+        sampled: sampledStr === "1",
+    }));
+};
+const xb3 = (headers) => {
+    const traceId = headers.get("x-b3-traceid");
+    const spanId = headers.get("x-b3-spanid");
+    if (traceId === null || spanId === null)
+        return Option.none();
+    const sampled = headers.get("x-b3-sampled");
+    return Option.some(Tracer.externalSpan({
+        spanId,
+        traceId,
+        sampled: sampled === "1",
+    }));
+};
+export const parentSpanFromHeaders = (headers) => {
+    let span = w3cTraceparent(headers);
+    if (span._tag === "Some")
+        return span;
+    span = b3Single(headers);
+    if (span._tag === "Some")
+        return span;
+    return xb3(headers);
+};

package/dist/RouteMount.d.ts

@@ -0,0 +1,119 @@
+import * as Types from "effect/Types";
+import * as Http from "./Http.ts";
+import * as PathPattern from "./PathPattern.ts";
+import * as Route from "./Route.ts";
+type Module = typeof import("./RouteMount.ts");
+export type Self = RouteMount.Builder | Module;
+export declare const use: RouteMount.Describer<"*">;
+export declare const get: RouteMount.Describer<"GET">;
+export declare const post: RouteMount.Describer<"POST">;
+export declare const put: RouteMount.Describer<"PUT">;
+export declare const del: RouteMount.Describer<"DELETE">;
+export declare const patch: RouteMount.Describer<"PATCH">;
+export declare const head: RouteMount.Describer<"HEAD">;
+export declare const options: RouteMount.Describer<"OPTIONS">;
+export declare const add: RouteMount.Add;
+export type MountedRoute = Route.Route.Route<{
+    method: RouteMount.Method;
+    path: PathPattern.PathPattern;
+    format?: string;
+}, {}, any, any, any>;
+export declare namespace RouteMount {
+    export type Method = "*" | Http.Method;
+    export type MountSet = Route.RouteSet.RouteSet<{
+        method: Method;
+    }, {}, Route.Route.Tuple>;
+    export interface Builder<D extends {} = {}, I extends Route.Route.Tuple = []> extends Route.RouteSet.RouteSet<D, {}, I>, Module {
+    }
+    export type EmptySet<M extends Method, B = {}> = Route.RouteSet.RouteSet<{
+        method: M;
+    }, B, [
+    ]>;
+    export type Items<S> = S extends Builder<any, infer I> ? I : [];
+    export type BuilderBindings<S> = S extends Builder<any, infer I> ? Types.Simplify<WildcardBindings<I>> & {
+        request: Request;
+    } : {
+        request: Request;
+    };
+    type WildcardBindingsItem<T> = T extends Route.Route.Route<{
+        method: "*";
+    }, infer B, any, any, any> ? B : {};
+    type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+    export type WildcardBindings<I extends Route.Route.Tuple> = UnionToIntersection<{
+        [K in keyof I]: WildcardBindingsItem<I[K]>;
+    }[number]>;
+    type PrefixPathItem<Prefix extends string, T> = T extends Route.Route.Route<infer D, infer B, infer A, infer E, infer R> ? D extends {
+        path: infer P extends string;
+    } ? Route.Route.Route<Omit<D, "path"> & {
+        path: `${Prefix}${P}`;
+    }, B, A, E, R> : Route.Route.Route<D & {
+        path: Prefix;
+    }, B, A, E, R> : T;
+    export type PrefixPath<Prefix extends string, I extends Route.Route.Tuple> = {
+        [K in keyof I]: PrefixPathItem<Prefix, I[K]>;
+    } extends infer R extends Route.Route.Tuple ? R : never;
+    export interface Add {
+        <S extends Self, P extends string, R extends Route.RouteSet.Any>(this: S, path: P, routes: R): Builder<{}, [
+            ...Items<S>,
+            ...PrefixPath<P, Route.RouteSet.Items<R>>
+        ]>;
+        <S extends Self, P extends string, R extends Route.RouteSet.Any>(this: S, path: P, 
+        /**
+         * Callback form provides a builder seeded with higher-level bindings so
+         * nested routes can type-infer outer context when mounting.
+         */
+        routes: (self: Builder<{}, []>) => R): Builder<{}, [
+            ...Items<S>,
+            ...PrefixPath<P, Route.RouteSet.Items<R>>
+        ]>;
+    }
+    export type FlattenItems<M extends Method, B, I extends Route.Route.Tuple> = I extends [
+        Route.Route.Route<infer D, infer RB, infer A, infer E, infer R>,
+        ...infer Tail extends Route.Route.Tuple
+    ] ? [
+        Route.Route.Route<Types.Simplify<{
+            method: M;
+        } & D> & {}, Types.Simplify<Omit<B & RB, "request">>, A, E, R>,
+        ...FlattenItems<M, Types.Simplify<B & RB>, Tail>
+    ] : [];
+    export interface Describer<M extends Method> {
+        <S extends Self, A extends Route.RouteSet.Any>(this: S, ab: (a: EmptySet<M, BuilderBindings<S>>) => A): Builder<{}, [
+            ...Items<S>,
+            ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<A>>
+        ]>;
+        <S extends Self, A extends Route.RouteSet.Any, B extends Route.RouteSet.Any>(this: S, ab: (a: EmptySet<M, BuilderBindings<S>>) => A, bc: (b: A) => B): Builder<{}, [
+            ...Items<S>,
+            ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<B>>
+        ]>;
+        <S extends Self, A extends Route.RouteSet.Any, B extends Route.RouteSet.Any, C extends Route.RouteSet.Any>(this: S, ab: (a: EmptySet<M, BuilderBindings<S>>) => A, bc: (b: A) => B, cd: (c: B) => C): Builder<{}, [
+            ...Items<S>,
+            ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<C>>
+        ]>;
+        <S extends Self, A extends Route.RouteSet.Any, B extends Route.RouteSet.Any, C extends Route.RouteSet.Any, D extends Route.RouteSet.Any>(this: S, ab: (a: EmptySet<M, BuilderBindings<S>>) => A, bc: (b: A) => B, cd: (c: B) => C, de: (d: C) => D): Builder<{}, [
+            ...Items<S>,
+            ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<D>>
+        ]>;
+        <S extends Self, A extends Route.RouteSet.Any, B extends Route.RouteSet.Any, C extends Route.RouteSet.Any, D extends Route.RouteSet.Any, E extends Route.RouteSet.Any>(this: S, ab: (a: EmptySet<M, BuilderBindings<S>>) => A, bc: (b: A) => B, cd: (c: B) => C, de: (d: C) => D, ef: (e: D) => E): Builder<{}, [
+            ...Items<S>,
+            ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<E>>
+        ]>;
+        <S extends Self, A extends Route.RouteSet.Any, B extends Route.RouteSet.Any, C extends Route.RouteSet.Any, D extends Route.RouteSet.Any, E extends Route.RouteSet.Any, F extends Route.RouteSet.Any>(this: S, ab: (a: EmptySet<M, BuilderBindings<S>>) => A, bc: (b: A) => B, cd: (c: B) => C, de: (d: C) => D, ef: (e: D) => E, fg: (f: E) => F): Builder<{}, [
+            ...Items<S>,
+            ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<F>>
+        ]>;
+        <S extends Self, A extends Route.RouteSet.Any, B extends Route.RouteSet.Any, C extends Route.RouteSet.Any, D extends Route.RouteSet.Any, E extends Route.RouteSet.Any, F extends Route.RouteSet.Any, G extends Route.RouteSet.Any>(this: S, ab: (a: EmptySet<M, BuilderBindings<S>>) => A, bc: (b: A) => B, cd: (c: B) => C, de: (d: C) => D, ef: (e: D) => E, fg: (f: E) => F, gh: (g: F) => G): Builder<{}, [
+            ...Items<S>,
+            ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<G>>
+        ]>;
+        <S extends Self, A extends Route.RouteSet.Any, B extends Route.RouteSet.Any, C extends Route.RouteSet.Any, D extends Route.RouteSet.Any, E extends Route.RouteSet.Any, F extends Route.RouteSet.Any, G extends Route.RouteSet.Any, H extends Route.RouteSet.Any>(this: S, ab: (a: EmptySet<M, BuilderBindings<S>>) => A, bc: (b: A) => B, cd: (c: B) => C, de: (d: C) => D, ef: (e: D) => E, fg: (f: E) => F, gh: (g: F) => G, hi: (h: G) => H): Builder<{}, [
+            ...Items<S>,
+            ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<H>>
+        ]>;
+        <S extends Self, A extends Route.RouteSet.Any, B extends Route.RouteSet.Any, C extends Route.RouteSet.Any, D extends Route.RouteSet.Any, E extends Route.RouteSet.Any, F extends Route.RouteSet.Any, G extends Route.RouteSet.Any, H extends Route.RouteSet.Any, I extends Route.RouteSet.Any>(this: S, ab: (a: EmptySet<M, BuilderBindings<S>>) => A, bc: (b: A) => B, cd: (c: B) => C, de: (d: C) => D, ef: (e: D) => E, fg: (f: E) => F, gh: (g: F) => G, hi: (h: G) => H, ij: (i: H) => I): Builder<{}, [
+            ...Items<S>,
+            ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<I>>
+        ]>;
+    }
+    export {};
+}
+export {};