@fluixi/reactive 1.0.0-alpha.100

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

@@ -0,0 +1,89 @@
+"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, {
+  createResourceCache: () => createResourceCache,
+  currentResourceCache: () => currentResourceCache,
+  getServerData: () => getServerData,
+  nextResourceId: () => nextResourceId,
+  reportResourceData: () => reportResourceData,
+  setResourceCacheScope: () => setResourceCacheScope,
+  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);
+}
+function createResourceCache() {
+  const entries = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => entries.get(key),
+    set: (key, entry) => void entries.set(key, entry),
+    delete: (key) => void entries.delete(key),
+    keys: () => entries.keys(),
+    clear: () => {
+      entries.clear();
+      inflight.clear();
+    },
+    inflight
+  };
+}
+var _cacheScope = null;
+function setResourceCacheScope(fn) {
+  _cacheScope = fn;
+}
+var _pageCache;
+function currentResourceCache() {
+  const scoped = _cacheScope?.();
+  if (scoped) return scoped;
+  if (typeof window === "undefined") return createResourceCache();
+  return _pageCache ??= createResourceCache();
+}

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

@@ -0,0 +1,51 @@
+/**
+ * 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,
+ * 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. */
+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. */
+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. */
+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. */
+export declare function reportResourceData(id: string, value: any): void;
+/** Where cached resources keep their entries and in-flight fetches. */
+export interface ResourceCacheEntry {
+    value: unknown;
+    /** Date.now() when it was fetched. */
+    timestamp: number;
+}
+export interface ResourceCache {
+    get(key: string): ResourceCacheEntry | undefined;
+    set(key: string, entry: ResourceCacheEntry): void;
+    delete(key: string): void;
+    keys(): Iterable<string>;
+    clear(): void;
+    /** Fetches running now, by key, so two readers share one request. Same scope as the entries. */
+    readonly inflight: Map<string, Promise<unknown>>;
+}
+/** A cache held in memory, values kept as they are (Dates, class instances). */
+export declare function createResourceCache(): ResourceCache;
+/**
+ * Inject the cache for the current scope. The server sets one per request, so two visitors
+ * never share an entry or an in-flight fetch.
+ */
+export declare function setResourceCacheScope(fn: (() => ResourceCache | undefined) | null): void;
+/** The cache for where this runs: the injected scope, else the page in a browser, else a private one. */
+export declare function currentResourceCache(): ResourceCache;
+//# sourceMappingURL=ssr-hooks.d.ts.map

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

@@ -0,0 +1 @@
+{"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;AAED,uEAAuE;AACvE,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,OAAO,CAAC;IACf,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAAC;IACjD,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAClD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,IAAI,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzB,KAAK,IAAI,IAAI,CAAC;IACd,gGAAgG;IAChG,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;CAClD;AAED,gFAAgF;AAChF,wBAAgB,mBAAmB,IAAI,aAAa,CAcnD;AAGD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,CAAC,MAAM,aAAa,GAAG,SAAS,CAAC,GAAG,IAAI,GAAG,IAAI,CAExF;AAKD,yGAAyG;AACzG,wBAAgB,oBAAoB,IAAI,aAAa,CAMpD"}

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

