sigmx 0.1.0

package/dist/kernel/precompiled.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/kernel/precompiled.ts"],
+  "sourcesContent": ["import type { Evaluator, ExpressionCompiler } from './contracts.js'\n\nexport type ExpressionTable = Record<string, (root: any, actions: any, el: any, evt: any, ...args: any[]) => any>\n\n/** Key used by the build plugin and the lookup: returns flag, parameter names, trimmed source. */\nexport const expressionKey = (src: string, params: string[], returns: boolean): string => `${+returns}|${params.join()}|${src.trim()}`\n\n/**\n * Look expressions up in a table generated at build time (see `sigmx/precompile`). Precompiled functions\n * receive the root store proxy as `$` instead of a `with` scope. Pass a `fallback` (for example\n * `runtimeExpressions(functionCompiler)`) for markup assembled at runtime; omit it and the runtime\n * compiler is not bundled at all.\n */\nexport const precompiled =\n  (table: ExpressionTable, fallback?: ExpressionCompiler, onMiss?: (src: string) => void): ExpressionCompiler =>\n  (src, params, returns) => {\n    const fn = table[expressionKey(src, params, returns)]\n    if (fn) return ((store, actions, el, evt, ...args) => fn(store.$, actions, el, evt, ...args)) as Evaluator\n    onMiss?.(src)\n    if (!fallback) throw new Error(`expression not precompiled: ${src}`)\n    return fallback(src, params, returns)\n  }\n"],
+  "mappings": "AAKO,MAAM,gBAAgB,CAAC,KAAa,QAAkB,YAA6B,GAAG,CAAC,OAAO,IAAI,OAAO,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC;AAQ7H,MAAM,cACX,CAAC,OAAwB,UAA+B,WACxD,CAAC,KAAK,QAAQ,YAAY;AACxB,QAAM,KAAK,MAAM,cAAc,KAAK,QAAQ,OAAO,CAAC;AACpD,MAAI,GAAI,SAAQ,CAAC,OAAO,SAAS,IAAI,QAAQ,SAAS,GAAG,MAAM,GAAG,SAAS,IAAI,KAAK,GAAG,IAAI;AAC3F,WAAS,GAAG;AACZ,MAAI,CAAC,SAAU,OAAM,IAAI,MAAM,+BAA+B,GAAG,EAAE;AACnE,SAAO,SAAS,KAAK,QAAQ,OAAO;AACtC;",
+  "names": []
+}

package/dist/kernel/reactive.d.ts

@@ -0,0 +1,42 @@
+interface Tracker {
+    _deps: Map<Signal<any>, number>;
+    _invalidate(): void;
+}
+export declare class Signal<T> {
+    /** @internal */ _v: T;
+    /** @internal */ _ver: number;
+    /** @internal */ _subs: Set<Tracker>;
+    constructor(v: T);
+    get value(): T;
+    set value(x: T);
+    /** Read without subscribing. */
+    peek(): T;
+    /** Notify subscribers without replacing the value (after mutating an array or object in place). */
+    bump(): void;
+}
+export declare class Computed<T> extends Signal<T> implements Tracker {
+    _deps: Map<Signal<any>, number>;
+    /** @internal */ _dirty: boolean;
+    /** @internal */ _fn: () => T;
+    constructor(fn: () => T);
+    /** @internal */ _refresh(): void;
+    get value(): T;
+    set value(_: T);
+    peek(): T;
+    _invalidate(): void;
+}
+export declare const signal: <T>(value: T) => Signal<T>;
+export declare const computed: <T>(fn: () => T) => Computed<T>;
+/**
+ * Run `fn` now and again whenever a signal it read changes. Effects created inside another
+ * effect are disposed when the parent re-runs. Returns a disposer.
+ */
+export declare const effect: (fn: () => void, onError?: (e: unknown) => void) => (() => void);
+/** Coalesce many writes into one round of effect runs. */
+export declare const batch: <R>(fn: () => R) => R;
+/** Read signals inside `fn` without subscribing the current effect to them. */
+export declare const untracked: <R>(fn: () => R) => R;
+/** Called after each flush once every queued effect has run. */
+export declare const onSettled: (fn: () => void) => (() => void);
+export declare const flush: () => void;
+export {};

package/dist/kernel/reactive.js

