@jjlmoya/utils-books 1.5.0 → 1.7.0

package/src/tool/book-interior-margin-and-gutter-planner/controller.ts

@@ -0,0 +1,141 @@
+import { calculateInterior, DEFAULT_INPUTS, type BookInteriorInputs } from './logic';
+import { loadBookInteriorState, saveBookInteriorState } from './storage';
+import { renderCalculation } from './dom-views';
+import type { BookInteriorUI } from './ui';
+
+const MM_PER_INCH = 25.4;
+
+export function initBookInteriorPlanner(root: HTMLElement, ui: BookInteriorUI): void {
+  const fallback = { inputs: DEFAULT_INPUTS, unit: 'metric' as const };
+  const stored = loadBookInteriorState(fallback);
+  const state = { inputs: { ...DEFAULT_INPUTS, ...stored.inputs }, unit: stored.unit };
+  bindSelects(root, state, ui);
+  bindInputs(root, state, ui);
+  bindUnitToggle(root, state, ui);
+  bindBleed(root, state, ui);
+  updateView(root, state, ui);
+}
+
+function bindInputs(root: HTMLElement, state: { inputs: BookInteriorInputs; unit: 'metric' | 'imperial' }, ui: BookInteriorUI): void {
+  root.querySelectorAll<HTMLInputElement>('[data-input="number"]').forEach((input) => {
+    input.addEventListener('input', () => {
+      const key = input.dataset.field as 'pages' | 'widthMm' | 'heightMm';
+      const value = Number(input.value);
+      state.inputs[key] = key === 'pages' ? value : toMillimetres(value, state.unit);
+      updateView(root, state, ui);
+    });
+  });
+}
+
+function bindSelects(root: HTMLElement, state: { inputs: BookInteriorInputs; unit: 'metric' | 'imperial' }, ui: BookInteriorUI): void {
+  root.querySelectorAll<HTMLElement>('[data-select]').forEach((select) => {
+    const trigger = select.querySelector<HTMLButtonElement>('[data-select-trigger]');
+    const menu = select.querySelector<HTMLElement>('[data-select-menu]');
+    if (!trigger || !menu) return;
+    trigger.addEventListener('click', () => {
+      const isOpen = select.dataset.open === 'true';
+      closeSelects(root);
+      if (!isOpen) {
+        select.dataset.open = 'true';
+        menu.hidden = false;
+      }
+    });
+    select.querySelectorAll<HTMLButtonElement>('[data-select-option]').forEach((option) => {
+      option.addEventListener('click', () => {
+        const field = select.dataset.select as 'binding' | 'paperType';
+        state.inputs[field] = option.dataset.value as never;
+        closeSelects(root);
+        updateView(root, state, ui);
+      });
+    });
+  });
+  document.addEventListener('click', (event) => {
+    if (!(event.target instanceof Node) || !root.contains(event.target)) closeSelects(root);
+  });
+}
+
+function bindUnitToggle(root: HTMLElement, state: { inputs: BookInteriorInputs; unit: 'metric' | 'imperial' }, ui: BookInteriorUI): void {
+  root.querySelectorAll<HTMLButtonElement>('[data-unit]').forEach((button) => {
+    button.addEventListener('click', () => {
+      state.unit = button.dataset.unit as 'metric' | 'imperial';
+      updateView(root, state, ui);
+    });
+  });
+}
+
+function bindBleed(root: HTMLElement, state: { inputs: BookInteriorInputs; unit: 'metric' | 'imperial' }, ui: BookInteriorUI): void {
+  const toggle = root.querySelector<HTMLButtonElement>('[data-bleed-toggle]');
+  toggle?.addEventListener('click', () => {
+    state.inputs.bleed = !state.inputs.bleed;
+    updateView(root, state, ui);
+  });
+}
+
+function updateView(root: HTMLElement, state: { inputs: BookInteriorInputs; unit: 'metric' | 'imperial' }, ui: BookInteriorUI): void {
+  const calculation = calculateInterior(state.inputs);
+  updateNumberInputs(root, state);
+  updateSelectLabels(root, state, ui);
+  updateUnitState(root, state);
+  updateBleedState(root, state, ui);
+  root.dataset.paper = state.inputs.paperType;
+  renderCalculation(root, calculation, ui, state.unit);
+  saveBookInteriorState(state);
+}
+
+function updateNumberInputs(root: HTMLElement, state: { inputs: BookInteriorInputs; unit: 'metric' | 'imperial' }): void {
+  root.querySelectorAll<HTMLInputElement>('[data-input="number"]').forEach((input) => {
+    const field = input.dataset.field as 'pages' | 'widthMm' | 'heightMm';
+    const value = field === 'pages' ? state.inputs.pages : fromMillimetres(state.inputs[field], state.unit);
+    input.value = value.toFixed(field === 'pages' ? 0 : 2);
+  });
+}
+
+function updateSelectLabels(root: HTMLElement, state: { inputs: BookInteriorInputs; unit: 'metric' | 'imperial' }, ui: BookInteriorUI): void {
+  const labels: Record<string, string> = {
+    'perfect-bound': ui.bindingPerfectLabel,
+    hardcover: ui.bindingHardcoverLabel,
+    'saddle-stitched': ui.bindingSaddleLabel,
+    'white-uncoated': ui.paperWhiteLabel,
+    'cream-uncoated': ui.paperCreamLabel,
+    coated: ui.paperCoatedLabel,
+  };
+  root.querySelectorAll<HTMLElement>('[data-select]').forEach((select) => {
+    const field = select.dataset.select as 'binding' | 'paperType';
+    const trigger = select.querySelector<HTMLElement>('[data-select-trigger]');
+    const selected = labels[state.inputs[field]];
+    if (trigger && selected) trigger.textContent = selected;
+  });
+}
+
+function updateUnitState(root: HTMLElement, state: { inputs: BookInteriorInputs; unit: 'metric' | 'imperial' }): void {
+  root.dataset.unit = state.unit;
+  root.querySelectorAll<HTMLButtonElement>('[data-unit]').forEach((button) => {
+    button.setAttribute('aria-pressed', String(button.dataset.unit === state.unit));
+  });
+  root.querySelectorAll<HTMLElement>('[data-unit-label]').forEach((label) => {
+    label.textContent = state.unit === 'metric' ? 'mm' : 'in';
+  });
+}
+
+function updateBleedState(root: HTMLElement, state: { inputs: BookInteriorInputs; unit: 'metric' | 'imperial' }, ui: BookInteriorUI): void {
+  const toggle = root.querySelector<HTMLButtonElement>('[data-bleed-toggle]');
+  if (!toggle) return;
+  toggle.setAttribute('aria-checked', String(state.inputs.bleed));
+  toggle.querySelector('[data-bleed-state]')!.textContent = state.inputs.bleed ? ui.bleedOn : ui.bleedOff;
+}
+
+function closeSelects(root: HTMLElement): void {
+  root.querySelectorAll<HTMLElement>('[data-select]').forEach((select) => {
+    select.dataset.open = 'false';
+    const menu = select.querySelector<HTMLElement>('[data-select-menu]');
+    if (menu) menu.hidden = true;
+  });
+}
+
+function toMillimetres(value: number, unit: 'metric' | 'imperial'): number {
+  return unit === 'metric' ? value : value * MM_PER_INCH;
+}
+
+function fromMillimetres(value: number, unit: 'metric' | 'imperial'): number {
+  return unit === 'metric' ? value : value / MM_PER_INCH;
+}

