@libar-dev/architect 1.0.0-pre.3

package/dist/renderable/codecs/business-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"business-rules.d.ts","sourceRoot":"","sources":["../../../src/renderable/codecs/business-rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,mBAAmB,EAEpB,MAAM,4CAA4C,CAAC;AAapD,OAAO,EAAE,KAAK,gBAAgB,EAAsC,MAAM,iBAAiB,CAAC;AAO5F;;;;;;;GAOG;AACH,MAAM,WAAW,yBAA0B,SAAQ,gBAAgB;IACjE,oDAAoD;IACpD,OAAO,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,mBAAmB,CAAC;IAEnD,oFAAoF;IACpF,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAE9B,qEAAqE;IACrE,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB,gDAAgD;IAChD,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,iDAAiD;IACjD,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB,sCAAsC;IACtC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAExB,gEAAgE;IAChE,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B,qEAAqE;IACrE,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB,mFAAmF;IACnF,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B,8FAA8F;IAC9F,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAE9B,yFAAyF;IACzF,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED;;GAEG;AACH,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,yBAAyB,CAa9E,CAAC;AACF,OAAO,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AAkDpE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,CAAC,EAAE,yBAAyB,GAClC,CAAC,CAAC,QAAQ,CAAC,OAAO,mBAAmB,EAAE,OAAO,8BAA8B,CAAC,CAY/E;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA6B,CAAC;AA6oB7D;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,SAAS,MAAM,EAAE,EAChC,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GACxC,MAAM,EAAE,CAiBV"}

package/dist/renderable/codecs/business-rules.js

