rspress-plugin-api-extractor 0.11.0 → 0.13.0

package/layers/HighlighterServiceLive.js

@@ -1,52 +0,0 @@
-import { PluginEvent } from "../observability/events.js";
-import { emit } from "../observability/EventBus.js";
-import { HighlighterService } from "../services/HighlighterService.js";
-import { SHIKI_LANGS } from "../markdown/shiki-utils.js";
-import { Effect, Layer } from "effect";
-import { createHighlighter } from "shiki";
-
-//#region src/layers/HighlighterServiceLive.ts
-/**
-* Acquire the build's highlighter, and release it when the runtime is
-* disposed.
-*
-* @remarks
-* `Layer.effect` over `Effect.acquireRelease` is the v4 scoped-constructor
-* idiom (`Layer.scoped` is gone; `Layer.effect` strips `Scope` from `R`).
-* Because the layer sits in the `ManagedRuntime`'s stack, the highlighter is
-* created on the runtime's first use and `dispose()`d by
-* `effectRuntime.dispose()` — which `plugin.ts` calls on production builds
-* only, so a dev HMR session keeps one highlighter across rebuilds instead of
-* leaking one per rebuild.
-*
-* **Bind the result to a `const`.** This is a layer FACTORY: each call mints a
-* fresh layer reference, and layers memoize by reference, so calling it twice
-* in one graph acquires two highlighters — the exact leak this layer exists to
-* fix.
-*
-* The themes are passed in rather than read from a resolved build context
-* because the layer builds before `ConfigService.resolve()` runs. Passing them
-* as an argument rather than through a `Context.Reference` is deliberate: a
-* Reference carries a default, so forgetting to wire it would silently load
-* only the default themes and render every custom-themed block wrong. A
-* missing argument is a type error.
-*/
-function HighlighterServiceLive(themes) {
-	return Layer.effect(HighlighterService, Effect.gen(function* () {
-		const startedMs = performance.now();
-		const highlighter = yield* Effect.acquireRelease(Effect.promise(() => createHighlighter({
-			themes: [...themes],
-			langs: [...SHIKI_LANGS]
-		})), (instance) => Effect.sync(() => instance.dispose()));
-		yield* emit(PluginEvent.PhaseCompleted({
-			ctx: {},
-			level: "debug",
-			phase: "shikiInit",
-			durationMs: Math.round(performance.now() - startedMs)
-		}));
-		return { highlighter };
-	}));
-}
-
-//#endregion
-export { HighlighterServiceLive };

package/layers/OgServiceLive.js

