@jjlmoya/utils-diy 1.11.0 → 1.13.0

package/src/tool/workshopFractionConverter/engine.ts

@@ -0,0 +1,223 @@
+export interface FractionInput {
+  whole: number;
+  numerator: number;
+  denominator: number;
+}
+
+export interface ConversionResult {
+  fraction: FractionInput;
+  inches: number;
+  millimeters: number;
+  closestFastener: FastenerMatch | null;
+  closestSocket: SocketMatch | null;
+}
+
+export interface FastenerMatch {
+  name: string;
+  size_mm: number;
+  size_inch: string;
+  difference_mm: number;
+  difference_pct: number;
+}
+
+export interface SocketMatch {
+  name: string;
+  size_mm: number;
+  size_inch: string;
+  difference_mm: number;
+  difference_pct: number;
+}
+
+export interface ReverseSearchResult {
+  input_mm: number;
+  closest_fraction: FractionInput;
+  inches: number;
+  closestFastener: FastenerMatch | null;
+  closestSocket: SocketMatch | null;
+}
+
+const STANDARD_FASTENERS = [
+  { name: '#0', inch: '1/80', mm: 0.318 },
+  { name: '#1', inch: '1/73', mm: 0.346 },
+  { name: '#2', inch: '3/32', mm: 2.362 },
+  { name: '#3', inch: '7/64', mm: 2.778 },
+  { name: '#4', inch: '7/64', mm: 2.819 },
+  { name: '#5', inch: '1/8', mm: 3.175 },
+  { name: '#6', inch: '9/64', mm: 3.556 },
+  { name: '#8', inch: '5/32', mm: 4.191 },
+  { name: '#10', inch: '3/16', mm: 4.826 },
+  { name: '#12', inch: '7/32', mm: 5.461 },
+  { name: '1/4"', inch: '1/4', mm: 6.35 },
+  { name: '5/16"', inch: '5/16', mm: 7.938 },
+  { name: '3/8"', inch: '3/8', mm: 9.525 },
+  { name: '7/16"', inch: '7/16', mm: 11.113 },
+  { name: '1/2"', inch: '1/2', mm: 12.7 },
+  { name: '9/16"', inch: '9/16', mm: 14.288 },
+  { name: '5/8"', inch: '5/8', mm: 15.875 },
+  { name: '3/4"', inch: '3/4', mm: 19.05 },
+  { name: '7/8"', inch: '7/8', mm: 22.225 },
+  { name: '1"', inch: '1', mm: 25.4 },
+];
+
+const STANDARD_SOCKETS = [
+  { name: '4mm', mm: 4.0, inch: '5/32' },
+  { name: '4.5mm', mm: 4.5, inch: '3/16' },
+  { name: '5mm', mm: 5.0, inch: '13/64' },
+  { name: '5.5mm', mm: 5.5, inch: '7/32' },
+  { name: '6mm', mm: 6.0, inch: '15/64' },
+  { name: '7mm', mm: 7.0, inch: '9/32' },
+  { name: '8mm', mm: 8.0, inch: '5/16' },
+  { name: '9mm', mm: 9.0, inch: '23/64' },
+  { name: '10mm', mm: 10.0, inch: '3/8' },
+  { name: '11mm', mm: 11.0, inch: '7/16' },
+  { name: '12mm', mm: 12.0, inch: '15/32' },
+  { name: '13mm', mm: 13.0, inch: '1/2' },
+  { name: '14mm', mm: 14.0, inch: '9/16' },
+  { name: '15mm', mm: 15.0, inch: '19/32' },
+  { name: '16mm', mm: 16.0, inch: '5/8' },
+  { name: '17mm', mm: 17.0, inch: '11/16' },
+  { name: '18mm', mm: 18.0, inch: '23/32' },
+  { name: '19mm', mm: 19.0, inch: '3/4' },
+  { name: '20mm', mm: 20.0, inch: '13/16' },
+  { name: '1/4" socket', mm: 6.35, inch: '1/4' },
+  { name: '5/16" socket', mm: 7.938, inch: '5/16' },
+  { name: '3/8" socket', mm: 9.525, inch: '3/8' },
+  { name: '7/16" socket', mm: 11.113, inch: '7/16' },
+  { name: '1/2" socket', mm: 12.7, inch: '1/2' },
+  { name: '9/16" socket', mm: 14.288, inch: '9/16' },
+  { name: '5/8" socket', mm: 15.875, inch: '5/8' },
+  { name: '11/16" socket', mm: 17.463, inch: '11/16' },
+  { name: '3/4" socket', mm: 19.05, inch: '3/4' },
+];
+
+export function fractionToInches(input: FractionInput): number {
+  if (input.denominator === 0) return 0;
+  return input.whole + input.numerator / input.denominator;
+}
+
+export function inchesToMillimeters(inches: number): number {
+  return inches * 25.4;
+}
+
+export function convertFraction(input: FractionInput): ConversionResult {
+  const inches = fractionToInches(input);
+  const mm = inchesToMillimeters(inches);
+  const closestFastener = findClosestFastener(mm);
+  const closestSocket = findClosestSocket(mm);
+
+  return {
+    fraction: input,
+    inches,
+    millimeters: mm,
+    closestFastener,
+    closestSocket,
+  };
+}
+
+export function reverseSearch(millimeters: number): ReverseSearchResult {
+  const inches = millimeters / 25.4;
+  const fraction = mmToFraction(millimeters);
+  const closestFastener = findClosestFastener(millimeters);
+  const closestSocket = findClosestSocket(millimeters);
+
+  return {
+    input_mm: millimeters,
+    closest_fraction: fraction,
+    inches,
+    closestFastener,
+    closestSocket,
+  };
+}
+
+export function findClosestFastener(mm: number): FastenerMatch | null {
+  if (STANDARD_FASTENERS.length === 0) return null;
+
+  let closest = STANDARD_FASTENERS[0];
+  let minDiff = Math.abs(closest.mm - mm);
+
+  for (const fastener of STANDARD_FASTENERS) {
+    const diff = Math.abs(fastener.mm - mm);
+    if (diff < minDiff) {
+      minDiff = diff;
+      closest = fastener;
+    }
+  }
+
+  const pct = (minDiff / mm) * 100;
+  return {
+    name: closest.name,
+    size_mm: closest.mm,
+    size_inch: closest.inch,
+    difference_mm: closest.mm - mm,
+    difference_pct: pct,
+  };
+}
+
+export function findClosestSocket(mm: number): SocketMatch | null {
+  if (STANDARD_SOCKETS.length === 0) return null;
+
+  let closest = STANDARD_SOCKETS[0];
+  let minDiff = Math.abs(closest.mm - mm);
+
+  for (const socket of STANDARD_SOCKETS) {
+    const diff = Math.abs(socket.mm - mm);
+    if (diff < minDiff) {
+      minDiff = diff;
+      closest = socket;
+    }
+  }
+
+  const pct = (minDiff / mm) * 100;
+  return {
+    name: closest.name,
+    size_mm: closest.mm,
+    size_inch: closest.inch,
+    difference_mm: closest.mm - mm,
+    difference_pct: pct,
+  };
+}
+
+export function mmToFraction(mm: number): FractionInput {
+  const inches = mm / 25.4;
+  const whole = Math.floor(inches);
+  const fractional = inches - whole;
+
+  const denominators = [2, 4, 8, 16, 32, 64];
+  let bestNum = 0;
+  let bestDenom = 1;
+  let bestError = Math.abs(fractional);
+
+  for (const denom of denominators) {
+    const num = Math.round(fractional * denom);
+    const error = Math.abs(fractional - num / denom);
+    if (error < bestError) {
+      bestError = error;
+      bestNum = num;
+      bestDenom = denom;
+    }
+  }
+
+  if (bestNum === bestDenom) {
+    return { whole: whole + 1, numerator: 0, denominator: 1 };
+  }
+
+  return {
+    whole,
+    numerator: bestNum,
+    denominator: bestDenom,
+  };
+}
+
+export function formatFraction(input: FractionInput): string {
+  if (input.denominator === 0 || (input.numerator === 0 && input.denominator === 1)) {
+    return `${input.whole}"`;
+  }
+  if (input.whole === 0) {
+    return `${input.numerator}/${input.denominator}"`;
+  }
+  return `${input.whole} ${input.numerator}/${input.denominator}"`;
+}
+
+export function formatMillimeters(mm: number, precision: number = 2): string {
+  return `${mm.toFixed(precision)} mm`;
+}

