@das-org/dascode 0.0.31

package/dist/Config-DcF-IZjO.mjs

@@ -0,0 +1,1274 @@
+#!/usr/bin/env node
+
+import { A as Record$1, Al as map$2, C as NonEmptyString, Cn as toEncoded, E as Number$1, En as transform, Eu as some, Fu as Prototype, Gr as flatMap, Kl as Reference, Kr as flatMapEager, Lu as PipeInspectableProto, M as String$1, Qt as decodeUnknownEffect, Si as mapErrorEager, Tn as splitKeyValue, W as Union, Wu as assignProperty, Yr as fnUntraced, Zt as _is, ad as hasProperty, bu as isSome, dr as all$1, en as SchemaError, h as Int, ht as isBetween, kr as catch_, na as succeed$1, nt as decodeTo, po as TaggedError, r as Boolean$1, tn as isSchemaError, tr as Pointer, v as Literals, vu as isNone, wu as none, xd as dual, yi as map$1, z as URL, zr as fail$1, zt as toCodecStringTree } from "./Schema-DuQUv9rO.mjs";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.102_patch_10dcca2e28a1e6c67a3825e6da1ff253/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 { ConfigProvider } from "effect"
+*
+* const node = 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 { ConfigProvider } from "effect"
+*
+* const node = ConfigProvider.makeRecord(new Set(["host", "port"]))
+* // { _tag: "Record", keys: Set(["host", "port"]), 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 { ConfigProvider } from "effect"
+*
+* const node = 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 { ConfigProvider, Effect } from "effect"
+*
+* const provider = ConfigProvider.make((_path) =>
+*   Effect.fail(
+*     new ConfigProvider.SourceError({ message: "connection refused" })
+*   )
+* )
+* ```
+*
+* @see {@link ConfigProvider} – the interface whose `load` may fail with this
+*   error
+*
+* @category models
+* @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 { 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)
+* )
+* ```
+*
+* @see {@link layer} – install a provider as a Layer
+* @see {@link layerAdd} – add a fallback provider as a Layer
+*
+* @category services
+* @since 2.0.0
+*/
+const ConfigProvider = /*#__PURE__*/ Reference("effect/ConfigProvider", { defaultValue: () => fromEnv() });
+const Proto$1 = {
+	...PipeInspectableProto,
+	toJSON() {
+		return { _id: "ConfigProvider" };
+	}
+};
+const identityPath = (path) => path;
+function makeProvider(state, load) {
+	const self = Object.create(Proto$1);
+	self.state = state;
+	self.load = load;
+	return self;
+}
+function makeSource(get, transform) {
+	const state = {
+		_tag: "Source",
+		get,
+		transform
+	};
+	return makeProvider(state, (path) => state.get(state.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; fail with `SourceError` only for actual I/O errors.
+*
+* **Example** (Creating a simple in-memory provider)
+*
+* ```ts
+* 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
+*   )
+* })
+* ```
+*
+* @see {@link fromEnv} – pre-built provider for environment variables
+* @see {@link fromUnknown} – pre-built provider for JSON objects
+*
+* @category constructors
+* @since 2.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 { 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 ConfigProviders
+* @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$1(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.102_patch_10dcca2e28a1e6c67a3825e6da1ff253/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 models
+* @since 4.0.0
+*/
+const values = [
+	"All",
+	"Fatal",
+	"Error",
+	"Warn",
+	"Info",
+	"Debug",
+	"Trace",
+	"None"
+];
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.102_patch_10dcca2e28a1e6c67a3825e6da1ff253/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 { Config } from "effect"
+*
+* console.log(Config.isConfig(Config.string("HOST"))) // true
+* console.log(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 for missing-data errors
+*
+* @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(parse) {
+	const self = Object.create(Proto);
+	self.parse = (provider, pathPrefix = []) => parse(provider, pathPrefix);
+	return self;
+}
+/**
+* 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 { 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(self.parse(provider, pathPrefix), f));
+});
+/**
+* Transforms the parsed value with a function that may fail.
+*
+* **When to use**
+*
+* Use when you need to transform a parsed config value with a function that can
+* produce a `ConfigError` (e.g. parsing a URL, checking a range).
+*
+* **Example** (Wrapping a value in an effectful transformation)
+*
+* ```ts
+* import { Config, Effect } from "effect"
+*
+* const trimmed = Config.string("name").pipe(
+*   Config.mapOrFail((s) => Effect.succeed(s.trim()))
+* )
+* ```
+*
+* @see {@link map} – when the transformation cannot fail
+*
+* @category mapping
+* @since 2.0.0
+*/
+const mapOrFail = /*#__PURE__*/ dual(2, (self, f) => {
+	return make((provider, pathPrefix) => flatMap(self.parse(provider, pathPrefix), f));
+});
+/**
+* Provides a fallback config when parsing fails with a `ConfigError`.
+*
+* **When to use**
+*
+* Use when you need to try an alternative config source after the primary one
+* fails.
+*
+* **Details**
+*
+* Unlike {@link withDefault}, this catches **all** `ConfigError`s (not just
+* missing data). The fallback function receives the error and returns a new
+* `Config`.
+*
+* **Example** (Falling back to a literal)
+*
+* ```ts
+* import { Config } from "effect"
+*
+* const hostConfig = Config.string("HOST").pipe(
+*   Config.orElse(() => Config.succeed("localhost"))
+* )
+* ```
+*
+* @see {@link withDefault} – fallback only on missing data
+*
+* @category combinators
+* @since 2.0.0
+*/
+const orElse = /*#__PURE__*/ dual(2, (self, that) => {
+	return make((provider, pathPrefix) => catch_(self.parse(provider, pathPrefix), (error) => that(error).parse(provider, pathPrefix)));
+});
+/**
+* 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.
+*
+* **Example** (Combining configs as a struct)
+*
+* ```ts
+* 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) => all$1(configs.map((config) => config.parse(provider, pathPrefix))));
+	else return make((provider, pathPrefix) => all$1(map$2(configs, (config) => config.parse(provider, pathPrefix))));
+}
+function isMissingDataOnly(issue) {
+	switch (issue._tag) {
+		case "MissingKey": return true;
+		case "InvalidType":
+		case "InvalidValue": return isNone(issue.actual) || isSome(issue.actual) && issue.actual.value === void 0;
+		case "OneOf": return issue.actual === void 0;
+		case "Encoding": return isNone(issue.actual) || isSome(issue.actual) && issue.actual.value === void 0 ? true : isMissingDataOnly(issue.issue);
+		case "Pointer": return isMissingDataOnly(issue.issue);
+		case "Filter":
+		case "UnexpectedKey":
+		case "Forbidden": return false;
+		case "Composite": return issue.issues.every(isMissingDataOnly);
+		case "AnyOf":
+			if (issue.issues.length === 0) return issue.actual === void 0;
+			return issue.issues.every(isMissingDataOnly);
+	}
+}
+/**
+* Provides a fallback value when the config fails due to missing data.
+*
+* **When to use**
+*
+* Use when you need to make a config key optional with a sensible default.
+*
+* **Gotchas**
+*
+* Only applies when the error is a `SchemaError` caused exclusively by
+* missing data (missing keys, undefined values). Validation errors (wrong
+* type, out of range) still propagate.
+*
+* **Example** (Defaulting a missing port)
+*
+* ```ts
+* 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 missing data
+*
+* @category combinators
+* @since 2.0.0
+*/
+const withDefault = /*#__PURE__*/ dual(2, (self, defaultValue) => {
+	return orElse(self, (err) => {
+		if (isSchemaError(err.cause)) {
+			const issue = err.cause.issue;
+			if (isMissingDataOnly(issue)) return succeed(defaultValue);
+		}
+		return fail(err.cause);
+	});
+});
+/**
+* Makes a config optional: returns `Some(value)` on success and `None` when
+* data is missing.
+*
+* **When to use**
+*
+* Use when you need to handle a config key that may or may not be present.
+*
+* **Gotchas**
+*
+* Like {@link withDefault}, only missing-data errors produce `None`.
+* Validation errors still propagate.
+*
+* **Example** (Reading optional config)
+*
+* ```ts
+* import { Config, ConfigProvider, Effect } from "effect"
+*
+* const maybePort = Config.option(Config.number("port"))
+*
+* const provider = ConfigProvider.fromUnknown({})
+* // Effect.runSync(maybePort.parse(provider)) // { _tag: "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 { Config } from "effect"
+*
+* interface Options {
+*   key: string
+* }
+*
+* const makeConfig = (config: Config.Wrap<Options>): Config.Config<Options> =>
+*   Config.unwrap(config)
+* ```
+*
+* @see {@link Wrap} – the utility type accepted by this function
+*
+* @category Wrap
+* @since 2.0.0
+*/
+const unwrap = (wrapped) => {
+	if (isConfig(wrapped)) return wrapped;
+	return make((provider, pathPrefix) => {
+		return all$1(Object.entries(wrapped).map(([key, config]) => unwrap(config).parse(provider, pathPrefix).pipe(map$1((value) => [key, value])))).pipe(map$1(Object.fromEntries));
+	});
+};
+const dump = /*#__PURE__*/ fnUntraced(function* (provider, path) {
+	const stat = yield* provider.load(path);
+	if (stat === void 0) return void 0;
+	switch (stat._tag) {
+		case "Value": return stat.value;
+		case "Record": {
+			if (stat.value !== void 0) return stat.value;
+			const out = {};
+			for (const key of stat.keys) {
+				const child = yield* dump(provider, [...path, key]);
+				if (child !== void 0) assignProperty(out, key, child);
+			}
+			return out;
+		}
+		case "Array": {
+			if (stat.value !== void 0) return stat.value;
+			const out = [];
+			for (let i = 0; i < stat.length; i++) out.push(yield* dump(provider, [...path, i]));
+			return out;
+		}
+	}
+});
+const recur = /*#__PURE__*/ fnUntraced(function* (ast, provider, path) {
+	switch (ast._tag) {
+		case "Objects": {
+			const stat = yield* provider.load(path);
+			if (stat === void 0 && path.length > 0) return void 0;
+			const out = {};
+			for (const ps of ast.propertySignatures) {
+				const name = ps.name;
+				if (typeof name === "string") {
+					const value = yield* recur(ps.type, provider, [...path, name]);
+					if (value !== void 0) assignProperty(out, name, value);
+				}
+			}
+			if (ast.indexSignatures.length > 0) {
+				if (stat && stat._tag === "Record") for (const is of ast.indexSignatures) {
+					const matches = _is(is.parameter);
+					for (const key of stat.keys) if (!Object.hasOwn(out, key) && matches(key)) {
+						const value = yield* recur(is.type, provider, [...path, key]);
+						if (value !== void 0) assignProperty(out, key, value);
+					}
+				}
+			}
+			return out;
+		}
+		case "Arrays": {
+			const stat = yield* provider.load(path);
+			if (stat === void 0) return void 0;
+			if (stat && stat._tag === "Value") return stat.value === "" ? [] : stat.value.split(",");
+			if (stat && stat._tag === "Array" && stat.value !== void 0) return stat.value === "" ? [] : stat.value.split(",");
+			const out = [];
+			const length = stat && stat._tag === "Array" ? stat.length : ast.elements.length;
+			for (let i = 0; i < length; i++) {
+				const element = ast.elements[i] ?? ast.rest[0];
+				if (element !== void 0) out.push(yield* recur(element, provider, [...path, i]));
+			}
+			return out;
+		}
+		case "Union": return yield* dump(provider, path);
+		case "Suspend": return yield* recur(ast.thunk(), provider, path);
+		default: {
+			const stat = yield* provider.load(path);
+			if (stat === void 0) return void 0;
+			if (stat._tag === "Value") return stat.value;
+			if (stat._tag === "Record" && stat.value !== void 0) return stat.value;
+			if (stat._tag === "Array" && stat.value !== void 0) return stat.value;
+			return;
+		}
+	}
+});
+/**
+* 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 used to decode the raw `StringTree` produced by the provider
+* into `T`. Schema validation errors are wrapped in `ConfigError`.
+*
+* **Example** (Reading a structured config)
+*
+* ```ts
+* 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 decodeUnknownEffect$1 = decodeUnknownEffect(codecStringTree);
+	const codecStringTreeEncoded = toEncoded(codecStringTree.ast);
+	const localPath = typeof path === "string" ? [path] : path ?? [];
+	return make((provider, pathPrefix) => {
+		const fullPath = [...pathPrefix, ...localPath];
+		return recur(codecStringTreeEncoded, provider, fullPath).pipe(flatMapEager((tree) => decodeUnknownEffect$1(tree).pipe(mapErrorEager((issue) => new SchemaError(fullPath.length > 0 ? new Pointer(fullPath, issue) : issue)))), mapErrorEager((cause) => new ConfigError(cause)));
+	});
+}
+/** @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(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 { 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"
+*   }
+* })
+*
+* console.dir(Effect.runSync(config.parse(provider)))
+* // {
+* //   'service.name': 'my-service',
+* //   'service.version': '1.0.0',
+* //   'custom.attribute': 'value'
+* // }
+* ```
+*
+* @category schemas
+* @since 4.0.0
+*/
+const Record = (key, value, options) => {
+	const record = Record$1(key, value);
+	return Union([record, String$1.pipe(decodeTo(Record$1(String$1, String$1), splitKeyValue(options)), decodeTo(record))]);
+};
+/**
+* Creates a config that always fails with the given error.
+*
+* **When to use**
+*
+* Use when you need to re-raise a specific config error, such as inside
+* {@link orElse}.
+*
+* @category constructors
+* @since 2.0.0
+*/
+function fail(err) {
+	return make(() => fail$1(new ConfigError(err)));
+}
+/**
+* Creates a config that always succeeds with the given value, ignoring the
+* provider entirely.
+*
+* **When to use**
+*
+* Use when you need a hardcoded config value, such as inside {@link orElse} or
+* tests.
+*
+* **Example** (Returning a constant fallback)
+*
+* ```ts
+* import { Config } from "effect"
+*
+* const host = Config.string("HOST").pipe(
+*   Config.orElse(() => Config.succeed("localhost"))
+* )
+* ```
+*
+* @category constructors
+* @since 2.0.0
+*/
+function succeed(value) {
+	return make(() => succeed$1(value));
+}
+/**
+* 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 { 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 non-empty string value. Fails if the value is an
+* empty string.
+*
+* **When to use**
+*
+* Use to read a string config value that must contain at least one character.
+*
+* **Details**
+*
+* Shortcut for `Config.schema(Schema.NonEmptyString, name)`.
+*
+* @see {@link string} for allowing empty strings
+*
+* @category constructors
+* @since 3.7.0
+*/
+function nonEmptyString(name) {
+	return schema(NonEmptyString, 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 { Config, ConfigProvider, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const flag = yield* Config.boolean("FEATURE_FLAG")
+*   console.log(flag)
+* })
+*
+* const provider = ConfigProvider.fromEnv({
+*   env: {
+*     FEATURE_FLAG: "yes"
+*   }
+* })
+*
+* Effect.runSync(
+*   program.pipe(Effect.provideService(ConfigProvider.ConfigProvider, provider))
+* )
+* // Output: 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 { Config, ConfigProvider, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const port = yield* Config.port("PORT")
+*   console.log(port)
+* })
+*
+* const provider = ConfigProvider.fromEnv({
+*   env: {
+*     PORT: "8080"
+*   }
+* })
+*
+* Effect.runSync(
+*   program.pipe(Effect.provideService(ConfigProvider.ConfigProvider, provider))
+* )
+* // Output: 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 { Config, ConfigProvider, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const logLevel = yield* Config.logLevel("LOG_LEVEL")
+*   console.log(logLevel)
+* })
+*
+* const provider = ConfigProvider.fromEnv({
+*   env: {
+*     LOG_LEVEL: "Info"
+*   }
+* })
+*
+* Effect.runSync(
+*   program.pipe(Effect.provideService(ConfigProvider.ConfigProvider, provider))
+* )
+* // Output: "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 { Config, ConfigProvider, Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const url = yield* Config.url("URL")
+*   console.log(url)
+* })
+*
+* const provider = ConfigProvider.fromEnv({
+*   env: {
+*     URL: "https://example.com"
+*   }
+* })
+*
+* Effect.runSync(
+*   program.pipe(Effect.provideService(ConfigProvider.ConfigProvider, provider))
+* )
+* // Output:
+* // URL {
+* //   href: 'https://example.com/',
+* //   origin: 'https://example.com',
+* //   protocol: 'https:',
+* //   username: '',
+* //   password: '',
+* //   host: 'example.com',
+* //   hostname: 'example.com',
+* //   port: '',
+* //   pathname: '/',
+* //   search: '',
+* //   searchParams: URLSearchParams {},
+* //   hash: ''
+* // }
+* ```
+*
+* @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 { SourceError as S, schema as _, TrueValues as a, url as b, int as c, mapOrFail as d, nonEmptyString as f, port as g, orElse as h, Record as i, logLevel as l, option as m, ConfigError as n, all as o, number as p, FalseValues as r, boolean as s, Boolean as t, map as u, string as v, withDefault as x, unwrap as y };
+
+//# sourceMappingURL=Config-DcF-IZjO.mjs.map