@@ -1,134 +0,0 @@
-import { PluginEvent } from "../observability/events.js";
-import { emit } from "../observability/EventBus.js";
-import { imageMimeType, ogAltText, resolveOgUrl } from "../og-resolver.js";
-import { OgImageError, OgService } from "../services/OgService.js";
-import { Effect, FileSystem, Layer, Option, Path } from "effect";
-import { imageSize } from "image-size";
-
-//#region src/layers/OgServiceLive.ts
-/**
-* Resolve OG images through the core `FileSystem`, with one read per file per
-* build.
-*
-* @remarks
-* The `node:fs` `existsSync` + `imageSizeFromFile` pair this replaces ran once
-* per PAGE, so a 400-page API re-read the same image 400 times. The memo below
-* keys on the absolute path and removes that entirely.
-*
-* The memo is per build, not persisted. A cross-build cache in the shared XDG
-* store was considered and deliberately deferred: it would need mtime/size
-* invalidation to stay sound, and a stale image dimension is a silent wrong
-* answer. There is nothing expensive enough here to justify that yet — when
-* phase 4 starts GENERATING images, which are expensive and content-addressed,
-* the XDG cache is the right home for them.
-*
-* `imageSize` over the read bytes replaces `imageSizeFromFile`, which took a
-* path and therefore required real `node:fs`. Same parser, same output.
-*/
-const OgServiceLive = Layer.effect(OgService, Effect.gen(function* () {
-	const fileSystem = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	/** Absolute path → facts, or `null` for "looked, could not use it". */
-	const factsByPath = /* @__PURE__ */ new Map();
-	/** Locate a root-relative image under the docs `public/` directory. */
-	const findLocalImage = (imagePath, docsRoot) => {
-		if (docsRoot == null || !imagePath.startsWith("/")) return Effect.succeed(Option.none());
-		const candidate = path.join(docsRoot, "public", imagePath);
-		return fileSystem.exists(candidate).pipe(Effect.orElseSucceed(() => false), Effect.map((found) => found ? Option.some(candidate) : Option.none()));
-	};
-	/**
-	* Read dimensions and MIME type. A file that cannot be parsed warns and
-	* yields nothing — the page still gets its `og:image`, just without
-	* dimensions, which is what the class this replaced did.
-	*/
-	const readImageFacts = (filePath) => Effect.gen(function* () {
-		const memoed = factsByPath.get(filePath);
-		if (memoed !== void 0) return memoed;
-		const result = yield* Effect.result(fileSystem.readFile(filePath).pipe(Effect.flatMap((bytes) => Effect.try(() => imageSize(bytes)))));
-		if (result._tag === "Failure") {
-			const error = new OgImageError({
-				code: "unreadable-image",
-				field: "ogImage",
-				value: filePath,
-				cause: result.failure
-			});
-			yield* emit(PluginEvent.ConfigValidationWarning({
-				ctx: {},
-				field: "ogImage",
-				value: filePath,
-				reason: error.message,
-				level: "warn"
-			}));
-			factsByPath.set(filePath, null);
-			return null;
-		}
-		const size = result.success;
-		const mimeType = imageMimeType(size.type);
-		const facts = {
-			...size.width != null ? { width: size.width } : {},
-			...size.height != null ? { height: size.height } : {},
-			...mimeType != null ? { type: mimeType } : {}
-		};
-		factsByPath.set(filePath, facts);
-		return facts;
-	});
-	const resolveFromString = (imageUrl, request) => Effect.gen(function* () {
-		const resolvedUrl = resolveOgUrl(request.siteUrl, imageUrl);
-		if (resolvedUrl == null) return yield* Effect.fail(new OgImageError({
-			code: "invalid-url",
-			field: "ogImage",
-			value: imageUrl
-		}));
-		const localPath = yield* findLocalImage(imageUrl, request.docsRoot);
-		const facts = Option.isSome(localPath) ? yield* readImageFacts(localPath.value) : null;
-		return Option.some({
-			url: resolvedUrl,
-			type: facts?.type,
-			width: facts?.width,
-			height: facts?.height,
-			alt: ogAltText(request.packageName, request.apiName)
-		});
-	});
-	const resolveFromMetadata = (metadata, request) => Effect.gen(function* () {
-		const { url, secureUrl, type, width, height, alt } = metadata;
-		const resolvedUrl = resolveOgUrl(request.siteUrl, url);
-		if (resolvedUrl == null) return yield* Effect.fail(new OgImageError({
-			code: "invalid-url",
-			field: "ogImage.url",
-			value: url
-		}));
-		let resolvedSecureUrl;
-		if (secureUrl != null) {
-			if (secureUrl.startsWith("https://")) resolvedSecureUrl = secureUrl;
-			else {
-				const error = new OgImageError({
-					code: "invalid-secure-url",
-					field: "ogImage.secureUrl",
-					value: secureUrl
-				});
-				yield* emit(PluginEvent.ConfigValidationWarning({
-					ctx: {},
-					field: "ogImage.secureUrl",
-					value: secureUrl,
-					reason: error.message,
-					level: "warn"
-				}));
-			}
-		}
-		return Option.some({
-			url: resolvedUrl,
-			secureUrl: resolvedSecureUrl,
-			type,
-			width,
-			height,
-			alt: alt ?? ogAltText(request.packageName, request.apiName)
-		});
-	});
-	return { resolveImage: (request) => {
-		if (request.config == null) return Effect.succeed(Option.none());
-		return typeof request.config === "object" ? resolveFromMetadata(request.config, request) : resolveFromString(request.config, request);
-	} };
-}));
-
-//#endregion
-export { OgServiceLive };

package/layers/TwoslashCacheServiceLive.js

