effect-start 0.17.0 → 0.17.2

package/dist/RouteTrie.js

@@ -0,0 +1,157 @@
+import * as PathPattern from "./PathPattern.js";
+import * as Route from "./Route.js";
+function createNode() {
+    return {
+        children: {},
+        paramChild: null,
+        paramName: null,
+        requiredWildcardChild: null,
+        requiredWildcardName: null,
+        optionalWildcardChild: null,
+        optionalWildcardName: null,
+        routes: [],
+    };
+}
+function insertRoute(node, segments, route) {
+    if (segments.length === 0) {
+        node.routes.push(route);
+        return;
+    }
+    const segment = segments[0];
+    const rest = segments.slice(1);
+    if (segment.startsWith(":")) {
+        const name = segment.slice(1);
+        if (name.endsWith("+")) {
+            if (!node.requiredWildcardChild) {
+                node.requiredWildcardChild = createNode();
+            }
+            node.requiredWildcardChild.requiredWildcardName = name.slice(0, -1);
+            node.requiredWildcardChild.routes.push(route);
+        }
+        else if (name.endsWith("*")) {
+            if (!node.optionalWildcardChild) {
+                node.optionalWildcardChild = createNode();
+            }
+            node.optionalWildcardChild.optionalWildcardName = name.slice(0, -1);
+            node.optionalWildcardChild.routes.push(route);
+        }
+        else if (name.endsWith("?")) {
+            if (!node.paramChild) {
+                node.paramChild = createNode();
+            }
+            node.paramChild.paramName = name.slice(0, -1);
+            insertRoute(node.paramChild, rest, route);
+            insertRoute(node, rest, route);
+        }
+        else {
+            if (!node.paramChild) {
+                node.paramChild = createNode();
+            }
+            node.paramChild.paramName = name;
+            insertRoute(node.paramChild, rest, route);
+        }
+    }
+    else {
+        if (!node.children[segment]) {
+            node.children[segment] = createNode();
+        }
+        insertRoute(node.children[segment], rest, route);
+    }
+}
+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 currentMethod = desc?.method ?? parentMethod;
+        if (Route.isRoute(item)) {
+            if (currentPath !== "") {
+                results.push({
+                    route: item,
+                    method: currentMethod,
+                    path: currentPath,
+                });
+            }
+        }
+        else {
+            const nestedItems = Route.items(item);
+            results.push(...collectRoutes(nestedItems, currentPath, currentMethod));
+        }
+    }
+    return results;
+}
+export function make(set) {
+    const methods = {};
+    const collected = collectRoutes(Route.items(set), "", "*");
+    for (const { route, method, path } of collected) {
+        if (!methods[method]) {
+            methods[method] = createNode();
+        }
+        const result = PathPattern.validate(path);
+        if (!result.ok) {
+            throw new Error(result.error);
+        }
+        insertRoute(methods[method], result.segments, route);
+    }
+    return { methods };
+}
+function lookupNode(node, segments, params) {
+    const results = [];
+    if (segments.length === 0) {
+        for (const route of node.routes) {
+            results.push({ route, params });
+        }
+        if (node.optionalWildcardChild
+            && node.optionalWildcardChild.optionalWildcardName) {
+            for (const route of node.optionalWildcardChild.routes) {
+                results.push({ route, params });
+            }
+        }
+        return results;
+    }
+    const segment = segments[0];
+    const rest = segments.slice(1);
+    if (node.children[segment]) {
+        results.push(...lookupNode(node.children[segment], rest, params));
+    }
+    if (node.paramChild && node.paramChild.paramName) {
+        const newParams = { ...params, [node.paramChild.paramName]: segment };
+        results.push(...lookupNode(node.paramChild, rest, newParams));
+    }
+    if (node.requiredWildcardChild
+        && node.requiredWildcardChild.requiredWildcardName) {
+        const wildcardValue = segments.join("/");
+        const newParams = {
+            ...params,
+            [node.requiredWildcardChild.requiredWildcardName]: wildcardValue,
+        };
+        for (const route of node.requiredWildcardChild.routes) {
+            results.push({ route, params: newParams });
+        }
+    }
+    if (node.optionalWildcardChild
+        && node.optionalWildcardChild.optionalWildcardName) {
+        const wildcardValue = segments.join("/");
+        const newParams = {
+            ...params,
+            [node.optionalWildcardChild.optionalWildcardName]: wildcardValue,
+        };
+        for (const route of node.optionalWildcardChild.routes) {
+            results.push({ route, params: newParams });
+        }
+    }
+    return results;
+}
+export function lookup(trie, method, path) {
+    const segments = path.split("/").filter(Boolean);
+    const results = [];
+    if (trie.methods[method]) {
+        results.push(...lookupNode(trie.methods[method], segments, {}));
+    }
+    if (method !== "*" && trie.methods["*"]) {
+        results.push(...lookupNode(trie.methods["*"], segments, {}));
+    }
+    return results;
+}

