@sylwellsoftware/glue 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,9 +1,9 @@
-var U = Object.defineProperty;
-var V = (r, t, e) => t in r ? U(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
-var n = (r, t, e) => V(r, typeof t != "symbol" ? t + "" : t, e);
-let I = 1;
+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(t = {}) {
+  constructor(r = {}) {
     n(this, "id");
     n(this, "timestamp");
     n(this, "purpose");
@@ -16,53 +16,53 @@ class b {
     n(this, "ownerRef");
     n(this, "strongOwner");
     var s;
-    if (t == null || typeof t != "object" || Array.isArray(t))
+    if (r == null || typeof r != "object" || Array.isArray(r))
       throw new TypeError("EventBubble options must be an object");
-    this.id = `event-${I++}`, this.timestamp = t.timestamp ?? Date.now(), this.purpose = t.purpose ?? "unspecified", this.cause = t.cause ?? null, this.value = t.value, this.parent = t.parent ?? null, this.parentBubble = this.parent;
-    const e = t.owner;
-    this.ownerType = e == null ? null : z(e) ?? typeof e, D(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);
+    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 t;
-    return ((t = this.ownerRef) == null ? void 0 : t.deref()) ?? this.strongOwner;
+    var r;
+    return ((r = this.ownerRef) == null ? void 0 : r.deref()) ?? this.strongOwner;
   }
-  registerChild(t) {
-    if (!(t instanceof b))
+  registerChild(r) {
+    if (!(r instanceof b))
       throw new TypeError("EventBubble children must be EventBubble instances");
-    this.children.includes(t) || this.children.push(t);
+    this.children.includes(r) || this.children.push(r);
   }
 }
-function D(r) {
-  return typeof r == "object" && r !== null || typeof r == "function";
+function B(t) {
+  return typeof t == "object" && t !== null || typeof t == "function";
 }
-function z(r) {
-  const t = Reflect.get(r, "constructor");
-  if (t == null || typeof t != "object" && 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(t, "name");
+  const e = Reflect.get(r, "name");
   return typeof e == "string" ? e : void 0;
 }
 const m = /* @__PURE__ */ new Set();
-function v(r) {
-  if (typeof r != "function")
+function C(t) {
+  if (typeof t != "function")
     throw new TypeError("EventBus.subscribe requires a function");
-  m.add(r);
-  let t = !0;
+  m.add(t);
+  let r = !0;
   return () => {
-    t && (t = !1, m.delete(r));
+    r && (r = !1, m.delete(t));
   };
 }
-function S(r) {
-  for (const t of [...m]) t(r);
+function V(t) {
+  for (const r of [...m]) r(t);
 }
-const y = Object.freeze({
-  subscribe: v,
-  emit: S,
-  emitBubble: S,
-  registerBubbleGraph(r) {
-    if (r == null || typeof r.addBubble != "function")
+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 v((t) => r.addBubble(t));
+    return C((r) => t.addBubble(r));
   },
   get hasSubscribers() {
     return m.size > 0;
@@ -70,28 +70,28 @@ const y = Object.freeze({
   get subscriberCount() {
     return m.size;
   }
-}), a = Object.freeze({
+}), h = Object.freeze({
   Error: "error",
   Loading: "loading",
   Initial: "initial",
   Ready: "ready"
-}), g = /* @__PURE__ */ new Map([
-  [a.Ready, 1],
-  [a.Initial, 2],
-  [a.Loading, 3],
-  [a.Error, 4]
+}), S = /* @__PURE__ */ new Map([
+  [h.Ready, 1],
+  [h.Initial, 2],
+  [h.Loading, 3],
+  [h.Error, 4]
 ]);
-function q(r) {
-  let t = a.Ready;
-  for (const e of r) {
-    if (!g.has(e))
+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 ((g.get(e) ?? 0) > (g.get(t) ?? 0) && (t = e), t === a.Error) break;
+    if ((S.get(e) ?? 0) > (S.get(r) ?? 0) && (r = e), r === h.Error) break;
   }
-  return t;
+  return r;
 }
-class w {
-  constructor(t, e = {}) {
+class g {
+  constructor(r, e = {}) {
     n(this, "subscribers", /* @__PURE__ */ new Set());
     n(this, "value");
     n(this, "fetchState");
@@ -103,28 +103,28 @@ class w {
     n(this, "trace");
     if (e == null || typeof e != "object" || Array.isArray(e))
       throw new TypeError("Emitter options must be an object");
-    if (this.value = t, this.fetchState = e.fetchState ?? a.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")
+    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");
-    E(this.fetchState);
+    R(this.fetchState);
   }
-  subscribe(t, e = {}) {
+  subscribe(r, e = {}) {
     if (this.isDisposed) throw new Error("Cannot subscribe to a disposed emitter");
-    if (typeof t != "function")
+    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(t), s) {
+    if (this.subscribers.add(r), s) {
       const u = this.createEvent("subscribed", i, this.value);
-      t(this.notification(u));
+      r(this.notification(u));
     }
     let o = !0;
     return () => {
-      o && (o = !1, this.subscribers.delete(t));
+      o && (o = !1, this.subscribers.delete(r));
     };
   }
-  subscribeFutureValues(t) {
-    return this.subscribe(t, { emitCurrent: !1 });
+  subscribeFutureValues(r) {
+    return this.subscribe(r, { emitCurrent: !1 });
   }
   get() {
     return this.value;
@@ -141,11 +141,11 @@ class w {
   get subscriberCount() {
     return this.subscribers.size;
   }
-  map(t, e = {}) {
-    if (typeof t != "function") throw new TypeError("map requires a function");
-    return new R(
+  map(r, e = {}) {
+    if (typeof r != "function") throw new TypeError("map requires a function");
+    return new D(
       [this],
-      ([s]) => t(s),
+      ([s]) => r(s),
       {
         ...e,
         owner: e.owner ?? this.owner,
@@ -154,13 +154,13 @@ class w {
       }
     );
   }
-  mapEach(t, e = {}) {
-    if (typeof t != "function") throw new TypeError("mapEach requires a function");
-    return new R([this], ([s]) => {
+  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 : t(o, u));
+      return s.map((o, u) => o == null ? o : r(o, u));
     }, {
       ...e,
       purpose: e.purpose ?? `${this.purpose}:mapEach`
@@ -169,45 +169,45 @@ class w {
   dispose() {
     this.isDisposed || (this.isDisposed = !0, this.subscribers.clear());
   }
-  notification(t = null) {
+  notification(r = null) {
     return Object.freeze({
       value: this.value,
       fetchState: this.fetchState,
       error: this.error,
-      event: t
+      event: r
     });
   }
-  notify(t = null) {
+  notify(r = null) {
     if (this.isDisposed) return;
-    const e = this.notification(t);
+    const e = this.notification(r);
     for (const s of [...this.subscribers]) s(e);
   }
-  setSnapshot(t = {}) {
+  setSnapshot(r = {}) {
     if (this.isDisposed) return !1;
-    const e = Object.hasOwn(t, "value") ? t.value : this.value, s = t.fetchState ?? this.fetchState, i = Object.hasOwn(t, "error") ? t.error : this.error, o = t.cause ?? "state changed", u = t.parentEvent ?? null;
-    if (E(s), !(!this.equals(this.value, e) || this.fetchState !== s || !Object.is(this.error, i))) 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(t, e = null, s = this.value) {
-    if (!this.trace && !e && !y.hasSubscribers) return null;
+  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: t,
+      cause: r,
       parent: e
     });
-    return e || y.emit(i), i;
+    return e || w.emit(i), i;
   }
 }
-class R extends w {
+class D extends g {
   constructor(e, s, i = {}) {
-    const { computeFetchState: o = q, ...u } = i;
+    const { computeFetchState: o = j, ...u } = i;
     super(void 0, {
       ...u,
-      fetchState: a.Initial,
+      fetchState: h.Initial,
       error: null
     });
     n(this, "sources");
@@ -218,7 +218,7 @@ class R extends w {
   }
   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) => !Q(o)))
+    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");
@@ -234,75 +234,75 @@ class R extends w {
     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, j) => ({ sourceIndex: j, error: d.getError() })).filter((d) => d.error != null);
-    let h, c = null;
+    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 {
-      h = this.compute(i);
+      a = this.compute(i);
     } catch (d) {
-      c = d, h = void 0;
+      c = d, a = void 0;
     }
-    const l = c == null ? u : [...u, { sourceIndex: null, error: c }], p = L(this.error, l);
-    let f = this.computeFetchState(o);
-    if (E(f), (c != null || u.length > 0) && (f = a.Error), !s) {
-      this.value = h, this.fetchState = f, this.error = p;
+    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: h,
-      fetchState: f,
+      value: a,
+      fetchState: l,
       error: p,
       cause: "derived source changed",
       parentEvent: e
     });
   }
 }
-function L(r, t) {
-  return t.length === 0 ? null : r != null && r.length === t.length && r.every((e, s) => {
+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 = t[s]) == null ? void 0 : i.sourceIndex) && Object.is(e.error, (o = t[s]) == null ? void 0 : o.error);
-  }) ? r : Object.freeze(t.map((e) => Object.freeze(e)));
+    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 Q(r) {
-  return (typeof r != "object" || r === null) && typeof r != "function" ? !1 : typeof Reflect.get(r, "get") == "function" && typeof Reflect.get(r, "getFetchState") == "function" && typeof Reflect.get(r, "getError") == "function" && typeof Reflect.get(r, "subscribe") == "function";
+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 E(r) {
-  q([r]);
+function R(t) {
+  j([t]);
 }
-class C extends w {
-  constructor(t, e = {}) {
-    super(t, e);
+class U extends g {
+  constructor(r, e = {}) {
+    super(r, e);
   }
-  setWithState(t, e = a.Ready, s = null, i = null) {
+  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: t, fetchState: e, error: s, cause: u, parentEvent: o });
+    return this.setSnapshot({ value: r, fetchState: e, error: s, cause: u, parentEvent: o });
   }
-  set(t, e = null) {
-    return this.setWithState(t, a.Ready, null, e);
+  set(r, e = null) {
+    return this.setWithState(r, h.Ready, null, e);
   }
 }
-class B extends Error {
+class M extends Error {
   constructor() {
     super("AsyncCommand is already running"), this.name = "AsyncCommandConcurrencyError";
   }
 }
-class K extends w {
+class fe extends g {
   constructor(e) {
-    O(e);
+    N(e);
     const {
       execute: s,
       concurrency: i = "ignore",
-      mapError: o = (l) => l,
+      mapError: o = (f) => f,
       owner: u,
-      purpose: h = "async command",
+      purpose: a = "async command",
       trace: c
     } = e;
-    if (F(i), typeof o != "function")
+    if (W(i), typeof o != "function")
       throw new TypeError("AsyncCommand mapError must be a function");
     super(void 0, {
-      fetchState: a.Initial,
+      fetchState: h.Initial,
       error: null,
       owner: u,
-      purpose: h,
+      purpose: a,
       ...c === void 0 ? {} : { trace: c }
     });
     n(this, "execute");
@@ -316,9 +316,9 @@ class K extends w {
     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 C(!1, {
+    this.execute = s, this.concurrency = i, this.mapError = o, this.runningEmitter = new U(!1, {
       owner: u ?? this,
-      purpose: `${h}:running`,
+      purpose: `${a}:running`,
       ...c === void 0 ? {} : { trace: c }
     }), this.isRunning = this.runningEmitter;
   }
@@ -328,52 +328,52 @@ class K extends w {
     if (this._activeRequest != null) {
       if (this.concurrency === "ignore") return this._activeRequest;
       if (this.concurrency === "reject")
-        return Promise.reject(new B());
+        return Promise.reject(new M());
       (p = this.abortController) == null || p.abort();
     }
-    const i = ++this.requestId, o = k();
+    const i = ++this.requestId, o = G();
     this.abortController = o;
-    const u = s instanceof b ? s : null, h = u ? "parent command requested" : s;
+    const u = s instanceof b ? s : null, a = u ? "parent command requested" : s;
     this.setSnapshot({
       value: this.lastSuccessfulValue,
-      fetchState: a.Loading,
+      fetchState: h.Loading,
       error: null,
-      cause: h,
+      cause: a,
       parentEvent: u
     });
     const c = this.createEvent("command execute", u, e);
-    this.runningEmitter.set(!0, c ?? h);
-    const l = Promise.resolve().then(() => this.execute(e, {
+    this.runningEmitter.set(!0, c ?? a);
+    const f = Promise.resolve().then(() => this.execute(e, {
       signal: o.signal,
       event: c
-    })).then((f) => {
+    })).then((l) => {
       if (this.isCurrentRequest(i, o))
-        return this.lastSuccessfulValue = f, this.hasSuccessfulValue = !0, this.setSnapshot({
-          value: f,
-          fetchState: a.Ready,
+        return this.lastSuccessfulValue = l, this.hasSuccessfulValue = !0, this.setSnapshot({
+          value: l,
+          fetchState: h.Ready,
           error: null,
           cause: "command succeeded",
           parentEvent: c
-        }), f;
-    }).catch((f) => {
+        }), l;
+    }).catch((l) => {
       this.isCurrentRequest(i, o) && this.setSnapshot({
         value: this.lastSuccessfulValue,
-        fetchState: a.Error,
-        error: this.mapCommandError(f),
+        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 = l, l;
+    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 ? a.Ready : a.Initial,
+      fetchState: this.hasSuccessfulValue ? h.Ready : h.Initial,
       error: null,
       cause: i,
       parentEvent: s
@@ -385,7 +385,7 @@ class K extends w {
     const s = e instanceof b ? e : null;
     this.setSnapshot({
       value: void 0,
-      fetchState: a.Initial,
+      fetchState: h.Initial,
       error: null,
       cause: s ? "parent command reset" : e,
       parentEvent: s
@@ -406,23 +406,23 @@ class K extends w {
     }
   }
 }
-function O(r) {
-  if (r == null || typeof r != "object" || Array.isArray(r))
+function N(t) {
+  if (t == null || typeof t != "object" || Array.isArray(t))
     throw new TypeError("AsyncCommand options must be an object");
-  if (typeof r.execute != "function")
+  if (typeof t.execute != "function")
     throw new TypeError("AsyncCommand execute must be a function");
 }
-function F(r) {
-  if (r !== "ignore" && r !== "replace" && r !== "reject")
-    throw new TypeError(`Unknown AsyncCommand concurrency policy: ${r}`);
+function W(t) {
+  if (t !== "ignore" && t !== "replace" && t !== "reject")
+    throw new TypeError(`Unknown AsyncCommand concurrency policy: ${t}`);
 }
-function k() {
-  const r = Reflect.get(globalThis, "AbortController");
-  if (typeof r != "function")
+function G() {
+  const t = Reflect.get(globalThis, "AbortController");
+  if (typeof t != "function")
     throw new Error("AsyncCommand requires AbortController in this runtime");
-  return new r();
+  return new t();
 }
-class X extends w {
+class I extends g {
   constructor(e) {
     if (e == null || typeof e != "object" || Array.isArray(e))
       throw new TypeError("LiveQuery options must be an object");
@@ -431,34 +431,40 @@ class X extends w {
       args: i = {},
       autoFetch: o = !0,
       keepPreviousValue: u = !0,
-      owner: h,
-      purpose: c = "live query",
-      trace: l
+      polling: a,
+      owner: c,
+      purpose: f = "live query",
+      trace: p
     } = e;
     if (s == null || typeof s.fetch != "function")
       throw new TypeError("LiveQuery handler must implement fetch()");
-    P(i);
+    X(i), a != null && K(a);
     super(void 0, {
-      fetchState: a.Initial,
+      fetchState: h.Initial,
       error: null,
-      owner: h,
-      purpose: c,
-      ...l === void 0 ? {} : { trace: l }
+      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 = s, this.args = { ...i }, this.keepPreviousValue = u, this.lastSuccessfulValue = void 0, this.argumentUnsubscribers = Object.values(this.args).map(
-      (p) => p.subscribe(({ event: f }) => {
-        this.refresh(f);
+    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(
@@ -470,73 +476,139 @@ class X extends w {
     if (this.isDisposed) return Promise.resolve(void 0);
     const s = ++this.requestId;
     (p = this.abortController) == null || p.abort();
-    const i = _();
+    const i = Y();
     this.abortController = i;
-    const o = e instanceof b ? e : null, u = o ? "query arguments changed" : e, h = 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: h,
-      fetchState: a.Loading,
+      value: a,
+      fetchState: h.Loading,
       error: null,
       cause: u,
       parentEvent: o
     });
-    const c = this.createEvent("query fetch", o, this.argumentValues), l = 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((f) => {
+    })).then((l) => {
       if (this.isCurrentRequest(s, i))
-        return this.lastSuccessfulValue = f, this.setSnapshot({
-          value: f,
-          fetchState: a.Ready,
+        return this.lastSuccessfulValue = l, this.hasSuccessfulValue = !0, this.setSnapshot({
+          value: l,
+          fetchState: h.Ready,
           error: null,
           cause: "query succeeded",
           parentEvent: c
-        }), f;
-    }).catch((f) => {
-      !this.isCurrentRequest(s, i) || H(f) || this.setSnapshot({
+        }), l;
+    }).catch((l) => {
+      !this.isCurrentRequest(s, i) || Z(l) || this.setSnapshot({
         value: this.keepPreviousValue ? this.lastSuccessfulValue : void 0,
-        fetchState: a.Error,
-        error: f,
+        fetchState: h.Error,
+        error: l,
         cause: "query failed",
         parentEvent: c
       });
     }).finally(() => {
       this.isCurrentRequest(s, i) && (this.abortController = null, this._activeRequest = null);
     });
-    return this._activeRequest = l, l;
+    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;
+      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 = [], super.dispose();
+      this.argumentUnsubscribers = [];
+      for (const s of this.pollingUnsubscribers) s();
+      this.pollingUnsubscribers = [], super.dispose();
     }
   }
+  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 P(r) {
-  if (r == null || typeof r != "object" || Array.isArray(r))
+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 [t, e] of Object.entries(r))
+  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 ${t} must be an emitter`);
+      throw new TypeError(`LiveQuery argument ${r} must be an emitter`);
 }
-function _() {
-  const r = Reflect.get(globalThis, "AbortController");
-  if (typeof r != "function")
+function Y() {
+  const t = Reflect.get(globalThis, "AbortController");
+  if (typeof t != "function")
     throw new Error("LiveQuery requires AbortController in this runtime");
-  return new r();
+  return new t();
 }
-function H(r) {
-  return r instanceof Error && r.name === "AbortError";
+function Z(t) {
+  return t instanceof Error && t.name === "AbortError";
 }
-class Y extends C {
+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");
@@ -564,120 +636,277 @@ class Y extends C {
     this.isDisposed || ((e = this.sourceUnsubscribe) == null || e.call(this), this.sourceUnsubscribe = null, super.dispose());
   }
 }
-class $ {
-  fetch(t, e = {}) {
+class ee {
+  fetch(r, e = {}) {
     throw new Error("fetch() must be implemented");
   }
 }
-class x extends Error {
+class te extends Error {
   constructor(e) {
     super(`HTTP ${e ?? "unknown"}`);
     n(this, "status");
     this.name = "HttpError", this.status = e;
   }
 }
-class Z extends $ {
+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 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 s.url != "string" || s.url.length === 0)
       throw new TypeError("RestQueryHandler url must be a non-empty string");
-    if (this.url = s.url, this.baseUrl = s.baseUrl ?? N(), this.fetchImplementation = s.fetch ?? J(), this.serialize = s.serialize ?? W, this.trace = s.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, s = {}) {
     if (e == null || typeof e != "object" || Array.isArray(e))
       throw new TypeError("REST query args must be a named record");
-    const i = G(this.url, this.baseUrl), o = this.serialize(i, e) ?? i, u = A();
+    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 h = s.event ?? null;
-    if (this.trace || h || y.hasSubscribers) {
-      const p = new b({
+    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: h
+        parent: a
       });
-      h || y.emit(p);
+      a || w.emit(l);
     }
-    const c = s.signal === void 0 ? {} : { signal: s.signal }, l = await this.fetchImplementation(o.toString(), c);
-    if (!(l != null && l.ok)) throw new x(l == null ? void 0 : l.status);
-    return await l.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 W(r, t) {
-  for (const [e, s] of Object.entries(t))
-    T(r.searchParams, e, s);
-  return r;
+function se(t, r) {
+  for (const [e, s] of Object.entries(r))
+    L(t.searchParams, e, s);
+  return t;
 }
-function T(r, t, e) {
+function L(t, r, e) {
   if (e !== void 0) {
     if (e === null) {
-      r.append(t, "");
+      t.append(r, "");
       return;
     }
     if (Array.isArray(e)) {
-      for (const s of e) T(r, t, s);
+      for (const s of e) L(t, r, s);
       return;
     }
     if (typeof e == "object") {
-      r.append(t, JSON.stringify(e));
+      t.append(r, JSON.stringify(e));
       return;
     }
-    r.append(t, String(e));
+    t.append(r, String(e));
   }
 }
-function G(r, t) {
-  const e = A();
+function ne(t, r) {
+  const e = P();
   try {
-    return new e(r);
+    return new e(t);
   } catch (s) {
-    if (t == null)
-      throw new TypeError(`Relative REST URL requires baseUrl: ${r}`, { cause: s });
-    return new e(r, t);
+    if (r == null)
+      throw new TypeError(`Relative REST URL requires baseUrl: ${t}`, { cause: s });
+    return new e(t, r);
   }
 }
-function A() {
-  const r = Reflect.get(globalThis, "URL");
-  if (typeof r != "function")
+function P() {
+  const t = Reflect.get(globalThis, "URL");
+  if (typeof t != "function")
     throw new Error("RestQueryHandler requires URL in this runtime");
-  return r;
+  return t;
 }
-function N() {
-  const r = Reflect.get(globalThis, "location");
-  if (r == null || typeof r != "object" && typeof r != "function")
+function ie() {
+  const t = Reflect.get(globalThis, "location");
+  if (t == null || typeof t != "object" && typeof t != "function")
     return;
-  const t = Reflect.get(r, "href");
-  return typeof t == "string" ? t : 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 {
-  K as AsyncCommand,
-  B as AsyncCommandConcurrencyError,
-  w as BaseEmitter,
-  R as DerivedEmitter,
-  C as Emitter,
+  fe as AsyncCommand,
+  M as AsyncCommandConcurrencyError,
+  g as BaseEmitter,
+  D as DerivedEmitter,
+  le as DerivedEndpoint,
+  ae as DerivedLiveResult,
+  U as Emitter,
   b as EventBubble,
-  y as EventBus,
-  a as FetchState,
-  g as FetchStateValues,
-  X as LiveQuery,
-  Y as QueryArg,
-  $ as QueryHandler,
-  Z as RestQueryHandler,
-  q as combineFetchStates
+  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