vagejs 0.3.5 → 0.5.0

package/dist/content/optimize.js

@@ -23,7 +23,11 @@ export async function sharpResize(root) {
     }
     const sharp = (await import(pathToFileURL(resolved).href)).default;
     // rotate() applies EXIF orientation first, so phone photos aren't served sideways.
-    return (input, width, quality) => sharp(input).rotate().resize({ width, withoutEnlargement: true }).webp({ quality }).toBuffer();
+    // AVIF uses sharp's own default quality: its scale differs from WebP's, so images.quality would overshoot.
+    return (input, width, quality, format = "webp") => {
+        const resized = sharp(input).rotate().resize({ width, withoutEnlargement: true });
+        return (format === "avif" ? resized.avif() : resized.webp({ quality })).toBuffer();
+    };
 }
 /**
  * WebP variants for one site-path image in public/. Undefined for remote images,
@@ -61,30 +65,39 @@ export async function imageVariants(src, root, options, resize) {
     const dir = cacheDir(root);
     fs.mkdirSync(dir, { recursive: true });
     const files = new Map();
-    const entries = [];
-    for (const w of widths) {
-        const name = `${base}-${hash}-${w}.webp`;
-        const cached = path.join(dir, name);
-        if (!fs.existsSync(cached)) {
-            const tmp = `${cached}.${process.pid}.tmp`;
-            let data;
-            try {
-                data = await resize(input, w, options.quality);
+    const srcsets = {};
+    // Real widths, read from the WebP files; AVIF copies are resized the same way (vagejs can't read AVIF sizes).
+    const realWidth = new Map();
+    for (const format of options.avif ? ["webp", "avif"] : ["webp"]) {
+        const entries = [];
+        for (const w of widths) {
+            const name = `${base}-${hash}-${w}.${format}`;
+            const cached = path.join(dir, name);
+            if (!fs.existsSync(cached)) {
+                const tmp = `${cached}.${process.pid}.tmp`;
+                let data;
+                try {
+                    data = await resize(input, w, options.quality, format);
+                }
+                catch (err) {
+                    throw new VageError(`Couldn't make a ${format === "avif" ? "AVIF" : "WebP"} copy of ${src}: ${err.message}. Replace the file, or turn off ${format === "avif" ? "images.avif" : "images.optimize"}.`);
+                }
+                fs.writeFileSync(tmp, data);
+                fs.renameSync(tmp, cached);
             }
-            catch (err) {
-                throw new VageError(`Couldn't optimize ${src}: ${err.message}. Replace the file, or turn off images.optimize.`);
-            }
-            fs.writeFileSync(tmp, data);
-            fs.renameSync(tmp, cached);
+            // Label with the file's real width (rotation can change it); publish each width once.
+            const actual = format === "webp" ? (imageSize(cached)?.width ?? w) : (realWidth.get(w) ?? w);
+            if (format === "webp")
+                realWidth.set(w, actual);
+            if (entries.some((e) => e.endsWith(` ${actual}w`)))
+                continue;
+            files.set(`${IMAGE_DIR}/${name}`, cached);
+            entries.push(`/${IMAGE_DIR}/${name} ${actual}w`);
         }
-        // Label with the file's real width (rotation can change it); publish each width once.
-        const actual = imageSize(cached)?.width ?? w;
-        if (entries.some((e) => e.endsWith(` ${actual}w`)))
-            continue;
-        files.set(`${IMAGE_DIR}/${name}`, cached);
-        entries.push(`/${IMAGE_DIR}/${name} ${actual}w`);
+        if (entries.length)
+            srcsets[format] = entries.join(", ");
     }
-    return entries.length ? { srcset: entries.join(", "), files } : undefined;
+    return srcsets.webp ? { srcset: srcsets.webp, avifSrcset: srcsets.avif, files } : undefined;
 }
 /** Image sources used in rendered Markdown, read with an HTML parser (so entities decode like the DOM's). */
 export function contentImageSources(html) {

package/dist/content/sanitize.d.ts

@@ -1,3 +1,9 @@
+/** Optimized copies for one image source: WebP srcset and sizes, plus AVIF when images.avif is on. */
+export interface ImageVariant {
+    srcset: string;
+    sizes: string;
+    avifSrcset?: string;
+}
 /**
  * Sanitizes rendered Markdown HTML. Page content may be written by AI agents,
  * contributors or (later) CMS sources, so scripts, event handlers, javascript:
@@ -11,13 +17,10 @@
 export declare function sanitizeHtml(html: string, options?: {
     publicDir?: string;
     inlineStyles?: boolean;
-    variants?: Map<string, {
-        srcset: string;
-        sizes: string;
-    }>;
+    variants?: Map<string, ImageVariant>;
+    headingIds?: boolean;
 }): Promise<string>;
-/** For trusted content (`markdown.html: "allow"`): the same image hints, applied through the DOM. */
-export declare function enhanceTrustedHtml(html: string, publicDir: string, variants?: Map<string, {
-    srcset: string;
-    sizes: string;
-}>): Promise<string>;
+/** For trusted content (`markdown.html: "allow"`): the same image hints and heading ids, applied through the DOM. */
+export declare function enhanceTrustedHtml(html: string, publicDir: string, variants?: Map<string, ImageVariant>, headingIds?: boolean): Promise<string>;
+/** "Quick start: 2 steps!" -> "quick-start-2-steps". Letters in any script are kept; accents are dropped. */
+export declare function headingSlug(text: string): string;

package/dist/content/sanitize.js

@@ -29,29 +29,105 @@ export async function sanitizeHtml(html, options = {}) {
             first = false;
         }
     };
