effect-start 0.22.0 → 0.23.0

package/dist/PathPattern.d.ts

@@ -15,7 +15,7 @@ export type Params<T extends string> = string extends T ? Record<string, string>
 } : {};
 export type ValidateResult = {
     ok: true;
-    segments: string[];
+    segments: Array<string>;
 } | {
     ok: false;
     error: string;
@@ -33,7 +33,7 @@ export declare function toRegex(path: string): RegExp;
  * - `:param+` → `/*param`
  * - `:param*` → `/`, `/*param`
  */
-export declare function toExpress(path: string): string[];
+export declare function toExpress(path: string): Array<string>;
 /**
  * Converts to URLPattern path pattern.
  *
@@ -44,7 +44,7 @@ export declare function toExpress(path: string): string[];
  * - `:param+` → `:param+`
  * - `:param*` → `:param*`
  */
-export declare function toURLPattern(path: string): string[];
+export declare function toURLPattern(path: string): Array<string>;
 /**
  * Converts to React Router path pattern.
  *
@@ -55,7 +55,7 @@ export declare function toURLPattern(path: string): string[];
  * - `:param+` → `*` (splat, required)
  * - `:param*` → `/`, `/*` (splat, optional - two routes)
  */
-export declare function toReactRouter(path: string): string[];
+export declare function toReactRouter(path: string): Array<string>;
 /**
  * Alias for toReactRouter.
  *
@@ -104,7 +104,7 @@ export declare function toTanStack(path: string): string;
  * - `:param+` → `*` (unnamed, required)
  * - `:param*` → `/`, `/*` (unnamed, optional - two routes)
  */
-export declare function toHono(path: string): string[];
+export declare function toHono(path: string): Array<string>;
 /**
  * Converts to Effect HttpRouter / find-my-way path pattern.
  *
@@ -117,7 +117,7 @@ export declare function toHono(path: string): string[];
  * - `:param+` → `*` (unnamed)
  * - `:param*` → `/`, `/*` (two routes)
  */
-export declare function toEffect(path: string): string[];
+export declare function toEffect(path: string): Array<string>;
 /**
  * Converts to Bun.serve path pattern.
  *
@@ -131,4 +131,4 @@ export declare function toEffect(path: string): string[];
  * - `:param+` → `/*`
  * - `:param*` → `/`, `/*` (two routes)
  */
-export declare function toBun(path: string): PathPattern[];
+export declare function toBun(path: string): Array<PathPattern>;

package/dist/PathPattern.js

@@ -406,9 +406,7 @@ export function toBun(path) {
     const basePath = beforePath ? `/${beforePath}` : "/";
     const optionalModifier = getModifier(optional);
     const optionalName = getParamName(optional);
-    const requiredOptional = optionalModifier === "*"
-        ? `:${optionalName}+`
-        : `:${optionalName}`;
+    const requiredOptional = optionalModifier === "*" ? `:${optionalName}+` : `:${optionalName}`;
     const withOptionalSegments = [...before, requiredOptional, ...after];
     const withOptionalPath = `/${withOptionalSegments.map(formatSegment).join("/")}`;
     return [...toBun(basePath), ...toBun(withOptionalPath)];

package/dist/PlatformError.d.ts

@@ -1,46 +1,38 @@
 import type * as Cause from "effect/Cause";
-import * as Schema from "effect/Schema";
 import type * as Types from "effect/Types";
-import { TypeId as TypeId_ } from "@effect/platform/Error";
-export declare const TypeId: typeof TypeId_;
+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> & {
+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 const Module: Schema.Literal<["Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal"]>;
-declare const BadArgument_base: Schema.TaggedErrorClass<BadArgument, "BadArgument", {
-    readonly _tag: Schema.tag<"BadArgument">;
-} & {
-    module: Schema.Literal<["Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal"]>;
-    method: typeof Schema.String;
-    description: Schema.optional<typeof Schema.String>;
-    cause: Schema.optional<typeof Schema.Defect>;
-}>;
-export declare class BadArgument extends BadArgument_base {
+export declare class BadArgument extends BadArgument_base<{
+    module: string;
+    method: string;
+    description?: string | undefined;
+    cause?: unknown;
+}> {
     readonly [TypeId]: typeof TypeId;
     get message(): string;
 }
-export declare const SystemErrorReason: Schema.Literal<["AlreadyExists", "BadResource", "Busy", "InvalidData", "NotFound", "PermissionDenied", "TimedOut", "UnexpectedEof", "Unknown", "WouldBlock", "WriteZero"]>;
-export type SystemErrorReason = typeof SystemErrorReason.Type;
-declare const SystemError_base: Schema.TaggedErrorClass<SystemError, "SystemError", {
-    readonly _tag: Schema.tag<"SystemError">;
-} & {
-    reason: Schema.Literal<["AlreadyExists", "BadResource", "Busy", "InvalidData", "NotFound", "PermissionDenied", "TimedOut", "UnexpectedEof", "Unknown", "WouldBlock", "WriteZero"]>;
-    module: Schema.Literal<["Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal"]>;
-    method: typeof Schema.String;
-    description: Schema.optional<typeof Schema.String>;
-    syscall: Schema.optional<typeof Schema.String>;
-    pathOrDescriptor: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
-    cause: Schema.optional<typeof Schema.Defect>;
-}>;
-export declare class SystemError extends SystemError_base {
+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 declare const PlatformError: Schema.Union<[
-    typeof BadArgument,
-    typeof SystemError
-]>;
 export {};

package/dist/PlatformError.js

@@ -1,8 +1,6 @@
 import * as Data from "effect/Data";
 import * as Predicate from "effect/Predicate";
-import * as Schema from "effect/Schema";
-import { TypeId as TypeId_ } from "@effect/platform/Error";
-export const TypeId = TypeId_;
+export const TypeId = Symbol.for("@effect/platform/Error/PlatformError");
 export const isPlatformError = (u) => Predicate.hasProperty(u, TypeId);
 export const TypeIdError = (typeId, tag) => {
     class Base extends Data.Error {
@@ -13,31 +11,15 @@ export const TypeIdError = (typeId, tag) => {
     Base.prototype.name = tag;
     return Base;
 };
-export const Module = Schema.Literal("Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal");
-export class BadArgument extends Schema.TaggedError("@effect/platform/Error/BadArgument")("BadArgument", {
-    module: Module,
-    method: Schema.String,
-    description: Schema.optional(Schema.String),
-    cause: Schema.optional(Schema.Defect),
-}) {
+export class BadArgument extends Data.TaggedError("BadArgument") {
     [TypeId] = TypeId;
     get message() {
         return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`;
     }
 }
-export const SystemErrorReason = Schema.Literal("AlreadyExists", "BadResource", "Busy", "InvalidData", "NotFound", "PermissionDenied", "TimedOut", "UnexpectedEof", "Unknown", "WouldBlock", "WriteZero");
-export class SystemError extends Schema.TaggedError("@effect/platform/Error/SystemError")("SystemError", {
-    reason: SystemErrorReason,
-    module: Module,
-    method: Schema.String,
-    description: Schema.optional(Schema.String),
-    syscall: Schema.optional(Schema.String),
-    pathOrDescriptor: Schema.optional(Schema.Union(Schema.String, Schema.Number)),
-    cause: Schema.optional(Schema.Defect),
-}) {
+export class SystemError extends Data.TaggedError("SystemError") {
     [TypeId] = TypeId;
     get message() {
         return `${this.reason}: ${this.module}.${this.method}${this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : ""}${this.description ? `: ${this.description}` : ""}`;
     }
 }
-export const PlatformError = Schema.Union(BadArgument, SystemError);

package/dist/PlatformRuntime.js

@@ -23,9 +23,7 @@ const addPrettyLogger = (refs, fiberId) => {
 export const makeRunMain = (f) => Function.dual((args) => Effect.isEffect(args[0]), (effect, options) => {
     const fiber = options?.disableErrorReporting === true
         ? Effect.runFork(effect, {
-            updateRefs: options?.disablePrettyLogger === true
-                ? undefined
-                : addPrettyLogger,
+            updateRefs: options?.disablePrettyLogger === true ? undefined : addPrettyLogger,
         })
         : Effect.runFork(Effect.tapErrorCause(effect, (cause) => {
             if (Cause.isInterruptedOnly(cause)) {
@@ -33,9 +31,7 @@ export const makeRunMain = (f) => Function.dual((args) => Effect.isEffect(args[0
             }
             return Effect.logError(cause);
         }), {
-            updateRefs: options?.disablePrettyLogger === true
-                ? undefined
-                : addPrettyLogger,
+            updateRefs: options?.disablePrettyLogger === true ? undefined : addPrettyLogger,
         });
     const teardown = options?.teardown ?? defaultTeardown;
     return f({ fiber, teardown });
@@ -44,8 +40,7 @@ export const makeRunMain = (f) => Function.dual((args) => Effect.isEffect(args[0
  * Are we running within an agent harness, like Claude Code?
  */
 export function isAgentHarness() {
-    return typeof process !== "undefined"
-        && !process.stdout.isTTY
-        && (process.env.CLAUDECODE
-            || process.env.CURSOR_AGENT);
+    return (typeof process !== "undefined" &&
+        !process.stdout.isTTY &&
+        (process.env.CLAUDECODE || process.env.CURSOR_AGENT));
 }

package/dist/Route.d.ts

@@ -5,7 +5,7 @@ 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 * as Values from "./Values.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;
@@ -33,17 +33,13 @@ export declare namespace RouteSet {
     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>
-    ]> {
+    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 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.
@@ -51,7 +47,7 @@ export declare namespace Route {
     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>) : {};
+    ] ? 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
@@ -59,10 +55,7 @@ export declare namespace Route {
      * 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>) : {};
+    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;
@@ -73,30 +66,32 @@ 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>): 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>) : {};
+] ? 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 { 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, status?: 301 | 302 | 303 | 307 | 308): Entity.Entity<"">;
+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 { 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/Route.js

@@ -24,8 +24,7 @@ export function isRouteSet(input) {
     return Predicate.hasProperty(input, TypeId);
 }
 export function isRoute(input) {
-    return isRouteSet(input)
-        && Predicate.hasProperty(input, "handler");
+    return isRouteSet(input) && Predicate.hasProperty(input, "handler");
 }
 export function set(items = [], descriptor = {}) {
     return Object.assign(Object.create(Proto), {
@@ -58,7 +57,7 @@ export function descriptor(self) {
 }
 export * from "./RouteHook.js";
 export * from "./RouteSchema.js";
-export { add, del, get, head, options, patch, post, put, use, } from "./RouteMount.js";
+export { add, del, get, head, options, patch, post, put, use } from "./RouteMount.js";
 export const text = RouteBody.build({
     format: "text",
 });
@@ -71,11 +70,11 @@ export const json = RouteBody.build({
 export const bytes = RouteBody.build({
     format: "bytes",
 });
-export { render, } from "./RouteBody.js";
-export { sse, } from "./RouteSse.js";
-export function redirect(url, status = 302) {
+export { render } from "./RouteBody.js";
+export { sse } from "./RouteSse.js";
+export function redirect(url, options) {
     return Entity.make("", {
-        status,
+        status: options?.status ?? 302,
         headers: {
             location: url instanceof URL ? url.href : url,
         },
@@ -84,11 +83,9 @@ export function redirect(url, status = 302) {
 export class Routes extends Context.Tag("effect-start/Routes")() {
 }
 export function layer(routes) {
-    return Layer.sync(Routes, () => RouteTree.isRouteTree(routes)
-        ? routes
-        : RouteTree.make(routes));
+    return Layer.sync(Routes, () => (RouteTree.isRouteTree(routes) ? routes : RouteTree.make(routes)));
 }
-export { make as tree, } from "./RouteTree.js";
+export { make as tree } from "./RouteTree.js";
 export function lazy(load) {
     let cached;
     return Effect.suspend(() => {

package/dist/RouteBody.d.ts

@@ -23,12 +23,9 @@ 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>, 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>
-    ]>;
+    }>, 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;
@@ -44,10 +41,7 @@ export declare function render<D extends Route.RouteDescriptor.Any, B extends {}
 ]>;
 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>
-]>;
+}>, 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

@@ -35,7 +35,7 @@ function normalizeToEntity(value) {
     return Entity.make(value, { status: 200 });
 }
 export function build(descriptors) {
-    return (function (handler) {
+    return function (handler) {
         return function (self) {
             const contentType = formatToContentType[descriptors.format];
             const baseHandler = handle(handler);
@@ -53,7 +53,7 @@ export function build(descriptors) {
             ];
             return Route.set(items, Route.descriptor(self));
         };
-    });
+    };
 }
 export function render(handler) {
     return function (self) {

package/dist/RouteError.d.ts

@@ -0,0 +1,98 @@
+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/RouteError.js

@@ -0,0 +1,55 @@
+import * as Schema from "effect/Schema";
+export class BadRequest extends Schema.TaggedError()("BadRequest", {
+    message: Schema.String,
+}) {
+    static status = 400;
+}
+export class Unauthorized extends Schema.TaggedError()("Unauthorized", {
+    message: Schema.String,
+}) {
+    static status = 401;
+}
+export class Forbidden extends Schema.TaggedError()("Forbidden", {
+    message: Schema.String,
+}) {
+    static status = 403;
+}
+export class NotFound extends Schema.TaggedError()("NotFound", {
+    message: Schema.String,
+}) {
+    static status = 404;
+}
+export class MethodNotAllowed extends Schema.TaggedError()("MethodNotAllowed", {
+    message: Schema.String,
+}) {
+    static status = 405;
+}
+export class Conflict extends Schema.TaggedError()("Conflict", {
+    message: Schema.String,
+}) {
+    static status = 409;
+}
+export class Gone extends Schema.TaggedError()("Gone", {
+    message: Schema.String,
+}) {
+    static status = 410;
+}
+export class UnprocessableEntity extends Schema.TaggedError()("UnprocessableEntity", { message: Schema.String }) {
+    static status = 422;
+}
+export class TooManyRequests extends Schema.TaggedError()("TooManyRequests", {
+    message: Schema.String,
+}) {
+    static status = 429;
+}
+export class InternalServerError extends Schema.TaggedError()("InternalServerError", { message: Schema.String }) {
+    static status = 500;
+}
+export class NotImplemented extends Schema.TaggedError()("NotImplemented", {
+    message: Schema.String,
+}) {
+    static status = 501;
+}
+export class ServiceUnavailable extends Schema.TaggedError()("ServiceUnavailable", { message: Schema.String }) {
+    static status = 503;
+}

package/dist/RouteHook.js

@@ -6,22 +6,17 @@ export function filter(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;
+            const mergedContext = filterResult ? { ...context, ...filterResult.context } : context;
             return yield* Entity.resolve(next(mergedContext));
         }));
-        return Route.set([
-            ...Route.items(self),
-            route,
-        ], Route.descriptor(self));
+        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");
+    return (typeof value === "object" &&
+        value !== null &&
+        Symbol.iterator in value &&
+        typeof value.next === "function");
 }
 function normalizeFilterHandler(handler) {
     if (typeof handler === "function") {

package/dist/RouteHttp.d.ts

@@ -1,9 +1,9 @@
 import * as FiberId from "effect/FiberId";
 import * as Runtime from "effect/Runtime";
-import * as Http from "./Http.ts";
+import type * as Http from "./Http.ts";
 import * as Route from "./Route.ts";
-import * as RouteBody from "./RouteBody.ts";
-import * as RouteMount from "./RouteMount.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;