@jjlmoya/utils-forensic-science 1.17.0 → 1.18.0

package/src/pages/[locale]/[utilities]/[categories]/[category]/[slug]/manifest.json.ts

@@ -0,0 +1,49 @@
+import type { APIRoute } from "astro";
+import { ALL_TOOLS, forensicCategory } from "../../../../../../index";
+import type { CategoryLocaleContent, ToolLocaleContent } from "../../../../../../types";
+import { LANGUAGE_CODES, type Language } from "../../../../../../i18n/languages";
+import { getCategoryNamespace, getUtilityNamespace, getUtilityPath } from "../../../../../../mfe/routes";
+import { createUtilityManifestResponse, type UtilityManifestInput } from "../../../../../../mfe/manifest";
+
+const loadCategories = async () => Object.fromEntries(await Promise.all(LANGUAGE_CODES.map(async (language) => [
+    language,
+    await forensicCategory.i18n[language]!(),
+]))) as Record<Language, CategoryLocaleContent>;
+
+const loadContents = async (entry: (typeof ALL_TOOLS)[number]["entry"]) => Object.fromEntries(await Promise.all(LANGUAGE_CODES.map(async (language) => {
+    const loader = entry.i18n[language] ?? entry.i18n.en;
+    if (!loader) throw new Error(`Missing ${language} locale for ${entry.id}`);
+    return [language, await loader()];
+}))) as Record<Language, ToolLocaleContent>;
+
+const createManifestPath = (locale: Exclude<Language, "es">, category: CategoryLocaleContent, content: ToolLocaleContent, englishContent: ToolLocaleContent) => ({
+    params: {
+        locale,
+        utilities: getUtilityNamespace(locale),
+        categories: getCategoryNamespace(locale),
+        category: category.slug,
+        slug: content.slug,
+    },
+    props: {
+        title: content.title,
+        description: content.description,
+        startUrl: getUtilityPath(locale, category.slug, content.slug),
+        englishSlug: englishContent.slug,
+    },
+});
+
+export async function getStaticPaths() {
+    const categories = await loadCategories();
+    const paths = [];
+    for (const { entry } of ALL_TOOLS) {
+        const contents = await loadContents(entry);
+        for (const locale of LANGUAGE_CODES.filter((candidate) => candidate !== "es")) {
+            const content = contents[locale];
+            const category = categories[locale];
+            paths.push(createManifestPath(locale, category, content, contents.en));
+        }
+    }
+    return paths;
+}
+
+export const GET: APIRoute = ({ props }) => createUtilityManifestResponse(props as unknown as UtilityManifestInput);

package/src/pages/[locale]/[utilities]/[categories]/[category]/[slug].astro