@@ -1,108 +0,0 @@
-import { TwoslashCacheService } from "../services/TwoslashCacheService.js";
-import { decodeTwoslashCache, encodeTwoslashCache, makeTwoslashCache, twoslashBlobKey } from "../twoslash-cache.js";
-import { AppDirsLive, PlatformLive } from "./xdg.js";
-import { Effect, Layer, Option, Path } from "effect";
-import { Cache } from "@effected/store";
-import { AppDirs } from "@effected/xdg";
-
-//#region src/layers/TwoslashCacheServiceLive.ts
-/**
-* A sqlite-backed `@effected/store` Cache in the XDG cache dir, separate from
-* the registry's `metadata.sqlite`.
-*
-* XDG rather than the repo: these are regenerable results derived from content
-* hashes, so they belong with the user's other caches — shared across worktrees
-* and checkouts of the same project, and untouched by cleaning `dist/`. Nothing
-* here needs to be committed for a build to be correct.
-*/
-const CacheLive = Layer.unwrap(Effect.gen(function* () {
-	const appDirs = yield* AppDirs;
-	const path = yield* Path.Path;
-	const cacheDir = yield* appDirs.ensureCache;
-	return Cache.layerSqlite({ filename: path.join(cacheDir, "twoslash.sqlite") });
-})).pipe(Layer.provide(Layer.mergeAll(AppDirsLive, PlatformLive)));
-/**
-* Live Twoslash cache persistence.
-*
-* Both operations swallow every failure by design — see the service docs. A
-* missing HOME, an unwritable cache dir or a corrupt database degrades the
-* build to "type-check everything", which is exactly the behaviour before this
-* cache existed.
-*/
-/**
-* Add the build-generation half of the service on top of a load/save pair.
-*
-* @remarks
-* Shared by the real and degraded layers so the two cannot drift: a degraded
-* build must still hand out a working in-memory cache, otherwise the
-* transformers have nothing to read or write and the render pass changes
-* shape rather than merely losing persistence.
-*/
-function withGeneration(base) {
-	let open = null;
-	return {
-		...base,
-		open: (envHash) => base.load(envHash).pipe(Effect.map((restored) => {
-			const cache = makeTwoslashCache(restored);
-			open = {
-				cache,
-				envHash
-			};
-			return cache;
-		})),
-		persist: () => Effect.suspend(() => {
-			if (open === null) return Effect.succeed(Option.none());
-			const { cache, envHash } = open;
-			const stats = cache.stats();
-			const report = Option.some({
-				...stats,
-				envHash
-			});
-			return stats.dirty ? base.save(envHash, cache.entries()).pipe(Effect.as(report)) : Effect.succeed(report);
-		})
-	};
-}
-const CacheBackedLive = Layer.effect(TwoslashCacheService, Effect.gen(function* () {
-	const cache = yield* Cache;
-	return withGeneration({
-		load: (envHash) => cache.get(twoslashBlobKey(envHash)).pipe(Effect.map((entry) => Option.isSome(entry) ? decodeTwoslashCache(entry.value.value) : /* @__PURE__ */ new Map()), Effect.catch(() => Effect.succeed(/* @__PURE__ */ new Map()))),
-		save: (envHash, entries) => cache.set({
-			key: twoslashBlobKey(envHash),
-			value: encodeTwoslashCache(entries),
-			tags: ["twoslash"]
-		}).pipe(Effect.catch(() => Effect.void))
-	});
-})).pipe(Layer.provide(CacheLive));
-/**
-* A cache that holds nothing, for when the real one cannot be opened.
-*
-* @remarks
-* `load` returns empty and `save` discards, which is precisely the behaviour
-* before this cache existed: type-check everything, persist nothing.
-*/
-const DegradedLive = Layer.succeed(TwoslashCacheService, withGeneration({
-	load: () => Effect.succeed(/* @__PURE__ */ new Map()),
-	save: () => Effect.void
-}));
-/**
-* Live Twoslash cache persistence.
-*
-* @remarks
-* Failure is absorbed at TWO levels, and both are load-bearing. Inside the
-* service, a failed read or write degrades that one operation. Around the
-* layer, a failed CONSTRUCTION — no HOME for XDG, an unwritable cache
-* directory, a corrupt database — degrades to {@link DegradedLive}.
-*
-* The second is why `Layer.catchCause` wraps this at all. While the sqlite
-* layer was provided inside each method, a construction failure surfaced as
-* that method's failure and the in-method handler swallowed it. Hoisting
-* acquisition to layer construction moved the failure to `ManagedRuntime`
-* build time, where it would abort the entire build — breaking the contract
-* this service documents, that an unreachable cache must never fail a build
-* that would otherwise succeed. `catchCause` rather than a failure-only catch
-* because a defect thrown by the sqlite driver must degrade too.
-*/
-const TwoslashCacheServiceLive = CacheBackedLive.pipe(Layer.catchCause(() => DegradedLive));
-
-//#endregion
-export { TwoslashCacheServiceLive };

