@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/Config-B6OND9WR.mjs

@@ -0,0 +1,854 @@
+import { $ as fromResult, M as fail, N as failCause, Qr as isFailReason, V as flatMapEager, W as fnUntraced, Wr as fromReasons, Xr as isDieReason, Xt as succeed, _ as catchEager, dt as map$1, ia as Reference, m as catchCause, mt as mapEager, ni as makeDieReason, ri as makeFailReason, si as reasonAnnotations, va as Prototype } from "./Effect-CKFpqbmw.mjs";
+import { $ as isFailure, S as isCanonicalArrayIndex, Y as fail$1, at as succeed$1, nt as map$2 } from "./Array-B4kuTQeW.mjs";
+import { Cn as memoize, F as PipeInspectableProto, S as none, bn as dual, gt as assignProperty, un as isTagged, w as some } from "./Option-DkxSnBhp.mjs";
+import { Cn as Transformation, F as String$2, N as Redacted$1, On as transformEffect, P as SchemaError, Sn as unknown, Tn as passthrough, gn as decodeTo, hn as applyToSelfOrLastLinkEncoding, ht as isBetween, jn as Pointer, ln as toCodecStringTree, mn as decodeUnknownEffect, o as BooleanLiterals, tn as make$2, v as Int, vn as getIndexSignatureKeys, xn as toEncoded } from "./Schema-MiKt5K1v.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/ConfigProvider.js
+/**
+* Data sources used by `Config` to load raw configuration values. A
+* `ConfigProvider` reads paths from places such as environment variables,
+* JavaScript objects, `.env` contents, or directories, and returns a uniform
+* `Node` shape that config schemas can decode. The module also includes helpers
+* for composing providers, changing paths, and installing providers through
+* layers.
+*
+* @stability stable
+* @since 4.0.0
+*/
+/**
+* Creates a `Value` node representing a terminal string leaf.
+*
+* **When to use**
+*
+* Use when building nodes inside a custom `ConfigProvider`'s `get`
+* callback.
+*
+* **Details**
+*
+* The function returns a new plain object.
+*
+* **Example** (Creating a value node)
+*
+* ```ts import.meta.vitest
+* import { ConfigProvider } from "effect"
+*
+* ConfigProvider.makeValue("3000") // => { _tag: "Value", value: "3000" }
+* ```
+*
+* @see {@link makeRecord} – for object-like containers
+* @see {@link makeArray} – for array-like containers
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+function makeValue(value) {
+	return {
+		_tag: "Value",
+		value
+	};
+}
+/**
+* Creates a `Record` node representing an object-like container with known
+* child keys.
+*
+* **When to use**
+*
+* Use when you need to describe a directory or JSON object inside a custom
+* provider.
+*
+* **Details**
+*
+* The optional `value` allows a node to be both a container and a leaf at the
+* same time (for example, an env var `A=x` that also has children `A_FOO` and
+* `A_BAR`).
+*
+* **Example** (Creating a record node)
+*
+* ```ts import.meta.vitest
+* import { ConfigProvider } from "effect"
+*
+* const node = ConfigProvider.makeRecord(new Set(["host", "port"]))
+* node._tag // => "Record"
+* if (node._tag === "Record") {
+*   node.keys // => new Set(["host", "port"])
+*   node.value // => undefined
+* }
+* ```
+*
+* @see {@link makeValue} – for terminal leaves
+* @see {@link makeArray} – for array-like containers
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+function makeRecord(keys, value) {
+	return {
+		_tag: "Record",
+		keys,
+		value
+	};
+}
+/**
+* Creates an `Array` node representing an indexed container with a known
+* length.
+*
+* **When to use**
+*
+* Use when you need to describe a JSON array or numerically indexed env vars
+* inside a custom provider.
+*
+* **Details**
+*
+* The optional `value` allows a node to be both a container and a leaf at the
+* same time.
+*
+* **Example** (Creating an array node)
+*
+* ```ts import.meta.vitest
+* import { ConfigProvider } from "effect"
+*
+* ConfigProvider.makeArray(3) // => { _tag: "Array", length: 3, value: undefined }
+* ```
+*
+* @see {@link makeValue} – for terminal leaves
+* @see {@link makeRecord} – for object-like containers
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+function makeArray(length, value) {
+	return {
+		_tag: "Array",
+		length,
+		value
+	};
+}
+/**
+* Context reference for the active raw configuration provider, registered in the context with a
+* default value of `fromEnv()`. Because it is a `Context.Reference`, it is
+* available without explicit provision; `Config` schemas automatically resolve
+* it.
+*
+* **When to use**
+*
+* Use to override the active raw configuration provider for an entire program,
+* or retrieve the current provider inside an Effect.
+*
+* **Example** (Providing a custom provider)
+*
+* ```ts import.meta.vitest
+* import { ConfigProvider, Effect } from "effect"
+*
+* const provider = ConfigProvider.fromUnknown({ port: 8080 })
+*
+* const program = Effect.gen(function*() {
+*   const current = yield* ConfigProvider.ConfigProvider
+*   return current
+* }).pipe(
+*   Effect.provideService(ConfigProvider.ConfigProvider, provider)
+* )
+*
+* Effect.runSync(program) === provider // => true
+* ```
+*
+* @see {@link layer} – install a provider as a Layer
+* @see {@link layerAdd} – add a fallback provider as a Layer
+*
+* @stability stable
+* @category services
+* @since 4.0.0
+*/
+const ConfigProvider = /*#__PURE__*/ Reference("effect/ConfigProvider", { defaultValue: () => fromEnv() });
+const Proto$1 = {
+	...PipeInspectableProto,
+	toJSON() {
+		return { _id: "ConfigProvider" };
+	}
+};
+const identityPath = (path) => path;
+function makeProvider(load, mapInput) {
+	const self = Object.create(Proto$1);
+	self.load = load;
+	self.mapInput = mapInput;
+	return self;
+}
+function makeSource(get, transform) {
+	return makeProvider((path) => get(transform(path)), (f) => makeSource(get, (path) => f(transform(path))));
+}
+/**
+* Creates a `ConfigProvider` from a raw lookup function.
+*
+* **When to use**
+*
+* Use when implementing a provider backed by a custom store, such as a
+* database, remote API, or in-memory map.
+*
+* **Details**
+*
+* The `get` callback receives a `Path` and must return
+* `Effect<Node | undefined, SourceError>`. Return `undefined` when the path does
+* not exist, a `Node` when it does, and fail with `SourceError` only when the
+* source cannot be read.
+*
+* Providers created by `make` also implement the path-transformation
+* capability used by {@link mapInput}, {@link constantCase}, and
+* {@link nested}.
+*
+* **Example** (Creating a simple in-memory provider)
+*
+* ```ts import.meta.vitest
+* import { ConfigProvider, Effect } from "effect"
+*
+* const data: Record<string, string> = {
+*   host: "localhost",
+*   port: "5432"
+* }
+*
+* const provider = ConfigProvider.make((path) => {
+*   const key = path.join(".")
+*   const value = data[key]
+*   return Effect.succeed(
+*     value !== undefined ? ConfigProvider.makeValue(value) : undefined
+*   )
+* })
+*
+* Effect.runSync(provider.load(["host"])) // => ConfigProvider.makeValue("localhost")
+* ```
+*
+* @see {@link fromEnv} – pre-built provider for environment variables
+* @see {@link fromUnknown} – pre-built provider for JSON objects
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+function make$1(get) {
+	return makeSource(get, identityPath);
+}
+function emptyStringAsMissing(value, preserveEmptyStrings) {
+	return value === "" && !preserveEmptyStrings ? void 0 : value;
+}
+/**
+* Creates a `ConfigProvider` backed by an explicit environment record.
+*
+* **When to use**
+*
+* Use when a restricted runtime cannot evaluate the automatic environment
+* detection performed by {@link fromEnv}, or whenever the environment record
+* must be supplied explicitly.
+*
+* **Details**
+*
+* `undefined` values are ignored. Path lookup and child discovery otherwise
+* use the same environment-variable semantics as {@link fromEnv}.
+*
+* Environment variable names are captured at construction time to establish
+* record keys and array lengths. The supplied record remains live for value
+* lookups, so updates to known paths are observed by later loads. Keys added
+* after construction can be loaded directly, but do not appear in captured
+* parent record keys or array lengths.
+*
+* Literal empty strings are treated as missing values by default. Pass
+* `{ preserveEmptyStrings: true }` to keep empty strings as explicit values.
+*
+* @see {@link fromEnv} – automatically reads the runtime environment
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+function fromEnvRecord(env, options) {
+	const preserveEmptyStrings = options?.preserveEmptyStrings === true;
+	const trie = buildEnvTrie(env);
+	return make$1((path) => succeed(nodeAtEnv(trie, env, path, preserveEmptyStrings)));
+}
+/**
+* Creates a `ConfigProvider` backed by environment variables.
+*
+* **When to use**
+*
+* Use to read configuration from `process.env`, which is the default when no
+* provider is explicitly set, or pass a custom env record for testing.
+*
+* **Details**
+*
+* Path segments are joined with `_` for direct lookup, and env var names are
+* also split on `_` to build a trie for child key discovery. This means
+* `DATABASE_HOST=localhost` is accessible at both path `["DATABASE_HOST"]`
+* and `["DATABASE", "HOST"]`. If all immediate children of a trie node have
+* purely numeric names, the node is reported as an `Array`; otherwise as a
+* `Record`.
+*
+* The default environment merges `process.env` and `import.meta.env` (when
+* available). Override by passing `{ env: { ... } }`.
+*
+* Literal empty strings are treated as missing values when loaded as values by
+* default. Pass `{ preserveEmptyStrings: true }` to keep empty strings as
+* explicit values. Child discovery still reflects the environment variable
+* names present in the source.
+*
+* Never fails with `SourceError` — all lookups are synchronous.
+*
+* **Example** (Reading from a custom env record)
+*
+* ```ts import.meta.vitest
+* import { Config, ConfigProvider, Effect } from "effect"
+*
+* const provider = ConfigProvider.fromEnv({
+*   env: {
+*     DATABASE_HOST: "localhost",
+*     DATABASE_PORT: "5432"
+*   }
+* })
+*
+* const host = Config.String("HOST").parse(
+*   provider.pipe(ConfigProvider.nested("DATABASE"))
+* )
+*
+* Effect.runSync(host) // => "localhost"
+* ```
+*
+* @see {@link fromUnknown} – for JSON objects
+* @see {@link fromEnvRecord} – for explicit records in restricted runtimes
+* @see {@link constantCase} – bridge camelCase keys to SCREAMING_SNAKE_CASE
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+function fromEnv(options) {
+	return fromEnvRecord(options?.env ?? {
+		...globalThis.process?.env,
+		...import.meta.env
+	}, { preserveEmptyStrings: options?.preserveEmptyStrings });
+}
+function buildEnvTrie(env) {
+	const trie = {};
+	for (const [name, value] of Object.entries(env)) {
+		if (value === void 0) continue;
+		const segments = name.split("_");
+		let node = trie;
+		for (const seg of segments) {
+			const children = node.children ??= Object.create(null);
+			node = children[seg] ??= {};
+		}
+	}
+	return trie;
+}
+function nodeAtEnv(trie, env, path, preserveEmptyStrings) {
+	const key = path.map(String).join("_");
+	const leafValue = emptyStringAsMissing(Object.hasOwn(env, key) ? env[key] : void 0, preserveEmptyStrings);
+	const trieNode = trieNodeAt(trie, path);
+	const children = trieNode?.children ? Object.keys(trieNode.children) : [];
+	if (children.length === 0) return leafValue === void 0 ? void 0 : makeValue(leafValue);
+	if (children.every(isCanonicalArrayIndex)) return makeArray(Math.max(...children.map((k) => parseInt(k, 10))) + 1, leafValue);
+	return makeRecord(new Set(children), leafValue);
+}
+function trieNodeAt(root, path) {
+	if (path.length === 0) return root;
+	let node = root;
+	for (const seg of path) {
+		node = node?.children?.[String(seg)];
+		if (!node) return void 0;
+	}
+	return node;
+}
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Config.js
+/**
+* Descriptions of configuration values that can be read from a
+* `ConfigProvider`. A `Config<T>` explains which keys to read, how to decode
+* and validate them, and how to combine defaults, fallbacks, nested paths, and
+* multiple settings. Configs are also Effects, so they can be yielded in
+* `Effect.gen` after a provider has been supplied.
+*
+* @stability stable
+* @since 4.0.0
+*/
+const TypeId = "~effect/Config";
+/**
+* Represents the error type produced when config loading or validation fails.
+*
+* **When to use**
+*
+* Use when you need to inspect config loading or validation failures.
+*
+* **Details**
+*
+* Wraps either:
+* - A `SourceError` — the provider could not read data (I/O failure).
+* - A `SchemaError` — the data was found but did not match the schema
+*   (wrong type, out of range, missing key, etc.).
+*
+* @see {@link orElse} – recover from a ConfigError
+* @see {@link withDefault} – provide a fallback when relevant input is absent
+*
+* @stability stable
+* @category errors
+* @since 4.0.0
+*/
+var ConfigError = class {
+	_tag = "ConfigError";
+	name = "ConfigError";
+	cause;
+	constructor(cause) {
+		this.cause = cause;
+	}
+	get message() {
+		return this.cause.toString();
+	}
+	toString() {
+		return `ConfigError(${this.message})`;
+	}
+};
+const Proto = {
+	.../*#__PURE__*/ Prototype({
+		label: "Config",
+		evaluate(fiber) {
+			return this.parse(fiber.getRef(ConfigProvider));
+		}
+	}),
+	[TypeId]: TypeId,
+	toJSON() {
+		return { _id: "Config" };
+	}
+};
+function make(evaluator) {
+	const self = Object.create(Proto);
+	self.evaluator = evaluator;
+	self.parse = (provider) => flatMapEager(evaluator(provider, []), fromResult);
+	return self;
+}
+const evaluateAt = (self, provider, pathPrefix) => self.evaluator(provider, pathPrefix);
+/**
+* Transforms the parsed value of a config with a pure function.
+*
+* **When to use**
+*
+* Use when you need to transform a parsed config value with a function that
+* cannot fail.
+*
+* **Example** (Uppercasing a string config)
+*
+* ```ts import.meta.vitest
+* import { Config, ConfigProvider, Effect } from "effect"
+*
+* const upper = Config.String("name").pipe(
+*   Config.map((s) => s.toUpperCase())
+* )
+*
+* const provider = ConfigProvider.fromUnknown({ name: "alice" })
+* Effect.runSync(upper.parse(provider)) // => "ALICE"
+* ```
+*
+* @see {@link mapEffect} – when the transformation can fail
+*
+* @stability stable
+* @category mapping
+* @since 2.0.0
+*/
+const map = /*#__PURE__*/ dual(2, (self, f) => {
+	return make((provider, pathPrefix) => map$1(evaluateAt(self, provider, pathPrefix), map$2(f)));
+});
+/**
+* Provides a fallback value when the config is absent.
+*
+* **When to use**
+*
+* Use when you need to make a config key optional with a sensible default.
+*
+* **Gotchas**
+*
+* Validation and source errors still propagate. For an {@link all} group, any
+* absent child causes the default to replace the entire group unless another
+* child fails. Apply defaults to individual children to preserve other values.
+*
+* A schema that successfully decodes absent input keeps its decoded value
+* instead of using the default. Schema configs first represent a missing or
+* incompatible provider shape as `undefined`; the default is used only when
+* the schema rejects that value and no relevant input was found.
+*
+* **Example** (Defaulting a missing port)
+*
+* ```ts import.meta.vitest
+* import { Config, ConfigProvider, Effect } from "effect"
+*
+* const port = Config.Number("port").pipe(Config.withDefault(3000))
+*
+* const provider = ConfigProvider.fromUnknown({})
+* Effect.runSync(port.parse(provider)) // => 3000
+* ```
+*
+* @see {@link option} – returns `Option` instead of a default value
+* @see {@link orElse} – catches all errors, not just absent input
+*
+* @stability stable
+* @category combinators
+* @since 2.0.0
+*/
+const withDefault = /*#__PURE__*/ dual(2, (self, defaultValue) => {
+	return make((provider, pathPrefix) => mapEager(evaluateAt(self, provider, pathPrefix), (resolution) => isFailure(resolution) ? succeed$1(defaultValue) : resolution));
+});
+/**
+* Makes a config optional: returns `Some(value)` on success and `None` when the
+* config is absent.
+*
+* **When to use**
+*
+* Use when you need to handle a config key that may or may not be present.
+*
+* **Gotchas**
+*
+* Validation and source errors still propagate. For an {@link all} group, any
+* absent child produces `None` unless another child fails. Successful values
+* are always wrapped in `Some`, including `undefined` when the schema
+* explicitly accepts it. Schema configs first represent a missing or
+* incompatible provider shape as `undefined`; `None` is returned only when the
+* schema rejects that value and no relevant input was found.
+*
+* **Example** (Reading optional config)
+*
+* ```ts import.meta.vitest
+* import { Config, ConfigProvider, Effect, Option } from "effect"
+*
+* const maybePort = Config.option(Config.Number("port"))
+*
+* const provider = ConfigProvider.fromUnknown({})
+* Effect.runSync(maybePort.parse(provider)) // => Option.none()
+* ```
+*
+* @see {@link withDefault} – provide a concrete fallback value instead
+*
+* @stability stable
+* @category combinators
+* @since 2.0.0
+*/
+const option = (self) => self.pipe(map(some), withDefault(none()));
+const isSourceError = (u) => isTagged(u, "SourceError");
+const cursorToString = () => "<configuration>";
+const mapReasons = (f) => (self) => catchCause(self, (cause) => failCause(fromReasons(cause.reasons.map(f))));
+const loadCursor = (provider, path) => provider.load(path).pipe(mapReasons((reason) => isFailReason(reason) ? makeDieReason(reason.error).annotate(reasonAnnotations(reason)) : reason), mapEager((node) => ({
+	provider,
+	path,
+	node,
+	toString: cursorToString
+})));
+const loadChildCursor = (cursor, segment) => loadCursor(cursor.provider, [...cursor.path, segment]);
+const decodeFromCursor = (ast, decode) => decodeTo(unknown, ast, new Transformation(transformEffect((input) => decode(input)), passthrough()));
+const isScalarInput = (ast) => {
+	switch (ast._tag) {
+		case "Union": return ast.types.every(isScalarInput);
+		case "Objects":
+		case "Arrays":
+		case "Suspend": return false;
+		default: return true;
+	}
+};
+const hasProviderInput = (ast, node) => {
+	switch (ast._tag) {
+		case "Objects": return node?._tag === "Record";
+		case "Arrays": return node?._tag === "Array";
+		case "Union": return ast.types.some((ast) => hasProviderInput(ast, node));
+		case "Suspend": return hasProviderInput(ast.thunk(), node);
+		default: return node?.value !== void 0;
+	}
+};
+const toConfigCursorAST = /*#__PURE__*/ memoize((root) => {
+	const seen = /* @__PURE__ */ new WeakSet();
+	const recur = applyToSelfOrLastLinkEncoding((ast) => {
+		seen.add(ast);
+		switch (ast._tag) {
+			case "Objects": {
+				const materialize = fnUntraced(function* (cursor) {
+					if (cursor.node?._tag !== "Record") return;
+					const node = cursor.node;
+					const keys = /* @__PURE__ */ new Set();
+					for (const property of ast.propertySignatures) if (typeof property.name === "string") keys.add(property.name);
+					if (ast.indexSignatures.length > 0) {
+						const input = {};
+						for (const key of node.keys) assignProperty(input, key, void 0);
+						for (const is of ast.indexSignatures) for (const key of getIndexSignatureKeys(input, is.parameter)) if (typeof key === "string") keys.add(key);
+					}
+					const out = {};
+					for (const key of keys) {
+						const child = yield* loadChildCursor(cursor, key);
+						if (child.node !== void 0) assignProperty(out, key, child);
+					}
+					return out;
+				});
+				return decodeFromCursor(ast.recur(recur, (ast) => ast), materialize);
+			}
+			case "Arrays": {
+				const materialize = fnUntraced(function* (cursor) {
+					if (cursor.node?._tag !== "Array") return;
+					const out = [];
+					for (let i = 0; i < cursor.node.length; i++) out.push(yield* loadChildCursor(cursor, i));
+					return out;
+				});
+				return decodeFromCursor(ast.recur(recur), materialize);
+			}
+			case "Union":
+				for (const member of ast.types) recur(member);
+				if (!isScalarInput(ast)) return ast.recur(recur);
+				break;
+			case "Suspend": {
+				const target = ast.thunk();
+				if (!seen.has(target)) recur(target);
+				return ast.recur(recur);
+			}
+			case "Declaration":
+			case "Any": throw new globalThis.Error("Config.schema does not support opaque StringTree encodings", { cause: ast });
+		}
+		return decodeFromCursor(ast, (cursor) => succeed(cursor.node?.value));
+	});
+	return recur(root);
+});
+/**
+* Creates a `Config<T>` from a `Schema.Codec`.
+*
+* **When to use**
+*
+* Use when you need to read structured or schema-validated configuration.
+*
+* **Details**
+*
+* The optional `path` sets the local path segment(s) for the config lookup.
+* It is appended to the logical path prefix accumulated from outer
+* {@link nested} calls. Pass a single string for a flat key or an array for
+* nested paths.
+*
+* Convenience constructors such as `String`, `Number`, and `Boolean` delegate
+* to this API.
+*
+* The codec is converted to its canonical `StringTree` form. Its encoded shape
+* determines how provider data is loaded: scalar schemas read a co-located
+* scalar value, object schemas read declared properties and matching record
+* keys, and array schemas read indexed children. A mixed-shape union loads each
+* member according to that member's shape before applying the union's mode and
+* checks.
+*
+* At the config's lookup path, a missing node or a node that cannot provide the
+* representation required by the schema is decoded as `undefined`. Missing
+* object properties remain omitted so the schema's property semantics still
+* apply. Decoding success always wins, even when no provider input was found.
+* For example,
+* `Schema.UndefinedOr(Schema.String)` decodes to `undefined` and is not replaced
+* by {@link withDefault}. If decoding fails and no relevant representation was
+* found, the config is absent. Invalid data in a relevant representation is a
+* validation failure. Provider `SourceError`s are always failures.
+*
+* **Gotchas**
+*
+* Plain `Schema.Array` and `Schema.Record` schemas use structural provider
+* input. Use {@link Array} or {@link Record} when a flat separated string must
+* also be accepted.
+*
+* `Schema.Struct` and {@link all} describe different lookup models. An
+* existing object, even an empty one, is validated as a whole by a struct;
+* missing required fields cause a validation failure. An `all` group combines
+* independent lookups and is absent if any child is absent and none fail.
+*
+* The canonical `StringTree` encoding must expose a concrete scalar, object,
+* array, or union shape. Opaque encodings such as `Schema.Any`,
+* `Schema.Unknown`, `Schema.ObjectKeyword`, `Schema.Json`, and
+* `Schema.MutableJson` are rejected synchronously when this config is
+* constructed, including when they are nested in another schema. Suspended
+* recursive schemas remain supported when their eventual shape is concrete.
+* Declarations such as `Schema.URL` also remain supported when their canonical
+* encoding has a concrete shape. To read arbitrary JSON from one scalar value,
+* use `Schema.fromJsonString(Schema.Json)`.
+*
+* **Example** (Reading a structured config)
+*
+* ```ts import.meta.vitest
+* import { Config, ConfigProvider, Effect, Schema } from "effect"
+*
+* const DbConfig = Config.schema(
+*   Schema.Struct({
+*     host: Schema.String,
+*     port: Schema.Int
+*   }),
+*   "db"
+* )
+*
+* const provider = ConfigProvider.fromUnknown({
+*   db: { host: "localhost", port: 5432 }
+* })
+*
+* Effect.runSync(DbConfig.parse(provider)) // => { host: "localhost", port: 5432 }
+* ```
+*
+* @see {@link String} / {@link Number} / {@link Boolean} – shortcuts for
+*   single-value configs
+*
+* @stability stable
+* @category schemas
+* @since 4.0.0
+*/
+function schema(codec, path) {
+	const codecStringTree = toCodecStringTree(codec);
+	const encodedAst = toEncoded(codecStringTree.ast);
+	const decodeCursor = decodeUnknownEffect(make$2(toConfigCursorAST(codecStringTree.ast)));
+	const localPath = typeof path === "string" ? [path] : path ?? [];
+	return make((provider, pathPrefix) => {
+		const fullPath = [...pathPrefix, ...localPath];
+		return loadCursor(provider, fullPath).pipe(flatMapEager((cursor) => decodeCursor(cursor).pipe(mapEager(succeed$1), catchEager((issue) => {
+			const error = new ConfigError(new SchemaError(fullPath.length > 0 ? new Pointer(fullPath, issue) : issue));
+			return hasProviderInput(encodedAst, cursor.node) ? fail(error) : succeed(fail$1(error));
+		}))), mapReasons((reason) => isDieReason(reason) && isSourceError(reason.defect) ? makeFailReason(new ConfigError(reason.defect)).annotate(reasonAnnotations(reason)) : reason));
+	});
+}
+const PortSchema = /*#__PURE__*/ Int.check(/*#__PURE__*/ isBetween({
+	minimum: 1,
+	maximum: 65535
+}));
+/**
+* Creates a config for a single string value.
+*
+* **When to use**
+*
+* Use when reading a single string env var or config key.
+*
+* **Details**
+*
+* Shortcut for `Config.schema(Schema.String, name)`.
+*
+* **Example** (Reading a string config)
+*
+* ```ts import.meta.vitest
+* import { Config, ConfigProvider, Effect } from "effect"
+*
+* const host = Config.String("HOST")
+*
+* const provider = ConfigProvider.fromUnknown({ HOST: "localhost" })
+* Effect.runSync(host.parse(provider)) // => "localhost"
+* ```
+*
+* @see {@link NonEmptyString} – rejects empty strings
+* @see {@link schema} – for more complex types
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+function String$1(name) {
+	return schema(String$2, name);
+}
+/**
+* Creates a config for a boolean value parsed from common string
+* representations.
+*
+* **When to use**
+*
+* Use to read boolean flags from string-like config sources.
+*
+* **Details**
+*
+* Accepted values: `true`, `false`, `yes`, `no`, `on`, `off`, `1`, `0`,
+* `y`, `n`.
+*
+* **Example** (Reading a boolean flag)
+*
+* ```ts import.meta.vitest
+* import { Config, ConfigProvider, Effect } from "effect"
+*
+* const program = Config.Boolean("FEATURE_FLAG")
+*
+* const provider = ConfigProvider.fromEnv({
+*   env: {
+*     FEATURE_FLAG: "yes"
+*   }
+* })
+*
+* Effect.runSync(
+*   program.pipe(Effect.provideService(ConfigProvider.ConfigProvider, provider))
+* ) // => true
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+function Boolean(name) {
+	return schema(BooleanLiterals, name);
+}
+/**
+* Creates a config for a port number (integer in 1–65535).
+*
+* **When to use**
+*
+* Use to read network port settings that must be valid port numbers.
+*
+* **Details**
+*
+* Accepts integers from `1` through `65535`.
+*
+* **Example** (Reading a port)
+*
+* ```ts import.meta.vitest
+* import { Config, ConfigProvider, Effect } from "effect"
+*
+* const program = Config.Port("PORT")
+*
+* const provider = ConfigProvider.fromEnv({
+*   env: {
+*     PORT: "8080"
+*   }
+* })
+*
+* Effect.runSync(
+*   program.pipe(Effect.provideService(ConfigProvider.ConfigProvider, provider))
+* ) // => 8080
+* ```
+*
+* @see {@link Int} for integer config values outside the port range
+*
+* @stability stable
+* @category constructors
+* @since 3.16.0
+*/
+function Port(name) {
+	return schema(PortSchema, name);
+}
+/**
+* Creates a config for a redacted string value. The parsed result is wrapped
+* in a `Redacted` container that hides the value from logs and `toString`.
+*
+* **When to use**
+*
+* Use to read secret string settings that should not be exposed in logs or
+* string output.
+*
+* **Details**
+*
+* Shortcut for `Config.schema(Schema.Redacted(Schema.String), name)`.
+*
+* **Example** (Reading a secret)
+*
+* ```ts import.meta.vitest
+* import { Config, ConfigProvider, Effect } from "effect"
+*
+* const program = Config.Redacted("API_KEY").pipe(Effect.map(String))
+*
+* const provider = ConfigProvider.fromEnv({
+*   env: {
+*     API_KEY: "sk-1234567890abcdef"
+*   }
+* })
+*
+* Effect.runSync(
+*   program.pipe(Effect.provideService(ConfigProvider.ConfigProvider, provider))
+* ) // => "<redacted>"
+* ```
+*
+* @see {@link String} for non-secret string settings
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+function Redacted(name) {
+	return schema(Redacted$1(String$2), name);
+}
+export { option as a, String$1 as i, Port as n, withDefault as o, Redacted as r, ConfigProvider as s, Boolean as t };