test(server): Add native-crash pinpointing probes for reinitialize.js

The reinitialize.js test exits with 0xC0000005 (access violation) on Windows,
a native crash in the forked AVA worker rather than a JS test failure. Add
standalone probes that drive each native subsystem the test exercises in
isolation — node:sqlite (single and overlapping WAL+mmap handles), the
@parcel/watcher subscribe/unsubscribe cycle, and the full serve/reinitialize/
close lifecycle without AVA — so the crash origin can be attributed on Windows
before changing the teardown logic further. See test/probes/README.md.

Author: matz3

packages/server/test/probes/README.md

@@ -0,0 +1,58 @@
+# Windows `0xC0000005` pinpointing kit for `reinitialize.js`
+
+`test/lib/server/reinitialize.js` exits with `3221225477` (`0xC0000005`, an **access
+violation**) on Windows. That is a native crash in the AVA worker **child process**
+(AVA runs each test file in a forked process — `workerThreads: false`), not a JS-level
+test failure. The two native subsystems this test drives are:
+
+- **`@parcel/watcher`** — the source watcher (`WatchHandler`) and the definition watcher
+  (`ProjectDefinitionWatcher`). On Windows it runs a background `ReadDirectoryChangesW`
+  thread; a watch thread outliving `unsubscribe()` or racing process exit is a classic
+  `0xC0000005` source.
+- **`node:sqlite`** (`BuildCacheStorage`) — opened with `PRAGMA journal_mode=WAL` and
+  `PRAGMA mmap_size=268435456`. Closing a memory-mapped WAL database, or letting the
+  process exit while pages are still mapped, can access-violate on Windows.
+
+The branch already serialized `destroy()` against the in-flight swap and cancelled the
+settle timer, yet the crash persists — which points at native teardown / process exit
+rather than a JS race.
+
+Run these probes on the Windows machine (from `packages/server`) and report the exit
+code of each. `echo %ERRORLEVEL%` after each in cmd, or `$LASTEXITCODE` in PowerShell.
+`3221225477` = the crash; `0` = clean.
+
+```
+node test/probes/probe-sqlite.mjs           # node:sqlite open/write/close, single handle
+node test/probes/probe-sqlite-reopen.mjs    # two overlapping handles on one WAL+mmap db (the swap pattern)
+node test/probes/probe-parcel.mjs           # @parcel/watcher subscribe/event/unsubscribe
+node test/probes/probe-serve.mjs            # full serve() -> reinitialize() -> close(), no AVA
+```
+
+`probe-serve.mjs` prints staged markers (`serving` / `reinitialized` / `closed` /
+`settled`). Note the last line printed before a crash:
+
+- crash **before** `closed` → teardown while JS still running.
+- `closed` + `settled` printed, crash **after** → exit-time native handle not released.
+- exit 0 → the isolated lifecycle is clean; the trigger needs the AVA worker environment.
+
+## Which probe crashed → where it originates
+
+| Crashes | Clean | Origin |
+|---|---|---|
+| `probe-sqlite` | — | `node:sqlite` close (WAL checkpoint / mmap unmap) — single handle is enough |
+| `probe-sqlite-reopen` | `probe-sqlite` | overlapping handles on one WAL+mmap db (the reinitialize swap) |
+| `probe-parcel` | sqlite probes | `@parcel/watcher` native teardown / watch thread vs. exit |
+| `probe-serve` | all component probes | interaction only visible in the full lifecycle |
+| none | all | needs the AVA worker env (supertest sockets, `--loader`, concurrent files) |
+
+## Bisecting the AVA subtests
+
+`reinitialize.js` has three serial subtests. Run each alone to see which crashes:
+
+```
+npx ava test/lib/server/reinitialize.js -m "reinitialize() keeps the port bound*"
+npx ava test/lib/server/reinitialize.js -m "editing ui5.yaml triggers*"
+npx ava test/lib/server/reinitialize.js -m "reinitialize() without a graphFactory*"
+```
+
+Delete this directory once the origin is confirmed.

packages/server/test/probes/probe-parcel.mjs

