effect-start 0.23.0 → 0.25.0

package/dist/PlatformError.d.ts

@@ -1,38 +0,0 @@
-import type * as Cause from "effect/Cause";
-import type * as Types from "effect/Types";
-export declare const TypeId: unique symbol;
-export type TypeId = typeof TypeId;
-export declare const isPlatformError: (u: unknown) => u is PlatformError;
-export declare const TypeIdError: <const TypeId extends symbol, const Tag extends string>(typeId: TypeId, tag: Tag) => (new <A extends Record<string, any>>(args: Types.Simplify<A>) => Cause.YieldableError & Record<TypeId, TypeId> & {
-    readonly _tag: Tag;
-} & Readonly<A>);
-export type SystemErrorReason = "AlreadyExists" | "BadResource" | "Busy" | "InvalidData" | "NotFound" | "PermissionDenied" | "TimedOut" | "UnexpectedEof" | "Unknown" | "WouldBlock" | "WriteZero";
-declare const BadArgument_base: new <A extends Record<string, any> = {}>(args: Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
-    readonly _tag: "BadArgument";
-} & Readonly<A>;
-export declare class BadArgument extends BadArgument_base<{
-    module: string;
-    method: string;
-    description?: string | undefined;
-    cause?: unknown;
-}> {
-    readonly [TypeId]: typeof TypeId;
-    get message(): string;
-}
-declare const SystemError_base: new <A extends Record<string, any> = {}>(args: Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
-    readonly _tag: "SystemError";
-} & Readonly<A>;
-export declare class SystemError extends SystemError_base<{
-    reason: SystemErrorReason;
-    module: string;
-    method: string;
-    description?: string | undefined;
-    syscall?: string | undefined;
-    pathOrDescriptor?: string | number | undefined;
-    cause?: unknown;
-}> {
-    readonly [TypeId]: typeof TypeId;
-    get message(): string;
-}
-export type PlatformError = BadArgument | SystemError;
-export {};

package/dist/PlatformRuntime.d.ts

@@ -1,27 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import type * as Fiber from "effect/Fiber";
-export interface Teardown {
-    <E, A>(exit: Exit.Exit<E, A>, onExit: (code: number) => void): void;
-}
-export declare const defaultTeardown: Teardown;
-export interface RunMain {
-    (options?: {
-        readonly disableErrorReporting?: boolean | undefined;
-        readonly disablePrettyLogger?: boolean | undefined;
-        readonly teardown?: Teardown | undefined;
-    }): <E, A>(effect: Effect.Effect<A, E>) => void;
-    <E, A>(effect: Effect.Effect<A, E>, options?: {
-        readonly disableErrorReporting?: boolean | undefined;
-        readonly disablePrettyLogger?: boolean | undefined;
-        readonly teardown?: Teardown | undefined;
-    }): void;
-}
-export declare const makeRunMain: (f: <E, A>(options: {
-    readonly fiber: Fiber.RuntimeFiber<A, E>;
-    readonly teardown: Teardown;
-}) => void) => RunMain;
-/**
- * Are we running within an agent harness, like Claude Code?
- */
-export declare function isAgentHarness(): string | false | undefined;

package/dist/Route.d.ts

