effect-start 0.23.1 → 0.26.0

package/dist/RouteHttp.js

@@ -1,258 +0,0 @@
-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";
-// 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;
-};
-const respondError = (options) => new Response(JSON.stringify(options, null, 2), {
-    status: options.status,
-    headers: { "content-type": "application/json" },
-});
-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(respondError({ status: 405, message: "method not allowed" }));
-            }
-            const allRoutes = [...wildcards, ...methodRoutes];
-            const selectedFormat = determineSelectedFormat(accept, allRoutes);
-            const specificFormats = new Set();
-            let hasWildcardFormatRoutes = false;
-            for (const r of allRoutes) {
-                const format = Route.descriptor(r).format;
-                if (format === "*")
-                    hasWildcardFormatRoutes = true;
-                else if (format)
-                    specificFormats.add(format);
-            }
-            const hasSpecificFormatRoutes = specificFormats.size > 0;
-            const varyAccept = specificFormats.size > 1;
-            if (selectedFormat === undefined && hasSpecificFormatRoutes && !hasWildcardFormatRoutes) {
-                return Promise.resolve(respondError({ status: 406, message: "not acceptable" }));
-            }
-            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 respondError({ status: 406, message: "not acceptable" });
-                    }
-                    const response = yield* toResponse(entity, selectedFormat, runtime);
-                    if (varyAccept) {
-                        response.headers.set("vary", "Accept");
-                    }
-                    return response;
-                });
-                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);
-                    const message = Cause.pretty(cause, { renderErrorCause: true });
-                    return respondError({ status, message });
-                }))));
-                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(respondError({ status: 499, message: "client closed request" }));
-                    }
-                    else {
-                        const status = getStatusFromCause(exit.cause);
-                        const message = Cause.pretty(exit.cause, { renderErrorCause: true });
-                        resolve(respondError({ status, message }));
-                    }
-                });
-            });
-        };
-    };
-};
-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

@@ -1,10 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,86 +0,0 @@
-import type * as Types from "effect/Types";
-import type * as Http from "./Http.ts";
-import type * as PathPattern from "./PathPattern.ts";
-import * as Route from "./Route.ts";
-import type * as RouteBody from "./RouteBody.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?: RouteBody.Format;
-}, {}, 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 {};

package/dist/RouteMount.js

@@ -1,63 +0,0 @@
-import * as Function from "effect/Function";
-import * as Route from "./Route.js";
-const RouteSetTypeId = Symbol.for("effect-start/RouteSet");
-export const use = makeMethodDescriber("*");
-export const get = makeMethodDescriber("GET");
-export const post = makeMethodDescriber("POST");
-export const put = makeMethodDescriber("PUT");
-export const del = makeMethodDescriber("DELETE");
-export const patch = makeMethodDescriber("PATCH");
-export const head = makeMethodDescriber("HEAD");
-export const options = makeMethodDescriber("OPTIONS");
-export const add = function (path, routes) {
-    const baseItems = Route.isRouteSet(this) ? Route.items(this) : [];
-    const routeSet = typeof routes === "function" ? routes(make([])) : routes;
-    const routeItems = Route.items(routeSet);
-    const newItems = routeItems.map((item) => {
-        const itemDescriptor = Route.descriptor(item);
-        const concatenatedPath = typeof itemDescriptor?.path === "string" ? path + itemDescriptor.path : path;
-        const newDescriptor = { ...itemDescriptor, path: concatenatedPath };
-        return Route.isRoute(item)
-            ? Route.make(item.handler, newDescriptor)
-            : Route.set(Route.items(item), newDescriptor);
-    });
-    return make([...baseItems, ...newItems]);
-};
-const Proto = Object.assign(Object.create(null), {
-    [RouteSetTypeId]: RouteSetTypeId,
-    *[Symbol.iterator]() {
-        yield* Route.items(this);
-    },
-    use,
-    get,
-    post,
-    put,
-    del,
-    patch,
-    head,
-    options,
-    add,
-});
-function make(items) {
-    return Object.assign(Object.create(Proto), {
-        [Route.RouteItems]: items,
-        [Route.RouteDescriptor]: {},
-    });
-}
-function makeMethodDescriber(method) {
-    function describeMethod(...fs) {
-        const baseItems = Route.isRouteSet(this) ? Route.items(this) : [];
-        const methodSet = Route.set([], { method });
-        const f = Function.flow(...fs);
-        const result = f(methodSet);
-        const resultItems = Route.items(result);
-        // Items are already flat (only Routes), just merge method into each descriptor
-        const flattenedItems = resultItems.map((item) => {
-            const itemDescriptor = Route.descriptor(item);
-            const newDescriptor = { method, ...itemDescriptor };
-            return Route.make(item.handler, newDescriptor);
-        });
-        return make([...baseItems, ...flattenedItems]);
-    }
-    return describeMethod;
-}

