@ultrst-armada/krnl 0.0.0-stage → 1.0.1

package/packages/core/dist/chunk-A5KRAYDB.js

@@ -0,0 +1,107 @@
+import {
+  krnlSystemEntityBase
+} from "./chunk-T2ZVN434.js";
+import {
+  KrnlShell
+} from "./chunk-GADIRLRS.js";
+
+// src/core/K_LIB_Krnl_System_App_Adapter.ts
+import fs from "fs";
+import path from "path";
+import http from "http";
+import net from "net";
+var KrnlNonKrnlAppAdapter = class extends krnlSystemEntityBase {
+  childProcess = null;
+  appPort = -1;
+  appPath;
+  constructor(name, appPath) {
+    super(name, null, -1, "127.0.0.1", { Singleton: true, _skipMagneticLoading: true });
+    this.appPath = appPath;
+    this._isIngressNetworkMember = true;
+    this.unifiedHttpAdapter._handleRequest = async (req, res) => {
+      await this.proxyRequest(req, res, req.url || "/");
+    };
+  }
+  async startApp() {
+    this.appPort = await this._probeAvailablePort(11e3, "127.0.0.1");
+    let command = "node";
+    let args = ["."];
+    try {
+      const pkgPath = path.join(this.appPath, "package.json");
+      if (fs.existsSync(pkgPath)) {
+        const packageJson = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (packageJson.scripts?.start) {
+          command = "npm";
+          args = ["run", "start"];
+        } else if (packageJson.main) {
+          args = [packageJson.main];
+        }
+      }
+    } catch (_) {
+    }
+    const env = {
+      ...process.env,
+      PORT: this.appPort.toString()
+    };
+    console.log(`[AppAdapter] Spawning non-Krnl app '${this.entityName}' in background (Port: ${this.appPort})...`);
+    this.childProcess = KrnlShell.spawn(command, args, {
+      cwd: this.appPath,
+      env,
+      stdio: "inherit"
+    });
+    let ready = false;
+    const timeout = 15e3;
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      ready = await new Promise((resolve) => {
+        const socket = net.connect(this.appPort, "127.0.0.1");
+        socket.on("connect", () => {
+          socket.destroy();
+          resolve(true);
+        });
+        socket.on("error", () => resolve(false));
+      });
+      if (ready) break;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    if (!ready) {
+      throw new Error(`[AppAdapter] Non-Krnl app '${this.entityName}' failed to boot on port ${this.appPort} within 15s.`);
+    }
+    console.log(`[AppAdapter] Non-Krnl app '${this.entityName}' successfully booted.`);
+  }
+  async proxyRequest(req, res, subPath) {
+    if (this.appPort === -1) {
+      res.writeHead(503, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "error", message: "Service Temporarily Unavailable: Sub-app not running." }));
+      return;
+    }
+    const options = {
+      hostname: "127.0.0.1",
+      port: this.appPort,
+      path: subPath,
+      method: req.method,
+      headers: req.headers
+    };
+    const proxyReq = http.request(options, (proxyRes) => {
+      res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+      proxyRes.pipe(res);
+    });
+    proxyReq.on("error", (err) => {
+      res.writeHead(502, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "error", message: `Bad Gateway: ${err.message}` }));
+    });
+    req.pipe(proxyReq);
+  }
+  dispose() {
+    if (this.childProcess) {
+      console.log(`[AppAdapter] Killing child process (PID: ${this.childProcess.pid}) for '${this.entityName}'`);
+      this.childProcess.kill("SIGTERM");
+      this.childProcess = null;
+    }
+    super.dispose();
+  }
+};
+
+export {
+  KrnlNonKrnlAppAdapter
+};

package/packages/core/dist/chunk-ANEAZ3PO.js

