@hagicode/hagilight 0.11.1-dev.129.1.ea757b8 → 0.11.1-dev.133.1.338317a

package/README.md

@@ -73,6 +73,51 @@ hagilight({
 
 Pass `llms: false` (or `{ enabled: false }`) to opt out. The file is only as good as the page titles and descriptions it reads, so write a real `description` for important pages.
 
+## Site metadata
+
+`hagilight()` writes `/.well-known/hagilight.metadata.json` after the build, next to `llms.txt`. A consumer that needs one machine-readable description of the site reads this file. The schema and its privacy rules are in `@hagicode/hagilight-core`'s README.
+
+```json
+{
+  "schemaVersion": 1,
+  "generator": { "name": "@hagicode/hagilight-starlight", "version": "0.1.0" },
+  "site": {
+    "name": "HagiCode Docs",
+    "url": "https://docs.hagicode.com/",
+    "base": "/",
+    "description": "Documentation for HagiCode."
+  },
+  "languages": {
+    "default": "en-US",
+    "locales": [
+      { "code": "en-US", "lang": "en-US", "path": "/" },
+      { "code": "zh-CN", "lang": "zh-CN", "path": "/zh-CN/" }
+    ]
+  },
+  "build": {
+    "branch": "main",
+    "commit": "a1b2c3d4e5f60718293a4b5c6d7e8f9012345678",
+    "builtAt": "2026-10-17T08:12:34Z"
+  },
+  "discovery": {
+    "sitemap": "/sitemap-index.xml",
+    "robots": "/robots.txt",
+    "rss": "/rss.xml",
+    "llms": "/llms.txt"
+  },
+  "analytics": { "googleAnalytics": true, "fiftyOneLa": false, "posthog": true },
+  "features": { "seo": true, "promoto": true }
+}
+```
+
+- The file is served under the site's base path, at `<site URL><base>.well-known/hagilight.metadata.json`. A site under `/docs/` gets `/docs/.well-known/hagilight.metadata.json`. An origin-level `/.well-known/` path needs a proxy or a second deployment; a hagilight build controls only its own output.
+- Name and description come from the `name` and `description` options, then the home page `og:site_name` or title and description. Locales come from Astro `i18n`. Analytics flags are `true` only when the built pages contain that provider's loader.
+- The file needs an absolute `site` URL. Without one, the build warns and skips the file; it does not fail.
+- Sitemap and `llms.txt` are checked after they are written, so `discovery` lists what this build actually produced.
+- Pass `metadata: false` to opt out, or `metadata: { name, description }` to set the values. The `enabled` option does not turn it off. A `public/.well-known/hagilight.metadata.json` file is copied as the site's own and kept byte for byte.
+- Hosts that drop dot-directories need an explicit opt-in. GitHub Pages' Jekyll step skips `.well-known` unless the published root contains an empty `.nojekyll` file.
+- When the Starlight plugin is also registered with metadata enabled, the Starlight plugin writes the file, and this integration defers to it. Registration order does not change the output.
+
 ## Body images
 
 `hagilight()` registers the content-image plugin from `@hagicode/hagilight-core/content-images`. Markdown and MDX body images then get `loading="lazy"`, `decoding="async"`, and the class `hagilight-content-image`, with the author's values kept. This registration does not depend on `enabled`, so `hagilight({ enabled: false })` still registers the plugin.

package/dist/integration.d.ts

@@ -27,6 +27,21 @@ export interface HagilightOptions {
      * overwritten. It also follows `enabled`: `hagilight({ enabled: false })` skips it.
      */
     llms?: boolean | HagilightLlmsOptions;
+    /**
+     * Generate `/.well-known/hagilight.metadata.json` after the build. Defaults to `true`; `false`
+     * opts out, and an options object may set `name` and `description`. A site-provided file is
+     * never overwritten. Independent of `enabled`. When the Starlight plugin is also registered
+     * and generates metadata, the Starlight plugin writes the file.
+     */
+    metadata?: boolean | HagilightMetadataOptions;
+}
+export interface HagilightMetadataOptions {
+    /** Defaults to `true`. */
+    enabled?: boolean;
+    /** Site name. Defaults to the home page `og:site_name` or title, then the site hostname. */
+    name?: string;
+    /** Site description. Defaults to the home page description. */
+    description?: string;
 }
 export interface HagilightLlmsOptions {
     /** Defaults to `true`. */
@@ -59,6 +74,6 @@ export type HagilightFaviconOptions = FaviconOptions;
  * owns sitemap generation, a consumer-owned robots page or public file takes
  * precedence, and an enabled Starlight Hagilight integration owns RSS feeds.
  */
-export declare function hagilight({ enabled, rss, contentImages, llms }?: HagilightOptions): AstroIntegration;
+export declare function hagilight({ enabled, rss, contentImages, llms, metadata }?: HagilightOptions): AstroIntegration;
 /** Inject the bundled HagiCode favicon unless the site head already declares an icon. */
 export declare function hagilightFavicon(options?: HagilightFaviconOptions): AstroIntegration;

package/dist/integration.js

@@ -7,7 +7,10 @@ import { checkContentImageRegistration, registerContentImages } from '@hagicode/
 import { resolveFaviconHeadEntry } from '@hagicode/hagilight-core/favicon';
 import { resolveRssLocales } from '@hagicode/hagilight-core/rss';
 import { resolvePlainAstroRssOwner } from '@hagicode/hagilight-core/rss-ownership';
+import { resolveSiteMetadataOption } from '@hagicode/hagilight-core/site-metadata';
+import { expectSiteMetadataReport, reportSiteMetadataBuilt, resolveSiteMetadataOwner, } from '@hagicode/hagilight-core/site-metadata-ownership';
 import { buildLlmsTxt, parsePageMeta } from './llms.js';
+import { writeAstroSiteMetadata } from './site-metadata.js';
 const VIRTUAL_RSS_CONFIG = 'virtual:hagilight/rss-config';
 const VIRTUAL_RSS_CONFIG_RESOLVED = `\0${VIRTUAL_RSS_CONFIG}`;
 const VIRTUAL_BUILD_INFO = 'virtual:hagilight/build-info';
@@ -52,7 +55,7 @@ const BUILTIN_RSS_FEED_SOURCE = BUILTIN_RSS_FEED.toString();
  * owns sitemap generation, a consumer-owned robots page or public file takes
  * precedence, and an enabled Starlight Hagilight integration owns RSS feeds.
  */
-export function hagilight({ enabled = true, rss, contentImages, llms } = {}) {
+export function hagilight({ enabled = true, rss, contentImages, llms, metadata } = {}) {
     if (typeof enabled !== 'boolean') {
         throw new TypeError('Hagilight sitemap and robots enabled option must be a boolean.');
     }
@@ -63,6 +66,7 @@ export function hagilight({ enabled = true, rss, contentImages, llms } = {}) {
         throw new TypeError('Hagilight content images enabled option must be a boolean.');
     }
     const llmsOptions = resolveLlmsOptions(llms);
+    const metadataOptions = resolveSiteMetadataOption(metadata);
     const contentImagesEnabled = typeof contentImages === 'boolean' ? contentImages : contentImages?.enabled !== false;
     if (rss !== undefined && typeof rss !== 'boolean' && !isRecord(rss)) {
         throw new TypeError('Hagilight RSS option must be a boolean or an options object.');
@@ -76,70 +80,116 @@ export function hagilight({ enabled = true, rss, contentImages, llms } = {}) {
         }
     }
     let resolvedConfig;
+    let resolvedBuildInfo;
+    // Set when the Starlight plugin owns the metadata file. This integration then reports
+    // after its `llms.txt` step, so the owner's write sees the final discovery outputs.
+    let metadataPeerToken;
     return {
         name: '@hagicode/hagilight:discovery',
         hooks: {
             'astro:config:setup'({ config, injectRoute, addMiddleware, updateConfig, logger }) {
-                registerContentImages({ config, logger, enabled: contentImagesEnabled });
-                const buildInfo = resolveBuildInfo({ root: fileURLToPath(config.root) });
-                updateConfig({ vite: { plugins: [createBuildInfoPlugin(buildInfo)] } });
-                addMiddleware({ entrypoint: fileURLToPath(new URL('./build-info-middleware.js', import.meta.url)), order: 'pre' });
-                if (!enabled)
-                    return;
-                resolveDiscoverySite(config.site);
-                const integrations = config.integrations ?? [];
-                if (!integrations.some((integration) => {
-                    const name = integrationName(integration);
-                    return name === '@astrojs/sitemap' || name === '@astrojs/starlight';
-                })) {
-                    updateConfig({ integrations: [sitemap()] });
-                }
-                const pageRoot = resolve(fileURLToPath(config.srcDir), 'pages');
-                const publicRoot = fileURLToPath(config.publicDir);
-                const hasRobotsPage = existsSync(pageRoot) && readdirSync(pageRoot).some((name) => /^robots\.txt\.(?:astro|html|js|jsx|md|mdx|ts|tsx)$/u.test(name)
-                    || name === 'robots.txt');
-                if (!hasRobotsPage && !existsSync(resolve(publicRoot, 'robots.txt'))) {
-                    injectRoute({
-                        pattern: '/robots.txt',
-                        entrypoint: routeEntrypoint('robots.txt.ts'),
-                        prerender: true,
+                // Integrations added by this hook go in one update, in order: the sitemap first, then the
+                // metadata finalizer, so the finalizer's build hook runs after the sitemap has written its index.
+                let sitemapNeeded = false;
+                try {
+                    registerContentImages({ config, logger, enabled: contentImagesEnabled });
+                    const buildInfo = resolveBuildInfo({ root: fileURLToPath(config.root) });
+                    resolvedBuildInfo = buildInfo;
+                    metadataPeerToken = resolveSiteMetadataOwner() === 'starlight' ? expectSiteMetadataReport() : undefined;
+                    updateConfig({ vite: { plugins: [createBuildInfoPlugin(buildInfo)] } });
+                    addMiddleware({ entrypoint: fileURLToPath(new URL('./build-info-middleware.js', import.meta.url)), order: 'pre' });
+                    if (!enabled)
+                        return;
+                    resolveDiscoverySite(config.site);
+                    const integrations = config.integrations ?? [];
+                    sitemapNeeded = !integrations.some((integration) => {
+                        const name = integrationName(integration);
+                        return name === '@astrojs/sitemap' || name === '@astrojs/starlight';
+                    });
+                    const pageRoot = resolve(fileURLToPath(config.srcDir), 'pages');
+                    const publicRoot = fileURLToPath(config.publicDir);
+                    const hasRobotsPage = existsSync(pageRoot) && readdirSync(pageRoot).some((name) => /^robots\.txt\.(?:astro|html|js|jsx|md|mdx|ts|tsx)$/u.test(name)
+                        || name === 'robots.txt');
+                    if (!hasRobotsPage && !existsSync(resolve(publicRoot, 'robots.txt'))) {
+                        injectRoute({
+                            pattern: '/robots.txt',
+                            entrypoint: routeEntrypoint('robots.txt.ts'),
+                            prerender: true,
+                        });
+                    }
+                    if (rss === false)
+                        return;
+                    if (resolvePlainAstroRssOwner(config.integrations) === 'starlight')
+                        return;
+                    const rssOptions = rss === true || rss === undefined ? {} : rss;
+                    const locales = resolveRssLocales(deriveRssLocales(rssOptions.locales, config), { requireNonEmpty: false });
+                    const modulePath = rssOptions.getFeed
+                        ? resolveFeedModule(config.root, rssOptions.getFeed)
+                        : null;
+                    const site = resolveSite(config.site);
+                    assertNoRouteCollisions(config, locales);
+                    const baseSegments = `${config.base || '/'}`.split('/').filter(Boolean);
+                    const baseUrl = baseSegments.length > 0 ? `/${baseSegments.join('/')}/` : '/';
+                    const baseLocation = new URL(baseUrl, site);
+                    const defaultFeedUrl = new URL('rss.xml', baseLocation).href;
+                    const localeFeedUrls = Object.fromEntries(locales
+                        .filter(({ filename }) => filename !== 'en')
+                        .map(({ lang, filename }) => [lang, new URL(`rss.${filename}.xml`, baseLocation).href]));
+                    injectRoute({ pattern: '/rss.xml', entrypoint: routeEntrypoint('rss.xml.ts'), prerender: true });
+                    injectRoute({ pattern: '/rss.[language].xml', entrypoint: routeEntrypoint('rss.[language].xml.ts'), prerender: true });
+                    addMiddleware({ entrypoint: fileURLToPath(new URL('./rss-middleware.js', import.meta.url)), order: 'pre' });
+                    updateConfig({
+                        vite: {
+                            plugins: [createVirtualPlugin({ modulePath, site, baseUrl, locales, defaultFeedUrl, localeFeedUrls })],
+                        },
                     });
                 }
-                if (rss === false)
-                    return;
-                if (resolvePlainAstroRssOwner(config.integrations) === 'starlight')
-                    return;
-                const rssOptions = rss === true || rss === undefined ? {} : rss;
-                const locales = resolveRssLocales(deriveRssLocales(rssOptions.locales, config), { requireNonEmpty: false });
-                const modulePath = rssOptions.getFeed
-                    ? resolveFeedModule(config.root, rssOptions.getFeed)
-                    : null;
-                const site = resolveSite(config.site);
-                assertNoRouteCollisions(config, locales);
-                const baseSegments = `${config.base || '/'}`.split('/').filter(Boolean);
-                const baseUrl = baseSegments.length > 0 ? `/${baseSegments.join('/')}/` : '/';
-                const baseLocation = new URL(baseUrl, site);
-                const defaultFeedUrl = new URL('rss.xml', baseLocation).href;
-                const localeFeedUrls = Object.fromEntries(locales
-                    .filter(({ filename }) => filename !== 'en')
-                    .map(({ lang, filename }) => [lang, new URL(`rss.${filename}.xml`, baseLocation).href]));
-                injectRoute({ pattern: '/rss.xml', entrypoint: routeEntrypoint('rss.xml.ts'), prerender: true });
-                injectRoute({ pattern: '/rss.[language].xml', entrypoint: routeEntrypoint('rss.[language].xml.ts'), prerender: true });
-                addMiddleware({ entrypoint: fileURLToPath(new URL('./rss-middleware.js', import.meta.url)), order: 'pre' });
-                updateConfig({
-                    vite: {
-                        plugins: [createVirtualPlugin({ modulePath, site, baseUrl, locales, defaultFeedUrl, localeFeedUrls })],
-                    },
-                });
+                finally {
+                    // The finalizer is skipped when a Starlight owner writes the file.
+                    const appended = [
+                        ...(sitemapNeeded ? [sitemap()] : []),
+                        ...(metadataPeerToken === undefined && metadataOptions.enabled
+                            ? [createMetadataFinalizer(() => ({ config: resolvedConfig, build: resolvedBuildInfo, options: metadataOptions }))]
+                            : []),
+                    ];
+                    if (appended.length > 0)
+                        updateConfig({ integrations: appended });
+                }
             },
             'astro:config:done'({ config, logger }) {
                 resolvedConfig = config;
                 checkContentImageRegistration({ config, logger, enabled: contentImagesEnabled });
             },
             'astro:build:done'({ dir, pages, logger }) {
-                if (!enabled || !llmsOptions.enabled || !resolvedConfig)
+                try {
+                    if (enabled && llmsOptions.enabled && resolvedConfig) {
+                        writeLlmsTxt({ config: resolvedConfig, dir, pages, options: llmsOptions, logger });
+                    }
+                }
+                finally {
+                    if (metadataPeerToken !== undefined) {
+                        reportSiteMetadataBuilt(metadataPeerToken);
+                        metadataPeerToken = undefined;
+                    }
+                }
+            },
+        },
+    };
+}
+/**
+ * Integration appended after the sitemap, so its `astro:build:done` runs after
+ * `@astrojs/sitemap` has written `sitemap-index.xml`. Hook order follows the
+ * integration list, which is why the metadata write does not run in this integration's own hook.
+ */
+function createMetadataFinalizer(source) {
+    return {
+        name: '@hagicode/hagilight:metadata',
+        hooks: {
+            'astro:build:done'({ dir, pages, logger }) {
+                const { config, build, options } = source();
+                if (!config || !build || !options.enabled)
                     return;
-                writeLlmsTxt({ config: resolvedConfig, dir, pages, options: llmsOptions, logger });
+                writeAstroSiteMetadata({ config, outDir: fileURLToPath(dir), pages, build, options, logger });
             },
         },
     };

package/dist/llms.d.ts

@@ -38,6 +38,11 @@ export declare const DEFAULT_MAX_LINKS = 120;
  * not be listed: `noindex`, instant redirects, 404 pages, and pages whose canonical URL points
  * somewhere else.
  */
+/**
+ * Read the page head without applying indexing rules. Site-level facts such as the
+ * site name and description stay available on pages that are `noindex`.
+ */
+export declare function parseHeadMeta(html: string): LlmsPageMeta;
 export declare function parsePageMeta(html: string, pageUrl: string): LlmsPageMeta | undefined;
 /** Build the `llms.txt` body. Returns `undefined` when there is nothing to list. */
 export declare function buildLlmsTxt(options: BuildLlmsTxtOptions): string | undefined;

package/dist/llms.js

@@ -46,12 +46,30 @@ function normalizeUrl(href, base) {
  * not be listed: `noindex`, instant redirects, 404 pages, and pages whose canonical URL points
  * somewhere else.
  */
-export function parsePageMeta(html, pageUrl) {
+/**
+ * Read the page head without applying indexing rules. Site-level facts such as the
+ * site name and description stay available on pages that are `noindex`.
+ */
+export function parseHeadMeta(html) {
     const headEnd = html.indexOf('</head>');
     const head = headEnd === -1 ? html : html.slice(0, headEnd);
     const metas = [...head.matchAll(/<meta\b[^>]*>/giu)].map(([tag]) => attributes(tag));
     const named = (name) => metas.find((meta) => meta.name?.toLowerCase() === name)?.content;
     const property = (name) => metas.find((meta) => meta.property?.toLowerCase() === name)?.content;
+    const title = clean(decodeEntities(head.match(/<title[^>]*>([\s\S]*?)<\/title>/iu)?.[1] ?? '')) ?? '';
+    const htmlTag = html.match(/<html\b[^>]*>/iu)?.[0];
+    return {
+        lang: clean(htmlTag ? attributes(htmlTag).lang : undefined),
+        title,
+        description: clean(named('description') ?? property('og:description')),
+        siteName: clean(property('og:site_name')),
+    };
+}
+export function parsePageMeta(html, pageUrl) {
+    const headEnd = html.indexOf('</head>');
+    const head = headEnd === -1 ? html : html.slice(0, headEnd);
+    const metas = [...head.matchAll(/<meta\b[^>]*>/giu)].map(([tag]) => attributes(tag));
+    const named = (name) => metas.find((meta) => meta.name?.toLowerCase() === name)?.content;
     if (/noindex/iu.test(named('robots') ?? ''))
         return undefined;
     if (metas.some((meta) => meta['http-equiv']?.toLowerCase() === 'refresh'))
@@ -66,17 +84,10 @@ export function parsePageMeta(html, pageUrl) {
         if (canonical && own && canonical.replace(/\/$/u, '') !== own.replace(/\/$/u, ''))
             return undefined;
     }
-    const title = clean(decodeEntities(head.match(/<title[^>]*>([\s\S]*?)<\/title>/iu)?.[1] ?? ''));
-    if (!title || /^(?:404\b|page not found)/iu.test(title))
+    const meta = parseHeadMeta(html);
+    if (!meta.title || /^(?:404\b|page not found)/iu.test(meta.title))
         return undefined;
-    const htmlTag = html.match(/<html\b[^>]*>/iu)?.[0];
-    const lang = clean(htmlTag ? attributes(htmlTag).lang : undefined);
-    return {
-        lang,
-        title,
-        description: clean(named('description') ?? property('og:description')),
-        siteName: clean(property('og:site_name')),
-    };
+    return meta;
 }
 function sameLanguage(a, b) {
     if (!a || !b)

package/dist/site-metadata.d.ts

@@ -0,0 +1,31 @@
+import type { BuildInfo } from '@hagicode/hagilight-core/build-info';
+import { type SiteMetadataLocale } from '@hagicode/hagilight-core/site-metadata';
+import { type SiteMetadataLogger } from '@hagicode/hagilight-core/site-metadata-writer';
+export interface WriteAstroSiteMetadataInput {
+    config: {
+        site?: unknown;
+        base?: string;
+        publicDir: URL;
+        i18n?: unknown;
+    };
+    outDir: string;
+    pages: readonly {
+        pathname: string;
+    }[];
+    build: BuildInfo;
+    options: {
+        name?: string;
+        description?: string;
+    };
+    logger: SiteMetadataLogger;
+}
+/** Map Astro `i18n` to locales relative to the base. Mirrors the RSS locale derivation. */
+export declare function deriveAstroMetadataLocales(i18n: unknown): {
+    locales: SiteMetadataLocale[];
+    defaultLocale?: string;
+};
+/**
+ * Build and write the metadata file for a plain-Astro build. Skips with a warning
+ * when no absolute site URL is configured, because the file has to name the site.
+ */
+export declare function writeAstroSiteMetadata({ config, outDir, pages, build, options, logger }: WriteAstroSiteMetadataInput): void;

package/dist/site-metadata.js

@@ -0,0 +1,107 @@
+/**
+ * Facts for `.well-known/hagilight.metadata.json` from a plain-Astro build. Site
+ * name and description come from the built home page, locales from Astro `i18n`,
+ * and analytics flags from the loaders present in the built pages.
+ */
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { buildSiteMetadata, detectAnalyticsLoaders, SITE_METADATA_PATH, } from '@hagicode/hagilight-core/site-metadata';
+import { findDiscoveryOutputs, writeSiteMetadata } from '@hagicode/hagilight-core/site-metadata-writer';
+import { parseHeadMeta } from './llms.js';
+const ASTRO_PACKAGE_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function absoluteSite(site) {
+    try {
+        const parsed = new URL(site);
+        return ['http:', 'https:'].includes(parsed.protocol) && !parsed.username && !parsed.password ? parsed.href : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Read the built HTML of each page that the build emitted, using the same lookup as `llms.txt`. */
+function builtPageHtml(outDir, pages) {
+    const html = [];
+    for (const { pathname } of pages) {
+        const relative = pathname.replace(/^\/+/u, '');
+        const candidates = relative === '' || relative.endsWith('/')
+            ? [join(outDir, relative, 'index.html')]
+            : [join(outDir, relative, 'index.html'), join(outDir, `${relative}.html`)];
+        const file = candidates.find((candidate) => existsSync(candidate) && statSync(candidate).isFile());
+        if (file)
+            html.push(readFileSync(file, 'utf8'));
+    }
+    return html;
+}
+function localeEntryKey(entry) {
+    if (typeof entry === 'string')
+        return entry.trim() || undefined;
+    if (isRecord(entry) && typeof entry.path === 'string' && entry.path.trim())
+        return entry.path.trim();
+    return undefined;
+}
+/** Map Astro `i18n` to locales relative to the base. Mirrors the RSS locale derivation. */
+export function deriveAstroMetadataLocales(i18n) {
+    if (!isRecord(i18n) || !Array.isArray(i18n.locales) || i18n.locales.length === 0)
+        return { locales: [] };
+    const defaultLocale = typeof i18n.defaultLocale === 'string'
+        ? i18n.defaultLocale
+        : localeEntryKey(i18n.locales[0]);
+    const prefixDefaultLocale = isRecord(i18n.routing) && i18n.routing.prefixDefaultLocale === true;
+    const locales = [];
+    for (const entry of i18n.locales) {
+        const code = localeEntryKey(entry);
+        if (!code)
+            continue;
+        const codes = isRecord(entry) && Array.isArray(entry.codes) ? entry.codes : [];
+        const lang = typeof codes[0] === 'string' && codes[0].trim() ? codes[0].trim() : code;
+        const isDefault = code === defaultLocale;
+        locales.push({ code, lang, path: isDefault && !prefixDefaultLocale ? '/' : `/${code}/` });
+    }
+    return { locales, ...(defaultLocale === undefined ? {} : { defaultLocale }) };
+}
+/**
+ * Build and write the metadata file for a plain-Astro build. Skips with a warning
+ * when no absolute site URL is configured, because the file has to name the site.
+ */
+export function writeAstroSiteMetadata({ config, outDir, pages, build, options, logger }) {
+    const siteUrl = absoluteSite(config.site);
+    if (!siteUrl) {
+        logger.warn(`${SITE_METADATA_PATH} requires an absolute Astro site URL, so it was not generated.`);
+        return;
+    }
+    const base = `${config.base || '/'}`.replace(/\/?$/u, '/');
+    const siteBase = new URL(base, siteUrl);
+    const homeFile = join(outDir, 'index.html');
+    const homeHtml = existsSync(homeFile) ? readFileSync(homeFile, 'utf8') : undefined;
+    // Site-level facts are read even when the home page is noindex, such as a root redirect page.
+    const homeMeta = homeHtml === undefined ? undefined : parseHeadMeta(homeHtml);
+    const pageHtml = builtPageHtml(outDir, pages);
+    if (homeHtml !== undefined && !pageHtml.includes(homeHtml))
+        pageHtml.push(homeHtml);
+    const locales = deriveAstroMetadataLocales(config.i18n);
+    const metadata = buildSiteMetadata({
+        generator: { name: '@hagicode/hagilight', version: ASTRO_PACKAGE_VERSION },
+        site: {
+            name: options.name ?? homeMeta?.siteName ?? homeMeta?.title,
+            url: siteUrl,
+            base,
+            description: options.description ?? homeMeta?.description,
+        },
+        locales: locales.locales,
+        defaultLocale: locales.defaultLocale,
+        fallbackLang: homeMeta?.lang,
+        build,
+        discovery: findDiscoveryOutputs(outDir),
+        analytics: detectAnalyticsLoaders(pageHtml),
+    });
+    writeSiteMetadata({
+        outDir,
+        metadata,
+        siteOwnedFiles: [join(fileURLToPath(config.publicDir), SITE_METADATA_PATH)],
+        logger,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hagicode/hagilight",
-  "version": "0.11.1-dev.129.1.ea757b8",
+  "version": "0.11.1-dev.133.1.338317a",
   "type": "module",
   "description": "Astro integrations and components for HagiCode sites",
   "repository": {
@@ -40,7 +40,7 @@
   },
   "dependencies": {
     "@astrojs/sitemap": "^3.7.4",
-    "@hagicode/hagilight-core": "0.11.1-dev.129.1.ea757b8"
+    "@hagicode/hagilight-core": "0.11.1-dev.133.1.338317a"
   },
   "keywords": [
     "hagicode",