@opengroundplan/core 0.1.1

package/templates/architectures/feature-sliced-design/files/docs/architecture.md

@@ -0,0 +1,148 @@
+# Architecture — Feature-Sliced Design
+
+This repository is organised with [Feature-Sliced Design](https://feature-sliced.design)
+(FSD): a folder methodology for front-end applications. Code is split into **layers**
+(technical responsibility), then into **slices** (business domain), then into **segments**
+(technical nature).
+
+## The one rule
+
+> A module (file) in a slice can only import other slices when they are located on layers
+> strictly **below**.
+> — [feature-sliced.design/docs/reference/layers](https://feature-sliced.design/docs/reference/layers)
+
+Everything else in this document follows from that sentence. Imports point one way, down
+the list. There is no upward import, no sideways import, and no exception negotiated in a
+pull request — `scripts/check-fsd-boundaries.mjs` fails the build instead.
+
+## Layers
+
+Top has the most responsibility and the most dependencies; bottom has the least.
+
+| Layer      | Holds                                                                       | May import         |
+| ---------- | --------------------------------------------------------------------------- | ------------------ |
+| `app`      | Everything that makes the app run: routing, entrypoints, providers, styles.  | all layers below   |
+| `pages`    | Full pages, or large parts of a page in nested routing.                      | widgets and below  |
+| `widgets`  | Large self-contained blocks of UI or functionality — usually a whole use case.| features and below |
+| `features` | Reused implementations of product features; actions that carry business value.| entities and below |
+| `entities` | The business entities the product works with — one slice each.               | shared             |
+| `shared`   | Reusable code with no business specifics: UI kit, API client, config, libs.  | nothing above it   |
+
+The `processes` layer of older FSD versions is deprecated and is deliberately absent here.
+
+## Slices and segments
+
+`pages`, `widgets`, `features` and `entities` are divided into **slices** named after the
+business domain (`entities/user`, `features/comment-form`). Slice names are not prescribed
+by FSD — they come from your product.
+
+`app` and `shared` have no slices; they go straight to segments, and their segments may
+import each other freely.
+
+Inside a slice, **segments** group by technical nature:
+
+```
+entities/user/
+├── ui/        components
+├── api/       requests and cache keys
+├── model/     store, business logic, types
+├── lib/       helpers used only by this slice
+└── index.ts   the public API
+```
+
+## Public API
+
+> Every slice (and segment on layers that don't have slices) must contain a public API
+> definition. Modules outside of this slice/segment can only reference the public API, not
+> the internal file structure.
+
+So `index.ts` at the root of every slice, and at the root of every `shared/*` segment:
+
+```ts
+// entities/user/index.ts
+export { UserAvatar } from './ui/user-avatar';
+export { useUser } from './model/use-user';
+export type { User } from './model/types';
+```
+
+```ts
+import { UserAvatar } from '@/entities/user';        // yes — through the public API
+import { UserAvatar } from '@/entities/user/ui/user-avatar'; // no — reaches past it
+```
+
+Two slices on the same layer never import each other. When one entity genuinely needs
+another, the owning slice publishes a dedicated cross-import API at
+`entities/<owner>/@x/<consumer>`; that is the only same-layer import the checker allows.
+
+## Where the layers live
+
+The layers are created under the application source root:
+
+```
+src/
+├── app/          (or _app/ on Next.js — see below)
+├── pages/        (or _pages/ on Next.js)
+├── widgets/
+├── features/
+├── entities/
+└── shared/
+    ├── ui/
+    ├── api/
+    ├── lib/
+    └── config/
+```
+
+In a monorepo the same tree lives in the UI workspace, at `apps/<app>/src/`.
+
+### Next.js: the `app/` and `pages/` collision
+
+Next.js reserves the folder names `app` and `pages` for its router. FSD's official Next.js
+guide resolves this by renaming the two colliding **FSD** layers:
+
+> Rename both `app` and `pages` FSD layers to `_app` and `_pages`, regardless of which
+> router you use.
+> — [feature-sliced.design/docs/guides/tech/with-nextjs](https://feature-sliced.design/docs/guides/tech/with-nextjs)
+
+So in a Next.js repo, `app/` (wherever Next reads it from) stays Next's router and holds
+nothing but thin route files that re-export from `_pages`:
+
+```tsx
+// src/app/profile/page.tsx — Next's routing folder
+export { ProfilePage as default } from '@/_pages/profile';
+```
+
+The boundary checker knows both spellings and treats Next's router folder as the `app`
+layer, so route files are still forbidden from reaching past a slice's public API.
+
+## Enforcement
+
+| Check                                | Command                                  | Runs in |
+| ------------------------------------ | ---------------------------------------- | ------- |
+| Layer order, slice isolation, public API | `node scripts/check-fsd-boundaries.mjs` | `lint`  |
+| Full FSD ruleset (structure + naming) | `lint:fsd` (Steiger), where installed     | on demand |
+
+`scripts/check-fsd-boundaries.mjs` has no dependencies, discovers its own source roots, and
+exits non-zero on the first violation. It reads relative imports and imports through the
+`@/` alias; override either with `FSD_ROOTS` or `FSD_ALIASES` if this repo moves them.
+
+What it deliberately does **not** decide for you:
+
+- Whether a slice belongs on `features` or on `widgets`. That is a design judgement.
+- Whether a slice is cohesive, or is a `utils`-style dump wearing a domain name.
+- Imports it cannot see: bare package specifiers, and anything resolved through a runtime
+  path map rather than the alias.
+- Whether an `index.ts` exports the right things — only that nothing bypasses it.
+
+[Steiger](https://github.com/feature-sliced/steiger) — the official FSD linter, present when
+`lint:fsd` is in package.json — covers the structural half the import checker cannot see: segments without a public API, slices with nothing in them, inconsistent naming.
+It passes on a fresh repo and starts talking once slices exist. It is kept out of `lint`
+because it is beta software and because it needs `node_modules`; add it to CI once its
+output has settled for your team. `steiger.config.js` lists the folders this repo shipped
+before FSD existed — shortening that list is the migration.
+
+## Sources
+
+- [Overview](https://feature-sliced.design/docs/get-started/overview)
+- [Layers](https://feature-sliced.design/docs/reference/layers)
+- [Slices and segments](https://feature-sliced.design/docs/reference/slices-segments)
+- [Next.js guide](https://feature-sliced.design/docs/guides/tech/with-nextjs)

package/templates/architectures/feature-sliced-design/files/package.json

@@ -0,0 +1,6 @@
+{
+  "devDependencies": {
+    "steiger": "^0.6.0",
+    "@feature-sliced/steiger-plugin": "^0.7.0"
+  }
+}

package/templates/architectures/feature-sliced-design/files/scripts/check-fsd-boundaries.mjs

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+/**
+ * Feature-Sliced Design boundary gate. Fails the build on the three rules the
+ * methodology rests on:
+ *
+ *   layer-order      a module may only import from layers strictly below its own
+ *   slice-isolation  slices on the same layer never import each other (`@x` excepted)
+ *   public-api       nothing reaches past a slice's or segment's index
+ *
+ * Zero dependencies so it runs before anything is installed.
+ * Reference: https://feature-sliced.design/docs/reference/layers
+ */
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+
+/**
+ * The layer list is the specification, not a setting. `_app` and `_pages` are the renames
+ * the official Next.js guide prescribes, because Next reserves `app/` and `pages/`.
+ */
+const LAYERS = [
+  { dirs: ['app', '_app'], sliced: false },
+  { dirs: ['pages', '_pages'], sliced: true },
+  { dirs: ['widgets'], sliced: true },
+  { dirs: ['features'], sliced: true },
+  { dirs: ['entities'], sliced: true },
+  { dirs: ['shared'], sliced: false },
+];
+
+/** `entities/<slice>/@x/<consumer>` — the only sanctioned same-layer import. */
+const CROSS_IMPORT_DIR = '@x';
+
+const DEFAULTS = {
+  /** Empty means discover: any directory holding several layer folders is a root. */
+  roots: [],
+  aliases: ['@/'],
+  ignoreDirs: [
+    'node_modules', 'dist', 'build', 'out', 'coverage',
+    '.git', '.next', '.turbo', '.vite', '.cache',
+  ],
+  extensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+  /** A lone `app/` is Next's router, not an FSD root. */
+  minLayerDirs: 2,
+};
+
+const settings = {
+  roots: fromEnv('FSD_ROOTS', DEFAULTS.roots),
+  aliases: fromEnv('FSD_ALIASES', DEFAULTS.aliases),
+  ignoreDirs: new Set(fromEnv('FSD_IGNORE_DIRS', DEFAULTS.ignoreDirs)),
+  extensions: new Set(fromEnv('FSD_EXTENSIONS', DEFAULTS.extensions)),
+  minLayerDirs: Number(process.env.FSD_MIN_LAYER_DIRS ?? DEFAULTS.minLayerDirs),
+};
+
+function fromEnv(name, fallback) {
+  const raw = (process.env[name] ?? '').split(',').map((v) => v.trim()).filter(Boolean);
+  return raw.length ? raw : fallback;
+}
+
+const toPosix = (value) => value.split(path.sep).join('/');
+
+/* ── discovery ──────────────────────────────────────────────────────────────── */
+
+function layerIndexOf(dirName) {
+  return LAYERS.findIndex((layer) => layer.dirs.includes(dirName));
+}
+
+async function subdirectories(dir) {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  return entries.filter((e) => e.isDirectory() && !settings.ignoreDirs.has(e.name));
+}
+
+async function discoverRoots(dir, found = []) {
+  const dirs = await subdirectories(dir);
+  if (dirs.filter((d) => layerIndexOf(d.name) >= 0).length >= settings.minLayerDirs) {
+    found.push(dir);
+    return found;
+  }
+  for (const child of dirs) await discoverRoots(path.join(dir, child.name), found);
+  return found;
+}
+
+async function sourceFiles(dir, found = []) {
+  for (const entry of await readdir(dir, { withFileTypes: true }).catch(() => [])) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!settings.ignoreDirs.has(entry.name)) await sourceFiles(full, found);
+    } else if (settings.extensions.has(path.extname(entry.name))) {
+      found.push(full);
+    }
+  }
+  return found;
+}
+
+/* ── parsing ────────────────────────────────────────────────────────────────── */
+
+const SPECIFIER_PATTERNS = [
+  /\bfrom\s*['"]([^'"]+)['"]/g,
+  /\bimport\s*\(\s*['"]([^'"]+)['"]/g,
+  /\brequire\s*\(\s*['"]([^'"]+)['"]/g,
+  /^[ \t]*import\s+['"]([^'"]+)['"]/gm,
+];
+
+function specifiers(source) {
+  const found = [];
+  for (const pattern of SPECIFIER_PATTERNS) {
+    pattern.lastIndex = 0;
+    for (const match of source.matchAll(pattern)) {
+      found.push({ spec: match[1], line: lineOf(source, match.index) });
+    }
+  }
+  return found;
+}
+
+const lineOf = (source, index) => source.slice(0, index).split('\n').length;
+
+/* ── classification ─────────────────────────────────────────────────────────── */
+
+/** Where a path sits in the hierarchy, or null when it is outside FSD's reach. */
+function classify(relative) {
+  const parts = relative.split('/').filter((p) => p && p !== '.');
+  const layerIndex = layerIndexOf(parts[0]);
+  if (layerIndex < 0) return null;
+  return {
+    layerIndex,
+    layer: parts[0],
+    sliced: LAYERS[layerIndex].sliced,
+    slice: parts[1] ?? '',
+    rest: parts.slice(2),
+  };
+}
+
+/** Import target as a root-relative path, or null for package and cross-root imports. */
+function resolveTarget(fileRelative, spec) {
+  if (spec.startsWith('.')) {
+    const joined = path.posix.normalize(path.posix.join(path.posix.dirname(fileRelative), spec));
+    return joined.startsWith('..') ? null : joined;
+  }
+  const alias = settings.aliases.find((prefix) => spec.startsWith(prefix));
+  return alias ? spec.slice(alias.length) : null;
+}
+
+/* ── rules ──────────────────────────────────────────────────────────────────── */
+
+function violation(source, target) {
+  if (source && source.layerIndex === target.layerIndex) {
+    if (!source.sliced) return null; // segments of app and shared import each other freely
+    if (source.slice === target.slice) return null; // inside one slice
+    if (target.rest[0] !== CROSS_IMPORT_DIR) {
+      return { rule: 'slice-isolation', detail: `sibling slice "${target.slice}" on the same layer` };
+    }
+    // `<slice>/@x/<consumer>` and nothing deeper.
+    if (target.rest.length > 2) {
+      return { rule: 'public-api', detail: `reaches past the @x API of "${target.slice}"` };
+    }
+    return null;
+  }
+
+  if (source && target.layerIndex < source.layerIndex) {
+    return { rule: 'layer-order', detail: `"${target.layer}" sits above "${source.layer}"` };
+  }
+
+  if (target.rest.length > 0) {
+    return { rule: 'public-api', detail: `reaches past the index of "${target.slice}"` };
+  }
+  return null;
+}
+
+/* ── run ────────────────────────────────────────────────────────────────────── */
+
+const roots = settings.roots.length ? settings.roots : await discoverRoots(process.cwd());
+
+if (roots.length === 0) {
+  console.log('check-fsd-boundaries: no FSD source root found — nothing to check.');
+  process.exit(0);
+}
+
+const problems = [];
+let checked = 0;
+
+for (const root of roots) {
+  for (const file of await sourceFiles(root)) {
+    checked += 1;
+    const fileRelative = toPosix(path.relative(root, file));
+    const source = classify(fileRelative);
+    const contents = await readFile(file, 'utf8');
+
+    for (const { spec, line } of specifiers(contents)) {
+      const targetPath = resolveTarget(fileRelative, spec);
+      const target = targetPath === null ? null : classify(targetPath);
+      if (!target) continue;
+
+      const found = violation(source, target);
+      if (found) problems.push({ file: toPosix(path.relative(process.cwd(), file)), line, spec, ...found });
+    }
+  }
+}
+
+for (const p of problems) {
+  console.error(`${p.file}:${p.line}  ${p.rule}  imports "${p.spec}" — ${p.detail}`);
+}
+
+const scanned = `${checked} file(s) under ${roots.map((r) => toPosix(path.relative(process.cwd(), r)) || '.').join(', ')}`;
+
+if (problems.length) {
+  console.error(`\n✖ ${problems.length} FSD boundary violation(s) in ${scanned}`);
+  console.error('  See docs/architecture.md for the layer order and the public API rule.');
+  process.exit(1);
+}
+
+console.log(`✔ FSD boundaries hold — ${scanned}`);

package/templates/architectures/feature-sliced-design/files/src/_app/.gitkeep

@@ -0,0 +1 @@
+# App layer - everything that makes the app run: routing, entrypoints, providers, global styles. Renamed from app/ because Next.js reserves that folder for its router.

package/templates/architectures/feature-sliced-design/files/src/_pages/.gitkeep

@@ -0,0 +1 @@
+# Pages layer - one slice per full page or per large part of a page in nested routing. Renamed from pages/ because Next.js reserves that folder for its router.

package/templates/architectures/feature-sliced-design/files/src/app/.gitkeep

@@ -0,0 +1 @@
+# App layer - everything that makes the app run: routing, entrypoints, providers, global styles.

package/templates/architectures/feature-sliced-design/files/src/entities/.gitkeep

@@ -0,0 +1 @@
+# Entities layer - the business entities the product works with, one slice each (user, product...).

package/templates/architectures/feature-sliced-design/files/src/features/.gitkeep

@@ -0,0 +1 @@
+# Features layer - reused implementations of product features; actions that carry business value.

package/templates/architectures/feature-sliced-design/files/src/pages/.gitkeep

@@ -0,0 +1 @@
+# Pages layer - one slice per full page or per large part of a page in nested routing.

package/templates/architectures/feature-sliced-design/files/src/shared/api/index.ts

@@ -0,0 +1,3 @@
+// Public API of the shared/api segment: the backend client and request helpers
+// Import it as `shared/api` — never reach into the files below this one.
+export {};

package/templates/architectures/feature-sliced-design/files/src/shared/config/index.ts

@@ -0,0 +1,3 @@
+// Public API of the shared/config segment: environment variables, feature flags and global constants
+// Import it as `shared/config` — never reach into the files below this one.
+export {};

package/templates/architectures/feature-sliced-design/files/src/shared/lib/index.ts

@@ -0,0 +1,3 @@
+// Public API of the shared/lib segment: internal libraries, each with a stated area of focus
+// Import it as `shared/lib` — never reach into the files below this one.
+export {};

package/templates/architectures/feature-sliced-design/files/src/shared/ui/index.ts

@@ -0,0 +1,3 @@
+// Public API of the shared/ui segment: the UI kit, unopinionated components with no business logic
+// Import it as `shared/ui` — never reach into the files below this one.
+export {};

package/templates/architectures/feature-sliced-design/files/src/widgets/.gitkeep

@@ -0,0 +1 @@
+# Widgets layer - large self-contained blocks of UI or functionality, usually a whole use case.

package/templates/architectures/feature-sliced-design/files/steiger.config.js

@@ -0,0 +1,21 @@
+import fsd from '@feature-sliced/steiger-plugin';
+import { defineConfig } from 'steiger';
+
+/**
+ * Structural FSD rules (public API, slice cohesion, naming), run on demand with `lint:fsd`.
+ * The import gate CI enforces is scripts/check-fsd-boundaries.mjs, which needs no install.
+ */
+export default defineConfig([
+  ...fsd.configs.recommended,
+  {
+    // Base-owned entrypoints and pre-FSD folders. Delete an entry once you have moved it
+    // into shared/ or into a slice.
+    ignores: [
+      './src/main.tsx',
+      './src/vite-env.d.ts',
+      './src/api/**',
+      './src/config/**',
+      './src/styles/**',
+    ],
+  },
+]);

package/templates/architectures/hexagonal/blueprint.yaml

@@ -0,0 +1,146 @@
+id: hexagonal
+kind: architecture
+name: Hexagonal (Ports and Adapters)
+description: >-
+  Cockburn's Ports and Adapters as a folder overlay. Ships the layout and the enforcement,
+  not an application: a sealed domain project, an application project owning the inbound
+  (driving) and outbound (driven) port folders, one project per adapter technology, and a
+  composition root that is the only place a concrete adapter is named. You write the first
+  port; the boundaries are enforced from that moment by a check that fails the build on every
+  stack — NetArchTest on .NET, import-linter on Python, a dependency-free import scanner on
+  Node, a stdlib fitness test on Go.
+
+tags:
+  - hexagonal
+  - ports-and-adapters
+  - boundaries
+  - testability
+  - architecture-overlay
+
+requires: []
+conflicts: []
+provides:
+  - hexagon-layout
+  - inbound-ports
+  - outbound-ports
+  - composition-root
+  - boundary-enforcement
+
+variables:
+  # Named to match the dotnet bases and testing-unit, so a dotnet interview asks this once.
+  - name: dotnetTargetFramework
+    prompt: Target framework for the hexagon projects
+    type: string
+    default: net10.0
+    required: false
+    when: "stack == 'dotnet'"
+
+  - name: pythonPackageManager
+    prompt: Python package manager (used to add import-linter)
+    type: select
+    default: uv
+    required: false
+    when: "stack == 'python'"
+    choices:
+      - { value: uv, label: uv }
+      - { value: pip, label: pip }
+      - { value: poetry, label: poetry }
+
+  - name: netArchTestVersion
+    prompt: NetArchTest.eNhancedEdition version (enforces the hexagon boundaries in tests)
+    type: string
+    default: '1.4.5'
+    when: "stack == 'dotnet'"
+
+files:
+  # ── shared ──────────────────────────────────────────────────────────────────
+  # Not docs/ARCHITECTURE.md: the agent-kit owns that file, and the engine overwrites rather
+  # than appends, so writing there would delete the ADR and decision sections.
+  - from: files/docs/architecture/hexagonal.md
+    to: .
+
+  # ── dotnet ──────────────────────────────────────────────────────────────────
+  # Zones are separate projects here, so the direction of each ProjectReference is compiled
+  # in. The base's Api project stays the process host and references Bootstrap — see the doc.
+  - from: files/src/__solutionName.dot__.*/**/*.csproj
+    to: .
+    when: "stack == 'dotnet'"
+  - from: files/src/__solutionName.dot__.*/**/*.cs
+    to: .
+    when: "stack == 'dotnet'"
+  - from: files/src/__solutionName.dot__.*/**/.gitkeep
+    to: .
+    when: "stack == 'dotnet'"
+  # Fixed name, unlike the projects it tests: `dotnet sln add` does not expand globs on
+  # Windows and postApply commands are never token-rendered, so the one path the solution
+  # step has to name must be deterministic. The assembly is still branded.
+  - from: files/tests/ArchitectureTests/*
+    to: .
+    when: "stack == 'dotnet'"
+
+  # ── python ──────────────────────────────────────────────────────────────────
+  # `__init__` reads as a path token and is reported as left-literal at plan time; that is
+  # expected here, the same as in the Python bases.
+  - from: files/src/__solutionName.snake__/**/*.py
+    to: .
+    when: "stack == 'python'"
+  - from: files/.importlinter
+    to: .
+    when: "stack == 'python'"
+
+  # ── node ────────────────────────────────────────────────────────────────────
+  - from: files/src/**/*.ts
+    to: .
+    when: "stack == 'node'"
+  # Zones are matched under any `src/`, so one script polices a single package and a monorepo
+  # workspace. Polyglot gets the check without the skeleton: which workspace the hexagon
+  # belongs in is the user's call, and the doc says how to lay it out.
+  - from: files/scripts/check-architecture.mjs
+    to: .
+    when: "stack == 'node' || stack == 'polyglot'"
+
+  # ── go ──────────────────────────────────────────────────────────────────────
+  - from: files/internal/**/*.go
+    to: .
+    when: "stack == 'go'"
+
+  # Declared, not installed by a post-apply step: a package added after generation is
+  # missing from the first install (ADR 0005, spec 003).
+  - from: files/pyproject.toml
+    to: .
+    onConflict: merge
+    when: "stack == 'python'"
+
+  # The solution is completed declaratively rather than by `dotnet sln add`, which runs
+  # after the first build and is skippable — a solution missing projects that exist on
+  # disk builds green while covering less than the repo contains (ADR 0005, spec 003).
+  - from: files/__solutionName.dot__.slnx
+    to: .
+    onConflict: merge
+    when: "stack == 'dotnet'"
+
+  # Central package management: versions live in Directory.Packages.props and projects
+  # reference without one. A bare Version= on a PackageReference fails restore (NU1008).
+  - from: files/Directory.Packages.props
+    to: .
+    onConflict: merge
+    when: "stack == 'dotnet'"
+
+postApply:
+  # One deterministic path: `dotnet sln add` defaults to --include-references, so adding the
+  # architecture test project pulls Domain, Application, every adapter and Bootstrap into the
+  # solution with it, each in the solution folder matching its directory.
+
+
+  # Manifest-only: the check has no dependency to install, so a pnpm repo never gains a stray
+  # npm lockfile. dependency-cruiser is the obvious tool here and is deliberately not used —
+  # it needs a `typescript` it supports, and reports a clean cruise of zero modules when it
+  # does not find one, which is a boundary check that passes without checking anything.
+  - run: npm pkg set "scripts.arch:check=node scripts/check-architecture.mjs src"
+    when: "stack == 'node'"
+    optional: true
+  - run: npm pkg set "scripts.arch:check=node scripts/check-architecture.mjs apps packages"
+    when: "stack == 'polyglot'"
+    optional: true
+
+  # Go needs no dependency either: the fitness test is stdlib go/parser only.

package/templates/architectures/hexagonal/files/.importlinter

@@ -0,0 +1,33 @@
+# Boundary enforcement for the hexagon. Run `lint-imports` — see docs/architecture/hexagonal.md.
+# Modules the base template already ships are deliberately not listed: `exhaustive` is off, so
+# adding a contract here is opt-in rather than a wall the base has to climb.
+
+[importlinter]
+root_package = {{ solutionName | snake }}
+
+[importlinter:contract:hexagon-layers]
+name = Dependencies point inward
+type = layers
+layers =
+    {{ solutionName | snake }}.bootstrap
+    {{ solutionName | snake }}.adapters
+    {{ solutionName | snake }}.application
+    {{ solutionName | snake }}.ports
+    {{ solutionName | snake }}.domain
+
+[importlinter:contract:adapters-are-independent]
+name = Driving and driven adapters never import each other
+type = independence
+modules =
+    {{ solutionName | snake }}.adapters.inbound
+    {{ solutionName | snake }}.adapters.outbound
+
+[importlinter:contract:only-bootstrap-knows-adapters]
+name = Only the composition root names a concrete adapter
+type = forbidden
+source_modules =
+    {{ solutionName | snake }}.domain
+    {{ solutionName | snake }}.ports
+    {{ solutionName | snake }}.application
+forbidden_modules =
+    {{ solutionName | snake }}.adapters

package/templates/architectures/hexagonal/files/Directory.Packages.props

@@ -0,0 +1,8 @@
+<Project>
+  <ItemGroup>
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.8.1" />
+    <PackageVersion Include="NetArchTest.eNhancedEdition" Version="{{ netArchTestVersion }}" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
+    <PackageVersion Include="xunit.v3" Version="3.2.2" />
+  </ItemGroup>
+</Project>

package/templates/architectures/hexagonal/files/__solutionName.dot__.slnx

@@ -0,0 +1,13 @@
+<Solution>
+  <Folder Name="/src/">
+    <Project Path="src/{{ solutionName | dot }}.Adapters.Inbound.Http/{{ solutionName | dot }}.Adapters.Inbound.Http.csproj" />
+    <Project Path="src/{{ solutionName | dot }}.Adapters.Outbound.InMemory/{{ solutionName | dot }}.Adapters.Outbound.InMemory.csproj" />
+    <Project Path="src/{{ solutionName | dot }}.Adapters.Outbound.Persistence/{{ solutionName | dot }}.Adapters.Outbound.Persistence.csproj" />
+    <Project Path="src/{{ solutionName | dot }}.Application/{{ solutionName | dot }}.Application.csproj" />
+    <Project Path="src/{{ solutionName | dot }}.Bootstrap/{{ solutionName | dot }}.Bootstrap.csproj" />
+    <Project Path="src/{{ solutionName | dot }}.Domain/{{ solutionName | dot }}.Domain.csproj" />
+  </Folder>
+  <Folder Name="/tests/">
+    <Project Path="tests/ArchitectureTests/ArchitectureTests.csproj" />
+  </Folder>
+</Solution>