boundry 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maksymilian Piechota
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,173 @@
+# Boundry
+
+**Compile a C4 architecture diagram into a deterministic dependency linter.**
+
+You draw the allowed architecture once, as a [LikeC4](https://likec4.dev) diagram.
+Boundry turns it into a [dependency-cruiser](https://github.com/sverweij/dependency-cruiser)
+ruleset and checks your code against it — locally and in CI. No model calls, no
+heuristics, no judgement: the architecture you drew *is* the linter.
+
+It's built for a world where AI agents write most of the code. Review doesn't
+scale and LLM-judge supervisors are non-deterministic; Boundry gives agents a
+hard boundary they can't cross instead of a suggestion they might.
+
+```
+diagram (LikeC4)  ──►  boundary model  ──►  dependency-cruiser rules  ──►  ✓ / ✗
+     you draw            source-agnostic         generated                 the gate
+```
+
+## How it works
+
+1. You annotate each element in your diagram with the folder it owns:
+   `metadata { folder 'src/domain' }`.
+2. Every relationship you draw (`a -> b`) is an **allowed** dependency.
+   Anything you don't draw is **forbidden**.
+3. Boundry lifts the diagram into a source-agnostic boundary model, compiles a
+   dependency-cruiser ruleset from it, and runs the linter over your code.
+
+Elements without a `folder` (actors, external systems, notes) are ignored, so a
+rich communication diagram and an enforcement diagram can be the same file.
+
+## See it
+
+The diagram you draw *is* the whole spec. Below is the example architecture that
+Boundry's own end-to-end suite enforces — a hexagonal model with a pure DDD
+core, CQRS, and a public-API boundary.
+
+**[Explore every view interactively →](https://makspiechota.github.io/boundry/)**
+
+### Top-level layers
+
+![Top-level layers: entry point, domain, application, infrastructure](docs/diagrams/example-overview.png)
+
+### Inside the domain — the rules are what's *not* drawn
+
+Aggregates compose Entities and hold Value Objects; Entities may reach Value
+Objects but never Aggregates; Value Objects import nothing. Every missing arrow
+is a forbidden dependency Boundry will reject.
+
+![Domain internals: aggregates, entities, value objects](docs/diagrams/example-domain.png)
+
+## Install
+
+```bash
+npm install --save-dev boundry
+```
+
+Requires Node 20+. `likec4` and `dependency-cruiser` come along as dependencies.
+
+## Quickstart
+
+Draw your architecture — `arch/architecture.likec4`:
+
+```likec4
+specification {
+  element module { style { shape rectangle } }
+}
+
+model {
+  module domain 'Domain' {
+    metadata { folder 'src/domain' }
+  }
+  module infra 'Infrastructure' {
+    metadata { folder 'src/infra' }
+  }
+
+  // Allowed dependency. Everything not drawn is forbidden.
+  infra -> domain
+}
+
+views {
+  view index { include * }
+}
+```
+
+Check your code against it:
+
+```bash
+npx boundry check --arch arch src
+# ✓ no boundary violations                          (exit 0)
+# ✗ src/domain/user.ts → src/infra/db.ts [boundary-domain]   (exit 1)
+```
+
+A `domain → infra` import is now a build failure; `infra → domain` is fine.
+
+## CLI
+
+```
+boundry check    [--arch <dir>] [--cwd <dir>] [sources...]
+boundry generate [--arch <dir>] [--cwd <dir>] [--out <file>]
+```
+
+| Flag | Meaning |
+| --- | --- |
+| `--arch <dir>` | LikeC4 workspace directory (all `.likec4` files in it are merged). Default `.`. |
+| `--cwd <dir>` | Repo root to check. `folder` paths are relative to it. Lets you run from anywhere. |
+| `--out <file>` | `generate` only: where to write the dependency-cruiser config. Default `.dependency-cruiser.cjs`. |
+| `sources...` | `check` only: paths to lint. Default `src`. |
+
+- **`check`** compiles the rules and runs the linter. Exits non-zero on any violation.
+- **`generate`** just emits the dependency-cruiser config so you can commit it or
+  run `depcruise` yourself.
+
+Boundry warns (but does not fail) when a mapped folder matches **zero** files —
+so a passing check can never silently enforce nothing.
+
+## CI
+
+```yaml
+# .github/workflows/architecture.yml
+name: architecture
+on: [push, pull_request]
+jobs:
+  boundry:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: 20 }
+      - run: npm ci
+      - run: npx boundry check --arch arch src
+```
+
+## Programmatic use (SDK)
+
+The CLI is a thin wrapper over the SDK. Everything is pluggable — the diagram
+source and the target linter are both adapters behind ports.
+
+```ts
+import { Pipeline, LikeC4Visualizer, DepCruiserEnforcer } from 'boundry';
+
+const pipeline = new Pipeline(
+  new LikeC4Visualizer('arch'),
+  new DepCruiserEnforcer(),
+);
+
+const result = await pipeline.check(['src']);
+if (!result.ok) {
+  for (const v of result.violations) console.error(`${v.from} → ${v.to}`);
+  process.exit(1);
+}
+```
+
+## Status & scope
+
+Early but real — Boundry enforces its own architecture on itself, and ships an
+end-to-end test suite covering a hexagonal + CQRS + DDD model (pure domain core,
+read/write separation, a public-API boundary).
+
+Today: **TypeScript** via dependency-cruiser, **LikeC4** as the diagram source.
+Both are adapters, so more languages/linters and diagram formats can plug in
+without touching the core.
+
+Current limitations:
+
+- One element maps to exactly one folder.
+- Nesting is supported: you can map a parent folder *and* its children. A
+  parent's edges govern only the parent's own files — a child never inherits
+  them and must be permitted explicitly.
+- `folder` paths are relative to the repo root (`--cwd`), not the diagram file.
+
+## License
+
+[MIT](./LICENSE) © Maksymilian Piechota

package/dist/adapters/enforcer/depcruiser.d.ts

@@ -0,0 +1,7 @@
+import type { EnforcerPort, EnforcerConfig, CheckResult } from '../../core/ports/ports.js';
+import type { BoundaryModel } from '../../core/model/boundary-model.js';
+/** First enforcer adapter: targets dependency-cruiser for TypeScript. */
+export declare class DepCruiserEnforcer implements EnforcerPort {
+    render(model: BoundaryModel): EnforcerConfig;
+    check(model: BoundaryModel, sources: string[]): Promise<CheckResult>;
+}

package/dist/adapters/enforcer/depcruiser.js

@@ -0,0 +1,98 @@
+import * as dependencyCruiser from 'dependency-cruiser';
+// dependency-cruiser ships CommonJS; reach `cruise` through either interop shape.
+const cruise = dependencyCruiser.cruise ?? dependencyCruiser.default?.cruise;
+function folderPrefix(folder) {
+    return folder.replace(/\/+$/, '');
+}
+function folderToRegex(folder) {
+    const escaped = folderPrefix(folder).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return `^${escaped}/`;
+}
+/** True if `child` is a folder strictly nested under `parent`. */
+function isDescendantFolder(child, parent) {
+    const c = folderPrefix(child);
+    const p = folderPrefix(parent);
+    return c !== p && c.startsWith(`${p}/`);
+}
+/**
+ * Derives one forbidden rule per (module, disallowed target) pair. A module owns
+ * its folder MINUS any mapped descendant folders (which belong to more-specific
+ * modules). That containment handling means a parent-level rule never governs a
+ * child's files, and a module's own internal imports are never flagged.
+ * Dependencies into non-module paths (node_modules, unmapped folders) are left
+ * untouched — the architecture only governs edges it drew.
+ */
+function buildForbiddenRules(model) {
+    const allowedTargets = new Map();
+    for (const m of model.modules)
+        allowedTargets.set(m.id, new Set([m.id]));
+    for (const edge of model.allowed)
+        allowedTargets.get(edge.from)?.add(edge.to);
+    // Each module's scope: its folder, carving out any mapped descendant folders.
+    const scopeOf = new Map();
+    for (const m of model.modules) {
+        const descendants = model.modules
+            .filter((other) => isDescendantFolder(other.folder, m.folder))
+            .map((other) => folderToRegex(other.folder));
+        scopeOf.set(m.id, descendants.length
+            ? { path: folderToRegex(m.folder), pathNot: descendants }
+            : { path: folderToRegex(m.folder) });
+    }
+    const rules = [];
+    for (const from of model.modules) {
+        const allowed = allowedTargets.get(from.id);
+        for (const to of model.modules) {
+            if (allowed.has(to.id))
+                continue; // self or an explicitly allowed edge
+            rules.push({
+                name: `boundary:${from.id}->${to.id}`,
+                comment: `${from.title} may not depend on ${to.title}`,
+                severity: 'error',
+                from: scopeOf.get(from.id),
+                to: scopeOf.get(to.id),
+            });
+        }
+    }
+    return rules;
+}
+/** First enforcer adapter: targets dependency-cruiser for TypeScript. */
+export class DepCruiserEnforcer {
+    render(model) {
+        const forbidden = buildForbiddenRules(model);
+        const content = `/** Generated by Boundry from the architecture diagram. Do not edit by hand. */
+module.exports = {
+  forbidden: ${JSON.stringify(forbidden, null, 2)},
+  options: {
+    doNotFollow: { path: 'node_modules' },
+    tsPreCompilationDeps: true,
+  },
+};
+`;
+        return { filename: '.dependency-cruiser.cjs', content };
+    }
+    async check(model, sources) {
+        const forbidden = buildForbiddenRules(model);
+        const result = await cruise(sources, {
+            validate: true,
+            ruleSet: { forbidden },
+            doNotFollow: { path: 'node_modules' },
+            tsPreCompilationDeps: true,
+        });
+        const output = typeof result.output === 'string' ? JSON.parse(result.output) : result.output;
+        const raw = output?.summary?.violations ?? [];
+        const violations = raw
+            .filter((v) => v.rule?.severity === 'error')
+            .map((v) => ({ from: v.from, to: v.to, rule: v.rule?.name ?? 'unknown' }));
+        // A module whose folder matched no source files enforces nothing — the
+        // "green but inert" trap. Surface it so a passing check can't hide it.
+        const seen = (output?.modules ?? []).map((m) => String(m.source));
+        const warnings = [];
+        for (const mod of model.modules) {
+            const prefix = `${mod.folder.replace(/\/+$/, '')}/`;
+            if (!seen.some((source) => source.startsWith(prefix))) {
+                warnings.push(`module '${mod.title}' maps to '${mod.folder}', which matched 0 source files`);
+            }
+        }
+        return { ok: violations.length === 0, violations, warnings };
+    }
+}

package/dist/adapters/visualizer/likec4.d.ts

@@ -0,0 +1,20 @@
+import type { VisualizerPort } from '../../core/ports/ports.js';
+import type { BoundaryModel } from '../../core/model/boundary-model.js';
+/**
+ * First visualizer adapter. Reads a LikeC4 workspace and lifts it into the
+ * boundary model: any element carrying a `folder` metadata key becomes a
+ * module, and any relationship between two such elements becomes an allowed
+ * edge.
+ */
+export declare class LikeC4Visualizer implements VisualizerPort {
+    private readonly workspaceDir;
+    constructor(workspaceDir: string);
+    read(): Promise<BoundaryModel>;
+    /**
+     * Deterministically strip `#proposed` markers from the diagram source,
+     * promoting intent edges to approved. Source-preserving; never an LLM edit —
+     * it locates each marked relationship in the LikeC4 CST and splices out its
+     * proposal decoration, leaving all other formatting intact.
+     */
+    approve(): Promise<void>;
+}

package/dist/adapters/visualizer/likec4.js

@@ -0,0 +1,138 @@
+import { LikeC4 } from 'likec4';
+import { readFileSync, writeFileSync } from 'node:fs';
+function findDescendant(node, predicate) {
+    const seen = new Set();
+    const stack = [node];
+    while (stack.length) {
+        const n = stack.pop();
+        if (!n || typeof n !== 'object' || seen.has(n))
+            continue;
+        seen.add(n);
+        if (Array.isArray(n)) {
+            stack.push(...n);
+            continue;
+        }
+        if (predicate(n))
+            return n;
+        for (const key of Object.keys(n)) {
+            if (!key.startsWith('$'))
+                stack.push(n[key]);
+        }
+    }
+    return undefined;
+}
+function isProposedTag(node, text) {
+    return (node.$type === 'TagRef' &&
+        node.$cstNode &&
+        text.slice(node.$cstNode.offset, node.$cstNode.end) === '#proposed');
+}
+/**
+ * For a relationship carrying a `#proposed` marker, the range of source to
+ * remove: the whole relationship body (the proposal decoration) plus the
+ * whitespace before it, or the bare inline tag when there is no body.
+ */
+function proposedRemovalRange(relation, text) {
+    const body = findDescendant(relation, (n) => n.$type === 'RelationBody' && n.$cstNode);
+    if (body) {
+        let start = body.$cstNode.offset;
+        while (start > 0 && /\s/.test(text[start - 1]))
+            start--;
+        return { start, end: body.$cstNode.end };
+    }
+    const tag = findDescendant(relation, (n) => isProposedTag(n, text));
+    if (tag) {
+        let start = tag.$cstNode.offset;
+        while (start > 0 && (text[start - 1] === ' ' || text[start - 1] === '\t'))
+            start--;
+        return { start, end: tag.$cstNode.end };
+    }
+    return undefined;
+}
+function collectProposedRanges(root, text) {
+    const ranges = [];
+    const seen = new Set();
+    const walk = (node) => {
+        if (!node || typeof node !== 'object' || seen.has(node))
+            return;
+        seen.add(node);
+        if (Array.isArray(node)) {
+            for (const item of node)
+                walk(item);
+            return;
+        }
+        if (node.$type === 'Relation' &&
+            node.$cstNode &&
+            findDescendant(node, (n) => isProposedTag(n, text))) {
+            const range = proposedRemovalRange(node, text);
+            if (range)
+                ranges.push(range);
+        }
+        for (const key of Object.keys(node)) {
+            if (!key.startsWith('$'))
+                walk(node[key]);
+        }
+    };
+    walk(root);
+    return ranges;
+}
+/**
+ * First visualizer adapter. Reads a LikeC4 workspace and lifts it into the
+ * boundary model: any element carrying a `folder` metadata key becomes a
+ * module, and any relationship between two such elements becomes an allowed
+ * edge.
+ */
+export class LikeC4Visualizer {
+    workspaceDir;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    async read() {
+        const likec4 = await LikeC4.fromWorkspace(this.workspaceDir);
+        const model = await likec4.computedModel();
+        const modules = [];
+        const folderIds = new Set();
+        for (const el of model.elements()) {
+            const meta = el.getMetadata('folder');
+            const folder = Array.isArray(meta) ? meta[0] : meta;
+            if (folder) {
+                const id = String(el.id);
+                modules.push({ id, title: el.title, folder });
+                folderIds.add(id);
+            }
+        }
+        const allowed = [];
+        for (const rel of model.relationships()) {
+            // A `#proposed` edge is an intent, not yet approved — it is NOT enforced
+            // as allowed until the marker is stripped (see `approve`).
+            if (rel.tags.some((tag) => String(tag) === 'proposed'))
+                continue;
+            const from = String(rel.source.id);
+            const to = String(rel.target.id);
+            if (from !== to && folderIds.has(from) && folderIds.has(to)) {
+                allowed.push({ from, to });
+            }
+        }
+        return { modules, allowed };
+    }
+    /**
+     * Deterministically strip `#proposed` markers from the diagram source,
+     * promoting intent edges to approved. Source-preserving; never an LLM edit —
+     * it locates each marked relationship in the LikeC4 CST and splices out its
+     * proposal decoration, leaving all other formatting intact.
+     */
+    async approve() {
+        const likec4 = await LikeC4.fromWorkspace(this.workspaceDir);
+        for (const doc of likec4.LangiumDocuments.all) {
+            const filePath = doc.uri.fsPath;
+            const text = doc.textDocument?.getText?.() ?? readFileSync(filePath, 'utf8');
+            const ranges = collectProposedRanges(doc.parseResult?.value, text);
+            if (ranges.length === 0)
+                continue;
+            let next = text;
+            for (const { start, end } of ranges.sort((a, b) => b.start - a.start)) {
+                next = next.slice(0, start) + next.slice(end);
+            }
+            writeFileSync(filePath, next);
+        }
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, readdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, relative, resolve } from 'node:path';
+import { Pipeline } from '../core/pipeline/pipeline.js';
+import { LikeC4Visualizer } from '../adapters/visualizer/likec4.js';
+import { DepCruiserEnforcer } from '../adapters/enforcer/depcruiser.js';
+const USAGE = 'usage: boundry <generate|check|approve|verify> [--arch <dir>] [--base <git-ref>] [--cwd <dir>] [--out <file>] [sources...]';
+function optValue(args, flag) {
+    const i = args.indexOf(flag);
+    return i >= 0 ? args[i + 1] : undefined;
+}
+function positionals(args) {
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        if (args[i].startsWith('--')) {
+            i++; // skip the flag's value
+            continue;
+        }
+        out.push(args[i]);
+    }
+    return out;
+}
+/**
+ * Materialize the architecture as of a git ref into a temp workspace, so the
+ * previously-approved boundary model can be lifted and compared against HEAD.
+ */
+function materializeArchAt(archDir, ref) {
+    const gitRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+        cwd: archDir,
+        encoding: 'utf8',
+    }).trim();
+    const workDir = mkdtempSync(join(tmpdir(), 'boundry-base-'));
+    for (const file of readdirSync(archDir).filter((f) => f.endsWith('.likec4'))) {
+        try {
+            const content = execFileSync('git', ['show', `${ref}:${relative(gitRoot, join(archDir, file))}`], {
+                cwd: gitRoot,
+                encoding: 'utf8',
+            });
+            writeFileSync(join(workDir, file), content);
+        }
+        catch {
+            // The file did not exist at `ref` — everything it declares is new.
+        }
+    }
+    return workDir;
+}
+function listGrantedEdges(granted) {
+    for (const edge of granted)
+        console.error(`  ${edge.from} → ${edge.to}`);
+    console.error('  Mark them #proposed so the grant is an explicit, reviewable act.');
+}
+async function main() {
+    const [command, ...rest] = process.argv.slice(2);
+    // Resolve paths against the *original* cwd before we optionally move into the
+    // target repo, so `--arch` and `--out` are unaffected by `--cwd`.
+    const archDir = resolve(optValue(rest, '--arch') ?? '.');
+    const outArg = optValue(rest, '--out');
+    const outFile = outArg ? resolve(outArg) : undefined;
+    const baseRef = optValue(rest, '--base');
+    // `--cwd` lets you check a repo without cd-ing into it. `folder` metadata is
+    // relative to the target repo root, so the enforcer runs from there.
+    const cwd = optValue(rest, '--cwd');
+    if (cwd)
+        process.chdir(resolve(cwd));
+    const pipeline = new Pipeline(new LikeC4Visualizer(archDir), new DepCruiserEnforcer());
+    const grantedSince = (ref) => pipeline.verify(new LikeC4Visualizer(materializeArchAt(archDir, ref)));
+    if (command === 'generate') {
+        const config = await pipeline.generate();
+        const out = outFile ?? resolve(config.filename);
+        writeFileSync(out, config.content);
+        console.log(`Boundry: wrote ${out}`);
+        return;
+    }
+    if (command === 'check') {
+        const sources = positionals(rest);
+        const result = await pipeline.check(sources.length ? sources : ['src']);
+        for (const warning of result.warnings) {
+            console.error(`Boundry: ⚠ ${warning}`);
+        }
+        if (result.ok) {
+            console.log('Boundry: ✓ no boundary violations');
+            return;
+        }
+        console.error(`Boundry: ✗ ${result.violations.length} boundary violation(s)`);
+        for (const v of result.violations) {
+            console.error(`  ${v.from} → ${v.to}  [${v.rule}]`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    if (command === 'verify') {
+        if (!baseRef) {
+            console.error('Boundry: verify requires --base <git-ref>');
+            process.exitCode = 2;
+            return;
+        }
+        const granted = await grantedSince(baseRef);
+        if (granted.length === 0) {
+            console.log(`Boundry: ✓ no edges granted without a #proposed marker (vs ${baseRef})`);
+            return;
+        }
+        console.error(`Boundry: ✗ ${granted.length} edge(s) granted without a #proposed marker (vs ${baseRef})`);
+        listGrantedEdges(granted);
+        process.exitCode = 1;
+        return;
+    }
+    if (command === 'approve') {
+        // Approving must never launder an edge that skipped the proposal protocol.
+        if (baseRef) {
+            const granted = await grantedSince(baseRef);
+            if (granted.length > 0) {
+                console.error(`Boundry: ✗ refusing to approve — ${granted.length} edge(s) were granted without a #proposed marker (vs ${baseRef})`);
+                listGrantedEdges(granted);
+                process.exitCode = 1;
+                return;
+            }
+        }
+        else {
+            console.error('Boundry: ⚠ no --base given — approving without verifying that every new edge was proposed');
+        }
+        await pipeline.approve();
+        console.log('Boundry: ✓ approved — stripped #proposed markers from the diagram');
+        return;
+    }
+    console.error(USAGE);
+    process.exitCode = 2;
+}
+main().catch((err) => {
+    console.error(err);
+    process.exitCode = 1;
+});

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

@@ -0,0 +1,30 @@
+/**
+ * The single, source-agnostic representation everything in Boundry compiles
+ * from. A visualizer adapter produces it; an enforcer adapter renders it.
+ */
+/** A unit of architecture that maps to a folder of source code. */
+export interface Module {
+    /** Stable id, taken from the diagram element. */
+    id: string;
+    /** Human-readable name for messages. */
+    title: string;
+    /** Source path prefix the module owns, e.g. "src/core". */
+    folder: string;
+}
+/** A permitted dependency: modules in `from` may import modules in `to`. */
+export interface AllowedEdge {
+    from: string;
+    to: string;
+}
+export interface BoundaryModel {
+    modules: Module[];
+    allowed: AllowedEdge[];
+}
+/**
+ * Edges allowed at `head` that were not allowed at `base`.
+ *
+ * A `#proposed` edge is deliberately excluded from a model's allow-list, so a
+ * proposal never appears here. That makes this delta exactly the set of
+ * dependencies granted WITHOUT going through a proposal — i.e. self-approvals.
+ */
+export declare function newlyAllowedEdges(base: BoundaryModel, head: BoundaryModel): AllowedEdge[];

package/dist/core/model/boundary-model.js

@@ -0,0 +1,16 @@
+/**
+ * The single, source-agnostic representation everything in Boundry compiles
+ * from. A visualizer adapter produces it; an enforcer adapter renders it.
+ */
+const edgeKey = (edge) => `${edge.from} -> ${edge.to}`;
+/**
+ * Edges allowed at `head` that were not allowed at `base`.
+ *
+ * A `#proposed` edge is deliberately excluded from a model's allow-list, so a
+ * proposal never appears here. That makes this delta exactly the set of
+ * dependencies granted WITHOUT going through a proposal — i.e. self-approvals.
+ */
+export function newlyAllowedEdges(base, head) {
+    const allowedAtBase = new Set(base.allowed.map(edgeKey));
+    return head.allowed.filter((edge) => !allowedAtBase.has(edgeKey(edge)));
+}

package/dist/core/pipeline/pipeline.d.ts

@@ -0,0 +1,23 @@
+import type { VisualizerPort, EnforcerPort, EnforcerConfig, CheckResult } from "../ports/ports.js";
+import type { AllowedEdge } from "../model/boundary-model.js";
+/**
+ * The SDK's public surface. Orchestrates the two driven ports and stays blind
+ * to any concrete diagram source or linter — swap adapters, this is untouched.
+ */
+export declare class Pipeline {
+    private readonly visualizer;
+    private readonly enforcer;
+    constructor(visualizer: VisualizerPort, enforcer: EnforcerPort);
+    /** Diagram -> boundary model -> generated linter config. */
+    generate(): Promise<EnforcerConfig>;
+    /** Diagram -> boundary model -> run the linter over `sources`. */
+    check(sources: string[]): Promise<CheckResult>;
+    /**
+     * Edges this diagram grants that `base` did not — i.e. dependencies added
+     * without a `#proposed` marker. Proposals are excluded from the allow-list,
+     * so anything reported here bypassed the approval protocol.
+     */
+    verify(base: VisualizerPort): Promise<AllowedEdge[]>;
+    /** Approve proposed edges: strip their `#proposed` markers from the diagram. */
+    approve(): Promise<void>;
+}

package/dist/core/pipeline/pipeline.js

@@ -0,0 +1,36 @@
+import { newlyAllowedEdges } from "../model/boundary-model.js";
+/**
+ * The SDK's public surface. Orchestrates the two driven ports and stays blind
+ * to any concrete diagram source or linter — swap adapters, this is untouched.
+ */
+export class Pipeline {
+    visualizer;
+    enforcer;
+    constructor(visualizer, enforcer) {
+        this.visualizer = visualizer;
+        this.enforcer = enforcer;
+    }
+    /** Diagram -> boundary model -> generated linter config. */
+    async generate() {
+        const model = await this.visualizer.read();
+        return this.enforcer.render(model);
+    }
+    /** Diagram -> boundary model -> run the linter over `sources`. */
+    async check(sources) {
+        const model = await this.visualizer.read();
+        return this.enforcer.check(model, sources);
+    }
+    /**
+     * Edges this diagram grants that `base` did not — i.e. dependencies added
+     * without a `#proposed` marker. Proposals are excluded from the allow-list,
+     * so anything reported here bypassed the approval protocol.
+     */
+    async verify(base) {
+        const [baseModel, headModel] = await Promise.all([base.read(), this.visualizer.read()]);
+        return newlyAllowedEdges(baseModel, headModel);
+    }
+    /** Approve proposed edges: strip their `#proposed` markers from the diagram. */
+    async approve() {
+        return this.visualizer.approve();
+    }
+}

package/dist/core/ports/ports.d.ts

@@ -0,0 +1,35 @@
+import type { BoundaryModel } from '../model/boundary-model.js';
+/** A driven port: turns some diagram source into the boundary model. */
+export interface VisualizerPort {
+    read(): Promise<BoundaryModel>;
+    /**
+     * Deterministically strip `#proposed` markers from the diagram source,
+     * promoting intent edges to approved. Source-preserving; never an LLM edit.
+     */
+    approve(): Promise<void>;
+}
+/** A generated linter config artifact. */
+export interface EnforcerConfig {
+    filename: string;
+    content: string;
+}
+/** A single boundary violation found by an enforcer. */
+export interface Violation {
+    from: string;
+    to: string;
+    rule: string;
+}
+export interface CheckResult {
+    ok: boolean;
+    violations: Violation[];
+    /** Non-fatal problems, e.g. a mapped folder that matched no source files. */
+    warnings: string[];
+}
+/**
+ * A driven port: renders the boundary model into a target linter's native
+ * config, and runs that linter against source.
+ */
+export interface EnforcerPort {
+    render(model: BoundaryModel): EnforcerConfig;
+    check(model: BoundaryModel, sources: string[]): Promise<CheckResult>;
+}

package/dist/core/ports/ports.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type { BoundaryModel, Module, AllowedEdge, } from './core/model/boundary-model.js';
+export type { VisualizerPort, EnforcerPort, EnforcerConfig, CheckResult, Violation, } from './core/ports/ports.js';
+export { Pipeline } from './core/pipeline/pipeline.js';
+export { LikeC4Visualizer } from './adapters/visualizer/likec4.js';
+export { DepCruiserEnforcer } from './adapters/enforcer/depcruiser.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { Pipeline } from './core/pipeline/pipeline.js';
+export { LikeC4Visualizer } from './adapters/visualizer/likec4.js';
+export { DepCruiserEnforcer } from './adapters/enforcer/depcruiser.js';

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "boundry",
+  "version": "0.0.1",
+  "description": "Compile a C4 architecture diagram into a deterministic dependency linter. Deterministic architectural guardrails for AI agents and humans.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Maksymilian Piechota",
+  "homepage": "https://github.com/makspiechota/boundry#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/makspiechota/boundry.git"
+  },
+  "bugs": {
+    "url": "https://github.com/makspiechota/boundry/issues"
+  },
+  "keywords": [
+    "architecture",
+    "dependency-cruiser",
+    "likec4",
+    "c4",
+    "linter",
+    "guardrails",
+    "hexagonal",
+    "ddd",
+    "typescript",
+    "ai-agents"
+  ],
+  "bin": {
+    "boundry": "./dist/cli/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "boundry": "tsx src/cli/index.ts",
+    "generate": "tsx src/cli/index.ts generate --arch arch --out .dependency-cruiser.cjs",
+    "check": "tsx src/cli/index.ts check --arch arch src",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "test": "node --import tsx --test src/__tests__/e2e/*.e2e.test.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "dependency-cruiser": "^16.4.0",
+    "likec4": "^1.46.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  }
+}