@libar-dev/architect 1.0.0-pre.3

package/dist/renderable/codecs/diagram-utils.js

@@ -0,0 +1,70 @@
+/**
+ * @architect
+ * @architect-pattern MermaidDiagramUtils
+ * @architect-status completed
+ * @architect-used-by Architecture Codec, Reference Codec
+ * @architect-arch-context renderer
+ *
+ * ## Shared Mermaid Diagram Utilities
+ *
+ * Sanitization and formatting helpers shared across architecture.ts and reference.ts
+ * diagram builders.
+ *
+ * **When to Use:** When building Mermaid diagram output in a codec — use
+ * `sanitizeNodeId()`, `EDGE_STYLES`, `NODE_SHAPES`, and `formatNodeDeclaration()`
+ * rather than inlining diagram syntax in the codec directly.
+ */
+/**
+ * Sanitize pattern name for Mermaid node ID.
+ * Mermaid requires alphanumeric + underscore only.
+ */
+export function sanitizeNodeId(name) {
+    return name.replace(/[^a-zA-Z0-9]/g, '_');
+}
+/** Arrow styles per relationship type for Mermaid diagram generation */
+export const EDGE_STYLES = {
+    uses: '-->',
+    dependsOn: '-.->',
+    implementsPatterns: '..->',
+    extendsPattern: '-->>',
+};
+/** Human-readable relationship labels for edge annotations (DD-4) */
+export const EDGE_LABELS = {
+    uses: 'uses',
+    dependsOn: 'depends on',
+    implementsPatterns: 'implements',
+    extendsPattern: 'extends',
+};
+/** Arrow syntax for sequence diagram messages (DD-2) */
+export const SEQUENCE_ARROWS = {
+    uses: '->>',
+    dependsOn: '-->>',
+    implementsPatterns: '--)',
+    extendsPattern: '-->>',
+};
+/**
+ * Mermaid flowchart node shape brackets per archRole (DD-1).
+ * Maps archRole to [openBracket, closeBracket] pairs.
+ * Uses `satisfies` to ensure every canonical archRole has a mapping.
+ */
+export const NODE_SHAPES = {
+    'bounded-context': ['[["', '"]]'],
+    'command-handler': ['(["', '"])'],
+    projection: ['[("', '")]'],
+    saga: ['{{"', '"}}'],
+    'process-manager': ['{{"', '"}}'],
+    infrastructure: ['[/"', '"/]'],
+    repository: ['[("', '")]'],
+    decider: ['("', '")'],
+    'read-model': ['[/"', '"/]'],
+    service: ['("', '")'],
+};
+/** Format a Mermaid flowchart node declaration with shape based on archRole */
+export function formatNodeDeclaration(nodeId, label, archRole) {
+    if (archRole !== undefined && archRole in NODE_SHAPES) {
+        const shape = NODE_SHAPES[archRole];
+        return `${nodeId}${shape[0]}${label}${shape[1]}`;
+    }
+    return `${nodeId}["${label}"]`;
+}
+//# sourceMappingURL=diagram-utils.js.map

package/dist/renderable/codecs/diagram-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagram-utils.js","sourceRoot":"","sources":["../../../src/renderable/codecs/diagram-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAUH;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC;AAC5C,CAAC;AAED,wEAAwE;AACxE,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,IAAI,EAAE,KAAK;IACX,SAAS,EAAE,MAAM;IACjB,kBAAkB,EAAE,MAAM;IAC1B,cAAc,EAAE,MAAM;CACd,CAAC;AAEX,qEAAqE;AACrE,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,IAAI,EAAE,MAAM;IACZ,SAAS,EAAE,YAAY;IACvB,kBAAkB,EAAE,YAAY;IAChC,cAAc,EAAE,SAAS;CAC0B,CAAC;AAEtD,wDAAwD;AACxD,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,IAAI,EAAE,KAAK;IACX,SAAS,EAAE,MAAM;IACjB,kBAAkB,EAAE,KAAK;IACzB,cAAc,EAAE,MAAM;CAC6B,CAAC;AAEtD;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;IACjC,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;IACjC,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;IAC1B,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;IACpB,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;IACjC,cAAc,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;IAC9B,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;IAC1B,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC;IACrB,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;IAC5B,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC;CACyC,CAAC;AAEjE,+EAA+E;AAC/E,MAAM,UAAU,qBAAqB,CAAC,MAAc,EAAE,KAAa,EAAE,QAAiB;IACpF,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,IAAI,WAAW,EAAE,CAAC;QACtD,MAAM,KAAK,GAAG,WAAW,CAAC,QAAoB,CAAC,CAAC;QAChD,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;IACnD,CAAC;IACD,OAAO,GAAG,MAAM,KAAK,KAAK,IAAI,CAAC;AACjC,CAAC"}