package/src/tool/book-interior-margin-and-gutter-planner/dom-views.ts

@@ -0,0 +1,66 @@
+import type { BookInteriorCalculation } from './logic';
+import type { BookInteriorUI } from './ui';
+import { evaluateInterior } from './evaluator';
+
+type DisplayUnit = 'metric' | 'imperial';
+
+export function createSpreadMarkup(calculation: BookInteriorCalculation, ui: BookInteriorUI, unit: DisplayUnit = 'metric'): string {
+  const result = evaluateInterior(calculation);
+  const gutter = Math.min(24, Math.max(8, calculation.gutterMm * 0.8));
+  const outer = Math.min(22, Math.max(10, calculation.outerMarginMm * 0.8));
+  const pageWidth = 132;
+  const pageHeight = 174;
+  const leftX = 24;
+  const rightX = 164;
+  const pageY = 28;
+  const safeLeft = leftX + outer; const safeRight = rightX + outer;
+  const safeY = pageY + outer;
+  const safeWidth = pageWidth - outer * 2 - gutter / 2;
+  const safeHeight = pageHeight - outer * 2;
+  const gutterLabel = formatValue(calculation.gutterMm, unit);
+  const outerLabel = formatValue(calculation.outerMarginMm, unit);
+  return `<svg class="n-spread-svg" viewBox="0 0 320 228" role="img" aria-label="${ui.sceneLabel}. ${ui.safeZoneLabel}. ${ui.spineLabel}. ${ui.pageLabel}">
+    <rect class="n-paper n-paper-left" x="${leftX}" y="${pageY}" width="${pageWidth}" height="${pageHeight}" rx="2" />
+    <rect class="n-paper n-paper-right" x="${rightX}" y="${pageY}" width="${pageWidth}" height="${pageHeight}" rx="2" />
+    <rect class="n-safe-zone" x="${safeLeft}" y="${safeY}" width="${safeWidth}" height="${safeHeight}" rx="1" />
+    <rect class="n-safe-zone" x="${safeRight + gutter / 2}" y="${safeY}" width="${safeWidth}" height="${safeHeight}" rx="1" />
+    <path class="n-crease" d="M160 25 C156 76 156 178 160 204" />
+    <path class="n-rule" d="M38 56 H142 M38 66 H142 M38 76 H142 M38 86 H126 M184 56 H288 M184 66 H288 M184 76 H288 M184 86 H272" />
+    <path class="n-rule n-rule-soft" d="M38 107 H128 M38 117 H136 M38 127 H118 M184 107 H276 M184 117 H264 M184 127 H284" />
+    <path class="n-measure n-measure-gutter" d="M151 28 V202 M169 28 V202" />
+    <path class="n-measure n-measure-outer" d="M24 213 H46" />
+    <text class="n-measure-text" x="160" y="218" text-anchor="middle">${gutterLabel}</text>
+    <text class="n-measure-text" x="35" y="224" text-anchor="middle">${outerLabel}</text>
+    <text class="n-scene-status n-scene-status-${result.status}" x="160" y="16" text-anchor="middle">${ui[result.messageKey]}</text>
+  </svg>`;
+}
+
+export function renderCalculation(root: HTMLElement, calculation: BookInteriorCalculation, ui: BookInteriorUI, unit: DisplayUnit): void {
+  const result = evaluateInterior(calculation);
+  root.dataset.status = result.status;
+  root.dataset.pages = String(calculation.pages);
+  const values: Record<string, string> = {
+    gutter: formatValue(calculation.gutterMm, unit),
+    outer: formatValue(calculation.outerMarginMm, unit),
+    safeWidth: formatValue(calculation.safeWidthMm, unit),
+    safeHeight: formatValue(calculation.safeHeightMm, unit),
+    pages: String(calculation.pages),
+    band: calculation.referenceBand,
+  };
+  Object.entries(values).forEach(([key, value]) => {
+    const target = root.querySelector(`[data-output="${key}"]`);
+    if (target) target.textContent = value;
+  });
+  const status = root.querySelector('[data-status-title]');
+  const detail = root.querySelector('[data-status-detail]');
+  if (status) status.textContent = ui[result.messageKey];
+  if (detail) detail.textContent = ui[result.detailKey];
+  const scene = root.querySelector('[data-scene]');
+  if (scene) scene.innerHTML = createSpreadMarkup(calculation, ui, unit);
+}
+
+function formatValue(valueMm: number, unit: DisplayUnit): string {
+  const value = unit === 'metric' ? valueMm : valueMm / 25.4;
+  const suffix = unit === 'metric' ? 'mm' : 'in';
+  return `${Math.max(0, value).toFixed(2)} ${suffix}`;
+}

package/src/tool/book-interior-margin-and-gutter-planner/entry.ts

@@ -0,0 +1,27 @@
+import type { BooksToolEntry, ToolLocaleContent } from '../../types';
+import type { BookInteriorUI } from './ui';
+
+export type { BookInteriorUI } from './ui';
+export type BookInteriorLocaleContent = ToolLocaleContent<BookInteriorUI>;
+
+export const bookInteriorMarginAndGutterPlanner: BooksToolEntry<BookInteriorUI> = {
+  id: 'book-interior-margin-and-gutter-planner',
+  icons: { bg: 'mdi:book-open-page-variant-outline', fg: 'mdi:ruler-square' },
+  i18n: {
+    de: () => import('./i18n/de').then((module) => module.content),
+    en: () => import('./i18n/en').then((module) => module.content),
+    es: () => import('./i18n/es').then((module) => module.content),
+    fr: () => import('./i18n/fr').then((module) => module.content),
+    id: () => import('./i18n/id').then((module) => module.content),
+    it: () => import('./i18n/it').then((module) => module.content),
+    ja: () => import('./i18n/ja').then((module) => module.content),
+    ko: () => import('./i18n/ko').then((module) => module.content),
+    nl: () => import('./i18n/nl').then((module) => module.content),
+    pl: () => import('./i18n/pl').then((module) => module.content),
+    pt: () => import('./i18n/pt').then((module) => module.content),
+    ru: () => import('./i18n/ru').then((module) => module.content),
+    sv: () => import('./i18n/sv').then((module) => module.content),
+    tr: () => import('./i18n/tr').then((module) => module.content),
+    zh: () => import('./i18n/zh').then((module) => module.content),
+  },
+};

