effect-start 0.22.1 → 0.23.0

package/dist/RouteHttp.js

@@ -33,8 +33,8 @@ const mediaTypeToFormat = {
  * 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 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") {
@@ -51,10 +51,11 @@ const respondError = (options) => new Response(JSON.stringify(options, null, 2),
 });
 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 });
+    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);
@@ -80,9 +81,7 @@ function determineSelectedFormat(accept, routes) {
         .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);
+    const mediaTypes = uniqueFormats.map((f) => formatToMediaType[f]).filter(Boolean);
     if (mediaTypes.length === 0) {
         return undefined;
     }
@@ -123,14 +122,18 @@ export const toWebHandlerRuntime = (runtime) => {
             }
             const allRoutes = [...wildcards, ...methodRoutes];
             const selectedFormat = determineSelectedFormat(accept, allRoutes);
-            const hasSpecificFormatRoutes = allRoutes.some((r) => {
+            const specificFormats = new Set();
+            let hasWildcardFormatRoutes = false;
+            for (const r of allRoutes) {
                 const format = Route.descriptor(r).format;
-                return format && format !== "*";
-            });
-            const hasWildcardFormatRoutes = allRoutes.some((r) => Route.descriptor(r).format === "*");
-            if (selectedFormat === undefined
-                && hasSpecificFormatRoutes
-                && !hasWildcardFormatRoutes) {
+                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) => {
@@ -168,18 +171,20 @@ export const toWebHandlerRuntime = (runtime) => {
                 return runNext();
             };
             const effect = Effect.withFiberRuntime((fiber) => {
-                const tracerDisabled = !fiber.getFiberRef(FiberRef.currentTracerEnabled)
-                    || fiber.getFiberRef(RouteHttpTracer.currentTracerDisabledWhen)(request);
+                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 });
+                    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" });
                     }
-                    return yield* toResponse(entity, selectedFormat, runtime);
+                    const response = yield* toResponse(entity, selectedFormat, runtime);
+                    if (varyAccept) {
+                        response.headers.set("vary", "Accept");
+                    }
+                    return response;
                 });
                 if (tracerDisabled) {
                     return innerEffect;

package/dist/RouteMount.d.ts

@@ -1,8 +1,8 @@
-import * as Types from "effect/Types";
-import * as Http from "./Http.ts";
-import * as PathPattern from "./PathPattern.ts";
+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 * as RouteBody from "./RouteBody.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<"*">;
@@ -28,8 +28,7 @@ export declare namespace RouteMount {
     }
     export type EmptySet<M extends Method, B = {}> = Route.RouteSet.RouteSet<{
         method: M;
-    }, B, [
-    ]>;
+    }, 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;
@@ -54,19 +53,13 @@ export declare namespace RouteMount {
         [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, 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>>
-        ]>;
+        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>,
@@ -78,42 +71,15 @@ export declare namespace RouteMount {
         ...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>>
-        ]>;
+        <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 {};
 }

package/dist/RouteMount.js

@@ -10,27 +10,18 @@ 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 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 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,
-    ]);
+    return make([...baseItems, ...newItems]);
 };
 const Proto = Object.assign(Object.create(null), {
     [RouteSetTypeId]: RouteSetTypeId,
@@ -55,9 +46,7 @@ function make(items) {
 }
 function makeMethodDescriber(method) {
     function describeMethod(...fs) {
-        const baseItems = Route.isRouteSet(this)
-            ? Route.items(this)
-            : [];
+        const baseItems = Route.isRouteSet(this) ? Route.items(this) : [];
         const methodSet = Route.set([], { method });
         const f = Function.flow(...fs);
         const result = f(methodSet);
@@ -68,10 +57,7 @@ function makeMethodDescriber(method) {
             const newDescriptor = { method, ...itemDescriptor };
             return Route.make(item.handler, newDescriptor);
         });
-        return make([
-            ...baseItems,
-            ...flattenedItems,
-        ]);
+        return make([...baseItems, ...flattenedItems]);
     }
     return describeMethod;
 }

package/dist/RouteSchema.d.ts

@@ -1,4 +1,4 @@
-import * as ParseResult from "effect/ParseResult";
+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";
@@ -63,3 +63,24 @@ export declare function schemaBodyForm<A, I extends Partial<Record<string, Reado
         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/RouteSchema.js

@@ -1,7 +1,9 @@
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
+import * as Entity from "./Entity.js";
 import * as Http from "./Http.js";
 import * as PathPattern from "./PathPattern.js";
+import * as Route from "./Route.js";
 import * as RouteHook from "./RouteHook.js";
 export const RequestBodyError = (reason, cause) => ({ _tag: "RequestBodyError", reason, cause });
 export const File = Schema.TaggedStruct("File", {
@@ -153,3 +155,34 @@ export function schemaBodyForm(fields) {
         };
     }));
 }
