rspress-plugin-api-extractor 0.8.9 → 0.9.0

package/content-hash.js

@@ -1,79 +0,0 @@
-import { createHash } from "node:crypto";
-
-//#region src/content-hash.ts
-/**
-* Normalizes content string for consistent hashing.
-*
-* Applies the following transformations:
-* - Converts all line endings to Unix-style (`\n`)
-* - Trims leading and trailing whitespace
-* - Collapses multiple consecutive blank lines to a single blank line
-*
-* @param content - The content string to normalize
-* @returns Normalized content string
-*
-* @example
-* ```typescript
-* const normalized = normalizeContent("line1\r\n\r\n\r\nline2  ");
-* // Returns: "line1\n\nline2"
-* ```
-*/
-function normalizeContent(content) {
-	return content.replaceAll("\r\n", "\n").replaceAll("\r", "\n").trim().replaceAll(/\n{3,}/g, "\n\n");
-}
-/**
-* Generates a SHA-256 hash of normalized markdown content.
-*
-* The content is normalized before hashing to ensure consistent results
-* regardless of line ending differences or trailing whitespace.
-*
-* @param content - The markdown content to hash (excluding frontmatter)
-* @returns Hexadecimal SHA-256 hash string
-*
-* @example
-* ```typescript
-* const hash = hashContent("# My Title\n\nContent here");
-* ```
-*/
-function hashContent(content) {
-	const normalized = normalizeContent(content);
-	return createHash("sha256").update(normalized).digest("hex");
-}
-/**
-* Generates a SHA-256 hash of frontmatter fields.
-*
-* Excludes timestamp-related fields (`publishedTime`, `modifiedTime`, `head`,
-* `article:published_time`, `article:modified_time`) to prevent circular
-* dependencies in change detection.
-*
-* @param frontmatter - The frontmatter object to hash
-* @returns Hexadecimal SHA-256 hash string
-*
-* @remarks
-* Keys are sorted alphabetically before hashing to ensure consistent
-* results regardless of object key order.
-*
-* @example
-* ```typescript
-* const hash = hashFrontmatter({
-*   title: "My Page",
-*   description: "Page description"
-* });
-* ```
-*/
-function hashFrontmatter(frontmatter) {
-	const filtered = {};
-	for (const [key, value] of Object.entries(frontmatter)) {
-		if (key === "publishedTime" || key === "modifiedTime" || key === "head" || key === "article:published_time" || key === "article:modified_time") continue;
-		filtered[key] = value;
-	}
-	const sorted = Object.keys(filtered).sort().reduce((acc, key) => {
-		acc[key] = filtered[key];
-		return acc;
-	}, {});
-	const json = JSON.stringify(sorted);
-	return createHash("sha256").update(json).digest("hex");
-}
-
-//#endregion
-export { hashContent, hashFrontmatter, normalizeContent };

package/formatter.js

