effect-start 0.23.1 → 0.26.0

package/dist/FileSystem.d.ts

@@ -1,158 +0,0 @@
-import * as Brand from "effect/Brand";
-import * as Context from "effect/Context";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Sink from "effect/Sink";
-import type * as Scope from "effect/Scope";
-import * as Stream from "effect/Stream";
-import * as PlatformError from "./PlatformError.ts";
-export interface FileSystem {
-    readonly access: (path: string, options?: AccessFileOptions) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly copy: (fromPath: string, toPath: string, options?: CopyOptions) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly copyFile: (fromPath: string, toPath: string) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly chmod: (path: string, mode: number) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly chown: (path: string, uid: number, gid: number) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly exists: (path: string) => Effect.Effect<boolean, PlatformError.PlatformError>;
-    readonly link: (fromPath: string, toPath: string) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly makeDirectory: (path: string, options?: MakeDirectoryOptions) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly makeTempDirectory: (options?: MakeTempDirectoryOptions) => Effect.Effect<string, PlatformError.PlatformError>;
-    readonly makeTempDirectoryScoped: (options?: MakeTempDirectoryOptions) => Effect.Effect<string, PlatformError.PlatformError, Scope.Scope>;
-    readonly makeTempFile: (options?: MakeTempFileOptions) => Effect.Effect<string, PlatformError.PlatformError>;
-    readonly makeTempFileScoped: (options?: MakeTempFileOptions) => Effect.Effect<string, PlatformError.PlatformError, Scope.Scope>;
-    readonly open: (path: string, options?: OpenFileOptions) => Effect.Effect<File, PlatformError.PlatformError, Scope.Scope>;
-    readonly readDirectory: (path: string, options?: ReadDirectoryOptions) => Effect.Effect<Array<string>, PlatformError.PlatformError>;
-    readonly readFile: (path: string) => Effect.Effect<Uint8Array, PlatformError.PlatformError>;
-    readonly readFileString: (path: string, encoding?: string) => Effect.Effect<string, PlatformError.PlatformError>;
-    readonly readLink: (path: string) => Effect.Effect<string, PlatformError.PlatformError>;
-    readonly realPath: (path: string) => Effect.Effect<string, PlatformError.PlatformError>;
-    readonly remove: (path: string, options?: RemoveOptions) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly rename: (oldPath: string, newPath: string) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly sink: (path: string, options?: SinkOptions) => Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError>;
-    readonly stat: (path: string) => Effect.Effect<File.Info, PlatformError.PlatformError>;
-    readonly stream: (path: string, options?: StreamOptions) => Stream.Stream<Uint8Array, PlatformError.PlatformError>;
-    readonly symlink: (fromPath: string, toPath: string) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly truncate: (path: string, length?: SizeInput) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly utimes: (path: string, atime: Date | number, mtime: Date | number) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly watch: (path: string, options?: WatchOptions) => Stream.Stream<WatchEvent, PlatformError.PlatformError>;
-    readonly writeFile: (path: string, data: Uint8Array, options?: WriteFileOptions) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly writeFileString: (path: string, data: string, options?: WriteFileStringOptions) => Effect.Effect<void, PlatformError.PlatformError>;
-}
-export declare const FileSystem: Context.Tag<FileSystem, FileSystem>;
-export type Size = Brand.Branded<bigint, "Size">;
-export type SizeInput = bigint | number | Size;
-export declare const Size: (bytes: SizeInput) => Size;
-export type OpenFlag = "r" | "r+" | "w" | "wx" | "w+" | "wx+" | "a" | "ax" | "a+" | "ax+";
-export type SeekMode = "start" | "current";
-export interface AccessFileOptions {
-    readonly ok?: boolean;
-    readonly readable?: boolean;
-    readonly writable?: boolean;
-}
-export interface MakeDirectoryOptions {
-    readonly recursive?: boolean;
-    readonly mode?: number;
-}
-export interface CopyOptions {
-    readonly overwrite?: boolean;
-    readonly preserveTimestamps?: boolean;
-}
-export interface MakeTempDirectoryOptions {
-    readonly directory?: string;
-    readonly prefix?: string;
-}
-export interface MakeTempFileOptions {
-    readonly directory?: string;
-    readonly prefix?: string;
-    readonly suffix?: string;
-}
-export interface OpenFileOptions {
-    readonly flag?: OpenFlag;
-    readonly mode?: number;
-}
-export interface ReadDirectoryOptions {
-    readonly recursive?: boolean;
-}
-export interface RemoveOptions {
-    readonly recursive?: boolean;
-    readonly force?: boolean;
-}
-export interface SinkOptions extends OpenFileOptions {
-}
-export interface StreamOptions {
-    readonly bufferSize?: number;
-    readonly bytesToRead?: SizeInput;
-    readonly chunkSize?: SizeInput;
-    readonly offset?: SizeInput;
-}
-export interface WriteFileOptions {
-    readonly flag?: OpenFlag;
-    readonly mode?: number;
-}
-export interface WriteFileStringOptions {
-    readonly flag?: OpenFlag;
-    readonly mode?: number;
-}
-export interface WatchOptions {
-    readonly recursive?: boolean;
-}
-export declare const FileTypeId: unique symbol;
-export type FileTypeId = typeof FileTypeId;
-export interface File {
-    readonly [FileTypeId]: FileTypeId;
-    readonly fd: File.Descriptor;
-    readonly stat: Effect.Effect<File.Info, PlatformError.PlatformError>;
-    readonly seek: (offset: SizeInput, from: SeekMode) => Effect.Effect<void>;
-    readonly sync: Effect.Effect<void, PlatformError.PlatformError>;
-    readonly read: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError.PlatformError>;
-    readonly readAlloc: (size: SizeInput) => Effect.Effect<Option.Option<Uint8Array>, PlatformError.PlatformError>;
-    readonly truncate: (length?: SizeInput) => Effect.Effect<void, PlatformError.PlatformError>;
-    readonly write: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError.PlatformError>;
-    readonly writeAll: (buffer: Uint8Array) => Effect.Effect<void, PlatformError.PlatformError>;
-}
-export declare namespace File {
-    type Descriptor = Brand.Branded<number, "FileDescriptor">;
-    type Type = "File" | "Directory" | "SymbolicLink" | "BlockDevice" | "CharacterDevice" | "FIFO" | "Socket" | "Unknown";
-    interface Info {
-        readonly type: Type;
-        readonly mtime: Option.Option<Date>;
-        readonly atime: Option.Option<Date>;
-        readonly birthtime: Option.Option<Date>;
-        readonly dev: number;
-        readonly ino: Option.Option<number>;
-        readonly mode: number;
-        readonly nlink: Option.Option<number>;
-        readonly uid: Option.Option<number>;
-        readonly gid: Option.Option<number>;
-        readonly rdev: Option.Option<number>;
-        readonly size: Size;
-        readonly blksize: Option.Option<Size>;
-        readonly blocks: Option.Option<number>;
-    }
-}
-export declare const FileDescriptor: Brand.Brand.Constructor<File.Descriptor>;
-export type WatchEvent = WatchEvent.Create | WatchEvent.Update | WatchEvent.Remove;
-export declare namespace WatchEvent {
-    interface Create {
-        readonly _tag: "Create";
-        readonly path: string;
-    }
-    interface Update {
-        readonly _tag: "Update";
-        readonly path: string;
-    }
-    interface Remove {
-        readonly _tag: "Remove";
-        readonly path: string;
-    }
-}
-export declare const WatchEventCreate: Data.Case.Constructor<WatchEvent.Create, "_tag">;
-export declare const WatchEventUpdate: Data.Case.Constructor<WatchEvent.Update, "_tag">;
-export declare const WatchEventRemove: Data.Case.Constructor<WatchEvent.Remove, "_tag">;
-declare const WatchBackend_base: Context.TagClass<WatchBackend, "@effect/platform/FileSystem/WatchBackend", {
-    readonly register: (path: string, stat: File.Info, options?: WatchOptions) => Option.Option<Stream.Stream<WatchEvent, PlatformError.PlatformError>>;
-}>;
-export declare class WatchBackend extends WatchBackend_base {
-}
-export declare const make: (impl: Omit<FileSystem, "exists" | "readFileString" | "stream" | "sink" | "writeFileString">) => FileSystem;
-export {};

