@pitlane/content 0.1.1 → 0.2.1

package/CHANGELOG.md

@@ -1,7 +1,34 @@
 # @pitlane/content
 
+## 0.2.1
+
+### Patch Changes
+
+- f2fa73e: Read a heading's `text`, and the `id` made from it, from what the heading shows on the page. Three kinds of heading change, and an anchor written by hand against one of them needs checking once:
+
+    - Inline HTML now contributes its words and not its tags. `## <span>Visible</span> text` was `<span>Visible</span> text` with the `id` `spanvisiblespan-text`, and is now `Visible text` with `visible-text`.
+    - An image no longer contributes its alt text, which matches GitHub and Astro. `## [A](url) ![Cat photo](cat.png)` was `a-cat-photo` and is now `a-`, keeping the space before the image as GitHub does.
+    - In MDX, an expression that is a single string literal now contributes its value. `## Hello {"world"}` was `hello-` and is now `hello-world`, and `## The {"{"} key` reads `The { key`. Any other expression, such as `{name}`, still contributes nothing.
+
+    Headings without inline HTML, images, or expressions keep their `text` and `id`.
+
+## 0.2.0
+
+### Minor Changes
+
+- 87ec1f6: Give headings the ids GitHub gives them. `headings()` now lowercases a heading, removes every character outside letters, marks, digits, and connector punctuation, and turns each space into a hyphen without collapsing or trimming any of them — the algorithm GitHub uses, and the one Astro's `rehype-heading-ids` uses through the same `github-slugger` package. `## Databases & Data Loading` was `databases-data-loading` and is now `databases--data-loading`; `## Jenni’s Quesadillas` was `jenni-s-quesadillas` and is now `jennis-quesadillas`.
+
+    A heading containing punctuation or symbols can therefore get a different `id` than it did before — `## Hello World!` keeps `hello-world`, but `## Databases & Data Loading` does not — so an anchor written by hand against the old ids needs checking once. In exchange, a table of contents carried over from GitHub or Astro keeps landing without being rewritten. A heading that slugs to nothing at all, such as `## 🎉`, still falls back to `heading` rather than to the empty `id` GitHub produces, and a later `## Heading` in the same document then takes `heading-1`.
+
+### Patch Changes
+
+- f8b0db5: Keep content prebuilds from deleting the running app's optimized browser dependencies. This fixes `504 (Outdated Optimize Dep)` errors that could leave MDX updates and client-side navigation broken until the dev server restarted.
+- 98e8a77: Vite no longer warns that it cannot analyze a dynamic import in `@pitlane/content` when an app using `contentLayer()` starts its dev server. The runtime import of a document's resolved dependencies is now marked `/* @vite-ignore */`, since its target is only known at request time.
+
 ## 0.1.1
 
