boundry 0.0.1 → 0.1.0

package/README.md

@@ -28,6 +28,25 @@ diagram (LikeC4)  ──►  boundary model  ──►  dependency-cruiser rules
 Elements without a `folder` (actors, external systems, notes) are ignored, so a
 rich communication diagram and an enforcement diagram can be the same file.
 
+### Governing a whole root (opt-in)
+
+By default a folder no element maps to is *ignored* — any module may import it.
+That is what keeps a communication diagram usable as an enforcement diagram, but
+it means brand-new, unmodelled code is free to import. Declare a root as fully
+governed and the whole tree becomes the universe instead:
+
+```likec4
+system app 'App' {
+  metadata { governRoot 'src' }
+}
+```
+
+Now importing anything under `src/` that no module claims is a **violation**, and
+`check` **warns** about code under the root that no module covers. That is the
+mirror of the zero-files warning: the model failing to cover the code is as much
+a gap as the code failing to back the model. Nothing changes unless you declare
+it.
+
 ## See it
 
 The diagram you draw *is* the whole spec. Below is the example architecture that

package/dist/adapters/enforcer/depcruiser.js

@@ -53,6 +53,21 @@ function buildForbiddenRules(model) {
             });
         }
     }
+    // A declared govern root makes the whole tree the universe: territory no
+    // module claims is forbidden, not free. Additive — the pair rules above still
+    // decide every mapped-to-mapped edge on their own.
+    if (model.governRoot) {
+        const claimed = model.modules.map((m) => folderToRegex(m.folder));
+        for (const from of model.modules) {
+            rules.push({
+                name: `boundary:${from.id}->unmapped`,
+                comment: `${from.title} may not depend on code under '${model.governRoot}' that no module claims`,
+                severity: 'error',
+                from: scopeOf.get(from.id),
+                to: { path: folderToRegex(model.governRoot), pathNot: claimed },
+            });
+        }
+    }
     return rules;
 }
 /** First enforcer adapter: targets dependency-cruiser for TypeScript. */
@@ -93,6 +108,24 @@ module.exports = {
                 warnings.push(`module '${mod.title}' maps to '${mod.folder}', which matched 0 source files`);
             }
         }
+        // The symmetric guard: code under a declared govern root that no module
+        // claims. The model not covering the code is as much a gap as the code not
+        // backing the model.
+        if (model.governRoot) {
+            const rootPrefix = `${folderPrefix(model.governRoot)}/`;
+            const claimed = model.modules.map((m) => `${folderPrefix(m.folder)}/`);
+            const unclaimed = new Set();
+            for (const source of seen) {
+                if (!source.startsWith(rootPrefix))
+                    continue;
+                if (claimed.some((prefix) => source.startsWith(prefix)))
+                    continue;
+                unclaimed.add(source.slice(0, source.lastIndexOf('/')));
+            }
+            for (const dir of unclaimed) {
+                warnings.push(`'${dir}' is under govern root '${model.governRoot}' but no module claims it`);
+            }
+        }
         return { ok: violations.length === 0, violations, warnings };
     }
 }

package/dist/adapters/visualizer/likec4.js

@@ -91,7 +91,14 @@ export class LikeC4Visualizer {
         const model = await likec4.computedModel();
         const modules = [];
         const folderIds = new Set();
+        let governRoot;
         for (const el of model.elements()) {
+            // Opt-in: any element may declare the code root as fully governed. It
+            // needs no `folder` of its own — it is a declaration, not a module.
+            const rootMeta = el.getMetadata('governRoot');
+            const declaredRoot = Array.isArray(rootMeta) ? rootMeta[0] : rootMeta;
+            if (declaredRoot && !governRoot)
+                governRoot = declaredRoot;
             const meta = el.getMetadata('folder');
             const folder = Array.isArray(meta) ? meta[0] : meta;
             if (folder) {
@@ -112,7 +119,7 @@ export class LikeC4Visualizer {
                 allowed.push({ from, to });
             }
         }
-        return { modules, allowed };
+        return { modules, allowed, governRoot };
     }
     /**
      * Deterministically strip `#proposed` markers from the diagram source,

package/dist/core/model/boundary-model.d.ts

@@ -19,6 +19,13 @@ export interface AllowedEdge {
 export interface BoundaryModel {
     modules: Module[];
     allowed: AllowedEdge[];
+    /**
+     * Optional code root declared fully governed. Every folder under it is
+     * expected to be modelled, so importing territory no module claims is
+     * forbidden rather than free. Omitted (the default) = unmapped folders are
+     * ignored, which keeps a communication diagram usable as an enforcement one.
+     */
+    governRoot?: string;
 }
 /**
  * Edges allowed at `head` that were not allowed at `base`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "boundry",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Compile a C4 architecture diagram into a deterministic dependency linter. Deterministic architectural guardrails for AI agents and humans.",
   "type": "module",
   "license": "MIT",