@fluixi/reactive 1.0.0-alpha.82 → 1.0.0-alpha.84

package/dist/lib/signal/graph/ssr-hooks.cjs

@@ -1 +1,60 @@
-"use strict";var i=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var v=Object.prototype.hasOwnProperty;var f=(e,n)=>{for(var t in n)i(e,t,{get:n[t],enumerable:!0})},p=(e,n,t,d)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of c(n))!v.call(e,r)&&r!==t&&i(e,r,{get:()=>n[r],enumerable:!(d=s(n,r))||d.enumerable});return e};var g=e=>p(i({},"__esModule",{value:!0}),e);var _={};f(_,{getServerData:()=>R,nextResourceId:()=>k,reportResourceData:()=>P,setResourceDataSink:()=>m,setResourceIdSource:()=>S,setResourceTracker:()=>x,setServerDataGetter:()=>D,trackResourcePromise:()=>y});module.exports=g(_);var u=null;function x(e){u=e}function y(e){u&&u(e)}var o=null;function D(e){o=e}function R(e){return o?o(e):void 0}var l=null;function S(e){l=e}function k(){return l?l():void 0}var a=null;function m(e){a=e}function P(e,n){a&&a(e,n)}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/signal/graph/ssr-hooks.ts
+var ssr_hooks_exports = {};
+__export(ssr_hooks_exports, {
+  getServerData: () => getServerData,
+  nextResourceId: () => nextResourceId,
+  reportResourceData: () => reportResourceData,
+  setResourceDataSink: () => setResourceDataSink,
+  setResourceIdSource: () => setResourceIdSource,
+  setResourceTracker: () => setResourceTracker,
+  setServerDataGetter: () => setServerDataGetter,
+  trackResourcePromise: () => trackResourcePromise
+});
+module.exports = __toCommonJS(ssr_hooks_exports);
+var _resourceTracker = null;
+function setResourceTracker(fn) {
+  _resourceTracker = fn;
+}
+function trackResourcePromise(p) {
+  if (_resourceTracker) _resourceTracker(p);
+}
+var _serverDataGetter = null;
+function setServerDataGetter(fn) {
+  _serverDataGetter = fn;
+}
+function getServerData(id) {
+  return _serverDataGetter ? _serverDataGetter(id) : void 0;
+}
+var _resourceIdSource = null;
+function setResourceIdSource(fn) {
+  _resourceIdSource = fn;
+}
+function nextResourceId() {
+  return _resourceIdSource ? _resourceIdSource() : void 0;
+}
+var _resourceDataSink = null;
+function setResourceDataSink(fn) {
+  _resourceDataSink = fn;
+}
+function reportResourceData(id, value) {
+  if (_resourceDataSink) _resourceDataSink(id, value);
+}

package/dist/lib/signal/graph/ssr-hooks.d.ts

@@ -1,28 +1,27 @@
 /**
- * SSR resource injectables — graph-agnostic module state. The server (@fluixi/server
+ * SSR resource injectables: graph-agnostic module state. The server (@fluixi/server
  * via @fluixi/dom) injects these so async SSR can await in-flight resource fetches and
- * seed resources from server-serialized data on the client. All no-ops when unset →
- * zero client/runtime impact. Used by both the TC39 resource core and the legacy graph,
+ * seed resources from server-serialized data on the client. All no-ops when unset -> * zero client/runtime impact. Used by both the TC39 resource core and the legacy graph,
  * so they live in a TC39-owned module (not signal.ts, which is being retired).
  */
 /** Register a sink that receives every resource fetch promise (server: collect & await). */
 export declare function setResourceTracker(fn: ((p: Promise<any>) => void) | null): void;
-/** @internal — resources report their fetch promise here. */
+/** @internal: resources report their fetch promise here. */
 export declare function trackResourcePromise(p: Promise<any>): void;
 /** Inject server-serialized resource data (client hydration: seed without refetch). */
 export declare function setServerDataGetter(fn: ((id: string) => {
     value: any;
 } | undefined) | null): void;