@@ -0,0 +1,107 @@
+import {
+  krnlSystemEntityBase
+} from "./chunk-3UEZ7JQA.js";
+import {
+  KrnlShell
+} from "./chunk-GADIRLRS.js";
+
+// src/core/K_LIB_Krnl_System_App_Adapter.ts
+import fs from "fs";
+import path from "path";
+import http from "http";
+import net from "net";
+var KrnlNonKrnlAppAdapter = class extends krnlSystemEntityBase {
+  childProcess = null;
+  appPort = -1;
+  appPath;
+  constructor(name, appPath) {
+    super(name, null, -1, "127.0.0.1", { Singleton: true, _skipMagneticLoading: true });
+    this.appPath = appPath;
+    this._isIngressNetworkMember = true;
+    this.unifiedHttpAdapter._handleRequest = async (req, res) => {
+      await this.proxyRequest(req, res, req.url || "/");
+    };
+  }
+  async startApp() {
+    this.appPort = await this._probeAvailablePort(11e3, "127.0.0.1");
+    let command = "node";
+    let args = ["."];
+    try {
+      const pkgPath = path.join(this.appPath, "package.json");
+      if (fs.existsSync(pkgPath)) {
+        const packageJson = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (packageJson.scripts?.start) {
+          command = "npm";
+          args = ["run", "start"];
+        } else if (packageJson.main) {
+          args = [packageJson.main];
+        }
+      }
+    } catch (_) {
+    }
+    const env = {
+      ...process.env,
+      PORT: this.appPort.toString()
+    };
+    console.log(`[AppAdapter] Spawning non-Krnl app '${this.entityName}' in background (Port: ${this.appPort})...`);
+    this.childProcess = KrnlShell.spawn(command, args, {
+      cwd: this.appPath,
+      env,
+      stdio: "inherit"
+    });
+    let ready = false;
+    const timeout = 15e3;
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      ready = await new Promise((resolve) => {
+        const socket = net.connect(this.appPort, "127.0.0.1");
+        socket.on("connect", () => {
+          socket.destroy();
+          resolve(true);
+        });
+        socket.on("error", () => resolve(false));
+      });
+      if (ready) break;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    if (!ready) {
+      throw new Error(`[AppAdapter] Non-Krnl app '${this.entityName}' failed to boot on port ${this.appPort} within 15s.`);
+    }
+    console.log(`[AppAdapter] Non-Krnl app '${this.entityName}' successfully booted.`);
+  }
+  async proxyRequest(req, res, subPath) {
+    if (this.appPort === -1) {
+      res.writeHead(503, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "error", message: "Service Temporarily Unavailable: Sub-app not running." }));
+      return;
+    }
+    const options = {
+      hostname: "127.0.0.1",
+      port: this.appPort,
+      path: subPath,
+      method: req.method,
+      headers: req.headers
+    };
+    const proxyReq = http.request(options, (proxyRes) => {
+      res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+      proxyRes.pipe(res);
+    });
+    proxyReq.on("error", (err) => {
+      res.writeHead(502, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "error", message: `Bad Gateway: ${err.message}` }));
+    });
+    req.pipe(proxyReq);
+  }
+  dispose() {
+    if (this.childProcess) {
+      console.log(`[AppAdapter] Killing child process (PID: ${this.childProcess.pid}) for '${this.entityName}'`);
+      this.childProcess.kill("SIGTERM");
+      this.childProcess = null;
+    }
+    super.dispose();
+  }
+};
+
+export {
+  KrnlNonKrnlAppAdapter
+};

package/packages/core/dist/chunk-BE76RL6F.js

