@libar-dev/architect 1.0.0-pre.3 → 1.0.0-pre.4

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

@@ -1,70 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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

@@ -1,553 +0,0 @@
-/**
- * @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

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