@@ -0,0 +1,38 @@
+// Probe C — @parcel/watcher subscribe/unsubscribe native teardown in isolation.
+//
+// Subscribes to a directory, triggers an event, unsubscribes, then lets the process exit.
+// If this crashes with 0xC0000005 on Windows, the origin is the @parcel/watcher native
+// binding (a background ReadDirectoryChangesW thread outliving unsubscribe / racing exit),
+// independent of node:sqlite and the swap logic.
+//
+// Run from packages/project:  node ../server/test/tmp/probe-parcel.mjs
+import path from "node:path";
+import fs from "node:fs/promises";
+import {fileURLToPath} from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const {subscribe} = await import(path.resolve(here, "../../../project/lib/build/helpers/fileWatcher.js"));
+
+const dir = path.resolve(here, `probe-parcel-${process.pid}`);
+await fs.mkdir(dir, {recursive: true});
+console.log(`[probe-parcel] subscribing to ${dir}`);
+
+let eventCount = 0;
+const sub = await subscribe(dir, (err, events) => {
+	if (err) {
+		console.error(`[probe-parcel] watcher error: ${err.message}`);
+		return;
+	}
+	eventCount += events.length;
+});
+
+// Produce a change so the native watch thread is actively delivering.
+await fs.writeFile(path.join(dir, "file.txt"), "hello");
+await new Promise((r) => setTimeout(r, 300));
+await fs.writeFile(path.join(dir, "file.txt"), "world");
+await new Promise((r) => setTimeout(r, 300));
+console.log(`[probe-parcel] observed ${eventCount} event(s)`);
+
+console.log(`[probe-parcel] unsubscribing`);
+await sub.unsubscribe();
+console.log(`[probe-parcel] unsubscribed OK — process exiting`);

packages/server/test/probes/probe-serve.mjs

@@ -0,0 +1,52 @@
+// Probe D — Full serve() -> reinitialize() -> close() lifecycle, standalone (no AVA).
+//
+// Mirrors the first subtest of reinitialize.js against the real graph + BuildServer +
+// Supervisor, but as a plain Node process so the exit code is attributable to this flow
+// alone (AVA is not in the picture). After close() resolves it prints a marker, waits
+// briefly, then exits.
+//
+//   - If it crashes 0xC0000005 BEFORE "[probe-serve] closed" -> the crash is during
+//     destroy()/teardown while JS is still running.
+//   - If it prints "[probe-serve] closed" and "[probe-serve] settled" and THEN the
+//     process crashes on exit -> the crash is at process exit with a native handle
+//     (parcel watch thread / sqlite mmap) not fully released.
+//   - Exit 0 clean -> the isolated lifecycle does not reproduce it; the trigger needs
+//     the AVA worker environment (e.g. supertest sockets, the loader, concurrent files).
+//
+// Run from packages/server:  node test/probes/probe-serve.mjs
+import path from "node:path";
+import {fileURLToPath} from "node:url";
+
+process.env.NODE_ENV = "test";
+const here = path.dirname(fileURLToPath(import.meta.url));
+const serverRoot = path.resolve(here, "..", "..");
+process.chdir(serverRoot); // so ./test/fixtures/application.a resolves like the test
+
+const {serve} = await import(path.resolve(serverRoot, "lib/server.js"));
+const {graphFromPackageDependencies} = await import("@ui5/project/graph");
+const projectWatcher = await import("@ui5/project/internal/graph/ProjectDefinitionWatcher");
+
+const buildGraph = () => graphFromPackageDependencies({cwd: "./test/fixtures/application.a"});
+
+const ui5DataDir = path.resolve("test", "tmp", "buildcache", `probe-serve-${process.pid}`);
+console.log(`[probe-serve] serving (ui5DataDir=${ui5DataDir})`);
+const graph = await buildGraph();
+const server = await serve(graph, {
+	port: 3399, // fixed port; changePortIfInUse bumps it if busy
+	changePortIfInUse: true,
+	liveReload: false,
+	ui5DataDir,
+}, undefined, buildGraph, projectWatcher);
+console.log(`[probe-serve] listening on ${server.port}`);
+
+console.log(`[probe-serve] reinitialize`);
+await server.reinitialize();
+console.log(`[probe-serve] reinitialized`);
+
+await new Promise((resolve) => server.close(resolve));
+console.log(`[probe-serve] closed`);
+
+// Hold the process open briefly so an exit-time native crash is clearly separated from
+// the in-flight teardown above.
+await new Promise((r) => setTimeout(r, 1000));
+console.log(`[probe-serve] settled — process exiting`);