+    // A heading's own id is kept even when DOMPurify's clobbering filter would drop it ("title",
+    // "images"), so it behaves like the ids vagejs adds and links to it keep working.
+    const keepHeadingId = (node, data) => {
+        if (data.attrName === "id" && /^H[23]$/.test(node.nodeName))
+            data.forceKeepAttr = true;
+    };
     if (publicDir) {
         purifier.addHook("afterSanitizeAttributes", hook);
     }
+    if (options.headingIds)
+        purifier.addHook("uponSanitizeAttribute", keepHeadingId);
+    const config = {
+        // font/marquee/center: legacy ways to hide or disguise text (white-on-white, 1px scrollers).
+        FORBID_TAGS: ["style", "form", "input", "button", "textarea", "select", "option", "base", "link", "meta", "object", "embed", "font", "marquee", "center"],
+        ALLOW_DATA_ATTR: true,
+        // Inline styles are the usual way to hide injected links (display:none, off-screen); layouts style pages.
+        // xlink:href: SVG links, which would slip past link checks.
+        FORBID_ATTR: options.inlineStyles ? ["xlink:href"] : ["style", "xlink:href"],
+    };
     try {
-        return purifier.sanitize(html, {
-            // font/marquee/center: legacy ways to hide or disguise text (white-on-white, 1px scrollers).
-            FORBID_TAGS: ["style", "form", "input", "button", "textarea", "select", "option", "base", "link", "meta", "object", "embed", "font", "marquee", "center"],
-            ALLOW_DATA_ATTR: true,
-            // Inline styles are the usual way to hide injected links (display:none, off-screen); layouts style pages.
-            // xlink:href: SVG links, which would slip past link checks.
-            FORBID_ATTR: options.inlineStyles ? ["xlink:href"] : ["style", "xlink:href"],
-        });
+        const avif = [...(options.variants?.values() ?? [])].some((v) => v.avifSrcset);
+        if (!avif && !options.headingIds)
+            return purifier.sanitize(html, config);
+        // Heading ids and AVIF <picture> wrappers are added on DOMPurify's own output tree, then serialized once.
+        // (Editing sanitized HTML as a string and parsing it again could change its meaning.)
+        const fragment = purifier.sanitize(html, { ...config, RETURN_DOM_FRAGMENT: true });
+        if (options.headingIds)
+            addHeadingIds(fragment);
+        if (avif)
+            addAvifSources(fragment, options.variants);
+        const container = fragment.ownerDocument.createElement("div");
+        container.appendChild(fragment);
+        return container.innerHTML;
     }
     finally {
         if (publicDir)
             purifier.removeHook("afterSanitizeAttributes", hook);
+        if (options.headingIds)
+            purifier.removeHook("uponSanitizeAttribute", keepHeadingId);
     }
 }
