@hyperfixi/reactivity 2.4.0

package/dist/index.js

@@ -0,0 +1,744 @@
+// src/signals.ts
+function debugEnabled() {
+  try {
+    return typeof localStorage !== "undefined" && localStorage.getItem("hyperfixi:debug") !== null;
+  } catch {
+    return false;
+  }
+}
+function debugWarn(message, err) {
+  if (!debugEnabled()) return;
+  if (typeof console === "undefined") return;
+  console.warn(`[@hyperfixi/reactivity] ${message}`, err);
+}
+var globalDepKey = (name) => `global:${name}`;
+var elementDepKey = (el, name) => `element:${reactiveIdFor(el)}:${name}`;
+var domDepKey = (el, prop) => `dom:${reactiveIdFor(el)}:${prop}`;
+var _reactiveIds = /* @__PURE__ */ new WeakMap();
+var _idCounter = 0;
+function reactiveIdFor(el) {
+  const existing = _reactiveIds.get(el);
+  if (existing !== void 0) return existing;
+  const id = ++_idCounter;
+  _reactiveIds.set(el, id);
+  return id;
+}
+var Effect = class {
+  constructor(r, expression, handler, element) {
+    this.r = r;
+    this.expression = expression;
+    this.handler = handler;
+    this.element = element;
+  }
+  dependencies = /* @__PURE__ */ new Map();
+  lastValue = void 0;
+  _stopped = false;
+  _consecutiveTriggers = 0;
+  get stopped() {
+    return this._stopped;
+  }
+  /**
+   * Run the effect for the first time: collect dependencies, subscribe, call
+   * handler with the initial value. Errors in expression evaluation are caught
+   * and silently swallowed (matches upstream's tolerance).
+   */
+  async initialize() {
+    if (this._stopped) return;
+    try {
+      const value = await this.r._runWithEffect(this, this.expression);
+      this.lastValue = value;
+      if (value !== void 0 && value !== null) {
+        await this.handler(value);
+      }
+    } catch (err) {
+      debugWarn("effect.initialize failed", err);
+    }
+  }
+  /**
+   * Re-run the effect after a notify. Cycle-detects (halts at 101 consecutive
+   * triggers). If the new value is Object.is-equal to the last, the handler
+   * is skipped. If the owning element has disconnected, the effect stops
+   * itself and returns.
+   */
+  async run() {
+    if (this._stopped) return;
+    if (this.element && !this.element.isConnected) {
+      this.stop();
+      return;
+    }
+    this._consecutiveTriggers++;
+    if (this._consecutiveTriggers > 100) {
+      if (typeof console !== "undefined") {
+        console.error(
+          "[@hyperfixi/reactivity] Effect halted: > 100 consecutive triggers (cycle detected)."
+        );
+      }
+      this.stop();
+      return;
+    }
+    try {
+      const value = await this.r._runWithEffect(this, this.expression);
+      if (Object.is(value, this.lastValue)) return;
+      this.lastValue = value;
+      await this.handler(value);
+    } catch (err) {
+      debugWarn("effect.run failed", err);
+    }
+  }
+  resetTriggerCount() {
+    this._consecutiveTriggers = 0;
+  }
+  /**
+   * Stop the effect and remove it from all dependency subscriptions. Safe to
+   * call multiple times.
+   */
+  stop() {
+    if (this._stopped) return;
+    this._stopped = true;
+    this.r._unsubscribeEffect(this);
+    this.dependencies.clear();
+  }
+};
+var Reactive = class {
+  currentEffect = null;
+  pending = /* @__PURE__ */ new Set();
+  scheduled = false;
+  globalSubs = /* @__PURE__ */ new Map();
+  elementState = /* @__PURE__ */ new WeakMap();
+  getElementState(el) {
+    let s = this.elementState.get(el);
+    if (!s) {
+      s = {
+        symbolSubs: /* @__PURE__ */ new Map(),
+        caretVars: /* @__PURE__ */ new Map(),
+        domHandlers: /* @__PURE__ */ new Map(),
+        effects: /* @__PURE__ */ new Set()
+      };
+      this.elementState.set(el, s);
+    }
+    return s;
+  }
+  /**
+   * Internal helper invoked by Effect — installs `this` as the current effect,
+   * runs the expression, then restores the previous current-effect pointer.
+   * Track* methods (called from read-paths) consult `currentEffect` to know
+   * which effect to subscribe.
+   */
+  async _runWithEffect(e, fn) {
+    const prev = this.currentEffect;
+    this.currentEffect = e;
+    this._unsubscribeEffect(e);
+    e.dependencies.clear();
+    try {
+      return await fn();
+    } finally {
+      this.currentEffect = prev;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Track (read-path) — invoked from interceptors / evaluators.
+  // ---------------------------------------------------------------------------
+  trackGlobal(name) {
+    const e = this.currentEffect;
+    if (!e) return;
+    const key = globalDepKey(name);
+    if (e.dependencies.has(key)) return;
+    e.dependencies.set(key, { key, kind: "global", name, element: null });
+    let subs = this.globalSubs.get(name);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.globalSubs.set(name, subs);
+    }
+    subs.add(e);
+  }
+  trackElement(el, name) {
+    const e = this.currentEffect;
+    if (!e) return;
+    const key = elementDepKey(el, name);
+    if (e.dependencies.has(key)) return;
+    e.dependencies.set(key, { key, kind: "element", name, element: el });
+    const state = this.getElementState(el);
+    let subs = state.symbolSubs.get(name);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      state.symbolSubs.set(name, subs);
+    }
+    subs.add(e);
+    state.effects.add(e);
+  }
+  trackDomProperty(el, prop) {
+    const e = this.currentEffect;
+    if (!e) return;
+    const key = domDepKey(el, prop);
+    if (e.dependencies.has(key)) return;
+    e.dependencies.set(key, { key, kind: "dom", name: prop, element: el });
+    const state = this.getElementState(el);
+    let handler = state.domHandlers.get(prop);
+    if (!handler) {
+      const subs = /* @__PURE__ */ new Set();
+      const listener = () => {
+        for (const effect of subs) this.schedule(effect);
+      };
+      el.addEventListener("input", listener);
+      el.addEventListener("change", listener);
+      handler = {
+        subs,
+        detach: () => {
+          el.removeEventListener("input", listener);
+          el.removeEventListener("change", listener);
+        }
+      };
+      state.domHandlers.set(prop, handler);
+    }
+    handler.subs.add(e);
+    state.effects.add(e);
+  }
+  // ---------------------------------------------------------------------------
+  // Notify (write-path) — schedules dependent effects for re-run.
+  // ---------------------------------------------------------------------------
+  notifyGlobal(name) {
+    const subs = this.globalSubs.get(name);
+    if (!subs) return;
+    for (const e of subs) this.schedule(e);
+  }
+  notifyElement(el, name) {
+    const state = this.elementState.get(el);
+    if (!state) return;
+    const subs = state.symbolSubs.get(name);
+    if (!subs) return;
+    for (const e of subs) this.schedule(e);
+  }
+  // ---------------------------------------------------------------------------
+  // Effect lifecycle.
+  // ---------------------------------------------------------------------------
+  /**
+   * Create + initialize an effect. Returns a disposer that stops the effect.
+   * Callers are expected to register the disposer with the core runtime's
+   * cleanup registry so it fires on element removal.
+   */
+  createEffect(expression, handler, owner) {
+    const e = new Effect(this, expression, handler, owner);
+    if (owner) this.getElementState(owner).effects.add(e);
+    queueMicrotask(() => {
+      void e.initialize();
+    });
+    return () => e.stop();
+  }
+  /**
+   * Stop all effects owned by an element. Called by the reactivity plugin's
+   * cleanup hook registered via `runtime.getCleanupRegistry()`.
+   */
+  stopElementEffects(el) {
+    const state = this.elementState.get(el);
+    if (!state) return;
+    for (const e of Array.from(state.effects)) e.stop();
+    state.effects.clear();
+  }
+  /**
+   * Internal: remove an effect's entries from all subscriber sets. Called by
+   * `Effect.stop()`.
+   */
+  _unsubscribeEffect(e) {
+    for (const dep of e.dependencies.values()) {
+      if (dep.kind === "global") {
+        const subs = this.globalSubs.get(dep.name);
+        subs?.delete(e);
+      } else if (dep.kind === "element" && dep.element) {
+        const state = this.elementState.get(dep.element);
+        const subs = state?.symbolSubs.get(dep.name);
+        subs?.delete(e);
+        state?.effects.delete(e);
+      } else if (dep.kind === "dom" && dep.element) {
+        const state = this.elementState.get(dep.element);
+        const handler = state?.domHandlers.get(dep.name);
+        handler?.subs.delete(e);
+        if (handler && handler.subs.size === 0) {
+          handler.detach();
+          state?.domHandlers.delete(dep.name);
+        }
+        state?.effects.delete(e);
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Caret-variable storage — `^name` reads/writes.
+  // ---------------------------------------------------------------------------
+  /**
+   * Whether `el` is a `dom-scope="isolated"` boundary. Walks of `^var`
+   * lookups stop at boundary elements that don't define the var, so nested
+   * components don't accidentally read or write each other's state.
+   */
+  isIsolationBoundary(el) {
+    return typeof el.getAttribute === "function" && el.getAttribute("dom-scope") === "isolated";
+  }
+  /**
+   * Walk up the DOM tree from `lookupRoot`, returning the first element whose
+   * state has `name` defined. Stops at any `dom-scope="isolated"` boundary
+   * that doesn't itself define the var. Returns `null` if no owner is found.
+   */
+  findCaretOwner(lookupRoot, name) {
+    let el = lookupRoot;
+    while (el) {
+      const state = this.elementState.get(el);
+      if (state && state.caretVars.has(name)) return el;
+      if (this.isIsolationBoundary(el)) return null;
+      el = el.parentElement;
+    }
+    return null;
+  }
+  /**
+   * Read a DOM-scoped variable. Walks up from `lookupRoot`, tracking each
+   * element visited as an `element` dep (so writes at any ancestor notify
+   * dependent effects). Stops at any `dom-scope="isolated"` boundary that
+   * doesn't itself define the var.
+   */
+  readCaret(lookupRoot, name) {
+    let el = lookupRoot;
+    while (el) {
+      this.trackElement(el, name);
+      const state = this.elementState.get(el);
+      if (state && state.caretVars.has(name)) {
+        return state.caretVars.get(name);
+      }
+      if (this.isIsolationBoundary(el)) return void 0;
+      el = el.parentElement;
+    }
+    return void 0;
+  }
+  /**
+   * Write a DOM-scoped variable. If `target` is provided, writes there
+   * directly; otherwise walks up from `lookupRoot` to find the existing owner,
+   * falling back to `lookupRoot` itself if no owner exists.
+   */
+  writeCaret(lookupRoot, name, value, target) {
+    const owner = target ?? this.findCaretOwner(lookupRoot, name) ?? lookupRoot;
+    const state = this.getElementState(owner);
+    state.caretVars.set(name, value);
+    this.notifyElement(owner, name);
+  }
+  // ---------------------------------------------------------------------------
+  // Scheduler — microtask-batched flush.
+  // ---------------------------------------------------------------------------
+  schedule(e) {
+    if (e.stopped) return;
+    this.pending.add(e);
+    if (this.scheduled) return;
+    this.scheduled = true;
+    queueMicrotask(() => void this.flush());
+  }
+  async flush() {
+    try {
+      while (this.pending.size > 0) {
+        const batch = Array.from(this.pending);
+        this.pending.clear();
+        for (const e of batch) {
+          if (e.stopped) continue;
+          await e.run();
+          if (!this.pending.has(e)) e.resetTriggerCount();
+        }
+      }
+    } finally {
+      this.scheduled = false;
+    }
+  }
+};
+var reactive = new Reactive();
+
+// src/caret-var.ts
+function coerceToElement(value) {
+  if (value instanceof Element) return value;
+  if (Array.isArray(value) && value[0] instanceof Element) return value[0];
+  return null;
+}
+function parseCaretPrefix(token, ctx) {
+  const pctx = ctx;
+  const ident = pctx.advance();
+  if (!ident || !ident.value) {
+    throw new Error("Expected identifier after '^'");
+  }
+  let onTarget = null;
+  const next = pctx.peek();
+  if (next && next.value === "on") {
+    pctx.advance();
+    onTarget = pctx.parseExpr(86);
+  }
+  const startTok = token;
+  return {
+    type: "caretVar",
+    name: ident.value,
+    onTarget,
+    start: startTok?.start ?? 0,
+    end: startTok?.end ?? 0,
+    line: startTok?.line,
+    column: startTok?.column
+  };
+}
+function makeEvaluateCaretVar(runtime) {
+  return async function evaluateCaretVar(node, ctx) {
+    const n = node;
+    const context = ctx;
+    let anchor = context.me ?? null;
+    if (n.onTarget) {
+      const resolved = await runtime.execute(n.onTarget, context);
+      const el = coerceToElement(resolved);
+      if (el) anchor = el;
+    }
+    if (!anchor) return void 0;
+    return reactive.readCaret(anchor, n.name);
+  };
+}
+function makeWriteCaretVar(runtime) {
+  return async function writeCaretVar(node, value, ctx) {
+    const n = node;
+    const context = ctx;
+    const anchor = context.me ?? null;
+    if (!anchor) return;
+    let target;
+    if (n.onTarget) {
+      const resolved = await runtime.execute(n.onTarget, context);
+      const el = coerceToElement(resolved);
+      if (el) target = el;
+    }
+    reactive.writeCaret(anchor, n.name, value, target);
+  };
+}
+
+// src/live.ts
+function parseLiveFeature(ctx, token) {
+  const pctx = ctx;
+  const body = pctx.parseCommandListUntilEnd();
+  if (!pctx.isAtEnd() && pctx.check("end")) pctx.match("end");
+  const tok = token;
+  return {
+    type: "liveFeature",
+    body,
+    start: tok?.start ?? 0,
+    end: pctx.getPosition().end,
+    line: tok?.line,
+    column: tok?.column
+  };
+}
+function makeEvaluateLiveFeature(runtime) {
+  return async function evaluateLiveFeature(node, ctx) {
+    const context = ctx;
+    const owner = context.me ?? document.body;
+    const n = node;
+    const stop = reactive.createEffect(
+      async () => {
+        for (const cmd of n.body) {
+          await runtime.execute(cmd, context);
+        }
+      },
+      () => {
+      },
+      owner
+    );
+    context.registerCleanup?.(owner, stop, "live-effect");
+    return void 0;
+  };
+}
+
+// src/when.ts
+function parseWhenFeature(ctx, token) {
+  const pctx = ctx;
+  const watched = [pctx.parseExpression()];
+  while (pctx.match("or")) {
+    watched.push(pctx.parseExpression());
+  }
+  pctx.consume("changes", "Expected 'changes' after when expression list");
+  const body = pctx.parseCommandListUntilEnd();
+  if (!pctx.isAtEnd() && pctx.check("end")) pctx.match("end");
+  const tok = token;
+  return {
+    type: "whenFeature",
+    watched,
+    body,
+    start: tok?.start ?? 0,
+    end: pctx.getPosition().end,
+    line: tok?.line,
+    column: tok?.column
+  };
+}
+function makeEvaluateWhenFeature(runtime) {
+  return async function evaluateWhenFeature(node, ctx) {
+    const context = ctx;
+    const owner = context.me ?? document.body;
+    const n = node;
+    for (const watchedExpr of n.watched) {
+      const stop = reactive.createEffect(
+        async () => {
+          return await runtime.execute(watchedExpr, context);
+        },
+        async (newValue) => {
+          const subCtx = { ...context, it: newValue, result: newValue };
+          for (const cmd of n.body) {
+            await runtime.execute(cmd, subCtx);
+          }
+        },
+        owner
+      );
+      context.registerCleanup?.(owner, stop, "when-effect");
+    }
+    return void 0;
+  };
+}
+
+// src/bind.ts
+function parseBindFeature(ctx, token) {
+  const pctx = ctx;
+  const left = pctx.parseExpression();
+  if (!(pctx.match("to") || pctx.match("and") || pctx.match("with"))) {
+    throw new Error("bind requires 'to', 'and', or 'with' between the two sides");
+  }
+  const right = pctx.parseExpression();
+  if (pctx.check("end")) pctx.match("end");
+  const tok = token;
+  return {
+    type: "bindFeature",
+    left,
+    right,
+    start: tok?.start ?? 0,
+    end: pctx.getPosition().end,
+    line: tok?.line,
+    column: tok?.column
+  };
+}
+function detectProperty(el) {
+  const tag = el.tagName;
+  if (tag === "INPUT") {
+    const type = el.type;
+    if (type === "checkbox" || type === "radio") return "checked";
+    if (type === "number" || type === "range") return "valueAsNumber";
+    return "value";
+  }
+  if (tag === "TEXTAREA" || tag === "SELECT") return "value";
+  const ce = el.contentEditable;
+  if (ce === "true") return "textContent";
+  if ("value" in el) return "value";
+  return null;
+}
+function unwrapExplicitProperty(node) {
+  if (!node || node.type !== "memberExpression" && node.type !== "possessiveExpression") {
+    return null;
+  }
+  if (node.type === "memberExpression" && node.computed === true) return null;
+  const property = node.property;
+  const object = node.object;
+  if (!property || !object || property.type !== "identifier") return null;
+  const name = property.name ?? "";
+  if (!name) return null;
+  return { element: object, propertyName: name };
+}
+function isChainedMember(node) {
+  if (!node) return false;
+  return node.type === "memberExpression" || node.type === "possessiveExpression";
+}
+function isFormLikeElement(el) {
+  const tag = el.tagName;
+  if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
+  if (el.contentEditable === "true") return true;
+  return false;
+}
+function debugEnabled2() {
+  try {
+    return typeof localStorage !== "undefined" && localStorage.getItem("hyperfixi:debug") !== null;
+  } catch {
+    return false;
+  }
+}
+function makeEvaluateBindFeature(runtime) {
+  return async function evaluateBindFeature(node, ctx) {
+    const context = ctx;
+    const owner = context.me ?? document.body;
+    const n = node;
+    const leftIsVar = isVarRef(n.left);
+    const rightIsVar = isVarRef(n.right);
+    let varSide = null;
+    let domSide = null;
+    if (leftIsVar && !rightIsVar) {
+      varSide = varRefInfo(n.left);
+      domSide = { exprNode: n.right };
+    } else if (rightIsVar && !leftIsVar) {
+      varSide = varRefInfo(n.right);
+      domSide = { exprNode: n.left };
+    } else if (leftIsVar && rightIsVar) {
+      throw new Error("bind: cannot bind two symbols together (need a DOM side)");
+    } else {
+      throw new Error("bind: could not identify a symbol side");
+    }
+    const explicit = unwrapExplicitProperty(domSide.exprNode);
+    if (explicit && isChainedMember(explicit.element)) {
+      throw new Error(
+        "bind: multi-level property access (e.g., `#el.a.b`) is not supported in v1 \u2014 restructure to a single property write or pass the element directly for auto-detection (e.g., `bind $x to #el`)."
+      );
+    }
+    const elementExpr = explicit ? explicit.element : domSide.exprNode;
+    const domValue = await runtime.execute(elementExpr, context);
+    if (!(domValue instanceof Element)) {
+      const valueType = domValue === null ? "null" : domValue === void 0 ? "undefined" : typeof domValue;
+      const snippet = domValue !== null && domValue !== void 0 ? ` "${String(domValue).slice(0, 40)}"` : "";
+      const suggestion = explicit ? "" : " If you meant to write to a property, use the explicit form: `<selector>'s <property>`.";
+      throw new Error(
+        `bind: right-hand side did not resolve to an element (got ${valueType}${snippet}).${suggestion}`
+      );
+    }
+    const el = domValue;
+    const prop = explicit ? explicit.propertyName : detectProperty(el);
+    if (!prop) {
+      throw new Error(
+        `bind: could not auto-detect property for <${el.tagName.toLowerCase()}> \u2014 use explicit \`<expr>'s <property>\` form`
+      );
+    }
+    const installDomToVar = !explicit || isFormLikeElement(el);
+    if (explicit && !installDomToVar && debugEnabled2() && typeof console !== "undefined") {
+      console.warn(
+        `[@hyperfixi/reactivity] bind: DOM\u2192var skipped for <${el.tagName.toLowerCase()}>.${prop} \u2014 no input/change event source.`
+      );
+    }
+    const readDom = () => {
+      if (prop === "valueAsNumber") return el.valueAsNumber;
+      if (prop === "checked") return el.checked;
+      if (prop === "textContent") return el.textContent ?? "";
+      return el[prop];
+    };
+    const writeDom = (value) => {
+      if (prop === "valueAsNumber") {
+        const n2 = Number(value);
+        el.valueAsNumber = Number.isNaN(n2) ? null : n2;
+      } else if (prop === "checked") {
+        el.checked = Boolean(value);
+      } else if (prop === "textContent") {
+        el.textContent = value == null ? "" : String(value);
+      } else {
+        el[prop] = value;
+      }
+    };
+    const readVar = () => {
+      if (varSide.isGlobal) return context.globals?.get(varSide.name);
+      return context.locals?.get(varSide.name);
+    };
+    const writeVar = (value) => {
+      if (varSide.isGlobal) {
+        context.globals?.set(varSide.name, value);
+        reactive.notifyGlobal(varSide.name);
+      } else {
+        context.locals?.set(varSide.name, value);
+        reactive.notifyElement(owner, varSide.name);
+      }
+    };
+    let stopDomToVar = null;
+    if (installDomToVar) {
+      stopDomToVar = reactive.createEffect(
+        () => {
+          reactive.trackDomProperty(el, prop);
+          return readDom();
+        },
+        (newValue) => {
+          writeVar(newValue);
+        },
+        owner
+      );
+    }
+    const stopVarToDom = reactive.createEffect(
+      () => {
+        if (varSide.isGlobal) reactive.trackGlobal(varSide.name);
+        else reactive.trackElement(owner, varSide.name);
+        return readVar();
+      },
+      (newValue) => {
+        if (newValue === void 0) return;
+        writeDom(newValue);
+      },
+      owner
+    );
+    if (stopDomToVar) context.registerCleanup?.(owner, stopDomToVar, "bind-dom-to-var");
+    context.registerCleanup?.(owner, stopVarToDom, "bind-var-to-dom");
+    return void 0;
+  };
+}
+function isVarRef(node) {
+  if (!node) return false;
+  if (node.type !== "identifier") return false;
+  const scope = node.scope;
+  if (scope === "local" || scope === "global") return true;
+  const name = node.name ?? "";
+  return name.startsWith("$") || name.startsWith(":");
+}
+function varRefInfo(node) {
+  const rawName = node.name ?? "";
+  const scope = node.scope;
+  let isGlobal;
+  let name;
+  if (scope === "global") {
+    isGlobal = true;
+    name = rawName;
+  } else if (scope === "local") {
+    isGlobal = false;
+    name = rawName;
+  } else if (rawName.startsWith("$")) {
+    isGlobal = true;
+    name = rawName.slice(1);
+  } else if (rawName.startsWith(":")) {
+    isGlobal = false;
+    name = rawName.slice(1);
+  } else {
+    isGlobal = false;
+    name = rawName;
+  }
+  if (!name) {
+    throw new Error("bind: variable reference has empty name");
+  }
+  return { name, isGlobal };
+}
+
+// src/index.ts
+var reactivityPlugin = {
+  name: "@hyperfixi/reactivity",
+  version: "2.3.1",
+  install(ctx) {
+    const { parserExtensions, runtime } = ctx;
+    if (parserExtensions.hasFeature("live")) return;
+    parserExtensions.registerFeature("live", parseLiveFeature);
+    parserExtensions.registerFeature("when", parseWhenFeature);
+    parserExtensions.registerFeature("bind", parseBindFeature);
+    parserExtensions.registerPrefixOperator("^", 85, parseCaretPrefix);
+    parserExtensions.registerNodeEvaluator(
+      "liveFeature",
+      makeEvaluateLiveFeature(runtime)
+    );
+    parserExtensions.registerNodeEvaluator(
+      "whenFeature",
+      makeEvaluateWhenFeature(runtime)
+    );
+    parserExtensions.registerNodeEvaluator(
+      "bindFeature",
+      makeEvaluateBindFeature(runtime)
+    );
+    parserExtensions.registerNodeEvaluator(
+      "caretVar",
+      makeEvaluateCaretVar(runtime)
+    );
+    parserExtensions.registerNodeWriter("caretVar", makeWriteCaretVar(runtime));
+    parserExtensions.registerGlobalWriteHook((name, _value, _context) => {
+      reactive.notifyGlobal(name);
+    });
+    parserExtensions.registerGlobalReadHook((name, _context) => {
+      reactive.trackGlobal(name);
+    });
+    parserExtensions.registerLocalWriteHook((name, _value, context) => {
+      const owner = context.me ?? null;
+      if (owner) reactive.notifyElement(owner, name);
+    });
+    parserExtensions.registerLocalReadHook((name, context) => {
+      const owner = context.me ?? null;
+      if (owner) reactive.trackElement(owner, name);
+    });
+  }
+};
+var index_default = reactivityPlugin;
+export {
+  index_default as default,
+  reactive,
+  reactivityPlugin
+};
+//# sourceMappingURL=index.js.map