bun-nested-workspace 0.3.1 → 0.4.0

package/README.md

@@ -51,6 +51,8 @@ Then update the nested lockfile with `bun install --lockfile-only` in the direct
 bunx bun-nested-workspace
 ```
 
+A nested repository without workspace packages updates its lockfile in a separate clone.
+
 Do not run other `bun install`, `bun add`, or `bun remove` commands in the nested directory or in its package directories:
 
 - In the nested root, Bun runs them for the host: it writes the host lockfile and leaves the nested one stale.
@@ -72,6 +74,7 @@ The sync:
 4. Fails if the install re-resolved own dependencies of host packages, or if the host does not resolve the nested packages as the nested lockfile does.
 
 Commit `package.json` and `bun.lock` after the sync.
+A failed sync restores `package.json` and `bun.lock` to their contents before the run, while `node_modules` stays as the install left it.
 
 In a Docker build, run the sync with `--lockfile-only` in a stage that contains only the dependency files, before installing dependencies.
 The dependency install runs the `prepare` script of the nested root unless it gets `--ignore-scripts`.
@@ -113,7 +116,7 @@ A package version patched by both the host and the nested repository is an error
 ### Lockfile
 
 The nested lockfile entries replace the host entries, so the nested packages keep their versions.
-When a replaced entry no longer satisfies a dependency of a host package, the host package keeps its previous resolution as a nested lockfile entry.
+When a replaced entry no longer satisfies a dependency of a host package, the host package keeps its previous resolution, and the nested packages keep theirs.
 When neither satisfies the range, which Bun lockfiles occasionally contain, the dependency gets the highest satisfying version recorded in either lockfile.
 Ranges are checked as `bun install` applies them: an override replaces the declared range, and an `npm:` alias requires the package it names.
 `bun install` then resolves new dependencies of host packages and drops unused entries.
@@ -121,7 +124,7 @@ Ranges are checked as `bun install` applies them: an override replaces the decla
 After the install, the sync compares the direct dependencies of host packages with the original host lockfile.
 A dependency may only change to the version that the nested lockfile hoists to its top level, and only within the host range.
 Any other change means either that the host lockfile did not pin the host dependencies, for example after an edit of a host `package.json` without `bun install`, or that the lockfile cannot record the host version next to the nested one.
-The latter happens to a host workspace without a name, because Bun records workspace-specific versions under the workspace name; name the workspace or align its range with the nested version.
+The latter happens to a host workspace other than the root without a name, because Bun records workspace-specific versions under the workspace name; name the workspace or align its range with the nested version.
 
 Only `bun.lock` with `lockfileVersion` 1 or 2 is supported, because the lockfile format is internal to Bun.
 
@@ -132,7 +135,8 @@ bunx bun-nested-workspace --check
 ```
 
 The check writes nothing, does not run `bun install`, and exits with code 1 when the host files lag behind the nested checkout.
-It reads the root `package.json` and `bun.lock` of the host and of the nested checkout only, so it relies on the nested `bun.lock` being up to date with the nested packages; `bun install --frozen-lockfile` in the CI of the nested repository verifies that.
+It reads the root `package.json` and `bun.lock` of the host and of the nested checkout only, so it relies on the nested `bun.lock` being up to date with the nested packages.
+Verify that in the CI of the nested repository with `bun install --lockfile-only` followed by `git diff --exit-code bun.lock`: `bun install --frozen-lockfile` misses some changes, such as a narrowed range that the locked version still satisfies.
 Use it in a non-blocking CI job that signals when a sync commit is due.
 
 It reports:
@@ -149,7 +153,7 @@ Limitations:
 
 - Peer dependencies are not walked.
 - Edges that the nested lockfile itself resolves outside their range are skipped, because the sync repairs them in the host.
-- The check does not verify that the host lockfile matches the host packages; `bun install --frozen-lockfile` does.
+- The check does not verify that the host lockfile matches the host packages; `bun install --lockfile-only` followed by `git diff --exit-code bun.lock` does.
 - The check does not predict whether a sync would re-resolve own dependencies of host packages; only the sync detects it after `bun install`.
 
 ## API
