t3code-cli 0.7.0 → 0.9.0

package/dist/transport-D3zBdZ1h.js

@@ -1,539 +0,0 @@
-import { An as identity, Cn as constFalse, Ft as BaseProto, Lt as NodeInspectSymbol, On as dual, Pn as pipeArguments, Rt as toJson, S as getOrUndefined, it as PipeInspectableProto, n as Service, p as merge, t as Reference, wn as constTrue } from "./Context-DueQ9iMH.js";
-import { A as failCause, Bt as useSpan, Ot as suspend, P as fn, Rt as uninterruptibleMask, Tt as succeed, Ut as withFiber, Wt as withParentSpan, X as map, b as catchTags, gn as hasInterrupts, j as flatMap, k as fail, kn as effect, kt as sync, ot as onInterrupt, tt as matchCauseEffect, ui as isFailure, w as contextWith, zr as DisablePropagation, zt as updateContext } from "./Path-D8WPdPwR.js";
-import { In as add, L as fromJsonString, Ln as formatIso, P as decodeUnknownEffect, Rn as now, Xt as suspend$1, b as Struct, bt as ensuring, d as Literals, et as optionalKey, g as Number$1, n as Boolean, u as Literal, y as String$1 } from "./Schema-DsQxYh6_.js";
-import { Dl as HttpClientErrorSchema, El as HttpClientError, Il as redact, Lu as allShort, Ml as CurrentRedactedNames, Ol as InvalidUrlError, Sl as setHeaders, _l as bearerToken, bl as make$2, dl as TypeId$2, fl as filterStatusOk$1, gl as acceptJson, iu as AuthAccessTokenType, ku as AuthTokenExchangeGrantType, ml as TypeId$3, mu as AuthEnvironmentBootstrapTokenType, rl as toHeaders, vl as bodyUrlParams, xl as post, yl as get } from "./src-KdbHqrex.js";
-import { r as makeUrl } from "./UrlParams-BA6gBvaY.js";
-import { n as toHttpEndpointUrl } from "./url-SlsaG8nY.js";
-import { s as AuthTransportError } from "./error-jwMt3VoW.js";
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/MutableRef.js
-const TypeId$1 = "~effect/MutableRef";
-const MutableRefProto = {
-	[TypeId$1]: TypeId$1,
-	...PipeInspectableProto,
-	toJSON() {
-		return {
-			_id: "MutableRef",
-			current: toJson(this.current)
-		};
-	}
-};
-/**
-* Creates a new MutableRef with the specified initial value.
-*
-* **When to use**
-*
-* Use to create a synchronous `MutableRef` initialized with a value.
-*
-* **Example** (Creating mutable refs)
-*
-* ```ts
-* import { MutableRef } from "effect"
-*
-* // Create a counter reference
-* const counter = MutableRef.make(0)
-* console.log(MutableRef.get(counter)) // 0
-*
-* // Create a configuration reference
-* const config = MutableRef.make({ debug: false, timeout: 5000 })
-* console.log(MutableRef.get(config)) // { debug: false, timeout: 5000 }
-*
-* // Create a string reference
-* const status = MutableRef.make("idle")
-* MutableRef.set(status, "running")
-* console.log(MutableRef.get(status)) // "running"
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
-const make$1 = (value) => {
-	const ref = Object.create(MutableRefProto);
-	ref.current = value;
-	return ref;
-};
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Ref.js
-/**
-* The `Ref` module provides fiber-safe mutable references for state inside
-* Effect programs. A `Ref<A>` holds one value of type `A` and exposes reads,
-* writes, and atomic transformations as effects, so state changes compose with
-* Effect's concurrency model.
-*
-* **Mental model**
-*
-* - {@link make} creates a reference with an initial value
-* - {@link get} reads the current value, and {@link set} replaces it
-* - {@link update}, {@link updateAndGet}, and {@link getAndUpdate} transform
-*   the current value atomically
-* - {@link modify} updates the value and returns a separate result computed
-*   from the previous value
-* - The `Some` variants use `Option` to leave the value unchanged when a
-*   partial update does not apply
-*
-* **Common tasks**
-*
-* - Create refs: {@link make}, {@link makeUnsafe}
-* - Read and write: {@link get}, {@link set}, {@link getAndSet},
-*   {@link setAndGet}
-* - Update state: {@link update}, {@link updateAndGet}, {@link getAndUpdate}
-* - Update conditionally: {@link updateSome}, {@link updateSomeAndGet},
-*   {@link getAndUpdateSome}, {@link modifySome}
-* - Compute while updating: {@link modify}
-*
-* **Example** (Updating shared state)
-*
-* ```ts
-* import { Effect, Ref } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   const counter = yield* Ref.make(0)
-*
-*   const next = yield* Ref.updateAndGet(counter, (n) => n + 1)
-*   const label = yield* Ref.modify(counter, (n) => [`count=${n}`, n + 1])
-*
-*   return { label, next }
-* })
-* ```
-*
-* **Gotchas**
-*
-* - Each `Ref` operation is atomic for that reference, but multiple refs are
-*   not updated transactionally as a group
-* - If the new value depends on the old value, prefer {@link update} or
-*   {@link modify} over a separate {@link get} followed by {@link set}
-* - Unsafe operations are synchronous low-level accessors; prefer effectful
-*   operations in application code
-*
-* @since 2.0.0
-*/
-const RefProto = {
-	["~effect/Ref"]: { _A: identity },
-	...PipeInspectableProto,
-	toJSON() {
-		return {
-			_id: "Ref",
-			ref: this.ref
-		};
-	}
-};
-/**
-* Creates a new Ref with the specified initial value (unsafe version).
-*
-* **When to use**
-*
-* Use when you need immediate synchronous construction and can guarantee
-* that creating the `Ref` outside of `Effect` is safe.
-*
-* **Gotchas**
-*
-* Prefer `Ref.make` for Effect-wrapped creation in Effect programs.
-*
-* **Example** (Creating a ref unsafely)
-*
-* ```ts
-* import { Ref } from "effect"
-*
-* // Create a ref directly without Effect
-* const counter = Ref.makeUnsafe(0)
-*
-* // Get the current value
-* const value = Ref.getUnsafe(counter)
-* console.log(value) // 0
-*
-* // Note: This is unsafe and should be used carefully
-* // Prefer Ref.make for Effect-wrapped creation
-* ```
-*
-* @category constructors
-* @since 4.0.0
-*/
-const makeUnsafe = (value) => {
-	const self = Object.create(RefProto);
-	self.ref = make$1(value);
-	return self;
-};
-/**
-* Gets the current value of the Ref, sets it to the specified value, and returns the previous value atomically.
-*
-* **When to use**
-*
-* Use to replace a plain `Ref` value while returning the previous value.
-*
-* **Example** (Replacing a value atomically)
-*
-* ```ts
-* import { Effect, Ref } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   const ref = yield* Ref.make("initial")
-*
-*   // Get current value and set new value atomically
-*   const previous = yield* Ref.getAndSet(ref, "updated")
-*   console.log(previous) // "initial"
-*
-*   const current = yield* Ref.get(ref)
-*   console.log(current) // "updated"
-* })
-* ```
-*
-* @see {@link set} for setting without returning the previous value
-* @see {@link getAndUpdate} for deriving the new value from the previous value
-*
-* @category mutations
-* @since 2.0.0
-*/
-const getAndSet = /*#__PURE__*/ dual(2, (self, value) => sync(() => {
-	const current = self.ref.current;
-	self.ref.current = value;
-	return current;
-}));
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/http/HttpClient.js
-const TypeId = "~effect/http/HttpClient";
-/**
-* Service tag for the default outgoing HTTP client service.
-*
-* **When to use**
-*
-* Use to provide the default outgoing HTTP client service used by request
-* accessors such as `execute`, `get`, and `post`.
-*
-* @category services
-* @since 4.0.0
-*/
-const HttpClient = /*#__PURE__*/ Service("effect/HttpClient");
-/**
-* Transforms a client by applying an effectful transformation to each response effect.
-*
-* @category mapping & sequencing
-* @since 4.0.0
-*/
-const transformResponse = /*#__PURE__*/ dual(2, (self, f) => makeWith((request) => f(self.postprocess(request)), self.preprocess));
-/**
-* Filters responses that return a 2xx status code.
-*
-* @category filters
-* @since 4.0.0
-*/
-const filterStatusOk = /*#__PURE__*/ transformResponse(/*#__PURE__*/ flatMap(filterStatusOk$1));
-/**
-* Constructs an `HttpClient.With` from a preprocessing function and a postprocessing function.
-*
-* **Details**
-*
-* `execute` applies preprocessing to the request and then passes the resulting request effect to postprocessing.
-*
-* @category constructors
-* @since 4.0.0
-*/
-const makeWith = (postprocess, preprocess) => {
-	const self = Object.create(Proto);
-	self.preprocess = preprocess;
-	self.postprocess = postprocess;
-	self.execute = function(request) {
-		return postprocess(preprocess(request));
-	};
-	return self;
-};
-const Proto = {
-	[TypeId]: TypeId,
-	pipe() {
-		return pipeArguments(this, arguments);
-	},
-	...BaseProto,
-	toJSON() {
-		return { _id: "effect/HttpClient" };
-	},
-	.../*#__PURE__*/ Object.fromEntries(/*#__PURE__*/ allShort.map(([fullMethod, method]) => [method, function(url, options) {
-		return this.execute(make$2(fullMethod)(url, options));
-	}]))
-};
-/**
-* Constructs an `HttpClient` from a low-level request runner.
-*
-* **Details**
-*
-* The runner receives the request, resolved URL, abort signal, and current fiber. The client wrapper handles URL construction failures, tracing and propagation, header redaction, and aborting non-scoped requests on interruption.
-*
-* @category constructors
-* @since 4.0.0
-*/
-const make = (f) => makeWith((effect) => flatMap(effect, (request) => withFiber((fiber) => {
-	const scopedController = scopedRequests.get(request);
-	const controller = scopedController ?? new AbortController();
-	const urlResult = makeUrl(request.url, request.urlParams, getOrUndefined(request.hash));
-	if (isFailure(urlResult)) return fail(new HttpClientError({ reason: new InvalidUrlError({
-		request,
-		cause: urlResult.failure
-	}) }));
-	const url = urlResult.success;
-	if (fiber.getRef(DisablePropagation) || fiber.getRef(TracerDisabledWhen)(request)) {
-		const effect = f(request, url, controller.signal, fiber);
-		if (scopedController) return effect;
-		return uninterruptibleMask((restore) => matchCauseEffect(restore(effect), {
-			onSuccess(response) {
-				responseRegistry.register(response, controller);
-				return succeed(new InterruptibleResponse(response, controller));
-			},
-			onFailure(cause) {
-				if (hasInterrupts(cause)) controller.abort();
-				return failCause(cause);
-			}
-		}));
-	}
-	return useSpan(fiber.getRef(SpanNameGenerator)(request), { kind: "client" }, (span) => {
-		span.attribute("http.request.method", request.method);
-		span.attribute("server.address", url.origin);
-		if (url.port !== "") span.attribute("server.port", +url.port);
-		span.attribute("url.full", url.toString());
-		span.attribute("url.path", url.pathname);
-		span.attribute("url.scheme", url.protocol.slice(0, -1));
-		const query = url.search.slice(1);
-		if (query !== "") span.attribute("url.query", query);
-		const redactedHeaderNames = fiber.getRef(CurrentRedactedNames);
-		const redactedHeaders = redact(request.headers, redactedHeaderNames);
-		for (const name in redactedHeaders) span.attribute(`http.request.header.${name}`, String(redactedHeaders[name]));
-		request = fiber.getRef(TracerPropagationEnabled) ? setHeaders(request, toHeaders(span)) : request;
-		return uninterruptibleMask((restore) => restore(f(request, url, controller.signal, fiber)).pipe(withParentSpan(span, { captureStackTrace: false }), matchCauseEffect({
-			onSuccess: (response) => {
-				span.attribute("http.response.status_code", response.status);
-				const redactedHeaders = redact(response.headers, redactedHeaderNames);
-				for (const name in redactedHeaders) span.attribute(`http.response.header.${name}`, String(redactedHeaders[name]));
-				if (scopedController) return succeed(response);
-				responseRegistry.register(response, controller);
-				return succeed(new InterruptibleResponse(response, controller));
-			},
-			onFailure(cause) {
-				if (!scopedController && hasInterrupts(cause)) controller.abort();
-				return failCause(cause);
-			}
-		})));
-	});
-})), succeed);
-/**
-* Context reference for a predicate that disables client-side tracing for matching outgoing requests.
-*
-* @category references
-* @since 4.0.0
-*/
-const TracerDisabledWhen = /*#__PURE__*/ Reference("effect/http/HttpClient/TracerDisabledWhen", { defaultValue: () => constFalse });
-/**
-* Context reference that controls whether outgoing client spans are propagated to request headers.
-*
-* @category references
-* @since 4.0.0
-*/
-const TracerPropagationEnabled = /*#__PURE__*/ Reference("effect/HttpClient/TracerPropagationEnabled", { defaultValue: constTrue });
-/**
-* Context reference for generating the span name used for outgoing client request spans.
-*
-* @category references
-* @since 4.0.0
-*/
-const SpanNameGenerator = /*#__PURE__*/ Reference("effect/http/HttpClient/SpanNameGenerator", { defaultValue: () => (request) => `http.client ${request.method}` });
-/**
-* Creates an `HttpClient` layer and merges the layer construction context into client response effects.
-*
-* @category layers
-* @since 4.0.0
-*/
-const layerMergedContext = (effect$1) => effect(HttpClient)(contextWith((context) => map(effect$1, (client) => transformResponse(client, updateContext((input) => merge(context, input))))));
-const responseRegistry = /*#__PURE__*/ (() => {
-	if ("FinalizationRegistry" in globalThis && globalThis.FinalizationRegistry) {
-		const registry = /*#__PURE__*/ new FinalizationRegistry((controller) => {
-			controller.abort();
-		});
-		return {
-			register(response, controller) {
-				registry.register(response, controller, response);
-			},
-			unregister(response) {
-				registry.unregister(response);
-			}
-		};
-	}
-	const timers = /*#__PURE__*/ new Map();
-	return {
-		register(response, controller) {
-			timers.set(response, setTimeout(() => controller.abort(), 5e3));
-		},
-		unregister(response) {
-			const timer = timers.get(response);
-			if (timer === void 0) return;
-			clearTimeout(timer);
-			timers.delete(response);
-		}
-	};
-})();
-const scopedRequests = /*#__PURE__*/ new WeakMap();
-var InterruptibleResponse = class {
-	original;
-	controller;
-	constructor(original, controller) {
-		this.original = original;
-		this.controller = controller;
-	}
-	[TypeId$2] = TypeId$2;
-	[TypeId$3] = TypeId$3;
-	applyInterrupt(effect) {
-		return suspend(() => {
-			responseRegistry.unregister(this.original);
-			return onInterrupt(effect, () => sync(() => {
-				this.controller.abort();
-			}));
-		});
-	}
-	get request() {
-		return this.original.request;
-	}
-	get status() {
-		return this.original.status;
-	}
-	get headers() {
-		return this.original.headers;
-	}
-	get cookies() {
-		return this.original.cookies;
-	}
-	get remoteAddress() {
-		return this.original.remoteAddress;
-	}
-	get formData() {
-		return this.applyInterrupt(this.original.formData);
-	}
-	get text() {
-		return this.applyInterrupt(this.original.text);
-	}
-	get json() {
-		return this.applyInterrupt(this.original.json);
-	}
-	get urlParamsBody() {
-		return this.applyInterrupt(this.original.urlParamsBody);
-	}
-	get arrayBuffer() {
-		return this.applyInterrupt(this.original.arrayBuffer);
-	}
-	get stream() {
-		return suspend$1(() => {
-			responseRegistry.unregister(this.original);
-			return ensuring(this.original.stream, sync(() => {
-				this.controller.abort();
-			}));
-		});
-	}
-	toJSON() {
-		return this.original.toJSON();
-	}
-	[NodeInspectSymbol]() {
-		return this.original[NodeInspectSymbol]();
-	}
-	pipe() {
-		return pipeArguments(this, arguments);
-	}
-};
-//#endregion
-//#region src/auth/schema.ts
-const AuthAccessTokenResultSchema = Struct({
-	access_token: String$1,
-	issued_token_type: String$1,
-	token_type: Literal("Bearer"),
-	expires_in: Number$1,
-	scope: String$1
-});
-const AuthSessionStateSchema = Struct({
-	authenticated: Boolean,
-	role: optionalKey(Literals(["owner", "client"])),
-	sessionMethod: optionalKey(String$1),
-	expiresAt: optionalKey(String$1)
-});
-const AuthWebSocketTicketResultSchema = Struct({
-	ticket: String$1,
-	expiresAt: String$1
-});
-const AuthLocalRuntimeStateSchema = Struct({
-	version: Literal(1),
-	origin: String$1
-});
-const decodeAuthAccessTokenResult = decodeUnknownEffect(AuthAccessTokenResultSchema);
-const decodeAuthSessionState = decodeUnknownEffect(AuthSessionStateSchema);
-const decodeAuthWebSocketTicketResult = decodeUnknownEffect(AuthWebSocketTicketResultSchema);
-decodeUnknownEffect(AuthLocalRuntimeStateSchema);
-const decodeAuthLocalRuntimeStateFromJson = decodeUnknownEffect(fromJsonString(AuthLocalRuntimeStateSchema));
-//#endregion
-//#region src/auth/transport.ts
-var T3AuthTransport = class extends Service()("t3cli/T3AuthTransport") {};
-const T3AuthTransportLive = effect(T3AuthTransport, fn("makeT3AuthTransport")(function* () {
-	const client = filterStatusOk(yield* HttpClient);
-	return {
-		bootstrapBearer: fn("AuthTransport.bootstrapBearer")(function* (input) {
-			const request = post(yield* makeHttpEndpointUrl(input.baseUrl, "/oauth/token")).pipe(acceptJson, bodyUrlParams({
-				grant_type: AuthTokenExchangeGrantType,
-				subject_token: input.credential,
-				subject_token_type: AuthEnvironmentBootstrapTokenType,
-				requested_token_type: AuthAccessTokenType
-			}));
-			const result = yield* (yield* client.execute(request).pipe(catchTags({ HttpClientError: (error) => fail(new AuthTransportError({
-				message: "auth request failed",
-				cause: HttpClientErrorSchema.fromHttpClientError(error)
-			})) }))).json.pipe(flatMap(decodeAuthAccessTokenResult), catchTags({
-				HttpClientError: (error) => fail(new AuthTransportError({
-					message: "auth request failed",
-					cause: HttpClientErrorSchema.fromHttpClientError(error)
-				})),
-				SchemaError: (error) => fail(new AuthTransportError({
-					message: "auth response decode failed",
-					cause: error
-				}))
-			}));
-			const now$1 = yield* now;
-			return {
-				authenticated: true,
-				role: result.scope.split(/\s+/u).includes("access:write") ? "owner" : "client",
-				sessionMethod: "bearer-access-token",
-				expiresAt: formatIso(add(now$1, { seconds: result.expires_in })),
-				sessionToken: result.access_token
-			};
-		}),
-		getSession: fn("AuthTransport.getSession")(function* (connection) {
-			const request = get(yield* makeHttpEndpointUrl(connection.url, "/api/auth/session")).pipe(authenticatedRequest(connection));
-			return yield* (yield* client.execute(request).pipe(catchTags({ HttpClientError: (error) => fail(new AuthTransportError({
-				message: "auth request failed",
-				cause: HttpClientErrorSchema.fromHttpClientError(error)
-			})) }))).json.pipe(flatMap(decodeAuthSessionState), catchTags({
-				HttpClientError: (error) => fail(new AuthTransportError({
-					message: "auth request failed",
-					cause: HttpClientErrorSchema.fromHttpClientError(error)
-				})),
-				SchemaError: (error) => fail(new AuthTransportError({
-					message: "auth response decode failed",
-					cause: error
-				}))
-			}));
-		}),
-		issueWebSocketTicket: fn("AuthTransport.issueWebSocketTicket")(function* (connection) {
-			const request = post(yield* makeHttpEndpointUrl(connection.url, "/api/auth/websocket-ticket")).pipe(authenticatedRequest(connection));
-			return yield* (yield* client.execute(request).pipe(catchTags({ HttpClientError: (error) => fail(new AuthTransportError({
-				message: "auth request failed",
-				cause: HttpClientErrorSchema.fromHttpClientError(error)
-			})) }))).json.pipe(flatMap(decodeAuthWebSocketTicketResult), catchTags({
-				HttpClientError: (error) => fail(new AuthTransportError({
-					message: "auth request failed",
-					cause: HttpClientErrorSchema.fromHttpClientError(error)
-				})),
-				SchemaError: (error) => fail(new AuthTransportError({
-					message: "auth response decode failed",
-					cause: error
-				}))
-			}));
-		})
-	};
-})());
-const authenticatedRequest = (connection) => (request) => request.pipe(acceptJson, bearerToken(connection.token));
-function makeHttpEndpointUrl(baseUrl, path) {
-	return toHttpEndpointUrl(baseUrl, path).pipe(catchTags({ UrlError: (error) => fail(new AuthTransportError({
-		message: "auth request failed",
-		cause: error
-	})) }));
-}
-//#endregion
-export { make as a, make$1 as c, layerMergedContext as i, T3AuthTransportLive as n, getAndSet as o, decodeAuthLocalRuntimeStateFromJson as r, makeUnsafe as s, T3AuthTransport as t };

