@tsdoctor/model 0.1.0 → 0.2.0

package/index.d.ts

@@ -1,5 +1,139 @@
-import { ApiItem, ApiPackage, Excerpt } from "@microsoft/api-extractor-model";
+import { ApiClass, ApiInterface, ApiItem, ApiModel, ApiNamespace, ApiPackage, Excerpt } from "@microsoft/api-extractor-model";
+import { Effect, Schema } from "effect";
+import { FlowContent, MarkdownNode } from "@effected/markdown";
+import { PackageManifest } from "@effected/package-json";
 import { DocNode } from "@microsoft/tsdoc";
+declare namespace EntryPoints_d_exports {
+  export { ResolvedEntryItem, entryPointName, resolve };
+}
+/**
+ * A resolved API item with entry point metadata for deduplication.
+ *
+ * @public
+ */
+interface ResolvedEntryItem {
+  /** The API item from the model */
+  readonly item: ApiItem;
+  /** Which entry point defines this item (canonical owner) */
+  readonly definingEntryPoint: string;
+  /** All entry points that export this item (includes re-exports) */
+  readonly availableFrom: string[];
+}
+/**
+ * Derive an entry point name from its display name in the API model.
+ *
+ * - Empty string (main entry `.` in package.json) maps to `"default"`
+ * - Named entries (e.g. `"testing"`) keep their name
+ *
+ * @public
+ */
+declare function entryPointName(displayName: string): string;
+/**
+ * Resolve all entry points from an API package into a flat list of
+ * deduplicated items.
+ *
+ * - Re-exported items (same displayName + kind across entries) are
+ *   deduplicated to a single entry with `availableFrom` listing all
+ *   entry points. The defining entry point prefers `"default"`.
+ * - Items with different kinds but the same displayName (e.g. the
+ *   Effect const + type companion pattern) remain as separate entries.
+ *
+ * @param apiPackage - The merged API package with 1+ entry points
+ * @returns Flat array of resolved items
+ *
+ * @public
+ */
+declare function resolve(apiPackage: ApiPackage): ResolvedEntryItem[];
+declare namespace ApiItems_d_exports {
+  export { CategorizedItems, CategorySpec, Inheritance, NamespaceMember, SourceLinkTarget, categorize, inheritance, namespaceMembers, sourceLink };
+}
+/**
+ * The category rules `categorize` reads — a structural subset of a consumer's
+ * richer category config (display names, sidebar options, …), so those configs
+ * assign directly.
+ *
+ * @public
+ */
+interface CategorySpec {
+  /** API item kinds included in this category. */
+  readonly itemKinds?: ReadonlyArray<string> | undefined;
+  /** TSDoc modifier tag that marks items for this category (takes precedence). */
+  readonly tsdocModifier?: string | undefined;
+}
+/**
+ * The result of {@link categorize}: items grouped by category key, plus the
+ * items no category matched. Uncategorized items are returned as data — the
+ * caller decides whether to warn.
+ *
+ * @public
+ */
+interface CategorizedItems {
+  readonly items: Record<string, ApiItem[]>;
+  readonly uncategorized: ReadonlyArray<ApiItem>;
+}
+/**
+ * A member of a namespace with its parent namespace context.
+ *
+ * @public
+ */
+interface NamespaceMember {
+  /** The API item (class, interface, function, etc.) */
+  readonly item: ApiItem;
+  /** The parent namespace */
+  readonly namespace: ApiNamespace;
+  /** Qualified name including namespace prefix (e.g. `"MathUtils.Vector"`) */
+  readonly qualifiedName: string;
+}
+/**
+ * Inheritance information read off a class or interface declaration.
+ *
+ * @public
+ */
+interface Inheritance {
+  readonly extends?: ReadonlyArray<string>;
+  readonly implements?: ReadonlyArray<string>;
+}
+/**
+ * Repository target for {@link sourceLink} — framework-neutral shape a
+ * consumer's source config assigns to structurally.
+ *
+ * @public
+ */
+interface SourceLinkTarget {
+  /** Repository base URL, e.g. `"https://github.com/org/repo"`. */
+  readonly url: string;
+  /** Ref path segment appended to the URL. Defaults to `"blob/main"`. */
+  readonly ref?: string | undefined;
+}
+/**
+ * Group top-level API items into categories. A category's `tsdocModifier`
+ * takes precedence over its `itemKinds`; categories declaring a modifier are
+ * checked first. Items no category matches land in `uncategorized`.
+ *
+ * @public
+ */
+declare function categorize(source: ApiPackage | ReadonlyArray<ResolvedEntryItem>, categories: Record<string, CategorySpec>): CategorizedItems;
+/**
+ * Extract all members of top-level namespaces as a flat list with qualified
+ * names.
+ *
+ * @public
+ */
+declare function namespaceMembers(source: ApiPackage | ReadonlyArray<ResolvedEntryItem>): NamespaceMember[];
+/**
+ * Read extends/implements information from a class or interface declaration.
+ *
+ * @public
+ */
+declare function inheritance(item: ApiClass | ApiInterface): Inheritance;
+/**
+ * Build a source-code URL (with line number when available) for an API item,
+ * or `null` when no target or file path is known.
+ *
+ * @public
+ */
+declare function sourceLink(item: ApiItem, target?: SourceLinkTarget): string | null;
+//#endregion
 //#region src/types.d.ts
 /**
  * URL-stable slug for an item kind, used in routes and generated doc paths.
@@ -48,7 +182,7 @@ interface RenderedDoc extends DocMeta {
   readonly markdown: string;
 }
 /**
- * Options for {@link renderPackage}: the package name plus the optional injected
+ * Options for `Render.docs`: the package name plus the optional injected
  * route, frontmatter, and filter services.
  *
  * @public
@@ -63,68 +197,115 @@ interface RenderPackageOptions {
   /**
    * Predicate deciding whether a top-level item is emitted (and registered as a
    * crosslink target). Returns `true` to keep the item. Omit → the default rule
-   * {@link isEmittable} drops compiler-synthetic forgotten exports
-   * (`isExported === false`). Providing a filter fully replaces the default; compose
-   * with {@link isEmittable} to retain the forgotten-export drop.
+   * `Render.isEmittable` drops compiler-synthetic forgotten exports
+   * (`isExported === false`). Providing a filter fully replaces the default;
+   * compose with `Render.isEmittable` to retain the forgotten-export drop.
    */
   readonly filter?: (item: ApiItem) => boolean;
 }
 //#endregion
