@libar-dev/architect 1.0.0-pre.3

package/dist/renderable/codecs/claude-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-module.d.ts","sourceRoot":"","sources":["../../../src/renderable/codecs/claude-module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;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;AAC5F,OAAO,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AAWpE;;;;;;;GAOG;AACH,MAAM,WAAW,wBAAyB,SAAQ,gBAAgB;IAChE,yEAAyE;IACzE,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,yDAAyD;IACzD,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,4DAA4D;IAC5D,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,wBAAwB,CAK5E,CAAC;AAMF;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,CAAC,EAAE,wBAAwB,GACjC,CAAC,CAAC,QAAQ,CAAC,OAAO,mBAAmB,EAAE,OAAO,8BAA8B,CAAC,CAY/E;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA4B,CAAC"}

package/dist/renderable/codecs/claude-module.js

@@ -0,0 +1,214 @@
+/**
+ * @architect
+ * @architect-pattern ClaudeModuleCodec
+ * @architect-status active
+ * @architect-convention codec-registry
+ * @architect-product-area:Generation
+ *
+ * ## ClaudeModuleCodec
+ *
+ * Transforms MasterDataset into RenderableDocuments for CLAUDE.md module generation.
+ * Filters patterns with `claudeModule` tags and generates compact markdown modules
+ * suitable for the `_claude-md/` directory structure.
+ *
+ * **Purpose:** Generate CLAUDE.md modules from annotated behavior specs.
+ *
+ * **Output Files:** One file per claude-module-tagged pattern at `{section}/{module}.md`
+ *
+ * ### Content Extraction
+ *
+ * - Feature description → skipped (meta-documentation, not operational content)
+ * - Rule: blocks → H4 sections with invariant + rationale
+ * - Scenario Outline Examples → decision tables
+ * - Tables in Rule descriptions → preserved as-is
+ *
+ * ### Factory Pattern
+ *
+ * Use `createClaudeModuleCodec(options)` for custom options:
+ * ```typescript
+ * const codec = createClaudeModuleCodec({ detailLevel: 'detailed' });
+ * 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 { RenderableDocumentOutputSchema } from './shared-schema.js';
+import { parseBusinessRuleAnnotations } from './helpers.js';
+import { extractTablesAsSectionBlocks } from './convention-extractor.js';
+const DEFAULT_CLAUDE_SECTION = 'core';
+/**
+ * Default options for ClaudeModuleCodec
+ */
+export const DEFAULT_CLAUDE_MODULE_OPTIONS = {
+    ...DEFAULT_BASE_OPTIONS,
+    fullDocsPath: 'docs/',
+    includeRationale: true,
+    includeTables: true,
+};
+// ═══════════════════════════════════════════════════════════════════════════
+// Codec Creation
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Create a ClaudeModuleCodec with custom options.
+ *
+ * @param options - Codec configuration options
+ * @returns Configured Zod codec
+ */
+export function createClaudeModuleCodec(options) {
+    const opts = mergeOptions(DEFAULT_CLAUDE_MODULE_OPTIONS, options);
+    return z.codec(MasterDatasetSchema, RenderableDocumentOutputSchema, {
+        decode: (dataset) => {
+            return buildClaudeModuleDocument(dataset, opts);
+        },
+        /** @throws Always - this codec is decode-only. See zod-codecs.md */
+        encode: () => {
+            throw new Error('ClaudeModuleCodec is decode-only. See zod-codecs.md');
+        },
+    });
+}
+/**
+ * Default Claude Module Codec
+ *
+ * Transforms MasterDataset → RenderableDocument for CLAUDE.md modules.
+ * Uses default options with standard detail level.
+ */
+export const ClaudeModuleCodec = createClaudeModuleCodec();
+// ═══════════════════════════════════════════════════════════════════════════
+// Document Builder
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Build the index document listing all generated modules,
+ * with each module as an additionalFile.
+ */
+function buildClaudeModuleDocument(dataset, options) {
+    // Filter to patterns with claudeModule set
+    const modulePatterns = dataset.patterns.filter((p) => p.claudeModule !== undefined && p.claudeModule !== '');
+    if (modulePatterns.length === 0) {
+        return document('Claude Modules', [
+            heading(2, 'No Claude Modules Found'),
+            paragraph('No patterns have `@architect-claude-module` tags.'),
+        ], {
+            purpose: 'Claude module generation index',
+        });
+    }
+    // Build index sections
+    const sections = [];
+    sections.push(heading(2, 'Generated Modules'), paragraph(`${modulePatterns.length} module(s) generated from annotated behavior specs.`));
+    // Summary table
+    const rows = modulePatterns.map((p) => [
+        p.claudeModule ?? '',
+        p.claudeSection ?? DEFAULT_CLAUDE_SECTION,
+        p.name,
+        `${p.rules?.length ?? 0} rules`,
+    ]);
+    sections.push(table(['Module', 'Section', 'Source Pattern', 'Content'], rows));
+    // Build each module as an additional file
+    const additionalFiles = {};
+    for (const pattern of modulePatterns) {
+        const section = pattern.claudeSection ?? DEFAULT_CLAUDE_SECTION;
+        const module = pattern.claudeModule ?? pattern.name;
+        const filePath = `${section}/${module}.md`;
+        additionalFiles[filePath] = buildModuleFile(pattern, options);
+    }
+    const docOptions = {
+        purpose: 'Claude module generation index',
+        detailLevel: options.detailLevel,
+    };
+    if (Object.keys(additionalFiles).length > 0) {
+        docOptions.additionalFiles = additionalFiles;
+    }
+    return document('Claude Modules', sections, docOptions);
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Module File Builder
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Build a single module file from a pattern.
+ * Extracts content from Feature description, Rule blocks, and Scenario Outline Examples.
+ */
+function buildModuleFile(pattern, options) {
+    const sections = [];
+    // Skip Feature description (Problem/Solution preamble) — it is meta-documentation
+    // about why the spec exists, not operational content. Only Rule blocks contain
+    // the actual invariants and guidance needed in _claude-md/ modules.
+    // Rule blocks → H4 sections
+    if (pattern.rules && pattern.rules.length > 0) {
+        sections.push(separator());
+        for (const rule of pattern.rules) {
+            sections.push(...buildRuleSection(rule, options));
+        }
+    }
+    // Scenario Outline Examples → decision tables
+    if (options.detailLevel !== 'summary') {
+        const examplesTables = extractExamplesTables(pattern);
+        if (examplesTables.length > 0) {
+            sections.push(...examplesTables);
+        }
+    }
+    // See-also link
+    if (options.fullDocsPath) {
+        const slug = pattern.claudeModule ?? pattern.name.toLowerCase();
+        const fullPath = `${options.fullDocsPath}${slug.toUpperCase()}.md`;
+        sections.push(separator());
+        sections.push(linkOut(`Full Documentation`, fullPath));
+    }
+    return document(pattern.name, sections, {
+        purpose: `Claude module: ${pattern.claudeModule ?? pattern.name}`,
+        detailLevel: options.detailLevel,
+    });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Content Extractors
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Build a Rule section (H4 heading + invariant + rationale + tables).
+ *
+ * Related: `renderRuleDescription()` in helpers.ts performs the same
+ * annotation-parse-to-blocks sequence but produces full-detail output
+ * (includes verifiedBy, codeExamples, remainingContent). This function
+ * intentionally produces compact output for _claude-md/ modules.
+ */
+function buildRuleSection(rule, options) {
+    const sections = [];
+    // H2 heading from rule name (renderer offsets to H4 for _claude-md/ modules)
+    sections.push(heading(2, rule.name));
+    // Parse structured annotations from rule description
+    const annotations = parseBusinessRuleAnnotations(rule.description);
+    if (annotations.invariant) {
+        sections.push(paragraph(`**Invariant:** ${annotations.invariant}`));
+    }
+    if (options.includeRationale && annotations.rationale) {
+        sections.push(paragraph(`**Rationale:** ${annotations.rationale}`));
+    }
+    // Extract and preserve tables from the rule description
+    if (options.includeTables) {
+        const tables = extractTablesAsSectionBlocks(rule.description);
+        for (const t of tables) {
+            sections.push(t);
+        }
+    }
+    return sections;
+}
+/**
+ * Extract Scenario Outline Examples tables from pattern scenarios.
+ */
+function extractExamplesTables(pattern) {
+    const sections = [];
+    if (!pattern.scenarios)
+        return sections;
+    for (const scenario of pattern.scenarios) {
+        if (!scenario.steps)
+            continue;
+        for (const step of scenario.steps) {
+            const dt = step.dataTable;
+            if (dt && dt.headers.length > 0 && dt.rows.length > 0) {
+                const rows = dt.rows.map((row) => dt.headers.map((h) => row[h] ?? ''));
+                sections.push(table([...dt.headers], rows));
+            }
+        }
+    }
+    return sections;
+}
+//# sourceMappingURL=claude-module.js.map

package/dist/renderable/codecs/claude-module.js.map

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

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

@@ -0,0 +1,84 @@
+/**
+ * @architect
+ * @architect-core
+ * @architect-pattern CompositeCodec
+ * @architect-status active
+ * @architect-implements ReferenceDocShowcase
+ * @architect-arch-role projection
+ * @architect-arch-context renderer
+ * @architect-arch-layer application
+ * @architect-convention codec-registry
+ * @architect-product-area:Generation
+ *
+ * ## CompositeCodec
+ *
+ * Assembles reference documents from multiple codec outputs by concatenating
+ * RenderableDocument sections. Enables building documents composed from any
+ * combination of existing codecs.
+ *
+ * **Purpose:** Assembles documents from multiple child codecs into a single RenderableDocument.
+ *
+ * **Output Files:** Configured per-instance (composes child codec outputs)
+ *
+ * ### When to Use
+ *
+ * - When building reference docs from multiple codec outputs
+ * - When composing session briefs from overview + current work + remaining work
+ * - When referenceDocConfigs need content from arbitrary codecs
+ *
+ * ### Factory Pattern
+ *
+ * Use the factory function with child codecs and options:
+ * ```typescript
+ * const codec = createCompositeCodec(
+ *   [OverviewCodec, CurrentWorkCodec, RemainingWorkCodec],
+ *   { title: 'Session Brief' }
+ * );
+ * const doc = codec.decode(dataset);
+ * ```
+ *
+ * Or use `composeDocuments` directly at the document level:
+ * ```typescript
+ * const doc = composeDocuments([docA, docB], { title: 'Combined' });
+ * ```
+ */
+import { type RenderableDocument } from '../schema.js';
+import { type BaseCodecOptions, type DocumentCodec } from './types/base.js';
+/**
+ * Options for composing RenderableDocuments without the codec wrapper.
+ */
+export interface ComposeOptions {
+    /** Document title for the composed output */
+    readonly title: string;
+    /** Optional purpose description */
+    readonly purpose?: string;
+    /** Optional detail level indicator */
+    readonly detailLevel?: string;
+    /** Insert separator blocks between document outputs (default: true) */
+    readonly separateSections?: boolean;
+}
+/**
+ * Options for createCompositeCodec factory.
+ */
+export interface CompositeCodecOptions extends BaseCodecOptions {
+    /** Document title for the composite output */
+    readonly title: string;
+    /** Optional purpose description */
+    readonly purpose?: string;
+    /** Insert separator blocks between codec outputs (default: true) */
+    readonly separateSections?: boolean;
+}
+/**
+ * Compose multiple RenderableDocuments into a single document.
+ *
+ * Concatenates sections in array order. Merges additionalFiles with
+ * last-wins semantics on key collision. Inserts separator blocks
+ * between non-empty document outputs by default.
+ */
+export declare function composeDocuments(documents: readonly RenderableDocument[], options: ComposeOptions): RenderableDocument;
+/**
+ * Create a CompositeCodec that decodes each child codec against the same
+ * MasterDataset and composes their outputs into a single RenderableDocument.
+ */
+export declare function createCompositeCodec(codecs: readonly DocumentCodec[], options: CompositeCodecOptions): DocumentCodec;
+//# sourceMappingURL=composite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../src/renderable/codecs/composite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAOH,OAAO,EAAE,KAAK,kBAAkB,EAA0C,MAAM,cAAc,CAAC;AAC/F,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,aAAa,EAAwB,MAAM,iBAAiB,CAAC;AAOlG;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,6CAA6C;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,mCAAmC;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAE1B,sCAAsC;IACtC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAE9B,uEAAuE;IACvE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,gBAAgB;IAC7D,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,mCAAmC;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAE1B,oEAAoE;IACpE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CACrC;AAMD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,SAAS,kBAAkB,EAAE,EACxC,OAAO,EAAE,cAAc,GACtB,kBAAkB,CAmDpB;AAMD;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,OAAO,EAAE,qBAAqB,GAC7B,aAAa,CAuBf"}

package/dist/renderable/codecs/composite.js

@@ -0,0 +1,124 @@
+/**
+ * @architect
+ * @architect-core
+ * @architect-pattern CompositeCodec
+ * @architect-status active
+ * @architect-implements ReferenceDocShowcase
+ * @architect-arch-role projection
+ * @architect-arch-context renderer
+ * @architect-arch-layer application
+ * @architect-convention codec-registry
+ * @architect-product-area:Generation
+ *
+ * ## CompositeCodec
+ *
+ * Assembles reference documents from multiple codec outputs by concatenating
+ * RenderableDocument sections. Enables building documents composed from any
+ * combination of existing codecs.
+ *
+ * **Purpose:** Assembles documents from multiple child codecs into a single RenderableDocument.
+ *
+ * **Output Files:** Configured per-instance (composes child codec outputs)
+ *
+ * ### When to Use
+ *
+ * - When building reference docs from multiple codec outputs
+ * - When composing session briefs from overview + current work + remaining work
+ * - When referenceDocConfigs need content from arbitrary codecs
+ *
+ * ### Factory Pattern
+ *
+ * Use the factory function with child codecs and options:
+ * ```typescript
+ * const codec = createCompositeCodec(
+ *   [OverviewCodec, CurrentWorkCodec, RemainingWorkCodec],
+ *   { title: 'Session Brief' }
+ * );
+ * const doc = codec.decode(dataset);
+ * ```
+ *
+ * Or use `composeDocuments` directly at the document level:
+ * ```typescript
+ * const doc = composeDocuments([docA, docB], { title: 'Combined' });
+ * ```
+ */
+import { z } from 'zod';
+import { MasterDatasetSchema, } from '../../validation-schemas/master-dataset.js';
+import { separator, document } from '../schema.js';
+import { DEFAULT_BASE_OPTIONS } from './types/base.js';
+import { RenderableDocumentOutputSchema } from './shared-schema.js';
+// ═══════════════════════════════════════════════════════════════════════════
+// composeDocuments — Pure Document Composition
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Compose multiple RenderableDocuments into a single document.
+ *
+ * Concatenates sections in array order. Merges additionalFiles with
+ * last-wins semantics on key collision. Inserts separator blocks
+ * between non-empty document outputs by default.
+ */
+export function composeDocuments(documents, options) {
+    const sections = [];
+    let mergedAdditionalFiles;
+    let hasPreviousContent = false;
+    for (const currentDoc of documents) {
+        // Skip empty documents entirely (no separator emitted)
+        if (currentDoc.sections.length === 0 && currentDoc.additionalFiles === undefined) {
+            continue;
+        }
+        // Add separator between non-empty outputs
+        if (options.separateSections !== false &&
+            hasPreviousContent &&
+            currentDoc.sections.length > 0) {
+            sections.push(separator());
+        }
+        if (currentDoc.sections.length > 0) {
+            hasPreviousContent = true;
+        }
+        sections.push(...currentDoc.sections);
+        // Merge additionalFiles (last-wins on key collision)
+        if (currentDoc.additionalFiles !== undefined) {
+            mergedAdditionalFiles ??= {};
+            for (const [key, value] of Object.entries(currentDoc.additionalFiles)) {
+                mergedAdditionalFiles[key] = value;
+            }
+        }
+    }
+    const docOptions = {};
+    if (options.purpose !== undefined) {
+        docOptions.purpose = options.purpose;
+    }
+    if (options.detailLevel !== undefined) {
+        docOptions.detailLevel = options.detailLevel;
+    }
+    if (mergedAdditionalFiles !== undefined) {
+        docOptions.additionalFiles = mergedAdditionalFiles;
+    }
+    return document(options.title, sections, docOptions);
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// createCompositeCodec — Codec Factory
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Create a CompositeCodec that decodes each child codec against the same
+ * MasterDataset and composes their outputs into a single RenderableDocument.
+ */
+export function createCompositeCodec(codecs, options) {
+    const separateSections = options.separateSections ?? true;
+    const detailLevel = options.detailLevel ?? DEFAULT_BASE_OPTIONS.detailLevel;
+    return z.codec(MasterDatasetSchema, RenderableDocumentOutputSchema, {
+        decode: (dataset) => {
+            const documents = codecs.map((codec) => codec.decode(dataset));
+            const composeOpts = {
+                title: options.title,
+                detailLevel,
+                separateSections,
+            };
+            return composeDocuments(documents, options.purpose !== undefined ? { ...composeOpts, purpose: options.purpose } : composeOpts);
+        },
+        encode: () => {
+            throw new Error('CompositeCodec is decode-only');
+        },
+    });
+}
+//# sourceMappingURL=composite.js.map

package/dist/renderable/codecs/composite.js.map

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

package/dist/renderable/codecs/convention-extractor.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Convention Extractor
+ *
+ * Filters MasterDataset for patterns tagged with `@architect-convention`
+ * and extracts convention content as structured data for reference codec
+ * composition. Supports two sources:
+ *
+ * - **Gherkin**: Extracts from `Rule:` blocks on the pattern's `rules` array
+ * - **TypeScript**: Decomposes JSDoc `directive.description` by `## Heading`
+ *   sections, parsing each section for structured annotations
+ *
+ * Both sources produce the same `ConventionRuleContent` output, enabling
+ * Gherkin and TypeScript convention content to merge in the same bundle.
+ *
+ * @see CodecDrivenReferenceGeneration spec
+ * @see ReferenceDocShowcase spec
+ */
+import type { MasterDataset } from '../../validation-schemas/master-dataset.js';
+import type { ExtractedPattern } from '../../validation-schemas/extracted-pattern.js';
+import type { SectionBlock } from '../schema.js';
+/**
+ * Structured content extracted from a decision record Rule block.
+ */
+export interface ConventionRuleContent {
+    /** Rule name (from Gherkin Rule: block or TypeScript ## heading) */
+    readonly ruleName: string;
+    /** Invariant statement if present */
+    readonly invariant?: string;
+    /** Rationale statement if present */
+    readonly rationale?: string;
+    /** Verified-by references if present */
+    readonly verifiedBy?: readonly string[];
+    /** Tables found in the Rule block description */
+    readonly tables: readonly ConventionTable[];
+    /** Code examples extracted from DocStrings in the rule description (includes mermaid diagrams) */
+    readonly codeExamples?: readonly SectionBlock[];
+    /** Free-text content (non-table, non-structured) */
+    readonly narrative: string;
+}
+/**
+ * A table extracted from a Rule block.
+ */
+export interface ConventionTable {
+    readonly headers: readonly string[];
+    readonly rows: ReadonlyArray<Record<string, string>>;
+}
+/**
+ * All convention content for a given tag value.
+ */
+export interface ConventionBundle {
+    /** The convention tag value (e.g., "fsm-rules") */
+    readonly conventionTag: string;
+    /** Source decision records that contributed */
+    readonly sourceDecisions: readonly string[];
+    /** Extracted Rule block content, ordered by source */
+    readonly rules: readonly ConventionRuleContent[];
+}
+/**
+ * Extract markdown tables from description text.
+ *
+ * Identifies lines starting and ending with `|` as table rows,
+ * groups consecutive table lines, and parses headers + data rows.
+ */
+export declare function extractTablesFromDescription(description: string): ConventionTable[];
+/**
+ * Extract markdown tables from description text and return as SectionBlock tables.
+ *
+ * Adapter that wraps `extractTablesFromDescription` for codecs that need
+ * `SectionBlock[]` output instead of `ConventionTable[]`.
+ */
+export declare function extractTablesAsSectionBlocks(description: string): SectionBlock[];
+/**
+ * Extracts convention content from MasterDataset.
+ *
+ * Filters patterns tagged with `@architect-convention` matching the
+ * requested tag values. For Gherkin-sourced patterns, extracts from
+ * Rule: blocks. For TypeScript-sourced patterns (no rules array),
+ * decomposes the JSDoc description by ## headings.
+ *
+ * @param dataset - The MasterDataset containing all extracted patterns
+ * @param conventionTags - Convention tag values to filter by
+ * @returns Array of ConventionBundles, one per requested tag value
+ *
+ * @example
+ * ```typescript
+ * const conventions = extractConventions(dataset, ['fsm-rules', 'testing-policy']);
+ * // conventions[0].conventionTag === 'fsm-rules'
+ * // conventions[0].rules[0].ruleName === 'FSM Transitions'
+ * // conventions[0].rules[0].tables[0].headers === ['From', 'To', 'Condition']
+ * ```
+ */
+export declare function extractConventions(dataset: MasterDataset, conventionTags: readonly string[]): ConventionBundle[];
+/**
+ * Extract convention bundles from pre-filtered patterns.
+ *
+ * DD-1 (CrossCuttingDocumentInclusion): Used by the include-tag pass to
+ * build convention content from patterns selected by include tag rather
+ * than by conventionTags filter. Groups output by each pattern's convention
+ * tag values.
+ *
+ * @param patterns - Pre-filtered patterns that have convention content
+ * @returns Array of ConventionBundles
+ */
+export declare function extractConventionsFromPatterns(patterns: readonly ExtractedPattern[]): ConventionBundle[];
+//# sourceMappingURL=convention-extractor.d.ts.map

package/dist/renderable/codecs/convention-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convention-extractor.d.ts","sourceRoot":"","sources":["../../../src/renderable/codecs/convention-extractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4CAA4C,CAAC;AAChF,OAAO,KAAK,EAAgB,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACpG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAQjD;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,qCAAqC;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAE5B,qCAAqC;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAE5B,wCAAwC;IACxC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAExC,iDAAiD;IACjD,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;IAE5C,kGAAkG;IAClG,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAEhD,oDAAoD;IACpD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACtD;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,mDAAmD;IACnD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B,+CAA+C;IAC/C,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IAE5C,sDAAsD;IACtD,QAAQ,CAAC,KAAK,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAClD;AAMD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,WAAW,EAAE,MAAM,GAAG,eAAe,EAAE,CA0BnF;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,WAAW,EAAE,MAAM,GAAG,YAAY,EAAE,CAOhF;AAyLD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,SAAS,MAAM,EAAE,GAChC,gBAAgB,EAAE,CA6DpB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,gBAAgB,EAAE,CAsCpB"}