@@ -1,97 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Pipeable from "effect/Pipeable";
-import * as Entity from "./Entity.ts";
-import * as RouteBody from "./RouteBody.ts";
-import * as RouteTree from "./RouteTree.ts";
-import type * as Values from "./Values.ts";
-export declare const RouteItems: unique symbol;
-export declare const RouteDescriptor: unique symbol;
-export declare const RouteBindings: unique symbol;
-export declare const TypeId: unique symbol;
-export declare namespace RouteDescriptor {
-    type Any = {
-        [key: string]: unknown;
-    };
-}
-export declare namespace RouteSet {
-    type RouteSet<D extends RouteDescriptor.Any = {}, B = {}, M extends Route.Tuple = []> = Data<D, B, M> & {
-        [TypeId]: typeof TypeId;
-    } & Pipeable.Pipeable & Iterable<M[number]>;
-    type Data<D extends RouteDescriptor.Any = {}, B = {}, M extends Route.Tuple = []> = {
-        [RouteItems]: M;
-        [RouteDescriptor]: D;
-        [RouteBindings]: B;
-    };
-    type Proto = Pipeable.Pipeable & Iterable<Route.Route<any, any, any, any, any>> & {
-        [TypeId]: typeof TypeId;
-    };
-    type Any = RouteSet<{}, {}, Route.Tuple>;
-    type Infer<R> = R extends RouteSet<infer D, infer B, infer I> ? RouteSet<D, B, I> : R;
-    type Items<T extends Data<any, any, any>> = T extends Data<any, any, infer M> ? M : never;
-    type Descriptor<T extends Data<any, any, any>> = T extends Data<infer D, any, any> ? D : never;
-}
-export declare namespace Route {
-    export interface Route<D extends RouteDescriptor.Any = {}, B = {}, A = any, E = never, R = never> extends RouteSet.RouteSet<D, {}, [Route<D, B, A, E, R>]> {
-        readonly handler: Handler<B & D, A, E, R>;
-    }
-    export type With<D extends RouteDescriptor.Any> = Route<any, any, any, any, any> & {
-        [RouteDescriptor]: D;
-    };
-    export type Tuple<_D extends RouteDescriptor.Any = {}> = [...Route<any, any, any, any, any>[]];
-    export type Handler<B, A, E, R> = (context: B, next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<A>) => Effect.Effect<Entity.Entity<A>, E, R>;
-    /**
-     * Extracts only the bindings (B) from routes, excluding descriptors.
-     */
-    export type Bindings<T extends RouteSet.Any, M extends Tuple = RouteSet.Items<T>> = M extends [
-        infer Head,
-        ...infer Tail extends Tuple
-    ] ? Head extends Route<any, infer B, any, any, any> ? ShallowMerge<B, Bindings<T, Tail>> : Bindings<T, Tail> : {};
-    /**
-     * Extracts the full handler context from a RouteSet.
-     * Merges descriptors and bindings from all routes, with later values
-     * taking precedence via ShallowMerge to avoid `never` from conflicting
-     * literal types (e.g. `{ method: "*" } & { method: "GET" }`).
-     */
-    export type Context<T extends RouteSet.Any> = Omit<RouteSet.Descriptor<T>, keyof ExtractContext<RouteSet.Items<T>>> & ExtractContext<RouteSet.Items<T>>;
-    type ExtractContext<M extends Tuple> = M extends [infer Head, ...infer Tail extends Tuple] ? Head extends Route<infer D, infer B, any, any, any> ? ShallowMerge<Omit<D, keyof B> & B, ExtractContext<Tail>> : ExtractContext<Tail> : {};
-    export {};
-}
-export declare function isRouteSet(input: unknown): input is RouteSet.Any;
-export declare function isRoute(input: unknown): input is Route.Route;
-export declare function set<D extends RouteDescriptor.Any = {}, B = {}, I extends Route.Tuple = []>(items?: I, descriptor?: D): RouteSet.RouteSet<D, B, I>;
-export declare function make<D extends RouteDescriptor.Any, B, A, E = never, R = never>(handler: Route.Handler<B & D, A, E, R>, descriptor?: D): Route.Route<D, B, A, E, R>;
-export declare const empty: RouteSet.RouteSet<{}, {}, []>;
-export declare function describe<D extends RouteDescriptor.Any>(descriptor: D): RouteSet.RouteSet<D, {}, never[]>;
-export declare function items<T extends RouteSet.Data<any, any, any>>(self: T): RouteSet.Items<T>;
-export declare function descriptor<T extends RouteSet.Data<any, any, any>>(self: T): T[typeof RouteDescriptor];
-export declare function descriptor<T extends RouteSet.Data<any, any, any>>(self: Iterable<T>): Array<T[typeof RouteDescriptor]>;
-export type ExtractBindings<M extends Route.Tuple> = M extends [
-    infer Head,
-    ...infer Tail extends Route.Tuple
-] ? Head extends Route.Route<any, infer B, any, any, any> ? ShallowMerge<B, ExtractBindings<Tail>> : ExtractBindings<Tail> : {};
-type ShallowMerge<A, B> = Omit<A, keyof B> & {
-    [K in keyof B]: K extends keyof A ? A[K] & B[K] : B[K];
-};
-export type ExtractContext<Items extends Route.Tuple, Descriptor extends RouteDescriptor.Any> = ExtractBindings<Items> & Descriptor;
-export * from "./RouteHook.ts";
-export * from "./RouteSchema.ts";
-export { add, del, get, head, options, patch, post, put, use } from "./RouteMount.ts";
-export declare const text: RouteBody.BuildReturn<string, "text">;
-export declare const html: RouteBody.BuildReturn<string, "html">;
-export declare const json: RouteBody.BuildReturn<Values.Json, "json">;
-export declare const bytes: RouteBody.BuildReturn<Uint8Array<ArrayBufferLike>, "bytes">;
-export { render } from "./RouteBody.ts";
-export { sse } from "./RouteSse.ts";
-export declare function redirect(url: string | URL, options?: {
-    status?: 301 | 302 | 303 | 307 | 308;
-}): Entity.Entity<"">;
-declare const Routes_base: Context.TagClass<Routes, "effect-start/Routes", RouteTree.RouteTree<RouteTree.RouteMap>>;
-export declare class Routes extends Routes_base {
-}
-export declare function layer(routes: RouteTree.RouteMap | RouteTree.RouteTree): Layer.Layer<Routes, never, never>;
-export { make as tree } from "./RouteTree.ts";
-export declare function lazy<T extends RouteSet.Any>(load: () => Promise<{
-    default: T;
-}>): Effect.Effect<T, never, never>;

