rolldown-pnpm-config 0.1.0

package/cli/discover.js

@@ -0,0 +1,128 @@
+import { Data } from "effect";
+import { parseSync } from "oxc-parser";
+
+//#region src/cli/discover.ts
+/**
+* Typed failure raised when the config source cannot be parsed.
+*
+* @internal
+*/
+var DiscoverError = class extends Data.TaggedError("DiscoverError") {};
+/** Matches a simple-operator range we can safely rewrite (`^x`, `~x`, or bare `x`). */
+const SIMPLE_RANGE_RE = /^(\^|~|)(\d[\w.+-]*)$/;
+function operatorOf(range) {
+	if (range.startsWith("^")) return "^";
+	if (range.startsWith("~")) return "~";
+	return "";
+}
+/**
+* Find a property value by key name in an ObjectExpression node.
+* Handles both Identifier keys (unquoted) and Literal keys (quoted).
+*/
+function prop(obj, key) {
+	const properties = obj.properties ?? [];
+	for (const p of properties) {
+		if (p.type !== "Property") continue;
+		const k = p.key;
+		if ((k.type === "Identifier" ? k.name : k.type === "Literal" ? String(k.value) : void 0) === key) return p.value;
+	}
+}
+/** Find the first `PnpmConfigPlugin(...)` CallExpression's first argument object. */
+function findPluginArg(program) {
+	let found;
+	const visit = (node) => {
+		if (found || node === null || typeof node !== "object") return;
+		const n = node;
+		if (n.type === "CallExpression") {
+			const callee = n.callee;
+			if (callee?.type === "Identifier" && callee.name === "PnpmConfigPlugin") {
+				const args = n.arguments;
+				if (args?.[0]?.type === "ObjectExpression") {
+					found = args[0];
+					return;
+				}
+			}
+		}
+		for (const value of Object.values(n)) if (Array.isArray(value)) value.forEach(visit);
+		else if (value && typeof value === "object") visit(value);
+	};
+	visit(program);
+	return found;
+}
+/**
+* Statically discover the catalog version literals in a config source. Locates
+* the single `PnpmConfigPlugin(...)` call and walks `.catalogs.<name>.packages`.
+* Each package whose range is a simple-operator string literal yields a
+* CatalogEntry with byte-offset spans; anything else (computed value, complex
+* range) is reported in `skipped` as `<catalog>.<pkg>` and never throws.
+*
+* @internal
+*/
+function discoverCatalogEntries(source, filename) {
+	const result = parseSync(filename, source);
+	if (result.errors.length > 0) throw new DiscoverError({ message: result.errors.map((e) => e.message).join("; ") });
+	const program = result.program;
+	const entries = [];
+	const skipped = [];
+	const arg = findPluginArg(program);
+	if (!arg) return {
+		entries,
+		skipped
+	};
+	const catalogs = prop(arg, "catalogs");
+	if (catalogs?.type !== "ObjectExpression") return {
+		entries,
+		skipped
+	};
+	for (const catProp of catalogs.properties ?? []) {
+		if (catProp.type !== "Property") continue;
+		const catKey = catProp.key;
+		const catalog = catKey.type === "Identifier" ? catKey.name : String(catKey.value);
+		const decl = catProp.value;
+		if (decl.type !== "ObjectExpression") continue;
+		const packages = prop(decl, "packages");
+		if (packages?.type !== "ObjectExpression") continue;
+		for (const pkgProp of packages.properties ?? []) {
+			if (pkgProp.type !== "Property") continue;
+			const pkgKey = pkgProp.key;
+			const pkg = pkgKey.type === "Identifier" ? pkgKey.name : String(pkgKey.value);
+			const value = pkgProp.value;
+			let rangeNode;
+			let peerNode;
+			let strategy;
+			if (value.type === "Literal" && typeof value.value === "string") rangeNode = value;
+			else if (value.type === "ObjectExpression") {
+				const r = prop(value, "range");
+				if (r?.type === "Literal" && typeof r.value === "string") rangeNode = r;
+				const p = prop(value, "peer");
+				if (p?.type === "Literal" && typeof p.value === "string") peerNode = p;
+				const s = prop(value, "strategy");
+				if (s?.type === "Literal" && (s.value === "lock" || s.value === "lock-minor" || s.value === "interop")) strategy = s.value;
+			}
+			if (!rangeNode || !SIMPLE_RANGE_RE.test(rangeNode.value)) {
+				skipped.push(`${catalog}.${pkg}`);
+				continue;
+			}
+			const currentRange = rangeNode.value;
+			entries.push({
+				catalog,
+				pkg,
+				currentRange,
+				operator: operatorOf(currentRange),
+				rangeSpan: [rangeNode.start, rangeNode.end],
+				...peerNode ? { peer: {
+					value: peerNode.value,
+					span: [peerNode.start, peerNode.end]
+				} } : {},
+				...strategy ? { strategy } : {}
+			});
+		}
+	}
+	return {
+		entries,
+		skipped
+	};
+}
+
+//#endregion
+export { DiscoverError, discoverCatalogEntries };

