Feature/reactive runtime resilient to duplicate module instances

CHANGELOG.md

@@ -6,6 +6,20 @@ This project follows [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [3.3.1] — 2026-06-26
+
+A robustness release. No breaking changes; no API or behavior change for normal usage.
+
+### Fixed
+
+- **Reactivity survives a duplicated runtime** — when a bundler materializes the reactive-core module more than once on a page (e.g. dependency pre-bundling in Vite/esbuild, which can serve the same internal chunk twice — once with an `?v=<hash>` query and once raw), `signal()` writes and reactive bindings landed in two independent worlds: a write notified one copy's queue while a binding had tracked itself through the other's. The binding then silently stopped updating, with no error thrown. The runtime now routes every duplicate copy through the first one loaded on the page, so reactivity keeps working regardless of how many copies a bundler emits — and the hot path is unchanged, so single-instance performance is identical. Raw ESM usage was never affected and is unchanged.
+
+### Added
+
+- **Dev warning for duplicated runtimes** — in development, loading a second copy of the reactive runtime now logs a one-time, actionable warning explaining how to de-duplicate (e.g. Vite `optimizeDeps.exclude: ['sibujs']` or `resolve.dedupe: ['sibujs']`). The warning is stripped from production builds.
+
+---
+
 ## [3.3.0] — 2026-06-11
 
 A security-hardening, correctness, and performance release. No breaking changes.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "sibujs",
-  "version": "3.3.0",
+  "version": "3.3.1",
   "description": "A lightweight, function-based frontend framework that combines the best of React, Svelte, and Vue — with zero VDOM and maximum simplicity. Designed for developers who want fine-grained reactivity and full control without compilation or magic.",
   "keywords": [
     "frontend",

src/core/signals/derived.ts

@@ -1,5 +1,5 @@
 import type { ReactiveSignal } from "../../reactivity/signal";
-import { recordDependency, retrack, track, trackingSuspended } from "../../reactivity/track";
+import { isTrackingSuspended, recordDependency, retrack, track } from "../../reactivity/track";
 import { devAssert } from "../dev";
 import type { Accessor } from "./signal";
 
@@ -101,7 +101,7 @@ export function derived<T>(
       );
     }
 
-    if (trackingSuspended) {
+    if (isTrackingSuspended()) {
       if (cs._d) {
         const prev = cs._v;
         evaluating = true;

src/reactivity/batch.ts

@@ -1,6 +1,11 @@
 import type { ReactiveSignal } from "./signal";
 import { drainNotificationQueue, queueSignalNotification } from "./track";
 
+// Batch coordination state is plain module-local — the same first-copy-wins
+// function-sharing as track.ts (see its file header) keeps it a single source
+// of truth across duplicate runtime instances: the first copy publishes its
+// batch functions on a globalThis registry and every later copy re-exports
+// them, so all copies funnel through ONE copy's batchDepth / pendingSignals.
 let batchDepth = 0;
 const pendingSignals = new Set<ReactiveSignal>();
 
@@ -26,7 +31,7 @@ const pendingSignals = new Set<ReactiveSignal>();
  * }); // Only one notification pass, result === "done"
  * ```
  */
-export function batch<T>(fn: () => T): T {
+function batchImpl<T>(fn: () => T): T {
   batchDepth++;
   try {
     return fn();
@@ -42,7 +47,7 @@ export function batch<T>(fn: () => T): T {
  * Queue a signal for deferred notification during a batch.
  * If not batching, returns false so the caller can notify immediately.
  */
-export function enqueueBatchedSignal(signal: ReactiveSignal): boolean {
+function enqueueBatchedSignalImpl(signal: ReactiveSignal): boolean {
   if (batchDepth === 0) return false;
   pendingSignals.add(signal);
   return true;
@@ -51,7 +56,7 @@ export function enqueueBatchedSignal(signal: ReactiveSignal): boolean {
 /**
  * Check if we're currently inside a batch.
  */
-export function isBatching(): boolean {
+function isBatchingImpl(): boolean {
   return batchDepth > 0;
 }
 
@@ -74,3 +79,32 @@ function flushBatch(): void {
   }
   drainNotificationQueue();
 }
+
+// ---------- Shared-instance registry (see track.ts) -----------------------
+
+interface BatchApi {
+  batch: typeof batchImpl;
+  enqueueBatchedSignal: typeof enqueueBatchedSignalImpl;
+  isBatching: typeof isBatchingImpl;
+}
+
+const BATCH_REGISTRY_KEY = Symbol.for("sibujs.reactive.batch.v1");
+
+function resolveBatchApi(): BatchApi {
+  const g = globalThis as typeof globalThis & { [BATCH_REGISTRY_KEY]?: BatchApi };
+  const existing = g[BATCH_REGISTRY_KEY];
+  if (existing) return existing;
+  const local: BatchApi = {
+    batch: batchImpl,
+    enqueueBatchedSignal: enqueueBatchedSignalImpl,
+    isBatching: isBatchingImpl,
+  };
+  g[BATCH_REGISTRY_KEY] = local;
+  return local;
+}
+
+const API: BatchApi = resolveBatchApi();
+
+export const batch: BatchApi["batch"] = API.batch;
+export const enqueueBatchedSignal: BatchApi["enqueueBatchedSignal"] = API.enqueueBatchedSignal;
+export const isBatching: BatchApi["isBatching"] = API.isBatching;