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

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

@@ -0,0 +1,163 @@
+"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/observe.ts
+var observe_exports = {};
+__export(observe_exports, {
+  enterReactiveRun: () => enterReactiveRun,
+  exitReactiveRun: () => exitReactiveRun,
+  isObserved: () => isObserved,
+  observeReactiveNodes: () => observeReactiveNodes,
+  reportReactiveBinding: () => reportReactiveBinding,
+  reportReactiveContext: () => reportReactiveContext,
+  reportReactiveContextCreated: () => reportReactiveContextCreated,
+  reportReactiveDirective: () => reportReactiveDirective,
+  reportReactiveDispose: () => reportReactiveDispose,
+  reportReactiveMove: () => reportReactiveMove,
+  reportReactiveNode: () => reportReactiveNode,
+  reportReactiveProps: () => reportReactiveProps,
+  reportReactiveRun: () => reportReactiveRun,
+  reportReactiveWrite: () => reportReactiveWrite,
+  withReactiveOrigin: () => withReactiveOrigin
+});
+module.exports = __toCommonJS(observe_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);
+
+// src/lib/signal/graph/observe.ts
+function observeReactiveNodes(next) {
+  G.observer = next;
+  return () => {
+    if (G.observer === next) G.observer = null;
+  };
+}
+var running = [];
+var origin;
+function withReactiveOrigin(owner, fn) {
+  if (!G.observer) return fn();
+  const previous = origin;
+  origin = owner;
+  try {
+    return fn();
+  } finally {
+    origin = previous;
+  }
+}
+function reportReactiveNode(report) {
+  const observer = G.observer;
+  if (observer) {
+    observer.created(
+      report.parents === void 0 ? { ...report, parents: running, origin: report.origin ?? origin } : report
+    );
+  }
+}
+function enterReactiveRun(node) {
+  if (!G.observer) return false;
+  running.push(node);
+  return true;
+}
+function exitReactiveRun() {
+  running.pop();
+}
+function reportReactiveRun(node) {
+  G.observer?.ran?.(node);
+}
+function reportReactiveWrite(node, by) {
+  G.observer?.wrote?.(node, by);
+}
+function reportReactiveBinding(target, kind, name, accessor) {
+  const observer = G.observer;
+  if (!observer?.bound || !running.length) return;
+  observer.bound(running[running.length - 1], target, kind, name, accessor);
+}
+function reportReactiveProps(props) {
+  const observer = G.observer;
+  if (!observer?.props || !running.length || !props) return;
+  observer.props(running[running.length - 1], props);
+}
+function reportReactiveDirective(target, kind, name, accessor) {
+  const observer = G.observer;
+  if (!observer?.directive || !running.length) return;
+  observer.directive(running[running.length - 1], target, kind, name, accessor);
+}
+function reportReactiveContextCreated(id) {
+  G.observer?.contextCreated?.(id);
+}
+function reportReactiveContext(id, kind, value) {
+  const observer = G.observer;
+  if (!observer?.context || !running.length) return;
+  observer.context(running[running.length - 1], id, kind, value);
+}
+function reportReactiveMove(node, origin2, name) {
+  G.observer?.moved?.(node, origin2, name);
+}
+function reportReactiveDispose(node) {
+  G.observer?.disposed?.(node);
+}
+var HOOK = "__FLUIXI_DEVTOOLS_HOOK__";
+var hook = globalThis[HOOK];
+if (typeof hook?.inject === "function") {
+  try {
+    hook.inject({ observeReactiveNodes, version: VERSION });
+  } catch {
+  }
+}
+function isObserved() {
+  return G.observer != null;
+}

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

