effect-start 0.17.0 → 0.17.2

package/dist/PathPattern.js

@@ -0,0 +1,415 @@
+function isValidSegment(segment) {
+    if (segment.startsWith(":")) {
+        const rest = segment.slice(1);
+        if (rest.endsWith("*") || rest.endsWith("+") || rest.endsWith("?")) {
+            const name = rest.slice(0, -1);
+            return name !== "" && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name);
+        }
+        return rest !== "" && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(rest);
+    }
+    return /^[\p{L}\p{N}._~-]+$/u.test(segment);
+}
+export function validate(path) {
+    const segments = path.split("/").filter(Boolean);
+    for (const segment of segments) {
+        if (!isValidSegment(segment)) {
+            return {
+                ok: false,
+                error: `Invalid segment "${segment}" in "${path}"`,
+            };
+        }
+    }
+    return { ok: true, segments };
+}
+export function match(pattern, path) {
+    const patternSegments = pattern.split("/").filter(Boolean);
+    const pathSegments = path.split("/").filter(Boolean);
+    const params = {};
+    let patternIndex = 0;
+    let pathIndex = 0;
+    while (patternIndex < patternSegments.length) {
+        const seg = patternSegments[patternIndex];
+        if (seg.startsWith(":")) {
+            const rest = seg.slice(1);
+            if (rest.endsWith("+")) {
+                const name = rest.slice(0, -1);
+                const remaining = pathSegments.slice(pathIndex);
+                if (remaining.length === 0) {
+                    return null;
+                }
+                params[name] = remaining.join("/");
+                return params;
+            }
+            if (rest.endsWith("*")) {
+                const name = rest.slice(0, -1);
+                const remaining = pathSegments.slice(pathIndex);
+                if (remaining.length > 0) {
+                    params[name] = remaining.join("/");
+                }
+                return params;
+            }
+            if (rest.endsWith("?")) {
+                const name = rest.slice(0, -1);
+                if (pathIndex < pathSegments.length) {
+                    params[name] = pathSegments[pathIndex];
+                    pathIndex++;
+                }
+                patternIndex++;
+                continue;
+            }
+            if (pathIndex >= pathSegments.length) {
+                return null;
+            }
+            params[rest] = pathSegments[pathIndex];
+            pathIndex++;
+            patternIndex++;
+            continue;
+        }
+        if (pathIndex >= pathSegments.length) {
+            return null;
+        }
+        if (seg !== pathSegments[pathIndex]) {
+            return null;
+        }
+        pathIndex++;
+        patternIndex++;
+    }
+    if (pathIndex !== pathSegments.length) {
+        return null;
+    }
+    return params;
+}
+export function toRegex(path) {
+    const result = path
+        .replace(/\/+(\/|$)/g, "$1")
+        .replace(/\./g, "\\.")
+        .replace(/(\/?):(\w+)\+/g, "($1(?<$2>*))")
+        .replace(/(\/?):(\w+)\*/g, "(?:\\/(?<$2>.*))?")
+        .replace(/(\/?):(\w+)/g, "($1(?<$2>[^$1/]+?))")
+        .replace(/(\/?)\*/g, "($1.*)?");
+    return new RegExp(`^${result}/*$`);
+}
+function getModifier(seg) {
+    const last = seg[seg.length - 1];
+    if (last === "?" || last === "*" || last === "+")
+        return last;
+    return "";
+}
+function getParamName(seg) {
+    const modifier = getModifier(seg);
+    return modifier ? seg.slice(1, -1) : seg.slice(1);
+}
+/**
+ * Converts to Express path pattern.
+ *
+ * @see https://expressjs.com/en/guide/routing.html
+ *
+ * - `:param` → `:param`
+ * - `:param?` → `{/:param}`
+ * - `:param+` → `/*param`
+ * - `:param*` → `/`, `/*param`
+ */
+export function toExpress(path) {
+    const segments = path.split("/").filter(Boolean);
+    const optionalWildcardIndex = segments.findIndex((s) => s.startsWith(":") && s.endsWith("*"));
+    if (optionalWildcardIndex !== -1) {
+        const before = segments.slice(0, optionalWildcardIndex);
+        const rest = segments[optionalWildcardIndex];
+        const name = getParamName(rest);
+        const beforeJoined = before
+            .map((s) => (s.startsWith(":") ? `:${getParamName(s)}` : s))
+            .join("/");
+        const basePath = beforeJoined ? "/" + beforeJoined : "/";
+        const withWildcard = basePath === "/" ? `/*${name}` : basePath + `/*${name}`;
+        return [basePath, withWildcard];
+    }
+    let result = "";
+    for (const seg of segments) {
+        if (!seg.startsWith(":")) {
+            result += "/" + seg;
+        }
+        else {
+            const name = getParamName(seg);
+            const modifier = getModifier(seg);
+            switch (modifier) {
+                case "":
+                    result += `/:${name}`;
+                    break;
+                case "?":
+                    result += `{/:${name}}`;
+                    break;
+                case "+":
+                    result += `/*${name}`;
+                    break;
+                case "*":
+                    result += `/*${name}`;
+                    break;
+            }
+        }
+    }
+    return [result || "/"];
+}
+/**
+ * Converts to URLPattern path pattern.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/URL_Pattern_API
+ *
+ * - `:param` → `:param`
+ * - `:param?` → `:param?`
+ * - `:param+` → `:param+`
+ * - `:param*` → `:param*`
+ */
+export function toURLPattern(path) {
+    const segments = path.split("/").filter(Boolean);
+    const joined = segments
+        .map((seg) => {
+        if (!seg.startsWith(":"))
+            return seg;
+        const name = getParamName(seg);
+        const modifier = getModifier(seg);
+        return `:${name}${modifier}`;
+    })
+        .join("/");
+    return [joined ? "/" + joined : "/"];
+}
+/**
+ * Converts to React Router path pattern.
+ *
+ * @see https://reactrouter.com/start/framework/routing
+ *
+ * - `:param` → `:param`
+ * - `:param?` → `:param?`
+ * - `:param+` → `*` (splat, required)
+ * - `:param*` → `/`, `/*` (splat, optional - two routes)
+ */
+export function toReactRouter(path) {
+    const segments = path.split("/").filter(Boolean);
+    const optionalWildcardIndex = segments.findIndex((s) => s.startsWith(":") && s.endsWith("*"));
+    if (optionalWildcardIndex !== -1) {
+        const before = segments.slice(0, optionalWildcardIndex);
+        const beforeJoined = before
+            .map((s) => {
+            if (!s.startsWith(":"))
+                return s;
+            const name = getParamName(s);
+            const modifier = getModifier(s);
+            return modifier === "?" ? `:${name}?` : `:${name}`;
+        })
+            .join("/");
+        const basePath = beforeJoined ? "/" + beforeJoined : "/";
+        const withWildcard = basePath === "/" ? "/*" : basePath + "/*";
+        return [basePath, withWildcard];
+    }
+    const joined = segments
+        .map((s) => {
+        if (!s.startsWith(":"))
+            return s;
+        const name = getParamName(s);
+        const modifier = getModifier(s);
+        switch (modifier) {
+            case "":
+                return `:${name}`;
+            case "?":
+                return `:${name}?`;
+            case "+":
+            case "*":
+                return "*";
+        }
+    })
+        .join("/");
+    return [joined ? "/" + joined : "/"];
+}
+/**
+ * Alias for toReactRouter.
+ *
+ * @see https://reactrouter.com/start/framework/routing
+ */
+export const toRemix = toReactRouter;
+/**
+ * Converts to Remix file-based route naming convention.
+ *
+ * Returns a file path segment (without extension) for Remix's
+ * flat file routing convention.
+ *
+ * @see https://remix.run/docs/file-conventions/routes
+ *
+ * - `:param` → `$param`
+ * - `:param?` → `($param)`
+ * - `:param+` → `$` (splat)
+ * - `:param*` → `($)` (optional splat) - Note: not officially supported
+ */
+export function toRemixFile(path) {
+    const segments = path.split("/").filter(Boolean);
+    const mapped = segments.map((seg) => {
+        if (!seg.startsWith(":"))
+            return seg;
+        const name = getParamName(seg);
+        const modifier = getModifier(seg);
+        switch (modifier) {
+            case "":
+                return `$${name}`;
+            case "?":
+                return `($${name})`;
+            case "+":
+                return "$";
+            case "*":
+                return "($)";
+        }
+    });
+    return mapped.join(".");
+}
+/**
+ * Converts to TanStack Router path/file pattern.
+ *
+ * TanStack uses the same `$param` syntax for both route paths and file names.
+ * Returns a dot-separated file name (without extension).
+ *
+ * @see https://tanstack.com/router/v1/docs/framework/react/guide/path-params
+ * @see https://tanstack.com/router/v1/docs/framework/react/routing/file-naming-conventions
+ *
+ * - `:param` → `$param`
+ * - `:param?` → `{-$param}` (optional segment)
+ * - `:param+` → `$` (splat)
+ * - `:param*` → `$` (splat, optional not supported - treated as required)
+ */
+export function toTanStack(path) {
+    const segments = path.split("/").filter(Boolean);
+    const mapped = segments.map((seg) => {
+        if (!seg.startsWith(":"))
+            return seg;
+        const name = getParamName(seg);
+        const modifier = getModifier(seg);
+        switch (modifier) {
+            case "":
+                return `$${name}`;
+            case "?":
+                return `{-$${name}}`;
+            case "+":
+                return "$";
+            case "*":
+                return "$";
+        }
+    });
+    return mapped.join(".");
+}
+/**
+ * Converts to Hono path pattern.
+ *
+ * Hono uses unnamed wildcards - they are NOT accessible via c.req.param().
+ * Use c.req.path to access the matched path for wildcard routes.
+ *
+ * @see https://hono.dev/docs/api/routing
+ *
+ * - `:param` → `:param`
+ * - `:param?` → `:param?`
+ * - `:param+` → `*` (unnamed, required)
+ * - `:param*` → `/`, `/*` (unnamed, optional - two routes)
+ */
+export function toHono(path) {
+    const segments = path.split("/").filter(Boolean);
+    const optionalWildcardIndex = segments.findIndex((s) => s.startsWith(":") && s.endsWith("*"));
+    if (optionalWildcardIndex !== -1) {
+        const before = segments.slice(0, optionalWildcardIndex);
+        const beforeJoined = before
+            .map((s) => {
+            if (!s.startsWith(":"))
+                return s;
+            const name = getParamName(s);
+            const modifier = getModifier(s);
+            return modifier === "?" ? `:${name}?` : `:${name}`;
+        })
+            .join("/");
+        const basePath = beforeJoined ? "/" + beforeJoined : "/";
+        const withWildcard = basePath === "/" ? "/*" : basePath + "/*";
+        return [basePath, withWildcard];
+    }
+    const joined = segments
+        .map((s) => {
+        if (!s.startsWith(":"))
+            return s;
+        const name = getParamName(s);
+        const modifier = getModifier(s);
+        switch (modifier) {
+            case "":
+                return `:${name}`;
+            case "?":
+                return `:${name}?`;
+            case "+":
+            case "*":
+                return "*";
+        }
+    })
+        .join("/");
+    return [joined ? "/" + joined : "/"];
+}
+/**
+ * Converts to Effect HttpRouter / find-my-way path pattern.
+ *
+ * Effect uses colon-style params with unnamed wildcards.
+ *
+ * @see https://effect.website/docs/platform/http-router
+ *
+ * - `:param` → `:param`
+ * - `:param?` → `:param?`
+ * - `:param+` → `*` (unnamed)
+ * - `:param*` → `/`, `/*` (two routes)
+ */
+export function toEffect(path) {
+    return toHono(path);
+}
+/**
+ * Converts to Bun.serve path pattern.
+ *
+ * Since Bun doesn't support optional params (`:param?`), optional segments
+ * are expanded into multiple routes.
+ *
+ * @see https://bun.sh/docs/api/http#routing
+ *
+ * - `:param` → `:param`
+ * - `:param?` → `/`, `/:param` (two routes)
+ * - `:param+` → `/*`
+ * - `:param*` → `/`, `/*` (two routes)
+ */
+export function toBun(path) {
+    const segments = path.split("/").filter(Boolean);
+    const optionalIndex = segments.findIndex((s) => s.startsWith(":") && (s.endsWith("?") || s.endsWith("*")));
+    if (optionalIndex === -1) {
+        const joined = segments
+            .map((s) => {
+            if (!s.startsWith(":"))
+                return s;
+            const modifier = getModifier(s);
+            const name = getParamName(s);
+            return modifier === "+" || modifier === "*" ? "*" : `:${name}`;
+        })
+            .join("/");
+        return [joined ? `/${joined}` : "/"];
+    }
+    const before = segments.slice(0, optionalIndex);
+    const optional = segments[optionalIndex];
+    const after = segments.slice(optionalIndex + 1);
+    const formatSegment = (s) => {
+        if (!s.startsWith(":"))
+            return s;
+        const modifier = getModifier(s);
+        const name = getParamName(s);
+        switch (modifier) {
+            case "":
+            case "?":
+                return `:${name}`;
+            case "+":
+            case "*":
+                return "*";
+        }
+    };
+    const beforePath = before.map(formatSegment).join("/");
+    const basePath = beforePath ? `/${beforePath}` : "/";
+    const optionalModifier = getModifier(optional);
+    const optionalName = getParamName(optional);
+    const requiredOptional = optionalModifier === "*"
+        ? `:${optionalName}+`
+        : `:${optionalName}`;
+    const withOptionalSegments = [...before, requiredOptional, ...after];
+    const withOptionalPath = `/${withOptionalSegments.map(formatSegment).join("/")}`;
+    return [...toBun(basePath), ...toBun(withOptionalPath)];
+}