package/dist/RouterPattern.d.ts

@@ -0,0 +1,118 @@
+export type RouterPattern = `/${string}`;
+export type ParamDelimiter = "_" | "-" | "." | "," | ";" | "!" | "@" | "~";
+export type ParamPrefix = `${string}${ParamDelimiter}` | "";
+export type ParamSuffix = `${ParamDelimiter}${string}` | "";
+export type LiteralSegment<Value extends string = string> = {
+    _tag: "LiteralSegment";
+    value: Value;
+};
+export type ParamSegment<Name extends string = string, Optional extends boolean = boolean, Prefix extends ParamPrefix = "", Suffix extends ParamSuffix = ""> = {
+    _tag: "ParamSegment";
+    name: Name;
+    optional?: Optional;
+    prefix?: Prefix;
+    suffix?: Suffix;
+};
+export type RestSegment<Name extends string = string, Optional extends boolean = boolean> = {
+    _tag: "RestSegment";
+    name: Name;
+    optional?: Optional;
+};
+export type Segment = LiteralSegment | ParamSegment<string, boolean, ParamPrefix, ParamSuffix> | RestSegment;
+/**
+ * Parses a route path string into a tuple of Segment types at compile time.
+ *
+ * @example
+ * ```ts
+ * type Usage = Segments<"/users/[id]/posts/[...rest]">
+ * type Expected = [
+ *   LiteralSegment<"users">,
+ *   ParamSegment<"id", false>,
+ *   LiteralSegment<"posts">,
+ *   RestSegment<"rest", false>
+ * ]
+ * ```
+ *
+ * Supports:
+ * - Literals: `users` → `LiteralSegment<"users">`
+ * - Params: `[id]` → `ParamSegment<"id", false>`
+ * - Params (optional): `[[id]]` → `ParamSegment<"id", true>`
+ * - Rest: `[...rest]` → `RestSegment<"rest", false>`
+ * - Rest (optional): `[[...rest]]` → `RestSegment<"rest", true>`
+ * - {Pre,Suf}fixed params: `prefix_[id]_suffix` → `ParamSegment<"id", false, "prefix_", "_suffix">`
+ * - Malformed segments: `pk_[id]foo` → `undefined` (suffix must start with delimiter)
+ *
+ * @limit Paths with more than 48 segments in TypeScript 5.9.3 will fail with
+ * `TS2589: Type instantiation is excessively deep and possibly infinite`.
+ */
+export type Segments<Path extends string> = Path extends `/${infer PathRest}` ? Segments<PathRest> : Path extends `${infer Head}/${infer Tail}` ? [ExtractSegment<Head>, ...Segments<Tail>] : Path extends "" ? [] : [ExtractSegment<Path>];
+export declare function parseSegment(segment: string): Segment | null;
+export declare function parse(pattern: string): Segment[];
+export declare function formatSegment(seg: Segment): string;
+export declare function format(segments: Segment[]): `/${string}`;
+/**
+ * Converts to colon-style path pattern (used by Hono, Bun, itty-router).
+ *
+ * - `[param]` → `:param`
+ * - `[[param]]` → `:param?`
+ * - `[...param]` → `*`
+ * - `[[...param]]` → `/`, `/*`
+ * - `pk_[id]` → `pk_:id`
+ */
+export declare function toColon(path: RouterPattern): string[];
+export declare const toHono: typeof toColon;
+/**
+ * Converts to Express path pattern.
+ *
+ * - `[param]` → `:param`
+ * - `[[param]]` → `{/:param}`
+ * - `[...param]` → `/*param`
+ * - `[[...param]]` → `/`, `/*param`
+ * - `pk_[id]` → `pk_:id`
+ */
+export declare function toExpress(path: RouterPattern): string[];
+/**
+ * Converts to Effect HttpRouter/find-my-way path pattern.
+ *
+ * - `[param]` → `:param`
+ * - `[[param]]` → `:param?` (must be final segment)
+ * - `[...param]` → `*`
+ * - `[[...param]]` → `/`, `/*`
+ * - `pk_[id]` → `pk_:id`
+ */
+export declare function toEffect(path: RouterPattern): string[];
+/**
+ * Converts to URLPattern path pattern.
+ *
+ * - `[param]` → `:param`
+ * - `[[param]]` → `:param?`
+ * - `[...param]` → `:param+`
+ * - `[[...param]]` → `:param*`
+ * - `pk_[id]` → `pk_:id`
+ */
+export declare function toURLPattern(path: RouterPattern): string[];
+/**
+ * Converts to Remix path pattern.
+ *
+ * - `[param]` → `$param`
+ * - `[[param]]` → `($param)`
+ * - `[...param]` → `$`
+ * - `[[...param]]` → `/`, `$`
+ * - `pk_[id]` → (not supported, emits `pk_$id`)
+ */
+export declare function toRemix(path: RouterPattern): string[];
+/**
+ * Converts to Bun.serve path pattern.
+ *
+ * Since Bun doesn't support optional params (`:param?`), optional segments
+ * are expanded into multiple routes recursively.
+ *
+ * - `[param]` → `:param`
+ * - `[[param]]` → `/`, `/:param` (two routes)
+ * - `[...param]` → `*`
+ * - `[[...param]]` → `/`, `/*` (two routes)
+ * - `pk_[id]` → `pk_:id`
+ */
+export declare function toBun(path: RouterPattern): string[];
+type ExtractSegment<S extends string> = S extends `[[...${infer Name}]]` ? RestSegment<Name, true> : S extends `[...${infer Name}]` ? RestSegment<Name, false> : S extends `[[${infer Name}]]` ? ParamSegment<Name, true, "", ""> : S extends `${infer Pre extends `${string}${ParamDelimiter}`}[${infer Name}]${infer Suf}` ? Suf extends `${infer Delim extends ParamDelimiter}${infer SufRest}` ? ParamSegment<Name, false, Pre, `${Delim}${SufRest}`> : Suf extends "" ? ParamSegment<Name, false, Pre, ""> : undefined : S extends `[${infer Name}]${infer Suf extends `${ParamDelimiter}${string}`}` ? ParamSegment<Name, false, "", Suf> : S extends `[${infer Name}]` ? ParamSegment<Name, false, "", ""> : LiteralSegment<S>;
+export {};