package/src/tool/book-interior-margin-and-gutter-planner/evaluator.ts

@@ -0,0 +1,22 @@
+import type { BookInteriorCalculation } from './logic';
+
+export type InteriorStatus = 'ready' | 'low-pages' | 'high-pages' | 'invalid';
+
+export interface InteriorEvaluation {
+  status: InteriorStatus;
+  messageKey: 'statusReady' | 'statusLowPages' | 'statusHighPages' | 'statusInvalid';
+  detailKey: 'statusReadyDetail' | 'statusLowPagesDetail' | 'statusHighPagesDetail' | 'statusInvalidDetail';
+}
+
+export function evaluateInterior(calculation: BookInteriorCalculation): InteriorEvaluation {
+  if (calculation.invalidGeometry) {
+    return { status: 'invalid', messageKey: 'statusInvalid', detailKey: 'statusInvalidDetail' };
+  }
+  if (calculation.aboveReferenceCeiling) {
+    return { status: 'high-pages', messageKey: 'statusHighPages', detailKey: 'statusHighPagesDetail' };
+  }
+  if (calculation.belowReferenceFloor) {
+    return { status: 'low-pages', messageKey: 'statusLowPages', detailKey: 'statusLowPagesDetail' };
+  }
+  return { status: 'ready', messageKey: 'statusReady', detailKey: 'statusReadyDetail' };
+}

package/src/tool/book-interior-margin-and-gutter-planner/i18n/de.ts

