@semiont/make-meaning 0.2.34 → 0.2.35-build.100

package/dist/index.js

@@ -222,9 +222,9 @@ Example output:
 // src/jobs/reference-annotation-worker.ts
 import { FilesystemRepresentationStore } from "@semiont/content";
 var ReferenceAnnotationWorker = class extends JobWorker {
-  constructor(jobQueue, config, eventStore, inferenceClient, eventBus, logger) {
+  constructor(jobQueue, config2, eventStore, inferenceClient, eventBus, logger) {
     super(jobQueue, void 0, void 0, logger);
-    this.config = config;
+    this.config = config2;
     this.eventStore = eventStore;
     this.inferenceClient = inferenceClient;
     this.eventBus = eventBus;
@@ -686,9 +686,9 @@ function generateUuid() {
 
 // src/jobs/generation-worker.ts
 var GenerationWorker = class extends JobWorker2 {
-  constructor(jobQueue, config, eventStore, inferenceClient, eventBus, logger) {
+  constructor(jobQueue, config2, eventStore, inferenceClient, eventBus, logger) {
     super(jobQueue, void 0, void 0, logger);
-    this.config = config;
+    this.config = config2;
     this.eventStore = eventStore;
     this.inferenceClient = inferenceClient;
     this.eventBus = eventBus;
@@ -981,9 +981,9 @@ import { generateAnnotationId as generateAnnotationId2 } from "@semiont/event-so
 import { resourceIdToURI as resourceIdToURI2 } from "@semiont/core";
 import { userId } from "@semiont/core";
 var HighlightAnnotationWorker = class extends JobWorker3 {
-  constructor(jobQueue, config, eventStore, inferenceClient, eventBus, logger) {
+  constructor(jobQueue, config2, eventStore, inferenceClient, eventBus, logger) {
     super(jobQueue, void 0, void 0, logger);
-    this.config = config;
+    this.config = config2;
     this.eventStore = eventStore;
     this.inferenceClient = inferenceClient;
     this.eventBus = eventBus;
@@ -1198,9 +1198,9 @@ import { generateAnnotationId as generateAnnotationId3 } from "@semiont/event-so
 import { resourceIdToURI as resourceIdToURI3 } from "@semiont/core";
 import { userId as userId2 } from "@semiont/core";
 var AssessmentAnnotationWorker = class extends JobWorker4 {
-  constructor(jobQueue, config, eventStore, inferenceClient, eventBus, logger) {
+  constructor(jobQueue, config2, eventStore, inferenceClient, eventBus, logger) {
     super(jobQueue, void 0, void 0, logger);
-    this.config = config;
+    this.config = config2;
     this.eventStore = eventStore;
     this.inferenceClient = inferenceClient;
     this.eventBus = eventBus;
@@ -1419,9 +1419,9 @@ import { generateAnnotationId as generateAnnotationId4 } from "@semiont/event-so
 import { resourceIdToURI as resourceIdToURI4 } from "@semiont/core";
 import { userId as userId3 } from "@semiont/core";
 var CommentAnnotationWorker = class extends JobWorker5 {
-  constructor(jobQueue, config, eventStore, inferenceClient, eventBus, logger) {
+  constructor(jobQueue, config2, eventStore, inferenceClient, eventBus, logger) {
     super(jobQueue, void 0, void 0, logger);
-    this.config = config;
+    this.config = config2;
     this.eventStore = eventStore;
     this.inferenceClient = inferenceClient;
     this.eventBus = eventBus;
@@ -1651,9 +1651,9 @@ import { resourceIdToURI as resourceIdToURI5 } from "@semiont/core";
 import { getTagSchema } from "@semiont/ontology";
 import { userId as userId4 } from "@semiont/core";
 var TagAnnotationWorker = class extends JobWorker6 {
-  constructor(jobQueue, config, eventStore, inferenceClient, eventBus, logger) {
+  constructor(jobQueue, config2, eventStore, inferenceClient, eventBus, logger) {
     super(jobQueue, void 0, void 0, logger);
-    this.config = config;
+    this.config = config2;
     this.eventStore = eventStore;
     this.inferenceClient = inferenceClient;
     this.eventBus = eventBus;
@@ -1915,21 +1915,1448 @@ var TagAnnotationWorker = class extends JobWorker6 {
   }
 };
 
+// ../../node_modules/rxjs/node_modules/tslib/tslib.es6.js
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+// ../../node_modules/rxjs/_esm5/internal/util/isFunction.js
+function isFunction(x) {
+  return typeof x === "function";
+}
+
+// ../../node_modules/rxjs/_esm5/internal/config.js
+var _enable_super_gross_mode_that_will_cause_bad_things = false;
+var config = {
+  Promise: void 0,
+  set useDeprecatedSynchronousErrorHandling(value) {
+    if (value) {
+      var error = /* @__PURE__ */ new Error();
+      /* @__PURE__ */ console.warn("DEPRECATED! RxJS was set to use deprecated synchronous error handling behavior by code at: \n" + error.stack);
+    } else if (_enable_super_gross_mode_that_will_cause_bad_things) {
+      /* @__PURE__ */ console.log("RxJS: Back to a better error behavior. Thank you. <3");
+    }
+    _enable_super_gross_mode_that_will_cause_bad_things = value;
+  },
+  get useDeprecatedSynchronousErrorHandling() {
+    return _enable_super_gross_mode_that_will_cause_bad_things;
+  }
+};
+
+// ../../node_modules/rxjs/_esm5/internal/util/hostReportError.js
+function hostReportError(err) {
+  setTimeout(function() {
+    throw err;
+  }, 0);
+}
+
+// ../../node_modules/rxjs/_esm5/internal/Observer.js
+var empty = {
+  closed: true,
+  next: function(value) {
+  },
+  error: function(err) {
+    if (config.useDeprecatedSynchronousErrorHandling) {
+      throw err;
+    } else {
+      hostReportError(err);
+    }
+  },
+  complete: function() {
+  }
+};
+
+// ../../node_modules/rxjs/_esm5/internal/util/isArray.js
+var isArray = /* @__PURE__ */ (function() {
+  return Array.isArray || (function(x) {
+    return x && typeof x.length === "number";
+  });
+})();
+
+// ../../node_modules/rxjs/_esm5/internal/util/isObject.js
+function isObject(x) {
+  return x !== null && typeof x === "object";
+}
+
+// ../../node_modules/rxjs/_esm5/internal/util/UnsubscriptionError.js
+var UnsubscriptionErrorImpl = /* @__PURE__ */ (function() {
+  function UnsubscriptionErrorImpl2(errors) {
+    Error.call(this);
+    this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+      return i + 1 + ") " + err.toString();
+    }).join("\n  ") : "";
+    this.name = "UnsubscriptionError";
+    this.errors = errors;
+    return this;
+  }
+  UnsubscriptionErrorImpl2.prototype = /* @__PURE__ */ Object.create(Error.prototype);
+  return UnsubscriptionErrorImpl2;
+})();
+var UnsubscriptionError = UnsubscriptionErrorImpl;
+
+// ../../node_modules/rxjs/_esm5/internal/Subscription.js
+var Subscription = /* @__PURE__ */ (function() {
+  function Subscription3(unsubscribe) {
+    this.closed = false;
+    this._parentOrParents = null;
+    this._subscriptions = null;
+    if (unsubscribe) {
+      this._ctorUnsubscribe = true;
+      this._unsubscribe = unsubscribe;
+    }
+  }
+  Subscription3.prototype.unsubscribe = function() {
+    var errors;
+    if (this.closed) {
+      return;
+    }
+    var _a = this, _parentOrParents = _a._parentOrParents, _ctorUnsubscribe = _a._ctorUnsubscribe, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions;
+    this.closed = true;
+    this._parentOrParents = null;
+    this._subscriptions = null;
+    if (_parentOrParents instanceof Subscription3) {
+      _parentOrParents.remove(this);
+    } else if (_parentOrParents !== null) {
+      for (var index = 0; index < _parentOrParents.length; ++index) {
+        var parent_1 = _parentOrParents[index];
+        parent_1.remove(this);
+      }
+    }
+    if (isFunction(_unsubscribe)) {
+      if (_ctorUnsubscribe) {
+        this._unsubscribe = void 0;
+      }
+      try {
+        _unsubscribe.call(this);
+      } catch (e) {
+        errors = e instanceof UnsubscriptionError ? flattenUnsubscriptionErrors(e.errors) : [e];
+      }
+    }
+    if (isArray(_subscriptions)) {
+      var index = -1;
+      var len = _subscriptions.length;
+      while (++index < len) {
+        var sub = _subscriptions[index];
+        if (isObject(sub)) {
+          try {
+            sub.unsubscribe();
+          } catch (e) {
+            errors = errors || [];
+            if (e instanceof UnsubscriptionError) {
+              errors = errors.concat(flattenUnsubscriptionErrors(e.errors));
+            } else {
+              errors.push(e);
+            }
+          }
+        }
+      }
+    }
+    if (errors) {
+      throw new UnsubscriptionError(errors);
+    }
+  };
+  Subscription3.prototype.add = function(teardown) {
+    var subscription = teardown;
+    if (!teardown) {
+      return Subscription3.EMPTY;
+    }
+    switch (typeof teardown) {
+      case "function":
+        subscription = new Subscription3(teardown);
+      case "object":
+        if (subscription === this || subscription.closed || typeof subscription.unsubscribe !== "function") {
+          return subscription;
+        } else if (this.closed) {
+          subscription.unsubscribe();
+          return subscription;
+        } else if (!(subscription instanceof Subscription3)) {
+          var tmp = subscription;
+          subscription = new Subscription3();
+          subscription._subscriptions = [tmp];
+        }
+        break;
+      default: {
+        throw new Error("unrecognized teardown " + teardown + " added to Subscription.");
+      }
+    }
+    var _parentOrParents = subscription._parentOrParents;
+    if (_parentOrParents === null) {
+      subscription._parentOrParents = this;
+    } else if (_parentOrParents instanceof Subscription3) {
+      if (_parentOrParents === this) {
+        return subscription;
+      }
+      subscription._parentOrParents = [_parentOrParents, this];
+    } else if (_parentOrParents.indexOf(this) === -1) {
+      _parentOrParents.push(this);
+    } else {
+      return subscription;
+    }
+    var subscriptions = this._subscriptions;
+    if (subscriptions === null) {
+      this._subscriptions = [subscription];
+    } else {
+      subscriptions.push(subscription);
+    }
+    return subscription;
+  };
+  Subscription3.prototype.remove = function(subscription) {
+    var subscriptions = this._subscriptions;
+    if (subscriptions) {
+      var subscriptionIndex = subscriptions.indexOf(subscription);
+      if (subscriptionIndex !== -1) {
+        subscriptions.splice(subscriptionIndex, 1);
+      }
+    }
+  };
+  Subscription3.EMPTY = (function(empty2) {
+    empty2.closed = true;
+    return empty2;
+  })(new Subscription3());
+  return Subscription3;
+})();
+function flattenUnsubscriptionErrors(errors) {
+  return errors.reduce(function(errs, err) {
+    return errs.concat(err instanceof UnsubscriptionError ? err.errors : err);
+  }, []);
+}
+
+// ../../node_modules/rxjs/_esm5/internal/symbol/rxSubscriber.js
+var rxSubscriber = /* @__PURE__ */ (function() {
+  return typeof Symbol === "function" ? /* @__PURE__ */ Symbol("rxSubscriber") : "@@rxSubscriber_" + /* @__PURE__ */ Math.random();
+})();
+
+// ../../node_modules/rxjs/_esm5/internal/Subscriber.js
+var Subscriber = /* @__PURE__ */ (function(_super) {
+  __extends(Subscriber2, _super);
+  function Subscriber2(destinationOrNext, error, complete) {
+    var _this = _super.call(this) || this;
+    _this.syncErrorValue = null;
+    _this.syncErrorThrown = false;
+    _this.syncErrorThrowable = false;
+    _this.isStopped = false;
+    switch (arguments.length) {
+      case 0:
+        _this.destination = empty;
+        break;
+      case 1:
+        if (!destinationOrNext) {
+          _this.destination = empty;
+          break;
+        }
+        if (typeof destinationOrNext === "object") {
+          if (destinationOrNext instanceof Subscriber2) {
+            _this.syncErrorThrowable = destinationOrNext.syncErrorThrowable;
+            _this.destination = destinationOrNext;
+            destinationOrNext.add(_this);
+          } else {
+            _this.syncErrorThrowable = true;
+            _this.destination = new SafeSubscriber(_this, destinationOrNext);
+          }
+          break;
+        }
+      default:
+        _this.syncErrorThrowable = true;
+        _this.destination = new SafeSubscriber(_this, destinationOrNext, error, complete);
+        break;
+    }
+    return _this;
+  }
+  Subscriber2.prototype[rxSubscriber] = function() {
+    return this;
+  };
+  Subscriber2.create = function(next, error, complete) {
+    var subscriber = new Subscriber2(next, error, complete);
+    subscriber.syncErrorThrowable = false;
+    return subscriber;
+  };
+  Subscriber2.prototype.next = function(value) {
+    if (!this.isStopped) {
+      this._next(value);
+    }
+  };
+  Subscriber2.prototype.error = function(err) {
+    if (!this.isStopped) {
+      this.isStopped = true;
+      this._error(err);
+    }
+  };
+  Subscriber2.prototype.complete = function() {
+    if (!this.isStopped) {
+      this.isStopped = true;
+      this._complete();
+    }
+  };
+  Subscriber2.prototype.unsubscribe = function() {
+    if (this.closed) {
+      return;
+    }
+    this.isStopped = true;
+    _super.prototype.unsubscribe.call(this);
+  };
+  Subscriber2.prototype._next = function(value) {
+    this.destination.next(value);
+  };
+  Subscriber2.prototype._error = function(err) {
+    this.destination.error(err);
+    this.unsubscribe();
+  };
+  Subscriber2.prototype._complete = function() {
+    this.destination.complete();
+    this.unsubscribe();
+  };
+  Subscriber2.prototype._unsubscribeAndRecycle = function() {
+    var _parentOrParents = this._parentOrParents;
+    this._parentOrParents = null;
+    this.unsubscribe();
+    this.closed = false;
+    this.isStopped = false;
+    this._parentOrParents = _parentOrParents;
+    return this;
+  };
+  return Subscriber2;
+})(Subscription);
+var SafeSubscriber = /* @__PURE__ */ (function(_super) {
+  __extends(SafeSubscriber2, _super);
+  function SafeSubscriber2(_parentSubscriber, observerOrNext, error, complete) {
+    var _this = _super.call(this) || this;
+    _this._parentSubscriber = _parentSubscriber;
+    var next;
+    var context = _this;
+    if (isFunction(observerOrNext)) {
+      next = observerOrNext;
+    } else if (observerOrNext) {
+      next = observerOrNext.next;
+      error = observerOrNext.error;
+      complete = observerOrNext.complete;
+      if (observerOrNext !== empty) {
+        context = Object.create(observerOrNext);
+        if (isFunction(context.unsubscribe)) {
+          _this.add(context.unsubscribe.bind(context));
+        }
+        context.unsubscribe = _this.unsubscribe.bind(_this);
+      }
+    }
+    _this._context = context;
+    _this._next = next;
+    _this._error = error;
+    _this._complete = complete;
+    return _this;
+  }
+  SafeSubscriber2.prototype.next = function(value) {
+    if (!this.isStopped && this._next) {
+      var _parentSubscriber = this._parentSubscriber;
+      if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
+        this.__tryOrUnsub(this._next, value);
+      } else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {
+        this.unsubscribe();
+      }
+    }
+  };
+  SafeSubscriber2.prototype.error = function(err) {
+    if (!this.isStopped) {
+      var _parentSubscriber = this._parentSubscriber;
+      var useDeprecatedSynchronousErrorHandling = config.useDeprecatedSynchronousErrorHandling;
+      if (this._error) {
+        if (!useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
+          this.__tryOrUnsub(this._error, err);
+          this.unsubscribe();
+        } else {
+          this.__tryOrSetError(_parentSubscriber, this._error, err);
+          this.unsubscribe();
+        }
+      } else if (!_parentSubscriber.syncErrorThrowable) {
+        this.unsubscribe();
+        if (useDeprecatedSynchronousErrorHandling) {
+          throw err;
+        }
+        hostReportError(err);
+      } else {
+        if (useDeprecatedSynchronousErrorHandling) {
+          _parentSubscriber.syncErrorValue = err;
+          _parentSubscriber.syncErrorThrown = true;
+        } else {
+          hostReportError(err);
+        }
+        this.unsubscribe();
+      }
+    }
+  };
+  SafeSubscriber2.prototype.complete = function() {
+    var _this = this;
+    if (!this.isStopped) {
+      var _parentSubscriber = this._parentSubscriber;
+      if (this._complete) {
+        var wrappedComplete = function() {
+          return _this._complete.call(_this._context);
+        };
+        if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
+          this.__tryOrUnsub(wrappedComplete);
+          this.unsubscribe();
+        } else {
+          this.__tryOrSetError(_parentSubscriber, wrappedComplete);
+          this.unsubscribe();
+        }
+      } else {
+        this.unsubscribe();
+      }
+    }
+  };
+  SafeSubscriber2.prototype.__tryOrUnsub = function(fn, value) {
+    try {
+      fn.call(this._context, value);
+    } catch (err) {
+      this.unsubscribe();
+      if (config.useDeprecatedSynchronousErrorHandling) {
+        throw err;
+      } else {
+        hostReportError(err);
+      }
+    }
+  };
+  SafeSubscriber2.prototype.__tryOrSetError = function(parent, fn, value) {
+    if (!config.useDeprecatedSynchronousErrorHandling) {
+      throw new Error("bad call");
+    }
+    try {
+      fn.call(this._context, value);
+    } catch (err) {
+      if (config.useDeprecatedSynchronousErrorHandling) {
+        parent.syncErrorValue = err;
+        parent.syncErrorThrown = true;
+        return true;
+      } else {
+        hostReportError(err);
+        return true;
+      }
+    }
+    return false;
+  };
+  SafeSubscriber2.prototype._unsubscribe = function() {
+    var _parentSubscriber = this._parentSubscriber;
+    this._context = null;
+    this._parentSubscriber = null;
+    _parentSubscriber.unsubscribe();
+  };
+  return SafeSubscriber2;
+})(Subscriber);
+
+// ../../node_modules/rxjs/_esm5/internal/util/canReportError.js
+function canReportError(observer) {
+  while (observer) {
+    var _a = observer, closed_1 = _a.closed, destination = _a.destination, isStopped = _a.isStopped;
+    if (closed_1 || isStopped) {
+      return false;
+    } else if (destination && destination instanceof Subscriber) {
+      observer = destination;
+    } else {
+      observer = null;
+    }
+  }
+  return true;
+}
+
+// ../../node_modules/rxjs/_esm5/internal/util/toSubscriber.js
+function toSubscriber(nextOrObserver, error, complete) {
+  if (nextOrObserver) {
+    if (nextOrObserver instanceof Subscriber) {
+      return nextOrObserver;
+    }
+    if (nextOrObserver[rxSubscriber]) {
+      return nextOrObserver[rxSubscriber]();
+    }
+  }
+  if (!nextOrObserver && !error && !complete) {
+    return new Subscriber(empty);
+  }
+  return new Subscriber(nextOrObserver, error, complete);
+}
+
+// ../../node_modules/rxjs/_esm5/internal/symbol/observable.js
+var observable = /* @__PURE__ */ (function() {
+  return typeof Symbol === "function" && Symbol.observable || "@@observable";
+})();
+
+// ../../node_modules/rxjs/_esm5/internal/util/identity.js
+function identity(x) {
+  return x;
+}
+
+// ../../node_modules/rxjs/_esm5/internal/util/pipe.js
+function pipeFromArray(fns) {
+  if (fns.length === 0) {
+    return identity;
+  }
+  if (fns.length === 1) {
+    return fns[0];
+  }
+  return function piped(input) {
+    return fns.reduce(function(prev, fn) {
+      return fn(prev);
+    }, input);
+  };
+}
+
+// ../../node_modules/rxjs/_esm5/internal/Observable.js
+var Observable = /* @__PURE__ */ (function() {
+  function Observable2(subscribe) {
+    this._isScalar = false;
+    if (subscribe) {
+      this._subscribe = subscribe;
+    }
+  }
+  Observable2.prototype.lift = function(operator) {
+    var observable2 = new Observable2();
+    observable2.source = this;
+    observable2.operator = operator;
+    return observable2;
+  };
+  Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
+    var operator = this.operator;
+    var sink = toSubscriber(observerOrNext, error, complete);
+    if (operator) {
+      sink.add(operator.call(sink, this.source));
+    } else {
+      sink.add(this.source || config.useDeprecatedSynchronousErrorHandling && !sink.syncErrorThrowable ? this._subscribe(sink) : this._trySubscribe(sink));
+    }
+    if (config.useDeprecatedSynchronousErrorHandling) {
+      if (sink.syncErrorThrowable) {
+        sink.syncErrorThrowable = false;
+        if (sink.syncErrorThrown) {
+          throw sink.syncErrorValue;
+        }
+      }
+    }
+    return sink;
+  };
+  Observable2.prototype._trySubscribe = function(sink) {
+    try {
+      return this._subscribe(sink);
+    } catch (err) {
+      if (config.useDeprecatedSynchronousErrorHandling) {
+        sink.syncErrorThrown = true;
+        sink.syncErrorValue = err;
+      }
+      if (canReportError(sink)) {
+        sink.error(err);
+      } else {
+        console.warn(err);
+      }
+    }
+  };
+  Observable2.prototype.forEach = function(next, promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve4, reject) {
+      var subscription;
+      subscription = _this.subscribe(function(value) {
+        try {
+          next(value);
+        } catch (err) {
+          reject(err);
+          if (subscription) {
+            subscription.unsubscribe();
+          }
+        }
+      }, reject, resolve4);
+    });
+  };
+  Observable2.prototype._subscribe = function(subscriber) {
+    var source = this.source;
+    return source && source.subscribe(subscriber);
+  };
+  Observable2.prototype[observable] = function() {
+    return this;
+  };
+  Observable2.prototype.pipe = function() {
+    var operations = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      operations[_i] = arguments[_i];
+    }
+    if (operations.length === 0) {
+      return this;
+    }
+    return pipeFromArray(operations)(this);
+  };
+  Observable2.prototype.toPromise = function(promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve4, reject) {
+      var value;
+      _this.subscribe(function(x) {
+        return value = x;
+      }, function(err) {
+        return reject(err);
+      }, function() {
+        return resolve4(value);
+      });
+    });
+  };
+  Observable2.create = function(subscribe) {
+    return new Observable2(subscribe);
+  };
+  return Observable2;
+})();
+function getPromiseCtor(promiseCtor) {
+  if (!promiseCtor) {
+    promiseCtor = config.Promise || Promise;
+  }
+  if (!promiseCtor) {
+    throw new Error("no Promise impl found");
+  }
+  return promiseCtor;
+}
+
+// ../../node_modules/rxjs/_esm5/internal/util/ObjectUnsubscribedError.js
+var ObjectUnsubscribedErrorImpl = /* @__PURE__ */ (function() {
+  function ObjectUnsubscribedErrorImpl2() {
+    Error.call(this);
+    this.message = "object unsubscribed";
+    this.name = "ObjectUnsubscribedError";
+    return this;
+  }
+  ObjectUnsubscribedErrorImpl2.prototype = /* @__PURE__ */ Object.create(Error.prototype);
+  return ObjectUnsubscribedErrorImpl2;
+})();
+var ObjectUnsubscribedError = ObjectUnsubscribedErrorImpl;
+
+// ../../node_modules/rxjs/_esm5/internal/SubjectSubscription.js
+var SubjectSubscription = /* @__PURE__ */ (function(_super) {
+  __extends(SubjectSubscription2, _super);
+  function SubjectSubscription2(subject, subscriber) {
+    var _this = _super.call(this) || this;
+    _this.subject = subject;
+    _this.subscriber = subscriber;
+    _this.closed = false;
+    return _this;
+  }
+  SubjectSubscription2.prototype.unsubscribe = function() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    var subject = this.subject;
+    var observers = subject.observers;
+    this.subject = null;
+    if (!observers || observers.length === 0 || subject.isStopped || subject.closed) {
+      return;
+    }
+    var subscriberIndex = observers.indexOf(this.subscriber);
+    if (subscriberIndex !== -1) {
+      observers.splice(subscriberIndex, 1);
+    }
+  };
+  return SubjectSubscription2;
+})(Subscription);
+
+// ../../node_modules/rxjs/_esm5/internal/Subject.js
+var SubjectSubscriber = /* @__PURE__ */ (function(_super) {
+  __extends(SubjectSubscriber2, _super);
+  function SubjectSubscriber2(destination) {
+    var _this = _super.call(this, destination) || this;
+    _this.destination = destination;
+    return _this;
+  }
+  return SubjectSubscriber2;
+})(Subscriber);
+var Subject = /* @__PURE__ */ (function(_super) {
+  __extends(Subject2, _super);
+  function Subject2() {
+    var _this = _super.call(this) || this;
+    _this.observers = [];
+    _this.closed = false;
+    _this.isStopped = false;
+    _this.hasError = false;
+    _this.thrownError = null;
+    return _this;
+  }
+  Subject2.prototype[rxSubscriber] = function() {
+    return new SubjectSubscriber(this);
+  };
+  Subject2.prototype.lift = function(operator) {
+    var subject = new AnonymousSubject(this, this);
+    subject.operator = operator;
+    return subject;
+  };
+  Subject2.prototype.next = function(value) {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    }
+    if (!this.isStopped) {
+      var observers = this.observers;
+      var len = observers.length;
+      var copy = observers.slice();
+      for (var i = 0; i < len; i++) {
+        copy[i].next(value);
+      }
+    }
+  };
+  Subject2.prototype.error = function(err) {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    }
+    this.hasError = true;
+    this.thrownError = err;
+    this.isStopped = true;
+    var observers = this.observers;
+    var len = observers.length;
+    var copy = observers.slice();
+    for (var i = 0; i < len; i++) {
+      copy[i].error(err);
+    }
+    this.observers.length = 0;
+  };
+  Subject2.prototype.complete = function() {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    }
+    this.isStopped = true;
+    var observers = this.observers;
+    var len = observers.length;
+    var copy = observers.slice();
+    for (var i = 0; i < len; i++) {
+      copy[i].complete();
+    }
+    this.observers.length = 0;
+  };
+  Subject2.prototype.unsubscribe = function() {
+    this.isStopped = true;
+    this.closed = true;
+    this.observers = null;
+  };
+  Subject2.prototype._trySubscribe = function(subscriber) {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    } else {
+      return _super.prototype._trySubscribe.call(this, subscriber);
+    }
+  };
+  Subject2.prototype._subscribe = function(subscriber) {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    } else if (this.hasError) {
+      subscriber.error(this.thrownError);
+      return Subscription.EMPTY;
+    } else if (this.isStopped) {
+      subscriber.complete();
+      return Subscription.EMPTY;
+    } else {
+      this.observers.push(subscriber);
+      return new SubjectSubscription(this, subscriber);
+    }
+  };
+  Subject2.prototype.asObservable = function() {
+    var observable2 = new Observable();
+    observable2.source = this;
+    return observable2;
+  };
+  Subject2.create = function(destination, source) {
+    return new AnonymousSubject(destination, source);
+  };
+  return Subject2;
+})(Observable);
+var AnonymousSubject = /* @__PURE__ */ (function(_super) {
+  __extends(AnonymousSubject2, _super);
+  function AnonymousSubject2(destination, source) {
+    var _this = _super.call(this) || this;
+    _this.destination = destination;
+    _this.source = source;
+    return _this;
+  }
+  AnonymousSubject2.prototype.next = function(value) {
+    var destination = this.destination;
+    if (destination && destination.next) {
+      destination.next(value);
+    }
+  };
+  AnonymousSubject2.prototype.error = function(err) {
+    var destination = this.destination;
+    if (destination && destination.error) {
+      this.destination.error(err);
+    }
+  };
+  AnonymousSubject2.prototype.complete = function() {
+    var destination = this.destination;
+    if (destination && destination.complete) {
+      this.destination.complete();
+    }
+  };
+  AnonymousSubject2.prototype._subscribe = function(subscriber) {
+    var source = this.source;
+    if (source) {
+      return this.source.subscribe(subscriber);
+    } else {
+      return Subscription.EMPTY;
+    }
+  };
+  return AnonymousSubject2;
+})(Subject);
+
+// ../../node_modules/rxjs/_esm5/internal/operators/groupBy.js
+function groupBy(keySelector, elementSelector, durationSelector, subjectSelector) {
+  return function(source) {
+    return source.lift(new GroupByOperator(keySelector, elementSelector, durationSelector, subjectSelector));
+  };
+}
+var GroupByOperator = /* @__PURE__ */ (function() {
+  function GroupByOperator2(keySelector, elementSelector, durationSelector, subjectSelector) {
+    this.keySelector = keySelector;
+    this.elementSelector = elementSelector;
+    this.durationSelector = durationSelector;
+    this.subjectSelector = subjectSelector;
+  }
+  GroupByOperator2.prototype.call = function(subscriber, source) {
+    return source.subscribe(new GroupBySubscriber(subscriber, this.keySelector, this.elementSelector, this.durationSelector, this.subjectSelector));
+  };
+  return GroupByOperator2;
+})();
+var GroupBySubscriber = /* @__PURE__ */ (function(_super) {
+  __extends(GroupBySubscriber2, _super);
+  function GroupBySubscriber2(destination, keySelector, elementSelector, durationSelector, subjectSelector) {
+    var _this = _super.call(this, destination) || this;
+    _this.keySelector = keySelector;
+    _this.elementSelector = elementSelector;
+    _this.durationSelector = durationSelector;
+    _this.subjectSelector = subjectSelector;
+    _this.groups = null;
+    _this.attemptedToUnsubscribe = false;
+    _this.count = 0;
+    return _this;
+  }
+  GroupBySubscriber2.prototype._next = function(value) {
+    var key;
+    try {
+      key = this.keySelector(value);
+    } catch (err) {
+      this.error(err);
+      return;
+    }
+    this._group(value, key);
+  };
+  GroupBySubscriber2.prototype._group = function(value, key) {
+    var groups = this.groups;
+    if (!groups) {
+      groups = this.groups = /* @__PURE__ */ new Map();
+    }
+    var group = groups.get(key);
+    var element;
+    if (this.elementSelector) {
+      try {
+        element = this.elementSelector(value);
+      } catch (err) {
+        this.error(err);
+      }
+    } else {
+      element = value;
+    }
+    if (!group) {
+      group = this.subjectSelector ? this.subjectSelector() : new Subject();
+      groups.set(key, group);
+      var groupedObservable = new GroupedObservable(key, group, this);
+      this.destination.next(groupedObservable);
+      if (this.durationSelector) {
+        var duration = void 0;
+        try {
+          duration = this.durationSelector(new GroupedObservable(key, group));
+        } catch (err) {
+          this.error(err);
+          return;
+        }
+        this.add(duration.subscribe(new GroupDurationSubscriber(key, group, this)));
+      }
+    }
+    if (!group.closed) {
+      group.next(element);
+    }
+  };
+  GroupBySubscriber2.prototype._error = function(err) {
+    var groups = this.groups;
+    if (groups) {
+      groups.forEach(function(group, key) {
+        group.error(err);
+      });
+      groups.clear();
+    }
+    this.destination.error(err);
+  };
+  GroupBySubscriber2.prototype._complete = function() {
+    var groups = this.groups;
+    if (groups) {
+      groups.forEach(function(group, key) {
+        group.complete();
+      });
+      groups.clear();
+    }
+    this.destination.complete();
+  };
+  GroupBySubscriber2.prototype.removeGroup = function(key) {
+    this.groups.delete(key);
+  };
+  GroupBySubscriber2.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      this.attemptedToUnsubscribe = true;
+      if (this.count === 0) {
+        _super.prototype.unsubscribe.call(this);
+      }
+    }
+  };
+  return GroupBySubscriber2;
+})(Subscriber);
+var GroupDurationSubscriber = /* @__PURE__ */ (function(_super) {
+  __extends(GroupDurationSubscriber2, _super);
+  function GroupDurationSubscriber2(key, group, parent) {
+    var _this = _super.call(this, group) || this;
+    _this.key = key;
+    _this.group = group;
+    _this.parent = parent;
+    return _this;
+  }
+  GroupDurationSubscriber2.prototype._next = function(value) {
+    this.complete();
+  };
+  GroupDurationSubscriber2.prototype._unsubscribe = function() {
+    var _a = this, parent = _a.parent, key = _a.key;
+    this.key = this.parent = null;
+    if (parent) {
+      parent.removeGroup(key);
+    }
+  };
+  return GroupDurationSubscriber2;
+})(Subscriber);
+var GroupedObservable = /* @__PURE__ */ (function(_super) {
+  __extends(GroupedObservable2, _super);
+  function GroupedObservable2(key, groupSubject, refCountSubscription) {
+    var _this = _super.call(this) || this;
+    _this.key = key;
+    _this.groupSubject = groupSubject;
+    _this.refCountSubscription = refCountSubscription;
+    return _this;
+  }
+  GroupedObservable2.prototype._subscribe = function(subscriber) {
+    var subscription = new Subscription();
+    var _a = this, refCountSubscription = _a.refCountSubscription, groupSubject = _a.groupSubject;
+    if (refCountSubscription && !refCountSubscription.closed) {
+      subscription.add(new InnerRefCountSubscription(refCountSubscription));
+    }
+    subscription.add(groupSubject.subscribe(subscriber));
+    return subscription;
+  };
+  return GroupedObservable2;
+})(Observable);
+var InnerRefCountSubscription = /* @__PURE__ */ (function(_super) {
+  __extends(InnerRefCountSubscription2, _super);
+  function InnerRefCountSubscription2(parent) {
+    var _this = _super.call(this) || this;
+    _this.parent = parent;
+    parent.count++;
+    return _this;
+  }
+  InnerRefCountSubscription2.prototype.unsubscribe = function() {
+    var parent = this.parent;
+    if (!parent.closed && !this.closed) {
+      _super.prototype.unsubscribe.call(this);
+      parent.count -= 1;
+      if (parent.count === 0 && parent.attemptedToUnsubscribe) {
+        parent.unsubscribe();
+      }
+    }
+  };
+  return InnerRefCountSubscription2;
+})(Subscription);
+
+// ../../node_modules/rxjs/_esm5/internal/util/subscribeToArray.js
+var subscribeToArray = function(array) {
+  return function(subscriber) {
+    for (var i = 0, len = array.length; i < len && !subscriber.closed; i++) {
+      subscriber.next(array[i]);
+    }
+    subscriber.complete();
+  };
+};
+
+// ../../node_modules/rxjs/_esm5/internal/scheduled/scheduleArray.js
+function scheduleArray(input, scheduler) {
+  return new Observable(function(subscriber) {
+    var sub = new Subscription();
+    var i = 0;
+    sub.add(scheduler.schedule(function() {
+      if (i === input.length) {
+        subscriber.complete();
+        return;
+      }
+      subscriber.next(input[i++]);
+      if (!subscriber.closed) {
+        sub.add(this.schedule());
+      }
+    }));
+    return sub;
+  });
+}
+
+// ../../node_modules/rxjs/_esm5/internal/operators/map.js
+function map(project, thisArg) {
+  return function mapOperation(source) {
+    if (typeof project !== "function") {
+      throw new TypeError("argument is not a function. Are you looking for `mapTo()`?");
+    }
+    return source.lift(new MapOperator(project, thisArg));
+  };
+}
+var MapOperator = /* @__PURE__ */ (function() {
+  function MapOperator2(project, thisArg) {
+    this.project = project;
+    this.thisArg = thisArg;
+  }
+  MapOperator2.prototype.call = function(subscriber, source) {
+    return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));
+  };
+  return MapOperator2;
+})();
+var MapSubscriber = /* @__PURE__ */ (function(_super) {
+  __extends(MapSubscriber2, _super);
+  function MapSubscriber2(destination, project, thisArg) {
+    var _this = _super.call(this, destination) || this;
+    _this.project = project;
+    _this.count = 0;
+    _this.thisArg = thisArg || _this;
+    return _this;
+  }
+  MapSubscriber2.prototype._next = function(value) {
+    var result;
+    try {
+      result = this.project.call(this.thisArg, value, this.count++);
+    } catch (err) {
+      this.destination.error(err);
+      return;
+    }
+    this.destination.next(result);
+  };
+  return MapSubscriber2;
+})(Subscriber);
+
+// ../../node_modules/rxjs/_esm5/internal/util/subscribeToPromise.js
+var subscribeToPromise = function(promise) {
+  return function(subscriber) {
+    promise.then(function(value) {
+      if (!subscriber.closed) {
+        subscriber.next(value);
+        subscriber.complete();
+      }
+    }, function(err) {
+      return subscriber.error(err);
+    }).then(null, hostReportError);
+    return subscriber;
+  };
+};
+
+// ../../node_modules/rxjs/_esm5/internal/symbol/iterator.js
+function getSymbolIterator() {
+  if (typeof Symbol !== "function" || !Symbol.iterator) {
+    return "@@iterator";
+  }
+  return Symbol.iterator;
+}
+var iterator = /* @__PURE__ */ getSymbolIterator();
+
+// ../../node_modules/rxjs/_esm5/internal/util/subscribeToIterable.js
+var subscribeToIterable = function(iterable) {
+  return function(subscriber) {
+    var iterator2 = iterable[iterator]();
+    do {
+      var item = void 0;
+      try {
+        item = iterator2.next();
+      } catch (err) {
+        subscriber.error(err);
+        return subscriber;
+      }
+      if (item.done) {
+        subscriber.complete();
+        break;
+      }
+      subscriber.next(item.value);
+      if (subscriber.closed) {
+        break;
+      }
+    } while (true);
+    if (typeof iterator2.return === "function") {
+      subscriber.add(function() {
+        if (iterator2.return) {
+          iterator2.return();
+        }
+      });
+    }
+    return subscriber;
+  };
+};
+
+// ../../node_modules/rxjs/_esm5/internal/util/subscribeToObservable.js
+var subscribeToObservable = function(obj) {
+  return function(subscriber) {
+    var obs = obj[observable]();
+    if (typeof obs.subscribe !== "function") {
+      throw new TypeError("Provided object does not correctly implement Symbol.observable");
+    } else {
+      return obs.subscribe(subscriber);
+    }
+  };
+};
+
+// ../../node_modules/rxjs/_esm5/internal/util/isArrayLike.js
+var isArrayLike = (function(x) {
+  return x && typeof x.length === "number" && typeof x !== "function";
+});
+
+// ../../node_modules/rxjs/_esm5/internal/util/isPromise.js
+function isPromise(value) {
+  return !!value && typeof value.subscribe !== "function" && typeof value.then === "function";
+}
+
+// ../../node_modules/rxjs/_esm5/internal/util/subscribeTo.js
+var subscribeTo = function(result) {
+  if (!!result && typeof result[observable] === "function") {
+    return subscribeToObservable(result);
+  } else if (isArrayLike(result)) {
+    return subscribeToArray(result);
+  } else if (isPromise(result)) {
+    return subscribeToPromise(result);
+  } else if (!!result && typeof result[iterator] === "function") {
+    return subscribeToIterable(result);
+  } else {
+    var value = isObject(result) ? "an invalid object" : "'" + result + "'";
+    var msg = "You provided " + value + " where a stream was expected. You can provide an Observable, Promise, Array, or Iterable.";
+    throw new TypeError(msg);
+  }
+};
+
+// ../../node_modules/rxjs/_esm5/internal/scheduled/scheduleObservable.js
+function scheduleObservable(input, scheduler) {
+  return new Observable(function(subscriber) {
+    var sub = new Subscription();
+    sub.add(scheduler.schedule(function() {
+      var observable2 = input[observable]();
+      sub.add(observable2.subscribe({
+        next: function(value) {
+          sub.add(scheduler.schedule(function() {
+            return subscriber.next(value);
+          }));
+        },
+        error: function(err) {
+          sub.add(scheduler.schedule(function() {
+            return subscriber.error(err);
+          }));
+        },
+        complete: function() {
+          sub.add(scheduler.schedule(function() {
+            return subscriber.complete();
+          }));
+        }
+      }));
+    }));
+    return sub;
+  });
+}
+
+// ../../node_modules/rxjs/_esm5/internal/scheduled/schedulePromise.js
+function schedulePromise(input, scheduler) {
+  return new Observable(function(subscriber) {
+    var sub = new Subscription();
+    sub.add(scheduler.schedule(function() {
+      return input.then(function(value) {
+        sub.add(scheduler.schedule(function() {
+          subscriber.next(value);
+          sub.add(scheduler.schedule(function() {
+            return subscriber.complete();
+          }));
+        }));
+      }, function(err) {
+        sub.add(scheduler.schedule(function() {
+          return subscriber.error(err);
+        }));
+      });
+    }));
+    return sub;
+  });
+}
+
+// ../../node_modules/rxjs/_esm5/internal/scheduled/scheduleIterable.js
+function scheduleIterable(input, scheduler) {
+  if (!input) {
+    throw new Error("Iterable cannot be null");
+  }
+  return new Observable(function(subscriber) {
+    var sub = new Subscription();
+    var iterator2;
+    sub.add(function() {
+      if (iterator2 && typeof iterator2.return === "function") {
+        iterator2.return();
+      }
+    });
+    sub.add(scheduler.schedule(function() {
+      iterator2 = input[iterator]();
+      sub.add(scheduler.schedule(function() {
+        if (subscriber.closed) {
+          return;
+        }
+        var value;
+        var done;
+        try {
+          var result = iterator2.next();
+          value = result.value;
+          done = result.done;
+        } catch (err) {
+          subscriber.error(err);
+          return;
+        }
+        if (done) {
+          subscriber.complete();
+        } else {
+          subscriber.next(value);
+          this.schedule();
+        }
+      }));
+    }));
+    return sub;
+  });
+}
+
+// ../../node_modules/rxjs/_esm5/internal/util/isInteropObservable.js
+function isInteropObservable(input) {
+  return input && typeof input[observable] === "function";
+}
+
+// ../../node_modules/rxjs/_esm5/internal/util/isIterable.js
+function isIterable(input) {
+  return input && typeof input[iterator] === "function";
+}
+
+// ../../node_modules/rxjs/_esm5/internal/scheduled/scheduled.js
+function scheduled(input, scheduler) {
+  if (input != null) {
+    if (isInteropObservable(input)) {
+      return scheduleObservable(input, scheduler);
+    } else if (isPromise(input)) {
+      return schedulePromise(input, scheduler);
+    } else if (isArrayLike(input)) {
+      return scheduleArray(input, scheduler);
+    } else if (isIterable(input) || typeof input === "string") {
+      return scheduleIterable(input, scheduler);
+    }
+  }
+  throw new TypeError((input !== null && typeof input || input) + " is not observable");
+}
+
+// ../../node_modules/rxjs/_esm5/internal/observable/from.js
+function from(input, scheduler) {
+  if (!scheduler) {
+    if (input instanceof Observable) {
+      return input;
+    }
+    return new Observable(subscribeTo(input));
+  } else {
+    return scheduled(input, scheduler);
+  }
+}
+
+// ../../node_modules/rxjs/_esm5/internal/innerSubscribe.js
+var SimpleInnerSubscriber = /* @__PURE__ */ (function(_super) {
+  __extends(SimpleInnerSubscriber2, _super);
+  function SimpleInnerSubscriber2(parent) {
+    var _this = _super.call(this) || this;
+    _this.parent = parent;
+    return _this;
+  }
+  SimpleInnerSubscriber2.prototype._next = function(value) {
+    this.parent.notifyNext(value);
+  };
+  SimpleInnerSubscriber2.prototype._error = function(error) {
+    this.parent.notifyError(error);
+    this.unsubscribe();
+  };
+  SimpleInnerSubscriber2.prototype._complete = function() {
+    this.parent.notifyComplete();
+    this.unsubscribe();
+  };
+  return SimpleInnerSubscriber2;
+})(Subscriber);
+var SimpleOuterSubscriber = /* @__PURE__ */ (function(_super) {
+  __extends(SimpleOuterSubscriber2, _super);
+  function SimpleOuterSubscriber2() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  SimpleOuterSubscriber2.prototype.notifyNext = function(innerValue) {
+    this.destination.next(innerValue);
+  };
+  SimpleOuterSubscriber2.prototype.notifyError = function(err) {
+    this.destination.error(err);
+  };
+  SimpleOuterSubscriber2.prototype.notifyComplete = function() {
+    this.destination.complete();
+  };
+  return SimpleOuterSubscriber2;
+})(Subscriber);
+function innerSubscribe(result, innerSubscriber) {
+  if (innerSubscriber.closed) {
+    return void 0;
+  }
+  if (result instanceof Observable) {
+    return result.subscribe(innerSubscriber);
+  }
+  var subscription;
+  try {
+    subscription = subscribeTo(result)(innerSubscriber);
+  } catch (error) {
+    innerSubscriber.error(error);
+  }
+  return subscription;
+}
+
+// ../../node_modules/rxjs/_esm5/internal/operators/mergeMap.js
+function mergeMap(project, resultSelector, concurrent) {
+  if (concurrent === void 0) {
+    concurrent = Number.POSITIVE_INFINITY;
+  }
+  if (typeof resultSelector === "function") {
+    return function(source) {
+      return source.pipe(mergeMap(function(a, i) {
+        return from(project(a, i)).pipe(map(function(b, ii) {
+          return resultSelector(a, b, i, ii);
+        }));
+      }, concurrent));
+    };
+  } else if (typeof resultSelector === "number") {
+    concurrent = resultSelector;
+  }
+  return function(source) {
+    return source.lift(new MergeMapOperator(project, concurrent));
+  };
+}
+var MergeMapOperator = /* @__PURE__ */ (function() {
+  function MergeMapOperator2(project, concurrent) {
+    if (concurrent === void 0) {
+      concurrent = Number.POSITIVE_INFINITY;
+    }
+    this.project = project;
+    this.concurrent = concurrent;
+  }
+  MergeMapOperator2.prototype.call = function(observer, source) {
+    return source.subscribe(new MergeMapSubscriber(observer, this.project, this.concurrent));
+  };
+  return MergeMapOperator2;
+})();
+var MergeMapSubscriber = /* @__PURE__ */ (function(_super) {
+  __extends(MergeMapSubscriber2, _super);
+  function MergeMapSubscriber2(destination, project, concurrent) {
+    if (concurrent === void 0) {
+      concurrent = Number.POSITIVE_INFINITY;
+    }
+    var _this = _super.call(this, destination) || this;
+    _this.project = project;
+    _this.concurrent = concurrent;
+    _this.hasCompleted = false;
+    _this.buffer = [];
+    _this.active = 0;
+    _this.index = 0;
+    return _this;
+  }
+  MergeMapSubscriber2.prototype._next = function(value) {
+    if (this.active < this.concurrent) {
+      this._tryNext(value);
+    } else {
+      this.buffer.push(value);
+    }
+  };
+  MergeMapSubscriber2.prototype._tryNext = function(value) {
+    var result;
+    var index = this.index++;
+    try {
+      result = this.project(value, index);
+    } catch (err) {
+      this.destination.error(err);
+      return;
+    }
+    this.active++;
+    this._innerSub(result);
+  };
+  MergeMapSubscriber2.prototype._innerSub = function(ish) {
+    var innerSubscriber = new SimpleInnerSubscriber(this);
+    var destination = this.destination;
+    destination.add(innerSubscriber);
+    var innerSubscription = innerSubscribe(ish, innerSubscriber);
+    if (innerSubscription !== innerSubscriber) {
+      destination.add(innerSubscription);
+    }
+  };
+  MergeMapSubscriber2.prototype._complete = function() {
+    this.hasCompleted = true;
+    if (this.active === 0 && this.buffer.length === 0) {
+      this.destination.complete();
+    }
+    this.unsubscribe();
+  };
+  MergeMapSubscriber2.prototype.notifyNext = function(innerValue) {
+    this.destination.next(innerValue);
+  };
+  MergeMapSubscriber2.prototype.notifyComplete = function() {
+    var buffer = this.buffer;
+    this.active--;
+    if (buffer.length > 0) {
+      this._next(buffer.shift());
+    } else if (this.active === 0 && this.hasCompleted) {
+      this.destination.complete();
+    }
+  };
+  return MergeMapSubscriber2;
+})(SimpleOuterSubscriber);
+
+// ../../node_modules/rxjs/_esm5/internal/operators/concatMap.js
+function concatMap(project, resultSelector) {
+  return mergeMap(project, resultSelector, 1);
+}
+
 // src/graph/consumer.ts
 import { EventQuery } from "@semiont/event-sourcing";