package/dist/RouteBody.d.ts

@@ -1,47 +0,0 @@
-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>, never>;
-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/RouteError.d.ts

@@ -1,98 +0,0 @@
-import * as Schema from "effect/Schema";
-declare const BadRequest_base: Schema.TaggedErrorClass<BadRequest, "BadRequest", {
-    readonly _tag: Schema.tag<"BadRequest">;
-} & {
-    message: typeof Schema.String;
-}>;
-export declare class BadRequest extends BadRequest_base {
-    static readonly status = 400;
-}
-declare const Unauthorized_base: Schema.TaggedErrorClass<Unauthorized, "Unauthorized", {
-    readonly _tag: Schema.tag<"Unauthorized">;
-} & {
-    message: typeof Schema.String;
-}>;
-export declare class Unauthorized extends Unauthorized_base {
-    static readonly status = 401;
-}
-declare const Forbidden_base: Schema.TaggedErrorClass<Forbidden, "Forbidden", {
-    readonly _tag: Schema.tag<"Forbidden">;
-} & {
-    message: typeof Schema.String;
-}>;
-export declare class Forbidden extends Forbidden_base {
-    static readonly status = 403;
-}
-declare const NotFound_base: Schema.TaggedErrorClass<NotFound, "NotFound", {
-    readonly _tag: Schema.tag<"NotFound">;
-} & {
-    message: typeof Schema.String;
-}>;
-export declare class NotFound extends NotFound_base {
-    static readonly status = 404;
-}
-declare const MethodNotAllowed_base: Schema.TaggedErrorClass<MethodNotAllowed, "MethodNotAllowed", {
-    readonly _tag: Schema.tag<"MethodNotAllowed">;
-} & {
-    message: typeof Schema.String;
-}>;
-export declare class MethodNotAllowed extends MethodNotAllowed_base {
-    static readonly status = 405;
-}
-declare const Conflict_base: Schema.TaggedErrorClass<Conflict, "Conflict", {
-    readonly _tag: Schema.tag<"Conflict">;
-} & {
-    message: typeof Schema.String;
-}>;
-export declare class Conflict extends Conflict_base {
-    static readonly status = 409;
-}
-declare const Gone_base: Schema.TaggedErrorClass<Gone, "Gone", {
-    readonly _tag: Schema.tag<"Gone">;
-} & {
-    message: typeof Schema.String;
-}>;
-export declare class Gone extends Gone_base {
-    static readonly status = 410;
-}
-declare const UnprocessableEntity_base: Schema.TaggedErrorClass<UnprocessableEntity, "UnprocessableEntity", {
-    readonly _tag: Schema.tag<"UnprocessableEntity">;
-} & {
-    message: typeof Schema.String;
-}>;
-export declare class UnprocessableEntity extends UnprocessableEntity_base {
-    static readonly status = 422;
-}
-declare const TooManyRequests_base: Schema.TaggedErrorClass<TooManyRequests, "TooManyRequests", {
-    readonly _tag: Schema.tag<"TooManyRequests">;
-} & {
-    message: typeof Schema.String;
-}>;
-export declare class TooManyRequests extends TooManyRequests_base {
-    static readonly status = 429;
-}
-declare const InternalServerError_base: Schema.TaggedErrorClass<InternalServerError, "InternalServerError", {
-    readonly _tag: Schema.tag<"InternalServerError">;
-} & {
-    message: typeof Schema.String;
-}>;
-export declare class InternalServerError extends InternalServerError_base {
-    static readonly status = 500;
-}
-declare const NotImplemented_base: Schema.TaggedErrorClass<NotImplemented, "NotImplemented", {
-    readonly _tag: Schema.tag<"NotImplemented">;
-} & {
-    message: typeof Schema.String;
-}>;
-export declare class NotImplemented extends NotImplemented_base {
-    static readonly status = 501;
-}
-declare const ServiceUnavailable_base: Schema.TaggedErrorClass<ServiceUnavailable, "ServiceUnavailable", {
-    readonly _tag: Schema.tag<"ServiceUnavailable">;
-} & {
-    message: typeof Schema.String;
-}>;
-export declare class ServiceUnavailable extends ServiceUnavailable_base {
-    static readonly status = 503;
-}
-export {};