package/dist/Random.d.ts

@@ -0,0 +1,5 @@
+export declare function uuid(): string;
+export declare function uuidSorted(): string;
+export declare function token(length: number): string;
+export declare function bytes(length: number): Uint8Array;
+export declare function uuid4bytes(): Uint8Array;

package/dist/Random.js

@@ -0,0 +1,49 @@
+export function uuid() {
+    return base36(uuid4bytes());
+}
+export function uuidSorted() {
+    return base36(uuid7bytes());
+}
+export function token(length) {
+    return base36(bytes(length));
+}
+function base36(bytes) {
+    if (bytes.length === 0)
+        return "";
+    let zeros = 0;
+    while (zeros < bytes.length && bytes[zeros] === 0)
+        zeros++;
+    let n = 0n;
+    for (let i = zeros; i < bytes.length; i++)
+        n = (n << 8n) + BigInt(bytes[i]);
+    return "0".repeat(zeros) + (n === 0n ? "" : n.toString(36));
+}
+export function bytes(length) {
+    const buf = new Uint8Array(length);
+    crypto.getRandomValues(buf);
+    return buf;
+}
+export function uuid4bytes() {
+    const buf = bytes(16);
+    buf[6] = (buf[6] & 0x0f) | 0x40; // version 4
+    buf[8] = (buf[8] & 0x3f) | 0x80; // variant
+    return buf;
+}
+function uuid7bytes() {
+    const buf = new Uint8Array(16);
+    const timestamp = BigInt(Date.now());
+    // 48-bit timestamp (6 bytes)
+    buf[0] = Number((timestamp >> 40n) & 0xffn);
+    buf[1] = Number((timestamp >> 32n) & 0xffn);
+    buf[2] = Number((timestamp >> 24n) & 0xffn);
+    buf[3] = Number((timestamp >> 16n) & 0xffn);
+    buf[4] = Number((timestamp >> 8n) & 0xffn);
+    buf[5] = Number(timestamp & 0xffn);
+    // 12-bit random A (1.5 bytes)
+    crypto.getRandomValues(buf.subarray(6, 8));
+    buf[6] = (buf[6] & 0x0f) | 0x70; // version 7
+    // 2-bit variant + 62-bit random B (8 bytes)
+    crypto.getRandomValues(buf.subarray(8, 16));
+    buf[8] = (buf[8] & 0x3f) | 0x80; // variant
+    return buf;
+}

package/dist/Route.d.ts

@@ -0,0 +1,98 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Pipeable from "effect/Pipeable";
+import type * as Entity from "./Entity.ts";
+import * as RouteBody from "./RouteBody.ts";
+import * as RouteTree from "./RouteTree.ts";
+import * 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>): 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";
+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";

package/dist/Route.js

@@ -0,0 +1,81 @@
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Pipeable from "effect/Pipeable";
+import * as Predicate from "effect/Predicate";
+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 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";