@effected/config-file 0.20.0 → 0.21.0

package/ConfigFile.js

@@ -114,7 +114,6 @@ var ConfigValidationError = class extends Schema.TaggedError()("ConfigValidation
 		})}`;
 	}
 };
-const Service = () => (id) => Context.Service()(id);
 /**
 * Re-raise a codec failure with the file it came from attached.
 *
@@ -401,46 +400,6 @@ const makeImpl = (options, fs, path, resolverEnv) => {
 		update
 	};
 };
-const layer = (tag, options) => Layer.effect(tag, Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const resolverEnv = yield* Effect.context();
-	return makeImpl(options, fs, path, resolverEnv);
-}));
-const testLayer = (tag, options) => Layer.effect(tag, Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const resolverEnv = yield* Effect.context();
-	const dir = yield* fs.makeTempDirectory({ prefix: "effected-config-file-" }).pipe(Effect.orDie);
-	yield* Effect.addFinalizer(() => fs.remove(dir, { recursive: true }).pipe(Effect.orDie));
-	for (const [name, content] of Object.entries(options.files)) {
-		const target = path.join(dir, name);
-		yield* fs.makeDirectory(path.dirname(target), { recursive: true }).pipe(Effect.orDie);
-		yield* fs.writeFileString(target, content).pipe(Effect.orDie);
-	}
-	const resolvers = Object.keys(options.files).map((name) => ConfigResolver.staticDir({
-		dir,
-		filename: name
-	}));
-	return makeImpl({
-		schema: options.schema,
-		codec: options.codec,
-		strategy: options.strategy,
-		resolvers,
-		...options.validate !== void 0 && { validate: options.validate }
-	}, fs, path, resolverEnv);
-}));
-const read = (path, options) => Effect.gen(function* () {
-	const raw = yield* (yield* FileSystem.FileSystem).readFileString(path).pipe(Effect.mapError((cause) => new ConfigFileReadError({
-		path,
-		cause
-	})));
-	const parsed = yield* options.codec.parse(raw).pipe(Effect.mapError((error) => withCodecPath(error, path)));
-	return yield* Schema.decodeUnknownEffect(options.schema)(parsed, options.parseOptions).pipe(Effect.catchTag("SchemaError", (error) => Effect.fail(new ConfigValidationError({
-		path: Option.some(path),
-		issue: error.issue
-	}))));
-}).pipe(Effect.withSpan("ConfigFile.read", { attributes: { path } }));
 /**
 * The config file service: a per-schema service factory, its layers, and the
 * one-shot {@link ConfigFile.read}.
@@ -471,7 +430,7 @@ var ConfigFile = class {
 	* >()("app/Secrets") {}
 	* ```
 	*/
-	static Service = Service;
+	static Service = () => (id) => Context.Service()(id);
 	/**
 	* Build the live layer for a config service class.
 	*
@@ -509,7 +468,12 @@ var ConfigFile = class {
 	* });
 	* ```
 	*/
-	static layer = layer;
+	static layer = (tag, options) => Layer.effect(tag, Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		const resolverEnv = yield* Effect.context();
+		return makeImpl(options, fs, path, resolverEnv);
+	}));
 	/**
 	* A scoped layer that seeds `files` into a temp directory, wires the **real**
 	* live implementation over them, and removes the directory when the scope
@@ -543,7 +507,29 @@ var ConfigFile = class {
 	* }).pipe(Layer.provide(NodeServices.layer));
 	* ```
 	*/
-	static testLayer = testLayer;
+	static testLayer = (tag, options) => Layer.effect(tag, Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		const resolverEnv = yield* Effect.context();
+		const dir = yield* fs.makeTempDirectory({ prefix: "effected-config-file-" }).pipe(Effect.orDie);
+		yield* Effect.addFinalizer(() => fs.remove(dir, { recursive: true }).pipe(Effect.orDie));
+		for (const [name, content] of Object.entries(options.files)) {
+			const target = path.join(dir, name);
+			yield* fs.makeDirectory(path.dirname(target), { recursive: true }).pipe(Effect.orDie);
+			yield* fs.writeFileString(target, content).pipe(Effect.orDie);
+		}
+		const resolvers = Object.keys(options.files).map((name) => ConfigResolver.staticDir({
+			dir,
+			filename: name
+		}));
+		return makeImpl({
+			schema: options.schema,
+			codec: options.codec,
+			strategy: options.strategy,
+			resolvers,
+			...options.validate !== void 0 && { validate: options.validate }
+		}, fs, path, resolverEnv);
+	}));
 	/**
 	* Read, decode and validate one explicit path — no service, no layer, no tag.
 	*
@@ -581,7 +567,17 @@ var ConfigFile = class {
 	* });
 	* ```
 	*/