@@ -0,0 +1,201 @@
+let active;
+let owner;
+let depth = 0;
+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();
+  constructor(v) {
+    this.a = v;
+  }
+  get value() {
+    if (active) {
+      active.b.set(this, this.e);
+      this.f.add(active);
+    }
+    return this.a;
+  }
+  set value(x) {
+    if (!Object.is(x, this.a)) {
+      this.a = x;
+      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();
+  }
+}
+const release = (t) => {
+  for (const d of t.b.keys()) d.f.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;
+  active = t;
+  try {
+    return fn();
+  } finally {
+    active = prev;
+  }
+};
+class Computed extends Signal {
+  b = /* @__PURE__ */ new Map();
+  /** @internal */
+  g = true;
+  /** @internal */
+  c;
+  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);
+    if (!Object.is(x, this.a)) {
+      this.a = x;
+      this.e++;
+    }
+  }
+  get value() {
+    this.i();
+    return super.value;
+  }
+  set value(_) {
+    throw new Error("computed signals are read-only");
+  }
+  peek() {
+    this.i();
+    return this.a;
+  }
+  h() {
+    if (!this.g) {
+      this.g = true;
+      for (const s of this.f) s.h();
+    }
+  }
+}
+class Effect {
+  b = /* @__PURE__ */ new Map();
+  j = false;
+  k = false;
+  d = /* @__PURE__ */ new Set();
+  c;
+  l;
+  constructor(fn, onError) {
+    this.c = fn;
+    this.l = onError;
+  }
+  h() {
+    if (!this.k && !this.j) {
+      this.j = 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();
+    const prevOwner = owner;
+    owner = this;
+    depth++;
+    try {
+      capture(this, this.c);
+    } catch (e) {
+      if (!this.l) throw e;
+      this.l(e);
+    } finally {
+      depth--;
+      owner = prevOwner;
+    }
+  }
+  m() {
+    this.k = true;
+    release(this);
+    for (const c of this.d) c.m();
+    this.d.clear();
+    queue.delete(this);
+  }
+}
+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();
+};
+const batch = (fn) => {
+  depth++;
+  try {
+    return fn();
+  } finally {
+    if (!--depth) flush();
+  }
+};
+const untracked = (fn) => {
+  const prev = active;
+  active = void 0;
+  try {
+    return fn();
+  } finally {
+    active = prev;
+  }
+};
+const onSettled = (fn) => {
+  settled.add(fn);
+  return () => settled.delete(fn);
+};
+const flush = () => {
+  if (flushing || depth) return;
+  flushing = true;
+  try {
+    let guard = 0;
+    while (queue.size) {
+      if (++guard > 1e5) throw new Error("effect loop");
+      const e = queue.values().next().value;
+      queue.delete(e);
+      e.n();
+    }
+  } finally {
+    flushing = false;
+  }
+  for (const fn of settled) fn();
+};
+export {
+  Computed,
+  Signal,
+  batch,
+  computed,
+  effect,
+  flush,
+  onSettled,
+  signal,
+  untracked
+};
+//# sourceMappingURL=reactive.js.map

package/dist/kernel/reactive.js.map

@@ -0,0 +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"]
+}

package/dist/kernel/runtime.d.ts

@@ -0,0 +1,11 @@
+import type { Mods, RuntimeOptions, Sigmx } from './contracts.js';
+type Parsed = {
+    plugin: string;
+    key: string | undefined;
+    mods: Mods;
+};
+/** 'on:click__debounce.300ms__prevent' → { plugin: 'on', key: 'click', mods: {debounce: ['300ms'], prevent: []} } */
+export declare const parseAttr: (raw: string) => Parsed;
+/** Low-level constructor: you supply the expression pipeline. `createSigmx` wraps it with the runtime compiler. */
+export declare const createRuntime: (options: RuntimeOptions) => Sigmx;
+export {};

package/dist/kernel/runtime.js