@@ -0,0 +1,648 @@
+/**
+ * @architect
+ * @architect-core
+ * @architect-pattern BusinessRulesCodec
+ * @architect-status completed
+ * @architect-unlock-reason:Progressive-disclosure-by-product-area
+ * @architect-convention codec-registry
+ * @architect-product-area:Generation
+ *
+ * ## BusinessRulesCodec
+ *
+ * Transforms MasterDataset into a RenderableDocument for business rules output.
+ * Generates BUSINESS-RULES.md organized by product area, phase, and feature.
+ *
+ * **Purpose:** Business rules documentation organized by product area, phase, and feature. Extracts domain constraints from Gherkin Rule: blocks.
+ *
+ * **Output Files:** `BUSINESS-RULES.md` (main index), `business-rules/<area-slug>.md` (area details)
+ *
+ * | Option | Type | Default | Description |
+ * | --- | --- | --- | --- |
+ * | groupBy | "domain" \| "phase" \| "domain-then-phase" | "domain-then-phase" | Primary grouping strategy |
+ * | includeCodeExamples | boolean | false | Include code examples from DocStrings |
+ * | includeTables | boolean | true | Include markdown tables from descriptions |
+ * | includeRationale | boolean | true | Include rationale section per rule |
+ * | filterDomains | string[] | [] | Filter by domain categories (empty = all) |
+ * | filterPhases | number[] | [] | Filter by phases (empty = all) |
+ * | onlyWithInvariants | boolean | false | Show only rules with explicit invariants |
+ * | includeSource | boolean | true | Include source feature file link |
+ * | includeVerifiedBy | boolean | true | Include Verified by scenario links |
+ * | maxDescriptionLength | number | 150 | Max description length in standard mode |
+ * | excludeSourcePaths | string[] | [] | Exclude patterns by source path prefix |
+ *
+ * ### When to Use
+ *
+ * - When generating business rules documentation for stakeholders
+ * - When extracting domain constraints without implementation details
+ * - When creating compliance or audit documentation from feature specs
+ *
+ * ### Information Architecture
+ *
+ * ```
+ * Product Area (Platform, DeliveryProcess)
+ *   └── Phase (21, 15, etc.) or Release (v0.1.0 for DeliveryProcess)
+ *        └── Feature (pattern name with description)
+ *             └── Rules (inline with Invariant + Rationale)
+ * ```
+ *
+ * ### Progressive Disclosure
+ *
+ * - **summary**: Statistics only (compact reference)
+ * - **standard**: Above + all features with rules inline
+ * - **detailed**: Full content including code examples and verification links
+ *
+ * ### Factory Pattern
+ *
+ * Use `createBusinessRulesCodec(options)` to create a configured codec:
+ * ```typescript
+ * const codec = createBusinessRulesCodec({ detailLevel: "summary" });
+ * const doc = codec.decode(dataset);
+ * ```
+ */
+import { z } from 'zod';
+import { MasterDatasetSchema, } from '../../validation-schemas/master-dataset.js';
+import { heading, paragraph, separator, table, linkOut, document, } from '../schema.js';
+import { DEFAULT_BASE_OPTIONS, mergeOptions } from './types/base.js';
+import { toKebabCase, camelCaseToTitleCase } from '../../utils/index.js';
+/**
+ * Default options for BusinessRulesCodec
+ */
+export const DEFAULT_BUSINESS_RULES_OPTIONS = {
+    ...DEFAULT_BASE_OPTIONS,
+    groupBy: 'domain-then-phase',
+    includeCodeExamples: false, // Only in detailed mode
+    includeTables: true,
+    includeRationale: true,
+    filterDomains: [],
+    filterPhases: [],
+    onlyWithInvariants: false,
+    includeSource: true,
+    includeVerifiedBy: true,
+    maxDescriptionLength: 150,
+    excludeSourcePaths: [],
+};
+import { RenderableDocumentOutputSchema } from './shared-schema.js';
+import { parseBusinessRuleAnnotations, extractFirstSentence, } from './helpers.js';
+import { extractTablesAsSectionBlocks } from './convention-extractor.js';
+// ═══════════════════════════════════════════════════════════════════════════
+// Constants
+// ═══════════════════════════════════════════════════════════════════════════
+const DEFAULT_PRODUCT_AREA = 'Platform';
+// ═══════════════════════════════════════════════════════════════════════════
+// Business Rules Document Codec
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Create a BusinessRulesCodec with custom options.
+ *
+ * @param options - Codec configuration options
+ * @returns Configured Zod codec
+ *
+ * @example
+ * ```typescript
+ * // Compact summary mode
+ * const codec = createBusinessRulesCodec({ detailLevel: "summary" });
+ *
+ * // Filter to specific domains
+ * const codec = createBusinessRulesCodec({ filterDomains: ["ddd", "event-sourcing"] });
+ * ```
+ */
+export function createBusinessRulesCodec(options) {
+    const opts = mergeOptions(DEFAULT_BUSINESS_RULES_OPTIONS, options);
+    return z.codec(MasterDatasetSchema, RenderableDocumentOutputSchema, {
+        decode: (dataset) => {
+            return buildBusinessRulesDocument(dataset, opts);
+        },
+        /** @throws Always - this codec is decode-only. See zod-codecs.md */
+        encode: () => {
+            throw new Error('BusinessRulesCodec is decode-only. See zod-codecs.md');
+        },
+    });
+}
+/**
+ * Default Business Rules Document Codec
+ *
+ * Transforms MasterDataset → RenderableDocument for business rules.
+ * Uses default options with standard detail level.
+ *
+ * @example
+ * ```typescript
+ * const doc = BusinessRulesCodec.decode(masterDataset);
+ * const markdown = renderToMarkdown(doc);
+ * ```
+ */
+export const BusinessRulesCodec = createBusinessRulesCodec();
+// ═══════════════════════════════════════════════════════════════════════════
+// Document Builder
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Build the business rules document from dataset
+ */
+function buildBusinessRulesDocument(dataset, options) {
+    const sections = [];
+    // 1. Collect all rules organized by product area → phase → feature
+    const productAreaGroups = collectRulesByProductArea(dataset, options);
+    // Calculate stats
+    const stats = calculateStats(productAreaGroups);
+    if (stats.totalRules === 0) {
+        sections.push(heading(2, 'No Business Rules Found'), paragraph('No business rules were found in the feature files. ' +
+            'Business rules are defined using the `Rule:` keyword in Gherkin feature files.'));
+        return document('Business Rules', sections, {
+            purpose: 'Domain constraints and invariants',
+        });
+    }
+    // 2. Build summary (single line with stats)
+    sections.push(...buildSummarySection(stats));
+    // 3. Progressive disclosure: split by product area when detail files enabled
+    if (options.generateDetailFiles && options.detailLevel !== 'summary') {
+        sections.push(...buildProductAreaIndexSection(productAreaGroups));
+        const additionalFiles = buildBusinessRulesDetailFiles(productAreaGroups, options);
+        const docOpts = {
+            purpose: 'Domain constraints and invariants extracted from feature files',
+            detailLevel: 'Overview with links to detailed business rules by product area',
+        };
+        if (Object.keys(additionalFiles).length > 0) {
+            docOpts.additionalFiles = additionalFiles;
+        }
+        return document('Business Rules', sections, docOpts);
+    }
+    // 4. Non-split mode: all content in single document
+    if (options.detailLevel !== 'summary') {
+        sections.push(...buildProductAreaSections(productAreaGroups, options));
+    }
+    return document('Business Rules', sections, {
+        purpose: 'Domain constraints and invariants extracted from feature files',
+        detailLevel: options.detailLevel,
+    });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Rule Collection
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Collect rules organized by Product Area → Phase → Feature
+ */
+function collectRulesByProductArea(dataset, options) {
+    const groups = new Map();
+    for (const pattern of dataset.patterns) {
+        // Skip patterns without rules
+        if (!pattern.rules || pattern.rules.length === 0) {
+            continue;
+        }
+        // Apply source path exclusion filter
+        if (options.excludeSourcePaths.length > 0 &&
+            options.excludeSourcePaths.some((prefix) => pattern.source.file.startsWith(prefix))) {
+            continue;
+        }
+        // Apply domain filter
+        if (options.filterDomains.length > 0 && !options.filterDomains.includes(pattern.category)) {
+            continue;
+        }
+        // Apply phase filter
+        if (options.filterPhases.length > 0 &&
+            pattern.phase !== undefined &&
+            !options.filterPhases.includes(pattern.phase)) {
+            continue;
+        }
+        const productArea = pattern.productArea ?? DEFAULT_PRODUCT_AREA;
+        const productAreaDisplay = formatProductAreaName(productArea);
+        // Determine phase key (use release for DeliveryProcess items without phase)
+        const phaseKey = getPhaseKey(pattern);
+        // Get or create product area group
+        let group = groups.get(productArea);
+        if (!group) {
+            group = {
+                productArea,
+                displayName: productAreaDisplay,
+                phases: new Map(),
+            };
+            groups.set(productArea, group);
+        }
+        // Get or create phase group
+        let phaseFeatures = group.phases.get(phaseKey);
+        if (!phaseFeatures) {
+            phaseFeatures = [];
+            group.phases.set(phaseKey, phaseFeatures);
+        }
+        // Build feature with rules
+        const featureWithRules = {
+            pattern,
+            featureName: pattern.name,
+            featureDescription: extractFeatureDescription(pattern),
+            rules: [],
+        };
+        // Process rules
+        for (const rule of pattern.rules) {
+            const annotations = parseBusinessRuleAnnotations(rule.description);
+            // Apply onlyWithInvariants filter
+            if (options.onlyWithInvariants && !annotations.invariant) {
+                continue;
+            }
+            featureWithRules.rules.push({
+                rule,
+                pattern,
+                annotations,
+            });
+        }
+        // Only add feature if it has rules after filtering
+        if (featureWithRules.rules.length > 0) {
+            phaseFeatures.push(featureWithRules);
+        }
+    }
+    return groups;
+}
+/**
+ * Get the phase key for grouping (e.g., "Phase 21" or "v0.1.0")
+ */
+function getPhaseKey(pattern) {
+    // If pattern has a phase, use it
+    if (pattern.phase !== undefined) {
+        return `Phase ${pattern.phase}`;
+    }
+    // For DeliveryProcess items without phase, use release
+    const release = pattern.release;
+    if (release) {
+        return release;
+    }
+    // Fallback
+    return 'Uncategorized';
+}
+const CONTENT_HEADER_PATTERNS = [
+    /\*\*Problem:\*\*\s*/,
+    /\*\*Business Value:\*\*\s*/,
+    /\*\*Solution:\*\*\s*/,
+    /\*\*Context:\*\*\s*/,
+];
+const NEXT_HEADER_PATTERN = /\n\s*(?:\*\*[A-Z]|\|)/m;
+/**
+ * Extract a compact description from the feature
+ *
+ * Looks for content after header markers like **Problem:** or **Business Value:**
+ * and extracts the full first sentence/paragraph.
+ */
+function extractFeatureDescription(pattern) {
+    const desc = pattern.directive.description;
+    // Try to find content after a header
+    for (const headerPattern of CONTENT_HEADER_PATTERNS) {
+        const match = headerPattern.exec(desc);
+        if (match) {
+            // Get text after the header
+            const afterHeader = desc.slice(match.index + match[0].length);
+            // Get content up to the next header or table
+            const nextHeaderMatch = NEXT_HEADER_PATTERN.exec(afterHeader);
+            const content = nextHeaderMatch ? afterHeader.slice(0, nextHeaderMatch.index) : afterHeader;
+            // Clean up and extract first sentence
+            const cleaned = content.trim().split('\n')[0]?.trim() ?? '';
+            if (cleaned.length > 0) {
+                return extractFirstSentence(cleaned);
+            }
+        }
+    }
+    // Fallback: Try to get the first meaningful line
+    const lines = desc.split('\n').filter((line) => {
+        const trimmed = line.trim();
+        return (trimmed.length > 0 &&
+            !trimmed.startsWith('**') && // Skip any header
+            !trimmed.startsWith('|') && // Skip table rows
+            !trimmed.startsWith('-') && // Skip list items
+            trimmed.length > 20 // Require substantial content
+        );
+    });
+    const firstLine = lines[0];
+    if (firstLine) {
+        return extractFirstSentence(firstLine);
+    }
+    return '';
+}
+function calculateStats(groups) {
+    let totalRules = 0;
+    let totalFeatures = 0;
+    let withInvariants = 0;
+    for (const group of groups.values()) {
+        for (const features of group.phases.values()) {
+            totalFeatures += features.length;
+            for (const feature of features) {
+                totalRules += feature.rules.length;
+                for (const ruleCtx of feature.rules) {
+                    if (ruleCtx.annotations.invariant) {
+                        withInvariants++;
+                    }
+                }
+            }
+        }
+    }
+    return {
+        totalRules,
+        totalFeatures,
+        withInvariants,
+        productAreas: groups.size,
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Summary Section
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Build compact summary section
+ */
+function buildSummarySection(stats) {
+    const summary = `Domain constraints and invariants extracted from feature specifications. ${stats.totalRules} rules from ${stats.totalFeatures} features across ${stats.productAreas} product areas.`;
+    return [paragraph(`**${summary}**`), separator()];
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Product Area Sections
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Build sections organized by Product Area → Phase → Feature → Rules
+ */
+function buildProductAreaSections(groups, options) {
+    const sections = [];
+    // Sort product areas alphabetically
+    const sortedGroups = [...groups.values()].sort((a, b) => a.displayName.localeCompare(b.displayName));
+    for (const group of sortedGroups) {
+        const sortedPhases = sortPhaseEntries([...group.phases.entries()]);
+        for (const [phaseKey, features] of sortedPhases) {
+            // Product Area / Phase heading
+            sections.push(heading(2, `${group.displayName} / ${phaseKey}`));
+            // Sort features by name
+            const sortedFeatures = [...features].sort((a, b) => a.featureName.localeCompare(b.featureName));
+            for (const feature of sortedFeatures) {
+                sections.push(...renderFeatureWithRules(feature, options));
+            }
+            sections.push(separator());
+        }
+    }
+    return sections;
+}
+/**
+ * Calculate statistics for a single product area group
+ */
+function calculateAreaStats(group) {
+    let totalRules = 0;
+    let totalFeatures = 0;
+    let withInvariants = 0;
+    for (const features of group.phases.values()) {
+        totalFeatures += features.length;
+        for (const feature of features) {
+            totalRules += feature.rules.length;
+            for (const ruleCtx of feature.rules) {
+                if (ruleCtx.annotations.invariant) {
+                    withInvariants++;
+                }
+            }
+        }
+    }
+    return { totalRules, totalFeatures, withInvariants };
+}
+/**
+ * Generate URL-safe slug from product area name
+ */
+function productAreaToSlug(productArea) {
+    return toKebabCase(productArea);
+}
+/**
+ * Build the product area index section for the main document.
+ * Shows a summary table with links to each product area's detail file.
+ */
+function buildProductAreaIndexSection(groups) {
+    const sections = [];
+    sections.push(heading(2, 'Product Areas'));
+    const sortedGroups = [...groups.values()].sort((a, b) => a.displayName.localeCompare(b.displayName));
+    const rows = sortedGroups.map((group) => {
+        const areaStats = calculateAreaStats(group);
+        const slug = productAreaToSlug(group.productArea);
+        const link = `[${group.displayName}](business-rules/${slug}.md)`;
+        return [
+            link,
+            String(areaStats.totalFeatures),
+            String(areaStats.totalRules),
+            String(areaStats.withInvariants),
+        ];
+    });
+    sections.push(table(['Product Area', 'Features', 'Rules', 'With Invariants'], rows));
+    sections.push(separator());
+    return sections;
+}
+/**
+ * Build one detail file per product area
+ */
+function buildBusinessRulesDetailFiles(groups, options) {
+    const files = {};
+    const sortedGroups = [...groups.values()].sort((a, b) => a.displayName.localeCompare(b.displayName));
+    for (const group of sortedGroups) {
+        const slug = productAreaToSlug(group.productArea);
+        files[`business-rules/${slug}.md`] = buildSingleProductAreaDocument(group, options);
+    }
+    return files;
+}
+/**
+ * Build a single product area detail document with rules organized by phase
+ */
+function buildSingleProductAreaDocument(group, options) {
+    const sections = [];
+    const areaStats = calculateAreaStats(group);
+    // Area stats
+    sections.push(paragraph(`**${areaStats.totalRules} rules** from ${areaStats.totalFeatures} features. ` +
+        `${areaStats.withInvariants} rules have explicit invariants.`));
+    sections.push(separator());
+    // Sort phases
+    const sortedPhases = sortPhaseEntries([...group.phases.entries()]);
+    for (const [phaseKey, features] of sortedPhases) {
+        const sortedFeatures = [...features].sort((a, b) => a.featureName.localeCompare(b.featureName));
+        // Render features for this phase
+        const phaseContent = [];
+        for (const feature of sortedFeatures) {
+            phaseContent.push(...renderFeatureWithRules(feature, options));
+        }
+        // Always render flat — file-level split by product area is sufficient disclosure
+        sections.push(heading(2, phaseKey));
+        sections.push(...phaseContent);
+        sections.push(separator());
+    }
+    // Back link
+    sections.push(linkOut('\u2190 Back to Business Rules', '../BUSINESS-RULES.md'));
+    return document(`${group.displayName} Business Rules`, sections, {
+        purpose: `Business rules for the ${group.displayName} product area`,
+    });
+}
+/**
+ * Sort phase entries: numeric phases first (ascending), then releases, then uncategorized
+ */
+function sortPhaseEntries(entries) {
+    return entries.sort(([a], [b]) => {
+        const aNum = extractPhaseNumber(a);
+        const bNum = extractPhaseNumber(b);
+        if (aNum !== null && bNum !== null) {
+            return aNum - bNum;
+        }
+        if (aNum !== null)
+            return -1;
+        if (bNum !== null)
+            return 1;
+        return a.localeCompare(b);
+    });
+}
+/**
+ * Extract phase number from phase key (e.g., "Phase 21" → 21)
+ */
+function extractPhaseNumber(phaseKey) {
+    const pattern = /^Phase\s+(\d+)$/;
+    const match = pattern.exec(phaseKey);
+    if (match?.[1]) {
+        return parseInt(match[1], 10);
+    }
+    return null;
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Feature Rendering
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Render a feature with its rules inline.
+ *
+ * All rules render flat — Rule title + Invariant + Rationale are essential
+ * business knowledge and must never be hidden behind collapsible blocks.
+ * Progressive disclosure happens at the file level (split by product area).
+ */
+function renderFeatureWithRules(feature, options) {
+    const sections = [];
+    const isDetailed = options.detailLevel === 'detailed';
+    // Feature heading (H3) — humanized from camelCase pattern name
+    sections.push(heading(3, humanizeFeatureName(feature.featureName)));
+    // Feature description
+    if (feature.featureDescription) {
+        sections.push(paragraph(`*${feature.featureDescription}*`));
+    }
+    // Render each rule flat — no collapsible wrapping
+    for (const ruleCtx of feature.rules) {
+        sections.push(...renderRuleInline(ruleCtx, options, isDetailed));
+    }
+    // Source file path as italic text (informational, not a link — paths are
+    // relative to the feature repo root and don't resolve from docs-generated/)
+    if (options.includeSource) {
+        const sourceFile = feature.pattern.source.file;
+        sections.push(paragraph(`*${extractSourceName(sourceFile)}*`));
+    }
+    return sections;
+}
+/**
+ * Render a single rule inline with its annotations.
+ *
+ * Each rule is preceded by a separator. Invariant + Rationale are combined
+ * into a blockquote "constraint card" for visual emphasis. Verified-by is
+ * rendered as a checkbox list for scanability. Scenario names from the
+ * Rule block are deduplicated against explicit **Verified by:** annotations.
+ */
+function renderRuleInline(ruleCtx, options, isDetailed) {
+    const sections = [];
+    const { rule, annotations } = ruleCtx;
+    // Visual separator before each rule
+    sections.push(separator());
+    // Rule name as H4 heading
+    sections.push(heading(4, rule.name));
+    // Constraint card: blockquote combining Invariant + Rationale
+    const cardLines = [];
+    if (annotations.invariant) {
+        cardLines.push(`> **Invariant:** ${annotations.invariant}`);
+    }
+    if (options.includeRationale && annotations.rationale) {
+        cardLines.push(`> **Rationale:** ${annotations.rationale}`);
+    }
+    if (cardLines.length > 0) {
+        sections.push(paragraph(cardLines.join('\n>\n')));
+    }
+    else if (annotations.remainingContent) {
+        // Fallback first-line stays as plain paragraph (not blockquoted)
+        const firstLine = extractFirstSentence(annotations.remainingContent);
+        if (firstLine) {
+            sections.push(paragraph(firstLine));
+        }
+    }
+    // Tables from rule description
+    if (options.includeTables && rule.description) {
+        const tableBlocks = extractTablesAsSectionBlocks(rule.description);
+        for (const tableBlock of tableBlocks) {
+            sections.push(tableBlock);
+        }
+    }
+    // Code examples (detailed mode only, or if explicitly enabled)
+    if ((isDetailed || options.includeCodeExamples) && annotations.codeExamples) {
+        for (const codeBlock of annotations.codeExamples) {
+            sections.push(codeBlock);
+        }
+    }
+    // Verified-by as compact bullet list (label + items in one block, no blank line gap)
+    if (options.includeVerifiedBy) {
+        const names = deduplicateScenarioNames(rule.scenarioNames, annotations.verifiedBy);
+        if (names.length > 0) {
+            const bullets = names.map((name) => `- ${name}`).join('\n');
+            sections.push(paragraph(`**Verified by:**\n${bullets}`));
+        }
+    }
+    // API implementation references
+    if (annotations.apiRefs && annotations.apiRefs.length > 0) {
+        const refList = annotations.apiRefs.map((ref) => `\`${ref}\``).join(', ');
+        sections.push(paragraph(`**Implementation:** ${refList}`));
+    }
+    // Placeholder only when there is truly no content
+    if (!annotations.invariant &&
+        !annotations.remainingContent &&
+        !annotations.rationale &&
+        rule.scenarioNames.length === 0) {
+        sections.push(paragraph('*No invariant or description specified.*'));
+    }
+    return sections;
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Utilities
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Humanize a camelCase/PascalCase feature name for display.
+ *
+ * Inserts spaces at camelCase boundaries and strips common suffixes
+ * like "Testing" that don't add value in business rules context.
+ *
+ * Examples:
+ * - ConfigResolution → Config Resolution
+ * - RichContentHelpersTesting → Rich Content Helpers
+ * - ProcessGuardTesting → Process Guard
+ * - ContextInference → Context Inference
+ */
+function humanizeFeatureName(name) {
+    return camelCaseToTitleCase(name).replace(/\s*Testing$/i, '');
+}
+/**
+ * Deduplicate scenario names from Rule block and **Verified by:** annotation.
+ *
+ * Uses case-insensitive comparison to catch near-duplicates like
+ * "Standard level includes source link-out" vs "Standard level includes source link-out".
+ */
+export function deduplicateScenarioNames(scenarioNames, verifiedBy) {
+    const seen = new Map(); // lowercase → original
+    for (const name of scenarioNames) {
+        const key = name.toLowerCase().trim();
+        if (!seen.has(key)) {
+            seen.set(key, name);
+        }
+    }
+    if (verifiedBy) {
+        for (const name of verifiedBy) {
+            const key = name.toLowerCase().trim();
+            if (!seen.has(key)) {
+                seen.set(key, name);
+            }
+        }
+    }
+    return [...seen.values()];
+}
+function formatProductAreaName(productArea) {
+    return camelCaseToTitleCase(productArea);
+}
+/**
+ * Extract a clean source name from file path
+ */
+function extractSourceName(filePath) {
+    const pattern = /([^/]+)\.feature$/;
+    const match = pattern.exec(filePath);
+    if (match?.[1]) {
+        return match[1] + '.feature';
+    }
+    return filePath;
+}
+//# sourceMappingURL=business-rules.js.map