fleetfizz 0.6.0 → 0.8.0

package/dist/fleetfizz.mjs

@@ -4299,6 +4299,18 @@ const findFirst$1 = /*#__PURE__*/ dual(2, (self, f) => {
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/Array.js
 /**
+* Works with JavaScript arrays, readonly arrays, and non-empty arrays.
+*
+* The helpers cover common collection work such as creating arrays, reading
+* elements, transforming values, sorting, grouping, splitting, combining, and
+* reducing many values to one result. Helpers that change contents return new
+* arrays and preserve non-empty array types when the result is guaranteed to
+* contain values.
+*
+* @stability stable
+* @since 2.0.0
+*/
+/**
 * Exposes the global array constructor.
 *
 * **When to use**
@@ -4562,6 +4574,17 @@ const findLast = /*#__PURE__*/ dual(2, (self, f) => {
 	}
 	return none();
 });
+const hashBucketsAdd = (buckets, value) => {
+	const hash$1 = hash(value);
+	const bucket = buckets.get(hash$1);
+	if (bucket === void 0) {
+		buckets.set(hash$1, [value]);
+		return true;
+	}
+	for (const previous of bucket) if (equals$1(previous, value)) return false;
+	bucket.push(value);
+	return true;
+};
 /**
 * Creates an empty array.
 *
@@ -4658,6 +4681,38 @@ const map$8 = /*#__PURE__*/ dual(2, (self, f) => self.map(f));
 * @since 2.0.0
 */
 const reduce = /*#__PURE__*/ dual(3, (self, b, f) => fromIterable$1(self).reduce((b, a, i) => f(b, a, i), b));
+/**
+* Removes duplicates using `Equal.equivalence()`, preserving the order of the
+* first occurrence.
+*
+* **When to use**
+*
+* Use to remove repeated values from an iterable when Effect's default equality
+* is the right comparison, preserving the first occurrence.
+*
+* **Example** (Removing duplicates)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.dedupe([1, 2, 1, 3, 2, 4]) // => [1, 2, 3, 4]
+* ```
+*
+* @see {@link dedupeWith} — use custom equality
+* @see {@link dedupeAdjacent} — only dedupes consecutive elements
+*
+* @stability stable
+* @category deduplication
+* @since 2.0.0
+*/
+const dedupe = (self) => {
+	const input = fromIterable$1(self);
+	if (input.length < 2) return [...input];
+	const buckets = /* @__PURE__ */ new Map();
+	const out = [];
+	for (const value of input) if (hashBucketsAdd(buckets, value)) out.push(value);
+	return out;
+};
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/Duration.js
 const TypeId$31 = "~effect/Duration";
@@ -20340,13 +20395,13 @@ function canPreserveEncodingChecks(ast) {
 * @category transforming
 * @since 4.0.0
 */
-const toType = /*#__PURE__*/ memoizeIdempotent((ast) => {
+const toType$1 = /*#__PURE__*/ memoizeIdempotent((ast) => {
 	const owner = getContextOwner(ast);
 	if (owner !== ast) {
-		const type = toType(owner);
+		const type = toType$1(owner);
 		return type === owner && ast.encoding === void 0 ? ast : replaceContext(type, ast.context);
 	}
-	const type = "recur" in ast ? ast.recur(toType) : ast;
+	const type = "recur" in ast ? ast.recur(toType$1) : ast;
 	if ("encodingChecks" in type && type.encodingChecks) {
 		const checks = canPreserveEncodingChecks(ast) ? type.encodingChecks : isArrays(type) || isObjects(type) || isDeclaration(type) && type.typeParameters.length > 0 ? extractStructuralChecks(type.encodingChecks) : void 0;
 		return copy$1(type, {
@@ -20384,7 +20439,7 @@ const toType = /*#__PURE__*/ memoizeIdempotent((ast) => {
 * @since 4.0.0
 */
 const toEncoded = /*#__PURE__*/ memoizeIdempotent((ast) => {
-	return toType(flip(ast));
+	return toType$1(flip(ast));
 });
 function flipEncoding(ast, encoding) {
 	const links = encoding;
@@ -22738,7 +22793,7 @@ function makeEffect(schema) {
 	const ast = schema.ast;
 	let parser;
 	return (input, options) => {
-		return (parser ??= runWithCompiler(constructorCompiler, toType(ast)))(input, options?.disableChecks ? options?.parseOptions ? {
+		return (parser ??= runWithCompiler(constructorCompiler, toType$1(ast)))(input, options?.disableChecks ? options?.parseOptions ? {
 			...options.parseOptions,
 			disableChecks: true
 		} : { disableChecks: true } : options?.parseOptions);
@@ -22799,7 +22854,7 @@ function makeOption(schema) {
 * @since 4.0.0
 */
 function make$5(schema) {
-	return makeConstructorSync(toType(schema.ast));
+	return makeConstructorSync(toType$1(schema.ast));
 }
 /**
 * Creates a type guard that checks whether an input satisfies the schema's decoded
@@ -22841,7 +22896,7 @@ function makeIs(ast) {
 }
 /** @internal */
 function _is(ast) {
-	const typeAST = toType(ast);
+	const typeAST = toType$1(ast);
 	let guard = (input) => {
 		guard = makeIs(typeAST);
 		return guard(input);
@@ -24100,7 +24155,7 @@ function toRepresentations(asts, options) {
 	}
 	function visitChecks(checks) {
 		checks?.forEach((check) => {
-			check.annotations?.representation?.schemas?.forEach((schema) => visit(toType(schema)));
+			check.annotations?.representation?.schemas?.forEach((schema) => visit(toType$1(schema)));
 			if (check._tag === "FilterGroup") visitChecks(check.checks);
 		});
 	}
@@ -24240,7 +24295,7 @@ function toRepresentations(asts, options) {
 		const { representation, ...ordinary } = annotations;
 		const projected = representation === void 0 ? void 0 : representation.schemas === void 0 ? representation : {
 			...representation,
-			schemas: representation.schemas.map((schema) => recur(toType(schema)))
+			schemas: representation.schemas.map((schema) => recur(toType$1(schema)))
 		};
 		return {
 			...projected === void 0 ? void 0 : { representation: projected },
@@ -24296,6 +24351,20 @@ function isSchemaError$1(u) {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/Schema.js
+/**
+* Describes data shapes and how unknown input becomes trusted values.
+*
+* A schema can validate input, decode it into an application type, and encode
+* that value back to another representation. This module contains the main
+* schema, codec, decoder, and encoder APIs, together with schemas for common
+* JavaScript values and Effect data types. It also supports refinements,
+* transformations, defaults, classes, JSON Schema generation, test data
+* generation, formatting, equivalence, optics, and differs derived from schema
+* definitions.
+*
+* @stability stable
+* @since 4.0.0
+*/
 const TypeId$5 = TypeId$6;
 /**
 * Error thrown or returned when schema decoding or encoding fails.
@@ -24753,6 +24822,15 @@ const optional$2 = /*#__PURE__*/ lambda((self) => {
 	return make$3(optional$3(self.ast), { schema });
 });
 /**
+* Extracts the type-side schema: sets `Encoded` to equal the decoded `Type`,
+* discarding the encoding transformation path.
+*
+* @stability stable
+* @category transforming
+* @since 4.0.0
+*/
+const toType = /*#__PURE__*/ lambda((schema) => make$3(toType$1(schema.ast), { schema }));
+/**
 * Creates a schema for a single literal value (string, number, bigint, boolean, or null).
 *
 * **Example** (Defining a string literal)
@@ -25286,6 +25364,45 @@ function isPattern(regExp, annotations) {
 		...annotations
 	});
 }
+/**
+* Validates that a value has at least the specified length. Works with strings
+* and arrays.
+*
+* **Details**
+*
+* JSON Schema:
+*
+* The bound must be finite; it is rounded down and clamped to zero. For arrays,
+* this check corresponds to `minItems`. JavaScript counts UTF-16 code units
+* while JSON Schema counts Unicode code points, so strings use
+* `minLength: Math.ceil(minLength / 2)`, the tightest lower bound that cannot
+* reject a string accepted by this check.
+*
+* Arbitrary:
+*
+* During arbitrary generation, this applies a `minLength`
+* constraint to ensure generated strings or arrays have at least the required
+* length.
+*
+* **Example** (Checking minimum length)
+*
+* ```ts import.meta.vitest
+* import { Schema } from "effect"
+*
+* const NonEmptyStringSchema = Schema.String.check(Schema.isMinLength(1))
+* const NonEmptyArraySchema = Schema.Array(Schema.Number).check(Schema.isMinLength(1))
+* Schema.is(NonEmptyStringSchema)("a") // => true
+* Schema.is(NonEmptyArraySchema)([1]) // => true
+* ```
+*
+* @stability stable
+* @category validation
+* @since 4.0.0
+*/
+function isMinLength(minLength, annotations) {
+	minLength = normalizeCardinality(minLength);
+	return makeIsMinLength(minLength, Math.ceil(minLength / 2), annotations);
+}
 function makeIsMinLength(minLength, minCodePoints, annotations) {
 	return makeFilter((input) => input.length >= minLength, {
 		expected: `a value with a length of at least ${minLength}`,
@@ -25326,6 +25443,39 @@ function makeIsMinLength(minLength, minCodePoints, annotations) {
 function isNonEmpty(annotations) {
 	return makeIsMinLength(1, 1, annotations);
 }
+function normalizeCardinality(value) {
+	if (!globalThis.Number.isFinite(value)) throw new globalThis.RangeError(`Expected a finite number, got ${value}`);
+	return Math.max(0, Math.floor(value));
+}
+/**
+* Validates that all items in an array are unique according to Effect equality.
+*
+* **Details**
+*
+* JSON Schema:
+* This check corresponds to the `uniqueItems: true` constraint in JSON Schema.
+*
+* Arbitrary:
+* During arbitrary generation, this applies a node-local identity selector
+* for constructive uniqueness using Effect equality.
+*
+* @stability stable
+* @category validation
+* @since 4.0.0
+*/
+function isUnique(annotations) {
+	return makeFilter((input) => dedupe(input).length === input.length, {
+		expected: "an array with unique items",
+		representation: {
+			id: "effect/schema/isUnique",
+			payload: null
+		},
+		toJsonSchema: () => ({ uniqueItems: true }),
+		toCode: () => ({ runtime: "Schema.isUnique()" }),
+		arbitraryConstraint: { uniqueBy: identity },
+		...annotations
+	});
+}
 /**
 * Schema for non-empty strings. Validates that a string has at least one
 * character.
@@ -32482,7 +32632,7 @@ const runWith = (command, config) => {
 };
 //#endregion
 //#region package.json
-var version = "0.6.0";
+var version = "0.8.0";
 //#endregion
 //#region ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
 /**
@@ -35148,15 +35298,18 @@ var BumpError = class extends TaggedError()("BumpError", {
 };
 const bumpedRange = (current, installed) => import_semver.valid(current) !== null ? installed : `^${installed}`;
 const bumpText = (text, path, installed) => {
-	const node = findNodeAtLocation(parseTree(text) ?? {
+	const tree = parseTree(text) ?? {
 		type: "null",
 		offset: 0,
 		length: 0
-	}, [...path]);
+	};
+	const shorthand = path.slice(0, -1);
+	const at = findNodeAtLocation(tree, [...path]) === void 0 && findNodeAtLocation(tree, shorthand)?.type === "string" ? shorthand : path;
+	const node = findNodeAtLocation(tree, [...at]);
 	if (node === void 0 || node.type !== "string" || typeof node.value !== "string") return { reason: `${path.join(".")} is not a string literal; change it by hand` };
 	const range = bumpedRange(node.value, installed);
 	return {
-		text: applyEdits(text, modify(text, [...path], range, { formattingOptions: {
+		text: applyEdits(text, modify(text, [...at], range, { formattingOptions: {
 			insertSpaces: true,
 			tabSize: 2
 		} })),
@@ -35200,14 +35353,25 @@ const TrackedRepo = Struct({
 	origin: Origin.annotateKey({ description: "The GitHub `owner/repo`." }),
 	ref: Ref.annotateKey({ description: "A branch, or a full 40-character commit SHA to pin it." }),
 	install: NonEmptyString.annotateKey({ description: "The Install Command, run in a login shell inside the Managed Clone." }),
-	name: optionalKey(NonEmptyString).annotateKey({ description: "Names the clone's directory and the repo in output. Default: `<owner>-<repo>`." }),
-	outputs: optionalKey(ArraySchema(NonEmptyString)).annotateKey({ description: "Paths outside the clone the Install Command produces. If one changes by hand, the repo reinstalls." }),
-	files: optionalKey(Record(NonEmptyString, String$5)).annotateKey({ description: "Gitignored files written into the clone before every install, keyed by path. Never secrets." })
+	outputs: optionalKey(ArraySchema(NonEmptyString)).annotateKey({ description: "Paths outside the clone the Install Command produces. If one changes by hand, the repo reinstalls." })
+});
+const withShorthand = (entry, value, shorthand) => Union([entry, value.pipe(decodeTo(toType(entry), transform$1(shorthand)))]);
+const variants = (entry) => Union([entry, NonEmptyArray(entry)]);
+const dependsOn = optionalKey(ArraySchema(ProviderName)).annotateKey({ description: "Providers whose Items must succeed on a Machine before this one changes there." });
+const section = (settings, items, description) => Struct({
+	...Targeting,
+	dependsOn,
+	...settings,
+	items: optionalKey(items).annotateKey({ description })
 });
-const Global = Union([Range, Struct({
+const VARIANTS = "or a list of Variants, of which a Machine gets the first that targets it";
+const Global = withShorthand(Struct({
 	...Targeting,
 	range: Range
-})]);
+}), Range, {
+	decode: (range) => ({ range }),
+	encode: (global) => global.range
+});
 const PACKAGE_MANAGERS = [
 	"npm",
 	"pnpm",
@@ -35222,54 +35386,53 @@ const NOT_GLOBALS = {
 	"vite-plus": "set vp with vp.version",
 	fleetfizz: "a Ship installs the fleetfizz that ships"
 };
-const VpSection = Struct({
-	...Targeting,
-	dependsOn: optionalKey(ArraySchema(ProviderName)).annotateKey({ description: "Providers whose Items must succeed on a Machine before vp changes there." }),
+const VpSection = section({
 	version: optionalKey(Range).annotateKey({ description: "The vp version. Pin it exactly." }),
 	node: optionalKey(Range).annotateKey({ description: "The default Node version. Pin it exactly." }),
 	npm: optionalKey(Range).annotateKey({ description: "The default npm version." }),
 	pnpm: optionalKey(Range).annotateKey({ description: "The default pnpm version." }),
 	yarn: optionalKey(Range).annotateKey({ description: "The default Yarn version." }),
-	bun: optionalKey(Range).annotateKey({ description: "The default Bun version." }),
-	globals: optionalKey(Record(NonEmptyString, Global).check(makeFilter((globals) => {
-		const name = Object.keys(globals).find((n) => n in NOT_GLOBALS);
-		return name === void 0 || `"${name}" is not a Global: ${NOT_GLOBALS[name]}`;
-	}, {
-		title: "Globals",
-		description: "npm packages other than vp, node, a package manager, vite-plus, and fleetfizz"
-	}))).annotateKey({ description: "Global packages, each with a Range, or `{ range, platforms?, machines? }` to target one." })
-});
+	bun: optionalKey(Range).annotateKey({ description: "The default Bun version." })
+}, Record(NonEmptyString, variants(Global)).check(makeFilter((globals) => {
+	const name = Object.keys(globals).find((n) => n in NOT_GLOBALS);
+	return name === void 0 || `"${name}" is not a Global: ${NOT_GLOBALS[name]}`;
+}, {
+	title: "Globals",
+	description: "npm packages other than vp, node, a package manager, vite-plus, and fleetfizz"
+})), `Globals, keyed by package. Each is a Range, \`{ range, platforms?, machines? }\` to target it, ${VARIANTS}.`);
 const HomebrewRange = Literals$2(["*", "latest"]).annotate({ description: "\"*\" (install when missing, never upgrade) or \"latest\" (brew update, then upgrade on every Ship)" });
-const HomebrewItems = Record(NonEmptyString, Union([HomebrewRange, Struct({
+const HomebrewItems = Record(NonEmptyString, variants(withShorthand(Struct({
 	...Targeting,
 	range: HomebrewRange
-})]));
-const homebrewSection = (items, noun) => Struct({
-	...Targeting,
-	dependsOn: optionalKey(ArraySchema(ProviderName)).annotateKey({ description: "Providers whose Items must succeed on a Machine before this one changes there." }),
-	items: optionalKey(items).annotateKey({ description: `${noun}, each \`"*"\` or \`"latest"\`, or \`{ range, platforms?, machines? }\` to target one. A tapped name (\`owner/tap/name\`) taps on install.` })
-});
-const BrewSection = homebrewSection(HomebrewItems.check(makeFilter((items) => !Object.hasOwn(items, "brew") || "\"brew\" is Homebrew itself", {
+}), HomebrewRange, {
+	decode: (range) => ({ range }),
+	encode: (entry) => entry.range
+})));
+const homebrewDescription = (noun) => `${noun}, keyed by name. Each is \`"*"\` or \`"latest"\`, \`{ range, platforms?, machines? }\` to target it, ${VARIANTS}. A tapped name (\`owner/tap/name\`) taps on install.`;
+const BrewSection = section({}, HomebrewItems.check(makeFilter((items) => !Object.hasOwn(items, "brew") || "\"brew\" is Homebrew itself", {
 	title: "Formulae",
 	description: "Formulae other than brew"
-})), "Formulae");
-const CaskSection = homebrewSection(HomebrewItems, "Casks");
-const MachineSettings = Struct({ clones: optionalKey(NonEmptyString).annotateKey({ description: `Where this Machine keeps its Managed Clones. \`~\` expands on that Machine. Default: \`~/.local/share/fleetfizz/clones\`.` }) });
+})), homebrewDescription("Formulae"));
+const CaskSection = section({}, HomebrewItems, homebrewDescription("Casks"));
+const DEFAULT_CLONE_ROOT = "~/.local/share/fleetfizz/clones";
+const ReposSection = section({ cloneRoot: optionalKey(variants(withShorthand(Struct({
+	...Targeting,
+	path: NonEmptyString
+}), NonEmptyString, {
+	decode: (path) => ({ path }),
+	encode: (root) => root.path
+}))).annotateKey({ description: `Where a Machine keeps its Managed Clones: a path, or a list of \`{ path, platforms?, machines? }\` where a Machine gets the first that targets it. \`~\` expands on that Machine. Default: \`${DEFAULT_CLONE_ROOT}\`.` }) }, Record(NonEmptyString, variants(TrackedRepo)), `Tracked Repos, keyed by name, which names the Managed Clone and the \`repos:<name>\` Item. Each is \`{ origin, ref, install, ... }\`, ${VARIANTS}.`);
 const FleetConfig = Struct({
 	$schema: optionalKey(String$5),
 	shippedAt: optionalKey(String$5),
 	shippedFrom: optionalKey(NonEmptyString),
 	shippedTo: optionalKey(Record(NonEmptyString, String$5)),
-	machines: Record(NonEmptyString, MachineSettings).check(makeFilter((machines) => Object.keys(machines).length > 0, {
-		title: "Fleet",
-		description: "at least one Machine"
-	})).annotateKey({ description: "The Fleet, keyed by each Machine's tailnet name. A tailnet member that is not listed is not part of the Fleet." }),
-	repos: optionalKey(ArraySchema(TrackedRepo)).annotateKey({ description: "Each Tracked Repo is cloned on every targeted Machine and installed from its origin ref." }),
+	machines: ArraySchema(NonEmptyString).check(isMinLength(1, { message: "list at least one Machine" }), isUnique({ message: "list each Machine once" })).annotateKey({ description: "The Fleet: each Machine's tailnet name. A tailnet member that is not listed is not part of the Fleet." }),
+	repos: optionalKey(ReposSection).annotateKey({ description: "Each Tracked Repo is cloned on every targeted Machine and installed from its origin ref." }),
 	vp: optionalKey(VpSection).annotateKey({ description: "The vite-plus toolchain." }),
 	brew: optionalKey(BrewSection).annotateKey({ description: "Homebrew Formulae. Needs Homebrew on the Machine; a Ship never installs it." }),
 	cask: optionalKey(CaskSection).annotateKey({ description: "Homebrew Casks, macOS only. Needs Homebrew on the Machine." })
 });
-const repoName = (repo) => repo.name ?? repo.origin.replace("/", "-");
 const SELF_PACKAGE = "fleetfizz";
 //#endregion
 //#region ../../packages/config/src/jsonSchema.ts
@@ -35302,17 +35465,33 @@ var ConfigNotFound = class extends TaggedError()("ConfigNotFound", { path: Strin
 	}
 };
 const lineOf = (text, offset) => text.slice(0, offset).split("\n").length;
-const semanticProblems = (config) => {
+const repeatedKeys = (text) => {
 	const problems = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const repo of config.repos ?? []) {
-		const name = repoName(repo);
-		if (seen.has(name)) problems.push(`repos: duplicate name "${name}"`);
-		seen.add(name);
-	}
-	if (config.vp?.globals?.["fleetfizz"] !== void 0) problems.push(`vp.globals: ${SELF_PACKAGE} is pinned by the running version; remove it`);
+	const visit = (node, path) => {
+		if (node.type === "array") node.children?.forEach((child, i) => visit(child, [...path, i]));
+		if (node.type !== "object") return;
+		const seen = /* @__PURE__ */ new Set();
+		for (const [key, value] of (node.children ?? []).map((property) => property.children ?? [])) {
+			if (key === void 0) continue;
+			const name = String(key.value);
+			if (seen.has(name)) problems.push(`line ${lineOf(text, key.offset)}: "${name}" is repeated${path.length > 0 ? ` in ${path.join(".")}` : ""}`);
+			seen.add(name);
+			if (value !== void 0) visit(value, [...path, name]);
+		}
+	};
+	const tree = parseTree(text, void 0, { allowTrailingComma: true });
+	if (tree !== void 0) visit(tree, []);
 	return problems;
 };
+const movedKeys = (parsed) => {
+	if (typeof parsed !== "object" || parsed === null) return [];
+	const config = parsed;
+	return [
+		...typeof config.machines === "object" && config.machines !== null && !Array.isArray(config.machines) ? ["machines is now a list of names, and machines.<name>.clones is repos.cloneRoot"] : [],
+		...Array.isArray(config.repos) ? ["repos is now { items: { <name>: { origin, ref, install } } }, keyed by each repo's name"] : [],
+		...typeof config.vp === "object" && config.vp !== null && "globals" in config.vp ? ["vp.globals is now vp.items"] : []
+	];
+};
 const parseConfig = fn("parseConfig")(function* (path, text) {
 	const parseErrors = [];
 	const parsed = parse(text, parseErrors, { allowTrailingComma: true });
@@ -35320,16 +35499,20 @@ const parseConfig = fn("parseConfig")(function* (path, text) {
 		path,
 		problems: parseErrors.map((e) => `line ${lineOf(text, e.offset)}: ${printParseErrorCode(e.error)}`)
 	});
-	const config = yield* decodeUnknownEffect(FleetConfig, { onExcessProperty: "error" })(parsed).pipe(mapError((error) => new ConfigError({
+	const moved = movedKeys(parsed);
+	if (moved.length > 0) return yield* new ConfigError({
 		path,
-		problems: [formatIssue(error.issue)]
-	})));
-	const problems = semanticProblems(config);
-	if (problems.length > 0) return yield* new ConfigError({
+		problems: moved
+	});
+	const repeated = repeatedKeys(text);
+	if (repeated.length > 0) return yield* new ConfigError({
 		path,
-		problems
+		problems: repeated
 	});
-	return config;
+	return yield* decodeUnknownEffect(FleetConfig, { onExcessProperty: "error" })(parsed).pipe(mapError((error) => new ConfigError({
+		path,
+		problems: [formatIssue(error.issue)]
+	})));
 });
 const formatIssue = makeFormatterDefault();
 const loadConfig = fn("loadConfig")(function* (path) {
@@ -35371,7 +35554,7 @@ const stampText = (text, stamp) => {
 const machinesOf = (config) => {
 	if (typeof config !== "object" || config === null || !("machines" in config)) return [];
 	const value = config.machines;
-	return typeof value === "object" && value !== null ? Object.keys(value) : [];
+	return Array.isArray(value) ? value.filter((name) => typeof name === "string") : [];
 };
 const shippedToOf = (config) => {
 	if (typeof config !== "object" || config === null || !("shippedTo" in config)) return {};
@@ -63826,24 +64009,46 @@ const useWindowSize = () => {
 //#endregion
 //#region ../../packages/core/src/targeting.ts
 const targets = (targeting, machine) => (targeting.platforms?.includes(machine.platform) ?? true) && (targeting.machines?.includes(machine.name) ?? true);
+const isVariantList = (entry) => Array.isArray(entry);
+const variantFor = (entry, machine) => {
+	if (!isVariantList(entry)) return targets(entry, machine) ? { variant: entry } : void 0;
+	const index = entry.findIndex((variant) => targets(variant, machine));
+	const variant = entry[index];
+	return variant === void 0 ? void 0 : {
+		variant,
+		index
+	};
+};
 //#endregion
 //#region ../../packages/core/src/engine.ts
-const isObjectSection = (section) => !Array.isArray(section);
-const sectionTargeting = (section) => isObjectSection(section) ? section : {};
-const dependenciesOf = (provider, config) => {
-	const section = config[provider.name];
-	const extra = section !== void 0 && isObjectSection(section) ? section.dependsOn ?? [] : [];
-	return [.../* @__PURE__ */ new Set([...provider.dependsOn, ...extra])];
-};
+const dependenciesOf = (provider, config) => [.../* @__PURE__ */ new Set([...provider.dependsOn, ...config[provider.name]?.dependsOn ?? []])];
+const withoutTargeting = ({ platforms: _platforms, machines: _machines, ...def }) => def;
 const targetedItems = (provider, config, machine) => {
 	const section = config[provider.name];
-	const scoped = section !== void 0 && targets(sectionTargeting(section), machine) ? section : void 0;
-	return provider.items(scoped).filter((item) => targets(item, machine));
+	if (section === void 0 || !targets(section, machine)) return provider.items(void 0, []);
+	const listed = Object.entries(section.items ?? {}).flatMap(([name, entry]) => {
+		const chosen = variantFor(entry, machine);
+		if (chosen === void 0) return [];
+		const at = chosen.index === void 0 ? [] : [chosen.index];
+		return [{
+			name,
+			def: withoutTargeting(chosen.variant),
+			path: [
+				provider.name,
+				"items",
+				name,
+				...at
+			]
+		}];
+	});
+	return provider.items(section, listed);
 };
-const machinesNamed = (provider, config) => {
-	const section = config[provider.name];
-	return [...section === void 0 ? [] : sectionTargeting(section).machines ?? [], ...provider.items(section).flatMap((item) => item.machines ?? [])];
+const machineNames = (value) => {
+	if (Array.isArray(value)) return value.flatMap(machineNames);
+	if (typeof value !== "object" || value === null) return [];
+	return Object.entries(value).flatMap(([key, v]) => key === "machines" && Array.isArray(v) && v.every((name) => typeof name === "string") ? v : machineNames(v));
 };
+const machinesNamed = (provider, config) => machineNames(config[provider.name]);
 const hold = (decisions, by) => decisions.map((d) => d.kind === "change" || d.kind === "ask" ? {
 	kind: "skip",
 	item: d.item,
@@ -64031,7 +64236,6 @@ const orderProviders = (all, dependsOn) => {
 };
 //#endregion
 //#region ../../packages/core/src/record.ts
-const sameRecord = (a, b) => Object.keys(a).length === Object.keys(b).length && Object.entries(a).every(([k, v]) => b[k] === v);
 const decideInstall = (record, now, rebuild) => {
 	if (rebuild) return {
 		run: true,
@@ -64053,10 +64257,6 @@ const decideInstall = (record, now, rebuild) => {
 		run: true,
 		reason: "install command changed"
 	};
-	if (!sameRecord(record.files, now.files)) return {
-		run: true,
-		reason: "files changed"
-	};
 	for (const [path, fingerprint] of Object.entries(now.outputs)) if (fingerprint === void 0 || record.outputs[path] !== fingerprint) return {
 		run: true,
 		reason: `drift: ${path}`
@@ -65122,7 +65322,7 @@ const decodeFact$2 = decodeUnknownOption(Union([Struct({
 	version: NullOr(String$5)
 }), AtFact]));
 const NO_BREW = "Homebrew is not installed; install it first";
-const homebrew = (name) => {
+function homebrew(name) {
 	const flag = name === "brew" ? "--formula" : "--cask";
 	const lookup = name === "brew" ? "\"$ff_i\"" : "\"${ff_i##*/}\"";
 	const report = (names) => `for ff_i in ${names.map(quote).join(" ")}; do ff_v=$(brew list --versions ${flag} ${lookup} 2>/dev/null | awk '{print $NF}'); [ -z "$ff_v" ] || ff_at ${name} "$ff_i" "$ff_v"; done`;
@@ -65145,17 +65345,13 @@ const homebrew = (name) => {
 		name,
 		rule: "range",
 		dependsOn: name === "cask" ? ["brew"] : [],
-		items(section) {
+		items(section, listed) {
 			if (section === void 0) return [];
-			const packages = Object.entries(section.items ?? {}).map(([item, entry]) => typeof entry === "string" ? {
+			const packages = listed.map(({ name: item, def }) => ({
 				name: item,
 				kind: "package",
-				range: entry
-			} : {
-				...entry,
-				name: item,
-				kind: "package"
-			});
+				range: def.range
+			}));
 			return name === "brew" ? [{
 				name: "brew",
 				kind: "homebrew"
@@ -65247,7 +65443,7 @@ const homebrew = (name) => {
 			});
 		}
 	};
-};
+}
 const brew = homebrew("brew");
 const cask = homebrew("cask");
 const decodeFact$1 = decodeUnknownOption(Union([
@@ -65274,15 +65470,17 @@ const decodeRecord = decodeUnknownOption(Struct({
 	commit: String$5,
 	path: String$5,
 	install: String$5,
-	files: Record(String$5, String$5),
 	outputs: Record(String$5, String$5)
 }));
-const cloneRoot = (config, machine) => config.machines[machine]?.clones ?? "~/.local/share/fleetfizz/clones";
+const branchKey = (repo) => `${repo.origin}#${repo.ref}`;
+const cloneRoot = (config, machine) => {
+	const root = config.repos?.cloneRoot;
+	return (root === void 0 ? void 0 : variantFor(root, machine))?.variant.path ?? "~/.local/share/fleetfizz/clones";
+};
 const originUrl = (origin) => `https://github.com/${origin}.git`;
 const short = (commit) => commit.slice(0, 7);
 const expandHome = (path, home) => path === "~" ? home : path.startsWith("~/") ? `${home}${path.slice(1)}` : path;
 const jsonString = encodeSync(fromJsonString(String$5));
-const jsonRecord = encodeSync(fromJsonString(Record(String$5, String$5)));
 const lsRemote = fn("lsRemote")(function* (repo, token) {
 	const spawner = yield* ChildProcessSpawner;
 	const auth = token === void 0 ? [] : [
@@ -65346,7 +65544,7 @@ const decideRepo = (repo, root, observed, resolved, ctx) => {
 	if (observed.cloneRoot?.present === false && !root.startsWith("~")) return fail(`clone root not mounted: ${observed.cloneRoot.path}`);
 	const url = originUrl(repo.origin);
 	if (clone?.present && clone.origin !== void 0 && clone.origin !== url) return fail(`managed clone has origin ${clone.origin}, expected ${url}`);
-	const target = isPin(repo.ref) ? { commit: repo.ref } : resolved[repo.name];
+	const target = isPin(repo.ref) ? { commit: repo.ref } : resolved[branchKey(repo)];
 	if (target === void 0) return fail(`could not resolve ${repo.ref}`);
 	if ("error" in target) return fail(target.error);
 	const { commit } = target;
@@ -65355,7 +65553,6 @@ const decideRepo = (repo, root, observed, resolved, ctx) => {
 		commit,
 		path: expandHome(`${root}/${repo.name}`, ctx.home),
 		install: repo.install,
-		files: repo.files ?? {},
 		outputs: Object.fromEntries((repo.outputs ?? []).map((o) => [o, outputs?.get(o)]))
 	}, ctx.rebuild(address("repos", repo.name)));
 	const reason = install.run ? install.reason : !clone?.present ? "not cloned" : clone.head !== commit ? `checked out at ${short(clone.head ?? "")}` : void 0;
@@ -65387,7 +65584,6 @@ const fetchStep = ({ item, root, commit }) => {
 		`git -C "$ff_d" checkout --quiet --detach ${quote(commit)}`,
 		`git -C "$ff_d" reset --quiet --hard ${quote(commit)}`
 	] : [`ff_git -C "$ff_d" fetch --quiet origin ${quote(item.ref)}`, `git -C "$ff_d" reset --quiet --hard ${quote(commit)}`];
-	const files = Object.entries(item.files ?? {}).flatMap(([path, content]) => [`mkdir -p "$(dirname "$ff_d"/${quote(path)})"`, `printf '%s' ${quote(content)} > "$ff_d"/${quote(path)}`]);
 	return {
 		id: `repos:${item.name}:fetch`,
 		items: [item.name],
@@ -65400,11 +65596,7 @@ const fetchStep = ({ item, root, commit }) => {
 			"  set -e",
 			`  if [ ! -d "$ff_d/.git" ]; then ff_git clone --quiet ${quote(url)} "$ff_d"; fi`,
 			`  if [ "$(git -C "$ff_d" remote get-url origin)" != ${quote(url)} ]; then echo "origin is $(git -C "$ff_d" remote get-url origin), expected ${url}"; exit 1; fi`,
-			...[
-				...sync,
-				`git -C "$ff_d" clean --quiet -fd`,
-				...files
-			].map((l) => `  ${l}`),
+			...[...sync, `git -C "$ff_d" clean --quiet -fd`].map((l) => `  ${l}`),
 			")"
 		]
 	};
@@ -65413,7 +65605,7 @@ const installStep = ({ item, root }, ctx) => {
 	const env = [
 		`FLEETFIZZ_MACHINE=${quote(ctx.machine.name)}`,
 		`FLEETFIZZ_PLATFORM=${quote(ctx.machine.platform)}`,
-		`FLEETFIZZ_MACHINES=${quote(Object.keys(ctx.config.machines).join(","))}`
+		`FLEETFIZZ_MACHINES=${quote(ctx.config.machines.join(","))}`
 	].join(" ");
 	const tmp = `${recordDir("repos")}/${quote(`${item.name}.json.tmp`)}`;
 	const record = [
@@ -65421,7 +65613,7 @@ const installStep = ({ item, root }, ctx) => {
 		`ff_outs=""`,
 		...(item.outputs ?? []).map((o) => `ff_fpv=$(ff_fp ${quotePath(o)}); if [ -n "$ff_fpv" ]; then ff_outs="$ff_outs,\\"$(ff_json ${quote(o)})\\":\\"$(ff_json "$ff_fpv")\\""; fi`),
 		`mkdir -p ${recordDir("repos")}`,
-		`printf '%s\\n' "{\\"commit\\":\\"$ff_after\\",\\"path\\":\\"$(ff_json "$ff_d")\\",\\"install\\":$(ff_lit ${quote(jsonString(item.install))}),\\"files\\":$(ff_lit ${quote(jsonRecord(item.files ?? {}))}),\\"outputs\\":{\${ff_outs#,}}}" > ${tmp}`,
+		`printf '%s\\n' "{\\"commit\\":\\"$ff_after\\",\\"path\\":\\"$(ff_json "$ff_d")\\",\\"install\\":$(ff_lit ${quote(jsonString(item.install))}),\\"outputs\\":{\${ff_outs#,}}}" > ${tmp}`,
 		`mv -f ${tmp} ${recordFile("repos", item.name)}`,
 		`rm -f ${quotePath(RECORDS_DIR)}/${quote(`${item.name}.json`)}`
 	];
@@ -65450,11 +65642,11 @@ const repos = {
 	name: "repos",
 	rule: "record",
 	dependsOn: ["vp"],
-	items: (section) => (section ?? []).map((repo) => ({
-		...repo,
-		name: repoName(repo)
+	items: (_section, listed) => listed.map(({ name, def }) => ({
+		...def,
+		name
 	})),
-	observe: (items, scope) => observe(items, cloneRoot(scope.config, scope.machine.name)),
+	observe: (items, scope) => observe(items, cloneRoot(scope.config, scope.machine)),
 	parse(facts, records) {
 		let root;
 		const clones = /* @__PURE__ */ new Map();
@@ -65497,9 +65689,9 @@ const repos = {
 			records: decoded
 		};
 	},
-	resolve: (items, { token }) => forEach$1(items.filter((repo) => !isPin(repo.ref)), (repo) => lsRemote(repo, token).pipe(map$5((result) => [repo.name, result])), { concurrency: 8 }).pipe(map$5((entries) => Object.fromEntries(entries))),
+	resolve: (items, { token }) => forEach$1([...new Map(items.filter((r) => !isPin(r.ref)).map((r) => [branchKey(r), r])).entries()], ([key, repo]) => lsRemote(repo, token).pipe(map$5((result) => [key, result])), { concurrency: 8 }).pipe(map$5((entries) => Object.fromEntries(entries))),
 	decide: ({ items, observed, resolved, ctx }) => {
-		const root = cloneRoot(ctx.config, ctx.machine.name);
+		const root = cloneRoot(ctx.config, ctx.machine);
 		return items.map((repo) => decideRepo(repo, root, observed, resolved, ctx));
 	},
 	act: (decisions, ctx) => decisions.flatMap((d) => d.kind === "change" ? [fetchStep(d.change), installStep(d.change, ctx)] : d.kind === "leave" && d.upkeep !== void 0 ? [fetchStep(d.upkeep)] : [])
@@ -65687,28 +65879,14 @@ const PROVIDERS = [
 		name: "vp",
 		rule: "range",
 		dependsOn: [],
-		items(section) {
-			const globals = Object.entries(section?.globals ?? {}).map(([name, global]) => {
-				const targeting = typeof global === "string" ? {} : global;
-				return {
-					...targeting.platforms === void 0 ? {} : { platforms: targeting.platforms },
-					...targeting.machines === void 0 ? {} : { machines: targeting.machines },
-					name,
-					kind: "global",
-					packages: [name],
-					range: typeof global === "string" ? global : global.range,
-					bumpPath: typeof global === "string" ? [
-						"vp",
-						"globals",
-						name
-					] : [
-						"vp",
-						"globals",
-						name,
-						"range"
-					]
-				};
-			});
+		items(section, listed) {
+			const globals = listed.map(({ name, def, path }) => ({
+				name,
+				kind: "global",
+				packages: [name],
+				range: def.range,
+				bumpPath: [...path, "range"]
+			}));
 			const defaults = ["node", ...PACKAGE_MANAGERS].flatMap((tool) => {
 				const range = section?.[tool];
 				return range === void 0 ? [] : [{
@@ -66080,23 +66258,33 @@ const askQuestions = fn("askQuestions")(function* (input) {
 	for (const group of groups.values()) {
 		const question = group[0]?.question;
 		if (question === void 0) continue;
-		const newest = newestOf(group.map((a) => a.question.found));
-		const where = group.map((a) => `${a.question.found} on ${a.machine}`).join(", ");
-		yield* input.ledger.note("ask", `${question.subject} ${where} ${question.problem}`);
+		const bumps = [...Map.groupBy(group.flatMap(({ question: q }) => q.bump === void 0 ? [] : [{
+			...q.bump,
+			found: q.found
+		}]), (bump) => JSON.stringify(bump.path)).values()].flatMap((list) => {
+			const first = list[0];
+			return first === void 0 ? [] : [{
+				path: first.path,
+				range: first.range,
+				newest: newestOf(list.map((b) => b.found))
+			}];
+		});
+		const where = [...Map.groupBy(group, (a) => a.question.problem)].map(([problem, list]) => `${list.map((a) => `${a.question.found} on ${a.machine}`).join(", ")} ${problem}`).join("; ");
+		yield* input.ledger.note("ask", `${question.subject} ${where}`);
 		if (input.dryRun) {
 			yield* input.ledger.note("answer", "not asked (dry run)");
 			continue;
 		}
 		const choices = question.choices.map((c) => ({
 			value: c.value,
-			title: c.value === "bump" && question.bump !== void 0 ? `bump the config to ${bumpedRange(question.bump.range, newest)}` : c.title
+			title: c.value === "bump" && bumps.length > 0 ? `bump the config to ${bumps.map((b) => bumpedRange(b.range, b.newest)).join(" and ")}` : c.title
 		}));
 		const answer = input.answer(question.kind, question.subject) ?? (input.ask === void 0 ? question.default : yield* input.ask(choices));
 		yield* input.ledger.note("answer", choices.find((c) => c.value === answer)?.title ?? answer);
 		answered.push({
 			question,
 			machines: group.map((a) => a.machine),
-			newest,
+			bumps,
 			answer
 		});
 	}
@@ -66110,7 +66298,7 @@ var ShipError = class extends Error {
 const unknownMachines = (config, tailnet, only) => {
 	const known = new Set(tailnet.fleet.map((m) => m.name));
 	const referenced = [
-		...Object.keys(config.machines),
+		...config.machines,
 		...PROVIDERS.flatMap((p) => machinesNamed(p, config)),
 		...only
 	];
@@ -66119,7 +66307,7 @@ const unknownMachines = (config, tailnet, only) => {
 const unshippable = (config, tailnet, only, source) => {
 	const unknown = unknownMachines(config, tailnet, only);
 	if (unknown.length > 0) return `unknown Machine: ${unknown.join(", ")} (the tailnet has: ${tailnet.fleet.map((m) => m.name).join(", ")})`;
-	const fleet = new Set(Object.keys(config.machines));
+	const fleet = new Set(config.machines);
 	if (!fleet.has(tailnet.self.name)) return `this Machine (${tailnet.self.name}) is not in machines in ${source}`;
 	const outsideFleet = only.filter((name) => !fleet.has(name));
 	if (outsideFleet.length > 0) return `not in machines in ${source}: ${outsideFleet.join(", ")}`;
@@ -66167,9 +66355,9 @@ const shipPass = fn("shipPass")(function* (flags) {
 	const tailnet = yield* readTailnet();
 	const problem = unshippable(config, tailnet, flags.only, path);
 	if (problem !== void 0) return yield* fail$1(new ShipError(problem));
-	const fleet = new Set(Object.keys(config.machines));
+	const fleet = new Set(config.machines);
 	const own = flags.config === void 0 ? tailnet.self.name : void 0;
-	const order = Object.keys(config.machines);
+	const order = config.machines;
 	const targetsList = tailnet.fleet.filter((m) => fleet.has(m.name) && (flags.only.length === 0 || flags.only.includes(m.name))).toSorted((a, b) => order.indexOf(a.name) - order.indexOf(b.name));
 	const count = `${targetsList.length} machine${targetsList.length === 1 ? "" : "s"}`;
 	yield* log(`${flags.dryRun ? "dry run, " : ""}${count} from ${tailnet.self.name}`);
@@ -66278,14 +66466,10 @@ const shipPass = fn("shipPass")(function* (flags) {
 			}
 		}
 	}
-	const targeted = providers.map((provider) => {
-		const items = /* @__PURE__ */ new Map();
-		for (const { machine } of checked) for (const item of targetedItems(provider, config, machine)) items.set(item.name, item);
-		return {
-			provider,
-			items: [...items.values()]
-		};
-	});
+	const targeted = providers.map((provider) => ({
+		provider,
+		items: checked.flatMap(({ machine }) => targetedItems(provider, config, machine))
+	}));
 	const lent = targeted.some(({ provider, items }) => provider.name === "repos" && items.length > 0) ? yield* readLentToken() : { token: void 0 };
 	if (lent.token === void 0 && lent.reason !== void 0) yield* ledger.note("info", `no gh token (${lent.reason}); private repos will fail`);
 	const resolved = Object.fromEntries(yield* forEach$1(targeted, ({ provider, items }) => provider.resolve(items, lent.token === void 0 ? {} : { token: lent.token }).pipe(map$5((r) => [provider.name, r])), { concurrency: "unbounded" }));
@@ -66324,15 +66508,17 @@ const shipPass = fn("shipPass")(function* (flags) {
 			dryRun: flags.dryRun
 		});
 		let progressed = false;
-		for (const { question, newest, answer: choice } of answered) {
+		for (const { question, bumps, answer: choice } of answered) {
 			const key = `${question.kind}:${question.subject}`;
 			progressed ||= !decided.has(key);
 			decided.set(key, choice);
-			if (choice !== "bump" || question.bump === void 0) continue;
-			changing = true;
-			const range = yield* bumpConfig(path, question.bump.path, newest);
-			progressed ||= range !== question.bump.range;
-			cfg = yield* loadConfig(path);
+			if (choice !== "bump") continue;
+			for (const bump of bumps) {
+				changing = true;
+				const range = yield* bumpConfig(path, bump.path, bump.newest);
+				progressed ||= range !== bump.range;
+			}
+			if (bumps.length > 0) cfg = yield* loadConfig(path);
 		}
 		if (!progressed) break;
 		planned = planAll(cfg, answer);