@@ -0,0 +1,82 @@
+import {
+  subappLocalStorage
+} from "./chunk-YUK6Q563.js";
+
+// src/core/K_LIB_Krnl_SubApp_Registry.ts
+import path from "path";
+import { pathToFileURL } from "url";
+var KrnlSubAppLoader = class {
+  /**
+   * Loads a single sub-app into the parent entity's _subAppRegistry.
+   *
+   * For 'local' mode the sub-app class is instantiated directly in the parent process.
+   * Networking is suppressed automatically because the entity is constructed inside the
+   * subappLocalStorage async context (sets _isSubApp = true) and _startSharedServer()
+   * returns early for sub-app entities.
+   *
+   * For 'worker' mode a worker_thread is spawned and a KrnlSubAppWorkerHost proxy is
+   * registered in its place. All calls transit via MessagePort — no TCP/HTTP involved.
+   */
+  static async load(parent, config) {
+    const mode = config.executionMode ?? "local";
+    const prefix = config.prefix.toLowerCase();
+    if (parent._subAppRegistry.has(prefix)) {
+      console.log(`[SubAppRegistry] Sub-app '${prefix}' already registered. Skipping.`);
+      return;
+    }
+    let entry;
+    if (mode === "local") {
+      const appDir = config.entryPath ? path.dirname(config.entryPath) : "";
+      let entity;
+      if (config.isKrnl === false || !config.ServiceClass) {
+        const { KrnlNonKrnlAppAdapter } = await import("./K_LIB_Krnl_System_App_Adapter-M6FJKLGU.js");
+        const adapter = new KrnlNonKrnlAppAdapter(config.prefix, config.entryPath || "");
+        await adapter.startApp();
+        entity = adapter;
+      } else {
+        const options = { host: "0.0.0.0" };
+        if (config.entryPath) options.sourcePath = pathToFileURL(config.entryPath).href;
+        entity = await subappLocalStorage.run({ appPath: appDir }, async () => {
+          const inst = new config.ServiceClass(-1, options, ...config.constructorArgs ?? []);
+          if (typeof inst.boot === "function") {
+            try {
+              await inst.boot();
+            } catch (bootErr) {
+              console.warn(`[SubAppRegistry] Auto-boot warning on sub-app '${prefix}':`, bootErr.message || bootErr);
+            }
+          }
+          if (inst._magneticLoadPromise) {
+            await inst._magneticLoadPromise;
+          }
+          return inst;
+        });
+      }
+      if (typeof entity._resolveReady === "function") {
+        entity._resolveReady();
+      }
+      parent.hierarchyManager.addComponentEntityInstance(entity);
+      entry = {
+        prefix,
+        executionMode: "local",
+        entity,
+        addedAt: Date.now()
+      };
+      console.log(`[SubAppRegistry] Loaded sub-app '${prefix}' in LOCAL mode (in-process).`);
+    } else {
+      const { KrnlSubAppWorkerHost } = await import("./K_LIB_Krnl_SubApp_Worker_Host-CQVTGGG7.js");
+      const host = await KrnlSubAppWorkerHost.create(config);
+      entry = {
+        prefix,
+        executionMode: "worker",
+        entity: host,
+        addedAt: Date.now()
+      };
+      console.log(`[SubAppRegistry] Loaded sub-app '${prefix}' in WORKER mode (isolated thread).`);
+    }
+    parent._subAppRegistry.set(prefix, entry);
+  }
+};
+
+export {
+  KrnlSubAppLoader
+};

package/packages/core/dist/chunk-CIARVYDO.js

