rolldown-pnpm-config 0.2.2 → 0.4.0

package/cli/validate.js

@@ -0,0 +1,88 @@
+import { Effect } from "effect";
+import { Range, SemVer } from "@effected/semver";
+
+//#region src/cli/validate.ts
+/**
+* Whether at least one published version satisfies `range`.
+*
+* The predicate is deliberately "some published version satisfies this range",
+* NOT "this exact version was published": `^3.4.0` is a valid lock-minor floor
+* even when 3.4.0 itself never shipped but 3.4.1 did. Conversely `^3.0.0`
+* against a package with only `3.0.0-next.*` releases matches nothing.
+*
+* Fails OPEN — an empty version list (fetch failure, fully age-gated package)
+* or an unparseable range yields `true`. Validation is a safety net against
+* ranges we DERIVED wrongly, not a gate on the author's own hand-written
+* ranges, and rejecting everything the moment the registry is unreachable would
+* break offline peer materialization.
+*
+* @internal
+*/
+function rangeIsSatisfiable(range, versions) {
+	return Effect.gen(function* () {
+		if (versions.length === 0) return true;
+		const parsedRange = yield* Range.parse(range).pipe(Effect.catch(() => Effect.succeed(null)));
+		if (parsedRange === null) return true;
+		for (const v of versions) {
+			const sv = yield* SemVer.parse(v).pipe(Effect.catch(() => Effect.succeed(null)));
+			if (sv && parsedRange.test(sv)) return true;
+		}
+		return false;
+	});
+}
+/**
+* Partition planned edits into those whose range some published version
+* satisfies and those none does — ATOMICALLY per package. A catalog package
+* with a `strategy` produces a `range` edit and a `peer` edit as a pair; if
+* either is unsatisfiable, BOTH are rejected. Writing one half of the pair
+* (say, an accepted range bump next to a rejected, stale peer) would leave the
+* file internally inconsistent — the peer no longer matches what the strategy
+* derives from the new range — and every subsequent run would re-report the
+* same drift and re-reject it forever. A package is either fully updated or
+* not touched at all.
+*
+* `versionsByPkg` MUST be the UNGATED version list. Validating against the
+* release-age-gated list would spuriously reject a package whose only matching
+* version was published inside the gate window.
+*
+* @internal
+*/
+function validateEdits(edits, versionsByPkg) {
+	return Effect.gen(function* () {
+		const byPkg = /* @__PURE__ */ new Map();
+		for (const e of edits) {
+			const group = byPkg.get(e.pkg) ?? [];
+			group.push(e);
+			byPkg.set(e.pkg, group);
+		}
+		const accepted = [];
+		const rejected = [];
+		for (const [pkg, group] of byPkg) {
+			const versions = versionsByPkg.get(pkg) ?? [];
+			const checked = [];
+			for (const e of group) checked.push({
+				edit: e,
+				ok: yield* rangeIsSatisfiable(e.value, versions)
+			});
+			const failing = checked.filter((c) => !c.ok);
+			if (failing.length === 0) {
+				accepted.push(...group);
+				continue;
+			}
+			const failingKinds = failing.map((f) => f.edit.kind).join(" and ");
+			for (const { edit, ok } of checked) rejected.push({
+				pkg,
+				kind: edit.kind,
+				value: edit.value,
+				reason: ok ? `dropped along with its ${failingKinds} edit for ${pkg}, which is unsatisfiable` : `no published version of ${pkg} satisfies ${edit.value}`
+			});
+		}
+		return {
+			accepted,
+			rejected
+		};
+	});
+}
+
+//#endregion
+export { rangeIsSatisfiable, validateEdits };

package/cli/walk-plan.js

@@ -7,7 +7,8 @@ import { Effect } from "effect";
 /**
 * Build the interactive walk items: for each entry, its candidate list (from
 * planEntry against the resolved versions), an up-to-date flag (only the keep
-* candidate remains), and any peer drift resync target.
+* candidate remains), any peer drift resync target, any peer to materialize,
+* and any strategy/prerelease incompatibility warning.
 *
 * @internal
 */