@@ -1,69 +0,0 @@
-import { TypeSignatureFormatter } from "@tsdoctor/model";
-
-//#region src/formatter.ts
-/**
-* Formats TypeScript type signatures for display in documentation.
-*
-* Transforms raw API Extractor excerpt text into clean, readable signatures.
-* The core {@link TypeSignatureFormatter.format | format} algorithm is
-* inherited from the `api-extractor-llms` `TypeSignatureFormatter`; this
-* subclass adds the positional constructor and the test-only
-* {@link TypeSignatureFormatter.addLinks | addLinks} cross-link injection.
-*
-* **Relationships:**
-* - Used by all page generators ({@link ClassPageGenerator}, etc.)
-* - Works with API Extractor's `Excerpt` model
-* - Can integrate with {@link MarkdownCrossLinker} for type linking
-*
-* @example
-* ```ts
-* const formatter = new TypeSignatureFormatter();
-*
-* // Format a simple signature
-* const signature = formatter.format(apiFunction.excerpt);
-* // "function myFunc(arg: string): Promise<void>"
-*
-* // With cross-linking
-* const linked = formatter.addLinks(signature, excerpt);
-* // "function myFunc(arg: string): Promise<[MyType](/api/types/mytype)>"
-* ```
-*/
-var TypeSignatureFormatter$1 = class extends TypeSignatureFormatter {
-	apiItemRoutes;
-	constructor(maxLineLength = 80, indent = "  ", apiItemRoutes) {
-		super({
-			maxLineLength,
-			indent
-		});
-		this.apiItemRoutes = apiItemRoutes;
-	}
-	/**
-	* Inject markdown cross-links into already-formatted signature text.
-	*
-	* A lower-level escape hatch kept for callers that want link injection at
-	* the formatter level; the build pipeline normally cross-links prose via
-	* MarkdownCrossLinker instead. The shared library's formatter has no
-	* equivalent, so this stays plugin-local. Covered by formatter.test.ts.
-	*/
-	addLinks(text, excerpt) {
-		if (!excerpt.spannedTokens || !this.apiItemRoutes) return text;
-		const typeReferences = /* @__PURE__ */ new Map();
-		for (const token of excerpt.spannedTokens) if (token.kind === "Reference" && token.canonicalReference) {
-			const canonicalRef = token.canonicalReference.toString();
-			const route = this.apiItemRoutes.get(canonicalRef);
-			if (route && token.text) typeReferences.set(token.text.trim(), route);
-		}
-		let result = text;
-		for (const [typeName, route] of typeReferences.entries()) {
-			const regex = new RegExp(`\\b${this.escapeRegExp(typeName)}\\b`, "g");
-			result = result.replace(regex, `[${typeName}](${route})`);
-		}
-		return result;
-	}
-	escapeRegExp(string) {
-		return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-	}
-};
-
-//#endregion
-export { TypeSignatureFormatter$1 as TypeSignatureFormatter };

package/layers/SnapshotServiceLive.js

