@ankhorage/paradox 0.1.8 → 0.1.10

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.1.10
+
+### Patch Changes
+
+- 47b7ced: Add generated README usage support from real source examples marked through configured usage entrypoints, while keeping existing package command usage intact.
+
+## 0.1.9
+
+### Patch Changes
+
+- 9b43e55: Keep generated README files compact by linking diagram artifacts from the generated documentation section instead of embedding the architecture preview inline.
+
 ## 0.1.8
 
 ### Patch Changes

package/README.md

@@ -3,7 +3,7 @@
 
 # @ankhorage/paradox
 
-![license: MIT](./paradox/badges/license.svg) ![npm: v0.1.8](./paradox/badges/npm.svg) ![runtime: bun](./paradox/badges/runtime.svg) ![typescript: strict](./paradox/badges/typescript.svg) ![eslint: checked](./paradox/badges/eslint.svg) ![prettier: checked](./paradox/badges/prettier.svg) ![build: checked](./paradox/badges/build.svg) ![tests: checked](./paradox/badges/tests.svg) ![docs: paradox](./paradox/badges/docs.svg)
+![license: MIT](./paradox/badges/license.svg) ![npm: v0.1.10](./paradox/badges/npm.svg) ![runtime: bun](./paradox/badges/runtime.svg) ![typescript: strict](./paradox/badges/typescript.svg) ![eslint: checked](./paradox/badges/eslint.svg) ![prettier: checked](./paradox/badges/prettier.svg) ![build: checked](./paradox/badges/build.svg) ![tests: checked](./paradox/badges/tests.svg) ![docs: paradox](./paradox/badges/docs.svg)
 
 Deterministic documentation generator for TypeScript packages.
 