@@ -0,0 +1,141 @@
+export type ReactiveNodeKind = 'signal' | 'memo' | 'effect' | 'store' | 'resource';
+export interface ReactiveNodeReport {
+    kind: ReactiveNodeKind;
+    /** The core node. Edges hang off this, and it is the identity later reports use. */
+    node: unknown;
+    /** What the caller was handed, when that is a different object from the node. */
+    handle?: unknown;
+    /** The name the call site gave, if it gave one. */
+    name?: string;
+    /**
+     * How to write it, for a signal. A watcher setting the value through this goes through
+     * the same path the application does, writing the node directly marks its readers dirty
+     * without ever flushing them, so the page keeps whatever it last rendered.
+     */
+    set?: (value: unknown) => void;
+    /**
+     * The node this one was built for. A store creates a signal per key, lazily, wherever it
+     * is first read, the useful location is the store's, not the reader's.
+     */
+    origin?: unknown;
+    /**
+     * The node is the framework's own plumbing, a render effect, one per dom binding. A graph
+     * does not show these, but it needs to know they exist: a row added to a list is created
+     * inside one, and without it the row has no ancestor it can be attached to.
+     */
+    internal?: boolean;
+    /**
+     * The computations running when this node was made, outermost first. A component's wrapper
+     * memo reads nothing itself, so what it created is the only thing tying it to the graph
+     * and the whole chain is given because the nearest one is often a render effect, which no
+     * graph shows.
+     *
+     * Live and reused: read it during the call, do not keep it.
+     */
+    parents?: readonly unknown[];
+}
+export interface ReactiveObserver {
+    created(report: ReactiveNodeReport): void;
+    /** A computation recomputed. Effects have no value to diff, so this is their only signal. */
+    ran?(node: unknown): void;
+    /** An effect was disposed. Memos and signals go with their owner and are not reported. */
+    disposed?(node: unknown): void;
+    /**
+     * A signal was written, and by which computation, nothing, when the write came from an
+     * event handler, which is where most of them come from.
+     */
+    wrote?(node: unknown, by: unknown): void;
+    /**
+     * A node now belongs somewhere else, and is called something else.
+     *
+     * A store write replaces the object that held a value: `set({ items: [...items, one] })`
+     * builds a new array, and the signals underneath it are the same signals in a new place.
+     * Without this they keep pointing at a node that no longer exists.
+     */
+    moved?(node: unknown, origin: unknown, name?: string): void;
+    /**
+     * A computation writes to this piece of the document. Only the dom layer knows a reader is
+     * the text of an `<li>` and not a `class`, and only as it wires the binding up.
+     *
+     * `node` is the render effect doing it. `accessor` is the function it reads, which the
+     * compiler may have stamped with the hole's position.
+     */
+    bound?(node: unknown, target: unknown, kind: string, name?: string, accessor?: unknown): void;
+    /**
+     * The props a component was handed.
+     *
+     * `node` is the computation the component was created inside, which is the node a watcher
+     * draws it as. The object is kept rather than read: every prop is a getter over whatever
+     * the caller passed, so reading one here would subscribe the wrong computation to it.
+     */
+    props?(node: unknown, props: unknown): void;
+    /**
+     * A directive applied to an element: `use:`, `class:`, `style:`, `bind:`.
+     *
+     * `bound` says a value writes to a class or a style but not which key, so two `class:`
+     * directives on one element both report as `class`. This carries the key too.
+     */
+    directive?(node: unknown, target: unknown, kind: string, name: string, accessor?: unknown): void;
+    /**
+     * A context provided or read.
+     *
+     * Nothing else in the graph records it: a provider stamps a value on the owner chain and a
+     * reader walks up looking for it, so neither is a dependency and no edge is ever made.
+     */
+    context?(node: unknown, id: symbol, kind: 'provide' | 'read', value?: unknown): void;
+    /**
+     * A context was created. Separate from providing it, because a context is usually made at
+     * module scope with nothing running, and the line it was written on is the one worth
+     * showing. The watcher reads its own stack for that.
+     */
+    contextCreated?(id: symbol): void;
+}
+/**
+ * Watch the graph. Returns a function that stops watching.
+ *
+ * One observer at a time, the last to register wins. Two tools watching one page at once is
+ * not a case worth carrying state for.
+ */
+export declare function observeReactiveNodes(next: ReactiveObserver): () => void;
+/** Attribute everything `fn` creates to `owner`. Free when nobody is watching. */
+export declare function withReactiveOrigin<T>(owner: unknown, fn: () => T): T;
+/** Called by the primitives. Not part of the public surface. */
+export declare function reportReactiveNode(report: ReactiveNodeReport): void;
+/** Called around a recompute, so a node can say what it was created inside. */
+export declare function enterReactiveRun(node: unknown): boolean;
+export declare function exitReactiveRun(): void;
+/** Called from the recompute path, so it stays a property read when nobody is watching. */
+export declare function reportReactiveRun(node: unknown): void;
+/** Called from the write path, so it stays a property read when nobody is watching. */
+export declare function reportReactiveWrite(node: unknown, by: unknown): void;
+/**
+ * The node is whatever is running: a binding is set up inside its own render effect. Nothing
+ * is pushed when no one is watching, so this stays a property read on the hot path.
+ */
+export declare function reportReactiveBinding(target: unknown, kind: string, name?: string, accessor?: unknown): void;
+/**
+ * A component's props, reported where it is created so the running computation is the one
+ * the props belong to. Nothing is read: the caller keeps the object and reads it untracked
+ * when someone asks.
+ */
+export declare function reportReactiveProps(props: unknown): void;
+/**
+ * As `reportReactiveBinding`: the node is whatever is running, since a directive is applied
+ * while its element is being built. A property read when nobody is watching.
+ */
+export declare function reportReactiveDirective(target: unknown, kind: string, name: string, accessor?: unknown): void;
+/** Called where the context is made, so a watcher can take the line from its own stack. */
+export declare function reportReactiveContextCreated(id: symbol): void;
+/** As the others: the node is whatever is running, and nothing happens without a watcher. */
+export declare function reportReactiveContext(id: symbol, kind: 'provide' | 'read', value?: unknown): void;
+export declare function reportReactiveMove(node: unknown, origin: unknown, name?: string): void;
+export declare function reportReactiveDispose(node: unknown): void;
+export interface DevtoolsHook {
+    inject?(runtime: {
+        observeReactiveNodes: typeof observeReactiveNodes;
+        version: string;
+    }): void;
+}
+/** Whether anything is watching, for a caller that would otherwise do work to report. */
+export declare function isObserved(): boolean;
+//# sourceMappingURL=observe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../../../../src/lib/signal/graph/observe.ts"],"names":[],"mappings":"AAmBA,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,UAAU,CAAC;AAEnF,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,gBAAgB,CAAC;IACvB,oFAAoF;IACpF,IAAI,EAAE,OAAO,CAAC;IACd,iFAAiF;IACjF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC/B;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC1C,6FAA6F;IAC7F,GAAG,CAAC,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,0FAA0F;IAC1F,QAAQ,CAAC,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B;;;OAGG;IACH,KAAK,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI,CAAC;IACzC;;;;;;OAMG;IACH,KAAK,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5D;;;;;;OAMG;IACH,KAAK,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC9F;;;;;;OAMG;IACH,KAAK,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5C;;;;;OAKG;IACH,SAAS,CAAC,CACR,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,OAAO,GACjB,IAAI,CAAC;IACR;;;;;OAKG;IACH,OAAO,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACrF;;;;OAIG;IACH,cAAc,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,IAAI,CAKvE;AAQD,kFAAkF;AAClF,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CASpE;AAED,gEAAgE;AAChE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,CASnE;AAED,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAIvD;AAED,wBAAgB,eAAe,IAAI,IAAI,CAEtC;AAED,2FAA2F;AAC3F,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAErD;AAED,uFAAuF;AACvF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI,CAEpE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,OAAO,GACjB,IAAI,CAMN;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAIxD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,OAAO,GACjB,IAAI,CAIN;AAED,2FAA2F;AAC3F,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAE7D;AAED,6FAA6F;AAC7F,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,SAAS,GAAG,MAAM,EACxB,KAAK,CAAC,EAAE,OAAO,GACd,IAAI,CAIN;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAEtF;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAEzD;AAcD,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,CAAC,OAAO,EAAE;QAAE,oBAAoB,EAAE,OAAO,oBAAoB,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CAChG;AAWD,yFAAyF;AACzF,wBAAgB,UAAU,IAAI,OAAO,CAEpC"}

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

