@ultrst-armada/krnl 1.0.17 → 1.0.19

package/packages/cli/dist/index.cjs

@@ -40,15 +40,17 @@ module.exports = __toCommonJS(index_exports);
 
 // ../validate/dist/index.js
 var fs2 = __toESM(require("fs"), 1);
-var path3 = __toESM(require("path"), 1);
+var path4 = __toESM(require("path"), 1);
 var import_ts_morph = require("ts-morph");
 var path = __toESM(require("path"), 1);
 var import_ts_morph2 = require("ts-morph");
 var import_ts_morph3 = require("ts-morph");
 var fs = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
 var path2 = __toESM(require("path"), 1);
 var import_ts_morph4 = require("ts-morph");
 var import_ts_morph5 = require("ts-morph");
+var import_ts_morph6 = require("ts-morph");
 function checkFileLimits(sf, options) {
   const errors = [];
   const warnings = [];
@@ -375,24 +377,24 @@ function checkTopLevelPurity(sf) {
   return { errors, warnings };
 }
 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,
@@ -402,12 +404,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,
@@ -419,12 +421,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,
@@ -434,12 +436,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,
@@ -451,12 +453,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,
@@ -466,12 +468,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,
@@ -562,14 +564,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());
 }
@@ -581,7 +575,7 @@ function isCustomContextualType(typeName, serviceName, localTypes) {
   return false;
 }
 function hasContextualTypeReference(node, serviceName, localTypes) {
-  const typeRefs = node.getDescendantsOfKind(import_ts_morph5.SyntaxKind.TypeReference);
+  const typeRefs = node.getDescendantsOfKind(import_ts_morph6.SyntaxKind.TypeReference);
   for (const ref of typeRefs) {
     const text = ref.getTypeName().getText().trim();
     if (isCustomContextualType(text, serviceName, localTypes)) {
@@ -590,6 +584,14 @@ function hasContextualTypeReference(node, serviceName, localTypes) {
   }
   return false;
 }
+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 = [];
@@ -728,13 +730,13 @@ 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_morph.Project({ tsConfigFilePath: tsConfigPath, skipAddingFilesFromTsConfig: true });
     } else {
@@ -769,7 +771,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: [] };
     }
@@ -804,7 +806,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"))) {
@@ -852,24 +854,24 @@ async function runValidate(projectRoot = process.cwd()) {
 }
 
 // src/commands/generators/functionalityOrchestrationGenerator.ts
-var path5 = __toESM(require("path"), 1);
+var path6 = __toESM(require("path"), 1);
 var fs4 = __toESM(require("fs"), 1);
 
 // src/commands/generators/common.ts
 var fs3 = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
+var path5 = __toESM(require("path"), 1);
 function getPlaneRoots(projectRoot) {
-  const krnlRoot = path4.join(projectRoot, "krnl");
+  const krnlRoot = path5.join(projectRoot, "krnl");
   if (fs3.existsSync(krnlRoot)) {
     return {
-      backend: path4.join(krnlRoot, "backend"),
-      frontend: path4.join(krnlRoot, "frontend"),
+      backend: path5.join(krnlRoot, "backend"),
+      frontend: path5.join(krnlRoot, "frontend"),
       isKrnlDir: true
     };
   }
   return {
-    backend: path4.join(projectRoot, "src"),
-    frontend: path4.join(projectRoot, "src"),
+    backend: path5.join(projectRoot, "src"),
+    frontend: path5.join(projectRoot, "src"),
     isKrnlDir: false
   };
 }
