alink-cli 0.7.2 → 0.7.4

package/dist/Config-Bj2ZPCsP.mjs

@@ -0,0 +1,1221 @@
+#!/usr/bin/env node
+
+import { $a as flatMapEager, B as Union, C as Number$1, Co as mapEager, D as String$1, E as Record$1, En as transformOrFail, F as URL, Fu as map$2, Ga as die, Io as orDie, Jt as _is, Kn as Pointer, Ld as assignProperty, Md as Prototype, Na as catchDefect, Nd as PipeInspectableProto, Pa as catchEager, Pt as toCodecStringTree, Qd as hasProperty, Qs as TaggedError, So as map$1, Td as some, To as mapErrorEager, Tt as make$2, Xu as Reference, Ya as fail, Yt as decodeUnknownEffect, Z as decodeTo$1, Zt as SchemaError, _n as Transformation, en as applyToSelfOrLastLinkEncoding, g as Literals, gn as unknown, hf as flow, hn as toEncoded, m as Int, mf as dual, no as fnUntraced, ns as succeed, r as Boolean$1, tn as decodeTo, ut as isBetween, vn as splitKeyValue, wd as none, wn as passthrough, xa as all$1, yn as transform } from "./Schema-B3i-HrZQ.mjs";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.103_patch_hash=a18f963109656ddbeb2a99ca45f942ecf54830986259eb01ce6a970421c9c6a9/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.
+*
+* @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
+*
+* @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
+*
+* @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
+*
+* @category constructors
+* @since 4.0.0
+*/
+function makeArray(length, value) {
+	return {
+		_tag: "Array",
+		length,
+		value
+	};
+}
+/**
+* Typed error indicating that a configuration source could not be read.
+*
+* **When to use**
+*
+* Use when you need to report that a custom provider's underlying store is
+* unreachable or produced an I/O error while reading configuration data.
+*
+* **Gotchas**
+*
+* Do not use `SourceError` for "key not found". That case is represented by
+* returning `undefined` from `load`.
+*
+* **Example** (Failing with a SourceError)
+*
+* ```ts import.meta.vitest
+* import { ConfigProvider, Effect } from "effect"
+*
+* const provider = ConfigProvider.make((_path) =>
+*   Effect.fail(
+*     new ConfigProvider.SourceError({ message: "connection refused" })
+*   )
+* )
+*
+* Effect.runSync(Effect.flip(provider.load(["host"]))).message // => "connection refused"
+* ```
+*
+* @see {@link ConfigProvider} – the interface whose `load` may fail with this
+*   error
+*
+* @category errors
+* @since 4.0.0
+*/
+var SourceError = class extends TaggedError("SourceError") {};
+/**
+* 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
+*
+* @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, flow(transform, f)));
+}
+/**
+* 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
+*
+* @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 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 or
+* non-Node runtimes.
+*
+* **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 constantCase} – bridge camelCase keys to SCREAMING_SNAKE_CASE
+*
+* @category constructors
+* @since 2.0.0
+*/
+function fromEnv(options) {
+	const env = options?.env ?? {
+		...globalThis.process?.env,
+		...import.meta.env
+	};
+	const preserveEmptyStrings = options?.preserveEmptyStrings === true;
+	const trie = buildEnvTrie(env);
+	return make$1((path) => succeed(nodeAtEnv(trie, env, path, 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;
+}
+const NUMERIC_INDEX = /^(0|[1-9][0-9]*)$/;
+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((k) => NUMERIC_INDEX.test(k))) 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;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.103_patch_hash=a18f963109656ddbeb2a99ca45f942ecf54830986259eb01ce6a970421c9c6a9/node_modules/effect/dist/LogLevel.js
+/**
+* Returns all `LogLevel` values in order from `All` through the concrete severities to
+* `None`.
+*
+* **When to use**
+*
+* Use to enumerate or validate all accepted `LogLevel` string values, including
+* the `All` and `None` sentinel levels.
+*
+* **Details**
+*
+* The array order matches the module severity order: `All`, concrete
+* severities from `Fatal` to `Trace`, then `None`.
+*
+* **Gotchas**
+*
+* This list includes `All` and `None`, so it is not limited to concrete emitted
+* severities.
+*
+* @see {@link Severity} for the concrete message severity type that excludes `All` and `None`
+* @see {@link Order} for comparing these levels by severity order
+*
+* @category constants
+* @since 4.0.0
+*/
+const values = [
+	"All",
+	"Fatal",
+	"Error",
+	"Warn",
+	"Info",
+	"Debug",
+	"Trace",
+	"None"
+];
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.103_patch_hash=a18f963109656ddbeb2a99ca45f942ecf54830986259eb01ce6a970421c9c6a9/node_modules/effect/dist/Config.js
+const TypeId = "~effect/Config";
+/**
+* Returns `true` if `u` is a `Config` instance.
+*
+* **When to use**
+*
+* Use when you need to distinguish a `Config` from an unknown value before
+* calling `.parse` or {@link unwrap}.
+*
+* **Example** (Checking Config values)
+*
+* ```ts import.meta.vitest
+* import { Config } from "effect"
+*
+* Config.isConfig(Config.string("HOST")) // => true
+* Config.isConfig("not a config") // => false
+* ```
+*
+* @category guards
+* @since 2.0.0
+*/
+const isConfig = (u) => hasProperty(u, TypeId);
+/**
+* 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
+*
+* @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) => evaluator(provider, []).pipe(mapErrorEager((failure) => failure.error), flatMapEager((resolution) => resolution._tag === "Resolved" ? succeed(resolution.value) : fail(resolution.error)));
+	return self;
+}
+const evaluateAt = (self, provider, pathPrefix) => self.evaluator(provider, pathPrefix);
+const resolved = (value, hasInput) => ({
+	_tag: "Resolved",
+	value,
+	hasInput
+});
+const absent = (error) => ({
+	_tag: "Absent",
+	error
+});
+const evaluationFailure = (error, hasInput) => ({
+	error,
+	hasInput
+});
+const catchSourceError = (self, hasInput) => self.pipe(catchDefect((defect) => defect instanceof SourceError ? fail(evaluationFailure(new ConfigError(defect), hasInput)) : die(defect)));
+/**
+* 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 mapOrFail} – when the transformation can fail
+*
+* @category mapping
+* @since 2.0.0
+*/
+const map = /*#__PURE__*/ dual(2, (self, f) => {
+	return make((provider, pathPrefix) => map$1(evaluateAt(self, provider, pathPrefix), (resolution) => resolution._tag === "Resolved" ? resolved(f(resolution.value), resolution.hasInput) : resolution));
+});
+/**
+* Combines multiple configs into a single config that parses all of them.
+*
+* **When to use**
+*
+* Use when you need to group related configs into a tuple or named struct.
+*
+* **Details**
+*
+* Accepts a tuple (preserves positions), an iterable, or a record of configs.
+* Returns a config whose parsed value mirrors the input shape.
+*
+* A combined config is absent when at least one child cannot resolve and none
+* of the other children read provider input. This lets {@link withDefault} and
+* {@link option} handle a wholly absent group. Once any child reads input, a
+* missing sibling makes the group incomplete and parsing fails. Values supplied
+* by child defaults do not count as provider input.
+*
+* Unlike a `Schema.Struct` passed to {@link schema}, `all` only considers input
+* read by its children. An explicitly present but empty parent container does
+* not by itself make the group present.
+*
+* **Example** (Combining configs as a struct)
+*
+* ```ts import.meta.vitest
+* import { Config, ConfigProvider, Effect } from "effect"
+*
+* const dbConfig = Config.all({
+*   host: Config.string("host"),
+*   port: Config.number("port")
+* })
+*
+* const provider = ConfigProvider.fromUnknown({ host: "localhost", port: 5432 })
+* Effect.runSync(dbConfig.parse(provider)) // => { host: "localhost", port: 5432 }
+* ```
+*
+* @category combinators
+* @since 2.0.0
+*/
+function all(arg) {
+	const configs = Array.isArray(arg) ? arg : Symbol.iterator in arg ? [...arg] : arg;
+	if (Array.isArray(configs)) return make((provider, pathPrefix) => flatMapEager(all$1(configs.map((config) => evaluateAt(config, provider, pathPrefix))), resolveArray));
+	else return make((provider, pathPrefix) => flatMapEager(all$1(map$2(configs, (config) => evaluateAt(config, provider, pathPrefix))), resolveRecord));
+}
+const resolveArray = (resolutions) => {
+	const values = [];
+	let firstAbsent;
+	let hasInput = false;
+	for (const resolution of resolutions) if (resolution._tag === "Absent") firstAbsent ??= resolution;
+	else {
+		values.push(resolution.value);
+		hasInput = hasInput || resolution.hasInput;
+	}
+	if (firstAbsent !== void 0) return hasInput ? fail(evaluationFailure(firstAbsent.error, true)) : succeed(firstAbsent);
+	return succeed(resolved(values, hasInput));
+};
+const resolveRecord = (resolutions) => {
+	const values = {};
+	let firstAbsent;
+	let hasInput = false;
+	for (const key in resolutions) {
+		const resolution = resolutions[key];
+		if (resolution._tag === "Absent") firstAbsent ??= resolution;
+		else {
+			assignProperty(values, key, resolution.value);
+			hasInput = hasInput || resolution.hasInput;
+		}
+	}
+	if (firstAbsent !== void 0) return hasInput ? fail(evaluationFailure(firstAbsent.error, true)) : succeed(firstAbsent);
+	return succeed(resolved(values, hasInput));
+};
+/**
+* Provides a fallback value when the config cannot resolve because none of its
+* relevant input is present.
+*
+* **When to use**
+*
+* Use when you need to make a config key optional with a sensible default.
+*
+* **Gotchas**
+*
+* Validation errors and partially supplied groups still propagate. A schema
+* that successfully decodes absent input also 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
+*
+* @category combinators
+* @since 2.0.0
+*/
+const withDefault = /*#__PURE__*/ dual(2, (self, defaultValue) => {
+	return make((provider, pathPrefix) => mapEager(evaluateAt(self, provider, pathPrefix), (resolution) => resolution._tag === "Absent" ? resolved(defaultValue, false) : resolution));
+});
+/**
+* Makes a config optional: returns `Some(value)` on success and `None` when the
+* config cannot resolve because none of its relevant input is present.
+*
+* **When to use**
+*
+* Use when you need to handle a config key that may or may not be present.
+*
+* **Gotchas**
+*
+* Validation errors and partially supplied groups still propagate. 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
+*
+* @category combinators
+* @since 2.0.0
+*/
+const option = (self) => self.pipe(map(some), withDefault(none()));
+/**
+* Constructs a `Config<T>` from a value matching `Wrap<T>`.
+*
+* **When to use**
+*
+* Use when accepting config from callers who may pass either a single `Config` or a
+*   record of individual `Config`s.
+*
+* **Details**
+*
+* If the input is already a `Config`, it is returned as-is. Otherwise, each
+* key is recursively unwrapped and combined.
+*
+* **Example** (Unwrapping a record of configs)
+*
+* ```ts import.meta.vitest
+* import { Config, ConfigProvider, Effect } from "effect"
+*
+* interface Options {
+*   key: string
+* }
+*
+* const makeConfig = (config: Config.Wrap<Options>): Config.Config<Options> =>
+*   Config.unwrap(config)
+*
+* const config = makeConfig({ key: Config.string("key") })
+* const provider = ConfigProvider.fromUnknown({ key: "value" })
+* Effect.runSync(config.parse(provider)) // => { key: "value" }
+* ```
+*
+* @see {@link Wrap} – the utility type accepted by this function
+*
+* @category converting
+* @since 2.0.0
+*/
+const unwrap = (wrapped) => {
+	if (isConfig(wrapped)) return wrapped;
+	return all(map$2(wrapped, (config) => unwrap(config)));
+};
+const cursorToString = () => "<configuration>";
+const loadCursor = (provider, path) => provider.load(path).pipe(orDie, mapEager((node) => ({
+	provider,
+	path,
+	node,
+	toString: cursorToString
+})));
+const loadChildCursor = (cursor, segment) => loadCursor(cursor.provider, [...cursor.path, segment]);
+const getScalar = (node) => node?.value;
+const decodeFromCursor = (ast, decode) => decodeTo(unknown, ast, new Transformation(transformOrFail((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 getScalar(node) !== void 0;
+	}
+};
+const toConfigCursorAST = (root) => {
+	const seen = /* @__PURE__ */ new WeakSet();
+	const recur = applyToSelfOrLastLinkEncoding((ast) => {
+		seen.add(ast);
+		switch (ast._tag) {
+			case "Objects": {
+				const matchesIndex = ast.indexSignatures.map((is) => _is(is.parameter));
+				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 (matchesIndex.length > 0) {
+						for (const key of node.keys) if (matchesIndex.some((matches) => matches(key))) 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);
+				return isScalarInput(ast) ? decodeFromCursor(ast, (cursor) => succeed(getScalar(cursor.node))) : ast.recur(recur);
+			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 });
+			default: return decodeFromCursor(ast, (cursor) => succeed(getScalar(cursor.node)));
+		}
+	});
+	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
+* explicitly present empty object is relevant input for a struct and required
+* fields are validated. The same empty parent container does not make an
+* `all` group present when all of its child configs are absent.
+*
+* 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
+*
+* @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 catchSourceError(loadCursor(provider, fullPath), false).pipe(flatMapEager((cursor) => {
+			const hasInput = hasProviderInput(encodedAst, cursor.node);
+			return catchSourceError(decodeCursor(cursor).pipe(mapEager((value) => resolved(value, hasInput)), catchEager((issue) => {
+				const error = new ConfigError(new SchemaError(fullPath.length > 0 ? new Pointer(fullPath, issue) : issue));
+				return hasInput ? fail(evaluationFailure(error, true)) : succeed(absent(error));
+			})), hasInput);
+		}));
+	});
+}
+/** @internal */
+const TrueValues = /*#__PURE__*/ Literals([
+	"true",
+	"yes",
+	"on",
+	"1",
+	"y"
+]);
+/** @internal */
+const FalseValues = /*#__PURE__*/ Literals([
+	"false",
+	"no",
+	"off",
+	"0",
+	"n"
+]);
+/**
+* Schema for boolean values encoded as strings.
+*
+* **When to use**
+*
+* Use when you need the reusable boolean schema value for `Config.schema` with
+* custom paths.
+*
+* **Details**
+*
+* Accepted string values: `true`, `false`, `yes`, `no`, `on`, `off`, `1`,
+* `0`, `y`, `n` (case-sensitive).
+*
+* @see {@link boolean} – convenience constructor
+*
+* @category schemas
+* @since 4.0.0
+*/
+const Boolean = /*#__PURE__*/ Literals([...TrueValues.literals, ...FalseValues.literals]).pipe(/*#__PURE__*/ decodeTo$1(Boolean$1, /*#__PURE__*/ transform({
+	decode: (value) => value === "true" || value === "yes" || value === "on" || value === "1" || value === "y",
+	encode: (value) => value ? "true" : "false"
+})));
+/**
+* Schema for port numbers (integers in 1–65535).
+*
+* **When to use**
+*
+* Use when you need the reusable port schema value for `Config.schema` with
+* custom paths.
+*
+* @see {@link port} – convenience constructor
+*
+* @category schemas
+* @since 4.0.0
+*/
+const Port = /*#__PURE__*/ Int.check(/*#__PURE__*/ isBetween({
+	minimum: 1,
+	maximum: 65535
+}));
+/**
+* Schema for `LogLevel` string literals.
+*
+* **When to use**
+*
+* Use when you need the reusable log-level schema value for `Config.schema`
+* with custom paths.
+*
+* **Details**
+*
+* Accepted values: `"All"`, `"Fatal"`, `"Error"`, `"Warn"`, `"Info"`,
+* `"Debug"`, `"Trace"`, `"None"`.
+*
+* @see {@link logLevel} – convenience constructor
+*
+* @category schemas
+* @since 4.0.0
+*/
+const LogLevel = /*#__PURE__*/ Literals(values);
+/**
+* Schema for key-value record types that can also be parsed from
+* a flat comma-separated string.
+*
+* **When to use**
+*
+* Use when reading key-value maps from a single env var (e.g. OpenTelemetry
+*   resource attributes).
+*
+* **Details**
+*
+* Accepts either a JSON-like record from the provider or a flat string like
+* `"key1=val1,key2=val2"`. The `separator` (default `","`) and
+* `keyValueSeparator` (default `"="`) can be customized.
+*
+* **Example** (Parsing a comma-separated record)
+*
+* ```ts import.meta.vitest
+* import { Config, ConfigProvider, Effect, Schema } from "effect"
+*
+* const schema = Config.Record(Schema.String, Schema.String)
+* const config = Config.schema(schema, "OTEL_RESOURCE_ATTRIBUTES")
+*
+* const provider = ConfigProvider.fromEnv({
+*   env: {
+*     OTEL_RESOURCE_ATTRIBUTES:
+*       "service.name=my-service,service.version=1.0.0,custom.attribute=value"
+*   }
+* })
+*
+* const result = Effect.runSync(config.parse(provider))
+* result["service.name"] // => "my-service"
+* result["service.version"] // => "1.0.0"
+* result["custom.attribute"] // => "value"
+* ```
+*
+* @see {@link Array} for separated or structural array input
+*
+* @category schemas
+* @since 4.0.0
+*/
+const Record = (key, value, options) => {
+	const record = Record$1(key, value);
+	const split = splitKeyValue(options);
+	return Union([record, String$1.pipe(decodeTo$1(toCodecStringTree(record), {
+		decode: split.decode,
+		encode: passthrough({ strict: false }).compose(split.encode)
+	}))]);
+};
+/**
+* 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
+*
+* @category constructors
+* @since 2.0.0
+*/
+function string(name) {
+	return schema(String$1, name);
+}
+/**
+* Creates a config for a numeric value (including `NaN`, `Infinity`).
+*
+* **When to use**
+*
+* Use when you need config input to accept JavaScript's full number domain,
+* including NaN and infinities, rather than reject non-finite values.
+*
+* **Details**
+*
+* Shortcut for `Config.schema(Schema.Number, name)`.
+*
+* @see {@link finite} for rejecting `NaN` and `Infinity`
+* @see {@link int} for accepting only integers
+*
+* @category constructors
+* @since 2.0.0
+*/
+function number(name) {
+	return schema(Number$1, name);
+}
+/**
+* Creates a config for an integer value. Rejects floats.
+*
+* **When to use**
+*
+* Use to read a numeric config value that must be an integer.
+*
+* **Details**
+*
+* Shortcut for `Config.schema(Schema.Int, name)`.
+*
+* @see {@link number} for accepting any number
+* @see {@link port} for accepting only integers in `1` through `65535`
+*
+* @category constructors
+* @since 4.0.0
+*/
+function int(name) {
+	return schema(Int, 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**
+*
+* Shortcut for `Config.schema(Config.Boolean, name)`.
+*
+* 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
+* ```
+*
+* @see {@link Boolean} for the underlying boolean codec
+*
+* @category constructors
+* @since 2.0.0
+*/
+function boolean(name) {
+	return schema(Boolean, 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**
+*
+* Shortcut for `Config.schema(Config.Port, name)`.
+*
+* **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
+* @see {@link Port} for the underlying port codec
+*
+* @category constructors
+* @since 3.16.0
+*/
+function port(name) {
+	return schema(Port, name);
+}
+/**
+* Creates a config for a log level string.
+*
+* **When to use**
+*
+* Use to read Effect log-level settings from configuration.
+*
+* **Details**
+*
+* Shortcut for `Config.schema(Config.LogLevel, name)`.
+*
+* Accepted values: `"All"`, `"Fatal"`, `"Error"`, `"Warn"`, `"Info"`,
+* `"Debug"`, `"Trace"`, `"None"`.
+*
+* **Example** (Reading a log level)
+*
+* ```ts import.meta.vitest
+* import { Config, ConfigProvider, Effect } from "effect"
+*
+* const program = Config.logLevel("LOG_LEVEL")
+*
+* const provider = ConfigProvider.fromEnv({
+*   env: {
+*     LOG_LEVEL: "Info"
+*   }
+* })
+*
+* Effect.runSync(
+*   program.pipe(Effect.provideService(ConfigProvider.ConfigProvider, provider))
+* ) // => "Info"
+* ```
+*
+* @see {@link LogLevel} for the underlying log-level codec
+*
+* @category constructors
+* @since 2.0.0
+*/
+function logLevel(name) {
+	return schema(LogLevel, name);
+}
+/**
+* Creates a config for a `URL` value parsed from a string.
+*
+* **When to use**
+*
+* Use to read configuration values that must be valid URL strings.
+*
+* **Details**
+*
+* This is a shortcut for `Config.schema(Schema.URL, name)`.
+*
+* **Gotchas**
+*
+* Fails if the string cannot be parsed by the `URL` constructor.
+*
+* **Example** (Reading a URL)
+*
+* ```ts import.meta.vitest
+* import { Config, ConfigProvider, Effect } from "effect"
+*
+* const program = Config.url("URL").pipe(Effect.map((url) => url.href))
+*
+* const provider = ConfigProvider.fromEnv({
+*   env: {
+*     URL: "https://example.com"
+*   }
+* })
+*
+* Effect.runSync(
+*   program.pipe(Effect.provideService(ConfigProvider.ConfigProvider, provider))
+* ) // => "https://example.com/"
+* ```
+*
+* @see {@link schema} for decoding configuration values with a custom codec
+*
+* @category constructors
+* @since 3.11.0
+*/
+function url(name) {
+	return schema(URL, name);
+}
+//#endregion
+export { withDefault as _, all as a, logLevel as c, option as d, port as f, url as g, unwrap as h, TrueValues as i, map as l, string as m, FalseValues as n, boolean as o, schema as p, Record as r, int as s, Boolean as t, number as u };
+
+//# sourceMappingURL=Config-Bj2ZPCsP.mjs.map