package/src/tool/workshopFractionConverter/entry.ts

@@ -0,0 +1,24 @@
+import type { DiyToolEntry } from '../../types';
+import type { WorkshopFractionConverterUI } from './ui';
+
+export const workshopFractionConverter: DiyToolEntry<WorkshopFractionConverterUI> = {
+  id: 'workshop-fraction-converter',
+  icons: { bg: 'mdi:tools', fg: 'mdi:ruler' },
+  i18n: {
+    de: () => import('./i18n/de').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};

package/src/tool/workshopFractionConverter/i18n/de.ts

@@ -0,0 +1,147 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { WorkshopFractionConverterUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'werkstatt-bruch-metrisch-umrechner';
+const title = 'Werkstatt Umrechner: Brüche in Millimeter';
+const description = 'Rechnen Sie Zoll-Brüche sofort in Millimeter um. Finden Sie die passenden Standard-Schrauben, Bolzen und Steckschlüssel für Ihre Werkstatt. Optimiert für schmutzige Hände und Arbeitshandschuhe.';
+
+const faqData = [
+  {
+    question: 'Warum muss ich Brüche in Millimeter umrechnen?',
+    answer: 'Die meisten modernen Werkzeuge und Befestigungselemente verwenden das metrische System, aber viele Oldtimer-Werkzeuge und Spezifikationen nutzen noch Zoll-Brüche. Dieser Umrechner schließt diese Lücke und hilft Ihnen, das metrische Äquivalent oder die nächste Standardgröße zu finden.',
+  },
+  {
+    question: 'Was ist der Unterschied zwischen 1/2 Zoll und 12,7 mm?',
+    answer: '1/2 Zoll entspricht exakt 12,7 Millimetern (0,5 × 25,4 = 12,7). Metrische und imperiale Werkzeuge sind bei Standardgrößen oft austauschbar, da die Hersteller gängige Größen in beiden Systemen angleichen.',
+  },
+  {
+    question: 'Warum zeigt das Tool die "nächste Standardgröße" an?',
+    answer: 'Weil exakte Umrechnungen oft zwischen den gängigen Standardgrößen liegen. Das Tool findet den im Handel erhältlichen Bolzen oder Steckschlüssel, der Ihrem Maß am nächsten kommt, damit Sie das verwenden können, was in Ihrer Werkstatt verfügbar ist.',
+  },
+  {
+    question: 'Was ist der Unterschied zwischen Holz- und Metallpräzision?',
+    answer: 'Bei Holzarbeiten sind Abweichungen von 0,5 mm oft vernachlässigbar. In der Metallbearbeitung und im Maschinenbau zählt jedes 0,1 mm. Der Präzisionsmodus gibt Hinweise auf akzeptable Toleranzbereiche für Ihr Material.',
+  },
+  {
+    question: 'Kann ich dieses Tool offline verwenden?',
+    answer: 'Ja. Alle Berechnungen finden in Ihrem Browser statt. Nach dem ersten Laden funktioniert das Tool komplett offline – perfekt für den Einsatz in der Werkstatt ohne WLAN.',
+  },
+  {
+    question: 'Warum enthält das Tool einen Verlauf?',
+    answer: 'Bei der Demontage oder Projekten mit vielen Teilen ermöglicht der Verlauf das Nachschlagen von Maßen, ohne sie erneut eingeben zu müssen, und hilft beim Erstellen einer Teileliste während der Arbeit.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Messart wählen',
+    text: 'Wählen Sie "Vorwärts", um einen Bruch in Millimeter umzurechnen, oder "Rückwärts", um den passenden Bruch für ein mit dem Messschieber genommenes Maß zu finden.',
+  },
+  {
+    name: 'Maß eingeben',
+    text: 'Nutzen Sie die dreispaltige Eingabe (Ganzzahl, Zähler, Nenner) oder tippen Sie auf eine Schnellauswahl. Mit den Schritt-Tasten können Sie Werte ohne Tippen anpassen.',
+  },
+  {
+    name: 'Ergebnisse prüfen',
+    text: 'Das Ergebnis zeigt die exakte Umrechnung sowie die nächsten Standardgrößen für Bolzen und Steckschlüssel. Eine visuelle Skala hilft bei der Einschätzung der Proportionen.',
+  },
+  {
+    name: 'Im Verlauf speichern',
+    text: 'Klicken Sie auf "Im Verlauf speichern", um Maße für später zu merken. Der Verlauf bleibt in Ihrem Browser gespeichert, auch wenn Sie ihn schließen.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'de',
+};
+
+export const content: ToolLocaleContent<WorkshopFractionConverterUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Häufig gestellte Fragen',
+  faq: faqData,
+  bibliography,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    { type: 'title', text: 'Warum Präzision bei der Bruchumrechnung in der Werkstatt entscheidend ist', level: 2 },
+    { type: 'paragraph', html: 'In einer professionellen Werkstatt oder beim anspruchsvollen Heimwerken führt ein "ungefähr" oft zu überdrehten Bolzen, wackeligen Verbindungen oder fehlerhaften Konstruktionen. Dieses Tool schließt die Lücke zwischen traditionellen Zoll-Maßen und der Präzision des metrischen Systems und stellt sicher, dass Ihre Projekte Profi-Standards entsprechen.' },
+    { type: 'title', text: 'Die Standard-Umrechnung: 1/2" vs. 12,7 mm', level: 3 },
+    { type: 'card', icon: 'mdi:ruler-square', title: 'Sind metrische und imperiale Maße austauschbar?', html: '<p>Viele nehmen das an. Obwohl 1/2" exakt 12,7 mm entspricht, ist der nächste metrische Steckschlüssel 13 mm groß. Die Verwendung des falschen Werkzeugs kann Schraubenköpfe runddrehen. Unser Umrechner findet die <strong>nächste Standard-Werkzeuggröße</strong>, damit Sie Ihre Hardware niemals beschädigen.</p>' },
+    { type: 'title', text: 'Toleranzen im Holzbau vs. Metallbau', level: 3 },
+    { type: 'paragraph', html: 'Die Anforderungen an die Toleranz variieren je nach Handwerk stark. Im <strong>Holzbau</strong> ist eine Toleranz von 1/64" (0,4 mm) meist akzeptabel. Im <strong>Metallbau und Maschinenbau</strong> zählt jedes 0,1 mm oder sogar 0,01 mm. Unser Tool bietet einen Präzisionsmodus, der Ihnen hilft, die sicherste Standardgröße für Ihr spezifisches Material zu wählen.' },
+    { type: 'title', text: '3 Tipps für präzise Messungen', level: 3 },
+    { type: 'paragraph', html: '<strong>1. Messschieber verwenden:</strong> Nutzen Sie für die Rückwärtssuche immer einen digitalen Messschieber für genaueste Millimeter-Werte. <strong>2. Verschleiß prüfen:</strong> Alte Steckschlüssel und Bolzen können abgenutzte Kanten haben, was die "nächste Übereinstimmung" noch wichtiger macht. <strong>3. Gewindesteigung beachten:</strong> Denken Sie daran: Auch wenn die Kopfgröße passt, ist die Gewindesteigung (metrisch vs. Zoll) immer unterschiedlich.' },
+  ],
+  ui: {
+    labelFraction: 'Messart',
+    labelWhole: 'Ganze Zahl',
+    labelNumerator: 'Zähler',
+    labelDenominator: 'Nenner',
+    labelInches: 'Zoll',
+    labelMillimeters: 'Millimeter',
+    resultTitle: 'Umrechnungsergebnis',
+    resultFraction: 'Bruch',
+    resultInches: 'Zoll',
+    resultMillimeters: 'Millimeter',
+    matchTitle: 'Nächste Standardgröße',
+    matchClosestFastener: 'Standard-Bolzen oder Schraube',
+    matchClosestSocket: 'Standard-Steckschlüssel',
+    matchDifference: 'Abweichung zum Messwert',
+    matchRecommendation: 'Diese Größe verwenden, falls vorhanden',
+    reverseSearchTitle: 'Rückwärtssuche',
+    reverseSearchLabel: 'Gemessenes Maß (mm)',
+    reverseSearchButton: 'Bruch finden',
+    reverseSearchHint: 'Mit Messschieber messen, Wert eingeben',
+    unitMm: 'mm',
+    unitInch: 'Zoll',
+    modeForward: 'Bruch → Metrisch',
+    modeReverse: 'Metrisch → Bruch',
+    precisionLabel: 'Präzisionsmodus',
+    precisionCarpentry: 'Holzbau',
+    precisionMetal: 'Metallbau',
+    buttonConvert: 'Umrechnen',
+    buttonClear: 'Löschen',
+    buttonCopyResult: 'Ergebnis kopieren',
+    buttonSaveToHistory: 'Speichern',
+    historyTitle: 'Verlauf',
+    historyEmpty: 'Noch keine Messungen',
+    historyRemove: 'Entfernen',
+    helpText: 'Wählen Sie ein Maß oder geben Sie einen Bruch ein.',
+    toolOverline: 'Werkstatt-Tools',
+    labelVisualReference: 'Visuelle Referenz (1 Zoll = 96px)',
+  },
+};

package/src/tool/workshopFractionConverter/i18n/en.ts

@@ -0,0 +1,147 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { WorkshopFractionConverterUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'workshop-fraction-converter';
+const title = 'Workshop Fraction to Metric Converter';
+const description = 'Convert fractional inch measurements to millimeters instantly. Find the closest standard fasteners, bolts, and sockets for your workshop. Designed for dirty hands and gloved fingers.';
+
+const faqData = [
+  {
+    question: 'Why do I need to convert fractions to millimeters?',
+    answer: 'Most modern tools and fasteners use metric measurements, but many vintage tools and specs use fractional inches. This converter bridges that gap, helping you find the right metric equivalent or the closest standard fastener size.',
+  },
+  {
+    question: 'What is the difference between 1/2 inch and 12.7 mm?',
+    answer: '1/2 inch equals exactly 12.7 millimeters (0.5 × 25.4 = 12.7). Metric tools and imperial tools are often interchangeable at standard sizes because manufacturers align common fastener sizes across both systems.',
+  },
+  {
+    question: 'Why does the tool show "closest fastener"?',
+    answer: 'Because exact conversions often land between standard fastener sizes. The tool finds the commercial bolt or socket closest to your measurement, so you can use what is available in your workshop.',
+  },
+  {
+    question: 'What is the difference between carpentry and metal precision?',
+    answer: 'In carpentry, 0.5 mm differences are negligible. In metalwork and machining, 0.1 mm matters. The precision mode hints at acceptable tolerance ranges for your material.',
+  },
+  {
+    question: 'Can I measure with this tool offline?',
+    answer: 'Yes. All calculations happen in your browser. The tool works completely offline after the first load, perfect for use in the workshop without WiFi.',
+  },
+  {
+    question: 'Why does the tool include history?',
+    answer: 'When working on a disassembly or a project with multiple parts, history lets you reference measurements without re-entering them, and lets you build a parts list as you work.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Select your measurement type',
+    text: 'Choose "Forward" to convert a fraction to millimeters, or "Reverse" to find a fraction for a measurement you took with calipers.',
+  },
+  {
+    name: 'Enter the measurement',
+    text: 'Use the three-column input (whole, numerator, denominator) or tap a quick preset button. Stepper buttons let you adjust without typing.',
+  },
+  {
+    name: 'Review the results',
+    text: 'The result shows the exact conversion plus the closest standard fastener and socket sizes. Visual scale gives you a sense of proportion.',
+  },
+  {
+    name: 'Save to history',
+    text: 'Click "Save to History" to keep measurements for later reference. History persists in your browser, even after closing.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'en',
+};
+
+export const content: ToolLocaleContent<WorkshopFractionConverterUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Frequently Asked Questions',
+  faq: faqData,
+  bibliography,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    { type: 'title', text: 'Why Precision Fractional Conversion Matters in the Workshop', level: 2 },
+    { type: 'paragraph', html: 'In a professional or high-stakes DIY workshop, being "close enough" often results in stripped bolts, wobbly joints, or failed assemblies. This tool is designed to bridge the gap between legacy imperial measurements and the precision of the metric system, ensuring your workshop projects maintain professional-grade standards.' },
+    { type: 'title', text: 'The Standard Conversion: 1/2" vs. 12.7mm', level: 3 },
+    { type: 'card', icon: 'mdi:ruler-square', title: 'Imperial vs. Metric Compatibility', html: '<p>Many DIYers assume imperial and metric fasteners are perfectly interchangeable. While 1/2" is exactly 12.7mm, the closest standard metric socket is 13mm. Using the wrong tool can round off bolt heads. Our converter identifies the <strong>closest standard tool match</strong> so you never damage your hardware.</p>' },
+    { type: 'title', text: 'Woodworking vs. Metalworking Tolerance', level: 3 },
+    { type: 'paragraph', html: 'Tolerance requirements vary wildly by trade. In <strong>woodworking</strong>, a tolerance of 1/64" (0.4mm) is usually acceptable. In <strong>metalworking and machining</strong>, 0.1mm or even 0.01mm matters. Our tool includes a precision mode to help you decide which standard fastener is the safest bet for your specific material.' },
+    { type: 'title', text: '3 Essential Tips for Accurate Measurements', level: 3 },
+    { type: 'paragraph', html: '<strong>1. Use Calipers:</strong> For reverse searching, always use digital calipers for the most accurate millimetre input. <strong>2. Check for Wear:</strong> Old sockets and bolts may have worn edges, making the "closest match" even more critical. <strong>3. Verify Pitch:</strong> Remember that even if the head size matches, the thread pitch (metric vs. imperial) will always be different.' },
+  ],
+  ui: {
+    labelFraction: 'Measurement Type',
+    labelWhole: 'Whole',
+    labelNumerator: 'Numerator',
+    labelDenominator: 'Denominator',
+    labelInches: 'Inches',
+    labelMillimeters: 'Millimeters',
+    resultTitle: 'Conversion Result',
+    resultFraction: 'Fraction',
+    resultInches: 'Inches',
+    resultMillimeters: 'Millimeters',
+    matchTitle: 'Closest Fastener Match',
+    matchClosestFastener: 'Standard bolt or fastener size',
+    matchClosestSocket: 'Standard socket size',
+    matchDifference: 'Difference from your measurement',
+    matchRecommendation: 'Use this size if available',
+    reverseSearchTitle: 'Reverse Search',
+    reverseSearchLabel: 'Measured Size (mm)',
+    reverseSearchButton: 'Find Fraction',
+    reverseSearchHint: 'Measure with calipers, enter the value',
+    unitMm: 'mm',
+    unitInch: 'in',
+    modeForward: 'Fraction → Metric',
+    modeReverse: 'Metric → Fraction',
+    precisionLabel: 'Precision Mode',
+    precisionCarpentry: 'Carpentry',
+    precisionMetal: 'Metalworking',
+    buttonConvert: 'Convert',
+    buttonClear: 'Clear',
+    buttonCopyResult: 'Copy Result',
+    buttonSaveToHistory: 'Save to History',
+    historyTitle: 'History',
+    historyEmpty: 'No measurements yet',
+    historyRemove: 'Remove',
+    helpText: 'Select a measurement or enter a fraction to get started.',
+    toolOverline: 'Workshop Converter',
+    labelVisualReference: 'Visual Reference (1 inch = 96px)',
+  },
+};