@effected/config-file 0.1.0

package/ConfigCodec.js

@@ -0,0 +1,27 @@
+import { Schema } from "effect";
+
+//#region src/ConfigCodec.ts
+/**
+* Indicates that a codec failed to parse or stringify configuration content.
+*
+* @remarks
+* The underlying failure is preserved structurally in `cause` — it is never
+* stringified. Route on the `"ConfigCodecError"` tag with `Effect.catchTag`.
+*
+* @public
+*/
+var ConfigCodecError = class extends Schema.TaggedErrorClass()("ConfigCodecError", {
+	/** The codec that failed, e.g. `"json"`. */
+	codec: Schema.String,
+	/** Which direction failed. */
+	operation: Schema.Literals(["parse", "stringify"]),
+	/** The underlying failure, preserved structurally. */
+	cause: Schema.Defect()
+}) {
+	get message() {
+		return `${this.codec} ${this.operation} failed`;
+	}
+};
+
+//#endregion
+export { ConfigCodecError };

package/ConfigEvent.js

@@ -0,0 +1,119 @@
+import { Context, Effect, Layer, PubSub, Schema } from "effect";
+
+//#region src/ConfigEvent.ts
+/**
+* A reference to one configuration source that contributed to a load.
+*
+* @remarks
+* Carries the resolver's name alongside the path so a subscriber can tell
+* `/etc/app/.apprc` found by `systemEtc` from the same path passed explicitly.
+*
+* @public
+*/
+const ConfigSourceRef = Schema.Struct({
+	/** The filesystem path the value was read from. */
+	path: Schema.String,
+	/** The name of the resolver that found it. */
+	resolver: Schema.String
+});
+/**
+* Every event published during config discovery, parsing, validation and
+* persistence.
+*
+* @remarks
+* v3's `Stringified` and `ResolutionFailed` variants were declared and never
+* emitted; they are not ported. `DiscoveryFailed` goes with them: under this
+* package's resolver-absorption contract a resolver's error channel is `never`
+* — every filesystem failure becomes `Option.none()` — so the pipeline can
+* never observe a discovery failure to report one.
+*
+* The failure variants carry the **structured** typed error in `error`, not a
+* `reason` string. v3 stringified them, destroying every field a subscriber
+* might branch on; a subscriber that wants prose can read `error.message`.
+*
+* @public
+*/
+const ConfigEventPayload = Schema.Union([
+	Schema.TaggedStruct("Discovered", {
+		path: Schema.String,
+		resolver: Schema.String
+	}),
+	Schema.TaggedStruct("NotFound", {}),
+	Schema.TaggedStruct("Parsed", {
+		path: Schema.String,
+		codec: Schema.String
+	}),
+	Schema.TaggedStruct("ParseFailed", {
+		path: Schema.String,
+		codec: Schema.String,
+		error: Schema.Defect()
+	}),
+	Schema.TaggedStruct("Validated", { path: Schema.String }),
+	Schema.TaggedStruct("ValidationFailed", {
+		path: Schema.String,
+		error: Schema.Defect()
+	}),
+	Schema.TaggedStruct("Resolved", {
+		sources: Schema.Array(ConfigSourceRef),
+		strategy: Schema.String
+	}),
+	Schema.TaggedStruct("Loaded", { sources: Schema.Array(ConfigSourceRef) }),
+	Schema.TaggedStruct("StringifyFailed", {
+		codec: Schema.String,
+		error: Schema.Defect()
+	}),
+	Schema.TaggedStruct("Written", { path: Schema.String }),
+	Schema.TaggedStruct("Saved", { path: Schema.String }),
+	Schema.TaggedStruct("Updated", { path: Schema.String })
+]);
+/**
+* A published event: the payload plus the instant it occurred.
+*
+* @public
+*/
+var ConfigEvent = class extends Schema.Class("ConfigEvent")({
+	/** When the event occurred. */
+	timestamp: Schema.DateTimeUtc,
+	/** What happened. */
+	event: ConfigEventPayload
+}) {};
+/**
+* The opt-in event hook: a PubSub of {@link ConfigEvent} that consumers
+* subscribe to.
+*
+* @remarks
+* Opt-in and honestly zero-cost: when `ConfigFileOptions.events` is omitted the
+* pipeline's `emit` is `Effect.void` and never even looks the service up.
+*
+* Events are a **consumer-facing hook**, not the package's observability
+* channel — every public fallible method is also an `Effect.fn` named span, and
+* the library stays telemetry-agnostic.
+*
+* @example
+* ```ts
+* const events = ConfigEvents.layer;
+* const AppLayer = Layer.mergeAll(
+* 	events,
+* 	ConfigFile.layer(AppConfig, { schema, codec, resolvers, strategy, events: ConfigEvents }),
+* );
+* ```
+*
+* @public
+*/
+var ConfigEvents = class ConfigEvents extends Context.Service()("@effected/config-file/ConfigEvents") {
+	/**
+	* An unbounded PubSub of config events.
+	*
+	* @remarks
+	* Unbounded on purpose: a slow subscriber must never apply backpressure to a
+	* config load. Bind this to a const and provide that const — building it
+	* twice mints two hubs, and the subscriber would watch the one `emit` does
+	* not publish to.
+	*/
+	static layer = Layer.effect(ConfigEvents, Effect.gen(function* () {
+		return { events: yield* PubSub.unbounded() };
+	}));
+};
+
+//#endregion
+export { ConfigEvent, ConfigEventPayload, ConfigEvents, ConfigSourceRef };

