sigmx 0.1.0 → 0.2.0

package/dist/kernel/reactive.js

@@ -5,19 +5,15 @@ let flushing = false;
 const queue = /* @__PURE__ */ new Set();
 const settled = /* @__PURE__ */ new Set();
 class Signal {
-  /** @internal */
-  a;
-  /** @internal */
-  e = 0;
-  /** @internal */
-  f = /* @__PURE__ */ new Set();
+  d = 0;
+  e = /* @__PURE__ */ new Set();
   constructor(v) {
     this.a = v;
   }
   get value() {
     if (active) {
-      active.b.set(this, this.e);
-      this.f.add(active);
+      active.b.set(this, this.d);
+      this.e.add(active);
     }
     return this.a;
   }
@@ -27,28 +23,20 @@ class Signal {
       this.bump();
     }
   }
-  /** Read without subscribing. */
   peek() {
     return this.a;
   }
   /** Notify subscribers without replacing the value (after mutating an array or object in place). */
   bump() {
-    this.e++;
-    for (const s of this.f) s.h();
-    if (!depth) flush();
+    this.d++;
+    for (const s of this.e) s.g();
+    depth || flush();
   }
 }
 const release = (t) => {
-  for (const d of t.b.keys()) d.f.delete(t);
+  for (const d of t.b.keys()) d.e.delete(t);
   t.b.clear();
 };
-const stale = (t) => {
-  for (const [d, seen] of t.b) {
-    if (d instanceof Computed) d.i();
-    if (d.e !== seen) return true;
-  }
-  return false;
-};
 const capture = (t, fn) => {
   release(t);
   const prev = active;
@@ -59,85 +47,93 @@ const capture = (t, fn) => {
     active = prev;
   }
 };
