@vzn/vx 0.0.243 → 0.0.244

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.243",
+  "version": "0.0.244",
   "description": "A fast, correct task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.243",
-    "@vzn/vx-linux-arm64": "0.0.243",
-    "@vzn/vx-darwin-x64": "0.0.243",
-    "@vzn/vx-darwin-arm64": "0.0.243"
+    "@vzn/vx-linux-x64": "0.0.244",
+    "@vzn/vx-linux-arm64": "0.0.244",
+    "@vzn/vx-darwin-x64": "0.0.244",
+    "@vzn/vx-darwin-arm64": "0.0.244"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/workspace/affected.ts

@@ -21,7 +21,7 @@ import { LOCKFILE_NAME } from './lockfile.js'
 import { configImportOwners } from './config-imports.js'
 import { configImports } from './config-cache.js'
 import { WORKSPACE_CONFIG_FILENAMES } from './project-loader.js'
-import { WORKSPACE_FINGERPRINT_FILES } from './fingerprint.js'
+import { bunPatchFiles, WORKSPACE_FINGERPRINT_FILES } from './fingerprint.js'
 import { buildPackageGraph } from './package-graph.js'
 import type { PackageJson, ProjectMeta } from './workspace.js'
 
@@ -212,6 +212,16 @@ export async function affectedProjects(args: AffectedArgs): Promise<Set<string>>
     return new Set(args.projects.map((p) => p.name))
   }
   const fingerprintChanged = changed.filter((p) => FINGERPRINT_SET.has(p))
+  // A patch bun.lock names folds into every key, core's fingerprint and
+  // `bun()`'s claim alike, so its edit widens as a lockfile edit does. A
+  // patch the lockfile no longer names moved bun.lock itself.
+  if (changed.length > 0) {
+    const lock = await bytesOrNull(path.join(args.workspaceRoot, 'bun.lock'))
+    if (lock !== null) {
+      const patches = new Set(bunPatchFiles(lock))
+      if (changed.some((p) => patches.has(p))) return new Set(args.projects.map((p) => p.name))
+    }
+  }
   const claimedOwned = new Set<string>()
   // A claim may also name a root file core does not fold (`turbo.json`,
   // read by `turbo()`'s stages): it re-keys tasks through their resolved

package/src/workspace/fingerprint.ts

@@ -106,9 +106,54 @@ export async function computeWorkspaceFingerprints(
     unclaimed = xxh3(`${f}\0`, unclaimed)
     unclaimed = xxh3(bytes, unclaimed)
   }
+  // bun.lock names a patch by PATH, never by its content: an edited patch
+  // left the lockfile byte-identical and every key unmoved while the
+  // install applied the new one (item 1014, where only `bun()`'s claim
+  // learned it). Each file it names folds here; a claimed bun.lock's
+  // plugin folds them itself.
+  const bunLock = files.get('bun.lock')
+  if (bunLock !== undefined) {
+    for (const rel of bunPatchFiles(bunLock)) {
+      const bytes = await readOnce(reads, path.join(workspaceRoot, rel))
+      const mark = `patch\0${rel}\0${bytes === null ? 'gone' : 'present'}`
+      all = xxh3(mark, all)
+      if (bytes !== null) all = xxh3(bytes, all)
+      if (claimed.has('bun.lock')) continue
+      unclaimed = xxh3(mark, unclaimed)
+      if (bytes !== null) unclaimed = xxh3(bytes, unclaimed)
+    }
+  }
   return { all: hex(all), unclaimed: hex(unclaimed), files }
 }
 
+const PATCHED = new TextEncoder().encode('"patchedDependencies"')
+
+/**
+ * The workspace-relative patch files a `bun.lock` names, sorted; none
+ * outside the workspace. A lockfile without the key is not parsed (the
+ * common case costs one byte search), and one that will not parse names
+ * none: its bytes still fold whole.
+ */
+export function bunPatchFiles(bytes: Uint8Array): string[] {
+  if (Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).indexOf(PATCHED) < 0) return []
+  let doc: unknown
+  try {
+    doc = Bun.JSONC.parse(new TextDecoder().decode(bytes))
+  } catch {
+    return []
+  }
+  const patched = (doc as { patchedDependencies?: unknown } | null)?.patchedDependencies
+  if (patched === null || typeof patched !== 'object') return []
+  const out = new Set<string>()
+  for (const v of Object.values(patched)) {
+    if (typeof v !== 'string') continue
+    const rel = path.posix.normalize(v.split(path.sep).join('/'))
+    if (rel.startsWith('../') || rel === '..' || path.posix.isAbsolute(rel)) continue
+    out.add(rel)
+  }
+  return [...out].sort()
+}
+
 function hex(h: bigint): string {
   return h.toString(16).padStart(16, '0')
 }