package/cli/drift.js

@@ -0,0 +1,22 @@
+import { derivePeerRange } from "./peer-range.js";
+import { Effect } from "effect";
+
+//#region src/cli/drift.ts
+/**
+* Detect whether an entry's materialized peer range has drifted from what its
+* strategy would produce from the CURRENT range. Returns the resync target (the
+* up-to-date peer range) on drift, or null when in sync or not applicable
+* (missing peer or strategy).
+*
+* @internal
+*/
+function detectPeerDrift(entry) {
+	return Effect.gen(function* () {
+		if (!entry.peer || !entry.strategy) return null;
+		const expected = yield* derivePeerRange(entry.currentRange, entry.strategy);
+		return expected === entry.peer.value ? null : expected;
+	});
+}
+
+//#endregion
+export { detectPeerDrift };

package/cli/edits.js

@@ -0,0 +1,41 @@
+//#region src/cli/edits.ts
+/**
+* Convert resolved decisions into span edits. A chosen upgrade rewrites the
+* range literal (and the existing peer literal when the candidate carries a
+* recomputed peerRange). A keep with peer drift rewrites only the peer literal
+* to the resync target.
+*
+* @internal
+*/
+function buildEdits(decisions) {
+	const edits = [];
+	for (const { item, chosen } of decisions) {
+		const { entry } = item;
+		const insertAt = entry.rangeSpan[1];
+		if (chosen.kind !== "keep") {
+			edits.push({
+				span: entry.rangeSpan,
+				text: JSON.stringify(chosen.range)
+			});
+			if (entry.peer && chosen.peerRange) edits.push({
+				span: entry.peer.span,
+				text: JSON.stringify(chosen.peerRange)
+			});
+			else if (!entry.peer && entry.strategy && chosen.peerRange) edits.push({
+				span: [insertAt, insertAt],
+				text: `, peer: ${JSON.stringify(chosen.peerRange)}`
+			});
+		} else if (entry.peer && item.driftPeer) edits.push({
+			span: entry.peer.span,
+			text: JSON.stringify(item.driftPeer)
+		});
+		else if (!entry.peer && item.materializePeer) edits.push({
+			span: [insertAt, insertAt],
+			text: `, peer: ${JSON.stringify(item.materializePeer)}`
+		});
+	}
+	return edits;
+}
+
+//#endregion
+export { buildEdits };

package/cli/effective.js

