vagejs 0.4.0 → 0.5.0

package/README.md

@@ -15,16 +15,16 @@
 
 **A free static site generator built for AI coding assistants.** Your assistant (Claude Code, Cursor, Codex, Copilot) writes the pages; vagejs checks them before anything goes live. Write pages in Markdown and get a fast static site with SEO, `llms.txt`, accessibility and security handled for you. **Pre-release (0.x).**
 
-[Website](https://vagejs.com) · [Docs](https://vagejs.com/docs/) · [Use with AI assistants](https://vagejs.com/agents/) · [Changelog](https://vagejs.com/changelog/) · [Discussions](https://github.com/agevenkat/vagejs/discussions)
+[Website](https://vagejs.com) · [Docs](https://vagejs.com/docs/) · [Use with AI assistants](https://vagejs.com/agents/) · [Changelog](https://vagejs.com/changelog/) · [Discussions](https://github.com/agevenkat/vagejs/discussions) · [LinkedIn](https://www.linkedin.com/company/vagejs/)
 
 <p align="center"><img src="https://raw.githubusercontent.com/agevenkat/vagejs/main/assets/demo.svg" alt="Terminal demo: create a vagejs site, install it, npm run check catches a broken link and names the file, the link is fixed, the check passes, and npm start runs the site." width="760"></p>
 
 - **Static by default**: plain HTML, no client JavaScript unless you add analytics.
 - **SEO built in**: `robots.txt`, `sitemap.xml`, `llms.txt`, canonical URLs, Open Graph and JSON-LD, generated from your pages.
 - **Checks before you ship**: `vage check` (links, SEO, structured data, accessibility) and `vage audit` (page-weight budgets, axe, optional Lighthouse and PageSpeed).
-- **Safe by default**: page content is sanitized; secrets, build output and force-pushes are refused; Cloudflare deploys get a computed Content-Security-Policy.
+- **Safe by default**: page content is sanitized; secrets, build output and force-pushes are refused; Cloudflare and Netlify deploys get a computed Content-Security-Policy.
 - **Agent-friendly**: every site ships with `AGENTS.md`, and `vage info --json` describes every command and config option.
-- **Runs everywhere**: macOS, Windows and Linux, tested on every change. Deploys to GitHub Pages and Cloudflare Workers built in; any static host (Vercel, Netlify) works with `npm run build` and the `dist` folder.
+- **Runs everywhere**: macOS, Windows and Linux, tested on every change. Deploys to GitHub Pages, Cloudflare Workers and Netlify built in; any other static host (Vercel) works with `npm run build` and the `dist` folder.
 
 ## Quick start
 
@@ -36,9 +36,17 @@ cd my-site
 npm install
 npm start
 ```
-
 `npm start` opens the site in your browser. Edit `src/pages/index.md` and the page reloads. (`npm run dev` does the same without opening a browser, and prints the address.)
 
+### Windows
+
+vagejs works on Windows and is tested on Windows on every change.
+
+- **Node.js:** install Node.js **22.12 or newer** before creating a project. Then open a new PowerShell or Command Prompt window and check it with `node --version` and `npm --version`.
+- **PowerShell or Command Prompt:** the `npm` and `npx` commands in this README work in both. Command Prompt doesn't treat `#` as a comment, so leave out the `# …` notes shown after some commands.
+- **Line endings:** Windows usually saves files with CRLF line endings. vagejs handles them, so there's no need to convert files to LF.
+- **HTTP 431 in the browser:** open the direct address (`[::1]` or `127.0.0.1`) that `npm start` and `npm run dev` print. It's the same server, without the cookies other local projects left on `localhost`.
+
 ## Using vagejs
 
 ### Project layout
@@ -71,7 +79,7 @@ description: Plans and prices.
 Our plans start at …
 ```
 
-Save it as `src/pages/pricing.md` and it's served at `/pricing/`. `title` is required. `description`, `draft`, `noindex`, `canonical`, `image`, `type: article`, `author`, `datePublished` and `dateModified` are optional; see [`templates/starter/AGENTS.md`](templates/starter/AGENTS.md).
+Save it as `src/pages/pricing.md` and it's served at `/pricing/`. `title` is required. `description`, `draft`, `noindex`, `canonical`, `image`, `type: article`, `author`, `datePublished`, `dateModified` and `tags` are optional (a future `datePublished` schedules the page; each tag gets a page at `/tags/<tag>/`); see [`templates/starter/AGENTS.md`](templates/starter/AGENTS.md).
 
 Images in `public/` used as `![Alt text](/images/photo.jpg)` get their `width` and `height` from the file, so the page doesn't jump while loading. With `images: { optimize: true }` (and `npm install --save-dev sharp`), vagejs also makes resized WebP copies of images in page content and offers them with `srcset`. Add `avif: true` for AVIF copies too, offered first through `<picture>` (usually smaller; slower to make). `vage audit` counts the copy browsers download, not the original.
 
@@ -145,6 +153,7 @@ npx vage deploy:github --remote https://github.com/you/site.git   # check, build
 npx vage deploy                                                  # GitHub Pages via Actions
 npx vage deploy --target cloudflare-workers --project my-site    # Cloudflare Workers: new version, no downtime
 npx vage deploy --target cloudflare-pages --project my-site      # older Cloudflare Pages projects
+npx vage deploy --target netlify --project my-site               # Netlify production deploy (deploy.target: "netlify")
 ```
 
 Every deploy shows its plan and asks for confirmation (`--dry-run` to preview, `--yes` to skip). It reports success only after the host confirms.
@@ -201,6 +210,7 @@ vage deploy:github [--remote URL] [--branch B] [-m MSG] [--dry-run] [--yes] [--j
 vage deploy        [--remote URL] [--no-wait] [--dry-run] [--yes] # GitHub Pages via Actions; confirms with GitHub
 vage deploy --target cloudflare-workers [--project NAME]          # new Worker version at 100%; custom domains stay up
 vage deploy --target cloudflare-pages --project NAME [--branch B] # Wrangler upload; preview URL per branch
+vage deploy --target netlify [--project SITE]                     # netlify-cli production deploy, then a live check
 vage indexnow --changed-since REF | --urls … | --all              # IndexNow URL notification (asks first)
 vage connect gsc|ga4 / vage disconnect google      # read-only Google OAuth (PKCE, loopback); token outside the repo
 vage connect pagespeed|crux / vage disconnect …   # save your own Google API key for audit --url (outside the repo)
@@ -211,7 +221,7 @@ vage info     [--json]                            # commands + config/frontmatte
 
 ## Planned, not implemented
 
-Bing Webmaster Tools API, Netlify/Vercel adapters, CMS content sources, multi-language sites, base paths, sitemap indexes.
+Bing Webmaster Tools API, a Vercel adapter, CMS content sources, multi-language sites, base paths, sitemap indexes.
 
 ## Security
 

package/dist/checks/check.js

@@ -62,10 +62,17 @@ export function checkSite(root, model) {
         if (e.route)
             outputs.add(`${e.route}index.html`);
     const drafts = new Set(model.draftRoutes);
+    const scheduled = new Map(model.skippedScheduled.map((s) => [s.route, s.date]));
     const pages = model.notFound ? [...model.pages, model.notFound] : model.pages;
-    for (const page of pages) {
+    const docs = pages.map((page) => ({ page, doc: parse(page.html) }));
+    // Link targets on each output file: element ids and <a name>, for #fragment links.
+    const anchors = new Map(docs.map(({ page, doc }) => [
+        `/${page.outFile}`,
+        new Set([...doc.querySelectorAll("[id]").map((el) => el.getAttribute("id")), ...doc.querySelectorAll("a[name]").map((el) => el.getAttribute("name"))]),
+    ]));
+    for (const { page, doc } of docs) {
         const add = (f) => findings.push({ ...f, page: page.route, source: page.source });
-        checkPage(page, parse(page.html), model, outputs, drafts, add);
+        checkPage(page, doc, model, outputs, drafts, scheduled, anchors, add);
     }
     findings.push(...checkDuplicates(listedPages(model)));
     findings.push(...checkRobots(model));
@@ -73,7 +80,7 @@ export function checkSite(root, model) {
     findings.push(...checkOutboundLinks(root, model));
     return findings;
 }
-function checkPage(page, doc, model, outputs, drafts, add) {
+function checkPage(page, doc, model, outputs, drafts, scheduled, anchors, add) {
     const indexable = !page.meta.noindex;
     if (model.site.security.spamPatterns) {
         const text = `${doc.querySelector("body")?.text ?? ""} ${doc.querySelectorAll("a[href]").map((a) => a.getAttribute("href")).join(" ")}`;
@@ -101,6 +108,25 @@ function checkPage(page, doc, model, outputs, drafts, add) {
     if (titles.length !== 1 || !titles[0].text.trim()) {
         add({ rule: "title", severity: "error", message: `Expected exactly one non-empty <title>, found ${titles.length}.`, docs: DOCS.title });
     }
+    // Only pages shown in search results can be shortened there.
+    const renderedTitle = titles[0]?.text.trim() ?? "";
+    if (indexable && renderedTitle.length > 60) {
+        add({
+            rule: "title-length",
+            severity: "warning",
+            message: `Rendered <title> in "${page.source}" is ${renderedTitle.length} characters; it may be shortened in search results.`,
+            docs: DOCS.title,
+        });
+    }
+    const description = doc.querySelector('meta[name="description"]')?.getAttribute("content")?.trim() ?? "";
+    if (indexable && description.length > 160) {
+        add({
+            rule: "meta-description-length",
+            severity: "warning",
+            message: `Meta description in "${page.source}" is ${description.length} characters; it may be shortened in search results.`,
+            docs: DOCS.description,
+        });
+    }
     if (indexable && !doc.querySelector('meta[name="description"]')?.getAttribute("content")) {
         add({
             rule: "meta-description",
@@ -148,6 +174,10 @@ function checkPage(page, doc, model, outputs, drafts, add) {
         if (!a.text.trim() && !a.getAttribute("aria-label") && !a.querySelector("img[alt]:not([alt=''])")) {
             add({ rule: "link-text", severity: "warning", message: `Link to "${href}" has no accessible text.`, docs: DOCS.linkPurpose });
         }
+        if (/^#./.test(href.trim())) {
+            checkFragment(href, `/${page.outFile}`, anchors, add);
+            continue;
+        }
         const target = internalPath(href, page.route, model.site.site);
         if (target === undefined)
             continue;
@@ -156,12 +186,19 @@ function checkPage(page, doc, model, outputs, drafts, add) {
             continue;
         }
         const resolved = resolveOutput(target, outputs);
+        if (resolved === "ok")
+            checkFragment(href, target.endsWith("/") ? `${target}index.html` : target, anchors, add);
         if (resolved === "missing") {
-            const draft = drafts.has(target.endsWith("/") ? target : `${target}/`);
+            const route = target.endsWith("/") ? target : `${target}/`;
+            const date = scheduled.get(route);
             add({
                 rule: "link-broken",
                 severity: "error",
-                message: draft ? `Link to "${href}" points to a draft page, which is not published.` : `Link to "${href}" does not match any page or file.`,
+                message: drafts.has(route)
+                    ? `Link to "${href}" points to a draft page, which is not published.`
+                    : date
+                        ? `Link to "${href}" points to a page scheduled for ${date}, which is not published yet.`
+                        : `Link to "${href}" does not match any page or file.`,
             });
         }
         else if (resolved === "needs-slash") {
@@ -423,6 +460,27 @@ function internalPath(href, base, site) {
         return MALFORMED;
     }
 }
+/**
+ * A #fragment must match an id (or <a name>) on the page it points to; otherwise the
+ * page opens at the top instead of the section. "#top" and text fragments (#:~:text=)
+ * work without one. Files that aren't rendered pages (PDFs, redirects) aren't checked.
+ */
+function checkFragment(href, outFile, anchors, add) {
+    const ids = anchors.get(outFile);
+    const hash = href.indexOf("#");
+    if (!ids || hash === -1)
+        return;
+    let fragment;
+    try {
+        fragment = decodeURIComponent(href.slice(hash + 1));
+    }
+    catch {
+        fragment = href.slice(hash + 1);
+    }
+    if (!fragment || fragment.toLowerCase() === "top" || fragment.startsWith(":~:") || ids.has(fragment))
+        return;
+    add({ rule: "link-fragment", severity: "warning", message: `Link to "${href}": no element with id "${fragment}" on that page, so it opens at the top.` });
+}
 function resolveOutput(target, outputs) {
     if (target.endsWith("/"))
         return outputs.has(`${target}index.html`) ? "ok" : "missing";

package/dist/cli/index.js

@@ -56,6 +56,8 @@ cli
         console.log(`  ${"".padEnd(30)} -> ${file}`);
     for (const draft of result.skippedDrafts)
         console.log(`  (draft, skipped) ${draft}`);
+    for (const s of result.skippedScheduled)
+        console.log(`  (scheduled for ${s.date}, skipped) ${s.source}`);
     for (const warning of result.warnings)
         console.log(`\nWarning: ${warning}`);
     console.log(`\nBuilt ${result.pages.length} page(s) into ${result.outDir} in ${result.durationMs}ms`);
@@ -203,10 +205,10 @@ cli
     reportPublish(result);
 }));
 cli
-    .command("deploy", "Deploy: GitHub Pages (workflow + push, waits for GitHub), Cloudflare Workers (new version, no downtime) or Cloudflare Pages")
+    .command("deploy", "Deploy: GitHub Pages (workflow + push, waits for GitHub), Cloudflare Workers (new version, no downtime), Cloudflare Pages or Netlify")
     .option("--root <dir>", "Project root", { default: "." })
-    .option("--target <host>", "github-pages, cloudflare-workers or cloudflare-pages (default: deploy.target in config)")
-    .option("--project <name>", "Cloudflare Pages project or Worker name (default: deploy.cloudflareProject / cloudflareWorker)")
+    .option("--target <host>", "github-pages, cloudflare-workers, cloudflare-pages or netlify (default: deploy.target in config)")
+    .option("--project <name>", "Cloudflare Pages project, Worker or Netlify site name (default: deploy.cloudflareProject / cloudflareWorker / netlifySite)")
     .option("--remote <url>", "Git URL to add as origin if there is none")
     .option("--branch <name>", "Branch for a new repository (default: main)")
     .option("-m, --message <msg>", "Commit message")
@@ -222,8 +224,13 @@ cli
         return deployToCloudflare(opts, config.deploy.cloudflareProject);
     if (target === "cloudflare-workers")
         return deployToWorkers(opts, config.deploy.cloudflareWorker ?? config.deploy.cloudflareProject, config.site);
+    if (target === "netlify") {
+        if (config.deploy.target !== "netlify")
+            throw new VageError('Set deploy.target to "netlify" in vage.config.ts, so the build writes Netlify\'s _redirects and _headers.');
+        return deployToNetlify(opts, config.deploy.netlifySite, config.site);
+    }
     if (target !== "github-pages")
-        throw new VageError(`Unknown --target "${target}". Use github-pages, cloudflare-workers or cloudflare-pages.`);
+        throw new VageError(`Unknown --target "${target}". Use github-pages, cloudflare-workers, cloudflare-pages or netlify.`);
     const { publish } = await import("../deploy/publish.js");
     const pages = await import("../deploy/github-pages.js");
     // Stop before pushing a site GitHub Pages would serve from a subfolder (its links would break).
@@ -489,7 +496,9 @@ cli
         urls = opts.urls.split(",").map((u) => abs(u.trim()));
     else if (opts.changedSince) {
         const { changedPageRoutes } = await import("../deploy/git.js");
-        urls = (await changedPageRoutes(root, opts.changedSince)).map(abs);
+        // Deleted pages are submitted too (so engines drop them); drafts and scheduled pages aren't live yet.
+        const unpublished = new Set([...model.draftRoutes, ...model.skippedScheduled.map((s) => s.route)]);
+        urls = (await changedPageRoutes(root, opts.changedSince)).filter((r) => !unpublished.has(r)).map(abs);
         if (!urls.length)
             return opts.json ? print({ ok: true, submitted: 0 }) : console.log(`No page changes since ${opts.changedSince}.`);
     }
@@ -647,6 +656,40 @@ async function deployToWorkers(opts, configuredWorker, siteUrl) {
     if (deployment.status === "failure")
         process.exit(1);
 }
+async function deployToNetlify(opts, configuredSite, siteUrl) {
+    const site = opts.project ?? configuredSite;
+    if (!site)
+        throw new VageError("No Netlify site. Pass --project <site name or ID> or set deploy.netlifySite in vage.config.ts (create the site in Netlify first).");
+    if (!/^[a-z0-9][a-z0-9-]{0,62}$/.test(site))
+        throw new VageError(`"${site}" isn't a Netlify site name or ID (lowercase letters, digits and hyphens).`);
+    const root = path.resolve(opts.root);
+    const { check } = await import("../checks/check.js");
+    const checked = await check(root);
+    if (checked.errors)
+        throw new VageError(`vage check found ${checked.errors} error(s). Fix them before deploying.`);
+    const result = await build(root);
+    const { deployNetlify, NETLIFY_CLI } = await import("../deploy/netlify.js");
+    const steps = [
+        `upload ${result.outDir} (${result.pages.length} page(s), ${result.files.length} generated file(s)) to the Netlify site "${site}" (production)`,
+        `runs: npx ${NETLIFY_CLI} deploy --dir dist --prod --no-build --site ${site}`,
+        `verifies: ${siteUrl ?? "the site's Netlify URL"} answers 200`,
+    ];
+    const lines = ["Deploy plan (Netlify)", ...steps.map((s) => `  • ${s}`)];
+    if (!(await askConfirm(lines, opts))) {
+        if (opts.dryRun)
+            return opts.json ? print({ ok: true, dryRun: true, target: "netlify", site, steps }) : console.log("Dry run: nothing deployed.");
+        return opts.json ? print({ ok: false, status: "aborted" }) : console.log("Nothing deployed.");
+    }
+    const deployment = await deployNetlify(root, { site, siteUrl });
+    if (opts.json)
+        print({ ok: deployment.status !== "failure", target: "netlify", deployment });
+    else if (deployment.status === "success")
+        console.log(`Deployed and verified: ${deployment.pageUrl}${deployment.deployId ? ` (deploy ${deployment.deployId})` : ""}`);
+    else
+        console.log(`Deployment ${deployment.status === "failure" ? "FAILED" : "not confirmed"}: ${deployment.reason}`);
+    if (deployment.status === "failure")
+        process.exit(1);
+}
 async function confirmPlan(plan, opts, extra) {
     const lines = [`Publish plan for ${plan.root}`];
     if (plan.initRepo)

package/dist/cli/info.d.ts

@@ -88,6 +88,7 @@ export declare function frameworkInfo(cli: CAC, version: string): {
         VAGE_CONFIG_DIR: string;
         CLOUDFLARE_API_TOKEN: string;
         CLOUDFLARE_ACCOUNT_ID: string;
+        NETLIFY_AUTH_TOKEN: string;
     };
     notImplemented: string[];
 };

package/dist/cli/info.js

@@ -34,7 +34,7 @@ export function frameworkInfo(cli, version) {
                 "two files mapping to one route is an error",
             ],
             layouts: "see `layouts`",
-            drafts: "draft: true pages render in `vage dev` for preview, are skipped by build, and never appear in `pages`",
+            drafts: "draft: true pages render in `vage dev` for preview, are skipped by build, and never appear in `pages`. A future datePublished does the same until a build on or after that date (scheduled pages)",
         },
         layouts: {
             file: "src/layouts/<name>.ts, chosen with `layout: <name>` in frontmatter (default: default)",
@@ -88,8 +88,9 @@ export function frameworkInfo(cli, version) {
             "llms-full.txt (opt-in)",
             "404.html",
             "redirect pages",
+            "/tags/<tag>/ pages for tags used in frontmatter (tags.pages)",
             "<indexnow-key>.txt (opt-in)",
-            "_redirects and _headers (cloudflare-workers and cloudflare-pages targets)",
+            "_redirects and _headers (cloudflare-workers, cloudflare-pages and netlify targets)",
             "<section>/feed.xml (seo.feeds)",
             "/<path>.md Markdown copies of listed pages (seo.markdownCopies)",
             "/_vage/img/*.webp resized images (images.optimize)",
@@ -102,10 +103,12 @@ export function frameworkInfo(cli, version) {
             VAGE_CONFIG_DIR: "optional; where the Google token is stored (default: OS user config dir)",
             CLOUDFLARE_API_TOKEN: "for Cloudflare deploys (cloudflare-workers or cloudflare-pages targets), or run `npx wrangler login`",
             CLOUDFLARE_ACCOUNT_ID: "for Cloudflare deploys (cloudflare-workers or cloudflare-pages targets)",
+            NETLIFY_AUTH_TOKEN: "for Netlify deploys (netlify target), or run `npx netlify-cli login`",
         },
         notImplemented: [
             "Bing Webmaster Tools API (use IndexNow for URL submission)",
-            "Netlify and Vercel deploy adapters",
+            "A Vercel deploy adapter (Vercel serves dist/ as plain files)",
+            "RSS feeds per tag",
             "CMS / external content-source adapters",
             "hreflang / multi-language sites, base paths, sitemap indexes",
         ],

package/dist/content/markdown.d.ts

@@ -16,6 +16,7 @@ export declare const frontmatterSchema: z.ZodObject<{
     dateModified: z.ZodOptional<z.ZodPreprocess<z.ZodUnion<readonly [z.ZodISODate, z.ZodISODateTime]>, unknown>>;
     order: z.ZodOptional<z.ZodNumber>;
     navTitle: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>;
 export type Frontmatter = z.output<typeof frontmatterSchema>;
 export interface MarkdownPage {

package/dist/content/markdown.js

@@ -30,6 +30,10 @@ export const frontmatterSchema = z.looseObject({
     dateModified: isoDate.optional().describe("ISO date or datetime; also the sitemap <lastmod>."),
     order: z.number().finite().optional().describe('Position in navigation lists (lower first). Used by collection(pages, { sort: "order" }) and tree().'),
     navTitle: singleLine.min(1).optional().describe("Shorter title for menus and breadcrumbs. Defaults to the title."),
+    tags: z
+        .array(singleLine.regex(/[\p{L}\p{N}]/u, "each tag needs a letter or digit (it becomes the address /tags/<tag>/)"))
+        .optional()
+        .describe('Topics, e.g. [SEO, AI]. Each tag gets a page at /tags/<tag>/ listing its pages (tags.pages); collection(pages, { tag: "SEO" }) picks them.'),
 });
 const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
 const marked = new Marked({ gfm: true });

package/dist/content/sanitize.d.ts

@@ -18,6 +18,9 @@ export declare function sanitizeHtml(html: string, options?: {
     publicDir?: string;
     inlineStyles?: boolean;
     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, ImageVariant>): 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,9 +29,17 @@ 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"],
@@ -41,12 +49,16 @@ export async function sanitizeHtml(html, options = {}) {
         FORBID_ATTR: options.inlineStyles ? ["xlink:href"] : ["style", "xlink:href"],
     };
     try {
-        if (![...(options.variants?.values() ?? [])].some((v) => v.avifSrcset))
+        const avif = [...(options.variants?.values() ?? [])].some((v) => v.avifSrcset);
+        if (!avif && !options.headingIds)
             return purifier.sanitize(html, config);
-        // AVIF: wrap images in <picture> on DOMPurify's own output tree, then serialize once.
+        // 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 });
-        addAvifSources(fragment, options.variants);
+        if (options.headingIds)
+            addHeadingIds(fragment);
+        if (avif)
+            addAvifSources(fragment, options.variants);
         const container = fragment.ownerDocument.createElement("div");
         container.appendChild(fragment);
         return container.innerHTML;
@@ -54,18 +66,51 @@ export async function sanitizeHtml(html, options = {}) {
     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

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

@@ -12,12 +12,17 @@ export declare const configSchema: z.ZodObject<{
         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<{
@@ -116,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

@@ -194,6 +194,16 @@ export const configSchema = z.strictObject({
         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, 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
@@ -204,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();
@@ -29,8 +29,8 @@ export async function renderPage(options) {
         }
     }
     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[];

package/dist/core/site.js

@@ -7,7 +7,7 @@ import { copySource, htmlToMarkdown, markdownCopy, markdownCopyPath } from "../d
 import { robotsTxt } from "../discovery/robots.js";
 import { SITEMAP_URL_LIMIT, sitemapXml } from "../discovery/sitemap.js";
 import { copyCanonicalsFit, headersFile } from "../deploy/headers.js";
-import { cloudflareRedirects } from "../deploy/redirects.js";
+import { cloudflareRedirects, netlifyRedirects } from "../deploy/redirects.js";
 import { findSecrets } from "../deploy/secrets.js";
 import { rulePack } from "../guidelines/pack.js";
 import { absoluteUrl } from "../seo/urls.js";
@@ -17,7 +17,8 @@ import { escapeHtml } from "./html.js";
 import { renderPage } from "./render.js";
 import { parseFrontmatter } from "../content/markdown.js";
 import { sharpResize } from "../content/optimize.js";
-import { collectPages } from "./pages.js";
+import { scheduledFor } from "./dates.js";
+import { collection, collectPages, tagList } from "./pages.js";
 import { discoverRoutes, findNotFoundPage, normalizeRequestPath } from "./routes.js";
 /** Renders every page and derives discovery files from the same data, without writing anything. */
 export async function renderSite(root, load, options = {}) {
@@ -31,7 +32,7 @@ export async function renderSite(root, load, options = {}) {
         throw new VageError(`This project pins rule pack ${pinned}, but the installed vagejs ships ${rulePack.version}. ` +
             `Review what changed with "vage guidelines", then update guidelines.rulePack in vage.config.ts.`);
     }
-    const model = { site, pageErrors: [], pages: [], skippedDrafts: [], draftRoutes: [], redirects: [], files: new Map(), warnings: [] };
+    const model = { site, pageErrors: [], pages: [], skippedDrafts: [], draftRoutes: [], skippedScheduled: [], redirects: [], files: new Map(), warnings: [] };
     const collect = options.collectErrors === true;
     const attempt = async (file, route, work) => {
         try {
@@ -51,16 +52,37 @@ export async function renderSite(root, load, options = {}) {
     for (const entry of discoverRoutes(pagesDir)) {
         const source = path.relative(root, entry.file);
         await attempt(entry.file, entry.route, async () => {
-            // Drafts are skipped before rendering, so their fields can't fail a build.
-            if (parseFrontmatter(fs.readFileSync(entry.file, "utf8"), entry.file).frontmatter.draft) {
+            // Drafts and scheduled pages are skipped before rendering, so their fields can't fail a build.
+            const { frontmatter } = parseFrontmatter(fs.readFileSync(entry.file, "utf8"), entry.file);
+            if (frontmatter.draft) {
                 model.skippedDrafts.push(source);
                 model.draftRoutes.push(entry.route);
                 return;
             }
+            const date = scheduledFor(frontmatter.datePublished);
+            if (date) {
+                model.skippedScheduled.push({ source, route: entry.route, date });
+                return;
+            }
             const page = await renderPage({ root, file: entry.file, route: entry.route, site, load, analytics: true, pages, resize });
             model.pages.push({ ...page, route: entry.route, source, outFile: entry.outFile });
         });
     }
+    if (site.tags.pages) {
+        // Only published pages can clash: a draft or scheduled page at a tag address isn't in the build.
+        const taken = new Map(model.pages.map((p) => [p.route, p.source]));
+        for (const tag of tagList(pages)) {
+            const file = path.join(pagesDir, "tags", `${tag.slug}.md`);
+            const source = `(tag "${tag.name}")`;
+            await attempt(file, tag.route, async () => {
+                if (taken.has(tag.route)) {
+                    throw new VageError(`${taken.get(tag.route)} and the tag "${tag.name}" both make ${tag.route}. Rename one, or set tags.pages: false in vage.config.ts.`);
+                }
+                const page = await renderPage({ root, file, route: tag.route, site, load, analytics: true, pages, resize, source: tagPageSource(site, tag.name, collection(pages, { tag: tag.name, sort: "date" })) });
+                model.pages.push({ ...page, route: tag.route, source, outFile: `${tag.route.slice(1)}index.html` });
+            });
+        }
+    }
     const notFound = findNotFoundPage(pagesDir);
     if (notFound) {
         await attempt(notFound, undefined, async () => {
@@ -79,6 +101,23 @@ export async function renderSite(root, load, options = {}) {
     addDiscoveryFiles(root, model, markdown);
     return model;
 }
+/** 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 function tagPageSource(site, name, tagged) {
+    const items = tagged.map((p) => `<li><a href="${escapeHtml(p.route)}">${escapeHtml(p.title)}</a>${p.description ? `: ${escapeHtml(p.description)}` : ""}</li>`);
+    const description = `Pages${site.title ? ` on ${site.title}` : ""} tagged ${name}.`;
+    return [
+        "---",
+        `title: ${JSON.stringify(`Tagged: ${name}`)}`,
+        `description: ${JSON.stringify(description)}`,
+        ...(site.tags.layout ? [`layout: ${site.tags.layout}`] : []),
+        "---",
+        "",
+        `<h1>Tagged: ${escapeHtml(name)}</h1>`,
+        "",
+        `<ul>\n${items.join("\n")}\n</ul>`,
+        "",
+    ].join("\n");
+}
 /** Pages that should appear in sitemap.xml and llms.txt: indexable and canonical to themselves. */
 export function listedPages(model) {
     return model.pages.filter((p) => !p.meta.noindex && p.meta.canonical === absoluteUrl(model.site.site, p.route));
@@ -134,11 +173,14 @@ function addDiscoveryFiles(root, model, markdown) {
     const indexNow = site.integrations.indexNow;
     if (indexNow)
         generate(`${indexNow.key}.txt`, () => `${indexNow.key}\n`);
-    // Cloudflare Pages and Workers static assets both read _redirects and _headers.
+    // Cloudflare Pages, Workers static assets and Netlify all read _redirects and _headers.
+    const netlify = site.deploy.target === "netlify";
     const cloudflare = site.deploy.target === "cloudflare-pages" || site.deploy.target === "cloudflare-workers";
     if (cloudflare && model.redirects.length)
         generate("_redirects", () => cloudflareRedirects(model.redirects));
-    if (cloudflare && site.security.headers) {
+    if (netlify && model.redirects.length)
+        generate("_redirects", () => netlifyRedirects(model.redirects));
+    if ((cloudflare || netlify) && site.security.headers) {
         const html = [...model.pages, ...(model.notFound ? [model.notFound] : []), ...model.redirects].map((p) => p.html);
         // Each Markdown copy names its HTML page as canonical, so search engines don't index both.
         const copies = site.seo.markdownCopies && site.site ? listed.map((p) => ({ path: `/${markdownCopyPath(p.route)}`, canonical: p.meta.canonical })).filter((c) => /^\/[A-Za-z0-9._~\/-]+$/.test(c.path) && /^[^\s<>]+$/.test(c.canonical)) : [];

package/dist/deploy/netlify.d.ts

@@ -0,0 +1,22 @@
+import type { DeployStatus, Runner } from "./github-pages.js";
+/** Pinned so deploys are reproducible; checked 2026-10-25. */
+export declare const NETLIFY_CLI = "netlify-cli@27.12.1";
+export interface NetlifyDeployment extends DeployStatus {
+    site: string;
+    deployId?: string;
+}
+/**
+ * Uploads dist/ to a Netlify site's production deploy with netlify-cli (no Netlify build:
+ * vagejs already built it). Auth comes from NETLIFY_AUTH_TOKEN or a prior `netlify login`,
+ * never a command-line flag. The build wrote Netlify's _headers and _redirects (forced
+ * 301s, so they win over the HTML forwarding pages). Success needs netlify-cli to
+ * succeed AND the live site to answer 200: `siteUrl` when set, else the site's Netlify URL.
+ */
+export declare function deployNetlify(root: string, options: {
+    site: string;
+    siteUrl?: string;
+    run?: Runner;
+    fetch?: typeof fetch;
+    sleep?: (ms: number) => Promise<void>;
+    env?: Record<string, string | undefined>;
+}): Promise<NetlifyDeployment>;

package/dist/deploy/netlify.js

@@ -0,0 +1,48 @@
+import { redact } from "../integrations/http.js";
+import { runCommand } from "./github-pages.js";
+/** Pinned so deploys are reproducible; checked 2026-10-25. */
+export const NETLIFY_CLI = "netlify-cli@27.12.1";
+/**
+ * Uploads dist/ to a Netlify site's production deploy with netlify-cli (no Netlify build:
+ * vagejs already built it). Auth comes from NETLIFY_AUTH_TOKEN or a prior `netlify login`,
+ * never a command-line flag. The build wrote Netlify's _headers and _redirects (forced
+ * 301s, so they win over the HTML forwarding pages). Success needs netlify-cli to
+ * succeed AND the live site to answer 200: `siteUrl` when set, else the site's Netlify URL.
+ */
+export async function deployNetlify(root, options) {
+    const run = options.run ?? runCommand;
+    const doFetch = options.fetch ?? fetch;
+    const sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const secrets = [(options.env ?? process.env).NETLIFY_AUTH_TOKEN];
+    const { site } = options;
+    const res = await run("npx", ["--yes", NETLIFY_CLI, "deploy", "--dir", "dist", "--prod", "--no-build", "--site", site, "--json"], root);
+    const output = redact(`${res.stdout}\n${res.stderr}`, secrets);
+    if (res.code !== 0) {
+        const auth = /auth|log ?in|token|unauthori[sz]ed|401/i.test(output) ? " Set NETLIFY_AUTH_TOKEN, or run `npx netlify-cli login`." : "";
+        const missing = /not found|404|no (?:project|site)/i.test(output) ? ` Check that the Netlify site "${site}" exists (deploy.netlifySite is its name or ID).` : "";
+        return { status: "failure", site, reason: `netlify-cli failed (exit ${res.code}).${auth}${missing}\n${tail(output)}` };
+    }
+    let data = {};
+    try {
+        data = JSON.parse(res.stdout.slice(res.stdout.indexOf("{")));
+    }
+    catch {
+        // Older or newer netlify-cli output; the live check below still decides.
+    }
+    const deployId = typeof data.deploy_id === "string" ? data.deploy_id : undefined;
+    const netlifyUrl = typeof data.url === "string" && /^https:\/\//.test(data.url) ? data.url : undefined;
+    const pageUrl = options.siteUrl ?? netlifyUrl;
+    if (!pageUrl)
+        return { status: "unconfirmed", site, deployId, reason: `Uploaded, but there is no URL to check: set \`site\` in vage.config.ts.\n${tail(output)}` };
+    for (let i = 0; i < 5; i++) {
+        const page = await doFetch(pageUrl, { signal: AbortSignal.timeout(20_000) }).catch(() => undefined);
+        if (page?.ok)
+            return { status: "success", site, deployId, pageUrl };
+        await sleep(3000);
+    }
+    const own = netlifyUrl && netlifyUrl !== pageUrl ? ` The site itself is at ${netlifyUrl}. If ${pageUrl} is your own domain, add it in Netlify under Domain management.` : "";
+    return { status: "unconfirmed", site, deployId, pageUrl, reason: `Deployed, but ${pageUrl} did not respond with 200 yet. Check it in a minute.${own}` };
+}
+function tail(text) {
+    return text.trim().split("\n").slice(-8).join("\n");
+}

package/dist/deploy/redirects.d.ts

@@ -5,3 +5,8 @@ import type { SiteRedirect } from "../core/site.js";
  * Both "/old" and "/old/" are listed so either form redirects.
  */
 export declare function cloudflareRedirects(redirects: SiteRedirect[]): string;
+/**
+ * Netlify `_redirects`: the same rules, forced ("301!"). Netlify serves an existing file
+ * before a redirect, and vagejs writes an HTML forwarding page at each old address.
+ */
+export declare function netlifyRedirects(redirects: SiteRedirect[]): string;

package/dist/deploy/redirects.js

@@ -16,3 +16,11 @@ export function cloudflareRedirects(redirects) {
         throw new VageError(`_redirects would have ${lines.length} rules; Cloudflare Pages allows ${maxStaticRules}.`);
     return `# Generated by vagejs from redirects in vage.config.ts\n${lines.join("\n")}\n`;
 }
+/**
+ * Netlify `_redirects`: the same rules, forced ("301!"). Netlify serves an existing file
+ * before a redirect, and vagejs writes an HTML forwarding page at each old address.
+ */
+export function netlifyRedirects(redirects) {
+    const lines = redirects.flatMap((r) => (r.from === "/" ? ["/"] : [r.from, r.from.replace(/\/$/, "")]).map((from) => `${from} ${r.to} 301!`));
+    return `# Generated by vagejs from redirects in vage.config.ts\n${lines.join("\n")}\n`;
+}

package/dist/dev/server.js

@@ -7,8 +7,8 @@ import { escapeHtml } from "../core/html.js";
 import { baseViteConfig, viteLoader } from "../core/loader.js";
 import { renderPage } from "../core/render.js";
 import { cacheDir } from "../content/optimize.js";
-import { collectPages } from "../core/pages.js";
-import { renderSite } from "../core/site.js";
+import { collection, collectPages, tagList } from "../core/pages.js";
+import { renderSite, tagPageSource } from "../core/site.js";
 import { discoverRoutes, findNotFoundPage, normalizeRequestPath } from "../core/routes.js";
 import { devAccessGuard } from "./guard.js";
 import { listenOrExplain } from "./listen.js";
@@ -91,6 +91,17 @@ export async function startDevServer(root, options = {}) {
             if (entry && !pathname.endsWith("/") && !pathname.endsWith(".html")) {
                 return redirect(res, entry.route + urlPath.slice(pathname.length));
             }
+            if (!entry && site.tags.pages && route.startsWith("/tags/")) {
+                const pages = await collectPages(root, site, load, { skipInvalid: true });
+                const tag = tagList(pages).find((t) => t.route === route);
+                if (tag) {
+                    if (!pathname.endsWith("/"))
+                        return redirect(res, tag.route + urlPath.slice(pathname.length));
+                    const source = tagPageSource(site, tag.name, collection(pages, { tag: tag.name, sort: "date" }));
+                    const page = await renderPage({ root, file: path.join(pagesDir, "tags", `${tag.slug}.md`), route, site, load, pages, source });
+                    return send(res, 200, await server.transformIndexHtml(urlPath, page.html));
+                }
+            }
             const notFound = findNotFoundPage(pagesDir);
             if (!entry && !notFound) {
                 return send(res, 404, await server.transformIndexHtml(urlPath, plainPage("404 — Not found", `No page for ${route}`)));

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { escapeHtml, html, raw, type SafeHtml } from "./core/html.js";
 export { z } from "zod";
 export type { Layout, LayoutProps } from "./core/render.js";
 export type { Frontmatter } from "./content/markdown.js";
-export { breadcrumbs, collection, flatten, neighbors, tree, type CollectionOptions, type PageSummary, type TreeNode } from "./core/pages.js";
+export { breadcrumbs, collection, flatten, neighbors, tagList, tagSlug, tree, type CollectionOptions, type PageSummary, type TagSummary, type TreeNode } from "./core/pages.js";
 export { build, type BuildResult } from "./core/build.js";
 export { startDevServer } from "./dev/server.js";
 export { startPreviewServer } from "./dev/preview.js";

package/dist/index.js

@@ -2,7 +2,7 @@ export { defineConfig } from "./core/config.js";
 export { escapeHtml, html, raw } from "./core/html.js";
 /** Zod, for layout field schemas: `export const frontmatter = z.object({ ... })`. Same instance vagejs validates with. */
 export { z } from "zod";
-export { breadcrumbs, collection, flatten, neighbors, tree } from "./core/pages.js";
+export { breadcrumbs, collection, flatten, neighbors, tagList, tagSlug, tree } from "./core/pages.js";
 export { build } from "./core/build.js";
 export { startDevServer } from "./dev/server.js";
 export { startPreviewServer } from "./dev/preview.js";

package/dist/mcp/server.d.ts

@@ -1,4 +1,4 @@
-/** Published pages and drafts, without writing anything. */
+/** Published pages, drafts and scheduled pages, without writing anything. */
 export declare function listPages(root: string): Promise<{
     pages: {
         route: string;
@@ -9,6 +9,10 @@ export declare function listPages(root: string): Promise<{
         noindex: boolean;
     }[];
     drafts: string[];
+    scheduled: {
+        source: string;
+        date: string;
+    }[];
     errors: import("../core/site.js").PageError[];
 }>;
 /**

package/dist/mcp/server.js

@@ -24,7 +24,7 @@ async function loadSdk(root) {
     }
     throw new VageError(INSTALL);
 }
-/** Published pages and drafts, without writing anything. */
+/** Published pages, drafts and scheduled pages, without writing anything. */
 export async function listPages(root) {
     const loader = await createBuildLoader(root);
     try {
@@ -39,6 +39,7 @@ export async function listPages(root) {
                 noindex: Boolean(p.meta.noindex),
             })),
             drafts: model.skippedDrafts,
+            scheduled: model.skippedScheduled.map(({ source, date }) => ({ source, date })),
             errors: model.pageErrors,
         };
     }
@@ -74,7 +75,7 @@ export async function startMcpServer(root, options) {
     });
     server.registerTool("vage_info", { title: "Describe vagejs", description: "Commands, configuration options and page frontmatter fields, with their JSON Schemas (the same as `vage info --json`).", annotations: READ_ONLY }, tool(async () => options.info()));
     server.registerTool("vage_check", { title: "Check the site", description: "Checks every page for broken links, missing titles and descriptions, structured data, accessibility basics and unapproved outbound links (the same as `vage check --json`). Writes nothing.", annotations: READ_ONLY }, tool(() => check(root)));
-    server.registerTool("vage_pages", { title: "List pages", description: "Every published page (route, source file, title, description, layout, noindex), the drafts that are skipped, and pages that fail to render.", annotations: READ_ONLY }, tool(() => listPages(root)));
+    server.registerTool("vage_pages", { title: "List pages", description: "Every published page (route, source file, title, description, layout, noindex), the drafts and scheduled pages that are skipped, and pages that fail to render.", annotations: READ_ONLY }, tool(() => listPages(root)));
     server.registerTool("vage_links", { title: "List outbound domains", description: "External domains the site links to, which pages link there, and whether each is approved in links.lock.json. Only the site owner approves new domains.", annotations: READ_ONLY }, tool(() => linkStatus(root)));
     await server.connect(options.transport ?? new sdk.StdioServerTransport());
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vagejs",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A free static site generator for AI website development: Markdown pages with built-in SEO, llms.txt, checks, spam protection and safe deploys.",
   "keywords": [
     "static-site-generator",

package/templates/starter/AGENTS.md

@@ -16,6 +16,15 @@ This website uses **vagejs** (pre-release). Only the features listed here exist
 Add `--json` to `npx vage build`, `check` or `audit` for machine-readable output (`{ ok: false, error }` on failure).
 Run `npm run check` after every change and fix all errors before finishing.
 
+## Windows
+
+vagejs is tested on Windows on every change.
+
+- Node.js **22.12 or newer** is needed. Check with `node --version` in a new PowerShell or Command Prompt window.
+- The `npm` and `npx` commands in this file work in PowerShell and Command Prompt. In Command Prompt, leave out any `# …` notes after a command: it doesn't treat `#` as a comment.
+- Windows usually saves files with **CRLF** line endings. vagejs handles them; don't convert line endings.
+- If a browser shows **HTTP 431** on `localhost`, open the direct `[::1]` or `127.0.0.1` address that `npm start` and `npm run dev` print.
+
 ## Machine-readable reference
 
 `npx vage info --json` prints every command and option plus JSON Schemas for `vage.config.ts` and page frontmatter. Prefer it over guessing.
@@ -33,6 +42,9 @@ Run `npm run check` after every change and fix all errors before finishing.
 - **Order a menu or sidebar:** set `order:` (lower first) and optionally a short `navTitle:` in each page's frontmatter (shown as `p.label`), then build the menu in a layout with `tree(pages, "/docs/")`. For previous/next links in the same order use `neighbors(flatten(tree(pages, "/docs/")), page.route)`. For a flat section, `collection(pages, { under: "/docs/", sort: "order", includeIndex: true })` works too. `breadcrumbs(pages, page.route)` gives the trail from the home page.
 - **Add an RSS feed for the blog:** `seo: { feeds: [{ under: "/blog/" }] }` in `vage.config.ts` writes `/blog/feed.xml`, newest `datePublished` first (undated posts last, without a date).
 - **Help AI tools read the site:** `seo: { markdownCopies: true }` publishes a Markdown copy of every listed page (`/docs/cli/` becomes `/docs/cli.md`), converted from the page's `<main>`, so it contains exactly what the page shows (including content a layout builds from frontmatter), and `llms.txt` links to them. In layouts, add `data-vage-copy="skip"` to repeated extras such as share links or a call to action to leave them out of the copy. On Cloudflare, each copy gets a canonical `Link` header pointing to its page. `seo: { lastmod: "git" }` dates the sitemap from git history (needs full history in CI: `fetch-depth: 0`).
+- **Link to a section:** every `##` and `###` heading gets an id from its text (`## Quick start` becomes `id="quick-start"`), so link to `/docs/setup/#quick-start`. `npm run check` warns when a `#section` matches no id on the target page (`link-fragment`). Write `<h2 id="...">` in Markdown for an id of your own. Ids are only kept unique within the page content, so avoid headings that repeat an id the layout uses (such as `main`); `markdown: { headingIds: false }` turns automatic ids off.
+- **Schedule a post:** give it a future `datePublished` (and no `draft: true`). It stays out of builds, lists, feeds and the sitemap until a build on or after that day; `npm run build` lists it as `(scheduled for <date>, skipped)`. A date goes live on that day in the build machine's time zone (UTC on most CI); use a datetime such as `2026-11-01T09:00:00+05:30` for an exact time. Nothing rebuilds the site by itself: the owner needs a deploy on that day (for example a scheduled GitHub Actions workflow). `vage indexnow --changed-since` skips drafts and scheduled pages; once the page is live, submit it with `--urls`.
+- **Tag pages:** `tags: [SEO, AI]` in frontmatter. Each tag gets a page at `/tags/<tag>/` listing its pages, newest first (`tags: { layout: "<name>" }` picks its layout, `tags: { pages: false }` turns them off). In layouts, `collection(pages, { tag: "SEO" })` picks tagged pages and `tagList(pages)` lists every tag with its `route` and `count`. Tags are matched by their address, so "SEO" and "seo" are the same tag.
 - **Rename a page:** move the file, then add `redirects: { "/old-slug/": "/new-slug/" }` to `vage.config.ts`.
 - **Hide a page from search:** `noindex: true` (it stays published). To unpublish, use `draft: true` or delete it.
 - **AI crawler policy:** set `seo.robots.aiTraining` / `aiSearch` only on the owner's instruction.
@@ -66,10 +78,11 @@ canonical: /other/       # canonical override (path or absolute URL); page then
 image: /images/og.png    # og:image (made absolute using `site`)
 type: article            # og:type + Article JSON-LD (default: website)
 author: Jane Doe         # Article author
-datePublished: 2026-01-31
+datePublished: 2026-01-31  # a future date schedules the page: it's skipped until a build on or after that day
 dateModified: 2026-02-15 # also the sitemap <lastmod> (otherwise datePublished, or git with seo.lastmod: "git")
 order: 2                 # position in menus built with tree() or sort: "order" (lower first)
 navTitle: Pricing        # shorter label for menus and breadcrumbs (PageSummary.label)
+tags: [SEO, AI]          # each tag gets a page at /tags/<tag>/
 ---
 ```
 
@@ -90,7 +103,7 @@ Hacked sites are usually abused for hidden spam links and doorway pages. vagejs
 
 HTML inside Markdown is sanitized: scripts, event handlers, `javascript:` links, iframes and forms are removed. Embeds (e.g. video) belong in a layout, which is trusted code. The owner can trust all authors with `markdown: { html: "allow" }`; don't set that yourself. Values inside `{ }` in frontmatter that contain a comma or colon must be quoted; `vage check` warns about empty values (`frontmatter-empty`). Never put secrets in `public/` (it is published, and the build refuses secret-looking files and symlinks there). `npm run dev -- --host` exposes the dev server to your network; it serves only pages and `public/`, but use it only on trusted networks.
 
-With `deploy.target: "cloudflare-workers"` or `"cloudflare-pages"`, the build writes `_headers` with security headers and a Content-Security-Policy computed from the pages (inline scripts are allowed by hash). Don't use inline event handlers (`onclick=`); add sources the site really needs to `security.cspSources`.
+With `deploy.target: "cloudflare-workers"`, `"cloudflare-pages"` or `"netlify"`, the build writes `_headers` with security headers and a Content-Security-Policy computed from the pages (inline scripts are allowed by hash). Don't use inline event handlers (`onclick=`); add sources the site really needs to `security.cspSources`.
 
 ## Layouts
 
@@ -115,14 +128,14 @@ From the published pages and config (never from `public/`; a hand-written `publi
 - `sitemap.xml`: indexable, self-canonical, non-draft pages. Needs `site`.
 - `llms.txt` (+ `llms-full.txt` with `llmsTxt: { full: true }`): same pages. An emerging convention; not a guarantee that AI tools use it.
 - Redirects: `redirects: { "/old/": "/new/" }` become noindex meta-refresh pages (dev server answers 301).
-- With `seo.feeds`: `<section>/feed.xml` (RSS). With `seo.markdownCopies`: `/<path>.md` copies of listed pages. With `images.optimize`: resized images in `/_vage/img/`.
+- Tag pages at `/tags/<tag>/` for every tag in frontmatter (`tags.pages`). With `seo.feeds`: `<section>/feed.xml` (RSS). With `seo.markdownCopies`: `/<path>.md` copies of listed pages. With `images.optimize`: resized images in `/_vage/img/`.
 
 
 ## Config
 
 `vage.config.ts` keys: `site` (origin only, no path), `title`, `description`, `lang`,
-`seo: { robots, sitemap, llmsTxt, structuredData, feeds, markdownCopies, lastmod }`, `redirects`, `markdown`,
-`images: { optimize, widths, quality, sizes }`, `performance`, `deploy: { target, cloudflareWorker, cloudflareProject }`,
+`seo: { robots, sitemap, llmsTxt, structuredData, feeds, markdownCopies, lastmod }`, `redirects`, `markdown: { html, inlineStyles, headingIds }`, `tags: { pages, layout }`,
+`images: { optimize, widths, quality, sizes }`, `performance`, `deploy: { target, cloudflareWorker, cloudflareProject, netlifySite }`,
 `security: { headers, csp, cspSources, outboundLinks, spamPatterns }`, `integrations`, `guidelines`.
 Keys not in this list are an error; `npx vage info --json` has the full schema.
 
@@ -142,13 +155,14 @@ Always ask the site owner before publishing or deploying. Show them the plan fir
 - `npx vage deploy` with `deploy: { target: "cloudflare-workers", cloudflareWorker: "<name>" }`: Cloudflare's current way to host static sites. Uploads a new version and switches all traffic to it, so custom domains stay up. For custom domains or routes, the owner adds a `wrangler.jsonc` (vagejs then uses it). Config redirects become real 301s (`_redirects`).
 - `npx vage deploy --target cloudflare-pages --project <name>`: older Cloudflare Pages projects. Non-production branches get preview URLs. Cloudflare now turns new Pages projects into Workers; use `cloudflare-workers` for new sites.
 - Both Cloudflare targets report success only when Wrangler succeeds and the site responds. They need `CLOUDFLARE_API_TOKEN` + `CLOUDFLARE_ACCOUNT_ID` or `npx wrangler login`.
+- `npx vage deploy` with `deploy: { target: "netlify", netlifySite: "<site name or ID>" }`: uploads `dist/` to the Netlify site's production deploy (create the site in Netlify first). The build writes Netlify's `_headers` (security headers) and `_redirects` (config redirects as forced 301s). It reports success only when netlify-cli succeeds and the site responds. Needs `NETLIFY_AUTH_TOKEN` or `npx netlify-cli login`.
 - `npx vage deploy`: GitHub Pages (default target). Adds `.github/workflows/deploy.yml` (if missing), publishes, enables Pages via `gh` if needed, then waits for the Actions run. It says "deployed" only when GitHub reports success.
 
 After deploying, `npx vage indexnow --changed-since HEAD~1` (needs `integrations.indexNow.key`) tells IndexNow search engines about changed pages. It's a hint, not a guarantee of indexing; ask the owner first.
 
 GitHub Pages needs a custom domain or a `<user>.github.io` repository, because vagejs does not support base paths yet; `vage deploy` stops before pushing when the site would land in a subfolder.
 
-Other static hosts (Vercel, Netlify and the like) work without a vagejs deploy command: build command `npm run build`, output folder `dist`, no framework preset. Config redirects become small forwarding pages there, and the `_headers` security headers apply only on Cloudflare.
+Other static hosts (Vercel and the like) work without a vagejs deploy command: build command `npm run build`, output folder `dist`, no framework preset. Config redirects become small forwarding pages there, and the `_headers` security headers apply only on Cloudflare and Netlify.
 `.github/workflows/ci.yml` runs check, build and audit on every push and PR, and uploads `dist/` as a downloadable preview artifact.
 
 ## Analytics and search reports
@@ -168,7 +182,7 @@ Off unless configured in `vage.config.ts` under `integrations`. Ask the site own
 
 ## Not implemented yet
 
-Bing Webmaster Tools API, Netlify/Vercel adapters, CMS content sources, multi-language sites, base paths. Do not use or document them as available. A passing `check` does not guarantee indexing, rankings or AI citations.
+Bing Webmaster Tools API, a Vercel adapter, CMS content sources, multi-language sites, base paths. Do not use or document them as available. A passing `check` does not guarantee indexing, rankings or AI citations.
 
 ## Favicon
 

package/templates/starter/package.json

@@ -12,6 +12,6 @@
     "preview": "vage preview"
   },
   "devDependencies": {
-    "vagejs": "^0.4.0"
+    "vagejs": "^0.5.0"
   }
 }