effect-start 0.23.1 → 0.26.0

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>;

package/dist/PathPattern.js

@@ -1,413 +0,0 @@
-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/PlatformError.d.ts

@@ -1,38 +0,0 @@
-import type * as Cause from "effect/Cause";
-import type * as Types from "effect/Types";
-export declare const TypeId: unique symbol;
-export type TypeId = typeof TypeId;
-export declare const isPlatformError: (u: unknown) => u is PlatformError;
-export declare const TypeIdError: <const TypeId extends symbol, const Tag extends string>(typeId: TypeId, tag: Tag) => (new <A extends Record<string, any>>(args: Types.Simplify<A>) => Cause.YieldableError & Record<TypeId, TypeId> & {
-    readonly _tag: Tag;
-} & Readonly<A>);
-export type SystemErrorReason = "AlreadyExists" | "BadResource" | "Busy" | "InvalidData" | "NotFound" | "PermissionDenied" | "TimedOut" | "UnexpectedEof" | "Unknown" | "WouldBlock" | "WriteZero";
-declare const BadArgument_base: new <A extends Record<string, any> = {}>(args: Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
-    readonly _tag: "BadArgument";
-} & Readonly<A>;
-export declare class BadArgument extends BadArgument_base<{
-    module: string;
-    method: string;
-    description?: string | undefined;
-    cause?: unknown;
-}> {
-    readonly [TypeId]: typeof TypeId;
-    get message(): string;
-}
-declare const SystemError_base: new <A extends Record<string, any> = {}>(args: Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Cause.YieldableError & {
-    readonly _tag: "SystemError";
-} & Readonly<A>;
-export declare class SystemError extends SystemError_base<{
-    reason: SystemErrorReason;
-    module: string;
-    method: string;
-    description?: string | undefined;
-    syscall?: string | undefined;
-    pathOrDescriptor?: string | number | undefined;
-    cause?: unknown;
-}> {
-    readonly [TypeId]: typeof TypeId;
-    get message(): string;
-}
-export type PlatformError = BadArgument | SystemError;
-export {};

package/dist/PlatformError.js

@@ -1,25 +0,0 @@
-import * as Data from "effect/Data";
-import * as Predicate from "effect/Predicate";
-export const TypeId = Symbol.for("@effect/platform/Error/PlatformError");
-export const isPlatformError = (u) => Predicate.hasProperty(u, TypeId);
-export const TypeIdError = (typeId, tag) => {
-    class Base extends Data.Error {
-        _tag = tag;
-    }
-    ;
-    Base.prototype[typeId] = typeId;
-    Base.prototype.name = tag;
-    return Base;
-};
-export class BadArgument extends Data.TaggedError("BadArgument") {
-    [TypeId] = TypeId;
-    get message() {
-        return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`;
-    }
-}
-export class SystemError extends Data.TaggedError("SystemError") {
-    [TypeId] = TypeId;
-    get message() {
-        return `${this.reason}: ${this.module}.${this.method}${this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : ""}${this.description ? `: ${this.description}` : ""}`;
-    }
-}

package/dist/PlatformRuntime.d.ts

@@ -1,27 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import type * as Fiber from "effect/Fiber";
-export interface Teardown {
-    <E, A>(exit: Exit.Exit<E, A>, onExit: (code: number) => void): void;
-}
-export declare const defaultTeardown: Teardown;
-export interface RunMain {
-    (options?: {
-        readonly disableErrorReporting?: boolean | undefined;
-        readonly disablePrettyLogger?: boolean | undefined;
-        readonly teardown?: Teardown | undefined;
-    }): <E, A>(effect: Effect.Effect<A, E>) => void;
-    <E, A>(effect: Effect.Effect<A, E>, options?: {
-        readonly disableErrorReporting?: boolean | undefined;
-        readonly disablePrettyLogger?: boolean | undefined;
-        readonly teardown?: Teardown | undefined;
-    }): void;
-}
-export declare const makeRunMain: (f: <E, A>(options: {
-    readonly fiber: Fiber.RuntimeFiber<A, E>;
-    readonly teardown: Teardown;
-}) => void) => RunMain;
-/**
- * Are we running within an agent harness, like Claude Code?
- */
-export declare function isAgentHarness(): string | false | undefined;