nimbus-docs 0.1.4 → 0.1.5

package/dist/index.js

@@ -1,14 +1,16 @@
-import { t as withStrictKeys } from "./strict-keys-D06tc9YZ.js";
+import { o as validateLintOptions, r as suggest, t as IMPLEMENTED_CODES } from "./rules-DnAP-j89.js";
+import { t as withStrictKeys } from "./strict-keys-BiXiT3pq.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import mdx from "@astrojs/mdx";
 import { satteri } from "@astrojs/markdown-satteri";
 import sitemap from "@astrojs/sitemap";
-import fs from "node:fs/promises";
-import { transformerMetaHighlight, transformerMetaWordHighlight, transformerNotationDiff, transformerNotationErrorLevel, transformerNotationFocus, transformerNotationHighlight, transformerNotationWordHighlight } from "@shikijs/transformers";
+import fs$1 from "node:fs/promises";
 import { z } from "astro/zod";
+import { transformerMetaHighlight, transformerMetaWordHighlight, transformerNotationDiff, transformerNotationErrorLevel, transformerNotationFocus, transformerNotationHighlight, transformerNotationWordHighlight } from "@shikijs/transformers";
 
 //#region src/_internal/runtime-config.ts
 let _cached = null;
@@ -16,8 +18,9 @@ let _cachedCollections = null;
 let _cachedAlternates = null;
 async function loadNimbusConfig() {
 	if (_cached) return _cached;
-	_cached = (await import("virtual:nimbus/config")).config;
-	return _cached;
+	const value = (await import("virtual:nimbus/config")).config;
+	_cached = value;
+	return value;
 }
 /**
 * Build-time-resolved list of collections the agent-facing routes
@@ -26,8 +29,9 @@ async function loadNimbusConfig() {
 */
 async function loadIndexedCollections() {
 	if (_cachedCollections) return _cachedCollections;
-	_cachedCollections = (await import("virtual:nimbus/config")).indexedCollections;
-	return _cachedCollections;
+	const value = (await import("virtual:nimbus/config")).indexedCollections;
+	_cachedCollections = value;
+	return value;
 }
 /**
 * Build-time-resolved alternates table for cross-version SEO links.
@@ -36,14 +40,15 @@ async function loadIndexedCollections() {
 */
 async function loadVersionAlternates() {
 	if (_cachedAlternates) return _cachedAlternates;
-	_cachedAlternates = (await import("virtual:nimbus/config")).versionAlternates ?? {};
-	return _cachedAlternates;
+	const value = (await import("virtual:nimbus/config")).versionAlternates ?? {};
+	_cachedAlternates = value;
+	return value;
 }
 
 //#endregion
 //#region src/_internal/content.ts
 /** Primary collection name. Hard-coded — see also `getDocsStaticPaths`. */
-const PRIMARY_COLLECTION$3 = "docs";
+const PRIMARY_COLLECTION$2 = "docs";
 /**
 * Return visible entries from one or more collections. Drafts are
 * filtered out in production builds (matching the existing
@@ -58,7 +63,7 @@ const PRIMARY_COLLECTION$3 = "docs";
 * time. Callers that need per-collection type safety should call
 * `getCollection("api")` directly.
 */