package/dist/renderable/codecs/helpers.d.ts

@@ -0,0 +1,553 @@
+/**
+ * @architect
+ * @architect-core
+ * @architect-pattern RichContentHelpers
+ * @architect-status completed
+ *
+ * ## Rich Content Rendering Helpers
+ *
+ * Shared helper functions for rendering Gherkin rich content in document codecs.
+ * Provides granular and composite helpers for DataTables, DocStrings, steps,
+ * scenarios, and business rules.
+ *
+ * ### When to Use
+ *
+ * - When building custom codecs that need to render Gherkin content
+ * - When transforming DataTables, DocStrings, or scenarios into markdown
+ * - When implementing acceptance criteria or business rules sections
+ *
+ * ### Usage Pattern
+ *
+ * ```typescript
+ * import { renderAcceptanceCriteria, renderBusinessRulesSection } from "./helpers.js";
+ *
+ * // Composite helpers (most common use)
+ * sections.push(...renderAcceptanceCriteria(pattern.scenarios));
+ * sections.push(...renderBusinessRulesSection(pattern.rules));
+ *
+ * // Granular helpers (for custom rendering)
+ * const tableBlock = renderDataTable(step.dataTable);
+ * const codeBlock = renderDocString(step.docString, "markdown");
+ * ```
+ */
+import type { ScenarioDataTable, ScenarioStep, ScenarioRef } from '../../validation-schemas/scenario-ref.js';
+import type { BusinessRule } from '../../validation-schemas/extracted-pattern.js';
+import type { ExtractedShape, PropertyDoc } from '../../validation-schemas/extracted-shape.js';
+import { type SectionBlock } from '../schema.js';
+import type { WarningCollector } from '../../generators/warning-collector.js';
+export type { BusinessRule };
+/**
+ * Result of partitioning business rules by ADR-style prefixes.
+ */
+export interface PartitionedRules {
+    /** Rules with names starting with "Context" */
+    context: BusinessRule[];
+    /** Rules with names starting with "Decision" */
+    decision: BusinessRule[];
+    /** Rules with names starting with "Consequence" */
+    consequences: BusinessRule[];
+    /** Rules that don't match any expected prefix */
+    other: BusinessRule[];
+}
+/**
+ * Options for partitioning business rules.
+ */
+export interface PartitionRulesOptions {
+    /**
+     * Warn about rules that don't match expected prefixes (default: false).
+     * When true, emits a warning for non-matching rules via onWarning callback.
+     * ADR codec sets this to true; Decision Doc codec keeps false.
+     */
+    warnOnOther?: boolean;
+    /** Pattern name for warning context (optional) */
+    patternName?: string;
+    /**
+     * Callback for warnings (default: console.warn).
+     * Allows programmatic capture of warnings for testing or custom handling.
+     */
+    onWarning?: (message: string) => void;
+}
+/**
+ * Partition business rules by ADR-style name prefixes.
+ *
+ * Rules are categorized based on their name prefix:
+ * - "Context..." → context section
+ * - "Decision..." → decision section
+ * - "Consequence..." → consequences section
+ * - Others → other (optionally logged as warning)
+ *
+ * This is a shared helper used by both ADR and Decision Doc codecs.
+ *
+ * @param rules - Business rules from the extracted pattern
+ * @param options - Partitioning options
+ * @returns Partitioned rules by category
+ *
+ * @example
+ * ```typescript
+ * // ADR codec (warn about unmatched rules)
+ * const partitioned = partitionRulesByPrefix(pattern.rules, {
+ *   warnOnOther: true,
+ *   patternName: pattern.name
+ * });
+ *
+ * // Decision doc codec (no warning)
+ * const partitioned = partitionRulesByPrefix(pattern.rules);
+ * ```
+ */
+export declare function partitionRulesByPrefix(rules: readonly BusinessRule[] | undefined, options?: PartitionRulesOptions): PartitionedRules;
+/**
+ * Warning information emitted during rich content rendering
+ */
+export interface RichContentWarning {
+    /** Warning code for programmatic handling */
+    code: 'unclosed-docstring' | 'invalid-content';
+    /** Human-readable warning message */
+    message: string;
+    /** Additional context about the warning */
+    context?: string;
+}
+/**
+ * Configuration options for rich content rendering
+ */
+export interface RichContentOptions {
+    /** Include Given/When/Then steps (default: true) */
+    includeSteps?: boolean;
+    /** Include DataTables from steps (default: true) */
+    includeDataTables?: boolean;
+    /** Include DocStrings from steps (default: true) */
+    includeDocStrings?: boolean;
+    /** Include business rules section (default: true) */
+    includeRules?: boolean;
+    /** Default language for DocString code blocks (default: "markdown") */
+    docStringLanguage?: string;
+    /**
+     * Base heading level for section headers (default: 4)
+     *
+     * Used by renderAcceptanceCriteria and renderBusinessRulesSection to set
+     * the heading level for "Acceptance Criteria" and "Business Rules" sections.
+     * Callers can override to maintain proper document hierarchy.
+     *
+     * - H2: Use when rendering as top-level section in detail documents
+     * - H3: Use when rendering under a parent H2 section
+     * - H4: Use when deeply nested (default)
+     */
+    baseHeadingLevel?: 2 | 3 | 4;
+    /**
+     * Optional callback invoked when warnings are detected during rendering.
+     *
+     * If not provided or undefined, warnings are logged to stderr via console.warn.
+     * Provide this callback to capture warnings programmatically or suppress them.
+     */
+    onWarning?: ((warning: RichContentWarning) => void) | undefined;
+    /**
+     * Optional WarningCollector for structured warning capture.
+     *
+     * When provided, warnings are captured using the collector for aggregation
+     * and structured reporting. Takes precedence over `onWarning` callback.
+     * Use this for CI/CD pipelines that need machine-readable warning output.
+     */
+    warningCollector?: WarningCollector | undefined;
+}
+/**
+ * Default options type - all fields are required values from RichContentOptions.
+ * Since RichContentOptions.onWarning explicitly allows undefined in its type definition,
+ * Required<RichContentOptions> correctly allows undefined for onWarning.
+ */
+export type ResolvedRichContentOptions = Required<RichContentOptions>;
+/**
+ * Default rich content options
+ *
+ * Note: onWarning and warningCollector are intentionally undefined by default.
+ * When undefined, warnings fall back to console.warn via emitWarning().
+ */
+export declare const DEFAULT_RICH_CONTENT_OPTIONS: ResolvedRichContentOptions;
+/**
+ * Merge user options with defaults
+ */
+export declare function mergeRichContentOptions(options?: RichContentOptions): ResolvedRichContentOptions;
+/**
+ * Structured warning format for CI parsing.
+ *
+ * Format: `::warning file={file},code={code}::{message}`
+ *
+ * This format is compatible with GitHub Actions and other CI systems
+ * that support structured annotations.
+ */
+export interface StructuredWarning {
+    /** Warning code for categorization */
+    code: string;
+    /** Human-readable message */
+    message: string;
+    /** Source file (if available) */
+    file?: string;
+    /** Line number (if available) */
+    line?: number;
+}
+/**
+ * Format a warning for CI output (GitHub Actions compatible).
+ *
+ * @param warning - The warning to format
+ * @returns Formatted string for CI log parsing
+ */
+export declare function formatWarningForCI(warning: StructuredWarning): string;
+/**
+ * Render a Gherkin DataTable as a markdown table block
+ *
+ * @param dt - The DataTable to render
+ * @returns A table SectionBlock
+ *
+ * @example
+ * ```typescript
+ * const tableBlock = renderDataTable(step.dataTable);
+ * sections.push(tableBlock);
+ * ```
+ */
+export declare function renderDataTable(dt: ScenarioDataTable): SectionBlock;
+/**
+ * Render a DocString as a code block
+ *
+ * Accepts either a plain string or an object with content and optional mediaType.
+ * When mediaType is provided in the object, it takes precedence over the language parameter.
+ *
+ * @param docString - The DocString content (string or object with content/mediaType)
+ * @param language - Optional language hint fallback (default: "markdown")
+ * @returns A code SectionBlock
+ *
+ * @example
+ * ```typescript
+ * // With plain string
+ * const codeBlock = renderDocString(step.docString, "json");
+ *
+ * // With object containing mediaType
+ * const codeBlock = renderDocString({ content: "code", mediaType: "typescript" });
+ * ```
+ */
+export declare function renderDocString(docString: string | {
+    content: string;
+    mediaType?: string | undefined;
+}, language?: string): SectionBlock;
+/**
+ * Render scenario steps as a list
+ *
+ * @param steps - The scenario steps
+ * @returns A list SectionBlock
+ *
+ * @example
+ * ```typescript
+ * const stepsList = renderStepsList(scenario.steps);
+ * sections.push(stepsList);
+ * ```
+ */
+export declare function renderStepsList(steps: readonly ScenarioStep[]): SectionBlock;
+/**
+ * Remove common leading indentation from all lines in a code block.
+ *
+ * When DocStrings are embedded in Gherkin files, they often have consistent
+ * indentation to align with the surrounding scenario structure. This function
+ * normalizes that indentation by:
+ * 1. Normalizing tabs to spaces (default: 2 spaces per tab)
+ * 2. Finding the minimum indentation across all non-empty lines
+ * 3. Removing that common indentation from every line
+ * 4. Trimming trailing whitespace from each line
+ *
+ * @param text - The code block content to dedent
+ * @param tabWidth - Number of spaces per tab (default: 2)
+ * @returns The dedented text with normalized indentation
+ *
+ * @example
+ * ```typescript
+ * // Input (indented to match Gherkin formatting):
+ * dedent("    const x = 1;\n    const y = 2;")
+ * // Returns: "const x = 1;\nconst y = 2;"
+ *
+ * // Mixed indentation (preserves relative indentation):
+ * dedent("    function foo() {\n      return 42;\n    }")
+ * // Returns: "function foo() {\n  return 42;\n}"
+ *
+ * // Tab-indented code (tabs normalized to spaces):
+ * dedent("\t\tconst x = 1;")
+ * // Returns: "const x = 1;"
+ * ```
+ */
+export declare function dedent(text: string, tabWidth?: number): string;
+/**
+ * Parse description text for embedded DocStrings and convert to mixed content
+ *
+ * DocStrings in Gherkin are identified by: """language\n...\n"""
+ * Text between DocStrings renders as paragraphs, DocStrings render as code blocks.
+ *
+ * **Defensive handling:**
+ * - Normalizes Windows line endings (CRLF → LF) before parsing
+ * - Detects unclosed DocStrings (odd count of """) and returns plain paragraph fallback
+ * - Handles empty input gracefully
+ * - Dedents code block content to normalize indentation from Gherkin formatting
+ *
+ * @param description - The description text that may contain DocStrings
+ * @param options - Optional rendering options (used for warning callback)
+ * @returns Array of SectionBlocks (paragraphs and code blocks)
+ *
+ * @example
+ * ```typescript
+ * // Input with DocString:
+ * // "Some text\n\"\"\"typescript\nconst x = 1;\n\"\"\"\nMore text"
+ * // Output: [paragraph("Some text"), code("const x = 1;", "typescript"), paragraph("More text")]
+ * ```
+ */
+export declare function parseDescriptionWithDocStrings(description: string, options?: RichContentOptions): SectionBlock[];
+/**
+ * Protect backtick-quoted content from regex matching by replacing with placeholders.
+ *
+ * This is essential when parsing markdown-style content where `**bold**` patterns
+ * might appear inside inline code (e.g., `` `**Verified by:**` ``). Without protection,
+ * regexes that look for `**` boundaries will incorrectly match inside backticks.
+ *
+ * @param text - The text to process
+ * @returns Object with processed text and restore function
+ *
+ * @example
+ * ```typescript
+ * const { processed, restore } = protectBacktickContent("Text `**inside**` more");
+ * // processed = "Text __BT0__ more"
+ * const result = "Extracted: __BT0__";
+ * restore(result); // "Extracted: `**inside**`"
+ * ```
+ */
+export declare function protectBacktickContent(text: string): {
+    processed: string;
+    restore: (s: string) => string;
+};
+/**
+ * Parsed annotations from a business rule description.
+ *
+ * Business rules in feature files can include structured annotations:
+ * - `**Invariant:**` - What must always be true (business constraint)
+ * - `**Rationale:**` - Why this rule exists (business justification)
+ * - `**Verified by:**` - Comma-separated list of verifying scenario names
+ * - `**API:** See \`path\`` - Reference to implementation file/stub
+ */
+export interface BusinessRuleAnnotations {
+    /** The business constraint that must always be true */
+    invariant?: string;
+    /** Business justification for why this rule exists */
+    rationale?: string;
+    /** List of scenario names that verify this rule */
+    verifiedBy?: string[];
+    /** Code examples extracted from DocStrings in the description */
+    codeExamples?: SectionBlock[];
+    /** API implementation references extracted from **API:** See `path` patterns */
+    apiRefs?: readonly string[];
+    /** Input type annotation for sequence diagram steps (from **Input:** marker) */
+    input?: string;
+    /** Output type annotation for sequence diagram steps (from **Output:** marker) */
+    output?: string;
+    /** Remaining description content after annotation extraction */
+    remainingContent?: string;
+}
+/**
+ * Truncate text to a maximum length, adding ellipsis if truncated.
+ *
+ * Attempts to truncate at word boundaries for cleaner output.
+ * If the text is already shorter than maxLength, returns it unchanged.
+ *
+ * @param text - The text to truncate
+ * @param maxLength - Maximum length (0 or negative = no limit)
+ * @returns Truncated text with "..." suffix if truncated
+ *
+ * @example
+ * ```typescript
+ * truncateText("This is a long description", 15);
+ * // Returns: "This is a..."
+ *
+ * truncateText("Short", 100);
+ * // Returns: "Short"
+ * ```
+ */
+export declare function truncateText(text: string, maxLength: number): string;
+export { extractFirstSentenceRaw as extractFirstSentence } from '../../utils/string-utils.js';
+/**
+ * Parse structured annotations from a business rule description.
+ *
+ * Extracts:
+ * - `**Invariant:** <text>` - until next `**` annotation or end
+ * - `**Rationale:** <text>` - until next `**` annotation or end
+ * - `**Verified by:** <comma,separated,list>`
+ * - DocStrings ("""language\n...\n""") as code blocks
+ *
+ * The remaining content after extraction is returned in `remainingContent`.
+ *
+ * @param description - The rule description text to parse
+ * @returns Parsed annotations with structured fields
+ *
+ * @example
+ * ```typescript
+ * const annotations = parseBusinessRuleAnnotations(`
+ *   **Invariant:** Only one reservation can exist for a given key.
+ *
+ *   **Rationale:** Prevents TOCTOU race conditions.
+ *
+ *   **Verified by:** Concurrent reservations, Expired cleanup
+ * `);
+ * // annotations.invariant === "Only one reservation can exist for a given key."
+ * // annotations.rationale === "Prevents TOCTOU race conditions."
+ * // annotations.verifiedBy === ["Concurrent reservations", "Expired cleanup"]
+ * ```
+ */
+export declare function parseBusinessRuleAnnotations(description: string): BusinessRuleAnnotations;
+/**
+ * Strip markdown tables from text content.
+ *
+ * Tables are identified by lines starting and ending with | character.
+ * This removes header rows, separator rows, and data rows to prevent
+ * duplicate rendering when tables are extracted separately.
+ *
+ * @param text - Text that may contain markdown tables
+ * @returns Text with tables removed and excess newlines cleaned up
+ *
+ * @example
+ * ```typescript
+ * const text = "Intro\n| Col | Col |\n| --- | --- |\n| A | B |\nOutro";
+ * stripMarkdownTables(text); // "Intro\n\nOutro"
+ * ```
+ */
+export declare function stripMarkdownTables(text: string): string;
+/**
+ * Render a single business rule with its description and verification info
+ *
+ * Parses the description for embedded DocStrings and renders them as code blocks.
+ *
+ * @param rule - The business rule to render
+ * @returns Array of SectionBlocks for the rule
+ *
+ * @example
+ * ```typescript
+ * sections.push(...renderBusinessRule(rule));
+ * ```
+ */
+export declare function renderBusinessRule(rule: BusinessRule): SectionBlock[];
+/**
+ * Render a rule description using structured annotation parsing.
+ *
+ * Extracts `**Invariant:**`, `**Rationale:**`, `**Verified by:**`, tables, and
+ * code examples for polished output with proper table formatting and separator rows.
+ *
+ * IMPORTANT: Table lines are stripped BEFORE annotation regexes so that bold markers
+ * inside table cells (e.g. `| **Context:** ... |`) don't act as false annotation
+ * boundaries that truncate the lazy `[\s\S]*?` capture.
+ *
+ * @param description - Raw rule description text from Gherkin Rule: block
+ * @returns Array of SectionBlocks with structured content
+ */
+export declare function renderRuleDescription(description: string): SectionBlock[];
+/**
+ * Render a scenario's content including steps, DataTables, and DocStrings
+ *
+ * @param scenario - The scenario to render
+ * @param options - Rendering options
+ * @returns Array of SectionBlocks for the scenario
+ *
+ * @example
+ * ```typescript
+ * for (const scenario of pattern.scenarios) {
+ *   sections.push(...renderScenarioContent(scenario));
+ * }
+ * ```
+ */
+export declare function renderScenarioContent(scenario: ScenarioRef, options?: RichContentOptions): SectionBlock[];
+/**
+ * Render acceptance criteria from a list of scenarios
+ *
+ * Includes a "Acceptance Criteria" heading followed by all scenarios
+ * with their steps, DataTables, and DocStrings.
+ *
+ * @param scenarios - The scenarios to render as acceptance criteria
+ * @param options - Rendering options (including baseHeadingLevel for proper hierarchy)
+ * @returns Array of SectionBlocks, empty if no scenarios
+ *
+ * @example
+ * ```typescript
+ * if (pattern.scenarios && pattern.scenarios.length > 0) {
+ *   // Default H4 heading
+ *   sections.push(...renderAcceptanceCriteria(pattern.scenarios));
+ *
+ *   // H2 heading for top-level section in detail documents
+ *   sections.push(...renderAcceptanceCriteria(pattern.scenarios, { baseHeadingLevel: 2 }));
+ * }
+ * ```
+ */
+export declare function renderAcceptanceCriteria(scenarios: readonly ScenarioRef[] | undefined, options?: RichContentOptions): SectionBlock[];
+/**
+ * Render a business rules section from a list of rules
+ *
+ * Includes a "Business Rules" heading followed by all rules
+ * with their descriptions and verification info.
+ *
+ * @param rules - The business rules to render
+ * @param options - Rendering options (including baseHeadingLevel for proper hierarchy)
+ * @returns Array of SectionBlocks, empty if no rules
+ *
+ * @example
+ * ```typescript
+ * if (pattern.rules && pattern.rules.length > 0) {
+ *   // Default H4 heading
+ *   sections.push(...renderBusinessRulesSection(pattern.rules));
+ *
+ *   // H2 heading for top-level section in detail documents
+ *   sections.push(...renderBusinessRulesSection(pattern.rules, { baseHeadingLevel: 2 }));
+ * }
+ * ```
+ */
+export declare function renderBusinessRulesSection(rules: readonly BusinessRule[] | undefined, options?: RichContentOptions): SectionBlock[];
+/**
+ * Render all rich content for a pattern (scenarios + rules)
+ *
+ * Convenience function that combines acceptance criteria and business rules.
+ *
+ * @param pattern - Object with optional scenarios and rules arrays
+ * @param options - Rendering options
+ * @returns Array of SectionBlocks
+ *
+ * @example
+ * ```typescript
+ * sections.push(...renderPatternRichContent(pattern));
+ * ```
+ */
+export declare function renderPatternRichContent(pattern: {
+    scenarios?: readonly ScenarioRef[];
+    rules?: readonly BusinessRule[];
+}, options?: RichContentOptions): SectionBlock[];
+/**
+ * Options for rendering extracted shapes as markdown.
+ */
+export interface RenderShapesOptions {
+    /** If true, combine all shapes into a single fenced code block (default: true) */
+    groupInSingleBlock?: boolean;
+    /** If true, include JSDoc comments with each shape (default: true) */
+    includeJsDoc?: boolean;
+}
+/**
+ * Render extracted TypeScript shapes as markdown code blocks.
+ *
+ * @param shapes - Shapes to render
+ * @param options - Rendering options
+ * @returns Markdown string with fenced code blocks
+ */
+export declare function renderShapesAsMarkdown(shapes: readonly ExtractedShape[], options?: RenderShapesOptions): string;
+/**
+ * Render property documentation as a markdown table.
+ *
+ * Generates a two-column table with property names and their JSDoc descriptions.
+ * Returns empty string if no property docs exist.
+ *
+ * @param propertyDocs - Property documentation array from ExtractedShape
+ * @returns Markdown table string, or empty string if no docs
+ *
+ * @example
+ * ```typescript
+ * const table = renderPropertyDocsTable(shape.propertyDocs);
+ * if (table) {
+ *   sections.push(md(table));
+ * }
+ * ```
+ */
+export declare function renderPropertyDocsTable(propertyDocs: readonly PropertyDoc[] | undefined): string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/renderable/codecs/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/renderable/codecs/helpers.ts"],"names":[],"mappings":"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"}