package/dist/RouterPattern.js

@@ -0,0 +1,269 @@
+const PARAM_PATTERN = /^(?<prefix>.*[^a-zA-Z0-9])?\[(?<name>[^\]]+)\](?<suffix>[^a-zA-Z0-9].*)?$/;
+export function parseSegment(segment) {
+    if (segment.startsWith("[[...")
+        && segment.endsWith("]]")) {
+        return {
+            _tag: "RestSegment",
+            name: segment.slice(5, -2),
+            optional: true,
+        };
+    }
+    if (segment.startsWith("[...")
+        && segment.endsWith("]")) {
+        return {
+            _tag: "RestSegment",
+            name: segment.slice(4, -1),
+        };
+    }
+    if (segment.startsWith("[[")
+        && segment.endsWith("]]")) {
+        return {
+            _tag: "ParamSegment",
+            name: segment.slice(2, -2),
+            optional: true,
+        };
+    }
+    const match = segment.match(PARAM_PATTERN);
+    if (match?.groups) {
+        const { prefix, name, suffix } = match.groups;
+        return {
+            _tag: "ParamSegment",
+            name,
+            prefix: prefix || undefined,
+            suffix: suffix || undefined,
+        };
+    }
+    if (/^[\p{L}\p{N}._~-]+$/u.test(segment)) {
+        return { _tag: "LiteralSegment", value: segment };
+    }
+    return null;
+}
+export function parse(pattern) {
+    const segments = pattern.split("/").filter(Boolean).map(parseSegment);
+    if (segments.some((seg) => seg === null)) {
+        throw new Error(`Invalid path segment in "${pattern}": contains invalid characters or format`);
+    }
+    return segments;
+}
+export function formatSegment(seg) {
+    switch (seg._tag) {
+        case "LiteralSegment":
+            return seg.value;
+        case "ParamSegment": {
+            const param = seg.optional ? `[[${seg.name}]]` : `[${seg.name}]`;
+            return (seg.prefix ?? "") + param + (seg.suffix ?? "");
+        }
+        case "RestSegment":
+            return seg.optional ? `[[...${seg.name}]]` : `[...${seg.name}]`;
+    }
+}
+export function format(segments) {
+    const joined = segments.map(formatSegment).join("/");
+    return (joined ? `/${joined}` : "/");
+}
+function buildPaths(segments, mapper, restWildcard) {
+    const optionalRestIndex = segments.findIndex((s) => s._tag === "RestSegment" && s.optional);
+    if (optionalRestIndex !== -1) {
+        const before = segments.slice(0, optionalRestIndex);
+        const beforeJoined = before.map(mapper).join("/");
+        const basePath = beforeJoined ? "/" + beforeJoined : "/";
+        const withWildcard = basePath === "/"
+            ? restWildcard
+            : basePath + restWildcard;
+        return [basePath, withWildcard];
+    }
+    const joined = segments.map(mapper).join("/");
+    return [joined ? "/" + joined : "/"];
+}
+function colonParamSegment(segment) {
+    switch (segment._tag) {
+        case "LiteralSegment":
+            return segment.value;
+        case "ParamSegment": {
+            const param = `:${segment.name}${segment.optional ? "?" : ""}`;
+            return (segment.prefix ?? "") + param + (segment.suffix ?? "");
+        }
+        case "RestSegment":
+            return "*";
+    }
+}
+/**
+ * Converts to colon-style path pattern (used by Hono, Bun, itty-router).
+ *
+ * - `[param]` → `:param`
+ * - `[[param]]` → `:param?`
+ * - `[...param]` → `*`
+ * - `[[...param]]` → `/`, `/*`
+ * - `pk_[id]` → `pk_:id`
+ */
+export function toColon(path) {
+    return buildPaths(parse(path), colonParamSegment, "/*");
+}
+export const toHono = toColon;
+/**
+ * Converts to Express path pattern.
+ *
+ * - `[param]` → `:param`
+ * - `[[param]]` → `{/:param}`
+ * - `[...param]` → `/*param`
+ * - `[[...param]]` → `/`, `/*param`
+ * - `pk_[id]` → `pk_:id`
+ */
+export function toExpress(path) {
+    const segments = parse(path);
+    const optionalRestIndex = segments.findIndex((s) => s._tag === "RestSegment" && s.optional);
+    const mapper = (segment) => {
+        switch (segment._tag) {
+            case "LiteralSegment":
+                return segment.value;
+            case "ParamSegment": {
+                const param = `:${segment.name}`;
+                return (segment.prefix ?? "") + param + (segment.suffix ?? "");
+            }
+            case "RestSegment":
+                return `*${segment.name}`;
+        }
+    };
+    if (optionalRestIndex !== -1) {
+        const before = segments.slice(0, optionalRestIndex);
+        const rest = segments[optionalRestIndex];
+        if (rest._tag !== "RestSegment")
+            throw new Error("unreachable");
+        const restName = rest.name;
+        const beforeJoined = before.map(mapper).join("/");
+        const basePath = beforeJoined ? "/" + beforeJoined : "/";
+        const withWildcard = basePath === "/"
+            ? `/*${restName}`
+            : basePath + `/*${restName}`;
+        return [basePath, withWildcard];
+    }
+    let result = "";
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const isFirst = i === 0;
+        switch (segment._tag) {
+            case "LiteralSegment":
+                result += "/" + segment.value;
+                break;
+            case "ParamSegment":
+                if (segment.optional && !segment.prefix && !segment.suffix) {
+                    result += isFirst
+                        ? "/{/:$name}".replace("$name", segment.name)
+                        : `{/:${segment.name}}`;
+                }
+                else {
+                    const param = `:${segment.name}`;
+                    result += "/"
+                        + (segment.prefix ?? "")
+                        + param
+                        + (segment.suffix ?? "");
+                }
+                break;
+            case "RestSegment":
+                result += `/*${segment.name}`;
+                break;
+        }
+    }
+    return [result || "/"];
+}
+/**
+ * Converts to Effect HttpRouter/find-my-way path pattern.
+ *
+ * - `[param]` → `:param`
+ * - `[[param]]` → `:param?` (must be final segment)
+ * - `[...param]` → `*`
+ * - `[[...param]]` → `/`, `/*`
+ * - `pk_[id]` → `pk_:id`
+ */
+export function toEffect(path) {
+    return buildPaths(parse(path), colonParamSegment, "/*");
+}
+/**
+ * Converts to URLPattern path pattern.
+ *
+ * - `[param]` → `:param`
+ * - `[[param]]` → `:param?`
+ * - `[...param]` → `:param+`
+ * - `[[...param]]` → `:param*`
+ * - `pk_[id]` → `pk_:id`
+ */
+export function toURLPattern(path) {
+    const segments = parse(path);
+    const joined = segments
+        .map((segment) => {
+        switch (segment._tag) {
+            case "LiteralSegment":
+                return segment.value;
+            case "ParamSegment": {
+                const param = `:${segment.name}${segment.optional ? "?" : ""}`;
+                return (segment.prefix ?? "") + param + (segment.suffix ?? "");
+            }
+            case "RestSegment":
+                return `:${segment.name}${segment.optional ? "*" : "+"}`;
+        }
+    })
+        .join("/");
+    return [joined ? "/" + joined : "/"];
+}
+/**
+ * Converts to Remix path pattern.
+ *
+ * - `[param]` → `$param`
+ * - `[[param]]` → `($param)`
+ * - `[...param]` → `$`
+ * - `[[...param]]` → `/`, `$`
+ * - `pk_[id]` → (not supported, emits `pk_$id`)
+ */
+export function toRemix(path) {
+    const segments = parse(path);
+    const optionalRestIndex = segments.findIndex((s) => s._tag === "RestSegment" && s.optional);
+    const mapper = (segment) => {
+        switch (segment._tag) {
+            case "LiteralSegment":
+                return segment.value;
+            case "ParamSegment": {
+                const param = segment.optional
+                    ? `($${segment.name})`
+                    : `$${segment.name}`;
+                return (segment.prefix ?? "") + param + (segment.suffix ?? "");
+            }
+            case "RestSegment":
+                return "$";
+        }
+    };
+    if (optionalRestIndex !== -1) {
+        const before = segments.slice(0, optionalRestIndex);
+        const beforeJoined = before.map(mapper).join("/");
+        const basePath = beforeJoined ? "/" + beforeJoined : "/";
+        const withWildcard = basePath === "/" ? "$" : basePath + "/$";
+        return [basePath, withWildcard];
+    }
+    const joined = segments.map(mapper).join("/");
+    return [joined ? "/" + joined : "/"];
+}
+/**
+ * Converts to Bun.serve path pattern.
+ *
+ * Since Bun doesn't support optional params (`:param?`), optional segments
+ * are expanded into multiple routes recursively.
+ *
+ * - `[param]` → `:param`
+ * - `[[param]]` → `/`, `/:param` (two routes)
+ * - `[...param]` → `*`
+ * - `[[...param]]` → `/`, `/*` (two routes)
+ * - `pk_[id]` → `pk_:id`
+ */
+export function toBun(path) {
+    const segments = parse(path);
+    const optionalIndex = segments.findIndex((s) => (s._tag === "ParamSegment" || s._tag === "RestSegment") && s.optional);
+    if (optionalIndex === -1) {
+        return buildPaths(segments, colonParamSegment, "/*");
+    }
+    const before = segments.slice(0, optionalIndex);
+    const optional = { ...segments[optionalIndex], optional: false };
+    const after = segments.slice(optionalIndex + 1);
+    return [
+        ...toBun(format(before)),
+        ...toBun(format([...before, optional, ...after])),
+    ];
+}

