@gallop.software/canon 1.0.0

package/README.md

@@ -0,0 +1,83 @@
+# @gallop/canon
+
+**Gallop Enterprise Architecture Canon** — A versioned, AI-compatible, auditable system of approved web architecture patterns.
+
+## What is the Canon?
+
+The Canon is a closed set of authoritative patterns that define how serious web applications should be built. Each pattern is:
+
+- **Versioned** — Pin to a specific version, upgrade deliberately
+- **Documented** — Decision-level documentation, not just code comments
+- **Enforced** — ESLint rules, CI validation, or AI constraints
+- **Immutable** — Once released, patterns don't change
+
+## Installation
+
+```bash
+npm install @gallop/canon
+```
+
+## Usage
+
+### Access Pattern Metadata
+
+```typescript
+import { patterns, getPattern, getPatternsByCategory } from '@gallop/canon'
+
+// Get all patterns
+console.log(patterns)
+
+// Get a specific pattern
+const pattern = getPattern('001')
+console.log(pattern.title) // "Server-First Blocks"
+
+// Get patterns by category
+const renderingPatterns = getPatternsByCategory('rendering')
+```
+
+### Pattern Categories
+
+| Category | Description |
+|----------|-------------|
+| `rendering` | Server/client component boundaries |
+| `layout` | Layout hierarchy and spacing |
+| `typography` | Text component usage |
+| `structure` | File and folder organization |
+| `styling` | CSS and Tailwind patterns |
+| `components` | Component design patterns |
+| `seo` | SEO and metadata patterns |
+
+## Patterns
+
+See the [patterns/](./patterns) directory for full documentation of each pattern.
+
+### Enforced by ESLint
+
+- **001** Server-First Blocks
+- **002** Layout Hierarchy
+- **003** Typography Components
+- **004** Component Props
+
+### Documentation-Only
+
+- **005** Page Structure
+- **006** Block Naming
+- **007** Import Paths
+- **008** Tailwind Only
+- **009** Color Tokens
+- **010** Spacing System
+- **011** Responsive Mobile-First
+- **012** Icon System
+- **013** New Component Pattern
+- **014** clsx Not classnames
+- **015** No Inline Hover Styles
+- **016** Client Extraction
+- **017** SEO Metadata
+
+## Guarantees
+
+See [guarantees.md](./guarantees.md) for version-specific promises.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,103 @@
+/**
+ * @gallop/canon
+ *
+ * Gallop Enterprise Architecture Canon
+ * Versioned, AI-compatible, auditable web architecture patterns
+ */
+export interface Pattern {
+    id: string;
+    title: string;
+    file: string;
+    category: PatternCategory;
+    status: 'stable' | 'proposed' | 'deprecated';
+    enforcement: 'eslint' | 'documentation' | 'ci';
+    rule: string | null;
+    summary: string;
+}
+export interface Category {
+    id: string;
+    name: string;
+    description: string;
+}
+export interface Guarantee {
+    id: string;
+    name: string;
+    since: string;
+    status: 'stable' | 'proposed' | 'deprecated';
+    patterns: string[];
+}
+export type PatternCategory = 'rendering' | 'layout' | 'typography' | 'structure' | 'styling' | 'components' | 'seo';
+export interface CanonSchema {
+    name: string;
+    version: string;
+    description: string;
+    categories: Category[];
+    patterns: Pattern[];
+    guarantees: Guarantee[];
+}
+export declare const canon: CanonSchema;
+export declare const version: string;
+export declare const patterns: Pattern[];
+export declare const categories: Category[];
+export declare const guarantees: Guarantee[];
+/**
+ * Get a pattern by ID
+ * @param id - Pattern ID (e.g., "001", "002")
+ * @returns Pattern object or undefined if not found
+ */
+export declare function getPattern(id: string): Pattern | undefined;
+/**
+ * Get all patterns in a category
+ * @param category - Category ID (e.g., "rendering", "typography")
+ * @returns Array of patterns in that category
+ */
+export declare function getPatternsByCategory(category: PatternCategory): Pattern[];
+/**
+ * Get all patterns enforced by ESLint
+ * @returns Array of ESLint-enforced patterns
+ */
+export declare function getEnforcedPatterns(): Pattern[];
+/**
+ * Get all patterns with a specific ESLint rule
+ * @param rule - ESLint rule name (e.g., "gallop/no-client-blocks")
+ * @returns Array of patterns using that rule
+ */
+export declare function getPatternsByRule(rule: string): Pattern[];
+/**
+ * Get a guarantee by ID
+ * @param id - Guarantee ID (e.g., "SEO_STABLE")
+ * @returns Guarantee object or undefined if not found
+ */
+export declare function getGuarantee(id: string): Guarantee | undefined;
+/**
+ * Get all patterns associated with a guarantee
+ * @param guaranteeId - Guarantee ID (e.g., "SEO_STABLE")
+ * @returns Array of patterns that support this guarantee
+ */
+export declare function getPatternsForGuarantee(guaranteeId: string): Pattern[];
+/**
+ * Check if a pattern ID is valid
+ * @param id - Pattern ID to check
+ * @returns true if valid, false otherwise
+ */
+export declare function isValidPattern(id: string): boolean;
+/**
+ * Get pattern count by enforcement type
+ * @returns Object with counts per enforcement type
+ */
+export declare function getEnforcementStats(): Record<string, number>;
+declare const _default: {
+    version: string;
+    patterns: Pattern[];
+    categories: Category[];
+    guarantees: Guarantee[];
+    getPattern: typeof getPattern;
+    getPatternsByCategory: typeof getPatternsByCategory;
+    getEnforcedPatterns: typeof getEnforcedPatterns;
+    getPatternsByRule: typeof getPatternsByRule;
+    getGuarantee: typeof getGuarantee;
+    getPatternsForGuarantee: typeof getPatternsForGuarantee;
+    isValidPattern: typeof isValidPattern;
+    getEnforcementStats: typeof getEnforcementStats;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * @gallop/canon
+ *
+ * Gallop Enterprise Architecture Canon
+ * Versioned, AI-compatible, auditable web architecture patterns
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guarantees = exports.categories = exports.patterns = exports.version = exports.canon = void 0;
+exports.getPattern = getPattern;
+exports.getPatternsByCategory = getPatternsByCategory;
+exports.getEnforcedPatterns = getEnforcedPatterns;
+exports.getPatternsByRule = getPatternsByRule;
+exports.getGuarantee = getGuarantee;
+exports.getPatternsForGuarantee = getPatternsForGuarantee;
+exports.isValidPattern = isValidPattern;
+exports.getEnforcementStats = getEnforcementStats;
+const schema_json_1 = __importDefault(require("../schema.json"));
+// Export the full schema
+exports.canon = schema_json_1.default;
+// Export version
+exports.version = schema_json_1.default.version;
+// Export patterns array
+exports.patterns = schema_json_1.default.patterns;
+// Export categories array
+exports.categories = schema_json_1.default.categories;
+// Export guarantees array
+exports.guarantees = schema_json_1.default.guarantees;
+/**
+ * Get a pattern by ID
+ * @param id - Pattern ID (e.g., "001", "002")
+ * @returns Pattern object or undefined if not found
+ */
+function getPattern(id) {
+    return exports.patterns.find((p) => p.id === id);
+}
+/**
+ * Get all patterns in a category
+ * @param category - Category ID (e.g., "rendering", "typography")
+ * @returns Array of patterns in that category
+ */
+function getPatternsByCategory(category) {
+    return exports.patterns.filter((p) => p.category === category);
+}
+/**
+ * Get all patterns enforced by ESLint
+ * @returns Array of ESLint-enforced patterns
+ */
+function getEnforcedPatterns() {
+    return exports.patterns.filter((p) => p.enforcement === 'eslint');
+}
+/**
+ * Get all patterns with a specific ESLint rule
+ * @param rule - ESLint rule name (e.g., "gallop/no-client-blocks")
+ * @returns Array of patterns using that rule
+ */
+function getPatternsByRule(rule) {
+    return exports.patterns.filter((p) => p.rule === rule);
+}
+/**
+ * Get a guarantee by ID
+ * @param id - Guarantee ID (e.g., "SEO_STABLE")
+ * @returns Guarantee object or undefined if not found
+ */
+function getGuarantee(id) {
+    return exports.guarantees.find((g) => g.id === id);
+}
+/**
+ * Get all patterns associated with a guarantee
+ * @param guaranteeId - Guarantee ID (e.g., "SEO_STABLE")
+ * @returns Array of patterns that support this guarantee
+ */
+function getPatternsForGuarantee(guaranteeId) {
+    const guarantee = getGuarantee(guaranteeId);
+    if (!guarantee)
+        return [];
+    return exports.patterns.filter((p) => guarantee.patterns.includes(p.id));
+}
+/**
+ * Check if a pattern ID is valid
+ * @param id - Pattern ID to check
+ * @returns true if valid, false otherwise
+ */
+function isValidPattern(id) {
+    return exports.patterns.some((p) => p.id === id);
+}
+/**
+ * Get pattern count by enforcement type
+ * @returns Object with counts per enforcement type
+ */
+function getEnforcementStats() {
+    const stats = {};
+    for (const pattern of exports.patterns) {
+        stats[pattern.enforcement] = (stats[pattern.enforcement] || 0) + 1;
+    }
+    return stats;
+}
+// Default export
+exports.default = {
+    version: exports.version,
+    patterns: exports.patterns,
+    categories: exports.categories,
+    guarantees: exports.guarantees,
+    getPattern,
+    getPatternsByCategory,
+    getEnforcedPatterns,
+    getPatternsByRule,
+    getGuarantee,
+    getPatternsForGuarantee,
+    isValidPattern,
+    getEnforcementStats,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;;;;AAoEH,gCAEC;AAOD,sDAEC;AAMD,kDAEC;AAOD,8CAEC;AAOD,oCAEC;AAOD,0DAIC;AAOD,wCAEC;AAMD,kDAMC;AAvID,iEAAmC;AA8CnC,yBAAyB;AACZ,QAAA,KAAK,GAAgB,qBAAqB,CAAA;AAEvD,iBAAiB;AACJ,QAAA,OAAO,GAAG,qBAAM,CAAC,OAAO,CAAA;AAErC,wBAAwB;AACX,QAAA,QAAQ,GAAc,qBAAM,CAAC,QAAqB,CAAA;AAE/D,0BAA0B;AACb,QAAA,UAAU,GAAe,qBAAM,CAAC,UAAU,CAAA;AAEvD,0BAA0B;AACb,QAAA,UAAU,GAAgB,qBAAM,CAAC,UAAyB,CAAA;AAEvE;;;;GAIG;AACH,SAAgB,UAAU,CAAC,EAAU;IACnC,OAAO,gBAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAA;AAC1C,CAAC;AAED;;;;GAIG;AACH,SAAgB,qBAAqB,CAAC,QAAyB;IAC7D,OAAO,gBAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAA;AACxD,CAAC;AAED;;;GAGG;AACH,SAAgB,mBAAmB;IACjC,OAAO,gBAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,QAAQ,CAAC,CAAA;AAC3D,CAAC;AAED;;;;GAIG;AACH,SAAgB,iBAAiB,CAAC,IAAY;IAC5C,OAAO,gBAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAA;AAChD,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CAAC,EAAU;IACrC,OAAO,kBAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAA;AAC5C,CAAC;AAED;;;;GAIG;AACH,SAAgB,uBAAuB,CAAC,WAAmB;IACzD,MAAM,SAAS,GAAG,YAAY,CAAC,WAAW,CAAC,CAAA;IAC3C,IAAI,CAAC,SAAS;QAAE,OAAO,EAAE,CAAA;IACzB,OAAO,gBAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AAClE,CAAC;AAED;;;;GAIG;AACH,SAAgB,cAAc,CAAC,EAAU;IACvC,OAAO,gBAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAA;AAC1C,CAAC;AAED;;;GAGG;AACH,SAAgB,mBAAmB;IACjC,MAAM,KAAK,GAA2B,EAAE,CAAA;IACxC,KAAK,MAAM,OAAO,IAAI,gBAAQ,EAAE,CAAC;QAC/B,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;IACpE,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,iBAAiB;AACjB,kBAAe;IACb,OAAO,EAAP,eAAO;IACP,QAAQ,EAAR,gBAAQ;IACR,UAAU,EAAV,kBAAU;IACV,UAAU,EAAV,kBAAU;IACV,UAAU;IACV,qBAAqB;IACrB,mBAAmB;IACnB,iBAAiB;IACjB,YAAY;IACZ,uBAAuB;IACvB,cAAc;IACd,mBAAmB;CACpB,CAAA","sourcesContent":["/**\n * @gallop/canon\n *\n * Gallop Enterprise Architecture Canon\n * Versioned, AI-compatible, auditable web architecture patterns\n */\n\nimport schema from '../schema.json'\n\n// Types\nexport interface Pattern {\n  id: string\n  title: string\n  file: string\n  category: PatternCategory\n  status: 'stable' | 'proposed' | 'deprecated'\n  enforcement: 'eslint' | 'documentation' | 'ci'\n  rule: string | null\n  summary: string\n}\n\nexport interface Category {\n  id: string\n  name: string\n  description: string\n}\n\nexport interface Guarantee {\n  id: string\n  name: string\n  since: string\n  status: 'stable' | 'proposed' | 'deprecated'\n  patterns: string[]\n}\n\nexport type PatternCategory =\n  | 'rendering'\n  | 'layout'\n  | 'typography'\n  | 'structure'\n  | 'styling'\n  | 'components'\n  | 'seo'\n\nexport interface CanonSchema {\n  name: string\n  version: string\n  description: string\n  categories: Category[]\n  patterns: Pattern[]\n  guarantees: Guarantee[]\n}\n\n// Export the full schema\nexport const canon: CanonSchema = schema as CanonSchema\n\n// Export version\nexport const version = schema.version\n\n// Export patterns array\nexport const patterns: Pattern[] = schema.patterns as Pattern[]\n\n// Export categories array\nexport const categories: Category[] = schema.categories\n\n// Export guarantees array\nexport const guarantees: Guarantee[] = schema.guarantees as Guarantee[]\n\n/**\n * Get a pattern by ID\n * @param id - Pattern ID (e.g., \"001\", \"002\")\n * @returns Pattern object or undefined if not found\n */\nexport function getPattern(id: string): Pattern | undefined {\n  return patterns.find((p) => p.id === id)\n}\n\n/**\n * Get all patterns in a category\n * @param category - Category ID (e.g., \"rendering\", \"typography\")\n * @returns Array of patterns in that category\n */\nexport function getPatternsByCategory(category: PatternCategory): Pattern[] {\n  return patterns.filter((p) => p.category === category)\n}\n\n/**\n * Get all patterns enforced by ESLint\n * @returns Array of ESLint-enforced patterns\n */\nexport function getEnforcedPatterns(): Pattern[] {\n  return patterns.filter((p) => p.enforcement === 'eslint')\n}\n\n/**\n * Get all patterns with a specific ESLint rule\n * @param rule - ESLint rule name (e.g., \"gallop/no-client-blocks\")\n * @returns Array of patterns using that rule\n */\nexport function getPatternsByRule(rule: string): Pattern[] {\n  return patterns.filter((p) => p.rule === rule)\n}\n\n/**\n * Get a guarantee by ID\n * @param id - Guarantee ID (e.g., \"SEO_STABLE\")\n * @returns Guarantee object or undefined if not found\n */\nexport function getGuarantee(id: string): Guarantee | undefined {\n  return guarantees.find((g) => g.id === id)\n}\n\n/**\n * Get all patterns associated with a guarantee\n * @param guaranteeId - Guarantee ID (e.g., \"SEO_STABLE\")\n * @returns Array of patterns that support this guarantee\n */\nexport function getPatternsForGuarantee(guaranteeId: string): Pattern[] {\n  const guarantee = getGuarantee(guaranteeId)\n  if (!guarantee) return []\n  return patterns.filter((p) => guarantee.patterns.includes(p.id))\n}\n\n/**\n * Check if a pattern ID is valid\n * @param id - Pattern ID to check\n * @returns true if valid, false otherwise\n */\nexport function isValidPattern(id: string): boolean {\n  return patterns.some((p) => p.id === id)\n}\n\n/**\n * Get pattern count by enforcement type\n * @returns Object with counts per enforcement type\n */\nexport function getEnforcementStats(): Record<string, number> {\n  const stats: Record<string, number> = {}\n  for (const pattern of patterns) {\n    stats[pattern.enforcement] = (stats[pattern.enforcement] || 0) + 1\n  }\n  return stats\n}\n\n// Default export\nexport default {\n  version,\n  patterns,\n  categories,\n  guarantees,\n  getPattern,\n  getPatternsByCategory,\n  getEnforcedPatterns,\n  getPatternsByRule,\n  getGuarantee,\n  getPatternsForGuarantee,\n  isValidPattern,\n  getEnforcementStats,\n}\n"]}

package/guarantees.md

@@ -0,0 +1,136 @@
+# Gallop Canon v1.0 Guarantees
+
+These guarantees are promises made by Canon v1.0. They are versioned and immutable once released.
+
+## SEO Stability
+
+**Guarantee ID:** `SEO_STABLE`  
+**Since:** v1.0
+
+### Promise
+
+Applications built following Canon v1.0 patterns will not experience SEO regressions from architectural decisions.
+
+### What This Means
+
+- **Server-rendered by default** — All blocks render on the server, content is visible to crawlers
+- **No hydration mismatches** — Client/server boundaries are clearly defined
+- **Structured metadata** — All pages have complete OG, Twitter, and Schema.org data
+- **Canonical URLs** — Every page declares its canonical URL
+- **Crawlable content** — No content hidden behind client-only rendering
+
+### Patterns That Enforce This
+
+- [001 Server-First Blocks](./patterns/001-server-first-blocks.md)
+- [016 Client Extraction](./patterns/016-client-extraction.md)
+- [017 SEO Metadata](./patterns/017-seo-metadata.md)
+
+---
+
+## Performance Baseline
+
+**Guarantee ID:** `PERF_BASELINE`  
+**Since:** v1.0
+
+### Promise
+
+Applications built following Canon v1.0 patterns will have predictable, minimal client-side JavaScript in blocks.
+
+### What This Means
+
+- **Minimal client bundle** — Blocks don't add to client JavaScript
+- **No layout shift** — Typography and spacing are predictable
+- **Efficient hydration** — Only interactive components hydrate
+- **Tree-shakeable imports** — Unused code is eliminated
+
+### Patterns That Enforce This
+
+- [001 Server-First Blocks](./patterns/001-server-first-blocks.md)
+- [007 Import Paths](./patterns/007-import-paths.md)
+- [010 Spacing System](./patterns/010-spacing-system.md)
+- [016 Client Extraction](./patterns/016-client-extraction.md)
+
+---
+
+## Maintainability
+
+**Guarantee ID:** `MAINTAIN`  
+**Since:** v1.0
+
+### Promise
+
+Applications built following Canon v1.0 patterns will be maintainable by any developer familiar with the Canon.
+
+### What This Means
+
+- **Consistent file structure** — Blocks, components, and pages follow naming conventions
+- **Traceable component usage** — Components are imported from known locations
+- **Auditable styling** — Tailwind classes and component props are searchable
+- **Documented patterns** — Every decision is explained with rationale
+
+### Patterns That Enforce This
+
+- [005 Page Structure](./patterns/005-page-structure.md)
+- [006 Block Naming](./patterns/006-block-naming.md)
+- [007 Import Paths](./patterns/007-import-paths.md)
+- [004 Component Props](./patterns/004-component-props.md)
+- [013 New Component Pattern](./patterns/013-new-component-pattern.md)
+
+---
+
+## Design System Compliance
+
+**Guarantee ID:** `DESIGN_SYSTEM`  
+**Since:** v1.0
+
+### Promise
+
+Applications built following Canon v1.0 patterns will have consistent visual design through typography, spacing, and color systems.
+
+### What This Means
+
+- **Semantic typography** — Text uses Heading, Paragraph, Label components
+- **Consistent spacing** — Margins and paddings follow the spacing scale
+- **Semantic colors** — Colors use tokens, not raw values
+- **Responsive patterns** — Mobile-first breakpoints are standard
+
+### Patterns That Enforce This
+
+- [003 Typography Components](./patterns/003-typography-components.md)
+- [004 Component Props](./patterns/004-component-props.md)
+- [009 Color Tokens](./patterns/009-color-tokens.md)
+- [010 Spacing System](./patterns/010-spacing-system.md)
+- [011 Responsive Mobile-First](./patterns/011-responsive-mobile-first.md)
+
+---
+
+## Versioning Policy
+
+### Guarantee Lifecycle
+
+1. **Proposed** — Under consideration, may change
+2. **Stable** — Committed, won't change in this major version
+3. **Deprecated** — Will be removed in next major version
+4. **Removed** — No longer applies
+
+### Breaking Changes
+
+Guarantees are never removed or weakened within a major version. If a guarantee must change:
+
+1. It is deprecated in a minor release
+2. Migration guidance is provided
+3. It is removed in the next major release
+
+### Version Pinning
+
+Organizations can pin to a specific Canon version:
+
+```json
+{
+  "dependencies": {
+    "@gallop/canon": "1.0.0"
+  }
+}
+```
+
+Upgrades should be deliberate and tested.

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@gallop.software/canon",
+  "version": "1.0.0",
+  "description": "Gallop Enterprise Architecture Canon - Versioned, AI-compatible, auditable web architecture patterns",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "patterns",
+    "guarantees.md",
+    "schema.json"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "gallop",
+    "architecture",
+    "patterns",
+    "canon",
+    "nextjs",
+    "react",
+    "governance",
+    "ai-compatible"
+  ],
+  "author": {
+    "name": "Gallop",
+    "url": "https://gallop.software"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gallop-software/gallop",
+    "directory": "canon"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

package/patterns/001-server-first-blocks.md

@@ -0,0 +1,84 @@
+# Pattern 001: Server-First Blocks
+
+**Canon Version:** 1.0  
+**Status:** Stable  
+**Category:** Rendering  
+**Enforcement:** ESLint
+
+## Decision
+
+Blocks in `src/blocks/` must be server components. They must not use the `'use client'` directive.
+
+## Rationale
+
+Server components provide significant benefits for web applications:
+
+1. **Smaller client bundle** — Server components don't add to JavaScript shipped to browsers
+2. **SEO-safe by default** — Content is rendered on the server, visible to crawlers
+3. **Predictable hydration** — No hydration mismatches when blocks are server-rendered
+4. **Faster initial load** — Less JavaScript to parse and execute
+
+Blocks are compositional units that should remain static and SEO-friendly. Interactive behavior belongs in components, not blocks.
+
+## Examples
+
+### Bad
+
+```tsx
+// src/blocks/hero-1.tsx
+'use client'
+import { useState } from 'react'
+
+export default function Hero1() {
+  const [isOpen, setIsOpen] = useState(false)
+  // ...
+}
+```
+
+### Good
+
+```tsx
+// src/blocks/hero-1.tsx (server component)
+import { InteractiveFeature } from '@/components/interactive-feature'
+
+export default function Hero1() {
+  return (
+    <Section>
+      <Heading>Welcome</Heading>
+      <InteractiveFeature /> {/* Client logic extracted */}
+    </Section>
+  )
+}
+```
+
+```tsx
+// src/components/interactive-feature.tsx
+'use client'
+import { useState } from 'react'
+
+export function InteractiveFeature() {
+  const [isOpen, setIsOpen] = useState(false)
+  // Client-side logic lives here
+}
+```
+
+## Enforcement
+
+- **ESLint rule:** `gallop/no-client-blocks`
+- **Severity:** Warning (upgradeable to error)
+
+## Escape Hatch
+
+If a block absolutely requires client-side logic that cannot be extracted:
+
+1. Document why extraction is impossible
+2. Consider if it should be a component instead of a block
+3. Use `// eslint-disable-next-line gallop/no-client-blocks` with a comment explaining why
+
+This should be extremely rare. Most "exceptions" indicate a design issue.
+
+## References
+
+- `src/blocks/hero-1.tsx` — Server block with extracted video player
+- `src/blocks/hero-16.tsx` — Server block with extracted animation init
+- `src/components/gallery-popup.tsx` — Client component extracted from block

package/patterns/002-layout-hierarchy.md

@@ -0,0 +1,84 @@
+# Pattern 002: Layout Hierarchy
+
+**Canon Version:** 1.0  
+**Status:** Stable  
+**Category:** Layout  
+**Enforcement:** ESLint
+
+## Decision
+
+Do not use `Container` inside `Section`. The `Section` component already handles containment.
+
+## Rationale
+
+1. **Redundant nesting** — `Section` already provides max-width and padding
+2. **Consistent spacing** — Avoids double-padding issues
+3. **Simpler DOM** — Fewer wrapper elements
+4. **Predictable layout** — One component handles section layout
+
+The layout hierarchy should be:
+```
+Section → Columns → Column → Content
+```
+
+Not:
+```
+Section → Container → Columns → Column → Content
+```
+
+## Examples
+
+### Bad
+
+```tsx
+<Section>
+  <Container>
+    <Heading>Title</Heading>
+    <Paragraph>Content here</Paragraph>
+  </Container>
+</Section>
+```
+
+### Good
+
+```tsx
+<Section>
+  <Heading>Title</Heading>
+  <Paragraph>Content here</Paragraph>
+</Section>
+```
+
+```tsx
+<Section innerAlign="content">
+  <Heading>Title</Heading>
+  <Paragraph>Content here</Paragraph>
+</Section>
+```
+
+If you need custom max-width, use a plain `div`:
+
+```tsx
+<Section>
+  <div className="max-w-4xl">
+    <Heading>Title</Heading>
+    <Paragraph>Content here</Paragraph>
+  </div>
+</Section>
+```
+
+## Enforcement
+
+- **ESLint rule:** `gallop/no-container-in-section`
+- **Severity:** Warning
+
+## Escape Hatch
+
+If you need nested containment for a specific design:
+
+1. Use a plain `div` with Tailwind classes instead of `Container`
+2. Document why the nested structure is necessary
+
+## References
+
+- `src/components/section.tsx` — Section component with built-in containment
+- `src/blocks/section-35.tsx` — Example using div for custom max-width