package/ConfigFile.js

@@ -0,0 +1,421 @@
+import { ConfigEvent } from "./ConfigEvent.js";
+import { ConfigResolver } from "./ConfigResolver.js";
+import { Context, DateTime, Effect, FileSystem, Layer, Option, Path, PubSub, Schema, Semaphore } from "effect";
+
+//#region src/ConfigFile.ts
+/**
+* Indicates that the resolver chain produced no configuration source.
+*
+* @remarks
+* Its own tag, so "no config anywhere" is routable with `Effect.catchTag`
+* separately from "the config I found is broken" — the single most important
+* distinction the v3 mega-error could not express.
+*
+* @public
+*/
+var ConfigFileNotFoundError = class extends Schema.TaggedErrorClass()("ConfigFileNotFoundError", { 
+/** The names of the resolvers that were probed, in order. */
+searched: Schema.Array(Schema.String) }) {
+	get message() {
+		return `No config file found (searched: ${this.searched.join(", ")})`;
+	}
+};
+/**
+* Indicates that a config file could not be read from the filesystem.
+*
+* @remarks
+* `cause` preserves the underlying filesystem failure structurally. v3 flattened
+* it to `reason: String(e)`.
+*
+* @public
+*/
+var ConfigFileReadError = class extends Schema.TaggedErrorClass()("ConfigFileReadError", {
+	/** The path that could not be read. */
+	path: Schema.String,
+	/** The underlying failure, preserved structurally. */
+	cause: Schema.Defect()
+}) {
+	get message() {
+		return `Failed to read config file at "${this.path}"`;
+	}
+};
+/**
+* Indicates that a config file could not be written to the filesystem.
+*
+* @public
+*/
+var ConfigFileWriteError = class extends Schema.TaggedErrorClass()("ConfigFileWriteError", {
+	/** The path that could not be written. */
+	path: Schema.String,
+	/** The underlying failure, preserved structurally. */
+	cause: Schema.Defect()
+}) {
+	get message() {
+		return `Failed to write config file at "${this.path}"`;
+	}
+};
+/**
+* Indicates that {@link ConfigFileShape.save} or {@link ConfigFileShape.update}
+* was called on a service configured without a `defaultPath`.
+*
+* @remarks
+* v3 reported this as a generic `ConfigError` carrying `operation: "save"` and
+* `reason: "no default path configured"` — indistinguishable by tag from a real
+* write failure.
+*
+* It carries no `path` field on purpose. The whole point of this failure is
+* that there is no path; a {@link ConfigFileWriteError} with a fabricated path
+* would be a lie, and lying error payloads are what this port exists to undo.
+*
+* @public
+*/
+var ConfigDefaultPathMissingError = class extends Schema.TaggedErrorClass()("ConfigDefaultPathMissingError", {}) {
+	get message() {
+		return "No `defaultPath` configured: `save` and `update` require ConfigFileOptions.defaultPath";
+	}
+};
+/**
+* Indicates that parsed config content did not satisfy the schema, or that a
+* caller-supplied `validate` rejected it.
+*
+* @remarks
+* `issue` carries the **structured** schema failure — at runtime a
+* `SchemaIssue.Issue` tree, reachable through `_tag` and nested `issues`. v3
+* flattened this to `String(ParseError)`, destroying every field a caller might
+* branch on. It is typed `unknown` because v4 exposes no `Schema` for `Issue`;
+* narrow it with the `SchemaIssue` module.
+*
+* @public
+*/
+var ConfigValidationError = class extends Schema.TaggedErrorClass()("ConfigValidationError", {
+	/** The offending file, absent when `validate` was called on an in-memory value. */
+	path: Schema.Option(Schema.String),
+	/** The structured schema issue. Never a string. */
+	issue: Schema.Defect()
+}) {
+	get message() {
+		return `Config validation failed${Option.match(this.path, {
+			onNone: () => "",
+			onSome: (p) => ` at "${p}"`
+		})}`;
+	}
+};
+/**
+* Create a uniquely-keyed service class for one config schema.
+*
+* @example
+* ```ts
+* class AppConfig extends ConfigFile.Service<AppConfig, AppShape>()("app/Config") {}
+* ```
+*
+* @public
+*/
+const Service = () => (id) => Context.Service()(id);
+const makeImpl = (options, fs, path, resolverEnv) => {
+	/**
+	* Publish one event, or nothing at all.
+	*
+	* @remarks
+	* Three properties hold, in order of how easy they are to lose:
+	*
+	* 1. **Zero-cost when absent.** No `events` option means `Effect.void` — no
+	*    context lookup, no `DateTime.now`.
+	* 2. **Never a requirement.** `Effect.serviceOption` reads the ambient context
+	*    without adding to `R`, so wiring events cannot change a layer's type.
+	* 3. **Never fatal.** A subscriber's hub is consumer-supplied code. It cannot
+	*    FAIL — `PubSub.publish` has no error channel — but it CAN throw, and
+	*    `catchDefect` absorbs that; interruption is deliberately left to
+	*    propagate, because a config load that is being interrupted must stay
+	*    interrupted.
+	*/
+	const emit = (payload) => options.events === void 0 ? Effect.void : Effect.serviceOption(options.events).pipe(Effect.flatMap(Option.match({
+		onNone: () => Effect.void,
+		onSome: (svc) => Effect.gen(function* () {
+			const timestamp = yield* DateTime.now;
+			yield* PubSub.publish(svc.events, new ConfigEvent({
+				timestamp,
+				event: payload
+			}));
+		})
+	})), Effect.catchDefect((defect) => Effect.logDebug("ConfigEvents.emit: consumer hub raised a defect", defect)));
+	/** The public, path-and-resolver view of the sources that fed a load. */
+	const sourceRefs = (sources) => sources.map((s) => ({
+		path: s.path,
+		resolver: s.resolver
+	}));
+	const decode = (parsed, at) => Schema.decodeUnknownEffect(options.schema)(parsed).pipe(Effect.catchTag("SchemaError", (error) => Effect.fail(new ConfigValidationError({
+		path: at,
+		issue: error.issue
+	}))));
+	const runValidate = (value) => options.validate ? options.validate(value) : Effect.succeed(value);
+	const loadFrom = Effect.fn("ConfigFile.loadFrom")(function* (target) {
+		const raw = yield* fs.readFileString(target).pipe(Effect.mapError((cause) => new ConfigFileReadError({
+			path: target,
+			cause
+		})));
+		const parsed = yield* options.codec.parse(raw).pipe(Effect.tapError((error) => emit({
+			_tag: "ParseFailed",
+			path: target,
+			codec: options.codec.name,
+			error
+		})));
+		yield* emit({
+			_tag: "Parsed",
+			path: target,
+			codec: options.codec.name
+		});
+		const validated = yield* Effect.gen(function* () {
+			const decoded = yield* decode(parsed, Option.some(target));
+			return yield* runValidate(decoded);
+		}).pipe(Effect.tapError((error) => emit({
+			_tag: "ValidationFailed",
+			path: target,
+			error
+		})));
+		yield* emit({
+			_tag: "Validated",
+			path: target
+		});
+		return validated;
+	});
+	const discover = Effect.fn("ConfigFile.discover")(function* () {
+		const sources = [];
+		for (const resolver of options.resolvers) {
+			const found = yield* Effect.provide(resolver.resolve, resolverEnv);
+			if (Option.isSome(found)) {
+				const target = found.value;
+				yield* emit({
+					_tag: "Discovered",
+					path: target,
+					resolver: resolver.name
+				});
+				sources.push({
+					path: target,
+					resolver: resolver.name,
+					value: yield* loadFrom(target)
+				});
+			}
+		}
+		return sources;
+	});
+	const searched = options.resolvers.map((r) => r.name);
+	/**
+	* Merge the discovered sources and announce the result. Shared by `load` and
+	* `loadOrDefault`, which in v3 each re-inlined it and drifted apart.
+	*
+	* Both events carry EVERY contributing source. v3 reported `sources[0].path`,
+	* which is wrong under `layeredMerge`, where all of them contributed.
+	*/
+	const mergeAndEmit = (sources) => Effect.gen(function* () {
+		const value = yield* options.strategy.resolve(sources);
+		const refs = sourceRefs(sources);
+		yield* emit({
+			_tag: "Resolved",
+			sources: refs,
+			strategy: options.strategy.name
+		});
+		yield* emit({
+			_tag: "Loaded",
+			sources: refs
+		});
+		return value;
+	});
+	const load = Effect.fn("ConfigFile.load")(function* () {
+		const sources = yield* discover();
+		if (sources.length === 0) {
+			yield* emit({ _tag: "NotFound" });
+			return yield* Effect.fail(new ConfigFileNotFoundError({ searched }));
+		}
+		return yield* mergeAndEmit(sources);
+	});
+	const loadOrDefault = Effect.fn("ConfigFile.loadOrDefault")(function* (defaultValue) {
+		const sources = yield* discover();
+		if (sources.length === 0) {
+			yield* emit({ _tag: "NotFound" });
+			return defaultValue;
+		}
+		return yield* mergeAndEmit(sources);
+	});
+	const validate = Effect.fn("ConfigFile.validate")(function* (value) {
+		const decoded = yield* decode(value, Option.none());
+		return yield* runValidate(decoded);
+	});
+	/**
+	* Shared by `write` and `save`. Not an `Effect.fn`: it is internal, and the
+	* public boundaries that call it already open a span.
+	*/
+	const encodeAndWrite = (value, target) => Effect.gen(function* () {
+		const encoded = yield* Schema.encodeEffect(options.schema)(value).pipe(Effect.catchTag("SchemaError", (error) => Effect.fail(new ConfigValidationError({
+			path: Option.some(target),
+			issue: error.issue
+		}))));
+		const serialized = yield* options.codec.stringify(encoded).pipe(Effect.tapError((error) => emit({
+			_tag: "StringifyFailed",
+			codec: options.codec.name,
+			error
+		})));
+		yield* fs.writeFileString(target, serialized).pipe(Effect.mapError((cause) => new ConfigFileWriteError({
+			path: target,
+			cause
+		})));
+	});
+	/**
+	* Resolve `defaultPath`, `mkdir -p` its parent and write. Shared by `save`
+	* and `update`, and — crucially — emits nothing.
+	*
+	* v3's `update` called the public `save`, so a single `update` published
+	* `Written` + `Saved` + `Updated`; v3 documented this as a known smell. Event
+	* granularity is per-operation, so the emitting boundary must sit in the
+	* public method, never in the shared internals it delegates to.
+	*/
+	const saveTo = (value) => Effect.gen(function* () {
+		const configured = options.defaultPath;
+		if (configured === void 0) return yield* Effect.fail(new ConfigDefaultPathMissingError({}));
+		const target = yield* Effect.provide(configured, resolverEnv);
+		yield* fs.makeDirectory(path.dirname(target), { recursive: true }).pipe(Effect.mapError((cause) => new ConfigFileWriteError({
+			path: target,
+			cause
+		})));
+		yield* encodeAndWrite(value, target);
+		return target;
+	});
+	const write = Effect.fn("ConfigFile.write")(function* (value, target) {
+		yield* encodeAndWrite(value, target);
+		yield* emit({
+			_tag: "Written",
+			path: target
+		});
+	});
+	const save = Effect.fn("ConfigFile.save")(function* (value) {
+		const target = yield* saveTo(value);
+		yield* emit({
+			_tag: "Saved",
+			path: target
+		});
+		return target;
+	});
+	/**
+	* Serializes `update`'s read-modify-write. One permit, one service instance.
+	*
+	* @remarks
+	* `update` is load → transform → save. Without a lock, two concurrent calls
+	* both read the old document across the read's async boundary and both write
+	* their own transform of it, so one caller's change is silently lost. The
+	* lock covers the whole critical section, not just the write.
+	*
+	* This guards a single service instance in a single process. It is not a file
+	* lock: another process writing the same path concurrently can still clobber.
+	*/
+	const updateLock = Semaphore.makeUnsafe(1);
+	const update = Effect.fn("ConfigFile.update")(function* (fn, defaultValue) {
+		return yield* updateLock.withPermits(1)(Effect.gen(function* () {
+			const updated = fn(defaultValue !== void 0 ? yield* loadOrDefault(defaultValue) : yield* load());
+			const target = yield* saveTo(updated);
+			yield* emit({
+				_tag: "Updated",
+				path: target
+			});
+			return updated;
+		}));
+	});
+	return {
+		load: load(),
+		loadFrom,
+		discover: discover(),
+		loadOrDefault,
+		validate,
+		write,
+		save,
+		update
+	};
+};
+/**
+* Build the live layer for a config service class.
+*
+* @remarks
+* Resolver requirements flow into the layer's `R` type. v3 cast them away with
+* `as Effect.Effect<Option<string>>`, making `Layer<Service, never, FileSystem>`
+* a claim rather than a proof.
+*
+* `ConfigFile.layer` is a layer-RETURNING function, not a layer: calling it
+* twice builds two independent service instances. Bind its result to a const
+* and provide that const, per the memoization discipline — do not call
+* `ConfigFile.layer(...)` inline at each provide site.
+*
+* @public
+*/
+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);
+}));
+/**
+* A scoped layer that seeds `files` into a temp directory, wires the **real**
+* live implementation over them, and removes the directory when the scope
+* closes.
+*
+* @remarks
+* Deliberately not a mock. It delegates to the very same `makeImpl` that
+* {@link ConfigFile.layer} uses, so tests exercise the actual codec, resolver
+* and merge pipeline rather than a parallel implementation that can drift from
+* it. A stubbed test layer would make every downstream test a claim about the
+* stub instead of about the code under test.
+*
+* Platform-agnostic: the consumer supplies the `FileSystem` layer, and the temp
+* directory is created through `FileSystem.makeTempDirectory` rather than
+* `node:fs`.
+*
+* `Layer.scoped` does not exist in v4. `Layer.effect` types its layer as
+* `Layer<I, E, Exclude<R, Scope>>`, so an `Effect.addFinalizer` inside it binds
+* to the layer's own scope and runs on release without surfacing `Scope` in the
+* layer's requirements.
+*
+* @example
+* ```ts
+* const TestConfig = ConfigFile.testLayer(AppConfig, {
+* 	schema: AppShape,
+* 	codec: JsonCodec,
+* 	strategy: MergeStrategy.firstMatch<AppShape>(),
+* 	files: { ".apprc": `{"port":4242}` },
+* }).pipe(Layer.provide(NodeServices.layer));
+* ```
+*
+* @public
+*/
+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);
+}));
+/**
+* The config file service: a per-schema service factory and its layers.
+*
+* @public
+*/
+const ConfigFile = {
+	Service,
+	layer,
+	testLayer
+};
+
+//#endregion
+export { ConfigDefaultPathMissingError, ConfigFile, ConfigFileNotFoundError, ConfigFileReadError, ConfigFileWriteError, ConfigValidationError };

