effect-start 0.23.1 → 0.26.0

package/dist/PlatformRuntime.js

@@ -1,46 +0,0 @@
-import * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as FiberRef from "effect/FiberRef";
-import * as FiberRefs from "effect/FiberRefs";
-import * as Function from "effect/Function";
-import * as HashSet from "effect/HashSet";
-import * as Logger from "effect/Logger";
-export const defaultTeardown = (exit, onExit) => {
-    onExit(Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause) ? 1 : 0);
-};
-const addPrettyLogger = (refs, fiberId) => {
-    const loggers = FiberRefs.getOrDefault(refs, FiberRef.currentLoggers);
-    if (!HashSet.has(loggers, Logger.defaultLogger)) {
-        return refs;
-    }
-    return FiberRefs.updateAs(refs, {
-        fiberId,
-        fiberRef: FiberRef.currentLoggers,
-        value: loggers.pipe(HashSet.remove(Logger.defaultLogger), HashSet.add(Logger.prettyLoggerDefault)),
-    });
-};
-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,
-        })
-        : Effect.runFork(Effect.tapErrorCause(effect, (cause) => {
-            if (Cause.isInterruptedOnly(cause)) {
-                return Effect.void;
-            }
-            return Effect.logError(cause);
-        }), {
-            updateRefs: options?.disablePrettyLogger === true ? undefined : addPrettyLogger,
-        });
-    const teardown = options?.teardown ?? defaultTeardown;
-    return f({ fiber, teardown });
-});
-/**
- * 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));
-}

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/Route.js

@@ -1,100 +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 Predicate from "effect/Predicate";
-import * as Entity from "./Entity.js";
-import * as RouteBody from "./RouteBody.js";
-import * as RouteTree from "./RouteTree.js";
-export const RouteItems = Symbol();
-export const RouteDescriptor = Symbol();
-// only for structural type matching
-export const RouteBindings = Symbol();
-export const TypeId = Symbol.for("effect-start/RouteSet");
-const Proto = {
-    [TypeId]: TypeId,
-    pipe() {
-        return Pipeable.pipeArguments(this, arguments);
-    },
-    *[Symbol.iterator]() {
-        yield* items(this);
-    },
-};
-export function isRouteSet(input) {
-    return Predicate.hasProperty(input, TypeId);
-}
-export function isRoute(input) {
-    return isRouteSet(input) && Predicate.hasProperty(input, "handler");
-}
-export function set(items = [], descriptor = {}) {
-    return Object.assign(Object.create(Proto), {
-        [RouteItems]: items,
-        [RouteDescriptor]: descriptor,
-    });
-}
-export function make(handler, descriptor) {
-    const items = [];
-    const route = Object.assign(Object.create(Proto), {
-        [RouteItems]: items,
-        [RouteDescriptor]: descriptor,
-        handler,
-    });
-    items.push(route);
-    return route;
-}
-export const empty = set();
-export function describe(descriptor) {
-    return set([], descriptor);
-}
-export function items(self) {
-    return self[RouteItems];
-}
-export function descriptor(self) {
-    if (RouteDescriptor in self) {
-        return self[RouteDescriptor];
-    }
-    return [...self].map((r) => r[RouteDescriptor]);
-}
-export * from "./RouteHook.js";
-export * from "./RouteSchema.js";
-export { add, del, get, head, options, patch, post, put, use } from "./RouteMount.js";
-export const text = RouteBody.build({
-    format: "text",
-});
-export const html = RouteBody.build({
-    format: "html",
-});
-export const json = RouteBody.build({
-    format: "json",
-});
-export const bytes = RouteBody.build({
-    format: "bytes",
-});
-export { render } from "./RouteBody.js";
-export { sse } from "./RouteSse.js";
-export function redirect(url, options) {
-    return Entity.make("", {
-        status: options?.status ?? 302,
-        headers: {
-            location: url instanceof URL ? url.href : url,
-        },
-    });
-}
-export class Routes extends Context.Tag("effect-start/Routes")() {
-}
-export function layer(routes) {
-    return Layer.sync(Routes, () => (RouteTree.isRouteTree(routes) ? routes : RouteTree.make(routes)));
-}
-export { make as tree } from "./RouteTree.js";
-export function lazy(load) {
-    let cached;
-    return Effect.suspend(() => {
-        if (cached !== undefined) {
-            return Effect.succeed(cached);
-        }
-        return Effect.promise(load).pipe(Effect.map((mod) => {
-            cached = mod.default;
-            return cached;
-        }));
-    });
-}

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/RouteBody.js

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

package/dist/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/RouteError.js

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

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

package/dist/RouteHttp.d.ts

@@ -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 {};