@@ -0,0 +1,42 @@
+import { excludeByRepo } from "../runtime/ctx.js";
+import { applyLocalDirective } from "./local-merge.js";
+
+//#region src/cli/effective.ts
+/** Apply the manifest's excludeByRepo refine to publicHoistPattern, if present. */
+function applyExcludeByRepo(out, manifest, rootName) {
+	const byRepo = manifest.publicHoistPattern?.options?.excludeByRepo;
+	const phl = out.publicHoistPattern;
+	if (byRepo && typeof byRepo === "object" && Array.isArray(phl)) out.publicHoistPattern = excludeByRepo(phl, { rootName }, byRepo);
+}
+/**
+* Compute the effective workspace fields for THIS repo: managed base, then
+* excludeByRepo on publicHoistPattern, then per-field local directives.
+* `overrides` always runs (default file-protocol preserve), even with no local.
+*
+* @internal
+*/
+function effectiveManaged(managed, local, parsed, manifest, rootName) {
+	const out = { ...managed };
+	applyExcludeByRepo(out, manifest, rootName);
+	const fields = /* @__PURE__ */ new Set(["overrides", ...Object.keys(local ?? {})]);
+	for (const field of fields) {
+		const next = applyLocalDirective(out[field], local?.[field], parsed[field], field);
+		if (next === void 0) delete out[field];
+		else out[field] = next;
+	}
+	return out;
+}
+/**
+* The fresh-consumer ("vanilla") workspace fields: managed base + excludeByRepo
+* only — no local overlay and no preserve.
+*
+* @internal
+*/
+function vanillaManaged(managed, manifest, rootName) {
+	const out = { ...managed };
+	applyExcludeByRepo(out, manifest, rootName);
+	return out;
+}
+
+//#endregion
+export { effectiveManaged, vanillaManaged };

package/cli/evaluate.js

@@ -0,0 +1,91 @@
+import { parseSync } from "oxc-parser";
+
+//#region src/cli/evaluate.ts
+/** Find the first `PnpmConfigPlugin(...)` call's first argument (an object literal). */
+function findPluginArg(program) {
+	let found;
+	const visit = (node) => {
+		if (found || node === null || typeof node !== "object") return;
+		const n = node;
+		if (n.type === "CallExpression") {
+			const callee = n.callee;
+			if (callee?.type === "Identifier" && callee.name === "PnpmConfigPlugin") {
+				const args = n.arguments;
+				if (args?.[0]?.type === "ObjectExpression") {
+					found = args[0];
+					return;
+				}
+			}
+		}
+		for (const value of Object.values(n)) if (Array.isArray(value)) value.forEach(visit);
+		else if (value && typeof value === "object") visit(value);
+	};
+	visit(program);
+	return found;
+}
+/** Evaluate a literal AST node into a plain JS value; unsupported nodes push to `errors`. */
+function evalNode(node, path, errors) {
+	switch (node.type) {
+		case "Literal": return node.value;
+		case "ArrayExpression": {
+			const out = [];
+			for (const [i, el] of (node.elements ?? []).entries()) {
+				if (el === null) {
+					errors.push(`${path}[${i}]: holes are not supported`);
+					continue;
+				}
+				const val = evalNode(el, `${path}[${i}]`, errors);
+				if (val !== void 0) out.push(val);
+			}
+			return out;
+		}
+		case "ObjectExpression": {
+			const out = {};
+			for (const prop of node.properties ?? []) {
+				if (prop.type !== "Property") {
+					errors.push(`${path}: spread/getter is not supported`);
+					continue;
+				}
+				const key = prop.key;
+				const name = key.type === "Identifier" ? key.name : key.type === "Literal" ? String(key.value) : void 0;
+				if (name === void 0) {
+					errors.push(`${path}: computed key is not supported`);
+					continue;
+				}
+				const value = evalNode(prop.value, `${path}.${name}`, errors);
+				if (value !== void 0) out[name] = value;
+			}
+			return out;
+		}
+		default:
+			errors.push(`${path}: ${node.type} is not a literal; inline a concrete value`);
+			return;
+	}
+}
+/**
+* Statically evaluate the single `PnpmConfigPlugin(...)` call's object-literal
+* argument into a plain config object. No module execution. Non-literal values
+* are reported in `errors` and omitted; `config` is null when no call is found.
+*
+* @internal
+*/
+function evaluatePluginConfig(source, filename) {
+	const errors = [];
+	const result = parseSync(filename, source);
+	if (result.errors.length > 0) return {
+		config: null,
+		errors: result.errors.map((e) => e.message)
+	};
+	const arg = findPluginArg(result.program);
+	if (!arg) return {
+		config: null,
+		errors
+	};
+	return {
+		config: evalNode(arg, "config", errors),
+		errors
+	};
+}
+
+//#endregion
+export { evaluatePluginConfig };