-//#region src/cross-linker.d.ts
+//#region src/CrossLinker.d.ts
 /**
- * Links known API item names in prose to their docs, using an injected
- * {@link RouteFormatter} so each consumer supplies its own URL scheme.
+ * Links known API item names in prose to their documentation routes. Matching
+ * is longest-name-first with word boundaries, skipping code spans and existing
+ * links.
  *
  * @public
  */
 declare class CrossLinker {
-  private readonly byName;
-  private readonly routeFor;
-  constructor(refs: ReadonlyArray<ApiItemRef>, routeFor: RouteFormatter);
+  private readonly routesByName;
+  /** Names sorted longest-first so "HookEvent" matches before "Hook". */
+  private readonly orderedNames;
+  private constructor();
+  /**
+   * Build from a precomputed name → route map (member anchors and qualified
+   * names already baked into the routes). The primary pipeline path.
+   */
+  static fromRoutes(routes: ReadonlyMap<string, string>): CrossLinker;
+  /**
+   * Build from item refs plus an injected {@link RouteFormatter}, so each
+   * consumer supplies its own URL scheme. Routes are evaluated eagerly at
+   * construction.
+   */
+  static fromRefs(refs: ReadonlyArray<ApiItemRef>, routeFor: RouteFormatter): CrossLinker;
+  /** The identity cross-linker: `link(text)` returns `text` unchanged. */
+  static readonly empty: CrossLinker;
   /** Wrap known item names in markdown links, skipping code spans + existing links. */
-  addLinks(text: string): string;
+  link(text: string): string;
+  /**
+   * Wrap known item names in HTML `<a>` anchors — for text rendered as HTML
+   * rather than markdown. Skips matches inside an open `<a>` tag.
+   */
+  linkHtml(text: string): string;
 }
