arkgate 2.8.3 → 2.9.0

package/dist/nestjs/index.cjs

@@ -600,6 +600,82 @@ async function recordInterceptorError(interceptor, event, error, deps) {
   });
 }
 
+// src/domain/layerMatch.ts
+function normalizeGlobSeparators(pattern) {
+  let out = "";
+  for (let i = 0; i < pattern.length; i += 1) {
+    const c = pattern[i];
+    if (c === "\\" && i + 1 < pattern.length) {
+      const next = pattern[i + 1];
+      if ("*?{}[],".includes(next) || next === "\\") {
+        out += "\\" + next;
+        i += 1;
+        continue;
+      }
+      out += "/";
+      continue;
+    }
+    out += c;
+  }
+  return out;
+}
+function sliceIdForPath(relPath, sliceFolders) {
+  if (!sliceFolders?.length) return void 0;
+  const parts = String(relPath).split(/[/\\]/).filter(Boolean);
+  const folders = new Set(sliceFolders.map((s) => String(s).toLowerCase()));
+  for (let i = 0; i < parts.length - 1; i += 1) {
+    if (folders.has(parts[i].toLowerCase())) {
+      return `${parts[i]}/${parts[i + 1]}`;
+    }
+  }
+  return void 0;
+}
+function inferSliceFoldersFromPatterns(patterns) {
+  const out = /* @__PURE__ */ new Set();
+  for (const pattern of patterns ?? []) {
+    const glob = normalizeGlobSeparators(String(pattern));
+    const parts = glob.split("/").filter(Boolean);
+    for (let i = 0; i < parts.length; i += 1) {
+      const part = parts[i];
+      if ((part === "**" || part === "*") && i > 0) {
+        const prev = parts[i - 1];
+        if (prev && !prev.includes("*") && !prev.includes("{") && !prev.includes("}")) {
+          out.add(prev);
+        }
+      }
+    }
+  }
+  return [...out];
+}
+function resolveSliceFolders(rule, layerName, layers) {
+  if (Array.isArray(rule.sliceFolders) && rule.sliceFolders.length > 0) {
+    return rule.sliceFolders.filter((s) => typeof s === "string" && s.length > 0);
+  }
+  const layer = (layers ?? []).find((l) => l.name === layerName);
+  return inferSliceFoldersFromPatterns(layer?.patterns);
+}
+function findDeniedEdgeRule(rules, from, to, options) {
+  for (const rule of rules ?? []) {
+    if (rule.from !== from || rule.to !== to) continue;
+    if (rule.allowed !== false) continue;
+    if (rule.peerIsolation) {
+      const fromPath = options?.fromPath;
+      const toPath = options?.toPath;
+      if (!fromPath || !toPath) continue;
+      const folders = resolveSliceFolders(rule, from, options?.layers);
+      if (folders.length === 0) continue;
+      const fromSlice = sliceIdForPath(fromPath, folders);
+      const toSlice = sliceIdForPath(toPath, folders);
+      if (!fromSlice || !toSlice) continue;
+      if (fromSlice !== toSlice) return rule;
+      continue;
+    }
+    if (from === to) continue;
+    return rule;
+  }
+  return void 0;
+}
+
 // src/kernel/event-bus/observedLayerFlow.ts
 async function assertObservedLayerFlowAllowed(event, deps) {
   if (deps.mode === "off" || !deps.architectureProfile) {
@@ -611,9 +687,7 @@ async function assertObservedLayerFlowAllowed(event, deps) {
   const fromLayer = profile.resolveLayer(source);
   const toLayer = profile.resolveLayer(event.intent);
   if (!fromLayer || !toLayer) return;
-  const blocked = profile.rules.find(
-    (rule) => !rule.allowed && rule.from === fromLayer && rule.to === toLayer
-  );
+  const blocked = findDeniedEdgeRule(profile.rules, fromLayer, toLayer);
   if (!blocked) return;
   const severity = deps.mode;
   const message = blocked.message ?? `Observed layer violation: "${source}" (${fromLayer}) must not produce "${event.intent}" (${toLayer}).`;
@@ -1727,7 +1801,7 @@ var elevenLayerProfile = createArchitectureProfile({
 var MANIFEST_SCHEMA_VERSION = "1.0";
 
 // src/version.ts
-var version = "2.8.3";
+var version = "2.9.0";
 
 // src/kernel/manifest/createArkManifest.ts
 function policyId(name) {