@vzn/vx 0.0.594 → 0.0.595

package/src/orchestrator/plan.ts

@@ -13,7 +13,13 @@
 
 import type { CacheLayer, CachePolicy, GitFilesCache } from '../cache/index.js'
 import { FULL_CACHE_POLICY } from '../cache/index.js'
-import { isGroupTask, runGraph, type TaskNode, type TaskOutcome } from '../graph/index.js'
+import {
+  idleServers,
+  isGroupTask,
+  runGraph,
+  type TaskNode,
+  type TaskOutcome,
+} from '../graph/index.js'
 import type { HistoryProvider } from './history.js'
 import { computeGroupKey, computeTaskHash } from './task-hash.js'
 import { keyUpstream } from './upstream.js'
@@ -24,6 +30,7 @@ export type CacheStatus =
   | 'miss' // caching enabled but no entry — would execute
   | 'no-cache' // task opts out of caching (no `cache` block) or --no-cache
   | 'group' // no `exec`; just an aggregator
+  | 'not-started' // a server every dependant of which restores early: the run never spawns it
 
 export interface PlannedTask {
   node: TaskNode
@@ -108,6 +115,12 @@ export interface PlanArgs {
   history?: HistoryProvider
   /** Placement lookup (`placement.ts`): >1 executor declared, or a `noop` task. */
   executorOf?: (id: string) => string | undefined
+  /**
+   * The tasks the run's short-circuit would restore ahead of their deps on
+   * a local hit (stable key, no workspace-output reach). A server whose
+   * every dependant is one of those and a local hit is never spawned.
+   */
+  restorable?: ReadonlySet<string>
 }
 
 /**
@@ -171,6 +184,17 @@ export async function plan(args: PlanArgs): Promise<RunPlan> {
     },
   })
 
+  if (args.restorable !== undefined) {
+    const restoreTier = new Set(
+      [...args.restorable].filter((id) => cacheStatusById.get(id) === 'hit-local'),
+    )
+    const dependents = new Map<string, string[]>()
+    for (const node of args.nodes.values())
+      for (const dep of node.deps) dependents.set(dep, [...(dependents.get(dep) ?? []), node.id])
+    for (const id of idleServers(args.nodes, dependents, restoreTier))
+      cacheStatusById.set(id, 'not-started')
+  }
+
   const tasks: PlannedTask[] = []
   for (const id of args.nodes.keys()) {
     const o = outcomes.get(id)

package/src/orchestrator/plugin-host.ts

@@ -107,6 +107,25 @@ export function hasHook(
   return false
 }
 
+/**
+ * An in-place stage reads nothing a hook returns: Vite's `config` hook
+ * returns a partial config, and one written that way here loaded, changed
+ * nothing and said nothing. Returning the object it was handed is harmless.
+ */
+function assertEditedInPlace(
+  plugin: VxPlugin,
+  hook: 'config' | 'project' | 'graph',
+  returned: unknown,
+  edited: unknown,
+  what: string,
+): void {
+  if (returned === undefined || returned === edited) return
+  throw new UserError(
+    `plugin '${plugin.name}' failed in ${hook}: returned ${describeValue(returned)}, which core ` +
+      `ignores — edit ${what} in place`,
+  )
+}
+
 /** `config` stage: every plugin edits the workspace config in place. */
 export async function applyConfigHooks(
   plugins: readonly VxPlugin[],
@@ -117,7 +136,8 @@ export async function applyConfigHooks(
 ): Promise<void> {
   for (const plugin of plugins) {
     if (plugin.config === undefined) continue
-    await safe(plugin, 'config', () => plugin.config!(workspace, ctx))
+    const returned = await safe(plugin, 'config', () => plugin.config!(workspace, ctx))
+    assertEditedInPlace(plugin, 'config', returned, workspace, 'the workspace config')
     afterEach?.(plugin)
   }
 }
@@ -158,7 +178,8 @@ export async function applyProjectHooks(
 ): Promise<void> {
   for (const plugin of plugins) {
     if (plugin.project === undefined) continue
-    await safe(plugin, 'project', () => plugin.project!(config, ctx))
+    const returned = await safe(plugin, 'project', () => plugin.project!(config, ctx))
+    assertEditedInPlace(plugin, 'project', returned, config, "the project's config")
     afterEach?.(plugin)
   }
 }
@@ -184,7 +205,8 @@ export async function applyGraphHooks(
   let last: VxPlugin | undefined
   for (const plugin of plugins) {
     if (plugin.graph === undefined) continue
-    await safe(plugin, 'graph', () => plugin.graph!(nodes, ctx))
+    const returned = await safe(plugin, 'graph', () => plugin.graph!(nodes, ctx))
+    assertEditedInPlace(plugin, 'graph', returned, nodes, 'the task graph')
     await safe(plugin, 'graph', () => checkNodeShapes(nodes))
     afterEach?.(plugin)
     last = plugin

package/src/orchestrator/plugin.ts

@@ -440,7 +440,8 @@ function pluginPackageName(dir: string): string {
   for (let d = dir; ;) {
     let text: string | undefined
     try {
-      text = readFileSync(path.join(d, 'package.json'), 'utf8')
+      // A byte-order mark is stripped, as npm, Node and discovery strip it.
+      text = readFileSync(path.join(d, 'package.json'), 'utf8').replace(/^\uFEFF/, '')
     } catch {
       /* not here; look one level up */
     }

package/src/orchestrator/run.ts

@@ -87,8 +87,12 @@ import {
   detectCi,
 } from './run-context.js'
 import { startRemotePrefetch } from './remote-prefetch.js'
-import { startLocalShortCircuit, type ShortCircuit } from './local-shortcircuit.js'
-import { probesAfterWrites } from './stable-keys.js'
+import {
+  restoreTierExclusions,
+  startLocalShortCircuit,
+  type ShortCircuit,
+} from './local-shortcircuit.js'
+import { deriveStableKeys, probesAfterWrites } from './stable-keys.js'
 
 import { assembleRunRecords } from './run-records.js'
 import { hasEnded, selectKeepAlive, shutdownPersistent } from './persistent.js'
@@ -1086,8 +1090,6 @@ async function runOnBus(
     ).filter((c) => endedBeforeStop?.has(persistentRegistry.get(c.id)!) ?? true)
 
     mark('run graph')
-    // Clear the status line for good before the summary prints.
-    log.runEnd?.()
 
     // A server that died on its own before the stop failed, whatever its
     // outcome said when it became ready: the footer counted it a success
@@ -1097,8 +1099,11 @@ async function runOnBus(
     const failServer = (id: string, code: number | string): void => {
       const o = outcomes.get(id)
       if (o === undefined) return
-      const exitCode = typeof code === 'number' ? code : signalExitCode(code)
-      outcomes.set(id, { ...o, status: 'failed', exitCode })
+      // In place: the renderer holds this outcome (events carry live refs)
+      // and closes the server's output block from it at runEnd, where a
+      // copy left it reading `running` under its exit line (WD-10).
+      o.status = 'failed'
+      o.exitCode = typeof code === 'number' ? code : signalExitCode(code)
     }
     for (const c of crashedPersistent) failServer(c.id, c.code)
     keepAlive.nodes.forEach((n, i) => {
@@ -1107,6 +1112,8 @@ async function runOnBus(
       if (endedBeforeStop !== undefined && !endedBeforeStop.has(child)) return
       failServer(n.id, child.exitCode ?? child.signalCode ?? 'unknown')
     })
+    // Clear the status line for good before the summary prints.
+    log.runEnd?.()
     const list = [...outcomes.values()]
     const ok = list.every((o) => isPassStatus(o.status))
 
@@ -1396,7 +1403,9 @@ async function runOnBus(
         })
       })
       const node = keepAlive.nodes[first.i]!
-      const others = keepAlive.nodes.length - 1
+      // Only the ones still up are stopped: a kept server already dead was
+      // counted as one (WD-11).
+      const others = keepAlive.children.filter((c, j) => j !== first.i && !hasEnded(c)).length
       // Not when the run was stopped: the server ended because the user
       // stopped it, and "exited with code 130" read as a crash after every
       // Ctrl-C once a stop let run() finish its own path (item 852).
@@ -1526,12 +1535,13 @@ export async function planRun(options: RunOptions): Promise<RunPlan> {
     // Its own mark: a dry run's plan (every task's hash, the cache lookups,
     // the history p50s) was booked under `close`, the next mark, and read
     // as 105 ms of closing a cache at 1,000 projects (item 601).
+    const policy = effectiveCachePolicy(prepared.cachePolicy, prepared.hasRemoteLayer)
     const planned = await plan({
       nodes: prepared.nodes,
       workspaceRoot: prepared.workspaceRoot,
       workspaceFingerprint: prepared.workspaceFingerprint,
       cache: prepared.cache,
-      cachePolicy: effectiveCachePolicy(prepared.cachePolicy, prepared.hasRemoteLayer),
+      cachePolicy: policy,
       forwardArgs: options.forwardArgs,
       nestedDirsByProject: prepared.nestedDirsByProject,
       gitFilesCache: prepared.gitFilesCache,
@@ -1548,6 +1558,7 @@ export async function planRun(options: RunOptions): Promise<RunPlan> {
       // the same plugin-factory call `prepareRun` already makes for the
       // cache capability, so plan mode gains no new class of side effect.
       ...(await planExecutorOf(prepared, log, options.download ?? 'all')),
+      ...(await planRestorable(prepared, policy, options.forwardArgs)),
     })
     mark('plan')
     return planned
@@ -1564,6 +1575,39 @@ export async function planRun(options: RunOptions): Promise<RunPlan> {
   }
 }
 
+/**
+ * What the run's short-circuit would restore ahead of its deps, so the plan
+ * can tell a server nobody needs from one that starts: `--dry` called a
+ * server every dependant of which was a local hit `would exec`, and the run
+ * never spawned it. The run's own gates (`shouldShortCircuit`, stable keys,
+ * workspace-output reach), asked only when a server could idle.
+ */
+async function planRestorable(
+  prepared: PreparedRun,
+  policy: CachePolicy,
+  forwardArgs: readonly string[] | undefined,
+): Promise<{ restorable?: Set<string> }> {
+  const { nodes } = prepared
+  const serves = [...nodes.values()].some(
+    (n) => n.config.exec?.persistent !== undefined && !n.requested && n.surfaced !== true,
+  )
+  if (!serves || !shouldShortCircuit(nodes, policy, prepared.cache)) return {}
+  const keptOut = restoreTierExclusions(nodes, prepared.workspaceRoot)
+  const stable = await deriveStableKeys({
+    nodes,
+    cache: prepared.cache,
+    workspaceRoot: prepared.workspaceRoot,
+    workspaceFingerprint: prepared.workspaceFingerprint,
+    forwardArgs,
+    nestedDirsByProject: prepared.nestedDirsByProject,
+    gitFilesCache: prepared.gitFilesCache,
+    hashCache: prepared.hashCache,
+  })
+  return {
+    restorable: new Set(stable.map((k) => k.node.id).filter((id) => !keptOut.has(id))),
+  }
+}
+
 /** The names a project outside the run's selection declares, and how to reach them. */
 function elsewhereHint(names: readonly string[]): string {
   if (names.length === 0) return ''

package/src/orchestrator/signals.ts

@@ -14,7 +14,7 @@
 // them to the runner around every spawn.
 
 import { signalExitCode } from '../exec/index.js'
-import { killGraceMs, settleWithin } from '../util/index.js'
+import { claimExitForSignal, killGraceMs, settleWithin } from '../util/index.js'
 import { holdGroups, killTree, untilGroupsGone } from '../exec/index.js'
 import type { Logger } from './logger.js'
 
@@ -69,7 +69,9 @@ export async function terminateChildren(
   signal: ForwardedSignal = 'SIGTERM',
   graceMs: number = killGraceMs(SIGNAL_SHUTDOWN_GRACE_MS),
 ): Promise<void> {
-  const children = live()
+  // A ready server is in both of run()'s lists: signalled twice, it read
+  // the second as a repeated Ctrl-C (force quit).
+  const children = [...new Set(live())]
   // On the group guard's list until the sweep below is done: a shell that
   // dies on the signal lets its group go while what it forked runs out
   // the grace (kill-tree.ts, `holdGroups`).
@@ -131,6 +133,7 @@ export function forwardSignals(args: {
     // that ended the run.
     if (stopping !== undefined) exit(stopping)
     stopping = signal
+    claimExitForSignal()
     // Clear the live worker/status region BEFORE exiting so a TTY isn't
     // left with a frozen region in the scrollback. runEnd is idempotent
     // and a no-op for non-TTY loggers.

package/src/orchestrator/summary.ts

@@ -119,6 +119,8 @@ export interface SummaryStats {
   spread: { maxMs: number; minMs: number; sumMs: number; count: number } | null
   /** Tasks an `admit` policy held with a worker free, and the waits summed. Absent with no hold. */
   held?: { count: number; sumMs: number }
+  /** A run of groups only: their names, so `0 tasks` says why. */
+  emptyGroups?: readonly string[]
 }
 
 /**
@@ -213,7 +215,14 @@ export function formatSummarySection(
     // No legend line until the first bucket lands (live: all-gray bar).
     if (taskParts.length > 0) lines.push(legend(taskParts))
   } else {
-    lines.push(row('tasks', dim('0 tasks')))
+    const groups = stats.emptyGroups ?? []
+    // `vx run build` where no project gives build a command runs the default
+    // group alone: say so, or it reads like a selection that matched nothing.
+    const why =
+      groups.length > 0
+        ? ` ${dim('\u00b7')} ${dim(`${groups.join(', ')} ${groups.length === 1 ? 'has' : 'have'} no command in these projects`)}`
+        : ''
+    lines.push(row('tasks', dim('0 tasks') + why))
     // A stop before any task finished still names what it took down.
     if (taskParts.length > 0) lines.push(legend(taskParts))
   }
@@ -368,6 +377,9 @@ export function formatRunSummary(
     .map((o) => o.durationMs)
   const heldOutcomes = outcomes.filter((o) => o.admissionHeldMs !== undefined)
   const notRun = outcomes.filter((o) => neverStarted(o) && !isGroupTask(o.node)).length
+  const emptyGroups = outcomes.every((o) => isGroupTask(o.node))
+    ? [...new Set(outcomes.map((o) => o.node.taskName))]
+    : []
   return formatSummarySection(
     {
       failed: t.failed,
@@ -398,6 +410,7 @@ export function formatRunSummary(
             },
           }
         : {}),
+      ...(emptyGroups.length > 0 ? { emptyGroups } : {}),
     },
     totalMs,
     colors,

package/src/util/index.ts

@@ -49,7 +49,13 @@ export {
   wholeSubtreePrefixes,
   slashBraceExpansions,
 } from './paths.js'
-export { killGraceMs, settleWithin, teardownTimeoutMs } from './settle.js'
+export {
+  claimExitForSignal,
+  exitClaimedBySignal,
+  killGraceMs,
+  settleWithin,
+  teardownTimeoutMs,
+} from './settle.js'
 export { formatBytes, parseDuration, parseSize } from './size.js'
 export {
   cgroupCpuQuota,

package/src/util/secret-mask.ts

@@ -49,6 +49,13 @@ export interface SecretMask {
    * the next chunk or `end`.
    */
   stream(): { push(chunk: string): string; end(): string }
+  /**
+   * `mask` for the two sides of a cut, where the text between them is
+   * gone: a value the cut split leaves a piece at the end of `head` or the
+   * start of `tail` that no whole-value match sees, so each piece is
+   * masked too.
+   */
+  maskCut(head: string, tail: string): [string, string]
 }
 
 /**
@@ -103,8 +110,37 @@ export function secretMask(
     }
     return longest
   }
+  /** The longest head of `text` that is a proper suffix of a value. */
+  const partialHead = (text: string): number => {
+    let longest = 0
+    for (const v of sorted) {
+      for (let k = Math.min(v.length - 1, text.length); k > longest; k--) {
+        if (text.startsWith(v.slice(v.length - k))) {
+          longest = k
+          break
+        }
+      }
+    }
+    return longest
+  }
   return {
     mask,
+    maskCut(head, tail) {
+      let h = head.length - partialTail(head)
+      pattern.lastIndex = 0
+      for (let m = pattern.exec(head); m !== null; m = pattern.exec(head)) {
+        if (m.index < h && m.index + m[0].length > h) h = m.index
+      }
+      let t = partialHead(tail)
+      pattern.lastIndex = 0
+      for (let m = pattern.exec(tail); m !== null; m = pattern.exec(tail)) {
+        if (m.index < t && m.index + m[0].length > t) t = m.index + m[0].length
+      }
+      return [
+        mask(head.slice(0, h)) + (h < head.length ? MASKED : ''),
+        (t > 0 ? MASKED : '') + mask(tail.slice(t)),
+      ]
+    },
     stream() {
       let carry = ''
       return {

package/src/util/settle.ts

@@ -68,3 +68,18 @@ export async function settleWithin(p: Promise<unknown>, ms: number): Promise<boo
     void p.catch(() => {})
   }
 }
+
+// Who ends the process. bin.ts exits once its verb has settled and the
+// streams have ended; a signal's handler exits by itself, with the
+// signal's code, once the run it stopped is done. The verb settles first,
+// with the run's verdict (1), so bin.ts asks before it exits.
+let signalOwnsExit = false
+
+/** A signal's handler will end the process: bin.ts leaves the exit to it. */
+export function claimExitForSignal(): void {
+  signalOwnsExit = true
+}
+
+export function exitClaimedBySignal(): boolean {
+  return signalOwnsExit
+}

package/src/workspace/affected.ts

@@ -176,6 +176,14 @@ export async function affectedChanges(
         `("${since.slice(0, range) || 'HEAD'}"); vx diffs it against the working tree.`,
     )
   }
+  // `^main` is rev-list's exclusion, not a ref: merge-base refused it, it
+  // verified, and `git diff ^main` diffed from main itself, so changes
+  // only main made were selected (`^` is illegal in a ref name).
+  if (since.startsWith('^')) {
+    throw new UserError(
+      `git ref "${since}" is an exclusion, not a ref: pass the base alone ("${since.replace(/^\^+/, '') || 'HEAD'}").`,
+    )
+  }
   // Diff from the MERGE BASE of `since` and HEAD, not from `since` itself:
   // on a branch whose base has moved on, `git diff <base>` reports every
   // file OTHER people changed on the base (over-selection that defeats a
@@ -432,7 +440,17 @@ async function dependentsAtBase(
     ) {
       continue
     }
-    byDir.set(dir, { name: pkg.name, dir, packageJson: pkg, configPath: null })
+    // Today's catalogs, or both graphs would differ on every `catalog:`
+    // entry. A catalog edit is a `pnpm-workspace.yaml` or root manifest
+    // edit, which the fingerprint widening and the root's own change answer.
+    const catalogs = projects[0]?.catalogs
+    byDir.set(dir, {
+      name: pkg.name,
+      dir,
+      packageJson: pkg,
+      configPath: null,
+      ...(catalogs === undefined ? {} : { catalogs }),
+    })
     if (nameNow.get(dir) !== pkg.name) gone.add(pkg.name)
   }
   const now = buildPackageGraph([...projects])
@@ -468,8 +486,10 @@ function parentsOfNewNested(
   projects: readonly ProjectMeta[],
 ): Set<string> {
   const out = new Set<string>()
+  // Keyed NFC: macOS git reports paths NFC (core.precomposeunicode) while a
+  // dir discovered by readdir keeps the spelling it was created with.
   const dirToName = new Map<string, string>()
-  for (const p of projects) dirToName.set(p.dir, p.name)
+  for (const p of projects) dirToName.set(p.dir.normalize('NFC'), p.name)
   for (const [rel, bytes] of atBase) {
     const dir = path.resolve(workspaceRoot, path.posix.dirname(rel))
     if (!dirToName.has(dir)) continue
@@ -829,8 +849,10 @@ function projectsContaining(
   // O(files · path-depth) instead of O(files · projects): independent of the
   // project count, which is what a big --affected diff on a 1000-project repo
   // pays for.
+  // Keyed NFC: macOS git reports paths NFC (core.precomposeunicode) while a
+  // dir discovered by readdir keeps the spelling it was created with.
   const dirToName = new Map<string, string>()
-  for (const p of projects) dirToName.set(p.dir, p.name)
+  for (const p of projects) dirToName.set(p.dir.normalize('NFC'), p.name)
   // A member linked in from elsewhere in the tree (`pkgs/b -> ../ext/b`) is
   // indexed by its link, and git reports its files at their real place
   // (`ext/b/src/a.txt`), which resolved to no project: an edit there
@@ -841,18 +863,18 @@ function projectsContaining(
     const real = realDirs.get(p.dir) ?? p.dir
     const rel = path.relative(realRoot, real)
     if (rel.startsWith('..') || path.isAbsolute(rel)) continue
-    const spelled = path.resolve(workspaceRoot, rel)
-    if (spelled !== p.dir && !dirToName.has(spelled)) dirToName.set(spelled, p.name)
+    const spelled = path.resolve(workspaceRoot, rel).normalize('NFC')
+    if (!dirToName.has(spelled)) dirToName.set(spelled, p.name)
   }
   const owned = new Set<string>()
   for (const rel of changedRelPaths) {
-    let dir = path.resolve(workspaceRoot, rel)
+    let dir = path.resolve(workspaceRoot, rel).normalize('NFC')
     let hit = false
     for (;;) {
       const name = dirToName.get(dir)
       if (name !== undefined) {
         owned.add(name)
-        on?.path(name, relPosix(dir, path.resolve(workspaceRoot, rel)))
+        on?.path(name, relPosix(dir, path.resolve(workspaceRoot, rel).normalize('NFC')))
         hit = true
         break
       }
@@ -871,7 +893,7 @@ function projectsContaining(
     // this, `--affected` after an edit inside selected none of them.
     const abs = path.resolve(workspaceRoot, rel)
     if (isDirectory(abs)) {
-      const prefix = abs + path.sep
+      const prefix = abs.normalize('NFC') + path.sep
       for (const [dir, name] of dirToName) {
         if (!dir.startsWith(prefix)) continue
         owned.add(name)

package/src/workspace/config-cache.ts

@@ -409,6 +409,16 @@ function keySeed(workspaceFingerprint: string): bigint {
 
 const EXPLICIT_EXT = /\.(?:m?[jt]s|cjs|cts)$/
 
+/**
+ * A file's identity as the key folds it. `hashFile` names an executable
+ * `100755:<oid>`, the slow path's `hashBytes` the bare oid; the mode moves
+ * no evaluation, and with it the warm key of an executable config never
+ * met the stored one, so every load read and re-keyed it.
+ */
+function contentIdentity(identity: string): string {
+  return identity.startsWith('100755:') ? identity.slice(7) : identity
+}
+
 /**
  * The canonical directory Bun resolves `file`'s imports from: its REAL
  * path's, so a config linked in from elsewhere imports its neighbours
@@ -482,7 +492,7 @@ export async function configEvalKey(a: ConfigEvalKeyArgs): Promise<ConfigEvalKey
     const identity = a.hashBytes
       ? a.hashBytes(bytes, file)
       : a.hashFile
-        ? await a.hashFile(file)
+        ? contentIdentity(await a.hashFile(file))
         : await hashOf(file, bytes)
     h = xxh3(`${file}\0${identity}`, h)
     closure.push(file)
@@ -542,6 +552,14 @@ export async function configEvalKey(a: ConfigEvalKeyArgs): Promise<ConfigEvalKey
   return { key: h.toString(16).padStart(16, '0'), closure, indexable }
 }
 
+// `hashFile` names a symlink by its target string (git's mode 120000), not
+// the bytes the evaluation read, so no stored key can match a fold of it.
+// Only a linked config with no relative import is indexed at all; with no
+// warm key it joins the round lookup on its slow key instead of paying a
+// single lookup and an index rewrite per load. The identity is from the
+// lstat `hashFiles` already took: no syscall is added.
+const LINK_IDENTITY = '120000:'
+
 /**
  * The warm path: the key for a config whose ordered closure the store
  * remembers, from per-file identities alone — no read, no scan. The fold is
@@ -561,7 +579,10 @@ export async function configEvalKeyFromClosure(a: {
   } catch {
     return null
   }
-  for (let i = 0; i < a.closure.length; i++) h = xxh3(`${a.closure[i]}\0${identities[i]}`, h)
+  if (identities.some((id) => id.startsWith(LINK_IDENTITY))) return null
+  for (let i = 0; i < a.closure.length; i++) {
+    h = xxh3(`${a.closure[i]}\0${contentIdentity(identities[i]!)}`, h)
+  }
   return h.toString(16).padStart(16, '0')
 }
 
@@ -574,8 +595,8 @@ export function configEvalKeyFromIdentities(a: {
   let h = keySeed(a.workspaceFingerprint)
   for (const file of a.closure) {
     const id = a.identities.get(file)
-    if (id === undefined) return null
-    h = xxh3(`${file}\0${id}`, h)
+    if (id === undefined || id.startsWith(LINK_IDENTITY)) return null
+    h = xxh3(`${file}\0${contentIdentity(id)}`, h)
   }
   return h.toString(16).padStart(16, '0')
 }

package/src/workspace/config-imports.ts

@@ -305,7 +305,7 @@ function selfReference(pkg: string, fromDir: string): boolean {
     const manifest = path.join(dir, 'package.json')
     if (existsSync(manifest)) {
       try {
-        const json = JSON.parse(readFileSync(manifest, 'utf8')) as {
+        const json = JSON.parse(readFileSync(manifest, 'utf8').replace(/^\uFEFF/, '')) as {
           name?: unknown
           exports?: unknown
         }