@ultrst-armada/krnl 1.0.17 → 1.0.19

package/packages/core/dist/index.js

@@ -62,8 +62,60 @@ var LifecycleManager = class {
   }
 };
 
-// src/telemetry/TelemetryController.ts
+// src/telemetry/TelemetryInternals.ts
 import { randomUUID } from "crypto";
+var createTelemetryId = (prefix) => `${prefix}_${randomUUID()}`;
+
+// src/telemetry/TelemetrySnapshotBuilder.ts
+function percentiles(values) {
+  if (!values.length) return { min: 0, mean: 0, p50: 0, p90: 0, p95: 0, p99: 0, max: 0 };
+  const sorted = [...values].sort((a, b) => a - b);
+  const pick = (p) => sorted[Math.min(sorted.length - 1, Math.floor((sorted.length - 1) * p))];
+  return {
+    min: sorted[0],
+    mean: sorted.reduce((sum, value) => sum + value, 0) / sorted.length,
+    p50: pick(0.5),
+    p90: pick(0.9),
+    p95: pick(0.95),
+    p99: pick(0.99),
+    max: sorted[sorted.length - 1]
+  };
+}
+function buildTelemetrySnapshot(input) {
+  const invocations = input.invocations.slice();
+  const durations = invocations.map((item) => item.durationMs);
+  const targetMap = /* @__PURE__ */ new Map();
+  for (const invocation of invocations) {
+    const key = `${invocation.kind}:${invocation.target}`;
+    const group = targetMap.get(key) ?? [];
+    group.push(invocation);
+    targetMap.set(key, group);
+  }
+  const targets = [...targetMap.values()].map((group) => ({
+    target: group[0].target,
+    kind: group[0].kind,
+    count: group.length,
+    successCount: group.filter((item) => item.status === "completed").length,
+    errorCount: group.filter((item) => item.status === "failed").length,
+    durationMs: percentiles(group.map((item) => item.durationMs)),
+    lastInvocationAt: group[group.length - 1]?.completedAt
+  }));
+  return {
+    serviceId: input.serviceId,
+    mode: input.mode,
+    capturedAt: Date.now(),
+    status: input.status,
+    totals: {
+      invocationCount: input.totalInvocationCount,
+      successCount: input.totalSuccessCount,
+      errorCount: input.totalErrorCount,
+      durationMs: percentiles(durations)
+    },
+    targets,
+    activeInvocations: input.activeInvocations,
+    recentInvocations: invocations.slice(-input.maxRecentInvocations)
+  };
+}
 
 // src/telemetry/TelemetryResources.ts
 var runtimeProcess = typeof globalThis !== "undefined" ? globalThis.process : void 0;
@@ -103,21 +155,6 @@ function deltaResources(start, end) {
 }
 
 // src/telemetry/TelemetryController.ts