@@ -0,0 +1,210 @@
+import { functionCompiler } from "./compile.js";
+import { effect } 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 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 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,
+    emit: (type, detail) => document.dispatchEvent(new CustomEvent(`sigmx-${type}`, { detail })),
+    call: (name, ctx, args) => {
+      const a = 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];
+      h?.handle(runtime, data);
+      return !!h;
+    },
+    attributes,
+    actions,
+    handlers
+  };
+  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 unmount = (els) => {
+    for (const el of els) {
+      const m = mounted.get(el);
+      if (m && mounted.delete(el)) for (const d of m.values()) d();
+    }
+  };
+  const unmountAttr = (el, attr) => {
+    const m = mounted.get(el);
+    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 info = { plugin: name, el, attr };
+    const error = (message, extra) => fail(`${prefixes[0]}${name}: ${message}`, { ...info, ...extra });
+    const report = (e) => onError(e, info);
+    let fn;
+    const ctx = {
+      el,
+      plugin: name,
+      attr,
+      key,
+      value,
+      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);
+      },
+      effect: (f) => disposers.push(effect(f, report)),
+      listen: (target, type, f, opts) => {
+        const h = (e) => {
+          try {
+            f(e);
+          } catch (err) {
+            report(err);
+          }
+        };
+        target.addEventListener(type, h, opts);
+        disposers.push(() => target.removeEventListener(type, h, opts));
+      },
+      cleanup: (f) => disposers.push(f),
+      error,
+      store,
+      runtime
+    };
+    let m = mounted.get(el);
+    if (!m) mounted.set(el, m = /* @__PURE__ */ new Map());
+    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");
+      const r = plugin.mount(ctx);
+      if (typeof r === "function") disposers.push(r);
+    } catch (e) {
+      report(e);
+    }
+  };
+  const mountEls = (els, only) => {
+    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 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 addedNodes) mountEls(tree(n));
+      } else if (attributeName && isEl(target) && !ignored(target)) {
+        const raw = strip(attributeName);
+        if (!raw) continue;
+        const value = target.getAttribute(attributeName);
+        if (value === null) unmountAttr(target, attributeName);
+        else mount(target, attributeName, raw, value);
+      }
+    }
+  });
+  let ready = false;
+  const apply = (root = document.documentElement, observe = true, only) => {
+    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;
+    }
+    if (added.size) for (const r of roots) apply(r, false, added);
+  };
+  const stopPatches = store.onPatch((patch) => runtime.emit("signal-patch", patch));
+  use(...options.plugins ?? []);
+  const sigmx = {
+    runtime,
+    store,
+    get $() {
+      return store.$;
+    },
+    apply: (root, observe) => apply(root, observe),
+    use,
+    destroy: () => {
+      observer.disconnect();
+      stopPatches();
+      unmount([...mounted.keys()]);
+      roots.clear();
+    }
+  };
+  if (options.autoStart ?? true) {
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", () => sigmx.apply(), { once: true });
+    } else {
+      sigmx.apply();
+    }
+  }
+  return sigmx;
+};
+export {
+  createRuntime,
+  parseAttr
+};
+//# sourceMappingURL=runtime.js.map