@@ -0,0 +1,80 @@
+/**
+ * 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,
+ * so they live in a TC39-owned module (not signal.ts, which is being retired).
+ */
+let _resourceTracker = null;
+/** Register a sink that receives every resource fetch promise (server: collect & await). */
+export function setResourceTracker(fn) {
+    _resourceTracker = fn;
+}
+/** @internal: resources report their fetch promise here. */
+export function trackResourcePromise(p) {
+    if (_resourceTracker)
+        _resourceTracker(p);
+}
+let _serverDataGetter = null;
+/** Inject server-serialized resource data (client hydration: seed without refetch). */
+export function setServerDataGetter(fn) {
+    _serverDataGetter = fn;
+}
+/** @internal: resources look up seeded data by their SSR id. */
+export function getServerData(id) {
+    return _serverDataGetter ? _serverDataGetter(id) : undefined;
+}
+let _resourceIdSource = null;
+/** Inject a stable per-resource id source (server render order / hydration order). */
+export function setResourceIdSource(fn) {
+    _resourceIdSource = fn;
+}
+/** @internal, a resource asks for its SSR id at creation; undefined on a plain client. */
+export function nextResourceId() {
+    return _resourceIdSource ? _resourceIdSource() : undefined;
+}
+let _resourceDataSink = null;
+/** Inject a sink for resolved resource values (server: collect for serialization). */
+export function setResourceDataSink(fn) {
+    _resourceDataSink = fn;
+}
+/** @internal, a resource reports its resolved value here. */
+export function reportResourceData(id, value) {
+    if (_resourceDataSink)
+        _resourceDataSink(id, value);
+}
+/** A cache held in memory, values kept as they are (Dates, class instances). */
+export function createResourceCache() {
+    const entries = new Map();
+    const inflight = new Map();
+    return {
+        get: (key) => entries.get(key),
+        set: (key, entry) => void entries.set(key, entry),
+        delete: (key) => void entries.delete(key),
+        keys: () => entries.keys(),
+        clear: () => {
+            entries.clear();
+            inflight.clear();
+        },
+        inflight,
+    };
+}
+let _cacheScope = null;
+/**
+ * Inject the cache for the current scope. The server sets one per request, so two visitors
+ * never share an entry or an in-flight fetch.
+ */
+export function setResourceCacheScope(fn) {
+    _cacheScope = fn;
+}
+// The browser serves one user, so the page is the scope there.
+let _pageCache;
+/** The cache for where this runs: the injected scope, else the page in a browser, else a private one. */
+export function currentResourceCache() {
+    const scoped = _cacheScope?.();
+    if (scoped)
+        return scoped;
+    // A server with no scope injected: nothing safe to share, so nothing is shared.
+    if (typeof window === 'undefined')
+        return createResourceCache();
+    return (_pageCache ??= createResourceCache());
+}

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

@@ -0,0 +1,68 @@
+// 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);
+}
+function createResourceCache() {
+  const entries = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => entries.get(key),
+    set: (key, entry) => void entries.set(key, entry),
+    delete: (key) => void entries.delete(key),
+    keys: () => entries.keys(),
+    clear: () => {
+      entries.clear();
+      inflight.clear();
+    },
+    inflight
+  };
+}
+var _cacheScope = null;
+function setResourceCacheScope(fn) {
+  _cacheScope = fn;
+}
+var _pageCache;
+function currentResourceCache() {
+  const scoped = _cacheScope?.();
+  if (scoped) return scoped;
+  if (typeof window === "undefined") return createResourceCache();
+  return _pageCache ??= createResourceCache();
+}
+export {
+  createResourceCache,
+  currentResourceCache,
+  getServerData,
+  nextResourceId,
+  reportResourceData,
+  setResourceCacheScope,
+  setResourceDataSink,
+  setResourceIdSource,
+  setResourceTracker,
+  setServerDataGetter,
+  trackResourcePromise
+};

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

@@ -0,0 +1,72 @@
+"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.100";
+
+// 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

@@ -0,0 +1,76 @@
+/**
+ * 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?",
+ * "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
+ * 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.
+ *
+ * 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. */
+    consumer: any;
+    /** When true, reads don't subscribe (untrack / peek). */
+    untracked: boolean;
+    /** The current owner scope (ownership/disposal/context). */
+    owner: any;
+    /** Pending effects awaiting flush. */
+    queue: Array<{
+        queued: boolean;
+        disposed: boolean;
+        run(): void;
+    }>;
+    /**
+     * 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;
+    /**
+     * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,99 @@
+/**
+ * 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?",
+ * "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
+ * 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.
+ *
+ * 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 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);
+};
+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
+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

@@ -0,0 +1,49 @@
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.100";
+
+// 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
+};