@sylwellsoftware/glue 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,137 +1,628 @@
-var g = Object.defineProperty;
-var v = (t, s, e) => s in t ? g(t, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[s] = e;
-var n = (t, s, e) => v(t, typeof s != "symbol" ? s + "" : s, e);
-import { B as w, F as p, a as y, E, b } from "./emitter-upM7NC28.js";
-import { D as _, c as x, d as D } from "./emitter-upM7NC28.js";
-class H extends w {
+var H = Object.defineProperty;
+var F = (t, r, e) => r in t ? H(t, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[r] = e;
+var n = (t, r, e) => F(t, typeof r != "symbol" ? r + "" : r, e);
+let x = 1;
+class b {
+  constructor(r = {}) {
+    n(this, "id");
+    n(this, "timestamp");
+    n(this, "purpose");
+    n(this, "cause");
+    n(this, "value");
+    n(this, "parent");
+    n(this, "parentBubble");
+    n(this, "children", []);
+    n(this, "ownerType");
+    n(this, "ownerRef");
+    n(this, "strongOwner");
+    var s;
+    if (r == null || typeof r != "object" || Array.isArray(r))
+      throw new TypeError("EventBubble options must be an object");
+    this.id = `event-${x++}`, this.timestamp = r.timestamp ?? Date.now(), this.purpose = r.purpose ?? "unspecified", this.cause = r.cause ?? null, this.value = r.value, this.parent = r.parent ?? null, this.parentBubble = this.parent;
+    const e = r.owner;
+    this.ownerType = e == null ? null : $(e) ?? typeof e, B(e) && typeof WeakRef == "function" ? (this.ownerRef = new WeakRef(e), this.strongOwner = void 0) : (this.ownerRef = null, this.strongOwner = e), (s = this.parent) == null || s.registerChild(this);
+  }
+  get owner() {
+    var r;
+    return ((r = this.ownerRef) == null ? void 0 : r.deref()) ?? this.strongOwner;
+  }
+  registerChild(r) {
+    if (!(r instanceof b))
+      throw new TypeError("EventBubble children must be EventBubble instances");
+    this.children.includes(r) || this.children.push(r);
+  }
+}
+function B(t) {
+  return typeof t == "object" && t !== null || typeof t == "function";
+}
+function $(t) {
+  const r = Reflect.get(t, "constructor");
+  if (r == null || typeof r != "object" && typeof r != "function")
+    return;
+  const e = Reflect.get(r, "name");
+  return typeof e == "string" ? e : void 0;
+}
+const m = /* @__PURE__ */ new Set();
+function C(t) {
+  if (typeof t != "function")
+    throw new TypeError("EventBus.subscribe requires a function");
+  m.add(t);
+  let r = !0;
+  return () => {
+    r && (r = !1, m.delete(t));
+  };
+}
+function V(t) {
+  for (const r of [...m]) r(t);
+}
+const w = Object.freeze({
+  subscribe: C,
+  emit: V,
+  emitBubble: V,
+  registerBubbleGraph(t) {
+    if (t == null || typeof t.addBubble != "function")
+      throw new TypeError("registerBubbleGraph requires an addBubble() method");
+    return C((r) => t.addBubble(r));
+  },
+  get hasSubscribers() {
+    return m.size > 0;
+  },
+  get subscriberCount() {
+    return m.size;
+  }
+}), h = Object.freeze({
+  Error: "error",
+  Loading: "loading",
+  Initial: "initial",
+  Ready: "ready"
+}), S = /* @__PURE__ */ new Map([
+  [h.Ready, 1],
+  [h.Initial, 2],
+  [h.Loading, 3],
+  [h.Error, 4]
+]);
+function j(t) {
+  let r = h.Ready;
+  for (const e of t) {
+    if (!S.has(e))
+      throw new TypeError(`Unknown fetch state: ${String(e)}`);
+    if ((S.get(e) ?? 0) > (S.get(r) ?? 0) && (r = e), r === h.Error) break;
+  }
+  return r;
+}
+class g {
+  constructor(r, e = {}) {
+    n(this, "subscribers", /* @__PURE__ */ new Set());
+    n(this, "value");
+    n(this, "fetchState");
+    n(this, "error");
+    n(this, "equals");
+    n(this, "isDisposed", !1);
+    n(this, "owner");
+    n(this, "purpose");
+    n(this, "trace");
+    if (e == null || typeof e != "object" || Array.isArray(e))
+      throw new TypeError("Emitter options must be an object");
+    if (this.value = r, this.fetchState = e.fetchState ?? h.Ready, this.error = e.error ?? null, this.equals = e.equals ?? Object.is, this.owner = e.owner, this.purpose = e.purpose ?? this.constructor.name, this.trace = e.trace ?? !1, typeof this.equals != "function")
+      throw new TypeError("Emitter equals option must be a function");
+    R(this.fetchState);
+  }
+  subscribe(r, e = {}) {
+    if (this.isDisposed) throw new Error("Cannot subscribe to a disposed emitter");
+    if (typeof r != "function")
+      throw new TypeError("subscribe requires a function");
+    if (e == null || typeof e != "object" || Array.isArray(e))
+      throw new TypeError("subscribe options must be an object");
+    const { emitCurrent: s = !0, parentEvent: i = null } = e;
+    if (this.subscribers.add(r), s) {
+      const u = this.createEvent("subscribed", i, this.value);
+      r(this.notification(u));
+    }
+    let o = !0;
+    return () => {
+      o && (o = !1, this.subscribers.delete(r));
+    };
+  }
+  subscribeFutureValues(r) {
+    return this.subscribe(r, { emitCurrent: !1 });
+  }
+  get() {
+    return this.value;
+  }
+  getError() {
+    return this.error;
+  }
+  getFetchState() {
+    return this.fetchState;
+  }
+  get disposed() {
+    return this.isDisposed;
+  }
+  get subscriberCount() {
+    return this.subscribers.size;
+  }
+  map(r, e = {}) {
+    if (typeof r != "function") throw new TypeError("map requires a function");
+    return new D(
+      [this],
+      ([s]) => r(s),
+      {
+        ...e,
+        owner: e.owner ?? this.owner,
+        purpose: e.purpose ?? `${this.purpose}:map`,
+        trace: e.trace ?? this.trace
+      }
+    );
+  }
+  mapEach(r, e = {}) {
+    if (typeof r != "function") throw new TypeError("mapEach requires a function");
+    return new D([this], ([s]) => {
+      if (s == null) return s;
+      if (!Array.isArray(s))
+        throw new TypeError("mapEach source value must be an array");
+      return s.map((o, u) => o == null ? o : r(o, u));
+    }, {
+      ...e,
+      purpose: e.purpose ?? `${this.purpose}:mapEach`
+    });
+  }
+  dispose() {
+    this.isDisposed || (this.isDisposed = !0, this.subscribers.clear());
+  }
+  notification(r = null) {
+    return Object.freeze({
+      value: this.value,
+      fetchState: this.fetchState,
+      error: this.error,
+      event: r
+    });
+  }
+  notify(r = null) {
+    if (this.isDisposed) return;
+    const e = this.notification(r);
+    for (const s of [...this.subscribers]) s(e);
+  }
+  setSnapshot(r = {}) {
+    if (this.isDisposed) return !1;
+    const e = Object.hasOwn(r, "value") ? r.value : this.value, s = r.fetchState ?? this.fetchState, i = Object.hasOwn(r, "error") ? r.error : this.error, o = r.cause ?? "state changed", u = r.parentEvent ?? null;
+    if (R(s), !(!this.equals(this.value, e) || this.fetchState !== s || !Object.is(this.error, i))) return !1;
+    this.value = e, this.fetchState = s, this.error = i;
+    const c = this.createEvent(o, u, e);
+    return this.notify(c), !0;
+  }
+  createEvent(r, e = null, s = this.value) {
+    if (!this.trace && !e && !w.hasSubscribers) return null;
+    const i = new b({
+      owner: this.owner ?? this,
+      purpose: this.purpose,
+      value: s,
+      cause: r,
+      parent: e
+    });
+    return e || w.emit(i), i;
+  }
+}
+class D extends g {
+  constructor(e, s, i = {}) {
+    const { computeFetchState: o = j, ...u } = i;
+    super(void 0, {
+      ...u,
+      fetchState: h.Initial,
+      error: null
+    });
+    n(this, "sources");
+    n(this, "sourceUnsubscribers", []);
+    n(this, "compute");
+    n(this, "computeFetchState");
+    this.sources = [], this.compute = s, this.computeFetchState = o, this.setSourcesAndCompute(e, s, { notify: !1 });
+  }
+  setSourcesAndCompute(e, s = this.compute, i = {}) {
+    if (this.isDisposed) throw new Error("Cannot update a disposed derived emitter");
+    if (!Array.isArray(e) || e.some((o) => !k(o)))
+      throw new TypeError("DerivedEmitter sources must be an array of emitters");
+    if (typeof s != "function")
+      throw new TypeError("DerivedEmitter compute must be a function");
+    return this.releaseSources(), this.sources = [...e], this.compute = s, this.sourceUnsubscribers = this.sources.map(
+      (o) => o.subscribe(({ event: u }) => this.recompute(u), { emitCurrent: !1 })
+    ), this.recompute(i.parentEvent ?? null, i.notify ?? !0), this;
+  }
+  dispose() {
+    this.isDisposed || (this.releaseSources(), super.dispose());
+  }
+  releaseSources() {
+    for (const e of this.sourceUnsubscribers) e();
+    this.sourceUnsubscribers = [];
+  }
+  recompute(e = null, s = !0) {
+    const i = this.sources.map((d) => d.get()), o = this.sources.map((d) => d.getFetchState()), u = this.sources.map((d, v) => ({ sourceIndex: v, error: d.getError() })).filter((d) => d.error != null);
+    let a, c = null;
+    try {
+      a = this.compute(i);
+    } catch (d) {
+      c = d, a = void 0;
+    }
+    const f = c == null ? u : [...u, { sourceIndex: null, error: c }], p = _(this.error, f);
+    let l = this.computeFetchState(o);
+    if (R(l), (c != null || u.length > 0) && (l = h.Error), !s) {
+      this.value = a, this.fetchState = l, this.error = p;
+      return;
+    }
+    this.setSnapshot({
+      value: a,
+      fetchState: l,
+      error: p,
+      cause: "derived source changed",
+      parentEvent: e
+    });
+  }
+}
+function _(t, r) {
+  return r.length === 0 ? null : t != null && t.length === r.length && t.every((e, s) => {
+    var i, o;
+    return e.sourceIndex === ((i = r[s]) == null ? void 0 : i.sourceIndex) && Object.is(e.error, (o = r[s]) == null ? void 0 : o.error);
+  }) ? t : Object.freeze(r.map((e) => Object.freeze(e)));
+}
+function k(t) {
+  return (typeof t != "object" || t === null) && typeof t != "function" ? !1 : typeof Reflect.get(t, "get") == "function" && typeof Reflect.get(t, "getFetchState") == "function" && typeof Reflect.get(t, "getError") == "function" && typeof Reflect.get(t, "subscribe") == "function";
+}
+function R(t) {
+  j([t]);
+}
+class U extends g {
+  constructor(r, e = {}) {
+    super(r, e);
+  }
+  setWithState(r, e = h.Ready, s = null, i = null) {
+    const o = i instanceof b ? i : null, u = o ? "set called" : i ?? "set called";
+    return this.setSnapshot({ value: r, fetchState: e, error: s, cause: u, parentEvent: o });
+  }
+  set(r, e = null) {
+    return this.setWithState(r, h.Ready, null, e);
+  }
+}
+class M extends Error {
+  constructor() {
+    super("AsyncCommand is already running"), this.name = "AsyncCommandConcurrencyError";
+  }
+}
+class fe extends g {
+  constructor(e) {
+    N(e);
+    const {
+      execute: s,
+      concurrency: i = "ignore",
+      mapError: o = (f) => f,
+      owner: u,
+      purpose: a = "async command",
+      trace: c
+    } = e;
+    if (W(i), typeof o != "function")
+      throw new TypeError("AsyncCommand mapError must be a function");
+    super(void 0, {
+      fetchState: h.Initial,
+      error: null,
+      owner: u,
+      purpose: a,
+      ...c === void 0 ? {} : { trace: c }
+    });
+    n(this, "execute");
+    n(this, "concurrency");
+    n(this, "isRunning");
+    n(this, "mapError");
+    n(this, "runningEmitter");
+    n(this, "requestId", 0);
+    n(this, "abortController", null);
+    n(this, "lastSuccessfulValue");
+    n(this, "hasSuccessfulValue", !1);
+    /** Exposed for deterministic tests; consumers should use run()/abort(). */
+    n(this, "_activeRequest", null);
+    this.execute = s, this.concurrency = i, this.mapError = o, this.runningEmitter = new U(!1, {
+      owner: u ?? this,
+      purpose: `${a}:running`,
+      ...c === void 0 ? {} : { trace: c }
+    }), this.isRunning = this.runningEmitter;
+  }
+  run(e, s = "command run") {
+    var p;
+    if (this.isDisposed) return Promise.resolve(void 0);
+    if (this._activeRequest != null) {
+      if (this.concurrency === "ignore") return this._activeRequest;
+      if (this.concurrency === "reject")
+        return Promise.reject(new M());
+      (p = this.abortController) == null || p.abort();
+    }
+    const i = ++this.requestId, o = G();
+    this.abortController = o;
+    const u = s instanceof b ? s : null, a = u ? "parent command requested" : s;
+    this.setSnapshot({
+      value: this.lastSuccessfulValue,
+      fetchState: h.Loading,
+      error: null,
+      cause: a,
+      parentEvent: u
+    });
+    const c = this.createEvent("command execute", u, e);
+    this.runningEmitter.set(!0, c ?? a);
+    const f = Promise.resolve().then(() => this.execute(e, {
+      signal: o.signal,
+      event: c
+    })).then((l) => {
+      if (this.isCurrentRequest(i, o))
+        return this.lastSuccessfulValue = l, this.hasSuccessfulValue = !0, this.setSnapshot({
+          value: l,
+          fetchState: h.Ready,
+          error: null,
+          cause: "command succeeded",
+          parentEvent: c
+        }), l;
+    }).catch((l) => {
+      this.isCurrentRequest(i, o) && this.setSnapshot({
+        value: this.lastSuccessfulValue,
+        fetchState: h.Error,
+        error: this.mapCommandError(l),
+        cause: "command failed",
+        parentEvent: c
+      });
+    }).finally(() => {
+      this.isCurrentRequest(i, o) && (this.abortController = null, this._activeRequest = null, this.runningEmitter.set(!1, c ?? "command settled"));
+    });
+    return this._activeRequest = f, f;
+  }
+  abort(e = "command aborted") {
+    if (this.isDisposed || this.abortController == null) return !1;
+    const s = e instanceof b ? e : null, i = s ? "parent command aborted" : e;
+    return this.requestId += 1, this.abortController.abort(), this.abortController = null, this._activeRequest = null, this.runningEmitter.set(!1, s ?? i), this.setSnapshot({
+      value: this.lastSuccessfulValue,
+      fetchState: this.hasSuccessfulValue ? h.Ready : h.Initial,
+      error: null,
+      cause: i,
+      parentEvent: s
+    }), !0;
+  }
+  reset(e = "command reset") {
+    if (this.isDisposed) return;
+    this.abort(e), this.lastSuccessfulValue = void 0, this.hasSuccessfulValue = !1;
+    const s = e instanceof b ? e : null;
+    this.setSnapshot({
+      value: void 0,
+      fetchState: h.Initial,
+      error: null,
+      cause: s ? "parent command reset" : e,
+      parentEvent: s
+    });
+  }
+  dispose() {
+    var e;
+    this.isDisposed || (this.requestId += 1, (e = this.abortController) == null || e.abort(), this.abortController = null, this._activeRequest = null, this.runningEmitter.set(!1, "command disposed"), this.runningEmitter.dispose(), super.dispose());
+  }
+  isCurrentRequest(e, s) {
+    return !this.isDisposed && e === this.requestId && s === this.abortController && !s.signal.aborted;
+  }
+  mapCommandError(e) {
+    try {
+      return this.mapError(e);
+    } catch (s) {
+      return s;
+    }
+  }
+}
+function N(t) {
+  if (t == null || typeof t != "object" || Array.isArray(t))
+    throw new TypeError("AsyncCommand options must be an object");
+  if (typeof t.execute != "function")
+    throw new TypeError("AsyncCommand execute must be a function");
+}
+function W(t) {
+  if (t !== "ignore" && t !== "replace" && t !== "reject")
+    throw new TypeError(`Unknown AsyncCommand concurrency policy: ${t}`);
+}
+function G() {
+  const t = Reflect.get(globalThis, "AbortController");
+  if (typeof t != "function")
+    throw new Error("AsyncCommand requires AbortController in this runtime");
+  return new t();
+}
+class I extends g {
   constructor(e) {
     if (e == null || typeof e != "object" || Array.isArray(e))
       throw new TypeError("LiveQuery options must be an object");
     const {
-      handler: r,
+      handler: s,
       args: i = {},
       autoFetch: o = !0,
-      keepPreviousValue: f = !0,
-      owner: l,
-      purpose: c = "live query",
-      trace: u
+      keepPreviousValue: u = !0,
+      polling: a,
+      owner: c,
+      purpose: f = "live query",
+      trace: p
     } = e;
-    if (r == null || typeof r.fetch != "function")
+    if (s == null || typeof s.fetch != "function")
       throw new TypeError("LiveQuery handler must implement fetch()");
-    R(i);
+    X(i), a != null && K(a);
     super(void 0, {
-      fetchState: p.Initial,
+      fetchState: h.Initial,
       error: null,
-      owner: l,
-      purpose: c,
-      ...u === void 0 ? {} : { trace: u }
+      owner: c,
+      purpose: f,
+      ...p === void 0 ? {} : { trace: p }
     });
     n(this, "handler");
     n(this, "args");
     n(this, "keepPreviousValue");
     n(this, "lastSuccessfulValue");
+    n(this, "hasSuccessfulValue", !1);
     n(this, "argumentUnsubscribers");
+    n(this, "pollingUnsubscribers", []);
+    n(this, "polling");
+    n(this, "pollingScheduler");
+    n(this, "pollingHandle", null);
     n(this, "requestId", 0);
     n(this, "abortController", null);
     /** Exposed for deterministic tests; consumers should use refresh()/retry(). */
     n(this, "_activeRequest", null);
-    this.handler = r, this.args = { ...i }, this.keepPreviousValue = f, this.lastSuccessfulValue = void 0, this.argumentUnsubscribers = Object.values(this.args).map(
-      (h) => h.subscribe(({ event: a }) => {
-        this.refresh(a);
+    this.handler = s, this.args = { ...i }, this.keepPreviousValue = u, this.polling = a, this.pollingScheduler = (a == null ? void 0 : a.scheduler) ?? J, this.lastSuccessfulValue = void 0, this.argumentUnsubscribers = Object.values(this.args).map(
+      (l) => l.subscribe(({ event: d }) => {
+        this.refresh(d);
       }, { emitCurrent: !1 })
-    ), o && (this._activeRequest = this.refresh("initial fetch"));
+    ), a != null && this.initializePolling(a), o && (this._activeRequest = this.refresh("initial fetch")), this.scheduleNextPoll();
   }
   get argumentValues() {
     return Object.fromEntries(
-      Object.entries(this.args).map(([e, r]) => [e, r.get()])
+      Object.entries(this.args).map(([e, s]) => [e, s.get()])
     );
   }
   refresh(e = "refresh") {
-    var h;
+    var p;
     if (this.isDisposed) return Promise.resolve(void 0);
-    const r = ++this.requestId;
-    (h = this.abortController) == null || h.abort();
-    const i = q();
+    const s = ++this.requestId;
+    (p = this.abortController) == null || p.abort();
+    const i = Y();
     this.abortController = i;
-    const o = e instanceof y ? e : null, f = o ? "query arguments changed" : e, l = this.keepPreviousValue ? this.lastSuccessfulValue : void 0;
+    const o = e instanceof b ? e : null, u = o ? "query arguments changed" : e, a = this.keepPreviousValue ? this.lastSuccessfulValue : void 0;
     this.setSnapshot({
-      value: l,
-      fetchState: p.Loading,
+      value: a,
+      fetchState: h.Loading,
       error: null,
-      cause: f,
+      cause: u,
       parentEvent: o
     });
-    const c = this.createEvent("query fetch", o, this.argumentValues), u = Promise.resolve().then(() => this.handler.fetch(this.argumentValues, {
+    const c = this.createEvent("query fetch", o, this.argumentValues), f = Promise.resolve().then(() => this.handler.fetch(this.argumentValues, {
       signal: i.signal,
       event: c
-    })).then((a) => {
-      if (this.isCurrentRequest(r, i))
-        return this.lastSuccessfulValue = a, this.setSnapshot({
-          value: a,
-          fetchState: p.Ready,
+    })).then((l) => {
+      if (this.isCurrentRequest(s, i))
+        return this.lastSuccessfulValue = l, this.hasSuccessfulValue = !0, this.setSnapshot({
+          value: l,
+          fetchState: h.Ready,
           error: null,
           cause: "query succeeded",
           parentEvent: c
-        }), a;
-    }).catch((a) => {
-      !this.isCurrentRequest(r, i) || S(a) || this.setSnapshot({
+        }), l;
+    }).catch((l) => {
+      !this.isCurrentRequest(s, i) || Z(l) || this.setSnapshot({
         value: this.keepPreviousValue ? this.lastSuccessfulValue : void 0,
-        fetchState: p.Error,
-        error: a,
+        fetchState: h.Error,
+        error: l,
         cause: "query failed",
         parentEvent: c
       });
     }).finally(() => {
-      this.isCurrentRequest(r, i) && (this.abortController = null, this._activeRequest = null);
+      this.isCurrentRequest(s, i) && (this.abortController = null, this._activeRequest = null);
     });
-    return this._activeRequest = u, u;
+    return this._activeRequest = f, f;
   }
   retry(e = "retry") {
     return this.refresh(e);
   }
+  abort(e = "query aborted") {
+    if (this.isDisposed || this.abortController == null) return;
+    this.requestId += 1, this.abortController.abort(), this.abortController = null, this._activeRequest = null;
+    const s = e instanceof b ? e : null;
+    this.setSnapshot({
+      value: this.hasSuccessfulValue ? this.lastSuccessfulValue : void 0,
+      fetchState: this.hasSuccessfulValue ? h.Ready : h.Initial,
+      error: null,
+      cause: s == null ? e : "query aborted",
+      parentEvent: s
+    });
+  }
   dispose() {
     var e;
     if (!this.isDisposed) {
-      this.requestId += 1, (e = this.abortController) == null || e.abort(), this.abortController = null, this._activeRequest = null;
-      for (const r of this.argumentUnsubscribers) r();
-      this.argumentUnsubscribers = [], super.dispose();
+      this.requestId += 1, (e = this.abortController) == null || e.abort(), this.abortController = null, this._activeRequest = null, this.cancelScheduledPoll();
+      for (const s of this.argumentUnsubscribers) s();
+      this.argumentUnsubscribers = [];
+      for (const s of this.pollingUnsubscribers) s();
+      this.pollingUnsubscribers = [], super.dispose();
     }
   }
-  isCurrentRequest(e, r) {
-    return !this.isDisposed && e === this.requestId && r === this.abortController && !r.signal.aborted;
+  initializePolling(e) {
+    for (const s of [e.intervalMs, e.enabled])
+      T(s) && this.pollingUnsubscribers.push(s.subscribe(() => {
+        q(y(e.intervalMs)), Q(y(e.enabled, !0)), this.cancelScheduledPoll(), this.scheduleNextPoll();
+      }, { emitCurrent: !1 }));
+  }
+  scheduleNextPoll() {
+    if (this.isDisposed || this.polling == null || this.pollingHandle != null || !y(this.polling.enabled, !0)) return;
+    const e = y(this.polling.intervalMs);
+    q(e), this.pollingHandle = this.pollingScheduler.schedule(() => {
+      this.pollingHandle = null, this.scheduleNextPoll(), this._activeRequest == null && this.refresh("poll");
+    }, e);
+  }
+  cancelScheduledPoll() {
+    this.pollingHandle != null && (this.pollingScheduler.cancel(this.pollingHandle), this.pollingHandle = null);
+  }
+  isCurrentRequest(e, s) {
+    return !this.isDisposed && e === this.requestId && s === this.abortController && !s.signal.aborted;
   }
 }
-function R(t) {
+const J = {
+  schedule(t, r) {
+    const e = Reflect.get(globalThis, "setTimeout");
+    if (typeof e != "function")
+      throw new Error("LiveQuery polling requires an injected scheduler in this runtime");
+    return Reflect.apply(e, globalThis, [t, r]);
+  },
+  cancel(t) {
+    const r = Reflect.get(globalThis, "clearTimeout");
+    typeof r == "function" && Reflect.apply(r, globalThis, [t]);
+  }
+};
+function T(t) {
+  return t != null && (typeof t == "object" || typeof t == "function") && typeof Reflect.get(t, "get") == "function" && typeof Reflect.get(t, "subscribe") == "function";
+}
+function O(t, r) {
+  if (typeof t != "number" && typeof t != "boolean" && !T(t))
+    throw new TypeError(`LiveQuery polling ${r} must be a value or emitter`);
+}
+function K(t) {
+  if (t == null || typeof t != "object" || Array.isArray(t))
+    throw new TypeError("LiveQuery polling options must be an object");
+  if (O(t.intervalMs, "intervalMs"), t.enabled !== void 0 && O(t.enabled, "enabled"), q(y(t.intervalMs)), Q(y(t.enabled, !0)), t.scheduler != null && (typeof t.scheduler.schedule != "function" || typeof t.scheduler.cancel != "function"))
+    throw new TypeError("LiveQuery polling scheduler must implement schedule() and cancel()");
+}
+function y(t, r) {
+  return t === void 0 ? r : T(t) ? t.get() : t;
+}
+function q(t) {
+  if (!Number.isFinite(t) || t <= 0)
+    throw new RangeError("LiveQuery polling intervalMs must be a finite positive number");
+}
+function Q(t) {
+  if (typeof t != "boolean")
+    throw new TypeError("LiveQuery polling enabled must be a boolean");
+}
+function X(t) {
   if (t == null || typeof t != "object" || Array.isArray(t))
     throw new TypeError("LiveQuery args must be a named record of emitters");
-  for (const [s, e] of Object.entries(t))
+  for (const [r, e] of Object.entries(t))
     if (e == null || typeof Reflect.get(e, "get") != "function" || typeof Reflect.get(e, "subscribe") != "function")
-      throw new TypeError(`LiveQuery argument ${s} must be an emitter`);
+      throw new TypeError(`LiveQuery argument ${r} must be an emitter`);
 }
-function q() {
+function Y() {
   const t = Reflect.get(globalThis, "AbortController");
   if (typeof t != "function")
     throw new Error("LiveQuery requires AbortController in this runtime");
   return new t();
 }
-function S(t) {
+function Z(t) {
   return t instanceof Error && t.name === "AbortError";
 }
-class z extends E {
-  constructor(e, r, i = {}) {
+class pe extends U {
+  constructor(e, s, i = {}) {
     if (typeof e != "string" || e.length === 0)
       throw new TypeError("QueryArg name must be a non-empty string");
-    if (r == null || typeof r.get != "function" || typeof r.subscribe != "function")
+    if (s == null || typeof s.get != "function" || typeof s.subscribe != "function")
       throw new TypeError("QueryArg source must be an emitter");
-    super(r.get(), {
+    super(s.get(), {
       ...i,
-      fetchState: r.getFetchState(),
-      error: r.getError(),
+      fetchState: s.getFetchState(),
+      error: s.getError(),
       purpose: i.purpose ?? `query argument: ${e}`
     });
     n(this, "name");
     n(this, "sourceUnsubscribe");
-    this.name = e, this.sourceUnsubscribe = r.subscribe((o) => {
+    this.name = e, this.sourceUnsubscribe = s.subscribe((o) => {
       this.setWithState(
         o.value,
         o.fetchState,
@@ -145,118 +636,277 @@ class z extends E {
     this.isDisposed || ((e = this.sourceUnsubscribe) == null || e.call(this), this.sourceUnsubscribe = null, super.dispose());
   }
 }
-class T {
-  fetch(s, e = {}) {
+class ee {
+  fetch(r, e = {}) {
     throw new Error("fetch() must be implemented");
   }
 }
-class U extends Error {
+class te extends Error {
   constructor(e) {
     super(`HTTP ${e ?? "unknown"}`);
     n(this, "status");
     this.name = "HttpError", this.status = e;
   }
 }
-class I extends T {
+class re extends ee {
   constructor(e) {
     super();
     n(this, "url");
     n(this, "baseUrl");
     n(this, "fetchImplementation");
     n(this, "serialize");
+    n(this, "parseResult");
     n(this, "trace");
-    const r = typeof e == "string" ? { url: e } : e;
-    if (r == null || typeof r != "object")
+    const s = typeof e == "string" ? { url: e } : e;
+    if (s == null || typeof s != "object")
       throw new TypeError("RestQueryHandler requires a URL or options object");
-    if (typeof r.url != "string" || r.url.length === 0)
+    if (typeof s.url != "string" || s.url.length === 0)
       throw new TypeError("RestQueryHandler url must be a non-empty string");
-    if (this.url = r.url, this.baseUrl = r.baseUrl ?? V(), this.fetchImplementation = r.fetch ?? j(), this.serialize = r.serialize ?? A, this.trace = r.trace ?? !1, typeof this.fetchImplementation != "function")
+    if (this.url = s.url, this.baseUrl = s.baseUrl ?? ie(), this.fetchImplementation = s.fetch ?? oe(), this.serialize = s.serialize ?? se, this.parseResult = s.parseResult, this.trace = s.trace ?? !1, typeof this.fetchImplementation != "function")
       throw new TypeError("RestQueryHandler requires an injected fetch implementation");
     if (typeof this.serialize != "function")
       throw new TypeError("RestQueryHandler serialize must be a function");
+    if (this.parseResult !== void 0 && typeof this.parseResult != "function")
+      throw new TypeError("RestQueryHandler parseResult must be a function");
   }
-  async fetch(e, r = {}) {
+  async fetch(e, s = {}) {
     if (e == null || typeof e != "object" || Array.isArray(e))
       throw new TypeError("REST query args must be a named record");
-    const i = Q(this.url, this.baseUrl), o = this.serialize(i, e) ?? i, f = d();
-    if (!(o instanceof f))
+    const i = ne(this.url, this.baseUrl), o = this.serialize(i, e) ?? i, u = P();
+    if (!(o instanceof u))
       throw new TypeError("REST serializer must mutate or return a URL");
-    const l = r.event ?? null;
-    if (this.trace || l || b.hasSubscribers) {
-      const h = new y({
+    const a = s.event ?? null;
+    if (this.trace || a || w.hasSubscribers) {
+      const l = new b({
         owner: this,
         purpose: "REST fetch",
         value: o.toString(),
         cause: "fetch called",
-        parent: l
+        parent: a
       });
-      l || b.emit(h);
+      a || w.emit(l);
     }
-    const c = r.signal === void 0 ? {} : { signal: r.signal }, u = await this.fetchImplementation(o.toString(), c);
-    if (!(u != null && u.ok)) throw new U(u == null ? void 0 : u.status);
-    return await u.json();
+    const c = s.signal === void 0 ? {} : { signal: s.signal }, f = await this.fetchImplementation(o.toString(), c);
+    if (!(f != null && f.ok)) throw new te(f == null ? void 0 : f.status);
+    const p = await f.json();
+    return this.parseResult == null ? p : this.parseResult(p);
   }
 }
-function A(t, s) {
-  for (const [e, r] of Object.entries(s))
-    m(t.searchParams, e, r);
+function se(t, r) {
+  for (const [e, s] of Object.entries(r))
+    L(t.searchParams, e, s);
   return t;
 }
-function m(t, s, e) {
+function L(t, r, e) {
   if (e !== void 0) {
     if (e === null) {
-      t.append(s, "");
+      t.append(r, "");
       return;
     }
     if (Array.isArray(e)) {
-      for (const r of e) m(t, s, r);
+      for (const s of e) L(t, r, s);
       return;
     }
     if (typeof e == "object") {
-      t.append(s, JSON.stringify(e));
+      t.append(r, JSON.stringify(e));
       return;
     }
-    t.append(s, String(e));
+    t.append(r, String(e));
   }
 }
-function Q(t, s) {
-  const e = d();
+function ne(t, r) {
+  const e = P();
   try {
     return new e(t);
-  } catch (r) {
-    if (s == null)
-      throw new TypeError(`Relative REST URL requires baseUrl: ${t}`, { cause: r });
-    return new e(t, s);
+  } catch (s) {
+    if (r == null)
+      throw new TypeError(`Relative REST URL requires baseUrl: ${t}`, { cause: s });
+    return new e(t, r);
   }
 }
-function d() {
+function P() {
   const t = Reflect.get(globalThis, "URL");
   if (typeof t != "function")
     throw new Error("RestQueryHandler requires URL in this runtime");
   return t;
 }
-function V() {
+function ie() {
   const t = Reflect.get(globalThis, "location");
   if (t == null || typeof t != "object" && typeof t != "function")
     return;
-  const s = Reflect.get(t, "href");
-  return typeof s == "string" ? s : void 0;
+  const r = Reflect.get(t, "href");
+  return typeof r == "string" ? r : void 0;
 }
-function j() {
+function oe() {
   return Reflect.get(globalThis, "fetch");
 }
+class ue {
+  constructor(r) {
+    n(this, "handler");
+    n(this, "queryOptions");
+    if (r == null || typeof r != "object" || Array.isArray(r))
+      throw new TypeError("QueryEndpoint options must be an object");
+    if (r.handler == null || typeof r.handler.fetch != "function")
+      throw new TypeError("QueryEndpoint handler must implement fetch()");
+    const e = r.query ?? {};
+    E(e), this.handler = r.handler, this.queryOptions = Object.freeze({ ...e }), Object.freeze(this);
+  }
+  open(r, e = {}) {
+    return A(r), E(e), new I({
+      handler: this.handler,
+      args: r,
+      ...this.queryOptions,
+      ...e
+    });
+  }
+}
+function de(t) {
+  return new ue(t);
+}
+class ce {
+  constructor(r) {
+    n(this, "handler");
+    n(this, "queryOptions");
+    if (r == null || typeof r != "object" || Array.isArray(r))
+      throw new TypeError("RestEndpoint options must be an object");
+    const { query: e = {}, ...s } = r;
+    E(e, "RestEndpoint query options"), this.handler = new re(s), this.queryOptions = Object.freeze({ ...e }), Object.freeze(this);
+  }
+  open(r, e = {}) {
+    return A(r), E(e), new I({
+      handler: this.handler,
+      args: r,
+      ...this.queryOptions,
+      ...e
+    });
+  }
+}
+function be(t) {
+  return new ce(t);
+}
+class le {
+  constructor(r) {
+    n(this, "apply");
+    n(this, "purpose");
+    if (r == null || typeof r != "object" || Array.isArray(r))
+      throw new TypeError("DerivedEndpoint options must be an object");
+    if (typeof r.apply != "function")
+      throw new TypeError("DerivedEndpoint apply must be a function");
+    this.apply = r.apply, this.purpose = r.purpose ?? "derived endpoint", Object.freeze(this);
+  }
+  open(r) {
+    return new ae({
+      ...r,
+      apply: this.apply,
+      purpose: r.purpose ?? this.purpose
+    });
+  }
+}
+function ye(t) {
+  return new le(t);
+}
+class ae extends g {
+  constructor(e) {
+    if (e == null || typeof e != "object" || Array.isArray(e))
+      throw new TypeError("DerivedLiveResult options must be an object");
+    if (A(e.args), !z(e.source))
+      throw new TypeError("DerivedLiveResult source must be an emitter");
+    if (typeof e.apply != "function")
+      throw new TypeError("DerivedLiveResult apply must be a function");
+    super(void 0, {
+      fetchState: h.Initial,
+      error: null,
+      owner: e.owner,
+      ...e.purpose === void 0 ? {} : { purpose: e.purpose },
+      ...e.trace === void 0 ? {} : { trace: e.trace }
+    });
+    n(this, "source");
+    n(this, "args");
+    n(this, "apply");
+    n(this, "unsubscribers", []);
+    n(this, "lastSuccessfulValue");
+    this.source = e.source, this.args = { ...e.args }, this.apply = e.apply, this.lastSuccessfulValue = void 0;
+    const s = [
+      this.source,
+      ...Object.values(this.args)
+    ];
+    this.unsubscribers = s.map((i) => i.subscribe(({ event: o }) => {
+      this.recompute(o);
+    }, { emitCurrent: !1 })), this.recompute(null, !1);
+  }
+  dispose() {
+    if (!this.isDisposed) {
+      for (const e of this.unsubscribers) e();
+      this.unsubscribers = [], super.dispose();
+    }
+  }
+  recompute(e, s = !0) {
+    var p;
+    const i = [
+      this.source,
+      ...Object.values(this.args)
+    ], o = ((p = i.find((l) => l.getError() != null)) == null ? void 0 : p.getError()) ?? null;
+    let u = j(
+      i.map((l) => l.getFetchState())
+    );
+    const a = this.source.get();
+    let c = this.lastSuccessfulValue, f = o;
+    try {
+      const l = Object.fromEntries(
+        Object.entries(this.args).map(([d, v]) => [d, v.get()])
+      );
+      c = this.apply(a, l), this.lastSuccessfulValue = c;
+    } catch (l) {
+      f = l, u = h.Error;
+    }
+    if (o != null && (f = o, u = h.Error), !s) {
+      this.value = c, this.fetchState = u, this.error = f;
+      return;
+    }
+    this.setSnapshot({
+      value: c,
+      fetchState: u,
+      error: f,
+      cause: "derived endpoint source changed",
+      parentEvent: e
+    });
+  }
+}
+function E(t, r = "Endpoint query options") {
+  if (t == null || typeof t != "object" || Array.isArray(t))
+    throw new TypeError(`${r} must be an object`);
+}
+function A(t) {
+  if (t == null || typeof t != "object" || Array.isArray(t))
+    throw new TypeError("Endpoint args must be a named record of emitters");
+  for (const [r, e] of Object.entries(t))
+    if (!z(e))
+      throw new TypeError(`Endpoint argument ${r} must be an emitter`);
+}
+function z(t) {
+  return t != null && (typeof t == "object" || typeof t == "function") && typeof Reflect.get(t, "get") == "function" && typeof Reflect.get(t, "getFetchState") == "function" && typeof Reflect.get(t, "getError") == "function" && typeof Reflect.get(t, "subscribe") == "function";
+}
 export {
-  w as BaseEmitter,
-  _ as DerivedEmitter,
-  E as Emitter,
-  y as EventBubble,
-  b as EventBus,
-  p as FetchState,
-  x as FetchStateValues,
-  H as LiveQuery,
-  z as QueryArg,
-  T as QueryHandler,
-  I as RestQueryHandler,
-  D as combineFetchStates
+  fe as AsyncCommand,
+  M as AsyncCommandConcurrencyError,
+  g as BaseEmitter,
+  D as DerivedEmitter,
+  le as DerivedEndpoint,
+  ae as DerivedLiveResult,
+  U as Emitter,
+  b as EventBubble,
+  w as EventBus,
+  h as FetchState,
+  S as FetchStateValues,
+  I as LiveQuery,
+  pe as QueryArg,
+  ue as QueryEndpoint,
+  ee as QueryHandler,
+  ce as RestEndpoint,
+  re as RestQueryHandler,
+  j as combineFetchStates,
+  ye as derivedEndpoint,
+  de as queryEndpoint,
+  be as restEndpoint
 };
 //# sourceMappingURL=index.js.map