package/cli/interop.js

@@ -0,0 +1,285 @@
+import { Effect } from "effect";
+import { Range, SemVer } from "semver-effect";
+
+//#region src/cli/interop.ts
+/** Maximum number of concurrent peerDependencies fetches inside runInterop. @internal */
+const INTEROP_PEER_CONCURRENCY = 8;
+/** Strip a range operator to its bare version digits (e.g. `^3.17.0` → `3.17.0`). */
+function floorOf(range) {
+	return range.replace(/^[\^~>=\s]+/, "").split(/\s/)[0] ?? range;
+}
+/**
+* Derive each member's caret-capped peer floor: the lowest floor any in-group
+* member declares for it, or `^<its resolved version>` when no member peers on
+* it.
+*
+* @internal
+*/
+function deriveFloors(resolved, fetchPeer) {
+	return Effect.gen(function* () {
+		const floors = /* @__PURE__ */ new Map();
+		for (const [pkg, version] of resolved) {
+			const peers = yield* fetchPeer(pkg, version);
+			for (const [dep, range] of Object.entries(peers)) {
+				if (!resolved.has(dep)) continue;
+				const list = floors.get(dep) ?? [];
+				list.push(floorOf(range));
+				floors.set(dep, list);
+			}
+		}
+		const out = /* @__PURE__ */ new Map();
+		for (const [pkg, version] of resolved) {
+			const declared = floors.get(pkg);
+			if (declared?.length) {
+				const valid = (yield* Effect.forEach(declared, (f) => SemVer.parse(f).pipe(Effect.map((sv) => ({
+					f,
+					sv
+				})), Effect.catchAll(() => Effect.succeed(null))))).filter((x) => x !== null);
+				valid.sort((a, b) => a.sv.compare(b.sv));
+				out.set(pkg, `^${valid[0]?.f ?? version}`);
+			} else out.set(pkg, `^${version}`);
+		}
+		return out;
+	});
+}
+/** Does `version` satisfy `range`? Unparseable input is treated as not-satisfied. */
+function satisfies(version, range) {
+	return Effect.gen(function* () {
+		const r = yield* Range.parse(range).pipe(Effect.catchAll(() => Effect.succeed(null)));
+		if (!r) return false;
+		const v = yield* SemVer.parse(version).pipe(Effect.catchAll(() => Effect.succeed(null)));
+		return v ? r.test(v) : false;
+	});
+}
+/**
+* In-group peers of (pkg@version) that the current resolution violates, as
+* "dep@range" strings. Uses the Effectful `fetchPeer` so it fetches on-demand
+* only when a candidate version's peer-deps have not yet been cached.
+*/
+function violations(pkg, version, resolved, memberSet, fetchPeer) {
+	return Effect.gen(function* () {
+		const out = [];
+		for (const [dep, range] of Object.entries(yield* fetchPeer(pkg, version))) {
+			if (!memberSet.has(dep)) continue;
+			const rv = resolved.get(dep);
+			if (rv === void 0) continue;
+			if (!(yield* satisfies(rv, range))) out.push(`${dep}@${range}`);
+		}
+		return out;
+	});
+}
+/**
+* Reconcile a group's chosen versions against their cross-peerDependencies by
+* downgrading dependents only. Ceilings are never raised and peer targets are
+* never downgraded; unsatisfiable members become conflicts.
+*
+* @internal
+*/
+function resolveGroup(members, fetchPeer) {
+	return Effect.gen(function* () {
+		const memberSet = new Set(members.map((m) => m.pkg));
+		const resolved = new Map(members.map((m) => [m.pkg, m.ceiling]));
+		const ceilingOf = new Map(members.map((m) => [m.pkg, m.ceiling]));
+		const leq = (a, b) => Effect.gen(function* () {
+			const av = yield* SemVer.parse(a).pipe(Effect.catchAll(() => Effect.succeed(null)));
+			const bv = yield* SemVer.parse(b).pipe(Effect.catchAll(() => Effect.succeed(null)));
+			return av && bv ? av.compare(bv) <= 0 : false;
+		});
+		const maxIter = members.reduce((n, m) => n + m.candidates.length, 0) + members.length + 1;
+		for (let i = 0; i < maxIter; i++) {
+			let changed = false;
+			for (const m of members) {
+				const cur = resolved.get(m.pkg);
+				if ((yield* violations(m.pkg, cur, resolved, memberSet, fetchPeer)).length === 0) continue;
+				const ceiling = ceilingOf.get(m.pkg);
+				const eligible = [];
+				for (const c of m.candidates) if (yield* leq(c, ceiling)) eligible.push(c);
+				const sorted = yield* sortDesc(eligible);
+				let pick = null;
+				for (const c of sorted) if ((yield* violations(m.pkg, c, resolved, memberSet, fetchPeer)).length === 0) {
+					pick = c;
+					break;
+				}
+				if (pick !== null && pick !== cur) {
+					resolved.set(m.pkg, pick);
+					changed = true;
+				}
+			}
+			if (!changed) break;
+		}
+		const conflicts = [];
+		for (const m of members) {
+			const cur = resolved.get(m.pkg);
+			const v = yield* violations(m.pkg, cur, resolved, memberSet, fetchPeer);
+			if (v.length > 0) conflicts.push({
+				pkg: m.pkg,
+				ceiling: m.ceiling,
+				blockedBy: v.join(", ")
+			});
+		}
+		for (const c of conflicts) resolved.set(c.pkg, ceilingOf.get(c.pkg));
+		return {
+			resolved,
+			conflicts
+		};
+	});
+}
+/** Sort version strings descending; unparseable ones sink to the end. */
+function sortDesc(versions) {
+	return Effect.gen(function* () {
+		const parsed = yield* Effect.forEach(versions, (v) => SemVer.parse(v).pipe(Effect.map((sv) => ({
+			v,
+			sv
+		})), Effect.catchAll(() => Effect.succeed({
+			v,
+			sv: null
+		}))));
+		parsed.sort((a, b) => a.sv && b.sv ? b.sv.compare(a.sv) : a.sv ? -1 : 1);
+		return parsed.map((p) => p.v);
+	});
+}
+/**
+* Fetch the peerDependencies needed to reconcile one catalog interop group,
+* then run the pure resolve + floor derivation. Failures degrade to empty
+* peerDeps (the member resolves at its ceiling).
+*
+* Phase 1 now prefetches only the ceiling version of each member (one
+* `pnpm view` call per member) instead of every candidate version ≤ ceiling.
+* `resolveGroup` / `violations` fetch lower versions on-demand via the shared
+* `fetchPeer` Effectful memoized lookup — they are only consulted when a
+* downgrade search probes them, which for real-world interop groups (where most
+* members are compatible at their ceilings) reduces the total call count from
+* O(N × |candidates|) to O(N + |downgraded members| × depth).
+*
+* A `(pkg, version)` peerDeps lookup is immutable, so the optional `cache` may
+* be shared across the interactive re-entry rounds: each round only fetches the
+* keys a prior round did not, sparing the sequential `pnpm view` calls for
+* versions already seen. Omitting it yields a fresh per-call cache.
+*
+* @internal
+*/
+function runInterop(members, resolver, cache = /* @__PURE__ */ new Map()) {
+	return Effect.gen(function* () {
+		const key = (pkg, v) => `${pkg}@${v}`;
+		const fetchPeer = (pkg, v) => {
+			const k = key(pkg, v);
+			const cached = cache.get(k);
+			if (cached !== void 0) return Effect.succeed(cached);
+			return resolver.peerDependencies(pkg, v).pipe(Effect.catchAll(() => Effect.succeed({}))).pipe(Effect.map((deps) => {
+				cache.set(k, deps);
+				return deps;
+			}));
+		};
+		const seen = /* @__PURE__ */ new Set();
+		const toFetch = [];
+		for (const m of members) {
+			const k = key(m.pkg, m.ceiling);
+			if (seen.has(k) || cache.has(k)) continue;
+			seen.add(k);
+			toFetch.push([m.pkg, m.ceiling]);
+		}
+		yield* Effect.forEach(toFetch, ([pkg, v]) => fetchPeer(pkg, v), { concurrency: 8 });
+		const { resolved, conflicts } = yield* resolveGroup(members, fetchPeer);
+		const peers = yield* deriveFloors(resolved, fetchPeer);
+		const peerDepsOf = (pkg, v) => cache.get(key(pkg, v)) ?? {};
+		return {
+			resolved,
+			peers,
+			conflicts,
+			peerDepsOf
+		};
+	});
+}
+/**
+* The members to re-prompt in the interactive re-entry: each downgraded or
+* conflicted dependent (capped at its resolved version) PLUS the in-group peer
+* targets those dependents depend on (uncapped, so the user can RAISE the anchor
+* instead of accepting the downgrade). `cap` is the version to cap candidates at,
+* or null for an uncapped anchor.
+*
+* @internal
+*/
+function reentryCandidates(members, result) {
+	const memberSet = new Set(members.map((m) => m.pkg));
+	const byPkg = new Map(members.map((m) => [m.pkg, m]));
+	const conflicted = new Set(result.conflicts.map((c) => c.pkg));
+	const out = /* @__PURE__ */ new Map();
+	for (const m of members) {
+		const r = result.resolved.get(m.pkg);
+		if (r === void 0) continue;
+		if (r !== m.ceiling || conflicted.has(m.pkg)) out.set(m.pkg, r);
+	}
+	for (const pkg of [...out.keys()]) {
+		const m = byPkg.get(pkg);
+		if (!m) continue;
+		for (const dep of Object.keys(result.peerDepsOf(pkg, m.ceiling))) if (memberSet.has(dep) && !out.has(dep)) out.set(dep, null);
+	}
+	return [...out].map(([pkg, cap]) => ({
+		pkg,
+		cap
+	}));
+}
+/** True when an interop member's resolved version/peer differs from what's in source. @internal */
+function interopEntryChanged(e, result) {
+	const version = result.resolved.get(e.pkg);
+	if (version === void 0) return false;
+	if (`${e.operator}${version}` !== e.currentRange) return true;
+	const peer = result.peers.get(e.pkg);
+	if (peer === void 0) return false;
+	if (e.peer) return peer !== e.peer.value;
+	return true;
+}
+/**
+* Build the span edits for one interop catalog group from its resolution: a
+* range edit when the resolved version differs, and a peer edit that rewrites an
+* existing `peer` literal or inserts `, peer: "^..."` at the range-span end.
+*
+* @internal
+*/
+function buildInteropEdits(entries, result) {
+	const edits = [];
+	for (const e of entries) {
+		const version = result.resolved.get(e.pkg);
+		if (version === void 0) continue;
+		const peer = result.peers.get(e.pkg);
+		const newRange = `${e.operator}${version}`;
+		if (newRange !== e.currentRange) edits.push({
+			span: e.rangeSpan,
+			text: JSON.stringify(newRange)
+		});
+		const at = e.rangeSpan[1];
+		if (peer !== void 0) {
+			if (e.peer && peer !== e.peer.value) edits.push({
+				span: e.peer.span,
+				text: JSON.stringify(peer)
+			});
+			else if (!e.peer) edits.push({
+				span: [at, at],
+				text: `, peer: ${JSON.stringify(peer)}`
+			});
+		}
+	}
+	return edits;
+}
+/**
+* Keep only the versions less than or equal to `max` (SemVer comparison). Used
+* to cap the candidate list of a re-prompted interop member. An unparseable
+* `max` leaves the list unchanged.
+*
+* @internal
+*/
+function capVersions(list, max) {
+	return Effect.gen(function* () {
+		const mv = yield* SemVer.parse(max).pipe(Effect.catchAll(() => Effect.succeed(null)));
+		if (!mv) return [...list];
+		const out = [];
+		for (const v of list) {
+			const sv = yield* SemVer.parse(v).pipe(Effect.catchAll(() => Effect.succeed(null)));
+			if (sv && sv.compare(mv) <= 0) out.push(v);
+		}
+		return out;
+	});
+}
+
+//#endregion
+export { buildInteropEdits, capVersions, deriveFloors, interopEntryChanged, reentryCandidates, resolveGroup, runInterop };

