fix(core): share component registry across module instances

When the cli is installed globally (or hoisted at a different level
than the user's app), Node resolves `@webjskit/core` from each
importer's location and may load TWO instances of the package — one
for `@webjskit/server` (server-side) and one for the user's app
modules. Each instance had its own private `registry` Map, so:

  user-app:  ThemeToggle.register('theme-toggle')   → instance-A registry
  server:    lookup('theme-toggle')                  → instance-B registry (empty)

SSR's `injectDSD` then skipped the tag and emitted bare
`<theme-toggle></theme-toggle>` even though the user registered it
correctly. The component appeared empty in the SSR'd HTML and only
"showed up" after browser hydration.

Fix: key the registry Map and class→tag WeakMap off `globalThis` with
`Symbol.for('webjs:registry')` / `Symbol.for('webjs:classToTag')`. Every
instance of the registry module now finds the same maps regardless of
how many copies of `@webjskit/core` are loaded.

Adds a regression test (`test/registry.test.js`) that loads the
registry module twice from distinct file URLs (simulating the dual-
install scenario) and asserts a registration in instance A is visible
to instance B's `allTags()`, `lookup()`, and `tagOf()`.

Versions:
- `@webjskit/core`: 0.1.0 → 0.2.0
- `@webjskit/server`: 0.2.0 → 0.2.1 (core pin updated)
- `@webjskit/cli`: 0.2.0 → 0.2.1 (server pin updated)

Author: vivek7405

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@webjskit/cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "webjs CLI — dev, start, create, db",
   "bin": {
@@ -13,7 +13,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@webjskit/server": "0.2.0"
+    "@webjskit/server": "0.2.1"
   },
   "publishConfig": {
     "access": "public"

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webjskit/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "description": "webjs core runtime — html/css tags, WebComponent base, isomorphic renderers",
   "types": "./index.d.ts",

packages/core/package.json

@@ -17,10 +17,38 @@
  * @typedef {{ cls: typeof import('./component.js').WebComponent, moduleUrl: string | null, lazy: boolean, tag: string }} RegistryEntry
  */
 
+/* ------------------------------------------------------------------
+ * Shared registry on globalThis.
+ *
+ * In a typical install, the dev server (`@webjskit/server`) and the
+ * user's app modules each import `@webjskit/core`. When the cli is
+ * installed globally (or hoisted at a different level than the user's
+ * app), Node resolves the bare specifier from each importer's location
+ * and may end up loading TWO instances of `@webjskit/core` — one for
+ * the server, one for the user's app. Each instance would otherwise
+ * have its own private `registry` Map, so:
+ *
+ *   user-app:  ThemeToggle.register('theme-toggle')   → instance-A registry
+ *   server:    lookup('theme-toggle')                  → instance-B registry (empty)
+ *
+ * SSR's `injectDSD` would then skip the tag and emit bare
+ * `<theme-toggle></theme-toggle>` even though the user registered it
+ * correctly. Symptom: components render with no children server-side
+ * and only "appear" after the browser hydrates.
+ *
+ * We side-step this by keying both maps off `globalThis` with a stable
+ * `Symbol.for(...)`. Every loaded instance of this module finds the
+ * same maps regardless of which copy of `@webjskit/core` it lives in.
+ * @ts-ignore */
+const REGISTRY_KEY = Symbol.for('webjs:registry');
+/** @ts-ignore */
+const CLASS_TO_TAG_KEY = Symbol.for('webjs:classToTag');
+
+const _g = /** @type {any} */ (globalThis);
 /** @type {Map<string, RegistryEntry>} */
-const registry = new Map();
+const registry = _g[REGISTRY_KEY] || (_g[REGISTRY_KEY] = new Map());
 /** @type {WeakMap<Function, string>} */
-const classToTag = new WeakMap();
+const classToTag = _g[CLASS_TO_TAG_KEY] || (_g[CLASS_TO_TAG_KEY] = new WeakMap());
 
 const isBrowser =
   typeof window !== 'undefined' && typeof customElements !== 'undefined';

packages/core/src/registry.js

@@ -1,6 +1,6 @@
 {
   "name": "@webjskit/server",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "webjs dev/prod server: SSR, router, API, server actions, live reload",
   "main": "index.js",
@@ -14,7 +14,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@webjskit/core": "0.1.0",
+    "@webjskit/core": "0.2.0",
     "chokidar": "^3.6.0",
     "esbuild": "^0.28.0",
     "superjson": "^2.2.6",

packages/server/package.json

@@ -99,3 +99,41 @@ test('primeModuleUrl: creates an entry with no cls when called before register()
   // lookupModuleUrl via lookup+allTags shouldn't crash.
   assert.ok(allTags().includes('rx-prime'));
 });
+
+test('registry is shared across module instances via globalThis (dual-instance bug)', async () => {
+  // Two different file URLs for the same registry source. When `@webjskit/core`
+  // is installed twice (e.g. globally + locally), Node loads it as two distinct
+  // module instances. Each instance must still see the same registry, otherwise
+  // a component registered in one instance is invisible to lookups in the other
+  // (the bug that caused SSR-bare custom elements when the cli was global).
+  const { mkdtempSync, rmSync, copyFileSync } = await import('node:fs');
+  const { tmpdir } = await import('node:os');
+  const { join } = await import('node:path');
+  const { pathToFileURL } = await import('node:url');
+
+  const dir = mkdtempSync(join(tmpdir(), 'webjs-registry-dual-'));
+  try {
+    const src = new URL('../packages/core/src/registry.js', import.meta.url);
+    const copyA = join(dir, 'registry-a.js');
+    const copyB = join(dir, 'registry-b.js');
+    copyFileSync(src, copyA);
+    copyFileSync(src, copyB);
+
+    const a = await import(pathToFileURL(copyA).href);
+    const b = await import(pathToFileURL(copyB).href);
+
+    assert.notEqual(a, b, 'two distinct module instances expected');
+
+    class Shared {}
+    a.register('rx-shared-tag', Shared);
+
+    // Both instances must agree the tag is registered.
+    assert.ok(a.allTags().includes('rx-shared-tag'));
+    assert.ok(b.allTags().includes('rx-shared-tag'),
+      'instance B must see registrations made via instance A — registry is shared');
+    assert.equal(b.lookup('rx-shared-tag'), Shared);
+    assert.equal(b.tagOf(Shared), 'rx-shared-tag');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});