@sylwellsoftware/glue 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,30 +1,449 @@
-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 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;
+class b {
+  constructor(t = {}) {
+    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 (t == null || typeof t != "object" || Array.isArray(t))
+      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);
+  }
+  get owner() {
+    var t;
+    return ((t = this.ownerRef) == null ? void 0 : t.deref()) ?? this.strongOwner;
+  }
+  registerChild(t) {
+    if (!(t instanceof b))
+      throw new TypeError("EventBubble children must be EventBubble instances");
+    this.children.includes(t) || this.children.push(t);
+  }
+}
+function D(r) {
+  return typeof r == "object" && r !== null || typeof r == "function";
+}
+function z(r) {
+  const t = Reflect.get(r, "constructor");
+  if (t == null || typeof t != "object" && typeof t != "function")
+    return;
+  const e = Reflect.get(t, "name");
+  return typeof e == "string" ? e : void 0;
+}
+const m = /* @__PURE__ */ new Set();
+function v(r) {
+  if (typeof r != "function")
+    throw new TypeError("EventBus.subscribe requires a function");
+  m.add(r);
+  let t = !0;
+  return () => {
+    t && (t = !1, m.delete(r));
+  };
+}
+function S(r) {
+  for (const t of [...m]) t(r);
+}
+const y = Object.freeze({
+  subscribe: v,
+  emit: S,
+  emitBubble: S,
+  registerBubbleGraph(r) {
+    if (r == null || typeof r.addBubble != "function")
+      throw new TypeError("registerBubbleGraph requires an addBubble() method");
+    return v((t) => r.addBubble(t));
+  },
+  get hasSubscribers() {
+    return m.size > 0;
+  },
+  get subscriberCount() {
+    return m.size;
+  }
+}), a = 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]
+]);
+function q(r) {
+  let t = a.Ready;
+  for (const e of r) {
+    if (!g.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;
+  }
+  return t;
+}
+class w {
+  constructor(t, 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 = 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")
+      throw new TypeError("Emitter equals option must be a function");
+    E(this.fetchState);
+  }
+  subscribe(t, e = {}) {
+    if (this.isDisposed) throw new Error("Cannot subscribe to a disposed emitter");
+    if (typeof t != "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) {
+      const u = this.createEvent("subscribed", i, this.value);
+      t(this.notification(u));
+    }
+    let o = !0;
+    return () => {
+      o && (o = !1, this.subscribers.delete(t));
+    };
+  }
+  subscribeFutureValues(t) {
+    return this.subscribe(t, { 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(t, e = {}) {
+    if (typeof t != "function") throw new TypeError("map requires a function");
+    return new R(
+      [this],
+      ([s]) => t(s),
+      {
+        ...e,
+        owner: e.owner ?? this.owner,
+        purpose: e.purpose ?? `${this.purpose}:map`,
+        trace: e.trace ?? this.trace
+      }
+    );
+  }
+  mapEach(t, e = {}) {
+    if (typeof t != "function") throw new TypeError("mapEach requires a function");
+    return new R([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));
+    }, {
+      ...e,
+      purpose: e.purpose ?? `${this.purpose}:mapEach`
+    });
+  }
+  dispose() {
+    this.isDisposed || (this.isDisposed = !0, this.subscribers.clear());
+  }
+  notification(t = null) {
+    return Object.freeze({
+      value: this.value,
+      fetchState: this.fetchState,
+      error: this.error,
+      event: t
+    });
+  }
+  notify(t = null) {
+    if (this.isDisposed) return;
+    const e = this.notification(t);
+    for (const s of [...this.subscribers]) s(e);
+  }
+  setSnapshot(t = {}) {
+    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;
+    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;
+    const i = new b({
+      owner: this.owner ?? this,
+      purpose: this.purpose,
+      value: s,
+      cause: t,
+      parent: e
+    });
+    return e || y.emit(i), i;
+  }
+}
+class R extends w {
+  constructor(e, s, i = {}) {
+    const { computeFetchState: o = q, ...u } = i;
+    super(void 0, {
+      ...u,
+      fetchState: a.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) => !Q(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, j) => ({ sourceIndex: j, error: d.getError() })).filter((d) => d.error != null);
+    let h, c = null;
+    try {
+      h = this.compute(i);
+    } catch (d) {
+      c = d, h = 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;
+      return;
+    }
+    this.setSnapshot({
+      value: h,
+      fetchState: f,
+      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) => {
+    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)));
+}
+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 E(r) {
+  q([r]);
+}
+class C extends w {
+  constructor(t, e = {}) {
+    super(t, e);
+  }
+  setWithState(t, e = a.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 });
+  }
+  set(t, e = null) {
+    return this.setWithState(t, a.Ready, null, e);
+  }
+}
+class B extends Error {
+  constructor() {
+    super("AsyncCommand is already running"), this.name = "AsyncCommandConcurrencyError";
+  }
+}
+class K extends w {
+  constructor(e) {
+    O(e);
+    const {
+      execute: s,
+      concurrency: i = "ignore",
+      mapError: o = (l) => l,
+      owner: u,
+      purpose: h = "async command",
+      trace: c
+    } = e;
+    if (F(i), typeof o != "function")
+      throw new TypeError("AsyncCommand mapError must be a function");
+    super(void 0, {
+      fetchState: a.Initial,
+      error: null,
+      owner: u,
+      purpose: h,
+      ...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 C(!1, {
+      owner: u ?? this,
+      purpose: `${h}: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 B());
+      (p = this.abortController) == null || p.abort();
+    }
+    const i = ++this.requestId, o = k();
+    this.abortController = o;
+    const u = s instanceof b ? s : null, h = u ? "parent command requested" : s;
+    this.setSnapshot({
+      value: this.lastSuccessfulValue,
+      fetchState: a.Loading,
+      error: null,
+      cause: h,
+      parentEvent: u
+    });
+    const c = this.createEvent("command execute", u, e);
+    this.runningEmitter.set(!0, c ?? h);
+    const l = Promise.resolve().then(() => this.execute(e, {
+      signal: o.signal,
+      event: c
+    })).then((f) => {
+      if (this.isCurrentRequest(i, o))
+        return this.lastSuccessfulValue = f, this.hasSuccessfulValue = !0, this.setSnapshot({
+          value: f,
+          fetchState: a.Ready,
+          error: null,
+          cause: "command succeeded",
+          parentEvent: c
+        }), f;
+    }).catch((f) => {
+      this.isCurrentRequest(i, o) && this.setSnapshot({
+        value: this.lastSuccessfulValue,
+        fetchState: a.Error,
+        error: this.mapCommandError(f),
+        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;
+  }
+  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,
+      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: a.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 O(r) {
+  if (r == null || typeof r != "object" || Array.isArray(r))
+    throw new TypeError("AsyncCommand options must be an object");
+  if (typeof r.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 k() {
+  const r = Reflect.get(globalThis, "AbortController");
+  if (typeof r != "function")
+    throw new Error("AsyncCommand requires AbortController in this runtime");
+  return new r();
+}
+class X extends w {
   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,
+      keepPreviousValue: u = !0,
+      owner: h,
       purpose: c = "live query",
-      trace: u
+      trace: l
     } = 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);
+    P(i);
     super(void 0, {
-      fetchState: p.Initial,
+      fetchState: a.Initial,
       error: null,
-      owner: l,
+      owner: h,
       purpose: c,
-      ...u === void 0 ? {} : { trace: u }
+      ...l === void 0 ? {} : { trace: l }
     });
     n(this, "handler");
     n(this, "args");
@@ -35,56 +454,56 @@ class H extends w {
     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.lastSuccessfulValue = void 0, this.argumentUnsubscribers = Object.values(this.args).map(
+      (p) => p.subscribe(({ event: f }) => {
+        this.refresh(f);
       }, { emitCurrent: !1 })
     ), o && (this._activeRequest = this.refresh("initial fetch"));
   }
   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 = _();
     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, h = this.keepPreviousValue ? this.lastSuccessfulValue : void 0;
     this.setSnapshot({
-      value: l,
-      fetchState: p.Loading,
+      value: h,
+      fetchState: a.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), l = 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((f) => {
+      if (this.isCurrentRequest(s, i))
+        return this.lastSuccessfulValue = f, this.setSnapshot({
+          value: f,
+          fetchState: a.Ready,
           error: null,
           cause: "query succeeded",
           parentEvent: c
-        }), a;
-    }).catch((a) => {
-      !this.isCurrentRequest(r, i) || S(a) || this.setSnapshot({
+        }), f;
+    }).catch((f) => {
+      !this.isCurrentRequest(s, i) || H(f) || this.setSnapshot({
         value: this.keepPreviousValue ? this.lastSuccessfulValue : void 0,
-        fetchState: p.Error,
-        error: a,
+        fetchState: a.Error,
+        error: f,
         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 = l, l;
   }
   retry(e = "retry") {
     return this.refresh(e);
@@ -93,45 +512,45 @@ class H extends w {
     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();
+      for (const s of this.argumentUnsubscribers) s();
       this.argumentUnsubscribers = [], super.dispose();
     }
   }
-  isCurrentRequest(e, r) {
-    return !this.isDisposed && e === this.requestId && r === this.abortController && !r.signal.aborted;
+  isCurrentRequest(e, s) {
+    return !this.isDisposed && e === this.requestId && s === this.abortController && !s.signal.aborted;
   }
 }
-function R(t) {
-  if (t == null || typeof t != "object" || Array.isArray(t))
+function P(r) {
+  if (r == null || typeof r != "object" || Array.isArray(r))
     throw new TypeError("LiveQuery args must be a named record of emitters");
-  for (const [s, e] of Object.entries(t))
+  for (const [t, e] of Object.entries(r))
     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 ${t} must be an emitter`);
 }
-function q() {
-  const t = Reflect.get(globalThis, "AbortController");
-  if (typeof t != "function")
+function _() {
+  const r = Reflect.get(globalThis, "AbortController");
+  if (typeof r != "function")
     throw new Error("LiveQuery requires AbortController in this runtime");
-  return new t();
+  return new r();
 }
-function S(t) {
-  return t instanceof Error && t.name === "AbortError";
+function H(r) {
+  return r instanceof Error && r.name === "AbortError";
 }
-class z extends E {
-  constructor(e, r, i = {}) {
+class Y extends C {
+  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,19 +564,19 @@ class z extends E {
     this.isDisposed || ((e = this.sourceUnsubscribe) == null || e.call(this), this.sourceUnsubscribe = null, super.dispose());
   }
 }
-class T {
-  fetch(s, e = {}) {
+class $ {
+  fetch(t, e = {}) {
     throw new Error("fetch() must be implemented");
   }
 }
-class U extends Error {
+class x extends Error {
   constructor(e) {
     super(`HTTP ${e ?? "unknown"}`);
     n(this, "status");
     this.name = "HttpError", this.status = e;
   }
 }
-class I extends T {
+class Z extends $ {
   constructor(e) {
     super();
     n(this, "url");
@@ -165,98 +584,100 @@ class I extends T {
     n(this, "fetchImplementation");
     n(this, "serialize");
     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 ?? N(), this.fetchImplementation = s.fetch ?? J(), this.serialize = s.serialize ?? W, 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");
   }
-  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 = G(this.url, this.baseUrl), o = this.serialize(i, e) ?? i, u = A();
+    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 h = s.event ?? null;
+    if (this.trace || h || y.hasSubscribers) {
+      const p = new b({
         owner: this,
         purpose: "REST fetch",
         value: o.toString(),
         cause: "fetch called",
-        parent: l
+        parent: h
       });
-      l || b.emit(h);
+      h || y.emit(p);
     }
-    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 }, 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();
   }
 }
-function A(t, s) {
-  for (const [e, r] of Object.entries(s))
-    m(t.searchParams, e, r);
-  return t;
+function W(r, t) {
+  for (const [e, s] of Object.entries(t))
+    T(r.searchParams, e, s);
+  return r;
 }
-function m(t, s, e) {
+function T(r, t, e) {
   if (e !== void 0) {
     if (e === null) {
-      t.append(s, "");
+      r.append(t, "");
       return;
     }
     if (Array.isArray(e)) {
-      for (const r of e) m(t, s, r);
+      for (const s of e) T(r, t, s);
       return;
     }
     if (typeof e == "object") {
-      t.append(s, JSON.stringify(e));
+      r.append(t, JSON.stringify(e));
       return;
     }
-    t.append(s, String(e));
+    r.append(t, String(e));
   }
 }
-function Q(t, s) {
-  const e = d();
+function G(r, t) {
+  const e = A();
   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);
+    return new e(r);
+  } catch (s) {
+    if (t == null)
+      throw new TypeError(`Relative REST URL requires baseUrl: ${r}`, { cause: s });
+    return new e(r, t);
   }
 }
-function d() {
-  const t = Reflect.get(globalThis, "URL");
-  if (typeof t != "function")
+function A() {
+  const r = Reflect.get(globalThis, "URL");
+  if (typeof r != "function")
     throw new Error("RestQueryHandler requires URL in this runtime");
-  return t;
+  return r;
 }
-function V() {
-  const t = Reflect.get(globalThis, "location");
-  if (t == null || typeof t != "object" && typeof t != "function")
+function N() {
+  const r = Reflect.get(globalThis, "location");
+  if (r == null || typeof r != "object" && typeof r != "function")
     return;
-  const s = Reflect.get(t, "href");
-  return typeof s == "string" ? s : void 0;
+  const t = Reflect.get(r, "href");
+  return typeof t == "string" ? t : void 0;
 }
-function j() {
+function J() {
   return Reflect.get(globalThis, "fetch");
 }
 export {
+  K as AsyncCommand,
+  B as AsyncCommandConcurrencyError,
   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
+  R as DerivedEmitter,
+  C 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
 };
 //# sourceMappingURL=index.js.map