-var id = (prefix) => `${prefix}_${randomUUID()}`;
-function percentiles(values) {
-  if (!values.length) return { min: 0, mean: 0, p50: 0, p90: 0, p95: 0, p99: 0, max: 0 };
-  const sorted = [...values].sort((a, b) => a - b);
-  const pick = (p) => sorted[Math.min(sorted.length - 1, Math.floor((sorted.length - 1) * p))];
-  return {
-    min: sorted[0],
-    mean: sorted.reduce((sum, value) => sum + value, 0) / sorted.length,
-    p50: pick(0.5),
-    p90: pick(0.9),
-    p95: pick(0.95),
-    p99: pick(0.99),
-    max: sorted[sorted.length - 1]
-  };
-}
 var TelemetryController = class {
   constructor(serviceId, options = {}) {
     this.serviceId = serviceId;
@@ -169,9 +206,9 @@ var TelemetryController = class {
         end: () => void 0
       };
     }
-    const invocationId = id("inv");
-    const spanId = id("span");
-    const traceId = parentSpanId ? this.findTraceId(parentSpanId) ?? id("trace") : id("trace");
+    const invocationId = createTelemetryId("inv");
+    const spanId = createTelemetryId("span");
+    const traceId = parentSpanId ? this.findTraceId(parentSpanId) ?? createTelemetryId("trace") : createTelemetryId("trace");
     const active = {
       invocationId,
       traceId,
@@ -202,39 +239,17 @@ var TelemetryController = class {
     this.lastInvocationAt = void 0;
   }
   snapshot() {
-    const invocations = this.samples.slice();
-    const durations = invocations.map((item) => item.durationMs);
-    const targetMap = /* @__PURE__ */ new Map();
-    for (const invocation of invocations) {
-      const key = `${invocation.kind}:${invocation.target}`;
-      const group = targetMap.get(key) ?? [];
-      group.push(invocation);
-      targetMap.set(key, group);
-    }
-    const targets = [...targetMap.values()].map((group) => ({
-      target: group[0].target,
-      kind: group[0].kind,
-      count: group.length,
-      successCount: group.filter((item) => item.status === "completed").length,
-      errorCount: group.filter((item) => item.status === "failed").length,
-      durationMs: percentiles(group.map((item) => item.durationMs)),
-      lastInvocationAt: group[group.length - 1]?.completedAt
-    }));
-    return {
+    return buildTelemetrySnapshot({
       serviceId: this.serviceId,
       mode: this.mode,
-      capturedAt: Date.now(),
+      invocations: this.samples,
       status: this.status(),
-      totals: {
-        invocationCount: this.totalInvocationCount,
-        successCount: this.totalSuccessCount,
-        errorCount: this.totalErrorCount,
-        durationMs: percentiles(durations)
-      },
-      targets,
+      totalInvocationCount: this.totalInvocationCount,
+      totalSuccessCount: this.totalSuccessCount,
+      totalErrorCount: this.totalErrorCount,
       activeInvocations: this.active.size,
-      recentInvocations: invocations.slice(-this.maxRecentInvocations)
-    };
+      maxRecentInvocations: this.maxRecentInvocations
+    });
   }
   functionality(name) {
     return this.snapshot().targets.find((target) => target.kind === "functionality" && target.target === name);
@@ -638,22 +653,22 @@ var FunctionalityFacade = class {
   definition;
   eventBus;
   events;
-  constructor(id2, definition, options = {}) {
-    if (!id2 || typeof id2 !== "string") {
+  constructor(id, definition, options = {}) {
+    if (!id || typeof id !== "string") {
       throw new Error("[FunctionalityFacade] Functionality id must be a non-empty string.");
     }
     if (!definition || typeof definition.execute !== "function") {
-      throw new Error(`[FunctionalityFacade:${id2}] Functionality must define execute().`);
+      throw new Error(`[FunctionalityFacade:${id}] Functionality must define execute().`);
     }
-    this.id = id2;
-    this.name = definition.name || id2;
+    this.id = id;
+    this.name = definition.name || id;
     this.description = definition.description || "";
     this.bubbleEvents = options.bubbleEvents ?? definition.bubbleEvents ?? true;
     this.definition = definition;
     this.eventBus = new EventBus();
     for (const reserved of ["triggered", "completed", "failed"]) {
       if (definition.events && reserved in definition.events) {
-        throw new Error(`[FunctionalityFacade:${id2}] Event '${reserved}' is reserved for functionality lifecycle.`);
+        throw new Error(`[FunctionalityFacade:${id}] Event '${reserved}' is reserved for functionality lifecycle.`);
       }
     }
     const eventNames = [
@@ -767,11 +782,11 @@ var PriorityQueue = class {
     return item.run;
   }
   enqueue(run, options) {
-    const { priority = 0, id: id2 } = options ?? {};
+    const { priority = 0, id } = options ?? {};
     const { size } = this;
     const element = {
       priority,
-      id: id2,
+      id,
       run
     };
     if (size === 0) {
@@ -788,16 +803,16 @@ var PriorityQueue = class {
     const index = lowerBound(this.#queue, element, (a, b) => a.priority === b.priority ? 0 : b.priority - a.priority);
     this.#queue.splice(index, 0, element);
   }
-  setPriority(id2, priority) {
-    const index = this.#findIndex((element) => element.id === id2);
+  setPriority(id, priority) {
+    const index = this.#findIndex((element) => element.id === id);
     if (index === -1) {
-      throw new ReferenceError(`No promise function with the id "${id2}" exists in the queue.`);
+      throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
     }
     if (this.#queue[index].priority === priority) {
       return;
     }
     const [item] = this.#queue.splice(index, 1);
-    this.enqueue(item.run, { priority, id: id2 });
+    this.enqueue(item.run, { priority, id });
   }
   remove(idOrRun) {
     const index = this.#findIndex((element) => (typeof idOrRun === "string" ? element.id : element.run) === idOrRun);
@@ -1213,17 +1228,17 @@ var PQueue = class extends EventTarget {
     }
   }
   async #add(function_, options, waitingTask) {
-    const id2 = options.id ?? (this.#idAssigner++).toString();
+    const id = options.id ?? (this.#idAssigner++).toString();
     options = {
       timeout: this.#timeout,
       ...options,
-      id: id2
+      id
     };
     validateTimeout(options.timeout);
     if (options.priority !== void 0 && (typeof options.priority !== "number" || Number.isNaN(options.priority))) {
       throw new TypeError(`Expected \`priority\` to be a number, got \`${String(options.priority)}\` (${typeof options.priority})`);
     }
-    waitingTask.id = id2;
+    waitingTask.id = id;
     waitingTask.priority = options.priority ?? 0;
     return new Promise((resolve, reject) => {
       if (options.signal?.aborted) {
@@ -1240,7 +1255,7 @@ var PQueue = class extends EventTarget {
         }
         this.#pending++;
         const runningTask = {
-          id: id2,
+          id,
           priority: waitingTask.priority,
           startTime: Date.now(),
           timeout: options.timeout
@@ -1307,7 +1322,7 @@ var PQueue = class extends EventTarget {
           if (this.#queue instanceof PriorityQueue) {
             this.#queue.remove(run);
           } else {
-            this.#queue.remove(id2);
+            this.#queue.remove(id);
           }
           reject(signal.reason);
           this.#processQueue();
@@ -1383,18 +1398,18 @@ var PQueue = class extends EventTarget {
       // '🦀' runs last
       ```
       */
-  setPriority(id2, priority) {
+  setPriority(id, priority) {
     if (typeof priority !== "number" || !Number.isFinite(priority)) {
       throw new TypeError(`Expected \`priority\` to be a finite number, got \`${priority}\` (${typeof priority})`);
     }
     for (const waitingTask of this.#waitingTasks) {
-      if (waitingTask.id === id2) {
-        this.#queue.setPriority(id2, priority);
+      if (waitingTask.id === id) {
+        this.#queue.setPriority(id, priority);
         waitingTask.priority = priority;
         return;
       }
     }
-    throw new ReferenceError(`No promise function with the id "${id2}" exists in the queue.`);
+    throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
   }
   /**
       Adds a sync or async task to the queue.
@@ -1739,7 +1754,7 @@ var TimeoutError = class extends DOMException {
 // src/orchestration/canonical/KrnlQ.ts
 import { randomUUID as randomUUID2 } from "crypto";
 
-// src/orchestration/canonical/model.ts
+// src/orchestration/canonical/dagValidation.ts
 function validateOrchestrationDAG(steps) {
   const errors = [];
   const stepMap = /* @__PURE__ */ new Map();
@@ -1804,8 +1819,8 @@ function validateOrchestrationDAG(steps) {
     }
   }
   const queue = [];
-  for (const [id2, deg] of inDegree.entries()) {
-    if (deg === 0) queue.push(id2);
+  for (const [id, deg] of inDegree.entries()) {
+    if (deg === 0) queue.push(id);
   }
   const order = [];
   while (queue.length > 0) {
@@ -2009,9 +2024,9 @@ var KrnlQueue = class {
     if (this.jobs.size <= this.maxRetainedJobs) return;
     const excess = this.jobs.size - this.maxRetainedJobs;
     let pruned = 0;
-    for (const [id2, record] of this.jobs.entries()) {
+    for (const [id, record] of this.jobs.entries()) {
       if (record.status === "completed" || record.status === "failed" || record.status === "cancelled") {
-        this.jobs.delete(id2);
+        this.jobs.delete(id);
         pruned++;
         if (pruned >= excess) break;
       }
@@ -3576,9 +3591,9 @@ var ServiceRuntime = class {
 // src/discovery/ServiceDiscovery.ts
 var ServiceDiscovery = class {
   peers = /* @__PURE__ */ new Map();
-  registerPeer(id2, name, endpoints) {
-    this.peers.set(id2, {
-      id: id2,
+  registerPeer(id, name, endpoints) {
+    this.peers.set(id, {
+      id,
       name,
       endpoints,
       lastSeen: Date.now()
@@ -3587,8 +3602,8 @@ var ServiceDiscovery = class {
   getPeers() {
     return Array.from(this.peers.values());
   }
-  findPeer(id2) {
-    return this.peers.get(id2);
+  findPeer(id) {
+    return this.peers.get(id);
   }
 };
 

package/packages/validate/dist/index.cjs

@@ -36,8 +36,8 @@ module.exports = __toCommonJS(index_exports);
 
 // src/KrnlValidatorEngine.ts
 var fs2 = __toESM(require("fs"), 1);
-var path3 = __toESM(require("path"), 1);
-var import_ts_morph5 = require("ts-morph");
+var path4 = __toESM(require("path"), 1);
+var import_ts_morph6 = require("ts-morph");
 
 // src/rules/fileLimits.ts
 function checkFileLimits(sf, options) {
@@ -312,6 +312,9 @@ function checkOrchestrationRules(sf) {
 
 // src/rules/workspaceRules.ts
 var fs = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+
+// src/rules/topLevelPurityRules.ts
 var path2 = __toESM(require("path"), 1);
 var import_ts_morph3 = require("ts-morph");
 function checkTopLevelPurity(sf) {
@@ -377,25 +380,27 @@ function checkTopLevelPurity(sf) {
   }
   return { errors, warnings };
 }
+
+// src/rules/workspaceRules.ts
 function checkWorkspaceLayout(projectRoot, errors) {
-  const krnlDir = path2.join(projectRoot, "krnl");
-  const srcDir = path2.join(projectRoot, "src");
+  const krnlDir = path3.join(projectRoot, "krnl");
+  const srcDir = path3.join(projectRoot, "src");
   const targetDir = fs.existsSync(krnlDir) ? krnlDir : fs.existsSync(srcDir) ? srcDir : null;
   if (!targetDir) return;
-  const backendDir = path2.join(targetDir, "backend");
-  const frontendDir = path2.join(targetDir, "frontend");
+  const backendDir = path3.join(targetDir, "backend");
+  const frontendDir = path3.join(targetDir, "frontend");
   if (fs.existsSync(backendDir)) {
-    const bServices = path2.join(backendDir, "services");
+    const bServices = path3.join(backendDir, "services");
     if (fs.existsSync(bServices)) {
       for (const sEntry of fs.readdirSync(bServices, { withFileTypes: true })) {
         if (!sEntry.isDirectory()) continue;
-        const sDir = path2.join(bServices, sEntry.name);
-        const sLibs = path2.join(sDir, "libraries");
+        const sDir = path3.join(bServices, sEntry.name);
+        const sLibs = path3.join(sDir, "libraries");
         if (fs.existsSync(sLibs)) {
           for (const entry of fs.readdirSync(sLibs, { withFileTypes: true })) {
             if (!entry.isDirectory()) continue;
-            const libPath = path2.join(sLibs, entry.name);
-            if (!fs.existsSync(path2.join(libPath, "manifest.json"))) {
+            const libPath = path3.join(sLibs, entry.name);
+            if (!fs.existsSync(path3.join(libPath, "manifest.json"))) {
               errors.push({
                 ruleId: "krnl/concept-manifest-required",
                 filePath: libPath,
@@ -405,12 +410,12 @@ function checkWorkspaceLayout(projectRoot, errors) {
             }
           }
         }
-        const sFuncs = path2.join(sDir, "functionalities");
+        const sFuncs = path3.join(sDir, "functionalities");
         if (fs.existsSync(sFuncs)) {
           for (const entry of fs.readdirSync(sFuncs, { withFileTypes: true })) {
             if (!entry.isDirectory()) continue;
-            const funcPath = path2.join(sFuncs, entry.name);
-            if (!fs.existsSync(path2.join(funcPath, "manifest.json"))) {
+            const funcPath = path3.join(sFuncs, entry.name);
+            if (!fs.existsSync(path3.join(funcPath, "manifest.json"))) {
               errors.push({
                 ruleId: "krnl/functionality-manifest-required",
                 filePath: funcPath,
@@ -422,12 +427,12 @@ function checkWorkspaceLayout(projectRoot, errors) {
         }
       }
     }
-    const bLibs = path2.join(backendDir, "libraries");
+    const bLibs = path3.join(backendDir, "libraries");
     if (fs.existsSync(bLibs)) {
       for (const entry of fs.readdirSync(bLibs, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const libPath = path2.join(bLibs, entry.name);
-        if (!fs.existsSync(path2.join(libPath, "manifest.json"))) {
+        const libPath = path3.join(bLibs, entry.name);
+        if (!fs.existsSync(path3.join(libPath, "manifest.json"))) {
           errors.push({
             ruleId: "krnl/concept-manifest-required",
             filePath: libPath,
@@ -437,12 +442,12 @@ function checkWorkspaceLayout(projectRoot, errors) {
         }
       }
     }
-    const bFuncs = path2.join(backendDir, "functionalities");
+    const bFuncs = path3.join(backendDir, "functionalities");
     if (fs.existsSync(bFuncs)) {
       for (const entry of fs.readdirSync(bFuncs, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const funcPath = path2.join(bFuncs, entry.name);
-        if (!fs.existsSync(path2.join(funcPath, "manifest.json"))) {
+        const funcPath = path3.join(bFuncs, entry.name);
+        if (!fs.existsSync(path3.join(funcPath, "manifest.json"))) {
           errors.push({
             ruleId: "krnl/functionality-manifest-required",
             filePath: funcPath,
@@ -454,12 +459,12 @@ function checkWorkspaceLayout(projectRoot, errors) {
     }
   }
   if (fs.existsSync(frontendDir)) {
-    const fLibs = path2.join(frontendDir, "libraries");
+    const fLibs = path3.join(frontendDir, "libraries");
     if (fs.existsSync(fLibs)) {
       for (const entry of fs.readdirSync(fLibs, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const libPath = path2.join(fLibs, entry.name);
-        if (!fs.existsSync(path2.join(libPath, "manifest.json"))) {
+        const libPath = path3.join(fLibs, entry.name);
+        if (!fs.existsSync(path3.join(libPath, "manifest.json"))) {
           errors.push({
             ruleId: "krnl/frontend-concept-manifest-required",
             filePath: libPath,
@@ -469,12 +474,12 @@ function checkWorkspaceLayout(projectRoot, errors) {
         }
       }
     }
-    const fFuncs = path2.join(frontendDir, "functionalities");
+    const fFuncs = path3.join(frontendDir, "functionalities");
     if (fs.existsSync(fFuncs)) {
       for (const entry of fs.readdirSync(fFuncs, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const funcPath = path2.join(fFuncs, entry.name);
-        if (!fs.existsSync(path2.join(funcPath, "manifest.json"))) {
+        const funcPath = path3.join(fFuncs, entry.name);
+        if (!fs.existsSync(path3.join(funcPath, "manifest.json"))) {
           errors.push({
             ruleId: "krnl/frontend-functionality-manifest-required",
             filePath: funcPath,
@@ -518,6 +523,9 @@ function checkServiceBoundaries(sf) {
 }
 
 // src/rules/scopedLibraryRules.ts
+var import_ts_morph5 = require("ts-morph");
+
+// src/rules/scopedLibraryTypeHelpers.ts
 var import_ts_morph4 = require("ts-morph");
 var PRIMITIVE_AND_BUILTIN_TYPES = /* @__PURE__ */ new Set([
   "string",
@@ -570,14 +578,6 @@ var PRIMITIVE_AND_BUILTIN_TYPES = /* @__PURE__ */ new Set([
   "ReturnType",
   "InstanceType"
 ]);
-function detectServiceContext(filePath) {
-  const normalized = filePath.replace(/\\/g, "/");
-  const match = normalized.match(/(?:^|\/)services\/([^/]+)\/libraries\/([^/]+)/);
-  if (match) {
-    return { serviceName: match[1], libraryName: match[2] };
-  }
-  return null;
-}
 function containsIdentifier(name, target) {
   return name.toLowerCase().includes(target.toLowerCase());
 }
@@ -598,6 +598,16 @@ function hasContextualTypeReference(node, serviceName, localTypes) {
   }
   return false;
 }
+
+// src/rules/scopedLibraryRules.ts
+function detectServiceContext(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const match = normalized.match(/(?:^|\/)services\/([^/]+)\/libraries\/([^/]+)/);
+  if (match) {
+    return { serviceName: match[1], libraryName: match[2] };
+  }
+  return null;
+}
 function checkScopedLibraryRules(sf) {
   const errors = [];
   const warnings = [];
@@ -647,7 +657,7 @@ function checkScopedLibraryRules(sf) {
     for (const decl of stmt.getDeclarations()) {
       const varName = decl.getName();
       const init = decl.getInitializer();
-      const isFunction = init && (init.getKind() === import_ts_morph4.SyntaxKind.ArrowFunction || init.getKind() === import_ts_morph4.SyntaxKind.FunctionExpression);
+      const isFunction = init && (init.getKind() === import_ts_morph5.SyntaxKind.ArrowFunction || init.getKind() === import_ts_morph5.SyntaxKind.FunctionExpression);
       if (isFunction) {
         const isContextual = hasContextualTypeReference(decl, serviceName, localTypes);
         const hasServiceName = containsIdentifier(varName, serviceName);
@@ -738,17 +748,17 @@ var KrnlValidatorEngine = class {
   limitOptions;
   constructor(optionsOrRoot) {
     const options = typeof optionsOrRoot === "string" ? { projectRoot: optionsOrRoot } : optionsOrRoot;
-    this.projectRoot = path3.resolve(options.projectRoot || process.cwd());
+    this.projectRoot = path4.resolve(options.projectRoot || process.cwd());
     this.limitOptions = {
       maxFileLineLimit: options.maxFileLineLimit ?? 200,
       maxMainLogicLimit: options.maxMainLogicLimit ?? 20,
       maxHelperLineLimit: options.maxHelperLineLimit ?? 30
     };
-    const tsConfigPath = path3.join(this.projectRoot, "tsconfig.json");
+    const tsConfigPath = path4.join(this.projectRoot, "tsconfig.json");
     if (fs2.existsSync(tsConfigPath)) {
-      this.project = new import_ts_morph5.Project({ tsConfigFilePath: tsConfigPath, skipAddingFilesFromTsConfig: true });
+      this.project = new import_ts_morph6.Project({ tsConfigFilePath: tsConfigPath, skipAddingFilesFromTsConfig: true });
     } else {
-      this.project = new import_ts_morph5.Project({ compilerOptions: {
+      this.project = new import_ts_morph6.Project({ compilerOptions: {
         target: 99
         /* ESNext */
       } });
@@ -779,7 +789,7 @@ var KrnlValidatorEngine = class {
   }
   validateSourceFile(sf) {
     const filePath = sf.getFilePath();
-    const baseName = path3.basename(filePath);
+    const baseName = path4.basename(filePath);
     if (baseName.includes("_pb.") || baseName.endsWith(".d.ts")) {
       return { errors: [], warnings: [], promotableAssets: [] };
     }
@@ -814,7 +824,7 @@ var KrnlValidatorEngine = class {
     const entries = fs2.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
-      const full = path3.join(dir, entry.name);
+      const full = path4.join(dir, entry.name);
       if (entry.isDirectory()) {
         this.collectSourceFiles(full, collected);
       } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js") || entry.name.endsWith(".tsx") || entry.name.endsWith(".jsx"))) {