npm - @moku-labs/web - Versions diffs - 1.4.0 → 1.5.0 - Mend

@moku-labs/web 1.4.0 → 1.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/browser.d.mts CHANGED Viewed

@@ -557,6 +557,32 @@ type Api$3 = {
    */
   t(locale: string, key: string): string;
 };
+//#endregion
+//#region src/plugins/router/iso-match.d.ts
+/**
+ * A compiled, engine-agnostic path matcher: the same `.exec({ pathname })` shape the
+ * router consumed from `URLPattern`, but backed by a native `RegExp` with named
+ * groups. Dropping `URLPattern` keeps route matching alive in every browser engine —
+ * Safari < 18.4 and Firefox < ~142 have no `URLPattern` global and would otherwise
+ * throw `ReferenceError` the instant the router compiles its table on boot.
+ */
+interface PathMatcher {
+  /**
+   * Match a pathname, mirroring `URLPattern.exec`: the named-group bag (under
+   * `pathname.groups`) on a hit, or `null` on a miss.
+   *
+   * @param input - The match input carrying the `pathname` to test.
+   * @param input.pathname - The URL pathname to match, e.g. `/en/hello/`.
+   * @returns A `{ pathname: { groups } }` result on a match, or `null` on no match.
+   */
+  exec(input: {
+    readonly pathname: string;
+  }): {
+    readonly pathname: {
+      readonly groups: Record<string, string | undefined>;
+    };
+  } | null;
+}
 declare namespace types_d_exports$5 {
   export { Api$2 as Api, ClientRoute, CompileInput, CompiledRoute, Config$2 as Config, ExtractApi$1 as ExtractApi, ExtractRouteParams, ExtractSegmentParameter, GenerateContext, HeadConfig$1 as HeadConfig, LayoutContext, LoadContext, MatcherTable, Prettify, RouteBuilder, RouteContext, RouteDefinition, RouteHandlers, RouteMap, RouteRequire, RouteState, RouterApi, RouterConfig, RouterState, State$2 as State, TypedRoute, Urls };
 }