@@ -0,0 +1,100 @@
+---
+import ProductionUtilityPage from "../../../../../layouts/ProductionUtilityPage.astro";
+import { ALL_TOOLS, forensicCategory } from "../../../../../index";
+import { LANGUAGE_CODES, type Language } from "../../../../../i18n/languages";
+import type { CategoryLocaleContent, ToolLocaleContent } from "../../../../../types";
+import type { AstroComponentFactory } from "astro/runtime/server/index.js";
+import { getCategoryNamespace, getCategoryPath, getUtilityNamespace, getUtilityPath } from "../../../../../mfe/routes";
+import { getUtilityOgImage } from "../../../../../mfe/assets";
+
+type Loader<T> = () => Promise<{ default: T }>;
+type LoadedTool = ToolLocaleContent;
+
+export async function getStaticPaths() {
+    const paths = [];
+    for (const { entry, Component: componentLoader, SEOComponent: seoLoader, BibliographyComponent: bibliographyLoader } of ALL_TOOLS) {
+        const contents = Object.fromEntries(await Promise.all(LANGUAGE_CODES.map(async (language) => {
+            const loader = entry.i18n[language] ?? entry.i18n.en;
+            if (!loader) throw new Error(`Missing ${language} locale for ${entry.id}`);
+            return [language, await loader()];
+        }))) as Record<Language, LoadedTool>;
+        const categories = Object.fromEntries(await Promise.all(LANGUAGE_CODES.map(async (language) => [
+            language,
+            await forensicCategory.i18n[language]!(),
+        ]))) as Record<Language, CategoryLocaleContent>;
+        const { default: Component } = await (componentLoader as Loader<AstroComponentFactory>)();
+        const { default: SEOComponent } = await (seoLoader as Loader<AstroComponentFactory>)();
+        const { default: BibliographyComponent } = await (bibliographyLoader as Loader<AstroComponentFactory>)();
+        for (const locale of LANGUAGE_CODES.filter((candidate) => candidate !== "es")) {
+            const content = contents[locale];
+            const category = categories[locale];
+            paths.push({
+                params: {
+                    locale,
+                    utilities: getUtilityNamespace(locale),
+                    categories: getCategoryNamespace(locale),
+                    category: category.slug,
+                    slug: content.slug,
+                },
+                props: {
+                    locale,
+                    content,
+                    englishSlug: contents.en.slug,
+                    category,
+                    categorySlug: category.slug,
+                    Component,
+                    SEOComponent,
+                    BibliographyComponent,
+                    alternates: LANGUAGE_CODES.map((language) => ({
+                        language,
+                        url: getUtilityPath(language, categories[language].slug, contents[language].slug),
+                    })),
+                    image: getUtilityOgImage(contents.en.slug),
+                },
+            });
+        }
+    }
+    return paths;
+}
+
+const { locale, content, englishSlug, category, categorySlug, Component, SEOComponent, BibliographyComponent, relatedTools, alternates, image } = Astro.props as {
+    locale: Exclude<Language, "es">;
+    content: LoadedTool;
+    englishSlug: string;
+    category: CategoryLocaleContent;
+    categorySlug: string;
+    Component: AstroComponentFactory;
+    SEOComponent: AstroComponentFactory;
+    BibliographyComponent: AstroComponentFactory;
+    relatedTools?: { icon: string; title: string; description: string; href: string }[];
+    alternates: { language: Language; url: string }[];
+    image?: string;
+};
+const related = relatedTools ?? (await Promise.all(ALL_TOOLS.map(async ({ entry: relatedEntry }) => {
+    const loader = relatedEntry.i18n[locale] ?? relatedEntry.i18n.en;
+    if (!loader) return null;
+    const relatedContent = await loader();
+    if (relatedContent.slug === content.slug) return null;
+    return {
+        icon: relatedEntry.icons.fg,
+        title: relatedContent.title,
+        description: relatedContent.description,
+        href: getUtilityPath(locale, categorySlug, relatedContent.slug),
+    };
+}))).filter((tool): tool is { icon: string; title: string; description: string; href: string } => tool !== null);
+---
+
+<ProductionUtilityPage
+    {locale}
+    {content}
+    {englishSlug}
+    categoryTitle={category.title}
+    {categorySlug}
+    categoryHref={getCategoryPath(locale, categorySlug)}
+    relatedTools={related}
+    {Component}
+    {SEOComponent}
+    {BibliographyComponent}
+    {alternates}
+    {image}
+/> 

package/src/pages/[locale]/[utilities]/[categories]/[category].astro

