@ultrst-armada/krnl 0.0.0-stage → 1.0.1

package/packages/create-krnl/dist/chunk-OHVMVRBP.js

@@ -0,0 +1,117 @@
+// ../core/dist/chunk-7WUETJEV.js
+import { Worker } from "worker_threads";
+import { fileURLToPath } from "url";
+import path from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var _rpcSeq = 0;
+var KrnlSubAppWorkerHost = class _KrnlSubAppWorkerHost {
+  prefix;
+  _worker;
+  _manifest;
+  _pending;
+  _ready;
+  _resolveReady;
+  _rejectReady;
+  constructor(prefix, worker) {
+    this.prefix = prefix;
+    this._worker = worker;
+    this._manifest = null;
+    this._pending = /* @__PURE__ */ new Map();
+    this._ready = new Promise((resolve, reject) => {
+      this._resolveReady = resolve;
+      this._rejectReady = reject;
+    });
+    this._worker.on("message", (msg) => {
+      if (msg.type === "manifest") {
+        this._manifest = msg.manifest;
+        this._resolveReady();
+        return;
+      }
+      if (msg.type === "result") {
+        const pending = this._pending.get(msg.requestId);
+        if (!pending) return;
+        clearTimeout(pending.timeoutId);
+        this._pending.delete(msg.requestId);
+        if (msg.ok) pending.resolve(msg.result);
+        else pending.reject(new Error(msg.error || "Worker sub-app error"));
+      }
+    });
+    this._worker.on("error", (err) => {
+      console.error(`[SubAppWorkerHost:${prefix}] Worker error:`, err.message || err);
+      this._rejectReady(err instanceof Error ? err : new Error(String(err)));
+      for (const [id, p] of this._pending) {
+        clearTimeout(p.timeoutId);
+        p.reject(err);
+        this._pending.delete(id);
+      }
+    });
+    this._worker.on("exit", (code) => {
+      if (code !== 0) {
+        console.error(`[SubAppWorkerHost:${prefix}] Worker exited with code ${code}`);
+      }
+    });
+  }
+  /**
+   * Spawn a worker_thread for the given sub-app config and wait for the manifest.
+   */
+  static async create(config, timeoutMs = 3e4) {
+    const runtimePath = path.resolve(__dirname, "K_LIB_Krnl_SubApp_Worker_Runtime.js");
+    const worker = new Worker(runtimePath, {
+      workerData: {
+        entryPath: config.entryPath ?? "",
+        prefix: config.prefix,
+        constructorArgs: config.constructorArgs ?? []
+      }
+    });
+    const host = new _KrnlSubAppWorkerHost(config.prefix, worker);
+    const timeout = new Promise(
+      (_, reject) => setTimeout(() => reject(new Error(`[SubAppWorkerHost:${config.prefix}] Timed out waiting for worker ready signal.`)), timeoutMs)
+    );
+    await Promise.race([host._ready, timeout]);
+    return host;
+  }
+  /**
+   * Call a functionality on the worker-hosted sub-app.
+   * This is the primary dispatch path for worker-mode sub-apps.
+   * Uses MessagePort IPC — no networking.
+   */
+  async callInternal(fid, input = {}, timeoutMs = 3e4) {
+    const requestId = `wkr_${Date.now()}_${(_rpcSeq++).toString(36)}`;
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this._pending.delete(requestId);
+        reject(new Error(`[SubAppWorkerHost:${this.prefix}] Call '${fid}' timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this._pending.set(requestId, { resolve, reject, timeoutId });
+      this._worker.postMessage({ type: "call", requestId, fid, input });
+    });
+  }
+  /**
+   * Alias so both local entities and worker hosts expose the same dispatch surface.
+   */
+  async call(fid, input = {}) {
+    return this.callInternal(fid, input);
+  }
+  /**
+   * Returns the sub-app manifest obtained from the worker at startup.
+   */
+  getManifest() {
+    return this._manifest;
+  }
+  /**
+   * Terminate the worker thread gracefully.
+   */
+  async gracefulShutdown() {
+    try {
+      this._worker.postMessage({ type: "shutdown" });
+      await new Promise((resolve) => setTimeout(resolve, 5e3));
+    } finally {
+      await this._worker.terminate();
+    }
+  }
+};
+
+export {
+  KrnlSubAppWorkerHost
+};

package/packages/create-krnl/dist/chunk-Q45257P6.js

@@ -0,0 +1,173 @@
+// ../core/dist/chunk-DI27MOR7.js
+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
+};

package/packages/create-krnl/dist/chunk-QGM4M3NI.js

@@ -0,0 +1,37 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};