package/cli/local-merge.js

@@ -0,0 +1,75 @@
+//#region src/cli/local-merge.ts
+/** Default protocols whose existing-file override entries are preserved. @internal */
+const DEFAULT_PRESERVE = [
+	"file",
+	"link",
+	"workspace",
+	"portal"
+];
+const DIRECTIVE_KEYS = /* @__PURE__ */ new Set([
+	"preserve",
+	"value",
+	"strategy"
+]);
+/**
+* True when `v` is the `{ preserve?, value?, strategy? }` directive form: a
+* non-array object whose keys are a non-empty subset of the directive keys.
+* A record with any foreign key (e.g. a real override entry) is a bare value.
+*
+* @internal
+*/
+function isLocalDirective(v) {
+	if (v === null || typeof v !== "object" || Array.isArray(v)) return false;
+	const keys = Object.keys(v);
+	return keys.length > 0 && keys.every((k) => DIRECTIVE_KEYS.has(k));
+}
+function isRecord(v) {
+	return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+/** Union/difference two records or two arrays; managed is the left operand. */
+function combine(managed, value, strategy) {
+	if (Array.isArray(managed) || Array.isArray(value)) {
+		const m = Array.isArray(managed) ? managed : [];
+		const v = Array.isArray(value) ? value : [];
+		if (strategy === "union") return [.../* @__PURE__ */ new Set([...m, ...v])];
+		const drop = new Set(v.map((x) => JSON.stringify(x)));
+		return m.filter((x) => !drop.has(JSON.stringify(x)));
+	}
+	const m = isRecord(managed) ? managed : {};
+	const v = isRecord(value) ? value : {};
+	if (strategy === "union") return {
+		...m,
+		...v
+	};
+	const out = { ...m };
+	for (const k of Object.keys(v)) delete out[k];
+	return out;
+}
+/**
+* Compute the effective value of one field from the managed value, the
+* `config.local[field]` directive (or bare value / undefined), and the parsed
+* existing-file value. For `overrides`, file-protocol entries are preserved
+* from `parsed` (default list unless the directive sets `preserve`).
+*
+* @internal
+*/
+function applyLocalDirective(managed, raw, parsed, field) {
+	const directive = isLocalDirective(raw) ? raw : { value: raw };
+	let result;
+	if (directive.strategy && directive.value !== void 0) result = combine(managed, directive.value, directive.strategy);
+	else if (directive.value !== void 0) result = directive.value;
+	else result = managed;
+	if (field === "overrides") {
+		const protocols = directive.preserve ?? DEFAULT_PRESERVE;
+		const base = isRecord(result) ? { ...result } : {};
+		if (isRecord(parsed)) {
+			for (const [k, val] of Object.entries(parsed)) if (typeof val === "string" && protocols.some((p) => val.startsWith(`${p}:`))) base[k] = val;
+		}
+		if (Object.keys(base).length === 0 && managed === void 0) return void 0;
+		return base;
+	}
+	return result;
+}
+
+//#endregion
+export { DEFAULT_PRESERVE, applyLocalDirective, isLocalDirective };