fix: prevent WASM double-initialization with concurrent plugin instances (#125)

## Summary
- Fix race condition in `wasmInit()` that causes `buildStart` to hang
when multiple `icpBindgen()` plugin instances run concurrently
- Replace boolean `initialized` flag with a shared Promise pattern so
concurrent callers await the same initialization
- Reset the cached promise on failure so subsequent calls can retry

## Root Cause
When multiple `icpBindgen()` plugin instances call `buildStart` in
parallel, each triggers `wasmInit()`. The boolean `initialized` flag is
only set **after** `await init()` completes, so concurrent callers all
pass the `if (initialized)` check and each call `init()` independently,
causing WASM double-initialization and a hang:

```
(vite-plugin-icp-bindgen) buildStart   ← all hang
(vite-plugin-icp-bindgen) buildStart
(vite-plugin-icp-bindgen) buildStart
```

## Fix
Store the `init()` Promise so all concurrent callers share and await the
same initialization:

```ts
let initPromise: Promise<void> | undefined;

export async function wasmInit(...args: Parameters<typeof init>) {
  if (!initPromise) {
    initPromise = init(...args).then(
      () => {},
      (error: unknown) => {
        initPromise = undefined;
        throw error;
      },
    );
  }
  return initPromise;
}
```

The error handler resets `initPromise` on failure so callers can retry
if WASM loading fails.

## Test plan
- [x] Added `tests/wasm-init.test.ts` — 5 concurrent `wasmInit` calls
resolve without hanging
- [x] All existing tests pass (20/21; 1 pre-existing CLI test requires
`vite build` output)
- [x] Biome lint clean
- [x] CodeQL clean

Closes #124

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: Nikolaos Xenakis <25032940+nikosxenakis@users.noreply.github.com>

Author: 3 people

src/core/generate/rs.ts

@@ -5,15 +5,19 @@ import type {
 } from './rs/dist/icp-js-bindgen.d.ts';
 import init, { generate, start } from './rs/dist/icp-js-bindgen.js';
 
-let initialized = false;
+let initPromise: Promise<void> | undefined;
 
 export async function wasmInit(...args: Parameters<typeof init>) {
-  if (initialized) {
-    return;
+  if (!initPromise) {
+    initPromise = init(...args).then(
+      () => {},
+      (error: unknown) => {
+        initPromise = undefined;
+        throw error;
+      },
+    );
   }
-
-  await init(...args);
-  initialized = true;
+  return initPromise;
 }
 
 export const wasmStart = start;

tests/wasm-init.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { wasmInit } from '../src/core/generate/rs.ts';
+import { getWasm } from './utils/wasm.ts';
+
+describe('wasmInit', () => {
+  it('should handle concurrent calls without hanging', async () => {
+    const { wasm } = await getWasm();
+
+    // Simulate multiple concurrent wasmInit calls, as would happen when
+    // multiple icpBindgen() plugin instances trigger buildStart in parallel.
+    const results = await Promise.all([
+      wasmInit({ module_or_path: wasm }),
+      wasmInit({ module_or_path: wasm }),
+      wasmInit({ module_or_path: wasm }),
+      wasmInit({ module_or_path: wasm }),
+      wasmInit({ module_or_path: wasm }),
+    ]);
+
+    // All calls should resolve (not hang) and return undefined.
+    for (const result of results) {
+      expect(result).toBeUndefined();
+    }
+  });
+});