@@ -0,0 +1,107 @@
+import {
+  krnlSystemEntityBase
+} from "./chunk-UGVVJKC6.js";
+import {
+  KrnlShell
+} from "./chunk-GADIRLRS.js";
+
+// src/core/K_LIB_Krnl_System_App_Adapter.ts
+import fs from "fs";
+import path from "path";
+import http from "http";
+import net from "net";
+var KrnlNonKrnlAppAdapter = class extends krnlSystemEntityBase {
+  childProcess = null;
+  appPort = -1;
+  appPath;
+  constructor(name, appPath) {
+    super(name, null, -1, "127.0.0.1", { Singleton: true, _skipMagneticLoading: true });
+    this.appPath = appPath;
+    this._isIngressNetworkMember = true;
+    this.unifiedHttpAdapter._handleRequest = async (req, res) => {
+      await this.proxyRequest(req, res, req.url || "/");
+    };
+  }
+  async startApp() {
+    this.appPort = await this._probeAvailablePort(11e3, "127.0.0.1");
+    let command = "node";
+    let args = ["."];
+    try {
+      const pkgPath = path.join(this.appPath, "package.json");
+      if (fs.existsSync(pkgPath)) {
+        const packageJson = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (packageJson.scripts?.start) {
+          command = "npm";
+          args = ["run", "start"];
+        } else if (packageJson.main) {
+          args = [packageJson.main];
+        }
+      }
+    } catch (_) {
+    }
+    const env = {
+      ...process.env,
+      PORT: this.appPort.toString()
+    };
+    console.log(`[AppAdapter] Spawning non-Krnl app '${this.entityName}' in background (Port: ${this.appPort})...`);
+    this.childProcess = KrnlShell.spawn(command, args, {
+      cwd: this.appPath,
+      env,
+      stdio: "inherit"
+    });
+    let ready = false;
+    const timeout = 15e3;
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      ready = await new Promise((resolve) => {
+        const socket = net.connect(this.appPort, "127.0.0.1");
+        socket.on("connect", () => {
+          socket.destroy();
+          resolve(true);
+        });
+        socket.on("error", () => resolve(false));
+      });
+      if (ready) break;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    if (!ready) {
+      throw new Error(`[AppAdapter] Non-Krnl app '${this.entityName}' failed to boot on port ${this.appPort} within 15s.`);
+    }
+    console.log(`[AppAdapter] Non-Krnl app '${this.entityName}' successfully booted.`);
+  }
+  async proxyRequest(req, res, subPath) {
+    if (this.appPort === -1) {
+      res.writeHead(503, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "error", message: "Service Temporarily Unavailable: Sub-app not running." }));
+      return;
+    }
+    const options = {
+      hostname: "127.0.0.1",
+      port: this.appPort,
+      path: subPath,
+      method: req.method,
+      headers: req.headers
+    };
+    const proxyReq = http.request(options, (proxyRes) => {
+      res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+      proxyRes.pipe(res);
+    });
+    proxyReq.on("error", (err) => {
+      res.writeHead(502, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "error", message: `Bad Gateway: ${err.message}` }));
+    });
+    req.pipe(proxyReq);
+  }
+  dispose() {
+    if (this.childProcess) {
+      console.log(`[AppAdapter] Killing child process (PID: ${this.childProcess.pid}) for '${this.entityName}'`);
+      this.childProcess.kill("SIGTERM");
+      this.childProcess = null;
+    }
+    super.dispose();
+  }
+};
+
+export {
+  KrnlNonKrnlAppAdapter
+};

package/packages/core/dist/chunk-CR2ANE62.js

