@tsdoctor/model 0.1.0 → 0.2.0

package/ApiItems.js

@@ -0,0 +1,111 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { hasModifier } from "./Tsdoc.js";
+import { ApiItemKind } from "@microsoft/api-extractor-model";
+
+//#region src/ApiItems.ts
+var ApiItems_exports = /* @__PURE__ */ __exportAll({
+	categorize: () => categorize,
+	inheritance: () => inheritance,
+	namespaceMembers: () => namespaceMembers,
+	sourceLink: () => sourceLink
+});
+/** Extract the flat top-level item list from either source shape. */
+function topLevelItems(source) {
+	if (Array.isArray(source)) return source.map((r) => r.item);
+	const entryPoint = source.entryPoints[0];
+	return entryPoint ? entryPoint.members : [];
+}
+/**
+* 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
+*/
+function categorize(source, categories) {
+	const items = {};
+	for (const categoryKey of Object.keys(categories)) items[categoryKey] = [];
+	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;
+	});
+	const uncategorized = [];
+	for (const member of topLevelItems(source)) {
+		let categorized = false;
+		for (const [categoryKey, config] of sortedCategories) {
+			if (config.tsdocModifier && hasModifier(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) uncategorized.push(member);
+	}
+	return {
+		items,
+		uncategorized
+	};
+}
+/**
+* Extract all members of top-level namespaces as a flat list with qualified
+* names.
+*
+* @public
+*/
+function namespaceMembers(source) {
+	const members = [];
+	for (const item of topLevelItems(source)) 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;
+}
+/**
+* Read extends/implements information from a class or interface declaration.
+*
+* @public
+*/
+function inheritance(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;
+}
+/**
+* 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
+*/
+function sourceLink(item, target) {
+	if (!target) return null;
+	const itemAny = item;
+	const filePath = itemAny.fileUrlPath || itemAny.filePath;
+	if (!filePath) return null;
+	const lineNumber = itemAny.fileLineNumber || itemAny.line;
+	const ref = target.ref || "blob/main";
+	const baseUrl = `${target.url}/${ref}`;
+	return lineNumber ? `${baseUrl}/${filePath}#L${lineNumber}` : `${baseUrl}/${filePath}`;
+}
+
+//#endregion
+export { ApiItems_exports, categorize, inheritance, namespaceMembers, sourceLink };

package/CrossLinker.js

@@ -0,0 +1,81 @@
+import { escapeRegExp } from "./internal/text.js";
+
+//#region src/CrossLinker.ts
+/**
+* Link known API item names in prose to their docs. Immutable: construct one
+* per build from either a precomputed name → route map ({@link CrossLinker.fromRoutes})
+* or item refs plus an injected URL scheme ({@link CrossLinker.fromRefs}).
+* Pure.
+*
+* @packageDocumentation
+*/
+/**
+* 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
+*/
+var CrossLinker = class CrossLinker {
+	routesByName;
+	/** Names sorted longest-first so "HookEvent" matches before "Hook". */
+	orderedNames;
+	constructor(routesByName) {
+		this.routesByName = routesByName;
+		this.orderedNames = [...routesByName.keys()].sort((a, b) => b.length - a.length);
+	}
+	/**
+	* Build from a precomputed name → route map (member anchors and qualified
+	* names already baked into the routes). The primary pipeline path.
+	*/
+	static fromRoutes(routes) {
+		return new CrossLinker(new Map(routes));
+	}
+	/**
+	* 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, routeFor) {
+		return new CrossLinker(new Map(refs.map((r) => [r.name, routeFor(r)])));
+	}
+	/** The identity cross-linker: `link(text)` returns `text` unchanged. */
+	static empty = new CrossLinker(/* @__PURE__ */ new Map());
+	/** Wrap known item names in markdown links, skipping code spans + existing links. */
+	link(text) {
+		let result = text;
+		for (const name of this.orderedNames) {
+			const route = this.routesByName.get(name);
+			if (route === void 0) continue;
+			const regex = new RegExp(`\\b${escapeRegExp(name)}\\b`, "g");
+			result = result.replace(regex, (match, offset) => {
+				const before = result.slice(0, offset);
+				if (before.endsWith("](") || before.endsWith("[")) return match;
+				if ((before.match(/`/g) || []).length % 2 === 1) return match;
+				return `[${match}](${route})`;
+			});
+		}
+		return result;
+	}
+	/**
+	* 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) {
+		let result = text;
+		for (const name of this.orderedNames) {
+			const route = this.routesByName.get(name);
+			if (route === void 0) continue;
+			const regex = new RegExp(`\\b${escapeRegExp(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;
+	}
+};
+
+//#endregion
+export { CrossLinker };

package/EntryPoints.js

@@ -0,0 +1,76 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+
+//#region src/EntryPoints.ts
+var EntryPoints_exports = /* @__PURE__ */ __exportAll({
+	entryPointName: () => entryPointName,
+	resolve: () => resolve
+});
+/**
+* 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
+*/
+function entryPointName(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
+*
+* @public
+*/
+function resolve(apiPackage) {
+	const itemsByKey = /* @__PURE__ */ new Map();
+	for (const entryPoint of apiPackage.entryPoints) {
+		const epName = entryPointName(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 resolved = [];
+	for (const [, entries] of itemsByKey) if (entries.length === 1) {
+		const { item, entryPointName: epName } = entries[0];
+		resolved.push({
+			item,
+			definingEntryPoint: epName,
+			availableFrom: [epName]
+		});
+	} else {
+		const definingEntry = entries.find((e) => e.entryPointName === "default") || entries[0];
+		const allEntryPoints = [...new Set(entries.map((e) => e.entryPointName))];
+		resolved.push({
+			item: definingEntry.item,
+			definingEntryPoint: definingEntry.entryPointName,
+			availableFrom: allEntryPoints
+		});
+	}
+	return resolved;
+}
+
+//#endregion
+export { EntryPoints_exports, entryPointName, resolve };

package/Model.js

@@ -0,0 +1,90 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { ApiModel } from "@microsoft/api-extractor-model";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { Effect, Schema } from "effect";
+
+//#region src/Model.ts
+/**
+* Effect-typed loading of Microsoft API Extractor `.api.json` models.
+*
+* @remarks
+* `load` deliberately requires no `FileSystem` service: the underlying
+* `@microsoft/api-extractor-model` deserializer only exposes a file-path
+* entry point (`ApiModel#loadPackage` / `ApiPackage.loadFromJsonFile`) and
+* performs its own synchronous fs read — injecting a `FileSystem` the loader
+* would silently bypass would be dishonest dependency injection. Failures are
+* typed on the error channel instead.
+*
+* @packageDocumentation
+*/
+var Model_exports = /* @__PURE__ */ __exportAll({
+	EmptyModelError: () => EmptyModelError,
+	ModelNotFoundError: () => ModelNotFoundError,
+	ModelParseError: () => ModelParseError,
+	firstPackage: () => firstPackage,
+	load: () => load
+});
+/**
+* The `.api.json` file does not exist at the resolved path.
+*
+* @public
+*/
+var ModelNotFoundError = class extends Schema.TaggedError()("ModelNotFoundError", { modelPath: Schema.String }) {
+	get message() {
+		return `API model file not found: ${this.modelPath}`;
+	}
+};
+/**
+* The `.api.json` file exists but could not be deserialized (malformed JSON,
+* unsupported schema version, …). `reason` carries the deserializer's message.
+*
+* @public
+*/
+var ModelParseError = class extends Schema.TaggedError()("ModelParseError", {
+	modelPath: Schema.String,
+	reason: Schema.String
+}) {
+	get message() {
+		return `Failed to load API model at ${this.modelPath}: ${this.reason}`;
+	}
+};
+/**
+* An in-memory `ApiModel` carries no packages (or is otherwise unusable).
+*
+* @public
+*/
+var EmptyModelError = class extends Schema.TaggedError()("EmptyModelError", { reason: Schema.String }) {
+	get message() {
+		return this.reason;
+	}
+};
+/**
+* Load a `.api.json` model file and return its single `ApiPackage`.
+*
+* @public
+*/
+const load = (modelPath) => Effect.suspend(() => {
+	const resolved = resolve(modelPath);
+	if (!existsSync(resolved)) return Effect.fail(new ModelNotFoundError({ modelPath: resolved }));
+	return Effect.try({
+		try: () => new ApiModel().loadPackage(resolved),
+		catch: (cause) => new ModelParseError({
+			modelPath: resolved,
+			reason: cause instanceof Error ? cause.message : String(cause)
+		})
+	});
+});
+/**
+* Extract the first (only) package from an already-constructed `ApiModel` —
+* the user-supplied-loader path, where the caller obtained the model itself.
+*
+* @public
+*/
+const firstPackage = (model) => {
+	const pkg = model.packages[0];
+	return pkg !== void 0 ? Effect.succeed(pkg) : Effect.fail(new EmptyModelError({ reason: "API model contains no packages" }));
+};
+
+//#endregion
+export { EmptyModelError, ModelNotFoundError, ModelParseError, Model_exports, firstPackage, load };

package/README.md

@@ -1,102 +1,105 @@
 # @tsdoctor/model
 
-[![npm](https://img.shields.io/npm/v/@tsdoctor/model?label=npm&color=cb3837)](https://www.npmjs.com/package/@tsdoctor/model)
+[![npm](https://img.shields.io/npm/v/@tsdoctor%2Fmodel?label=npm&color=cb3837)](https://www.npmjs.com/package/@tsdoctor/model)
 [![License: MIT](https://img.shields.io/badge/License-MIT-4caf50.svg)](https://opensource.org/licenses/MIT)
-[![Node.js](https://img.shields.io/badge/Node.js-5fa04e.svg)](https://nodejs.org/)
-[![TypeScript](https://img.shields.io/badge/TypeScript-3178c6.svg)](https://www.typescriptlang.org/)
+[![Node.js %3E%3D24.11.0](https://img.shields.io/badge/Node.js-%3E%3D24.11.0-5fa04e.svg)](https://nodejs.org/)
+[![TypeScript 6.0](https://img.shields.io/badge/TypeScript-6.0-3178c6.svg)](https://www.typescriptlang.org/)
 
-Turn a Microsoft API Extractor `.api.json` model into plain markdown that reads cleanly for both people and language models. You get one markdown document per top-level export — an H1, the summary, a fenced `ts` signature, parameters, returns, container members and examples — with no site chrome, no HTML and no framework coupling.
+Framework-neutral analysis and rendering for Microsoft API Extractor `.api.json` models: Effect-typed loading, pure TSDoc extraction, categorization, multi-entry-point resolution, route/collision computation, synthetic-base detection, type-signature formatting, prose cross-linking and markdown rendering.
 
 ## Why @tsdoctor/model
 
-API Extractor already understands your `.d.ts` surface. What it will not do is hand you docs you can drop into a prompt, a wiki or a static site. That is the gap this package closes. The body of every rendered doc stays the same no matter where it ends up. Two things change between consumers: the frontmatter block at the top and the URL scheme for cross-links. You inject both, so one renderer feeds an RSPress site, an MCP server or a folder of bare `.md` files.
+API Extractor's `.api.json` gives you a full symbol graph but no opinion on what to do with it. Turning that graph into documentation means walking TSDoc comments, formatting signatures, deduplicating re-exports across entry points, and deciding where each item's page lives — the same handful of problems every static-doc adapter (RSPress, VitePress, an MCP server, a folder of plain markdown) solves independently. This package solves them once, as pure functions and namespace modules with no I/O beyond loading the model file, so an adapter supplies only the two things that actually differ between consumers: frontmatter and the URL scheme.
 
 ## Install
 
 ```bash
 npm install @tsdoctor/model
-# or
+```
+
+```bash
 pnpm add @tsdoctor/model
 ```
 
-The package is also published to GitHub Packages as `@spencerbeggs/@tsdoctor/model` if you prefer the scoped name; point your registry at `https://npm.pkg.github.com` for that scope and install it the same way.
+Requires Node.js >=24.11.0. This is an ESM-only package.
 
-This is an ESM-only package. Import it from a module context (`"type": "module"` or `.mjs`).
+`@effected/markdown` and `effect` are required peers (`Render` builds its output as `@effected/markdown` node trees). `@effected/package-json` is an optional peer, needed only by the `StructuredData` seam.
 
 ## Quick start
 
-Load a model, render it, then write each doc wherever you want. The library does no I/O of its own. File writing is yours.
+Load a model, render every top-level export to markdown, and write the files wherever you want — the library does no file I/O beyond the `Model.load` read itself.
 
 ```ts
 import { mkdir, writeFile } from "node:fs/promises";
-import { loadApiModel, renderPackage } from "@tsdoctor/model";
+import { Effect } from "effect";
+import { Model, Render } from "@tsdoctor/model";
 
-const pkg = await loadApiModel("./temp/my-pkg.api.json");
+const program = Effect.gen(function* () {
+  const pkg = yield* Model.load("./temp/my-pkg.api.json");
 
-const docs = renderPackage(pkg, {
-  packageName: "my-pkg",
-  routeFor: (ref) => `/api/${ref.slug}`,
-});
+  const docs = Render.docs(pkg, {
+    packageName: "my-pkg",
+    routeFor: (ref) => `/api/${ref.slug}`,
+    frontmatter: (meta) => `---\ntitle: ${meta.name}\nkind: ${meta.kind}\n---\n\n`,
+  });
+
+  yield* Effect.promise(() => mkdir("./out", { recursive: true }));
+  for (const doc of docs) {
+    yield* Effect.promise(() => writeFile(`./out/${doc.slug}.md`, doc.markdown));
+  }
 
-await mkdir("./out", { recursive: true });
-for (const doc of docs) {
-  await writeFile(`./out/${doc.slug}.md`, doc.markdown);
-}
+  return docs;
+});
 
+const docs = await Effect.runPromise(program);
 console.log(docs.map((d) => `${d.kind}: ${d.name}`));
-// e.g. [ 'function: loadApiModel', 'class: CrossLinker', 'type: RenderedDoc' ]
+// e.g. [ 'function: load', 'class: CrossLinker', 'interface: RenderedDoc' ]
 // (the actual list depends on your model's exports)
 ```
 
-Each entry in the returned array is a `RenderedDoc` with `name`, `kind`, `slug`, `summary`, `packageName` and the assembled `markdown`.
+`Model.load` fails with `ModelNotFoundError` or `ModelParseError` on the Effect error channel rather than throwing — a missing or malformed `.api.json` is an expected failure mode for a build pipeline, not a defect. `Render.docs` returns one `RenderedDoc` (`name`, `kind`, `slug`, `summary`, `packageName`, `markdown`) per top-level, emittable export.
+
+`routeFor` and `frontmatter` are independent — supply either, both, or neither. Without `routeFor`, item names in prose are left unlinked; without `frontmatter`, `markdown` is the bare body.
 
-### Inject frontmatter
+### Render a single item
 
-Pass a `frontmatter` function to prepend a block — YAML, TOML or whatever your target expects. Omit it for bare bodies.
+`Render.item` renders one `ApiItem` without walking the whole package — useful when a caller already has categorized items (via `ApiItems.categorize`) and wants to drive its own page-assembly loop.
 
 ```ts
-const docs = renderPackage(pkg, {
-  packageName: "my-pkg",
-  frontmatter: (meta) => `---\ntitle: ${meta.name}\nkind: ${meta.kind}\n---\n\n`,
-});
+import { Render } from "@tsdoctor/model";
 
-console.log(docs[0].markdown.startsWith("---"));
-// true
+const body = Render.item(apiItem, { packageName: "my-pkg" });
+console.log(body.startsWith("#"));
+// true — every rendered body opens with an H1 of the item's display name
 ```
 
-`routeFor` and `frontmatter` are independent. Supply either, both or neither.
-
-### Filter exports
-
-By default `renderPackage` drops compiler-synthetic forgotten exports — the `*_base` classes TypeScript hoists for Effect class mixins, which API Extractor keeps in the model when it runs with `includeForgottenExports: true`. They stay in the `.api.json` (downstream `.d.ts` reconstruction needs them) but never reach the rendered markdown. That default lives in the exported `isEmittable` predicate.
+### Filter which items get a page
 
-Pass your own `filter` to change which top-level items are emitted. A filter that returns `true` keeps the item, both as a rendered doc and as a crosslink target. Supplying a `filter` fully replaces the default, so compose it with `isEmittable` when you want to keep the forgotten-export drop alongside your own rule.
+By default `Render.docs` drops compiler-synthetic forgotten exports — the `*_base` declarations TypeScript hoists for Effect class mixins (`Schema.Class`, `Data.TaggedError`), which stay in the model under `includeForgottenExports: true` but should never be their own page. That default lives in the exported `Render.isEmittable` predicate; `SyntheticBases.detect` finds the same declarations for adapters that want to inline them on the owning class's page instead of dropping them silently.
 
 ```ts
-import { isEmittable, renderPackage } from "@tsdoctor/model";
+import { Render } from "@tsdoctor/model";
 
-const docs = renderPackage(pkg, {
+const docs = Render.docs(pkg, {
   packageName: "my-pkg",
-  filter: (item) => isEmittable(item) && !item.displayName.startsWith("Internal"),
+  filter: (item) => Render.isEmittable(item) && !item.displayName.startsWith("Internal"),
 });
-
-console.log(docs.every((d) => !d.name.startsWith("Internal")));
-// true
 ```
 
-## Features
-
-- `loadApiModel(path)` reads a `.api.json` file from disk and returns its `ApiPackage`.
-- `renderPackage(pkg, opts)` walks the first entry point and returns one `RenderedDoc` per top-level member, dropping compiler-synthetic forgotten exports unless you pass your own `filter`.
-- `renderItem(item, opts)` renders a single API item to a markdown body, with an optional `CrossLinker`.
-- `isEmittable(item)` is the default emit rule — it drops forgotten exports (`isExported === false`) and keeps everything else; compose it into a custom `filter` to keep that behaviour.
-- `CrossLinker` wraps known item names in prose with links, skipping code spans and existing links, using your injected route scheme.
-- `TypeSignatureFormatter` formats an API Extractor `Excerpt` into a clean type signature, wrapping long unions across lines.
-- TSDoc helpers — `getSummary`, `getParams`, `getReturns`, `getExamples`, `getDeprecation`, `getReleaseTag`, `hasModifierTag` and `extractPlainText` — pull plain data off an `ApiItem` with no rendering.
+Supplying `filter` fully replaces the default, so compose it with `Render.isEmittable` to keep the forgotten-export drop.
 
-## Generating a model
+## Features
 
-This package consumes the JSON that [Microsoft API Extractor](https://api-extractor.com/) produces. Run API Extractor against your project first with `docModel.enabled` set in your `api-extractor.json`, then feed the resulting `.api.json` to `loadApiModel`.
+- **`Model`** — Effect-typed `.api.json` loading. `Model.load(path)` returns the package's `ApiPackage` or fails with `ModelNotFoundError` / `ModelParseError`; `Model.firstPackage(apiModel)` extracts a package from a caller-constructed `ApiModel`, failing with `EmptyModelError` if it has none.
+- **`Tsdoc`** — pure extraction off an `ApiItem`: `summary`, `params`, `returns`, `examples`, `deprecation`, `releaseTag`, `hasModifier`, `seeReferences`, plus `plainText`/`toMarkdown` for walking a raw TSDoc `DocNode` tree yourself.
+- **`ApiItems`** — `categorize(items, categories)` groups top-level items by category key (returning `{ items, uncategorized }` so the caller decides how to handle the leftovers), `namespaceMembers` flattens namespace contents with qualified names, `inheritance` reads extends/implements, `sourceLink` builds a source-code URL.
+- **`EntryPoints`** — `resolve(apiPackage)` deduplicates items re-exported from more than one entry point (e.g. `.` and `./testing`) into a flat list, recording every entry point each item is available from.
+- **`Routes`** — `RouteCandidate`, `detectCollisions`, and the typed `RouteCollisionError` for failing a build when two distinct items would resolve to the same output route; `sanitizeId` is the single anchor-id sanitizer for member routes.
+- **`SyntheticBases`** — `detect(items)` finds the unexported `*_base` declarations an exported class's `extends` clause references, so an adapter can inline them instead of generating (or silently dropping) a page for them; `BASE_CLASS_ANCHOR` is the matching anchor id.
+- **`Signature`** — `format(excerpt)` turns an API Extractor `Excerpt` into a clean, line-wrapped type signature string; `stripExportDeclare` strips `export`/`declare` modifiers from declaration text.
+- **`CrossLinker`** — an immutable class that wraps known item names in prose with links, skipping code spans and existing links. Build one per build from a precomputed route map (`CrossLinker.fromRoutes`) or from item refs plus an injected URL scheme (`CrossLinker.fromRefs`); `link` returns markdown links, `linkHtml` returns `<a>` anchors.
+- **`Render`** — the markdown output system. `Render.docs(pkg, opts)` renders a whole package; `Render.item(apiItem, opts)` renders one item; `Render.isEmittable` is the default emit rule. `Render.tree` (`@alpha`) exposes the pre-serialization `@effected/markdown` node tree for a future page-IR consumer.
+- **`StructuredData`** (`@alpha`) — a reserved seam for schema.org JSON-LD derivation. `StructuredData.derive` is not implemented yet and throws if called.
 
 ## License