package/dist/RouteHook.d.ts

@@ -1,12 +0,0 @@
-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/RouteHttp.d.ts

@@ -1,21 +0,0 @@
-import * as FiberId from "effect/FiberId";
-import * as Runtime from "effect/Runtime";
-import type * as Http from "./Http.ts";
-import * as Route from "./Route.ts";
-import type * as RouteBody from "./RouteBody.ts";
-import type * as RouteMount from "./RouteMount.ts";
-import * as RouteTree from "./RouteTree.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]>;
-export {};

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/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/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>
-]>;

package/dist/RouteSse.d.ts

@@ -1,21 +0,0 @@
-import * as Effect from "effect/Effect";
-import * 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 interface SseEvent {
-    data?: string | undefined;
-    event?: string;
-    retry?: number;
-}
-export type SseTaggedEvent = {
-    readonly _tag: string;
-};
-export type SseEventInput = SseEvent | SseTaggedEvent;
-export type SseHandlerInput<B, E, R> = Stream.Stream<SseEventInput, E, R> | Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R> | ((context: Values.Simplify<B>, next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<string>) => Stream.Stream<SseEventInput, E, R> | Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R> | Generator<Utils.YieldWrap<Effect.Effect<unknown, E, R>>, Stream.Stream<SseEventInput, E, R>, unknown>);
-export declare function sse<D extends Route.RouteDescriptor.Any, B extends {}, I extends Route.Route.Tuple, E = never, R = never>(handler: SseHandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & {
-    format: "text";
-}>, E, R>): (self: Route.RouteSet.RouteSet<D, B, I>) => Route.RouteSet.RouteSet<D, B, [...I, Route.Route.Route<{
-    format: "text";
-}, {}, Stream.Stream<string, E, R>, E, R>]>;