@@ -0,0 +1,149 @@
+/**
+ * A place for a tool to watch the reactive graph from outside it.
+ *
+ * The runtime says a node exists, a computation re-ran, or an effect went away, and hands
+ * over the node itself. It does nothing else. Edges are already on the node, a source keeps
+ * its `observers`, a consumer keeps its `sources`, so a watcher reads the graph rather than
+ * reconstructing it, and nothing here wraps or replaces a primitive.
+ *
+ * Nothing is registered by default: an unwatched runtime pays one null check per node
+ * creation and per recompute.
+ *
+ * @fluixi/devtools is the intended caller. Nothing in the framework reads it back.
+ *
+ * The observer lives on the shared graph state rather than in a module `let`, so a bundle
+ * carrying two copies of this module still has one observer, the same reason G exists.
+ */
+import { G } from './state.js';
+import { VERSION } from '../../../version.generated.js';
+/**
+ * Watch the graph. Returns a function that stops watching.
+ *
+ * One observer at a time, the last to register wins. Two tools watching one page at once is
+ * not a case worth carrying state for.
+ */
+export function observeReactiveNodes(next) {
+    G.observer = next;
+    return () => {
+        if (G.observer === next)
+            G.observer = null;
+    };
+}
+/** What is running right now, outermost first. Empty unless something is watching. */
+const running = [];
+/** What the nodes created in here belong to. See ReactiveNodeReport.origin. */
+let origin;
+/** Attribute everything `fn` creates to `owner`. Free when nobody is watching. */
+export function withReactiveOrigin(owner, fn) {
+    if (!G.observer)
+        return fn();
+    const previous = origin;
+    origin = owner;
+    try {
+        return fn();
+    }
+    finally {
+        origin = previous;
+    }
+}
+/** Called by the primitives. Not part of the public surface. */
+export function reportReactiveNode(report) {
+    const observer = G.observer;
+    // Filled here rather than at each call site: the stack is already on hand, and a report
+    // costs nothing to build when nobody is watching.
+    if (observer) {
+        observer.created(report.parents === undefined ? { ...report, parents: running, origin: report.origin ?? origin } : report);
+    }
+}
+/** Called around a recompute, so a node can say what it was created inside. */
+export function enterReactiveRun(node) {
+    if (!G.observer)
+        return false;
+    running.push(node);
+    return true;
+}
+export function exitReactiveRun() {
+    running.pop();
+}
+/** Called from the recompute path, so it stays a property read when nobody is watching. */
+export function reportReactiveRun(node) {
+    G.observer?.ran?.(node);
+}
+/** Called from the write path, so it stays a property read when nobody is watching. */
+export function reportReactiveWrite(node, by) {
+    G.observer?.wrote?.(node, by);
+}
+/**
+ * The node is whatever is running: a binding is set up inside its own render effect. Nothing
+ * is pushed when no one is watching, so this stays a property read on the hot path.
+ */
+export function reportReactiveBinding(target, kind, name, accessor) {
+    const observer = G.observer;
+    if (!observer?.bound || !running.length)
+        return;
+    // The compiler may have stamped the accessor with the hole's line. A stack cannot say it:
+    // every binding in a template comes from the same generated expression.
+    observer.bound(running[running.length - 1], target, kind, name, accessor);
+}
+/**
+ * A component's props, reported where it is created so the running computation is the one
+ * the props belong to. Nothing is read: the caller keeps the object and reads it untracked
+ * when someone asks.
+ */
+export function reportReactiveProps(props) {
+    const observer = G.observer;
+    if (!observer?.props || !running.length || !props)
+        return;
+    observer.props(running[running.length - 1], props);
+}
+/**
+ * As `reportReactiveBinding`: the node is whatever is running, since a directive is applied
+ * while its element is being built. A property read when nobody is watching.
+ */
+export function reportReactiveDirective(target, kind, name, accessor) {
+    const observer = G.observer;
+    if (!observer?.directive || !running.length)
+        return;
+    observer.directive(running[running.length - 1], target, kind, name, accessor);
+}
+/** Called where the context is made, so a watcher can take the line from its own stack. */
+export function reportReactiveContextCreated(id) {
+    G.observer?.contextCreated?.(id);
+}
+/** As the others: the node is whatever is running, and nothing happens without a watcher. */
+export function reportReactiveContext(id, kind, value) {
+    const observer = G.observer;
+    if (!observer?.context || !running.length)
+        return;
+    observer.context(running[running.length - 1], id, kind, value);
+}
+export function reportReactiveMove(node, origin, name) {
+    G.observer?.moved?.(node, origin, name);
+}
+export function reportReactiveDispose(node) {
+    G.observer?.disposed?.(node);
+}
+/**
+ * Where a tool that cannot be imported finds the runtime.
+ *
+ * An extension has no way into an application's module graph, and an application should not
+ * have to import a debugger to be debuggable. So a tool sets this global before any of the
+ * app loads, and the runtime hands it the door on the way past.
+ *
+ * Set it too late and nothing happens, the runtime only offers once, when this module is
+ * first evaluated. A browser agent has to run at document_start for that reason.
+ */
+const HOOK = '__FLUIXI_DEVTOOLS_HOOK__';
+const hook = globalThis[HOOK];
+if (typeof hook?.inject === 'function') {
+    try {
+        hook.inject({ observeReactiveNodes, version: VERSION });
+    }
+    catch {
+        // A broken tool is not the application's problem.
+    }
+}
+/** Whether anything is watching, for a caller that would otherwise do work to report. */
+export function isObserved() {
+    return G.observer != null;
+}

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

