@tsdoctor/model 0.2.1 → 0.3.0

package/ApiItems.js

@@ -1,4 +1,5 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { memberAnchors as memberAnchors$1, memberRouteKeys as memberRouteKeys$1 } from "./Routes.js";
 import { hasModifier } from "./Tsdoc.js";
 import { ApiItemKind } from "@microsoft/api-extractor-model";
 
@@ -6,6 +7,8 @@ import { ApiItemKind } from "@microsoft/api-extractor-model";
 var ApiItems_exports = /* @__PURE__ */ __exportAll({
 	categorize: () => categorize,
 	inheritance: () => inheritance,
+	memberAnchors: () => memberAnchors,
+	memberRouteKeys: () => memberRouteKeys,
 	namespaceMembers: () => namespaceMembers,
 	sourceLink: () => sourceLink
 });
@@ -106,6 +109,60 @@ function sourceLink(item, target) {
 	const baseUrl = `${target.url}/${ref}`;
 	return lineNumber ? `${baseUrl}/${filePath}#L${lineNumber}` : `${baseUrl}/${filePath}`;
 }
+/**
+* The slot a class member occupies, for anchor disambiguation.
+*
+* @remarks
+* Getters and setters are `Method` items whose display name carries the
+* `get `/`set ` prefix — that is how API Extractor models them.
+*/
+function memberSlot(member) {
+	const isStatic = member.isStatic === true;
+	if (member.kind === "Method" && (member.displayName.startsWith("get ") || member.displayName.startsWith("set "))) return "getter";
+	const isMethod = member.kind === "Method" || member.kind === "MethodSignature";
+	if (isStatic) return isMethod ? "static-method" : "static-property";
+	return isMethod ? "instance-method" : "instance-property";
+}
+/**
+* Anchor id for every member of a class or interface, keyed by the member's
+* canonical reference.
+*
+* @remarks
+* The ONE place an API item is turned into the {@link Routes.MemberRef} shape
+* anchor computation needs. Both the cross-link route map and the rendered
+* page call this, so a member's `#fragment` and its `id=` cannot disagree —
+* which they did before Task 1.1, when each side derived anchors separately.
+*
+* A canonical reference already distinguishes a static member from an
+* instance member of the same name (`Foo.bar` vs `Foo#bar`), so it is the
+* natural key; a member without one falls back to its display name.
+*
+* @public
+*/
+function memberAnchors(item) {
+	return memberAnchors$1(memberRefs(item));
+}
+/** The {@link Routes.MemberRef} view of a class or interface's members. */
+function memberRefs(item) {
+	return item.members.map((member) => ({
+		id: member.canonicalReference?.toString() ?? member.displayName,
+		displayName: member.displayName,
+		slot: memberSlot(member)
+	}));
+}
+/**
+* Cross-link keys for a class or interface's members, mapped to the member's
+* canonical reference.
+*
+* @remarks
+* The {@link Routes.memberRouteKeys} vocabulary over real API items — see
+* there for which keys are emitted and why `Class#member` is not one of them.
+*
+* @public
+*/
+function memberRouteKeys(item) {
+	return memberRouteKeys$1(item.displayName, memberRefs(item));
+}
 
 //#endregion
-export { ApiItems_exports, categorize, inheritance, namespaceMembers, sourceLink };
+export { ApiItems_exports, categorize, inheritance, memberAnchors, memberRouteKeys, namespaceMembers, sourceLink };

package/CrossLinker.js