-/** @internal — resources look up seeded data by their SSR id. */
+/** @internal: resources look up seeded data by their SSR id. */
 export declare function getServerData(id: string): {
     value: any;
 } | undefined;
 /** Inject a stable per-resource id source (server render order / hydration order). */
 export declare function setResourceIdSource(fn: (() => string) | null): void;
-/** @internal — a resource asks for its SSR id at creation; undefined on a plain client. */
+/** @internal, a resource asks for its SSR id at creation; undefined on a plain client. */
 export declare function nextResourceId(): string | undefined;
 /** Inject a sink for resolved resource values (server: collect for serialization). */
 export declare function setResourceDataSink(fn: ((id: string, value: any) => void) | null): void;
-/** @internal — a resource reports its resolved value here. */
+/** @internal, a resource reports its resolved value here. */
 export declare function reportResourceData(id: string, value: any): void;
 //# sourceMappingURL=ssr-hooks.d.ts.map

package/dist/lib/signal/graph/ssr-hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr-hooks.d.ts","sourceRoot":"","sources":["../../../../src/lib/signal/graph/ssr-hooks.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,4FAA4F;AAC5F,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,CAE/E;AACD,6DAA6D;AAC7D,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAE1D;AAGD,uFAAuF;AACvF,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,MAAM,KAAK;IAAE,KAAK,EAAE,GAAG,CAAA;CAAE,GAAG,SAAS,CAAC,GAAG,IAAI,GAAG,IAAI,CAEjG;AACD,iEAAiE;AACjE,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,GAAG,CAAA;CAAE,GAAG,SAAS,CAEpE;AAGD,sFAAsF;AACtF,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI,CAEnE;AACD,2FAA2F;AAC3F,wBAAgB,cAAc,IAAI,MAAM,GAAG,SAAS,CAEnD;AAGD,sFAAsF;AACtF,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,CAEvF;AACD,8DAA8D;AAC9D,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI,CAE/D"}
+{"version":3,"file":"ssr-hooks.d.ts","sourceRoot":"","sources":["../../../../src/lib/signal/graph/ssr-hooks.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,4FAA4F;AAC5F,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,CAE/E;AACD,4DAA4D;AAC5D,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAE1D;AAGD,uFAAuF;AACvF,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,MAAM,KAAK;IAAE,KAAK,EAAE,GAAG,CAAA;CAAE,GAAG,SAAS,CAAC,GAAG,IAAI,GAAG,IAAI,CAEjG;AACD,gEAAgE;AAChE,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,GAAG,CAAA;CAAE,GAAG,SAAS,CAEpE;AAGD,sFAAsF;AACtF,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI,CAEnE;AACD,0FAA0F;AAC1F,wBAAgB,cAAc,IAAI,MAAM,GAAG,SAAS,CAEnD;AAGD,sFAAsF;AACtF,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,CAEvF;AACD,6DAA6D;AAC7D,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI,CAE/D"}

package/dist/lib/signal/graph/ssr-hooks.js

@@ -1,8 +1,7 @@
 /**
- * SSR resource injectables — graph-agnostic module state. The server (@fluixi/server
+ * SSR resource injectables: graph-agnostic module state. The server (@fluixi/server
  * via @fluixi/dom) injects these so async SSR can await in-flight resource fetches and
- * seed resources from server-serialized data on the client. All no-ops when unset →
- * zero client/runtime impact. Used by both the TC39 resource core and the legacy graph,
+ * seed resources from server-serialized data on the client. All no-ops when unset -> * zero client/runtime impact. Used by both the TC39 resource core and the legacy graph,
  * so they live in a TC39-owned module (not signal.ts, which is being retired).
  */
 let _resourceTracker = null;
@@ -10,7 +9,7 @@ let _resourceTracker = null;
 export function setResourceTracker(fn) {
     _resourceTracker = fn;
 }
-/** @internal — resources report their fetch promise here. */
+/** @internal: resources report their fetch promise here. */
 export function trackResourcePromise(p) {
     if (_resourceTracker)
         _resourceTracker(p);
@@ -20,7 +19,7 @@ let _serverDataGetter = null;
 export function setServerDataGetter(fn) {
     _serverDataGetter = fn;
 }
-/** @internal — resources look up seeded data by their SSR id. */
+/** @internal: resources look up seeded data by their SSR id. */
 export function getServerData(id) {
     return _serverDataGetter ? _serverDataGetter(id) : undefined;
 }
@@ -29,7 +28,7 @@ let _resourceIdSource = null;
 export function setResourceIdSource(fn) {
     _resourceIdSource = fn;
 }
-/** @internal — a resource asks for its SSR id at creation; undefined on a plain client. */
+/** @internal, a resource asks for its SSR id at creation; undefined on a plain client. */
 export function nextResourceId() {
     return _resourceIdSource ? _resourceIdSource() : undefined;
 }
@@ -38,7 +37,7 @@ let _resourceDataSink = null;
 export function setResourceDataSink(fn) {
     _resourceDataSink = fn;
 }
-/** @internal — a resource reports its resolved value here. */
+/** @internal, a resource reports its resolved value here. */
 export function reportResourceData(id, value) {
     if (_resourceDataSink)
         _resourceDataSink(id, value);

package/dist/lib/signal/graph/ssr-hooks.mjs

@@ -1 +1,39 @@
-var n=null;function o(e){n=e}function l(e){n&&n(e)}var r=null;function a(e){r=e}function d(e){return r?r(e):void 0}var t=null;function s(e){t=e}function c(){return t?t():void 0}var i=null;function v(e){i=e}function f(e,u){i&&i(e,u)}export{d as getServerData,c as nextResourceId,f as reportResourceData,v as setResourceDataSink,s as setResourceIdSource,o as setResourceTracker,a as setServerDataGetter,l as trackResourcePromise};
+// src/lib/signal/graph/ssr-hooks.ts
+var _resourceTracker = null;
+function setResourceTracker(fn) {
+  _resourceTracker = fn;
+}
+function trackResourcePromise(p) {
+  if (_resourceTracker) _resourceTracker(p);
+}
+var _serverDataGetter = null;
+function setServerDataGetter(fn) {
+  _serverDataGetter = fn;
+}
+function getServerData(id) {
+  return _serverDataGetter ? _serverDataGetter(id) : void 0;
+}
+var _resourceIdSource = null;
+function setResourceIdSource(fn) {
+  _resourceIdSource = fn;
+}
+function nextResourceId() {
+  return _resourceIdSource ? _resourceIdSource() : void 0;
+}
+var _resourceDataSink = null;
+function setResourceDataSink(fn) {
+  _resourceDataSink = fn;
+}
+function reportResourceData(id, value) {
+  if (_resourceDataSink) _resourceDataSink(id, value);
+}
+export {
+  getServerData,
+  nextResourceId,
+  reportResourceData,
+  setResourceDataSink,
+  setResourceIdSource,
+  setResourceTracker,
+  setServerDataGetter,
+  trackResourcePromise
+};

package/dist/lib/signal/graph/state.cjs

@@ -1 +1,72 @@
-"use strict";var l=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var s=Object.getOwnPropertyNames;var t=Object.prototype.hasOwnProperty;var i=(e,o)=>{for(var u in o)l(e,u,{get:o[u],enumerable:!0})},d=(e,o,u,a)=>{if(o&&typeof o=="object"||typeof o=="function")for(let n of s(o))!t.call(e,n)&&n!==u&&l(e,n,{get:()=>o[n],enumerable:!(a=r(o,n))||a.enumerable});return e};var c=e=>d(l({},"__esModule",{value:!0}),e);var b={};i(b,{G:()=>p});module.exports=c(b);var h="__fluixi_signal_next_state__",f=e=>{typeof queueMicrotask=="function"?queueMicrotask(e):Promise.resolve().then(e)},p=globalThis[h]??={consumer:null,untracked:!1,owner:null,queue:[],scheduled:!1,flushing:!1,batchDepth:0,hostSchedule:f,onSuspend:null,onError:null};
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/signal/graph/state.ts
+var state_exports = {};
+__export(state_exports, {
+  G: () => G,
+  backfillState: () => backfillState,
+  joinedVersions: () => joinedVersions
+});
+module.exports = __toCommonJS(state_exports);
+
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.84";
+
+// src/lib/signal/graph/state.ts
+var MAJOR = VERSION.split(".")[0];
+var KEY = `__fluixi_signal_state_v${MAJOR}__`;
+var VERSIONS_KEY = `__fluixi_signal_builds_v${MAJOR}__`;
+var defaultSchedule = (run) => {
+  if (typeof queueMicrotask === "function") queueMicrotask(run);
+  else void Promise.resolve().then(run);
+};
+function defaults() {
+  return {
+    consumer: null,
+    untracked: false,
+    owner: null,
+    queue: [],
+    scheduled: false,
+    flushing: false,
+    batchDepth: 0,
+    hostSchedule: defaultSchedule,
+    onSuspend: null,
+    onError: null,
+    observer: null
+  };
+}
+var realm = globalThis;
+function backfillState(existing) {
+  const fresh = defaults();
+  const target = existing;
+  for (const field of Object.keys(fresh)) {
+    if (!(field in existing)) target[field] = fresh[field];
+  }
+  return existing;
+}
+function claim() {
+  const existing = realm[KEY];
+  return existing ? backfillState(existing) : realm[KEY] = defaults();
+}
+var G = claim();
+(realm[VERSIONS_KEY] ??= []).push(VERSION);
+function joinedVersions() {
+  return [...new Set(realm[VERSIONS_KEY] ?? [])];
+}

package/dist/lib/signal/graph/state.d.ts

@@ -1,21 +1,32 @@
 /**
- * The reactive graph's mutable state, kept as a SINGLE object cached on globalThis.
+ * The reactive graph's mutable state, kept as a single object cached on globalThis.
  *
- * Why: tracking/scheduling reads module-global state ("who's the current consumer?",
+ * Why, tracking/scheduling reads module-global state ("who's the current consumer?",
  * "what owner are we under?", "the effect queue"). If a production bundle emits more
- * than one copy of this module (a common cross-package hazard — see @fluixi/dom's
- * integration bridge), plain `let`s would be DUPLICATED: an effect would set copy A's
- * consumer while a signal read checks copy B's → no subscription → reactivity silently
+ * than one copy of this module (a common cross-package hazard: see @fluixi/dom's
+ * integration bridge), plain `let`s would be duplicated: an effect would set copy A's
+ * consumer while a signal read checks copy B's -> no subscription -> reactivity silently
  * lost (works in dev, breaks in prod). Caching the state on globalThis means every copy
- * of this module reads/writes the SAME object, so the graph stays unified no matter how
- * many times the module is bundled — no integration bridge required.
+ * of this module reads/writes the same object, so the graph stays unified no matter how
+ * many times the module is bundled, no integration bridge required.
  *
  * This is strictly more robust than SolidJS, which keeps this state in module `let`s and
  * relies on dedup + a "multiple instances" warning. Node-ref fields are loosely typed
  * (`any`) to avoid import cycles with core.ts/runtime.ts; the public API stays fully typed.
+ *
+ * Sharing is deliberate, and a standalone web component makes it load-bearing: several
+ * independent bundles can land on one page, each carrying its own copy of this module, and they
+ * have to end up on one graph or an effect in one will not see a signal from another.
+ *
+ * Two consequences that the original `??=` got wrong once more than one version is in play.
+ * The first copy to run used to define the whole object, so a field added in a later
+ * release stayed absent for every copy, including the one that expected it. Fields are
+ * backfilled now instead. And nothing recorded which builds had joined, so a genuine
+ * mismatch was invisible; `joinedVersions()` reports it, and @fluixi/dom's version-skew
+ * warning is where that surfaces.
  */
 export interface GraphState {
-    /** The computation currently evaluating — reads inside it subscribe to it. */
+    /** The computation currently evaluating: reads inside it subscribe to it. */
     consumer: any;
     /** When true, reads don't subscribe (untrack / peek). */
     untracked: boolean;
@@ -27,17 +38,39 @@ export interface GraphState {
         disposed: boolean;
         run(): void;
     }>;
-    /** A flush has been scheduled (microtask) but not yet run. */
+    /**
+     * Effects are queued and a flush is pending.
+     *
+     * Not a microtask on the shipped path: `compat.ts` installs a no-op host scheduler
+     * and flushes explicitly after a write, so this says a drain is owed rather than
+     * that one is booked.
+     */
     scheduled: boolean;
     /** A flush is in progress (re-entrancy guard). */
     flushing: boolean;
     /** Depth of active batch() calls; >0 defers flushing. */
     batchDepth: number;
-    /** Host scheduler for the deferred flush (overridable: SSR/tests/compat). */
+    /**
+     * How a pending drain gets run. `compat.ts` sets it to a no-op because it owns the
+     * flush points itself; `setScheduler(null)` restores the microtask default. SSR and
+     * tests override it too.
+     */
     hostSchedule: (run: () => void) => void;
     /** Boundary hooks (injected by the Suspense / error-boundary layers). */
     onSuspend: ((promise: Promise<unknown>, owner: any) => void) | null;
     onError: ((error: unknown, owner: any) => boolean) | null;
+    /** A tool watching the graph (see observe.ts). Here for the same reason the rest is. */
+    observer: any;
 }
+/**
+ * Add any field this release reads that an earlier copy never created.
+ *
+ * `in` rather than `??`, so a field whose default is null is not rewritten every time
+ * another copy loads. Mutates and returns the object it was given, because the whole
+ * point is that every copy keeps pointing at the same one.
+ */
+export declare function backfillState(existing: GraphState): GraphState;
 export declare const G: GraphState;
+/** Every `@fluixi/reactive` build that has joined the shared graph, deduplicated. */
+export declare function joinedVersions(): string[];
 //# sourceMappingURL=state.d.ts.map

package/dist/lib/signal/graph/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../src/lib/signal/graph/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,WAAW,UAAU;IACzB,8EAA8E;IAE9E,QAAQ,EAAE,GAAG,CAAC;IACd,yDAAyD;IACzD,SAAS,EAAE,OAAO,CAAC;IACnB,4DAA4D;IAE5D,KAAK,EAAE,GAAG,CAAC;IACX,sCAAsC;IACtC,KAAK,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,GAAG,IAAI,IAAI,CAAA;KAAE,CAAC,CAAC;IAClE,8DAA8D;IAC9D,SAAS,EAAE,OAAO,CAAC;IACnB,kDAAkD;IAClD,QAAQ,EAAE,OAAO,CAAC;IAClB,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAC;IACnB,6EAA6E;IAC7E,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACxC,yEAAyE;IAEzE,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IAEpE,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,IAAI,CAAC;CAC3D;AASD,eAAO,MAAM,CAAC,EAAE,UAaS,CAAC"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../src/lib/signal/graph/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,MAAM,WAAW,UAAU;IACzB,6EAA6E;IAE7E,QAAQ,EAAE,GAAG,CAAC;IACd,yDAAyD;IACzD,SAAS,EAAE,OAAO,CAAC;IACnB,4DAA4D;IAE5D,KAAK,EAAE,GAAG,CAAC;IACX,sCAAsC;IACtC,KAAK,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,GAAG,IAAI,IAAI,CAAA;KAAE,CAAC,CAAC;IAClE;;;;;;OAMG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB,kDAAkD;IAClD,QAAQ,EAAE,OAAO,CAAC;IAClB,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACxC,yEAAyE;IAEzE,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IAEpE,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,IAAI,CAAC;IAC1D,wFAAwF;IAExF,QAAQ,EAAE,GAAG,CAAC;CACf;AA6CD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,UAAU,GAAG,UAAU,CAO9D;AAOD,eAAO,MAAM,CAAC,EAAE,UAAoB,CAAC;AAQrC,qFAAqF;AACrF,wBAAgB,cAAc,IAAI,MAAM,EAAE,CAEzC"}

package/dist/lib/signal/graph/state.js

@@ -1,37 +1,99 @@
 /**
- * The reactive graph's mutable state, kept as a SINGLE object cached on globalThis.
+ * The reactive graph's mutable state, kept as a single object cached on globalThis.
  *
- * Why: tracking/scheduling reads module-global state ("who's the current consumer?",
+ * Why, tracking/scheduling reads module-global state ("who's the current consumer?",
  * "what owner are we under?", "the effect queue"). If a production bundle emits more
- * than one copy of this module (a common cross-package hazard — see @fluixi/dom's
- * integration bridge), plain `let`s would be DUPLICATED: an effect would set copy A's
- * consumer while a signal read checks copy B's → no subscription → reactivity silently
+ * than one copy of this module (a common cross-package hazard: see @fluixi/dom's
+ * integration bridge), plain `let`s would be duplicated: an effect would set copy A's
+ * consumer while a signal read checks copy B's -> no subscription -> reactivity silently
  * lost (works in dev, breaks in prod). Caching the state on globalThis means every copy
- * of this module reads/writes the SAME object, so the graph stays unified no matter how
- * many times the module is bundled — no integration bridge required.
+ * of this module reads/writes the same object, so the graph stays unified no matter how
+ * many times the module is bundled, no integration bridge required.
  *
  * This is strictly more robust than SolidJS, which keeps this state in module `let`s and
  * relies on dedup + a "multiple instances" warning. Node-ref fields are loosely typed
  * (`any`) to avoid import cycles with core.ts/runtime.ts; the public API stays fully typed.
+ *
+ * Sharing is deliberate, and a standalone web component makes it load-bearing: several
+ * independent bundles can land on one page, each carrying its own copy of this module, and they
+ * have to end up on one graph or an effect in one will not see a signal from another.
+ *
+ * Two consequences that the original `??=` got wrong once more than one version is in play.
+ * The first copy to run used to define the whole object, so a field added in a later
+ * release stayed absent for every copy, including the one that expected it. Fields are
+ * backfilled now instead. And nothing recorded which builds had joined, so a genuine
+ * mismatch was invisible; `joinedVersions()` reports it, and @fluixi/dom's version-skew
+ * warning is where that surfaces.
+ */
+import { VERSION } from '../../../version.generated.js';
+/**
+ * The graph is shared per major version.
+ *
+ * Copies of one major share it, which is the point: several bundles on a page each carry
+ * their own copy of this module, and an effect in one has to see a signal from another.
+ * Fields are backfilled below so a copy from a later release finds what it expects.
+ *
+ * A different major gets its own graph instead. Within a major the state shape only
+ * grows, so backfilling is enough; across one it can change meaning, and sharing then
+ * means the older copy's semantics silently win for everybody. Two isolated graphs on a
+ * page is a visible problem. One graph running two sets of rules is not.
+ *
+ * Derived from the package version rather than written by hand, so it cannot be
+ * forgotten at a major bump.
  */
-const KEY = '__fluixi_signal_next_state__';
+const MAJOR = VERSION.split('.')[0];
+const KEY = `__fluixi_signal_state_v${MAJOR}__`;
+const VERSIONS_KEY = `__fluixi_signal_builds_v${MAJOR}__`;
 const defaultSchedule = (run) => {
     if (typeof queueMicrotask === 'function')
         queueMicrotask(run);
     else
         void Promise.resolve().then(run);
 };
-export const G = 
+function defaults() {
+    return {
+        consumer: null,
+        untracked: false,
+        owner: null,
+        queue: [],
+        scheduled: false,
+        flushing: false,
+        batchDepth: 0,
+        hostSchedule: defaultSchedule,
+        onSuspend: null,
+        onError: null,
+        observer: null,
+    };
+}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-(globalThis[KEY] ??= {
-    consumer: null,
-    untracked: false,
-    owner: null,
-    queue: [],
-    scheduled: false,
-    flushing: false,
-    batchDepth: 0,
-    hostSchedule: defaultSchedule,
-    onSuspend: null,
-    onError: null,
-});
+const realm = globalThis;
+/**
+ * Add any field this release reads that an earlier copy never created.
+ *
+ * `in` rather than `??`, so a field whose default is null is not rewritten every time
+ * another copy loads. Mutates and returns the object it was given, because the whole
+ * point is that every copy keeps pointing at the same one.
+ */
+export function backfillState(existing) {
+    const fresh = defaults();
+    const target = existing;
+    for (const field of Object.keys(fresh)) {
+        if (!(field in existing))
+            target[field] = fresh[field];
+    }
+    return existing;
+}
+function claim() {
+    const existing = realm[KEY];
+    return existing ? backfillState(existing) : (realm[KEY] = defaults());
+}
+export const G = claim();
+// Which builds of this module reached the shared graph, in the order they loaded.
+// One entry is the normal case. More than one distinct version means two releases are
+// driving the same graph, which is worth saying out loud but not worth refusing: the
+// alternative is a page where half the components are inert.
+(realm[VERSIONS_KEY] ??= []).push(VERSION);
+/** Every `@fluixi/reactive` build that has joined the shared graph, deduplicated. */
+export function joinedVersions() {
+    return [...new Set((realm[VERSIONS_KEY] ?? []))];
+}

package/dist/lib/signal/graph/state.mjs

@@ -1 +1,49 @@
-var o="__fluixi_signal_next_state__",n=e=>{typeof queueMicrotask=="function"?queueMicrotask(e):Promise.resolve().then(e)},u=globalThis[o]??={consumer:null,untracked:!1,owner:null,queue:[],scheduled:!1,flushing:!1,batchDepth:0,hostSchedule:n,onSuspend:null,onError:null};export{u as G};
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.84";
+
+// src/lib/signal/graph/state.ts
+var MAJOR = VERSION.split(".")[0];
+var KEY = `__fluixi_signal_state_v${MAJOR}__`;
+var VERSIONS_KEY = `__fluixi_signal_builds_v${MAJOR}__`;
+var defaultSchedule = (run) => {
+  if (typeof queueMicrotask === "function") queueMicrotask(run);
+  else void Promise.resolve().then(run);
+};
+function defaults() {
+  return {
+    consumer: null,
+    untracked: false,
+    owner: null,
+    queue: [],
+    scheduled: false,
+    flushing: false,
+    batchDepth: 0,
+    hostSchedule: defaultSchedule,
+    onSuspend: null,
+    onError: null,
+    observer: null
+  };
+}
+var realm = globalThis;
+function backfillState(existing) {
+  const fresh = defaults();
+  const target = existing;
+  for (const field of Object.keys(fresh)) {
+    if (!(field in existing)) target[field] = fresh[field];
+  }
+  return existing;
+}
+function claim() {
+  const existing = realm[KEY];
+  return existing ? backfillState(existing) : realm[KEY] = defaults();
+}
+var G = claim();
+(realm[VERSIONS_KEY] ??= []).push(VERSION);
+function joinedVersions() {
+  return [...new Set(realm[VERSIONS_KEY] ?? [])];
+}
+export {
+  G,
+  backfillState,
+  joinedVersions
+};