package/layers/TwoslashEnvironmentsLive.js

@@ -1,33 +0,0 @@
-import { TwoslashEnvironments } from "../services/TwoslashEnvironments.js";
-import { TwoslashEnvironmentRegistry } from "../twoslash-transformer.js";
-import { Layer } from "effect";
-
-//#region src/layers/TwoslashEnvironmentsLive.ts
-/**
-* One environment registry per runtime.
-*
-* @remarks
-* `Layer.sync` rather than `Layer.succeed`: the registry is mutable, and a
-* `Layer.succeed` would capture a single instance shared by every layer graph
-* that referenced this const — including, in a test run, every test file in
-* the process. Building it when the layer builds is what makes substitution
-* work: a test that wants an isolated registry provides its own layer, which
-* is what the old static `TwoslashManager.reset()` was standing in for.
-*
-* Deliberately NOT `Layer.effect` with a finalizer. The registry holds Shiki
-* transformers, which the render pass uses AFTER `config()` returns — the same
-* lifetime constraint the highlighter has, and for the same reason.
-*/
-const TwoslashEnvironmentsLive = Layer.sync(TwoslashEnvironments, () => {
-	const registry = new TwoslashEnvironmentRegistry();
-	return {
-		registerEnvironment: (options) => registry.registerEnvironment(options),
-		registerScope: (apiScope, compilerOptions) => registry.registerScope(apiScope, compilerOptions),
-		transformerFor: (apiScope) => registry.transformerFor(apiScope),
-		setCurrentFile: (path) => registry.setCurrentFile(path),
-		reportErrorForTest: (error, code, file) => registry.reportErrorForTest(error, code, file)
-	};
-});
-
-//#endregion
-export { TwoslashEnvironmentsLive };

package/layers/TypeRegistryServiceLive.js