+Published 2026-09-21. [npm](https://www.npmjs.com/package/@pitlane/content/v/0.1.1) · [GitHub release](https://github.com/pitlane-tools/pitlane/releases/tag/%40pitlane/content%400.1.1) · [Source](https://github.com/pitlane-tools/pitlane/commit/b725843491ad0c36c61c83d44466134f76dbd615).
+
 Documentation only. No code changed.
 
 - The npm description is one line now: "Schema-validated content collections for Remix." The old one led with `createContent()` and ran well past what a registry listing shows.
@@ -11,11 +38,18 @@ Documentation only. No code changed.
 
 ## 0.1.0
 
+Published 2026-09-21. [npm](https://www.npmjs.com/package/@pitlane/content/v/0.1.0) · [GitHub release](https://github.com/pitlane-tools/pitlane/releases/tag/%40pitlane/content%400.1.0) · [Source](https://github.com/pitlane-tools/pitlane/commit/31aae9c3c941238fbb94769e578e320179dc8284).
+
 Initial release.
 
 - `createContent` returns typed collection handles synchronously without loading entries. Reads and rendering remain asynchronous; declaration errors throw synchronously.
+- An entry's data is validated against its collection's schema as it loads, before any query returns it. Any Standard Schema validator does that work, `remix/data-schema` and Zod included, and the entry type is inferred from the schema rather than generated: `CollectionEntry<typeof content.blog>` names one. A failure reports the entry, the collection, the file it came from, and every issue.
 - `getCollection`, `getCollection(filter)`, and `getEntry` over entries sorted by id; `c.reference(collection)` for typed pointers between collections.
 - `render()` resolves an entry's Markdown or MDX to a Remix component and its heading list, parsing nothing until it is called.
-- Two loader interfaces: `ContentLoader` resolves a whole collection in one execution and can be prebuilt, `LiveLoader` answers one query at a time and runs on every read. `loaders.glob` and `loaders.file` implement the first.
+- Without a bundler, `render()` also resolves an MDX document's own imports relative to the document. A namespace import and `import.meta` are refused by name, since neither survives the function body an MDX document compiles to here.
+- Two loader interfaces: `ContentLoader` resolves a whole collection in one execution and can be prebuilt, `LiveLoader` answers one query at a time and runs on every read. `loaders.glob` and `loaders.file` implement the first. `glob` reads Markdown, MDX, JSON, and YAML, one entry per file; `file` reads a single JSON or YAML file holding many entries, and takes a `parser` for any other format.
 - `contentLayer()` from `@pitlane/content/vite` loads `ContentLoader` collections after evaluating their declarations and inlines them into the bundle. It waits for loading and validation before emitting, and watches the loaders' sources in dev.
-- `headings()` from `@pitlane/content/satteri` produces the heading list on both rendering paths.
+- `headings()` from `@pitlane/content/satteri` produces the heading list on both rendering paths. `rawStyles()` sits beside it and hands a `<style>` element's CSS to Remix as markup, which is what keeps an Expressive Code theme from reaching the page escaped into rules that match nothing. `render()` applies both; a Vite build passes them to `vite-plugin-satteri`.
+- `hotContent()` from `@pitlane/content/hot` reloads the browser when a file behind a collection changes, for an application that runs from source with no build. It does nothing unless `remix/node-hmr` is supervising the process, so it can stay in production code. A file created after startup still needs a restart.
+- Every peer dependency is optional, `remix` included. Reading and validating data imports neither it nor `satteri`; `render()` loads Remix only when something asks for a component, and names the entry that needed it if Remix is not installed. Node `^20.19.0 || >=22.12.0`.
+- The prebuild channel, the manifest emitter, and the MDX import reader ship as `@pitlane/content/internal/prebuild`, `/internal/codegen`, and `/internal/mdx`, so a plugin for a bundler other than Vite can reuse them.

package/dist/index.mjs

@@ -280,7 +280,7 @@ function view(collection, entry) {
 		data: entry.data,
 		...entry.filePath === void 0 ? {} : { filePath: entry.filePath },
 		render: async () => {
-			return await (await import("./render-U9dXN6f0.mjs").catch((cause) => {
+			return await (await import("./render-Bg0i1C_C.mjs").catch((cause) => {
 				throw missingRenderer(`${collection}/${entry.id}`, cause) ?? cause;
 			})).renderedEntry(collection, entry);
 		}

package/dist/{render-U9dXN6f0.mjs → render-Bg0i1C_C.mjs}

@@ -222,7 +222,14 @@ async function nodeResolution() {
 async function importFrom(specifier, from, where, node, attributes) {
 	let resolved = specifier.startsWith(".") ? new URL(specifier, from).href : resolveBare(specifier, from, where, node);
 	try {
-		return await (attributes ? import(resolved, { with: attributes }) : import(resolved));
+		return await (attributes ? import(
+			/* @vite-ignore */
+			resolved,
+			{ with: attributes }
+) : import(
+			/* @vite-ignore */
+			resolved
+));
 	} catch (error) {
 		let cause = error instanceof Error ? error.message : String(error);
 		throw new Error(`"${where}" imports "${specifier}", which could not be loaded: ${cause}`, { cause: error });

package/dist/satteri.d.mts

@@ -3,7 +3,8 @@ import { HastPluginEntry, MdastPluginEntry } from "satteri";
 /**
  * Collects every heading of a document as `{ depth, slug, text }`, publishes the
  * list as `data.headings`, and gives each heading an `id` matching its slug so an
- * anchor link lands on it. On MDX the list is also appended to the tree as
+ * anchor link lands on it. A heading's text is the text it shows on the page,
+ * as `visibleText` reads it. On MDX the list is also appended to the tree as
  * `export const headings`, so the compiled module carries its own table of
  * contents.
  *

package/dist/satteri.mjs

@@ -1,19 +1,40 @@
 //#region src/satteri.ts
 /**
-* The base slug for a heading with no letters or digits at all (`## ---`). An
-* empty `id` is invalid HTML and makes the anchor a bare `#`, which lands
-* nowhere; a fixed word plus the usual collision suffix keeps such headings
-* addressable and distinct.
+* The base slug for a heading that slugs to nothing at all, such as `## ***` or
+* `## 🎉`. GitHub answers the empty string there; an empty `id` is invalid HTML
+* and makes the anchor a bare `#`, which lands nowhere, so a fixed word plus
+* the usual collision suffix keeps such headings addressable and distinct. This
+* is the one case where these slugs are deliberately not GitHub's.
 */
 const FALLBACK_SLUG = "heading";
 /**
-* The slug for `text`, kept distinct from every slug `taken` already holds by
+* Every character GitHub's slugger removes: anything that is not alphabetic, a
+* combining mark, a decimal digit, connector punctuation, a space, or a hyphen.
+* Marks are kept because dropping them would shatter Devanagari, Hebrew, and
+* Arabic words into bare consonants; letters of every script are kept so a
+* Japanese or Cyrillic heading slugs to its own text rather than to nothing.
+*
+* `github-slugger` ships this set as a table generated from Unicode 13, while a
+* regular expression matches against whatever Unicode version the engine
+* carries. A character assigned after Unicode 13 therefore survives here and
+* would be stripped there; nothing assigned in Unicode 13 or earlier differs.
+*/
+const STRIPPED = /[^\p{Alphabetic}\p{M}\p{Nd}\p{Pc} -]/gu;
+/**
+* The slug for `text`, built the way GitHub builds a heading's `id`: lowercase
+* it, remove every stripped character, then turn each remaining space into a
+* hyphen. Nothing is collapsed and nothing is trimmed, so `Databases & Data
+* Loading` slugs to `databases--data-loading` and `## ---` to `---`. Astro slugs
+* with the same algorithm, so a table of contents written by hand against
+* either of them keeps landing after a move to Pitlane.
+*
+* The result is then kept distinct from every slug `taken` already holds by
 * suffixing `-1`, `-2`, … The map remembers the last suffix tried for a base so
 * a document of a hundred identical headings stays linear, and the loop covers
 * the case where the suffixed candidate is itself a real heading's slug.
 */
 function uniqueSlug(text, taken) {
-	let base = text.toLowerCase().replace(/[^\p{L}\p{N}\p{M}]+/gu, "-").replace(/^-+|-+$/g, "");
+	let base = text.toLowerCase().replace(STRIPPED, "").replaceAll(" ", "-");
 	if (!base) base = FALLBACK_SLUG;
 	let suffix = taken.get(base) ?? 0;
 	let slug = base;
@@ -26,9 +47,73 @@ function uniqueSlug(text, taken) {
 	return slug;
 }
 /**
+* The text a heading shows on the page, which is what GitHub and Astro slug.
+* Sätteri's `textContent` differs in three places: it keeps raw HTML tags as
+* text, includes image alt text, and reads every MDX expression as nothing.
+* Its options drop the first two, but an expression only carries its source,
+* so the walk is done here.
+*
+* Raw HTML nodes hold only the tags; the text between them is already its own
+* sibling node, so dropping `html` leaves the visible words. Images render no
+* text.
+*/
+function visibleText(node) {
+	switch (node.type) {
+		case "html":
+		case "image":
+		case "imageReference": return "";
+		case "mdxTextExpression": return stringLiteralValue(node.value ?? "") ?? "";
+	}
+	if (node.children) return node.children.map(visibleText).join("");
+	return node.value ?? "";
+}
+/** A lone JavaScript string or template literal, surrounded by nothing but whitespace. */
+const STRING_LITERAL = /^\s*(?:"((?:[^"\\\n\r]|\\[^])*)"|'((?:[^'\\\n\r]|\\[^])*)'|`((?:[^`\\$]|\\[^]|\$(?!\{))*)`)\s*$/;
+/**
+* One escape sequence: a code point in either `\u` form, a `\x` byte, `\0` not
+* followed by a digit, a line continuation, or any other escaped character.
+*/
+const ESCAPE = /\\(?:u\{([\da-fA-F]+)\}|u([\da-fA-F]{4})|x([\da-fA-F]{2})|(0)(?!\d)|(\r\n|[\n\r\u2028\u2029])|([^]))/g;
+const SINGLE_CHARACTER_ESCAPES = {
+	b: "\b",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	",
+	v: "\v"
+};
+/**
+* The value of an MDX expression whose source is a lone string literal, such
+* as `{"{"}`, the usual way to write a brace in MDX text. `undefined` for any
+* other expression, whose value is only known once the module runs.
+*
+* Escapes decode as in a module, which is strict code: a legacy octal escape
+* such as `\1`, a `\8`, or a malformed `\x` or `\u` makes the literal invalid.
+*/
+function stringLiteralValue(source) {
+	let match = STRING_LITERAL.exec(source);
+	if (!match) return void 0;
+	let [, double, single, template] = match;
+	let body = double ?? single ?? template.replace(/\r\n?/g, "\n");
+	let valid = true;
+	let value = body.replace(ESCAPE, (_, braced, unit, byte, nul, lineBreak, other) => {
+		if (braced !== void 0) {
+			let codePoint = Number.parseInt(braced, 16);
+			if (codePoint <= 1114111) return String.fromCodePoint(codePoint);
+		} else if (unit !== void 0 || byte !== void 0) return String.fromCharCode(Number.parseInt(unit ?? byte, 16));
+		else if (nul !== void 0) return "\0";
+		else if (lineBreak !== void 0) return "";
+		else if (!/[ux\d]/.test(other)) return SINGLE_CHARACTER_ESCAPES[other] ?? other;
+		valid = false;
+		return "";
+	});
+	return valid ? value : void 0;
+}
+/**
 * Collects every heading of a document as `{ depth, slug, text }`, publishes the
 * list as `data.headings`, and gives each heading an `id` matching its slug so an
-* anchor link lands on it. On MDX the list is also appended to the tree as
+* anchor link lands on it. A heading's text is the text it shows on the page,
+* as `visibleText` reads it. On MDX the list is also appended to the tree as
 * `export const headings`, so the compiled module carries its own table of
 * contents.
 *
@@ -51,7 +136,7 @@ function headings() {
 		return {
 			name: "pitlane-headings",
 			heading(node, context) {
-				let text = context.textContent(node);
+				let text = visibleText(node);
 				let slug = uniqueSlug(text, taken);
 				collected.push({
 					depth: node.depth,

package/dist/vite.mjs

@@ -225,6 +225,7 @@ async function inPrebuildServer(root, entry, resolution, onWatched) {
 		root,
 		configFile: false,
 		logLevel: "silent",
+		optimizeDeps: { noDiscovery: true },
 		resolve: resolution,
 		server: {
 			middlewareMode: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pitlane/content",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Schema-validated content collections for Remix.",
   "keywords": [
     "content",