@@ -10,6 +10,24 @@ import { escapeRegExp } from "./internal/text.js";
 * @packageDocumentation
 */
 /**
+* A word-boundary-anchored pattern for a literal name.
+*
+* @remarks
+* `\b` is an assertion ABOUT the adjacent character, not a delimiter: after a
+* non-word character it matches only when a word character follows. A key in
+* TSDoc selector form — `Registry.(create:instance)` — ends in `)`, so a
+* trailing `\b` made it unmatchable in every realistic sentence position
+* ("See Registry.(create:instance) for details." did not match). Escaping was
+* never the problem; the boundary was. Names that end in a word character —
+* every plain identifier and every `Class.member` key — get the same `\b`
+* they always did, so this is a strict widening.
+*/
+const boundedPattern = (name) => {
+	const lead = /^\w/.test(name) ? "\\b" : "";
+	const trail = /\w$/.test(name) ? "\\b" : "(?!\\w)";
+	return `${lead}${escapeRegExp(name)}${trail}`;
+};
+/**
 * 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.
@@ -47,7 +65,7 @@ var CrossLinker = class CrossLinker {
 		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");
+			const regex = new RegExp(boundedPattern(name), "g");
 			result = result.replace(regex, (match, offset) => {
 				const before = result.slice(0, offset);
 				if (before.endsWith("](") || before.endsWith("[")) return match;
@@ -66,7 +84,7 @@ var CrossLinker = class CrossLinker {
 		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");
+			const regex = new RegExp(`${boundedPattern(name)}(?![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;

package/Model.js

@@ -1,8 +1,8 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { ApiModel } from "@microsoft/api-extractor-model";
+import { Effect, Schema } from "effect";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
-import { Effect, Schema } from "effect";
 
 //#region src/Model.ts
 /**

package/README.md

@@ -92,9 +92,10 @@ Supplying `filter` fully replaces the default, so compose it with `Render.isEmit
 
 - **`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.
+- **`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; `memberAnchors(item)` and `memberRouteKeys(item)` are the `ApiClass` / `ApiInterface` views of the `Routes` functions below.
 - **`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.
+- **`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, with `memberAnchor` as its named alias for one member.
+- **`Routes` member anchors and keys** — `memberAnchors(members)` computes every member's anchor in one pass, keyed by `MemberRef.id`, prefixing the lower-priority member when two sanitize alike (`static create()` keeps `#create`, the instance one becomes `#instance-create`). `memberRouteKeys(className, members)` returns the cross-link keys those anchors answer to: a bare `Class.member` resolves to the static member when a class has both, with `Class.(member:static)`, `Class.(member:instance)` and `Class.prototype.member` emitted to disambiguate. Feed both from the same member list so a page's `id=` and a link's `#fragment` cannot drift.
 - **`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.

package/Render.js

@@ -4,8 +4,8 @@ import { CrossLinker } from "./CrossLinker.js";
 import { phrasingFromMarkdown } from "./internal/prose.js";
 import { format } from "./Signature.js";
 import { ApiItemContainerMixin } from "@microsoft/api-extractor-model";
-import { Blockquote, Code, Heading, InlineCode, List, ListItem, Markdown, Paragraph, Root, Strong, Text } from "@effected/markdown";
 import { Result } from "effect";
+import { Blockquote, Code, Heading, InlineCode, List, ListItem, Markdown, Paragraph, Root, Strong, Text } from "@effected/markdown";
 
 //#region src/Render.ts
 var Render_exports = /* @__PURE__ */ __exportAll({

package/Routes.js

@@ -13,6 +13,9 @@ var Routes_exports = /* @__PURE__ */ __exportAll({
 	RouteCandidate: () => RouteCandidate,
 	RouteCollisionError: () => RouteCollisionError,
 	detectCollisions: () => detectCollisions,
+	memberAnchor: () => memberAnchor,
+	memberAnchors: () => memberAnchors,
+	memberRouteKeys: () => memberRouteKeys,
 	sanitizeId: () => sanitizeId
 });
 /**
@@ -96,8 +99,17 @@ var RouteCollisionError = class extends Schema.TaggedError()("RouteCollisionErro
 /**
 * 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.
+* disambiguation.
+*
+* @remarks
+* The ONE canonical implementation. This docstring made that claim before it
+* was true: the RSPress adapter carried a second, subtly different sanitizer
+* for page-side `id=` attributes (it kept `_`, being in `\w`, and mapped `$`
+* to `-`), so `get_value` was linked as `#get-value` and rendered as
+* `id="get_value"` — a cross-link that landed nowhere. Both sides call this
+* now. Do not add a second spelling; if page ids ever genuinely need
+* different treatment from route anchors, that is a design change, not a
+* local helper.
 *
 * @public
 */
@@ -105,6 +117,149 @@ function sanitizeId(displayName, prefix = "") {
 	const sanitized = displayName.toLowerCase().replace(/[\s_]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/^-+|-+$/g, "");
 	return prefix ? `${prefix}-${sanitized}` : sanitized;
 }
+/**
+* The anchor for a single member, given an already-decided prefix.
+*
+* @remarks
+* A thin alias over {@link sanitizeId} that names the intent at the call site.
+* Prefer {@link memberAnchors} when rendering a whole class — deciding the
+* prefix per member is the part that is easy to get wrong.
+*
+* @public
+*/
+function memberAnchor(displayName, prefix = "") {
+	return sanitizeId(displayName, prefix);
+}
+/**
+* Slots ordered by which keeps the bare anchor when names collide.
+*
+* @remarks
+* Static slots lead because the bare cross-link key `Class.member` canonically
+* means the static member (see {@link memberRouteKeys}). One naming decision
+* applied to both halves: the name that resolves to a member is the name that
+* member's anchor uses.
+*/
+const SLOT_PRIORITY = [
+	"static-method",
+	"static-property",
+	"instance-method",
+	"getter",
+	"instance-property"
+];
+/**
+* The prefix a losing slot is disambiguated with.
+*
+* @remarks
+* The prefix marks the NON-canonical side, so an instance member displaced by
+* a static one becomes `instance-create`. TypeScript forbids two members of
+* one class sharing a name within the same static-ness, so in practice a
+* collision is exactly one static and one instance member and only
+* `"instance"` is ever emitted; the static entries are a total-map fallback.
+*/
+const SLOT_PREFIX = {
+	"static-method": "static",
+	"static-property": "static",
+	"instance-method": "instance",
+	getter: "instance",
+	"instance-property": "instance"
+};
+/**
+* Compute the anchor for every member of one class, keyed by
+* {@link MemberRef.id}.
+*
+* @remarks
+* When several members sanitize to the same anchor, the highest-priority slot
+* keeps the bare anchor and every other member is prefixed
+* (`instance-create`). Priority runs static method, static property, instance
+* method, getter, instance property — static first, so the anchor agrees with
+* the bare cross-link key, which resolves to the static member.
+*
+* The per-MEMBER keying is load-bearing. A previous implementation keyed the
+* prefix by sanitized NAME, so both halves of a `static create()` / `create()`
+* collision looked up the same entry and both rendered
+* `id="static-create"` — two elements sharing one HTML id, and the instance
+* member displaced from the anchor its cross-link pointed at. Keying by
+* member means the loser moves and the winner does not.
+*
+* @public
+*/
+function memberAnchors(members) {
+	const bySanitized = /* @__PURE__ */ new Map();
+	for (const member of members) {
+		const base = sanitizeId(member.displayName);
+		const bucket = bySanitized.get(base);
+		if (bucket) bucket.push(member);
+		else bySanitized.set(base, [member]);
+	}
+	const anchors = /* @__PURE__ */ new Map();
+	for (const bucket of bySanitized.values()) {
+		const winner = bucket.length === 1 ? bucket[0] : [...bucket].sort((a, b) => SLOT_PRIORITY.indexOf(a.slot) - SLOT_PRIORITY.indexOf(b.slot))[0];
+		for (const member of bucket) {
+			const prefix = member === winner ? "" : SLOT_PREFIX[member.slot];
+			anchors.set(member.id, memberAnchor(member.displayName, prefix));
+		}
+	}
+	return anchors;
+}
+/** Static slots, for the `:static` / `:instance` selector split. */
+const STATIC_SLOTS = /* @__PURE__ */ new Set(["static-property", "static-method"]);
+/**
+* Cross-link keys for one class's members, mapped to the member they resolve
+* to ({@link MemberRef.id}).
+*
+* @remarks
+* The bare `Class.member` key resolves to the STATIC member when a class has
+* both a static and an instance member of that name. `Registry.create` is the
+* static access expression in TypeScript — the instance one is
+* `registry.create` — so a prose author writing the qualified form means the
+* static member.
+*
+* The disambiguating keys use TSDoc declaration-reference selectors, the
+* vocabulary API Extractor canonical references already carry:
+*
+* - `Registry.create` — the static member (the common case)
+* - `Registry.(create:instance)` — the instance member
+* - `Registry.(create:static)` — the static member, explicitly
+* - `Registry.prototype.create` — an alias for the instance member; real
+*   JavaScript rather than invented syntax, and what a reader guesses
+*
+* `Class#member` is deliberately NOT emitted. `#` is the URL fragment
+* delimiter, so such a key reads ambiguously beside a route, and in modern
+* TypeScript `#` denotes a PRIVATE field (`this.#count`) — the JSDoc
+* convention predates both and has aged badly.
+*
+* Selector keys are emitted ONLY when a collision exists. On the
+* overwhelmingly common class with no name collision the bare key is
+* complete, and every extra key is one more pattern the prose cross-linker
+* compiles and tests against every string it links.
+*
+* @public
+*/
+function memberRouteKeys(className, members) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const member of members) {
+		const bucket = byName.get(member.displayName);
+		if (bucket) bucket.push(member);
+		else byName.set(member.displayName, [member]);
+	}
+	const keys = /* @__PURE__ */ new Map();
+	for (const [displayName, bucket] of byName) {
+		const statics = bucket.filter((m) => STATIC_SLOTS.has(m.slot));
+		const instances = bucket.filter((m) => !STATIC_SLOTS.has(m.slot));
+		const collides = statics.length > 0 && instances.length > 0;
+		const bare = statics[0] ?? instances[0];
+		if (bare) keys.set(`${className}.${displayName}`, bare.id);
+		if (!collides) continue;
+		const staticMember = statics[0];
+		const instanceMember = instances[0];
+		if (staticMember) keys.set(`${className}.(${displayName}:static)`, staticMember.id);
+		if (instanceMember) {
+			keys.set(`${className}.(${displayName}:instance)`, instanceMember.id);
+			keys.set(`${className}.prototype.${displayName}`, instanceMember.id);
+		}
+	}
+	return keys;
+}
 
 //#endregion