package/dist/FileSystem.js

@@ -1,70 +0,0 @@
-/*
- * Adapted from @effect/platform
- */
-import * as Brand from "effect/Brand";
-import * as Channel from "effect/Channel";
-import * as Chunk from "effect/Chunk";
-import * as Context from "effect/Context";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
-import * as Option from "effect/Option";
-import * as Sink from "effect/Sink";
-import * as Stream from "effect/Stream";
-import * as PlatformError from "./PlatformError.js";
-export const FileSystem = Context.GenericTag("@effect/platform/FileSystem");
-export const Size = (bytes) => typeof bytes === "bigint" ? bytes : BigInt(bytes);
-export const FileTypeId = Symbol.for("@effect/platform/FileSystem/File");
-export const FileDescriptor = Brand.nominal();
-export const WatchEventCreate = Data.tagged("Create");
-export const WatchEventUpdate = Data.tagged("Update");
-export const WatchEventRemove = Data.tagged("Remove");
-export class WatchBackend extends Context.Tag("@effect/platform/FileSystem/WatchBackend")() {
-}
-export const make = (impl) => {
-    return FileSystem.of({
-        ...impl,
-        exists: (path) => Function.pipe(impl.access(path), Effect.as(true), Effect.catchTag("SystemError", (e) => e.reason === "NotFound" ? Effect.succeed(false) : Effect.fail(e))),
-        readFileString: (path, encoding) => Effect.tryMap(impl.readFile(path), {
-            try: (_) => new TextDecoder(encoding).decode(_),
-            catch: (cause) => new PlatformError.BadArgument({
-                module: "FileSystem",
-                method: "readFileString",
-                description: "invalid encoding",
-                cause,
-            }),
-        }),
-        stream: (path, options) => Function.pipe(impl.open(path, { flag: "r" }), options?.offset
-            ? Effect.tap((file) => file.seek(options.offset, "start"))
-            : Function.identity, Effect.map((file) => fileStream(file, options)), Stream.unwrapScoped),
-        sink: (path, options) => Function.pipe(impl.open(path, { flag: "w", ...options }), Effect.map((file) => Sink.forEach((_) => file.writeAll(_))), Sink.unwrapScoped),
-        writeFileString: (path, data, options) => Effect.flatMap(Effect.try({
-            try: () => new TextEncoder().encode(data),
-            catch: (cause) => new PlatformError.BadArgument({
-                module: "FileSystem",
-                method: "writeFileString",
-                description: "could not encode string",
-                cause,
-            }),
-        }), (_) => impl.writeFile(path, _, options)),
-    });
-};
-const fileStream = (file, { bufferSize = 16, bytesToRead: bytesToRead_, chunkSize: chunkSize_ = Size(64 * 1024), } = {}) => {
-    const bytesToRead = bytesToRead_ !== undefined ? Size(bytesToRead_) : undefined;
-    const chunkSize = Size(chunkSize_);
-    function loop(totalBytesRead) {
-        if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
-            return Channel.void;
-        }
-        const toRead = bytesToRead !== undefined && bytesToRead - totalBytesRead < chunkSize
-            ? bytesToRead - totalBytesRead
-            : chunkSize;
-        return Channel.flatMap(file.readAlloc(toRead), Option.match({
-            onNone: () => Channel.void,
-            onSome: (buf) => Channel.flatMap(Channel.write(Chunk.of(buf)), () => loop(totalBytesRead + BigInt(buf.length))),
-        }));
-    }
-    return Stream.bufferChunks(Stream.fromChannel(loop(BigInt(0))), {
-        capacity: bufferSize,
-    });
-};