@@ -1,162 +0,0 @@
-import { PluginEvent } from "../observability/events.js";
-import { emit } from "../observability/EventBus.js";
-import { resolveExternalPackageVersions } from "../config-utils.js";
-import { TypeRegistryError } from "../errors.js";
-import { TypeRegistryService } from "../services/TypeRegistryService.js";
-import { AppDirsLive, PlatformLive } from "./xdg.js";
-import { NodeHttpClient } from "@effect/platform-node";
-import { Duration, Effect, Layer, Path } from "effect";
-import { PackageFetcher, PackageSpec, RegistryObserver, TypeCache, TypeRegistry } from "@tsdoctor/registry";
-import { Cache } from "@effected/store";
-import { AppDirs } from "@effected/xdg";
-
-//#region src/layers/TypeRegistryServiceLive.ts
-/**
-* Forward @tsdoctor/registry's typed `RegistryEvent`s to the plugin's Effect
-* logger. Since v1 the library emits no logs of its own — observers are the only
-* diagnostic surface — so this restores the build output and routes it through
-* the plugin's configured log level/format (a single source, no duplication).
-*
-* The summary (`BatchComplete`) and failures are surfaced at info/warning;
-* per-package detail stays at debug so a normal build is quiet.
-*/
-const RegistryObserverLayer = Layer.succeed(RegistryObserver, { emit: (event) => {
-	switch (event._tag) {
-		case "VersionResolved": return emit(PluginEvent.TypeRegistryEvent({
-			ctx: { packageName: event.package },
-			level: "debug",
-			kind: "VersionResolved",
-			detail: `${event.requested} -> ${event.resolved}`
-		}));
-		case "VersionResolveFailed": return emit(PluginEvent.TypeRegistryEvent({
-			ctx: { packageName: event.package },
-			level: "debug",
-			kind: "VersionResolveFailed",
-			detail: `${event.requested}: ${event.kind}`
-		}));
-		case "CacheHit":
-		case "CacheMiss":
-		case "FetchStart": return emit(PluginEvent.TypeRegistryEvent({
-			ctx: {
-				packageName: event.package,
-				version: event.version
-			},
-			level: "debug",
-			kind: event._tag,
-			detail: ""
-		}));
-		case "CacheStale": return emit(PluginEvent.TypeRegistryEvent({
-			ctx: {
-				packageName: event.package,
-				version: event.version
-			},
-			level: "debug",
-			kind: "CacheStale",
-			detail: ""
-		}));
-		case "FetchFailed": return emit(PluginEvent.TypeRegistryEvent({
-			ctx: {},
-			level: "debug",
-			kind: "FetchFailed",
-			detail: `HTTP ${event.status}: ${event.url}${event.bodySnippet ? ` — ${event.bodySnippet}` : ""}`
-		}));
-		case "PackageLoaded": return emit(PluginEvent.TypeRegistryEvent({
-			ctx: {
-				packageName: event.package,
-				version: event.version
-			},
-			level: "debug",
-			kind: "PackageLoaded",
-			detail: `${event.files} files, ${event.source}`
-		}));
-		case "PackageLoadFailed": return emit(PluginEvent.TypeRegistryEvent({
-			ctx: {
-				packageName: event.package,
-				version: event.version
-			},
-			level: "warn",
-			kind: "PackageLoadFailed",
-			detail: `[${event.kind}] ${event.error instanceof Error ? event.error.message : String(event.error)}`
-		}));
-		case "BatchStart": return emit(PluginEvent.TypeRegistryEvent({
-			ctx: {},
-			level: "debug",
-			kind: "BatchStart",
-			detail: `${event.total} package(s)`
-		}));
-		case "BatchComplete": return emit(PluginEvent.TypeRegistryEvent({
-			ctx: {},
-			level: "info",
-			kind: "BatchComplete",
-			detail: `${event.loaded}/${event.total} packages, ${event.totalFiles} files, ${Math.round(Duration.toMillis(event.duration))}ms`
-		}));
-	}
-} });
-/** Metadata plane: a sqlite-backed `@effected/store` Cache rooted in the XDG cache dir. */
-const MetadataCacheLive = Layer.unwrap(Effect.gen(function* () {
-	const appDirs = yield* AppDirs;
-	const path = yield* Path.Path;
-	const cacheDir = yield* appDirs.ensureCache;
-	return Cache.layerSqlite({ filename: path.join(cacheDir, "metadata.sqlite") });
-})).pipe(Layer.provide(Layer.mergeAll(AppDirsLive, PlatformLive)));
-/**
-* The full registry runtime: TypeRegistry over an XDG-rooted TypeCache and the
-* jsDelivr PackageFetcher, with the observer that forwards registry events to
-* the plugin's EventBus (found ambiently via serviceOption at emit time).
-*/
-const RegistryLayer = TypeRegistry.layer.pipe(Layer.provideMerge(Layer.mergeAll(TypeCache.layerXdg(), PackageFetcher.layer)), Layer.provideMerge(RegistryObserverLayer), Layer.provide(Layer.mergeAll(MetadataCacheLive, AppDirsLive, PlatformLive, NodeHttpClient.layerUndici)));
-/**
-* TypeRegistryServiceLive: uses @tsdoctor/registry Effect programs directly.
-*/
-const RegistryBackedLive = Layer.effect(TypeRegistryService, Effect.gen(function* () {
-	const registry = yield* TypeRegistry;
-	return {
-		resolveVersions: (packages) => resolveExternalPackageVersions(packages, (pkg) => registry.resolveVersion(pkg.name, pkg.version)).pipe(Effect.catch(() => Effect.succeed([...packages]))),
-		loadPackages: (packages) => packages.length === 0 ? Effect.succeed({ vfs: /* @__PURE__ */ new Map() }) : Effect.gen(function* () {
-			const specs = packages.map((pkg) => new PackageSpec({
-				name: pkg.name,
-				version: pkg.version
-			}));
-			return { vfs: yield* registry.getVfs(specs, { autoFetch: true }) };
-		}).pipe(Effect.catch((error) => Effect.fail(new TypeRegistryError({
-			packageName: packages.map((p) => p.name).join(", "),
-			version: packages.map((p) => p.version).join(", "),
-			reason: error instanceof Error ? error.message ?? String(error) : String(error)
-		}))))
-	};
-})).pipe(Layer.provide(RegistryLayer));
-/**
-* The service when the registry stack cannot be built at all.
-*
-* @remarks
-* Preserves exactly the split the working service documents: `resolveVersions`
-* passes its specs through unresolved rather than swallowing the problem, so
-* the failure surfaces from `loadPackages` as a {@link PluginTypeRegistryError}
-* with a message, which `ConfigServiceLive` turns into a build-continues
-* warning. Before acquisition moved to layer construction this fell out of the
-* per-method handlers; it has to be stated explicitly now.
-*/
-const DegradedLive = Layer.succeed(TypeRegistryService, {
-	resolveVersions: (packages) => Effect.succeed([...packages]),
-	loadPackages: (packages) => Effect.fail(new TypeRegistryError({
-		packageName: packages.map((p) => p.name).join(", "),
-		version: packages.map((p) => p.version).join(", "),
-		reason: "type registry unavailable: its cache directory or metadata database could not be opened"
-	}))
-});
-/**
-* TypeRegistryServiceLive: the `@tsdoctor/registry` stack, acquired once.
-*
-* @remarks
-* `Layer.catchCause` keeps a broken environment — no HOME for XDG, an
-* unwritable cache directory — from aborting the build at `ManagedRuntime`
-* construction. External type loading is an enhancement: without it code
-* blocks render without Twoslash enrichment, which is a degradation, not a
-* failure. That was true while the stack was provided per method and the
-* in-method handlers absorbed it; hoisting acquisition made it something the
-* layer has to say for itself.
-*/
-const TypeRegistryServiceLive = RegistryBackedLive.pipe(Layer.catchCause(() => DegradedLive));
-
-//#endregion
-export { TypeRegistryServiceLive };