+export function schemaError(schema, options) {
+    const status = options?.status ?? schema.status;
+    if (typeof status !== "number") {
+        throw new Error("schemaError: status is required either via options or as a static property on the schema");
+    }
+    const encode = Schema.encode(schema);
+    const is = Schema.is(schema);
+    return function (self) {
+        const route = Route.make((_context, next) => Entity.resolve(next()).pipe(Effect.catchIf(is, (error) => Effect.map(Effect.orDie(encode(error)), (encoded) => Entity.make(encoded, { status })))));
+        const items = [
+            ...Route.items(self),
+            route,
+        ];
+        return Route.set(items, Route.descriptor(self));
+    };
+}
+export function schemaSuccess(schema) {
+    const encode = Schema.encodeUnknown(schema);
+    return function (self) {
+        const route = Route.make((_context, next) => Effect.flatMap(Entity.resolve(next()), (entity) => Effect.map(encode(entity.body), (encoded) => Entity.make(encoded, {
+            status: entity.status,
+            headers: entity.headers,
+            url: entity.url,
+        }))));
+        const items = [
+            ...Route.items(self),
+            route,
+        ];
+        return Route.set(items, Route.descriptor(self));
+    };
+}

package/dist/RouteSse.js

@@ -8,8 +8,7 @@ import * as StreamExtra from "./StreamExtra.js";
 const HEARTBEAT_INTERVAL = Duration.seconds(5);
 const HEARTBEAT = ": <3\n\n";
 function isTaggedEvent(event) {
-    return Object.hasOwn(event, "_tag")
-        && typeof event["_tag"] === "string";
+    return Object.hasOwn(event, "_tag") && typeof event["_tag"] === "string";
 }
 function formatSseEvent(event) {
     if (isTaggedEvent(event)) {
@@ -60,9 +59,7 @@ export function sse(handler) {
             };
             return Effect.map(getStream(), (eventStream) => {
                 const formattedStream = Stream.map(eventStream, formatSseEvent);
-                const heartbeat = Stream
-                    .repeat(Stream.succeed(HEARTBEAT), Schedule.spaced(HEARTBEAT_INTERVAL))
-                    .pipe(Stream.drop(1));
+                const heartbeat = Stream.repeat(Stream.succeed(HEARTBEAT), Schedule.spaced(HEARTBEAT_INTERVAL)).pipe(Stream.drop(1));
                 const merged = Stream.merge(formattedStream, heartbeat, {
                     haltStrategy: "left",
                 });
@@ -70,16 +67,13 @@ export function sse(handler) {
                     headers: {
                         "content-type": "text/event-stream",
                         "cache-control": "no-cache",
-                        "connection": "keep-alive",
+                        connection: "keep-alive",
                     },
                 });
             });
         };
         const route = Route.make(sseHandler, { format: "text" });
-        const items = [
-            ...Route.items(self),
-            route,
-        ];
+        const items = [...Route.items(self), route];
         return Route.set(items, Route.descriptor(self));
     };
 }

package/dist/RouteTree.d.ts

@@ -1,6 +1,6 @@
 import * as PathPattern from "./PathPattern.ts";
 import * as Route from "./Route.ts";
