@kinotic-ai/core 1.0.0-beta.0

package/dist/index.js

@@ -0,0 +1,2565 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// node_modules/.bun/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js
+var require_Reflect = __commonJS(() => {
+  /*! *****************************************************************************
+  Copyright (C) Microsoft. All rights reserved.
+  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of the
+  License at http://www.apache.org/licenses/LICENSE-2.0
+  
+  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+  MERCHANTABLITY OR NON-INFRINGEMENT.
+  
+  See the Apache Version 2.0 License for specific language governing permissions
+  and limitations under the License.
+  ***************************************************************************** */
+  var Reflect2;
+  (function(Reflect3) {
+    (function(factory) {
+      var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
+      var exporter = makeExporter(Reflect3);
+      if (typeof root.Reflect !== "undefined") {
+        exporter = makeExporter(root.Reflect, exporter);
+      }
+      factory(exporter, root);
+      if (typeof root.Reflect === "undefined") {
+        root.Reflect = Reflect3;
+      }
+      function makeExporter(target, previous) {
+        return function(key, value) {
+          Object.defineProperty(target, key, { configurable: true, writable: true, value });
+          if (previous)
+            previous(key, value);
+        };
+      }
+      function functionThis() {
+        try {
+          return Function("return this;")();
+        } catch (_) {}
+      }
+      function indirectEvalThis() {
+        try {
+          return (undefined, eval)("(function() { return this; })()");
+        } catch (_) {}
+      }
+      function sloppyModeThis() {
+        return functionThis() || indirectEvalThis();
+      }
+    })(function(exporter, root) {
+      var hasOwn = Object.prototype.hasOwnProperty;
+      var supportsSymbol = typeof Symbol === "function";
+      var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+      var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+      var supportsCreate = typeof Object.create === "function";
+      var supportsProto = { __proto__: [] } instanceof Array;
+      var downLevel = !supportsCreate && !supportsProto;
+      var HashMap = {
+        create: supportsCreate ? function() {
+          return MakeDictionary(Object.create(null));
+        } : supportsProto ? function() {
+          return MakeDictionary({ __proto__: null });
+        } : function() {
+          return MakeDictionary({});
+        },
+        has: downLevel ? function(map2, key) {
+          return hasOwn.call(map2, key);
+        } : function(map2, key) {
+          return key in map2;
+        },
+        get: downLevel ? function(map2, key) {
+          return hasOwn.call(map2, key) ? map2[key] : undefined;
+        } : function(map2, key) {
+          return map2[key];
+        }
+      };
+      var functionPrototype = Object.getPrototypeOf(Function);
+      var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
+      var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
+      var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
+      var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : undefined;
+      var metadataRegistry = GetOrCreateMetadataRegistry();
+      var metadataProvider = CreateMetadataProvider(metadataRegistry);
+      function decorate(decorators, target, propertyKey, attributes) {
+        if (!IsUndefined(propertyKey)) {
+          if (!IsArray(decorators))
+            throw new TypeError;
+          if (!IsObject(target))
+            throw new TypeError;
+          if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
+            throw new TypeError;
+          if (IsNull(attributes))
+            attributes = undefined;
+          propertyKey = ToPropertyKey(propertyKey);
+          return DecorateProperty(decorators, target, propertyKey, attributes);
+        } else {
+          if (!IsArray(decorators))
+            throw new TypeError;
+          if (!IsConstructor(target))
+            throw new TypeError;
+          return DecorateConstructor(decorators, target);
+        }
+      }
+      exporter("decorate", decorate);
+      function metadata(metadataKey, metadataValue) {
+        function decorator(target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError;
+          if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
+            throw new TypeError;
+          OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+        }
+        return decorator;
+      }
+      exporter("metadata", metadata);
+      function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+      }
+      exporter("defineMetadata", defineMetadata);
+      function hasMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryHasMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("hasMetadata", hasMetadata);
+      function hasOwnMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("hasOwnMetadata", hasOwnMetadata);
+      function getMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryGetMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("getMetadata", getMetadata);
+      function getOwnMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("getOwnMetadata", getOwnMetadata);
+      function getMetadataKeys(target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryMetadataKeys(target, propertyKey);
+      }
+      exporter("getMetadataKeys", getMetadataKeys);
+      function getOwnMetadataKeys(target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryOwnMetadataKeys(target, propertyKey);
+      }
+      exporter("getOwnMetadataKeys", getOwnMetadataKeys);
+      function deleteMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        var provider = GetMetadataProvider(target, propertyKey, false);
+        if (IsUndefined(provider))
+          return false;
+        return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("deleteMetadata", deleteMetadata);
+      function DecorateConstructor(decorators, target) {
+        for (var i = decorators.length - 1;i >= 0; --i) {
+          var decorator = decorators[i];
+          var decorated = decorator(target);
+          if (!IsUndefined(decorated) && !IsNull(decorated)) {
+            if (!IsConstructor(decorated))
+              throw new TypeError;
+            target = decorated;
+          }
+        }
+        return target;
+      }
+      function DecorateProperty(decorators, target, propertyKey, descriptor) {
+        for (var i = decorators.length - 1;i >= 0; --i) {
+          var decorator = decorators[i];
+          var decorated = decorator(target, propertyKey, descriptor);
+          if (!IsUndefined(decorated) && !IsNull(decorated)) {
+            if (!IsObject(decorated))
+              throw new TypeError;
+            descriptor = decorated;
+          }
+        }
+        return descriptor;
+      }
+      function OrdinaryHasMetadata(MetadataKey, O, P) {
+        var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+        if (hasOwn2)
+          return true;
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (!IsNull(parent))
+          return OrdinaryHasMetadata(MetadataKey, parent, P);
+        return false;
+      }
+      function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
+        var provider = GetMetadataProvider(O, P, false);
+        if (IsUndefined(provider))
+          return false;
+        return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
+      }
+      function OrdinaryGetMetadata(MetadataKey, O, P) {
+        var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+        if (hasOwn2)
+          return OrdinaryGetOwnMetadata(MetadataKey, O, P);
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (!IsNull(parent))
+          return OrdinaryGetMetadata(MetadataKey, parent, P);
+        return;
+      }
+      function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
+        var provider = GetMetadataProvider(O, P, false);
+        if (IsUndefined(provider))
+          return;
+        return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
+      }
+      function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
+        var provider = GetMetadataProvider(O, P, true);
+        provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
+      }
+      function OrdinaryMetadataKeys(O, P) {
+        var ownKeys = OrdinaryOwnMetadataKeys(O, P);
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (parent === null)
+          return ownKeys;
+        var parentKeys = OrdinaryMetadataKeys(parent, P);
+        if (parentKeys.length <= 0)
+          return ownKeys;
+        if (ownKeys.length <= 0)
+          return parentKeys;
+        var set = new _Set;
+        var keys = [];
+        for (var _i = 0, ownKeys_1 = ownKeys;_i < ownKeys_1.length; _i++) {
+          var key = ownKeys_1[_i];
+          var hasKey = set.has(key);
+          if (!hasKey) {
+            set.add(key);
+            keys.push(key);
+          }
+        }
+        for (var _a = 0, parentKeys_1 = parentKeys;_a < parentKeys_1.length; _a++) {
+          var key = parentKeys_1[_a];
+          var hasKey = set.has(key);
+          if (!hasKey) {
+            set.add(key);
+            keys.push(key);
+          }
+        }
+        return keys;
+      }
+      function OrdinaryOwnMetadataKeys(O, P) {
+        var provider = GetMetadataProvider(O, P, false);
+        if (!provider) {
+          return [];
+        }
+        return provider.OrdinaryOwnMetadataKeys(O, P);
+      }
+      function Type(x) {
+        if (x === null)
+          return 1;
+        switch (typeof x) {
+          case "undefined":
+            return 0;
+          case "boolean":
+            return 2;
+          case "string":
+            return 3;
+          case "symbol":
+            return 4;
+          case "number":
+            return 5;
+          case "object":
+            return x === null ? 1 : 6;
+          default:
+            return 6;
+        }
+      }
+      function IsUndefined(x) {
+        return x === undefined;
+      }
+      function IsNull(x) {
+        return x === null;
+      }
+      function IsSymbol(x) {
+        return typeof x === "symbol";
+      }
+      function IsObject(x) {
+        return typeof x === "object" ? x !== null : typeof x === "function";
+      }
+      function ToPrimitive(input, PreferredType) {
+        switch (Type(input)) {
+          case 0:
+            return input;
+          case 1:
+            return input;
+          case 2:
+            return input;
+          case 3:
+            return input;
+          case 4:
+            return input;
+          case 5:
+            return input;
+        }
+        var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
+        var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
+        if (exoticToPrim !== undefined) {
+          var result = exoticToPrim.call(input, hint);
+          if (IsObject(result))
+            throw new TypeError;
+          return result;
+        }
+        return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
+      }
+      function OrdinaryToPrimitive(O, hint) {
+        if (hint === "string") {
+          var toString_1 = O.toString;
+          if (IsCallable(toString_1)) {
+            var result = toString_1.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+          var valueOf = O.valueOf;
+          if (IsCallable(valueOf)) {
+            var result = valueOf.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+        } else {
+          var valueOf = O.valueOf;
+          if (IsCallable(valueOf)) {
+            var result = valueOf.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+          var toString_2 = O.toString;
+          if (IsCallable(toString_2)) {
+            var result = toString_2.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+        }
+        throw new TypeError;
+      }
+      function ToBoolean(argument) {
+        return !!argument;
+      }
+      function ToString(argument) {
+        return "" + argument;
+      }
+      function ToPropertyKey(argument) {
+        var key = ToPrimitive(argument, 3);
+        if (IsSymbol(key))
+          return key;
+        return ToString(key);
+      }
+      function IsArray(argument) {
+        return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
+      }
+      function IsCallable(argument) {
+        return typeof argument === "function";
+      }
+      function IsConstructor(argument) {
+        return typeof argument === "function";
+      }
+      function IsPropertyKey(argument) {
+        switch (Type(argument)) {
+          case 3:
+            return true;
+          case 4:
+            return true;
+          default:
+            return false;
+        }
+      }
+      function SameValueZero(x, y) {
+        return x === y || x !== x && y !== y;
+      }
+      function GetMethod(V, P) {
+        var func = V[P];
+        if (func === undefined || func === null)
+          return;
+        if (!IsCallable(func))
+          throw new TypeError;
+        return func;
+      }
+      function GetIterator(obj) {
+        var method = GetMethod(obj, iteratorSymbol);
+        if (!IsCallable(method))
+          throw new TypeError;
+        var iterator = method.call(obj);
+        if (!IsObject(iterator))
+          throw new TypeError;
+        return iterator;
+      }
+      function IteratorValue(iterResult) {
+        return iterResult.value;
+      }
+      function IteratorStep(iterator) {
+        var result = iterator.next();
+        return result.done ? false : result;
+      }
+      function IteratorClose(iterator) {
+        var f = iterator["return"];
+        if (f)
+          f.call(iterator);
+      }
+      function OrdinaryGetPrototypeOf(O) {
+        var proto = Object.getPrototypeOf(O);
+        if (typeof O !== "function" || O === functionPrototype)
+          return proto;
+        if (proto !== functionPrototype)
+          return proto;
+        var prototype = O.prototype;
+        var prototypeProto = prototype && Object.getPrototypeOf(prototype);
+        if (prototypeProto == null || prototypeProto === Object.prototype)
+          return proto;
+        var constructor = prototypeProto.constructor;
+        if (typeof constructor !== "function")
+          return proto;
+        if (constructor === O)
+          return proto;
+        return constructor;
+      }
+      function CreateMetadataRegistry() {
+        var fallback;
+        if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
+          fallback = CreateFallbackProvider(root.Reflect);
+        }
+        var first;
+        var second;
+        var rest;
+        var targetProviderMap = new _WeakMap;
+        var registry = {
+          registerProvider,
+          getProvider,
+          setProvider
+        };
+        return registry;
+        function registerProvider(provider) {
+          if (!Object.isExtensible(registry)) {
+            throw new Error("Cannot add provider to a frozen registry.");
+          }
+          switch (true) {
+            case fallback === provider:
+              break;
+            case IsUndefined(first):
+              first = provider;
+              break;
+            case first === provider:
+              break;
+            case IsUndefined(second):
+              second = provider;
+              break;
+            case second === provider:
+              break;
+            default:
+              if (rest === undefined)
+                rest = new _Set;
+              rest.add(provider);
+              break;
+          }
+        }
+        function getProviderNoCache(O, P) {
+          if (!IsUndefined(first)) {
+            if (first.isProviderFor(O, P))
+              return first;
+            if (!IsUndefined(second)) {
+              if (second.isProviderFor(O, P))
+                return first;
+              if (!IsUndefined(rest)) {
+                var iterator = GetIterator(rest);
+                while (true) {
+                  var next = IteratorStep(iterator);
+                  if (!next) {
+                    return;
+                  }
+                  var provider = IteratorValue(next);
+                  if (provider.isProviderFor(O, P)) {
+                    IteratorClose(iterator);
+                    return provider;
+                  }
+                }
+              }
+            }
+          }
+          if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
+            return fallback;
+          }
+          return;
+        }
+        function getProvider(O, P) {
+          var providerMap = targetProviderMap.get(O);
+          var provider;
+          if (!IsUndefined(providerMap)) {
+            provider = providerMap.get(P);
+          }
+          if (!IsUndefined(provider)) {
+            return provider;
+          }
+          provider = getProviderNoCache(O, P);
+          if (!IsUndefined(provider)) {
+            if (IsUndefined(providerMap)) {
+              providerMap = new _Map;
+              targetProviderMap.set(O, providerMap);
+            }
+            providerMap.set(P, provider);
+          }
+          return provider;
+        }
+        function hasProvider(provider) {
+          if (IsUndefined(provider))
+            throw new TypeError;
+          return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
+        }
+        function setProvider(O, P, provider) {
+          if (!hasProvider(provider)) {
+            throw new Error("Metadata provider not registered.");
+          }
+          var existingProvider = getProvider(O, P);
+          if (existingProvider !== provider) {
+            if (!IsUndefined(existingProvider)) {
+              return false;
+            }
+            var providerMap = targetProviderMap.get(O);
+            if (IsUndefined(providerMap)) {
+              providerMap = new _Map;
+              targetProviderMap.set(O, providerMap);
+            }
+            providerMap.set(P, provider);
+          }
+          return true;
+        }
+      }
+      function GetOrCreateMetadataRegistry() {
+        var metadataRegistry2;
+        if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+          metadataRegistry2 = root.Reflect[registrySymbol];
+        }
+        if (IsUndefined(metadataRegistry2)) {
+          metadataRegistry2 = CreateMetadataRegistry();
+        }
+        if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+          Object.defineProperty(root.Reflect, registrySymbol, {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: metadataRegistry2
+          });
+        }
+        return metadataRegistry2;
+      }
+      function CreateMetadataProvider(registry) {
+        var metadata2 = new _WeakMap;
+        var provider = {
+          isProviderFor: function(O, P) {
+            var targetMetadata = metadata2.get(O);
+            if (IsUndefined(targetMetadata))
+              return false;
+            return targetMetadata.has(P);
+          },
+          OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
+          OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
+          OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
+          OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
+          OrdinaryDeleteMetadata
+        };
+        metadataRegistry.registerProvider(provider);
+        return provider;
+        function GetOrCreateMetadataMap(O, P, Create) {
+          var targetMetadata = metadata2.get(O);
+          var createdTargetMetadata = false;
+          if (IsUndefined(targetMetadata)) {
+            if (!Create)
+              return;
+            targetMetadata = new _Map;
+            metadata2.set(O, targetMetadata);
+            createdTargetMetadata = true;
+          }
+          var metadataMap = targetMetadata.get(P);
+          if (IsUndefined(metadataMap)) {
+            if (!Create)
+              return;
+            metadataMap = new _Map;
+            targetMetadata.set(P, metadataMap);
+            if (!registry.setProvider(O, P, provider)) {
+              targetMetadata.delete(P);
+              if (createdTargetMetadata) {
+                metadata2.delete(O);
+              }
+              throw new Error("Wrong provider for target.");
+            }
+          }
+          return metadataMap;
+        }
+        function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined(metadataMap))
+            return false;
+          return ToBoolean(metadataMap.has(MetadataKey));
+        }
+        function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined(metadataMap))
+            return;
+          return metadataMap.get(MetadataKey);
+        }
+        function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, true);
+          metadataMap.set(MetadataKey, MetadataValue);
+        }
+        function OrdinaryOwnMetadataKeys2(O, P) {
+          var keys = [];
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined(metadataMap))
+            return keys;
+          var keysObj = metadataMap.keys();
+          var iterator = GetIterator(keysObj);
+          var k = 0;
+          while (true) {
+            var next = IteratorStep(iterator);
+            if (!next) {
+              keys.length = k;
+              return keys;
+            }
+            var nextValue = IteratorValue(next);
+            try {
+              keys[k] = nextValue;
+            } catch (e) {
+              try {
+                IteratorClose(iterator);
+              } finally {
+                throw e;
+              }
+            }
+            k++;
+          }
+        }
+        function OrdinaryDeleteMetadata(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined(metadataMap))
+            return false;
+          if (!metadataMap.delete(MetadataKey))
+            return false;
+          if (metadataMap.size === 0) {
+            var targetMetadata = metadata2.get(O);
+            if (!IsUndefined(targetMetadata)) {
+              targetMetadata.delete(P);
+              if (targetMetadata.size === 0) {
+                metadata2.delete(targetMetadata);
+              }
+            }
+          }
+          return true;
+        }
+      }
+      function CreateFallbackProvider(reflect) {
+        var { defineMetadata: defineMetadata2, hasOwnMetadata: hasOwnMetadata2, getOwnMetadata: getOwnMetadata2, getOwnMetadataKeys: getOwnMetadataKeys2, deleteMetadata: deleteMetadata2 } = reflect;
+        var metadataOwner = new _WeakMap;
+        var provider = {
+          isProviderFor: function(O, P) {
+            var metadataPropertySet = metadataOwner.get(O);
+            if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
+              return true;
+            }
+            if (getOwnMetadataKeys2(O, P).length) {
+              if (IsUndefined(metadataPropertySet)) {
+                metadataPropertySet = new _Set;
+                metadataOwner.set(O, metadataPropertySet);
+              }
+              metadataPropertySet.add(P);
+              return true;
+            }
+            return false;
+          },
+          OrdinaryDefineOwnMetadata: defineMetadata2,
+          OrdinaryHasOwnMetadata: hasOwnMetadata2,
+          OrdinaryGetOwnMetadata: getOwnMetadata2,
+          OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
+          OrdinaryDeleteMetadata: deleteMetadata2
+        };
+        return provider;
+      }
+      function GetMetadataProvider(O, P, Create) {
+        var registeredProvider = metadataRegistry.getProvider(O, P);
+        if (!IsUndefined(registeredProvider)) {
+          return registeredProvider;
+        }
+        if (Create) {
+          if (metadataRegistry.setProvider(O, P, metadataProvider)) {
+            return metadataProvider;
+          }
+          throw new Error("Illegal state.");
+        }
+        return;
+      }
+      function CreateMapPolyfill() {
+        var cacheSentinel = {};
+        var arraySentinel = [];
+        var MapIterator = function() {
+          function MapIterator2(keys, values, selector) {
+            this._index = 0;
+            this._keys = keys;
+            this._values = values;
+            this._selector = selector;
+          }
+          MapIterator2.prototype["@@iterator"] = function() {
+            return this;
+          };
+          MapIterator2.prototype[iteratorSymbol] = function() {
+            return this;
+          };
+          MapIterator2.prototype.next = function() {
+            var index = this._index;
+            if (index >= 0 && index < this._keys.length) {
+              var result = this._selector(this._keys[index], this._values[index]);
+              if (index + 1 >= this._keys.length) {
+                this._index = -1;
+                this._keys = arraySentinel;
+                this._values = arraySentinel;
+              } else {
+                this._index++;
+              }
+              return { value: result, done: false };
+            }
+            return { value: undefined, done: true };
+          };
+          MapIterator2.prototype.throw = function(error) {
+            if (this._index >= 0) {
+              this._index = -1;
+              this._keys = arraySentinel;
+              this._values = arraySentinel;
+            }
+            throw error;
+          };
+          MapIterator2.prototype.return = function(value) {
+            if (this._index >= 0) {
+              this._index = -1;
+              this._keys = arraySentinel;
+              this._values = arraySentinel;
+            }
+            return { value, done: true };
+          };
+          return MapIterator2;
+        }();
+        var Map2 = function() {
+          function Map3() {
+            this._keys = [];
+            this._values = [];
+            this._cacheKey = cacheSentinel;
+            this._cacheIndex = -2;
+          }
+          Object.defineProperty(Map3.prototype, "size", {
+            get: function() {
+              return this._keys.length;
+            },
+            enumerable: true,
+            configurable: true
+          });
+          Map3.prototype.has = function(key) {
+            return this._find(key, false) >= 0;
+          };
+          Map3.prototype.get = function(key) {
+            var index = this._find(key, false);
+            return index >= 0 ? this._values[index] : undefined;
+          };
+          Map3.prototype.set = function(key, value) {
+            var index = this._find(key, true);
+            this._values[index] = value;
+            return this;
+          };
+          Map3.prototype.delete = function(key) {
+            var index = this._find(key, false);
+            if (index >= 0) {
+              var size = this._keys.length;
+              for (var i = index + 1;i < size; i++) {
+                this._keys[i - 1] = this._keys[i];
+                this._values[i - 1] = this._values[i];
+              }
+              this._keys.length--;
+              this._values.length--;
+              if (SameValueZero(key, this._cacheKey)) {
+                this._cacheKey = cacheSentinel;
+                this._cacheIndex = -2;
+              }
+              return true;
+            }
+            return false;
+          };
+          Map3.prototype.clear = function() {
+            this._keys.length = 0;
+            this._values.length = 0;
+            this._cacheKey = cacheSentinel;
+            this._cacheIndex = -2;
+          };
+          Map3.prototype.keys = function() {
+            return new MapIterator(this._keys, this._values, getKey);
+          };
+          Map3.prototype.values = function() {
+            return new MapIterator(this._keys, this._values, getValue);
+          };
+          Map3.prototype.entries = function() {
+            return new MapIterator(this._keys, this._values, getEntry);
+          };
+          Map3.prototype["@@iterator"] = function() {
+            return this.entries();
+          };
+          Map3.prototype[iteratorSymbol] = function() {
+            return this.entries();
+          };
+          Map3.prototype._find = function(key, insert) {
+            if (!SameValueZero(this._cacheKey, key)) {
+              this._cacheIndex = -1;
+              for (var i = 0;i < this._keys.length; i++) {
+                if (SameValueZero(this._keys[i], key)) {
+                  this._cacheIndex = i;
+                  break;
+                }
+              }
+            }
+            if (this._cacheIndex < 0 && insert) {
+              this._cacheIndex = this._keys.length;
+              this._keys.push(key);
+              this._values.push(undefined);
+            }
+            return this._cacheIndex;
+          };
+          return Map3;
+        }();
+        return Map2;
+        function getKey(key, _) {
+          return key;
+        }
+        function getValue(_, value) {
+          return value;
+        }
+        function getEntry(key, value) {
+          return [key, value];
+        }
+      }
+      function CreateSetPolyfill() {
+        var Set2 = function() {
+          function Set3() {
+            this._map = new _Map;
+          }
+          Object.defineProperty(Set3.prototype, "size", {
+            get: function() {
+              return this._map.size;
+            },
+            enumerable: true,
+            configurable: true
+          });
+          Set3.prototype.has = function(value) {
+            return this._map.has(value);
+          };
+          Set3.prototype.add = function(value) {
+            return this._map.set(value, value), this;
+          };
+          Set3.prototype.delete = function(value) {
+            return this._map.delete(value);
+          };
+          Set3.prototype.clear = function() {
+            this._map.clear();
+          };
+          Set3.prototype.keys = function() {
+            return this._map.keys();
+          };
+          Set3.prototype.values = function() {
+            return this._map.keys();
+          };
+          Set3.prototype.entries = function() {
+            return this._map.entries();
+          };
+          Set3.prototype["@@iterator"] = function() {
+            return this.keys();
+          };
+          Set3.prototype[iteratorSymbol] = function() {
+            return this.keys();
+          };
+          return Set3;
+        }();
+        return Set2;
+      }
+      function CreateWeakMapPolyfill() {
+        var UUID_SIZE = 16;
+        var keys = HashMap.create();
+        var rootKey = CreateUniqueKey();
+        return function() {
+          function WeakMap2() {
+            this._key = CreateUniqueKey();
+          }
+          WeakMap2.prototype.has = function(target) {
+            var table = GetOrCreateWeakMapTable(target, false);
+            return table !== undefined ? HashMap.has(table, this._key) : false;
+          };
+          WeakMap2.prototype.get = function(target) {
+            var table = GetOrCreateWeakMapTable(target, false);
+            return table !== undefined ? HashMap.get(table, this._key) : undefined;
+          };
+          WeakMap2.prototype.set = function(target, value) {
+            var table = GetOrCreateWeakMapTable(target, true);
+            table[this._key] = value;
+            return this;
+          };
+          WeakMap2.prototype.delete = function(target) {
+            var table = GetOrCreateWeakMapTable(target, false);
+            return table !== undefined ? delete table[this._key] : false;
+          };
+          WeakMap2.prototype.clear = function() {
+            this._key = CreateUniqueKey();
+          };
+          return WeakMap2;
+        }();
+        function CreateUniqueKey() {
+          var key;
+          do
+            key = "@@WeakMap@@" + CreateUUID();
+          while (HashMap.has(keys, key));
+          keys[key] = true;
+          return key;
+        }
+        function GetOrCreateWeakMapTable(target, create) {
+          if (!hasOwn.call(target, rootKey)) {
+            if (!create)
+              return;
+            Object.defineProperty(target, rootKey, { value: HashMap.create() });
+          }
+          return target[rootKey];
+        }
+        function FillRandomBytes(buffer, size) {
+          for (var i = 0;i < size; ++i)
+            buffer[i] = Math.random() * 255 | 0;
+          return buffer;
+        }
+        function GenRandomBytes(size) {
+          if (typeof Uint8Array === "function") {
+            var array = new Uint8Array(size);
+            if (typeof crypto !== "undefined") {
+              crypto.getRandomValues(array);
+            } else if (typeof msCrypto !== "undefined") {
+              msCrypto.getRandomValues(array);
+            } else {
+              FillRandomBytes(array, size);
+            }
+            return array;
+          }
+          return FillRandomBytes(new Array(size), size);
+        }
+        function CreateUUID() {
+          var data = GenRandomBytes(UUID_SIZE);
+          data[6] = data[6] & 79 | 64;
+          data[8] = data[8] & 191 | 128;
+          var result = "";
+          for (var offset = 0;offset < UUID_SIZE; ++offset) {
+            var byte = data[offset];
+            if (offset === 4 || offset === 6 || offset === 8)
+              result += "-";
+            if (byte < 16)
+              result += "0";
+            result += byte.toString(16).toLowerCase();
+          }
+          return result;
+        }
+      }
+      function MakeDictionary(obj) {
+        obj.__ = undefined;
+        delete obj.__;
+        return obj;
+      }
+    });
+  })(Reflect2 || (Reflect2 = {}));
+});
+
+// packages/core/src/api/ConnectionInfo.ts
+class ConnectHeaders {
+}
+
+class ServerInfo {
+  host;
+  port;
+  useSSL;
+}
+
+class ConnectionInfo extends ServerInfo {
+  connectHeaders;
+  maxConnectionAttempts;
+  disableStickySession;
+}
+// packages/core/src/core/api/crud/AbstractIterablePage.ts
+class AbstractIterablePage {
+  pageable;
+  currentPage;
+  firstPage = true;
+  constructor(pageable, page) {
+    this.pageable = pageable;
+    this.currentPage = page;
+  }
+  async next() {
+    let ret;
+    if (this.firstPage) {
+      this.firstPage = false;
+      ret = { done: !this.hasContent(), value: this };
+    } else {
+      if (this.isOffsetPageable()) {
+        const offsetPageable = this.pageable;
+        offsetPageable.pageNumber++;
+        const numPages = Math.ceil(this.totalElements / this.pageable.pageSize);
+        if (offsetPageable.pageNumber < numPages) {
+          this.currentPage = await this.findNext(this.pageable);
+          ret = { done: false, value: this };
+        } else {
+          ret = { done: true, value: this };
+        }
+      } else {
+        const cursorPageable = this.pageable;
+        cursorPageable.cursor = this.currentPage.cursor || null;
+        this.currentPage = await this.findNext(this.pageable);
+        ret = { done: this.isLastPage(), value: this };
+      }
+    }
+    return ret;
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  hasContent() {
+    return this.currentPage.content !== null && this.currentPage.content !== undefined && this.currentPage.content.length > 0;
+  }
+  isLastPage() {
+    let ret;
+    if (this.isOffsetPageable()) {
+      const numPages = Math.ceil(this.totalElements / this.pageable.pageSize);
+      ret = numPages === this.pageable.pageNumber + 1;
+    } else {
+      ret = !this.firstPage && this.currentPage.cursor === null;
+    }
+    return ret;
+  }
+  isOffsetPageable() {
+    return this.pageable.pageNumber !== undefined;
+  }
+  get totalElements() {
+    return this.currentPage.totalElements;
+  }
+  get cursor() {
+    return this.currentPage.cursor;
+  }
+  get content() {
+    return this.currentPage.content;
+  }
+}
+
+// packages/core/src/internal/core/api/crud/FindAllIterablePage.ts
+class FindAllIterablePage extends AbstractIterablePage {
+  crudServiceProxy;
+  constructor(pageable, page, crudServiceProxy) {
+    super(pageable, page);
+    this.crudServiceProxy = crudServiceProxy;
+  }
+  findNext(pageable) {
+    return this.crudServiceProxy.findAllSinglePage(pageable);
+  }
+}
+
+// packages/core/src/internal/core/api/crud/SearchIterablePage.ts
+class SearchIterablePage extends AbstractIterablePage {
+  searchText;
+  crudServiceProxy;
+  constructor(pageable, page, searchText, crudServiceProxy) {
+    super(pageable, page);
+    this.searchText = searchText;
+    this.crudServiceProxy = crudServiceProxy;
+  }
+  findNext(pageable) {
+    return this.crudServiceProxy.searchSinglePage(this.searchText, pageable);
+  }
+}
+
+// packages/core/src/core/api/crud/CrudServiceProxy.ts
+class CrudServiceProxy {
+  serviceProxy;
+  constructor(serviceProxy) {
+    this.serviceProxy = serviceProxy;
+  }
+  count() {
+    return this.serviceProxy.invoke("count");
+  }
+  create(entity) {
+    return this.serviceProxy.invoke("create", [entity]);
+  }
+  deleteById(id) {
+    return this.serviceProxy.invoke("deleteById", [id]);
+  }
+  async findAll(pageable) {
+    const page = await this.findAllSinglePage(pageable);
+    return new FindAllIterablePage(pageable, page, this);
+  }
+  findAllSinglePage(pageable) {
+    return this.serviceProxy.invoke("findAll", [pageable]);
+  }
+  findById(id) {
+    return this.serviceProxy.invoke("findById", [id]);
+  }
+  save(entity) {
+    return this.serviceProxy.invoke("save", [entity]);
+  }
+  findByIdNotIn(ids, page) {
+    return this.serviceProxy.invoke("findByIdNotIn", [ids, page]);
+  }
+  async search(searchText, pageable) {
+    const page = await this.searchSinglePage(searchText, pageable);
+    return new SearchIterablePage(pageable, page, searchText, this);
+  }
+  searchSinglePage(searchText, pageable) {
+    return this.serviceProxy.invoke("search", [searchText, pageable]);
+  }
+}
+
+// packages/core/src/core/api/crud/CrudServiceProxyFactory.ts
+class CrudServiceProxyFactory {
+  serviceRegistry;
+  constructor(serviceRegistry) {
+    this.serviceRegistry = serviceRegistry;
+  }
+  crudServiceProxy(serviceIdentifier) {
+    if (typeof serviceIdentifier === "undefined" || serviceIdentifier.length === 0) {
+      throw new Error("The serviceIdentifier provided must contain a value");
+    }
+    return new CrudServiceProxy(this.serviceRegistry.serviceProxy(serviceIdentifier));
+  }
+}
+
+// packages/core/src/api/errors/KinoticError.ts
+class KinoticError extends Error {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, KinoticError.prototype);
+  }
+}
+
+// packages/core/src/core/api/IEventBus.ts
+var EventConstants;
+((EventConstants2) => {
+  EventConstants2["CONTENT_TYPE_HEADER"] = "content-type";
+  EventConstants2["CONTENT_LENGTH_HEADER"] = "content-length";
+  EventConstants2["REPLY_TO_HEADER"] = "reply-to";
+  EventConstants2["REPLY_TO_ID_HEADER"] = "reply-to-id";
+  EventConstants2["SESSION_HEADER"] = "session";
+  EventConstants2["CONNECTED_INFO_HEADER"] = "connected-info";
+  EventConstants2["DISABLE_STICKY_SESSION_HEADER"] = "disable-sticky-session";
+  EventConstants2["CORRELATION_ID_HEADER"] = "__correlation-id";
+  EventConstants2["ERROR_HEADER"] = "error";
+  EventConstants2["COMPLETE_HEADER"] = "complete";
+  EventConstants2["CONTROL_HEADER"] = "control";
+  EventConstants2["CONTROL_VALUE_COMPLETE"] = "complete";
+  EventConstants2["CONTROL_VALUE_CANCEL"] = "cancel";
+  EventConstants2["CONTROL_VALUE_SUSPEND"] = "suspend";
+  EventConstants2["CONTROL_VALUE_RESUME"] = "resume";
+  EventConstants2["SERVICE_DESTINATION_PREFIX"] = "srv://";
+  EventConstants2["SERVICE_DESTINATION_SCHEME"] = "srv";
+  EventConstants2["STREAM_DESTINATION_PREFIX"] = "stream://";
+  EventConstants2["STREAM_DESTINATION_SCHEME"] = "stream";
+  EventConstants2["CONTENT_JSON"] = "application/json";
+  EventConstants2["CONTENT_TEXT"] = "text/plain";
+  EventConstants2["TRACEPARENT_HEADER"] = "traceparent";
+  EventConstants2["TRACESTATE_HEADER"] = "tracestate";
+})(EventConstants ||= {});
+
+// packages/core/src/core/api/StompConnectionManager.ts
+import { RxStomp } from "@stomp/rx-stomp";
+import { ReconnectionTimeMode } from "@stomp/stompjs";
+import { v4 as uuidv4 } from "uuid";
+import debug from "debug";
+
+class StompConnectionManager {
+  lastWebsocketError = null;
+  maxConnectionAttemptsReached = false;
+  rxStomp = null;
+  INITIAL_RECONNECT_DELAY = 2000;
+  MAX_RECONNECT_DELAY = 120000;
+  JITTER_MAX = 5000;
+  connectionAttempts = 0;
+  initialConnectionSuccessful = false;
+  debugLogger = debug("kinoitc:stomp");
+  uuidv4 = uuidv4();
+  replyToId = uuidv4();
+  _replyToCri = "srv://" /* SERVICE_DESTINATION_PREFIX */ + this.replyToId + ":" + this.uuidv4 + "@kinoitc.js.EventBus/replyHandler";
+  deactivationHandler = null;
+  get active() {
+    return !!this.rxStomp;
+  }
+  get replyToCri() {
+    return this._replyToCri;
+  }
+  get connected() {
+    return this.rxStomp != null && this.rxStomp.connected();
+  }
+  activate(connectionInfo) {
+    return new Promise((resolve, reject) => {
+      if (!connectionInfo) {
+        reject("You must supply a valid connectionInfo object");
+        return;
+      }
+      if (!connectionInfo.host) {
+        reject("No host provided");
+        return;
+      }
+      if (this.rxStomp) {
+        reject("Stomp connection already active");
+        return;
+      }
+      this.connectionAttempts = 0;
+      this.initialConnectionSuccessful = false;
+      this.lastWebsocketError = null;
+      this.maxConnectionAttemptsReached = false;
+      const url = "ws" + (connectionInfo.useSSL ? "s" : "") + "://" + connectionInfo.host + (connectionInfo.port ? ":" + connectionInfo.port : "") + "/v1";
+      this.rxStomp = new RxStomp;
+      let connectHeadersInternal = typeof connectionInfo.connectHeaders !== "function" && connectionInfo.connectHeaders != null ? connectionInfo.connectHeaders : {};
+      const stompConfig = {
+        brokerURL: url,
+        connectHeaders: connectHeadersInternal,
+        heartbeatIncoming: 120000,
+        heartbeatOutgoing: 30000,
+        reconnectDelay: this.INITIAL_RECONNECT_DELAY,
+        beforeConnect: async () => {
+          if (typeof connectionInfo.connectHeaders === "function") {
+            const headers = await connectionInfo.connectHeaders();
+            for (const key in headers) {
+              connectHeadersInternal[key] = headers[key];
+            }
+          }
+          if (connectionInfo.disableStickySession) {
+            connectHeadersInternal["disable-sticky-session" /* DISABLE_STICKY_SESSION_HEADER */] = "true";
+          }
+          if (connectHeadersInternal["reply-to-id" /* REPLY_TO_ID_HEADER */]) {
+            this.replyToId = connectHeadersInternal["reply-to-id" /* REPLY_TO_ID_HEADER */];
+            this._replyToCri = "srv://" /* SERVICE_DESTINATION_PREFIX */ + this.replyToId + ":" + this.uuidv4 + "@kinoitc.js.EventBus/replyHandler";
+          } else {
+            connectHeadersInternal["reply-to-id" /* REPLY_TO_ID_HEADER */] = this.replyToId;
+          }
+          if (connectionInfo?.maxConnectionAttempts) {
+            this.connectionAttempts++;
+            if (this.connectionAttempts > connectionInfo.maxConnectionAttempts) {
+              this.maxConnectionAttemptsReached = true;
+              await this.deactivate();
+              if (!this.initialConnectionSuccessful) {
+                let message = this.lastWebsocketError?.message ? this.lastWebsocketError?.message : "UNKNOWN";
+                reject(`Max number of reconnection attempts reached. Last WS Error ${message}`);
+              }
+            } else {
+              await this.connectionJitterDelay();
+            }
+          } else {
+            await this.connectionJitterDelay();
+          }
+        }
+      };
+      if (this.debugLogger.enabled) {
+        stompConfig.debug = (msg) => {
+          this.debugLogger(msg);
+        };
+      }
+      this.rxStomp.configure(stompConfig);
+      this.rxStomp.stompClient.maxReconnectDelay = this.MAX_RECONNECT_DELAY;
+      this.rxStomp.stompClient.reconnectTimeMode = ReconnectionTimeMode.EXPONENTIAL;
+      this.rxStomp.webSocketErrors$.subscribe((value) => {
+        this.lastWebsocketError = value;
+      });
+      const connectedSubscription = this.rxStomp.connected$.subscribe(() => {
+        connectedSubscription.unsubscribe();
+        if (!this.initialConnectionSuccessful) {
+          this.initialConnectionSuccessful = true;
+        }
+      });
+      const errorSubscription = this.rxStomp.stompErrors$.subscribe((value) => {
+        errorSubscription.unsubscribe();
+        const message = value.headers["message"];
+        this.rxStomp?.deactivate();
+        this.rxStomp = null;
+        reject(message);
+      });
+      const serverHeadersSubscription = this.rxStomp.serverHeaders$.subscribe((value) => {
+        let connectedInfoJson = value["connected-info" /* CONNECTED_INFO_HEADER */];
+        if (connectedInfoJson != null) {
+          const connectedInfo = JSON.parse(connectedInfoJson);
+          if (!connectionInfo.disableStickySession) {
+            serverHeadersSubscription.unsubscribe();
+            if (connectedInfo.sessionId != null && connectedInfo.replyToId != null) {
+              if (connectionInfo.connectHeaders != null) {
+                for (let key in connectHeadersInternal) {
+                  delete connectHeadersInternal[key];
+                }
+              }
+              connectHeadersInternal["session" /* SESSION_HEADER */] = connectedInfo.sessionId;
+              resolve(connectedInfo);
+            } else {
+              reject("Server did not return proper data for successful login");
+            }
+          } else if (typeof connectionInfo.connectHeaders === "function") {
+            for (let key in connectHeadersInternal) {
+              delete connectHeadersInternal[key];
+            }
+            if (!this.initialConnectionSuccessful) {
+              resolve(connectedInfo);
+            }
+          } else if (typeof connectionInfo.connectHeaders === "object") {
+            serverHeadersSubscription.unsubscribe();
+            resolve(connectedInfo);
+          }
+        } else {
+          reject("Server did not return proper data for successful login");
+        }
+      });
+      this.rxStomp.activate();
+    });
+  }
+  async deactivate(force) {
+    if (this.rxStomp) {
+      await this.rxStomp.deactivate({ force });
+      if (this.deactivationHandler) {
+        this.deactivationHandler();
+      }
+      this.rxStomp = null;
+    }
+    return;
+  }
+  async connectionJitterDelay() {
+    if (this.initialConnectionSuccessful) {
+      const randomJitter = Math.random() * this.JITTER_MAX;
+      this.debugLogger(`Adding ${randomJitter}ms of jitter delay`);
+      return new Promise((resolve) => setTimeout(resolve, randomJitter));
+    }
+  }
+}
+
+// packages/core/src/core/api/EventBus.ts
+import { context, propagation } from "@opentelemetry/api";
+import { firstValueFrom, Observable, Subject, throwError } from "rxjs";
+import { filter, map, multicast } from "rxjs/operators";
+import { Optional } from "typescript-optional";
+import { v4 as uuidv42 } from "uuid";
+class Event {
+  cri;
+  headers;
+  data;
+  constructor(cri, headers, data) {
+    this.cri = cri;
+    if (headers !== undefined) {
+      this.headers = headers;
+    } else {
+      this.headers = new Map;
+    }
+    this.data = Optional.ofNullable(data);
+  }
+  getHeader(key) {
+    return this.headers.get(key);
+  }
+  hasHeader(key) {
+    return this.headers.has(key);
+  }
+  setHeader(key, value) {
+    this.headers.set(key, value);
+  }
+  removeHeader(key) {
+    return this.headers.delete(key);
+  }
+  setDataString(data) {
+    const uint8Array = new TextEncoder().encode(data);
+    this.data = Optional.ofNonNull(uint8Array);
+  }
+  getDataString() {
+    let ret = "";
+    this.data.ifPresent((value) => ret = new TextDecoder().decode(value));
+    return ret;
+  }
+}
+
+class EventBus {
+  fatalErrors;
+  serverInfo = null;
+  stompConnectionManager = new StompConnectionManager;
+  replyToCri = null;
+  requestRepliesObservable = null;
+  requestRepliesSubject = null;
+  requestRepliesSubscription = null;
+  errorSubject = new Subject;
+  errorSubjectSubscription = null;
+  constructor() {
+    this.fatalErrors = this.errorSubject.pipe(map((frame) => {
+      this.disconnect().catch((error) => {
+        if (console) {
+          console.error("Error disconnecting from Stomp: " + error);
+        }
+      });
+      return new KinoticError(frame.headers["message"]);
+    }));
+    this.stompConnectionManager.deactivationHandler = () => {
+      this.cleanup();
+    };
+  }
+  isConnectionActive() {
+    return this.stompConnectionManager.active;
+  }
+  isConnected() {
+    return this.stompConnectionManager.connected;
+  }
+  async connect(connectionInfo) {
+    if (!this.stompConnectionManager.active) {
+      this.cleanup();
+      const connectedInfo = await this.stompConnectionManager.activate(connectionInfo);
+      this.serverInfo = new ServerInfo;
+      this.serverInfo.host = connectionInfo.host;
+      this.serverInfo.port = connectionInfo.port;
+      this.serverInfo.useSSL = connectionInfo.useSSL;
+      this.replyToCri = this.stompConnectionManager.replyToCri;
+      this.errorSubjectSubscription = this.stompConnectionManager.rxStomp?.stompErrors$.subscribe(this.errorSubject);
+      return connectedInfo;
+    } else {
+      throw new Error("Event Bus connection already active");
+    }
+  }
+  async disconnect(force) {
+    await this.stompConnectionManager.deactivate(force);
+    this.cleanup();
+  }
+  send(event) {
+    if (this.stompConnectionManager.rxStomp) {
+      const headers = {};
+      for (const [key, value] of event.headers.entries()) {
+        headers[key] = value;
+      }
+      const carrier = {};
+      propagation.inject(context.active(), carrier);
+      if (carrier.traceparent) {
+        headers["traceparent" /* TRACEPARENT_HEADER */] = carrier.traceparent;
+      }
+      if (carrier.tracestate) {
+        headers["tracestate" /* TRACESTATE_HEADER */] = carrier.tracestate;
+      }
+      this.stompConnectionManager.rxStomp.publish({
+        destination: event.cri,
+        headers,
+        binaryBody: event.data.orUndefined()
+      });
+    } else {
+      throw this.createSendUnavailableError();
+    }
+  }
+  request(event) {
+    return firstValueFrom(this.requestStream(event, false));
+  }
+  requestStream(event, sendControlEvents = true) {
+    if (this.stompConnectionManager?.rxStomp) {
+      return new Observable((subscriber) => {
+        if (this.requestRepliesObservable == null) {
+          this.requestRepliesSubject = new Subject;
+          this.requestRepliesObservable = this._observe(this.replyToCri).pipe(multicast(this.requestRepliesSubject));
+          this.requestRepliesSubscription = this.requestRepliesObservable.connect();
+        }
+        let serverSignaledCompletion = false;
+        const correlationId = uuidv42();
+        const defaultMessagesSubscription = this.requestRepliesObservable.pipe(filter((value) => {
+          return value.headers.get("__correlation-id" /* CORRELATION_ID_HEADER */) === correlationId;
+        })).subscribe({
+          next(value) {
+            if (value.hasHeader("control" /* CONTROL_HEADER */)) {
+              if (value.headers.get("control" /* CONTROL_HEADER */) === "complete") {
+                serverSignaledCompletion = true;
+                subscriber.complete();
+              } else {
+                throw new Error("Control Header " + value.headers.get("control" /* CONTROL_HEADER */) + " is not supported");
+              }
+            } else if (value.hasHeader("error" /* ERROR_HEADER */)) {
+              serverSignaledCompletion = true;
+              subscriber.error(new Error(value.getHeader("error" /* ERROR_HEADER */)));
+            } else {
+              subscriber.next(value);
+            }
+          },
+          error(err) {
+            subscriber.error(err);
+          },
+          complete() {
+            subscriber.complete();
+          }
+        });
+        subscriber.add(defaultMessagesSubscription);
+        event.setHeader("reply-to" /* REPLY_TO_HEADER */, this.replyToCri);
+        event.setHeader("__correlation-id" /* CORRELATION_ID_HEADER */, correlationId);
+        this.send(event);
+        return () => {
+          if (sendControlEvents && !serverSignaledCompletion) {
+            const controlEvent = new Event(event.cri);
+            controlEvent.setHeader("control" /* CONTROL_HEADER */, "cancel" /* CONTROL_VALUE_CANCEL */);
+            controlEvent.setHeader("__correlation-id" /* CORRELATION_ID_HEADER */, correlationId);
+            this.send(controlEvent);
+          }
+        };
+      });
+    } else {
+      return throwError(() => this.createSendUnavailableError());
+    }
+  }
+  listen(_serverInfo) {
+    return Promise.reject("Not implemented");
+  }
+  observe(cri) {
+    return this._observe(cri);
+  }
+  cleanup() {
+    if (this.requestRepliesSubject != null) {
+      this.requestRepliesSubject.error(new Error("Connection disconnected"));
+      if (this.requestRepliesSubscription != null) {
+        this.requestRepliesSubscription.unsubscribe();
+        this.requestRepliesSubscription = null;
+      }
+      this.requestRepliesSubject = null;
+      this.requestRepliesObservable = null;
+    }
+    if (this.errorSubjectSubscription) {
+      this.errorSubjectSubscription.unsubscribe();
+      this.errorSubjectSubscription = null;
+    }
+    this.serverInfo = null;
+  }
+  createSendUnavailableError() {
+    let ret = "You must call connect on the event bus before sending any request";
+    if (this.stompConnectionManager.maxConnectionAttemptsReached) {
+      ret = "Max connection attempts reached event bus is not available";
+    }
+    return new Error(ret);
+  }
+  _observe(cri) {
+    if (this.stompConnectionManager?.rxStomp) {
+      return this.stompConnectionManager.rxStomp.watch(cri).pipe(map((message) => {
+        const headers = new Map;
+        let destination = "";
+        for (const prop of Object.keys(message.headers)) {
+          if (prop === "destination") {
+            destination = message.headers[prop];
+          } else {
+            headers.set(prop, message.headers[prop]);
+          }
+        }
+        return new Event(destination, headers, message.binaryBody);
+      }));
+    } else {
+      throw this.createSendUnavailableError();
+    }
+  }
+}
+
+// packages/core/src/core/api/ServiceRegistry.ts
+import debug2 from "debug";
+
+// packages/core/src/core/api/DefaultCRI.ts
+class DefaultCRI {
+  _scheme;
+  _scope;
+  _resourceName;
+  _path;
+  _version;
+  _raw;
+  constructor(...args) {
+    if (args.length === 1) {
+      const rawURC = args[0];
+      if (typeof rawURC !== "string") {
+        throw new Error("Raw URI must be a string");
+      }
+      const parsed = DefaultCRI.parseRaw(rawURC);
+      this._scheme = parsed.scheme;
+      this._scope = parsed.scope;
+      this._resourceName = parsed.resourceName;
+      this._path = parsed.path;
+      this._version = parsed.version;
+      this._raw = rawURC;
+    } else if (args.length === 5) {
+      const [scheme, scope, resourceName, path, version] = args;
+      this._scheme = scheme;
+      this._scope = scope;
+      this._resourceName = resourceName;
+      this._path = path;
+      this._version = version;
+      this._raw = DefaultCRI.buildRaw(scheme, scope, resourceName, path, version);
+    } else {
+      throw new Error("Invalid constructor arguments for DefaultCRI");
+    }
+    if (!this._scheme || !this._resourceName) {
+      throw new Error(`Invalid CRI: scheme and resourceName are required. Got: ${this._raw}`);
+    }
+  }
+  scheme() {
+    return this._scheme;
+  }
+  scope() {
+    return this._scope;
+  }
+  hasScope() {
+    return this._scope !== null;
+  }
+  resourceName() {
+    return this._resourceName;
+  }
+  version() {
+    return this._version;
+  }
+  hasVersion() {
+    return this._version !== null;
+  }
+  path() {
+    return this._path;
+  }
+  hasPath() {
+    return this._path !== null;
+  }
+  baseResource() {
+    let result = `${this._scheme}://`;
+    if (this.hasScope()) {
+      result += `${this._scope}@`;
+    }
+    result += this._resourceName;
+    return result;
+  }
+  raw() {
+    return this._raw;
+  }
+  equals(other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof DefaultCRI))
+      return false;
+    return this._raw === other.raw();
+  }
+  hashCode() {
+    let hash = 17;
+    hash = hash * 37 + this._raw.split("").reduce((a, c) => a + c.charCodeAt(0), 0);
+    return hash;
+  }
+  toString() {
+    return this._raw;
+  }
+  static parseRaw(raw) {
+    const regex = /^([^:]+):\/\/(?:([^@]+)@)?([^\/#]+)(\/[^#]*)?(?:#(.+))?$/;
+    const match = raw.match(regex);
+    if (!match) {
+      throw new Error(`Invalid CRI format: ${raw}`);
+    }
+    const [, scheme, scope, resourceName, path, version] = match;
+    return {
+      scheme,
+      scope: scope || null,
+      resourceName,
+      path: path ? path.substring(1) : null,
+      version: version || null
+    };
+  }
+  static buildRaw(scheme, scope, resourceName, path, version) {
+    let result = `${scheme}://`;
+    if (scope) {
+      result += `${scope}@`;
+    }
+    result += resourceName;
+    if (path) {
+      result += `/${path}`;
+    }
+    if (version) {
+      result += `#${version}`;
+    }
+    return result;
+  }
+}
+
+// packages/core/src/core/api/CRI.ts
+function createCRI(...args) {
+  if (args.length === 1)
+    return new DefaultCRI(args[0]);
+  if (args.length === 2)
+    return new DefaultCRI(args[0], null, args[1], null, null);
+  if (args.length === 3)
+    return new DefaultCRI(args[0], args[1], args[2], null, null);
+  if (args.length === 5)
+    return new DefaultCRI(args[0], args[1], args[2], args[3], args[4]);
+  throw new Error("Invalid arguments for createCRI");
+}
+
+// packages/core/src/internal/core/api/ArgumentResolver.ts
+class JsonArgumentResolver {
+  resolveArguments(event) {
+    if (this.containsJsonContent(event)) {
+      const data = event.getDataString();
+      return data ? JSON.parse(data) : [];
+    } else {
+      throw new Error("Currently only JSON content is supported");
+    }
+  }
+  containsJsonContent(event) {
+    const contentType = event.getHeader("content-type" /* CONTENT_TYPE_HEADER */);
+    return contentType != null && contentType !== "" && contentType === "application/json";
+  }
+}
+
+// packages/core/src/internal/core/api/EventUtil.ts
+class EventUtil {
+  static createReplyEvent(incomingHeaders, headers, body) {
+    if (!incomingHeaders) {
+      throw new Error("incomingHeaders cannot be null");
+    }
+    const replyCRI = incomingHeaders.get("reply-to" /* REPLY_TO_HEADER */);
+    if (!replyCRI || replyCRI.trim() === "") {
+      throw new Error("No reply-to header found, cannot create outgoing message");
+    }
+    const newHeaders = new Map;
+    for (const [key, value] of incomingHeaders) {
+      if (key.startsWith("__")) {
+        newHeaders.set(key, value);
+      }
+    }
+    if (headers) {
+      for (const [key, value] of headers) {
+        newHeaders.set(key, value);
+      }
+    }
+    return new Event(replyCRI, newHeaders, body || undefined);
+  }
+}
+
+// packages/core/src/internal/core/api/ReturnValueConverter.ts
+class BasicReturnValueConverter {
+  convert(incomingMetadata, returnValue) {
+    return EventUtil.createReplyEvent(incomingMetadata, new Map([["content-type" /* CONTENT_TYPE_HEADER */, "application/json"]]), new TextEncoder().encode(JSON.stringify(returnValue)));
+  }
+}
+
+// packages/core/src/internal/core/api/Logger.ts
+function createDebugLogger(namespace) {
+  let debug2;
+  try {
+    debug2 = __require("debug")(namespace);
+  } catch (e) {
+    debug2 = (...args) => console.debug(`[${namespace}]`, ...args);
+  }
+  return {
+    trace: (...args) => debug2("TRACE", ...args),
+    debug: (...args) => debug2("DEBUG", ...args),
+    info: (...args) => debug2("INFO", ...args),
+    warn: (...args) => debug2("WARN", ...args),
+    error: (...args) => debug2("ERROR", ...args)
+  };
+}
+
+// packages/core/src/api/KinoticDecorators.ts
+var import_reflect_metadata = __toESM(require_Reflect(), 1);
+
+// packages/core/src/core/api/ServiceIdentifier.ts
+class ServiceIdentifier {
+  namespace;
+  name;
+  scope;
+  version;
+  _cri = null;
+  constructor(namespace, name) {
+    this.namespace = namespace;
+    this.name = name;
+  }
+  qualifiedName() {
+    return this.namespace + "." + this.name;
+  }
+  cri() {
+    if (this._cri == null) {
+      this._cri = createCRI("srv" /* SERVICE_DESTINATION_SCHEME */, this.scope || null, this.qualifiedName(), null, this.version || null);
+    }
+    return this._cri;
+  }
+}
+
+// packages/core/src/api/KinoticDecorators.ts
+var SCOPE_METADATA_KEY = Symbol("scope");
+var VERSION_METADATA_KEY = Symbol("version");
+var CONTEXT_METADATA_KEY = Symbol("context");
+function Scope(target, propertyKey, descriptor) {
+  Reflect.defineMetadata(SCOPE_METADATA_KEY, propertyKey, target);
+}
+function Version(version) {
+  if (!/^\d+\.\d+\.\d+(-[a-zA-Z0-9]+)?$/.test(version)) {
+    throw new Error(`Invalid semantic version: ${version}. Must follow X.Y.Z[-optional] format.`);
+  }
+  return function(target) {
+    Reflect.defineMetadata(VERSION_METADATA_KEY, version, target);
+  };
+}
+function Context() {
+  return function(target, propertyKey, parameterIndex) {
+    const existingContexts = Reflect.getMetadata(CONTEXT_METADATA_KEY, target, propertyKey) || [];
+    existingContexts.push(parameterIndex);
+    Reflect.defineMetadata(CONTEXT_METADATA_KEY, existingContexts, target, propertyKey);
+  };
+}
+function Publish(namespace, name) {
+  return function(target) {
+    const original = target;
+    const serviceIdentifier = new ServiceIdentifier(namespace, name || target.name);
+    const version = Reflect.getMetadata(VERSION_METADATA_KEY, target);
+    if (version) {
+      serviceIdentifier.version = version;
+    }
+    const newConstructor = function(...args) {
+      const instance = Reflect.construct(original, args);
+      const scopeProperty = Reflect.getMetadata(SCOPE_METADATA_KEY, target.prototype);
+      if (scopeProperty) {
+        const scopeValue = instance[scopeProperty];
+        serviceIdentifier.scope = typeof scopeValue === "function" ? scopeValue.call(instance) : scopeValue;
+      }
+      Kinotic.serviceRegistry.register(serviceIdentifier, instance);
+      return instance;
+    };
+    newConstructor.prototype = original.prototype;
+    return newConstructor;
+  };
+}
+
+// packages/core/src/internal/core/api/ServiceInvocationSupervisor.ts
+class ServiceInvocationSupervisor {
+  log;
+  active = false;
+  _eventBus;
+  interceptorProvider;
+  argumentResolver;
+  returnValueConverter;
+  serviceIdentifier;
+  serviceInstance;
+  methodSubscription = null;
+  methodMap;
+  constructor(serviceIdentifier, serviceInstance, eventBusService, interceptorProvider, options = {}) {
+    if (!serviceIdentifier)
+      throw new Error("ServiceIdentifier must not be null");
+    if (!serviceInstance)
+      throw new Error("Service instance must not be null");
+    if (!eventBusService)
+      throw new Error("IEventBus must not be null");
+    if (!interceptorProvider)
+      throw new Error("interceptorProvider must not be null");
+    this.serviceIdentifier = serviceIdentifier;
+    this.serviceInstance = serviceInstance;
+    this._eventBus = eventBusService;
+    this.interceptorProvider = interceptorProvider;
+    this.log = options.logger || createDebugLogger("kinoitc:ServiceInvocationSupervisor");
+    this.argumentResolver = options.argumentResolver || new JsonArgumentResolver;
+    this.returnValueConverter = options.returnValueConverter || new BasicReturnValueConverter;
+    this.methodMap = this.buildMethodMap(serviceInstance);
+  }
+  isActive() {
+    return this.active;
+  }
+  set eventBus(eventBus) {
+    if (this.active) {
+      this.stop();
+      this._eventBus = eventBus;
+      this.start();
+    } else {
+      this._eventBus = eventBus;
+    }
+  }
+  start() {
+    if (this.active) {
+      throw new Error("Service already started");
+    }
+    this.active = true;
+    const criBase = this.serviceIdentifier.cri().baseResource();
+    this.methodSubscription = this._eventBus.observe(criBase).subscribe({
+      next: async (event) => {
+        await this.processEvent(event);
+      },
+      error: (error) => {
+        this.log.error("Event listener error", error);
+        this.active = false;
+      },
+      complete: () => {
+        this.log.error("Event listener stopped unexpectedly. Setting supervisor inactive.");
+        this.active = false;
+      }
+    });
+    this.log.info(`ServiceInvocationSupervisor started for ${criBase}`);
+  }
+  stop() {
+    if (!this.active) {
+      throw new Error("Service already stopped");
+    }
+    this.active = false;
+    if (this.methodSubscription) {
+      this.methodSubscription.unsubscribe();
+      this.methodSubscription = null;
+    }
+    this.log.info("ServiceInvocationSupervisor stopped");
+  }
+  buildMethodMap(serviceInstance) {
+    const methodMap = {};
+    for (const key of Object.getOwnPropertyNames(Object.getPrototypeOf(serviceInstance))) {
+      const method = serviceInstance[key];
+      if (typeof method === "function" && key !== "constructor") {
+        methodMap[key] = method.bind(serviceInstance);
+      }
+    }
+    return methodMap;
+  }
+  async processEvent(event) {
+    const isControl = event.hasHeader("control" /* CONTROL_HEADER */);
+    this.log.trace(`Service ${isControl ? "Control" : "Invocation"} requested for ${event.cri}`);
+    try {
+      if (isControl) {
+        this.processControlPlaneRequest(event);
+      } else {
+        if (this.validateReplyTo(event)) {
+          await this.processInvocationRequest(event);
+        } else {
+          this.log.error(`ReplyTo header missing or invalid. Ignoring event: ${JSON.stringify(event)}`);
+        }
+      }
+    } catch (e) {
+      this.log.debug(`Exception processing service request: ${JSON.stringify(event)}`, e);
+      this.handleException(event, e);
+    }
+  }
+  processControlPlaneRequest(event) {
+    const correlationId = event.getHeader("__correlation-id" /* CORRELATION_ID_HEADER */);
+    if (!correlationId) {
+      throw new Error("Streaming control plane messages require a CORRELATION_ID_HEADER");
+    }
+    this.log.trace(`Processing control event for correlationId: ${correlationId}`);
+  }
+  async processInvocationRequest(event) {
+    const path = createCRI(event.cri).path();
+    if (!path) {
+      throw new Error("The methodId must not be blank");
+    }
+    const handlerMethod = this.methodMap[path];
+    if (!handlerMethod) {
+      throw new Error(`No method resolved for methodId ${path}`);
+    }
+    const methodName = path;
+    const args = this.argumentResolver.resolveArguments(event);
+    const contextIndices = Reflect.getMetadata(CONTEXT_METADATA_KEY, this.serviceInstance, methodName) || [];
+    let context2 = {};
+    const interceptor = this.interceptorProvider();
+    if (interceptor) {
+      try {
+        context2 = await interceptor.intercept(event, context2);
+      } catch (e) {
+        this.log.error(`Interceptor failed to create context for event: ${JSON.stringify(event)}`, e);
+        this.handleException(event, new Error("Internal server error"));
+        return;
+      }
+    }
+    for (const index of contextIndices) {
+      args[index] = context2;
+    }
+    const expectedArgsCount = handlerMethod.length;
+    if (args.length !== expectedArgsCount) {
+      throw new Error(`Argument count mismatch for method ${path}: expected ${expectedArgsCount}, got ${args.length}`);
+    }
+    let result;
+    try {
+      result = handlerMethod(...args);
+      if (result instanceof Promise) {
+        result.then((resolved) => this.processMethodInvocationResult(event, resolved), (error) => this.handleException(event, error));
+      } else {
+        this.processMethodInvocationResult(event, result);
+      }
+    } catch (e) {
+      this.handleException(event, e);
+    }
+  }
+  processMethodInvocationResult(event, result) {
+    const outgoingEvent = this.returnValueConverter.convert(event.headers, result);
+    this._eventBus.send(outgoingEvent);
+  }
+  handleException(event, error) {
+    const errorEvent = EventUtil.createReplyEvent(event.headers, new Map([
+      ["error" /* ERROR_HEADER */, error.message || "Unknown error"],
+      ["content-type" /* CONTENT_TYPE_HEADER */, "application/json"]
+    ]), new TextEncoder().encode(JSON.stringify({ message: error.message })));
+    this._eventBus.send(errorEvent);
+  }
+  validateReplyTo(event) {
+    const replyTo = event.getHeader("reply-to" /* REPLY_TO_HEADER */);
+    if (!replyTo) {
+      this.log.warn("No reply-to header found in event");
+      return false;
+    }
+    if (replyTo.trim() === "") {
+      this.log.warn("Reply-to header must not be blank");
+      return false;
+    }
+    if (!replyTo.startsWith(`${"srv" /* SERVICE_DESTINATION_SCHEME */}:`)) {
+      this.log.warn("Reply-to header must be a valid service destination");
+      return false;
+    }
+    return true;
+  }
+}
+
+// packages/core/src/core/api/ServiceRegistry.ts
+import opentelemetry, { SpanKind, SpanStatusCode } from "@opentelemetry/api";
+import {
+  ATTR_SERVER_ADDRESS,
+  ATTR_SERVER_PORT
+} from "@opentelemetry/semantic-conventions";
+import { first, map as map2 } from "rxjs/operators";
+// packages/core/package.json
+var package_default = {
+  name: "@kinotic-ai/core",
+  description: "Kinotic Core",
+  version: "1.0.0-beta.0",
+  type: "module",
+  files: [
+    "dist"
+  ],
+  module: "./dist/index.js",
+  main: "./dist/index.cjs",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js"
+      },
+      require: {
+        types: "./dist/index.d.cts",
+        default: "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  homepage: "https://github.com/kinotic-ai/kinotic",
+  license: "Elastic License 2.0",
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    "type-check": "tsc --noEmit",
+    test: "vitest run",
+    coverage: "vitest run --coverage",
+    "ui-test": "vitest --ui --coverage.enabled=true --mode development"
+  },
+  devDependencies: {
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.212.0",
+    "@opentelemetry/resources": "^2.5.1",
+    "@opentelemetry/sdk-metrics": "^2.5.1",
+    "@opentelemetry/sdk-node": "^0.212.0",
+    "@opentelemetry/sdk-trace-node": "^2.5.1",
+    "@types/node": "^25.3.2",
+    "@types/uuid": "^11.0.0",
+    "@types/ws": "^8.18.1",
+    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/runner": "^4.0.18",
+    "@vitest/ui": "^4.0.18",
+    allure: "^3.3.1",
+    "allure-vitest": "^3.5.0",
+    dotenv: "^17.3.1",
+    "properties-file": "^3.6.4",
+    testcontainers: "^11.12.0",
+    tslib: "^2.8.1",
+    typescript: "^5.9.3",
+    vitest: "^4.0.18",
+    ws: "^8.19.0"
+  },
+  dependencies: {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/semantic-conventions": "^1.40.0",
+    "@stomp/rx-stomp": "^2.3.0",
+    "@stomp/stompjs": "^7.3.0",
+    "@types/debug": "^4.1.12",
+    debug: "^4.4.3",
+    "p-tap": "^4.0.0",
+    rxjs: "^7.8.2",
+    "typescript-optional": "3.0.0-alpha.3",
+    uuid: "^13.0.0"
+  },
+  peerDependenciesMeta: {
+    typescript: {
+      optional: true
+    }
+  }
+};
+
+// packages/core/src/core/api/ServiceRegistry.ts
+class JsonEventFactory {
+  create(cri, args) {
+    const event = new Event(cri);
+    event.setHeader("content-type" /* CONTENT_TYPE_HEADER */, "application/json" /* CONTENT_JSON */);
+    if (args != null) {
+      event.setDataString(JSON.stringify(args));
+    }
+    return event;
+  }
+}
+
+class TextEventFactory {
+  create(cri, args) {
+    const event = new Event(cri);
+    event.setHeader("content-type" /* CONTENT_TYPE_HEADER */, "text/plain" /* CONTENT_TEXT */);
+    if (args != null) {
+      let data = "";
+      let i = 0;
+      for (const arg of args) {
+        if (i > 0) {
+          data = data + `
+`;
+        }
+        data = data + arg;
+        i++;
+      }
+      if (data.length > 0) {
+        event.setDataString(data);
+      }
+    }
+    return event;
+  }
+}
+
+class ServiceRegistry {
+  _eventBus;
+  supervisors = new Map;
+  contextInterceptor = null;
+  debugLogger = debug2("kinoitc:serviceRegistry");
+  constructor(eventBus) {
+    this._eventBus = eventBus;
+  }
+  set eventBus(eventBus) {
+    this._eventBus = eventBus;
+    for (const supervisor of this.supervisors.values()) {
+      supervisor.eventBus = eventBus;
+    }
+  }
+  get eventBus() {
+    return this._eventBus;
+  }
+  serviceProxy(serviceIdentifier) {
+    return new ServiceProxy(serviceIdentifier, this);
+  }
+  register(serviceIdentifier, service) {
+    const criString = serviceIdentifier.cri().raw();
+    if (!this.supervisors.has(criString)) {
+      this.debugLogger(`Registering service for CRI: ${criString}`);
+      const supervisor = new ServiceInvocationSupervisor(serviceIdentifier, service, this.eventBus, () => this.contextInterceptor);
+      this.supervisors.set(criString, supervisor);
+      supervisor.start();
+    }
+  }
+  unRegister(serviceIdentifier) {
+    const criString = serviceIdentifier.cri().raw();
+    const supervisor = this.supervisors.get(criString);
+    if (supervisor) {
+      this.debugLogger(`Unregistering service for CRI: ${criString}`);
+      supervisor.stop();
+      this.supervisors.delete(criString);
+    }
+  }
+  registerContextInterceptor(interceptor) {
+    this.contextInterceptor = interceptor;
+  }
+}
+var defaultEventFactory = new JsonEventFactory;
+
+class ServiceProxy {
+  serviceIdentifier;
+  serviceRegistry;
+  tracer;
+  constructor(serviceIdentifier, serviceRegistry) {
+    if (typeof serviceIdentifier === "undefined" || serviceIdentifier.length === 0) {
+      throw new Error("The serviceIdentifier provided must contain a value");
+    }
+    this.serviceIdentifier = serviceIdentifier;
+    this.serviceRegistry = serviceRegistry;
+    this.tracer = opentelemetry.trace.getTracer("kinoitc.client", package_default.version);
+  }
+  invoke(methodIdentifier, args, scope, eventFactory) {
+    return this.tracer.startActiveSpan(`${this.serviceIdentifier}/${methodIdentifier}`, {
+      kind: SpanKind.CLIENT
+    }, async (span) => {
+      if (scope) {
+        span.setAttribute("kinoitc.scope", scope);
+      }
+      span.setAttribute("rpc.system", "kinoitc");
+      span.setAttribute("rpc.service", this.serviceIdentifier);
+      span.setAttribute("rpc.method", methodIdentifier);
+      return this.__invokeStream(false, methodIdentifier, args, scope, eventFactory).pipe(first()).toPromise().then(async (value) => {
+        span.end();
+        return value;
+      }, async (ex) => {
+        span.recordException(ex);
+        span.setStatus({ code: SpanStatusCode.ERROR });
+        span.end();
+        throw ex;
+      });
+    });
+  }
+  invokeStream(methodIdentifier, args, scope, eventFactory) {
+    return this.__invokeStream(true, methodIdentifier, args, scope, eventFactory);
+  }
+  __invokeStream(sendControlEvents, methodIdentifier, args, scope, eventFactory) {
+    const cri = "srv://" /* SERVICE_DESTINATION_PREFIX */ + (scope != null ? scope + "@" : "") + this.serviceIdentifier + "/" + methodIdentifier;
+    let eventFactoryToUse = defaultEventFactory;
+    if (eventFactory) {
+      eventFactoryToUse = eventFactory;
+    }
+    let eventBusToUse = this.serviceRegistry.eventBus;
+    const span = opentelemetry.trace.getActiveSpan();
+    if (span) {
+      span.setAttribute(ATTR_SERVER_ADDRESS, eventBusToUse.serverInfo?.host || "unknown");
+      span.setAttribute(ATTR_SERVER_PORT, eventBusToUse.serverInfo?.port || "unknown");
+    }
+    let event = eventFactoryToUse.create(cri, args);
+    return eventBusToUse.requestStream(event, sendControlEvents).pipe(map2((value) => {
+      const contentType = value.getHeader("content-type" /* CONTENT_TYPE_HEADER */);
+      if (contentType !== undefined) {
+        if (contentType === "application/json") {
+          return JSON.parse(value.getDataString());
+        } else if (contentType === "text/plain") {
+          return value.getDataString();
+        } else {
+          throw new Error("Content Type " + contentType + " is not supported");
+        }
+      } else {
+        return null;
+      }
+    }));
+  }
+}
+
+// packages/core/src/api/Kinotic.ts
+class KinoticSingleton {
+  _eventBus;
+  serviceRegistry;
+  crudServiceProxyFactory;
+  constructor() {
+    this._eventBus = new EventBus;
+    this.serviceRegistry = new ServiceRegistry(this._eventBus);
+    this.crudServiceProxyFactory = new CrudServiceProxyFactory(this.serviceRegistry);
+  }
+  get eventBus() {
+    return this._eventBus;
+  }
+  set eventBus(eventBus) {
+    this._eventBus = eventBus;
+    this.serviceRegistry.eventBus = eventBus;
+  }
+  connect(connectionInfo) {
+    return this._eventBus.connect(connectionInfo);
+  }
+  disconnect(force) {
+    return this._eventBus.disconnect(force);
+  }
+  serviceProxy(serviceIdentifier) {
+    return this.serviceRegistry.serviceProxy(serviceIdentifier);
+  }
+  crudServiceProxy(serviceIdentifier) {
+    return this.crudServiceProxyFactory.crudServiceProxy(serviceIdentifier);
+  }
+}
+var Kinotic = new KinoticSingleton;
+// packages/core/src/api/ILogManager.ts
+var LogLevel;
+((LogLevel2) => {
+  LogLevel2["TRACE"] = "TRACE";
+  LogLevel2["DEBUG"] = "DEBUG";
+  LogLevel2["INFO"] = "INFO";
+  LogLevel2["WARN"] = "WARN";
+  LogLevel2["ERROR"] = "ERROR";
+  LogLevel2["FATAL"] = "FATAL";
+  LogLevel2["OFF"] = "OFF";
+})(LogLevel ||= {});
+
+class LoggerLevelsDescriptor {
+  configuredLevel;
+}
+
+class GroupLoggerLevelsDescriptor extends LoggerLevelsDescriptor {
+  members = [];
+}
+
+class SingleLoggerLevelsDescriptor extends LoggerLevelsDescriptor {
+  effectiveLevel;
+}
+
+class LoggersDescriptor {
+  levels = [];
+  loggerLevels = new Map;
+  groups = new Map;
+}
+// packages/core/src/api/LogManager.ts
+class LogManager {
+  serviceProxy;
+  constructor() {
+    this.serviceProxy = Kinotic.serviceProxy("org.kinotic.kinoitc.api.log.LogManager");
+  }
+  loggers(nodeId) {
+    return this.serviceProxy.invoke("loggers", null, nodeId);
+  }
+  async loggerLevels(nodeId, name) {
+    const data = await this.serviceProxy.invoke("loggerLevels", [name], nodeId);
+    let ret = null;
+    if (data.hasOwnProperty("members")) {
+      ret = new GroupLoggerLevelsDescriptor;
+    } else if (data.hasOwnProperty("effectiveLevel")) {
+      ret = new SingleLoggerLevelsDescriptor;
+    } else {
+      ret = new LoggerLevelsDescriptor;
+    }
+    Object.assign(ret, data);
+    return ret;
+  }
+  configureLogLevel(nodeId, name, level) {
+    return this.serviceProxy.invoke("configureLogLevel", [name, level], nodeId);
+  }
+}
+var logManager = new LogManager;
+// packages/core/src/api/errors/AuthenticationError.ts
+class AuthenticationError extends KinoticError {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, AuthenticationError.prototype);
+  }
+}
+// packages/core/src/api/errors/AuthorizationError.ts
+class AuthorizationError extends KinoticError {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, AuthorizationError.prototype);
+  }
+}
+// packages/core/src/api/security/ConnectedInfo.ts
+class ConnectedInfo {
+  sessionId;
+  replyToId;
+  participant;
+}
+// packages/core/src/api/security/Participant.ts
+class Participant {
+  id;
+  tenantId;
+  metadata;
+  roles;
+  constructor(id, tenantId, metadata, roles) {
+    this.id = id;
+    this.tenantId = tenantId;
+    this.metadata = metadata || new Map;
+    this.roles = roles || [];
+  }
+}
+// packages/core/src/api/security/ParticipantConstants.ts
+class ParticipantConstants {
+  static PARTICIPANT_TYPE_METADATA_KEY = "type";
+  static PARTICIPANT_TYPE_DEVICE = "device";
+  static PARTICIPANT_TYPE_CLI = "cli";
+  static PARTICIPANT_TYPE_USER = "user";
+  static PARTICIPANT_TYPE_NODE = "node";
+  static CLI_PARTICIPANT_ID = "-42-Kinotic-CLI-42-";
+}
+// packages/core/src/core/api/StreamData.ts
+var StreamOperation;
+((StreamOperation2) => {
+  StreamOperation2["EXISTING"] = "EXISTING";
+  StreamOperation2["UPDATE"] = "UPDATE";
+  StreamOperation2["REMOVE"] = "REMOVE";
+})(StreamOperation ||= {});
+
+class StreamData {
+  streamOperation;
+  id;
+  value;
+  constructor(streamOperation, id, value) {
+    this.streamOperation = streamOperation;
+    this.id = id;
+    this.value = value;
+  }
+  isSet() {
+    return this.value !== null && this.value !== undefined;
+  }
+}
+// packages/core/src/core/api/crud/FunctionalIterablePage.ts
+class FunctionalIterablePage extends AbstractIterablePage {
+  pageFunction;
+  constructor(pageable, page, pageFunction) {
+    super(pageable, page);
+    this.pageFunction = pageFunction;
+  }
+  findNext(pageable) {
+    return this.pageFunction(pageable);
+  }
+}
+// packages/core/src/core/api/crud/IDataSource.ts
+class DataSourceUtils {
+  static instanceOfEditableDataSource(datasource) {
+    return "create" in datasource;
+  }
+}
+// packages/core/src/core/api/crud/Pageable.ts
+class Pageable {
+  sort = null;
+  pageSize = 25;
+  static create(pageNumber, pageSize, sort) {
+    return new OffsetPageable(pageNumber, pageSize, sort);
+  }
+  static createWithCursor(cursor, pageSize, sort) {
+    return new CursorPageable(cursor, pageSize, sort);
+  }
+}
+
+class OffsetPageable extends Pageable {
+  pageNumber = 0;
+  constructor(pageNumber, pageSize, sort) {
+    super();
+    this.pageNumber = pageNumber;
+    this.pageSize = pageSize;
+    this.sort = sort;
+  }
+}
+
+class CursorPageable extends Pageable {
+  cursor;
+  constructor(cursor, pageSize, sort) {
+    super();
+    this.cursor = cursor;
+    this.pageSize = pageSize;
+    this.sort = sort;
+  }
+}
+// packages/core/src/core/api/crud/Sort.ts
+var Direction;
+((Direction2) => {
+  Direction2["ASC"] = "ASC";
+  Direction2["DESC"] = "DESC";
+})(Direction ||= {});
+var NullHandling;
+((NullHandling2) => {
+  NullHandling2["NATIVE"] = "NATIVE";
+  NullHandling2["NULLS_FIRST"] = "NULLS_FIRST";
+  NullHandling2["NULLS_LAST"] = "NULLS_LAST";
+})(NullHandling ||= {});
+
+class Order {
+  property;
+  direction = "ASC" /* ASC */;
+  nullHandling = "NATIVE" /* NATIVE */;
+  constructor(property, direction) {
+    this.property = property;
+    if (direction !== null) {
+      this.direction = direction;
+    }
+  }
+  isAscending() {
+    return this.direction === "ASC" /* ASC */;
+  }
+  isDescending() {
+    return this.direction === "DESC" /* DESC */;
+  }
+}
+
+class Sort {
+  orders = [];
+}
+export {
+  logManager,
+  createCRI,
+  Version,
+  TextEventFactory,
+  StreamOperation,
+  StreamData,
+  Sort,
+  SingleLoggerLevelsDescriptor,
+  ServiceRegistry,
+  ServerInfo,
+  Scope,
+  Publish,
+  ParticipantConstants,
+  Participant,
+  Pageable,
+  Order,
+  OffsetPageable,
+  NullHandling,
+  LoggersDescriptor,
+  LoggerLevelsDescriptor,
+  LogManager,
+  LogLevel,
+  KinoticSingleton,
+  KinoticError,
+  Kinotic,
+  JsonEventFactory,
+  GroupLoggerLevelsDescriptor,
+  FunctionalIterablePage,
+  EventConstants,
+  EventBus,
+  Event,
+  Direction,
+  DefaultCRI,
+  DataSourceUtils,
+  CursorPageable,
+  CrudServiceProxyFactory,
+  CrudServiceProxy,
+  Context,
+  ConnectionInfo,
+  ConnectedInfo,
+  ConnectHeaders,
+  CONTEXT_METADATA_KEY,
+  AuthorizationError,
+  AuthenticationError,
+  AbstractIterablePage
+};