package/markdown/index.js

@@ -1,11 +0,0 @@
-import { linkProse, setProseLinker } from "./prose-linker.js";
-import { ClassPageGenerator } from "./page-generators/class-page.js";
-import { EnumPageGenerator } from "./page-generators/enum-page.js";
-import { FunctionPageGenerator } from "./page-generators/function-page.js";
-import { MainIndexPageGenerator } from "./page-generators/index-pages.js";
-import { InterfacePageGenerator } from "./page-generators/interface-page.js";
-import { NamespacePageGenerator } from "./page-generators/namespace-page.js";
-import { TypeAliasPageGenerator } from "./page-generators/type-alias-page.js";
-import { VariablePageGenerator } from "./page-generators/variable-page.js";
-
-export { ClassPageGenerator, EnumPageGenerator, FunctionPageGenerator, InterfacePageGenerator, MainIndexPageGenerator, NamespacePageGenerator, TypeAliasPageGenerator, VariablePageGenerator, setProseLinker };

package/og-resolver.js

@@ -1,64 +0,0 @@
-//#region src/og-resolver.ts
-/**
-* MIME type mappings for common image formats, used for `og:image:type`.
-*/
-const IMAGE_MIME_TYPES = {
-	jpg: "image/jpeg",
-	jpeg: "image/jpeg",
-	png: "image/png",
-	gif: "image/gif",
-	webp: "image/webp",
-	svg: "image/svg+xml"
-};
-/**
-* The `og:image:type` value for a detected image format, or `undefined` for a
-* format with no mapping.
-*/
-function imageMimeType(type) {
-	if (type == null) return void 0;
-	return IMAGE_MIME_TYPES[type.toLowerCase()];
-}
-/**
-* Turn a configured image URL into an absolute one.
-*
-* @returns The absolute URL, or `undefined` when the input is neither an
-* absolute `http(s)` URL nor a site-root-relative path. A bare relative path
-* is deliberately rejected rather than guessed at — there is no base to
-* resolve it against that would not silently produce a broken link.
-*/
-function resolveOgUrl(siteUrl, url) {
-	if (url.startsWith("http://") || url.startsWith("https://")) return url;
-	if (url.startsWith("/")) return `${siteUrl}${url}`;
-}
-/** Descriptive alt text for a package's (or one API's) OG image. */
-function ogAltText(packageName, apiName) {
-	return apiName ? `${apiName} - ${packageName} API Documentation` : `${packageName} API Documentation`;
-}
-/**
-* Assemble the complete Open Graph metadata for one documentation page.
-*
-* @remarks
-* Was `OpenGraphResolver.createPageMetadata`. It never touched the resolver's
-* instance state, so it is a free function now rather than a static on a class
-* that no longer exists.
-*/
-function createPageMetadata(options) {
-	return {
-		siteUrl: options.siteUrl,
-		pageRoute: options.pageRoute,
-		description: options.description,
-		publishedTime: options.publishedTime,
-		modifiedTime: options.modifiedTime,
-		section: options.section,
-		tags: [
-			"TypeScript",
-			"API",
-			options.packageName
-		],
-		...options.ogImage != null ? { ogImage: options.ogImage } : {},
-		ogType: "article"
-	};
-}
-
-//#endregion
-export { createPageMetadata, imageMimeType, ogAltText, resolveOgUrl };