package/dist/url-SlsaG8nY.js

@@ -1,165 +0,0 @@
-import { On as dual } from "./Context-DueQ9iMH.js";
-import { H as fromResult, Tt as succeed, b as catchTags, cn as IllegalArgumentError, j as flatMap, k as fail, mi as try_ } from "./Path-D8WPdPwR.js";
-import { n as UrlError } from "./error-BHRnjLux.js";
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/http/Url.js
-/**
-* Immutable helpers for parsing and editing platform `URL` values.
-*
-* This module keeps the WHATWG `URL` object as the URL representation used by
-* HTTP clients and servers, then adds safe parsing and pipeable setters for
-* credentials, host, path, protocol, query, and hash components. Query strings
-* can be read, replaced, or transformed through `UrlParams` so repeated keys and
-* key/value encoding stay explicit.
-*
-* **Mental model**
-*
-* `fromString` returns a `Result` instead of throwing when URL construction
-* fails. Setters never mutate the original `URL`; each one clones the input and
-* assigns the requested component on the clone. Use `mutate` when several
-* component assignments should happen on the same clone.
-*
-* **Common tasks**
-*
-* - Parse absolute URLs, or resolve relative URL strings against a base URL.
-* - Pipe setters to adjust host, protocol, path, credentials, search, or hash.
-* - Extract query parameters with `urlParams`.
-* - Replace or transform query parameters with `setUrlParams` and
-*   `modifyUrlParams`.
-*
-* **Gotchas**
-*
-* Relative input needs an explicit base. Component assignment and serialization
-* follow platform `URL` rules, so values may be normalized or percent-encoded.
-* `setPassword` accepts `Redacted` input, but the resulting `URL` still contains
-* the actual credential and should be treated as sensitive when serialized.
-*
-* @since 4.0.0
-*/
-/**
-* Parses a URL string safely into a `URL` object, returning a `Result` type for
-* error handling.
-*
-* **Details**
-*
-* This function converts a string into a `URL` object, enabling safe URL
-* parsing with built-in error handling. If the string is invalid or fails to
-* parse, this function does not throw an error; instead, it wraps the error in
-* a `IllegalArgumentError` and returns it as the `Failure` value of an
-* `Result`. The `Success` value contains the successfully parsed `URL`.
-*
-* An optional `base` parameter can be provided to resolve relative URLs. If
-* specified, the function interprets the input `url` as relative to this
-* `base`. This is especially useful when dealing with URLs that might not be
-* fully qualified.
-*
-* **Example** (Parsing absolute and relative URLs)
-*
-* ```ts
-* import { Result } from "effect"
-* import { Url } from "effect/unstable/http"
-*
-* // Parse an absolute URL
-* //
-* //      ┌─── Result<URL, IllegalArgumentError>
-* //      ▼
-* const parsed = Url.fromString("https://example.com/path")
-*
-* if (Result.isSuccess(parsed)) {
-*   console.log("Parsed URL:", parsed.success.toString())
-* } else {
-*   console.log("Error:", parsed.failure.message)
-* }
-* // Output: Parsed URL: https://example.com/path
-*
-* // Parse a relative URL with a base
-* const relativeParsed = Url.fromString("/relative-path", "https://example.com")
-*
-* if (Result.isSuccess(relativeParsed)) {
-*   console.log("Parsed relative URL:", relativeParsed.success.toString())
-* } else {
-*   console.log("Error:", relativeParsed.failure.message)
-* }
-* // Output: Parsed relative URL: https://example.com/relative-path
-* ```
-*
-* @category constructors
-* @since 4.0.0
-*/
-const fromString = (url, base) => try_({
-	try: () => new URL(url, base),
-	catch: () => new IllegalArgumentError(`Invalid URL: "${url}"${base !== void 0 ? ` with base "${base}"` : ""}`)
-});
-/**
-* Updates a cloned `URL` with a callback, allowing multiple changes at once.
-*
-* **Example** (Mutating URL credentials)
-*
-* ```ts
-* import { Url } from "effect/unstable/http"
-*
-* const myUrl = new URL("https://example.com")
-*
-* const mutatedUrl = Url.mutate(myUrl, (url) => {
-*   url.username = "user"
-*   url.password = "pass"
-* })
-*
-* console.log("Mutated:", mutatedUrl.toString())
-* // Output: Mutated: https://user:pass@example.com/
-* ```
-*
-* @category modifiers
-* @since 4.0.0
-*/
-const mutate = /*#__PURE__*/ dual(2, (self, f) => {
-	const copy = new URL(self);
-	f(copy);
-	return copy;
-});
-//#endregion
-//#region src/config/url.ts
-function normalizeHttpBaseUrl(value) {
-	return parseUrl(value).pipe(flatMap((url) => succeed(normalizeBaseUrl(url))));
-}
-function toHttpEndpointUrl(httpBaseUrl, pathname) {
-	return parseUrl(httpBaseUrl).pipe(flatMap((url) => succeed(withPathname(url, pathname).toString())));
-}
-function toWebSocketEndpointUrl(httpBaseUrl, pathname) {
-	return parseUrl(httpBaseUrl).pipe(flatMap((url) => {
-		if (url.protocol === "http:") return succeed(withPathname(url, pathname, "ws:").toString());
-		if (url.protocol === "https:") return succeed(withPathname(url, pathname, "wss:").toString());
-		return fail(new UrlError({
-			message: `unsupported server url protocol: ${url.protocol}`,
-			protocol: url.protocol
-		}));
-	}));
-}
-function parseUrl(value) {
-	return fromResult(fromString(value)).pipe(catchTags({ IllegalArgumentError: (error) => fail(new UrlError({
-		message: "invalid url",
-		cause: error
-	})) }));
-}
-function normalizeBaseUrl(url) {
-	return mutate(url, (current) => {
-		current.hash = "";
-		current.search = "";
-		current.pathname = normalizePathname(current.pathname);
-	}).toString().replace(/\/$/, "");
-}
-function withPathname(url, pathname, protocol) {
-	return mutate(url, (current) => {
-		if (protocol !== void 0) current.protocol = protocol;
-		current.pathname = appendPathname(current.pathname, pathname);
-		current.search = "";
-		current.hash = "";
-	});
-}
-function normalizePathname(pathname) {
-	return pathname === "/" ? "" : pathname.replace(/\/+$/u, "");
-}
-function appendPathname(basePathname, pathname) {
-	return `${normalizePathname(basePathname)}${pathname.startsWith("/") ? pathname : `/${pathname}`}`;
-}
-//#endregion
-export { mutate as a, fromString as i, toHttpEndpointUrl as n, toWebSocketEndpointUrl as r, normalizeHttpBaseUrl as t };