@@ -0,0 +1,44 @@
+---
+import ProductionCategoryPage from "../../../../layouts/ProductionCategoryPage.astro";
+import { ALL_TOOLS, forensicCategory } from "../../../../index";
+import { LANGUAGE_CODES, type Language } from "../../../../i18n/languages";
+import { getCategoryNamespace, getCategoryPath, getUtilityNamespace, getUtilityPath } from "../../../../mfe/routes";
+import { CATEGORY_OG_IMAGE } from "../../../../mfe/assets";
+
+export async function getStaticPaths() {
+    const categories = Object.fromEntries(await Promise.all(
+        LANGUAGE_CODES.map(async (language) => [language, await forensicCategory.i18n[language]!()]),
+    ));
+    return LANGUAGE_CODES.filter((language) => language !== "es").map((locale) => {
+        const category = categories[locale]!;
+        const alternates = LANGUAGE_CODES.map((language) => ({
+            language,
+            url: getCategoryPath(language, categories[language]!.slug),
+        }));
+        return {
+            params: { locale, utilities: getUtilityNamespace(locale), categories: getCategoryNamespace(locale), category: category.slug },
+            props: { locale, category, alternates },
+        };
+    });
+}
+
+const { locale, category, alternates } = Astro.props as {
+    locale: Exclude<Language, "es">;
+    category: Awaited<ReturnType<NonNullable<(typeof forensicCategory.i18n)[Language]>>>;
+    alternates: { language: Language; url: string }[];
+};
+const tools = await Promise.all(ALL_TOOLS.map(async ({ entry }) => {
+    const loader = entry.i18n[locale] ?? entry.i18n.en;
+    if (!loader) throw new Error(`Missing ${locale} locale for ${entry.id}`);
+    const content = await loader();
+    return {
+        id: entry.id,
+        icon: entry.icons.fg,
+        title: content.title,
+        description: content.description,
+        href: getUtilityPath(locale, category.slug, content.slug),
+    };
+}));
+---
+
+<ProductionCategoryPage locale={locale} {category} {tools} {alternates} image={CATEGORY_OG_IMAGE} />

package/src/pages/index.astro

@@ -1,3 +1,3 @@
----
 ---
-<meta http-equiv="refresh" content="0;url=/en" />
+---
+<meta http-equiv="refresh" content="0;url=/utilidades/categorias/ciencia-forense/" />

package/src/pages/utilidades/[slug]/manifest.json.ts

@@ -0,0 +1,28 @@
+import type { APIRoute } from "astro";
+import { ALL_TOOLS, forensicCategory } from "../../../index";
+import type { ToolLocaleContent } from "../../../types";
+import { getUtilityPath } from "../../../mfe/routes";
+import { createUtilityManifestResponse, type UtilityManifestInput } from "../../../mfe/manifest";
+
+export async function getStaticPaths() {
+    const category = await forensicCategory.i18n.es!();
+    const paths = [];
+    for (const { entry } of ALL_TOOLS) {
+        const loader = entry.i18n.es ?? entry.i18n.en;
+        if (!loader) continue;
+        const content = await loader() as ToolLocaleContent;
+        const englishContent = await (entry.i18n.en ?? loader)() as ToolLocaleContent;
+        paths.push({
+            params: { slug: content.slug },
+            props: {
+                title: content.title,
+                description: content.description,
+                startUrl: getUtilityPath("es", category.slug, content.slug),
+                englishSlug: englishContent.slug,
+            },
+        });
+    }
+    return paths;
+}
+
+export const GET: APIRoute = ({ props }) => createUtilityManifestResponse(props as unknown as UtilityManifestInput);

package/src/pages/utilidades/[slug].astro