-import { didToAgent } from "@semiont/core";
+import { didToAgent, burstBuffer } from "@semiont/core";
 import { resourceId as makeResourceId, findBodyItem } from "@semiont/core";
 import { toResourceUri, toAnnotationUri } from "@semiont/event-sourcing";
-var GraphDBConsumer = class {
-  constructor(config, eventStore, graphDb, logger) {
-    this.config = config;
+var GraphDBConsumer = class _GraphDBConsumer {
+  constructor(config2, eventStore, graphDb, logger) {
+    this.config = config2;
     this.eventStore = eventStore;
     this.graphDb = graphDb;
     this.logger = logger;
   }
+  // Event types that produce GraphDB mutations — filter everything else
+  static GRAPH_RELEVANT_EVENTS = /* @__PURE__ */ new Set([
+    "resource.created",
+    "resource.archived",
+    "resource.unarchived",
+    "annotation.added",
+    "annotation.removed",
+    "annotation.body.updated",
+    "entitytag.added",
+    "entitytag.removed",
+    "entitytype.added"
+  ]);
+  // Burst buffer thresholds — see class doc and BATCH-GRAPH-CONSUMER-RX.md
+  static BURST_WINDOW_MS = 50;
+  static MAX_BATCH_SIZE = 500;
+  static IDLE_TIMEOUT_MS = 200;
   _globalSubscription = null;
-  // Global subscription (receives ALL events)
-  processing = /* @__PURE__ */ new Map();
+  eventSubject = new Subject();
+  pipelineSubscription = null;
   lastProcessed = /* @__PURE__ */ new Map();
   logger;
   async initialize() {
@@ -1937,20 +3364,70 @@ var GraphDBConsumer = class {
     await this.subscribeToGlobalEvents();
   }
   /**
-   * Subscribe globally to ALL events (system AND resource events)
-   * Resource events are now sent to global subscribers (see EventBus.publish)
+   * Subscribe globally to ALL events, pre-filter to graph-relevant types,
+   * and wire through the RxJS burst-buffered pipeline.
    */
   async subscribeToGlobalEvents() {
-    this._globalSubscription = this.eventStore.bus.subscriptions.subscribeGlobal(async (storedEvent) => {
-      await this.processEvent(storedEvent);
+    this._globalSubscription = this.eventStore.bus.subscriptions.subscribeGlobal(
+      (storedEvent) => {
+        if (!_GraphDBConsumer.GRAPH_RELEVANT_EVENTS.has(storedEvent.event.type)) return;
+        this.eventSubject.next(storedEvent);
+      }
+    );
+    this.pipelineSubscription = this.eventSubject.pipe(
+      // Split into one inner Observable per resource (system events grouped under '__system__')
+      groupBy((se) => se.event.resourceId ?? "__system__"),
+      mergeMap((group) => {
+        if (group.key === "__system__") {
+          return group.pipe(
+            concatMap((se) => from(this.safeApplyEvent(se)))
+          );
+        }
+        return group.pipe(
+          burstBuffer({
+            burstWindowMs: _GraphDBConsumer.BURST_WINDOW_MS,
+            maxBatchSize: _GraphDBConsumer.MAX_BATCH_SIZE,
+            idleTimeoutMs: _GraphDBConsumer.IDLE_TIMEOUT_MS
+          }),
+          concatMap((eventOrBatch) => {
+            if (Array.isArray(eventOrBatch)) {
+              return from(this.processBatch(eventOrBatch));
+            }
+            return from(this.safeApplyEvent(eventOrBatch).then(() => {
+              this.lastProcessed.set(
+                eventOrBatch.event.resourceId,
+                eventOrBatch.metadata.sequenceNumber
+              );
+            }));
+          })
+        );
+      })
+    ).subscribe({
+      error: (err) => {
+        this.logger.error("GraphDB consumer pipeline error", { error: err });
+      }
     });
-    this.logger.info("Subscribed to global events (system + resource)");
+    this.logger.info("Subscribed to global events with burst-buffered pipeline");
+  }
+  /**
+   * Wrap applyEventToGraph in try/catch so one failed event doesn't kill the pipeline.
+   */
+  async safeApplyEvent(storedEvent) {
+    try {
+      await this.applyEventToGraph(storedEvent);
+    } catch (error) {
+      this.logger.error("Failed to apply event to graph", {
+        eventType: storedEvent.event.type,
+        resourceId: storedEvent.event.resourceId,
+        error
+      });
+    }
   }
   ensureInitialized() {
     return this.graphDb;
   }
   /**
-   * Stop the consumer and unsubscribe from all events
+   * Stop the consumer, flush remaining buffered events, and unsubscribe.
    */
   async stop() {
     this.logger.info("Stopping GraphDB consumer");
@@ -1958,35 +3435,119 @@ var GraphDBConsumer = class {
       this._globalSubscription.unsubscribe();
     }
     this._globalSubscription = null;
+    this.eventSubject.complete();
+    if (this.pipelineSubscription) {
+      this.pipelineSubscription.unsubscribe();
+      this.pipelineSubscription = null;
+    }
+    this.eventSubject = new Subject();
     this.logger.info("GraphDB consumer stopped");
   }
   /**
-   * Process event with ordering guarantee (sequential per resource)
+   * Process a batch of events for the same resource.
+   * Partitions into consecutive same-type runs for batch optimization.
    */
-  async processEvent(storedEvent) {
-    const { resourceId: resourceId3 } = storedEvent.event;
-    if (!resourceId3) {
-      await this.applyEventToGraph(storedEvent);
-      return;
+  async processBatch(events) {
+    const runs = [];
+    let currentRun = [];
+    for (const event of events) {
+      if (currentRun.length > 0 && currentRun[0].event.type !== event.event.type) {
+        runs.push(currentRun);
+        currentRun = [];
+      }
+      currentRun.push(event);
     }
-    const previousProcessing = this.processing.get(resourceId3);
-    if (previousProcessing) {
-      await previousProcessing;
+    if (currentRun.length > 0) runs.push(currentRun);
+    for (const run of runs) {
+      try {
+        if (run.length === 1) {
+          await this.applyEventToGraph(run[0]);
+        } else {
+          await this.applyBatchByType(run);
+        }
+      } catch (error) {
+        this.logger.error("Failed to process batch run", {
+          eventType: run[0].event.type,
+          runSize: run.length,
+          error
+        });
+      }
+      const last = run[run.length - 1];
+      if (last.event.resourceId) {
+        this.lastProcessed.set(last.event.resourceId, last.metadata.sequenceNumber);
+      }
     }
-    const processingPromise = this.applyEventToGraph(storedEvent);
-    this.processing.set(resourceId3, processingPromise);
-    try {
-      await processingPromise;
-      this.lastProcessed.set(resourceId3, storedEvent.metadata.sequenceNumber);
-    } catch (error) {
-      this.logger.error("Failed to process event", { error });
-      throw error;
-    } finally {
-      this.processing.delete(resourceId3);
+    this.logger.debug("Processed batch", {
+      resourceId: events[0]?.event.resourceId,
+      batchSize: events.length
+    });
+  }
+  /**
+   * Batch-optimized processing for consecutive events of the same type.
+   * Uses batch graph methods where available, falls back to sequential.
+   */
+  async applyBatchByType(events) {
+    const graphDb = this.ensureInitialized();
+    const type = events[0].event.type;
+    switch (type) {
+      case "resource.created": {
+        const resources = events.map((e) => this.buildResourceDescriptor(e));
+        await graphDb.batchCreateResources(resources);
+        this.logger.info("Batch created resources in graph", { count: events.length });
+        break;
+      }
+      case "annotation.added": {
+        const inputs = events.map((e) => {
+          const event = e.event;
+          return {
+            ...event.payload.annotation,
+            creator: didToAgent(event.userId)
+          };
+        });
+        await graphDb.createAnnotations(inputs);
+        this.logger.info("Batch created annotations in graph", { count: events.length });
+        break;
+      }
+      default:
+        for (const event of events) {
+          await this.applyEventToGraph(event);
+        }
+    }
+  }
+  /**
+   * Build a ResourceDescriptor from a resource.created event.
+   * Extracted for reuse by both applyEventToGraph and applyBatchByType.
+   */
+  buildResourceDescriptor(storedEvent) {
+    const event = storedEvent.event;
+    if (event.type !== "resource.created") {
+      throw new Error("Expected resource.created event");
+    }
+    if (!event.resourceId) {
+      throw new Error("resource.created requires resourceId");
     }
+    const resourceUri2 = toResourceUri(
+      { baseUrl: this.config.services.backend.publicURL },
+      event.resourceId
+    );
+    return {
+      "@context": "https://schema.org/",
+      "@id": resourceUri2,
+      name: event.payload.name,
+      entityTypes: event.payload.entityTypes || [],
+      representations: [{
+        mediaType: event.payload.format,
+        checksum: event.payload.contentChecksum,
+        rel: "original"
+      }],
+      archived: false,
+      dateCreated: (/* @__PURE__ */ new Date()).toISOString(),
+      wasAttributedTo: didToAgent(event.userId),
+      creationMethod: event.payload.creationMethod
+    };
   }
   /**
-   * Apply event to GraphDB
+   * Apply a single event to GraphDB.
    */
   async applyEventToGraph(storedEvent) {
     const graphDb = this.ensureInitialized();
@@ -1997,26 +3558,10 @@ var GraphDBConsumer = class {
     });
     switch (event.type) {
       case "resource.created": {
-        if (!event.resourceId) throw new Error("resource.created requires resourceId");
-        const resourceUri2 = toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId);
-        const resource = {
-          "@context": "https://schema.org/",
-          "@id": resourceUri2,
-          name: event.payload.name,
-          entityTypes: event.payload.entityTypes || [],
-          representations: [{
-            mediaType: event.payload.format,
-            checksum: event.payload.contentChecksum,
-            rel: "original"
-          }],
-          archived: false,
-          dateCreated: (/* @__PURE__ */ new Date()).toISOString(),
-          wasAttributedTo: didToAgent(event.userId),
-          creationMethod: event.payload.creationMethod
-        };
-        this.logger.debug("Creating resource in graph", { resourceUri: resourceUri2 });
+        const resource = this.buildResourceDescriptor(storedEvent);
+        this.logger.debug("Creating resource in graph", { resourceUri: resource["@id"] });
         await graphDb.createResource(resource);
-        this.logger.info("Resource created in graph", { resourceUri: resourceUri2 });
+        this.logger.info("Resource created in graph", { resourceUri: resource["@id"] });
         break;
       }
       case "resource.archived":
@@ -2053,44 +3598,27 @@ var GraphDBConsumer = class {
         });
         try {
           const annotationUri2 = toAnnotationUri({ baseUrl: this.config.services.backend.publicURL }, event.payload.annotationId);
-          this.logger.debug("Created annotation URI", { annotationUri: annotationUri2 });
-          this.logger.debug("Processing body update", {
-            annotationUri: annotationUri2,
-            operations: event.payload.operations
-          });
           const currentAnnotation = await graphDb.getAnnotation(annotationUri2);
-          this.logger.debug("Current annotation lookup result", {
-            found: !!currentAnnotation
-          });
           if (currentAnnotation) {
-            this.logger.debug("Current annotation body", { body: currentAnnotation.body });
             let bodyArray = Array.isArray(currentAnnotation.body) ? [...currentAnnotation.body] : currentAnnotation.body ? [currentAnnotation.body] : [];
             for (const op of event.payload.operations) {
-              this.logger.debug("Applying body operation", { operation: op });
               if (op.op === "add") {
                 const exists = findBodyItem(bodyArray, op.item) !== -1;
                 if (!exists) {
                   bodyArray.push(op.item);
-                  this.logger.debug("Added item to body");
-                } else {
-                  this.logger.debug("Item already exists, skipping");
                 }
               } else if (op.op === "remove") {
                 const index = findBodyItem(bodyArray, op.item);
                 if (index !== -1) {
                   bodyArray.splice(index, 1);
-                  this.logger.debug("Removed item from body");
                 }
               } else if (op.op === "replace") {
                 const index = findBodyItem(bodyArray, op.oldItem);
                 if (index !== -1) {
                   bodyArray[index] = op.newItem;
-                  this.logger.debug("Replaced item in body");
                 }
               }
             }
-            this.logger.debug("New body array", { bodyArray });
-            this.logger.debug("Calling updateAnnotation");
             await graphDb.updateAnnotation(annotationUri2, {
               body: bodyArray
             });
@@ -2108,20 +3636,24 @@ var GraphDBConsumer = class {
         break;
       case "entitytag.added":
         if (!event.resourceId) throw new Error("entitytag.added requires resourceId");
-        const doc = await graphDb.getResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId));
-        if (doc) {
-          await graphDb.updateResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId), {
-            entityTypes: [...doc.entityTypes || [], event.payload.entityType]
-          });
+        {
+          const doc = await graphDb.getResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId));
+          if (doc) {
+            await graphDb.updateResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId), {
+              entityTypes: [...doc.entityTypes || [], event.payload.entityType]
+            });
+          }
         }
         break;
       case "entitytag.removed":
         if (!event.resourceId) throw new Error("entitytag.removed requires resourceId");
-        const doc2 = await graphDb.getResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId));
-        if (doc2) {
-          await graphDb.updateResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId), {
-            entityTypes: (doc2.entityTypes || []).filter((t) => t !== event.payload.entityType)
-          });
+        {
+          const doc = await graphDb.getResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId));
+          if (doc) {
+            await graphDb.updateResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId), {
+              entityTypes: (doc.entityTypes || []).filter((t) => t !== event.payload.entityType)
+            });
+          }
         }
         break;
       case "entitytype.added":