@@ -1,92 +0,0 @@
-import { hashContent } from "../content-hash.js";
-import { SnapshotService } from "../services/SnapshotService.js";
-import { SnapshotDbError } from "../errors.js";
-import migration from "../migrations/001_create_snapshots.js";
-import { Effect, Layer, Option } from "effect";
-import { SqliteClient, SqliteMigrator } from "@effect/sql-sqlite-node";
-import { Migrator, SqlClient } from "effect/unstable/sql";
-
-//#region src/layers/SnapshotServiceLive.ts
-function toFileSnapshot(row) {
-	return {
-		outputDir: row.output_dir,
-		filePath: row.file_path,
-		publishedTime: row.published_time,
-		modifiedTime: row.modified_time,
-		contentHash: row.content_hash,
-		frontmatterHash: row.frontmatter_hash,
-		buildTime: row.build_time
-	};
-}
-function toSnapshotDbError(error) {
-	return new SnapshotDbError({
-		operation: "query",
-		dbPath: "snapshot-db",
-		reason: error instanceof Error ? error.message : String(error)
-	});
-}
-const SnapshotServiceLive = (dbPath) => {
-	const SqlLive = SqliteClient.layer({ filename: dbPath });
-	const MigratorLive = SqliteMigrator.layer({ loader: Migrator.fromRecord({ "001_create_snapshots": migration }) }).pipe(Layer.provide(SqlLive));
-	const ServiceImpl = Layer.effect(SnapshotService, Effect.gen(function* () {
-		const sql = yield* SqlClient.SqlClient;
-		yield* Effect.addFinalizer(() => sql`PRAGMA wal_checkpoint(TRUNCATE)`.pipe(Effect.ignore));
-		return {
-			hashContent,
-			getSnapshot: (outputDir, filePath) => sql`SELECT * FROM file_snapshots WHERE output_dir = ${outputDir} AND file_path = ${filePath}`.pipe(Effect.map((rows) => rows.length > 0 ? Option.some(toFileSnapshot(rows[0])) : Option.none()), Effect.mapError(toSnapshotDbError)),
-			getAllForDirectory: (outputDir) => sql`SELECT * FROM file_snapshots WHERE output_dir = ${outputDir}`.pipe(Effect.map((rows) => rows.map(toFileSnapshot)), Effect.mapError(toSnapshotDbError)),
-			getFilePaths: (outputDir) => sql`SELECT file_path FROM file_snapshots WHERE output_dir = ${outputDir}`.pipe(Effect.map((rows) => rows.map((r) => r.file_path)), Effect.mapError(toSnapshotDbError)),
-			upsert: (snapshot) => sql`INSERT INTO file_snapshots
-						(output_dir, file_path, published_time, modified_time,
-						 content_hash, frontmatter_hash, build_time)
-						VALUES (${snapshot.outputDir}, ${snapshot.filePath},
-								${snapshot.publishedTime}, ${snapshot.modifiedTime},
-								${snapshot.contentHash}, ${snapshot.frontmatterHash},
-								${snapshot.buildTime})
-						ON CONFLICT(output_dir, file_path) DO UPDATE SET
-							published_time = ${snapshot.publishedTime},
-							modified_time = ${snapshot.modifiedTime},
-							content_hash = ${snapshot.contentHash},
-							frontmatter_hash = ${snapshot.frontmatterHash},
-							build_time = ${snapshot.buildTime}
-						WHERE published_time != ${snapshot.publishedTime}
-						   OR modified_time != ${snapshot.modifiedTime}
-						   OR content_hash != ${snapshot.contentHash}
-						   OR frontmatter_hash != ${snapshot.frontmatterHash}`.pipe(Effect.as(true), Effect.mapError(toSnapshotDbError)),
-			batchUpsert: (snapshots) => (snapshots.length === 0 ? Effect.succeed(0) : sql.withTransaction(Effect.forEach(snapshots, (s) => sql`INSERT INTO file_snapshots
-												(output_dir, file_path, published_time, modified_time,
-												 content_hash, frontmatter_hash, build_time)
-												VALUES (${s.outputDir}, ${s.filePath},
-														${s.publishedTime}, ${s.modifiedTime},
-														${s.contentHash}, ${s.frontmatterHash},
-														${s.buildTime})
-												ON CONFLICT(output_dir, file_path) DO UPDATE SET
-													published_time = ${s.publishedTime},
-													modified_time = ${s.modifiedTime},
-													content_hash = ${s.contentHash},
-													frontmatter_hash = ${s.frontmatterHash},
-													build_time = ${s.buildTime}
-												WHERE published_time != ${s.publishedTime}
-												   OR modified_time != ${s.modifiedTime}
-												   OR content_hash != ${s.contentHash}
-												   OR frontmatter_hash != ${s.frontmatterHash}`, { concurrency: 1 })).pipe(Effect.map(() => snapshots.length))).pipe(Effect.mapError(toSnapshotDbError)),
-			deleteSnapshot: (outputDir, filePath) => sql`DELETE FROM file_snapshots WHERE output_dir = ${outputDir} AND file_path = ${filePath}`.pipe(Effect.asVoid, Effect.mapError(toSnapshotDbError)),
-			cleanupStale: (outputDir, currentFiles) => Effect.gen(function* () {
-				const rows = yield* sql`SELECT file_path FROM file_snapshots WHERE output_dir = ${outputDir}`;
-				const staleFiles = [];
-				for (const row of rows) {
-					const fp = row.file_path;
-					if (!currentFiles.has(fp)) {
-						yield* sql`DELETE FROM file_snapshots WHERE output_dir = ${outputDir} AND file_path = ${fp}`;
-						staleFiles.push(fp);
-					}
-				}
-				return staleFiles;
-			}).pipe(Effect.mapError(toSnapshotDbError))
-		};
-	}));
-	return Layer.provide(ServiceImpl, Layer.merge(SqlLive, MigratorLive));
-};
-
-//#endregion
-export { SnapshotServiceLive };

package/loader.js