-import * as RouteMount from "./RouteMount.ts";
+import type * as RouteMount from "./RouteMount.ts";
 declare const TypeId: unique symbol;
 declare const RouteTreeRoutes: unique symbol;
 type MethodRoute = Route.Route.With<{
@@ -47,6 +47,7 @@ export type WalkDescriptor = {
     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;

package/dist/RouteTree.js

@@ -11,27 +11,18 @@ function routes(tree) {
 function sortScore(path) {
     const segments = path.split("/");
     const greedyIdx = segments.findIndex((s) => s.endsWith("*") || s.endsWith("+"));
-    const maxPriority = Math.max(...segments.map((s) => !s.startsWith(":")
-        ? 0
-        : s.endsWith("*")
-            ? 4
-            : s.endsWith("+")
-                ? 3
-                : s.endsWith("?")
-                    ? 2
-                    : 1), 0);
+    const maxPriority = Math.max(...segments.map((s) => !s.startsWith(":") ? 0 : s.endsWith("*") ? 4 : s.endsWith("+") ? 3 : s.endsWith("?") ? 2 : 1), 0);
     return greedyIdx === -1
-        // non-greedy: sort by depth, then by max segment priority
-        ? (segments.length << 16) + (maxPriority << 8)
-        // greedy: sort after non-greedy, by greedy position (later = first), then priority
-        : (1 << 24) + ((16 - greedyIdx) << 16) + (maxPriority << 8);
+        ? // non-greedy: sort by depth, then by max segment priority
+            (segments.length << 16) + (maxPriority << 8)
+        : // greedy: sort after non-greedy, by greedy position (later = first), then priority
+            (1 << 24) + ((16 - greedyIdx) << 16) + (maxPriority << 8);
 }
 function sortRoutes(input) {
     const keys = Object.keys(input).sort((a, b) => sortScore(a) - sortScore(b) || a.localeCompare(b));
     const sorted = {};
     for (const key of keys) {
-        sorted[key] =
-            input[key];
+        sorted[key] = input[key];
     }
     return sorted;
 }
@@ -74,6 +65,17 @@ export function* walk(tree) {
         yield* flattenRoutes(path, _routes[path]);
     }
 }
+export function merge(a, b) {
+    const combined = { ...routes(a) };
+    for (const [path, items] of Object.entries(routes(b))) {
+        const key = path;
+        combined[key] = combined[key] ? [...combined[key], ...items] : items;
+    }
+    return {
+        [TypeId]: TypeId,
+        [RouteTreeRoutes]: sortRoutes(combined),
+    };
+}
 export function isRouteTree(input) {
     return Predicate.hasProperty(input, TypeId);
 }

package/dist/RouteTrie.d.ts

@@ -7,7 +7,7 @@ export interface Node {
     requiredWildcardName: string | null;
     optionalWildcardChild: Node | null;
     optionalWildcardName: string | null;
-    routes: Route.Route.Route[];
+    routes: Array<Route.Route.Route>;
 }
 export interface RouteTrie {
     readonly methods: Record<string, Node>;
@@ -17,4 +17,4 @@ export interface LookupResult {
     params: Record<string, string>;
 }
 export declare function make(set: Route.RouteSet.Any): RouteTrie;
-export declare function lookup(trie: RouteTrie, method: string, path: string): LookupResult[];
+export declare function lookup(trie: RouteTrie, method: string, path: string): Array<LookupResult>;

package/dist/RouteTrie.js

@@ -62,9 +62,7 @@ function collectRoutes(items, parentPath, parentMethod) {
     const results = [];
     for (const item of items) {
         const desc = Route.descriptor(item);
-        const currentPath = typeof desc?.path === "string"
-            ? parentPath + desc.path
-            : parentPath;
+        const currentPath = typeof desc?.path === "string" ? parentPath + desc.path : parentPath;
         const currentMethod = desc?.method ?? parentMethod;
         if (Route.isRoute(item)) {
             if (currentPath !== "") {
@@ -103,8 +101,7 @@ function lookupNode(node, segments, params) {
         for (const route of node.routes) {
             results.push({ route, params });
         }
-        if (node.optionalWildcardChild
-            && node.optionalWildcardChild.optionalWildcardName) {
+        if (node.optionalWildcardChild && node.optionalWildcardChild.optionalWildcardName) {
             for (const route of node.optionalWildcardChild.routes) {
                 results.push({ route, params });
             }
@@ -120,8 +117,7 @@ function lookupNode(node, segments, params) {
         const newParams = { ...params, [node.paramChild.paramName]: segment };
         results.push(...lookupNode(node.paramChild, rest, newParams));
     }
-    if (node.requiredWildcardChild
-        && node.requiredWildcardChild.requiredWildcardName) {
+    if (node.requiredWildcardChild && node.requiredWildcardChild.requiredWildcardName) {
         const wildcardValue = segments.join("/");
         const newParams = {
             ...params,
@@ -131,8 +127,7 @@ function lookupNode(node, segments, params) {
             results.push({ route, params: newParams });
         }
     }
-    if (node.optionalWildcardChild
-        && node.optionalWildcardChild.optionalWildcardName) {
+    if (node.optionalWildcardChild && node.optionalWildcardChild.optionalWildcardName) {
         const wildcardValue = segments.join("/");
         const newParams = {
             ...params,

package/dist/SchemaExtra.d.ts

@@ -1,4 +1,4 @@
-import * as Schema from "effect/Schema";
+import type * as Schema from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 export declare function getBaseSchemaAST(schema: Schema.Schema.Any): SchemaAST.AST;
 export declare function isOptional(schema: Schema.Schema.Any): boolean;

package/dist/Socket.d.ts

@@ -0,0 +1,27 @@
+export declare const SocketErrorTypeId: unique symbol;
+export type SocketErrorTypeId = typeof SocketErrorTypeId;
+export declare const isSocketError: (u: unknown) => u is SocketError;
+export type SocketError = SocketGenericError | SocketCloseError;
+declare const SocketGenericError_base: new <A extends Record<string, any>>(args: import("effect/Types").Simplify<A>) => import("effect/Cause").YieldableError & Record<typeof SocketErrorTypeId, typeof SocketErrorTypeId> & {
+    readonly _tag: "SocketError";
+} & Readonly<A>;
+export declare class SocketGenericError extends SocketGenericError_base<{
+    readonly reason: "Write" | "Read" | "Open" | "OpenTimeout";
+    readonly cause: unknown;
+}> {
+    get message(): string;
+}
+declare const SocketCloseError_base: new <A extends Record<string, any>>(args: import("effect/Types").Simplify<A>) => import("effect/Cause").YieldableError & Record<typeof SocketErrorTypeId, typeof SocketErrorTypeId> & {
+    readonly _tag: "SocketError";
+} & Readonly<A>;
+export declare class SocketCloseError extends SocketCloseError_base<{
+    readonly reason: "Close";
+    readonly code: number;
+    readonly closeReason?: string | undefined;
+}> {
+    static is(u: unknown): u is SocketCloseError;
+    static isClean(isClean: (code: number) => boolean): (u: unknown) => u is SocketCloseError;
+    get message(): string;
+}
+export declare const defaultCloseCodeIsError: (code: number) => boolean;
+export {};

package/dist/Socket.js

@@ -1,37 +1,29 @@
 /*
  * Adapted from @effect/platform
  */
-import * as Predicate from "effect/Predicate"
-import * as PlatformError from "./PlatformError.js"
-
-export const SocketErrorTypeId = Symbol.for("@effect/platform/Socket/SocketError")
-
-export const isSocketError = (u) =>
-  Predicate.hasProperty(u, SocketErrorTypeId)
-
+import * as Predicate from "effect/Predicate";
+import * as PlatformError from "./PlatformError.js";
+export const SocketErrorTypeId = Symbol.for("@effect/platform/Socket/SocketError");
+export const isSocketError = (u) => Predicate.hasProperty(u, SocketErrorTypeId);
 export class SocketGenericError extends PlatformError.TypeIdError(SocketErrorTypeId, "SocketError") {
-  get message() {
-    return `An error occurred during ${this.reason}`
-  }
+    get message() {
+        return `An error occurred during ${this.reason}`;
+    }
 }
-
 export class SocketCloseError extends PlatformError.TypeIdError(SocketErrorTypeId, "SocketError") {
-  static is(u) {
-    return isSocketError(u) && u.reason === "Close"
-  }
-
-  static isClean(isClean) {
-    return function(u) {
-      return SocketCloseError.is(u) && isClean(u.code)
+    static is(u) {
+        return isSocketError(u) && u.reason === "Close";
+    }
+    static isClean(isClean) {
+        return function (u) {
+            return SocketCloseError.is(u) && isClean(u.code);
+        };
     }
-  }
-
-  get message() {
-    if (this.closeReason) {
-      return `${this.reason}: ${this.code}: ${this.closeReason}`
+    get message() {
+        if (this.closeReason) {
+            return `${this.reason}: ${this.code}: ${this.closeReason}`;
+        }
+        return `${this.reason}: ${this.code}`;
     }
-    return `${this.reason}: ${this.code}`
-  }
 }
-
-export const defaultCloseCodeIsError = (code) => code !== 1000 && code !== 1006
+export const defaultCloseCodeIsError = (code) => code !== 1000 && code !== 1006;

package/dist/Sql.d.ts

@@ -0,0 +1,34 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+declare const SqlError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SqlError";
+} & Readonly<A>;
+export declare class SqlError extends SqlError_base<{
+    readonly code: string;
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+export interface SqlQuery {
+    <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>): Effect.Effect<ReadonlyArray<T>, SqlError>;
+    readonly unsafe: <T = any>(query: string, values?: Array<unknown>) => Effect.Effect<ReadonlyArray<T>, SqlError>;
+    readonly values: {
+        <T extends Record<string, unknown>>(obj: T | ReadonlyArray<T>): SqlHelper<T>;
+        <T extends Record<string, unknown>, K extends keyof T>(obj: T | ReadonlyArray<T>, ...columns: [K, ...Array<K>]): SqlHelper<Pick<T, K>>;
+    };
+}
+export interface SqlClient extends SqlQuery {
+    readonly withTransaction: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, SqlError | E, R>;
+    readonly reserve: Effect.Effect<SqlQuery, SqlError, Scope.Scope>;
+    readonly close: (options?: {
+        readonly timeout?: number;
+    }) => Effect.Effect<void, SqlError>;
+    readonly use: <T>(fn: (driver: any) => Promise<T> | T) => Effect.Effect<T, SqlError>;
+}
+export interface SqlHelper<T> {
+    readonly value: ReadonlyArray<T>;
+    readonly columns: ReadonlyArray<keyof T>;
+}
+export declare const SqlClient: Context.Tag<SqlClient, SqlClient>;
+export {};

package/dist/Sql.js

@@ -0,0 +1,5 @@
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+export class SqlError extends Data.TaggedError("SqlError") {
+}
+export const SqlClient = Context.GenericTag("effect-start/Sql/SqlClient");