package/dist/Http.d.ts

@@ -1,37 +0,0 @@
-export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
-type Respondable = Response | Promise<Response>;
-export type WebHandler = (request: Request) => Respondable;
-export type WebMiddleware = (request: Request, next: WebHandler) => Respondable;
-export declare function fetch(handler: WebHandler, init: Omit<RequestInit, "body"> & ({
-    url: string;
-} | {
-    path: `/${string}`;
-}) & {
-    body?: RequestInit["body"] | Record<string, unknown>;
-}): Promise<Response>;
-export declare function createAbortableRequest(init: Omit<RequestInit, "signal"> & ({
-    url: string;
-} | {
-    path: `/${string}`;
-})): {
-    request: Request;
-    abort: () => void;
-};
-export declare function mapHeaders(headers: Headers): Record<string, string | undefined>;
-export declare function parseCookies(cookieHeader: string | null): Record<string, string | undefined>;
-export declare function mapUrlSearchParams(params: URLSearchParams): Record<string, string | ReadonlyArray<string> | undefined>;
-export interface FilePart {
-    readonly _tag: "File";
-    readonly key: string;
-    readonly name: string;
-    readonly contentType: string;
-    readonly content: Uint8Array;
-}
-export interface FieldPart {
-    readonly _tag: "Field";
-    readonly key: string;
-    readonly value: string;
-}
-export type MultipartPart = FilePart | FieldPart;
-export declare function parseFormData(request: Request): Promise<Record<string, ReadonlyArray<FilePart> | ReadonlyArray<string> | string>>;
-export {};