@@ -0,0 +1,90 @@
+---
+import ProductionUtilityPage from "../../layouts/ProductionUtilityPage.astro";
+import { ALL_TOOLS, forensicCategory } from "../../index";
+import { LANGUAGE_CODES, type Language } from "../../i18n/languages";
+import type { CategoryLocaleContent, ToolLocaleContent } from "../../types";
+import type { AstroComponentFactory } from "astro/runtime/server/index.js";
+import { getCategoryPath, getUtilityPath } from "../../mfe/routes";
+import { getUtilityOgImage } from "../../mfe/assets";
+
+type Loader<T> = () => Promise<{ default: T }>;
+type LoadedTool = ToolLocaleContent;
+
+export async function getStaticPaths() {
+    const category = await forensicCategory.i18n.es!();
+    const categories = Object.fromEntries(await Promise.all(LANGUAGE_CODES.map(async (language) => [
+        language,
+        await forensicCategory.i18n[language]!(),
+    ]))) as Record<Language, CategoryLocaleContent>;
+    const paths = [];
+    for (const { entry, Component: componentLoader, SEOComponent: seoLoader, BibliographyComponent: bibliographyLoader } of ALL_TOOLS) {
+        const contents = Object.fromEntries(await Promise.all(LANGUAGE_CODES.map(async (language) => {
+            const loader = entry.i18n[language] ?? entry.i18n.en;
+            if (!loader) throw new Error(`Missing ${language} locale for ${entry.id}`);
+            return [language, await loader()];
+        }))) as Record<Language, LoadedTool>;
+        const { default: Component } = await (componentLoader as Loader<AstroComponentFactory>)();
+        const { default: SEOComponent } = await (seoLoader as Loader<AstroComponentFactory>)();
+        const { default: BibliographyComponent } = await (bibliographyLoader as Loader<AstroComponentFactory>)();
+        paths.push({
+            params: { slug: contents.es.slug },
+            props: {
+                locale: "es",
+                content: contents.es,
+                englishSlug: contents.en.slug,
+                category,
+                categorySlug: category.slug,
+                Component,
+                SEOComponent,
+                BibliographyComponent,
+                alternates: LANGUAGE_CODES.map((language) => ({
+                    language,
+                    url: getUtilityPath(language, categories[language].slug, contents[language].slug),
+                })),
+                image: getUtilityOgImage(contents.en.slug),
+            },
+        });
+    }
+    return paths;
+}
+
+const { locale, content, englishSlug, category, categorySlug, Component, SEOComponent, BibliographyComponent, alternates, image } = Astro.props as {
+    locale: "es";
+    content: LoadedTool;
+    englishSlug: string;
+    category: CategoryLocaleContent;
+    categorySlug: string;
+    Component: AstroComponentFactory;
+    SEOComponent: AstroComponentFactory;
+    BibliographyComponent: AstroComponentFactory;
+    alternates: { language: Language; url: string }[];
+    image?: string;
+};
+const relatedTools = (await Promise.all(ALL_TOOLS.map(async ({ entry: relatedEntry }) => {
+    const loader = relatedEntry.i18n.es ?? relatedEntry.i18n.en;
+    if (!loader) return null;
+    const relatedContent = await loader();
+    if (relatedContent.slug === content.slug) return null;
+    return {
+        icon: relatedEntry.icons.fg,
+        title: relatedContent.title,
+        description: relatedContent.description,
+        href: getUtilityPath("es", categorySlug, relatedContent.slug),
+    };
+}))).filter((tool): tool is { icon: string; title: string; description: string; href: string } => tool !== null);
+---
+
+<ProductionUtilityPage
+    {locale}
+    {content}
+    {englishSlug}
+    categoryTitle={category.title}
+    {categorySlug}
+    categoryHref={getCategoryPath(locale, categorySlug)}
+    {relatedTools}
+    {Component}
+    {SEOComponent}
+    {BibliographyComponent}
+    {alternates}
+    {image}
+/> 

package/src/pages/utilidades/categorias/[category].astro

@@ -0,0 +1,38 @@
+---
+import ProductionCategoryPage from "../../../layouts/ProductionCategoryPage.astro";
+import { ALL_TOOLS, forensicCategory } from "../../../index";
+import { LANGUAGE_CODES, type Language } from "../../../i18n/languages";
+import { getCategoryPath, getUtilityPath } from "../../../mfe/routes";
+import { CATEGORY_OG_IMAGE } from "../../../mfe/assets";
+
+export async function getStaticPaths() {
+    const categories = Object.fromEntries(await Promise.all(
+        LANGUAGE_CODES.map(async (language) => [language, await forensicCategory.i18n[language]!()]),
+    ));
+    const category = categories.es!;
+    const alternates = LANGUAGE_CODES.map((language) => ({
+        language,
+        url: getCategoryPath(language, categories[language]!.slug),
+    }));
+    return [{ params: { category: category.slug }, props: { category, alternates } }];
+}
+
+const { category, alternates } = Astro.props as {
+    category: Awaited<ReturnType<NonNullable<(typeof forensicCategory.i18n)[Language]>>>;
+    alternates: { language: Language; url: string }[];
+};
+const tools = await Promise.all(ALL_TOOLS.map(async ({ entry }) => {
+    const loader = entry.i18n.es ?? entry.i18n.en;
+    if (!loader) throw new Error(`Missing Spanish locale for ${entry.id}`);
+    const content = await loader();
+    return {
+        id: entry.id,
+        icon: entry.icons.fg,
+        title: content.title,
+        description: content.description,
+        href: getUtilityPath("es", category.slug, content.slug),
+    };
+}));
+---
+
+<ProductionCategoryPage locale="es" {category} {tools} {alternates} image={CATEGORY_OG_IMAGE} />