package/dist/RouteSchema.d.ts

@@ -1,86 +0,0 @@
-import type * as ParseResult from "effect/ParseResult";
-import * as Schema from "effect/Schema";
-import type * as Scope from "effect/Scope";
-import * as Http from "./Http.ts";
-import * as Route from "./Route.ts";
-export interface RequestBodyError {
-    readonly _tag: "RequestBodyError";
-    readonly reason: "JsonError" | "UrlParamsError" | "MultipartError" | "FormDataError";
-    readonly cause: unknown;
-}
-export declare const RequestBodyError: (reason: RequestBodyError["reason"], cause: unknown) => RequestBodyError;
-export declare const File: Schema.TaggedStruct<"File", {
-    key: typeof Schema.String;
-    name: typeof Schema.String;
-    contentType: typeof Schema.String;
-    content: typeof Schema.Uint8ArrayFromSelf;
-}>;
-export declare function schemaHeaders<A, I extends Readonly<Record<string, string | undefined>>, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
-    ...P,
-    Route.Route.Route<{}, {
-        headers: A;
-    }, unknown, ParseResult.ParseError, R>
-]>;
-export declare function schemaCookies<A, I extends Readonly<Record<string, string | undefined>>, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
-    ...P,
-    Route.Route.Route<{}, {
-        cookies: A;
-    }, unknown, ParseResult.ParseError, R>
-]>;
-export declare function schemaSearchParams<A, I extends Readonly<Record<string, string | ReadonlyArray<string> | undefined>>, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
-    ...P,
-    Route.Route.Route<{}, {
-        searchParams: A;
-    }, unknown, ParseResult.ParseError, R>
-]>;
-export declare function schemaPathParams<A, I extends Readonly<Record<string, string | undefined>>, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
-    ...P,
-    Route.Route.Route<{}, {
-        pathParams: A;
-    }, unknown, ParseResult.ParseError, R>
-]>;
-export declare function schemaBodyJson<A, I, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
-    ...P,
-    Route.Route.Route<{}, {
-        body: A;
-    }, unknown, RequestBodyError | ParseResult.ParseError, R>
-]>;
-export declare function schemaBodyUrlParams<A, I extends Readonly<Record<string, string | ReadonlyArray<string> | undefined>>, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
-    ...P,
-    Route.Route.Route<{}, {
-        body: A;
-    }, unknown, RequestBodyError | ParseResult.ParseError, R>
-]>;
-export declare function schemaBodyMultipart<A, I extends Partial<Record<string, ReadonlyArray<Http.FilePart> | ReadonlyArray<string> | string>>, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
-    ...P,
-    Route.Route.Route<{}, {
-        body: A;
-    }, unknown, RequestBodyError | ParseResult.ParseError, R | Scope.Scope>
-]>;
-export declare function schemaBodyForm<A, I extends Partial<Record<string, ReadonlyArray<Http.FilePart> | ReadonlyArray<string> | string>>, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
-    ...P,
-    Route.Route.Route<{}, {
-        body: A;
-    }, unknown, RequestBodyError | ParseResult.ParseError, R | Scope.Scope>
-]>;
-/**
- * Intercepts typed errors from downstream handlers, encodes them through the
- * schema, and returns a JSON response with the given status code.
- *
- * Without `schemaError`, handler errors fall through to global catch during
- * execution of request. `schemaError` short circuts error handling by
- * return an error response immedietly.
- *
- * TODO: store the errors in runtime to enable generating OpenAPI and other
- * goodies.
- */
-export declare function schemaError<A, I, R>(schema: Schema.Schema<A, I, R> & {
-    readonly status: number;
-}): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [...P, Route.Route.Route<{}, {}, unknown, never, R>]>;
-export declare function schemaError<A, I, R>(schema: Schema.Schema<A, I, R>, options: {
-    readonly status: number;
-}): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [...P, Route.Route.Route<{}, {}, unknown, never, R>]>;
-export declare function schemaSuccess<A, I, R>(schema: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
-    ...P,
-    Route.Route.Route<{}, {}, I, ParseResult.ParseError, R>
-]>;