package/dist/Http.js

@@ -1,88 +0,0 @@
-import * as Values from "./Values.js";
-export function fetch(handler, init) {
-    const url = "path" in init ? `http://localhost${init.path}` : init.url;
-    const isPlain = Values.isPlainObject(init.body);
-    const headers = new Headers(init.headers);
-    if (isPlain && !headers.has("Content-Type")) {
-        headers.set("Content-Type", "application/json");
-    }
-    const body = isPlain ? JSON.stringify(init.body) : init.body;
-    const request = new Request(url, {
-        ...init,
-        headers,
-        body: body,
-    });
-    return Promise.resolve(handler(request));
-}
-export function createAbortableRequest(init) {
-    const url = "path" in init ? `http://localhost${init.path}` : init.url;
-    const controller = new AbortController();
-    const request = new Request(url, { ...init, signal: controller.signal });
-    return { request, abort: () => controller.abort() };
-}
-export function mapHeaders(headers) {
-    const result = {};
-    headers.forEach((value, key) => {
-        result[key.toLowerCase()] = value;
-    });
-    return result;
-}
-export function parseCookies(cookieHeader) {
-    if (!cookieHeader)
-        return {};
-    const result = {};
-    for (const part of cookieHeader.split(";")) {
-        const idx = part.indexOf("=");
-        if (idx === -1) {
-            // Cookie without value (e.g., "name" or just whitespace)
-            const key = part.trim();
-            if (key) {
-                result[key] = undefined;
-            }
-        }
-        else {
-            const key = part.slice(0, idx).trim();
-            const value = part.slice(idx + 1).trim();
-            if (key) {
-                result[key] = value;
-            }
-        }
-    }
-    return result;
-}
-export function mapUrlSearchParams(params) {
-    const result = {};
-    for (const key of new Set(params.keys())) {
-        const values = params.getAll(key);
-        result[key] = values.length === 1 ? values[0] : values;
-    }
-    return result;
-}
-export async function parseFormData(request) {
-    const formData = await request.formData();
-    const result = {};
-    for (const key of new Set(formData.keys())) {
-        const values = formData.getAll(key);
-        const first = values[0];
-        if (typeof first === "string") {
-            result[key] = values.length === 1 ? first : values;
-        }
-        else {
-            const files = [];
-            for (const value of values) {
-                if (typeof value !== "string") {
-                    const content = new Uint8Array(await value.arrayBuffer());
-                    files.push({
-                        _tag: "File",
-                        key,
-                        name: value.name,
-                        contentType: value.type || "application/octet-stream",
-                        content,
-                    });
-                }
-            }
-            result[key] = files;
-        }
-    }
-    return result;
-}