-	static read = read;
+	static read = (path, options) => Effect.gen(function* () {
+		const raw = yield* (yield* FileSystem.FileSystem).readFileString(path).pipe(Effect.mapError((cause) => new ConfigFileReadError({
+			path,
+			cause
+		})));
+		const parsed = yield* options.codec.parse(raw).pipe(Effect.mapError((error) => withCodecPath(error, path)));
+		return yield* Schema.decodeUnknownEffect(options.schema)(parsed, options.parseOptions).pipe(Effect.catchTag("SchemaError", (error) => Effect.fail(new ConfigValidationError({
+			path: Option.some(path),
+			issue: error.issue
+		}))));
+	}).pipe(Effect.withSpan("ConfigFile.read", { attributes: { path } }));
 };
 
 export { ConfigDefaultPathMissingError, ConfigFile, ConfigFileNotFoundError, ConfigFileReadError, ConfigFileWriteError, ConfigValidationError };

package/ConfigMigration.js

@@ -60,24 +60,6 @@ const runPhase = (phase, version, name, run) => Effect.suspend(run).pipe(Effect.
 	phase,
 	cause
 })));
-const make = (options) => {
-	const access = options.versionAccess ?? VersionAccess.default;
-	const sorted = [...options.migrations].sort((a, b) => a.version - b.version);
-	return {
-		name: options.codec.name,
-		stringify: options.codec.stringify,
-		parse: (raw) => Effect.gen(function* () {
-			let parsed = yield* options.codec.parse(raw);
-			if (sorted.length === 0) return parsed;
-			const current = yield* runPhase("read-version", 0, "", () => access.get(parsed));
-			for (const migration of sorted.filter((m) => m.version > current)) {
-				parsed = yield* runPhase("apply", migration.version, migration.name, () => migration.up(parsed));
-				parsed = yield* runPhase("write-version", migration.version, migration.name, () => access.set(parsed, migration.version));
-			}
-			return parsed;
-		})
-	};
-};
 /** Versioned migration support for config codecs. @public */
 var ConfigMigration = class {
 	constructor() {}
@@ -111,7 +93,24 @@ var ConfigMigration = class {
 	* });
 	* ```
 	*/
-	static make = make;
+	static make = (options) => {
+		const access = options.versionAccess ?? VersionAccess.default;
+		const sorted = [...options.migrations].sort((a, b) => a.version - b.version);
+		return {
+			name: options.codec.name,
+			stringify: options.codec.stringify,
+			parse: (raw) => Effect.gen(function* () {
+				let parsed = yield* options.codec.parse(raw);
+				if (sorted.length === 0) return parsed;
+				const current = yield* runPhase("read-version", 0, "", () => access.get(parsed));
+				for (const migration of sorted.filter((m) => m.version > current)) {
+					parsed = yield* runPhase("apply", migration.version, migration.name, () => migration.up(parsed));
+					parsed = yield* runPhase("write-version", migration.version, migration.name, () => access.set(parsed, migration.version));
+				}
+				return parsed;
+			})
+		};
+	};
 };
 
 export { ConfigMigration, ConfigMigrationError, VersionAccess };

package/ConfigResolver.js

@@ -22,48 +22,6 @@ const absorb = (effect) => Effect.catch(effect, () => Effect.succeed({
 	probed: []
 }));
 const cwdOf = (given) => given ?? globalThis.process?.cwd?.() ?? "/";
-const explicitPath = (target) => fromProbe("explicit", absorb(Effect.gen(function* () {
-	return {
-		match: (yield* (yield* FileSystem.FileSystem).exists(target)) ? Option.some({ path: target }) : Option.none(),
-		probed: [target]
-	};
-})));
-const staticDir = (options) => fromProbe("static", absorb(Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	const candidate = (yield* Path.Path).join(options.dir, options.filename);
-	return {
-		match: (yield* fs.exists(candidate)) ? Option.some({
-			path: candidate,
-			dir: options.dir,
-			filename: options.filename
-		}) : Option.none(),
-		probed: [candidate]
-	};
-})));
-const upwardWalk = (options) => fromProbe(options.name ?? "walk", Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const subpaths = options.subpaths ?? ["."];
-	const filenames = options.filenames ?? [options.filename];
-	const dirs = yield* Walker.ascend(cwdOf(options.cwd), { ...options.stopAt !== void 0 && { stopAt: options.stopAt } });
-	const candidates = [];
-	for (const dir of dirs) for (const sub of subpaths) for (const filename of filenames) candidates.push({
-		path: path.join(dir, sub, filename),
-		dir,
-		filename,
-		...options.subpaths !== void 0 && { subpath: sub }
-	});
-	const paths = candidates.map((candidate) => candidate.path);
-	const found = yield* Walker.firstMatch(paths, (candidate) => fs.exists(candidate));
-	const probed = Option.match(found, {
-		onNone: () => paths,
-		onSome: (target) => paths.slice(0, paths.indexOf(target) + 1)
-	});
-	return {
-		match: Option.flatMap(found, (target) => Option.fromNullishOr(candidates.find((candidate) => candidate.path === target))),
-		probed
-	};
-}));
 /**
 * Ascend from `cwd` looking for the first directory where `isRoot` reports
 * true, then probe `subpaths` under it. Shared by `gitRoot` and
@@ -125,27 +83,6 @@ const isWorkspaceRoot = (dir) => Effect.gen(function* () {
 	if (yield* fs.exists(pkgPath)) return Option.isSome(decodeWorkspacesManifest(yield* fs.readFileString(pkgPath)));
 	return false;
 });
-const gitRoot = (options) => rootAnchored("git", isGitRoot, options);
-const workspaceRoot = (options) => rootAnchored("workspace", isWorkspaceRoot, options);
-const systemEtc = (options) => fromProbe("system", absorb(Effect.gen(function* () {
-	if (globalThis.process?.platform === "win32") return {
-		match: Option.none(),
-		probed: []
-	};
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const base = options.dir ?? "/etc";
-	const dir = path.join(base, options.app);
-	const candidate = path.join(dir, options.filename);
-	return {
-		match: (yield* fs.exists(candidate)) ? Option.some({
-			path: candidate,
-			dir,
-			filename: options.filename
-		}) : Option.none(),
-		probed: [candidate]
-	};
-})));
 /**
 * Built-in resolvers, in the order a typical chain uses them.
 *
@@ -154,12 +91,28 @@ const systemEtc = (options) => fromProbe("system", absorb(Effect.gen(function* (
 var ConfigResolver = class {
 	constructor() {}
 	/** Resolves to `target` when it exists on disk, or `Option.none()` when it does not — no walking, no filename convention. */
-	static explicitPath = explicitPath;
+	static explicitPath = (target) => fromProbe("explicit", absorb(Effect.gen(function* () {
+		return {
+			match: (yield* (yield* FileSystem.FileSystem).exists(target)) ? Option.some({ path: target }) : Option.none(),
+			probed: [target]
+		};
+	})));
 	/** Resolves `path.join(dir, filename)` when it exists on disk, or `Option.none()` when it does not. */
-	static staticDir = staticDir;
+	static staticDir = (options) => fromProbe("static", absorb(Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		const candidate = (yield* Path.Path).join(options.dir, options.filename);
+		return {
+			match: (yield* fs.exists(candidate)) ? Option.some({
+				path: candidate,
+				dir: options.dir,
+				filename: options.filename
+			}) : Option.none(),
+			probed: [candidate]
+		};
+	})));
 	/**
-	* Ascends from `cwd` (or the process cwd) toward `stopAt`, resolving the
-	* first `subpaths/filename` combination found at each level.
+	* Ascends from `cwd` (or the process cwd) toward `stopAt` or `ceiling`,
+	* resolving the first `subpaths/filename` combination found at each level.
 	*
 	* @remarks
 	* `filenames` replaces `filename` with a per-directory candidate list: every
@@ -172,24 +125,65 @@ var ConfigResolver = class {
 	* distinguishable; `ConfigSource.match` identifies the matching candidate
 	* more precisely still.
 	*/
-	static upwardWalk = upwardWalk;
+	static upwardWalk = (options) => fromProbe(options.name ?? "walk", Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		const subpaths = options.subpaths ?? ["."];
+		const filenames = options.filenames ?? [options.filename];
+		const dirs = options.ceiling !== void 0 ? yield* Walker.ascendWithin(cwdOf(options.cwd), Option.some(options.ceiling)) : yield* Walker.ascend(cwdOf(options.cwd), { ...options.stopAt !== void 0 && { stopAt: options.stopAt } });
+		const candidates = [];
+		for (const dir of dirs) for (const sub of subpaths) for (const filename of filenames) candidates.push({
+			path: path.join(dir, sub, filename),
+			dir,
+			filename,
+			...options.subpaths !== void 0 && { subpath: sub }
+		});
+		const paths = candidates.map((candidate) => candidate.path);
+		const found = yield* Walker.firstMatch(paths, (candidate) => fs.exists(candidate));
+		const probed = Option.match(found, {
+			onNone: () => paths,
+			onSome: (target) => paths.slice(0, paths.indexOf(target) + 1)
+		});
+		return {
+			match: Option.flatMap(found, (target) => Option.fromNullishOr(candidates.find((candidate) => candidate.path === target))),
+			probed
+		};
+	}));
 	/**
 	* Ascends from `cwd` to the nearest workspace root — a directory with a
 	* `pnpm-workspace.yaml`, or a `package.json` carrying a `workspaces` field —
 	* then resolves the first `subpaths/filename` combination found under it.
 	*/
-	static workspaceRoot = workspaceRoot;
+	static workspaceRoot = (options) => rootAnchored("workspace", isWorkspaceRoot, options);
 	/**
 	* Ascends from `cwd` to the nearest git root — a directory containing a
 	* `.git` entry, directory or file (the latter for a worktree) — then
 	* resolves the first `subpaths/filename` combination found under it.
 	*/
-	static gitRoot = gitRoot;
+	static gitRoot = (options) => rootAnchored("git", isGitRoot, options);
 	/**
 	* Resolves `<dir>/<app>/<filename>` under the system config root (`/etc` by
 	* default). Always `Option.none()` on Windows, where `/etc` has no meaning.
 	*/
-	static systemEtc = systemEtc;
+	static systemEtc = (options) => fromProbe("system", absorb(Effect.gen(function* () {
+		if (globalThis.process?.platform === "win32") return {
+			match: Option.none(),
+			probed: []
+		};
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		const base = options.dir ?? "/etc";
+		const dir = path.join(base, options.app);
+		const candidate = path.join(dir, options.filename);
+		return {
+			match: (yield* fs.exists(candidate)) ? Option.some({
+				path: candidate,
+				dir,
+				filename: options.filename
+			}) : Option.none(),
+			probed: [candidate]
+		};
+	})));
 };
 
 export { ConfigResolver };

package/MergeStrategy.js

@@ -2,39 +2,6 @@ import { canMerge, deepMerge } from "./internal/deepMerge.js";
 import { Effect } from "effect";
 
 // src/MergeStrategy.ts
-const firstMatch = () => ({
-	name: "first-match",
-	resolve: (sources) => Effect.succeed(sources[0].value)
-});
-/**
-* Deep-merge every contributing source, higher priority winning on conflict.
-*
-* @remarks
-* Two values merge only when both are record-like and share a prototype, so a
-* document decoded through `Schema.Class` merges with another of the same class
-* and **survives as a real instance** — `instanceof` holds and its getters
-* still work. Everything else is atomic: a nested `Date`, `Map`, `Set`,
-* `RegExp`, array, or class instance is taken whole from the highest-priority
-* source that defines it, never reshaped field-by-field.
-*
-* The alternative — spreading each value into a fresh object — would make
-* `load`'s declared `Effect<A>` a lie, handing back a structurally-equal plain
-* object whose class methods are gone and whose `Date` fields have decayed to
-* `{}`.
-*
-* Nested *plain* objects (a `Schema.Struct` section) still merge field-wise.
-*/
-const layeredMerge = () => ({
-	name: "layered-merge",
-	resolve: (sources) => {
-		let merged = sources[sources.length - 1]?.value;
-		for (let i = sources.length - 2; i >= 0; i--) {
-			const higher = sources[i]?.value;
-			merged = canMerge(merged, higher) ? deepMerge(higher, merged) : higher;
-		}
-		return Effect.succeed(merged);
-	}
-});
 /**
 * Built-in merge strategies: `firstMatch` (the highest-priority source wins
 * whole) and `layeredMerge` (every source deep-merged, higher priority winning).
@@ -53,8 +20,40 @@ const layeredMerge = () => ({
 * @public
 */
 const MergeStrategy = {
-	firstMatch,
-	layeredMerge
+	/** Take the highest-priority source whole. */
+	firstMatch: () => ({
+		name: "first-match",
+		resolve: (sources) => Effect.succeed(sources[0].value)
+	}),
+	/**
+	* Deep-merge every contributing source, higher priority winning on conflict.
+	*
+	* @remarks
+	* Two values merge only when both are record-like and share a prototype, so a
+	* document decoded through `Schema.Class` merges with another of the same class
+	* and **survives as a real instance** — `instanceof` holds and its getters
+	* still work. Everything else is atomic: a nested `Date`, `Map`, `Set`,
+	* `RegExp`, array, or class instance is taken whole from the highest-priority
+	* source that defines it, never reshaped field-by-field.
+	*
+	* The alternative — spreading each value into a fresh object — would make
+	* `load`'s declared `Effect<A>` a lie, handing back a structurally-equal plain
+	* object whose class methods are gone and whose `Date` fields have decayed to
+	* `{}`.
+	*
+	* Nested *plain* objects (a `Schema.Struct` section) still merge field-wise.
+	*/
+	layeredMerge: () => ({
+		name: "layered-merge",
+		resolve: (sources) => {
+			let merged = sources[sources.length - 1]?.value;
+			for (let i = sources.length - 2; i >= 0; i--) {
+				const higher = sources[i]?.value;
+				merged = canMerge(merged, higher) ? deepMerge(higher, merged) : higher;
+			}
+			return Effect.succeed(merged);
+		}
+	})
 };
 
 export { MergeStrategy };

package/index.d.ts

@@ -411,16 +411,53 @@ interface ConfigProbe {
  * (`".config/app.toml"`), which is how a mixed convention is spelled without a
  * `subpaths` cross product.
  *
+ * At most one of `stopAt` (a lexical ceiling) and `ceiling` (a physical
+ * one) is given. Bound the walk by a path git answered — `Git.repoRoot` — with
+ * `ceiling`; `stopAt` never matches a symlink-resolved spelling of the start.
+ *
  * @public
  */
-type UpwardWalkOptions = {
+type UpwardWalkOptions = ({
   /** The single file name probed at each ancestor directory. */
   readonly filename: string;
   readonly filenames?: undefined;
+} | {
+  /**
+   * The candidate file names probed at each ancestor directory, in order,
+   * before the walk ascends.
+   */
+  readonly filenames: ReadonlyArray<string>;
+  readonly filename?: undefined;
+}) & ({
+  /**
+   * An absolute ceiling the walk stops at, inclusive, compared
+   * LEXICALLY (`Walker.ascend`'s `stopAt`).
+   *
+   * @remarks
+   * A ceiling spelled differently from the walk's own path never
+   * matches, and the walk runs on to the filesystem root. That is
+   * every physical path — `Git.repoRoot`'s answer from a symlinked or
+   * macOS-tmpdir start — so bound by such a path with `ceiling`.
+   */
+  readonly stopAt?: string;
+  readonly ceiling?: undefined;
+} | {
+  /**
+   * A ceiling the walk stops at, inclusive, compared PHYSICALLY: the
+   * nearest ancestor whose real path is the ceiling's real path
+   * (`Walker.ascendWithin`).
+   *
+   * @remarks
+   * For a ceiling that may be spelled differently from the walk's own
+   * path, above all `Git.repoRoot`'s symlink-resolved answer. Omit it
+   * to walk to the filesystem root. A relative ceiling is a defect.
+   * Cannot be combined with `stopAt`.
+   */
+  readonly ceiling?: string;
+  readonly stopAt?: undefined;
+}) & {
   /** Where the walk starts. Defaults to the process cwd. */
   readonly cwd?: string;
-  /** An absolute ceiling the walk stops at, inclusive. */
-  readonly stopAt?: string;
   /** Directories probed under each ancestor, in order. Defaults to `["."]`. */
   readonly subpaths?: ReadonlyArray<string>;
   /**
@@ -433,21 +470,6 @@ type UpwardWalkOptions = {
    * identifies the matching candidate rather than the resolver.
    */
   readonly name?: string;
-} | {
-  /**
-   * The candidate file names probed at each ancestor directory, in order,
-   * before the walk ascends.
-   */
-  readonly filenames: ReadonlyArray<string>;
-  readonly filename?: undefined;
-  /** Where the walk starts. Defaults to the process cwd. */
-  readonly cwd?: string;
-  /** An absolute ceiling the walk stops at, inclusive. */
-  readonly stopAt?: string;
-  /** Directories probed under each ancestor, in order. Defaults to `["."]`. */
-  readonly subpaths?: ReadonlyArray<string>;
-  /** The resolver's reported name. Defaults to `"walk"`. */
-  readonly name?: string;
 };
 /**
  * Built-in resolvers, in the order a typical chain uses them.
@@ -464,8 +486,8 @@ export declare class ConfigResolver {
     readonly filename: string;
   }) => ConfigResolver<FileSystem.FileSystem | Path.Path>;
   /**
-   * Ascends from `cwd` (or the process cwd) toward `stopAt`, resolving the
-   * first `subpaths/filename` combination found at each level.
+   * Ascends from `cwd` (or the process cwd) toward `stopAt` or `ceiling`,
+   * resolving the first `subpaths/filename` combination found at each level.
    *
    * @remarks
    * `filenames` replaces `filename` with a per-directory candidate list: every
@@ -576,7 +598,26 @@ export interface MergeStrategy<A> {
  * @public
  */
 export declare const MergeStrategy: {
+  /** Take the highest-priority source whole. */
   readonly firstMatch: <A>() => MergeStrategy<A>;
+  /**
+   * Deep-merge every contributing source, higher priority winning on conflict.
+   *
+   * @remarks
+   * Two values merge only when both are record-like and share a prototype, so a
+   * document decoded through `Schema.Class` merges with another of the same class
+   * and **survives as a real instance** — `instanceof` holds and its getters
+   * still work. Everything else is atomic: a nested `Date`, `Map`, `Set`,
+   * `RegExp`, array, or class instance is taken whole from the highest-priority
+   * source that defines it, never reshaped field-by-field.
+   *
+   * The alternative — spreading each value into a fresh object — would make
+   * `load`'s declared `Effect<A>` a lie, handing back a structurally-equal plain
+   * object whose class methods are gone and whose `Date` fields have decayed to
+   * `{}`.
+   *
+   * Nested *plain* objects (a `Schema.Struct` section) still merge field-wise.
+   */
   readonly layeredMerge: <A>() => MergeStrategy<A>;
 };
 declare const ConfigFileNotFoundError_base: Schema.Class<ConfigFileNotFoundError, Schema.TaggedStruct<"ConfigFileNotFoundError", {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/config-file",
-	"version": "0.20.0",
+	"version": "0.21.0",
 	"private": false,
 	"description": "Composable config file loading for Effect: JSON, JSONC, YAML and TOML codecs, resolution strategies, and merge behaviors.",
 	"keywords": [
@@ -58,10 +58,10 @@
 		"./package.json": "./package.json"
 	},
 	"peerDependencies": {
-		"@effected/glob": "^0.14.0",
-		"@effected/jsonc": "^0.20.0",
+		"@effected/glob": "^0.15.0",
+		"@effected/jsonc": "^0.20.1",
 		"@effected/toml": "^0.16.0",
-		"@effected/walker": "^0.20.0",
+		"@effected/walker": "^0.21.0",
 		"@effected/yaml": "^0.25.1",
 		"effect": "^4.0.0"
 	},

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.59.1"
+      "packageVersion": "7.59.4"
     }
   ]
 }