fix: run npm through a shell on Windows, and assert timing-free event shapes

The packaging proof spawned `npm`, which on Windows is npm.cmd -- a file Node
declines to spawn without a shell -- so the proof never ran there. Arguments
are quoted now that they travel as one command line.

Two shared engine assertions pinned a race instead of a contract. A change made
before unwatch() may still be draining when it returns, so the baseline is now
taken once the stream settles; and how many corrections close a debounce window
depends on when the backend delivered the second write, so the create-then-
correct test asserts the shape it means -- a leading created, corrections after
it -- while the bound on coalescing stays with the burst test that owns it.

Author: GriffinCanCode

src/bindings/nodejs/scripts/verify-package.js

@@ -40,13 +40,25 @@ function check(name, fn) {
 const NPM_TIMEOUT_MS = 180_000;
 const NODE_TIMEOUT_MS = 30_000;
 
+/**
+ * npm is `npm.cmd` on Windows, and Node refuses to spawn a `.cmd` without a shell, so there the
+ * command has to go through one. Its arguments then travel as a single command line rather than as
+ * a vector, which is why they are quoted: every path passed below sits under the temp directory,
+ * and on a machine whose user name contains a space one argument would otherwise arrive as two.
+ */
 function npm(args, cwd) {
-  const result = spawnSync('npm', args, {
-    cwd,
-    encoding: 'utf8',
-    timeout: NPM_TIMEOUT_MS,
-    env: { ...process.env, npm_config_audit: 'false', npm_config_fund: 'false' },
-  });
+  const windows = process.platform === 'win32';
+  const result = spawnSync(
+    windows ? 'npm.cmd' : 'npm',
+    windows ? args.map((arg) => (/\s/.test(arg) ? `"${arg}"` : arg)) : args,
+    {
+      cwd,
+      encoding: 'utf8',
+      timeout: NPM_TIMEOUT_MS,
+      shell: windows,
+      env: { ...process.env, npm_config_audit: 'false', npm_config_fund: 'false' },
+    }
+  );
   if (result.error) throw new Error(`npm ${args.join(' ')}: ${result.error.message}`);
   if (result.status !== 0) {
     throw new Error(`npm ${args.join(' ')} failed (${result.status})\n${result.stderr}`);

src/bindings/nodejs/test/shared/engine-suite.mjs

@@ -216,10 +216,15 @@ export function runEngineSuite(engineName, makeRetrigger) {
       await waitFor(() => kindsFor(events, target).length > 0, { message: 'first write missed' });
 
       watcher.unwatch(dir);
+      // Settled before the baseline is taken. A correction owed for the write above, or a
+      // notification the kernel had already queued, both belong to the watched period and arrive
+      // whenever the platform gets to them; counting them as breaches would make this assert how
+      // promptly a backend drains, not whether the unwatch took.
+      await waitForQuiet(() => events.length);
       const before = events.length;
       writeFile(target, 'two-longer');
       await waitForQuiet(() => events.length);
-      expect(events.length).toBe(before);
+      expect(events.length, 'a change made after unwatch() must not be reported').toBe(before);
     });
 
     // -------------------------------------------------------------- debouncing
@@ -276,7 +281,22 @@ export function runEngineSuite(engineName, makeRetrigger) {
         message: 'the write absorbed by the window never arrived as a correction',
       });
       await waitForQuiet(() => events.length, { quietMs: 250 });
-      expect(kindsFor(events, target)).toEqual(['created', 'modified']);
+
+      // Asserted as a shape rather than an exact list. How many corrections close the window is a
+      // property of when the backend delivered the second write -- a slow machine can report it
+      // late enough to open a window of its own -- and the bound on coalescing is the burst test's
+      // subject, just above. What belongs to this test is that the leading event kept its own
+      // identity and that the absorbed write was not swallowed.
+      const kinds = kindsFor(events, target);
+      expect(kinds[0], 'a new file is announced as created, not as a modification').toBe('created');
+      expect(
+        kinds.length,
+        'the write the window absorbed must still reach the consumer'
+      ).toBeGreaterThanOrEqual(2);
+      expect(
+        kinds.slice(1).every((kind) => kind === 'modified'),
+        `everything after the leading event is a correction, got ${kinds}`
+      ).toBe(true);
     });
 
     // -------------------------------------------------------- content changes