-async function getVisibleEntries(collections = [PRIMARY_COLLECTION$3]) {
+async function getVisibleEntries(collections = [PRIMARY_COLLECTION$2]) {
 	const { getCollection } = await import("astro:content");
 	const all = (await Promise.all(collections.map((name) => getCollection(name).catch(() => [])))).flat();
 	return import.meta.env.PROD ? all.filter((entry) => !entry.data.draft) : all;
@@ -78,6 +83,191 @@ async function getVisibleEntriesByCollection(collections) {
 	return out;
 }
 
+//#endregion
+//#region ../../node_modules/.pnpm/github-slugger@2.0.0/node_modules/github-slugger/regex.js
+const regex = /[\0-\x1F!-,\.\/:-@\[-\^`\{-\xA9\xAB-\xB4\xB6-\xB9\xBB-\xBF\xD7\xF7\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0378\u0379\u037E\u0380-\u0385\u0387\u038B\u038D\u03A2\u03F6\u0482\u0530\u0557\u0558\u055A-\u055F\u0589-\u0590\u05BE\u05C0\u05C3\u05C6\u05C8-\u05CF\u05EB-\u05EE\u05F3-\u060F\u061B-\u061F\u066A-\u066D\u06D4\u06DD\u06DE\u06E9\u06FD\u06FE\u0700-\u070F\u074B\u074C\u07B2-\u07BF\u07F6-\u07F9\u07FB\u07FC\u07FE\u07FF\u082E-\u083F\u085C-\u085F\u086B-\u089F\u08B5\u08C8-\u08D2\u08E2\u0964\u0965\u0970\u0984\u098D\u098E\u0991\u0992\u09A9\u09B1\u09B3-\u09B5\u09BA\u09BB\u09C5\u09C6\u09C9\u09CA\u09CF-\u09D6\u09D8-\u09DB\u09DE\u09E4\u09E5\u09F2-\u09FB\u09FD\u09FF\u0A00\u0A04\u0A0B-\u0A0E\u0A11\u0A12\u0A29\u0A31\u0A34\u0A37\u0A3A\u0A3B\u0A3D\u0A43-\u0A46\u0A49\u0A4A\u0A4E-\u0A50\u0A52-\u0A58\u0A5D\u0A5F-\u0A65\u0A76-\u0A80\u0A84\u0A8E\u0A92\u0AA9\u0AB1\u0AB4\u0ABA\u0ABB\u0AC6\u0ACA\u0ACE\u0ACF\u0AD1-\u0ADF\u0AE4\u0AE5\u0AF0-\u0AF8\u0B00\u0B04\u0B0D\u0B0E\u0B11\u0B12\u0B29\u0B31\u0B34\u0B3A\u0B3B\u0B45\u0B46\u0B49\u0B4A\u0B4E-\u0B54\u0B58-\u0B5B\u0B5E\u0B64\u0B65\u0B70\u0B72-\u0B81\u0B84\u0B8B-\u0B8D\u0B91\u0B96-\u0B98\u0B9B\u0B9D\u0BA0-\u0BA2\u0BA5-\u0BA7\u0BAB-\u0BAD\u0BBA-\u0BBD\u0BC3-\u0BC5\u0BC9\u0BCE\u0BCF\u0BD1-\u0BD6\u0BD8-\u0BE5\u0BF0-\u0BFF\u0C0D\u0C11\u0C29\u0C3A-\u0C3C\u0C45\u0C49\u0C4E-\u0C54\u0C57\u0C5B-\u0C5F\u0C64\u0C65\u0C70-\u0C7F\u0C84\u0C8D\u0C91\u0CA9\u0CB4\u0CBA\u0CBB\u0CC5\u0CC9\u0CCE-\u0CD4\u0CD7-\u0CDD\u0CDF\u0CE4\u0CE5\u0CF0\u0CF3-\u0CFF\u0D0D\u0D11\u0D45\u0D49\u0D4F-\u0D53\u0D58-\u0D5E\u0D64\u0D65\u0D70-\u0D79\u0D80\u0D84\u0D97-\u0D99\u0DB2\u0DBC\u0DBE\u0DBF\u0DC7-\u0DC9\u0DCB-\u0DCE\u0DD5\u0DD7\u0DE0-\u0DE5\u0DF0\u0DF1\u0DF4-\u0E00\u0E3B-\u0E3F\u0E4F\u0E5A-\u0E80\u0E83\u0E85\u0E8B\u0EA4\u0EA6\u0EBE\u0EBF\u0EC5\u0EC7\u0ECE\u0ECF\u0EDA\u0EDB\u0EE0-\u0EFF\u0F01-\u0F17\u0F1A-\u0F1F\u0F2A-\u0F34\u0F36\u0F38\u0F3A-\u0F3D\u0F48\u0F6D-\u0F70\u0F85\u0F98\u0FBD-\u0FC5\u0FC7-\u0FFF\u104A-\u104F\u109E\u109F\u10C6\u10C8-\u10CC\u10CE\u10CF\u10FB\u1249\u124E\u124F\u1257\u1259\u125E\u125F\u1289\u128E\u128F\u12B1\u12B6\u12B7\u12BF\u12C1\u12C6\u12C7\u12D7\u1311\u1316\u1317\u135B\u135C\u1360-\u137F\u1390-\u139F\u13F6\u13F7\u13FE-\u1400\u166D\u166E\u1680\u169B-\u169F\u16EB-\u16ED\u16F9-\u16FF\u170D\u1715-\u171F\u1735-\u173F\u1754-\u175F\u176D\u1771\u1774-\u177F\u17D4-\u17D6\u17D8-\u17DB\u17DE\u17DF\u17EA-\u180A\u180E\u180F\u181A-\u181F\u1879-\u187F\u18AB-\u18AF\u18F6-\u18FF\u191F\u192C-\u192F\u193C-\u1945\u196E\u196F\u1975-\u197F\u19AC-\u19AF\u19CA-\u19CF\u19DA-\u19FF\u1A1C-\u1A1F\u1A5F\u1A7D\u1A7E\u1A8A-\u1A8F\u1A9A-\u1AA6\u1AA8-\u1AAF\u1AC1-\u1AFF\u1B4C-\u1B4F\u1B5A-\u1B6A\u1B74-\u1B7F\u1BF4-\u1BFF\u1C38-\u1C3F\u1C4A-\u1C4C\u1C7E\u1C7F\u1C89-\u1C8F\u1CBB\u1CBC\u1CC0-\u1CCF\u1CD3\u1CFB-\u1CFF\u1DFA\u1F16\u1F17\u1F1E\u1F1F\u1F46\u1F47\u1F4E\u1F4F\u1F58\u1F5A\u1F5C\u1F5E\u1F7E\u1F7F\u1FB5\u1FBD\u1FBF-\u1FC1\u1FC5\u1FCD-\u1FCF\u1FD4\u1FD5\u1FDC-\u1FDF\u1FED-\u1FF1\u1FF5\u1FFD-\u203E\u2041-\u2053\u2055-\u2070\u2072-\u207E\u2080-\u208F\u209D-\u20CF\u20F1-\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u2140-\u2144\u214A-\u214D\u214F-\u215F\u2189-\u24B5\u24EA-\u2BFF\u2C2F\u2C5F\u2CE5-\u2CEA\u2CF4-\u2CFF\u2D26\u2D28-\u2D2C\u2D2E\u2D2F\u2D68-\u2D6E\u2D70-\u2D7E\u2D97-\u2D9F\u2DA7\u2DAF\u2DB7\u2DBF\u2DC7\u2DCF\u2DD7\u2DDF\u2E00-\u2E2E\u2E30-\u3004\u3008-\u3020\u3030\u3036\u3037\u303D-\u3040\u3097\u3098\u309B\u309C\u30A0\u30FB\u3100-\u3104\u3130\u318F-\u319F\u31C0-\u31EF\u3200-\u33FF\u4DC0-\u4DFF\u9FFD-\u9FFF\uA48D-\uA4CF\uA4FE\uA4FF\uA60D-\uA60F\uA62C-\uA63F\uA673\uA67E\uA6F2-\uA716\uA720\uA721\uA789\uA78A\uA7C0\uA7C1\uA7CB-\uA7F4\uA828-\uA82B\uA82D-\uA83F\uA874-\uA87F\uA8C6-\uA8CF\uA8DA-\uA8DF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA954-\uA95F\uA97D-\uA97F\uA9C1-\uA9CE\uA9DA-\uA9DF\uA9FF\uAA37-\uAA3F\uAA4E\uAA4F\uAA5A-\uAA5F\uAA77-\uAA79\uAAC3-\uAADA\uAADE\uAADF\uAAF0\uAAF1\uAAF7-\uAB00\uAB07\uAB08\uAB0F\uAB10\uAB17-\uAB1F\uAB27\uAB2F\uAB5B\uAB6A-\uAB6F\uABEB\uABEE\uABEF\uABFA-\uABFF\uD7A4-\uD7AF\uD7C7-\uD7CA\uD7FC-\uD7FF\uE000-\uF8FF\uFA6E\uFA6F\uFADA-\uFAFF\uFB07-\uFB12\uFB18-\uFB1C\uFB29\uFB37\uFB3D\uFB3F\uFB42\uFB45\uFBB2-\uFBD2\uFD3E-\uFD4F\uFD90\uFD91\uFDC8-\uFDEF\uFDFC-\uFDFF\uFE10-\uFE1F\uFE30-\uFE32\uFE35-\uFE4C\uFE50-\uFE6F\uFE75\uFEFD-\uFF0F\uFF1A-\uFF20\uFF3B-\uFF3E\uFF40\uFF5B-\uFF65\uFFBF-\uFFC1\uFFC8\uFFC9\uFFD0\uFFD1\uFFD8\uFFD9\uFFDD-\uFFFF]|\uD800[\uDC0C\uDC27\uDC3B\uDC3E\uDC4E\uDC4F\uDC5E-\uDC7F\uDCFB-\uDD3F\uDD75-\uDDFC\uDDFE-\uDE7F\uDE9D-\uDE9F\uDED1-\uDEDF\uDEE1-\uDEFF\uDF20-\uDF2C\uDF4B-\uDF4F\uDF7B-\uDF7F\uDF9E\uDF9F\uDFC4-\uDFC7\uDFD0\uDFD6-\uDFFF]|\uD801[\uDC9E\uDC9F\uDCAA-\uDCAF\uDCD4-\uDCD7\uDCFC-\uDCFF\uDD28-\uDD2F\uDD64-\uDDFF\uDF37-\uDF3F\uDF56-\uDF5F\uDF68-\uDFFF]|\uD802[\uDC06\uDC07\uDC09\uDC36\uDC39-\uDC3B\uDC3D\uDC3E\uDC56-\uDC5F\uDC77-\uDC7F\uDC9F-\uDCDF\uDCF3\uDCF6-\uDCFF\uDD16-\uDD1F\uDD3A-\uDD7F\uDDB8-\uDDBD\uDDC0-\uDDFF\uDE04\uDE07-\uDE0B\uDE14\uDE18\uDE36\uDE37\uDE3B-\uDE3E\uDE40-\uDE5F\uDE7D-\uDE7F\uDE9D-\uDEBF\uDEC8\uDEE7-\uDEFF\uDF36-\uDF3F\uDF56-\uDF5F\uDF73-\uDF7F\uDF92-\uDFFF]|\uD803[\uDC49-\uDC7F\uDCB3-\uDCBF\uDCF3-\uDCFF\uDD28-\uDD2F\uDD3A-\uDE7F\uDEAA\uDEAD-\uDEAF\uDEB2-\uDEFF\uDF1D-\uDF26\uDF28-\uDF2F\uDF51-\uDFAF\uDFC5-\uDFDF\uDFF7-\uDFFF]|\uD804[\uDC47-\uDC65\uDC70-\uDC7E\uDCBB-\uDCCF\uDCE9-\uDCEF\uDCFA-\uDCFF\uDD35\uDD40-\uDD43\uDD48-\uDD4F\uDD74\uDD75\uDD77-\uDD7F\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDFF\uDE12\uDE38-\uDE3D\uDE3F-\uDE7F\uDE87\uDE89\uDE8E\uDE9E\uDEA9-\uDEAF\uDEEB-\uDEEF\uDEFA-\uDEFF\uDF04\uDF0D\uDF0E\uDF11\uDF12\uDF29\uDF31\uDF34\uDF3A\uDF45\uDF46\uDF49\uDF4A\uDF4E\uDF4F\uDF51-\uDF56\uDF58-\uDF5C\uDF64\uDF65\uDF6D-\uDF6F\uDF75-\uDFFF]|\uD805[\uDC4B-\uDC4F\uDC5A-\uDC5D\uDC62-\uDC7F\uDCC6\uDCC8-\uDCCF\uDCDA-\uDD7F\uDDB6\uDDB7\uDDC1-\uDDD7\uDDDE-\uDDFF\uDE41-\uDE43\uDE45-\uDE4F\uDE5A-\uDE7F\uDEB9-\uDEBF\uDECA-\uDEFF\uDF1B\uDF1C\uDF2C-\uDF2F\uDF3A-\uDFFF]|\uD806[\uDC3B-\uDC9F\uDCEA-\uDCFE\uDD07\uDD08\uDD0A\uDD0B\uDD14\uDD17\uDD36\uDD39\uDD3A\uDD44-\uDD4F\uDD5A-\uDD9F\uDDA8\uDDA9\uDDD8\uDDD9\uDDE2\uDDE5-\uDDFF\uDE3F-\uDE46\uDE48-\uDE4F\uDE9A-\uDE9C\uDE9E-\uDEBF\uDEF9-\uDFFF]|\uD807[\uDC09\uDC37\uDC41-\uDC4F\uDC5A-\uDC71\uDC90\uDC91\uDCA8\uDCB7-\uDCFF\uDD07\uDD0A\uDD37-\uDD39\uDD3B\uDD3E\uDD48-\uDD4F\uDD5A-\uDD5F\uDD66\uDD69\uDD8F\uDD92\uDD99-\uDD9F\uDDAA-\uDEDF\uDEF7-\uDFAF\uDFB1-\uDFFF]|\uD808[\uDF9A-\uDFFF]|\uD809[\uDC6F-\uDC7F\uDD44-\uDFFF]|[\uD80A\uD80B\uD80E-\uD810\uD812-\uD819\uD824-\uD82B\uD82D\uD82E\uD830-\uD833\uD837\uD839\uD83D\uD83F\uD87B-\uD87D\uD87F\uD885-\uDB3F\uDB41-\uDBFF][\uDC00-\uDFFF]|\uD80D[\uDC2F-\uDFFF]|\uD811[\uDE47-\uDFFF]|\uD81A[\uDE39-\uDE3F\uDE5F\uDE6A-\uDECF\uDEEE\uDEEF\uDEF5-\uDEFF\uDF37-\uDF3F\uDF44-\uDF4F\uDF5A-\uDF62\uDF78-\uDF7C\uDF90-\uDFFF]|\uD81B[\uDC00-\uDE3F\uDE80-\uDEFF\uDF4B-\uDF4E\uDF88-\uDF8E\uDFA0-\uDFDF\uDFE2\uDFE5-\uDFEF\uDFF2-\uDFFF]|\uD821[\uDFF8-\uDFFF]|\uD823[\uDCD6-\uDCFF\uDD09-\uDFFF]|\uD82C[\uDD1F-\uDD4F\uDD53-\uDD63\uDD68-\uDD6F\uDEFC-\uDFFF]|\uD82F[\uDC6B-\uDC6F\uDC7D-\uDC7F\uDC89-\uDC8F\uDC9A-\uDC9C\uDC9F-\uDFFF]|\uD834[\uDC00-\uDD64\uDD6A-\uDD6C\uDD73-\uDD7A\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDE41\uDE45-\uDFFF]|\uD835[\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3\uDFCC\uDFCD]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85-\uDE9A\uDEA0\uDEB0-\uDFFF]|\uD838[\uDC07\uDC19\uDC1A\uDC22\uDC25\uDC2B-\uDCFF\uDD2D-\uDD2F\uDD3E\uDD3F\uDD4A-\uDD4D\uDD4F-\uDEBF\uDEFA-\uDFFF]|\uD83A[\uDCC5-\uDCCF\uDCD7-\uDCFF\uDD4C-\uDD4F\uDD5A-\uDFFF]|\uD83B[\uDC00-\uDDFF\uDE04\uDE20\uDE23\uDE25\uDE26\uDE28\uDE33\uDE38\uDE3A\uDE3C-\uDE41\uDE43-\uDE46\uDE48\uDE4A\uDE4C\uDE50\uDE53\uDE55\uDE56\uDE58\uDE5A\uDE5C\uDE5E\uDE60\uDE63\uDE65\uDE66\uDE6B\uDE73\uDE78\uDE7D\uDE7F\uDE8A\uDE9C-\uDEA0\uDEA4\uDEAA\uDEBC-\uDFFF]|\uD83C[\uDC00-\uDD2F\uDD4A-\uDD4F\uDD6A-\uDD6F\uDD8A-\uDFFF]|\uD83E[\uDC00-\uDFEF\uDFFA-\uDFFF]|\uD869[\uDEDE-\uDEFF]|\uD86D[\uDF35-\uDF3F]|\uD86E[\uDC1E\uDC1F]|\uD873[\uDEA2-\uDEAF]|\uD87A[\uDFE1-\uDFFF]|\uD87E[\uDE1E-\uDFFF]|\uD884[\uDF4B-\uDFFF]|\uDB40[\uDC00-\uDCFF\uDDF0-\uDFFF]/g;
+
+//#endregion
+//#region ../../node_modules/.pnpm/github-slugger@2.0.0/node_modules/github-slugger/index.js
+const own = Object.hasOwnProperty;
+/**
+* Generate a slug.
+*
+* Does not track previously generated slugs: repeated calls with the same value
+* will result in the exact same slug.
+* Use the `GithubSlugger` class to get unique slugs.
+*
+* @param  {string} value
+*   String of text to slugify
+* @param  {boolean} [maintainCase=false]
+*   Keep the current case, otherwise make all lowercase
+* @return {string}
+*   A unique slug string
+*/
+function slug(value, maintainCase) {
+	if (typeof value !== "string") return "";
+	if (!maintainCase) value = value.toLowerCase();
+	return value.replace(regex, "").replace(/ /g, "-");
+}
+
+//#endregion
+//#region src/_internal/astro-slug.ts
+/**
+* Mirror of Astro's content-layer slug normalization, used by every
+* framework URL builder that derives a URL from an `entry.id`.
+*
+* Astro's `glob` content loader (used by Nimbus's `docsCollection` /
+* `partialsCollection` factories) runs each path segment through
+* `github-slugger.slug()` and strips a trailing `/index`. That output is
+* what `entry.id` becomes inside `getCollection`, and it's what `params.slug`
+* substitutes into `[...slug].astro` routes. Anything that constructs a
+* URL from the raw filesystem path *must* apply the same normalization or
+* the URL won't match what Astro actually serves.
+*
+* Why mirror instead of asking Astro: framework URL builders run at page
+* render time (sidebar hrefs) and during the integration's
+* `astro:config:setup` (sitemap, llms.txt). At neither point do we have a
+* clean way to read Astro's resolved routes. The honest architectural fix
+* is to refactor those builders to consume the route manifest at
+* `astro:routes:resolved` (sitemap/llms) or via a build-emitted lookup
+* table (sidebar). Until that work lands, this helper keeps the URLs
+* correct.
+*
+* Mirror caveat: this matches `github-slugger.slug()` and the trailing-
+* /index strip — the documented public-library behaviors Astro inherits
+* — not Astro's private routing internals. If a user supplies a custom
+* `generateId` to the content loader, or a `data.slug` override in
+* frontmatter, this helper doesn't see it. Both are uncommon.
+*/
+/** Canonicalize one entry id the way Astro's content layer does. */
+function canonicalSlug(entryId) {
+	const slugged = entryId.split("/").map((segment) => slug(segment)).join("/");
+	if (slugged === "index") return "";
+	return slugged.endsWith("/index") ? slugged.slice(0, -6) : slugged;
+}
+/**
+* Compose the URL Astro serves for an entry at a given collection prefix.
+*
+*   canonicalEntryUrl("", "WIP/index")    → "/wip"
+*   canonicalEntryUrl("/blog", "first")   → "/blog/first"
+*   canonicalEntryUrl("/v1", "index")     → "/v1"
+*
+* `prefix` is the collection mount path (`""` for the primary `docs`
+* collection, `/blog` for a `blog` collection, `/v1` for a version
+* collection). Pass exactly what your framework prefix resolver returns.
+*/
+function canonicalEntryUrl(prefix, entryId) {
+	const slug = canonicalSlug(entryId);
+	if (slug === "") return prefix === "" ? "/" : prefix;
+	return `${prefix}/${slug}`;
+}
+
+//#endregion
+//#region src/_internal/url.ts
+/**
+* Internal URL helpers — one shape for matching, one shape for rendering.
+*
+* Static hosts that serve `page/index.html` (Astro's default `build.format:
+* "directory"`) canonicalize to a trailing-slash URL. If framework helpers
+* emit slashless hrefs, every sidebar click costs a 307 redirect before
+* Astro's client router can pick up the page. The fix splits href shape
+* into two forms:
+*
+*   - `toRouteKey(href)` — slashless canonical form. Used wherever the
+*     framework compares paths for identity (active sidebar state,
+*     prev/next lookup, validation against the indexed route set).
+*
+*   - `toBrowserHref(href)` — what we emit into `<a href>` / `<link>` for
+*     HTML document routes. Adds a trailing slash so the URL matches the
+*     directory-index page the host serves directly.
+*
+* Asset URLs (`.md`, `.png`, `.txt`, …), external URLs, and anchor-only
+* hrefs are returned unchanged by `toBrowserHref` — they aren't HTML
+* document routes and adding a slash would break them.
+*
+* Keep these out of the public API: starter components consume hrefs the
+* framework already shaped. Authors don't (and shouldn't) call these
+* directly.
+*/
+/**
+* True for hrefs that point off-site — anything with a URI scheme
+* (`https:`, `mailto:`, `data:`, …) or a protocol-relative `//cdn.…`
+* prefix. Bare relative paths like `"cli"` and `"./foo"` are NOT external
+* — they resolve against the current page and the framework shouldn't
+* second-guess them.
+*/
+function isAbsoluteUrl(href) {
+	return /^([a-z][a-z0-9+\-.]*:|\/\/)/i.test(href);
+}
+/**
+* Detect whether the final path segment looks like a file (has an
+* extension). HTML document routes don't carry an extension under
+* `build.format: "directory"`; assets like `/og/card.png`,
+* `/llms.txt`, and `/cli/index.md` do.
+*
+* Conservative: only treats short, ASCII-letter-only extensions as files,
+* so paths with dots inside a segment (`/v1.2/foo`, version slugs) still
+* count as document routes.
+*/
+function hasFileExtension(pathname) {
+	const lastSegment = pathname.slice(pathname.lastIndexOf("/") + 1);
+	const dot = lastSegment.lastIndexOf(".");
+	if (dot <= 0) return false;
+	const ext = lastSegment.slice(dot + 1);
+	return ext.length > 0 && ext.length <= 6 && /^[a-zA-Z0-9]+$/.test(ext);
+}
+/** Split an href into `[pathname, suffix]` where `suffix` is the `?…#…` tail. */
+function splitSuffix(href) {
+	const queryAt = href.indexOf("?");
+	const hashAt = href.indexOf("#");
+	const cutAt = queryAt === -1 ? hashAt : hashAt === -1 ? queryAt : Math.min(queryAt, hashAt);
+	if (cutAt === -1) return [href, ""];
+	return [href.slice(0, cutAt), href.slice(cutAt)];
+}
+/**
+* Slashless canonical form for path comparisons.
+*
+*   /cli           → /cli
+*   /cli/          → /cli
+*   /cli/?x=1#y    → /cli
+*   /              → /
+*   /guides/setup/ → /guides/setup
+*
+* Strips query and hash so callers can compare two hrefs that differ only
+* in their tail. Root stays `"/"` — that's identity, not a trailing-slash
+* artifact.
+*/
+function toRouteKey(href) {
+	const [pathname] = splitSuffix(href);
+	if (pathname.length <= 1) return pathname || "/";
+	return pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+}
+/**
+* Trailing-slash form for browser-facing hrefs to HTML document routes.
+* Preserves query and hash; root, external URLs, anchor-only hrefs, and
+* asset URLs (paths with a file extension) are returned unchanged.
+*
+*   /cli              → /cli/
+*   /cli/             → /cli/
+*   /cli#install      → /cli/#install
+*   /cli?v=1          → /cli/?v=1
+*   /                 → /
+*   /og/card.png      → /og/card.png        (asset, unchanged)
+*   /cli/index.md     → /cli/index.md       (asset, unchanged)
+*   https://x.com/a   → https://x.com/a     (external, unchanged)
+*   #anchor           → #anchor             (anchor-only, unchanged)
+*/
+function toBrowserHref(href) {
+	if (isAbsoluteUrl(href)) return href;
+	if (href.startsWith("#") || href.startsWith("?")) return href;
+	if (!href.startsWith("/")) return href;
+	const [pathname, suffix] = splitSuffix(href);
+	if (pathname === "/") return href;
+	if (hasFileExtension(pathname)) return href;
+	if (pathname.endsWith("/")) return href;
+	return `${pathname}/${suffix}`;
+}
+
 //#endregion
 //#region src/_internal/sidebar.ts
 const sortKeyByItem = /* @__PURE__ */ new WeakMap();
@@ -90,17 +280,6 @@ function sortSidebarItems(a, b) {
 	if (keyDiff !== 0) return keyDiff;
 	return a.type.localeCompare(b.type);
 }
-/** Ensure internal href has leading /, no trailing slash (except root) */
-function normalizeInternalHref(href) {
-	let h = href.split("?")[0].split("#")[0];
-	if (!h.startsWith("/")) h = `/${h}`;
-	if (h.length > 1 && h.endsWith("/")) h = h.slice(0, -1);
-	return h;
-}
-/** Strip query and hash for active-state matching */
-function stripQueryHash(href) {
-	return href.split("?")[0].split("#")[0];
-}
 function buildEntryIndex(entries) {
 	const visible = entries.filter((e) => !e.data.sidebar?.hidden);
 	const byId = /* @__PURE__ */ new Map();
@@ -116,9 +295,16 @@ function buildEntryIndex(entries) {
 		hasChildren
 	};
 }
-/** Compose a final href for an entry. `hrefPrefix` is the collection mount path (e.g. `/api`). */
+/**
+* Compose a final href for an entry. `hrefPrefix` is the collection mount
+* path (e.g. `/api`). Runs through `canonicalEntryUrl` so the href
+* matches what Astro serves (lowercase + folder-index strip — see
+* `_internal/astro-slug.ts` for the why and known caveats), then through
+* `toBrowserHref` so the rendered link is the trailing-slash form static
+* hosts serve directly (no 307 round-trip on click).
+*/
 function joinHref(hrefPrefix, entryId) {
-	return `${hrefPrefix.replace(/\/$/, "")}/${entryId}`;
+	return toBrowserHref(canonicalEntryUrl(hrefPrefix.replace(/\/$/, ""), entryId));
 }
 function createLink(entry, currentPath, hrefPrefix = "") {
 	const href = joinHref(hrefPrefix, entry.id);
@@ -130,7 +316,7 @@ function createLink(entry, currentPath, hrefPrefix = "") {
 		type: "link",
 		label: entry.data.sidebar?.label ?? entry.data.title,
 		href,
-		isCurrent: currentPath === href,
+		isCurrent: toRouteKey(currentPath) === toRouteKey(href),
 		badge,
 		order: entry.data.sidebar?.order ?? Number.MAX_VALUE
 	};
@@ -222,6 +408,7 @@ function resolveConfigItems(configItems, entriesByCollection, primaryCollection,
 	const result = [];
 	for (let i = 0; i < configItems.length; i++) {
 		const item = configItems[i];
+		if (!item) continue;
 		const order = orderStart + i;
 		if (typeof item === "string") {
 			const entry = byId.get(item);
@@ -230,7 +417,7 @@ function resolveConfigItems(configItems, entriesByCollection, primaryCollection,
 				link.order = order;
 				result.push(link);
 			} else console.warn(`[sidebar] Page "${item}" referenced in config but not found in primary collection "${primaryCollection}"`);
-		} else if ("link" in item) if (!item.link.startsWith("/")) {
+		} else if ("link" in item) if (isAbsoluteUrl(item.link) || !item.link.startsWith("/")) {
 			const extLink = {
 				type: "external",
 				label: item.label,
@@ -240,15 +427,15 @@ function resolveConfigItems(configItems, entriesByCollection, primaryCollection,
 			};
 			result.push(extLink);
 		} else {
-			const href = normalizeInternalHref(item.link);
-			const matchPath = stripQueryHash(href);
-			const lookup = href.slice(1);
-			if (!lookup.includes("/") && href !== "/" && !byId.has(lookup)) console.warn(`[sidebar] Internal link "${item.link}" (label: "${item.label}") does not match any entry in primary collection "${primaryCollection}"`);
+			const href = toBrowserHref(item.link);
+			const routeKey = toRouteKey(item.link);
+			const lookup = routeKey.slice(1);
+			if (lookup !== "" && !lookup.includes("/") && !byId.has(lookup)) console.warn(`[sidebar] Internal link "${item.link}" (label: "${item.label}") does not match any entry in primary collection "${primaryCollection}"`);
 			const link = {
 				type: "link",
 				label: item.label,
 				href,
-				isCurrent: currentPath === matchPath,
+				isCurrent: toRouteKey(currentPath) === routeKey,
 				badge: item.badge,
 				order
 			};
@@ -334,7 +521,7 @@ function deriveSidebarSections(items) {
 		if (links.length === 0) return [];
 		return [{
 			label: item.label,
-			href: item._prefix ?? links[0].href,
+			href: toBrowserHref(item._prefix ?? links[0].href),
 			isActive: links.some((link) => link.isCurrent === true)
 		}];
 	});
@@ -388,8 +575,8 @@ function processHideChildren(items, entries) {
 			}
 			if (item._indexId) {
 				if (entryById.get(item._indexId)?.data.sidebar?.hideChildren) {
-					const indexHref = `/${item._indexId}`;
-					const indexLink = item.children.find((c) => c.type === "link" && c.href === indexHref);
+					const indexKey = toRouteKey(canonicalEntryUrl("", item._indexId));
+					const indexLink = item.children.find((c) => c.type === "link" && toRouteKey(c.href) === indexKey);
 					if (indexLink) {
 						const link = {
 							...indexLink,
@@ -452,6 +639,54 @@ function sidebarHash(items) {
 	return (hash >>> 0).toString(36).padStart(7, "0");
 }
 
+//#endregion
+//#region src/_internal/collection-mount.ts
+/**
+* Collection-mount conventions — one source of truth for "what URL prefix
+* does collection X serve at?".
+*
+* Shared between `index.ts` (which uses it for `getIndexedEntries`,
+* `getDocsPageProps`, etc.) and `lint/site-model.ts` (where
+* `findDuplicateRoutes` needs it to detect cross-collection URL
+* collisions). Keeping the function here prevents the duplicate-slug
+* validator from drifting out of sync with the actual routing.
+*/
+/** Primary collection name — mounted at the site root with no prefix. */
+const PRIMARY_COLLECTION$1 = "docs";
+/**
+* Resolve the URL-prefix segment for a given collection name.
+*
+*   1. Primary `docs` collection mounts at root → returns `""`.
+*   2. With `versions` configured, a `docs-<slug>` collection whose slug
+*      appears in `versions.others` mounts under `/<slug>` (the version
+*      label, not the collection id).
+*   3. Any other collection (`api`, `blog`, …) mounts at `/<collection>`.
+*
+* Returned shape: empty string OR `/<segment>` with leading slash, no
+* trailing slash. Callers append `/<entryId>` or `/index.md`.
+*/
+function collectionMountPrefix(collection, versions) {
+	if (collection === PRIMARY_COLLECTION$1) return "";
+	if (versions && collection.startsWith("docs-")) {
+		const slug = collection.slice(5);
+		if (versions.others.includes(slug)) return `/${slug}`;
+	}
+	return `/${collection}`;
+}
+/**
+* Resolve the URL-safe label a collection is referenced by — the segment
+* that appears in URLs and section headers. For version collections this
+* is the manifest's short slug; for everything else it's the collection id.
+*/
+function collectionLabel(collection, versions) {
+	if (collection === PRIMARY_COLLECTION$1) return collection;
+	if (versions && collection.startsWith("docs-")) {
+		const slug = collection.slice(5);
+		if (versions.others.includes(slug)) return slug;
+	}
+	return collection;
+}
+
 //#endregion
 //#region src/_internal/transform.ts
 function protectCode(markdown) {
@@ -611,18 +846,11 @@ function getBreadcrumbs$1(slug, homeLabel = "Home") {
 		path += `/${part}`;
 		crumbs.push({
 			label: part.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
-			href: path
+			href: toBrowserHref(path)
 		});
 	}
 	return crumbs;
 }
-function normalizeInternalPath(path) {
-	const [withoutHash] = path.split("#", 1);
-	const [pathname] = withoutHash.split("?", 1);
-	if (!pathname) return "/";
-	if (pathname.length > 1 && pathname.endsWith("/")) return pathname.slice(0, -1);
-	return pathname;
-}
 function resolveOverride(override, fallback, validInternalLinks) {
 	if (override === false) return void 0;
 	if (override === void 0) return fallback;
@@ -635,11 +863,11 @@ function resolveOverride(override, fallback, validInternalLinks) {
 	}
 	if (override.link && !override.link.startsWith("/") && !override.link.startsWith("http")) throw new Error(`prev/next override link "${override.link}" must be an absolute path (starting with /) or a full URL`);
 	if (override.link?.startsWith("/") && validInternalLinks) {
-		const targetPath = normalizeInternalPath(override.link);
+		const targetPath = toRouteKey(override.link);
 		if (!validInternalLinks.has(targetPath)) throw new Error(`prev/next override link "${override.link}" does not match any existing internal docs route`);
 	}
 	const label = override.label ?? fallback?.label;
-	const href = override.link ?? fallback?.href;
+	const href = override.link ? toBrowserHref(override.link) : fallback?.href;
 	if (!fallback && (label === void 0 || href === void 0)) throw new Error("prev/next object override requires both `label` and `link` when no sidebar neighbor exists");
 	if (!href) return void 0;
 	return {
@@ -649,7 +877,8 @@ function resolveOverride(override, fallback, validInternalLinks) {
 }
 function getPrevNext$1(currentPath, sidebarTree, overrides, validInternalLinks) {
 	const flat = flattenSidebar(sidebarTree);
-	const index = flat.findIndex((item) => item.href === currentPath);
+	const currentKey = toRouteKey(currentPath);
+	const index = flat.findIndex((item) => toRouteKey(item.href) === currentKey);
 	const sidebarPrev = index > 0 ? {
 		label: flat[index - 1].label,
 		href: flat[index - 1].href
@@ -771,7 +1000,7 @@ const EXPORT_PATTERN = /export\s+const\s+components\s*(?::\s*[^=]+)?=\s*\{([\s\S
 async function parseComponentsRegistry(filePath) {
 	let source;
 	try {
-		source = await fs.readFile(filePath, "utf8");
+		source = await fs$1.readFile(filePath, "utf8");
 	} catch (err) {
 		if (err.code === "ENOENT") return null;
 		throw err;
@@ -823,6 +1052,178 @@ function splitTopLevelCommas$1(input) {
 	return result;
 }
 
+//#endregion
+//#region src/lint/site-model.ts
+/**
+* Lint-side data shapes + the `nimbus/duplicate-slug` build validator.
+*
+* Route truth for `nimbus/internal-link` comes from Astro itself
+* (`astro:build:done` hands us the emitted `pages` array — the single
+* source of truth for served URLs). The integration writes that to
+* `.nimbus/routes.json`; the type lives here only so the rule and the
+* writer agree on the shape.
+*
+* The duplicate-slug validator runs *before* the build because Astro
+* silently dedupes colliding routes — by the time `astro:build:done`
+* fires, one entry has already shadowed the other. We catch collisions
+* pre-build by computing each entry's canonical slug with the same
+* library Astro's content layer uses (`github-slugger`), then grouping
+* entries by collection + slug. This is mirror-behavior, but mirroring
+* a documented public library rather than Astro's private internals —
+* a much smaller maintenance surface.
+*/
+/**
+* Walk `src/content/` using a `(collection key → folder name)` map so
+* entries are tagged with the registered key, not the on-disk folder.
+* Skips folders that aren't in the map (they're loose content, not a
+* routed collection).
+*/
+function enumerateEntriesByBase(contentRoot, bases) {
+	const folderToKey = /* @__PURE__ */ new Map();
+	for (const [key, base] of bases) folderToKey.set(base, key);
+	const out = [];
+	for (const [folder, key] of folderToKey) {
+		const baseDir = path.join(contentRoot, folder);
+		walkFolder(baseDir, baseDir, (relInBase) => {
+			out.push({
+				collection: key,
+				id: relInBase.replace(/\.mdx$/, ""),
+				relPath: `${folder}/${relInBase}`
+			});
+		});
+	}
+	return out;
+}
+function walkFolder(dir, root, visit) {
+	let dirents;
+	try {
+		dirents = fs.readdirSync(dir, { withFileTypes: true });
+	} catch (err) {
+		if (err.code === "ENOENT") return;
+		throw err;
+	}
+	for (const entry of dirents) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+			walkFolder(full, root, visit);
+		} else if (entry.isFile() && entry.name.endsWith(".mdx")) visit(path.relative(root, full).replace(/\\/g, "/"));
+	}
+}
+/**
+* Group route owners by URL. A group with more than one member is a real
+* collision Astro will silently shadow at build time — that's what this
+* helper exists to surface before the build wastes a cycle.
+*
+* Owners come from two sources, both fed in by the integration:
+*
+*   - **Content entries**, with URLs computed via
+*     `collectionMountPrefix(entry.collection, versions) +
+*     canonicalEntryUrl(prefix, entry.id)`. Catches cross-collection
+*     (`docs/blog/post.mdx` vs `blog/post.mdx`), version-collection
+*     (`docs/v1/x.mdx` vs `docs-v1/x.mdx`), case-only, and
+*     leaf-vs-folder-index collisions Astro's content layer dedupes.
+*   - **Static `src/pages/**` files** (via `enumerateStaticPageRoutes`).
+*     Catches the page-vs-content collision (`pages/search.astro`
+*     shadowing `content/docs/search.mdx` at `/search`).
+*
+* Doesn't honor `data.slug` frontmatter overrides — entries that use those
+* may produce false negatives. Reading frontmatter from every entry
+* pre-build would add noticeable I/O for a v1 feature; tracked as a
+* follow-up.
+*/
+function findDuplicateRoutes(owners) {
+	const byUrl = /* @__PURE__ */ new Map();
+	for (const { url, source } of owners) {
+		const bucket = byUrl.get(url);
+		if (bucket) bucket.push(source);
+		else byUrl.set(url, [source]);
+	}
+	const dups = [];
+	for (const [url, sources] of byUrl) if (sources.length > 1) dups.push({
+		url,
+		sources
+	});
+	return dups;
+}
+/** Format duplicate groups into a build-error message. */
+function formatDuplicateRoutes(dups) {
+	const lines = dups.map((d) => `  ${d.url}  ←  ${d.sources.join(", ")}`);
+	return `[nimbus-docs] Duplicate ${dups.length === 1 ? "route is" : "routes are"} claimed by more than one source (nimbus/duplicate-slug):\n` + lines.join("\n") + "\n\nTwo or more sources resolve to the same URL — one would shadow the other on the deployed site (Astro silently dedupes colliding routes). Rename or move one source in each pair.";
+}
+const PAGE_EXTS = new Set([
+	".astro",
+	".ts",
+	".js",
+	".md",
+	".mdx"
+]);
+function enumerateStaticPageRoutes(pagesRoot, projectRoot) {
+	const out = [];
+	walkPages(pagesRoot, pagesRoot, (relPath) => {
+		const ext = path.extname(relPath);
+		if (!PAGE_EXTS.has(ext)) return;
+		if (path.basename(relPath).startsWith("_")) return;
+		const parts = relPath.replace(/\\/g, "/").split("/");
+		const bareLeaf = parts[parts.length - 1].replace(/\.[^.]+$/, "");
+		if (parts.slice(0, -1).some(isDynamicSegment) || isDynamicSegment(bareLeaf)) return;
+		const url = fileToRoute(parts, ext);
+		const sourceAbs = path.join(pagesRoot, relPath);
+		const source = path.relative(projectRoot, sourceAbs).replace(/\\/g, "/");
+		out.push({
+			url,
+			source
+		});
+	});
+	return out;
+}
+function walkPages(dir, root, visit) {
+	let dirents;
+	try {
+		dirents = fs.readdirSync(dir, { withFileTypes: true });
+	} catch (err) {
+		if (err.code === "ENOENT") return;
+		throw err;
+	}
+	for (const entry of dirents) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (entry.name.startsWith("_") || entry.name === "node_modules") continue;
+			walkPages(full, root, visit);
+		} else if (entry.isFile()) visit(path.relative(root, full));
+	}
+}
+function isDynamicSegment(seg) {
+	return seg.startsWith("[") && seg.endsWith("]") && seg.length >= 3;
+}
+/**
+* Translate a static page file path (no dynamic segments) to its URL.
+*
+*   pages/index.astro       → /
+*   pages/search.astro      → /search
+*   pages/Search.astro      → /search       (Astro lowercases via joinSegments)
+*   pages/llms.txt.ts       → /llms.txt     (endpoint: strip .ts, keep .txt)
+*   pages/blog/index.astro  → /blog
+*   pages/blog/post.md      → /blog/post
+*/
+function fileToRoute(parts, ext) {
+	const cloned = [...parts];
+	const last = cloned[cloned.length - 1];
+	if ((ext === ".ts" || ext === ".js") && /\.[^.]+\.[tj]s$/.test(last)) cloned[cloned.length - 1] = last.replace(/\.[tj]s$/, "");
+	else cloned[cloned.length - 1] = last.replace(/\.[^.]+$/, "");
+	if (cloned[cloned.length - 1] === "index") cloned.pop();
+	const joined = cloned.map((s) => s.toLowerCase()).join("/");
+	return joined === "" ? "/" : `/${joined}`;
+}
+/**
+* Compute the mounted URL a content entry resolves to. Exposed so callers
+* (the integration's pre-build dup-check) can build `RouteOwner` records
+* with the same logic the framework uses everywhere else.
+*/
+function contentEntryUrl(entry, versions) {
+	return canonicalEntryUrl(collectionMountPrefix(entry.collection, versions), entry.id);
+}
+
 //#endregion
 //#region src/_internal/parse-content-collections.ts
 /**
@@ -862,7 +1263,7 @@ const EXPORT_PREFIX_PATTERN = /export\s+const\s+collections\s*(?::\s*[^=]+)?=\s*
 async function parseContentCollections(filePath) {
 	let source;
 	try {
-		source = await fs.readFile(filePath, "utf8");
+		source = await fs$1.readFile(filePath, "utf8");
 	} catch (err) {
 		if (err.code === "ENOENT") return null;
 		throw err;
@@ -887,6 +1288,181 @@ async function parseContentCollections(filePath) {
 	return names;
 }
 /**
+* Sibling of `parseContentCollections` that also extracts each entry's
+* `base` option — the folder name under `src/content/` the collection
+* loads from. Returns a `Map<key, folderName>` where the folder defaults
+* to the collection key when no `base:` override is present.
+*
+* Used by the `nimbus/duplicate-slug` validator and any other framework
+* code that needs to walk a collection's actual on-disk location rather
+* than assuming the folder name matches the collection key. Astro's
+* content layer respects the `base` option — `docsCollection({ base:
+* "documentation" })` loads from `src/content/documentation/` while still
+* registering as collection `docs`. Without this map, filesystem-walking
+* code would mis-tag those entries (`collection: "documentation"`) and
+* either flag bogus collisions or silently skip them via the indexable-
+* collections filter.
+*
+* Extraction is regex-based — for each entry's value text, looks for
+* `\bbase:\s*["']([^"']+)["']`. That covers the documented Nimbus pattern
+* (`docsCollection({ base: "..." })`, `partialsCollection({ base: "..." })`,
+* `componentsCollection({ base: "..." })`). Limitations:
+*
+*   - Computed/dynamic bases (`base: someVar`) fall back to the collection
+*     key. A future regression would silently miscount; for now,
+*     accepted as a known v1 limitation.
+*   - Hand-rolled `defineCollection({ loader: glob({ base: "./src/content/x" }) })`
+*     puts a *path* in `base`, not a folder name. The extracted value
+*     starts with `./src/content/` and won't match a folder under
+*     `src/content/` directly. Users who write the loader by hand can
+*     keep folder names matching collection keys, or accept that
+*     `duplicate-slug` won't see their non-conforming collection until
+*     they migrate to the Nimbus helpers.
+*
+* Returns `null` when the file is missing or unparseable, matching
+* `parseContentCollections`'s contract.
+*/
+async function parseCollectionBases(filePath) {
+	let source;
+	try {
+		source = await fs$1.readFile(filePath, "utf8");
+	} catch (err) {
+		if (err.code === "ENOENT") return null;
+		throw err;
+	}
+	const stripped = source.replace(/\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, " "));
+	const prefixMatch = stripped.match(EXPORT_PREFIX_PATTERN);
+	if (!prefixMatch || prefixMatch.index === void 0) return null;
+	const objectStart = prefixMatch.index + prefixMatch[0].length;
+	const objectEnd = findMatchingBrace(stripped, objectStart - 1);
+	if (objectEnd === -1) return null;
+	const body = stripped.slice(objectStart, objectEnd);
+	const out = /* @__PURE__ */ new Map();
+	for (const raw of splitTopLevelCommas(body)) {
+		const entry = raw.trim();
+		if (!entry) continue;
+		if (entry.startsWith("...")) continue;
+		if (entry.startsWith("[")) continue;
+		const colonIdx = entry.indexOf(":");
+		const key = (colonIdx === -1 ? entry : entry.slice(0, colonIdx)).trim().replace(/^['"`]|['"`]$/g, "");
+		if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(key)) continue;
+		const baseMatch = (colonIdx === -1 ? findLocalDeclarationValue(stripped, key) : entry.slice(colonIdx + 1)).match(/\bbase\s*:\s*["']([^"']+)["']/);
+		out.set(key, baseMatch ? baseMatch[1] : key);
+	}
+	return out;
+}
+/**
+* Locate `const|let|var <identifier> = <value>` at any depth in the source
+* and return the captured `<value>` text. Used to resolve shorthand
+* collection entries (`{ docs }` in the registration object refers to a
+* `const docs = defineCollection(...)` declared somewhere above).
+*
+* The walker is brace/bracket/paren-aware and string-literal-aware so the
+* captured value spans nested object/function-call expressions without
+* losing depth. It stops at the next top-level `;` or end-of-input.
+*
+* Limitations (false negatives — never false positives):
+*   - Identifiers imported from other modules can't be resolved (we don't
+*     follow imports).
+*   - Type-only annotations using `=>` (`const docs: () => X = …`) would
+*     fool the `=` detection. Realistic collection declarations don't use
+*     this shape; if a user does, the check falls back to the key.
+*/
+function findLocalDeclarationValue(source, identifier) {
+	const safeId = identifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const declRe = new RegExp(`\\b(?:const|let|var)\\s+${safeId}\\b`, "g");
+	let match;
+	while ((match = declRe.exec(source)) !== null) {
+		const eqIdx = findAssignmentEquals(source, match.index + match[0].length);
+		if (eqIdx === -1) continue;
+		const endIdx = findStatementEnd(source, eqIdx + 1);
+		return source.slice(eqIdx + 1, endIdx);
+	}
+	return "";
+}
+/**
+* Find the first `=` after `from` that's an assignment operator —
+* skipping `==`, `===`, and `=>`. Used to locate where the assignment
+* value begins in `const id [: Type] = value;`.
+*/
+function findAssignmentEquals(source, from) {
+	for (let i = from; i < source.length; i++) {
+		if (source[i] !== "=") continue;
+		if (source[i + 1] === "=") {
+			i++;
+			continue;
+		}
+		if (source[i + 1] === ">") {
+			i++;
+			continue;
+		}
+		if (source[i - 1] === "!" || source[i - 1] === "<" || source[i - 1] === ">") continue;
+		return i;
+	}
+	return -1;
+}
+/**
+* Walk forward from `from` tracking brace/bracket/paren depth and string
+* literals; return the index of the statement terminator.
+*
+* Terminates at the first of:
+*   1. A top-level `;`.
+*   2. A top-level newline that occurs *after* the value expression has
+*      produced any non-whitespace content. This is the ASI rule the
+*      walker has to honor for semicolonless code:
+*
+*      ```
+*      const docs = defineCollection(docsCollection())   // ← stop here
+*      export const collections = { … }                  // ← not part of `docs`
+*      ```
+*
+*      Without the ASI rule the walker would swallow the next statement
+*      and the `base:` regex could read an unrelated value.
+*   3. End-of-input.
+*
+* The "after non-whitespace" gate handles the leading-newline case:
+*
+*      ```
+*      const docs =
+*        defineCollection(docsCollection({ base: "x" }))
+*      ```
+*
+*      Here the newline right after `=` doesn't terminate; the walker
+*      keeps scanning until the value starts. Once content has been seen,
+*      the next top-level newline ends the statement.
+*
+* Limitations: method-chain continuations like `defineCollection(…)\n  .extend(…)`
+* stop at the first `)`. That captures the inner call's options (where any
+* `base:` would live), so the result is still correct in practice.
+*/
+function findStatementEnd(source, from) {
+	let depth = 0;
+	let inString = null;
+	let sawContent = false;
+	for (let i = from; i < source.length; i++) {
+		const ch = source[i];
+		if (inString) {
+			if (ch === "\\") {
+				i++;
+				continue;
+			}
+			if (ch === inString) inString = null;
+			continue;
+		}
+		if (ch === "\"" || ch === "'" || ch === "`") {
+			inString = ch;
+			sawContent = true;
+		} else if (ch === "{" || ch === "[" || ch === "(") {
+			depth++;
+			sawContent = true;
+		} else if (ch === "}" || ch === "]" || ch === ")") depth--;
+		else if (ch === ";" && depth === 0) return i;
+		else if (ch === "\n" && depth === 0 && sawContent) return i;
+		else if (ch !== " " && ch !== "	" && ch !== "\r" && ch !== "\n") sawContent = true;
+	}
+	return source.length;
+}
+/**
 * Starting from an opening brace at `openIdx`, walk forward tracking brace
 * depth (and skipping string literals + nested brackets) and return the
 * index of the matching close brace. Returns `-1` if no match is found —
@@ -1041,52 +1617,6 @@ function titleAndLangTransformer() {
 	};
 }
 
-//#endregion
-//#region src/_internal/levenshtein.ts
-/**
-* Tiny Levenshtein distance + "did you mean" suggester.
-*
-* Used by the MDX PascalCase validator and any framework diagnostic that
-* wants to suggest a near-match on a misspelled name. Kept internal — user
-* code that wants the same hint duplicates ~10 lines rather than depending
-* on a framework wrapper. See the north-star guardrail on thin wrappers.
-*/
-function levenshtein(a, b) {
-	if (a === b) return 0;
-	if (a.length === 0) return b.length;
-	if (b.length === 0) return a.length;
-	const v0 = new Array(b.length + 1);
-	const v1 = new Array(b.length + 1);
-	for (let i = 0; i <= b.length; i++) v0[i] = i;
-	for (let i = 0; i < a.length; i++) {
-		v1[0] = i + 1;
-		for (let j = 0; j < b.length; j++) {
-			const cost = a[i] === b[j] ? 0 : 1;
-			v1[j + 1] = Math.min(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost);
-		}
-		for (let j = 0; j <= b.length; j++) v0[j] = v1[j];
-	}
-	return v1[b.length];
-}
-/**
-* Return the closest candidate within `maxDist`, or null.
-*
-* Comparison is case-insensitive (so "tabs" suggests "Tabs"), but the
-* returned name keeps its original casing.
-*/
-function suggest(target, candidates, maxDist = 3) {
-	const targetLower = target.toLowerCase();
-	let best = null;
-	for (const c of candidates) {
-		const dist = levenshtein(targetLower, c.toLowerCase());
-		if (dist <= maxDist && (!best || dist < best.dist)) best = {
-			name: c,
-			dist
-		};
-	}
-	return best?.name ?? null;
-}
-
 //#endregion
 //#region src/_internal/validate-mdx-content.ts
 /**
@@ -1128,7 +1658,7 @@ async function validateMdxContent(options) {
 		const files = await walkMdx(dir);
 		for (const file of files) {
 			if (options.skip?.(file)) continue;
-			const fileFailures = scanFile(await fs.readFile(file, "utf8"), globalsSet);
+			const fileFailures = scanFile(await fs$1.readFile(file, "utf8"), globalsSet);
 			for (const f of fileFailures) {
 				const knownNames = [...globalsSet, ...f.imports];
 				failures.push({
@@ -1159,7 +1689,7 @@ async function walkMdx(dir) {
 	async function visit(current) {
 		let entries;
 		try {
-			entries = await fs.readdir(current, { withFileTypes: true });
+			entries = await fs$1.readdir(current, { withFileTypes: true });
 		} catch (err) {
 			if (err.code === "ENOENT") return;
 			throw err;
@@ -1427,13 +1957,13 @@ function virtualConfigPlugin(config, extras) {
 * versioned-docs collections. Drafts (frontmatter `draft: true`) are
 * filtered. Consumers feed this into `buildVersionAlternates()`.
 */
-const PRIMARY_COLLECTION$2 = "docs";
+const PRIMARY_COLLECTION = "docs";
 const EXTENSIONS = new Set([".mdx", ".md"]);
 async function scanVersionFrontmatter(options) {
 	const { projectRoot, versions } = options;
 	const out = [];
 	const collectionsToScan = [{
-		collection: PRIMARY_COLLECTION$2,
+		collection: PRIMARY_COLLECTION,
 		dir: path.join(projectRoot, "src/content/docs")
 	}, ...versions.others.map((slug) => ({
 		collection: `docs-${slug}`,
@@ -1444,7 +1974,7 @@ async function scanVersionFrontmatter(options) {
 		for (const file of files) {
 			let source;
 			try {
-				source = await fs.readFile(file, "utf8");
+				source = await fs$1.readFile(file, "utf8");
 			} catch {
 				continue;
 			}
@@ -1467,7 +1997,7 @@ async function walk(dir) {
 	async function visit(current) {
 		let entries;
 		try {
-			entries = await fs.readdir(current, { withFileTypes: true });
+			entries = await fs$1.readdir(current, { withFileTypes: true });
 		} catch (err) {
 			if (err.code === "ENOENT") return;
 			throw err;
@@ -1596,7 +2126,6 @@ function idFromPath(collectionDir, filePath) {
 
 //#endregion
 //#region src/_internal/version-alternates.ts
-const PRIMARY_COLLECTION$1 = "docs";
 /**
 * Build the alternates table for one site.
 *
@@ -1705,8 +2234,10 @@ function buildVersionAlternates(versions, entries) {
 *
 * Returns a list of `{ from, to }` redirect pairs ready for Astro's
 * `redirects` config. `from` is the URL the reader hit; `to` is the
-* current-version sibling. Both are absolute paths, leading slash, no
-* trailing slash. Astro applies trailing-slash normalisation on output.
+* current-version sibling. Both are absolute paths in the trailing-slash
+* browser-href form Astro serves under `build.format: "directory"`.
+* Astro's default `trailingSlash: "ignore"` matches incoming requests in
+* either form, so a reader landing on `/v1/foo` still resolves.
 */
 function computeMissingPageRedirects(versions, table, entries) {
 	if (!versions || versions.all.length < 2) return [];
@@ -1725,9 +2256,7 @@ function computeMissingPageRedirects(versions, table, entries) {
 			if (existing.has(`${oldVersion}:${entry.id}`)) continue;
 			if (table[refKey({
 				collection: entry.collection,
-				version,
-				slug: entry.id,
-				url: currentUrl
+				slug: entry.id
 			})]?.alternates.some((a) => a.version === oldVersion)) continue;
 			redirects.push({
 				from: pageUrl(versions, oldVersion, entry.id),
@@ -1755,10 +2284,14 @@ function collectionToVersion(versions, collection) {
 * `index.ts::resolveCollectionPrefix`:
 *   - current version → root (`/foo`)
 *   - others → `/<version>/<slug>`
+*
+* Runs through `canonicalEntryUrl` so the result matches what Astro
+* serves (lowercase + folder-index strip — see `_internal/astro-slug.ts`
+* for the why and known caveats). The `<link rel="alternate">` tags and
+* auto-redirect machinery both consume these URLs.
 */
 function pageUrl(versions, version, slug) {
-	if (version === versions.current) return `/${slug}`;
-	return `/${version}/${slug}`;
+	return toBrowserHref(canonicalEntryUrl(version === versions.current ? "" : `/${version}`, slug));
 }
 
 //#endregion
@@ -1795,12 +2328,19 @@ function pageUrl(versions, version, slug) {
 */
 function nimbus(rawConfig, options = {}) {
 	const config = validateNimbusConfig(rawConfig);
+	const lintOptions = validateLintOptions({
+		rules: options.rules,
+		collections: options.collections
+	}, IMPLEMENTED_CODES);
+	let projectRootForBuild = "";
+	let astroBaseForBuild = "";
 	return {
 		name: "nimbus-docs",
 		hooks: {
 			"astro:config:setup": async (params) => {
 				const { updateConfig, config: astroConfig, logger } = params;
 				const integrationsToAdd = [];
+				materializeLintConfig(fileURLToPath(astroConfig.root), lintOptions.rules, lintOptions.collections, config.site);
 				if (options.validateMdx !== false) {
 					const validateOpts = typeof options.validateMdx === "object" ? options.validateMdx : {};
 					const projectRoot = fileURLToPath(astroConfig.root);
@@ -1820,9 +2360,26 @@ function nimbus(rawConfig, options = {}) {
 					}
 				}
 				const projectRoot = fileURLToPath(astroConfig.root);
-				const rawCollections = await parseContentCollections(path.join(projectRoot, "src/content.config.ts"));
+				projectRootForBuild = projectRoot;
+				astroBaseForBuild = astroConfig.base ?? "";
+				const contentConfigPath = path.join(projectRoot, "src/content.config.ts");
+				const rawCollections = await parseContentCollections(contentConfigPath);
+				const collectionBases = await parseCollectionBases(contentConfigPath);
 				const indexedCollections = rawCollections === null ? ["docs"] : filterIndexableCollections(rawCollections);
 				if (rawCollections === null) logger.warn("nimbus-docs: `src/content.config.ts` is missing or doesn't expose a parseable `export const collections = { ... }`. Falling back to indexing the `docs` collection only.");
+				const indexedSet = new Set(indexedCollections);
+				const versionInfo = config.versions ? { others: config.versions.others ?? [] } : null;
+				const indexedBases = /* @__PURE__ */ new Map();
+				if (collectionBases !== null) {
+					for (const [key, base] of collectionBases) if (indexedSet.has(key)) indexedBases.set(key, base);
+				} else for (const key of indexedCollections) indexedBases.set(key, key);
+				const contentOwners = enumerateEntriesByBase(path.join(projectRoot, "src/content"), indexedBases).map((entry) => ({
+					url: contentEntryUrl(entry, versionInfo),
+					source: `src/content/${entry.relPath}`
+				}));
+				const pageOwners = enumerateStaticPageRoutes(path.join(projectRoot, "src/pages"), projectRoot);
+				const duplicateRoutes = findDuplicateRoutes([...contentOwners, ...pageOwners]);
+				if (duplicateRoutes.length > 0) throw new Error(formatDuplicateRoutes(duplicateRoutes));
 				if (config.versions && rawCollections !== null) {
 					const registered = new Set(rawCollections);
 					const missing = config.versions.others.filter((slug) => !registered.has(`docs-${slug}`));
@@ -1889,13 +2446,74 @@ function nimbus(rawConfig, options = {}) {
 					].join("\n")
 				});
 			},
-			"astro:build:done": async ({ dir }) => {
+			"astro:build:done": async ({ dir, pages, logger }) => {
+				materializeRouteTruthFromPages(projectRootForBuild, astroBaseForBuild, pages, logger);
 				if (config.search === false || config.search?.provider === "custom") return;
 				await runPagefind(fileURLToPath(dir));
 			}
 		}
 	};
 }
+/**
+* Write the resolved authoring-lint config to `<root>/.nimbus/lint.json`
+* for the standalone CLI. Best-effort: any filesystem error is swallowed
+* so it can't fail an `astro build`. `.nimbus/` is a gitignored scratch
+* dir (same home the Vale recipe uses).
+*
+* `site` is materialized alongside the rules so site-aware rules
+* (`no-self-host-url`) get the project's deploy host without making the
+* user duplicate it in their lint config.
+*/
+function materializeLintConfig(projectRoot, rules, collections, site) {
+	try {
+		const dir = path.join(projectRoot, ".nimbus");
+		fs.mkdirSync(dir, { recursive: true });
+		fs.writeFileSync(path.join(dir, "lint.json"), JSON.stringify({
+			version: 1,
+			rules,
+			collections,
+			site
+		}, null, 2) + "\n", "utf8");
+	} catch {}
+}
+/**
+* Write the site's route truth to `<root>/.nimbus/routes.json` from the
+* `pages` array Astro hands us at `astro:build:done`. Each entry in `pages`
+* is a real emitted URL — no reconstruction, no slug mirroring.
+*
+* Best-effort write, same as `materializeLintConfig`. When the file is
+* missing (e.g. lint ran before any `astro build`), `internal-link` skips
+* silently rather than false-positive.
+*
+* Duplicate-slug detection lives in `astro:config:setup` (above), not
+* here. Astro silently dedupes colliding routes before this hook fires,
+* so a post-build collision check on `pages` would never see the
+* collisions it claims to catch.
+*/
+function materializeRouteTruthFromPages(projectRoot, base, pages, logger) {
+	const canonical = /* @__PURE__ */ new Set();
+	for (const { pathname } of pages) canonical.add(canonicalizePathname(pathname));
+	const truth = {
+		version: 1,
+		base,
+		knownRoutes: [...canonical].sort(),
+		opaqueNamespaces: []
+	};
+	try {
+		const dir = path.join(projectRoot, ".nimbus");
+		fs.mkdirSync(dir, { recursive: true });
+		fs.writeFileSync(path.join(dir, "routes.json"), JSON.stringify(truth, null, 2) + "\n", "utf8");
+	} catch (err) {
+		logger.debug?.(`failed to write .nimbus/routes.json — internal-link will skip: ${err.message}`);
+	}
+}
+function canonicalizePathname(pathname) {
+	let s = pathname;
+	if (s === "") return "/";
+	if (!s.startsWith("/")) s = `/${s}`;
+	if (s.length > 1 && s.endsWith("/")) s = s.slice(0, -1);
+	return s;
+}
 function runPagefind(siteDir) {
 	const bin = process.platform === "win32" ? "pagefind.cmd" : "pagefind";
 	return new Promise((resolve) => {
@@ -1921,8 +2539,6 @@ function runPagefind(siteDir) {
 * by our Vite plugin) and content entries from `astro:content`. Both
 * are external in tsdown and resolved at the consumer's build time.
 */
-/** Primary collection name — kept in sync with `_internal/content.ts`. */
-const PRIMARY_COLLECTION = "docs";
 /**
 * Define a typed Nimbus config. Returns the config unchanged but inferred.
 */
@@ -1951,47 +2567,10 @@ function defineConfig(config) {
 * the collection: hand-rolled `defineCollection({ loader, schema })`
 * collections work without modification.
 */
-/**
-* Resolve the URL-prefix segment for a given collection ID.
-*
-* Rules, in order:
-*   1. Primary `docs` collection mounts at root → returns `""`.
-*   2. When `versions` is configured, a `docs-<slug>` collection whose
-*      slug appears in `versions.others` mounts under `/<slug>/` (not
-*      `/docs-<slug>/`). This is the versioning URL convention — a
-*      version is reached by its short label, not its collection ID.
-*   3. Any other collection (`api`, `blog`, …) mounts at `/<collection>/`
-*      — the default multi-collection convention.
-*
-* Returned shape: empty string OR `/<segment>` with leading slash, no
-* trailing slash. Callers append `/<entryId>` or `/index.md`.
-*/
-function resolveCollectionPrefix(versions, collection) {
-	if (collection === PRIMARY_COLLECTION) return "";
-	if (versions && collection.startsWith("docs-")) {
-		const slug = collection.slice(5);
-		if (versions.others.includes(slug)) return `/${slug}`;
-	}
-	return `/${collection}`;
-}
-/**
-* Resolve the URL-safe slug a collection should be referenced by — the
-* label that appears in URLs and section headers. For version
-* collections this is the manifest's short slug; for everything else
-* it's the collection ID.
-*/
-function resolveCollectionSlug(versions, collection) {
-	if (collection === PRIMARY_COLLECTION) return collection;
-	if (versions && collection.startsWith("docs-")) {
-		const slug = collection.slice(5);
-		if (versions.others.includes(slug)) return slug;
-	}
-	return collection;
-}
 async function getIndexedEntries() {
 	const { getCollection } = await import("astro:content");
 	const collectionNames = await loadIndexedCollections();
-	const names = collectionNames.length > 0 ? collectionNames : [PRIMARY_COLLECTION];
+	const names = collectionNames.length > 0 ? collectionNames : [PRIMARY_COLLECTION$1];
 	const versions = await getVersions();
 	const indexed = [];
 	for (const name of names) {
@@ -2001,19 +2580,22 @@ async function getIndexedEntries() {
 		} catch {
 			continue;
 		}
-		const prefix = resolveCollectionPrefix(versions, name);
+		const prefix = collectionMountPrefix(name, versions);
 		for (const entry of entries) {
 			const data = entry.data ?? {};
 			if (data.draft === true) continue;
 			const title = typeof data.title === "string" && data.title.length > 0 ? data.title : entry.id;
 			const rawDescription = data.description;
 			const description = typeof rawDescription === "string" && rawDescription.length > 0 ? rawDescription : void 0;
+			const canonicalUrl = canonicalEntryUrl(prefix, entry.id);
+			const markdownUrl = canonicalUrl === "/" ? "/index.md" : `${canonicalUrl}/index.md`;
 			indexed.push({
 				entry,
 				collection: name,
 				title,
 				description,
-				url: `${prefix}/${entry.id}`
+				url: toBrowserHref(canonicalUrl),
+				markdownUrl
 			});
 		}
 	}
@@ -2037,13 +2619,13 @@ async function getIndexedTopLevel() {
 	const secondaryBuckets = /* @__PURE__ */ new Map();
 	const versionSlugs = new Set(versions?.others ?? []);
 	const hiddenSlugs = new Set(versions?.hidden ?? []);
-	for (const item of items) if (item.collection === PRIMARY_COLLECTION) {
+	for (const item of items) if (item.collection === PRIMARY_COLLECTION$1) {
 		const top = item.entry.id.split("/")[0];
 		const bucket = primaryBuckets.get(top);
 		if (bucket) bucket.push(item);
 		else primaryBuckets.set(top, [item]);
 	} else {
-		const slug = resolveCollectionSlug(versions, item.collection);
+		const slug = collectionLabel(item.collection, versions);
 		const bucket = secondaryBuckets.get(slug);
 		if (bucket) bucket.push(item);
 		else secondaryBuckets.set(slug, [item]);
@@ -2138,13 +2720,13 @@ async function getSidebarSections(currentSlug, options) {
 async function buildFullSidebarTree(currentSlug, pageCollection) {
 	const runtimeConfig = await loadNimbusConfig();
 	const versions = await getVersions();
-	let effectivePrimary = PRIMARY_COLLECTION;
+	let effectivePrimary = PRIMARY_COLLECTION$1;
 	let primaryPrefix = "";
 	if (versions && pageCollection && pageCollection.startsWith("docs-") && versions.others.includes(pageCollection.slice(5))) {
 		effectivePrimary = pageCollection;
-		primaryPrefix = resolveCollectionPrefix(versions, pageCollection);
+		primaryPrefix = collectionMountPrefix(pageCollection, versions);
 	}
-	const rewrittenItems = effectivePrimary !== PRIMARY_COLLECTION ? rewriteSidebarItemsForVersion(runtimeConfig.sidebar?.items, effectivePrimary) : runtimeConfig.sidebar?.items;
+	const rewrittenItems = effectivePrimary !== PRIMARY_COLLECTION$1 ? rewriteSidebarItemsForVersion(runtimeConfig.sidebar?.items, effectivePrimary) : runtimeConfig.sidebar?.items;
 	const referenced = collectSidebarCollectionRefs(rewrittenItems);
 	return buildSidebarTree(await getVisibleEntriesByCollection([effectivePrimary, ...referenced.filter((c) => c !== effectivePrimary)]), effectivePrimary, currentSlug, runtimeConfig.sidebar ? {
 		...runtimeConfig.sidebar,
@@ -2163,7 +2745,7 @@ function rewriteSidebarItemsForVersion(items, effectivePrimary) {
 		if (!item || typeof item !== "object") return item;
 		const o = item;
 		const autogen = o.autogenerate;
-		if (autogen && autogen.collection === PRIMARY_COLLECTION) return {
+		if (autogen && autogen.collection === PRIMARY_COLLECTION$1) return {
 			...o,
 			autogenerate: {
 				...autogen,
@@ -2194,7 +2776,7 @@ function rewriteSidebarItemsForVersion(items, effectivePrimary) {
 async function getPrevNext(currentSlug, options) {
 	const tree = options?.sidebarTree ?? await getSidebar(currentSlug);
 	const indexed = await getIndexedEntries();
-	const validInternalLinks = new Set(indexed.map((e) => e.url));
+	const validInternalLinks = new Set(indexed.map((e) => toRouteKey(e.url)));
 	return getPrevNext$1(currentSlug, tree, options?.overrides, validInternalLinks);
 }
 /**
@@ -2406,7 +2988,7 @@ async function getVersions() {
 async function getCurrentVersion(collectionId) {
 	const versions = await getVersions();
 	if (!versions) return null;
-	if (collectionId === PRIMARY_COLLECTION) return versions.current;
+	if (collectionId === PRIMARY_COLLECTION$1) return versions.current;
 	if (!collectionId.startsWith("docs-")) return null;
 	const suffix = collectionId.slice(5);
 	return versions.all.includes(suffix) ? suffix : null;
@@ -2474,7 +3056,7 @@ async function getCanonicalUrl(collectionId, entryId) {
 * the wrong section.
 */
 async function getCollectionLlmsUrl(collectionId) {
-	if (collectionId === PRIMARY_COLLECTION) return "/llms.txt";
+	if (collectionId === PRIMARY_COLLECTION$1) return "/llms.txt";
 	const versions = await getVersions();
 	if (versions && collectionId.startsWith("docs-")) {
 		const slug = collectionId.slice(5);
@@ -2533,7 +3115,7 @@ async function getVersionLandingUrl(version) {
 	const versions = await getVersions();
 	if (!versions) return null;
 	if (!versions.all.includes(version)) return null;
-	const targetCollection = version === versions.current ? PRIMARY_COLLECTION : `docs-${version}`;
+	const targetCollection = version === versions.current ? PRIMARY_COLLECTION$1 : `docs-${version}`;
 	const inVersion = (await getIndexedEntries()).filter((i) => i.collection === targetCollection);
 	if (inVersion.length === 0) return null;
 	const byId = new Map(inVersion.map((i) => [i.entry.id, i]));