package/src/tests/mfe_cache_contract.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { getCacheControl, LONG_LIVED_ASSET_CACHE } from "../worker";
+
+describe("MFE cache contract", () => {
+    it("caches versioned assets and manifests for one year", () => {
+        expect(getCacheControl("/_utilities/forensic-science/images/tool.webp")).toBe(LONG_LIVED_ASSET_CACHE);
+        expect(getCacheControl("/_utilities/forensic-science/styles/tool.css")).toBe(LONG_LIVED_ASSET_CACHE);
+        expect(getCacheControl("/en/utilities/categories/forensic-science/tool/manifest.json")).toBe(LONG_LIVED_ASSET_CACHE);
+    });
+
+});

package/src/tests/mfe_manifest.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { createUtilityManifestResponse } from "../mfe/manifest";
+
+describe("MFE utility manifest", () => {
+    it("returns a versioned installable manifest for the current utility", async () => {
+        const response = createUtilityManifestResponse({
+            title: "Card draw odds calculator",
+            description: "Calculate card draw probabilities.",
+            startUrl: "/en/utilities/categories/forensic-science/card-draw-odds-calculator/",
+            englishSlug: "card-draw-odds-calculator",
+        });
+        const manifest = await response.json() as {
+            name: string;
+            start_url: string;
+            scope: string;
+            icons: { src: string; sizes: string; type: string; purpose: string }[];
+        };
+
+        expect(response.headers.get("Content-Type")).toContain("application/manifest+json");
+        expect(response.headers.get("Cache-Control")).toContain("immutable");
+        expect(manifest.name).toBe("Card draw odds calculator");
+        expect(manifest.start_url).toBe(manifest.scope);
+        expect(manifest.icons[0]?.src).toContain("/_utilities/forensic-science/images/card-draw-odds-calculator.webp?version=");
+        expect(manifest.icons[0]?.sizes).toBe("512x512");
+        expect(manifest.icons[0]?.type).toBe("image/webp");
+        expect(manifest.icons[0]?.purpose).toBe("any");
+    });
+});