@@ -0,0 +1,107 @@
+import {
+  krnlSystemEntityBase
+} from "./chunk-ZZFRJGXM.js";
+import {
+  KrnlShell
+} from "./chunk-GADIRLRS.js";
+
+// src/core/K_LIB_Krnl_System_App_Adapter.ts
+import fs from "fs";
+import path from "path";
+import http from "http";
+import net from "net";
+var KrnlNonKrnlAppAdapter = class extends krnlSystemEntityBase {
+  childProcess = null;
+  appPort = -1;
+  appPath;
+  constructor(name, appPath) {
+    super(name, null, -1, "127.0.0.1", { Singleton: true, _skipMagneticLoading: true });
+    this.appPath = appPath;
+    this._isIngressNetworkMember = true;
+    this.unifiedHttpAdapter._handleRequest = async (req, res) => {
+      await this.proxyRequest(req, res, req.url || "/");
+    };
+  }
+  async startApp() {
+    this.appPort = await this._probeAvailablePort(11e3, "127.0.0.1");
+    let command = "node";
+    let args = ["."];
+    try {
+      const pkgPath = path.join(this.appPath, "package.json");
+      if (fs.existsSync(pkgPath)) {
+        const packageJson = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (packageJson.scripts?.start) {
+          command = "npm";
+          args = ["run", "start"];
+        } else if (packageJson.main) {
+          args = [packageJson.main];
+        }
+      }
+    } catch (_) {
+    }
+    const env = {
+      ...process.env,
+      PORT: this.appPort.toString()
+    };
+    console.log(`[AppAdapter] Spawning non-Krnl app '${this.entityName}' in background (Port: ${this.appPort})...`);
+    this.childProcess = KrnlShell.spawn(command, args, {
+      cwd: this.appPath,
+      env,
+      stdio: "inherit"
+    });
+    let ready = false;
+    const timeout = 15e3;
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      ready = await new Promise((resolve) => {
+        const socket = net.connect(this.appPort, "127.0.0.1");
+        socket.on("connect", () => {
+          socket.destroy();
+          resolve(true);
+        });
+        socket.on("error", () => resolve(false));
+      });
+      if (ready) break;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    if (!ready) {
+      throw new Error(`[AppAdapter] Non-Krnl app '${this.entityName}' failed to boot on port ${this.appPort} within 15s.`);
+    }
+    console.log(`[AppAdapter] Non-Krnl app '${this.entityName}' successfully booted.`);
+  }
+  async proxyRequest(req, res, subPath) {
+    if (this.appPort === -1) {
+      res.writeHead(503, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "error", message: "Service Temporarily Unavailable: Sub-app not running." }));
+      return;
+    }
+    const options = {
+      hostname: "127.0.0.1",
+      port: this.appPort,
+      path: subPath,
+      method: req.method,
+      headers: req.headers
+    };
+    const proxyReq = http.request(options, (proxyRes) => {
+      res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+      proxyRes.pipe(res);
+    });
+    proxyReq.on("error", (err) => {
+      res.writeHead(502, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "error", message: `Bad Gateway: ${err.message}` }));
+    });
+    req.pipe(proxyReq);
+  }
+  dispose() {
+    if (this.childProcess) {
+      console.log(`[AppAdapter] Killing child process (PID: ${this.childProcess.pid}) for '${this.entityName}'`);
+      this.childProcess.kill("SIGTERM");
+      this.childProcess = null;
+    }
+    super.dispose();
+  }
+};
+
+export {
+  KrnlNonKrnlAppAdapter
+};

package/packages/core/dist/chunk-DI27MOR7.js

