@ultrst-armada/krnl 1.0.2 → 1.0.4

package/packages/validate/dist/index.js

@@ -1,6 +1,6 @@
 // src/KrnlValidatorEngine.ts
 import * as fs2 from "fs";
-import * as path4 from "path";
+import * as path3 from "path";
 import { Project } from "ts-morph";
 
 // src/rules/fileLimits.ts
@@ -8,7 +8,7 @@ function checkFileLimits(sf, options) {
   const errors = [];
   const warnings = [];
   const filePath = sf.getFilePath();
-  const sourceText = sf.getText();
+  const sourceText = sf.getFullText();
   const lines = sourceText.split("\n");
   if (lines.length > options.maxFileLineLimit) {
     errors.push({
@@ -123,7 +123,7 @@ function checkComponentRules(sf) {
           ruleId: "krnl/helper-purity",
           filePath,
           line: decl.getStartLineNumber(),
-          message: `Helper functions (Layer 1) cannot directly import I/O modules ('${spec}'). Delegate to Layer 0 libraries or Entity context.`,
+          message: `Helper functions (Layer 1) cannot directly import I/O modules ('${spec}'). Delegate to Layer 0 libraries or ServiceFacade context.`,
           severity: "error"
         });
       }
@@ -132,15 +132,13 @@ function checkComponentRules(sf) {
   return { errors, warnings };
 }
 
-// src/rules/entityRules.ts
-import * as path2 from "path";
+// src/rules/orchestrationRules.ts
 import { SyntaxKind as SyntaxKind2, Node } from "ts-morph";
-function checkEntityRules(sf) {
+function checkOrchestrationRules(sf) {
   const errors = [];
   const warnings = [];
   const filePath = sf.getFilePath();
   const sourceText = sf.getText();
-  const baseName = path2.basename(filePath);
   const calls = sf.getDescendantsOfKind(SyntaxKind2.CallExpression);
   for (const call of calls) {
     const exprText = call.getExpression().getText();
@@ -149,7 +147,7 @@ function checkEntityRules(sf) {
         ruleId: "krnl/no-polling",
         filePath,
         line: call.getStartLineNumber(),
-        message: `Prohibited use of 'setInterval'. Krnl applications must use reactive event streams (entity.emitEvent / entity.on).`,
+        message: `Prohibited use of 'setInterval'. Krnl applications must use reactive event streams or triggers.`,
         severity: "error"
       });
     }
@@ -158,65 +156,36 @@ function checkEntityRules(sf) {
     const match = sourceText.match(/main\s*=\s*async\s*\([^,]+,\s*\{([^}]*)\}\s*\)/);
     if (match) {
       const destructured = match[1];
-      if (/\bsystem\b/.test(destructured) && !/\bentity\b/.test(destructured)) {
+      if (/\bsystem\b/.test(destructured)) {
         errors.push({
           ruleId: "krnl/context-destructuring",
           filePath,
-          message: `Functionality context parameter destructures 'system'. Functionality passes { state, entity }. Always destructure 'entity'.`,
+          message: `Functionality context parameter destructures 'system'. Functionality passes { state, orchestration } or service context.`,
           severity: "error"
         });
       }
     }
   }
-  const isEntityClass = sf.getClasses().some((c) => {
+  const isOrchestrationClass = sf.getClasses().some((c) => {
     const ext = c.getExtends();
-    return ext && (ext.getText().includes("Entity") || ext.getText().includes("krnlEntityBase"));
+    return ext && (ext.getText().includes("FunctionalityOrchestration") || ext.getText().includes("Orchestration") || ext.getText().includes("krnlOrchestrationBase"));
   });
-  if (isEntityClass) {
+  if (isOrchestrationClass) {
     for (const decl of sf.getImportDeclarations()) {
       const spec = decl.getModuleSpecifierValue();
       if (spec.includes("libraries/") || spec.includes("Concepts")) {
         errors.push({
-          ruleId: "krnl/entity-no-libraries",
+          ruleId: "krnl/orchestration-no-libraries",
           filePath,
           line: decl.getStartLineNumber(),
-          message: `Entity class violates Library Calling Invariant. Entities must not call or import libraries directly ('${spec}'). Only functionalities in 'src/functionalities/' are permitted to call shared libraries.`,
+          message: `FunctionalityOrchestration class violates Library Calling Invariant. FunctionalityOrchestrations must not call or import libraries directly ('${spec}'). Only functionalities are permitted to call shared libraries.`,
           severity: "error"
         });
       }
     }
-    let loadAllLine = -1;
-    const addLocalLines = [];
-    for (const call of calls) {
-      const txt = call.getText();
-      if (txt.includes("MagneticLoader.loadAll") || txt.includes("KrnlMagneticLoader.loadAll")) {
-        loadAllLine = call.getStartLineNumber();
-      } else if (txt.startsWith("this.addLocal(")) {
-        const hasUiSpec = txt.includes("uiSpec");
-        const idMatch = txt.match(/id\s*:\s*["']([^"']+)["']/);
-        addLocalLines.push({
-          line: call.getStartLineNumber(),
-          hasUiSpec,
-          id: idMatch ? idMatch[1] : "unknown"
-        });
-      }
-    }
-    if (loadAllLine !== -1) {
-      for (const al of addLocalLines) {
-        if (al.hasUiSpec && al.line > loadAllLine) {
-          errors.push({
-            ruleId: "krnl/boot-order",
-            filePath,
-            line: al.line,
-            message: `addLocal('${al.id}') with uiSpec at line ${al.line} appears AFTER loadAll() at line ${loadAllLine}. All addLocal() with UI must precede loadAll().`,
-            severity: "error"
-          });
-        }
-      }
-    }
     for (const cls of sf.getClasses()) {
       const ext = cls.getExtends();
-      if (ext && (ext.getText().includes("Entity") || ext.getText().includes("krnlEntityBase"))) {
+      if (ext && (ext.getText().includes("FunctionalityOrchestration") || ext.getText().includes("Orchestration") || ext.getText().includes("krnlOrchestrationBase"))) {
         const loops = [
           ...cls.getDescendantsOfKind(SyntaxKind2.ForStatement),
           ...cls.getDescendantsOfKind(SyntaxKind2.ForOfStatement),
@@ -226,21 +195,34 @@ function checkEntityRules(sf) {
         ];
         for (const loop of loops) {
           errors.push({
-            ruleId: "krnl/entity-purity",
+            ruleId: "krnl/orchestration-purity",
             filePath,
             line: loop.getStartLineNumber(),
-            message: `Entity '${cls.getName() || "Anonymous"}' violates Entity Purity Law. Loops and procedural algorithms are prohibited inside entities. Move logic to a functionality or a global library function.`,
+            message: `FunctionalityOrchestration '${cls.getName() || "Anonymous"}' violates Orchestration Purity Law. Loops and procedural algorithms are prohibited inside orchestrations. Move logic to a functionality or a global library function.`,
             severity: "error"
           });
         }
+        const allowedMethods = /* @__PURE__ */ new Set([
+          "flow",
+          "getFlow",
+          "listFlows",
+          "clearFlows",
+          "thenFunctionality",
+          "parallel",
+          "branch",
+          "fanOut",
+          "thenFunctionalityOrchestration",
+          "getSteps",
+          "assertServiceBoundary"
+        ]);
         for (const method of cls.getMethods()) {
           const methodName = method.getName();
-          if (!["boot", "init", "dispose"].includes(methodName)) {
+          if (!allowedMethods.has(methodName)) {
             errors.push({
-              ruleId: "krnl/entity-purity",
+              ruleId: "krnl/orchestration-purity",
               filePath,
               line: method.getStartLineNumber(),
-              message: `Entity '${cls.getName() || "Anonymous"}' defines custom method '${methodName}'. Entities are purely declarative compositors/orchestrators. Define capabilities as functionalities or global library functions.`,
+              message: `FunctionalityOrchestration '${cls.getName() || "Anonymous"}' defines custom method '${methodName}'. FunctionalityOrchestrations are purely declarative compositors. Define capabilities as functionalities or global library functions.`,
               severity: "error"
             });
           }
@@ -249,7 +231,7 @@ function checkEntityRules(sf) {
     }
     for (const call of calls) {
       const callText = call.getText();
-      if (callText.startsWith("this.orchestration(") || callText.startsWith("this.flow(")) {
+      if (callText.startsWith("this.flow(") || callText.startsWith("orchestration.flow(")) {
         let currentExpr = call;
         const chainCalls = [];
         while (currentExpr && Node.isCallExpression(currentExpr)) {
@@ -266,14 +248,22 @@ function checkEntityRules(sf) {
         }
         let chainId = "orchestration";
         for (const step of chainCalls) {
-          if (step.name === "orchestration" || step.name === "flow") {
+          if (step.name === "flow") {
             chainId = step.argText ? step.argText.replace(/['"]/g, "") : "orchestration";
           } else if (step.name === "thenFunction") {
             errors.push({
-              ruleId: "krnl/entity-no-direct-library-calls",
+              ruleId: "krnl/orchestration-no-direct-library-calls",
               filePath,
               line: step.node.getStartLineNumber(),
-              message: `Orchestration chain '${chainId}' violates Entity Purity Law. Entities cannot chain direct library functions via thenFunction(). Entities must only orchestrate functionalities (thenFunctionality) and orchestrations from other entities (thenEntityOrchestration).`,
+              message: `FunctionalityOrchestration flow '${chainId}' violates Orchestration Purity Law. Orchestrations cannot chain direct library functions via thenFunction(). Orchestrations must only sequence functionalities (thenFunctionality) and peer functionality orchestrations (thenFunctionalityOrchestration).`,
+              severity: "error"
+            });
+          } else if (step.name === "thenService") {
+            errors.push({
+              ruleId: "krnl/orchestration-no-external-services",
+              filePath,
+              line: step.node.getStartLineNumber(),
+              message: `FunctionalityOrchestration flow '${chainId}' violates Plane Isolation Law L1. A service-level FunctionalityOrchestration cannot compose external services. Use Skipo ServiceOrchestration at the application layer instead.`,
               severity: "error"
             });
           }
@@ -286,15 +276,15 @@ function checkEntityRules(sf) {
 
 // src/rules/workspaceRules.ts
 import * as fs from "fs";
-import * as path3 from "path";
+import * as path2 from "path";
 import { SyntaxKind as SyntaxKind3 } from "ts-morph";
 function checkTopLevelPurity(sf) {
   const errors = [];
   const warnings = [];
   const filePath = sf.getFilePath();
-  const baseName = path3.basename(filePath);
+  const baseName = path2.basename(filePath);
   const isUiTopLevel = /^(App|main|index|_app|root)\.(tsx|jsx)$/i.test(baseName);
-  const isBackendTopLevel = /^(server|app)\.(ts|js)$/i.test(baseName) && !filePath.includes("/components/") && !filePath.includes("/entities/") && !filePath.includes("/libraries/");
+  const isBackendTopLevel = /^(server|app|index)\.(ts|js)$/i.test(baseName) && !filePath.includes("/components/") && !filePath.includes("/orchestrations/") && !filePath.includes("/services/") && !filePath.includes("/libraries/");
   if (isUiTopLevel) {
     const jsxElements = sf.getDescendantsOfKind(SyntaxKind3.JsxOpeningElement);
     const jsxSelfClosing = sf.getDescendantsOfKind(SyntaxKind3.JsxSelfClosingElement);
@@ -352,19 +342,56 @@ function checkTopLevelPurity(sf) {
   return { errors, warnings };
 }
 function checkWorkspaceLayout(projectRoot, errors) {
-  const krnlDir = path3.join(projectRoot, "krnl");
-  const srcDir = path3.join(projectRoot, "src");
+  const krnlDir = path2.join(projectRoot, "krnl");
+  const srcDir = path2.join(projectRoot, "src");
   const targetDir = fs.existsSync(krnlDir) ? krnlDir : fs.existsSync(srcDir) ? srcDir : null;
   if (!targetDir) return;
-  const backendDir = path3.join(targetDir, "backend");
-  const frontendDir = path3.join(targetDir, "frontend");
+  const backendDir = path2.join(targetDir, "backend");
+  const frontendDir = path2.join(targetDir, "frontend");
   if (fs.existsSync(backendDir)) {
-    const bLibs = path3.join(backendDir, "libraries");
+    const bServices = path2.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");
+        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"))) {
+              errors.push({
+                ruleId: "krnl/concept-manifest-required",
+                filePath: libPath,
+                message: `Service-owned concept library "${sEntry.name}/${entry.name}" is missing a manifest.json file.`,
+                severity: "error"
+              });
+            }
+          }
+        }
+        const sFuncs = path2.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"))) {
+              errors.push({
+                ruleId: "krnl/functionality-manifest-required",
+                filePath: funcPath,
+                message: `Service-owned functionality "${sEntry.name}/${entry.name}" is missing a manifest.json file.`,
+                severity: "error"
+              });
+            }
+          }
+        }
+      }
+    }
+    const bLibs = path2.join(backendDir, "libraries");
     if (fs.existsSync(bLibs)) {
       for (const entry of fs.readdirSync(bLibs, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const libPath = path3.join(bLibs, entry.name);
-        if (!fs.existsSync(path3.join(libPath, "manifest.json"))) {
+        const libPath = path2.join(bLibs, entry.name);
+        if (!fs.existsSync(path2.join(libPath, "manifest.json"))) {
           errors.push({
             ruleId: "krnl/concept-manifest-required",
             filePath: libPath,
@@ -374,12 +401,12 @@ function checkWorkspaceLayout(projectRoot, errors) {
         }
       }
     }
-    const bFuncs = path3.join(backendDir, "functionalities");
+    const bFuncs = path2.join(backendDir, "functionalities");
     if (fs.existsSync(bFuncs)) {
       for (const entry of fs.readdirSync(bFuncs, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const funcPath = path3.join(bFuncs, entry.name);
-        if (!fs.existsSync(path3.join(funcPath, "manifest.json"))) {
+        const funcPath = path2.join(bFuncs, entry.name);
+        if (!fs.existsSync(path2.join(funcPath, "manifest.json"))) {
           errors.push({
             ruleId: "krnl/functionality-manifest-required",
             filePath: funcPath,
@@ -391,12 +418,12 @@ function checkWorkspaceLayout(projectRoot, errors) {
     }
   }
   if (fs.existsSync(frontendDir)) {
-    const fLibs = path3.join(frontendDir, "libraries");
+    const fLibs = path2.join(frontendDir, "libraries");
     if (fs.existsSync(fLibs)) {
       for (const entry of fs.readdirSync(fLibs, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const libPath = path3.join(fLibs, entry.name);
-        if (!fs.existsSync(path3.join(libPath, "manifest.json"))) {
+        const libPath = path2.join(fLibs, entry.name);
+        if (!fs.existsSync(path2.join(libPath, "manifest.json"))) {
           errors.push({
             ruleId: "krnl/frontend-concept-manifest-required",
             filePath: libPath,
@@ -406,12 +433,12 @@ function checkWorkspaceLayout(projectRoot, errors) {
         }
       }
     }
-    const fFuncs = path3.join(frontendDir, "functionalities");
+    const fFuncs = path2.join(frontendDir, "functionalities");
     if (fs.existsSync(fFuncs)) {
       for (const entry of fs.readdirSync(fFuncs, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const funcPath = path3.join(fFuncs, entry.name);
-        if (!fs.existsSync(path3.join(funcPath, "manifest.json"))) {
+        const funcPath = path2.join(fFuncs, entry.name);
+        if (!fs.existsSync(path2.join(funcPath, "manifest.json"))) {
           errors.push({
             ruleId: "krnl/frontend-functionality-manifest-required",
             filePath: funcPath,
@@ -424,6 +451,250 @@ function checkWorkspaceLayout(projectRoot, errors) {
   }
 }
 
+// src/rules/serviceBoundaryRules.ts
+function checkServiceBoundaries(sf) {
+  const errors = [];
+  const warnings = [];
+  const filePath = sf.getFilePath().replace(/\\/g, "/");
+  const serviceMatch = filePath.match(/\/services\/([^/]+)\//);
+  if (!serviceMatch) {
+    return { errors, warnings };
+  }
+  const currentService = serviceMatch[1];
+  const imports = sf.getImportDeclarations();
+  for (const imp of imports) {
+    const spec = imp.getModuleSpecifierValue();
+    const crossServiceLibMatch = spec.match(/(?:^|\/|\.\.\/)services\/([^/]+)\/libraries\//) || spec.match(/\.\.\/(?:(?:\.\.\/)+)?([^/]+)\/libraries\//);
+    if (crossServiceLibMatch) {
+      const targetService = crossServiceLibMatch[1];
+      if (targetService !== currentService && targetService !== "." && targetService !== "..") {
+        errors.push({
+          ruleId: "krnl/no-cross-service-library-imports",
+          filePath,
+          line: imp.getStartLineNumber(),
+          message: `Cross-service library import forbidden: '${spec}'. Service '${currentService}' cannot import '${targetService}' libraries directly via filesystem. Access libraries through the '${targetService}' ServiceFacade (e.g. ${targetService}Facade.libraries).`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  return { errors, warnings };
+}
+
+// src/rules/scopedLibraryRules.ts
+import { SyntaxKind as SyntaxKind4 } from "ts-morph";
+var PRIMITIVE_AND_BUILTIN_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "symbol",
+  "bigint",
+  "void",
+  "undefined",
+  "null",
+  "never",
+  "unknown",
+  "any",
+  "object",
+  "Record",
+  "Array",
+  "ReadonlyArray",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Promise",
+  "Date",
+  "RegExp",
+  "Error",
+  "Uint8Array",
+  "Int8Array",
+  "Uint16Array",
+  "Int16Array",
+  "Uint32Array",
+  "Int32Array",
+  "Float32Array",
+  "Float64Array",
+  "ArrayBuffer",
+  "Buffer",
+  "Iterable",
+  "AsyncIterable",
+  "Iterator",
+  "AsyncIterator",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "Parameters",
+  "ConstructorParameters",
+  "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());
+}
+function isCustomContextualType(typeName, serviceName, localTypes) {
+  if (PRIMITIVE_AND_BUILTIN_TYPES.has(typeName)) return false;
+  if (localTypes.has(typeName)) return true;
+  if (containsIdentifier(typeName, serviceName)) return true;
+  if (/^[A-Z][a-zA-Z0-9]+$/.test(typeName)) return true;
+  return false;
+}
+function hasContextualTypeReference(node, serviceName, localTypes) {
+  const typeRefs = node.getDescendantsOfKind(SyntaxKind4.TypeReference);
+  for (const ref of typeRefs) {
+    const text = ref.getTypeName().getText().trim();
+    if (isCustomContextualType(text, serviceName, localTypes)) {
+      return true;
+    }
+  }
+  return false;
+}
+function checkScopedLibraryRules(sf) {
+  const errors = [];
+  const warnings = [];
+  const promotableAssets = [];
+  const filePath = sf.getFilePath().replace(/\\/g, "/");
+  const context = detectServiceContext(filePath);
+  if (!context) {
+    return { errors, warnings, promotableAssets };
+  }
+  const { serviceName, libraryName } = context;
+  const localTypes = /* @__PURE__ */ new Set();
+  sf.getInterfaces().forEach((i) => localTypes.add(i.getName()));
+  sf.getTypeAliases().forEach((t) => localTypes.add(t.getName()));
+  sf.getClasses().forEach((c) => {
+    const n = c.getName();
+    if (n) localTypes.add(n);
+  });
+  sf.getEnums().forEach((e) => localTypes.add(e.getName()));
+  const functions = sf.getFunctions();
+  for (const fn of functions) {
+    const fnName = fn.getName();
+    if (!fnName) continue;
+    const isContextual = hasContextualTypeReference(fn, serviceName, localTypes);
+    const hasServiceName = containsIdentifier(fnName, serviceName);
+    if (isContextual) {
+      if (!hasServiceName) {
+        errors.push({
+          ruleId: "krnl/service-library-asset-naming",
+          filePath,
+          line: fn.getStartLineNumber(),
+          message: `Service library asset '${fnName}' in service '${serviceName}' violates scoped library naming convention. Custom library asset identifiers must contain the owning service name ('${serviceName}'). Expected name containing '${serviceName}' (e.g. '${serviceName.toLowerCase()}${fnName[0].toUpperCase()}${fnName.slice(1)}'), or eliminate contextual custom type dependencies to make it a generic promotable utility.`,
+          severity: "error"
+        });
+      }
+    } else {
+      promotableAssets.push({
+        name: fnName,
+        kind: "function",
+        filePath,
+        scope: "service",
+        scopeName: serviceName,
+        target: "GutTS"
+      });
+    }
+  }
+  for (const stmt of sf.getVariableStatements()) {
+    for (const decl of stmt.getDeclarations()) {
+      const varName = decl.getName();
+      const init = decl.getInitializer();
+      const isFunction = init && (init.getKind() === SyntaxKind4.ArrowFunction || init.getKind() === SyntaxKind4.FunctionExpression);
+      if (isFunction) {
+        const isContextual = hasContextualTypeReference(decl, serviceName, localTypes);
+        const hasServiceName = containsIdentifier(varName, serviceName);
+        if (isContextual) {
+          if (!hasServiceName) {
+            errors.push({
+              ruleId: "krnl/service-library-asset-naming",
+              filePath,
+              line: decl.getStartLineNumber(),
+              message: `Service library asset '${varName}' in service '${serviceName}' violates scoped library naming convention. Custom library asset identifiers must contain the owning service name ('${serviceName}'). Expected name containing '${serviceName}', or eliminate contextual custom type dependencies to make it a generic promotable utility.`,
+              severity: "error"
+            });
+          }
+        } else {
+          promotableAssets.push({
+            name: varName,
+            kind: "function",
+            filePath,
+            scope: "service",
+            scopeName: serviceName,
+            target: "GutTS"
+          });
+        }
+      } else {
+        const isContextual = hasContextualTypeReference(decl, serviceName, localTypes);
+        const hasServiceName = containsIdentifier(varName, serviceName);
+        if (isContextual && !hasServiceName) {
+          errors.push({
+            ruleId: "krnl/service-library-asset-naming",
+            filePath,
+            line: decl.getStartLineNumber(),
+            message: `Service library asset '${varName}' in service '${serviceName}' violates scoped library naming convention. Custom library asset identifiers must contain the owning service name ('${serviceName}').`,
+            severity: "error"
+          });
+        }
+      }
+    }
+  }
+  for (const iface of sf.getInterfaces()) {
+    const name = iface.getName();
+    const hasServiceName = containsIdentifier(name, serviceName);
+    const hasProps = iface.getProperties().length > 0;
+    if (hasProps && !hasServiceName) {
+      errors.push({
+        ruleId: "krnl/service-library-asset-naming",
+        filePath,
+        line: iface.getStartLineNumber(),
+        message: `Service library interface '${name}' in service '${serviceName}' violates scoped library naming convention. Custom library asset identifiers must contain the owning service name ('${serviceName}'). Expected name like '${serviceName}${name}'.`,
+        severity: "error"
+      });
+    }
+  }
+  for (const t of sf.getTypeAliases()) {
+    const name = t.getName();
+    const hasServiceName = containsIdentifier(name, serviceName);
+    const isContextual = hasContextualTypeReference(t, serviceName, localTypes);
+    if (isContextual && !hasServiceName) {
+      errors.push({
+        ruleId: "krnl/service-library-asset-naming",
+        filePath,
+        line: t.getStartLineNumber(),
+        message: `Service library type alias '${name}' in service '${serviceName}' violates scoped library naming convention. Custom library asset identifiers must contain the owning service name ('${serviceName}'). Expected name like '${serviceName}${name}'.`,
+        severity: "error"
+      });
+    }
+  }
+  for (const cls of sf.getClasses()) {
+    const name = cls.getName();
+    if (!name) continue;
+    const hasServiceName = containsIdentifier(name, serviceName);
+    if (!hasServiceName) {
+      errors.push({
+        ruleId: "krnl/service-library-asset-naming",
+        filePath,
+        line: cls.getStartLineNumber(),
+        message: `Service library class '${name}' in service '${serviceName}' violates scoped library naming convention. Custom library asset identifiers must contain the owning service name ('${serviceName}'). Expected name like '${serviceName}${name}'.`,
+        severity: "error"
+      });
+    }
+  }
+  return { errors, warnings, promotableAssets };
+}
+
 // src/KrnlValidatorEngine.ts
 var KrnlValidatorEngine = class {
   project;
@@ -431,13 +702,13 @@ var KrnlValidatorEngine = class {
   limitOptions;
   constructor(optionsOrRoot) {
     const options = typeof optionsOrRoot === "string" ? { projectRoot: optionsOrRoot } : optionsOrRoot;
-    this.projectRoot = path4.resolve(options.projectRoot || process.cwd());
+    this.projectRoot = path3.resolve(options.projectRoot || process.cwd());
     this.limitOptions = {
       maxFileLineLimit: options.maxFileLineLimit ?? 200,
       maxMainLogicLimit: options.maxMainLogicLimit ?? 20,
       maxHelperLineLimit: options.maxHelperLineLimit ?? 30
     };
-    const tsConfigPath = path4.join(this.projectRoot, "tsconfig.json");
+    const tsConfigPath = path3.join(this.projectRoot, "tsconfig.json");
     if (fs2.existsSync(tsConfigPath)) {
       this.project = new Project({ tsConfigFilePath: tsConfigPath, skipAddingFilesFromTsConfig: true });
     } else {
@@ -451,33 +722,55 @@ var KrnlValidatorEngine = class {
     const files = this.collectSourceFiles(this.projectRoot);
     const errors = [];
     const warnings = [];
+    const promotableAssets = [];
     checkWorkspaceLayout(this.projectRoot, errors);
     for (const f of files) {
       const sf = this.project.addSourceFileAtPath(f);
       const fileReport = this.validateSourceFile(sf);
       errors.push(...fileReport.errors);
       warnings.push(...fileReport.warnings);
+      if (fileReport.promotableAssets) {
+        promotableAssets.push(...fileReport.promotableAssets);
+      }
     }
     return {
       valid: errors.length === 0,
       totalFiles: files.length,
       errors,
-      warnings
+      warnings,
+      promotableAssets
     };
   }
   validateSourceFile(sf) {
     const filePath = sf.getFilePath();
-    const baseName = path4.basename(filePath);
+    const baseName = path3.basename(filePath);
     if (baseName.includes("_pb.") || baseName.endsWith(".d.ts")) {
-      return { errors: [], warnings: [] };
+      return { errors: [], warnings: [], promotableAssets: [] };
     }
     const limits = checkFileLimits(sf, this.limitOptions);
     const purity = checkTopLevelPurity(sf);
     const components = checkComponentRules(sf);
-    const entity = checkEntityRules(sf);
+    const orchestration = checkOrchestrationRules(sf);
+    const boundaries = checkServiceBoundaries(sf);
+    const scopedLibraries = checkScopedLibraryRules(sf);
     return {
-      errors: [...limits.errors, ...purity.errors, ...components.errors, ...entity.errors],
-      warnings: [...limits.warnings, ...purity.warnings, ...components.warnings, ...entity.warnings]
+      errors: [
+        ...limits.errors,
+        ...purity.errors,
+        ...components.errors,
+        ...orchestration.errors,
+        ...boundaries.errors,
+        ...scopedLibraries.errors
+      ],
+      warnings: [
+        ...limits.warnings,
+        ...purity.warnings,
+        ...components.warnings,
+        ...orchestration.warnings,
+        ...boundaries.warnings,
+        ...scopedLibraries.warnings
+      ],
+      promotableAssets: scopedLibraries.promotableAssets
     };
   }
   collectSourceFiles(dir, collected = []) {
@@ -485,7 +778,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 = path4.join(dir, entry.name);
+      const full = path3.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"))) {