package/dist/SchemaExtra.d.ts

@@ -0,0 +1,7 @@
+import * 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;
+export declare function schemaEqual(userSchema: Schema.Struct<any> | undefined, expectedSchema: Schema.Struct<any> | null): boolean;
+export declare function getSchemaTypeName(schema: Schema.Schema.Any): string;
+export declare function formatSchemaCode(schema: Schema.Struct<any>): string;

package/dist/SchemaExtra.js

@@ -0,0 +1,74 @@
+import * as SchemaAST from "effect/SchemaAST";
+export function getBaseSchemaAST(schema) {
+    let current = schema.ast;
+    while (SchemaAST.isRefinement(current) || SchemaAST.isTransformation(current)) {
+        current = current.from;
+    }
+    return current;
+}
+export function isOptional(schema) {
+    const ast = schema.ast;
+    if (ast._tag === "Union") {
+        return ast.types.some((t) => t._tag === "UndefinedKeyword");
+    }
+    return false;
+}
+export function schemaEqual(userSchema, expectedSchema) {
+    if (!userSchema && !expectedSchema) {
+        return true;
+    }
+    if (!userSchema || !expectedSchema) {
+        return false;
+    }
+    const userFields = userSchema.fields;
+    const expectedFields = expectedSchema.fields;
+    const userKeys = Object.keys(userFields).sort();
+    const expectedKeys = Object.keys(expectedFields).sort();
+    if (userKeys.length !== expectedKeys.length) {
+        return false;
+    }
+    for (let i = 0; i < userKeys.length; i++) {
+        if (userKeys[i] !== expectedKeys[i]) {
+            return false;
+        }
+    }
+    for (const key of userKeys) {
+        const userFieldSchema = userFields[key];
+        const expectedFieldSchema = expectedFields[key];
+        const userOptional = isOptional(userFieldSchema);
+        const expectedOptional = isOptional(expectedFieldSchema);
+        if (userOptional !== expectedOptional) {
+            return false;
+        }
+        const userBaseAST = getBaseSchemaAST(userFieldSchema);
+        const expectedBaseAST = getBaseSchemaAST(expectedFieldSchema);
+        if (userBaseAST._tag !== expectedBaseAST._tag) {
+            return false;
+        }
+    }
+    return true;
+}
+export function getSchemaTypeName(schema) {
+    const baseAST = getBaseSchemaAST(schema);
+    switch (baseAST._tag) {
+        case "StringKeyword":
+            return "Schema.String";
+        case "NumberKeyword":
+            return "Schema.Number";
+        case "BooleanKeyword":
+            return "Schema.Boolean";
+        default:
+            return "Schema.String";
+    }
+}
+export function formatSchemaCode(schema) {
+    const fields = schema.fields;
+    const fieldStrings = [];
+    for (const [key, fieldSchema] of Object.entries(fields)) {
+        const optional = isOptional(fieldSchema);
+        const typeName = getSchemaTypeName(fieldSchema);
+        const fieldStr = optional ? `${key}?: ${typeName}` : `${key}: ${typeName}`;
+        fieldStrings.push(fieldStr);
+    }
+    return `{ ${fieldStrings.join(", ")} }`;
+}