-export { RouteCandidate, RouteCollisionError, Routes_exports, detectCollisions, sanitizeId };
+export { RouteCandidate, RouteCollisionError, Routes_exports, detectCollisions, memberAnchor, memberAnchors, memberRouteKeys, sanitizeId };

package/index.d.ts

@@ -45,7 +45,7 @@ declare function entryPointName(displayName: string): string;
  */
 declare function resolve(apiPackage: ApiPackage): ResolvedEntryItem[];
 declare namespace ApiItems_d_exports {
-  export { CategorizedItems, CategorySpec, Inheritance, NamespaceMember, SourceLinkTarget, categorize, inheritance, namespaceMembers, sourceLink };
+  export { CategorizedItems, CategorySpec, Inheritance, NamespaceMember, SourceLinkTarget, categorize, inheritance, memberAnchors$1 as memberAnchors, memberRouteKeys$1 as memberRouteKeys, namespaceMembers, sourceLink };
 }
 /**
  * The category rules `categorize` reads — a structural subset of a consumer's
@@ -133,6 +133,34 @@ declare function inheritance(item: ApiClass | ApiInterface): Inheritance;
  * @public
  */
 declare function sourceLink(item: ApiItem, target?: SourceLinkTarget): string | null;
+/**
+ * Anchor id for every member of a class or interface, keyed by the member's
+ * canonical reference.
+ *
+ * @remarks
+ * The ONE place an API item is turned into the {@link Routes.MemberRef} shape
+ * anchor computation needs. Both the cross-link route map and the rendered
+ * page call this, so a member's `#fragment` and its `id=` cannot disagree —
+ * which they did before Task 1.1, when each side derived anchors separately.
+ *
+ * A canonical reference already distinguishes a static member from an
+ * instance member of the same name (`Foo.bar` vs `Foo#bar`), so it is the
+ * natural key; a member without one falls back to its display name.
+ *
+ * @public
+ */
+declare function memberAnchors$1(item: ApiClass | ApiInterface): ReadonlyMap<string, string>;
+/**
+ * Cross-link keys for a class or interface's members, mapped to the member's
+ * canonical reference.
+ *
+ * @remarks
+ * The {@link Routes.memberRouteKeys} vocabulary over real API items — see
+ * there for which keys are emitted and why `Class#member` is not one of them.
+ *
+ * @public
+ */
+declare function memberRouteKeys$1(item: ApiClass | ApiInterface): ReadonlyMap<string, string>;
 //#endregion
 //#region src/types.d.ts
 /**
@@ -335,7 +363,7 @@ declare function item(apiItem: ApiItem, opts: RenderItemOptions): string;
  */
 declare function docs(apiPackage: ApiPackage, opts: RenderPackageOptions): RenderedDoc[];
 declare namespace Routes_d_exports {
-  export { RouteCandidate, RouteCollision, RouteCollisionError, detectCollisions, sanitizeId };
+  export { MemberRef, MemberSlot, RouteCandidate, RouteCollision, RouteCollisionError, detectCollisions, memberAnchor, memberAnchors, memberRouteKeys, sanitizeId };
 }
 declare const RouteCandidate_base: Schema.Class<RouteCandidate, Schema.Struct<{
   /** Stable identity (e.g. `"displayName::kind"` or a namespace qualified name). */
@@ -404,12 +432,112 @@ declare class RouteCollisionError extends RouteCollisionError_base {
 /**
  * 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.
+ * disambiguation.
+ *
+ * @remarks
+ * The ONE canonical implementation. This docstring made that claim before it
+ * was true: the RSPress adapter carried a second, subtly different sanitizer
+ * for page-side `id=` attributes (it kept `_`, being in `\w`, and mapped `$`
+ * to `-`), so `get_value` was linked as `#get-value` and rendered as
+ * `id="get_value"` — a cross-link that landed nowhere. Both sides call this
+ * now. Do not add a second spelling; if page ids ever genuinely need
+ * different treatment from route anchors, that is a design change, not a
+ * local helper.
  *
  * @public
  */
 declare function sanitizeId(displayName: string, prefix?: string): string;
+/**
+ * Which slot a class member occupies. Two members may share a display name
+ * while occupying different slots (a `static create()` beside an instance
+ * `create()`), which is what {@link memberAnchors} disambiguates.
+ *
+ * @public
+ */
+type MemberSlot = "static-property" | "static-method" | "instance-property" | "instance-method" | "getter";
+/**
+ * One class member, identified for anchor computation.
+ *
+ * @public
+ */
+interface MemberRef {
+  /**
+   * Caller-supplied stable identity, unique per member. An API Extractor
+   * `canonicalReference` is the natural choice: it already distinguishes a
+   * static member from an instance member of the same name (`Foo.bar` vs
+   * `Foo#bar`), so the caller never has to re-derive that distinction.
+   */
+  readonly id: string;
+  /** The member's display name, as written in the source. */
+  readonly displayName: string;
+  /** The slot the member occupies. */
+  readonly slot: MemberSlot;
+}
+/**
+ * The anchor for a single member, given an already-decided prefix.
+ *
+ * @remarks
+ * A thin alias over {@link sanitizeId} that names the intent at the call site.
+ * Prefer {@link memberAnchors} when rendering a whole class — deciding the
+ * prefix per member is the part that is easy to get wrong.
+ *
+ * @public
+ */
+declare function memberAnchor(displayName: string, prefix?: string): string;
+/**
+ * Compute the anchor for every member of one class, keyed by
+ * {@link MemberRef.id}.
+ *
+ * @remarks
+ * When several members sanitize to the same anchor, the highest-priority slot
+ * keeps the bare anchor and every other member is prefixed
+ * (`instance-create`). Priority runs static method, static property, instance
+ * method, getter, instance property — static first, so the anchor agrees with
+ * the bare cross-link key, which resolves to the static member.
+ *
+ * The per-MEMBER keying is load-bearing. A previous implementation keyed the
+ * prefix by sanitized NAME, so both halves of a `static create()` / `create()`
+ * collision looked up the same entry and both rendered
+ * `id="static-create"` — two elements sharing one HTML id, and the instance
+ * member displaced from the anchor its cross-link pointed at. Keying by
+ * member means the loser moves and the winner does not.
+ *
+ * @public
+ */
+declare function memberAnchors(members: readonly MemberRef[]): ReadonlyMap<string, string>;
+/**
+ * Cross-link keys for one class's members, mapped to the member they resolve
+ * to ({@link MemberRef.id}).
+ *
+ * @remarks
+ * The bare `Class.member` key resolves to the STATIC member when a class has
+ * both a static and an instance member of that name. `Registry.create` is the
+ * static access expression in TypeScript — the instance one is
+ * `registry.create` — so a prose author writing the qualified form means the
+ * static member.
+ *
+ * The disambiguating keys use TSDoc declaration-reference selectors, the
+ * vocabulary API Extractor canonical references already carry:
+ *
+ * - `Registry.create` — the static member (the common case)
+ * - `Registry.(create:instance)` — the instance member
+ * - `Registry.(create:static)` — the static member, explicitly
+ * - `Registry.prototype.create` — an alias for the instance member; real
+ *   JavaScript rather than invented syntax, and what a reader guesses
+ *
+ * `Class#member` is deliberately NOT emitted. `#` is the URL fragment
+ * delimiter, so such a key reads ambiguously beside a route, and in modern
+ * TypeScript `#` denotes a PRIVATE field (`this.#count`) — the JSDoc
+ * convention predates both and has aged badly.
+ *
+ * Selector keys are emitted ONLY when a collision exists. On the
+ * overwhelmingly common class with no name collision the bare key is
+ * complete, and every extra key is one more pattern the prose cross-linker
+ * compiles and tests against every string it links.
+ *
+ * @public
+ */
+declare function memberRouteKeys(className: string, members: readonly MemberRef[]): ReadonlyMap<string, string>;
 declare namespace Signature_d_exports {
   export { FormatOptions, format, linkReferences, stripExportDeclare };
 }

package/index.js

@@ -1,3 +1,4 @@
+import { Routes_exports } from "./Routes.js";
 import { Tsdoc_exports } from "./Tsdoc.js";
 import { ApiItems_exports } from "./ApiItems.js";
 import { CrossLinker } from "./CrossLinker.js";
@@ -5,7 +6,6 @@ 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";
 

package/internal/prose.js

@@ -1,5 +1,5 @@
-import { Markdown, Text } from "@effected/markdown";
 import { Result } from "effect";
+import { Markdown, Text } from "@effected/markdown";
 
 //#region src/internal/prose.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsdoctor/model",
-	"version": "0.2.1",
+	"version": "0.3.0",
 	"private": false,
 	"description": "Render Microsoft API Extractor models into LLM-lean markdown. Pure model loading, TSDoc extraction, type-signature formatting, and per-item markdown rendering.",
 	"keywords": [
@@ -38,7 +38,7 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@microsoft/api-extractor-model": "^7.33.10",
+		"@microsoft/api-extractor-model": "^7.33.11",
 		"@microsoft/tsdoc": "^0.16.0"
 	},
 	"peerDependencies": {