@@ -1,200 +0,0 @@
-import { PluginEvent } from "./observability/events.js";
-import { ApiDocumentedItem, ApiItemKind } from "@microsoft/api-extractor-model";
-import { extractPlainText, getDeprecation, getExamples, getParams, getReleaseTag, getReturns, getSummary, hasModifierTag } from "@tsdoctor/model";
-
-//#region src/loader.ts
-/** Module-level emitter injected by plugin.ts at startup. */
-let emitEvent = () => {};
-let currentBuildId = "";
-function setLoaderEventEmitter(fn, buildId = "") {
-	emitEvent = fn;
-	currentBuildId = buildId;
-}
-/**
-* Parser for extracting and analyzing information from API Extractor models and TSDoc comments
-*/
-var ApiParser = class ApiParser {
-	/**
-	* Private constructor to prevent instantiation
-	*/
-	constructor() {}
-	/**
-	* Check if an API item has a custom modifier tag
-	*/
-	static hasModifierTag(item, tagName) {
-		return hasModifierTag(item, tagName);
-	}
-	/**
-	* Extract all API items from a package (or resolved entry items) and categorize them based on configuration.
-	*
-	* When passed a `ResolvedEntryItem[]`, uses the items directly (multi-entry support).
-	* When passed an `ApiPackage`, reads from `entryPoints[0]` (legacy single-entry behavior).
-	*/
-	static categorizeApiItems(source, categories) {
-		const items = {};
-		for (const categoryKey of Object.keys(categories)) items[categoryKey] = [];
-		let members;
-		if (Array.isArray(source)) members = source.map((r) => r.item);
-		else {
-			const entryPoint = source.entryPoints[0];
-			if (!entryPoint) return items;
-			members = entryPoint.members;
-		}
-		const sortedCategories = Object.entries(categories).sort((a, b) => {
-			const [, configA] = a;
-			const [, configB] = b;
-			if (configA.tsdocModifier && !configB.tsdocModifier) return -1;
-			if (!configA.tsdocModifier && configB.tsdocModifier) return 1;
-			return 0;
-		});
-		for (const member of members) {
-			let categorized = false;
-			for (const [categoryKey, config] of sortedCategories) {
-				if (config.tsdocModifier && ApiParser.hasModifierTag(member, config.tsdocModifier)) {
-					items[categoryKey].push(member);
-					categorized = true;
-					break;
-				}
-				if (config.itemKinds?.includes(member.kind)) {
-					items[categoryKey].push(member);
-					categorized = true;
-					break;
-				}
-			}
-			if (!categorized && typeof process !== "undefined" && !process.env.VITEST) emitEvent(PluginEvent.ItemSkipped({
-				ctx: { buildId: currentBuildId },
-				item: member.displayName,
-				kind: String(member.kind),
-				reason: "uncategorized",
-				level: "warn"
-			}));
-		}
-		return items;
-	}
-	/**
-	* Extract all members from namespaces in a package (or resolved entry items).
-	* Returns a flat list of namespace members with their qualified names.
-	*
-	* When passed a `ResolvedEntryItem[]`, scans those items for namespaces (multi-entry support).
-	* When passed an `ApiPackage`, reads from `entryPoints[0]` (legacy single-entry behavior).
-	*
-	* @param source - The API package or resolved entry items to extract from
-	* @returns Array of namespace members with qualified names
-	*/
-	static extractNamespaceMembers(source) {
-		const members = [];
-		let topLevelItems;
-		if (Array.isArray(source)) topLevelItems = source.map((r) => r.item);
-		else {
-			const entryPoint = source.entryPoints[0];
-			if (!entryPoint) return members;
-			topLevelItems = entryPoint.members;
-		}
-		for (const item of topLevelItems) if (item.kind === ApiItemKind.Namespace) {
-			const namespace = item;
-			for (const member of namespace.members) members.push({
-				item: member,
-				namespace,
-				qualifiedName: `${namespace.displayName}.${member.displayName}`
-			});
-		}
-		return members;
-	}
-	/**
-	* Extract plain text from a TSDoc DocNode tree (prose form).
-	*
-	* Delegates to api-extractor-llms `extractPlainText`. Used internally for
-	* `@see` reference text, where `{@link}` targets are flattened to display text.
-	*/
-	static extractPlainText(node) {
-		return extractPlainText(node);
-	}
-	/**
-	* Get the summary text from an API item's TSDoc comment
-	*/
-	static getSummary(item) {
-		return getSummary(item);
-	}
-	/**
-	* Get the release tag (public, beta, alpha, internal) from an API item
-	*/
-	static getReleaseTag(item) {
-		return getReleaseTag(item);
-	}
-	/**
-	* Get parameter documentation from an API item's TSDoc comment
-	*/
-	static getParams(item) {
-		return getParams(item);
-	}
-	/**
-	* Get return value documentation from an API item's TSDoc comment
-	*/
-	static getReturns(item) {
-		return getReturns(item);
-	}
-	/**
-	* Get code examples from an API item's TSDoc comment
-	*/
-	static getExamples(item) {
-		return getExamples(item);
-	}
-	/**
-	* Get deprecation message from an API item's TSDoc comment
-	*/
-	static getDeprecation(item) {
-		return getDeprecation(item);
-	}
-	/**
-	* Get inheritance information from a class or interface
-	*/
-	static getInheritance(item) {
-		const result = {};
-		if (item.kind === ApiItemKind.Class) {
-			const apiClass = item;
-			if (apiClass.extendsType) result.extends = [apiClass.extendsType.excerpt.text];
-			const implementsTypes = apiClass.implementsTypes || [];
-			if (implementsTypes.length > 0) result.implements = implementsTypes.map((type) => type.excerpt.text);
-		} else if (item.kind === ApiItemKind.Interface) {
-			const extendsTypes = item.extendsTypes || [];
-			if (extendsTypes.length > 0) result.extends = extendsTypes.map((type) => type.excerpt.text);
-		}
-		return result;
-	}
-	/**
-	* Get see also references from an API item's TSDoc comment
-	*/
-	static getSeeReferences(item) {
-		if (item instanceof ApiDocumentedItem) {
-			const tsdoc = item.tsdocComment;
-			const references = [];
-			for (const seeBlock of tsdoc?.seeBlocks || []) {
-				const content = seeBlock.content;
-				const text = ApiParser.extractPlainText(content);
-				if (text.trim()) references.push({ text: text.replace(/\s+/g, " ").trim() });
-			}
-			return references;
-		}
-		return [];
-	}
-	/**
-	* Get source code link for an API item
-	* @param item - The API item
-	* @param sourceConfig - Source configuration with repository URL and ref
-	* @returns Source code URL with line number, or null if not available
-	*/
-	static getSourceLink(item, sourceConfig) {
-		if (!sourceConfig) return null;
-		const itemAny = item;
-		const filePath = itemAny.fileUrlPath || itemAny.filePath;
-		if (!filePath) return null;
-		const lineNumber = itemAny.fileLineNumber || itemAny.line;
-		const ref = sourceConfig.ref || "blob/main";
-		const baseUrl = `${sourceConfig.url}/${ref}`;
-		if (lineNumber) return `${baseUrl}/${filePath}#L${lineNumber}`;
-		return `${baseUrl}/${filePath}`;
-	}
-};
-
-//#endregion
-export { ApiParser, setLoaderEventEmitter };

