effect-start 0.17.2 → 0.19.0

package/dist/Development.d.ts

@@ -1,5 +1,10 @@
-import { Context, Effect, Layer, PubSub, Stream } from "effect";
-import { Error, FileSystem } from "./node/FileSystem.ts";
+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 Stream from "effect/Stream";
+import * as Error from "./node/PlatformError.ts";
+import * as FileSystem from "@effect/platform/FileSystem";
 export type DevelopmentEvent = FileSystem.WatchEvent | {
     readonly _tag: "Reload";
 };

package/dist/Development.js

@@ -1,7 +1,13 @@
-import { Context, Effect, Function, Layer, Option, pipe, PubSub, Stream, } from "effect";
-import { globalValue } from "effect/GlobalValue";
-import { FileSystem, } from "./node/FileSystem.js";
-const devState = globalValue(Symbol.for("effect-start/Development"), () => ({
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as GlobalValue from "effect/GlobalValue";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as PubSub from "effect/PubSub";
+import * as Stream from "effect/Stream";
+import * as FileSystem from "@effect/platform/FileSystem";
+const devState = GlobalValue.globalValue(Symbol.for("effect-start/Development"), () => ({
     count: 0,
     pubsub: null,
 }));
@@ -34,7 +40,7 @@ export const watch = (opts) => Effect.gen(function* () {
     if (devState.count === 1) {
         const pubsub = yield* PubSub.unbounded();
         devState.pubsub = pubsub;
-        yield* pipe(watchSource({
+        yield* Function.pipe(watchSource({
             path: opts?.path,
             recursive: opts?.recursive,
             filter: opts?.filter ?? filterSourceFiles,
@@ -46,7 +52,7 @@ export const watch = (opts) => Effect.gen(function* () {
     return { events: devState.pubsub };
 });
 export const layerWatch = (opts) => Layer.scoped(Development, watch(opts));
-export const stream = () => Stream.unwrap(pipe(Effect.serviceOption(Development), Effect.map(Option.match({
+export const stream = () => Stream.unwrap(Function.pipe(Effect.serviceOption(Development), Effect.map(Option.match({
     onNone: () => Stream.empty,
     onSome: (dev) => Stream.fromPubSub(dev.events),
 }))));

package/dist/PlatformRuntime.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Are we running within an agent harness, like Claude Code?
+ */
+export declare function isAgentHarness(): string | false | undefined;

package/dist/PlatformRuntime.js

@@ -0,0 +1,9 @@
+/**
+ * Are we running within an agent harness, like Claude Code?
+ */
+export function isAgentHarness() {
+    return typeof process !== "undefined"
+        && !process.stdout.isTTY
+        && (process.env.CLAUDECODE
+            || process.env.CURSOR_AGENT);
+}

package/dist/Route.d.ts

@@ -1,8 +1,8 @@
 import * as Context from "effect/Context";
-import type * as Effect from "effect/Effect";
+import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Pipeable from "effect/Pipeable";
-import type * as Entity from "./Entity.ts";
+import * as Entity from "./Entity.ts";
 import * as RouteBody from "./RouteBody.ts";
 import * as RouteTree from "./RouteTree.ts";
 import * as Values from "./Values.ts";
@@ -91,8 +91,12 @@ export declare const json: RouteBody.BuildReturn<Values.Json, "json">;
 export declare const bytes: RouteBody.BuildReturn<Uint8Array<ArrayBufferLike>, "bytes">;
 export { render, } from "./RouteBody.ts";
 export { sse, } from "./RouteSse.ts";
+export declare function redirect(url: string | URL, status?: 301 | 302 | 303 | 307 | 308): Entity.Entity<"">;
 declare const Routes_base: Context.TagClass<Routes, "effect-start/Routes", RouteTree.RouteTree<RouteTree.RouteMap>>;
 export declare class Routes extends Routes_base {
 }
 export declare function layer(routes: RouteTree.RouteMap | RouteTree.RouteTree): Layer.Layer<Routes, never, never>;
 export { make as tree, } from "./RouteTree.ts";
+export declare function lazy<T extends RouteSet.Any>(load: () => Promise<{
+    default: T;
+}>): Effect.Effect<T, never, never>;

package/dist/Route.js

@@ -1,7 +1,9 @@
 import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Pipeable from "effect/Pipeable";
 import * as Predicate from "effect/Predicate";
+import * as Entity from "./Entity.js";
 import * as RouteBody from "./RouteBody.js";
 import * as RouteTree from "./RouteTree.js";
 export const RouteItems = Symbol();
@@ -71,6 +73,14 @@ export const bytes = RouteBody.build({
 });
 export { render, } from "./RouteBody.js";
 export { sse, } from "./RouteSse.js";
+export function redirect(url, status = 302) {
+    return Entity.make("", {
+        status,
+        headers: {
+            location: url instanceof URL ? url.href : url,
+        },
+    });
+}
 export class Routes extends Context.Tag("effect-start/Routes")() {
 }
 export function layer(routes) {
@@ -79,3 +89,15 @@ export function layer(routes) {
         : RouteTree.make(routes));
 }
 export { make as tree, } from "./RouteTree.js";
+export function lazy(load) {
+    let cached;
+    return Effect.suspend(() => {
+        if (cached !== undefined) {
+            return Effect.succeed(cached);
+        }
+        return Effect.promise(load).pipe(Effect.map((mod) => {
+            cached = mod.default;
+            return cached;
+        }));
+    });
+}

package/dist/RouteHttp.d.ts

@@ -5,7 +5,6 @@ import * as Route from "./Route.ts";
 import * as RouteBody from "./RouteBody.ts";
 import * as RouteMount from "./RouteMount.ts";
 import * as RouteTree from "./RouteTree.ts";
-export { currentSpanNameGenerator, currentTracerDisabledWhen, parentSpanFromHeaders, withSpanNameGenerator, withTracerDisabledWhen, } from "./RouteHttpTracer.ts";
 type UnboundedRouteWithMethod = Route.Route.With<{
     method: RouteMount.RouteMount.Method;
     format?: RouteBody.Format;
@@ -19,3 +18,4 @@ export declare const clientAbortFiberId: FiberId.Runtime;
 export declare const toWebHandlerRuntime: <R>(runtime: Runtime.Runtime<R>) => (routes: Iterable<UnboundedRouteWithMethod>) => Http.WebHandler;
 export declare const toWebHandler: (routes: Iterable<UnboundedRouteWithMethod>) => Http.WebHandler;
 export declare function walkHandles(tree: RouteTree.RouteTree, runtime?: Runtime.Runtime<never>): Generator<[path: string, handler: Http.WebHandler]>;
+export {};

package/dist/RouteHttp.js

@@ -12,7 +12,6 @@ import * as Route from "./Route.js";
 import * as RouteHttpTracer from "./RouteHttpTracer.js";
 import * as RouteTree from "./RouteTree.js";
 import * as StreamExtra from "./StreamExtra.js";
-export { currentSpanNameGenerator, currentTracerDisabledWhen, parentSpanFromHeaders, withSpanNameGenerator, withTracerDisabledWhen, } from "./RouteHttpTracer.js";
 // Used to match Accept headers against available route formats.
 // text/* matches any text type (text/plain, text/event-stream, text/markdown, etc.)
 const formatToMediaType = {
@@ -46,6 +45,10 @@ const getStatusFromCause = (cause) => {
     }
     return 500;
 };
+const respondError = (options) => new Response(JSON.stringify(options, null, 2), {
+    status: options.status,
+    headers: { "content-type": "application/json" },
+});
 function streamResponse(stream, headers, status, runtime) {
     const encoder = new TextEncoder();
     const byteStream = stream.pipe(Stream.map((chunk) => typeof chunk === "string"
@@ -116,9 +119,7 @@ export const toWebHandlerRuntime = (runtime) => {
             const accept = request.headers.get("accept");
             const methodRoutes = methodGroups[method] ?? [];
             if (methodRoutes.length === 0 && wildcards.length === 0) {
-                return Promise.resolve(Response.json({ status: 405, message: "method not allowed" }, {
-                    status: 405,
-                }));
+                return Promise.resolve(respondError({ status: 405, message: "method not allowed" }));
             }
             const allRoutes = [...wildcards, ...methodRoutes];
             const selectedFormat = determineSelectedFormat(accept, allRoutes);
@@ -130,9 +131,7 @@ export const toWebHandlerRuntime = (runtime) => {
             if (selectedFormat === undefined
                 && hasSpecificFormatRoutes
                 && !hasWildcardFormatRoutes) {
-                return Promise.resolve(Response.json({ status: 406, message: "not acceptable" }, {
-                    status: 406,
-                }));
+                return Promise.resolve(respondError({ status: 406, message: "not acceptable" }));
             }
             const createChain = (initialContext) => {
                 let index = 0;
@@ -178,9 +177,7 @@ export const toWebHandlerRuntime = (runtime) => {
                         ? result
                         : Entity.make(result, { status: 200 });
                     if (entity.status === 404 && entity.body === undefined) {
-                        return Response.json({ status: 406, message: "not acceptable" }, {
-                            status: 406,
-                        });
+                        return respondError({ status: 406, message: "not acceptable" });
                     }
                     return yield* toResponse(entity, selectedFormat, runtime);
                 });
@@ -217,9 +214,8 @@ export const toWebHandlerRuntime = (runtime) => {
                 const fiber = runFork(effect.pipe(Effect.scoped, Effect.catchAllCause((cause) => Effect.gen(function* () {
                     yield* Effect.logError(cause);
                     const status = getStatusFromCause(cause);
-                    return Response.json({ status, message: Cause.pretty(cause) }, {
-                        status,
-                    });
+                    const message = Cause.pretty(cause, { renderErrorCause: true });
+                    return respondError({ status, message });
                 }))));
                 request.signal?.addEventListener("abort", () => {
                     fiber.unsafeInterruptAsFork(clientAbortFiberId);
@@ -229,15 +225,12 @@ export const toWebHandlerRuntime = (runtime) => {
                         resolve(exit.value);
                     }
                     else if (isClientAbort(exit.cause)) {
-                        resolve(Response.json({ status: 499, message: "client closed request" }, {
-                            status: 499,
-                        }));
+                        resolve(respondError({ status: 499, message: "client closed request" }));
                     }
                     else {
                         const status = getStatusFromCause(exit.cause);
-                        resolve(Response.json({ status, message: Cause.pretty(exit.cause) }, {
-                            status,
-                        }));
+                        const message = Cause.pretty(exit.cause, { renderErrorCause: true });
+                        resolve(respondError({ status, message }));
                     }
                 });
             });

package/dist/RouteMount.d.ts

@@ -2,6 +2,7 @@ import * as Types from "effect/Types";
 import * as Http from "./Http.ts";
 import * as PathPattern from "./PathPattern.ts";
 import * as Route from "./Route.ts";
+import * as RouteBody from "./RouteBody.ts";
 type Module = typeof import("./RouteMount.ts");
 export type Self = RouteMount.Builder | Module;
 export declare const use: RouteMount.Describer<"*">;
@@ -16,7 +17,7 @@ export declare const add: RouteMount.Add;
 export type MountedRoute = Route.Route.Route<{
     method: RouteMount.Method;
     path: PathPattern.PathPattern;
-    format?: string;
+    format?: RouteBody.Format;
 }, {}, any, any, any>;
 export declare namespace RouteMount {
     export type Method = "*" | Http.Method;

package/dist/Start.d.ts

@@ -1,7 +1,3 @@
-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 [
@@ -15,5 +11,5 @@ export declare function layer<Layers extends [
     [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>;
+    default: Layer.Layer<ROut, E, BunHttpServer.BunHttpServer>;
 }>): void;

package/dist/Start.js

@@ -1,23 +1,16 @@
-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,
+    return Function.pipe(BunHttpServer.layerAuto(), Layer.provide(appLayer), Layer.provide([
         BunHttpServer.layer(),
-        NodeFileSystem.layer,
         StartApp.layer(),
     ]), Layer.launch, BunRuntime.runMain);
 }

package/dist/Unique.d.ts

@@ -0,0 +1,50 @@
+export declare const ALPHABET_BASE32_CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+export declare const ALPHABET_BASE32_RFC4648 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+export declare const ALPHABET_BASE64_URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+export declare const ALPHABET_HEX = "0123456789abcdef";
+/**
+ * Generate a random string for ids, session tokens, and API keys.
+ * It uses human-friendly crockford base32 encoding (5 bit of entropy per char)
+ *
+ * Minimal recommended length:
+ * - public ids: 16 chars (~80 bits)
+ * - API keys: 32 chars (~160 bits)
+ * - session tokens: 32-40 chars (~160-200 bits)
+ */
+export declare function token(length?: number): string;
+export declare function bytes(length: number): Uint8Array;
+export declare const UUID_NIL = "00000000-0000-0000-0000-000000000000";
+export declare function uuid4(): string;
+export declare function uuid7(time?: number): string;
+/**
+ * Decode a 48-bit Unix timestamp (ms) from UUID7 or ULID.
+ *
+ * @example
+ * const bytes = Unique.uuid7Bytes()
+ * const timestamp = Unique.toTimestamp(bytes)
+ *
+ * @example
+ * const bytes = Unique.ulidBytes()
+ * const timestamp = Unique.toTimestamp(bytes)
+ */
+export declare function toTimestamp(bytes: Uint8Array): number;
+export declare function uuid7Bytes(time?: number): Uint8Array;
+/**
+ * Convert UUID bytes to canonical (RFC9562) representation.
+ *
+ * @example
+ * Unique.formatUuid(new Uint8Array(16))
+ */
+export declare function formatUuid(bytes: Uint8Array): string;
+export declare function ulid(time?: number): string;
+export declare function ulidBytes(time?: number): Uint8Array;
+/**
+ * Generate a nanoid-style random string.
+ *
+ * FUN_FACT: Original nanoid implementation uses base64url alphabet
+ * with non-standard custom order where charater form common words found
+ * in source code (like use, random, strict) to make gzip/brotli more efficient.
+ * It's qt lil opt from the times where web developers
+ * were competing to have the smallest possible bundle size.
+ */
+export declare function nanoid(size?: number, alphabet?: string): string;

package/dist/Unique.js

@@ -0,0 +1,187 @@
+export const ALPHABET_BASE32_CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+export const ALPHABET_BASE32_RFC4648 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+export const ALPHABET_BASE64_URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+export const ALPHABET_HEX = "0123456789abcdef";
+/**
+ * Generate a random string for ids, session tokens, and API keys.
+ * It uses human-friendly crockford base32 encoding (5 bit of entropy per char)
+ *
+ * Minimal recommended length:
+ * - public ids: 16 chars (~80 bits)
+ * - API keys: 32 chars (~160 bits)
+ * - session tokens: 32-40 chars (~160-200 bits)
+ */
+export function token(length = 32) {
+    if (length <= 0)
+        return "";
+    const buf = new Uint8Array(length);
+    crypto.getRandomValues(buf);
+    let result = "";
+    for (let i = 0; i < buf.length; i++) {
+        result += ALPHABET_BASE32_CROCKFORD[buf[i] & 31];
+    }
+    return result;
+}
+export function bytes(length) {
+    const buf = new Uint8Array(length);
+    crypto.getRandomValues(buf);
+    return buf;
+}
+export const UUID_NIL = "00000000-0000-0000-0000-000000000000";
+export function uuid4() {
+    return formatUuid(uuid4bytes());
+}
+export function uuid7(time = Date.now()) {
+    return formatUuid(uuid7Bytes(time));
+}
+function uuid4bytes() {
+    const buf = bytes(16);
+    buf[6] = (buf[6] & 0x0f) | 0x40; // version 4
+    buf[8] = (buf[8] & 0x3f) | 0x80; // variant
+    return buf;
+}
+/**
+ * Decode a 48-bit Unix timestamp (ms) from UUID7 or ULID.
+ *
+ * @example
+ * const bytes = Unique.uuid7Bytes()
+ * const timestamp = Unique.toTimestamp(bytes)
+ *
+ * @example
+ * const bytes = Unique.ulidBytes()
+ * const timestamp = Unique.toTimestamp(bytes)
+ */
+export function toTimestamp(bytes) {
+    if (bytes.length < 6)
+        return 0;
+    return (bytes[0] * 0x10000000000
+        + bytes[1] * 0x100000000
+        + bytes[2] * 0x1000000
+        + bytes[3] * 0x10000
+        + bytes[4] * 0x100
+        + bytes[5]);
+}
+export function uuid7Bytes(time = Date.now()) {
+    const buf = new Uint8Array(16);
+    const timestamp = BigInt(toSafeTime(time));
+    // 48-bit timestamp (6 bytes)
+    buf[0] = Number((timestamp >> 40n) & 0xffn);
+    buf[1] = Number((timestamp >> 32n) & 0xffn);
+    buf[2] = Number((timestamp >> 24n) & 0xffn);
+    buf[3] = Number((timestamp >> 16n) & 0xffn);
+    buf[4] = Number((timestamp >> 8n) & 0xffn);
+    buf[5] = Number(timestamp & 0xffn);
+    // 12-bit random A (1.5 bytes)
+    crypto.getRandomValues(buf.subarray(6, 8));
+    buf[6] = (buf[6] & 0x0f) | 0x70; // version 7
+    // 2-bit variant + 62-bit random B (8 bytes)
+    crypto.getRandomValues(buf.subarray(8, 16));
+    buf[8] = (buf[8] & 0x3f) | 0x80; // variant
+    return buf;
+}
+/**
+ * Convert UUID bytes to canonical (RFC9562) representation.
+ *
+ * @example
+ * Unique.formatUuid(new Uint8Array(16))
+ */
+export function formatUuid(bytes) {
+    if (bytes.length === 0)
+        return "";
+    let result = "";
+    for (let i = 0; i < bytes.length; i++) {
+        const byte = bytes[i];
+        result += ALPHABET_HEX[(byte >> 4) & 0x0f];
+        result += ALPHABET_HEX[byte & 0x0f];
+        if (i === 3 || i === 5 || i === 7 || i === 9)
+            result += "-";
+    }
+    return result;
+}
+export function ulid(time = Date.now()) {
+    const bytes = ulidBytes(time);
+    return formatUlid(bytes);
+}
+export function ulidBytes(time = Date.now()) {
+    const buf = new Uint8Array(16);
+    const timestamp = BigInt(toSafeTime(time));
+    buf[0] = Number((timestamp >> 40n) & 0xffn);
+    buf[1] = Number((timestamp >> 32n) & 0xffn);
+    buf[2] = Number((timestamp >> 24n) & 0xffn);
+    buf[3] = Number((timestamp >> 16n) & 0xffn);
+    buf[4] = Number((timestamp >> 8n) & 0xffn);
+    buf[5] = Number(timestamp & 0xffn);
+    crypto.getRandomValues(buf.subarray(6, 16));
+    return buf;
+}
+function formatUlid(bytes) {
+    if (bytes.length !== 16)
+        return "";
+    const timestamp = toTimestamp(bytes);
+    const timePart = encodeUlidTime(timestamp);
+    const randomPart = toBase32(bytes.subarray(6, 16));
+    return `${timePart}${randomPart}`;
+}
+function encodeUlidTime(time) {
+    let value = BigInt(time);
+    const result = new Array(10);
+    for (let i = 9; i >= 0; i--) {
+        result[i] = ALPHABET_BASE32_CROCKFORD[Number(value & 31n)];
+        value >>= 5n;
+    }
+    return result.join("");
+}
+function toSafeTime(time) {
+    if (!Number.isFinite(time))
+        return 0;
+    return Math.max(0, Math.trunc(time));
+}
+/**
+ * Generate a nanoid-style random string.
+ *
+ * FUN_FACT: Original nanoid implementation uses base64url alphabet
+ * with non-standard custom order where charater form common words found
+ * in source code (like use, random, strict) to make gzip/brotli more efficient.
+ * It's qt lil opt from the times where web developers
+ * were competing to have the smallest possible bundle size.
+ */
+export function nanoid(size = 21, alphabet = ALPHABET_BASE64_URL) {
+    if (size <= 0 || alphabet.length === 0)
+        return "";
+    const length = alphabet.length;
+    const mask = (2 << Math.floor(Math.log2(length - 1))) - 1;
+    const step = Math.ceil((1.6 * mask * size) / length);
+    let id = "";
+    while (id.length < size) {
+        const bytes = new Uint8Array(step);
+        crypto.getRandomValues(bytes);
+        for (let i = 0; i < step && id.length < size; i++) {
+            const index = bytes[i] & mask;
+            if (index < length)
+                id += alphabet[index];
+        }
+    }
+    return id;
+}
+function toBase32(bytes, alphabet = ALPHABET_BASE32_CROCKFORD) {
+    if (bytes.length === 0)
+        return "";
+    let result = "";
+    let buffer = 0;
+    let bits = 0;
+    for (const byte of bytes) {
+        buffer = (buffer << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            bits -= 5;
+            const index = (buffer >> bits) & 31;
+            result += alphabet[index];
+            buffer &= (1 << bits) - 1;
+        }
+    }
+    if (bits > 0) {
+        const index = (buffer << (5 - bits)) & 31;
+        result += alphabet[index];
+    }
+    return result;
+}

package/dist/bun/BunHttpServer.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import * as HttpApp from "@effect/platform/HttpApp";
 import * as HttpServer from "@effect/platform/HttpServer";
 import * as HttpServerError from "@effect/platform/HttpServerError";
@@ -14,19 +13,19 @@ import * as FiberSet from "effect/FiberSet";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as PathPattern from "../PathPattern.js";
-import * as Random from "../Random.js";
+import * as PlataformRuntime from "../PlatformRuntime.js";
 import * as Route from "../Route.js";
 import * as RouteHttp from "../RouteHttp.js";
 import * as RouteTree from "../RouteTree.js";
+import * as Unique from "../Unique.js";
 import EmptyHTML from "./_empty.html";
 import { makeResponse, ServerRequestImpl, } from "./BunHttpServer_web.js";
 import * as BunRoute from "./BunRoute.js";
 export const BunHttpServer = Context.GenericTag("effect-start/BunServer");
 export const make = (options) => Effect.gen(function* () {
     const port = yield* Config.number("PORT").pipe(Effect.catchTag("ConfigError", () => {
-        if (typeof process !== "undefined"
-            && !process.stdout.isTTY
-            && process.env.CLAUDECODE) {
+        if (PlataformRuntime.isAgentHarness()) {
+            // use random port
             return Effect.succeed(0);
         }
         return Effect.succeed(3000);
@@ -41,7 +40,7 @@ export const make = (options) => Effect.gen(function* () {
     // Bun HMR doesn't work on successive calls to `server.reload` if there are no routes
     // on server start. We workaround that by passing a dummy HTMLBundle [2025-11-26]
     // see: https://github.com/oven-sh/bun/issues/23564
-    currentRoutes[`/.BunEmptyHtml-${Random.token(6)}`] = EmptyHTML;
+    currentRoutes[`/.BunEmptyHtml-${Unique.token(10)}`] = EmptyHTML;
     const websocket = {
         open(ws) {
             Deferred.unsafeDone(ws.data.deferred, Exit.succeed(ws));

package/dist/bun/BunRoute.d.ts

@@ -15,7 +15,7 @@ export type BunDescriptors = {
     bunPrefix: string;
     bunLoad: () => Promise<Bun.HTMLBundle>;
 };
-export declare function descriptors(route: Route.Route.Route): BunDescriptors | undefined;
+export declare function descriptors(route: Route.Route.Route<any, any, any, any, any>): BunDescriptors | undefined;
 export declare function htmlBundle(load: () => Promise<Bun.HTMLBundle | {
     default: Bun.HTMLBundle;
 }>): <D extends Route.RouteDescriptor.Any, B extends {}, I extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, B, I>) => Route.RouteSet.RouteSet<D, B, [...I, Route.Route.Route<BunDescriptors & {

package/dist/bun/BunRoute.js

@@ -5,7 +5,7 @@ import * as Option from "effect/Option";
 import * as Entity from "../Entity.js";
 import * as Hyper from "../hyper/Hyper.js";
 import * as HyperHtml from "../hyper/HyperHtml.js";
-import * as Random from "../Random.js";
+import * as Unique from "../Unique.js";
 import * as Route from "../Route.js";
 import * as RouterPattern from "../RouterPattern.js";
 import * as BunHttpServer from "./BunHttpServer.js";
@@ -21,7 +21,7 @@ export function descriptors(route) {
     return undefined;
 }
 export function htmlBundle(load) {
-    const bunPrefix = `/.BunRoute-${Random.token(6)}`;
+    const bunPrefix = `/.BunRoute-${Unique.token(10)}`;
     const bunLoad = () => load().then(mod => "default" in mod ? mod.default : mod);
     const descriptors = { bunPrefix, bunLoad, format: "html" };
     return function (self) {

package/dist/index.d.ts

@@ -2,5 +2,6 @@ export * as Bundle from "./bundler/Bundle.ts";
 export * as Development from "./Development.ts";
 export * as Entity from "./Entity.ts";
 export * as FileRouter from "./FileRouter.ts";
+export * as Unique from "./Unique.ts";
 export * as Route from "./Route.ts";
 export * as Start from "./Start.ts";

package/dist/index.js

@@ -2,5 +2,6 @@ export * as Bundle from "./bundler/Bundle.js";
 export * as Development from "./Development.js";
 export * as Entity from "./Entity.js";
 export * as FileRouter from "./FileRouter.js";
+export * as Unique from "./Unique.js";
 export * as Route from "./Route.js";
 export * as Start from "./Start.js";