package/src/tests/registry_contract.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+import { ALL_ENTRIES } from '../entries';
+import { ALL_TOOLS } from '../tools';
+import type { ToolDefinition } from '../types';
+
+function isToolDefinition(value: unknown): value is ToolDefinition {
+  if (!value || typeof value !== 'object') return false;
+
+  const candidate = value as Record<string, unknown>;
+  return Boolean(
+    candidate.entry &&
+      typeof candidate.entry === 'object' &&
+      typeof candidate.Component === 'function' &&
+      typeof candidate.SEOComponent === 'function' &&
+      typeof candidate.BibliographyComponent === 'function',
+  );
+}
+
+const toolRoot = join(process.cwd(), 'src', 'tool');
+const toolDirectories = readdirSync(toolRoot, { withFileTypes: true })
+  .filter((entry) => entry.isDirectory() && existsSync(join(toolRoot, entry.name, 'index.ts')))
+  .map((entry) => entry.name)
+  .sort();
+
+describe('Library registry contract', () => {
+  it('keeps ALL_ENTRIES and ALL_TOOLS synchronized by id', () => {
+    const entryIds = ALL_ENTRIES.map((entry) => entry.id);
+    const toolIds = ALL_TOOLS.map((tool) => tool.entry.id);
+
+    expect(new Set(entryIds).size).toBe(entryIds.length);
+    expect(new Set(toolIds).size).toBe(toolIds.length);
+    expect([...toolIds].sort()).toEqual([...entryIds].sort());
+  });
+
+  it('registers every tool runtime index in both public registries', async () => {
+    const failures: string[] = [];
+
+    for (const directory of toolDirectories) {
+      const runtimeModule = await import(
+        pathToFileURL(join(toolRoot, directory, 'index.ts')).href,
+      );
+      const definitions = [...new Set(Object.values(runtimeModule).filter(isToolDefinition))];
+
+      if (definitions.length !== 1) {
+        failures.push(`${directory}: expected exactly one ToolDefinition export, found ${definitions.length}`);
+        continue;
+      }
+
+      const [definition] = definitions;
+      if (!definition) {
+        failures.push(`${directory}: runtime definition is undefined`);
+        continue;
+      }
+      if (!ALL_TOOLS.some((tool) => tool.entry.id === definition.entry.id)) {
+        failures.push(`${directory}: runtime definition is missing from ALL_TOOLS`);
+      }
+      if (!ALL_ENTRIES.some((entry) => entry.id === definition.entry.id)) {
+        failures.push(`${directory}: runtime entry is missing from ALL_ENTRIES`);
+      }
+    }
+
+    expect(failures).toEqual([]);
+  });
+});

package/src/tests/script_density.test.ts