-//#endregion
-//#region src/formatter.d.ts
+declare namespace Model_d_exports {
+  export { EmptyModelError, ModelNotFoundError, ModelParseError, firstPackage, load };
+}
+declare const ModelNotFoundError_base: Schema.Class<ModelNotFoundError, Schema.TaggedStruct<"ModelNotFoundError", {
+  readonly modelPath: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 /**
- * Formats an API Extractor `Excerpt` into a clean, line-wrapped type signature string.
+ * The `.api.json` file does not exist at the resolved path.
  *
  * @public
  */
-declare class TypeSignatureFormatter {
-  private readonly maxLineLength;
-  private readonly indent;
-  constructor(opts?: {
-    maxLineLength?: number;
-    indent?: string;
-  });
-  format(excerpt: Excerpt): string;
-  private stripExportDeclare;
-  private needsSpaceBefore;
+declare class ModelNotFoundError extends ModelNotFoundError_base {
+  get message(): string;
 }
-//#endregion
-//#region src/model-loader.d.ts
+declare const ModelParseError_base: Schema.Class<ModelParseError, Schema.TaggedStruct<"ModelParseError", {
+  readonly modelPath: Schema.String;
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 /**
- * Load a `.api.json` model file and return its first (only) package.
+ * The `.api.json` file exists but could not be deserialized (malformed JSON,
+ * unsupported schema version, …). `reason` carries the deserializer's message.
  *
  * @public
  */
-declare function loadApiModel(modelPath: string): Promise<ApiPackage>;
-//#endregion
-//#region src/render.d.ts
+declare class ModelParseError extends ModelParseError_base {
+  get message(): string;
+}
+declare const EmptyModelError_base: Schema.Class<EmptyModelError, Schema.TaggedStruct<"EmptyModelError", {
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 /**
- * The default emit rule for {@link renderPackage}: drop compiler-synthetic
- * forgotten exports — items the model retains only because API Extractor ran with
- * `includeForgottenExports: true` (e.g. the `*_base` classes TypeScript hoists for
- * Effect class mixins). Those carry `isExported === false` on `ApiExportedMixin`.
- * Every other item, including any lacking the flag, is kept.
+ * An in-memory `ApiModel` carries no packages (or is otherwise unusable).
+ *
+ * @public
+ */
+declare class EmptyModelError extends EmptyModelError_base {
+  get message(): string;
+}
+/**
+ * Load a `.api.json` model file and return its single `ApiPackage`.
+ *
+ * @public
+ */
+declare const load: (modelPath: string) => Effect.Effect<ApiPackage, ModelNotFoundError | ModelParseError>;
+/**
+ * Extract the first (only) package from an already-constructed `ApiModel` —
+ * the user-supplied-loader path, where the caller obtained the model itself.
+ *
+ * @public
+ */
+declare const firstPackage: (model: ApiModel) => Effect.Effect<ApiPackage, EmptyModelError>;
+declare namespace Render_d_exports {
+  export { RenderItemOptions, docs, isEmittable, item, tree };
+}
+/**
+ * The default emit rule for {@link docs}: drop compiler-synthetic forgotten
+ * exports — items the model retains only because API Extractor ran with
+ * `includeForgottenExports: true` (e.g. the `*_base` classes TypeScript hoists
+ * for Effect class mixins). Those carry `isExported === false` on
+ * `ApiExportedMixin`. Every other item, including any lacking the flag, is
+ * kept.
  *
  * @public
  */
 declare const isEmittable: (item: ApiItem) => boolean;
 /**
- * Options for {@link renderItem}: the package name used in fallbacks and an
- * optional crosslinker applied to the rendered prose.
+ * Options for {@link item} and {@link tree}: the package name used in
+ * fallbacks and an optional crosslinker applied to the rendered prose.
  *
  * @public
  */
@@ -134,78 +315,308 @@ interface RenderItemOptions {
   readonly crossLinker?: CrossLinker;
 }
 /**
- * Render one API item to a markdown body (no frontmatter).
+ * Render one API item's markdown body as flow nodes — the pre-serialization
+ * form of {@link item}.
+ *
+ * @alpha
+ */
+declare function tree(apiItem: ApiItem, opts: RenderItemOptions): ReadonlyArray<FlowContent>;
+/**
+ * Render one API item to a markdown body string (no frontmatter).
  *
  * @public
  */
-declare function renderItem(item: ApiItem, opts: RenderItemOptions): string;
+declare function item(apiItem: ApiItem, opts: RenderItemOptions): string;
 /**
- * Walk a package's first entry point and assemble one RenderedDoc per top-level member.
+ * Walk a package's first entry point and assemble one RenderedDoc per
+ * top-level member.
  *
  * @public
  */
-declare function renderPackage(apiPackage: ApiPackage, opts: RenderPackageOptions): RenderedDoc[];
-//#endregion
-//#region src/tsdoc.d.ts
+declare function docs(apiPackage: ApiPackage, opts: RenderPackageOptions): RenderedDoc[];
+declare namespace Routes_d_exports {
+  export { RouteCandidate, RouteCollision, RouteCollisionError, detectCollisions, sanitizeId };
+}
+declare const RouteCandidate_base: Schema.Class<RouteCandidate, Schema.Struct<{
+  /** Stable identity (e.g. `"displayName::kind"` or a namespace qualified name). */
+  readonly id: Schema.String;
+  /** Human-readable name for error messages (original, non-lowercased). */
+  readonly displayName: Schema.String;
+  /** Category folder name, e.g. `"variable"`. */
+  readonly folder: Schema.String;
+  /** Lowercased sanitized last path segment, e.g. `"foo"` — the value used in the route. */
+  readonly baseName: Schema.String;
+  /** API item kind string, e.g. `"Variable"`. */
+  readonly kind: Schema.String;
+  /** canonicalReference string, used for deterministic ordering. */
+  readonly canonicalRef: Schema.String;
+}>, {}>;
+/**
+ * A candidate output route for collision detection. All-string and
+ * serializable — candidates cross the error boundary inside
+ * {@link RouteCollisionError} and may be persisted by consumer diagnostics.
+ *
+ * @public
+ */
+declare class RouteCandidate extends RouteCandidate_base {}
 /**
- * Recursively flatten a TSDoc DocNode tree to plain text (code spans → backticks).
+ * A set of distinct items that resolve to the same output route.
  *
  * @public
  */
-declare function extractPlainText(node: DocNode): string;
+interface RouteCollision {
+  /** The shared route key: `${folder}/${baseName}`. */
+  readonly route: string;
+  /** The distinct candidates that resolve to it (two or more). */
+  readonly items: ReadonlyArray<RouteCandidate>;
+}
+/**
+ * Group candidates by their final route (`${folder}/${baseName}`) and return
+ * the groups with more than one distinct item. The route key is the lowercased
+ * path the file is written to, so detection matches generation (and what a
+ * case-insensitive filesystem would merge). Companion pairs (same name,
+ * different folders) land under different keys and are never collisions.
+ *
+ * Output is deterministic: collisions ordered by route, items within a
+ * collision ordered by canonicalReference.
+ *
+ * @public
+ */
+declare function detectCollisions(candidates: ReadonlyArray<RouteCandidate>): RouteCollision[];
+declare const RouteCollisionError_base: Schema.Class<RouteCollisionError, Schema.TaggedStruct<"RouteCollisionError", {
+  readonly baseRoute: Schema.String;
+  readonly collisions: Schema.$Array<Schema.Struct<{
+    readonly route: Schema.String;
+    readonly items: Schema.$Array<typeof RouteCandidate>;
+  }>>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Two or more distinct API items resolve to the same documentation route — a
+ * naming or category-configuration problem the build must fail on. The
+ * `message` names every colliding item with its kind and canonical reference,
+ * plus remediation guidance.
+ *
+ * @public
+ */
+declare class RouteCollisionError extends RouteCollisionError_base {
+  get message(): string;
+}
+/**
+ * Sanitize a display name into a valid HTML anchor id: lowercase,
+ * spaces/underscores → hyphens, other specials stripped, optional prefix for
+ * disambiguation. The ONE canonical implementation — anchor generation and
+ * cross-link routes must agree on it by construction.
+ *
+ * @public
+ */
+declare function sanitizeId(displayName: string, prefix?: string): string;
+declare namespace Signature_d_exports {
+  export { FormatOptions, format, linkReferences, stripExportDeclare };
+}
+/**
+ * Options for {@link format}.
+ *
+ * @public
+ */
+interface FormatOptions {
+  /** Wrap long union/intersection lines beyond this length. Default 80. */
+  readonly maxLineLength?: number;
+  /** Continuation-line indent. Default two spaces. */
+  readonly indent?: string;
+}
+/**
+ * Strip `export` / `declare` modifiers from a declaration text.
+ *
+ * @public
+ */
+declare function stripExportDeclare(text: string): string;
+/**
+ * Format an API Extractor `Excerpt` into a clean type signature string,
+ * wrapping long top-level unions/intersections.
+ *
+ * @public
+ */
+declare function format(excerpt: Excerpt, options?: FormatOptions): string;
+/**
+ * Inject markdown cross-links into already-formatted signature text. Reference
+ * tokens in the excerpt whose canonical reference appears in
+ * `routesByCanonicalRef` have their display text wrapped in a markdown link.
+ *
+ * @public
+ */
+declare function linkReferences(text: string, excerpt: Excerpt, routesByCanonicalRef: ReadonlyMap<string, string>): string;
+declare namespace StructuredData_d_exports {
+  export { StructuredDataGraph, derive };
+}
+/**
+ * A schema.org JSON-LD graph.
+ *
+ * @alpha
+ */
+interface StructuredDataGraph {
+  readonly "@context": "https://schema.org";
+  readonly "@graph": ReadonlyArray<Record<string, unknown>>;
+}
+/**
+ * Derive schema.org structured data for a documented package.
+ *
+ * @remarks
+ * Not implemented yet — this is the phase-4 seam. Calling it throws.
+ *
+ * @alpha
+ */
+declare function derive(_apiPackage: ApiPackage, _manifest: PackageManifest): StructuredDataGraph;
+declare namespace SyntheticBases_d_exports {
+  export { BASE_CLASS_ANCHOR, SyntheticBase, SyntheticBaseDetection, detect };
+}
+/**
+ * Anchor id of the inline "Base Class" section rendered on the owner class
+ * page. Must match the slug RSPress derives from the `## Base Class` heading
+ * emitted by the owner-class page.
+ *
+ * @public
+ */
+declare const BASE_CLASS_ANCHOR = "base-class";
 /**
- * The TSDoc `@summary` section as a single cleaned line.
+ * A synthetic base declaration: an unexported item that API Extractor hoisted
+ * into the model (via `includeForgottenExports`) because an exported class's
+ * extends clause references it.
+ *
+ * TypeScript emits these for classes extending a call expression — e.g. the
+ * Effect `Schema.Class`/`Data.TaggedError` patterns or mixin factories — as
+ * `declare const Foo_base: ...; class Foo extends Foo_base {}`.
+ *
+ * @public
+ */
+interface SyntheticBase {
+  /** The unexported supporting declaration (usually a Variable). */
+  readonly baseItem: ApiItem;
+  /** Classes whose extends clause references this declaration, in model order. */
+  readonly ownerClasses: readonly ApiClass[];
+}
+/**
+ * The result of {@link detect}.
+ *
+ * @public
+ */
+interface SyntheticBaseDetection {
+  /** Detected base declarations, keyed by the base ApiItem (identity). */
+  readonly bases: ReadonlyMap<ApiItem, SyntheticBase>;
+  /** Owner class -> its synthetic base declaration (identity keys). */
+  readonly baseByOwner: ReadonlyMap<ApiItem, ApiItem>;
+}
+/**
+ * Detect synthetic base declarations among top-level API items.
+ *
+ * An item qualifies when it is unexported (hoisted into the model only because
+ * something references it) AND at least one class's extends clause references
+ * its canonical symbol. Unexported items with no class referencing them
+ * (genuine forgotten exports) are left alone, as are extends references whose
+ * target is absent from the model.
  *
  * @public
  */
-declare function getSummary(item: ApiItem): string;
+declare function detect(items: readonly ApiItem[]): SyntheticBaseDetection;
+declare namespace Tsdoc_d_exports {
+  export { DocExample, DocParam, ReleaseTagName, deprecation, examples, hasModifier, params, plainText, releaseTag, returns, seeReferences, summary, toMarkdown };
+}
+/**
+ * One documented parameter: the `@param` block merged with the declared type.
+ *
+ * @public
+ */
+interface DocParam {
+  readonly name: string;
+  readonly type?: string;
+  readonly description: string;
+}
+/**
+ * One `@example` block's code (language defaults to `typescript`).
+ *
+ * @public
+ */
+interface DocExample {
+  readonly language: string;
+  readonly code: string;
+}
+/**
+ * TSDoc release tag names, with `"Public"` as the absent-tag default.
+ *
+ * @public
+ */
+type ReleaseTagName = "Public" | "Beta" | "Alpha" | "Internal";
+/**
+ * Recursively flatten a TSDoc DocNode tree to plain text (code spans →
+ * backticks, `{@link}` → display text, code fences dropped).
+ *
+ * @public
+ */
+declare function plainText(node: DocNode): string;
+/**
+ * Convert a TSDoc DocNode tree to markdown nodes, preserving structure the
+ * plain-text flattener drops: code spans become {@link InlineCode}, url
+ * `{@link}` tags become {@link Link} nodes, fenced code becomes {@link Code}
+ * blocks. Code-destination `{@link}` tags (declaration references) flatten to
+ * their display text — resolving them to URLs is the caller's cross-linking
+ * concern, not this layer's.
+ *
+ * @public
+ */
+declare function toMarkdown(node: DocNode): ReadonlyArray<MarkdownNode>;
+/**
+ * The TSDoc summary section as a single cleaned line.
+ *
+ * @public
+ */
+declare function summary(item: ApiItem): string;
 /**
  * `@param` blocks merged with parameter types from the declaration excerpt.
  *
  * @public
  */
-declare function getParams(item: ApiItem): Array<{
-  name: string;
-  type?: string;
-  description: string;
-}>;
+declare function params(item: ApiItem): ReadonlyArray<DocParam>;
 /**
  * The `@returns` block description, if present.
  *
  * @public
  */
-declare function getReturns(item: ApiItem): {
-  description: string;
+declare function returns(item: ApiItem): {
+  readonly description: string;
 } | null;
 /**
  * All `@example` fenced-code blocks (falls back to plain text).
  *
  * @public
  */
-declare function getExamples(item: ApiItem): Array<{
-  language: string;
-  code: string;
-}>;
+declare function examples(item: ApiItem): ReadonlyArray<DocExample>;
 /**
- * Reads the deprecation-block message from an ApiItem, if one is present.
+ * The deprecation-block message, if one is present.
  *
  * @public
  */
-declare function getDeprecation(item: ApiItem): {
-  message: string;
+declare function deprecation(item: ApiItem): {
+  readonly message: string;
 } | null;
 /**
- * The release tag (Public/Beta/Alpha/Internal) or "Public" when absent.
+ * The release tag (Public/Beta/Alpha/Internal), `"Public"` when absent.
  *
  * @public
  */
-declare function getReleaseTag(item: ApiItem): string;
+declare function releaseTag(item: ApiItem): ReleaseTagName;
 /**
  * True when the item carries the given TSDoc modifier tag (without the `@`).
  *
  * @public
  */
-declare function hasModifierTag(item: ApiItem, tagName: string): boolean;
+declare function hasModifier(item: ApiItem, tagName: string): boolean;
+/**
+ * `@see` block contents, flattened to prose (whitespace-normalized).
+ *
+ * @public
+ */
+declare function seeReferences(item: ApiItem): ReadonlyArray<{
+  readonly text: string;
+}>;
 //#endregion
-export { type ApiItemRef, CrossLinker, type DocMeta, type FrontmatterRenderer, type ItemKindSlug, type RenderItemOptions, type RenderPackageOptions, type RenderedDoc, type RouteFormatter, TypeSignatureFormatter, extractPlainText, getDeprecation, getExamples, getParams, getReleaseTag, getReturns, getSummary, hasModifierTag, isEmittable, loadApiModel, renderItem, renderPackage };
+export { type ApiItemRef, ApiItems_d_exports as ApiItems, CrossLinker, type DocMeta, EntryPoints_d_exports as EntryPoints, type FrontmatterRenderer, type ItemKindSlug, Model_d_exports as Model, Render_d_exports as Render, type RenderPackageOptions, type RenderedDoc, type RouteFormatter, Routes_d_exports as Routes, Signature_d_exports as Signature, StructuredData_d_exports as StructuredData, SyntheticBases_d_exports as SyntheticBases, Tsdoc_d_exports as Tsdoc };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,7 +1,12 @@
-import { CrossLinker } from "./cross-linker.js";
-import { TypeSignatureFormatter } from "./formatter.js";
-import { loadApiModel } from "./model-loader.js";
-import { extractPlainText, getDeprecation, getExamples, getParams, getReleaseTag, getReturns, getSummary, hasModifierTag } from "./tsdoc.js";
-import { isEmittable, renderItem, renderPackage } from "./render.js";
+import { Tsdoc_exports } from "./Tsdoc.js";
+import { ApiItems_exports } from "./ApiItems.js";
+import { CrossLinker } from "./CrossLinker.js";
+import { EntryPoints_exports } from "./EntryPoints.js";
+import { Model_exports } from "./Model.js";
+import { Signature_exports } from "./Signature.js";
+import { Render_exports } from "./Render.js";
+import { Routes_exports } from "./Routes.js";
+import { StructuredData_exports } from "./StructuredData.js";
+import { SyntheticBases_exports } from "./SyntheticBases.js";
 
-export { CrossLinker, TypeSignatureFormatter, extractPlainText, getDeprecation, getExamples, getParams, getReleaseTag, getReturns, getSummary, hasModifierTag, isEmittable, loadApiModel, renderItem, renderPackage };
+export { ApiItems_exports as ApiItems, CrossLinker, EntryPoints_exports as EntryPoints, Model_exports as Model, Render_exports as Render, Routes_exports as Routes, Signature_exports as Signature, StructuredData_exports as StructuredData, SyntheticBases_exports as SyntheticBases, Tsdoc_exports as Tsdoc };

package/internal/prose.js

@@ -0,0 +1,20 @@
+import { Markdown, Paragraph, Text } from "@effected/markdown";
+import { Result } from "effect";
+
+//#region src/internal/prose.ts
+/**
+* Parse a single-line markdown prose string into phrasing nodes. Multiple
+* paragraphs collapse into one phrasing run (prose from TSDoc extraction is
+* whitespace-normalized single-line text). Falls back to a literal Text node
+* when the string does not parse.
+*/
+const phrasingFromMarkdown = (prose) => {
+	const parsed = Markdown.parseResult(prose);
+	if (Result.isFailure(parsed)) return [new Text({ value: prose })];
+	const phrasing = [];
+	for (const child of parsed.success.children) if (child instanceof Paragraph) phrasing.push(...child.children);
+	return phrasing.length > 0 ? phrasing : [new Text({ value: prose })];
+};
+
+//#endregion
+export { phrasingFromMarkdown };