@@ -2132,8 +3664,8 @@ var GraphDBConsumer = class {
     }
   }
   /**
-   * Rebuild entire resource from events
-   * Useful for recovery or initial sync
+   * Rebuild entire resource from events.
+   * Bypasses the live pipeline — reads directly from event store.
    */
   async rebuildResource(resourceId3) {
     const graphDb = this.ensureInitialized();
@@ -2151,8 +3683,9 @@ var GraphDBConsumer = class {
     this.logger.info("Resource rebuild complete", { resourceId: resourceId3, eventCount: events.length });
   }
   /**
-   * Rebuild entire GraphDB from all events
-   * Uses two-pass approach to ensure all resources exist before creating REFERENCES edges
+   * Rebuild entire GraphDB from all events.
+   * Uses two-pass approach to ensure all resources exist before creating REFERENCES edges.
+   * Bypasses the live pipeline — reads directly from event store.
    */
   async rebuildAll() {
     const graphDb = this.ensureInitialized();
@@ -2186,25 +3719,20 @@ var GraphDBConsumer = class {
     this.logger.info("Rebuild complete");
   }
   /**
-   * Get consumer health metrics
+   * Get consumer health metrics.
    */
   getHealthMetrics() {
     return {
       subscriptions: this._globalSubscription ? 1 : 0,
-      // Only global subscription
       lastProcessed: Object.fromEntries(this.lastProcessed),
-      processing: Array.from(this.processing.keys())
+      pipelineActive: !!this.pipelineSubscription
     };
   }
   /**
-   * Shutdown consumer
+   * Shutdown consumer.
    */
   async shutdown() {
-    if (this._globalSubscription) {
-      this._globalSubscription.unsubscribe();
-      this._globalSubscription = null;
-      this.logger.info("Unsubscribed from global events");
-    }
+    await this.stop();
     this.logger.info("GraphDB consumer shut down");
   }
 };
@@ -2215,13 +3743,13 @@ import * as path from "path";
 import { DEFAULT_ENTITY_TYPES } from "@semiont/ontology";
 import { userId as userId5 } from "@semiont/core";
 var bootstrapCompleted = false;
-async function bootstrapEntityTypes(eventStore, config, logger) {
+async function bootstrapEntityTypes(eventStore, config2, logger) {
   if (bootstrapCompleted) {
     logger?.debug("Entity types bootstrap already completed, skipping");
     return;
   }
-  const configuredPath = config.services.filesystem.path;
-  const projectRoot = config._metadata?.projectRoot;
+  const configuredPath = config2.services.filesystem.path;
+  const projectRoot = config2._metadata?.projectRoot;
   let basePath;
   if (path.isAbsolute(configuredPath)) {
     basePath = configuredPath;
@@ -2268,16 +3796,16 @@ function resetBootstrap() {
 }
 
 // src/service.ts
-async function startMakeMeaning(config, eventBus, logger) {
-  const configuredPath = config.services?.filesystem?.path;
+async function startMakeMeaning(config2, eventBus, logger) {
+  const configuredPath = config2.services?.filesystem?.path;
   if (!configuredPath) {
     throw new Error("services.filesystem.path is required for make-meaning service");
   }
-  const baseUrl = config.services?.backend?.publicURL;
+  const baseUrl = config2.services?.backend?.publicURL;
   if (!baseUrl) {
     throw new Error("services.backend.publicURL is required for make-meaning service");
   }
-  const projectRoot = config._metadata?.projectRoot;
+  const projectRoot = config2._metadata?.projectRoot;
   let basePath;
   if (path2.isAbsolute(configuredPath)) {
     basePath = configuredPath;
@@ -2292,12 +3820,12 @@ async function startMakeMeaning(config, eventBus, logger) {
   const eventStoreLogger = logger.child({ component: "event-store" });
   const eventStore = createEventStoreCore(basePath, baseUrl, void 0, eventBus, eventStoreLogger);
   const bootstrapLogger = logger.child({ component: "entity-types-bootstrap" });
-  await bootstrapEntityTypes(eventStore, config, bootstrapLogger);
+  await bootstrapEntityTypes(eventStore, config2, bootstrapLogger);
   const repStoreLogger = logger.child({ component: "representation-store" });
   const repStore = new FilesystemRepresentationStore3({ basePath }, projectRoot, repStoreLogger);
   const inferenceLogger = logger.child({ component: "inference-client" });
-  const inferenceClient = await getInferenceClient(config, inferenceLogger);
-  const graphDb = await getGraphDatabase(config);
+  const inferenceClient = await getInferenceClient(config2, inferenceLogger);
+  const graphDb = await getGraphDatabase(config2);
   const detectionLogger = logger.child({ component: "reference-detection-worker" });
   const generationLogger = logger.child({ component: "generation-worker" });
   const highlightLogger = logger.child({ component: "highlight-detection-worker" });
@@ -2305,15 +3833,15 @@ async function startMakeMeaning(config, eventBus, logger) {
   const commentLogger = logger.child({ component: "comment-detection-worker" });
   const tagLogger = logger.child({ component: "tag-detection-worker" });
   const graphConsumerLogger = logger.child({ component: "graph-consumer" });
-  const graphConsumer = new GraphDBConsumer(config, eventStore, graphDb, graphConsumerLogger);
+  const graphConsumer = new GraphDBConsumer(config2, eventStore, graphDb, graphConsumerLogger);
   await graphConsumer.initialize();
   const workers = {
-    detection: new ReferenceAnnotationWorker(jobQueue, config, eventStore, inferenceClient, eventBus, detectionLogger),
-    generation: new GenerationWorker(jobQueue, config, eventStore, inferenceClient, eventBus, generationLogger),
-    highlight: new HighlightAnnotationWorker(jobQueue, config, eventStore, inferenceClient, eventBus, highlightLogger),
-    assessment: new AssessmentAnnotationWorker(jobQueue, config, eventStore, inferenceClient, eventBus, assessmentLogger),
-    comment: new CommentAnnotationWorker(jobQueue, config, eventStore, inferenceClient, eventBus, commentLogger),
-    tag: new TagAnnotationWorker(jobQueue, config, eventStore, inferenceClient, eventBus, tagLogger)
+    detection: new ReferenceAnnotationWorker(jobQueue, config2, eventStore, inferenceClient, eventBus, detectionLogger),
+    generation: new GenerationWorker(jobQueue, config2, eventStore, inferenceClient, eventBus, generationLogger),
+    highlight: new HighlightAnnotationWorker(jobQueue, config2, eventStore, inferenceClient, eventBus, highlightLogger),
+    assessment: new AssessmentAnnotationWorker(jobQueue, config2, eventStore, inferenceClient, eventBus, assessmentLogger),
+    comment: new CommentAnnotationWorker(jobQueue, config2, eventStore, inferenceClient, eventBus, commentLogger),
+    tag: new TagAnnotationWorker(jobQueue, config2, eventStore, inferenceClient, eventBus, tagLogger)
   };
   workers.detection.start().catch((error) => {
     detectionLogger.error("Worker stopped unexpectedly", { error });
@@ -2362,9 +3890,9 @@ async function startMakeMeaning(config, eventBus, logger) {
 // src/views/entity-types-reader.ts
 import { promises as fs2 } from "fs";
 import * as path3 from "path";
-async function readEntityTypesProjection(config) {
-  const configuredPath = config.services.filesystem.path;
-  const projectRoot = config._metadata?.projectRoot;
+async function readEntityTypesProjection(config2) {
+  const configuredPath = config2.services.filesystem.path;
+  const projectRoot = config2._metadata?.projectRoot;
   let basePath;
   if (path3.isAbsolute(configuredPath)) {
     basePath = configuredPath;
@@ -2401,7 +3929,7 @@ var ResourceOperations = class {
    * Create a new resource
    * Orchestrates: content storage → event emission → response building
    */
-  static async createResource(input, userId6, eventStore, repStore, config) {
+  static async createResource(input, userId6, eventStore, repStore, config2) {
     const rId = resourceId2(generateUuid());
     const storedRep = await repStore.store(input.content, {
       mediaType: input.format,
@@ -2428,7 +3956,7 @@ var ResourceOperations = class {
         generationPrompt: void 0
       }
     });
-    const backendUrl = config.services.backend?.publicURL;
+    const backendUrl = config2.services.backend?.publicURL;
     if (!backendUrl) {
       throw new Error("Backend publicURL not configured");
     }
@@ -2571,9 +4099,9 @@ var ResourceContext = class {
   /**
    * Get resource metadata from view storage
    */
-  static async getResourceMetadata(resourceId3, config) {
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
+  static async getResourceMetadata(resourceId3, config2) {
+    const basePath = config2.services.filesystem.path;
+    const projectRoot = config2._metadata?.projectRoot;
     const viewStorage = new FilesystemViewStorage(basePath, projectRoot);
     const view = await viewStorage.get(resourceId3);
     if (!view) {
@@ -2584,9 +4112,9 @@ var ResourceContext = class {
   /**
    * List all resources by scanning view storage
    */
-  static async listResources(filters, config) {
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
+  static async listResources(filters, config2) {
+    const basePath = config2.services.filesystem.path;
+    const projectRoot = config2._metadata?.projectRoot;
     const viewStorage = new FilesystemViewStorage(basePath, projectRoot);
     const allViews = await viewStorage.getAll();
     const resources = [];
@@ -2614,9 +4142,9 @@ var ResourceContext = class {
    * Add content previews to resources (for search results)
    * Retrieves and decodes the first 200 characters of each resource's primary representation
    */
-  static async addContentPreviews(resources, config) {
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
+  static async addContentPreviews(resources, config2) {
+    const basePath = config2.services.filesystem.path;
+    const projectRoot = config2._metadata?.projectRoot;
     const repStore = new FilesystemRepresentationStore4({ basePath }, projectRoot);
     return await Promise.all(
       resources.map(async (doc) => {
@@ -2638,9 +4166,9 @@ var ResourceContext = class {
    * Get full content for a resource
    * Retrieves and decodes the primary representation
    */
-  static async getResourceContent(resource, config) {
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
+  static async getResourceContent(resource, config2) {
+    const basePath = config2.services.filesystem.path;
+    const projectRoot = config2._metadata?.projectRoot;
     const repStore = new FilesystemRepresentationStore4({ basePath }, projectRoot);
     const primaryRep = getPrimaryRepresentation2(resource);
     if (primaryRep?.checksum && primaryRep?.mediaType) {
@@ -2663,7 +4191,7 @@ var AnnotationContext = class {
    * @returns Rich context for LLM processing
    * @throws Error if annotation or resource not found
    */
-  static async buildLLMContext(annotationUri2, resourceId3, config, options = {}, logger) {
+  static async buildLLMContext(annotationUri2, resourceId3, config2, options = {}, logger) {
     const {
       includeSourceContext = true,
       includeTargetContext = true,
@@ -2673,9 +4201,9 @@ var AnnotationContext = class {
       throw new Error("contextWindow must be between 100 and 5000");
     }
     logger?.debug("Building LLM context", { annotationUri: annotationUri2, resourceId: resourceId3 });
-    const basePath = config.services.filesystem.path;
+    const basePath = config2.services.filesystem.path;
     logger?.debug("Filesystem basePath", { basePath });
-    const projectRoot = config._metadata?.projectRoot;
+    const projectRoot = config2._metadata?.projectRoot;
     const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
     const repStore = new FilesystemRepresentationStore5({ basePath }, projectRoot);
     logger?.debug("Getting view for resource", { resourceId: resourceId3 });
@@ -2767,7 +4295,7 @@ var AnnotationContext = class {
       if (targetRep?.checksum && targetRep?.mediaType) {
         const targetContent = await repStore.retrieve(targetRep.checksum, targetRep.mediaType);
         const contentStr = decodeRepresentation3(targetContent, targetRep.mediaType);
-        const client = await getInferenceClient2(config, logger);
+        const client = await getInferenceClient2(config2, logger);
         targetContext = {
           content: contentStr.slice(0, contextWindow * 2),
           summary: await generateResourceSummary(targetDoc.name, contentStr, getResourceEntityTypes(targetDoc), client)
@@ -2803,12 +4331,12 @@ var AnnotationContext = class {
    * Get resource annotations from view storage (fast path)
    * Throws if view missing
    */
-  static async getResourceAnnotations(resourceId3, config) {
-    if (!config.services?.filesystem?.path) {
+  static async getResourceAnnotations(resourceId3, config2) {
+    if (!config2.services?.filesystem?.path) {
       throw new Error("Filesystem path not found in configuration");
     }
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
+    const basePath = config2.services.filesystem.path;
+    const projectRoot = config2._metadata?.projectRoot;
     const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
     const view = await viewStorage.get(resourceId3);
     if (!view) {
@@ -2820,17 +4348,17 @@ var AnnotationContext = class {
    * Get all annotations
    * @returns Array of all annotation objects
    */
-  static async getAllAnnotations(resourceId3, config) {
-    const annotations = await this.getResourceAnnotations(resourceId3, config);
-    return await this.enrichResolvedReferences(annotations.annotations, config);
+  static async getAllAnnotations(resourceId3, config2) {
+    const annotations = await this.getResourceAnnotations(resourceId3, config2);
+    return await this.enrichResolvedReferences(annotations.annotations, config2);
   }
   /**
    * Enrich reference annotations with resolved document names
    * Adds _resolvedDocumentName property to annotations that link to documents
    * @private
    */
-  static async enrichResolvedReferences(annotations, config) {
-    if (!config.services?.filesystem?.path) {
+  static async enrichResolvedReferences(annotations, config2) {
+    if (!config2.services?.filesystem?.path) {
       return annotations;
     }
     const resolvedUris = /* @__PURE__ */ new Set();
@@ -2847,8 +4375,8 @@ var AnnotationContext = class {
     if (resolvedUris.size === 0) {
       return annotations;
     }
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
+    const basePath = config2.services.filesystem.path;
+    const projectRoot = config2._metadata?.projectRoot;
     const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
     const metadataPromises = Array.from(resolvedUris).map(async (uri) => {
       const docId = uri.split("/resources/")[1];
@@ -2898,8 +4426,8 @@ var AnnotationContext = class {
    * Get resource stats (version info)
    * @returns Version and timestamp info for the annotations
    */
-  static async getResourceStats(resourceId3, config) {
-    const annotations = await this.getResourceAnnotations(resourceId3, config);
+  static async getResourceStats(resourceId3, config2) {
+    const annotations = await this.getResourceAnnotations(resourceId3, config2);
     return {
       resourceId: annotations.resourceId,
       version: annotations.version,
@@ -2909,12 +4437,12 @@ var AnnotationContext = class {
   /**
    * Check if resource exists in view storage
    */
-  static async resourceExists(resourceId3, config) {
-    if (!config.services?.filesystem?.path) {
+  static async resourceExists(resourceId3, config2) {
+    if (!config2.services?.filesystem?.path) {
       throw new Error("Filesystem path not found in configuration");
     }
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
+    const basePath = config2.services.filesystem.path;
+    const projectRoot = config2._metadata?.projectRoot;
     const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
     return await viewStorage.exists(resourceId3);
   }
@@ -2922,8 +4450,8 @@ var AnnotationContext = class {
    * Get a single annotation by ID
    * O(1) lookup using resource ID to access view storage
    */
-  static async getAnnotation(annotationId3, resourceId3, config) {
-    const annotations = await this.getResourceAnnotations(resourceId3, config);
+  static async getAnnotation(annotationId3, resourceId3, config2) {
+    const annotations = await this.getResourceAnnotations(resourceId3, config2);
     return annotations.annotations.find((a) => {
       const shortId = a.id.split("/").pop();
       return shortId === annotationId3;
@@ -2934,26 +4462,26 @@ var AnnotationContext = class {
    * @param filters - Optional filters like resourceId and type
    * @throws Error if resourceId not provided (cross-resource queries not supported in view storage)
    */
-  static async listAnnotations(filters, config) {
+  static async listAnnotations(filters, config2) {
     if (!filters?.resourceId) {
       throw new Error("resourceId is required for annotation listing - cross-resource queries not supported in view storage");
     }
-    return await this.getAllAnnotations(filters.resourceId, config);
+    return await this.getAllAnnotations(filters.resourceId, config2);
   }
   /**
    * Get annotation context (selected text with surrounding context)
    */
-  static async getAnnotationContext(annotationId3, resourceId3, contextBefore, contextAfter, config) {
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
+  static async getAnnotationContext(annotationId3, resourceId3, contextBefore, contextAfter, config2) {
+    const basePath = config2.services.filesystem.path;
+    const projectRoot = config2._metadata?.projectRoot;
     const repStore = new FilesystemRepresentationStore5({ basePath }, projectRoot);
-    const annotation = await this.getAnnotation(annotationId3, resourceId3, config);
+    const annotation = await this.getAnnotation(annotationId3, resourceId3, config2);
     if (!annotation) {
       throw new Error("Annotation not found");
     }
     const resource = await ResourceContext.getResourceMetadata(
       uriToResourceId(getTargetSource(annotation.target)),
-      config
+      config2
     );
     if (!resource) {
       throw new Error("Resource not found");
@@ -2979,17 +4507,17 @@ var AnnotationContext = class {
   /**
    * Generate AI summary of annotation in context
    */
-  static async generateAnnotationSummary(annotationId3, resourceId3, config, logger) {
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
+  static async generateAnnotationSummary(annotationId3, resourceId3, config2, logger) {
+    const basePath = config2.services.filesystem.path;
+    const projectRoot = config2._metadata?.projectRoot;
     const repStore = new FilesystemRepresentationStore5({ basePath }, projectRoot);
-    const annotation = await this.getAnnotation(annotationId3, resourceId3, config);
+    const annotation = await this.getAnnotation(annotationId3, resourceId3, config2);
     if (!annotation) {
       throw new Error("Annotation not found");
     }
     const resource = await ResourceContext.getResourceMetadata(
       uriToResourceId(getTargetSource(annotation.target)),
-      config
+      config2
     );
     if (!resource) {
       throw new Error("Resource not found");
@@ -2998,7 +4526,7 @@ var AnnotationContext = class {
     const contextSize = 500;
     const context = this.extractAnnotationContext(annotation, contentStr, contextSize, contextSize);
     const annotationEntityTypes = getEntityTypes2(annotation);
-    const summary = await this.generateSummary(resource, context, annotationEntityTypes, config, logger);
+    const summary = await this.generateSummary(resource, context, annotationEntityTypes, config2, logger);
     return {
       summary,
       relevantFields: {
@@ -3049,7 +4577,7 @@ var AnnotationContext = class {
    * Generate LLM summary of annotation in context
    * Creates inference client per-request (HTTP handler context)
    */
-  static async generateSummary(resource, context, entityTypes, config, logger) {
+  static async generateSummary(resource, context, entityTypes, config2, logger) {
     const summaryPrompt = `Summarize this text in context:
 
 Context before: "${context.before.substring(Math.max(0, context.before.length - 200))}"
@@ -3058,7 +4586,7 @@ Context after: "${context.after.substring(0, 200)}"
 
 Resource: ${resource.name}
 Entity types: ${entityTypes.join(", ")}`;
-    const client = await getInferenceClient2(config, logger);
+    const client = await getInferenceClient2(config2, logger);
     return await client.generateText(summaryPrompt, 500, 0.5);
   }
 };
@@ -3068,8 +4596,8 @@ var AnnotationOperations = class {
   /**
    * Create a new annotation
    */
-  static async createAnnotation(request, userId6, eventStore, config) {
-    const backendUrl = config.services.backend?.publicURL;
+  static async createAnnotation(request, userId6, eventStore, config2) {
+    const backendUrl = config2.services.backend?.publicURL;
     if (!backendUrl) {
       throw new Error("Backend publicURL not configured");
     }
@@ -3114,11 +4642,11 @@ var AnnotationOperations = class {
   /**
    * Update annotation body with operations (add/remove/replace)
    */
-  static async updateAnnotationBody(id, request, userId6, eventStore, config) {
+  static async updateAnnotationBody(id, request, userId6, eventStore, config2) {
     const annotation = await AnnotationContext.getAnnotation(
       annotationId2(id),
       uriToResourceId2(request.resourceId),
-      config
+      config2
     );
     if (!annotation) {
       throw new Error("Annotation not found");
@@ -3144,9 +4672,9 @@ var AnnotationOperations = class {
   /**
    * Delete an annotation
    */
-  static async deleteAnnotation(id, resourceIdUri, userId6, eventStore, config, logger) {
+  static async deleteAnnotation(id, resourceIdUri, userId6, eventStore, config2, logger) {
     const resourceId3 = uriToResourceId2(resourceIdUri);
-    const projection = await AnnotationContext.getResourceAnnotations(resourceId3, config);
+    const projection = await AnnotationContext.getResourceAnnotations(resourceId3, config2);
     const annotation = projection.annotations.find((a) => a.id === id);
     if (!annotation) {
       throw new Error("Annotation not found in resource");
@@ -3205,42 +4733,42 @@ var GraphContext = class {
    * Get all resources referencing this resource (backlinks)
    * Requires graph traversal - must use graph database
    */
-  static async getBacklinks(resourceId3, config) {
-    const graphDb = await getGraphDatabase2(config);
-    const resourceUri2 = resourceIdToURI6(resourceId3, config.services.backend.publicURL);
+  static async getBacklinks(resourceId3, config2) {
+    const graphDb = await getGraphDatabase2(config2);
+    const resourceUri2 = resourceIdToURI6(resourceId3, config2.services.backend.publicURL);
     return await graphDb.getResourceReferencedBy(resourceUri2);
   }
   /**
    * Find shortest path between two resources
    * Requires graph traversal - must use graph database
    */
-  static async findPath(fromResourceId, toResourceId, config, maxDepth) {
-    const graphDb = await getGraphDatabase2(config);
+  static async findPath(fromResourceId, toResourceId, config2, maxDepth) {
+    const graphDb = await getGraphDatabase2(config2);
     return await graphDb.findPath(fromResourceId, toResourceId, maxDepth);
   }
   /**
    * Get resource connections (graph edges)
    * Requires graph traversal - must use graph database
    */
-  static async getResourceConnections(resourceId3, config) {
-    const graphDb = await getGraphDatabase2(config);
+  static async getResourceConnections(resourceId3, config2) {
+    const graphDb = await getGraphDatabase2(config2);
     return await graphDb.getResourceConnections(resourceId3);
   }
   /**
    * Search resources by name (cross-resource query)
    * Requires full-text search - must use graph database
    */
-  static async searchResources(query, config, limit) {
-    const graphDb = await getGraphDatabase2(config);
+  static async searchResources(query, config2, limit) {
+    const graphDb = await getGraphDatabase2(config2);
     return await graphDb.searchResources(query, limit);
   }
   /**
    * Build graph representation with nodes and edges for a resource and its connections
    * Retrieves connections from graph and builds visualization-ready structure
    */
-  static async buildGraphRepresentation(resourceId3, maxRelated, config) {
-    const graphDb = await getGraphDatabase2(config);
-    const publicURL = config.services.backend.publicURL;
+  static async buildGraphRepresentation(resourceId3, maxRelated, config2) {
+    const graphDb = await getGraphDatabase2(config2);
+    const publicURL = config2.services.backend.publicURL;
     const resourceUri2 = resourceIdToURI6(resourceId3, publicURL);
     const mainDoc = await graphDb.getResource(resourceUri2);
     if (!mainDoc) {
@@ -3280,22 +4808,22 @@ var LLMContext = class {
    * Get comprehensive LLM context for a resource
    * Includes: main resource, related resources, annotations, graph, content, summary, references
    */
-  static async getResourceContext(resourceId3, options, config, inferenceClient) {
-    const mainDoc = await ResourceContext.getResourceMetadata(resourceId3, config);
+  static async getResourceContext(resourceId3, options, config2, inferenceClient) {
+    const mainDoc = await ResourceContext.getResourceMetadata(resourceId3, config2);
     if (!mainDoc) {
       throw new Error("Resource not found");
     }
-    const mainContent = options.includeContent ? await ResourceContext.getResourceContent(mainDoc, config) : void 0;
+    const mainContent = options.includeContent ? await ResourceContext.getResourceContent(mainDoc, config2) : void 0;
     const graph = await GraphContext.buildGraphRepresentation(
       resourceId3,
       options.maxResources,
-      config
+      config2
     );
     const relatedDocs = [];
     const resourceIdStr = resourceId3.toString();
     for (const node of graph.nodes) {
       if (node.id !== resourceIdStr) {
-        const relatedDoc = await ResourceContext.getResourceMetadata(makeResourceId2(node.id), config);
+        const relatedDoc = await ResourceContext.getResourceMetadata(makeResourceId2(node.id), config2);
         if (relatedDoc) {
           relatedDocs.push(relatedDoc);
         }
@@ -3307,14 +4835,14 @@ var LLMContext = class {
         relatedDocs.map(async (doc) => {
           const docId = getResourceId2(doc);
           if (!docId) return;
-          const content = await ResourceContext.getResourceContent(doc, config);
+          const content = await ResourceContext.getResourceContent(doc, config2);
           if (content) {
             relatedResourcesContent[docId] = content;
           }
         })
       );
     }
-    const annotations = await AnnotationContext.getAllAnnotations(resourceId3, config);
+    const annotations = await AnnotationContext.getAllAnnotations(resourceId3, config2);
     const summary = options.includeSummary && mainContent ? await generateResourceSummary(
       mainDoc.name,
       mainContent,
@@ -3837,12 +5365,12 @@ var AnnotationDetection = class {
    * @param density - Optional target number of comments per 2000 words
    * @returns Array of validated comment matches
    */
-  static async detectComments(resourceId3, config, client, instructions, tone, density) {
-    const resource = await ResourceContext.getResourceMetadata(resourceId3, config);
+  static async detectComments(resourceId3, config2, client, instructions, tone, density) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId3, config2);
     if (!resource) {
       throw new Error(`Resource ${resourceId3} not found`);
     }
-    const content = await this.loadResourceContent(resourceId3, config);
+    const content = await this.loadResourceContent(resourceId3, config2);
     if (!content) {
       throw new Error(`Could not load content for resource ${resourceId3}`);
     }
@@ -3866,12 +5394,12 @@ var AnnotationDetection = class {
    * @param density - Optional target number of highlights per 2000 words
    * @returns Array of validated highlight matches
    */
-  static async detectHighlights(resourceId3, config, client, instructions, density) {
-    const resource = await ResourceContext.getResourceMetadata(resourceId3, config);
+  static async detectHighlights(resourceId3, config2, client, instructions, density) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId3, config2);
     if (!resource) {
       throw new Error(`Resource ${resourceId3} not found`);
     }
-    const content = await this.loadResourceContent(resourceId3, config);
+    const content = await this.loadResourceContent(resourceId3, config2);
     if (!content) {
       throw new Error(`Could not load content for resource ${resourceId3}`);
     }
@@ -3896,12 +5424,12 @@ var AnnotationDetection = class {
    * @param density - Optional target number of assessments per 2000 words
    * @returns Array of validated assessment matches
    */
-  static async detectAssessments(resourceId3, config, client, instructions, tone, density) {
-    const resource = await ResourceContext.getResourceMetadata(resourceId3, config);
+  static async detectAssessments(resourceId3, config2, client, instructions, tone, density) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId3, config2);
     if (!resource) {
       throw new Error(`Resource ${resourceId3} not found`);
     }
-    const content = await this.loadResourceContent(resourceId3, config);
+    const content = await this.loadResourceContent(resourceId3, config2);
     if (!content) {
       throw new Error(`Could not load content for resource ${resourceId3}`);
     }
@@ -3925,7 +5453,7 @@ var AnnotationDetection = class {
    * @param category - The specific category to detect
    * @returns Array of validated tag matches
    */
-  static async detectTags(resourceId3, config, client, schemaId, category) {
+  static async detectTags(resourceId3, config2, client, schemaId, category) {
     const schema = getTagSchema2(schemaId);
     if (!schema) {
       throw new Error(`Invalid tag schema: ${schemaId}`);
@@ -3934,11 +5462,11 @@ var AnnotationDetection = class {
     if (!categoryInfo) {
       throw new Error(`Invalid category "${category}" for schema ${schemaId}`);
     }
-    const resource = await ResourceContext.getResourceMetadata(resourceId3, config);
+    const resource = await ResourceContext.getResourceMetadata(resourceId3, config2);
     if (!resource) {
       throw new Error(`Resource ${resourceId3} not found`);
     }
-    const content = await this.loadResourceContent(resourceId3, config);
+    const content = await this.loadResourceContent(resourceId3, config2);
     if (!content) {
       throw new Error(`Could not load content for resource ${resourceId3}`);
     }
@@ -3969,8 +5497,8 @@ var AnnotationDetection = class {
    * @param config - Environment configuration
    * @returns Resource content as string, or null if not available
    */
-  static async loadResourceContent(resourceId3, config) {
-    const resource = await ResourceContext.getResourceMetadata(resourceId3, config);
+  static async loadResourceContent(resourceId3, config2) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId3, config2);
     if (!resource) return null;
     const primaryRep = getPrimaryRepresentation4(resource);
     if (!primaryRep) return null;
@@ -3979,8 +5507,8 @@ var AnnotationDetection = class {
       return null;
     }
     if (!primaryRep.checksum || !primaryRep.mediaType) return null;
-    const basePath = config.services.filesystem.path;
-    const projectRoot = config._metadata?.projectRoot;
+    const basePath = config2.services.filesystem.path;
+    const projectRoot = config2._metadata?.projectRoot;
     const repStore = new FilesystemRepresentationStore6({ basePath }, projectRoot);
     const contentBuffer = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
     return decodeRepresentation4(contentBuffer, primaryRep.mediaType);
@@ -4019,4 +5547,22 @@ export {
   resetBootstrap,
   startMakeMeaning
 };
+/*! Bundled license information:
+
+tslib/tslib.es6.js:
+  (*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+  
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+  
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** *)
+*/
 //# sourceMappingURL=index.js.map