@@ -17,14 +18,21 @@ function buildWalkItems(entries, versionsByPkg) {
 		for (const entry of entries) {
 			const candidates = yield* planEntry(entry, [...versionsByPkg.get(entry.pkg) ?? []]);
 			const driftPeer = yield* detectPeerDrift(entry);
-			const materializePeer = entry.strategy && !entry.peer ? yield* derivePeerRange(entry.currentRange, entry.strategy) : null;
+			let peerWarning = null;
+			let materializePeer = null;
+			if (entry.strategy && entry.strategy !== "interop") {
+				const derived = yield* derivePeerRange(entry.currentRange, entry.strategy);
+				peerWarning = derived.warning;
+				if (!entry.peer) materializePeer = derived.range;
+			}
 			const upToDate = candidates.length === 1 && driftPeer === null && materializePeer === null;
 			items.push({
 				entry,
 				candidates,
 				upToDate,
 				driftPeer,
-				materializePeer
+				materializePeer,
+				peerWarning
 			});
 		}
 		return items;

package/cli/walk-reducer.js

@@ -1,61 +1,116 @@
 //#region src/cli/walk-reducer.ts
-/** Index of the next actionable (not up-to-date) item at or after `from`, or -1. */
-function nextActionable(items, from) {
-	for (let i = from; i < items.length; i++) if (!items[i].upToDate) return i;
-	return -1;
+const ORDER = {
+	keep: 0,
+	"in-range": 1,
+	latest: 2
+};
+/**
+* The row's options in display order: keep first (always index 0, always the
+* default), then the in-range bump, then the latest-overall bump. `planEntry`
+* emits them in the opposite order, with keep last.
+*
+* @internal
+*/
+function displayCandidates(item) {
+	return [...item.candidates].sort((a, b) => ORDER[a.kind] - ORDER[b.kind]);
 }
 /**
-* Initialize the walk on the first actionable item (auto-skipping up-to-date
-* items). If none are actionable, the walk is immediately done.
+* Initialize the table: cursor on the first row, keep selected on every row, so
+* the default state applies nothing.
 *
 * @internal
 */
-function initWalk(items) {
-	const index = nextActionable(items, 0);
+function initTable(items) {
 	return {
-		index: index === -1 ? items.length : index,
 		cursor: 0,
-		decisions: [],
-		done: index === -1
+		picks: items.map(() => 0),
+		done: false,
+		cancelled: false
 	};
 }
+const clamp = (n, max) => n < 0 ? 0 : n > max ? max : n;
 /**
-* Advance the walk by a key. up/down move the cursor within the current item's
-* candidates; enter records the highlighted candidate and moves to the next
-* actionable item (or completes).
+* Advance the table by a key. up/down move between rows; left/right move the
+* radio selection within the row under the cursor; submit applies; cancel exits
+* without applying. Both axes clamp at their ends rather than wrapping.
 *
 * @internal
 */
-function walkStep(state, items, key) {
+function tableStep(state, items, key) {
 	if (state.done) return state;
-	const item = items[state.index];
-	const count = item.candidates.length;
-	if (key === "up") return {
+	if (key === "submit") return {
 		...state,
-		cursor: (state.cursor - 1 + count) % count
+		done: true
 	};
-	if (key === "down") return {
+	if (key === "cancel") return {
 		...state,
-		cursor: (state.cursor + 1) % count
+		done: true,
+		cancelled: true
 	};
-	const chosen = item.candidates[state.cursor];
-	const decisions = [...state.decisions, {
-		item,
-		chosen
-	}];
-	const next = nextActionable(items, state.index + 1);
-	if (next === -1) return {
+	if (items.length === 0) return state;
+	if (key === "up") return {
 		...state,
-		decisions,
-		done: true
+		cursor: clamp(state.cursor - 1, items.length - 1)
+	};
+	if (key === "down") return {
+		...state,
+		cursor: clamp(state.cursor + 1, items.length - 1)
 	};
+	const count = displayCandidates(items[state.cursor]).length;
+	const delta = key === "right" ? 1 : -1;
+	const picks = [...state.picks];
+	picks[state.cursor] = clamp(picks[state.cursor] + delta, count - 1);
 	return {
-		index: next,
-		cursor: 0,
-		decisions,
-		done: false
+		...state,
+		picks
 	};
 }
+/**
+* Project the table's selections into decisions. A cancelled table yields none,
+* so nothing is written.
+*
+* @internal
+*/
+function tableDecisions(state, items) {
+	if (state.cancelled) return [];
+	return items.map((item, i) => ({
+		item,
+		chosen: displayCandidates(item)[state.picks[i] ?? 0]
+	}));
+}
+/**
+* The peer range that would be written for a row's currently chosen candidate.
+* Non-keep candidates carry their own recomputed `peerRange`; keep reuses
+* whichever peer source the item already resolved (a drift resync, a
+* materialize target, or the entry's existing literal), falling back to an
+* em dash placeholder when none applies.
+*
+* @internal
+*/
+function peerFor(item, chosen) {
+	if (chosen.kind !== "keep") return chosen.peerRange ?? "—";
+	if (item.driftPeer) return item.driftPeer;
+	if (item.materializePeer) return item.materializePeer;
+	return item.entry.peer?.value ?? "—";
+}
+/**
+* The Ink color for one candidate cell, or null for the terminal's default.
+*
+* Only a SELECTED UPGRADE is colored — green in-range, yellow for a major. A
+* selected KEEP is deliberately left uncolored: it is the current value, not a
+* change, and coloring it dim made the column the eye lands on first read as
+* disabled. Unselected cells are always default.
+*
+* Extracted from the render so it can be unit-tested: `ink-testing-library`
+* strips ANSI from `lastFrame()`, so a color assertion is impossible against
+* the rendered output.
+*
+* @internal
+*/
+function cellColor(candidate, selected) {
+	if (!selected || candidate.kind === "keep") return null;
+	return candidate.isMajor ? "yellow" : "green";
+}
 
 //#endregion
-export { initWalk, walkStep };
+export { cellColor, displayCandidates, initTable, peerFor, tableDecisions, tableStep };

package/cli/workspace-file.js

@@ -1,14 +1,14 @@
+import { Effect } from "effect";
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { parse, stringify } from "yaml";
+import { Yaml, YamlStringifyOptions } from "@effected/yaml";
 
 //#region src/cli/workspace-file.ts
 const FILENAME = "pnpm-workspace.yaml";
-const STRINGIFY_OPTIONS = {
+const STRINGIFY_OPTIONS = YamlStringifyOptions.make({
 	indent: 2,
-	lineWidth: 0,
-	singleQuote: false
-};
+	lineWidth: 0
+});
 /** True when every element is a string/number/boolean (safe to sort). */
 function allPrimitive(arr) {
 	return arr.every((v) => v === null || typeof v !== "object" && typeof v !== "function");
@@ -46,12 +46,12 @@ function findWorkspaceFile(startDir) {
 }
 /** Parse pnpm-workspace.yaml source; empty/whitespace yields an empty object. @internal */
 function parseWorkspace(source) {
-	const parsed = parse(source);
+	const parsed = Effect.runSync(Yaml.parse(source));
 	return parsed && typeof parsed === "object" ? parsed : {};
 }
 /** Render a workspace object: deterministic key sort + yaml.stringify. @internal */
 function renderWorkspace(obj) {
-	return stringify(canonicalize(obj), STRINGIFY_OPTIONS);
+	return Effect.runSync(Yaml.stringify(canonicalize(obj), STRINGIFY_OPTIONS));
 }
 
 //#endregion

package/descriptors/build.js

@@ -104,7 +104,12 @@ const build = {
 		anchor: "nodeoptions"
 	},
 	verifyDepsBeforeRun: {
-		schema: Schema.Union(Schema.Literal("install", "warn", "error", "prompt"), Schema.Boolean),
+		schema: Schema.Union([Schema.Literals([
+			"install",
+			"warn",
+			"error",
+			"prompt"
+		]), Schema.Boolean]),
 		kind: "union",
 		strategy: "scalar",
 		enforcement: "absent",

package/descriptors/hoisting.js

@@ -41,7 +41,11 @@ const hoisting = {
 		anchor: "shamefullyhoist"
 	},
 	hoistingLimits: {
-		schema: Schema.Literal("none", "workspaces", "dependencies"),
+		schema: Schema.Literals([
+			"none",
+			"workspaces",
+			"dependencies"
+		]),
 		kind: "enum",
 		strategy: "scalar",
 		enforcement: "absent",
@@ -63,7 +67,11 @@ const hoisting = {
 		anchor: "modulesdir"
 	},
 	nodeLinker: {
-		schema: Schema.Literal("isolated", "hoisted", "pnp"),
+		schema: Schema.Literals([
+			"isolated",
+			"hoisted",
+			"pnp"
+		]),
 		kind: "enum",
 		strategy: "scalar",
 		enforcement: "absent",
@@ -121,7 +129,13 @@ const hoisting = {
 		anchor: "virtualstoreonly"
 	},
 	packageImportMethod: {
-		schema: Schema.Literal("auto", "hardlink", "copy", "clone", "clone-or-copy"),
+		schema: Schema.Literals([
+			"auto",
+			"hardlink",
+			"copy",
+			"clone",
+			"clone-or-copy"
+		]),
 		kind: "enum",
 		strategy: "scalar",
 		enforcement: "absent",

package/descriptors/misc.js

@@ -5,7 +5,11 @@ import { Schema } from "effect";
 /** The 14 resolution/misc preference fields. @internal */
 const misc = {
 	resolutionMode: {
-		schema: Schema.Literal("highest", "time-based", "lowest-direct"),
+		schema: Schema.Literals([
+			"highest",
+			"time-based",
+			"lowest-direct"
+		]),
 		kind: "enum",
 		strategy: "scalar",
 		enforcement: "absent",
@@ -18,7 +22,11 @@ const misc = {
 		}
 	},
 	savePrefix: {
-		schema: Schema.Literal("^", "~", ""),
+		schema: Schema.Literals([
+			"^",
+			"~",
+			""
+		]),
 		kind: "enum",
 		strategy: "scalar",
 		enforcement: "absent",

package/descriptors/resolution.js

@@ -19,10 +19,7 @@ const PeerRulesSchema = Schema.Struct({
 */
 const resolution = {
 	catalogs: {
-		schema: Schema.Record({
-			key: Str,
-			value: StringRecord
-		}),
+		schema: Schema.Record(Str, StringRecord),
 		kind: "object",
 		strategy: "catalogs",
 		enforcement: "warn",
@@ -205,7 +202,7 @@ const resolution = {
 		anchor: "minimumreleaseageignoremissingtime"
 	},
 	trustPolicy: {
-		schema: Schema.Literal("off", "no-downgrade"),
+		schema: Schema.Literals(["off", "no-downgrade"]),
 		kind: "enum",
 		strategy: "scalar",
 		enforcement: "warn",

package/descriptors/runtime-cfg.js

@@ -32,7 +32,12 @@ const runtimeCfg = {
 		anchor: "managepackagemanagerversions"
 	},
 	pmOnFail: {
-		schema: Schema.Literal("download", "error", "warn", "ignore"),
+		schema: Schema.Literals([
+			"download",
+			"error",
+			"warn",
+			"ignore"
+		]),
 		kind: "enum",
 		strategy: "scalar",
 		enforcement: "absent",
@@ -45,7 +50,12 @@ const runtimeCfg = {
 		}
 	},
 	runtimeOnFail: {
-		schema: Schema.Literal("download", "error", "warn", "ignore"),
+		schema: Schema.Literals([
+			"download",
+			"error",
+			"warn",
+			"ignore"
+		]),
 		kind: "enum",
 		strategy: "scalar",
 		enforcement: "absent",

package/descriptors/schemas.js

@@ -5,22 +5,10 @@ import { Schema } from "effect";
 /** @internal */ const Num = Schema.Number;
 /** @internal */ const Str = Schema.String;
 /** @internal */ const StringArray = Schema.Array(Schema.String);
-/** @internal */ const StringRecord = Schema.Record({
-	key: Schema.String,
-	value: Schema.String
-});
-/** @internal */ const BooleanRecord = Schema.Record({
-	key: Schema.String,
-	value: Schema.Boolean
-});
-/** @internal */ const UnknownRecord = Schema.Record({
-	key: Schema.String,
-	value: Schema.Unknown
-});
-/** @internal */ const StringArrayRecord = Schema.Record({
-	key: Schema.String,
-	value: StringArray
-});
+/** @internal */ const StringRecord = Schema.Record(Schema.String, Schema.String);
+/** @internal */ const BooleanRecord = Schema.Record(Schema.String, Schema.Boolean);
+/** @internal */ const UnknownRecord = Schema.Record(Schema.String, Schema.Unknown);
+/** @internal */ const StringArrayRecord = Schema.Record(Schema.String, StringArray);
 
 //#endregion
 export { Bool, BooleanRecord, Num, Str, StringArray, StringArrayRecord, StringRecord, UnknownRecord };

package/descriptors/workspace.js

@@ -5,7 +5,11 @@ import { Schema } from "effect";
 /** The 10 catalog + workspace + audit fields. @internal */
 const workspace = {
 	catalogMode: {
-		schema: Schema.Literal("strict", "prefer", "manual"),
+		schema: Schema.Literals([
+			"strict",
+			"prefer",
+			"manual"
+		]),
 		kind: "enum",
 		strategy: "scalar",
 		enforcement: "absent",
@@ -27,7 +31,7 @@ const workspace = {
 		anchor: "cleanupunusedcatalogs"
 	},
 	linkWorkspacePackages: {
-		schema: Schema.Union(Schema.Boolean, Schema.Literal("deep")),
+		schema: Schema.Union([Schema.Boolean, Schema.Literals(["deep"])]),
 		kind: "union",
 		strategy: "scalar",
 		enforcement: "absent",
@@ -49,7 +53,7 @@ const workspace = {
 		anchor: "preferworkspacepackages"
 	},
 	saveWorkspaceProtocol: {
-		schema: Schema.Union(Schema.Boolean, Schema.Literal("rolling")),
+		schema: Schema.Union([Schema.Boolean, Schema.Literals(["rolling"])]),
 		kind: "union",
 		strategy: "scalar",
 		enforcement: "absent",
@@ -98,7 +102,12 @@ const workspace = {
 		anchor: "workspaceconcurrency"
 	},
 	auditLevel: {
-		schema: Schema.Literal("low", "moderate", "high", "critical"),
+		schema: Schema.Literals([
+			"low",
+			"moderate",
+			"high",
+			"critical"
+		]),
 		kind: "enum",
 		strategy: "scalar",
 		enforcement: "absent",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rolldown-pnpm-config",
-	"version": "0.2.2",
+	"version": "0.4.0",
 	"private": false,
 	"description": "A dogfooding example of our plugin",
 	"repository": {
@@ -33,26 +33,16 @@
 		"rolldown-pnpm-config": "bin/rolldown-pnpm-config.js"
 	},
 	"dependencies": {
-		"@effect/cli": "^0.75.2",
-		"@effect/cluster": "^0.59.0",
-		"@effect/experimental": "^0.60.0",
-		"@effect/platform": "^0.96.2",
-		"@effect/platform-node": "^0.107.0",
-		"@effect/printer": "^0.49.0",
-		"@effect/printer-ansi": "^0.49.0",
-		"@effect/rpc": "^0.75.1",
-		"@effect/sql": "^0.51.1",
-		"@effect/typeclass": "^0.40.0",
-		"@effect/workflow": "^0.18.2",
-		"effect": "^3.21.4",
+		"@effect/platform-node": "4.0.0-beta.98",
+		"@effected/semver": "^0.1.0",
+		"@effected/yaml": "^0.1.0",
+		"effect": "4.0.0-beta.98",
 		"ink": "^7.1.0",
 		"ink-tab": "^5.2.0",
-		"oxc-parser": "^0.139.0",
+		"oxc-parser": "^0.140.0",
 		"react": "^19.2.7",
-		"semver-effect": "^0.3.1",
 		"std-env": "^4.2.0",
-		"std-osc8": "^0.2.0",
-		"yaml": "^2.9.0"
+		"std-osc8": "^0.2.0"
 	},
 	"peerDependencies": {
 		"rolldown": "^1.1.0"

package/plugin/freeze.js

@@ -48,7 +48,7 @@ function freeze(config) {
 	return Effect.gen(function* () {
 		const base = {};
 		const manifest = {};
-		base.catalogs = yield* Schema.decodeUnknown(CatalogsSchema)(normalizeCatalogs(config.catalogs)).pipe(Effect.mapError((error) => new ConfigError({ message: `Invalid catalogs: ${String(error)}` })));
+		base.catalogs = yield* Schema.decodeUnknownEffect(CatalogsSchema)(normalizeCatalogs(config.catalogs)).pipe(Effect.mapError((error) => new ConfigError({ message: `Invalid catalogs: ${String(error)}` })));
 		manifest.catalogs = {
 			strategy: "catalogs",
 			enforcement: "warn"
@@ -60,7 +60,7 @@ function freeze(config) {
 			if (raw === void 0) continue;
 			const decl = normalizeField(raw);
 			const schema = FIELD_SCHEMAS[field];
-			base[field] = schema ? yield* Schema.decodeUnknown(schema)(decl.value).pipe(Effect.mapError((error) => new ConfigError({ message: `Invalid ${field}: ${String(error)}` }))) : decl.value;
+			base[field] = schema ? yield* Schema.decodeUnknownEffect(schema)(decl.value).pipe(Effect.mapError((error) => new ConfigError({ message: `Invalid ${field}: ${String(error)}` }))) : decl.value;
 			manifest[field] = {
 				strategy: reg.strategy,
 				enforcement: decl.enforcement ?? reg.enforcement,

package/virtual.d.ts

@@ -9,8 +9,18 @@
 // per-module boilerplate.
 
 declare module "rolldown-pnpm-config/virtual/pnpmfile" {
-	import type { PnpmHooks } from "rolldown-pnpm-config/runtime";
-	export const hooks: PnpmHooks;
+	// Inlined rather than imported from "rolldown-pnpm-config/runtime": this file is
+	// shipped byte-for-byte (never compiled), so any cross-module import here resolves
+	// against this package's own *source* `exports` map during the build's declaration
+	// pass and pulls a raw .ts file into API Extractor's analysis (ae-wrong-input-file-type).
+	// Keep this shape in sync with `PnpmConfig`/`PnpmHooks` in `src/runtime/types.ts`.
+	interface PnpmConfig {
+		catalogs?: Record<string, Record<string, string>>;
+		[key: string]: unknown;
+	}
+	export const hooks: {
+		updateConfig(config: PnpmConfig): PnpmConfig;
+	};
 }
 
 declare module "rolldown-pnpm-config/virtual/catalogs" {