@anglefeint/astro-theme 0.1.40 → 0.2.0

package/README.md

@@ -42,6 +42,8 @@ For content schema:
 export { collections } from '@anglefeint/astro-theme/content-schema';
 ```
 
+`sourceLinks` in blog frontmatter accepts standard `http(s)` URLs and bare domains such as `github.com/anglefeint/astro-theme-anglefeint`. Bare domains are normalized to `https://...` during schema parsing.
+
 ## Site Config Injection
 
 This package reads site-specific config from alias imports:
@@ -68,10 +70,10 @@ Examples:
 anglefeint-new-post my-first-post
 
 # create post only for selected locales
-anglefeint-new-post my-first-post --locales en,ja
+anglefeint-new-post my-first-post --locales en,fr
 
 # or via environment variable
-ANGLEFEINT_LOCALES=en,ja anglefeint-new-post my-first-post
+ANGLEFEINT_LOCALES=en,fr anglefeint-new-post my-first-post
 
 # create a custom page with theme variant
 anglefeint-new-page projects --theme base

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anglefeint/astro-theme",
-  "version": "0.1.40",
+  "version": "0.2.0",
   "type": "module",
   "description": "Anglefeint core theme package for Astro",
   "keywords": [

package/src/cli-new-post.mjs

@@ -1,113 +1,350 @@
 import { mkdir, writeFile, access } from 'node:fs/promises';
 import { constants } from 'node:fs';
+import { execFile as execFileCallback } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { SUPPORTED_LOCALES } from './i18n/locales.mjs';
+import { promisify } from 'node:util';
 import {
-	buildNewPostTemplate,
-	loadDefaultCovers,
-	parseNewPostArgs,
-	pickDefaultCoverBySlug,
-	resolveLocales,
-	usageNewPost,
-	validatePostSlug,
+  buildNewPostTemplate,
+  loadDefaultCovers,
+  parseNewPostArgs,
+  pickDefaultCoverBySlug,
+  resolveLocales,
+  usageNewPost,
+  validatePostSlug,
 } from './scaffold/new-post.mjs';
 
 const CONTENT_ROOT = path.resolve(process.cwd(), 'src/content/blog');
 const DEFAULT_COVERS_ROOT = path.resolve(process.cwd(), 'src/assets/blog/default-covers');
 const SITE_CONFIG_PATH = path.resolve(process.cwd(), 'src/site.config.ts');
+const FALLBACK_LOCALES = ['en'];
+const execFile = promisify(execFileCallback);
 
 async function exists(filePath) {
-	try {
-		await access(filePath, constants.F_OK);
-		return true;
-	} catch {
-		return false;
-	}
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
-function parseSupportedLocalesFromConfig(configSource) {
-	const localeArrayPattern = /supportedLocales\s*:\s*\[([\s\S]*?)\]/g;
-	let match = null;
-	let picked = '';
-
-	while (true) {
-		const next = localeArrayPattern.exec(configSource);
-		if (!next) break;
-		const body = next[1] ?? '';
-		if (body.includes("'") || body.includes('"')) {
-			match = next;
-			picked = body;
-		}
-	}
-
-	if (!match || !picked) return [];
-	const localeMatches = picked.match(/['"]([a-z]{2,3}(?:-[a-z0-9]+)?)['"]/gi) || [];
-	return localeMatches.map((token) => token.slice(1, -1).toLowerCase());
+function extractObjectLiteral(source, marker) {
+  const markerIndex = source.indexOf(marker);
+  if (markerIndex === -1) return '';
+
+  const start = source.indexOf('{', markerIndex);
+  return extractObjectLiteralFromIndex(source, start);
+}
+
+function extractObjectLiteralFromIndex(source, start) {
+  if (start === -1) return '';
+
+  let depth = 0;
+  let inString = false;
+  let quote = '';
+  let escaped = false;
+
+  for (let index = start; index < source.length; index += 1) {
+    const char = source[index];
+
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === '\\') {
+        escaped = true;
+        continue;
+      }
+      if (char === quote) {
+        inString = false;
+        quote = '';
+      }
+      continue;
+    }
+
+    if (char === '"' || char === "'" || char === '`') {
+      inString = true;
+      quote = char;
+      continue;
+    }
+
+    if (char === '{') depth += 1;
+    if (char === '}') {
+      depth -= 1;
+      if (depth === 0) return source.slice(start, index + 1);
+    }
+  }
+
+  return '';
+}
+
+function extractThemeConfigObject(configSource) {
+  const themeConfigMarkers = ['export const THEME_CONFIG', 'const THEME_CONFIG'];
+
+  for (const marker of themeConfigMarkers) {
+    const markerIndex = configSource.indexOf(marker);
+    if (markerIndex === -1) continue;
+
+    const assignmentIndex = configSource.indexOf('=', markerIndex);
+    if (assignmentIndex === -1) continue;
+
+    const objectStart = configSource.indexOf('{', assignmentIndex);
+    if (objectStart === -1) continue;
+
+    let depth = 0;
+    let inString = false;
+    let quote = '';
+    let escaped = false;
+
+    for (let index = objectStart; index < configSource.length; index += 1) {
+      const char = configSource[index];
+
+      if (inString) {
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (char === '\\') {
+          escaped = true;
+          continue;
+        }
+        if (char === quote) {
+          inString = false;
+          quote = '';
+        }
+        continue;
+      }
+
+      if (char === '"' || char === "'" || char === '`') {
+        inString = true;
+        quote = char;
+        continue;
+      }
+
+      if (char === '{') depth += 1;
+      if (char === '}') {
+        depth -= 1;
+        if (depth === 0) return configSource.slice(objectStart, index + 1);
+      }
+    }
+  }
+
+  return '';
+}
+
+function localeKeyFromToken(key) {
+  return /^[a-z]{2,3}(?:-[a-z0-9]+)?$/i.test(key) ? key.toLowerCase() : '';
+}
+
+function localeObjectIsEnabled(localeObjectSource) {
+  const metaObject = extractObjectLiteral(localeObjectSource, 'meta');
+  if (!metaObject) return true;
+
+  return !/\benabled\s*:\s*false\b/.test(metaObject);
+}
+
+function parseLocaleRegistryKeys(configSource) {
+  const themeConfigObject = extractThemeConfigObject(configSource);
+  if (!themeConfigObject) return [];
+
+  const i18nObject = extractObjectLiteral(themeConfigObject, 'i18n');
+  if (!i18nObject) return [];
+
+  const localesObject = extractObjectLiteral(i18nObject, 'locales');
+  if (!localesObject) return [];
+
+  const keys = [];
+  let depth = 0;
+
+  for (let index = 0; index < localesObject.length; index += 1) {
+    const char = localesObject[index];
+
+    if (char === '{') {
+      depth += 1;
+      if (depth === 1) continue;
+    }
+    if (char === '}') {
+      depth -= 1;
+      continue;
+    }
+
+    if (depth !== 1) continue;
+
+    if (char === '"' || char === "'" || char === '`') {
+      let key = '';
+      let escaped = false;
+      const quote = char;
+      let cursor = index + 1;
+
+      for (; cursor < localesObject.length; cursor += 1) {
+        const next = localesObject[cursor];
+        if (escaped) {
+          key += next;
+          escaped = false;
+          continue;
+        }
+        if (next === '\\') {
+          escaped = true;
+          continue;
+        }
+        if (next === quote) break;
+        key += next;
+      }
+
+      let colonIndex = cursor + 1;
+      while (colonIndex < localesObject.length && /\s/.test(localesObject[colonIndex])) {
+        colonIndex += 1;
+      }
+
+      const normalizedKey = localeKeyFromToken(key);
+      if (localesObject[colonIndex] === ':' && normalizedKey) {
+        const localeObject = extractObjectLiteralFromIndex(
+          localesObject,
+          localesObject.indexOf('{', colonIndex)
+        );
+        if (!localeObject || localeObjectIsEnabled(localeObject)) {
+          keys.push(normalizedKey);
+        }
+      }
+
+      index = cursor;
+      continue;
+    }
+
+    if (/[A-Za-z_$]/.test(char)) {
+      let cursor = index + 1;
+      while (cursor < localesObject.length && /[A-Za-z0-9_$-]/.test(localesObject[cursor])) {
+        cursor += 1;
+      }
+      const key = localesObject.slice(index, cursor).trim();
+
+      let colonIndex = cursor;
+      while (colonIndex < localesObject.length && /\s/.test(localesObject[colonIndex])) {
+        colonIndex += 1;
+      }
+
+      const normalizedKey = localeKeyFromToken(key);
+      if (localesObject[colonIndex] === ':' && normalizedKey) {
+        const localeObject = extractObjectLiteralFromIndex(
+          localesObject,
+          localesObject.indexOf('{', colonIndex)
+        );
+        if (!localeObject || localeObjectIsEnabled(localeObject)) {
+          keys.push(normalizedKey);
+        }
+      }
+
+      index = cursor - 1;
+    }
+  }
+
+  return Array.from(new Set(keys));
+}
+
+async function loadNormalizedProjectI18n() {
+  const loaderSource = `
+    import { pathToFileURL } from 'node:url';
+
+    const mod = await import(pathToFileURL(process.argv[1]).href);
+    const config = mod.THEME_CONFIG?.i18n;
+
+    if (!config) process.exit(2);
+
+    const normalized =
+      typeof mod.normalizeI18nConfig === 'function' ? mod.normalizeI18nConfig(config) : config;
+
+    process.stdout.write(JSON.stringify(normalized));
+  `;
+
+  const { stdout } = await execFile(
+    process.execPath,
+    ['--experimental-strip-types', '--input-type=module', '--eval', loaderSource, SITE_CONFIG_PATH],
+    {
+      cwd: process.cwd(),
+      encoding: 'utf8',
+    }
+  );
+
+  return JSON.parse(stdout);
 }
 
 async function resolveProjectLocales() {
-	try {
-		const configSource = await readFile(SITE_CONFIG_PATH, 'utf8');
-		const locales = parseSupportedLocalesFromConfig(configSource);
-		if (locales.length === 0) return [];
-		return Array.from(new Set(locales));
-	} catch {
-		return [];
-	}
+  try {
+    const normalized = await loadNormalizedProjectI18n();
+    const locales = Object.values(normalized.locales ?? {})
+      .filter((locale) => locale?.meta?.enabled)
+      .map((locale) => locale.code)
+      .filter((locale) => typeof locale === 'string');
+    if (locales.length > 0) {
+      return Array.from(new Set(locales));
+    }
+  } catch {
+    // Fall through to the source parser fallback for environments without TS loading support.
+  }
+
+  try {
+    const configSource = await readFile(SITE_CONFIG_PATH, 'utf8');
+    const locales = parseLocaleRegistryKeys(configSource);
+    if (locales.length === 0) return [];
+    return Array.from(new Set(locales));
+  } catch {
+    return [];
+  }
 }
 
 async function main() {
-	const { slug, locales: cliLocales } = parseNewPostArgs(process.argv);
-	if (!slug) {
-		console.error(usageNewPost());
-		process.exit(1);
-	}
-
-	if (!validatePostSlug(slug)) {
-		console.error('Invalid slug. Use lowercase letters, numbers, and hyphens only.');
-		process.exit(1);
-	}
-
-	const pubDate = new Date().toISOString().slice(0, 10);
-	const defaultCovers = await loadDefaultCovers(DEFAULT_COVERS_ROOT);
-	const projectLocales = await resolveProjectLocales();
-	const locales = resolveLocales({
-		cliLocales,
-		envLocales: process.env.ANGLEFEINT_LOCALES ?? '',
-		defaultLocales: projectLocales.length > 0 ? projectLocales : SUPPORTED_LOCALES,
-	});
-	const created = [];
-	const skipped = [];
-
-	for (const locale of locales) {
-		const localeDir = path.join(CONTENT_ROOT, locale);
-		const filePath = path.join(localeDir, `${slug}.md`);
-		await mkdir(localeDir, { recursive: true });
-
-		if (await exists(filePath)) {
-			skipped.push(filePath);
-			continue;
-		}
-
-		const heroImage = pickDefaultCoverBySlug(slug, localeDir, defaultCovers);
-
-		await writeFile(filePath, buildNewPostTemplate(locale, slug, pubDate, heroImage), 'utf8');
-		created.push(filePath);
-	}
-
-	if (created.length > 0) {
-		console.log('Created files:');
-		for (const filePath of created) console.log(`- ${filePath}`);
-	}
-
-	if (skipped.length > 0) {
-		console.log('Skipped existing files:');
-		for (const filePath of skipped) console.log(`- ${filePath}`);
-	}
+  const { slug, locales: cliLocales } = parseNewPostArgs(process.argv);
+  if (!slug) {
+    console.error(usageNewPost());
+    process.exit(1);
+  }
+
+  if (!validatePostSlug(slug)) {
+    console.error('Invalid slug. Use lowercase letters, numbers, and hyphens only.');
+    process.exit(1);
+  }
+
+  const pubDate = new Date().toISOString().slice(0, 10);
+  const defaultCovers = await loadDefaultCovers(DEFAULT_COVERS_ROOT);
+  const projectLocales = await resolveProjectLocales();
+  const locales = resolveLocales({
+    cliLocales,
+    envLocales: process.env.ANGLEFEINT_LOCALES ?? '',
+    defaultLocales: projectLocales.length > 0 ? projectLocales : FALLBACK_LOCALES,
+  });
+  const created = [];
+  const skipped = [];
+
+  for (const locale of locales) {
+    const localeDir = path.join(CONTENT_ROOT, locale);
+    const filePath = path.join(localeDir, `${slug}.md`);
+    await mkdir(localeDir, { recursive: true });
+
+    if (await exists(filePath)) {
+      skipped.push(filePath);
+      continue;
+    }
+
+    const heroImage = pickDefaultCoverBySlug(slug, localeDir, defaultCovers);
+
+    await writeFile(filePath, buildNewPostTemplate(locale, slug, pubDate, heroImage), 'utf8');
+    created.push(filePath);
+  }
+
+  if (created.length > 0) {
+    console.log('Created files:');
+    for (const filePath of created) console.log(`- ${filePath}`);
+  }
+
+  if (skipped.length > 0) {
+    console.log('Skipped existing files:');
+    for (const filePath of skipped) console.log(`- ${filePath}`);
+  }
 }
 
 main().catch((error) => {
-	console.error(error);
-	process.exit(1);
+  console.error(error);
+  process.exit(1);
 });

package/src/components/BaseHead.astro

@@ -9,6 +9,8 @@ import {
   DEFAULT_LOCALE,
   SUPPORTED_LOCALES,
   alternatePathForLocale,
+  getLocaleHreflang,
+  getLocaleOgLocale,
   isLocale,
   stripLocaleFromPath,
 } from '@anglefeint/site-i18n/config';
@@ -52,21 +54,14 @@ const rssURL = new URL(`/${currentLocale}/rss.xml`, siteURL);
 const localeSubpath = stripLocaleFromPath(Astro.url.pathname, currentLocale);
 const alternatePaths = SUPPORTED_LOCALES.map((locale) => ({
   locale,
+  hreflang: getLocaleHreflang(locale),
   href: new URL(alternatePathForLocale(locale, localeSubpath), siteURL).toString(),
 }));
 const xDefaultHref = new URL(alternatePathForLocale(DEFAULT_LOCALE, localeSubpath), siteURL);
-
-const OG_LOCALE: Record<string, string> = {
-  en: 'en_US',
-  ja: 'ja_JP',
-  ko: 'ko_KR',
-  es: 'es_ES',
-  zh: 'zh_CN',
-};
-const ogLocale = OG_LOCALE[currentLocale] ?? 'en_US';
-const ogLocaleAlternates = SUPPORTED_LOCALES.filter((l) => l !== currentLocale).map(
-  (l) => OG_LOCALE[l]
-);
+const ogLocale = getLocaleOgLocale(currentLocale);
+const ogLocaleAlternates = SUPPORTED_LOCALES.filter((locale) => locale !== currentLocale)
+  .map((locale) => getLocaleOgLocale(locale))
+  .filter(Boolean);
 const articleModifiedISO = (modifiedTime ?? publishedTime)?.toISOString();
 
 const websiteSchema = {
@@ -133,7 +128,7 @@ const jsonLdSchemas = [websiteSchema, personSchema, articleSchema, ...extraSchem
 <link rel="canonical" href={canonicalURL} />
 {
   alternatePaths.map((alternate) => (
-    <link rel="alternate" hreflang={alternate.locale} href={alternate.href} />
+    <link rel="alternate" hreflang={alternate.hreflang} href={alternate.href} />
   ))
 }
 <link rel="alternate" hreflang="x-default" href={xDefaultHref} />
@@ -160,7 +155,7 @@ const jsonLdSchemas = [websiteSchema, personSchema, articleSchema, ...extraSchem
     <meta property="og:image:height" content={String(image.height)} />
   )
 }
-<meta property="og:locale" content={ogLocale} />
+{ogLocale && <meta property="og:locale" content={ogLocale} />}
 {ogLocaleAlternates.map((loc) => <meta property="og:locale:alternate" content={loc} />)}
 {
   isArticle && publishedTime && (

package/src/i18n/config.ts

@@ -1,50 +1,50 @@
 import {
-	SUPPORTED_LOCALES as SUPPORTED_LOCALES_RUNTIME,
-	DEFAULT_LOCALE as DEFAULT_LOCALE_RUNTIME,
+  SUPPORTED_LOCALES as SUPPORTED_LOCALES_RUNTIME,
+  DEFAULT_LOCALE as DEFAULT_LOCALE_RUNTIME,
 } from './locales.mjs';
 
-export type Locale = 'en' | 'ja' | 'ko' | 'es' | 'zh';
-export const SUPPORTED_LOCALES = SUPPORTED_LOCALES_RUNTIME as readonly Locale[];
-export const DEFAULT_LOCALE: Locale = DEFAULT_LOCALE_RUNTIME as Locale;
+export type Locale = string;
+export const SUPPORTED_LOCALES = SUPPORTED_LOCALES_RUNTIME as readonly string[];
+export const DEFAULT_LOCALE: Locale = DEFAULT_LOCALE_RUNTIME;
 
-export const LOCALE_LABELS: Record<Locale, string> = {
-	en: 'English',
-	ja: '日本語',
-	ko: '한국어',
-	es: 'Español',
-	zh: '中文',
+export const LOCALE_LABELS: Record<string, string> = {
+  en: 'English',
+  ja: '日本語',
+  ko: '한국어',
+  es: 'Español',
+  zh: '中文',
 };
 
 export function isLocale(value: string): value is Locale {
-	return (SUPPORTED_LOCALES as readonly string[]).includes(value);
+  return (SUPPORTED_LOCALES as readonly string[]).includes(value);
 }
 
 export function withLeadingSlash(path: string): string {
-	if (!path) return '/';
-	return path.startsWith('/') ? path : `/${path}`;
+  if (!path) return '/';
+  return path.startsWith('/') ? path : `/${path}`;
 }
 
-export function localePath(locale: Locale, path = '/'): string {
-	const normalized = withLeadingSlash(path);
-	if (normalized === '/') return `/${locale}/`;
-	return `/${locale}${normalized.endsWith('/') ? normalized : `${normalized}/`}`;
+export function localePath(locale: string, path = '/'): string {
+  const normalized = withLeadingSlash(path);
+  if (normalized === '/') return `/${locale}/`;
+  return `/${locale}${normalized.endsWith('/') ? normalized : `${normalized}/`}`;
 }
 
-export function stripLocaleFromPath(pathname: string, locale: Locale): string {
-	const prefix = `/${locale}`;
-	if (!pathname.startsWith(prefix)) return pathname;
-	const withoutLocale = pathname.slice(prefix.length);
-	return withoutLocale || '/';
+export function stripLocaleFromPath(pathname: string, locale: string): string {
+  const prefix = `/${locale}`;
+  if (!pathname.startsWith(prefix)) return pathname;
+  const withoutLocale = pathname.slice(prefix.length);
+  return withoutLocale || '/';
 }
 
 export function blogIdToSlugAnyLocale(id: string): string {
-	const parts = id.split('/');
-	if (parts.length > 1 && isLocale(parts[0])) return parts.slice(1).join('/');
-	return id;
+  const parts = id.split('/');
+  if (parts.length > 1 && isLocale(parts[0])) return parts.slice(1).join('/');
+  return id;
 }
 
 /** URL path for a locale's version of a page. For default locale home, returns / instead of /en/. */
-export function alternatePathForLocale(locale: Locale, subpath: string): string {
-	if (locale === DEFAULT_LOCALE && (subpath === '/' || subpath === '')) return '/';
-	return localePath(locale, subpath);
+export function alternatePathForLocale(locale: string, subpath: string): string {
+  if (locale === DEFAULT_LOCALE && (subpath === '/' || subpath === '')) return '/';
+  return localePath(locale, subpath);
 }

package/src/i18n/locales.mjs

@@ -1,3 +1,3 @@
+// Fallback locale defaults for direct package consumers without a starter-level i18n registry.
 export const SUPPORTED_LOCALES = ['en', 'ja', 'ko', 'es', 'zh'];
 export const DEFAULT_LOCALE = 'en';
-

package/src/i18n/messages.ts

@@ -1,4 +1,4 @@
-import type { Locale } from './config';
+import { DEFAULT_LOCALE, type Locale } from './config';
 
 export type Messages = {
   siteTitle: string;
@@ -70,7 +70,7 @@ export type Messages = {
   };
 };
 
-export const DEFAULT_MESSAGES: Record<Locale, Messages> = {
+export const DEFAULT_MESSAGES: Record<string, Messages> = {
   en: {
     siteTitle: 'Angle Feint',
     siteDescription: 'Cinematic web interfaces and AI-era engineering essays.',
@@ -420,5 +420,5 @@ export const DEFAULT_MESSAGES: Record<Locale, Messages> = {
 };
 
 export function getMessages(locale: Locale): Messages {
-  return DEFAULT_MESSAGES[locale];
+  return DEFAULT_MESSAGES[locale] ?? DEFAULT_MESSAGES[DEFAULT_LOCALE];
 }

package/src/scaffold/new-post.mjs

@@ -1,102 +1,111 @@
 import path from 'node:path';
 import { readdir } from 'node:fs/promises';
-import { hashString, normalizePathForFrontmatter, toTitleFromSlug, validatePostSlug } from './shared.mjs';
+import {
+  hashString,
+  normalizePathForFrontmatter,
+  toTitleFromSlug,
+  validatePostSlug,
+} from './shared.mjs';
 
 export function usageNewPost() {
-	return 'Usage: npm run new-post -- <slug> [--locales en,ja,ko,es,zh]';
+  return 'Usage: npm run new-post -- <slug> [--locales en,fr,...]';
 }
 
 export function parseNewPostArgs(argv) {
-	const args = argv.slice(2);
-	const positional = [];
-	let locales = '';
+  const args = argv.slice(2);
+  const positional = [];
+  let locales = '';
 
-	for (let i = 0; i < args.length; i += 1) {
-		const token = args[i];
-		if (token === '--locales') {
-			locales = args[i + 1] ?? '';
-			i += 1;
-			continue;
-		}
-		positional.push(token);
-	}
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (token === '--locales') {
+      locales = args[i + 1] ?? '';
+      i += 1;
+      continue;
+    }
+    positional.push(token);
+  }
 
-	return { slug: positional[0], locales };
+  return { slug: positional[0], locales };
 }
 
 export function resolveLocales({ cliLocales, envLocales, defaultLocales }) {
-	const raw = cliLocales || envLocales || '';
-	if (!raw) return [...defaultLocales];
+  const raw = cliLocales || envLocales || '';
+  if (!raw) return [...defaultLocales];
 
-	const parsed = raw
-		.split(',')
-		.map((locale) => locale.trim())
-		.filter(Boolean)
-		.map((locale) => locale.toLowerCase());
+  const parsed = raw
+    .split(',')
+    .map((locale) => locale.trim())
+    .filter(Boolean)
+    .map((locale) => locale.toLowerCase());
 
-	if (parsed.length === 0) {
-		throw new Error('Locales list is empty. Example: --locales en,ja,ko');
-	}
+  if (parsed.length === 0) {
+    throw new Error('Locales list is empty. Example: --locales en,fr');
+  }
 
-	const localePattern = /^[a-z]{2,3}(?:-[a-z0-9]+)?$/;
-	const invalid = parsed.find((locale) => !localePattern.test(locale));
-	if (invalid) {
-		throw new Error(`Invalid locale "${invalid}".`);
-	}
+  const localePattern = /^[a-z]{2,3}(?:-[a-z0-9]+)?$/;
+  const invalid = parsed.find((locale) => !localePattern.test(locale));
+  if (invalid) {
+    throw new Error(`Invalid locale "${invalid}".`);
+  }
 
-	return Array.from(new Set(parsed));
+  return Array.from(new Set(parsed));
 }
 
 export function buildNewPostTemplate(locale, slug, pubDate, heroImage) {
-	const titleByLocale = {
-		en: toTitleFromSlug(slug),
-		ja: '新しい記事タイトル',
-		ko: '새 글 제목',
-		es: 'Título del nuevo artículo',
-		zh: '新文章标题',
-	};
-	const descriptionByLocale = {
-		en: `A short EN post scaffold for "${slug}".`,
-		ja: `「${slug}」用の短い日本語記事テンプレートです。`,
-		ko: `"${slug}"용 한국어 글 템플릿입니다.`,
-		es: `Plantilla breve en español para "${slug}".`,
-		zh: `“${slug}”的中文文章模板。`,
-	};
-	const bodyByLocale = {
-		en: `Write your EN content for "${slug}" here.`,
-		ja: `ここに「${slug}」の日本語本文を書いてください。`,
-		ko: `여기에 "${slug}" 한국어 본문을 작성하세요.`,
-		es: `Escribe aquí el contenido en español para "${slug}".`,
-		zh: `请在这里填写“${slug}”的中文正文。`,
-	};
-	return `---
-title: '${titleByLocale[locale]}'
+  const titleByLocale = {
+    en: toTitleFromSlug(slug),
+    ja: '新しい記事タイトル',
+    ko: '새 글 제목',
+    es: 'Título del nuevo artículo',
+    zh: '新文章标题',
+  };
+  const descriptionByLocale = {
+    en: `A short EN post scaffold for "${slug}".`,
+    ja: `「${slug}」用の短い日本語記事テンプレートです。`,
+    ko: `"${slug}"용 한국어 글 템플릿입니다.`,
+    es: `Plantilla breve en español para "${slug}".`,
+    zh: `“${slug}”的中文文章模板。`,
+  };
+  const bodyByLocale = {
+    en: `Write your EN content for "${slug}" here.`,
+    ja: `ここに「${slug}」の日本語本文を書いてください。`,
+    ko: `여기에 "${slug}" 한국어 본문을 작성하세요.`,
+    es: `Escribe aquí el contenido en español para "${slug}".`,
+    zh: `请在这里填写“${slug}”的中文正文。`,
+  };
+  const resolvedTitle = titleByLocale[locale] ?? toTitleFromSlug(slug);
+  const resolvedDescription =
+    descriptionByLocale[locale] ?? `Localized post scaffold for "${slug}" (${locale}).`;
+  const resolvedBody = bodyByLocale[locale] ?? `Write your ${locale} content for "${slug}" here.`;
+  return `---
+title: '${resolvedTitle}'
 subtitle: ''
-description: '${descriptionByLocale[locale]}'
+description: '${resolvedDescription}'
 pubDate: '${pubDate}'
 ${heroImage ? `heroImage: '${heroImage}'` : ''}
 ---
 
-${bodyByLocale[locale]}
+${resolvedBody}
 `;
 }
 
 export async function loadDefaultCovers(defaultCoversRoot) {
-	try {
-		const entries = await readdir(defaultCoversRoot, { withFileTypes: true });
-		return entries
-			.filter((entry) => entry.isFile() && /\.(webp|png|jpe?g)$/i.test(entry.name))
-			.map((entry) => path.join(defaultCoversRoot, entry.name))
-			.sort((a, b) => a.localeCompare(b));
-	} catch {
-		return [];
-	}
+  try {
+    const entries = await readdir(defaultCoversRoot, { withFileTypes: true });
+    return entries
+      .filter((entry) => entry.isFile() && /\.(webp|png|jpe?g)$/i.test(entry.name))
+      .map((entry) => path.join(defaultCoversRoot, entry.name))
+      .sort((a, b) => a.localeCompare(b));
+  } catch {
+    return [];
+  }
 }
 
 export function pickDefaultCoverBySlug(slug, localeDir, defaultCovers) {
-	if (defaultCovers.length === 0) return '';
-	const coverPath = defaultCovers[hashString(slug) % defaultCovers.length];
-	return normalizePathForFrontmatter(path.relative(localeDir, coverPath));
+  if (defaultCovers.length === 0) return '';
+  const coverPath = defaultCovers[hashString(slug) % defaultCovers.length];
+  return normalizePathForFrontmatter(path.relative(localeDir, coverPath));
 }
 
 export { validatePostSlug };