@@ -1,94 +1,94 @@
-import { describe, expect, it } from 'vitest';
-import { ALL_TOOLS } from '../tools';
-
-type ScriptLocale = keyof typeof SCRIPT_RULES;
-
-const SCRIPT_RULES = {
-  ja: {
-    language: 'Japanese',
-    scriptName: 'kana/kanji',
-    scriptCharacters: /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/gu,
-    minScriptRatio: 0.45,
-  },
-  ko: {
-    language: 'Korean',
-    scriptName: 'hangul',
-    scriptCharacters: /\p{Script=Hangul}/gu,
-    minScriptRatio: 0.55,
-  },
-  ru: {
-    language: 'Russian',
-    scriptName: 'cyrillic',
-    scriptCharacters: /\p{Script=Cyrillic}/gu,
-    minScriptRatio: 0.65,
-  },
-  zh: {
-    language: 'Chinese',
-    scriptName: 'han',
-    scriptCharacters: /\p{Script=Han}/gu,
-    minScriptRatio: 0.45,
-  },
-} as const;
-
-const LETTERS = /\p{L}/gu;
-const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
-
-function collectStrings(value: unknown): string[] {
-  if (typeof value === 'string') return [value];
-  if (!value || typeof value !== 'object') return [];
-  if (Array.isArray(value)) return value.flatMap(collectStrings);
-  return Object.values(value).flatMap(collectStrings);
-}
-
-function normalizeText(value: unknown): string {
-  return collectStrings(value).join(' ').normalize('NFC');
-}
-
-function translatableContent(content: Record<string, unknown>) {
-  return TRANSLATABLE_KEYS.map((key) => content[key]);
-}
-
-function letterCount(text: string): number {
-  return text.match(LETTERS)?.length ?? 0;
-}
-
-function scriptCount(text: string, locale: ScriptLocale): number {
-  return text.match(SCRIPT_RULES[locale].scriptCharacters)?.length ?? 0;
-}
-
-function scriptRatio(text: string, locale: ScriptLocale): number {
-  const letters = letterCount(text);
-  if (letters === 0) return 0;
-  return scriptCount(text, locale) / letters;
-}
-
-describe('Native script density validation', () => {
-  ALL_TOOLS.forEach((tool) => {
-    describe(`Tool: ${tool.entry.id}`, () => {
-      Object.keys(SCRIPT_RULES).forEach((locale) => {
-        it(`${locale} keeps most translated text in its native script`, async () => {
-          const typedLocale = locale as ScriptLocale;
-          const loader = tool.entry.i18n[typedLocale];
-          if (!loader) return;
-
-          const content = await loader();
-          const rule = SCRIPT_RULES[typedLocale];
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+type ScriptLocale = keyof typeof SCRIPT_RULES;
+
+const SCRIPT_RULES = {
+  ja: {
+    language: 'Japanese',
+    scriptName: 'kana/kanji',
+    scriptCharacters: /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/gu,
+    minScriptRatio: 0.45,
+  },
+  ko: {
+    language: 'Korean',
+    scriptName: 'hangul',
+    scriptCharacters: /\p{Script=Hangul}/gu,
+    minScriptRatio: 0.55,
+  },
+  ru: {
+    language: 'Russian',
+    scriptName: 'cyrillic',
+    scriptCharacters: /\p{Script=Cyrillic}/gu,
+    minScriptRatio: 0.65,
+  },
+  zh: {
+    language: 'Chinese',
+    scriptName: 'han',
+    scriptCharacters: /\p{Script=Han}/gu,
+    minScriptRatio: 0.45,
+  },
+} as const;
+
+const LETTERS = /\p{L}/gu;
+const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
+
+function collectStrings(value: unknown): string[] {
+  if (typeof value === 'string') return [value];
+  if (!value || typeof value !== 'object') return [];
+  if (Array.isArray(value)) return value.flatMap(collectStrings);
+  return Object.values(value).flatMap(collectStrings);
+}
+
+function normalizeText(value: unknown): string {
+  return collectStrings(value).join(' ').normalize('NFC');
+}
+
+function translatableContent(content: Record<string, unknown>) {
+  return TRANSLATABLE_KEYS.map((key) => content[key]);
+}
+
+function letterCount(text: string): number {
+  return text.match(LETTERS)?.length ?? 0;
+}
+
+function scriptCount(text: string, locale: ScriptLocale): number {
+  return text.match(SCRIPT_RULES[locale].scriptCharacters)?.length ?? 0;
+}
+
+function scriptRatio(text: string, locale: ScriptLocale): number {
+  const letters = letterCount(text);
+  if (letters === 0) return 0;
+  return scriptCount(text, locale) / letters;
+}
+
+describe('Native script density validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(SCRIPT_RULES).forEach((locale) => {
+        it(`${locale} keeps most translated text in its native script`, async () => {
+          const typedLocale = locale as ScriptLocale;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const content = await loader();
+          const rule = SCRIPT_RULES[typedLocale];
           const text = normalizeText(translatableContent(content as unknown as Record<string, unknown>));
-          const letters = letterCount(text);
-          const matches = scriptCount(text, typedLocale);
-          const ratio = scriptRatio(text, typedLocale);
-
-          expect(
-            ratio,
-            [
-              `Possible broken translation detected in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
-              `The text has ${matches} ${rule.scriptName} characters out of ${letters} analyzed letters (${(ratio * 100).toFixed(1)}%).`,
-              `Most translatable content should be written in ${rule.scriptName} script.`,
-              'Non-translatable fields such as slug, bibliography, and schemas are ignored to avoid false positives.',
-            ].join(' '),
-          ).toBeGreaterThanOrEqual(rule.minScriptRatio);
-        });
-      });
-    });
-  });
-});
+          const letters = letterCount(text);
+          const matches = scriptCount(text, typedLocale);
+          const ratio = scriptRatio(text, typedLocale);
+
+          expect(
+            ratio,
+            [
+              `Possible broken translation detected in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `The text has ${matches} ${rule.scriptName} characters out of ${letters} analyzed letters (${(ratio * 100).toFixed(1)}%).`,
+              `Most translatable content should be written in ${rule.scriptName} script.`,
+              'Non-translatable fields such as slug, bibliography, and schemas are ignored to avoid false positives.',
+            ].join(' '),
+          ).toBeGreaterThanOrEqual(rule.minScriptRatio);
+        });
+      });
+    });
+  });
+});