package/markdown/cross-linker.js

@@ -1,157 +0,0 @@
-import { CrossLinker } from "@tsdoctor/model";
-
-//#region src/markdown/cross-linker.ts
-/**
-* A cross-linking utility for markdown API documentation.
-*
-* This class maintains a mapping of API item names to their documentation routes,
-* enabling automatic cross-linking of type references in markdown content. It supports
-* both top-level exports and class/interface members.
-*
-* **How it works:**
-* 1. During initialization, it builds a route map from all API items in a package
-* 2. For classes and interfaces, it also maps their members (e.g., `ClassName.methodName`)
-* 3. When processing text, it replaces type names with markdown or HTML links
-*
-* **Relationships:**
-* - Initialized by {@link ApiExtractorPlugin} with categorized API items
-* - Used by page generators to add cross-links in documentation text
-* - Provides route/kind data to {@link ShikiCrossLinker} for code block linking
-*
-* **Link Formats:**
-* - Markdown: `[TypeName](/path/to/type)` - for use in .mdx content
-* - HTML: anchor tags with href - for use in JSX/components
-*
-* @example Initialization
-* ```ts
-* const crossLinker = new MarkdownCrossLinker();
-* const { routes, kinds } = crossLinker.initialize(
-*   categorizedItems,
-*   "/api/my-package",
-*   categories
-* );
-* ```
-*
-* @example Adding cross-links
-* ```ts
-* // Markdown format
-* const text = crossLinker.addCrossLinks("Returns a MyClass instance");
-* // Result: "Returns a [MyClass](/api/my-package/class/myclass) instance"
-*
-* // HTML format (for JSX)
-* const html = crossLinker.addCrossLinksHtml("Returns a MyClass instance");
-* // Result: "Returns a anchor-linked MyClass instance"
-* ```
-*
-* @see {@link ShikiCrossLinker} for code block cross-linking
-*/
-var MarkdownCrossLinker = class {
-	/**
-	* Map of API item names to their route paths for cross-linking
-	*/
-	apiItemRoutes = /* @__PURE__ */ new Map();
-	/**
-	* Clear all accumulated routes. Call at the start of each build.
-	*/
-	clear() {
-		this.apiItemRoutes.clear();
-	}
-	/**
-	* Add routes for API items. Accumulates across multiple calls.
-	* Call clear() first if starting a fresh build.
-	* @returns Object with routes map and kinds map for semantic highlighting
-	*/
-	addRoutes(items, baseRoute, categories) {
-		const apiItemKinds = /* @__PURE__ */ new Map();
-		for (const [categoryKey, categoryConfig] of Object.entries(categories)) {
-			const categoryItems = items[categoryKey] || [];
-			for (const item of categoryItems) {
-				const itemRoute = `${baseRoute}/${categoryConfig.folderName}/${item.displayName.toLowerCase()}`;
-				this.apiItemRoutes.set(item.displayName, itemRoute);
-				apiItemKinds.set(item.displayName, item.kind);
-				if ((item.kind === "Class" || item.kind === "Interface") && item.members) for (const member of item.members) {
-					const memberName = member.displayName;
-					const memberId = this.sanitizeId(memberName);
-					const fullMemberName = `${item.displayName}.${memberName}`;
-					const memberRoute = `${itemRoute}#${memberId}`;
-					this.apiItemRoutes.set(fullMemberName, memberRoute);
-					apiItemKinds.set(fullMemberName, member.kind);
-				}
-			}
-		}
-		return {
-			routes: this.apiItemRoutes,
-			kinds: apiItemKinds
-		};
-	}
-	/**
-	* Initialize the cross-link map with all API items.
-	* @deprecated Use clear() + addRoutes() instead.
-	* @returns Object with routes map and kinds map for semantic highlighting
-	*/
-	initialize(items, baseRoute, categories) {
-		this.clear();
-		return this.addRoutes(items, baseRoute, categories);
-	}
-	/**
-	* Set routes directly from pre-built route maps (e.g., from prepareWorkItems).
-	* Replaces all existing routes.
-	*/
-	setRoutes(routes) {
-		this.apiItemRoutes.clear();
-		for (const [name, route] of routes) this.apiItemRoutes.set(name, route);
-	}
-	/**
-	* Add cross-links to type references in code (markdown format).
-	*
-	* Skips matches inside backtick code spans and existing markdown links.
-	*/
-	addCrossLinks(text) {
-		if (this.apiItemRoutes.size === 0) return text;
-		const refs = Array.from(this.apiItemRoutes.keys()).map((name) => ({
-			name,
-			kind: "type",
-			slug: name.toLowerCase()
-		}));
-		return new CrossLinker(refs, (ref) => this.apiItemRoutes.get(ref.name) ?? "").addLinks(text);
-	}
-	/**
-	* Add cross-links to type references in code (HTML format)
-	* Use this when the text will be rendered as HTML (e.g., in React components)
-	*
-	* Note: intentionally hand-rolled and test-only — the upstream library's
-	* CrossLinker emits markdown links only, so the HTML path has no library
-	* equivalent.
-	*/
-	addCrossLinksHtml(text) {
-		let result = text;
-		const sortedNames = Array.from(this.apiItemRoutes.keys()).sort((a, b) => b.length - a.length);
-		for (const name of sortedNames) {
-			const route = this.apiItemRoutes.get(name);
-			if (!route) continue;
-			const regex = new RegExp(`\\b${name}\\b(?![a-zA-Z])`, "g");
-			result = result.replace(regex, (match, offset) => {
-				const beforeMatch = result.substring(0, offset);
-				if (beforeMatch.includes("<a") && !beforeMatch.includes("</a>")) return match;
-				return `<a href="${route}">${match}</a>`;
-			});
-		}
-		return result;
-	}
-	/**
-	* Sanitize a display name to create a valid HTML ID
-	* Converts to lowercase, replaces spaces/special chars with hyphens
-	*/
-	sanitizeId(displayName, prefix = "") {
-		const sanitized = displayName.toLowerCase().replace(/[\s_]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/^-+|-+$/g, "");
-		return prefix ? `${prefix}-${sanitized}` : sanitized;
-	}
-};
-/**
-* Module-level instance used by internal generator functions.
-* External callers should create their own instance or use this one.
-*/
-const markdownCrossLinker = new MarkdownCrossLinker();
-
-//#endregion
-export { MarkdownCrossLinker, markdownCrossLinker };