package/dist/kernel/runtime.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/kernel/runtime.ts"],
+  "sourcesContent": ["import { functionCompiler } from './compile.js'\nimport { effect } from './reactive.js'\nimport { createStore } from './state.js'\nimport type { ActionCtx, AttributePlugin, Ctx, El, Evaluator, Mods, Plugin, Runtime, RuntimeOptions, Sigmx } from './contracts.js'\nimport { recase, type CaseStyle } from '../lib/casing.js'\n\nconst isEl = (n: Node): n is El => n instanceof HTMLElement || n instanceof SVGElement || n instanceof MathMLElement\n/** An element (or shadow root) followed by every element under it; nothing for text and comment nodes. */\nconst tree = (n: Node): El[] =>\n  isEl(n) ? [n, ...n.querySelectorAll<El>('*')] : n instanceof ShadowRoot ? [...n.querySelectorAll<El>('*')] : []\n\ntype Parsed = { plugin: string; key: string | undefined; mods: Mods }\nconst parsed = new Map<string, Parsed>()\n\n/** 'on:click__debounce.300ms__prevent' \u2192 { plugin: 'on', key: 'click', mods: {debounce: ['300ms'], prevent: []} } */\nexport const parseAttr = (raw: string): Parsed => {\n  let p = parsed.get(raw)\n  if (!p) {\n    const [head, ...modParts] = raw.split('__')\n    const i = head.indexOf(':')\n    const mods: Mods = new Map()\n    for (const m of modParts) {\n      const [name, ...args] = m.split('.')\n      mods.set(name, args)\n    }\n    p = { plugin: i < 0 ? head : head.slice(0, i), key: i < 0 ? undefined : head.slice(i + 1), mods }\n    parsed.set(raw, p)\n  }\n  return p\n}\n\nconst fail = (message: string, info: Record<string, unknown>): Error =>\n  Object.assign(new Error(message), { info })\n\n/** Low-level constructor: you supply the expression pipeline. `createSigmx` wraps it with the runtime compiler. */\nexport const createRuntime = (options: RuntimeOptions): Sigmx => {\n  const prefixes = ([] as string[]).concat(options.prefix ?? 'data-')\n  const eventPrefixes = ([] as string[]).concat(options.eventPrefix ?? 'sigmx-')\n  const store = options.store ?? createStore()\n  const compiler = options.compile ?? functionCompiler\n  const { expressions } = options\n  const onError = options.onError ?? ((e, info) => console.error(e, info))\n  const attributes: Record<string, AttributePlugin> = Object.create(null)\n  const actions: Runtime['actions'] = Object.create(null)\n  const handlers: Runtime['handlers'] = Object.create(null)\n\n  const runtime: Runtime = {\n    prefixes,\n    attr: (name) => prefixes[0] + name,\n    store,\n    compiler,\n    emit: (type, detail) => document.dispatchEvent(new CustomEvent(`sigmx-${type}`, { detail })),\n    call: (name, ctx, args) => {\n      const a = actions[name]\n      if (!a) throw ctx.error(`unknown action @${name}`)\n      return a.call(ctx, ...args)\n    },\n    eventPrefixes,\n    handle: (event, data) => {\n      const p = eventPrefixes.find((p) => event.startsWith(p))\n      const h = handlers[p ? event.slice(p.length) : event]\n      h?.handle(runtime, data)\n      return !!h\n    },\n    attributes,\n    actions,\n    handlers,\n  }\n\n  // element \u2192 attribute name \u2192 dispose\n  const mounted = new Map<El, Map<string, () => void>>()\n  const roots = new Set<El | ShadowRoot>()\n  const ignoreSelf = prefixes.map((p) => `[${p}ignore__self]`).join()\n  const ignoreAny = prefixes.map((p) => `[${p}ignore]`).join()\n  const ignored = (el: El) => el.matches(ignoreSelf) || !!el.closest(ignoreAny)\n\n  const strip = (attr: string): string | undefined => {\n    for (const p of prefixes) if (attr.startsWith(p)) return attr.slice(p.length)\n  }\n\n  const unmount = (els: Iterable<El>): void => {\n    for (const el of els) {\n      const m = mounted.get(el)\n      if (m && mounted.delete(el)) for (const d of m.values()) d()\n    }\n  }\n\n  const unmountAttr = (el: El, attr: string): void => {\n    const m = mounted.get(el)\n    m?.get(attr)?.()\n    m?.delete(attr)\n  }\n\n  const actionsFor = (el: El, evt: Event | undefined, error: Ctx['error'], cleanup: (fn: () => void) => void) => {\n    const ctx: ActionCtx = { el, evt, store, runtime, error, cleanup }\n    return new Proxy({}, { get: (_, name: string) => (...args: any[]) => runtime.call(name, ctx, args) })\n  }\n\n  const mount = (el: El, attr: string, raw: string, value: string, only?: Set<string>): void => {\n    const { plugin: name, key, mods } = parseAttr(raw)\n    const plugin = attributes[name]\n    if (!plugin || (only && !only.has(name))) return\n    unmountAttr(el, attr)\n\n    const disposers: (() => void)[] = []\n    const info = { plugin: name, el, attr }\n    const error: Ctx['error'] = (message, extra) => fail(`${prefixes[0]}${name}: ${message}`, { ...info, ...extra })\n    const report = (e: unknown) => onError(e, info)\n    let fn: Evaluator | undefined\n    const ctx: Ctx = {\n      el,\n      plugin: name,\n      attr,\n      key,\n      value,\n      mods,\n      cased: (style = 'camel') => recase(key ?? '', (mods.get('case')?.[0] as CaseStyle) || style),\n      evaluate: (evt, ...args) => {\n        fn ??= expressions(value, ['el', 'evt', ...(plugin.args ?? [])], plugin.returns ?? true)\n        return fn(store, actionsFor(el, evt, error, ctx.cleanup), el, evt, ...args)\n      },\n      effect: (f) => disposers.push(effect(f, report)),\n      listen: (target, type, f, opts) => {\n        const h = (e: Event) => {\n          try {\n            f(e)\n          } catch (err) {\n            report(err)\n          }\n        }\n        target.addEventListener(type, h, opts)\n        disposers.push(() => target.removeEventListener(type, h, opts))\n      },\n      cleanup: (f) => disposers.push(f),\n      error,\n      store,\n      runtime,\n    }\n\n    let m = mounted.get(el)\n    if (!m) mounted.set(el, (m = new Map()))\n    m.set(attr, () => {\n      for (const d of disposers.splice(0)) d()\n    })\n\n    try {\n      if (plugin.key === 'required' && !key) throw error('needs a key')\n      if (plugin.key === 'forbidden' && key) throw error('takes no key')\n      if (plugin.value === 'required' && !value) throw error('needs a value')\n      if (plugin.value === 'forbidden' && value) throw error('takes no value')\n      const r = plugin.mount(ctx)\n      if (typeof r === 'function') disposers.push(r)\n    } catch (e) {\n      report(e)\n    }\n  }\n\n  const mountEls = (els: Iterable<El>, only?: Set<string>): void => {\n    for (const el of els) {\n      if (ignored(el)) continue\n      for (const { name, value } of [...el.attributes]) {\n        const raw = strip(name)\n        if (raw) mount(el, name, raw, value, only)\n      }\n    }\n  }\n\n  const observer = new MutationObserver((records) => {\n    for (const { type, target, attributeName, addedNodes, removedNodes } of records) {\n      if (type === 'childList') {\n        for (const n of removedNodes) unmount(tree(n))\n        for (const n of addedNodes) mountEls(tree(n))\n      } else if (attributeName && isEl(target) && !ignored(target)) {\n        const raw = strip(attributeName)\n        if (!raw) continue\n        const value = target.getAttribute(attributeName)\n        if (value === null) unmountAttr(target, attributeName)\n        else mount(target, attributeName, raw, value)\n      }\n    }\n  })\n\n  let ready = false\n  const apply = (root: El | ShadowRoot = document.documentElement, observe = true, only?: Set<string>) => {\n    mountEls(tree(root), only)\n    if (observe && !roots.has(root)) {\n      observer.observe(root, { subtree: true, childList: true, attributes: true })\n      roots.add(root)\n    }\n    if (!ready && roots.has(document.documentElement)) {\n      ready = true\n      runtime.emit('ready')\n    }\n  }\n\n  const use = (...plugins: Plugin[]): void => {\n    const added = new Set<string>()\n    for (const p of plugins) {\n      if (p.type === 'attribute') {\n        attributes[p.name] = p\n        added.add(p.name)\n      } else if (p.type === 'action') actions[p.name] = p\n      else handlers[p.name] = p\n    }\n    if (added.size) for (const r of roots) apply(r, false, added)\n  }\n\n  const stopPatches = store.onPatch((patch) => runtime.emit('signal-patch', patch))\n  use(...(options.plugins ?? []))\n\n  const sigmx: Sigmx = {\n    runtime,\n    store,\n    get $() {\n      return store.$\n    },\n    apply: (root, observe) => apply(root, observe),\n    use,\n    destroy: () => {\n      observer.disconnect()\n      stopPatches()\n      unmount([...mounted.keys()])\n      roots.clear()\n    },\n  }\n\n  if (options.autoStart ?? true) {\n    if (document.readyState === 'loading') {\n      document.addEventListener('DOMContentLoaded', () => sigmx.apply(), { once: true })\n    } else {\n      sigmx.apply()\n    }\n  }\n  return sigmx\n}\n"],
+  "mappings": "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",
+  "names": ["p"]
+}

