[Bug] Native HMR starts replacement activation before asynchronous disposal finishes

[builtin-pb]

A live Host reload can start the replacement plugin before the previous instance's asynchronous disposer finishes. A plugin holding an exclusive resource then fails to reactivate even though its disposer eventually releases that resource.

Reproduced directly with DSH 0.1.5-rc.2, Node 24.19.0, macOS ARM64. The attached reproduction invokes the installed DSH entry with native Cordis HMR; it does not use dsh-developer, a browser, a model, or plugin installation.

The fixture acquires a file with open(path, 'wx'). Its ctx.effect() disposer awaits 200 ms, closes the handle, and unlinks the file. Changing an imported module produces:

Relative time	Instance	Event
0 ms	old	disposer starts
1 ms	replacement	apply starts
1 ms	replacement	exclusive acquisition fails with EEXIST
201 ms	old	disposer finishes

Expected: awaited cleanup finishes before replacement activation reacquires an exclusive resource. Actual: cleanup and replacement activation overlap. This is live reload, separate from SIGTERM or forced process shutdown.

In the installed @deepseek-ai/cordis-plugin-hmr implementation, partialReload() calls ctx.registry.delete(plugin) and proceeds to reload(...). Cordis registry delete() starts each fiber.dispose() without awaiting it. The replacement also takes over the loader entry's current fiber, so awaiting current entries does not establish that the removed fiber has drained. This appears to be the lifecycle handoff that needs attention; I have not implemented an upstream repair.

Self-contained reproduction (Node built-ins only)

Save as native-hmr-disposal.mjs, then run against an installed runtime:

node native-hmr-disposal.mjs /absolute/path/to/node_modules/@deepseek-ai/dsh/lib/bin.js

The script uses a disposable DSH home, disables browser opening, keeps the lock and trace outside the watched directory, prints the observed ordering, and removes its temporary files after stopping the owned process.

// Usage: node native-direct-repro.mjs /absolute/path/to/@deepseek-ai/dsh/lib/bin.js
// Node built-ins only. No dsh-developer, pnpm install, browser, or model call.
import assert from 'node:assert/strict'
import { spawn } from 'node:child_process'
import { mkdir, mkdtemp, readFile, writeFile, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { dirname, join, resolve, sep } from 'node:path'
import { pathToFileURL } from 'node:url'
import { setTimeout as sleep } from 'node:timers/promises'

if (!process.argv[2]) throw new Error('Pass the installed native DSH lib/bin.js path')
const dsh = resolve(process.argv[2])
const runtime = JSON.parse(await readFile(join(dirname(dirname(dsh)), 'package.json'), 'utf8')).version
const root = await mkdtemp(join(tmpdir(), 'native-hmr-disposal-'))
const source = join(root, 'source'), trace = join(root, 'trace.jsonl')
const lock = join(root, 'exclusive.lock'), patch = join(root, 'hmr.patch.yml')
let child, closed, diagnostics = ''
try {
  await mkdir(source)
  await writeFile(trace, '')
  await writeFile(join(source, 'value.mjs'), 'export const version = 1\n')
  await writeFile(join(source, 'index.mjs'), `
import { appendFileSync } from 'node:fs'
import { open, unlink } from 'node:fs/promises'
import { setTimeout } from 'node:timers/promises'
import { version } from './value.mjs'
const log = event => appendFileSync(${JSON.stringify(trace)}, JSON.stringify({ time: Date.now(), version, event }) + '\\n')
export const name = 'async-disposal-repro'
export const inject = ['hmr']
export async function apply(ctx) {
  log('apply-start')
  let handle
  try { handle = await open(${JSON.stringify(lock)}, 'wx') }
  catch (error) { log('lock-failed:' + error.code); throw error }
  log('lock-acquired')
  ctx.effect(() => async () => {
    log('dispose-start')
    await setTimeout(200)
    await handle.close()
    await unlink(${JSON.stringify(lock)})
    log('dispose-end')
  })
  ctx.effect(() => ctx.get('appReady').onReady(() => log('ready')))
}
`)
  await writeFile(patch, `- id: web-runtime
  config:
    openBrowser: false
    printUrl: false
- id: hmr
  disabled: false
  config:
    base: ${JSON.stringify(pathToFileURL(source + sep).href)}
    root: ["."]
- insert:
    - id: async-disposal-repro
      name: ${JSON.stringify(pathToFileURL(join(source, 'index.mjs')).href)}
`)
  const env = Object.fromEntries(Object.entries(process.env).filter(([key]) =>
    /^(PATH|PATHEXT|SYSTEMROOT|WINDIR|COMSPEC|TEMP|TMP|TMPDIR|LANG|LC_ALL)$/i.test(key)))
  Object.assign(env, { DSH_HOME: join(root, 'home'), DSH_TELEMETRY_DISABLED: '1', CI: '1', NO_COLOR: '1' })
  child = spawn(process.execPath, ['--expose-internals', dsh, '--profile', 'web',
    '--patch', patch, '--port', '0', '--no-open'], { cwd: root, env, stdio: ['ignore', 'ignore', 'pipe'] })
  child.stderr.on('data', chunk => { diagnostics = (diagnostics + chunk).slice(-4096) })
  closed = new Promise((accept, reject) => { child.once('error', reject); child.once('close', accept) })
  void closed.catch(() => {})
  const records = async () => (await readFile(trace, 'utf8')).trim().split('\n').filter(Boolean).map(JSON.parse)
  const until = async predicate => {
    const deadline = Date.now() + 30_000
    while (Date.now() < deadline) {
      const rows = await records()
      if (predicate(rows)) return rows
      if (child.exitCode !== null || child.signalCode !== null) throw new Error('DSH exited: ' + diagnostics)
      await sleep(25)
    }
    throw new Error('Timed out: ' + diagnostics)
  }
  await until(rows => rows.some(row => row.event === 'ready' && row.version === 1))
  await sleep(500)
  await writeFile(join(source, 'value.mjs'), 'export const version = 2\n')
  const rows = await until(rows => rows.some(row => row.event === 'dispose-end' && row.version === 1)
    && rows.some(row => row.version === 2 && ['lock-acquired', 'lock-failed:EEXIST'].includes(row.event)))
  const start = rows.find(row => row.event === 'dispose-start' && row.version === 1).time
  const timeline = rows.filter(row => row.time >= start).map(({ time, ...row }) => ({ ms: time - start, ...row }))
  console.log(JSON.stringify({ runtime, node: process.version, platform: process.platform, timeline }, null, 2))
  assert(rows.some(row => row.version === 2 && row.event === 'lock-failed:EEXIST'),
    'Expected the reported race; native behavior may have changed')
} finally {
  if (child?.pid && child.exitCode === null && child.signalCode === null) {
    child.kill('SIGTERM')
    const force = setTimeout(() => child.kill('SIGKILL'), 1500)
    try { await closed } finally { clearTimeout(force) }
  }
  await rm(root, { recursive: true, force: true })
}

Separate development-wrapper trials observed the same overlap on 0.1.1-rc.2 and 0.1.5-rc.2. The wrapper correctly reported failed activation with one inactive entry; the direct reproduction above isolates the current native runtime behavior. Windows and other versions are not established by these observations.

Until the handoff is resolved, plugins requiring an exclusive resource should restart the process or explicitly coordinate that resource's lifetime. There is no claim here that all plugins fail to reload.