+const stale = (t) => {
+  if (!t.b.size) return true;
+  for (const [d, seen] of t.b) {
+    if (d instanceof Computed) d.l();
+    if (d.d !== seen) return true;
+  }
+  return false;
+};
 class Computed extends Signal {
   b = /* @__PURE__ */ new Map();
-  /** @internal */
-  g = true;
-  /** @internal */
-  c;
+  c = true;
   constructor(fn) {
     super(void 0);
-    this.c = fn;
-  }
-  /** @internal */
-  i() {
-    if (!this.g) return;
-    this.g = false;
-    if (this.b.size && !stale(this)) return;
-    const x = capture(this, this.c);
+    this.h = fn;
+  }
+  l() {
+    if (!this.c) return;
+    this.c = false;
+    if (!stale(this)) return;
+    const x = capture(this, this.h);
     if (!Object.is(x, this.a)) {
       this.a = x;
-      this.e++;
+      this.d++;
     }
   }
   get value() {
-    this.i();
+    this.l();
     return super.value;
   }
   set value(_) {
-    throw new Error("computed signals are read-only");
+    throw new Error("computed is read-only");
   }
-  peek() {
-    this.i();
-    return this.a;
-  }
-  h() {
-    if (!this.g) {
-      this.g = true;
-      for (const s of this.f) s.h();
+  g() {
+    if (!this.c) {
+      this.c = true;
+      for (const s of this.e) s.g();
     }
   }
+  /** Unsubscribe from every dependency; the computed is no longer recalculated. Public: the store calls it. */
+  dispose() {
+    release(this);
+    this.c = false;
+  }
 }
 class Effect {
   b = /* @__PURE__ */ new Map();
-  j = false;
-  k = false;
-  d = /* @__PURE__ */ new Set();
-  c;
-  l;
+  f = false;
+  i = false;
+  j = /* @__PURE__ */ new Set();
   constructor(fn, onError) {
-    this.c = fn;
-    this.l = onError;
+    this.h = fn;
+    this.m = onError;
   }
-  h() {
-    if (!this.k && !this.j) {
-      this.j = true;
+  g() {
+    if (!this.i && !this.f) {
+      this.f = true;
       queue.add(this);
     }
   }
   n() {
-    this.j = false;
-    if (this.k || this.b.size && !stale(this)) return;
-    for (const c of this.d) c.m();
-    this.d.clear();
+    this.f = false;
+    if (this.i) return;
     const prevOwner = owner;
     owner = this;
     depth++;
     try {
-      capture(this, this.c);
+      if (stale(this)) {
+        this.o();
+        capture(this, this.h);
+      }
     } catch (e) {
-      if (!this.l) throw e;
-      this.l(e);
+      if (!this.m) throw e;
+      this.m(e);
     } finally {
       depth--;
       owner = prevOwner;
     }
   }
-  m() {
-    this.k = true;
+  o() {
+    for (const c of this.j) c.k();
+    this.j.clear();
+  }
+  k() {
+    this.i = true;
     release(this);
-    for (const c of this.d) c.m();
-    this.d.clear();
+    if (active === this) active = void 0;
+    this.o();
     queue.delete(this);
   }
 }
@@ -145,17 +141,31 @@ const signal = (value) => new Signal(value);
 const computed = (fn) => new Computed(fn);
 const effect = (fn, onError) => {
   const e = new Effect(fn, onError);
-  owner?.d.add(e);
-  e.n();
-  if (!depth) flush();
-  return () => e.m();
+  owner?.j.add(e);
+  try {
+    e.n();
+    depth || flush();
+  } catch (err) {
+    e.k();
+    throw err;
+  }
+  return () => e.k();
+};
+const rootEffect = (fn, onError) => {
+  const prev = owner;
+  owner = void 0;
+  try {
+    return effect(fn, onError);
+  } finally {
+    owner = prev;
+  }
 };
 const batch = (fn) => {
   depth++;
   try {
     return fn();
   } finally {
-    if (!--depth) flush();
+    --depth || flush();
   }
 };
 const untracked = (fn) => {
@@ -174,18 +184,32 @@ const onSettled = (fn) => {
 const flush = () => {
   if (flushing || depth) return;
   flushing = true;
+  let thrown;
+  let failed = false;
   try {
     let guard = 0;
     while (queue.size) {
-      if (++guard > 1e5) throw new Error("effect loop");
+      if (++guard > 1e5) {
+        for (const e2 of queue) e2.f = false;
+        queue.clear();
+        throw new Error("effect loop");
+      }
       const e = queue.values().next().value;
       queue.delete(e);
-      e.n();
+      try {
+        e.n();
+      } catch (err) {
+        if (!failed) {
+          failed = true;
+          thrown = err;
+        }
+      }
     }
   } finally {
     flushing = false;
   }
   for (const fn of settled) fn();
+  if (failed) throw thrown;
 };
 export {
   Computed,
@@ -195,6 +219,7 @@ export {
   effect,
   flush,
   onSettled,
+  rootEffect,
   signal,
   untracked
 };

package/dist/kernel/reactive.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/kernel/reactive.ts"],
-  "sourcesContent": ["// Reactive primitives: push invalidation, pull recomputation, version-checked effects.\n// No DOM dependency, so this module is unit-testable in plain Node.\n// Members prefixed with `_` are internal and get mangled by the build.\n\ninterface Tracker {\n  _deps: Map<Signal<any>, number>\n  _invalidate(): void\n}\n\nlet active: Tracker | undefined\nlet owner: Effect | undefined\nlet depth = 0\nlet flushing = false\nconst queue = new Set<Effect>()\nconst settled = new Set<() => void>()\n\nexport class Signal<T> {\n  /** @internal */ _v: T\n  /** @internal */ _ver = 0\n  /** @internal */ _subs = new Set<Tracker>()\n  constructor(v: T) {\n    this._v = v\n  }\n  get value(): T {\n    if (active) {\n      active._deps.set(this, this._ver)\n      this._subs.add(active)\n    }\n    return this._v\n  }\n  set value(x: T) {\n    if (!Object.is(x, this._v)) {\n      this._v = x\n      this.bump()\n    }\n  }\n  /** Read without subscribing. */\n  peek(): T {\n    return this._v\n  }\n  /** Notify subscribers without replacing the value (after mutating an array or object in place). */\n  bump(): void {\n    this._ver++\n    for (const s of this._subs) s._invalidate()\n    if (!depth) flush()\n  }\n}\n\nconst release = (t: Tracker): void => {\n  for (const d of t._deps.keys()) d._subs.delete(t)\n  t._deps.clear()\n}\n\n/** True when any dependency's version moved since the tracker last ran. Refreshes computeds on the way. */\nconst stale = (t: Tracker): boolean => {\n  for (const [d, seen] of t._deps) {\n    if (d instanceof Computed) d._refresh()\n    if (d._ver !== seen) return true\n  }\n  return false\n}\n\nconst capture = <R>(t: Tracker, fn: () => R): R => {\n  release(t)\n  const prev = active\n  active = t\n  try {\n    return fn()\n  } finally {\n    active = prev\n  }\n}\n\nexport class Computed<T> extends Signal<T> implements Tracker {\n  _deps = new Map<Signal<any>, number>()\n  /** @internal */ _dirty = true\n  /** @internal */ _fn: () => T\n  constructor(fn: () => T) {\n    super(undefined as T)\n    this._fn = fn\n  }\n  /** @internal */ _refresh(): void {\n    if (!this._dirty) return\n    this._dirty = false\n    if (this._deps.size && !stale(this)) return\n    const x = capture(this, this._fn)\n    if (!Object.is(x, this._v)) {\n      this._v = x\n      this._ver++\n    }\n  }\n  override get value(): T {\n    this._refresh()\n    return super.value\n  }\n  override set value(_: T) {\n    throw new Error('computed signals are read-only')\n  }\n  override peek(): T {\n    this._refresh()\n    return this._v\n  }\n  _invalidate(): void {\n    if (!this._dirty) {\n      this._dirty = true\n      for (const s of this._subs) s._invalidate()\n    }\n  }\n}\n\nclass Effect implements Tracker {\n  _deps = new Map<Signal<any>, number>()\n  _queued = false\n  _dead = false\n  _kids = new Set<Effect>()\n  _fn: () => void\n  _onError?: (e: unknown) => void\n  constructor(fn: () => void, onError?: (e: unknown) => void) {\n    this._fn = fn\n    this._onError = onError\n  }\n  _invalidate(): void {\n    if (!this._dead && !this._queued) {\n      this._queued = true\n      queue.add(this)\n    }\n  }\n  _exec(): void {\n    this._queued = false\n    if (this._dead || (this._deps.size && !stale(this))) return\n    for (const c of this._kids) c._dispose()\n    this._kids.clear()\n    const prevOwner = owner\n    owner = this\n    depth++\n    try {\n      capture(this, this._fn)\n    } catch (e) {\n      if (!this._onError) throw e\n      this._onError(e)\n    } finally {\n      depth--\n      owner = prevOwner\n    }\n  }\n  _dispose(): void {\n    this._dead = true\n    release(this)\n    for (const c of this._kids) c._dispose()\n    this._kids.clear()\n    queue.delete(this)\n  }\n}\n\nexport const signal = <T>(value: T): Signal<T> => new Signal(value)\nexport const computed = <T>(fn: () => T): Computed<T> => new Computed(fn)\n\n/**\n * Run `fn` now and again whenever a signal it read changes. Effects created inside another\n * effect are disposed when the parent re-runs. Returns a disposer.\n */\nexport const effect = (fn: () => void, onError?: (e: unknown) => void): (() => void) => {\n  const e = new Effect(fn, onError)\n  owner?._kids.add(e)\n  e._exec()\n  if (!depth) flush()\n  return () => e._dispose()\n}\n\n/** Coalesce many writes into one round of effect runs. */\nexport const batch = <R>(fn: () => R): R => {\n  depth++\n  try {\n    return fn()\n  } finally {\n    if (!--depth) flush()\n  }\n}\n\n/** Read signals inside `fn` without subscribing the current effect to them. */\nexport const untracked = <R>(fn: () => R): R => {\n  const prev = active\n  active = undefined\n  try {\n    return fn()\n  } finally {\n    active = prev\n  }\n}\n\n/** Called after each flush once every queued effect has run. */\nexport const onSettled = (fn: () => void): (() => void) => {\n  settled.add(fn)\n  return () => settled.delete(fn)\n}\n\nexport const flush = (): void => {\n  if (flushing || depth) return\n  flushing = true\n  try {\n    let guard = 0\n    while (queue.size) {\n      if (++guard > 1e5) throw new Error('effect loop')\n      const e: Effect = queue.values().next().value!\n      queue.delete(e)\n      e._exec()\n    }\n  } finally {\n    flushing = false\n  }\n  for (const fn of settled) fn()\n}\n"],
-  "mappings": "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",
-  "names": ["_v", "_ver", "_subs", "_deps", "_invalidate", "_refresh", "_dirty", "_fn", "_queued", "_dead", "_kids", "_onError", "_exec", "_dispose"]
+  "sourcesContent": ["// Members prefixed with `_` are internal and get mangled by the build.\n\ninterface Tracker {\n  _deps: Map<Signal<any>, number>;\n  _invalidate(): void;\n}\n\nlet active: Tracker | undefined;\nlet owner: Effect | undefined;\nlet depth = 0;\nlet flushing = false;\nconst queue = new Set<Effect>();\nconst settled = new Set<() => void>();\n\nexport class Signal<T> {\n  declare _v: T;\n  _ver = 0;\n  _subs = new Set<Tracker>();\n  constructor(v: T) {\n    this._v = v;\n  }\n  get value(): T {\n    if (active) {\n      active._deps.set(this, this._ver);\n      this._subs.add(active);\n    }\n    return this._v;\n  }\n  set value(x: T) {\n    if (!Object.is(x, this._v)) {\n      this._v = x;\n      this.bump();\n    }\n  }\n  peek(): T {\n    return this._v;\n  }\n  /** Notify subscribers without replacing the value (after mutating an array or object in place). */\n  bump(): void {\n    this._ver++;\n    for (const s of this._subs) s._invalidate();\n    depth || flush();\n  }\n}\n\n/** Drop `t`'s subscriptions. */\nconst release = (t: Tracker): void => {\n  for (const d of t._deps.keys()) d._subs.delete(t);\n  t._deps.clear();\n};\n\n/** Drop `t`'s subscriptions, then run `fn` with `t` as the active tracker so its reads re-subscribe. */\nconst capture = <R>(t: Tracker, fn: () => R): R => {\n  release(t);\n  const prev = active;\n  active = t;\n  try {\n    return fn();\n  } finally {\n    active = prev;\n  }\n};\n\n/** True when `t` has never run or any dependency's version moved since. Refreshes computeds on the way. */\nconst stale = (t: Tracker): boolean => {\n  if (!t._deps.size) return true;\n  for (const [d, seen] of t._deps) {\n    if (d instanceof Computed) d._refresh();\n    if (d._ver !== seen) return true;\n  }\n  return false;\n};\n\nexport class Computed<T> extends Signal<T> implements Tracker {\n  declare _fn: () => T;\n  _deps = new Map<Signal<any>, number>();\n  _dirty = true;\n  constructor(fn: () => T) {\n    super(undefined as T);\n    this._fn = fn;\n  }\n  _refresh(): void {\n    if (!this._dirty) return;\n    this._dirty = false;\n    if (!stale(this)) return;\n    const x = capture(this, this._fn);\n    if (!Object.is(x, this._v)) {\n      this._v = x;\n      this._ver++;\n    }\n  }\n  override get value(): T {\n    this._refresh();\n    return super.value;\n  }\n  override set value(_: T) {\n    throw new Error('computed is read-only');\n  }\n  _invalidate(): void {\n    if (!this._dirty) {\n      this._dirty = true;\n      for (const s of this._subs) s._invalidate();\n    }\n  }\n  /** Unsubscribe from every dependency; the computed is no longer recalculated. Public: the store calls it. */\n  dispose(): void {\n    release(this);\n    this._dirty = false;\n  }\n}\n\nclass Effect implements Tracker {\n  _deps = new Map<Signal<any>, number>();\n  _queued = false;\n  _dead = false;\n  _kids = new Set<Effect>();\n  declare _fn: () => void;\n  declare _onError?: (e: unknown) => void;\n  constructor(fn: () => void, onError?: (e: unknown) => void) {\n    this._fn = fn;\n    this._onError = onError;\n  }\n  _invalidate(): void {\n    if (!this._dead && !this._queued) {\n      this._queued = true;\n      queue.add(this);\n    }\n  }\n  _exec(): void {\n    this._queued = false;\n    if (this._dead) return;\n    const prevOwner = owner;\n    owner = this;\n    depth++;\n    try {\n      // `stale` refreshes computeds, which may throw: that belongs to this effect's error handling.\n      if (stale(this)) {\n        this._drop();\n        capture(this, this._fn);\n      }\n    } catch (e) {\n      if (!this._onError) throw e;\n      this._onError(e);\n    } finally {\n      depth--;\n      owner = prevOwner;\n    }\n  }\n  _drop(): void {\n    for (const c of this._kids) c._dispose();\n    this._kids.clear();\n  }\n  _dispose(): void {\n    this._dead = true;\n    release(this);\n    if (active === this) active = undefined; // disposed from inside its own run: stop subscribing\n    this._drop();\n    queue.delete(this);\n  }\n}\n\nexport const signal = <T>(value: T): Signal<T> => new Signal(value);\nexport const computed = <T>(fn: () => T): Computed<T> => new Computed(fn);\n\n/**\n * Run `fn` now and again whenever a signal it read changes. Effects created inside another\n * effect are disposed when the parent re-runs. Returns a disposer.\n */\nexport const effect = (fn: () => void, onError?: (e: unknown) => void): (() => void) => {\n  const e = new Effect(fn, onError);\n  owner?._kids.add(e);\n  try {\n    e._exec();\n    depth || flush();\n  } catch (err) {\n    e._dispose(); // a first run that throws (or loops) without a handler leaves nothing subscribed\n    throw err;\n  }\n  return () => e._dispose();\n};\n\n/**\n * Like `effect`, but never owned by the effect that happens to be running: for long-lived effects\n * such as mounted attributes, which must not die when an unrelated parent effect re-runs.\n */\nexport const rootEffect = (fn: () => void, onError?: (e: unknown) => void): (() => void) => {\n  const prev = owner;\n  owner = undefined;\n  try {\n    return effect(fn, onError);\n  } finally {\n    owner = prev;\n  }\n};\n\nexport const batch = <R>(fn: () => R): R => {\n  depth++;\n  try {\n    return fn();\n  } finally {\n    --depth || flush();\n  }\n};\n\nexport const untracked = <R>(fn: () => R): R => {\n  const prev = active;\n  active = undefined;\n  try {\n    return fn();\n  } finally {\n    active = prev;\n  }\n};\n\nexport const onSettled = (fn: () => void): (() => void) => {\n  settled.add(fn);\n  return () => settled.delete(fn);\n};\n\nexport const flush = (): void => {\n  if (flushing || depth) return;\n  flushing = true;\n  let thrown: unknown;\n  let failed = false;\n  try {\n    let guard = 0;\n    while (queue.size) {\n      if (++guard > 1e5) {\n        // Leave nothing behind, or every later flush would trip the same guard; the effects stay\n        // subscribed and run again on their next change.\n        for (const e of queue) e._queued = false;\n        queue.clear();\n        throw new Error('effect loop');\n      }\n      const e = queue.values().next().value as Effect;\n      queue.delete(e);\n      try {\n        e._exec();\n      } catch (err) {\n        // One throwing effect (no onError) must not starve the others; rethrow after the flush.\n        if (!failed) {\n          failed = true;\n          thrown = err;\n        }\n      }\n    }\n  } finally {\n    flushing = false;\n  }\n  for (const fn of settled) fn();\n  if (failed) throw thrown;\n};\n"],
+  "mappings": "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",
+  "names": ["_ver", "_subs", "_v", "_deps", "_invalidate", "_refresh", "_dirty", "_fn", "_queued", "_dead", "_kids", "_onError", "_exec", "_drop", "_dispose", "e"]
 }

package/dist/kernel/runtime.js

@@ -1,66 +1,59 @@
+import { recase } from "../lib/casing.js";
 import { functionCompiler } from "./compile.js";
-import { effect } from "./reactive.js";
+import { rootEffect } from "./reactive.js";
 import { createStore } from "./state.js";
-import { recase } from "../lib/casing.js";
-const isEl = (n) => n instanceof HTMLElement || n instanceof SVGElement || n instanceof MathMLElement;
-const tree = (n) => isEl(n) ? [n, ...n.querySelectorAll("*")] : n instanceof ShadowRoot ? [...n.querySelectorAll("*")] : [];
-const parsed = /* @__PURE__ */ new Map();
+const isEl = (n) => n.nodeType === 1;
+const tree = (n) => n.querySelectorAll ? [...isEl(n) ? [n] : [], ...n.querySelectorAll("*")] : [];
 const parseAttr = (raw) => {
-  let p = parsed.get(raw);
-  if (!p) {
-    const [head, ...modParts] = raw.split("__");
-    const i = head.indexOf(":");
-    const mods = /* @__PURE__ */ new Map();
-    for (const m of modParts) {
-      const [name, ...args] = m.split(".");
-      mods.set(name, args);
-    }
-    p = { plugin: i < 0 ? head : head.slice(0, i), key: i < 0 ? void 0 : head.slice(i + 1), mods };
-    parsed.set(raw, p);
-  }
-  return p;
+  const [head, ...modParts] = raw.split("__");
+  const [, plugin, key] = /^([^:]*)(?::(.*))?$/.exec(head);
+  return {
+    plugin,
+    key,
+    mods: new Map(
+      modParts.map((m) => {
+        const [name, ...args] = m.split(".");
+        return [name, args];
+      })
+    )
+  };
+};
+const cut = (list, s) => {
+  for (const p of list) if (s.startsWith(p)) return s.slice(p.length);
 };
-const fail = (message, info) => Object.assign(new Error(message), { info });
 const createRuntime = (options) => {
   const prefixes = [].concat(options.prefix ?? "data-");
   const eventPrefixes = [].concat(options.eventPrefix ?? "sigmx-");
   const store = options.store ?? createStore();
-  const compiler = options.compile ?? functionCompiler;
   const { expressions } = options;
   const onError = options.onError ?? ((e, info) => console.error(e, info));
   const attributes = /* @__PURE__ */ Object.create(null);
-  const actions = /* @__PURE__ */ Object.create(null);
-  const handlers = /* @__PURE__ */ Object.create(null);
   const runtime = {
     prefixes,
     attr: (name) => prefixes[0] + name,
     store,
-    compiler,
+    compiler: options.compile ?? functionCompiler,
     emit: (type, detail) => document.dispatchEvent(new CustomEvent(`sigmx-${type}`, { detail })),
     call: (name, ctx, args) => {
-      const a = actions[name];
+      const a = runtime.actions[name];
       if (!a) throw ctx.error(`unknown action @${name}`);
       return a.call(ctx, ...args);
     },
     eventPrefixes,
     handle: (event, data) => {
-      const p = eventPrefixes.find((p2) => event.startsWith(p2));
-      const h = handlers[p ? event.slice(p.length) : event];
+      const h = runtime.handlers[cut(eventPrefixes, event) ?? event];
       h?.handle(runtime, data);
       return !!h;
     },
     attributes,
-    actions,
-    handlers
+    actions: /* @__PURE__ */ Object.create(null),
+    handlers: /* @__PURE__ */ Object.create(null)
   };
   const mounted = /* @__PURE__ */ new Map();
   const roots = /* @__PURE__ */ new Set();
-  const ignoreSelf = prefixes.map((p) => `[${p}ignore__self]`).join();
   const ignoreAny = prefixes.map((p) => `[${p}ignore]`).join();
-  const ignored = (el) => el.matches(ignoreSelf) || !!el.closest(ignoreAny);
-  const strip = (attr) => {
-    for (const p of prefixes) if (attr.startsWith(p)) return attr.slice(p.length);
-  };
+  const ignored = (el) => !!el.closest(ignoreAny);
+  let destroyed = false;
   const unmount = (els) => {
     for (const el of els) {
       const m = mounted.get(el);
@@ -72,20 +65,30 @@ const createRuntime = (options) => {
     m?.get(attr)?.();
     m?.delete(attr);
   };
-  const actionsFor = (el, evt, error, cleanup) => {
-    const ctx = { el, evt, store, runtime, error, cleanup };
-    return new Proxy({}, { get: (_, name) => (...args) => runtime.call(name, ctx, args) });
-  };
   const mount = (el, attr, raw, value, only) => {
     const { plugin: name, key, mods } = parseAttr(raw);
     const plugin = attributes[name];
     if (!plugin || only && !only.has(name)) return;
     unmountAttr(el, attr);
     const disposers = [];
+    const cleanup = (f) => {
+      disposers.push(f);
+      return () => {
+        const i = disposers.indexOf(f);
+        if (i >= 0) disposers.splice(i, 1);
+      };
+    };
     const info = { plugin: name, el, attr };
-    const error = (message, extra) => fail(`${prefixes[0]}${name}: ${message}`, { ...info, ...extra });
+    const error = (message, extra) => Object.assign(new Error(`${prefixes[0]}${name}: ${message}`), { info: { ...info, ...extra } });
     const report = (e) => onError(e, info);
     let fn;
+    const watched = /* @__PURE__ */ new WeakSet();
+    const watch = (r) => {
+      if (r instanceof Promise && !watched.has(r)) {
+        watched.add(r);
+        r.catch(report);
+      }
+    };
     const ctx = {
       el,
       plugin: name,
@@ -95,10 +98,27 @@ const createRuntime = (options) => {
       mods,
       cased: (style = "camel") => recase(key ?? "", mods.get("case")?.[0] || style),
       evaluate: (evt, ...args) => {
-        fn ??= expressions(value, ["el", "evt", ...plugin.args ?? []], plugin.returns ?? true);
-        return fn(store, actionsFor(el, evt, error, ctx.cleanup), el, evt, ...args);
+        if (plugin.literal && !mods.has("dynamic")) return value;
+        fn ??= expressions(value, ["el", "evt", ...plugin.args ?? []]);
+        const actx = { el, evt, store, runtime, error, cleanup, report };
+        const actions = new Proxy(
+          {},
+          {
+            get: (_, name2) => (...args2) => {
+              const r2 = runtime.call(name2, actx, args2);
+              watch(r2);
+              return r2;
+            }
+          }
+        );
+        const r = fn(store, actions, el, evt, ...args);
+        watch(r);
+        return r;
+      },
+      // Root-owned: an attribute mounted from inside another effect must outlive that effect's re-runs.
+      effect: (f) => {
+        cleanup(rootEffect(f, report));
       },
-      effect: (f) => disposers.push(effect(f, report)),
       listen: (target, type, f, opts) => {
         const h = (e) => {
           try {
@@ -108,25 +128,33 @@ const createRuntime = (options) => {
           }
         };
         target.addEventListener(type, h, opts);
-        disposers.push(() => target.removeEventListener(type, h, opts));
+        cleanup(() => target.removeEventListener(type, h, opts));
       },
-      cleanup: (f) => disposers.push(f),
+      cleanup,
       error,
+      report,
       store,
       runtime
     };
     let m = mounted.get(el);
-    if (!m) mounted.set(el, m = /* @__PURE__ */ new Map());
+    if (!m) {
+      m = /* @__PURE__ */ new Map();
+      mounted.set(el, m);
+    }
     m.set(attr, () => {
       for (const d of disposers.splice(0)) d();
     });
     try {
-      if (plugin.key === "required" && !key) throw error("needs a key");
-      if (plugin.key === "forbidden" && key) throw error("takes no key");
-      if (plugin.value === "required" && !value) throw error("needs a value");
-      if (plugin.value === "forbidden" && value) throw error("takes no value");
+      for (const [k, v] of [
+        ["key", key],
+        ["value", value]
+      ]) {
+        const rule = plugin[k];
+        if (rule && rule === "required" === !v) throw error(`${rule === "required" ? "needs a" : "takes no"} ${k}`);
+      }
       const r = plugin.mount(ctx);
-      if (typeof r === "function") disposers.push(r);
+      if (typeof r === "function") cleanup(r);
+      else watch(r);
     } catch (e) {
       report(e);
     }
@@ -135,18 +163,18 @@ const createRuntime = (options) => {
     for (const el of els) {
       if (ignored(el)) continue;
       for (const { name, value } of [...el.attributes]) {
-        const raw = strip(name);
-        if (raw) mount(el, name, raw, value, only);
+        const raw = cut(prefixes, name);
+        if (raw && !mounted.get(el)?.has(name)) mount(el, name, raw, value, only);
       }
     }
   };
   const observer = new MutationObserver((records) => {
     for (const { type, target, attributeName, addedNodes, removedNodes } of records) {
       if (type === "childList") {
-        for (const n of removedNodes) unmount(tree(n));
+        for (const n of removedNodes) if (!n.isConnected) unmount(tree(n));
         for (const n of addedNodes) mountEls(tree(n));
       } else if (attributeName && isEl(target) && !ignored(target)) {
-        const raw = strip(attributeName);
+        const raw = cut(prefixes, attributeName);
         if (!raw) continue;
         const value = target.getAttribute(attributeName);
         if (value === null) unmountAttr(target, attributeName);
@@ -154,26 +182,19 @@ const createRuntime = (options) => {
       }
     }
   });
-  let ready = false;
   const apply = (root = document.documentElement, observe = true, only) => {
+    if (destroyed) return;
     mountEls(tree(root), only);
     if (observe && !roots.has(root)) {
       observer.observe(root, { subtree: true, childList: true, attributes: true });
       roots.add(root);
     }
-    if (!ready && roots.has(document.documentElement)) {
-      ready = true;
-      runtime.emit("ready");
-    }
   };
   const use = (...plugins) => {
     const added = /* @__PURE__ */ new Set();
     for (const p of plugins) {
-      if (p.type === "attribute") {
-        attributes[p.name] = p;
-        added.add(p.name);
-      } else if (p.type === "action") actions[p.name] = p;
-      else handlers[p.name] = p;
+      runtime[`${p.type}s`][p.name] = p;
+      if (p.type === "attribute") added.add(p.name);
     }
     if (added.size) for (const r of roots) apply(r, false, added);
   };
@@ -188,6 +209,7 @@ const createRuntime = (options) => {
     apply: (root, observe) => apply(root, observe),
     use,
     destroy: () => {
+      destroyed = true;
       observer.disconnect();
       stopPatches();
       unmount([...mounted.keys()]);