@@ -0,0 +1,59 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { BookInteriorUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const ui: BookInteriorUI = {
+  setupLabel: 'Druckeinrichtung', pagesLabel: 'Innenseiten', widthLabel: 'Beschnittbreite', heightLabel: 'Beschnitthöhe',
+  bindingLabel: 'Bindung', bindingPerfectLabel: 'Taschenbuch mit Klebebindung', bindingHardcoverLabel: 'Hardcover mit Deckenbindung', bindingSaddleLabel: 'Rückstichheftung',
+  paperLabel: 'Papier', paperWhiteLabel: 'Weiß ungestrichen', paperCreamLabel: 'Creme ungestrichen', paperCoatedLabel: 'Gestrichenes Papier',
+  bleedLabel: 'Randabfallende Gestaltung', bleedOn: 'Enthalten', bleedOff: 'Nicht enthalten', metricLabel: 'Metrisch mm', imperialLabel: 'Imperial in',
+  marginLabel: 'Randplanung', gutterLabel: 'Bundsteg', outerLabel: 'Sicherheitsrand außen', safeWidthLabel: 'Sichere Textbreite', safeHeightLabel: 'Sichere Texthöhe',
+  normalizedPagesLabel: 'Seitenzahl für das Layout', pageFormatLabel: 'Referenzbereich', sceneLabel: 'Doppelseitenplan',
+  sceneHint: 'Der warme Bereich ist die nutzbare Textzone. Die mittlere Falz ist die Bindekante. Wichtiger Text bleibt außerhalb.',
+  statusReady: 'Referenzbereich abgedeckt', statusLowPages: 'Kurze Auflage prüfen', statusHighPages: 'Außerhalb des Referenzbereichs', statusInvalid: 'Beschnittformat zu klein',
+  statusReadyDetail: 'Nutze diese Maße als Layoutanfang und bestätige sie mit der Druckvorlage.',
+  statusLowPagesDetail: 'Die veröffentlichte Randtabelle beginnt bei 24 Seiten. Bitte die Heftungsspezifikation der Druckerei prüfen.',
+  statusHighPagesDetail: 'Die veröffentlichte Tabelle endet bei 828 Seiten. Bitte eine individuelle Prüfung von Rand und Bindung anfordern.',
+  statusInvalidDetail: 'Das gewählte Format lässt nach den erforderlichen Rändern keine positive sichere Textfläche übrig.',
+  pageLabel: 'Seite', spineLabel: 'Bindekante', safeZoneLabel: 'Sichere Textzone', trimLabel: 'Endformat',
+  sourceLabel: 'Planungswerte sind kein Druckabzug. Bestätige Vorlage, Papier, Bindung und Produktionstoleranzen mit der Druckerei.',
+};
+
+const faq = [
+  { question: 'Was ist der Bundsteg?', answer: 'Der Bundsteg ist der zusätzliche Rand an der Bindekante. Er hält wichtigen Text und Seitendetails von dem Bereich fern, der nach der Bindung schwer lesbar werden kann.' },
+  { question: 'Warum wächst der Bundsteg mit der Seitenzahl?', answer: 'Ein dickeres Buch führt mehr Papier in die Bindung. Deshalb steigen die empfohlenen Mindestwerte für den inneren Rand mit der Länge des Buchblocks.' },
+  { question: 'Was ändert ein randabfallendes Motiv?', answer: 'Randabfallende Bilder benötigen zusätzliche Bildfläche über die Schnittkante hinaus. Der Planer vergrößert außerdem den äußeren Sicherheitsrand für Text und wichtige Details.' },
+  { question: 'Kann ich diese Werte direkt an die Druckerei schicken?', answer: 'Nein. Verwende sie als Planungsbrief. Die Druckvorlage für Format, Papier, Bindung und Produktionsverfahren ist maßgeblich.' },
+];
+
+const howTo = [
+  { name: 'Innenformat eingeben', text: 'Lege Seitenzahl sowie beschnittene Breite und Höhe des Buches fest.' },
+  { name: 'Produktionskontext wählen', text: 'Wähle Bindung, Papier und ob die Innenseiten randabfallende Gestaltung enthalten.' },
+  { name: 'Doppelseite lesen', text: 'Nutze Bundsteg, Außenrand und sichere Textmaße als Layoutgrenze.' },
+  { name: 'Druckdatei bestätigen', text: 'Vergleiche den Plan mit der exakten Vorlage und den Produktionstoleranzen der Druckerei.' },
+];
+
+const seo: ToolLocaleContent<BookInteriorUI>['seo'] = [
+  { type: 'title', text: 'Buchinnenränder und Bundsteg vor dem Layout planen', level: 2 },
+  { type: 'paragraph', html: 'Lege einen praktischen Startpunkt für druckfertige Buchinnenseiten fest. Seitenzahl, Endformat, Bindung, Papier und Anschnitt werden in Bundsteg, äußeren Sicherheitsrand und nutzbare Textfläche einer Doppelseite übersetzt.' },
+  { type: 'title', text: 'So funktioniert die Randplanung', level: 2 },
+  { type: 'list', items: ['Gib Seitenzahl und Endformat ein und wähle die passende Bindung.', 'Aktiviere den Anschnitt, wenn Bilder oder Farbflächen über die Schnittkante hinausreichen.', 'Behandle den Bundsteg als Mindestwert und halte wichtige Texte, Seitenzahlen und Tabellen von der Falz fern.', 'Verwende die sichere Breite und Höhe als Layoutgrenze und übertrage danach die genaue Druckvorlage.'] },
+  { type: 'title', text: 'Warum die Seitenzahl den Bundsteg verändert', level: 2 },
+  { type: 'paragraph', html: 'Ein dickerer Buchblock führt mehr Papier an die Bindekante. Die Referenzbereiche reichen von 9,6 mm für 24 bis 150 Seiten bis 22,3 mm für 701 bis 828 Seiten. Gebundene Bücher werden auf eine gerade Seitenzahl und Rückstichheftungen auf ein Vielfaches von vier gerundet.' },
+  { type: 'table', headers: ['Innenseiten', 'Bundsteg', 'Außenrand ohne Anschnitt'], rows: [['24 bis 150', '9,6 mm', 'mindestens 6,4 mm'], ['151 bis 300', '12,7 mm', 'mindestens 6,4 mm'], ['301 bis 500', '15,9 mm', 'mindestens 6,4 mm'], ['501 bis 700', '19,1 mm', 'mindestens 6,4 mm'], ['701 bis 828', '22,3 mm', 'mindestens 6,4 mm']] },
+  { type: 'tip', title: 'Nicht bis an den Mindestwert gestalten', html: 'Mindestwerte sind eine Produktionsgrenze und keine Garantie für angenehmes Lesen. Plane zusätzliche Reserve für breite Buchstaben, Seitenzahlen, Abbildungen und das Öffnungsverhalten der Bindung ein.' },
+  { type: 'title', text: 'Anschnitt und Sicherheitszone haben verschiedene Aufgaben', level: 2 },
+  { type: 'paragraph', html: 'Anschnitt gibt Bildern und Hintergründen zusätzliche Fläche für den Schnitt. Er macht Text nicht sicher an Schnitt- oder Bindekante. Wichtige Inhalte bleiben in der Sicherheitszone, während nur wirklich randfüllende Gestaltung über den Rand hinausläuft.' },
+  { type: 'tip', title: 'Das Ergebnis als Layoutbrief verwenden', html: 'Notiere Endformat, Seitenzahl, Bindung, Papier, Bundsteg und Anschnitt neben deiner Designdatei. Wenn Papier oder Bindung wechseln, berechne den Brief neu.' },
+];
+
+export const content: ToolLocaleContent<BookInteriorUI> = {
+  slug: 'buchinnenraender-und-bundsteg-planer', title: 'Planer für Buchinnenränder und Bundsteg',
+  description: 'Plane Bundsteg, äußeren Sicherheitsrand und nutzbare Textfläche für Buchinnenseiten vor dem Layout.',
+  ui, seo, faq, bibliography, howTo,
+  schemas: [
+    { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: 'Planer für Buchinnenränder und Bundsteg', applicationCategory: 'DesignApplication', operatingSystem: 'Any', offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' } },
+    { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+    { '@context': 'https://schema.org', '@type': 'HowTo', name: 'Buchinnenränder und Bundsteg planen', step: howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) },
+  ],
+};

package/src/tool/book-interior-margin-and-gutter-planner/i18n/en.ts

@@ -0,0 +1,60 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { BookInteriorUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const ui: BookInteriorUI = {
+  setupLabel: 'Print setup', pagesLabel: 'Interior pages', widthLabel: 'Trim width', heightLabel: 'Trim height',
+  bindingLabel: 'Binding', bindingPerfectLabel: 'Paperback perfect bound', bindingHardcoverLabel: 'Hardcover case bound', bindingSaddleLabel: 'Saddle stitched booklet',
+  paperLabel: 'Paper stock', paperWhiteLabel: 'White uncoated', paperCreamLabel: 'Cream uncoated', paperCoatedLabel: 'Coated paper',
+  bleedLabel: 'Full bleed artwork', bleedOn: 'Included', bleedOff: 'Not included', metricLabel: 'Metric mm', imperialLabel: 'Imperial in',
+  marginLabel: 'Margin plan', gutterLabel: 'Inside gutter', outerLabel: 'Outside safe margin', safeWidthLabel: 'Safe text width', safeHeightLabel: 'Safe text height',
+  normalizedPagesLabel: 'Layout page count', pageFormatLabel: 'Reference band', sceneLabel: 'Facing page plan',
+  sceneHint: 'The warm area is the usable text zone. The central crease is the binding edge; keep essential text outside it.',
+  statusReady: 'Reference band covered', statusLowPages: 'Short run needs a check', statusHighPages: 'Beyond the reference band', statusInvalid: 'Trim size is too small',
+  statusReadyDetail: 'Use these dimensions as a starting layout and confirm them with the printer template.',
+  statusLowPagesDetail: 'The published margin table starts at 24 pages. Ask the printer for the booklet specification.',
+  statusHighPagesDetail: 'The published table ends at 828 pages. Request a custom margin and binding review.',
+  statusInvalidDetail: 'The chosen trim size leaves no positive safe text area after the required margins.',
+  pageLabel: 'Page', spineLabel: 'Binding edge', safeZoneLabel: 'Safe text zone', trimLabel: 'Trim size',
+  sourceLabel: 'Planning values are not a printer proof. Confirm the final template, stock, binding, and production tolerances with the printer.',
+};
+
+const faq = [
+  { question: 'What is the inside gutter?', answer: 'The inside gutter is the extra margin beside the binding edge. It keeps essential text and page details away from the part of the spread that becomes difficult to read after binding.' },
+  { question: 'Why does the gutter grow with page count?', answer: 'A thicker book places more paper into the binding. The reference margin bands therefore increase the minimum inside gutter as the interior becomes longer.' },
+  { question: 'What does full bleed change?', answer: 'Full bleed artwork needs extra image area beyond the trim edge. This planner also increases the outside safe margin so text and important details stay farther from the cut.' },
+  { question: 'Can I send these values directly to a printer?', answer: 'No. Use them as a planning brief. The printer template for the selected trim size, paper, binding, and production method is the final authority.' },
+];
+
+const howTo = [
+  { name: 'Enter the interior format', text: 'Set the final page count and trimmed width and height of the book.' },
+  { name: 'Choose the production context', text: 'Select the binding, paper stock, and whether the interior includes full bleed artwork.' },
+  { name: 'Read the spread plan', text: 'Use the gutter, outside margin, and safe text dimensions as the starting envelope for layout.' },
+  { name: 'Confirm the printer file', text: 'Compare the plan with the exact template and production tolerances supplied by the printer.' },
+];
+
+const seo: ToolLocaleContent<BookInteriorUI>['seo'] = [
+  { type: 'title', text: 'Plan Book Interior Margins and Gutter Before Layout', level: 2 },
+  { type: 'paragraph', html: 'Set a practical starting point for a print ready book interior by combining page count, trim size, binding, paper context, and bleed. The planner turns those choices into an inside gutter, an outside safe margin, and a usable text area for a facing page spread.' },
+  { type: 'title', text: 'How the Margin Plan Works', level: 2 },
+  { type: 'list', items: ['Enter the final interior page count and trim size, then choose the binding that matches the job.', 'Turn full bleed on when images or color continue past the trim edge. The outside safe margin becomes more generous.', 'Use the gutter as the minimum inside margin and keep important text, folios, and table details outside the central crease.', 'Treat the safe text width and height as a layout envelope, then apply the exact template supplied by the printer.'] },
+  { type: 'title', text: 'Why Page Count Changes the Gutter', level: 2 },
+  { type: 'paragraph', html: 'A thicker book pushes more paper into the binding edge. The reference bands used here step the inside margin from 9.6 mm for 24 to 150 pages up to 22.3 mm for 701 to 828 pages. The calculator rounds bound books to an even page count and saddle stitched booklets to a multiple of four for a realistic planning spread.' },
+  { type: 'table', headers: ['Interior pages', 'Inside gutter', 'Outside margin without bleed'], rows: [['24 to 150', '9.6 mm', '6.4 mm minimum'], ['151 to 300', '12.7 mm', '6.4 mm minimum'], ['301 to 500', '15.9 mm', '6.4 mm minimum'], ['501 to 700', '19.1 mm', '6.4 mm minimum'], ['701 to 828', '22.3 mm', '6.4 mm minimum']] },
+  { type: 'tip', title: 'Do not design to the edge of the number', html: 'Minimum margins are a production floor, not a promise of comfortable reading. Leave additional room for wide letterforms, folios, illustrations, captions, and the way a particular binding opens. A printer supplied template wins over a generic estimate.' },
+  { type: 'title', text: 'Bleed and Safe Zones Are Different Jobs', level: 2 },
+  { type: 'paragraph', html: 'Bleed gives an image or background extra area to survive trimming. It does not make text safe near the cut or binding edge. Keep essential content inside the safe zone, extend only the artwork that truly reaches the edge, and inspect the first and last pages of every spread before exporting.' },
+  { type: 'tip', title: 'Use the result as a brief for your layout', html: 'Record the trim size, page count, binding, paper stock, gutter, and bleed choice beside your design file. When the printer changes paper or binding, recalculate the brief instead of quietly reusing old margins.' },
+];
+
+export const content: ToolLocaleContent<BookInteriorUI> = {
+  slug: 'book-interior-margin-and-gutter-planner',
+  title: 'Book Interior Margin and Gutter Planner',
+  description: 'Plan the inside gutter, outside safe margin, and usable text area for a book interior before you start layout.',
+  ui, seo, faq, bibliography, howTo,
+  schemas: [
+    { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: 'Book Interior Margin and Gutter Planner', applicationCategory: 'DesignApplication', operatingSystem: 'Any', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } },
+    { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+    { '@context': 'https://schema.org', '@type': 'HowTo', name: 'Plan book interior margins and gutter', step: howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) },
+  ],
+};

package/src/tool/book-interior-margin-and-gutter-planner/i18n/es.ts

@@ -0,0 +1,59 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { BookInteriorUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const ui: BookInteriorUI = {
+  setupLabel: 'Configuración de impresión', pagesLabel: 'Páginas interiores', widthLabel: 'Ancho de corte', heightLabel: 'Alto de corte',
+  bindingLabel: 'Encuadernación', bindingPerfectLabel: 'Rústica fresada', bindingHardcoverLabel: 'Tapa dura', bindingSaddleLabel: 'Grapado a caballete',
+  paperLabel: 'Papel', paperWhiteLabel: 'Blanco no estucado', paperCreamLabel: 'Crema no estucado', paperCoatedLabel: 'Papel estucado',
+  bleedLabel: 'Diseño a sangre', bleedOn: 'Incluido', bleedOff: 'No incluido', metricLabel: 'Métrico mm', imperialLabel: 'Imperial in',
+  marginLabel: 'Plan de márgenes', gutterLabel: 'Medianil interior', outerLabel: 'Margen exterior seguro', safeWidthLabel: 'Ancho de texto seguro', safeHeightLabel: 'Alto de texto seguro',
+  normalizedPagesLabel: 'Páginas para maquetar', pageFormatLabel: 'Rango de referencia', sceneLabel: 'Plan de doble página',
+  sceneHint: 'La zona cálida es el área de texto utilizable. El pliegue central es el borde de encuadernación; mantén fuera el texto esencial.',
+  statusReady: 'Rango de referencia cubierto', statusLowPages: 'Revisa la tirada corta', statusHighPages: 'Fuera del rango de referencia', statusInvalid: 'Formato de corte demasiado pequeño',
+  statusReadyDetail: 'Usa estas medidas como punto de partida y confírmalas con la plantilla de la imprenta.',
+  statusLowPagesDetail: 'La tabla publicada empieza en 24 páginas. Consulta la especificación del folleto con la imprenta.',
+  statusHighPagesDetail: 'La tabla publicada termina en 828 páginas. Solicita una revisión personalizada de margen y encuadernación.',
+  statusInvalidDetail: 'El formato elegido no deja una zona de texto segura positiva después de aplicar los márgenes requeridos.',
+  pageLabel: 'Página', spineLabel: 'Borde de encuadernación', safeZoneLabel: 'Zona de texto segura', trimLabel: 'Tamaño final',
+  sourceLabel: 'Estos valores son de planificación, no una prueba de imprenta. Confirma plantilla, papel, encuadernación y tolerancias con la imprenta.',
+};
+
+const faq = [
+  { question: '¿Qué es el medianil interior?', answer: 'El medianil interior es el margen adicional junto al borde de encuadernación. Aleja el texto y los detalles importantes de la zona que puede resultar difícil de leer al abrir el libro.' },
+  { question: '¿Por qué aumenta el medianil con el número de páginas?', answer: 'Un libro más grueso introduce más papel en la encuadernación. Por eso los rangos de referencia elevan el margen interior mínimo a medida que crece el bloque.' },
+  { question: '¿Qué cambia al activar el diseño a sangre?', answer: 'Las imágenes a sangre necesitan área adicional más allá del borde de corte. El planificador también amplía el margen exterior seguro para alejar texto y detalles importantes del corte.' },
+  { question: '¿Puedo enviar estos valores directamente a la imprenta?', answer: 'No. Úsalos como un briefing de maquetación. La plantilla de la imprenta para ese formato, papel, encuadernación y método de producción es la referencia final.' },
+];
+
+const howTo = [
+  { name: 'Introduce el formato interior', text: 'Indica el número final de páginas y el ancho y alto de corte del libro.' },
+  { name: 'Elige el contexto de producción', text: 'Selecciona encuadernación, papel y si el interior lleva elementos a sangre.' },
+  { name: 'Lee el plan de doble página', text: 'Usa medianil, margen exterior y dimensiones seguras como límite inicial de maquetación.' },
+  { name: 'Confirma el archivo de imprenta', text: 'Compara el plan con la plantilla exacta y las tolerancias de producción de la imprenta.' },
+];
+
+const seo: ToolLocaleContent<BookInteriorUI>['seo'] = [
+  { type: 'title', text: 'Planifica los márgenes interiores y el medianil de un libro', level: 2 },
+  { type: 'paragraph', html: 'Establece un punto de partida práctico para un interior de libro listo para imprimir combinando páginas, tamaño final, encuadernación, papel y sangre. El planificador convierte esas decisiones en medianil, margen exterior seguro y área de texto útil para una doble página.' },
+  { type: 'title', text: 'Cómo funciona el plan de márgenes', level: 2 },
+  { type: 'list', items: ['Introduce las páginas y el tamaño final, y elige la encuadernación del trabajo.', 'Activa la sangre cuando las imágenes o los fondos continúen más allá del borde de corte.', 'Usa el medianil como mínimo interior y mantén fuera del pliegue el texto, los folios y los datos de tablas.', 'Trata el ancho y el alto seguros como un límite de maquetación y aplica después la plantilla de la imprenta.'] },
+  { type: 'title', text: 'Por qué las páginas cambian el medianil', level: 2 },
+  { type: 'paragraph', html: 'Un bloque más grueso introduce más papel en el borde de encuadernación. Los rangos de referencia van de 9,6 mm para 24 a 150 páginas hasta 22,3 mm para 701 a 828 páginas. Los libros encuadernados se redondean a páginas pares y los folletos grapados a múltiplos de cuatro.' },
+  { type: 'table', headers: ['Páginas interiores', 'Medianil', 'Margen exterior sin sangre'], rows: [['24 a 150', '9,6 mm', 'mínimo 6,4 mm'], ['151 a 300', '12,7 mm', 'mínimo 6,4 mm'], ['301 a 500', '15,9 mm', 'mínimo 6,4 mm'], ['501 a 700', '19,1 mm', 'mínimo 6,4 mm'], ['701 a 828', '22,3 mm', 'mínimo 6,4 mm']] },
+  { type: 'tip', title: 'No maquetes al límite del número', html: 'Los mínimos son un suelo de producción, no una promesa de lectura cómoda. Deja margen adicional para letras anchas, folios, ilustraciones y la apertura real de la encuadernación.' },
+  { type: 'title', text: 'La sangre y la zona segura cumplen funciones distintas', level: 2 },
+  { type: 'paragraph', html: 'La sangre da a imágenes y fondos superficie adicional para sobrevivir al corte. No hace seguro el texto cerca del corte o de la encuadernación. Mantén los elementos esenciales dentro de la zona segura y extiende solo el arte que deba llegar al borde.' },
+  { type: 'tip', title: 'Usa el resultado como briefing de maquetación', html: 'Anota tamaño final, páginas, encuadernación, papel, medianil y sangre junto al archivo de diseño. Si cambia el papel o la encuadernación, recalcula el briefing.' },
+];
+
+export const content: ToolLocaleContent<BookInteriorUI> = {
+  slug: 'planificador-de-margenes-y-medianil-interior-de-libro', title: 'Planificador de márgenes y medianil interior de libro',
+  description: 'Planifica el medianil, el margen exterior seguro y el área de texto útil de un interior de libro antes de maquetar.',
+  ui, seo, faq, bibliography, howTo,
+  schemas: [
+    { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: 'Planificador de márgenes y medianil interior de libro', applicationCategory: 'DesignApplication', operatingSystem: 'Any', offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' } },
+    { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+    { '@context': 'https://schema.org', '@type': 'HowTo', name: 'Planificar márgenes interiores y medianil', step: howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) },
+  ],
+};

package/src/tool/book-interior-margin-and-gutter-planner/i18n/fr.ts

@@ -0,0 +1,59 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { BookInteriorUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const ui: BookInteriorUI = {
+  setupLabel: "Paramètres d'impression", pagesLabel: 'Pages intérieures', widthLabel: 'Largeur de coupe', heightLabel: 'Hauteur de coupe',
+  bindingLabel: 'Reliure', bindingPerfectLabel: 'Broché dos carré collé', bindingHardcoverLabel: 'Relié pleine toile', bindingSaddleLabel: 'Dos agrafé',
+  paperLabel: 'Papier', paperWhiteLabel: 'Blanc non couché', paperCreamLabel: 'Crème non couché', paperCoatedLabel: 'Papier couché',
+  bleedLabel: 'Illustration à fond perdu', bleedOn: 'Activée', bleedOff: 'Désactivée', metricLabel: 'Métrique mm', imperialLabel: 'Impérial in',
+  marginLabel: 'Plan de marges', gutterLabel: 'Marge de reliure', outerLabel: 'Marge extérieure sûre', safeWidthLabel: 'Largeur de texte sûre', safeHeightLabel: 'Hauteur de texte sûre',
+  normalizedPagesLabel: 'Pages pour la mise en page', pageFormatLabel: 'Plage de référence', sceneLabel: 'Plan de double page',
+  sceneHint: 'La zone chaude est la zone de texte utilisable. Le pli central est le bord de reliure. Gardez-y le texte essentiel à distance.',
+  statusReady: 'Plage de référence couverte', statusLowPages: 'Vérifier le petit tirage', statusHighPages: 'Hors plage de référence', statusInvalid: 'Format de coupe trop petit',
+  statusReadyDetail: "Utilisez ces dimensions comme point de départ et confirmez-les avec le gabarit de l'imprimeur.",
+  statusLowPagesDetail: "Le tableau publié commence à 24 pages. Demandez la spécification du livret à l'imprimeur.",
+  statusHighPagesDetail: "Le tableau publié s'arrête à 828 pages. Demandez une vérification personnalisée des marges et de la reliure.",
+  statusInvalidDetail: 'Le format choisi ne laisse aucune zone de texte sûre positive après les marges requises.',
+  pageLabel: 'Page', spineLabel: 'Bord de reliure', safeZoneLabel: 'Zone de texte sûre', trimLabel: 'Format fini',
+  sourceLabel: "Ces valeurs servent à planifier, pas à produire une épreuve. Confirmez le gabarit, le papier, la reliure et les tolérances auprès de l'imprimeur.",
+};
+
+const faq = [
+  { question: "Qu'est-ce que la marge de reliure ?", answer: "La marge de reliure est l'espace supplémentaire placé près du bord relié. Elle éloigne le texte et les détails importants de la zone qui devient difficile à lire une fois le livre relié." },
+  { question: 'Pourquoi la marge de reliure augmente-t-elle avec le nombre de pages ?', answer: "Un livre plus épais amène davantage de papier dans la reliure. Les plages de référence augmentent donc la marge intérieure minimale lorsque le bloc s'allonge." },
+  { question: 'Que change une illustration à fond perdu ?', answer: 'Une image à fond perdu a besoin de surface supplémentaire au-delà de la ligne de coupe. Le planificateur éloigne aussi le texte et les détails importants de la coupe.' },
+  { question: "Puis-je envoyer ces valeurs directement à l'imprimeur ?", answer: "Non. Utilisez-les comme brief de mise en page. Le gabarit de l'imprimeur adapté au format, au papier, à la reliure et au procédé reste la référence finale." },
+];
+
+const howTo = [
+  { name: 'Saisir le format intérieur', text: 'Indiquez le nombre final de pages et les largeur et hauteur de coupe du livre.' },
+  { name: 'Choisir le contexte de production', text: "Sélectionnez la reliure, le papier et la présence d'éléments à fond perdu." },
+  { name: 'Lire le plan de double page', text: 'Utilisez la marge de reliure, la marge extérieure et les dimensions sûres comme enveloppe de départ.' },
+  { name: 'Confirmer le fichier imprimeur', text: "Comparez le plan avec le gabarit exact et les tolérances de production de l'imprimeur." },
+];
+
+const seo: ToolLocaleContent<BookInteriorUI>['seo'] = [
+  { type: 'title', text: "Planifier les marges intérieures et la reliure d'un livre", level: 2 },
+  { type: 'paragraph', html: 'Définissez un point de départ pratique pour un intérieur de livre prêt à imprimer. Le nombre de pages, le format fini, la reliure, le papier et le fond perdu deviennent une marge de reliure, une marge extérieure sûre et une zone de texte utile pour une double page.' },
+  { type: 'title', text: 'Fonctionnement du plan de marges', level: 2 },
+  { type: 'list', items: ['Saisissez les pages et le format fini, puis choisissez la reliure adaptée.', 'Activez le fond perdu lorsque les images ou les aplats dépassent la coupe.', 'Considérez la marge de reliure comme un minimum et éloignez le texte, les folios et les tableaux du pli central.', "Utilisez la largeur et la hauteur sûres comme limite de mise en page avant d'appliquer le gabarit exact."] },
+  { type: 'title', text: 'Pourquoi le nombre de pages modifie la marge de reliure', level: 2 },
+  { type: 'paragraph', html: 'Un bloc plus épais pousse davantage de papier vers le bord relié. Les plages de référence vont de 9,6 mm pour 24 à 150 pages à 22,3 mm pour 701 à 828 pages. Les livres reliés sont arrondis à un nombre pair et les livrets agrafés à un multiple de quatre.' },
+  { type: 'table', headers: ['Pages intérieures', 'Marge de reliure', 'Marge extérieure sans fond perdu'], rows: [['24 à 150', '9,6 mm', '6,4 mm minimum'], ['151 à 300', '12,7 mm', '6,4 mm minimum'], ['301 à 500', '15,9 mm', '6,4 mm minimum'], ['501 à 700', '19,1 mm', '6,4 mm minimum'], ['701 à 828', '22,3 mm', '6,4 mm minimum']] },
+  { type: 'tip', title: 'Ne pas composer au bord du minimum', html: "Les minima sont un seuil de production, pas une garantie de confort de lecture. Ajoutez une réserve pour les lettres larges, les folios, les illustrations et l'ouverture réelle de la reliure." },
+  { type: 'title', text: 'Fond perdu et zone sûre ont des rôles différents', level: 2 },
+  { type: 'paragraph', html: 'Le fond perdu donne aux images et aux arrière-plans une surface supplémentaire pour supporter la coupe. Il ne sécurise pas le texte près de la coupe ou de la reliure. Gardez les éléments essentiels dans la zone sûre et prolongez seulement les images qui doivent atteindre le bord.' },
+  { type: 'tip', title: 'Utiliser le résultat comme brief de mise en page', html: 'Notez le format fini, les pages, la reliure, le papier, la marge de reliure et le fond perdu à côté du fichier. Si le papier ou la reliure changent, recalculez le brief.' },
+];
+
+export const content: ToolLocaleContent<BookInteriorUI> = {
+  slug: 'planificateur-marges-interieures-et-gouttiere-livre', title: 'Planificateur de marges intérieures et de reliure du livre',
+  description: "Planifiez la marge de reliure, la marge extérieure sûre et la zone de texte d'un intérieur de livre avant la mise en page.",
+  ui, seo, faq, bibliography, howTo,
+  schemas: [
+    { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: 'Planificateur de marges intérieures et de reliure du livre', applicationCategory: 'DesignApplication', operatingSystem: 'Any', offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' } },
+    { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+    { '@context': 'https://schema.org', '@type': 'HowTo', name: "Planifier les marges intérieures d'un livre", step: howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) },
+  ],
+};

package/src/tool/book-interior-margin-and-gutter-planner/i18n/id.ts

@@ -0,0 +1,59 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { BookInteriorUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const ui: BookInteriorUI = {
+  setupLabel: 'Pengaturan cetak', pagesLabel: 'Halaman isi', widthLabel: 'Lebar potong', heightLabel: 'Tinggi potong',
+  bindingLabel: 'Penjilidan', bindingPerfectLabel: 'Buku sampul lunak lem', bindingHardcoverLabel: 'Buku sampul keras', bindingSaddleLabel: 'Jilid kawat tengah',
+  paperLabel: 'Kertas', paperWhiteLabel: 'Putih tanpa lapisan', paperCreamLabel: 'Krem tanpa lapisan', paperCoatedLabel: 'Kertas berlapis',
+  bleedLabel: 'Karya sampai tepi', bleedOn: 'Aktif', bleedOff: 'Tidak aktif', metricLabel: 'Metrik mm', imperialLabel: 'Imperial in',
+  marginLabel: 'Rencana margin', gutterLabel: 'Margin dalam', outerLabel: 'Margin luar aman', safeWidthLabel: 'Lebar teks aman', safeHeightLabel: 'Tinggi teks aman',
+  normalizedPagesLabel: 'Jumlah halaman tata letak', pageFormatLabel: 'Rentang referensi', sceneLabel: 'Rencana dua halaman',
+  sceneHint: 'Area berwarna hangat adalah zona teks yang dapat digunakan. Lipatan tengah adalah tepi jilid; jauhkan teks penting darinya.',
+  statusReady: 'Rentang referensi tercakup', statusLowPages: 'Periksa cetak pendek', statusHighPages: 'Di luar rentang referensi', statusInvalid: 'Ukuran potong terlalu kecil',
+  statusReadyDetail: 'Gunakan ukuran ini sebagai awal tata letak dan konfirmasikan dengan templat percetakan.',
+  statusLowPagesDetail: 'Tabel margin yang diterbitkan dimulai dari 24 halaman. Tanyakan spesifikasi buklet kepada percetakan.',
+  statusHighPagesDetail: 'Tabel yang diterbitkan berakhir pada 828 halaman. Minta pemeriksaan margin dan jilid khusus.',
+  statusInvalidDetail: 'Ukuran yang dipilih tidak menyisakan area teks aman yang positif setelah margin diterapkan.',
+  pageLabel: 'Halaman', spineLabel: 'Tepi jilid', safeZoneLabel: 'Zona teks aman', trimLabel: 'Ukuran jadi',
+  sourceLabel: 'Nilai ini untuk perencanaan, bukan bukti cetak. Konfirmasikan templat, kertas, jilid, dan toleransi produksi kepada percetakan.',
+};
+
+const faq = [
+  { question: 'Apa yang dimaksud margin dalam?', answer: 'Margin dalam adalah ruang tambahan di dekat tepi jilid. Ruang ini menjauhkan teks dan detail penting dari bagian halaman ganda yang sulit dibaca setelah dijilid.' },
+  { question: 'Mengapa margin dalam bertambah sesuai jumlah halaman?', answer: 'Buku yang lebih tebal memasukkan lebih banyak kertas ke dalam jilid. Karena itu, rentang referensi menaikkan margin dalam minimum saat blok buku bertambah.' },
+  { question: 'Apa yang berubah saat karya sampai tepi diaktifkan?', answer: 'Gambar sampai tepi membutuhkan area tambahan di luar garis potong. Perencana ini juga memperbesar margin luar aman agar teks dan detail penting menjauh dari potongan.' },
+  { question: 'Bolehkah nilai ini langsung dikirim ke percetakan?', answer: 'Tidak. Gunakan sebagai ringkasan tata letak. Templat percetakan untuk ukuran, kertas, jilid, dan metode produksi yang dipilih tetap menjadi acuan akhir.' },
+];
+
+const howTo = [
+  { name: 'Masukkan format isi', text: 'Atur jumlah halaman akhir serta lebar dan tinggi potong buku.' },
+  { name: 'Pilih konteks produksi', text: 'Pilih jilid, jenis kertas, dan apakah isi memakai karya sampai tepi.' },
+  { name: 'Baca rencana halaman', text: 'Gunakan margin dalam, margin luar, dan ukuran teks aman sebagai batas awal.' },
+  { name: 'Konfirmasikan berkas cetak', text: 'Bandingkan rencana dengan templat dan toleransi produksi dari percetakan.' },
+];
+
+const seo: ToolLocaleContent<BookInteriorUI>['seo'] = [
+  { type: 'title', text: 'Merencanakan margin dalam dan jilid untuk isi buku', level: 2 },
+  { type: 'paragraph', html: 'Tentukan titik awal praktis untuk isi buku siap cetak. Jumlah halaman, ukuran jadi, jilid, kertas, dan area sampai tepi diterjemahkan menjadi margin dalam, margin luar aman, serta area teks yang dapat digunakan pada dua halaman.' },
+  { type: 'title', text: 'Cara kerja rencana margin', level: 2 },
+  { type: 'list', items: ['Masukkan halaman dan ukuran jadi, lalu pilih jilid yang sesuai.', 'Aktifkan karya sampai tepi saat gambar atau latar berlanjut melewati garis potong.', 'Anggap margin dalam sebagai minimum dan jauhkan teks, nomor halaman, serta tabel dari lipatan tengah.', 'Gunakan lebar dan tinggi aman sebagai batas tata letak awal sebelum menerapkan templat percetakan.'] },
+  { type: 'title', text: 'Mengapa jumlah halaman mengubah margin dalam', level: 2 },
+  { type: 'paragraph', html: 'Blok buku yang lebih tebal mendorong lebih banyak kertas ke tepi jilid. Rentang referensi naik dari 9,6 mm untuk 24 sampai 150 halaman menjadi 22,3 mm untuk 701 sampai 828 halaman. Buku berjilid dibulatkan ke jumlah halaman genap dan buklet kawat tengah ke kelipatan empat.' },
+  { type: 'table', headers: ['Halaman isi', 'Margin dalam', 'Margin luar tanpa area sampai tepi'], rows: [['24 sampai 150', '9,6 mm', 'minimum 6,4 mm'], ['151 sampai 300', '12,7 mm', 'minimum 6,4 mm'], ['301 sampai 500', '15,9 mm', 'minimum 6,4 mm'], ['501 sampai 700', '19,1 mm', 'minimum 6,4 mm'], ['701 sampai 828', '22,3 mm', 'minimum 6,4 mm']] },
+  { type: 'tip', title: 'Jangan menata tepat di batas minimum', html: 'Nilai minimum adalah batas produksi, bukan jaminan kenyamanan membaca. Sisakan ruang untuk huruf lebar, nomor halaman, ilustrasi, dan cara jilid membuka buku.' },
+  { type: 'title', text: 'Area sampai tepi dan zona aman memiliki fungsi berbeda', level: 2 },
+  { type: 'paragraph', html: 'Area sampai tepi memberi gambar dan latar ruang ekstra untuk bertahan saat dipotong. Area ini tidak membuat teks aman di dekat potongan atau jilid. Simpan elemen penting di dalam zona aman dan panjangkan hanya karya yang memang harus mencapai tepi.' },
+  { type: 'tip', title: 'Gunakan hasil sebagai ringkasan tata letak', html: 'Catat ukuran jadi, halaman, jilid, kertas, margin dalam, dan area sampai tepi di samping berkas desain. Jika kertas atau jilid berubah, hitung ulang ringkasannya.' },
+];
+
+export const content: ToolLocaleContent<BookInteriorUI> = {
+  slug: 'perencana-margin-dalam-dan-gutter-buku', title: 'Perencana margin dalam dan jilid isi buku',
+  description: 'Rencanakan margin dalam, margin luar aman, dan area teks isi buku sebelum mulai menata halaman.',
+  ui, seo, faq, bibliography, howTo,
+  schemas: [
+    { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: 'Perencana margin dalam dan jilid isi buku', applicationCategory: 'DesignApplication', operatingSystem: 'Any', offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' } },
+    { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+    { '@context': 'https://schema.org', '@type': 'HowTo', name: 'Merencanakan margin dalam buku', step: howTo.map((item) => ({ '@type': 'HowToStep', name: item.name, text: item.text })) },
+  ],
+};