package/dist/RouteTree.d.ts

@@ -1,57 +0,0 @@
-import * as PathPattern from "./PathPattern.ts";
-import * as Route from "./Route.ts";
-import type * as RouteMount from "./RouteMount.ts";
-declare const TypeId: unique symbol;
-declare const RouteTreeRoutes: unique symbol;
-type MethodRoute = Route.Route.With<{
-    method: string;
-}>;
-export type RouteTuple = Iterable<MethodRoute>;
-export type LayerRoute = Iterable<Route.Route.With<{
-    method: "*";
-}>>;
-type LayerKey = "*";
-declare const LayerKey: LayerKey;
-export type InputRouteMap = {
-    [LayerKey]?: LayerRoute;
-} & {
-    [path: PathPattern.PathPattern]: RouteTuple | RouteTree;
-};
-export type RouteMap = {
-    [path: PathPattern.PathPattern]: Route.Route.Tuple;
-};
-export type Routes<T extends RouteTree> = T[typeof RouteTreeRoutes];
-export interface RouteTree<Routes extends RouteMap = RouteMap> {
-    [TypeId]: typeof TypeId;
-    [RouteTreeRoutes]: Routes;
-}
-type PrefixKeys<T, Prefix extends string> = {
-    [K in keyof T as K extends string ? `${Prefix}${K}` : never]: T[K];
-};
-type InferItems<T> = T extends Route.RouteSet.Data<any, any, infer M> ? M : [];
-type LayerItems<T extends InputRouteMap> = "*" extends keyof T ? InferItems<T["*"]> : [];
-type FlattenRouteMap<T extends InputRouteMap> = {
-    [K in Exclude<keyof T, "*"> as T[K] extends RouteTree ? never : K]: [
-        ...LayerItems<T>,
-        ...InferItems<T[K]>
-    ];
-} & UnionToIntersection<FlattenNested<T, Exclude<keyof T, "*">, LayerItems<T>>>;
-type FlattenNested<T, K, L extends Route.Route.Tuple> = K extends keyof T ? T[K] extends RouteTree<infer R> ? PrefixKeys<PrependLayers<R, L>, K & string> : {} : {};
-type PrependLayers<T extends RouteMap, L extends Route.Route.Tuple> = {
-    [K in keyof T]: T[K] extends Route.Route.Tuple ? [...L, ...T[K]] : never;
-};
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-export declare function make<const Routes extends InputRouteMap>(input: Routes): RouteTree<FlattenRouteMap<Routes>>;
-export type WalkDescriptor = {
-    path: PathPattern.PathPattern;
-    method: string;
-} & Route.RouteDescriptor.Any;
-export declare function walk(tree: RouteTree): Generator<RouteMount.MountedRoute>;
-export declare function merge(a: RouteTree, b: RouteTree): RouteTree;
-export declare function isRouteTree(input: unknown): input is RouteTree;
-export interface LookupResult {
-    route: RouteMount.MountedRoute;
-    params: Record<string, string>;
-}
-export declare function lookup(tree: RouteTree, method: string, path: string): LookupResult | null;
-export {};

package/dist/RouteTrie.d.ts

@@ -1,20 +0,0 @@
-import * as Route from "./Route.ts";
-export interface Node {
-    children: Record<string, Node>;
-    paramChild: Node | null;
-    paramName: string | null;
-    requiredWildcardChild: Node | null;
-    requiredWildcardName: string | null;
-    optionalWildcardChild: Node | null;
-    optionalWildcardName: string | null;
-    routes: Array<Route.Route.Route>;
-}
-export interface RouteTrie {
-    readonly methods: Record<string, Node>;
-}
-export interface LookupResult {
-    route: Route.Route.Route;
-    params: Record<string, string>;
-}
-export declare function make(set: Route.RouteSet.Any): RouteTrie;
-export declare function lookup(trie: RouteTrie, method: string, path: string): Array<LookupResult>;