package/migrations/001_create_snapshots.js

@@ -1,25 +0,0 @@
-import { Effect } from "effect";
-import { SqlClient } from "effect/unstable/sql";
-
-//#region src/migrations/001_create_snapshots.ts
-const migration = Effect.gen(function* () {
-	const sql = yield* SqlClient.SqlClient;
-	yield* sql`
-		CREATE TABLE IF NOT EXISTS file_snapshots (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			output_dir TEXT NOT NULL,
-			file_path TEXT NOT NULL,
-			published_time TEXT NOT NULL,
-			modified_time TEXT NOT NULL,
-			content_hash TEXT NOT NULL,
-			frontmatter_hash TEXT NOT NULL,
-			build_time TEXT NOT NULL,
-			UNIQUE(output_dir, file_path)
-		)
-	`;
-	yield* sql`CREATE INDEX IF NOT EXISTS idx_output_dir ON file_snapshots(output_dir)`;
-	yield* sql`CREATE INDEX IF NOT EXISTS idx_file_path ON file_snapshots(file_path)`;
-});
-
-//#endregion
-export { migration as default };

package/multi-entry-resolver.js

@@ -1,70 +0,0 @@
-//#region src/multi-entry-resolver.ts
-/**
-* 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
-*/
-function getEntryPointName(displayName) {
-	return displayName === "" ? "default" : displayName;
-}
-/**
-* Create a stable identity key for an API item based on its display name and kind.
-* Used to detect re-exports across entry points.
-*/
-function itemKey(item) {
-	return `${item.displayName}::${item.kind}`;
-}
-/**
-* 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
-*/
-function resolveEntryPoints(apiPackage) {
-	const itemsByKey = /* @__PURE__ */ new Map();
-	for (const entryPoint of apiPackage.entryPoints) {
-		const epName = getEntryPointName(entryPoint.displayName);
-		for (const member of entryPoint.members) {
-			const key = itemKey(member);
-			const existing = itemsByKey.get(key) || [];
-			existing.push({
-				item: member,
-				entryPointName: epName
-			});
-			itemsByKey.set(key, existing);
-		}
-	}
-	const intermediate = [];
-	for (const [, entries] of itemsByKey) if (entries.length === 1) {
-		const { item, entryPointName } = entries[0];
-		intermediate.push({
-			item,
-			definingEntryPoint: entryPointName,
-			availableFrom: [entryPointName]
-		});
-	} else {
-		const definingEntry = entries.find((e) => e.entryPointName === "default") || entries[0];
-		const allEntryPoints = [...new Set(entries.map((e) => e.entryPointName))];
-		intermediate.push({
-			item: definingEntry.item,
-			definingEntryPoint: definingEntry.entryPointName,
-			availableFrom: allEntryPoints
-		});
-	}
-	return intermediate.map((r) => ({
-		item: r.item,
-		definingEntryPoint: r.definingEntryPoint,
-		availableFrom: r.availableFrom
-	}));
-}
-
-//#endregion
-export { resolveEntryPoints };