effect-start 0.23.0 → 0.25.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/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/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;

package/dist/HttpUtils.js

@@ -1,11 +0,0 @@
-export function makeUrlFromRequest(request) {
-    const origin = request.headers.origin
-        ?? request.headers.host
-        ?? "http://localhost";
-    const protocol = request.headers["x-forwarded-proto"] ?? "http";
-    const host = request.headers.host ?? "localhost";
-    const base = origin.startsWith("http")
-        ? origin
-        : `${protocol}://${host}`;
-    return new URL(request.url, base);
-}

package/dist/PathPattern.d.ts

@@ -1,134 +0,0 @@
-export type PathPattern = `/${string}`;
-export type Segments<Path extends string> = Path extends `/${infer Rest}` ? Segments<Rest> : Path extends `${infer Head}/${infer Tail}` ? [Head, ...Segments<Tail>] : Path extends "" ? [] : [Path];
-export type Params<T extends string> = string extends T ? Record<string, string> : T extends `${infer _Start}:${infer Param}?/${infer Rest}` ? {
-    [K in Param]?: string;
-} & Params<`/${Rest}`> : T extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
-    [K in Param]: string;
-} & Params<`/${Rest}`> : T extends `${infer _Start}:${infer Param}+` ? {
-    [K in Param]: string;
-} : T extends `${infer _Start}:${infer Param}*` ? {
-    [K in Param]?: string;
-} : T extends `${infer _Start}:${infer Param}?` ? {
-    [K in Param]?: string;
-} : T extends `${infer _Start}:${infer Param}` ? {
-    [K in Param]: string;
-} : {};
-export type ValidateResult = {
-    ok: true;
-    segments: Array<string>;
-} | {
-    ok: false;
-    error: string;
-};
-export declare function validate(path: string): ValidateResult;
-export declare function match(pattern: string, path: string): Record<string, string> | null;
-export declare function toRegex(path: string): RegExp;
-/**
- * Converts to Express path pattern.
- *
- * @see https://expressjs.com/en/guide/routing.html
- *
- * - `:param` → `:param`
- * - `:param?` → `{/:param}`
- * - `:param+` → `/*param`
- * - `:param*` → `/`, `/*param`
- */
-export declare function toExpress(path: string): Array<string>;
-/**
- * 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 declare function toURLPattern(path: string): Array<string>;
-/**
- * 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 declare function toReactRouter(path: string): Array<string>;
-/**
- * Alias for toReactRouter.
- *
- * @see https://reactrouter.com/start/framework/routing
- */
-export declare const toRemix: typeof 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 declare function toRemixFile(path: string): string;
-/**
- * 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 declare function toTanStack(path: string): string;
-/**
- * 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 declare function toHono(path: string): Array<string>;
-/**
- * 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 declare function toEffect(path: string): Array<string>;
-/**
- * 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 declare function toBun(path: string): Array<PathPattern>;