@@ -173,7 +177,8 @@ if (!isInSync(check)) {
 }
 ```
 
-`syncNestedWorkspace` writes the files and runs `bun install` before it checks the result, so a failed sync leaves the written files for inspection.
+`syncNestedWorkspace` writes the files and runs `bun install` before it checks the result.
+When `bun install` fails or the result shows differences, it restores both files before it throws or returns, and throws an error saying so when it cannot restore them.
 Its `onManifestSync` option receives the replaced host entries and whether the sync added `trustedDependencies`, as soon as `package.json` is written and even when `bun install` then fails.
 
 Lower-level functions work on parsed files without touching the disk: `syncManifest`, `diffManifests`, `parseLockfile`, `relocateLockfile`, `applyManifestToLockfile`, `mergeLockfiles`, and the `find*` checks.

package/dist/cli.mjs

@@ -1,11 +1,12 @@
 #!/usr/bin/env bun
-import { a as syncNestedWorkspace, i as loadNestedWorkspace, n as checkNestedWorkspace, r as isInSync, t as BunInstallError, y as getErrorMessage } from "./workspace-BzA7ccrb.mjs";
+import { a as isNestedWorkspace, i as isInSync, n as checkNestedWorkspace, o as loadNestedWorkspace, r as findNestedPackageDir, s as syncNestedWorkspace, t as BunInstallError, x as getErrorMessage } from "./workspace-DOwKm8pX.mjs";
 // src/cli.ts
 const usage = `Usage:
   bun-nested-workspace [bun install options]  Sync package.json and bun.lock, then run bun install
   bun-nested-workspace --check                Exit with 1 if package.json or bun.lock lag behind the nested checkout
 
 Configure the nested directory in the "bun-nested-workspace" field of the host package.json.`;
+const restoredMessage = "Restored package.json and bun.lock to their contents before the sync.";
 /** Runs the CLI with the given arguments in the given host root and returns the exit code. */
 async function runCli(args, root = process.cwd()) {
 	if (args.includes("--help") || args.includes("-h")) {
@@ -23,7 +24,10 @@ async function runCli(args, root = process.cwd()) {
 		}
 		return await runSync(root, args);
 	} catch (error) {
-		if (error instanceof BunInstallError) return error.exitCode;
+		if (error instanceof BunInstallError) {
+			console.error(restoredMessage);
+			return error.exitCode;
+		}
 		console.error(getErrorMessage(error));
 		return 1;
 	}
@@ -51,7 +55,7 @@ async function runSync(root, installArgs) {
 	if (ownDependencyChanges.length) {
 		console.error([
 			"The sync changed own dependencies of host packages.",
-			"Either the host bun.lock did not pin them: restore bun.lock, run bun install, commit bun.lock, and sync again.",
+			"Either the host bun.lock did not pin them: run bun install, commit bun.lock, and sync again.",
 			"Or the nested lockfile resolves them outside the host range: align the host range with the nested version.",
 			...ownDependencyChanges.map(({ workspace, dependency, expected, actual }) => formatChange(`${workspace} > ${dependency}`, expected, actual))
 		].join("\n"));
@@ -59,10 +63,23 @@ async function runSync(root, installArgs) {
 	}
 	if (!isInSync(check)) {
 		console.error(["bun install did not keep the nested resolutions:", ...formatCheckResult(check)].join("\n"));
+		const workspace = await loadNestedWorkspace(root);
+		if (check.workspaces.some((workspacePath) => isNestedWorkspace(workspace, workspacePath))) console.error(await formatNestedLockfileUpdate(workspace));
 		exitCode = 1;
 	}
+	if (exitCode) console.error(restoredMessage);
 	return exitCode;
 }
+/** Formats how to update a nested lockfile that lags behind the nested package.json files. */
+async function formatNestedLockfileUpdate(workspace) {
+	const { dir } = workspace.config;
+	const packageDir = await findNestedPackageDir(workspace);
+	return packageDir ? `${dir}/bun.lock lags behind the package.json files of ${dir}. Update it and sync again:\n  (cd ${quoteShellArgument(packageDir)} && bun install --lockfile-only)` : `${dir}/bun.lock lags behind the package.json files of ${dir}. Update it with bun install --lockfile-only in a separate clone of the nested repository and sync again.`;
+}
+/** Quotes a value for a POSIX shell when it contains characters other than those of plain paths. */
+function quoteShellArgument(value) {
+	return /^[\w@%+=:,./-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+}
 function printManifestSync({ overridden, addedTrustedDependencies }) {
 	if (overridden.length) console.log(["Nested entries replaced host entries:", ...overridden.map(formatOverridden)].join("\n"));
 	if (addedTrustedDependencies) console.warn([

package/dist/index.d.mts

@@ -194,7 +194,9 @@ export declare function applyManifestToLockfile(lock: Lockfile, manifest: Packag
  * A root entry overridden by the nested lockfile might not satisfy a dependency of a host package:
  * such a dependency gets back its previous host resolution as a nested entry, so `bun install` keeps the host version
  * instead of resolving the range again.
- * A host workspace without a name cannot have nested entries, so `bun install` resolves its dependency again.
+ * A dependency of the host root package gets it back at the top level instead, as `keepHostRootResolutions` describes.
+ * A host workspace other than the root without a name cannot have nested entries,
+ * so `bun install` resolves its dependency again.
  * When the previous host resolution does not satisfy the range either, which Bun lockfiles occasionally contain,
  * the dependency gets the highest satisfying version recorded in either lockfile.
  * Catalog dependencies are checked against the catalogs of the host lockfile, so apply the synced root fields
@@ -296,11 +298,15 @@ interface SyncOptions {
    */
   onManifestSync?: (sync: ManifestSync) => void;
 }
-/** Result of `syncNestedWorkspace`. */
+/**
+ * Result of `syncNestedWorkspace`.
+ *
+ * The sync failed and restored the host files when `ownDependencyChanges` is not empty or `isInSync(check)` is false.
+ */
 interface SyncResult {
-  /** Own dependencies of host workspaces that the sync re-resolved; the sync failed when this is not empty. */
+  /** Own dependencies of host workspaces that the sync re-resolved. */
   ownDependencyChanges: DependencyMismatch[];
-  /** Check of the synced files; the sync failed when it is not in sync. */
+  /** Check of the synced files. */
   check: CheckResult;
 }
 /**
@@ -308,6 +314,9 @@ interface SyncResult {
  *
  * Writes the synced `package.json`, writes the merged `bun.lock`, runs `bun install`,
  * and then compares the result with the nested checkout and with the original host resolutions.
+ * When `bun install` fails or the result differs, restores both files before it throws or returns,
+ * so that the next sync starts from the original host resolutions.
+ * Throws an error that says so when it cannot restore them.
  */
 export declare function syncNestedWorkspace(root: string, options?: SyncOptions): Promise<SyncResult>;
 export type { CheckResult, DependencyMismatch, Lockfile, ManifestDifference, ManifestSync, NestedWorkspace, NestedWorkspaceConfig, OverriddenEntry, PackageManifest, PackageMismatch, ResolvedConfig, SyncOptions, SyncResult, SyncedEntries, SyncedField, WorkspacesConfig };

package/dist/index.mjs

@@ -1 +1 @@
-export { t as BunInstallError, d as applyManifestToLockfile, n as checkNestedWorkspace, g as diffManifests, o as findDirectDependencyMismatches, s as findOwnDependencyChanges, c as findTransitiveMismatches, l as findUncoveredWorkspaces, u as findWorkspaceMismatches, r as isInSync, i as loadNestedWorkspace, f as mergeLockfiles, p as parseLockfile, m as relocateLockfile, h as supportedLockfileVersions, _ as syncManifest, a as syncNestedWorkspace, v as syncedFields } from "./workspace-BzA7ccrb.mjs";
+export { t as BunInstallError, p as applyManifestToLockfile, n as checkNestedWorkspace, v as diffManifests, c as findDirectDependencyMismatches, l as findOwnDependencyChanges, u as findTransitiveMismatches, d as findUncoveredWorkspaces, f as findWorkspaceMismatches, i as isInSync, o as loadNestedWorkspace, m as mergeLockfiles, h as parseLockfile, g as relocateLockfile, _ as supportedLockfileVersions, y as syncManifest, s as syncNestedWorkspace, b as syncedFields } from "./workspace-DOwKm8pX.mjs";

package/dist/{workspace-BzA7ccrb.mjs → workspace-DOwKm8pX.mjs}

@@ -1,6 +1,6 @@
+import path from "node:path";
 import JSON5 from "json5";
 import semver from "semver";
-import path from "node:path";
 // ../lockfile/src/parse.ts
 function isObject(value) {
 	return typeof value === "object" && value !== null;
@@ -557,7 +557,9 @@ function applyManifestToLockfile(lock, manifest) {
 * A root entry overridden by the nested lockfile might not satisfy a dependency of a host package:
 * such a dependency gets back its previous host resolution as a nested entry, so `bun install` keeps the host version
 * instead of resolving the range again.
-* A host workspace without a name cannot have nested entries, so `bun install` resolves its dependency again.
+* A dependency of the host root package gets it back at the top level instead, as `keepHostRootResolutions` describes.
+* A host workspace other than the root without a name cannot have nested entries,
+* so `bun install` resolves its dependency again.
 * When the previous host resolution does not satisfy the range either, which Bun lockfiles occasionally contain,
 * the dependency gets the highest satisfying version recorded in either lockfile.
 * Catalog dependencies are checked against the catalogs of the host lockfile, so apply the synced root fields
@@ -571,16 +573,16 @@ function mergeLockfiles(lock, nestedLock, dir) {
 		...nestedLock.packages
 	};
 	const hostWorkspaces = Object.entries(lock.workspaces).filter(([workspacePath]) => !isNestedPath(workspacePath, dir));
-	const dependents = [...hostWorkspaces.map(([, workspace]) => ({
+	if (lock.workspaces[""]) keepHostRootResolutions(lock, nestedLock, packages);
+	const dependents = [...hostWorkspaces.flatMap(([workspacePath, workspace]) => workspacePath && workspace.name ? [{
 		key: workspace.name,
 		dependencies: getWorkspaceDependencies(workspace)
-	})), ...Object.keys(packages).map((key) => ({
+	}] : []), ...Object.keys(packages).map((key) => ({
 		key,
 		dependencies: getPackageDependencies(packages[key])
 	}))];
 	for (let index = 0; index < dependents.length; index++) {
 		const { key, dependencies } = dependents[index];
-		if (key === void 0) continue;
 		for (const [dependency, specifier] of Object.entries(dependencies)) {
 			const requirement = getRequirement(lock, dependency, specifier);
 			const resolved = resolveDependencyLockKey(key, dependency, packages);
@@ -606,6 +608,63 @@ function mergeLockfiles(lock, nestedLock, dir) {
 		packages
 	};
 }
+/**
+* Gives the dependencies of the host root package back their previous host resolutions where top-level nested
+* entries do not satisfy them.
+*
+* Bun resolves the dependencies of the root package at the top level only, so placing the host resolution under the
+* root name does not pin the root dependency: the host resolution returns to the top level with its host chain instead.
+* Then every dependency of a nested workspace or package that no longer resolves to its nested entry or a copy of it,
+* such as one that resolved the replaced entry, gets a copy of its nested entry under the dependent,
+* so the copied entries keep their whole nested dependency trees.
+*/
+function keepHostRootResolutions(lock, nestedLock, packages) {
+	const replaced = /* @__PURE__ */ new Set();
+	for (const [dependency, specifier] of Object.entries(getWorkspaceDependencies(lock.workspaces[""]))) {
+		const requirement = getRequirement(lock, dependency, specifier);
+		const nestedEntry = Object.hasOwn(nestedLock.packages, dependency) ? nestedLock.packages[dependency] : void 0;
+		if (!requirement || !nestedEntry || satisfies(nestedEntry, requirement)) continue;
+		const previous = Object.hasOwn(lock.packages, dependency) ? lock.packages[dependency] : void 0;
+		const replacement = previous && satisfies(previous, requirement) ? previous : findSatisfyingEntry([nestedLock.packages, lock.packages], requirement);
+		if (!replacement) continue;
+		replaced.add(dependency);
+		const prefix = `${dependency}/`;
+		for (const key of Object.keys(packages)) if (key.startsWith(prefix)) delete packages[key];
+		packages[dependency] = replacement;
+		if (replacement === previous) {
+			for (const [key, entry] of Object.entries(lock.packages)) if (key.startsWith(prefix)) packages[key] = entry;
+		}
+	}
+	if (!replaced.size) return;
+	const nestedKeys = new Map(Object.keys(nestedLock.packages).filter((key) => !replaced.has(splitPackageKey(key)[0])).map((key) => [key, key]));
+	const queue = [...Object.values(nestedLock.workspaces).flatMap((workspace) => workspace.name ? [{
+		key: workspace.name,
+		nestedKey: workspace.name,
+		dependencies: getWorkspaceDependencies(workspace)
+	}] : []), ...[...nestedKeys.keys()].map((key) => ({
+		key,
+		nestedKey: key,
+		dependencies: getPackageDependencies(nestedLock.packages[key])
+	}))];
+	for (let index = 0; index < queue.length; index++) {
+		const { key, nestedKey, dependencies } = queue[index];
+		for (const dependency of Object.keys(dependencies)) {
+			const expected = resolveDependencyLockKey(nestedKey, dependency, nestedLock.packages);
+			if (expected === void 0) continue;
+			const actual = resolveDependencyLockKey(key, dependency, packages);
+			if (actual !== void 0 && nestedKeys.get(actual) === expected) continue;
+			const entry = nestedLock.packages[expected];
+			const pinnedKey = `${key}/${dependency}`;
+			packages[pinnedKey] = entry;
+			nestedKeys.set(pinnedKey, expected);
+			queue.push({
+				key: pinnedKey,
+				nestedKey: expected,
+				dependencies: getPackageDependencies(entry)
+			});
+		}
+	}
+}
 /** Returns the installed dependencies declared by a lockfile workspace. */
 function getWorkspaceDependencies(workspace) {
 	return {
@@ -683,12 +742,40 @@ function resolveDependency(lock, workspaceName, dependency) {
 	return key === void 0 ? void 0 : lock.packages[key][0];
 }
 // src/check.ts
+/** Returns the `workspaces` patterns of a root `package.json`. */
+function getWorkspacePatterns(manifest) {
+	const patterns = (Array.isArray(manifest.workspaces) ? manifest.workspaces : manifest.workspaces?.packages ?? []).map((pattern) => pattern.replace(/^(!?)\.\//, "$1").replace(/\/+$/, ""));
+	return {
+		included: patterns.filter((pattern) => !pattern.startsWith("!")),
+		excluded: patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1))
+	};
+}
+/**
+* Returns whether the patterns include a directory relative to their root, as `bun install` decides it.
+*
+* The root itself is never included.
+* A pattern without glob syntax includes its exact path regardless of exclusions.
+* A glob pattern matches the `package.json` path of the directory, so `dir/**` includes `dir` itself,
+* and skips `node_modules`, `.git`, and `CMakeFiles` directories.
+* An exclusion `dir/**` also excludes `dir` itself.
+*/
+function matchesWorkspacePatterns(patterns, dir) {
+	const isGlob = (pattern) => /[*?[\]{}]/.test(pattern);
+	const matches = (pattern) => new Bun.Glob(pattern).match(dir);
+	const matchesManifest = (pattern) => new Bun.Glob(path.posix.join(pattern, "package.json")).match(path.posix.join(dir, "package.json"));
+	if (path.posix.normalize(dir) === ".") return false;
+	if (patterns.included.some((pattern) => !isGlob(pattern) && path.posix.normalize(pattern) === dir)) return true;
+	return !dir.split("/").some((part) => ignoredGlobDirs.has(part)) && patterns.included.some((pattern) => isGlob(pattern) && matchesManifest(pattern)) && !patterns.excluded.some((pattern) => matches(pattern) || pattern.endsWith("/**") && matches(pattern.slice(0, -3)));
+}
+const ignoredGlobDirs = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	"CMakeFiles"
+]);
 /** Returns the nested workspace paths that the host `workspaces` patterns do not include. */
 function findUncoveredWorkspaces(manifest, nestedLock) {
-	const patterns = (Array.isArray(manifest.workspaces) ? manifest.workspaces : manifest.workspaces?.packages ?? []).map((pattern) => pattern.replace(/^(!?)\.\//, "$1").replace(/\/+$/, ""));
-	const included = patterns.filter((pattern) => !pattern.startsWith("!")).map((pattern) => new Bun.Glob(pattern));
-	const excluded = patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => new Bun.Glob(pattern.slice(1)));
-	return Object.keys(nestedLock.workspaces).filter((workspacePath) => !included.some((glob) => glob.match(workspacePath)) || excluded.some((glob) => glob.match(workspacePath)));
+	const patterns = getWorkspacePatterns(manifest);
+	return Object.keys(nestedLock.workspaces).filter((workspacePath) => !matchesWorkspacePatterns(patterns, workspacePath));
 }
 /**
 * Returns the paths of nested workspaces whose host lockfile entries differ from the relocated nested lockfile,
@@ -832,6 +919,33 @@ async function loadNestedWorkspace(root) {
 		nestedLock: relocateLockfile(await readLockfile(path.join(nestedRoot, "bun.lock")), config.dir, typeof nestedManifest.name === "string" ? nestedManifest.name : void 0)
 	};
 }
+/**
+* Returns whether a workspace path of the host lockfile is a workspace of the nested repository:
+* its root, a workspace of the nested lockfile, or a directory that the nested `workspaces` patterns include.
+*/
+function isNestedWorkspace(workspace, workspacePath) {
+	const { dir } = workspace.config;
+	return workspacePath === dir || workspacePath in workspace.nestedLock.workspaces || isNestedPath(workspacePath, dir) && matchesWorkspacePatterns(getWorkspacePatterns(workspace.nestedManifest), workspacePath.slice(dir.length + 1));
+}
+/**
+* Returns the first directory with a named package that the nested `workspaces` patterns include, relative to the host root.
+*
+* `bun install` treats the nested root as the workspace root there and writes the nested lockfile,
+* while in the nested root itself it writes the host lockfile.
+*/
+async function findNestedPackageDir(workspace) {
+	const nestedRoot = path.join(workspace.root, workspace.config.dir);
+	const patterns = getWorkspacePatterns(workspace.nestedManifest);
+	const dirs = /* @__PURE__ */ new Set();
+	for (const pattern of patterns.included) for await (const file of new Bun.Glob(`${pattern}/package.json`).scan(nestedRoot)) {
+		const dir = path.posix.normalize(path.posix.dirname(file.split(path.sep).join("/")));
+		if (matchesWorkspacePatterns(patterns, dir)) dirs.add(dir);
+	}
+	for (const dir of [...dirs].sort()) {
+		const manifest = await Bun.file(path.join(nestedRoot, dir, "package.json")).json();
+		if (typeof manifest.name === "string" && manifest.name) return `${workspace.config.dir}/${dir}`;
+	}
+}
 /** Returns whether a check found no differences. */
 function isInSync(result) {
 	return Object.values(result).every((list) => !list.length);
@@ -892,6 +1006,9 @@ async function runBunInstall(root, args = []) {
 *
 * Writes the synced `package.json`, writes the merged `bun.lock`, runs `bun install`,
 * and then compares the result with the nested checkout and with the original host resolutions.
+* When `bun install` fails or the result differs, restores both files before it throws or returns,
+* so that the next sync starts from the original host resolutions.
+* Throws an error that says so when it cannot restore them.
 */
 async function syncNestedWorkspace(root, options = {}) {
 	const workspace = await loadNestedWorkspace(root);
@@ -899,20 +1016,56 @@ async function syncNestedWorkspace(root, options = {}) {
 	const manifestSync = syncManifest(workspace.manifest, workspace.nestedManifest);
 	const { manifest } = manifestSync;
 	const merged = mergeLockfiles(applyManifestToLockfile(workspace.lock, manifest), workspace.nestedLock, workspace.config.dir);
-	const manifestText = formatJson(manifest, workspace.manifestText);
-	if (manifestText !== workspace.manifestText) await Bun.write(path.join(root, "package.json"), manifestText);
-	options.onManifestSync?.(manifestSync);
-	await Bun.write(path.join(root, "bun.lock"), renderBunLock(merged));
-	await runBunInstall(root, options.installArgs);
-	const synced = await loadNestedWorkspace(root);
-	return {
-		ownDependencyChanges: findOwnDependencyChanges(workspace.lock, synced.lock, workspace.nestedLock, workspace.config.dir),
-		check: checkNestedWorkspace(synced)
+	const manifestPath = path.join(root, "package.json");
+	const lockPath = path.join(root, "bun.lock");
+	const originals = /* @__PURE__ */ new Map([[manifestPath, workspace.manifestText], [lockPath, await Bun.file(lockPath).text()]]);
+	const restore = async () => {
+		const failures = await restoreFiles(originals);
+		if (failures.length) throw new Error([
+			"The sync failed and could not restore the host files:",
+			...failures.map(({ file, error }) => `  ${path.basename(file)}: ${getErrorMessage(error)}`),
+			"Restore them before running the sync again."
+		].join("\n"));
 	};
+	let result;
+	try {
+		const manifestText = formatJson(manifest, workspace.manifestText);
+		if (manifestText !== workspace.manifestText) await Bun.write(manifestPath, manifestText);
+		options.onManifestSync?.(manifestSync);
+		await Bun.write(lockPath, renderBunLock(merged));
+		await runBunInstall(root, options.installArgs);
+		const synced = await loadNestedWorkspace(root);
+		result = {
+			ownDependencyChanges: findOwnDependencyChanges(workspace.lock, synced.lock, workspace.nestedLock, workspace.config.dir),
+			check: checkNestedWorkspace(synced)
+		};
+	} catch (error) {
+		await restore();
+		throw error;
+	}
+	if (result.ownDependencyChanges.length || !isInSync(result.check)) await restore();
+	return result;
+}
+/**
+* Writes back the original texts of files whose contents differ from them and returns the files it could not restore.
+*
+* Restores each file separately, so that a failure does not keep the other files changed.
+*/
+async function restoreFiles(originals) {
+	const failures = [];
+	for (const [file, text] of originals) try {
+		if (await Bun.file(file).text().catch(() => void 0) !== text) await Bun.write(file, text);
+	} catch (error) {
+		failures.push({
+			file,
+			error
+		});
+	}
+	return failures;
 }
 /** Serializes JSON with the indentation and final newline of the original text. */
 function formatJson(value, original) {
 	const indent = /^[ \t]+(?=")/m.exec(original)?.[0] ?? "  ";
 	return `${JSON.stringify(value, null, indent)}${original.endsWith("\n") ? "\n" : ""}`;
 }
-export { syncManifest as _, syncNestedWorkspace as a, findTransitiveMismatches as c, applyManifestToLockfile as d, mergeLockfiles as f, diffManifests as g, supportedLockfileVersions as h, loadNestedWorkspace as i, findUncoveredWorkspaces as l, relocateLockfile as m, checkNestedWorkspace as n, findDirectDependencyMismatches as o, parseLockfile as p, isInSync as r, findOwnDependencyChanges as s, BunInstallError as t, findWorkspaceMismatches as u, syncedFields as v, getErrorMessage as y };
+export { supportedLockfileVersions as _, isNestedWorkspace as a, syncedFields as b, findDirectDependencyMismatches as c, findUncoveredWorkspaces as d, findWorkspaceMismatches as f, relocateLockfile as g, parseLockfile as h, isInSync as i, findOwnDependencyChanges as l, mergeLockfiles as m, checkNestedWorkspace as n, loadNestedWorkspace as o, applyManifestToLockfile as p, findNestedPackageDir as r, syncNestedWorkspace as s, BunInstallError as t, findTransitiveMismatches as u, diffManifests as v, getErrorMessage as x, syncManifest as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-nested-workspace",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Embed a checkout of another Bun workspace repository into a Bun workspace and keep the root package.json and bun.lock in sync with it",
   "keywords": [
     "bun",