-/** For trusted content (`markdown.html: "allow"`): the same image hints, applied through the DOM. */
-export async function enhanceTrustedHtml(html, publicDir, variants) {
+/** For trusted content (`markdown.html: "allow"`): the same image hints and heading ids, applied through the DOM. */
+export async function enhanceTrustedHtml(html, publicDir, variants, headingIds = false) {
     const { jsdom } = await load();
     const template = new jsdom.JSDOM("").window.document.createElement("template");
     template.innerHTML = html;
     template.content.querySelectorAll("img").forEach((img, i) => enhanceImage(img, publicDir, i === 0, variants?.get(img.getAttribute("src") ?? "")));
+    if (headingIds)
+        addHeadingIds(template.content);
+    if (variants)
+        addAvifSources(template.content, variants);
     return template.innerHTML;
 }
+/** "Quick start: 2 steps!" -> "quick-start-2-steps". Letters in any script are kept; accents are dropped. */
+export function headingSlug(text) {
+    return text
+        .normalize("NFKD")
+        // Only Latin accents are dropped; marks are part of other scripts (Hindi vowel signs, kana voicing).
+        .replace(/[\u0300-\u036f]/g, "")
+        .normalize("NFC")
+        .toLowerCase()
+        .replace(/[^\p{L}\p{M}\p{N}]+/gu, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/**
+ * Gives each h2 and h3 without an id one made from its text, so sections can be linked
+ * (/docs/setup/#quick-start). Ids already on the page are kept and never reused; repeats
+ * get -2, -3.
+ */
+function addHeadingIds(root) {
+    const used = new Set([...root.querySelectorAll("[id]")].map((el) => el.id));
+    for (const heading of root.querySelectorAll("h2, h3")) {
+        if (heading.id)
+            continue;
+        const base = headingSlug(heading.textContent ?? "") || "section";
+        let id = base;
+        for (let n = 2; used.has(id); n++)
+            id = `${base}-${n}`;
+        used.add(id);
+        heading.id = id;
+    }
+}
+/**
+ * Offers AVIF first: <picture><source type="image/avif" srcset sizes><img …></picture>.
+ * Browsers without AVIF use the <img> and its WebP srcset. Only images vagejs gave a
+ * srcset are wrapped (an author's own srcset or <picture> is left alone).
+ */
+function addAvifSources(root, variants) {
+    for (const img of [...root.querySelectorAll("img")]) {
+        const v = variants.get(img.getAttribute("src") ?? "");
+        if (!v?.avifSrcset || img.getAttribute("srcset") !== v.srcset || img.parentElement?.nodeName === "PICTURE")
+            continue;
+        const doc = img.ownerDocument;
+        const picture = doc.createElement("picture");
+        const source = doc.createElement("source");
+        source.setAttribute("type", "image/avif");
+        source.setAttribute("srcset", v.avifSrcset);
+        source.setAttribute("sizes", img.getAttribute("sizes") ?? v.sizes);
+        img.replaceWith(picture);
+        picture.append(source, img);
+    }
+}

package/dist/core/build.d.ts

@@ -14,6 +14,11 @@ export interface BuildResult {
     }[];
     files: string[];
     skippedDrafts: string[];
+    /** Pages with a later datePublished, and the date they go live (on a build from that day). */
+    skippedScheduled: {
+        source: string;
+        date: string;
+    }[];
     warnings: string[];
     durationMs: number;
 }

package/dist/core/build.js

@@ -54,6 +54,7 @@ export async function buildSite(root) {
             redirects: model.redirects.map((r) => ({ from: r.from, to: r.to, output: r.outFile })),
             files: [...model.files.keys()],
             skippedDrafts: model.skippedDrafts,
+            skippedScheduled: model.skippedScheduled.map(({ source, date }) => ({ source, date })),
             warnings: model.warnings,
             durationMs: Math.round(performance.now() - start),
         };

package/dist/core/config.d.ts

@@ -9,14 +9,20 @@ export declare const configSchema: z.ZodObject<{
         optimize: z.ZodDefault<z.ZodBoolean>;
         widths: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
         quality: z.ZodDefault<z.ZodNumber>;
+        avif: z.ZodDefault<z.ZodBoolean>;
         sizes: z.ZodDefault<z.ZodString>;
     }, z.core.$strict>>;
+    tags: z.ZodDefault<z.ZodObject<{
+        pages: z.ZodDefault<z.ZodBoolean>;
+        layout: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
     markdown: z.ZodDefault<z.ZodObject<{
         html: z.ZodDefault<z.ZodEnum<{
             allow: "allow";
             sanitize: "sanitize";
         }>>;
         inlineStyles: z.ZodDefault<z.ZodBoolean>;
+        headingIds: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
     seo: z.ZodDefault<z.ZodObject<{
         robots: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
@@ -115,9 +121,11 @@ export declare const configSchema: z.ZodObject<{
             "cloudflare-pages": "cloudflare-pages";
             "cloudflare-workers": "cloudflare-workers";
             "github-pages": "github-pages";
+            netlify: "netlify";
         }>>;
         cloudflareProject: z.ZodOptional<z.ZodString>;
         cloudflareWorker: z.ZodOptional<z.ZodString>;
+        netlifySite: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     security: z.ZodDefault<z.ZodObject<{
         headers: z.ZodDefault<z.ZodBoolean>;

package/dist/core/config.js

@@ -190,9 +190,20 @@ export const configSchema = z.strictObject({
         optimize: z.boolean().default(false).describe('Make resized WebP copies of images in page content and offer them with srcset. Needs "sharp" in the project (npm install --save-dev sharp).'),
         widths: z.array(z.number().int().min(16).max(8000)).min(1).max(8).default([480, 960, 1600]).describe("Widths to generate (never larger than the original)."),
         quality: z.number().int().min(1).max(100).default(75).describe("WebP quality."),
+        avif: z.boolean().default(false).describe("Also make AVIF copies (usually smaller than WebP, slower to make) and offer both with <picture>: browsers that support AVIF use it, others use WebP."),
         sizes: z.string().regex(/^[^<>"]+$/).default("(max-width: 48rem) 100vw, 48rem").describe('The sizes attribute: how wide images display, so browsers pick the right file.'),
     })
-        .default({ optimize: false, widths: [480, 960, 1600], quality: 75, sizes: "(max-width: 48rem) 100vw, 48rem" }),
+        .default({ optimize: false, widths: [480, 960, 1600], quality: 75, avif: false, sizes: "(max-width: 48rem) 100vw, 48rem" }),
+    tags: z
+        .strictObject({
+        pages: z.boolean().default(true).describe("Generate a page at /tags/<tag>/ for every tag used in page frontmatter, listing its pages, newest first."),
+        layout: z
+            .string()
+            .regex(/^[\w-]+$/, "layout must be a file name without extension")
+            .optional()
+            .describe("Layout for tag pages (src/layouts/<layout>.ts). Defaults to the default layout."),
+    })
+        .default({ pages: true }),
     markdown: z
         .strictObject({
         html: z
@@ -203,22 +214,31 @@ export const configSchema = z.strictObject({
             .boolean()
             .default(false)
             .describe('Keep style="..." attributes in page content (sanitize mode). Off by default: inline styles are the usual way to hide spam links. Put styling in layouts.'),
+        headingIds: z
+            .boolean()
+            .default(true)
+            .describe('Give each ## and ### heading in page content an id made from its text ("Quick start" -> id="quick-start"), so sections can be linked. Ids you write yourself are kept.'),
     })
-        .default({ html: "sanitize", inlineStyles: false }),
+        .default({ html: "sanitize", inlineStyles: false, headingIds: true }),
     seo: seoSchema.default(() => seoSchema.parse({})),
     performance: performanceSchema.default(() => performanceSchema.parse({})),
     deploy: z
         .strictObject({
         target: z
-            .enum(["github-pages", "cloudflare-pages", "cloudflare-workers"])
+            .enum(["github-pages", "cloudflare-pages", "cloudflare-workers", "netlify"])
             .default("github-pages")
-            .describe("Host used by `vage deploy`. Cloudflare now creates new sites as Workers: prefer cloudflare-workers there."),
+            .describe("Host used by `vage deploy`. Cloudflare now creates new sites as Workers: prefer cloudflare-workers there. netlify also makes the build write Netlify's _redirects and _headers."),
         cloudflareProject: z.string().regex(/^[a-z0-9][a-z0-9-]{0,57}$/).optional().describe("Cloudflare Pages project name."),
         cloudflareWorker: z
             .string()
             .regex(/^[a-z0-9][a-z0-9-]{0,62}$/)
             .optional()
             .describe("Cloudflare Worker name (cloudflare-workers target, when the project has no wrangler config). Defaults to cloudflareProject."),
+        netlifySite: z
+            .string()
+            .regex(/^[a-z0-9][a-z0-9-]{0,62}$/)
+            .optional()
+            .describe("Netlify site name or ID (netlify target). Create the site in Netlify first."),
     })
         .default({ target: "github-pages" }),
     security: z

package/dist/core/dates.d.ts

@@ -1,2 +1,8 @@
+/**
+ * The publish date of a page that isn't due yet, else undefined. A date ("2026-11-01")
+ * is due from that day on the build machine's calendar (UTC on most CI); a datetime
+ * with an offset ("2026-11-01T09:00:00+05:30") from that moment.
+ */
+export declare function scheduledFor(datePublished: string | undefined, now?: Date): string | undefined;
 /** A frontmatter date as a point in time ("2026-10-24" = midnight UTC); NaN when missing. */
 export declare function instant(date: string | undefined): number;

package/dist/core/dates.js

@@ -1,3 +1,17 @@
+/**
+ * The publish date of a page that isn't due yet, else undefined. A date ("2026-11-01")
+ * is due from that day on the build machine's calendar (UTC on most CI); a datetime
+ * with an offset ("2026-11-01T09:00:00+05:30") from that moment.
+ */
+export function scheduledFor(datePublished, now = new Date()) {
+    if (!datePublished)
+        return undefined;
+    if (datePublished.length === 10) {
+        const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+        return datePublished > today ? datePublished : undefined;
+    }
+    return Date.parse(datePublished) > now.getTime() ? datePublished : undefined;
+}
 /** A frontmatter date as a point in time ("2026-10-24" = midnight UTC); NaN when missing. */
 export function instant(date) {
     return date ? Date.parse(date.length === 10 ? `${date}T00:00:00Z` : date) : NaN;

package/dist/core/pages.d.ts

@@ -15,7 +15,7 @@ export interface PageSummary {
     frontmatter: Frontmatter;
 }
 /**
- * Every published page (drafts and 404.md excluded), sorted by route. Reads frontmatter
+ * Every published page (drafts, pages scheduled for a later date and 404.md excluded), sorted by route. Reads frontmatter
  * and applies each page's layout schema, so list entries get the same defaults as the
  * page itself. The result is frozen: layouts share it, so none may change it.
  * `skipInvalid` (dev server, `vage check`) leaves out pages whose frontmatter is invalid;
@@ -35,6 +35,8 @@ export interface CollectionOptions {
      */
     sort?: "date" | "title" | "route" | "order" | ((a: PageSummary, b: PageSummary) => number);
     limit?: number;
+    /** Only pages with this tag (compared like tag page addresses: "SEO" matches "seo"). */
+    tag?: string;
 }
 /**
  * Picks and orders pages for lists such as a blog index, a sidebar or "latest posts":
@@ -43,6 +45,18 @@ export interface CollectionOptions {
 /** By `order` (lowest first; pages without one last), then title. */
 export declare function byOrder(a: PageSummary, b: PageSummary): number;
 export declare function collection(pages: readonly PageSummary[], options?: CollectionOptions): PageSummary[];
+/** A tag's address part: "Web Design" -> "web-design" (tag pages live at /tags/<slug>/). */
+export declare function tagSlug(tag: string): string;
+export interface TagSummary {
+    /** The tag as first written in the pages, e.g. "SEO". */
+    name: string;
+    slug: string;
+    /** "/tags/<slug>/" (generated when tags.pages is on). */
+    route: string;
+    count: number;
+}
+/** Every tag the pages use, A to Z, with how many pages have it: for tag clouds and tag menus. */
+export declare function tagList(pages: readonly PageSummary[]): TagSummary[];
 /** The pages before and after `route` in an ordered list (e.g. from collection()), for "Previous / Next" links. */
 export declare function neighbors(list: readonly PageSummary[], route: string): {
     prev?: PageSummary;

package/dist/core/pages.js

@@ -1,14 +1,15 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseFrontmatter } from "../content/markdown.js";
+import { headingSlug } from "../content/sanitize.js";
 import { pageMeta } from "../seo/head.js";
 import { clonePlain } from "./clone.js";
-import { instant } from "./dates.js";
+import { instant, scheduledFor } from "./dates.js";
 import { applyLayoutFields } from "./render.js";
 import { VageError } from "./errors.js";
 import { discoverRoutes } from "./routes.js";
 /**
- * Every published page (drafts and 404.md excluded), sorted by route. Reads frontmatter
+ * Every published page (drafts, pages scheduled for a later date and 404.md excluded), sorted by route. Reads frontmatter
  * and applies each page's layout schema, so list entries get the same defaults as the
  * page itself. The result is frozen: layouts share it, so none may change it.
  * `skipInvalid` (dev server, `vage check`) leaves out pages whose frontmatter is invalid;
@@ -21,7 +22,7 @@ export async function collectPages(root, site, load, options = {}) {
         let frontmatter;
         try {
             ({ frontmatter } = parseFrontmatter(fs.readFileSync(entry.file, "utf8"), entry.file));
-            if (frontmatter.draft)
+            if (frontmatter.draft || scheduledFor(frontmatter.datePublished))
                 continue;
             await applyLayoutFields(root, frontmatter, load, entry.file);
         }
@@ -70,7 +71,9 @@ export function byOrder(a, b) {
 export function collection(pages, options = {}) {
     if (!Array.isArray(pages))
         throw new VageError("collection(): pass the layout's `pages` as the first argument.");
-    const { under, includeIndex = false, sort = "route", limit } = options;
+    const { under, includeIndex = false, sort = "route", limit, tag } = options;
+    if (tag !== undefined && (typeof tag !== "string" || !tagSlug(tag)))
+        throw new VageError(`collection(): "tag" must be a tag name like "SEO" (got ${JSON.stringify(tag)}).`);
     if (under !== undefined && !/^\/(?!\/)/.test(under)) {
         throw new VageError(`collection(): "under" must be a site path starting with "/", like "/blog/" (got ${JSON.stringify(under)}).`);
     }
@@ -83,7 +86,7 @@ export function collection(pages, options = {}) {
         throw new VageError(`collection(): "limit" must be a whole number of 0 or more (got ${JSON.stringify(limit)}).`);
     }
     const prefix = under ? (under.endsWith("/") ? under : `${under}/`) : undefined;
-    const picked = pages.filter((p) => !prefix || (p.route.startsWith(prefix) && (includeIndex || p.route !== prefix)));
+    const picked = pages.filter((p) => (!prefix || (p.route.startsWith(prefix) && (includeIndex || p.route !== prefix))) && (tag === undefined || (p.frontmatter.tags ?? []).some((t) => tagSlug(t) === tagSlug(tag))));
     const byTitle = (a, b) => a.title.localeCompare(b.title);
     const compare = typeof sort === "function"
         ? sort
@@ -103,6 +106,25 @@ export function collection(pages, options = {}) {
     const sorted = [...picked].sort(compare);
     return limit === undefined ? sorted : sorted.slice(0, limit);
 }
+/** A tag's address part: "Web Design" -> "web-design" (tag pages live at /tags/<slug>/). */
+export function tagSlug(tag) {
+    return headingSlug(tag);
+}
+/** Every tag the pages use, A to Z, with how many pages have it: for tag clouds and tag menus. */
+export function tagList(pages) {
+    const tags = new Map();
+    for (const p of pages) {
+        for (const name of new Set(p.frontmatter.tags ?? [])) {
+            const slug = tagSlug(name);
+            if (!slug)
+                continue;
+            const t = tags.get(slug) ?? { name, slug, route: `/tags/${slug}/`, count: 0 };
+            t.count++;
+            tags.set(slug, t);
+        }
+    }
+    return [...tags.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
 /** The pages before and after `route` in an ordered list (e.g. from collection()), for "Previous / Next" links. */
 export function neighbors(list, route) {
     const i = list.findIndex((p) => p.route === route);

package/dist/core/render.d.ts

@@ -49,6 +49,8 @@ export declare function renderPage(options: {
     pages?: readonly PageSummary[];
     /** Resizer for images.optimize (tests inject one; sharp otherwise). */
     resize?: Resize;
+    /** The page's Markdown, for generated pages (tag pages); otherwise `file` is read. */
+    source?: string;
 }): Promise<RenderedPage>;
 /**
  * Loads the page's layout and, if it exports a `frontmatter` schema, validates the page

package/dist/core/render.js

@@ -11,7 +11,7 @@ import { headTags, injectHead, pageMeta } from "../seo/head.js";
 import { analyticsTags, injectAnalytics } from "../integrations/tags.js";
 export async function renderPage(options) {
     const { root, file, route, site, load } = options;
-    const parsed = parseMarkdown(fs.readFileSync(file, "utf8"), file);
+    const parsed = parseMarkdown(options.source ?? fs.readFileSync(file, "utf8"), file);
     const { frontmatter, body } = parsed;
     const publicDir = path.join(root, "public");
     const assets = new Map();
@@ -23,14 +23,14 @@ export async function renderPage(options) {
             const v = await imageVariants(src, root, site.images, resize);
             if (!v)
                 continue;
-            variants.set(src, { srcset: v.srcset, sizes: site.images.sizes });
+            variants.set(src, { srcset: v.srcset, sizes: site.images.sizes, avifSrcset: v.avifSrcset });
             for (const [k, f] of v.files)
                 assets.set(k, f);
         }
     }
     const content = site.markdown.html === "allow"
-        ? await enhanceTrustedHtml(parsed.html, publicDir, variants)
-        : await sanitizeHtml(parsed.html, { publicDir, inlineStyles: site.markdown.inlineStyles, variants });
+        ? await enhanceTrustedHtml(parsed.html, publicDir, variants, site.markdown.headingIds)
+        : await sanitizeHtml(parsed.html, { publicDir, inlineStyles: site.markdown.inlineStyles, variants, headingIds: site.markdown.headingIds });
     const layout = await applyLayoutFields(root, frontmatter, load, file);
     const meta = pageMeta(site, route, frontmatter, options.notFound);
     const result = await layout({

package/dist/core/site.d.ts

@@ -1,5 +1,6 @@
 import { type ModuleLoader, type SiteConfig } from "./config.js";
 import { type RenderedPage } from "./render.js";
+import { type PageSummary } from "./pages.js";
 export interface SitePage extends RenderedPage {
     route: string;
     /** Source path relative to the project root. */
@@ -28,6 +29,12 @@ export interface SiteModel {
     skippedDrafts: string[];
     /** Routes of draft pages; links to them are broken in production. */
     draftRoutes: string[];
+    /** Pages whose datePublished is still ahead: skipped until a build on or after that date. */
+    skippedScheduled: {
+        source: string;
+        route: string;
+        date: string;
+    }[];
     notFound?: SitePage;
     redirects: SiteRedirect[];
     /** Generated discovery files: output path -> content. */
@@ -38,5 +45,7 @@ export interface SiteModel {
 export declare function renderSite(root: string, load: ModuleLoader, options?: {
     collectErrors?: boolean;
 }): Promise<SiteModel>;
+/** A tag page's Markdown: a heading and the tagged pages, newest first. Written as HTML so tag and page names can't become Markdown. */
+export declare function tagPageSource(site: SiteConfig, name: string, tagged: PageSummary[]): string;
 /** Pages that should appear in sitemap.xml and llms.txt: indexable and canonical to themselves. */
 export declare function listedPages(model: SiteModel): SitePage[];