package/ConfigMigration.js

@@ -0,0 +1,97 @@
+import { Effect, Schema } from "effect";
+
+//#region src/ConfigMigration.ts
+/**
+* Indicates that a versioned config migration failed.
+*
+* @remarks
+* `phase` says where: reading the current version, applying a step, or writing
+* the new version back. `cause` preserves the underlying failure by identity
+* when the failing step signals recoverable failure with `Effect.fail`. v3
+* assembled all three into a prose `reason` string.
+*
+* @public
+*/
+var ConfigMigrationError = class extends Schema.TaggedErrorClass()("ConfigMigrationError", {
+	/** The target version of the step that failed. `0` when reading the version failed. */
+	version: Schema.Number,
+	/** The name of the step that failed; empty when reading the version failed. */
+	name: Schema.String,
+	/** Which stage of a migration step failed. */
+	phase: Schema.Literals([
+		"read-version",
+		"apply",
+		"write-version"
+	]),
+	/** The underlying failure, preserved structurally. */
+	cause: Schema.Defect()
+}) {
+	get message() {
+		return this.phase === "read-version" ? "Failed to read the config version" : `Migration "${this.name}" (v${this.version}) failed during ${this.phase}`;
+	}
+};
+const defaultVersionAccess = {
+	get: (raw) => {
+		if (typeof raw !== "object" || raw === null) return Effect.fail(/* @__PURE__ */ new Error("config is not an object"));
+		const version = raw.version;
+		return typeof version === "number" ? Effect.succeed(version) : Effect.fail(/* @__PURE__ */ new Error("version field is missing or not a number"));
+	},
+	set: (raw, version) => Effect.succeed({
+		...raw,
+		version
+	})
+};
+/** Reads and writes a top-level `version` field. @public */
+const VersionAccess = { default: defaultVersionAccess };
+/**
+* Runs one migration phase, mapping its declared failure into a
+* {@link ConfigMigrationError}.
+*
+* @remarks
+* `up` and {@link (VersionAccess:interface)} are caller-supplied code with a declared error
+* channel: they signal failure with `Effect.fail`. A `throw` from one of them is
+* a contract violation — a programmer bug, not a data condition — and stays a
+* defect so a consumer's `catchTag("ConfigMigrationError")` cannot silently
+* swallow it. `Effect.suspend` ensures a throw raised while constructing the
+* effect dies exactly like a throw raised while running it.
+*/
+const runPhase = (phase, version, name, run) => Effect.suspend(run).pipe(Effect.mapError((cause) => new ConfigMigrationError({
+	version,
+	name,
+	phase,
+	cause
+})));
+/**
+* Wrap a codec so that parsed content is brought up to the latest version.
+*
+* @remarks
+* The returned codec's error channel **widens** to include
+* {@link ConfigMigrationError} rather than flattening migration failures into
+* the inner codec's error — the reason the {@link (ConfigCodec:interface)} seam is generic
+* in its error type.
+*
+* @public
+*/
+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 */
+const ConfigMigration = { make };
+
+//#endregion
+export { ConfigMigration, ConfigMigrationError, VersionAccess };