@@ -0,0 +1,140 @@
+// 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);
+
+// src/lib/signal/graph/observe.ts
+function observeReactiveNodes(next) {
+  G.observer = next;
+  return () => {
+    if (G.observer === next) G.observer = null;
+  };
+}
+var running = [];
+var origin;
+function withReactiveOrigin(owner, fn) {
+  if (!G.observer) return fn();
+  const previous = origin;
+  origin = owner;
+  try {
+    return fn();
+  } finally {
+    origin = previous;
+  }
+}
+function reportReactiveNode(report) {
+  const observer = G.observer;
+  if (observer) {
+    observer.created(
+      report.parents === void 0 ? { ...report, parents: running, origin: report.origin ?? origin } : report
+    );
+  }
+}
+function enterReactiveRun(node) {
+  if (!G.observer) return false;
+  running.push(node);
+  return true;
+}
+function exitReactiveRun() {
+  running.pop();
+}
+function reportReactiveRun(node) {
+  G.observer?.ran?.(node);
+}
+function reportReactiveWrite(node, by) {
+  G.observer?.wrote?.(node, by);
+}
+function reportReactiveBinding(target, kind, name, accessor) {
+  const observer = G.observer;
+  if (!observer?.bound || !running.length) return;
+  observer.bound(running[running.length - 1], target, kind, name, accessor);
+}
+function reportReactiveProps(props) {
+  const observer = G.observer;
+  if (!observer?.props || !running.length || !props) return;
+  observer.props(running[running.length - 1], props);
+}
+function reportReactiveDirective(target, kind, name, accessor) {
+  const observer = G.observer;
+  if (!observer?.directive || !running.length) return;
+  observer.directive(running[running.length - 1], target, kind, name, accessor);
+}
+function reportReactiveContextCreated(id) {
+  G.observer?.contextCreated?.(id);
+}
+function reportReactiveContext(id, kind, value) {
+  const observer = G.observer;
+  if (!observer?.context || !running.length) return;
+  observer.context(running[running.length - 1], id, kind, value);
+}
+function reportReactiveMove(node, origin2, name) {
+  G.observer?.moved?.(node, origin2, name);
+}
+function reportReactiveDispose(node) {
+  G.observer?.disposed?.(node);
+}
+var HOOK = "__FLUIXI_DEVTOOLS_HOOK__";
+var hook = globalThis[HOOK];
+if (typeof hook?.inject === "function") {
+  try {
+    hook.inject({ observeReactiveNodes, version: VERSION });
+  } catch {
+  }
+}
+function isObserved() {
+  return G.observer != null;
+}
+export {
+  enterReactiveRun,
+  exitReactiveRun,
+  isObserved,
+  observeReactiveNodes,
+  reportReactiveBinding,
+  reportReactiveContext,
+  reportReactiveContextCreated,
+  reportReactiveDirective,
+  reportReactiveDispose,
+  reportReactiveMove,
+  reportReactiveNode,
+  reportReactiveProps,
+  reportReactiveRun,
+  reportReactiveWrite,
+  withReactiveOrigin
+};