@@ -79,12 +79,12 @@ export default defineParadoxConfig({
 <details>
 <summary>Configuration options</summary>
 
-| Field   | Type                                                      | Required | Default | Description |
-| ------- | --------------------------------------------------------- | -------- | ------- | ----------- |
-| mode    | `'safe' \| 'write' \| undefined`                          | no       | —       |             |
-| docs    | `{ title?: string; description?: string; } \| undefined`  | no       | —       |             |
-| package | `{ root?: string; entrypoints?: string[]; } \| undefined` | no       | —       |             |
-| output  | `{ dir?: string; } \| undefined`                          | no       | —       |             |
+| Field   | Type                                                                                          | Required | Default | Description |
+| ------- | --------------------------------------------------------------------------------------------- | -------- | ------- | ----------- |
+| mode    | `'safe' \| 'write' \| undefined`                                                              | no       | —       |             |
+| docs    | `{ title?: string; description?: string; usage?: { entrypoints?: string[]; }; } \| undefined` | no       | —       |             |
+| package | `{ root?: string; entrypoints?: string[]; } \| undefined`                                     | no       | —       |             |
+| output  | `{ dir?: string; } \| undefined`                                                              | no       | —       |             |
 
 </details>
 
@@ -99,198 +99,6 @@ export default defineParadoxConfig({
 - [isParadoxDocTagName sequence](./paradox/diagrams/sequences/is-paradox-doc-tag-name.mmd)
 - [paradox sequence](./paradox/diagrams/sequences/paradox.mmd)
 
-## Architecture preview
-
-<details>
-<summary>Architecture overview</summary>
-
-```mermaid
-graph TD
-  package__ankhorage_paradox["@ankhorage/paradox"]
-  entrypoint_src_index_ts["src/index.ts"]
-  package__ankhorage_paradox --> entrypoint_src_index_ts
-  module_src_analyze_analyze_ts["src/analyze/analyze.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_analyze_ts
-  module_src_analyze_analyze_ts --> module_src_analyze_badges_ts
-  module_src_analyze_analyze_ts --> module_src_analyze_components_ts
-  module_src_analyze_analyze_ts --> module_src_analyze_exports_ts
-  module_src_analyze_analyze_ts --> module_src_analyze_modules_ts
-  module_src_analyze_analyze_ts --> module_src_analyze_project_ts
-  module_src_analyze_analyze_ts --> module_src_analyze_semantic_createTypeScriptProgram_ts
-  module_src_analyze_analyze_ts --> module_src_analyze_semantic_exports_ts
-  module_src_analyze_analyze_ts --> module_src_analyze_semantic_graphs_ts
-  module_src_analyze_analyze_ts --> module_src_analyze_sequenceScenarios_ts
-  module_src_analyze_analyze_ts --> module_src_analyze_sourceFunctions_ts
-  module_src_analyze_analyze_ts --> module_src_analyze_types_ts
-  module_src_analyze_analyze_ts --> module_src_analyze_usage_ts
-  module_src_analyze_analyze_ts --> module_src_config_types_ts
-  module_src_analyze_badges_ts["src/analyze/badges.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_badges_ts
-  module_src_analyze_badges_ts --> module_src_analyze_types_ts
-  module_src_analyze_badges_ts --> module_src_analyze_usage_ts
-  module_src_analyze_components_ts["src/analyze/components.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_components_ts
-  module_src_analyze_components_ts --> module_src_analyze_semantic_exports_ts
-  module_src_analyze_components_ts --> module_src_analyze_semantic_model_ts
-  module_src_analyze_components_ts --> module_src_analyze_types_ts
-  module_src_analyze_components_ts --> module_src_analyze_utils_getComponentPropsType_ts
-  module_src_analyze_components_ts --> module_src_analyze_utils_getPropsFromType_ts
-  module_src_analyze_components_ts --> module_src_analyze_utils_isReactComponent_ts
-  module_src_analyze_exports_ts["src/analyze/exports.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_exports_ts
-  module_src_analyze_exports_ts --> module_src_analyze_types_ts
-  module_src_analyze_exports_ts --> module_src_analyze_utils_getExportMetadata_ts
-  module_src_analyze_exports_ts --> module_src_analyze_utils_getParadoxComment_ts
-  module_src_analyze_exports_ts --> module_src_analyze_utils_parseParadoxComment_ts
-  module_src_analyze_exports_ts --> module_src_analyze_utils_resolveExportSymbol_ts
-  module_src_analyze_modules_ts["src/analyze/modules.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_modules_ts
-  module_src_analyze_modules_ts --> module_src_analyze_types_ts
-  module_src_analyze_project_ts["src/analyze/project.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_project_ts
-  module_src_analyze_semantic_analyzeProject_ts["src/analyze/semantic/analyzeProject.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_semantic_analyzeProject_ts
-  module_src_analyze_semantic_analyzeProject_ts --> module_src_analyze_semantic_associateDocBlocksWithSymbols_ts
-  module_src_analyze_semantic_analyzeProject_ts --> module_src_analyze_semantic_collectSourceFiles_ts
-  module_src_analyze_semantic_analyzeProject_ts --> module_src_analyze_semantic_createTypeScriptProgram_ts
-  module_src_analyze_semantic_analyzeProject_ts --> module_src_analyze_semantic_docBlocks_ts
-  module_src_analyze_semantic_analyzeProject_ts --> module_src_analyze_semantic_exports_ts
-  module_src_analyze_semantic_analyzeProject_ts --> module_src_analyze_semantic_graphs_ts
-  module_src_analyze_semantic_analyzeProject_ts --> module_src_analyze_semantic_model_ts
-  module_src_analyze_semantic_analyzeProject_ts --> module_src_analyze_semantic_tagRegistry_ts
-  module_src_analyze_semantic_associateDocBlocksWithSymbols_ts["src/analyze/semantic/associateDocBlocksWithSymbols.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_semantic_associateDocBlocksWithSymbols_ts
-  module_src_analyze_semantic_associateDocBlocksWithSymbols_ts --> module_src_analyze_semantic_model_ts
-  module_src_analyze_semantic_associateDocBlocksWithSymbols_ts --> module_src_analyze_semantic_utils_ts
-  module_src_analyze_semantic_collectSourceFiles_ts["src/analyze/semantic/collectSourceFiles.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_semantic_collectSourceFiles_ts
-  module_src_analyze_semantic_collectSourceFiles_ts --> module_src_analyze_semantic_model_ts
-  module_src_analyze_semantic_collectSourceFiles_ts --> module_src_analyze_semantic_utils_ts
-  module_src_analyze_semantic_createTypeScriptProgram_ts["src/analyze/semantic/createTypeScriptProgram.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_semantic_createTypeScriptProgram_ts
-  module_src_analyze_semantic_createTypeScriptProgram_ts --> module_src_analyze_semantic_model_ts
-  module_src_analyze_semantic_createTypeScriptProgram_ts --> module_src_analyze_semantic_utils_ts
-  module_src_analyze_semantic_docBlocks_ts["src/analyze/semantic/docBlocks.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_semantic_docBlocks_ts
-  module_src_analyze_semantic_docBlocks_ts --> module_src_analyze_semantic_model_ts
-  module_src_analyze_semantic_docBlocks_ts --> module_src_analyze_semantic_tagRegistry_ts
-  module_src_analyze_semantic_docBlocks_ts --> module_src_analyze_semantic_utils_ts
-  module_src_analyze_semantic_exports_ts["src/analyze/semantic/exports.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_semantic_exports_ts
-  module_src_analyze_semantic_exports_ts --> module_src_analyze_semantic_isReactComponent_ts
-  module_src_analyze_semantic_exports_ts --> module_src_analyze_semantic_model_ts
-  module_src_analyze_semantic_exports_ts --> module_src_analyze_semantic_paradoxComment_ts
-  module_src_analyze_semantic_exports_ts --> module_src_analyze_semantic_utils_ts
-  module_src_analyze_semantic_graphs_ts["src/analyze/semantic/graphs.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_semantic_graphs_ts
-  module_src_analyze_semantic_graphs_ts --> module_src_analyze_semantic_exports_ts
-  module_src_analyze_semantic_graphs_ts --> module_src_analyze_semantic_model_ts
-  module_src_analyze_semantic_graphs_ts --> module_src_analyze_semantic_utils_ts
-  module_src_analyze_semantic_isReactComponent_ts["src/analyze/semantic/isReactComponent.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_semantic_isReactComponent_ts
-  module_src_analyze_semantic_model_ts["src/analyze/semantic/model.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_semantic_model_ts
-  module_src_analyze_semantic_paradoxComment_ts["src/analyze/semantic/paradoxComment.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_semantic_paradoxComment_ts
-  module_src_analyze_semantic_tagRegistry_ts["src/analyze/semantic/tagRegistry.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_semantic_tagRegistry_ts
-  module_src_analyze_semantic_utils_ts["src/analyze/semantic/utils.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_semantic_utils_ts
-  module_src_analyze_sequenceScenarios_ts["src/analyze/sequenceScenarios.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_sequenceScenarios_ts
-  module_src_analyze_sequenceScenarios_ts --> module_src_analyze_semantic_utils_ts
-  module_src_analyze_sequenceScenarios_ts --> module_src_analyze_types_ts
-  module_src_analyze_sequenceScenarios_ts --> module_src_analyze_usage_ts
-  module_src_analyze_sequenceScenarios_ts --> module_src_analyze_utils_getParadoxComment_ts
-  module_src_analyze_sequenceScenarios_ts --> module_src_analyze_utils_parseParadoxComment_ts
-  module_src_analyze_sourceFunctions_ts["src/analyze/sourceFunctions.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_sourceFunctions_ts
-  module_src_analyze_sourceFunctions_ts --> module_src_analyze_types_ts
-  module_src_analyze_sourceFunctions_ts --> module_src_analyze_utils_getParadoxComment_ts
-  module_src_analyze_sourceFunctions_ts --> module_src_analyze_utils_parseParadoxComment_ts
-  module_src_analyze_types_ts["src/analyze/types.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_types_ts
-  module_src_analyze_usage_ts["src/analyze/usage.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_usage_ts
-  module_src_analyze_usage_ts --> module_src_analyze_types_ts
-  module_src_analyze_utils_getComponentPropsType_ts["src/analyze/utils/getComponentPropsType.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_utils_getComponentPropsType_ts
-  module_src_analyze_utils_getExportMetadata_ts["src/analyze/utils/getExportMetadata.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_utils_getExportMetadata_ts
-  module_src_analyze_utils_getExportMetadata_ts --> module_src_analyze_types_ts
-  module_src_analyze_utils_getExportMetadata_ts --> module_src_analyze_utils_getParadoxComment_ts
-  module_src_analyze_utils_getExportMetadata_ts --> module_src_analyze_utils_parseParadoxComment_ts
-  module_src_analyze_utils_getParadoxComment_ts["src/analyze/utils/getParadoxComment.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_utils_getParadoxComment_ts
-  module_src_analyze_utils_getPropsFromType_ts["src/analyze/utils/getPropsFromType.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_utils_getPropsFromType_ts
-  module_src_analyze_utils_getPropsFromType_ts --> module_src_analyze_types_ts
-  module_src_analyze_utils_getPropsFromType_ts --> module_src_analyze_utils_getParadoxComment_ts
-  module_src_analyze_utils_getPropsFromType_ts --> module_src_analyze_utils_parseParadoxComment_ts
-  module_src_analyze_utils_isReactComponent_ts["src/analyze/utils/isReactComponent.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_utils_isReactComponent_ts
-  module_src_analyze_utils_parseParadoxComment_ts["src/analyze/utils/parseParadoxComment.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_utils_parseParadoxComment_ts
-  module_src_analyze_utils_resolveExportSymbol_ts["src/analyze/utils/resolveExportSymbol.ts"]
-  package__ankhorage_paradox -.-> module_src_analyze_utils_resolveExportSymbol_ts
-  module_src_cli_ts["src/cli.ts"]
-  package__ankhorage_paradox -.-> module_src_cli_ts
-  module_src_cli_ts --> module_src_analyze_analyze_ts
-  module_src_cli_ts --> module_src_model_buildModel_ts
-  module_src_cli_ts --> module_src_paths_policy_ts
-  module_src_cli_ts --> module_src_render_render_ts
-  module_src_cli_ts --> module_src_write_write_ts
-  module_src_config_defineParadoxConfig_ts["src/config/defineParadoxConfig.ts"]
-  package__ankhorage_paradox -.-> module_src_config_defineParadoxConfig_ts
-  module_src_config_defineParadoxConfig_ts --> module_src_config_types_ts
-  module_src_config_types_ts["src/config/types.ts"]
-  package__ankhorage_paradox -.-> module_src_config_types_ts
-  module_src_doc_tags_registry_ts["src/doc-tags/registry.ts"]
-  package__ankhorage_paradox -.-> module_src_doc_tags_registry_ts
-  module_src_index_ts["src/index.ts"]
-  module_src_model_buildModel_ts["src/model/buildModel.ts"]
-  package__ankhorage_paradox -.-> module_src_model_buildModel_ts
-  module_src_model_buildModel_ts --> module_src_model_types_ts
-  module_src_model_types_ts["src/model/types.ts"]
-  package__ankhorage_paradox -.-> module_src_model_types_ts
-  module_src_paths_policy_ts["src/paths/policy.ts"]
-  package__ankhorage_paradox -.-> module_src_paths_policy_ts
-  module_src_paths_policy_ts --> module_src_config_types_ts
-  module_src_render_render_ts["src/render/render.ts"]
-  package__ankhorage_paradox -.-> module_src_render_render_ts
-  module_src_render_render_ts --> module_src_model_types_ts
-  module_src_render_render_ts --> module_src_render_renderers_badges_ts
-  module_src_render_render_ts --> module_src_render_renderers_diagrams_ts
-  module_src_render_render_ts --> module_src_render_renderers_html_ts
-  module_src_render_render_ts --> module_src_render_renderers_markdown_ts
-  module_src_render_render_ts --> module_src_render_types_ts
-  module_src_render_renderers_badges_ts["src/render/renderers/badges.ts"]
-  package__ankhorage_paradox -.-> module_src_render_renderers_badges_ts
-  module_src_render_renderers_badges_ts --> module_src_model_types_ts
-  module_src_render_renderers_badges_ts --> module_src_render_types_ts
-  module_src_render_renderers_diagrams_ts["src/render/renderers/diagrams.ts"]
-  package__ankhorage_paradox -.-> module_src_render_renderers_diagrams_ts
-  module_src_render_renderers_diagrams_ts --> module_src_model_types_ts
-  module_src_render_renderers_diagrams_ts --> module_src_render_types_ts
-  module_src_render_renderers_html_ts["src/render/renderers/html.ts"]
-  package__ankhorage_paradox -.-> module_src_render_renderers_html_ts
-  module_src_render_renderers_html_ts --> module_src_model_types_ts
-  module_src_render_renderers_html_ts --> module_src_render_types_ts
-  module_src_render_renderers_markdown_ts["src/render/renderers/markdown.ts"]
-  package__ankhorage_paradox -.-> module_src_render_renderers_markdown_ts
-  module_src_render_renderers_markdown_ts --> module_src_model_types_ts
-  module_src_render_renderers_markdown_ts --> module_src_render_types_ts
-  module_src_render_types_ts["src/render/types.ts"]
-  package__ankhorage_paradox -.-> module_src_render_types_ts
-  module_src_render_types_ts --> module_src_model_types_ts
-  module_src_write_write_ts["src/write/write.ts"]
-  package__ankhorage_paradox -.-> module_src_write_write_ts
-  module_src_write_write_ts --> module_src_config_types_ts
-  module_src_write_write_ts --> module_src_render_types_ts
-```
-
-</details>
-
 ## Public API
 
 ### Config
@@ -319,23 +127,3 @@ Module: `src/config/types.ts`
 Source: `src/config/types.ts:7:1`
 
 </details>
-
-### Documentation
-
-<details>
-<summary>PARADOX_DOC_TAGS</summary>
-
-Supported Paradox documentation tags.
-
-Paradox supports doc tags inside triple-star documentation comments.
-
-| name      | syntax     | description                                                                                                                                                      | applies to      | repeatable | handler        |
-| --------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------- | ---------- | -------------- |
-| `readme`  | `@readme`  | Includes a documentation block or exported symbol in README output.                                                                                              | block, symbol   | no         | `markReadme`   |
-| `config`  | `@config`  | Marks a type or interface as part of the Paradox configuration model. @config alone does not imply README inclusion; use @config plus @readme for README output. | interface, type | no         | `markConfig`   |
-| `example` | `@example` | Adds a titled fenced code example to the generated documentation for a symbol.                                                                                   | symbol          | yes        | `parseExample` |
-
-Module: `src/doc-tags/registry.ts`
-Source: `src/doc-tags/registry.ts:8:14`
-
-</details>

package/dist/analyze/analyze.js

@@ -5,6 +5,7 @@ import { analyzeComponents } from './components.js';
 import { analyzeExports } from './exports.js';
 import { analyzeModules } from './modules.js';
 import { createProject } from './project.js';
+import { analyzeReadmeUsage } from './readmeUsage.js';
 import { createTypeScriptProgram } from './semantic/createTypeScriptProgram.js';
 import { collectTypeMembers, resolveTypeReference } from './semantic/exports.js';
 import { collectCallGraph, collectComponentCompositionGraph, collectImportGraph, } from './semantic/graphs.js';
@@ -21,10 +22,16 @@ export async function analyze(config, runtime) {
     const badges = await analyzeBadges(root, pkg);
     const project = createProject(root);
     const entrypoints = config.package?.entrypoints ?? ['src/index.ts'];
+    const usageEntryPoints = config.docs?.usage?.entrypoints ?? [];
+    const readmeUsage = await analyzeReadmeUsage({ root, entrypoints: usageEntryPoints });
     const program = createTypeScriptProgram({ root, entrypoints, project });
     const { config: configMetadata, exports } = analyzeExports(project, { root, entrypoints });
     const components = analyzeComponents(exports, { program });
-    const modules = analyzeModules(project, { root, entrypoints });
+    const modules = analyzeModules(project, {
+        root,
+        entrypoints,
+        excludePaths: usageEntryPoints,
+    });
     const sourceFunctions = analyzeSourceFunctions(project, root);
     const sequenceScenarios = analyzeSequenceScenarios({ project, root, pkg, exports });
     const configExport = configMetadata
@@ -60,6 +67,7 @@ export async function analyze(config, runtime) {
         badges,
         sequenceScenarios,
         usage,
+        readmeUsage,
         config: configMetadata
             ? {
                 exportName: configMetadata.exportName,

package/dist/analyze/modules.d.ts

@@ -6,4 +6,5 @@ import type { AnalysisModule } from './types.js';
 export declare function analyzeModules(project: Project, options: {
     root: string;
     entrypoints: readonly string[];
+    excludePaths?: readonly string[];
 }): AnalysisModule[];

package/dist/analyze/modules.js

@@ -5,6 +5,7 @@ import { isAbsolute, join, normalize, relative } from 'node:path';
 export function analyzeModules(project, options) {
     const rootPath = normalize(options.root);
     const entrypointPaths = new Set(options.entrypoints.map((entrypoint) => normalize(isAbsolute(entrypoint) ? entrypoint : join(options.root, entrypoint))));
+    const excludedPaths = new Set((options.excludePaths ?? []).map((entrypoint) => normalize(isAbsolute(entrypoint) ? entrypoint : join(options.root, entrypoint))));
     return project
         .getSourceFiles()
         .filter((sourceFile) => {
@@ -12,6 +13,7 @@ export function analyzeModules(project, options) {
         const normalizedPath = toPosixPath(filePath);
         return (!sourceFile.isDeclarationFile() &&
             filePath.startsWith(rootPath) &&
+            !excludedPaths.has(filePath) &&
             !normalizedPath.includes('/node_modules/'));
     })
         .map((sourceFile) => {
@@ -21,7 +23,9 @@ export function analyzeModules(project, options) {
             .map((declaration) => declaration.getModuleSpecifierSourceFile())
             .filter((dependency) => dependency != null)
             .map((dependency) => normalize(dependency.getFilePath()))
-            .filter((dependency) => dependency.startsWith(rootPath) && !toPosixPath(dependency).includes('/node_modules/'))
+            .filter((dependency) => dependency.startsWith(rootPath) &&
+            !excludedPaths.has(dependency) &&
+            !toPosixPath(dependency).includes('/node_modules/'))
             .map((dependency) => toPosixPath(relative(options.root, dependency)));
         const exports = sourceFile
             .getExportSymbols()

package/dist/analyze/readmeUsage.d.ts

@@ -0,0 +1,14 @@
+export interface AnalysisReadmeUsage {
+    title: string | null;
+    description: string | null;
+    language: string;
+    code: string;
+    sourcePath: string;
+}
+/***
+ * Collects README usage examples from configured real source files.
+ */
+export declare function analyzeReadmeUsage(options: {
+    root: string;
+    entrypoints: readonly string[];
+}): Promise<AnalysisReadmeUsage[]>;

package/dist/analyze/readmeUsage.js

@@ -0,0 +1,72 @@
+import { readFile } from 'node:fs/promises';
+import { extname, isAbsolute, join, relative } from 'node:path';
+import { parseParadoxComment } from './utils/parseParadoxComment.js';
+const USAGE_TAG = `${String.fromCharCode(64)}usage`;
+/***
+ * Collects README usage examples from configured real source files.
+ */
+export async function analyzeReadmeUsage(options) {
+    const entries = await Promise.all(options.entrypoints.map(async (entrypoint) => analyzeUsageEntrypoint(options.root, entrypoint)));
+    return entries.flat().sort((left, right) => left.sourcePath.localeCompare(right.sourcePath));
+}
+async function analyzeUsageEntrypoint(root, entrypoint) {
+    const absolutePath = isAbsolute(entrypoint) ? entrypoint : join(root, entrypoint);
+    const source = await readFile(absolutePath, 'utf-8');
+    const sourcePath = toPosixPath(relative(root, absolutePath));
+    const matches = findUsageComments(source);
+    return matches.map((match) => {
+        const parsed = parseParadoxComment(match.comment);
+        return {
+            title: getUsageTitle(parsed.description, sourcePath),
+            description: parsed.description,
+            language: getLanguage(sourcePath),
+            code: removeRange(source, match.start, match.end).trim(),
+            sourcePath,
+        };
+    });
+}
+function findUsageComments(source) {
+    const matches = [];
+    const pattern = /\/\*\*\*[\s\S]*?\*\//g;
+    for (const match of source.matchAll(pattern)) {
+        const [comment] = match;
+        if (!comment.includes(USAGE_TAG))
+            continue;
+        matches.push({
+            comment,
+            start: match.index,
+            end: match.index + comment.length,
+        });
+    }
+    return matches;
+}
+function removeRange(source, start, end) {
+    const before = source.slice(0, start).trimEnd();
+    const after = source.slice(end).trimStart();
+    if (before.length === 0)
+        return after;
+    if (after.length === 0)
+        return before;
+    return `${before}\n\n${after}`;
+}
+function getUsageTitle(description, sourcePath) {
+    if (description === null)
+        return sourcePath;
+    const [firstLine = sourcePath] = description.split('\n');
+    return firstLine.trim() || sourcePath;
+}
+function getLanguage(sourcePath) {
+    const extension = extname(sourcePath).toLowerCase();
+    if (extension === '.tsx')
+        return 'tsx';
+    if (extension === '.ts')
+        return 'ts';
+    if (extension === '.jsx')
+        return 'jsx';
+    if (extension === '.js')
+        return 'js';
+    return '';
+}
+function toPosixPath(path) {
+    return path.replaceAll('\\', '/');
+}

package/dist/analyze/types.d.ts

@@ -79,6 +79,13 @@ interface AnalysisUsageCommand {
     name: string;
     command: string;
 }
+interface AnalysisReadmeUsage {
+    title: string | null;
+    description: string | null;
+    language: string;
+    code: string;
+    sourcePath: string;
+}
 export interface AnalysisBadge {
     id: string;
     label: string;
@@ -156,6 +163,7 @@ export interface AnalysisResult {
     badges: AnalysisBadge[];
     sequenceScenarios: AnalysisSequenceScenario[];
     usage: AnalysisUsage | null;
+    readmeUsage: AnalysisReadmeUsage[];
     config: {
         exportName: string;
         isReadme: boolean;

package/dist/analyze/utils/parseParadoxComment.d.ts

@@ -1,10 +1,11 @@
 /***
  * Parsed representation of a Paradox doc comment.
  */
-interface ParsedParadoxComment {
+export interface ParsedParadoxComment {
     description: string | null;
     isConfig: boolean;
     isReadme: boolean;
+    isUsage: boolean;
     examples: ParsedExample[];
     params: Record<string, string>;
     returns: string | null;

package/dist/analyze/utils/parseParadoxComment.js

@@ -1,3 +1,4 @@
+const USAGE_TAG = `${String.fromCharCode(64)}usage`;
 /***
  * Parses a Paradox doc comment into structured metadata.
  */
@@ -7,6 +8,7 @@ export function parseParadoxComment(rawComment) {
     const examples = [];
     let isConfig = false;
     let isReadme = false;
+    let isUsage = false;
     const params = {};
     let returns = null;
     for (let index = 0; index < lines.length; index += 1) {
@@ -20,6 +22,10 @@ export function parseParadoxComment(rawComment) {
             isReadme = true;
             continue;
         }
+        if (trimmed.startsWith(USAGE_TAG)) {
+            isUsage = true;
+            continue;
+        }
         if (trimmed.startsWith('@example')) {
             const parsed = parseExample(lines, index);
             examples.push(parsed.example);
@@ -46,6 +52,7 @@ export function parseParadoxComment(rawComment) {
         description: description.length > 0 ? description : null,
         isConfig,
         isReadme,
+        isUsage,
         examples,
         params,
         returns,

package/dist/config/types.d.ts

@@ -9,6 +9,9 @@ export interface ParadoxConfig {
     docs?: {
         title?: string;
         description?: string;
+        usage?: {
+            entrypoints?: string[];
+        };
     };
     package?: {
         root?: string;

package/dist/doc-tags/registry.d.ts

@@ -1,10 +1,3 @@
-/***
- * Supported Paradox documentation tags.
- *
- * Paradox supports doc tags inside triple-star documentation comments.
- *
- * @readme
- */
 export declare const PARADOX_DOC_TAGS: readonly [{
     readonly name: "readme";
     readonly syntax: "@readme";
@@ -26,6 +19,13 @@ export declare const PARADOX_DOC_TAGS: readonly [{
     readonly appliesTo: readonly ["symbol"];
     readonly repeatable: true;
     readonly handler: "parseExample";
+}, {
+    readonly name: "usage";
+    readonly syntax: "@usage";
+    readonly description: "Promotes a real source example into the generated README Usage section.";
+    readonly appliesTo: readonly ["block", "symbol"];
+    readonly repeatable: false;
+    readonly handler: "markUsage";
 }];
 export type ParadoxDocTagName = (typeof PARADOX_DOC_TAGS)[number]['name'];
 export type ParadoxDocTagHandlerId = (typeof PARADOX_DOC_TAGS)[number]['handler'];

package/dist/doc-tags/registry.js

@@ -5,6 +5,8 @@
  *
  * @readme
  */
+const DOC_TAG_PREFIX = '\u0040';
+const USAGE_DOC_TAG = `${DOC_TAG_PREFIX}usage`;
 export const PARADOX_DOC_TAGS = [
     {
         name: 'readme',
@@ -30,6 +32,14 @@ export const PARADOX_DOC_TAGS = [
         repeatable: true,
         handler: 'parseExample',
     },
+    {
+        name: 'usage',
+        syntax: USAGE_DOC_TAG,
+        description: 'Promotes a real source example into the generated README Usage section.',
+        appliesTo: ['block', 'symbol'],
+        repeatable: false,
+        handler: 'markUsage',
+    },
 ];
 /***
  * Looks up documentation tag metadata by tag name.

package/dist/model/buildModel.d.ts

@@ -107,6 +107,13 @@ interface BuildModelInput {
             command: string;
         }[];
     } | null;
+    readmeUsage: {
+        title: string | null;
+        description: string | null;
+        language: string;
+        code: string;
+        sourcePath: string;
+    }[];
     config: {
         exportName: string;
         isReadme: boolean;

package/dist/model/buildModel.js

@@ -24,6 +24,15 @@ export function buildModel(analysis) {
                 }))),
             }
             : null,
+        readmeUsage: analysis.readmeUsage
+            .map((usageEntry) => ({
+            title: usageEntry.title,
+            description: usageEntry.description,
+            language: usageEntry.language,
+            code: usageEntry.code,
+            sourcePath: usageEntry.sourcePath,
+        }))
+            .sort((left, right) => left.sourcePath.localeCompare(right.sourcePath)),
         config: analysis.config !== null
             ? {
                 exportName: analysis.config.exportName,

package/dist/model/types.d.ts

@@ -7,6 +7,7 @@ export interface DocumentationModel {
     description: string | null;
     badges: GeneratedBadge[];
     usage: UsageModel | null;
+    readmeUsage: ReadmeUsageModel[];
     config: ConfigModel | null;
     entrypoints: string[];
     modules: ModuleModel[];
@@ -30,6 +31,13 @@ interface UsageCommandModel {
     name: string;
     command: string;
 }
+interface ReadmeUsageModel {
+    title: string | null;
+    description: string | null;
+    language: string;
+    code: string;
+    sourcePath: string;
+}
 interface ConfigModel {
     exportName: string;
     isReadme: boolean;

package/dist/render/renderers/markdown.js

@@ -21,26 +21,41 @@ function renderReadme(model, outputDir, badges, diagrams) {
             .map((badge) => `![${badgeLabel(model, badge.path)}](./${outputDir}/${badge.path})`)
             .join(' '), '');
     }
-    if (model.description) {
+    if (model.description)
         lines.push(model.description, '');
-    }
+    renderReadmeUsage(lines, model.readmeUsage);
     if (model.usage !== null) {
-        lines.push('## Installation', '');
-        lines.push('```bash');
-        for (const command of model.usage.commands) {
+        lines.push('## Installation', '', '```bash');
+        for (const command of model.usage.commands)
             lines.push(command.command);
-        }
         lines.push('```', '');
     }
     renderCliScenarios(lines, model, outputDir, diagrams);
-    if (model.config?.isReadme) {
+    if (model.config?.isReadme)
         renderConfiguration(lines, model);
-    }
     renderGeneratedDocumentation(lines, outputDir, diagrams);
-    renderArchitecturePreview(lines, diagrams);
     renderReadmeApi(lines, model);
     return `${lines.join('\n').trimEnd()}\n`;
 }
+function renderReadmeUsage(lines, entries) {
+    if (entries.length === 0)
+        return;
+    lines.push('## Usage', '');
+    for (const entry of entries) {
+        if (entry.title !== null)
+            lines.push(`### ${entry.title}`, '');
+        if (entry.description !== null) {
+            const [, ...rest] = entry.description.split('\n');
+            const description = rest.join('\n').trim();
+            if (description.length > 0)
+                lines.push(description, '');
+        }
+        lines.push(`Source: \`${entry.sourcePath}\``, '');
+        lines.push(`\`\`\`${entry.language}`);
+        lines.push(entry.code);
+        lines.push('```', '');
+    }
+}
 function renderCliScenarios(lines, model, outputDir, diagrams) {
     const scenarios = model.sequenceScenarios.filter((scenario) => scenario.kind === 'bin' && scenario.isReadme);
     if (scenarios.length === 0)
@@ -49,9 +64,8 @@ function renderCliScenarios(lines, model, outputDir, diagrams) {
     for (const scenario of scenarios) {
         lines.push('<details>');
         lines.push(`<summary>${scenario.name}</summary>`, '');
-        if (scenario.description !== null) {
+        if (scenario.description !== null)
             lines.push(scenario.description, '');
-        }
         const command = model.usage?.commands.find((item) => item.name === scenario.name);
         if (command !== undefined) {
             lines.push('```bash');
@@ -95,38 +109,26 @@ function renderConfiguration(lines, model) {
         lines.push('export default config;');
     }
     lines.push('```', '');
-    if (config.members.length > 0) {
-        lines.push('<details>');
-        lines.push('<summary>Configuration options</summary>', '');
-        lines.push('| Field | Type | Required | Default | Description |');
-        lines.push('| --- | --- | --- | --- | --- |');
-        for (const configMember of flattenConfigMembers(config.members)) {
-            lines.push(`| ${escapeTableCell(configMember.path)} | \`${escapeTableCell(configMember.type)}\` | ${configMember.required ? 'yes' : 'no'} | ${renderDefault(configMember.defaultValue)} | ${escapeTableCell(configMember.description ?? '')} |`);
-        }
-        lines.push('', '</details>', '');
+    if (config.members.length === 0)
+        return;
+    lines.push('<details>');
+    lines.push('<summary>Configuration options</summary>', '');
+    lines.push('| Field | Type | Required | Default | Description |');
+    lines.push('| --- | --- | --- | --- | --- |');
+    for (const configMember of flattenConfigMembers(config.members)) {
+        lines.push(`| ${escapeTableCell(configMember.path)} | \`${escapeTableCell(configMember.type)}\` | ${configMember.required ? 'yes' : 'no'} | ${renderDefault(configMember.defaultValue)} | ${escapeTableCell(configMember.description ?? '')} |`);
     }
+    lines.push('', '</details>', '');
 }
 function renderGeneratedDocumentation(lines, outputDir, diagrams) {
     lines.push('## Generated documentation', '');
     lines.push(`- [Interactive documentation app](./${outputDir}/index.html)`);
     lines.push(`- [Public API reference](./${outputDir}/exports.md)`);
     lines.push(`- [Component registry](./${outputDir}/components.md)`);
-    for (const diagram of diagrams) {
+    for (const diagram of diagrams)
         lines.push(`- [${diagram.title}](./${outputDir}/${diagram.path})`);
-    }
     lines.push('');
 }
-function renderArchitecturePreview(lines, diagrams) {
-    lines.push('## Architecture preview', '');
-    if (diagrams.length > 0) {
-        lines.push('<details>');
-        lines.push('<summary>Architecture overview</summary>', '');
-        lines.push('```mermaid');
-        lines.push(diagrams[0]?.content.trimEnd() ?? '');
-        lines.push('```', '');
-        lines.push('</details>', '');
-    }
-}
 function renderReadmeApi(lines, model) {
     const groups = getReadmeGroups(model);
     if (groups.length === 0)
@@ -135,12 +137,10 @@ function renderReadmeApi(lines, model) {
     for (const group of groups) {
         lines.push(`### ${group.title}`, '');
         for (const item of group.items) {
-            if (item.kind === 'component') {
+            if (item.kind === 'component')
                 renderComponentAccordion(lines, item.component, item.exportEntry);
-            }
-            else {
+            else
                 renderExportAccordion(lines, item.exportEntry);
-            }
         }
     }
 }
@@ -217,9 +217,8 @@ function renderStructuredRows(lines, item) {
 function getStructuredColumns(item) {
     const columns = new Set();
     for (const row of item.structuredRows) {
-        for (const column of Object.keys(row.values)) {
+        for (const column of Object.keys(row.values))
             columns.add(column);
-        }
     }
     return [...columns];
 }
@@ -228,9 +227,8 @@ function formatStructuredColumnHeader(column) {
 }
 function formatStructuredCell(column, value) {
     const escaped = escapeTableCell(value);
-    if (column === 'syntax' || column === 'name' || column === 'handler') {
+    if (column === 'syntax' || column === 'name' || column === 'handler')
         return `\`${escaped}\``;
-    }
     if (value === 'true')
         return 'yes';
     if (value === 'false')
@@ -302,9 +300,8 @@ function renderExports(model) {
         lines.push(`Kind: \`${item.kind}\``);
         lines.push(`Module: \`${item.modulePath}\``);
         lines.push(`Source: \`${item.sourceLocation.filePath}:${item.sourceLocation.line}:${item.sourceLocation.column}\``, '');
-        if (item.description) {
+        if (item.description)
             lines.push(item.description, '');
-        }
         renderStructuredRows(lines, item);
         if (item.signatures.length > 0) {
             lines.push('### Signatures', '');
@@ -334,9 +331,8 @@ function renderComponents(model) {
     for (const component of model.components) {
         lines.push(`## ${component.name}`, '');
         lines.push(`Source: \`${component.sourceLocation.filePath}:${component.sourceLocation.line}:${component.sourceLocation.column}\``, '');
-        if (component.description) {
+        if (component.description)
             lines.push(component.description, '');
-        }
         if (component.exportPaths.length > 0) {
             lines.push(`Export paths: ${component.exportPaths.map((path) => `\`${path}\``).join(', ')}`, '');
         }
@@ -373,9 +369,8 @@ function flattenConfigMembers(members, prefix = '') {
 }
 function badgeLabel(model, badgePath) {
     const fileName = badgePath.split('/').pop();
-    if (!fileName) {
+    if (!fileName)
         return badgePath;
-    }
     const id = fileName.replace(/\.svg$/, '');
     const badge = model.badges.find((entry) => entry.id === id);
     return badge ? `${badge.label}: ${badge.value}` : badgePath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ankhorage/paradox",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Deterministic documentation generator for TypeScript packages.",
   "license": "MIT",
   "publishConfig": {