package/dist/HttpAppExtra.d.ts

@@ -1,7 +0,0 @@
-import { HttpServerRequest, HttpServerResponse } from "@effect/platform";
-import * as HttpApp from "@effect/platform/HttpApp";
-import { RouteNotFound } from "@effect/platform/HttpServerError";
-import { Effect } from "effect";
-export declare const renderError: (error: unknown, accept?: string) => Effect.Effect<HttpServerResponse.HttpServerResponse, never, HttpServerRequest.HttpServerRequest>;
-export declare function handleErrors<E, R>(app: HttpApp.Default<E, R>): HttpApp.Default<Exclude<E, RouteNotFound>, R | HttpServerRequest.HttpServerRequest>;
-export declare const withErrorHandled: <E, R>(app: HttpApp.Default<E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, never, HttpServerRequest.HttpServerRequest | R>;

package/dist/HttpAppExtra.js

@@ -1,320 +0,0 @@
-import { HttpServerRequest, HttpServerResponse, } from "@effect/platform";
-import * as HttpMiddleware from "@effect/platform/HttpMiddleware";
-import { Cause, Effect, Option, ParseResult, Record, } from "effect";
-/**
- * Groups: function, path
- */
-const StackLinePattern = /^at (.*?) \((.*?)\)/;
-const ERROR_PAGE_CSS = `
-  :root {
-    --error-red: #c00;
-    --error-red-dark: #a00;
-    --bg-error: #fee;
-    --bg-light: #f5f5f5;
-    --bg-white: #fff;
-    --border-color: #ddd;
-    --text-dark: #333;
-    --text-gray: #666;
-    --text-mono: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
-  }
-
-  * { box-sizing: border-box; }
-
-  body {
-    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif;
-    margin: 0;
-    padding: 0;
-    color: var(--text-dark);
-    line-height: 1.6;
-    min-height: 100dvh;
-  }
-
-  .error-page { width: 100%; margin: 0; }
-
-  .error-header {
-    background: var(--error-red);
-    color: white;
-    padding: 2rem 2.5rem;
-    margin: 0;
-    font-family: var(--text-mono);
-  }
-
-  .error-header h1 {
-    margin: 0 0 0.5rem 0;
-    font-size: 2rem;
-    font-weight: 600;
-    font-family: var(--text-mono);
-  }
-
-  .error-message {
-    margin: 0;
-    font-size: 1.1rem;
-    opacity: 0.95;
-    font-family: var(--text-mono);
-  }
-
-  .error-content {
-    background: var(--bg-white);
-    padding: 2rem 2.5rem;
-  }
-
-  .stack-trace {
-    margin: 1.5rem 0;
-    border: 1px solid var(--border-color);
-    border-radius: 4px;
-    overflow: hidden;
-  }
-
-  .stack-trace-header {
-    font-weight: 600;
-    padding: 0.75rem 1rem;
-    background: var(--bg-light);
-    border-bottom: 1px solid var(--border-color);
-  }
-
-  .stack-list {
-    list-style: none;
-    padding: 0;
-    margin: 0;
-    max-height: 400px;
-    overflow-y: auto;
-  }
-
-  .stack-list li {
-    padding: 0.5rem 1rem;
-    font-family: var(--text-mono);
-    font-size: 0.875rem;
-    border-bottom: 1px solid var(--border-color);
-    background: var(--bg-white);
-  }
-
-  .stack-list li:last-child { border-bottom: none; }
-
-  .stack-list li:hover { background: #fafafa; }
-
-  .stack-list code {
-    background: transparent;
-    padding: 0;
-    font-weight: 600;
-    color: var(--error-red-dark);
-  }
-
-  .stack-list .path { color: var(--text-gray); margin-left: 0.5rem; }
-
-  .request-info {
-    margin: 1.5rem 0;
-    border: 1px solid var(--border-color);
-    border-radius: 4px;
-    overflow: hidden;
-  }
-
-  .request-info-header {
-    font-weight: 700;
-    padding: 0.75rem 1rem;
-    background: var(--bg-light);
-    border-bottom: 1px solid var(--border-color);
-  }
-
-  .request-info-content {
-    padding: 1rem;
-    font-family: var(--text-mono);
-    font-size: 0.875rem;
-    white-space: pre-wrap;
-    word-break: break-all;
-  }
-
-  @media (max-width: 768px) {
-    .error-header, .error-content { padding: 1.5rem 1rem; }
-    .error-header h1 { font-size: 1.5rem; }
-  }
-`;
-function errorHtml(data) {
-    let detailsHtml = "";
-    if (data.details) {
-        const detailsObj = data.details;
-        if ("stack" in detailsObj && Array.isArray(detailsObj.stack)) {
-            const stackFrames = detailsObj.stack;
-            detailsHtml = renderStackTrace(stackFrames);
-        }
-    }
-    const requestHtml = data.requestContext
-        ? renderRequestContext(data.requestContext)
-        : "";
-    const messageHtml = data.message
-        ? `<p class="error-message">${escapeHtml(data.message)}</p>`
-        : "";
-    const headerTitle = data.errorName ?? "UnexpectedError";
-    const html = `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${headerTitle} - Error ${data.status}</title>
-  <style>${ERROR_PAGE_CSS}</style>
-</head>
-<body>
-  <div class="error-header">
-    <h1>${escapeHtml(headerTitle)}</h1>
-    ${messageHtml}
-  </div>
-  <div class="error-content">
-    ${detailsHtml}
-    ${requestHtml}
-  </div>
-</body>
-</html>`;
-    return HttpServerResponse.text(html, {
-        status: data.status,
-        contentType: "text/html",
-    });
-}
-function errorText(status, tag, details) {
-    const text = details ? `${tag}\n${JSON.stringify(details, null, 2)}` : tag;
-    return HttpServerResponse.text(text, { status });
-}
-function respondWithError(accept, status, tag, message, details, requestContext, errorName) {
-    if (accept.includes("text/html")) {
-        return errorHtml({
-            status,
-            tag,
-            message,
-            details,
-            requestContext,
-            errorName,
-        });
-    }
-    if (accept.includes("text/plain")) {
-        return errorText(status, tag, details);
-    }
-    return HttpServerResponse.unsafeJson({ error: { _tag: tag, ...details } }, { status });
-}
-export const renderError = (error, accept = "") => Effect.gen(function* () {
-    const request = yield* HttpServerRequest.HttpServerRequest;
-    const requestContext = {
-        url: request.url,
-        method: request.method,
-        headers: filterSensitiveHeaders(request.headers),
-    };
-    let unwrappedError;
-    if (Cause.isCause(error)) {
-        const failure = Cause.failureOption(error).pipe(Option.getOrUndefined);
-        if (failure?.["_tag"]) {
-            unwrappedError = failure;
-        }
-        yield* Effect.logError(error);
-    }
-    switch (unwrappedError?._tag) {
-        case "RouteNotFound":
-            return respondWithError(accept, 404, "RouteNotFound", "The page you were looking for doesn't exist", undefined, requestContext);
-        case "RequestError": {
-            const message = unwrappedError.reason === "Decode"
-                ? "Request body is invalid"
-                : "Request could not be processed";
-            return respondWithError(accept, 400, "RequestError", message, {
-                reason: unwrappedError.reason,
-            }, requestContext);
-        }
-        case "ParseError": {
-            const issues = yield* ParseResult.ArrayFormatter.formatIssue(unwrappedError.issue);
-            const cleanIssues = issues.map((v) => Record.remove(v, "_tag"));
-            return respondWithError(accept, 400, "ParseError", "Validation failed", {
-                issues: cleanIssues,
-            }, requestContext);
-        }
-    }
-    if (Cause.isCause(error)) {
-        const defects = [...Cause.defects(error)];
-        const defect = defects[0];
-        if (defect instanceof Error) {
-            const stackFrames = extractPrettyStack(defect.stack ?? "");
-            return respondWithError(accept, 500, "UnexpectedError", defect.message, {
-                name: defect.name,
-                stack: stackFrames,
-            }, requestContext, defect.name);
-        }
-    }
-    return respondWithError(accept, 500, "UnexpectedError", "An unexpected error occurred", undefined, requestContext, "UnexpectedError");
-});
-function parseStackFrame(line) {
-    const match = line.trim().match(StackLinePattern);
-    if (!match)
-        return null;
-    const [_, fn, fullPath] = match;
-    const relativePath = fullPath.replace(process.cwd(), ".");
-    let type;
-    if (relativePath.includes("node_modules")) {
-        type = "node_modules";
-    }
-    else if (relativePath.startsWith("./src")
-        || relativePath.startsWith("./examples")) {
-        type = "application";
-    }
-    else {
-        type = "framework";
-    }
-    return {
-        function: fn,
-        file: relativePath,
-        type,
-    };
-}
-function extractPrettyStack(stack) {
-    return stack
-        .split("\n")
-        .slice(1)
-        .map(parseStackFrame)
-        .filter((frame) => frame !== null);
-}
-function renderStackFrames(frames) {
-    if (frames.length === 0) {
-        return "<li>No stack frames</li>";
-    }
-    return frames
-        .map((f) => `<li><code>${f.function}</code> at <span class="path">${f.file}</span></li>`)
-        .join("");
-}
-function renderStackTrace(frames) {
-    return `
-    <div class="stack-trace">
-      <div class="stack-trace-header">Stack Trace (${frames.length})</div>
-      <ul class="stack-list">${renderStackFrames(frames)}</ul>
-    </div>
-  `;
-}
-function escapeHtml(unsafe) {
-    return unsafe
-        .replace(/&/g, "&amp;")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;")
-        .replace(/"/g, "&quot;")
-        .replace(/'/g, "&#039;");
-}
-function filterSensitiveHeaders(headers) {
-    const sensitive = ["authorization", "cookie", "x-api-key"];
-    return Object.fromEntries(Object.entries(headers).filter(([key]) => !sensitive.includes(key.toLowerCase())));
-}
-function renderRequestContext(context) {
-    const headersText = Object
-        .entries(context.headers)
-        .map(([key, value]) => `${key}: ${value}`)
-        .join("\n");
-    const requestText = `${context.method} ${context.url}\n${headersText}`;
-    return `
-    <div class="request-info">
-      <div class="request-info-header">Request</div>
-      <div class="request-info-content">${escapeHtml(requestText)}</div>
-    </div>
-  `;
-}
-export function handleErrors(app) {
-    return Effect.gen(function* () {
-        const request = yield* HttpServerRequest.HttpServerRequest;
-        const accept = request.headers.accept ?? "";
-        return yield* app.pipe(Effect.catchAllCause((cause) => renderError(cause, accept)));
-    });
-}
-export const withErrorHandled = HttpMiddleware.make(app => Effect.gen(function* () {
-    const request = yield* HttpServerRequest.HttpServerRequest;
-    const accept = request.headers.accept ?? "";
-    return yield* app.pipe(Effect.catchAllCause((cause) => renderError(cause, accept)));
-}));

package/dist/HttpUtils.d.ts

@@ -1,3 +0,0 @@
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
-export type FetchHandler = (request: Request) => Promise<Response>;
-export declare function makeUrlFromRequest(request: HttpServerRequest.HttpServerRequest): URL;