@@ -877,10 +879,10 @@ function getPlaneRoots(projectRoot) {
 // src/commands/generators/functionalityOrchestrationGenerator.ts
 function generateFunctionalityOrchestration(name, projectRoot) {
   const { backend } = getPlaneRoots(projectRoot);
-  const orchDir = path5.join(backend, "orchestrations", name);
-  fs4.mkdirSync(path5.join(orchDir, "tests"), { recursive: true });
+  const orchDir = path6.join(backend, "orchestrations", name);
+  fs4.mkdirSync(path6.join(orchDir, "tests"), { recursive: true });
   fs4.writeFileSync(
-    path5.join(orchDir, `${name}FunctionalityOrchestration.ts`),
+    path6.join(orchDir, `${name}FunctionalityOrchestration.ts`),
     `import { FunctionalityOrchestration } from '@ultrst-armada/krnl-core';
 
 /**
@@ -906,7 +908,7 @@ export default ${name}FunctionalityOrchestration;
 `
   );
   fs4.writeFileSync(
-    path5.join(orchDir, "tests", `${name}FunctionalityOrchestration.test.ts`),
+    path6.join(orchDir, "tests", `${name}FunctionalityOrchestration.test.ts`),
     `import { describe, it, expect } from 'vitest';
 import { ${name}FunctionalityOrchestration } from '../${name}FunctionalityOrchestration.js';
 
@@ -925,11 +927,11 @@ describe('${name}FunctionalityOrchestration', () => {
 
 // src/commands/generators/functionalityGenerator.ts
 var fs6 = __toESM(require("fs"), 1);
-var path7 = __toESM(require("path"), 1);
+var path8 = __toESM(require("path"), 1);
 
 // ../core/dist/index.js
 var fs5 = __toESM(require("fs"), 1);
-var path6 = __toESM(require("path"), 1);
+var path7 = __toESM(require("path"), 1);
 var import_gutts = require("@dinilmusick/gutts");
 var gutts = __toESM(require("@dinilmusick/gutts"), 1);
 var runtimeProcess = typeof globalThis !== "undefined" ? globalThis.process : void 0;
@@ -982,7 +984,7 @@ var KrnlPackageReconciler = class {
       }
       resolvedDevDeps[pkg] = versions[versions.length - 1];
     }
-    const pkgJsonPath = path6.join(projectRoot, "package.json");
+    const pkgJsonPath = path7.join(projectRoot, "package.json");
     let updated = false;
     if (fs5.existsSync(pkgJsonPath)) {
       const pkgContent = JSON.parse(fs5.readFileSync(pkgJsonPath, "utf8"));
@@ -1020,15 +1022,15 @@ var KrnlPackageReconciler = class {
    */
   static findManifests(projectRoot) {
     const searchDirs = [
-      path6.join(projectRoot, "krnl", "backend", "services"),
-      path6.join(projectRoot, "krnl", "backend", "libraries"),
-      path6.join(projectRoot, "krnl", "backend", "functionalities"),
-      path6.join(projectRoot, "krnl", "frontend", "libraries"),
-      path6.join(projectRoot, "krnl", "frontend", "functionalities"),
-      path6.join(projectRoot, "src", "backend", "services"),
-      path6.join(projectRoot, "src", "services"),
-      path6.join(projectRoot, "src", "functionalities"),
-      path6.join(projectRoot, "src", "libraries")
+      path7.join(projectRoot, "krnl", "backend", "services"),
+      path7.join(projectRoot, "krnl", "backend", "libraries"),
+      path7.join(projectRoot, "krnl", "backend", "functionalities"),
+      path7.join(projectRoot, "krnl", "frontend", "libraries"),
+      path7.join(projectRoot, "krnl", "frontend", "functionalities"),
+      path7.join(projectRoot, "src", "backend", "services"),
+      path7.join(projectRoot, "src", "services"),
+      path7.join(projectRoot, "src", "functionalities"),
+      path7.join(projectRoot, "src", "libraries")
     ];
     const found = [];
     for (const dir of searchDirs) {
@@ -1043,7 +1045,7 @@ var KrnlPackageReconciler = class {
       const entries = fs5.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
-        const full = path6.join(dir, entry.name);
+        const full = path7.join(dir, entry.name);
         if (entry.isDirectory()) {
           this.scanRecursive(full, found);
         } else if (entry.isFile() && entry.name === "manifest.json") {
@@ -1061,7 +1063,7 @@ function generateFunctionality(name, projectRoot, parentServiceOrOptions) {
   const options = typeof parentServiceOrOptions === "string" ? { parentService: parentServiceOrOptions } : parentServiceOrOptions || {};
   let targetService = options.parentService;
   if (!targetService) {
-    const servicesDir = path7.join(backend, "services");
+    const servicesDir = path8.join(backend, "services");
     if (fs6.existsSync(servicesDir)) {
       const existing = fs6.readdirSync(servicesDir, { withFileTypes: true }).filter((d) => d.isDirectory());
       if (existing.length === 1) {
@@ -1069,15 +1071,15 @@ function generateFunctionality(name, projectRoot, parentServiceOrOptions) {
       }
     }
   }
-  const bFuncDir = targetService ? path7.join(backend, "services", targetService, "functionalities", name) : path7.join(backend, "functionalities", name);
-  fs6.mkdirSync(path7.join(bFuncDir, "main_function"), { recursive: true });
-  fs6.mkdirSync(path7.join(bFuncDir, "helper_functions"), { recursive: true });
-  fs6.mkdirSync(path7.join(bFuncDir, "events"), { recursive: true });
-  fs6.mkdirSync(path7.join(bFuncDir, "tests"), { recursive: true });
+  const bFuncDir = targetService ? path8.join(backend, "services", targetService, "functionalities", name) : path8.join(backend, "functionalities", name);
+  fs6.mkdirSync(path8.join(bFuncDir, "main_function"), { recursive: true });
+  fs6.mkdirSync(path8.join(bFuncDir, "helper_functions"), { recursive: true });
+  fs6.mkdirSync(path8.join(bFuncDir, "events"), { recursive: true });
+  fs6.mkdirSync(path8.join(bFuncDir, "tests"), { recursive: true });
   if (options.withState) {
-    fs6.mkdirSync(path7.join(bFuncDir, "state_data"), { recursive: true });
+    fs6.mkdirSync(path8.join(bFuncDir, "state_data"), { recursive: true });
     fs6.writeFileSync(
-      path7.join(bFuncDir, "state_data", "state.ts"),
+      path8.join(bFuncDir, "state_data", "state.ts"),
       `export interface ${name}State {
   executionCount: number;
 }
@@ -1089,7 +1091,7 @@ export const initialState: ${name}State = {
     );
   }
   fs6.writeFileSync(
-    path7.join(bFuncDir, `${name}Atom.ts`),
+    path8.join(bFuncDir, `${name}Atom.ts`),
     `export interface ${name}Input {
   payload?: string;
 }
@@ -1101,7 +1103,7 @@ export interface ${name}Output {
 `
   );
   fs6.writeFileSync(
-    path7.join(bFuncDir, "manifest.json"),
+    path8.join(bFuncDir, "manifest.json"),
     JSON.stringify(
       {
         name,
@@ -1114,7 +1116,7 @@ export interface ${name}Output {
     )
   );
   fs6.writeFileSync(
-    path7.join(bFuncDir, "main_function", "logic.ts"),
+    path8.join(bFuncDir, "main_function", "logic.ts"),
     `import type { ${name}Input, ${name}Output } from "../${name}Atom.js";
 
 export const main = async (input: ${name}Input, context: any): Promise<${name}Output> => {
@@ -1126,13 +1128,13 @@ export const main = async (input: ${name}Input, context: any): Promise<${name}Ou
 `
   );
   fs6.writeFileSync(
-    path7.join(bFuncDir, "main_function", "lifecycle.ts"),
+    path8.join(bFuncDir, "main_function", "lifecycle.ts"),
     `export async function onMount() {}
 export async function onTeardown() {}
 `
   );
   fs6.writeFileSync(
-    path7.join(bFuncDir, "helper_functions", "helper.ts"),
+    path8.join(bFuncDir, "helper_functions", "helper.ts"),
     `/**
  * @role component
  */
@@ -1142,7 +1144,7 @@ export function exampleHelper(): boolean {
 `
   );
   fs6.writeFileSync(
-    path7.join(bFuncDir, "events", "events.ts"),
+    path8.join(bFuncDir, "events", "events.ts"),
     `/**
  * @role component
  */
@@ -1152,7 +1154,7 @@ export interface ${name}CompletedEvent {
 `
   );
   fs6.writeFileSync(
-    path7.join(bFuncDir, "tests", `${name}.test.ts`),
+    path8.join(bFuncDir, "tests", `${name}.test.ts`),
     `import { describe, it, expect } from "vitest";
 
 describe("${name} functionality", () => {
@@ -1162,10 +1164,10 @@ describe("${name} functionality", () => {
 });
 `
   );
-  const fFuncDir = path7.join(frontend, "functionalities", name);
-  fs6.mkdirSync(path7.join(fFuncDir, "tests"), { recursive: true });
+  const fFuncDir = path8.join(frontend, "functionalities", name);
+  fs6.mkdirSync(path8.join(fFuncDir, "tests"), { recursive: true });
   fs6.writeFileSync(
-    path7.join(fFuncDir, `${name}0.tsx`),
+    path8.join(fFuncDir, `${name}0.tsx`),
     `import React from "react";
 
 export const ${name}0: React.FC = () => {
@@ -1180,11 +1182,11 @@ export default ${name}0;
 `
   );
   fs6.writeFileSync(
-    path7.join(fFuncDir, "manifest.json"),
+    path8.join(fFuncDir, "manifest.json"),
     JSON.stringify({ name: `${name}UI`, dependencies: {} }, null, 2)
   );
   fs6.writeFileSync(
-    path7.join(fFuncDir, "tests", `${name}0.test.tsx`),
+    path8.join(fFuncDir, "tests", `${name}0.test.tsx`),
     `import { describe, it, expect } from "vitest";
 
 describe("${name}0 Component", () => {
@@ -1195,19 +1197,19 @@ describe("${name}0 Component", () => {
 `
   );
   KrnlPackageReconciler.reconcile(projectRoot, true);
-  console.log(`\u2705 Created Backend Functionality: ${path7.relative(projectRoot, bFuncDir)}/`);
-  console.log(`\u2705 Created Frontend Functionality: ${path7.relative(projectRoot, fFuncDir)}/`);
+  console.log(`\u2705 Created Backend Functionality: ${path8.relative(projectRoot, bFuncDir)}/`);
+  console.log(`\u2705 Created Frontend Functionality: ${path8.relative(projectRoot, fFuncDir)}/`);
 }
 
 // src/commands/generators/libraryGenerator.ts
 var fs7 = __toESM(require("fs"), 1);
-var path8 = __toESM(require("path"), 1);
+var path9 = __toESM(require("path"), 1);
 function generateLibrary(name, projectRoot, parentService) {
   const { backend, frontend } = getPlaneRoots(projectRoot);
   const conceptName = name.endsWith("Concepts") ? name : `${name}Concepts`;
   let targetService = parentService;
   if (!targetService) {
-    const servicesDir = path8.join(backend, "services");
+    const servicesDir = path9.join(backend, "services");
     if (fs7.existsSync(servicesDir)) {
       const existing = fs7.readdirSync(servicesDir, { withFileTypes: true }).filter((d) => d.isDirectory());
       if (existing.length === 1) {
@@ -1218,10 +1220,10 @@ function generateLibrary(name, projectRoot, parentService) {
   if (!targetService) {
     targetService = "App";
   }
-  const bLibDir = path8.join(backend, "services", targetService, "libraries", conceptName);
-  fs7.mkdirSync(path8.join(bLibDir, "tests"), { recursive: true });
+  const bLibDir = path9.join(backend, "services", targetService, "libraries", conceptName);
+  fs7.mkdirSync(path9.join(bLibDir, "tests"), { recursive: true });
   fs7.writeFileSync(
-    path8.join(bLibDir, "definitions.ts"),
+    path9.join(bLibDir, "definitions.ts"),
     `/**
  * @file definitions.ts
  * @role component
@@ -1232,7 +1234,7 @@ export interface ${conceptName}Options {
 `
   );
   fs7.writeFileSync(
-    path8.join(bLibDir, "functions.ts"),
+    path9.join(bLibDir, "functions.ts"),
     `/**
  * @file functions.ts
  * @role component
@@ -1245,17 +1247,17 @@ export function ${name.toLowerCase()}Transform<T>(data: T, _opts?: ${conceptName
 `
   );
   fs7.writeFileSync(
-    path8.join(bLibDir, "index.ts"),
+    path9.join(bLibDir, "index.ts"),
     `export * from "./definitions.js";
 export * from "./functions.js";
 `
   );
   fs7.writeFileSync(
-    path8.join(bLibDir, "manifest.json"),
+    path9.join(bLibDir, "manifest.json"),
     JSON.stringify({ name: conceptName, service: targetService, dependencies: {} }, null, 2)
   );
   fs7.writeFileSync(
-    path8.join(bLibDir, "tests", `${conceptName}.test.ts`),
+    path9.join(bLibDir, "tests", `${conceptName}.test.ts`),
     `import { describe, it, expect } from "vitest";
 import { ${name.toLowerCase()}Transform } from "../functions.js";
 
@@ -1266,17 +1268,17 @@ describe("${conceptName}", () => {
 });
 `
   );
-  const fLibDir = path8.join(frontend, "libraries", conceptName);
-  fs7.mkdirSync(path8.join(fLibDir, "tests"), { recursive: true });
+  const fLibDir = path9.join(frontend, "libraries", conceptName);
+  fs7.mkdirSync(path9.join(fLibDir, "tests"), { recursive: true });
   fs7.writeFileSync(
-    path8.join(fLibDir, "definitions.ts"),
+    path9.join(fLibDir, "definitions.ts"),
     `export interface ${name}Props {
   label?: string;
 }
 `
   );
   fs7.writeFileSync(
-    path8.join(fLibDir, "components.tsx"),
+    path9.join(fLibDir, "components.tsx"),
     `import React from "react";
 import type { ${name}Props } from "./definitions.js";
 import "./styles.css";
@@ -1287,18 +1289,18 @@ export const ${name}: React.FC<${name}Props> = ({ label = "${name}" }) => {
 `
   );
   fs7.writeFileSync(
-    path8.join(fLibDir, "styles.css"),
+    path9.join(fLibDir, "styles.css"),
     `.krnl-${name.toLowerCase()} {
   font-family: inherit;
 }
 `
   );
   fs7.writeFileSync(
-    path8.join(fLibDir, "manifest.json"),
+    path9.join(fLibDir, "manifest.json"),
     JSON.stringify({ name: `${conceptName}UI`, dependencies: {} }, null, 2)
   );
   fs7.writeFileSync(
-    path8.join(fLibDir, "tests", `${name}.test.tsx`),
+    path9.join(fLibDir, "tests", `${name}.test.tsx`),
     `import { describe, it, expect } from "vitest";
 
 describe("${name} UI Concept", () => {
@@ -1309,13 +1311,13 @@ describe("${name} UI Concept", () => {
 `
   );
   KrnlPackageReconciler.reconcile(projectRoot, true);
-  console.log(`\u2705 Created Service-Owned Library: ${path8.relative(projectRoot, bLibDir)}/ (Owner: ${targetService})`);
-  console.log(`\u2705 Created Frontend Concept Library: ${path8.relative(projectRoot, fLibDir)}/`);
+  console.log(`\u2705 Created Service-Owned Library: ${path9.relative(projectRoot, bLibDir)}/ (Owner: ${targetService})`);
+  console.log(`\u2705 Created Frontend Concept Library: ${path9.relative(projectRoot, fLibDir)}/`);
 }
 
 // src/commands/generators/serviceGenerator.ts
 var fs8 = __toESM(require("fs"), 1);
-var path9 = __toESM(require("path"), 1);
+var path10 = __toESM(require("path"), 1);
 function generateService(name, projectRoot, defaultFrontend) {
   const frontendReference = defaultFrontend?.component ? {
     component: defaultFrontend.component,
@@ -1325,20 +1327,20 @@ function generateService(name, projectRoot, defaultFrontend) {
   } : void 0;
   const frontendConfig = frontendReference ? JSON.stringify(frontendReference, null, 2).replace(/\n/g, "\n  ") : void 0;
   const { backend } = getPlaneRoots(projectRoot);
-  const serviceDir = path9.join(backend, "services", name);
-  const funcsDir = path9.join(serviceDir, "functionalities");
-  const orchsDir = path9.join(serviceDir, "orchestrations");
-  const libsDir = path9.join(serviceDir, "libraries");
-  const testsDir = path9.join(serviceDir, "tests");
+  const serviceDir = path10.join(backend, "services", name);
+  const funcsDir = path10.join(serviceDir, "functionalities");
+  const orchsDir = path10.join(serviceDir, "orchestrations");
+  const libsDir = path10.join(serviceDir, "libraries");
+  const testsDir = path10.join(serviceDir, "tests");
   fs8.mkdirSync(funcsDir, { recursive: true });
   fs8.mkdirSync(orchsDir, { recursive: true });
   fs8.mkdirSync(libsDir, { recursive: true });
   fs8.mkdirSync(testsDir, { recursive: true });
   const conceptName = `${name}Concepts`;
-  const defaultLibDir = path9.join(libsDir, conceptName);
-  fs8.mkdirSync(path9.join(defaultLibDir, "tests"), { recursive: true });
+  const defaultLibDir = path10.join(libsDir, conceptName);
+  fs8.mkdirSync(path10.join(defaultLibDir, "tests"), { recursive: true });
   fs8.writeFileSync(
-    path9.join(defaultLibDir, "definitions.ts"),
+    path10.join(defaultLibDir, "definitions.ts"),
     `/**
  * @file definitions.ts
  * @role component
@@ -1349,7 +1351,7 @@ export interface ${name}Options {
 `
   );
   fs8.writeFileSync(
-    path9.join(defaultLibDir, "functions.ts"),
+    path10.join(defaultLibDir, "functions.ts"),
     `/**
  * @file functions.ts
  * @role component
@@ -1362,17 +1364,17 @@ export function format${name}Name(input: string, _opts?: ${name}Options): string
 `
   );
   fs8.writeFileSync(
-    path9.join(defaultLibDir, "index.ts"),
+    path10.join(defaultLibDir, "index.ts"),
     `export * from "./definitions.js";
 export * from "./functions.js";
 `
   );
   fs8.writeFileSync(
-    path9.join(defaultLibDir, "manifest.json"),
+    path10.join(defaultLibDir, "manifest.json"),
     JSON.stringify({ name: conceptName, description: `${name} service-owned library`, dependencies: {} }, null, 2)
   );
   fs8.writeFileSync(
-    path9.join(defaultLibDir, "tests", `${conceptName}.test.ts`),
+    path10.join(defaultLibDir, "tests", `${conceptName}.test.ts`),
     `import { describe, it, expect } from "vitest";
 import { format${name}Name } from "../functions.js";
 
@@ -1386,7 +1388,7 @@ describe("${conceptName}", () => {
   const frontendProperty = frontendConfig ? `  defaultFrontend: ${frontendConfig},
 ` : "";
   fs8.writeFileSync(
-    path9.join(serviceDir, `${name}ServiceFacade.ts`),
+    path10.join(serviceDir, `${name}ServiceFacade.ts`),
     `import { ServiceFacade } from "@ultrst-armada/krnl-core";
 import * as ${name.toLowerCase()}Concepts from "./libraries/${conceptName}/index.js";
 
@@ -1404,7 +1406,7 @@ export default ${name}ServiceFacade;
 `
   );
   fs8.writeFileSync(
-    path9.join(testsDir, `${name}ServiceFacade.test.ts`),
+    path10.join(testsDir, `${name}ServiceFacade.test.ts`),
     `import { describe, it, expect } from "vitest";
 import { ${name}ServiceFacade } from "../${name}ServiceFacade.js";
 
@@ -1418,7 +1420,7 @@ describe("${name}ServiceFacade", () => {
 `
   );
   KrnlPackageReconciler.reconcile(projectRoot, true);
-  console.log(`\u2705 Created Service: ${path9.relative(projectRoot, serviceDir)}/`);
+  console.log(`\u2705 Created Service: ${path10.relative(projectRoot, serviceDir)}/`);
 }
 
 // src/commands/generate.ts
@@ -1454,7 +1456,7 @@ async function runGenerate(type, name, parentService, projectRoot = process.cwd(
 
 // src/commands/watch.ts
 var fs9 = __toESM(require("fs"), 1);
-var path10 = __toESM(require("path"), 1);
+var path11 = __toESM(require("path"), 1);
 function generateMagneticDeclarations(projectRoot = process.cwd()) {
   const { results: functionalities, libDirs } = scanDirectory(projectRoot);
   let dtsContent = `// Automatically generated by Krnl Magnetic Watcher. Do not edit manually.
@@ -1465,14 +1467,14 @@ function generateMagneticDeclarations(projectRoot = process.cwd()) {
 `;
   const globalDeclarations = [];
   for (const func of functionalities) {
-    const helpersDir = path10.join(func.funcPath, "helper_functions");
+    const helpersDir = path11.join(func.funcPath, "helper_functions");
     if (fs9.existsSync(helpersDir)) {
       const files = fs9.readdirSync(helpersDir);
       for (const file of files) {
         if (file.endsWith(".js") || file.endsWith(".ts")) {
-          const filePath = path10.join(helpersDir, file);
-          const baseName = path10.basename(file, path10.extname(file));
-          const importPath = `./${path10.relative(projectRoot, filePath).replace(/\\/g, "/")}`;
+          const filePath = path11.join(helpersDir, file);
+          const baseName = path11.basename(file, path11.extname(file));
+          const importPath = `./${path11.relative(projectRoot, filePath).replace(/\\/g, "/")}`;
           const { named, hasDefault } = parseExports(filePath, baseName);
           if (hasDefault) {
             globalDeclarations.push(`  const ${baseName}: typeof import('${importPath}')['default'];`);
@@ -1483,14 +1485,14 @@ function generateMagneticDeclarations(projectRoot = process.cwd()) {
         }
       }
     }
-    const eventsDir = path10.join(func.funcPath, "events");
+    const eventsDir = path11.join(func.funcPath, "events");
     if (fs9.existsSync(eventsDir)) {
       const files = fs9.readdirSync(eventsDir);
       for (const file of files) {
         if (file.endsWith(".js") || file.endsWith(".ts")) {
-          const filePath = path10.join(eventsDir, file);
-          const baseName = path10.basename(file, path10.extname(file));
-          const importPath = `./${path10.relative(projectRoot, filePath).replace(/\\/g, "/")}`;
+          const filePath = path11.join(eventsDir, file);
+          const baseName = path11.basename(file, path11.extname(file));
+          const importPath = `./${path11.relative(projectRoot, filePath).replace(/\\/g, "/")}`;
           const { named, hasDefault } = parseExports(filePath, baseName);
           if (hasDefault) {
             globalDeclarations.push(`  const ${baseName}: typeof import('${importPath}')['default'];`);
@@ -1511,7 +1513,7 @@ ${Array.from(new Set(globalDeclarations)).join("\n")}
 }
 `;
   }
-  const outPath = path10.join(projectRoot, "krnl-magnetic.d.ts");
+  const outPath = path11.join(projectRoot, "krnl-magnetic.d.ts");
   fs9.writeFileSync(outPath, dtsContent);
   console.log(`[Krnl Watch] Updated ambient declarations: ${outPath}`);
 }
@@ -1519,12 +1521,12 @@ function scanLibFiles(dir, projectRoot, decls) {
   if (!fs9.existsSync(dir)) return;
   for (const entry of fs9.readdirSync(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-    const full = path10.join(dir, entry.name);
+    const full = path11.join(dir, entry.name);
     if (entry.isDirectory()) {
       scanLibFiles(full, projectRoot, decls);
     } else if ((entry.name.endsWith(".ts") || entry.name.endsWith(".js")) && !entry.name.endsWith(".d.ts")) {
-      const baseName = path10.basename(entry.name, path10.extname(entry.name));
-      const importPath = `./${path10.relative(projectRoot, full).replace(/\\/g, "/")}`;
+      const baseName = path11.basename(entry.name, path11.extname(entry.name));
+      const importPath = `./${path11.relative(projectRoot, full).replace(/\\/g, "/")}`;
       const { named, hasDefault } = parseExports(full, baseName);
       if (hasDefault) decls.push(`  const ${baseName}: typeof import('${importPath}')['default'];`);
       for (const n of named) decls.push(`  const ${n}: typeof import('${importPath}')['${n}'];`);
@@ -1537,11 +1539,11 @@ function scanDirectory(dir, results = [], libDirs = []) {
   for (const entry of list) {
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
-      const fullPath = path10.join(dir, entry.name);
+      const fullPath = path11.join(dir, entry.name);
       if (entry.name === "functionalities") {
         const funcs = fs9.readdirSync(fullPath, { withFileTypes: true });
         for (const f of funcs) {
-          if (f.isDirectory()) results.push({ funcPath: path10.join(fullPath, f.name), funcName: f.name });
+          if (f.isDirectory()) results.push({ funcPath: path11.join(fullPath, f.name), funcName: f.name });
         }
       } else if (entry.name === "libraries" || entry.name === "library") {
         libDirs.push(fullPath);
@@ -1568,7 +1570,7 @@ function parseExports(filePath, defaultName) {
 }
 
 // src/commands/build.ts
-var path11 = __toESM(require("path"), 1);
+var path12 = __toESM(require("path"), 1);
 var fs10 = __toESM(require("fs"), 1);
 var import_child_process = require("child_process");
 async function runBuild(projectRoot = process.cwd(), options = {}) {
@@ -1586,10 +1588,10 @@ async function runBuild(projectRoot = process.cwd(), options = {}) {
     return { success: false, error: "Validation failed" };
   }
   generateMagneticDeclarations(projectRoot);
-  const tsConfigPath = path11.join(projectRoot, "tsconfig.json");
+  const tsConfigPath = path12.join(projectRoot, "tsconfig.json");
   if (fs10.existsSync(tsConfigPath)) {
     console.log("\u{1F3D7}\uFE0F  [Krnl Build] Compiling TypeScript source files to dist/...");
-    const localTsc = path11.join(projectRoot, "node_modules", ".bin", "tsc");
+    const localTsc = path12.join(projectRoot, "node_modules", ".bin", "tsc");
     const tscCmd = fs10.existsSync(localTsc) ? localTsc : "tsc";
     try {
       (0, import_child_process.execSync)(`${tscCmd} -p tsconfig.json`, { cwd: projectRoot, stdio: "inherit" });
@@ -1606,7 +1608,7 @@ async function runBuild(projectRoot = process.cwd(), options = {}) {
 
 // src/commands/dev.ts
 var http = __toESM(require("http"), 1);
-var path12 = __toESM(require("path"), 1);
+var path13 = __toESM(require("path"), 1);
 var fs11 = __toESM(require("fs"), 1);
 async function runDev(projectRoot = process.cwd(), options = {}) {
   const port = options.port ?? 8080;
@@ -1629,7 +1631,7 @@ async function runDev(projectRoot = process.cwd(), options = {}) {
       return;
     }
     if (url.pathname === "/manifest") {
-      const pkgPath = path12.join(projectRoot, "package.json");
+      const pkgPath = path13.join(projectRoot, "package.json");
       const pkg = fs11.existsSync(pkgPath) ? JSON.parse(fs11.readFileSync(pkgPath, "utf8")) : {};
       res.writeHead(200);
       res.end(JSON.stringify({ name: pkg.name || "krnl-app", version: pkg.version || "1.0.0" }));