package/dist/Start.d.ts

@@ -0,0 +1,19 @@
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpRouter from "@effect/platform/HttpRouter";
+import * as HttpServer from "@effect/platform/HttpServer";
+import * as Layer from "effect/Layer";
+import * as BunHttpServer from "./bun/BunHttpServer.ts";
+export declare function layer<Layers extends [
+    Layer.Layer<never, any, any>,
+    ...Array<Layer.Layer<never, any, any>>
+]>(...layers: Layers): Layer.Layer<{
+    [k in keyof Layers]: Layer.Layer.Success<Layers[k]>;
+}[number], {
+    [k in keyof Layers]: Layer.Layer.Error<Layers[k]>;
+}[number], {
+    [k in keyof Layers]: Layer.Layer.Context<Layers[k]>;
+}[number]>;
+export declare function serve<ROut, E>(load: () => Promise<{
+    default: Layer.Layer<ROut, E, HttpServer.HttpServer | HttpClient.HttpClient | HttpRouter.Default | FileSystem.FileSystem | BunHttpServer.BunHttpServer>;
+}>): void;

package/dist/Start.js

@@ -0,0 +1,23 @@
+import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
+import * as HttpRouter from "@effect/platform/HttpRouter";
+import * as HttpServer from "@effect/platform/HttpServer";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as BunHttpServer from "./bun/BunHttpServer.js";
+import * as BunRuntime from "./bun/BunRuntime.js";
+import * as NodeFileSystem from "./node/FileSystem.js";
+import * as StartApp from "./StartApp.js";
+export function layer(...layers) {
+    return Layer.mergeAll(...layers);
+}
+export function serve(load) {
+    const appLayer = Function.pipe(Effect.tryPromise(load), Effect.map(v => v.default), Effect.orDie, Layer.unwrapEffect);
+    return Function.pipe(BunHttpServer.layerAuto(), HttpServer.withLogAddress, Layer.provide(appLayer), Layer.provide([
+        FetchHttpClient.layer,
+        HttpRouter.Default.Live,
+        BunHttpServer.layer(),
+        NodeFileSystem.layer,
+        StartApp.layer(),
+    ]), Layer.launch, BunRuntime.runMain);
+}

package/dist/StartApp.d.ts

@@ -0,0 +1,19 @@
+import * as HttpApp from "@effect/platform/HttpApp";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as PubSub from "effect/PubSub";
+import * as Ref from "effect/Ref";
+type StartMiddleware = <E, R>(self: HttpApp.Default<E, R>) => HttpApp.Default<never, never>;
+declare const StartApp_base: Context.TagClass<StartApp, "effect-start/StartApp", {
+    readonly env: "development" | "production" | string;
+    readonly addMiddleware: (middleware: StartMiddleware) => Effect.Effect<void>;
+    readonly middleware: Ref.Ref<StartMiddleware>;
+    readonly events: PubSub.PubSub<any>;
+}>;
+export declare class StartApp extends StartApp_base {
+}
+export declare function layer(options?: {
+    env?: string;
+}): Layer.Layer<StartApp, never, never>;
+export {};