package/dist/kernel/scan.d.ts

@@ -0,0 +1,42 @@
+import type { Plugin } from './contracts.js';
+export type PluginMeta = {
+    /** Export name, e.g. `httpGet`; what the generated module imports. */
+    export: string;
+    /** Registered name, e.g. `get`; what markup refers to. */
+    name: string;
+    type: Plugin['type'];
+    /** Module to import from; built-ins come from `sigmx/plugins`. */
+    from: string;
+    returns?: boolean;
+    args?: string[];
+};
+/** Plugins that only make sense together. */
+export declare const implied: Record<string, string[]>;
+/** Metadata for every built-in plugin. */
+export declare const builtinPlugins: () => PluginMeta[];
+/**
+ * Read a custom plugin's metadata from its source without executing it: finds
+ * `attribute({ name: 'x', ... })`, `action({...})` or `handler({...})` near `export const <exportName>`.
+ */
+export declare const customPluginMeta: (exportName: string, source: string, from: string) => PluginMeta | undefined;
+/** True if `source` refers to the plugin: `data-<name>` for directives, `@name(` for functions, the name as a string for handlers. */
+export declare const mentions: (source: string, p: PluginMeta, prefixes: string[]) => boolean;
+export type Selection = {
+    /** Selected plugins in a stable order. */
+    plugins: PluginMeta[];
+    /** Why each one is in: 'used', 'always', or the plugin that implied it. */
+    reasons: Record<string, string>;
+    /** Known plugins that were left out. */
+    unused: string[];
+};
+/**
+ * Decide which plugins to ship. `sources` are file contents; `custom` are extra plugins (from
+ * `customPluginMeta`); `always` are export names that ship regardless.
+ */
+export declare const selectPlugins: (sources: string[], { prefixes, always, custom }?: {
+    prefixes?: string[];
+    always?: string[];
+    custom?: PluginMeta[];
+}) => Selection;
+/** JavaScript source for a module exporting `plugins` (and the selection report). */
+export declare const generatePluginsModule: (sel: Selection) => string;