package/schemas/index.js

@@ -1,6 +0,0 @@
-import { PerformanceConfig, PerformanceThresholds } from "./performance.js";
-import { EventLevelSchema, ObservabilityConfig, resolveObservability } from "./observability.js";
-import { OpenGraphImageConfig, OpenGraphImageMetadata } from "./opengraph.js";
-import { AutoDetectDependencies, CategoryConfig, DEFAULT_CATEGORIES, ErrorConfig, ExternalPackageSpec, LlmsPlugin, LogLevel, ModelInput, MultiApiConfig, PluginOptions, SingleApiConfig, SourceConfig, ThemeConfig, VersionConfig } from "./config.js";
-
-export { DEFAULT_CATEGORIES, PluginOptions };

package/schemas/opengraph.js

@@ -1,56 +0,0 @@
-import { Schema } from "effect";
-
-//#region src/schemas/opengraph.ts
-/**
-* Structured Open Graph image metadata (alternative to a plain URL string).
-*
-* @public
-*/
-const OpenGraphImageMetadata = Schema.Struct({
-	/** Absolute URL of the image. */
-	url: Schema.String,
-	/** HTTPS URL of the image (for secure contexts). */
-	secureUrl: Schema.optional(Schema.String),
-	/** MIME type of the image (e.g. `"image/png"`). */
-	type: Schema.optional(Schema.String),
-	/** Image width in pixels. */
-	width: Schema.optional(Schema.Number),
-	/** Image height in pixels. */
-	height: Schema.optional(Schema.Number),
-	/** Alt text for the image. */
-	alt: Schema.optional(Schema.String)
-});
-/**
-* Open Graph image: either a plain URL string or structured `OpenGraphImageMetadata`.
-*
-* @public
-*/
-const OpenGraphImageConfig = Schema.Union([Schema.String, OpenGraphImageMetadata]);
-/**
-* Resolved Open Graph metadata emitted into each generated page's frontmatter.
-*
-* @public
-*/
-const OpenGraphMetadata = Schema.Struct({
-	/** Canonical site base URL. */
-	siteUrl: Schema.String,
-	/** Page route path (e.g. `/api/classes/myclass`). */
-	pageRoute: Schema.String,
-	/** Page description for the `og:description` tag. */
-	description: Schema.String,
-	/** ISO 8601 date string for `article:published_time`. */
-	publishedTime: Schema.String,
-	/** ISO 8601 date string for `article:modified_time`. */
-	modifiedTime: Schema.String,
-	/** Article section label (e.g. `"API"`). */
-	section: Schema.String,
-	/** Article tag keywords. */
-	tags: Schema.mutable(Schema.Array(Schema.String)),
-	/** Optional structured image metadata. */
-	ogImage: Schema.optional(OpenGraphImageMetadata),
-	/** Open Graph object type (e.g. `"article"`). */
-	ogType: Schema.String
-});
-
-//#endregion
-export { OpenGraphImageConfig, OpenGraphImageMetadata };