arkgate 2.8.3 → 2.9.1

package/dist/runtime/index.cjs

@@ -80,7 +80,7 @@ __export(runtime_exports, {
 module.exports = __toCommonJS(runtime_exports);
 
 // src/version.ts
-var version = "2.8.3";
+var version = "2.9.1";
 
 // src/kernel/intent/IntentRegistry.ts
 var IntentRegistry = class {
@@ -743,6 +743,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) {
@@ -754,9 +830,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}).`;
@@ -2406,16 +2480,26 @@ function createAICodeGate(options = {}) {
         }
       }
       for (const specifier of extractModuleSpecifiers(source)) {
-        const targetLayer = options.resolveImportLayer?.(specifier.value, filePath);
-        if (targetLayer && contextLayer && targetLayer !== contextLayer) {
-          const blocked = options.architectureProfile?.rules.find(
-            (rule) => !rule.allowed && rule.from === contextLayer && rule.to === targetLayer
+        const targetHit = options.resolveImportTarget?.(specifier.value, filePath) ?? (options.resolveImportLayer ? { layer: options.resolveImportLayer(specifier.value, filePath) } : void 0);
+        const sourceHit = typeof filePath === "string" ? options.resolveImportTarget?.(filePath) ?? (options.resolveImportLayer ? { layer: contextLayer, relPath: void 0 } : void 0) : void 0;
+        const targetLayer = targetHit?.layer;
+        if (targetLayer && contextLayer) {
+          const blocked = findDeniedEdgeRule(
+            options.architectureProfile?.rules,
+            contextLayer,
+            targetLayer,
+            {
+              fromPath: sourceHit?.relPath,
+              toPath: targetHit?.relPath,
+              layers: options.architectureLayers
+            }
           );
           if (blocked) {
+            const peer = Boolean(blocked.peerIsolation);
             violations.push(
               violation(
                 "LAYER_IMPORT_VIOLATION",
-                blocked.message ?? `Layer "${contextLayer}" must not import "${targetLayer}".`,
+                blocked.message ?? (peer ? `Layer "${contextLayer}" must not import across slices into "${targetLayer}".` : `Layer "${contextLayer}" must not import "${targetLayer}".`),
                 {
                   line: lineOf(source, specifier.index),
                   source: specifier.value,
@@ -2423,13 +2507,16 @@ function createAICodeGate(options = {}) {
                   filePath,
                   fromLayer: contextLayer,
                   toLayer: targetLayer,
-                  suggestion: "Depend on a port/interface owned by an inner layer instead, or move this code to a layer allowed to make this import.",
-                  details: { importKind: specifier.kind }
+                  suggestion: peer ? "Extract shared code to a shared layer, or coordinate slices via events/ports \u2014 do not import across feature/context slices." : "Depend on a port/interface owned by an inner layer instead, or move this code to a layer allowed to make this import.",
+                  details: { importKind: specifier.kind, peerIsolation: peer }
                 }
               )
             );
+            continue;
+          }
+          if (targetLayer !== contextLayer) {
+            continue;
           }
-          continue;
         }
         if (exemptFromInfraHeuristics) continue;
         if (!hasInfrastructureToken(specifier.value) && !isKnownInfrastructurePackage(specifier.value)) {
@@ -2498,8 +2585,10 @@ function createAICodeGate(options = {}) {
           if (!looksLikeIntentName(literal.value)) continue;
           const targetLayer = options.architectureProfile.resolveLayer(literal.value);
           if (!targetLayer) continue;
-          const blocked = options.architectureProfile.rules.find(
-            (rule) => !rule.allowed && rule.from === contextLayer && rule.to === targetLayer
+          const blocked = findDeniedEdgeRule(
+            options.architectureProfile.rules,
+            contextLayer,
+            targetLayer
           );
           if (blocked) {
             violations.push(