@@ -0,0 +1,173 @@
+// src/core/K_LIB_Krnl_Telemetry.ts
+var KrnlTelemetry = class {
+  metrics;
+  callLogs;
+  libraryUsage;
+  dataUsage;
+  enabled;
+  ringBufferSize;
+  aiTraces;
+  totalAiCalls;
+  totalAiRetries;
+  avgAiLatencyMs;
+  runtimeStore = null;
+  constructor() {
+    this.metrics = /* @__PURE__ */ new Map();
+    this.callLogs = /* @__PURE__ */ new Map();
+    this.libraryUsage = /* @__PURE__ */ new Map();
+    this.dataUsage = /* @__PURE__ */ new Map();
+    this.enabled = false;
+    this.ringBufferSize = 100;
+    this.aiTraces = [];
+    this.totalAiCalls = 0;
+    this.totalAiRetries = 0;
+    this.avgAiLatencyMs = 0;
+  }
+  setRuntimeStore(store) {
+    this.runtimeStore = store;
+  }
+  recordAiTrace(trace) {
+    if (this.aiTraces.length >= this.ringBufferSize) {
+      this.aiTraces.shift();
+    }
+    this.aiTraces.push(trace);
+    this.totalAiCalls++;
+    this.totalAiRetries += trace.retryCount || 0;
+    this.avgAiLatencyMs = (this.avgAiLatencyMs * (this.totalAiCalls - 1) + trace.latencyMs) / this.totalAiCalls;
+    if (this.runtimeStore) {
+      this.runtimeStore.appendTelemetry({
+        type: "ai_trace",
+        endpointId: trace.endpointId,
+        timestamp: trace.timestamp,
+        latencyMs: trace.latencyMs,
+        retryCount: trace.retryCount,
+        success: !trace.failureReason,
+        failures: trace.validationFailures
+      }).catch(() => {
+      });
+    }
+  }
+  /**
+   * Starts a telemetry trace for a specific functionality.
+   * @param fid 
+   * @returns Trace data
+   */
+  startTrace(fid) {
+    return {
+      startTime: process.hrtime.bigint(),
+      startMemory: process.memoryUsage ? process.memoryUsage().heapUsed : 0
+    };
+  }
+  /**
+   * Ends a telemetry trace and updates aggregated metrics.
+   * @param fid 
+   * @param trace 
+   */
+  endTrace(fid, trace, success = true) {
+    const endTime = process.hrtime.bigint();
+    const endMemory = process.memoryUsage ? process.memoryUsage().heapUsed : 0;
+    const latencyNs = Number(endTime - trace.startTime);
+    const memoryDelta = endMemory - trace.startMemory;
+    const latencyMs = latencyNs / 1e6;
+    let stats = this.metrics.get(fid);
+    if (!stats) {
+      stats = {
+        calls: 0,
+        errors: 0,
+        totalLatencyNs: 0,
+        avgLatencyMs: 0,
+        peakLatencyMs: 0,
+        totalMemoryDelta: 0,
+        avgMemoryDelta: 0,
+        lastUpdated: 0
+      };
+      this.metrics.set(fid, stats);
+    }
+    stats.calls++;
+    if (!success) stats.errors++;
+    stats.totalLatencyNs += latencyNs;
+    stats.totalMemoryDelta += memoryDelta;
+    stats.avgLatencyMs = stats.totalLatencyNs / stats.calls / 1e6;
+    stats.avgMemoryDelta = stats.totalMemoryDelta / stats.calls;
+    if (latencyMs > stats.peakLatencyMs) stats.peakLatencyMs = latencyMs;
+    stats.lastUpdated = Date.now();
+    if (this.enabled) {
+      let logs = this.callLogs.get(fid);
+      if (!logs) {
+        logs = [];
+        this.callLogs.set(fid, logs);
+      }
+      logs.push({
+        timestamp: Date.now(),
+        durationMs: latencyMs,
+        success
+      });
+      if (logs.length > this.ringBufferSize) {
+        logs.shift();
+      }
+    }
+    if (this.runtimeStore) {
+      this.runtimeStore.appendTelemetry({
+        type: "standard_call",
+        endpointId: fid,
+        timestamp: Date.now(),
+        durationMs: latencyMs,
+        success
+      }).catch(() => {
+      });
+    }
+  }
+  /**
+   * Record library usage (functions/helpers).
+   */
+  recordLibraryCall(libraryId, durationMs) {
+    if (!this.enabled) return;
+    let stats = this.libraryUsage.get(libraryId);
+    if (!stats) {
+      stats = { calls: 0, totalDurationMs: 0, avgDurationMs: 0 };
+      this.libraryUsage.set(libraryId, stats);
+    }
+    stats.calls++;
+    stats.totalDurationMs += durationMs;
+    stats.avgDurationMs = stats.totalDurationMs / stats.calls;
+  }
+  /**
+   * Record library data access.
+   */
+  recordDataAccess(dataKey, type = "read") {
+    if (!this.enabled) return;
+    let stats = this.dataUsage.get(dataKey);
+    if (!stats) {
+      stats = { reads: 0, writes: 0 };
+      this.dataUsage.set(dataKey, stats);
+    }
+    if (type === "read") stats.reads++;
+    else stats.writes++;
+  }
+  /**
+   * Returns a snapshot of all metrics.
+   */
+  getSummary() {
+    return {
+      metrics: Object.fromEntries(this.metrics),
+      callLogs: Object.fromEntries(this.callLogs),
+      libraryUsage: Object.fromEntries(this.libraryUsage),
+      dataUsage: Object.fromEntries(this.dataUsage)
+    };
+  }
+  /**
+   * Clears all collected metrics.
+   */
+  reset() {
+    this.metrics.clear();
+    this.callLogs.clear();
+    this.libraryUsage.clear();
+    this.dataUsage.clear();
+  }
+};
+var telemetry = new KrnlTelemetry();
+
+export {
+  KrnlTelemetry,
+  telemetry
+};