@@ -836,10 +862,10 @@ interface CompiledRoute {
   readonly pattern: string;
   /** Dynamic-segment count (lower = more specific = matched first). */
   readonly dynamicSegmentCount: number;
-  /** Pre-built URLPattern matchers (lang-aware + bare fallback). */
+  /** Pre-built path matchers (lang-aware + bare fallback). */
   readonly matchers: {
-    readonly withLang: URLPattern;
-    readonly bare: URLPattern;
+    readonly withLang: PathMatcher;
+    readonly bare: PathMatcher;
   };
   /** Resolve pathname into params (withLang first, then bare with defaultLocale injected). */
   readonly matchFn: (pathname: string) => Record<string, string> | null;
@@ -1112,6 +1138,25 @@ type Api$1 = {
    * ```
    */
   render(route: ResolvedRoute, data: unknown): string;
+  /**
+   * Compose the SITE-LEVEL `<head>` Open Graph / Twitter block for a bare-path redirect or
+   * landing page that has no route identity (e.g. the apex-domain `/` redirect a
+   * `localeRedirects` build emits). Returns `""` UNLESS `defaultOgImage` is configured, so
+   * apps that opt out keep a bare redirect. Pulled synchronously by `build`.
+   *
+   * @param input - The landing URL (resolved to an absolute canonical) plus an optional locale.
+   * @param input.url - The page's URL or path (absolutized via `site.canonical`) → `og:url`.
+   * @param input.locale - Optional locale whose `og:locale` is emitted (e.g. the default locale).
+   * @returns The serialized inner HTML of the site-level head block, or `""` when disabled.
+   * @example
+   * ```ts
+   * api.siteHead({ url: "/en/", locale: "en" });
+   * ```
+   */
+  siteHead(input: {
+    url: string;
+    locale?: string;
+  }): string;
 };
 declare namespace types_d_exports$6 {
   export { COMPONENT_HOOK_NAMES, ComponentContext, ComponentDef, ComponentHooks, ComponentInstance, ExtractApi, PageData, ResolvedSpaConfig, SpaApi, SpaConfig, SpaContext, SpaDataReader, SpaEmitFunction, SpaEvents, SpaKernel, SpaKernelDeps, SpaRequire, SpaState };

package/dist/browser.mjs CHANGED Viewed

@@ -1331,22 +1331,101 @@ function extractGroups(groups) {
 	}
 	return params;
 }
-//#endregion
-//#region src/plugins/router/builders/match.ts
+/** Regex metacharacters escaped when a static path segment is inlined into a compiled pattern. */
+const REGEX_METACHARS = /[.*+?^${}()|[\]\\]/g;
+/** Matches a `:name` or `:name(regex)` URLPattern group occupying one whole segment. */
+const NAMED_GROUP = /^:([A-Za-z_]\w*)(?:\((.+)\))?$/;
+/**
+* Escape a static path segment so its literal text matches verbatim inside the
+* compiled `RegExp` (a segment like `c++` must not be read as regex syntax).
+*
+* @param text - The static segment text.
+* @returns The regex-escaped segment.
+* @example
+* ```ts
+* escapeStaticSegment("about"); // "about"
+* ```
+*/
+function escapeStaticSegment(text) {
+	return text.replaceAll(REGEX_METACHARS, String.raw`\$&`);
+}
 /**
-* @file router plugin — runtime matching domain.
+* Compile one URLPattern source segment (no surrounding slash) into a regex fragment
+* that captures a single path segment: `:name` → a named `[^/]+` group, `:name(re)` →
+* a named group constrained by `re`, and static text → its escaped literal.
 *
-* Pure functions that turn compiled patterns into a pathname matcher: build the
-* lang-aware/bare `URLPattern` pair, the `matchFn` (withLang first, bare fallback
-* injecting `defaultLocale`), and extract/strip params. No `ctx` here.
+* @param segment - One source segment, e.g. `:slug`, `:lang(en|uk)`, or `archive`.
+* @returns The regex fragment for that segment.
+* @example
+* ```ts
+* segmentToRegex(":lang(en|uk)"); // "(?<lang>en|uk)"
+* ```
 */
+function segmentToRegex(segment) {
+	const named = NAMED_GROUP.exec(segment);
+	if (named) {
+		const [, name, constraint] = named;
+		return `(?<${name}>${constraint ?? "[^/]+"})`;
+	}
+	return escapeStaticSegment(segment);
+}
 /**
-* Build a pathname matcher for a single route: tries the `withLang` URLPattern,
-* then the `bare` pattern injecting `defaultLocale` on miss.
+* Compile a URLPattern pathname source string into a {@link PathMatcher} backed by a
+* native `RegExp` — a drop-in replacement for `new URLPattern({ pathname })` over the
+* subset the router emits: `:name`, `:name(regex)`, the optional `:name?` segment
+* (whose leading `/` is absorbed, so `/:lang?` matches `/en` or nothing), static
+* segments, and a required trailing slash. Anchored full-match, like `URLPattern`.
 *
-* @param matchers - The pre-built `withLang` and `bare` URLPattern pair.
-* @param matchers.withLang - The locale-aware URLPattern variant.
-* @param matchers.bare - The bare URLPattern variant (no leading locale segment).
+* @param source - The URLPattern pathname source, e.g. `/:lang?/:slug/`.
+* @returns A matcher whose `.exec({ pathname })` yields named groups or `null`.
+* @example
+* ```ts
+* const m = createPathMatcher("/:lang?/:slug/");
+* m.exec({ pathname: "/en/hello/" }); // { pathname: { groups: { lang: "en", slug: "hello" } } }
+* ```
+*/
+function createPathMatcher(source) {
+	const segments = source.split("/");
+	let pattern = "^";
+	for (let index = 1; index < segments.length; index += 1) {
+		const segment = segments[index] ?? "";
+		if (segment === "") {
+			pattern += "/";
+			continue;
+		}
+		const optional = segment.endsWith("?");
+		const fragment = segmentToRegex(optional ? segment.slice(0, -1) : segment);
+		pattern += optional ? `(?:/${fragment})?` : `/${fragment}`;
+	}
+	pattern += "$";
+	const regexp = new RegExp(pattern);
+	return {
+	/**
+	* Run the compiled regex over a pathname (the {@link PathMatcher.exec} contract).
+	*
+	* @param input - The match input carrying the `pathname` to test.
+	* @param input.pathname - The URL pathname to match, e.g. `/en/hello/`.
+	* @returns A `{ pathname: { groups } }` result on a match, or `null` on no match.
+	* @example
+	* ```ts
+	* matcher.exec({ pathname: "/en/hello/" });
+	* ```
+	*/
+exec(input) {
+		const result = regexp.exec(input.pathname);
+		if (!result) return null;
+		return { pathname: { groups: result.groups ?? {} } };
+	} };
+}
+//#endregion
+//#region src/plugins/router/builders/match.ts
+/**
+* Build a pathname matcher for a single route: tries the `withLang` matcher,
+* then the `bare` matcher injecting `defaultLocale` on miss.
+*
+* @param matchers - The pre-built `withLang` and `bare` matcher pair.
+* @param matchers.withLang - The locale-aware matcher variant.
+* @param matchers.bare - The bare matcher variant (no leading locale segment).
 * @param defaultLocale - Locale injected when the bare fallback matches.
 * @returns A function resolving a pathname into params, or `null` on no match.
 * @example
@@ -1390,14 +1469,6 @@ function matchRoute(compiled, pathname) {
 }
 //#endregion
 //#region src/plugins/router/builders/compile.ts
-/**
-* @file router plugin — compilation + validation domain.
-*
-* Pure functions invoked from `onInit`: validate the route map, then compile each
-* route into URLPattern matchers + URL/file builders, count dynamic segments,
-* sort by specificity, and assemble the immutable `MatcherTable`. Receives DATA
-* only (`CompileInput`) — never the plugin ctx.
-*/
 /** Shared `[web]` error prefix for router validation failures. */
 const ERROR_PREFIX$6 = "[web] router";
 /** Maximum number of optional `{lang:?}` segments a single pattern may declare. */
@@ -1569,8 +1640,8 @@ function buildFilePath(pattern, params) {
 function buildMatchers(pattern, locales) {
 	const langRegex = `(${locales.join("|")})`;
 	return {
-		withLang: new URLPattern({ pathname: patternToUrlPattern(pattern, "withLang", langRegex) }),
-		bare: new URLPattern({ pathname: patternToUrlPattern(pattern, "bare", langRegex) })
+		withLang: createPathMatcher(patternToUrlPattern(pattern, "withLang", langRegex)),
+		bare: createPathMatcher(patternToUrlPattern(pattern, "bare", langRegex))
 	};
 }
 /**
@@ -2443,6 +2514,42 @@ function composeHead(input) {
 	}), ...head.elements ?? []]);
 }
 /**
+* Compose the SITE-LEVEL Open Graph / Twitter block for a bare-path redirect or landing
+* page that has no per-route head of its own. Returns `[]` UNLESS a `defaultOgImage` is
+* configured — so apps that opt out keep a bare redirect (no behavior change). The site
+* name + description become the card's title/description (`og:type=website`); `url` is the
+* canonical the page points at. A bare article/tag alias gets this site card as a fallback;
+* crawlers that honor the page's `rel=canonical` still resolve the per-route card.
+*
+* @param input - The site slice, head defaults, landing URL, and optional `og:locale`.
+* @returns The ordered site-level head element set, or `[]` when no default image is set.
+* @example composeSiteHead({ site, defaults, url: "https://blog.dev/en/", ogLocale: "en_US" })
+*/
+function composeSiteHead(input) {
+	const { site, defaults, url, ogLocale } = input;
+	const image = defaults.defaultOgImage;
+	if (image === void 0) return [];
+	const absoluteImage = resolveImage(image, site);
+	const name = site.name();
+	const description = site.description();
+	const elements = [
+		meta("description", description),
+		og("og:type", "website"),
+		og("og:site_name", name),
+		og("og:title", name),
+		og("og:description", description),
+		og("og:url", url),
+		og("og:image", absoluteImage),
+		twitter("twitter:card", defaults.twitterCard),
+		twitter("twitter:title", name),
+		twitter("twitter:description", description),
+		twitter("twitter:image", absoluteImage)
+	];
+	if (defaults.twitterHandle) elements.push(twitter("twitter:site", defaults.twitterHandle));
+	if (ogLocale) elements.push(og("og:locale", ogLocale));
+	return elements;
+}
+/**
 * HTML-escape a value for safe insertion into an attribute or text node. `&` is
 * escaped first so already-escaped entities are not double-escaped.
 *
@@ -2531,28 +2638,53 @@ function readDefaults(state) {
 * ```
 */
 function createApi$1(ctx) {
-	return {
-	/**
-	* Compose the final `<head>` inner HTML for a route (pulled by `build`).
-	*
-	* @param route - The resolved route descriptor (incl. its `.head()` HeadConfig).
-	* @param data - The page data object passed to the route's loader/render.
-	* @returns The serialized inner HTML of `<head>`.
-	* @example
-	* ```ts
-	* api.render(route, { title: "Post" });
-	* ```
-	*/
-render(route, data) {
-		return serializeHead(composeHead({
-			route,
-			data,
-			defaults: readDefaults(ctx.state),
-			site: ctx.require(sitePlugin),
-			i18n: ctx.require(i18nPlugin),
-			router: ctx.require(routerPlugin)
-		}));
-	} };
+	return {
+		/**
+		* Compose the final `<head>` inner HTML for a route (pulled by `build`).
+		*
+		* @param route - The resolved route descriptor (incl. its `.head()` HeadConfig).
+		* @param data - The page data object passed to the route's loader/render.
+		* @returns The serialized inner HTML of `<head>`.
+		* @example
+		* ```ts
+		* api.render(route, { title: "Post" });
+		* ```
+		*/
+		render(route, data) {
+			return serializeHead(composeHead({
+				route,
+				data,
+				defaults: readDefaults(ctx.state),
+				site: ctx.require(sitePlugin),
+				i18n: ctx.require(i18nPlugin),
+				router: ctx.require(routerPlugin)
+			}));
+		},
+		/**
+		* Compose the site-level OG/Twitter block for a bare-path redirect/landing page. Resolves
+		* `site`/`i18n` via `ctx.require`, absolutizes `url` against the site base, and emits an
+		* `og:locale` for `locale` when supplied. Returns `""` when no `defaultOgImage` is configured.
+		*
+		* @param input - The landing URL/path plus an optional locale (for `og:locale`).
+		* @param input.url - The page's URL or path (absolutized via `site.canonical`) → `og:url`.
+		* @param input.locale - Optional locale whose `og:locale` is emitted.
+		* @returns The serialized inner HTML of the site-level head block, or `""` when disabled.
+		* @example
+		* ```ts
+		* api.siteHead({ url: "/en/", locale: "en" });
+		* ```
+		*/
+		siteHead(input) {
+			const site = ctx.require(sitePlugin);
+			const ogLocale = input.locale === void 0 ? void 0 : ctx.require(i18nPlugin).ogLocale(input.locale);
+			return serializeHead(composeSiteHead({
+				site,
+				defaults: readDefaults(ctx.state),
+				url: site.canonical(input.url),
+				...ogLocale === void 0 ? {} : { ogLocale }
+			}));
+		}
+	};
 }
 //#endregion
 //#region src/plugins/head/config.ts

package/dist/index.cjs CHANGED Viewed

@@ -1889,22 +1889,101 @@ function extractGroups(groups) {
 	}
 	return params;
 }
-//#endregion
-//#region src/plugins/router/builders/match.ts
+/** Regex metacharacters escaped when a static path segment is inlined into a compiled pattern. */
+const REGEX_METACHARS = /[.*+?^${}()|[\]\\]/g;
+/** Matches a `:name` or `:name(regex)` URLPattern group occupying one whole segment. */
+const NAMED_GROUP = /^:([A-Za-z_]\w*)(?:\((.+)\))?$/;
 /**
-* @file router plugin — runtime matching domain.
+* Escape a static path segment so its literal text matches verbatim inside the
+* compiled `RegExp` (a segment like `c++` must not be read as regex syntax).
 *
-* Pure functions that turn compiled patterns into a pathname matcher: build the
-* lang-aware/bare `URLPattern` pair, the `matchFn` (withLang first, bare fallback
-* injecting `defaultLocale`), and extract/strip params. No `ctx` here.
+* @param text - The static segment text.
+* @returns The regex-escaped segment.
+* @example
+* ```ts
+* escapeStaticSegment("about"); // "about"
+* ```
 */
+function escapeStaticSegment(text) {
+	return text.replaceAll(REGEX_METACHARS, String.raw`\$&`);
+}
 /**
-* Build a pathname matcher for a single route: tries the `withLang` URLPattern,
-* then the `bare` pattern injecting `defaultLocale` on miss.
+* Compile one URLPattern source segment (no surrounding slash) into a regex fragment
+* that captures a single path segment: `:name` → a named `[^/]+` group, `:name(re)` →
+* a named group constrained by `re`, and static text → its escaped literal.
 *
-* @param matchers - The pre-built `withLang` and `bare` URLPattern pair.
-* @param matchers.withLang - The locale-aware URLPattern variant.
-* @param matchers.bare - The bare URLPattern variant (no leading locale segment).
+* @param segment - One source segment, e.g. `:slug`, `:lang(en|uk)`, or `archive`.
+* @returns The regex fragment for that segment.
+* @example
+* ```ts
+* segmentToRegex(":lang(en|uk)"); // "(?<lang>en|uk)"
+* ```
+*/
+function segmentToRegex(segment) {
+	const named = NAMED_GROUP.exec(segment);
+	if (named) {
+		const [, name, constraint] = named;
+		return `(?<${name}>${constraint ?? "[^/]+"})`;
+	}
+	return escapeStaticSegment(segment);
+}
+/**
+* Compile a URLPattern pathname source string into a {@link PathMatcher} backed by a
+* native `RegExp` — a drop-in replacement for `new URLPattern({ pathname })` over the
+* subset the router emits: `:name`, `:name(regex)`, the optional `:name?` segment
+* (whose leading `/` is absorbed, so `/:lang?` matches `/en` or nothing), static
+* segments, and a required trailing slash. Anchored full-match, like `URLPattern`.
+*
+* @param source - The URLPattern pathname source, e.g. `/:lang?/:slug/`.
+* @returns A matcher whose `.exec({ pathname })` yields named groups or `null`.
+* @example
+* ```ts
+* const m = createPathMatcher("/:lang?/:slug/");
+* m.exec({ pathname: "/en/hello/" }); // { pathname: { groups: { lang: "en", slug: "hello" } } }
+* ```
+*/
+function createPathMatcher(source) {
+	const segments = source.split("/");
+	let pattern = "^";
+	for (let index = 1; index < segments.length; index += 1) {
+		const segment = segments[index] ?? "";
+		if (segment === "") {
+			pattern += "/";
+			continue;
+		}
+		const optional = segment.endsWith("?");
+		const fragment = segmentToRegex(optional ? segment.slice(0, -1) : segment);
+		pattern += optional ? `(?:/${fragment})?` : `/${fragment}`;
+	}
+	pattern += "$";
+	const regexp = new RegExp(pattern);
+	return {
+	/**
+	* Run the compiled regex over a pathname (the {@link PathMatcher.exec} contract).
+	*
+	* @param input - The match input carrying the `pathname` to test.
+	* @param input.pathname - The URL pathname to match, e.g. `/en/hello/`.
+	* @returns A `{ pathname: { groups } }` result on a match, or `null` on no match.
+	* @example
+	* ```ts
+	* matcher.exec({ pathname: "/en/hello/" });
+	* ```
+	*/
+exec(input) {
+		const result = regexp.exec(input.pathname);
+		if (!result) return null;
+		return { pathname: { groups: result.groups ?? {} } };
+	} };
+}
+//#endregion
+//#region src/plugins/router/builders/match.ts
+/**
+* Build a pathname matcher for a single route: tries the `withLang` matcher,
+* then the `bare` matcher injecting `defaultLocale` on miss.
+*
+* @param matchers - The pre-built `withLang` and `bare` matcher pair.
+* @param matchers.withLang - The locale-aware matcher variant.
+* @param matchers.bare - The bare matcher variant (no leading locale segment).
 * @param defaultLocale - Locale injected when the bare fallback matches.
 * @returns A function resolving a pathname into params, or `null` on no match.
 * @example
@@ -1948,14 +2027,6 @@ function matchRoute(compiled, pathname) {
 }
 //#endregion
 //#region src/plugins/router/builders/compile.ts
-/**
-* @file router plugin — compilation + validation domain.
-*
-* Pure functions invoked from `onInit`: validate the route map, then compile each
-* route into URLPattern matchers + URL/file builders, count dynamic segments,
-* sort by specificity, and assemble the immutable `MatcherTable`. Receives DATA
-* only (`CompileInput`) — never the plugin ctx.
-*/
 /** Shared `[web]` error prefix for router validation failures. */
 const ERROR_PREFIX$11 = "[web] router";
 /** Maximum number of optional `{lang:?}` segments a single pattern may declare. */
@@ -2127,8 +2198,8 @@ function buildFilePath(pattern, params) {
 function buildMatchers(pattern, locales) {
 	const langRegex = `(${locales.join("|")})`;
 	return {
-		withLang: new URLPattern({ pathname: patternToUrlPattern(pattern, "withLang", langRegex) }),
-		bare: new URLPattern({ pathname: patternToUrlPattern(pattern, "bare", langRegex) })
+		withLang: createPathMatcher(patternToUrlPattern(pattern, "withLang", langRegex)),
+		bare: createPathMatcher(patternToUrlPattern(pattern, "bare", langRegex))
 	};
 }
 /**
@@ -3001,6 +3072,42 @@ function composeHead(input) {
 	}), ...head.elements ?? []]);
 }
 /**
+* Compose the SITE-LEVEL Open Graph / Twitter block for a bare-path redirect or landing
+* page that has no per-route head of its own. Returns `[]` UNLESS a `defaultOgImage` is
+* configured — so apps that opt out keep a bare redirect (no behavior change). The site
+* name + description become the card's title/description (`og:type=website`); `url` is the
+* canonical the page points at. A bare article/tag alias gets this site card as a fallback;
+* crawlers that honor the page's `rel=canonical` still resolve the per-route card.
+*
+* @param input - The site slice, head defaults, landing URL, and optional `og:locale`.
+* @returns The ordered site-level head element set, or `[]` when no default image is set.
+* @example composeSiteHead({ site, defaults, url: "https://blog.dev/en/", ogLocale: "en_US" })
+*/
+function composeSiteHead(input) {
+	const { site, defaults, url, ogLocale } = input;
+	const image = defaults.defaultOgImage;
+	if (image === void 0) return [];
+	const absoluteImage = resolveImage(image, site);
+	const name = site.name();
+	const description = site.description();
+	const elements = [
+		meta("description", description),
+		og("og:type", "website"),
+		og("og:site_name", name),
+		og("og:title", name),
+		og("og:description", description),
+		og("og:url", url),
+		og("og:image", absoluteImage),
+		twitter("twitter:card", defaults.twitterCard),
+		twitter("twitter:title", name),
+		twitter("twitter:description", description),
+		twitter("twitter:image", absoluteImage)
+	];
+	if (defaults.twitterHandle) elements.push(twitter("twitter:site", defaults.twitterHandle));
+	if (ogLocale) elements.push(og("og:locale", ogLocale));
+	return elements;
+}
+/**
 * HTML-escape a value for safe insertion into an attribute or text node. `&` is
 * escaped first so already-escaped entities are not double-escaped.
 *
@@ -3089,28 +3196,53 @@ function readDefaults(state) {
 * ```
 */
 function createApi$4(ctx) {
-	return {
-	/**
-	* Compose the final `<head>` inner HTML for a route (pulled by `build`).
-	*
-	* @param route - The resolved route descriptor (incl. its `.head()` HeadConfig).
-	* @param data - The page data object passed to the route's loader/render.
-	* @returns The serialized inner HTML of `<head>`.
-	* @example
-	* ```ts
-	* api.render(route, { title: "Post" });
-	* ```
-	*/
-render(route, data) {
-		return serializeHead(composeHead({
-			route,
-			data,
-			defaults: readDefaults(ctx.state),
-			site: ctx.require(sitePlugin),
-			i18n: ctx.require(i18nPlugin),
-			router: ctx.require(routerPlugin)
-		}));
-	} };
+	return {
+		/**
+		* Compose the final `<head>` inner HTML for a route (pulled by `build`).
+		*
+		* @param route - The resolved route descriptor (incl. its `.head()` HeadConfig).
+		* @param data - The page data object passed to the route's loader/render.
+		* @returns The serialized inner HTML of `<head>`.
+		* @example
+		* ```ts
+		* api.render(route, { title: "Post" });
+		* ```
+		*/
+		render(route, data) {
+			return serializeHead(composeHead({
+				route,
+				data,
+				defaults: readDefaults(ctx.state),
+				site: ctx.require(sitePlugin),
+				i18n: ctx.require(i18nPlugin),
+				router: ctx.require(routerPlugin)
+			}));
+		},
+		/**
+		* Compose the site-level OG/Twitter block for a bare-path redirect/landing page. Resolves
+		* `site`/`i18n` via `ctx.require`, absolutizes `url` against the site base, and emits an
+		* `og:locale` for `locale` when supplied. Returns `""` when no `defaultOgImage` is configured.
+		*
+		* @param input - The landing URL/path plus an optional locale (for `og:locale`).
+		* @param input.url - The page's URL or path (absolutized via `site.canonical`) → `og:url`.
+		* @param input.locale - Optional locale whose `og:locale` is emitted.
+		* @returns The serialized inner HTML of the site-level head block, or `""` when disabled.
+		* @example
+		* ```ts
+		* api.siteHead({ url: "/en/", locale: "en" });
+		* ```
+		*/
+		siteHead(input) {
+			const site = ctx.require(sitePlugin);
+			const ogLocale = input.locale === void 0 ? void 0 : ctx.require(i18nPlugin).ogLocale(input.locale);
+			return serializeHead(composeSiteHead({
+				site,
+				defaults: readDefaults(ctx.state),
+				url: site.canonical(input.url),
+				...ogLocale === void 0 ? {} : { ogLocale }
+			}));
+		}
+	};
 }
 //#endregion
 //#region src/plugins/head/config.ts
@@ -3683,19 +3815,26 @@ async function processImages(ctx, options = {}) {
 * bare path that points at the default-locale-prefixed URL. Deliberately does NOT
 * emit a Cloudflare `_redirects` catch-all (an SSG infinite-loop trap). Gated by
 * `config.localeRedirects` (false/unset disables).
+*
+* When `head.defaultOgImage` is configured, each redirect page ALSO carries the
+* site-level Open Graph / Twitter block (`head.siteHead`) so a social crawler that
+* fetches the apex domain (or any locale-less alias) — and does not follow the
+* meta-refresh — still gets a branded preview card. No image configured ⇒ bare redirect.
 */
 /**
-* Render a redirect HTML page: a `0;url` refresh meta + a canonical link to `target`.
+* Render a redirect HTML page: a `0;url` refresh meta + a canonical link to `target`,
+* with an optional site-level OG/Twitter block injected at the end of `<head>`.
 *
 * @param target - The default-locale-prefixed URL to redirect to.
+* @param headExtra - Extra `<head>` inner HTML (the site-level OG block), or `""` for none.
 * @returns The complete redirect HTML document string.
 * @example
 * ```ts
-* redirectHtml("/en/about/");
+* redirectHtml("/en/about/", '<meta property="og:image" content="…">');
 * ```
 */
-function redirectHtml(target) {
-	return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta http-equiv="refresh" content="0;url=${target}"><link rel="canonical" href="${target}"></head><body><a href="${target}">Redirecting…</a></body></html>`;
+function redirectHtml(target, headExtra = "") {
+	return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta http-equiv="refresh" content="0;url=${target}"><link rel="canonical" href="${target}">${headExtra}</head><body><a href="${target}">Redirecting…</a></body></html>`;
 }
 /**
 * Correlate manifest definitions to compiled `TypedRoute` entries by pattern (the
@@ -3787,16 +3926,17 @@ async function expandRedirects(definition, entry, defaultLocale, ctx) {
 * @param job.file - The redirect page's output path, relative to `outDir`.
 * @param job.target - The absolute default-locale URL the page redirects to.
 * @param outDir - The build output directory the file is resolved against.
+* @param headExtra - The site-level OG block to inject into `<head>`, or `""` for none.
 * @returns Resolves once the redirect HTML page is written.
 * @example
 * ```ts
-* await writeRedirectFile({ file: "about/index.html", target: "/en/about/" }, "dist");
+* await writeRedirectFile({ file: "about/index.html", target: "/en/about/" }, "dist", "");
 * ```
 */
-async function writeRedirectFile(job, outDir) {
+async function writeRedirectFile(job, outDir, headExtra = "") {
 	const filePath = node_path$1.default.join(outDir, job.file);
 	await (0, node_fs_promises.mkdir)(node_path$1.default.dirname(filePath), { recursive: true });
-	await (0, node_fs_promises.writeFile)(filePath, redirectHtml(job.target), "utf8");
+	await (0, node_fs_promises.writeFile)(filePath, redirectHtml(job.target, headExtra), "utf8");
 }
 /**
 * Emits one bare-path redirect HTML page per locale-prefixed route path, each a
@@ -3819,7 +3959,14 @@ async function generateLocaleRedirects(ctx) {
 	const router = ctx.require(routerPlugin);
 	const defaultLocale = ctx.require(i18nPlugin).defaultLocale();
 	const jobs = (await Promise.all(pairRoutes(router).map(([definition, entry]) => expandRedirects(definition, entry, defaultLocale, ctx)))).flat();
-	await Promise.all(jobs.map((job) => writeRedirectFile(job, ctx.config.outDir)));
+	const head = ctx.has("head") ? ctx.require(headPlugin) : void 0;
+	await Promise.all(jobs.map((job) => {
+		const headExtra = head ? head.siteHead({
+			url: job.target,
+			locale: defaultLocale
+		}) : "";
+		return writeRedirectFile(job, ctx.config.outDir, headExtra);
+	}));
 	ctx.log.debug("build:locale-redirects", { written: jobs.length });
 	return { written: jobs.length };
 }

package/dist/index.d.cts CHANGED Viewed

@@ -557,6 +557,32 @@ type Api$6 = {
    */
   t(locale: string, key: string): string;
 };
+//#endregion
+//#region src/plugins/router/iso-match.d.ts
+/**
+ * A compiled, engine-agnostic path matcher: the same `.exec({ pathname })` shape the
+ * router consumed from `URLPattern`, but backed by a native `RegExp` with named
+ * groups. Dropping `URLPattern` keeps route matching alive in every browser engine —
+ * Safari < 18.4 and Firefox < ~142 have no `URLPattern` global and would otherwise
+ * throw `ReferenceError` the instant the router compiles its table on boot.
+ */
+interface PathMatcher {
+  /**
+   * Match a pathname, mirroring `URLPattern.exec`: the named-group bag (under
+   * `pathname.groups`) on a hit, or `null` on a miss.
+   *
+   * @param input - The match input carrying the `pathname` to test.
+   * @param input.pathname - The URL pathname to match, e.g. `/en/hello/`.
+   * @returns A `{ pathname: { groups } }` result on a match, or `null` on no match.
+   */
+  exec(input: {
+    readonly pathname: string;
+  }): {
+    readonly pathname: {
+      readonly groups: Record<string, string | undefined>;
+    };
+  } | null;
+}
 declare namespace types_d_exports$8 {
   export { Api$5 as Api, ClientRoute, CompileInput, CompiledRoute, Config$5 as Config, ExtractApi$2 as ExtractApi, ExtractRouteParams, ExtractSegmentParameter, GenerateContext, HeadConfig$1 as HeadConfig, LayoutContext, LoadContext, MatcherTable, Prettify, RouteBuilder, RouteContext, RouteDefinition, RouteHandlers, RouteMap, RouteRequire, RouteState, RouterApi, RouterConfig, RouterState, State$5 as State, TypedRoute, Urls };
 }
@@ -836,10 +862,10 @@ interface CompiledRoute {
   readonly pattern: string;
   /** Dynamic-segment count (lower = more specific = matched first). */
   readonly dynamicSegmentCount: number;
-  /** Pre-built URLPattern matchers (lang-aware + bare fallback). */
+  /** Pre-built path matchers (lang-aware + bare fallback). */
   readonly matchers: {
-    readonly withLang: URLPattern;
-    readonly bare: URLPattern;
+    readonly withLang: PathMatcher;
+    readonly bare: PathMatcher;
   };
   /** Resolve pathname into params (withLang first, then bare with defaultLocale injected). */
   readonly matchFn: (pathname: string) => Record<string, string> | null;
@@ -1112,6 +1138,25 @@ type Api$4 = {
    * ```
    */
   render(route: ResolvedRoute, data: unknown): string;
+  /**
+   * Compose the SITE-LEVEL `<head>` Open Graph / Twitter block for a bare-path redirect or
+   * landing page that has no route identity (e.g. the apex-domain `/` redirect a
+   * `localeRedirects` build emits). Returns `""` UNLESS `defaultOgImage` is configured, so
+   * apps that opt out keep a bare redirect. Pulled synchronously by `build`.
+   *
+   * @param input - The landing URL (resolved to an absolute canonical) plus an optional locale.
+   * @param input.url - The page's URL or path (absolutized via `site.canonical`) → `og:url`.
+   * @param input.locale - Optional locale whose `og:locale` is emitted (e.g. the default locale).
+   * @returns The serialized inner HTML of the site-level head block, or `""` when disabled.
+   * @example
+   * ```ts
+   * api.siteHead({ url: "/en/", locale: "en" });
+   * ```
+   */
+  siteHead(input: {
+    url: string;
+    locale?: string;
+  }): string;
 };
 declare namespace types_d_exports$9 {
   export { COMPONENT_HOOK_NAMES, ComponentContext, ComponentDef, ComponentHooks, ComponentInstance, ExtractApi$1 as ExtractApi, PageData, ResolvedSpaConfig, SpaApi, SpaConfig, SpaContext, SpaDataReader, SpaEmitFunction, SpaEvents, SpaKernel, SpaKernelDeps, SpaRequire, SpaState };

package/dist/index.d.mts CHANGED Viewed

@@ -557,6 +557,32 @@ type Api$6 = {
    */
   t(locale: string, key: string): string;
 };
+//#endregion
+//#region src/plugins/router/iso-match.d.ts
+/**
+ * A compiled, engine-agnostic path matcher: the same `.exec({ pathname })` shape the
+ * router consumed from `URLPattern`, but backed by a native `RegExp` with named
+ * groups. Dropping `URLPattern` keeps route matching alive in every browser engine —
+ * Safari < 18.4 and Firefox < ~142 have no `URLPattern` global and would otherwise
+ * throw `ReferenceError` the instant the router compiles its table on boot.
+ */
+interface PathMatcher {
+  /**
+   * Match a pathname, mirroring `URLPattern.exec`: the named-group bag (under
+   * `pathname.groups`) on a hit, or `null` on a miss.
+   *
+   * @param input - The match input carrying the `pathname` to test.
+   * @param input.pathname - The URL pathname to match, e.g. `/en/hello/`.
+   * @returns A `{ pathname: { groups } }` result on a match, or `null` on no match.
+   */
+  exec(input: {
+    readonly pathname: string;
+  }): {
+    readonly pathname: {
+      readonly groups: Record<string, string | undefined>;
+    };
+  } | null;
+}
 declare namespace types_d_exports$8 {
   export { Api$5 as Api, ClientRoute, CompileInput, CompiledRoute, Config$5 as Config, ExtractApi$2 as ExtractApi, ExtractRouteParams, ExtractSegmentParameter, GenerateContext, HeadConfig$1 as HeadConfig, LayoutContext, LoadContext, MatcherTable, Prettify, RouteBuilder, RouteContext, RouteDefinition, RouteHandlers, RouteMap, RouteRequire, RouteState, RouterApi, RouterConfig, RouterState, State$5 as State, TypedRoute, Urls };
 }
@@ -836,10 +862,10 @@ interface CompiledRoute {
   readonly pattern: string;
   /** Dynamic-segment count (lower = more specific = matched first). */
   readonly dynamicSegmentCount: number;
-  /** Pre-built URLPattern matchers (lang-aware + bare fallback). */
+  /** Pre-built path matchers (lang-aware + bare fallback). */
   readonly matchers: {
-    readonly withLang: URLPattern;
-    readonly bare: URLPattern;
+    readonly withLang: PathMatcher;
+    readonly bare: PathMatcher;
   };
   /** Resolve pathname into params (withLang first, then bare with defaultLocale injected). */
   readonly matchFn: (pathname: string) => Record<string, string> | null;
@@ -1112,6 +1138,25 @@ type Api$4 = {
    * ```
    */
   render(route: ResolvedRoute, data: unknown): string;
+  /**
+   * Compose the SITE-LEVEL `<head>` Open Graph / Twitter block for a bare-path redirect or
+   * landing page that has no route identity (e.g. the apex-domain `/` redirect a
+   * `localeRedirects` build emits). Returns `""` UNLESS `defaultOgImage` is configured, so
+   * apps that opt out keep a bare redirect. Pulled synchronously by `build`.
+   *
+   * @param input - The landing URL (resolved to an absolute canonical) plus an optional locale.
+   * @param input.url - The page's URL or path (absolutized via `site.canonical`) → `og:url`.
+   * @param input.locale - Optional locale whose `og:locale` is emitted (e.g. the default locale).
+   * @returns The serialized inner HTML of the site-level head block, or `""` when disabled.
+   * @example
+   * ```ts
+   * api.siteHead({ url: "/en/", locale: "en" });
+   * ```
+   */
+  siteHead(input: {
+    url: string;
+    locale?: string;
+  }): string;
 };
 declare namespace types_d_exports$9 {
   export { COMPONENT_HOOK_NAMES, ComponentContext, ComponentDef, ComponentHooks, ComponentInstance, ExtractApi$1 as ExtractApi, PageData, ResolvedSpaConfig, SpaApi, SpaConfig, SpaContext, SpaDataReader, SpaEmitFunction, SpaEvents, SpaKernel, SpaKernelDeps, SpaRequire, SpaState };

package/dist/index.mjs CHANGED Viewed

@@ -1876,22 +1876,101 @@ function extractGroups(groups) {
 	}
 	return params;
 }
-//#endregion
-//#region src/plugins/router/builders/match.ts
+/** Regex metacharacters escaped when a static path segment is inlined into a compiled pattern. */
+const REGEX_METACHARS = /[.*+?^${}()|[\]\\]/g;
+/** Matches a `:name` or `:name(regex)` URLPattern group occupying one whole segment. */
+const NAMED_GROUP = /^:([A-Za-z_]\w*)(?:\((.+)\))?$/;
 /**
-* @file router plugin — runtime matching domain.
+* Escape a static path segment so its literal text matches verbatim inside the
+* compiled `RegExp` (a segment like `c++` must not be read as regex syntax).
 *
-* Pure functions that turn compiled patterns into a pathname matcher: build the
-* lang-aware/bare `URLPattern` pair, the `matchFn` (withLang first, bare fallback
-* injecting `defaultLocale`), and extract/strip params. No `ctx` here.
+* @param text - The static segment text.
+* @returns The regex-escaped segment.
+* @example
+* ```ts
+* escapeStaticSegment("about"); // "about"
+* ```
 */
+function escapeStaticSegment(text) {
+	return text.replaceAll(REGEX_METACHARS, String.raw`\$&`);
+}
 /**
-* Build a pathname matcher for a single route: tries the `withLang` URLPattern,
-* then the `bare` pattern injecting `defaultLocale` on miss.
+* Compile one URLPattern source segment (no surrounding slash) into a regex fragment
+* that captures a single path segment: `:name` → a named `[^/]+` group, `:name(re)` →
+* a named group constrained by `re`, and static text → its escaped literal.
 *
-* @param matchers - The pre-built `withLang` and `bare` URLPattern pair.
-* @param matchers.withLang - The locale-aware URLPattern variant.
-* @param matchers.bare - The bare URLPattern variant (no leading locale segment).
+* @param segment - One source segment, e.g. `:slug`, `:lang(en|uk)`, or `archive`.
+* @returns The regex fragment for that segment.
+* @example
+* ```ts
+* segmentToRegex(":lang(en|uk)"); // "(?<lang>en|uk)"
+* ```
+*/
+function segmentToRegex(segment) {
+	const named = NAMED_GROUP.exec(segment);
+	if (named) {
+		const [, name, constraint] = named;
+		return `(?<${name}>${constraint ?? "[^/]+"})`;
+	}
+	return escapeStaticSegment(segment);
+}
+/**
+* Compile a URLPattern pathname source string into a {@link PathMatcher} backed by a
+* native `RegExp` — a drop-in replacement for `new URLPattern({ pathname })` over the
+* subset the router emits: `:name`, `:name(regex)`, the optional `:name?` segment
+* (whose leading `/` is absorbed, so `/:lang?` matches `/en` or nothing), static
+* segments, and a required trailing slash. Anchored full-match, like `URLPattern`.
+*
+* @param source - The URLPattern pathname source, e.g. `/:lang?/:slug/`.
+* @returns A matcher whose `.exec({ pathname })` yields named groups or `null`.
+* @example
+* ```ts
+* const m = createPathMatcher("/:lang?/:slug/");
+* m.exec({ pathname: "/en/hello/" }); // { pathname: { groups: { lang: "en", slug: "hello" } } }
+* ```
+*/
+function createPathMatcher(source) {
+	const segments = source.split("/");
+	let pattern = "^";
+	for (let index = 1; index < segments.length; index += 1) {
+		const segment = segments[index] ?? "";
+		if (segment === "") {
+			pattern += "/";
+			continue;
+		}
+		const optional = segment.endsWith("?");
+		const fragment = segmentToRegex(optional ? segment.slice(0, -1) : segment);
+		pattern += optional ? `(?:/${fragment})?` : `/${fragment}`;
+	}
+	pattern += "$";
+	const regexp = new RegExp(pattern);
+	return {
+	/**
+	* Run the compiled regex over a pathname (the {@link PathMatcher.exec} contract).
+	*
+	* @param input - The match input carrying the `pathname` to test.
+	* @param input.pathname - The URL pathname to match, e.g. `/en/hello/`.
+	* @returns A `{ pathname: { groups } }` result on a match, or `null` on no match.
+	* @example
+	* ```ts
+	* matcher.exec({ pathname: "/en/hello/" });
+	* ```
+	*/
+exec(input) {
+		const result = regexp.exec(input.pathname);
+		if (!result) return null;
+		return { pathname: { groups: result.groups ?? {} } };
+	} };
+}
+//#endregion
+//#region src/plugins/router/builders/match.ts
+/**
+* Build a pathname matcher for a single route: tries the `withLang` matcher,
+* then the `bare` matcher injecting `defaultLocale` on miss.
+*
+* @param matchers - The pre-built `withLang` and `bare` matcher pair.
+* @param matchers.withLang - The locale-aware matcher variant.
+* @param matchers.bare - The bare matcher variant (no leading locale segment).
 * @param defaultLocale - Locale injected when the bare fallback matches.
 * @returns A function resolving a pathname into params, or `null` on no match.
 * @example
@@ -1935,14 +2014,6 @@ function matchRoute(compiled, pathname) {
 }
 //#endregion
 //#region src/plugins/router/builders/compile.ts
-/**
-* @file router plugin — compilation + validation domain.
-*
-* Pure functions invoked from `onInit`: validate the route map, then compile each
-* route into URLPattern matchers + URL/file builders, count dynamic segments,
-* sort by specificity, and assemble the immutable `MatcherTable`. Receives DATA
-* only (`CompileInput`) — never the plugin ctx.
-*/
 /** Shared `[web]` error prefix for router validation failures. */
 const ERROR_PREFIX$11 = "[web] router";
 /** Maximum number of optional `{lang:?}` segments a single pattern may declare. */
@@ -2114,8 +2185,8 @@ function buildFilePath(pattern, params) {
 function buildMatchers(pattern, locales) {
 	const langRegex = `(${locales.join("|")})`;
 	return {
-		withLang: new URLPattern({ pathname: patternToUrlPattern(pattern, "withLang", langRegex) }),
-		bare: new URLPattern({ pathname: patternToUrlPattern(pattern, "bare", langRegex) })
+		withLang: createPathMatcher(patternToUrlPattern(pattern, "withLang", langRegex)),
+		bare: createPathMatcher(patternToUrlPattern(pattern, "bare", langRegex))
 	};
 }
 /**
@@ -2988,6 +3059,42 @@ function composeHead(input) {
 	}), ...head.elements ?? []]);
 }
 /**
+* Compose the SITE-LEVEL Open Graph / Twitter block for a bare-path redirect or landing
+* page that has no per-route head of its own. Returns `[]` UNLESS a `defaultOgImage` is
+* configured — so apps that opt out keep a bare redirect (no behavior change). The site
+* name + description become the card's title/description (`og:type=website`); `url` is the
+* canonical the page points at. A bare article/tag alias gets this site card as a fallback;
+* crawlers that honor the page's `rel=canonical` still resolve the per-route card.
+*
+* @param input - The site slice, head defaults, landing URL, and optional `og:locale`.
+* @returns The ordered site-level head element set, or `[]` when no default image is set.
+* @example composeSiteHead({ site, defaults, url: "https://blog.dev/en/", ogLocale: "en_US" })
+*/
+function composeSiteHead(input) {
+	const { site, defaults, url, ogLocale } = input;
+	const image = defaults.defaultOgImage;
+	if (image === void 0) return [];
+	const absoluteImage = resolveImage(image, site);
+	const name = site.name();
+	const description = site.description();
+	const elements = [
+		meta("description", description),
+		og("og:type", "website"),
+		og("og:site_name", name),
+		og("og:title", name),
+		og("og:description", description),
+		og("og:url", url),
+		og("og:image", absoluteImage),
+		twitter("twitter:card", defaults.twitterCard),
+		twitter("twitter:title", name),
+		twitter("twitter:description", description),
+		twitter("twitter:image", absoluteImage)
+	];
+	if (defaults.twitterHandle) elements.push(twitter("twitter:site", defaults.twitterHandle));
+	if (ogLocale) elements.push(og("og:locale", ogLocale));
+	return elements;
+}
+/**
 * HTML-escape a value for safe insertion into an attribute or text node. `&` is
 * escaped first so already-escaped entities are not double-escaped.
 *
@@ -3076,28 +3183,53 @@ function readDefaults(state) {
 * ```
 */
 function createApi$4(ctx) {
-	return {
-	/**
-	* Compose the final `<head>` inner HTML for a route (pulled by `build`).
-	*
-	* @param route - The resolved route descriptor (incl. its `.head()` HeadConfig).
-	* @param data - The page data object passed to the route's loader/render.
-	* @returns The serialized inner HTML of `<head>`.
-	* @example
-	* ```ts
-	* api.render(route, { title: "Post" });
-	* ```
-	*/
-render(route, data) {
-		return serializeHead(composeHead({
-			route,
-			data,
-			defaults: readDefaults(ctx.state),
-			site: ctx.require(sitePlugin),
-			i18n: ctx.require(i18nPlugin),
-			router: ctx.require(routerPlugin)
-		}));
-	} };
+	return {
+		/**
+		* Compose the final `<head>` inner HTML for a route (pulled by `build`).
+		*
+		* @param route - The resolved route descriptor (incl. its `.head()` HeadConfig).
+		* @param data - The page data object passed to the route's loader/render.
+		* @returns The serialized inner HTML of `<head>`.
+		* @example
+		* ```ts
+		* api.render(route, { title: "Post" });
+		* ```
+		*/
+		render(route, data) {
+			return serializeHead(composeHead({
+				route,
+				data,
+				defaults: readDefaults(ctx.state),
+				site: ctx.require(sitePlugin),
+				i18n: ctx.require(i18nPlugin),
+				router: ctx.require(routerPlugin)
+			}));
+		},
+		/**
+		* Compose the site-level OG/Twitter block for a bare-path redirect/landing page. Resolves
+		* `site`/`i18n` via `ctx.require`, absolutizes `url` against the site base, and emits an
+		* `og:locale` for `locale` when supplied. Returns `""` when no `defaultOgImage` is configured.
+		*
+		* @param input - The landing URL/path plus an optional locale (for `og:locale`).
+		* @param input.url - The page's URL or path (absolutized via `site.canonical`) → `og:url`.
+		* @param input.locale - Optional locale whose `og:locale` is emitted.
+		* @returns The serialized inner HTML of the site-level head block, or `""` when disabled.
+		* @example
+		* ```ts
+		* api.siteHead({ url: "/en/", locale: "en" });
+		* ```
+		*/
+		siteHead(input) {
+			const site = ctx.require(sitePlugin);
+			const ogLocale = input.locale === void 0 ? void 0 : ctx.require(i18nPlugin).ogLocale(input.locale);
+			return serializeHead(composeSiteHead({
+				site,
+				defaults: readDefaults(ctx.state),
+				url: site.canonical(input.url),
+				...ogLocale === void 0 ? {} : { ogLocale }
+			}));
+		}
+	};
 }
 //#endregion
 //#region src/plugins/head/config.ts
@@ -3670,19 +3802,26 @@ async function processImages(ctx, options = {}) {
 * bare path that points at the default-locale-prefixed URL. Deliberately does NOT
 * emit a Cloudflare `_redirects` catch-all (an SSG infinite-loop trap). Gated by
 * `config.localeRedirects` (false/unset disables).
+*
+* When `head.defaultOgImage` is configured, each redirect page ALSO carries the
+* site-level Open Graph / Twitter block (`head.siteHead`) so a social crawler that
+* fetches the apex domain (or any locale-less alias) — and does not follow the
+* meta-refresh — still gets a branded preview card. No image configured ⇒ bare redirect.
 */
 /**
-* Render a redirect HTML page: a `0;url` refresh meta + a canonical link to `target`.
+* Render a redirect HTML page: a `0;url` refresh meta + a canonical link to `target`,
+* with an optional site-level OG/Twitter block injected at the end of `<head>`.
 *
 * @param target - The default-locale-prefixed URL to redirect to.
+* @param headExtra - Extra `<head>` inner HTML (the site-level OG block), or `""` for none.
 * @returns The complete redirect HTML document string.
 * @example
 * ```ts
-* redirectHtml("/en/about/");
+* redirectHtml("/en/about/", '<meta property="og:image" content="…">');
 * ```
 */
-function redirectHtml(target) {
-	return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta http-equiv="refresh" content="0;url=${target}"><link rel="canonical" href="${target}"></head><body><a href="${target}">Redirecting…</a></body></html>`;
+function redirectHtml(target, headExtra = "") {
+	return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta http-equiv="refresh" content="0;url=${target}"><link rel="canonical" href="${target}">${headExtra}</head><body><a href="${target}">Redirecting…</a></body></html>`;
 }
 /**
 * Correlate manifest definitions to compiled `TypedRoute` entries by pattern (the
@@ -3774,16 +3913,17 @@ async function expandRedirects(definition, entry, defaultLocale, ctx) {
 * @param job.file - The redirect page's output path, relative to `outDir`.
 * @param job.target - The absolute default-locale URL the page redirects to.
 * @param outDir - The build output directory the file is resolved against.
+* @param headExtra - The site-level OG block to inject into `<head>`, or `""` for none.
 * @returns Resolves once the redirect HTML page is written.
 * @example
 * ```ts
-* await writeRedirectFile({ file: "about/index.html", target: "/en/about/" }, "dist");
+* await writeRedirectFile({ file: "about/index.html", target: "/en/about/" }, "dist", "");
 * ```
 */
-async function writeRedirectFile(job, outDir) {
+async function writeRedirectFile(job, outDir, headExtra = "") {
 	const filePath = path.join(outDir, job.file);
 	await mkdir(path.dirname(filePath), { recursive: true });
-	await writeFile(filePath, redirectHtml(job.target), "utf8");
+	await writeFile(filePath, redirectHtml(job.target, headExtra), "utf8");
 }
 /**
 * Emits one bare-path redirect HTML page per locale-prefixed route path, each a
@@ -3806,7 +3946,14 @@ async function generateLocaleRedirects(ctx) {
 	const router = ctx.require(routerPlugin);
 	const defaultLocale = ctx.require(i18nPlugin).defaultLocale();
 	const jobs = (await Promise.all(pairRoutes(router).map(([definition, entry]) => expandRedirects(definition, entry, defaultLocale, ctx)))).flat();
-	await Promise.all(jobs.map((job) => writeRedirectFile(job, ctx.config.outDir)));
+	const head = ctx.has("head") ? ctx.require(headPlugin) : void 0;
+	await Promise.all(jobs.map((job) => {
+		const headExtra = head ? head.siteHead({
+			url: job.target,
+			locale: defaultLocale
+		}) : "";
+		return writeRedirectFile(job, ctx.config.outDir, headExtra);
+	}));
 	ctx.log.debug("build:locale-redirects", { written: jobs.length });
 	return { written: jobs.length };
 }

package/package.json CHANGED Viewed

@@ -113,5 +113,5 @@
     "test:cli-e2e": "bun test src/plugins/cli/__tests__/e2e/",
     "test:coverage": "vitest run --project unit --project integration --coverage"
   },
-  "version": "1.4.0"
+  "version": "1.5.0"
 }