package/dist/kernel/scan.js

@@ -0,0 +1,68 @@
+import * as builtins from "../plugins/index.js";
+const NETWORK = ["httpGet", "httpPost", "httpPut", "httpPatch", "httpDelete", "websocket", "boost"];
+const implied = {
+  ...Object.fromEntries(NETWORK.map((n) => [n, ["applyElements", "applyState"]])),
+  boost: ["httpGet", "httpPost", "applyElements", "applyState"]
+};
+const builtinPlugins = () => Object.entries(builtins).filter(([, v]) => v && typeof v === "object" && "type" in v).map(([key, v]) => {
+  const p = v;
+  return { export: key, name: p.name, type: p.type, from: "sigmx/plugins", returns: p.returns, args: p.args };
+});
+const customPluginMeta = (exportName, source, from) => {
+  const re = new RegExp(`export\\s+const\\s+${exportName}\\s*(?::[^=]+)?=\\s*(attribute|action|handler)\\s*\\(\\s*\\{([\\s\\S]*?)\\}\\s*\\)`, "m");
+  const m = re.exec(source);
+  if (!m) return;
+  const body = m[2];
+  const name = /\bname\s*:\s*['"`]([^'"`]+)['"`]/.exec(body)?.[1];
+  if (!name) return;
+  const returns = /\breturns\s*:\s*(true|false)/.exec(body)?.[1];
+  const args = /\bargs\s*:\s*\[([^\]]*)\]/.exec(body)?.[1];
+  return {
+    export: exportName,
+    name,
+    type: m[1],
+    from,
+    returns: returns === void 0 ? void 0 : returns === "true",
+    args: args?.split(",").map((s) => s.trim().replace(/^['"`]|['"`]$/g, "")).filter(Boolean)
+  };
+};
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const mentions = (source, p, prefixes) => {
+  const n = escape(p.name);
+  if (p.type === "attribute") return prefixes.some((pre) => new RegExp(`(^|[\\s"'\`<])${escape(pre)}${n}(?=[\\s=:_>"'\`/]|$)`, "m").test(source));
+  if (p.type === "action") return new RegExp(`@${n}\\s*\\(`).test(source);
+  return new RegExp(`['"\`](?:[\\w-]+-)?${n}['"\`]`).test(source);
+};
+const selectPlugins = (sources, { prefixes = ["data-"], always = [], custom = [] } = {}) => {
+  const known = [...builtinPlugins(), ...custom];
+  const byExport = new Map(known.map((p) => [p.export, p]));
+  const reasons = {};
+  const add = (exp, why) => {
+    if (!byExport.has(exp) || reasons[exp]) return;
+    reasons[exp] = why;
+    for (const dep of implied[exp] ?? []) add(dep, exp);
+  };
+  for (const exp of always) add(exp, "always");
+  const text = sources.join("\n");
+  for (const p of known) if (!reasons[p.export] && (p.type !== "handler" || custom.includes(p)) && mentions(text, p, prefixes)) add(p.export, "used");
+  const plugins = known.filter((p) => reasons[p.export]);
+  return { plugins, reasons, unused: known.filter((p) => !reasons[p.export]).map((p) => p.export) };
+};
+const generatePluginsModule = (sel) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const p of sel.plugins) groups.set(p.from, [...groups.get(p.from) ?? [], p.export]);
+  const imports = [...groups].map(([from, names]) => `import { ${names.join(", ")} } from ${JSON.stringify(from)}`).join("\n");
+  return `${imports}
+export const plugins = [${sel.plugins.map((p) => p.export).join(", ")}]
+export const report = ${JSON.stringify({ reasons: sel.reasons, unused: sel.unused }, null, 2)}
+`;
+};
+export {
+  builtinPlugins,
+  customPluginMeta,
+  generatePluginsModule,
+  implied,
+  mentions,
+  selectPlugins
+};
+//# sourceMappingURL=scan.js.map