packages/server/test/probes/probe-sqlite-reopen.mjs

@@ -0,0 +1,33 @@
+// Probe B — node:sqlite reopen/refcount pattern of a reinitialize() swap.
+//
+// A reinitialize() opens a SECOND handle on the same cache dir before the first is
+// closed (refcount 1 -> 2), then closes the first (2 -> 1), later the second (1 -> 0).
+// Two DatabaseSync handles onto the same WAL+mmap file, overlapping, then both closed.
+// If this crashes but probe-sqlite does not, the origin is concurrent handles onto the
+// same mmapped WAL DB on Windows.
+//
+// Run from packages/project:  node ../server/test/tmp/probe-sqlite-reopen.mjs
+import path from "node:path";
+import {fileURLToPath} from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const {default: BuildCacheStorage} =
+	await import(path.resolve(here, "../../../project/lib/build/cache/BuildCacheStorage.js"));
+
+const dbDir = path.resolve(here, `probe-sqlite-reopen-${process.pid}`);
+console.log(`[probe-reopen] open #1 ${dbDir}`);
+const a = new BuildCacheStorage(dbDir);
+a.transaction(() => a.putContent("sha512-a", Buffer.alloc(4096, 1)));
+
+console.log(`[probe-reopen] open #2 (overlapping) same dir`);
+const b = new BuildCacheStorage(dbDir);
+console.log(`[probe-reopen] #2 reads #1's row: ${b.hasContent("sha512-a")}`);
+b.transaction(() => b.putContent("sha512-b", Buffer.alloc(4096, 2)));
+
+console.log(`[probe-reopen] close #1 (swap: old stack torn down)`);
+a.close();
+console.log(`[probe-reopen] #2 still serving: ${b.hasContent("sha512-a")} / ${b.hasContent("sha512-b")}`);
+
+console.log(`[probe-reopen] close #2 (server.close)`);
+b.close();
+console.log(`[probe-reopen] both closed OK — process exiting`);

packages/server/test/probes/probe-sqlite.mjs

@@ -0,0 +1,29 @@
+// Probe A — node:sqlite (BuildCacheStorage) native teardown in isolation.
+//
+// Opens the build-cache DB the exact way the server does (WAL + mmap + busy_timeout),
+// writes a row, closes it (WAL checkpoint TRUNCATE + db.close()), then lets the process
+// exit. If this crashes with 0xC0000005 on Windows, the origin is node:sqlite teardown
+// (mmap unmap / WAL checkpoint on close), independent of parcel and the swap logic.
+//
+// Run from packages/project:  node ../server/test/tmp/probe-sqlite.mjs
+import path from "node:path";
+import {fileURLToPath} from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const {default: BuildCacheStorage} =
+	await import(path.resolve(here, "../../../project/lib/build/cache/BuildCacheStorage.js"));
+
+const dbDir = path.resolve(here, `probe-sqlite-${process.pid}`);
+console.log(`[probe-sqlite] opening ${dbDir}`);
+const storage = new BuildCacheStorage(dbDir);
+
+// Exercise a write + read so mmap pages are actually mapped in.
+storage.transaction(() => {
+	storage.putContent("sha512-probe", Buffer.alloc(4096, 7));
+});
+console.log(`[probe-sqlite] hasContent=${storage.hasContent("sha512-probe")}`);
+console.log(`[probe-sqlite] size=${storage.getDatabaseSize()}`);
+
+console.log(`[probe-sqlite] closing`);
+storage.close();
+console.log(`[probe-sqlite] closed OK — process exiting`);