path: root/frontend/src/pages/OverviewPage.vue

<!-- SPDX-FileCopyrightText: 2026 Progmasoft <support@progmasoft.com> -->
<!-- SPDX-License-Identifier: AGPL-3.0-or-later WITH AdditionRef-Progmasoft-Patent-Grant-1.1 -->

<script setup lang="ts">
import DocShell from "../components/DocShell.vue";
import { computed } from "vue";
import { RouterLink } from "vue-router";
import { arrow, locale } from "../preferences";

const text = {
  "en-US": {
    navOverview: "Overview",
    navStart: "Getting started",
    section: "DOCUMENTATION / OVERVIEW",
    title: "What Tala is trying to solve",
    lead: "Tala is designed around a simple question: can expressive code remain understandable when ownership, types, and native compilation matter? This page explains the direction, not a promise that every feature is finished.",
    goals: "Design goals",
    modelHeading: "A few language choices",
    modelIntro:
      "These are design contracts described by the public specification. Check the compiler's current coverage before treating a contract as a usable production feature.",
    model: [
      {
        title: "A class owns the entry point",
        body: "A program starts in a parameterless public static void Main() method on the configured entry class. The class may live in any source file; its namespace does not have to mirror folders.",
      },
      {
        title: "Types carry ownership consequences",
        body: "Value types remain value types only when every nested generic argument is a value type. A reference type anywhere in the generic structure makes the result a reference type.",
      },
      {
        title: "One standard library surface",
        body: "System namespaces own core facilities such as console I/O, arrays, text, and math. A standard library namespace is not a separately declared package dependency.",
      },
      {
        title: "Native output, without pretending the pipeline is finished",
        body: "The compiler has a source-to-native path for its implemented subset. The target is broader semantic coverage, verified intermediate boundaries, and reliable diagnostics as the language grows.",
      },
    ],
    pipelineHeading: "The compiler has visible boundaries",
    pipelineIntro:
      "The architecture is intentionally divided so each stage can reject malformed input and preserve what the previous stage established.",
    pipeline: [
      {
        title: "Source and syntax",
        body: "The Haskell lexer and parser produce a parsed AST while retaining source locations for diagnostics.",
      },
      {
        title: "Names and types",
        body: "Renaming, name resolution, and type checking produce distinct resolved and typed AST forms.",
      },
      {
        title: "Language semantics",
        body: "Desugaring and Core optimizations operate before the private CorePrep adapter.",
      },
      {
        title: "Native adaptation",
        body: "C++20 Xpp and Xmm stages carry a verified, target-independent representation toward LLVM.",
      },
      {
        title: "Executable",
        body: "LLVM lowers the verified program to object code, then a platform link step creates an executable of the host.",
      },
    ],
    boundariesHeading: "Where the boundaries are today",
    boundaries: [
      {
        label: "Public language contract",
        value: "Spec/ examples and the related Documents/ guides",
      },
      {
        label: "Implementation truth",
        value: "Compiler tests, supported subset, and explicit diagnostics",
      },
      {
        label: "Project definition",
        value:
          "A project file, BUILD.kts or one of four other names, evaluated by Tazel, the build system",
      },
      {
        label: "Website",
        value: "Language introduction and guides; no account or package-management surface",
      },
    ],
    questionHeading: "Common questions",
    questions: [
      {
        q: "Is Tala ready for production?",
        a: "No general production-readiness claim is made. The compiler and runtime are still developing. Use the repository's test gates and release notes to evaluate a specific feature.",
      },
      {
        q: "Is the public Spec an executable test suite?",
        a: "Not in its entirety. It includes intended valid and invalid fragments. Some examples document semantics before complete compiler support exists.",
      },
      {
        q: "Why show the intermediate stages?",
        a: "Each stage has an owner and a verifier boundary. This is meant to make compiler behavior auditable and to keep later stages from inventing source-language meaning.",
      },
      {
        q: "Does Tala require a particular IDE?",
        a: "No. The supported developer workflow uses command-line tools on Windows, macOS and Linux; the Xide project is a future interface, not a prerequisite.",
      },
    ],
    items: [
      {
        title: "Semantics before shortcuts",
        body: "The source language has a written specification. The compiler separates parsed, resolved, and typed syntax so later passes receive explicit meaning instead of guessing.",
      },
      {
        title: "Ownership you can follow",
        body: "Reference and value behavior is defined through type composition. Automatic reference counting and copy-on-write rules are part of the language model; runtime and lowering support are still being completed.",
      },
      {
        title: "A deliberate native pipeline",
        body: "The front end lowers through Core and CorePrep, then Xpp and Xmm adapt the program for LLVM code generation. Boundaries make validation and diagnostics possible at each stage.",
      },
    ],
    not: "What it is not",
    notText:
      "Tala is not presented as a finished replacement for established production languages. The specification records intended semantics; buildable compiler coverage should be checked separately. This language website does not host accounts or package management.",
    next: "Ready to look closer?",
    nextText:
      "Start with a small program, then explore the public specification and source repository.",
    start: "Getting started",
    spec: "Read the specification",
    source: "View source",
  },
  "de-DE": {
    navOverview: "Überblick",
    navStart: "Erste Schritte",
    section: "DOKUMENTATION / ÜBERBLICK",
    title: "Welches Problem Tala lösen will",
    lead: "Tala stellt eine Frage: Kann ausdrucksstarker Code verständlich bleiben, wenn Ownership, Typen und native Kompilierung wichtig sind? Diese Seite erklärt das Ziel, nicht die Fertigstellung aller Funktionen.",
    goals: "Entwurfsziele",
    modelHeading: "Einige Sprachentscheidungen",
    modelIntro:
      "Diese Verträge beschreibt die öffentliche Spezifikation. Prüfen Sie den aktuellen Compilerumfang, bevor Sie eine Regel als produktiv nutzbare Funktion voraussetzen.",
    model: [
      {
        title: "Der Einstiegspunkt gehört zu einer Klasse",
        body: "Ein Programm beginnt in der parameterlosen Methode public static void Main() der konfigurierten Einstiegsklasse. Die Quelldatei ist frei wählbar; Namespaces müssen Verzeichnisse nicht spiegeln.",
      },
      {
        title: "Typen beeinflussen das Ownership",
        body: "Ein generischer Typ bleibt nur dann ein Werttyp, wenn alle verschachtelten Typargumente Werttypen sind. Ein Referenztyp an beliebiger Stelle macht das Ergebnis zum Referenztyp.",
      },
      {
        title: "Eine Oberfläche für die Standardbibliothek",
        body: "System-Namespaces stellen unter anderem Konsole, Arrays, Text und Mathematik bereit. Ein Standardbibliotheks-Namespace ist keine separat einzutragende Paketabhängigkeit.",
      },
      {
        title: "Native Ausgabe ohne fertige Pipeline vorzutäuschen",
        body: "Für den implementierten Teilumfang gibt es einen Weg von Quellcode zu nativem Code. Das Ziel sind breitere Semantik, geprüfte Zwischenschritte und verlässliche Diagnosen.",
      },
    ],
    pipelineHeading: "Der Compiler hat sichtbare Grenzen",
    pipelineIntro:
      "Die Architektur ist bewusst aufgeteilt, damit jede Stufe fehlerhafte Eingaben ablehnen und die Aussagen der vorherigen Stufe erhalten kann.",
    pipeline: [
      {
        title: "Quellcode und Syntax",
        body: "Lexer und Parser in Haskell erzeugen einen geparsten AST mit Quellpositionen für Diagnosen.",
      },
      {
        title: "Namen und Typen",
        body: "Umbenennung, Namensauflösung und Typprüfung erzeugen getrennte aufgelöste und typisierte AST-Formen.",
      },
      {
        title: "Sprachsemantik",
        body: "Desugaring und Core-Optimierungen liegen vor dem privaten CorePrep-Adapter.",
      },
      {
        title: "Native Anpassung",
        body: "Die C++20-Stufen Xpp und Xmm tragen eine geprüfte, zielunabhängige Darstellung zu LLVM.",
      },
      {
        title: "Ausführbare Datei",
        body: "LLVM senkt das geprüfte Programm zu Objektcode ab; anschließend entsteht durch den Plattform-Linker eine ausführbare Datei des Hosts.",
      },
    ],
    boundariesHeading: "Die heutigen Zuständigkeiten",
    boundaries: [
      {
        label: "Öffentlicher Sprachvertrag",
        value: "Beispiele unter Spec/ und ergänzende Anleitungen unter Documents/",
      },
      {
        label: "Tatsächliche Implementierung",
        value: "Compiler-Tests, unterstützter Teilumfang und explizite Diagnosen",
      },
      {
        label: "Projektdefinition",
        value:
          "Eine Projektdatei, BUILD.kts oder einer von vier weiteren Namen, ausgewertet von Tazel, dem Build-System",
      },
      {
        label: "Website",
        value: "Spracheinführung und Anleitungen; keine Konto- oder Paketverwaltung",
      },
    ],
    questionHeading: "Häufige Fragen",
    questions: [
      {
        q: "Ist Tala produktionsreif?",
        a: "Eine allgemeine Zusage zur Produktionsreife gibt es nicht. Compiler und Runtime entwickeln sich weiter. Prüfen Sie Tests und Release-Hinweise für die jeweils benötigte Funktion.",
      },
      {
        q: "Ist die öffentliche Spec eine ausführbare Testsuite?",
        a: "Nicht vollständig. Sie enthält beabsichtigte gültige und ungültige Fragmente. Einige Beispiele gehen der vollständigen Compiler-Unterstützung voraus.",
      },
      {
        q: "Warum werden die Zwischenstufen gezeigt?",
        a: "Jede Stufe hat eine Zuständigkeit und eine Prüfgrenze. So bleibt Compilerverhalten nachvollziehbar und spätere Stufen erfinden keine Sprachsemantik.",
      },
      {
        q: "Benötigt Tala eine bestimmte IDE?",
        a: "Nein. Der unterstützte Entwicklungsweg nutzt Kommandozeilenwerkzeuge unter Windows, macOS und Linux; Xide ist eine künftige Oberfläche, keine Voraussetzung.",
      },
    ],
    items: [
      {
        title: "Semantik vor Abkürzungen",
        body: "Die Sprache hat eine öffentliche Spezifikation. Der Compiler trennt geparste, aufgelöste und typisierte Syntax, damit spätere Schritte nicht raten müssen.",
      },
      {
        title: "Nachvollziehbares Ownership",
        body: "Referenz- und Wertverhalten folgen der Typzusammensetzung. Automatische Referenzzählung und Copy-on-Write gehören zum Modell; Laufzeit und Lowering werden noch vervollständigt.",
      },
      {
        title: "Eine bewusste native Pipeline",
        body: "Das Frontend senkt über Core und CorePrep zu Xpp und Xmm ab; danach folgt LLVM. Die Grenzen ermöglichen Validierung und Diagnose in jeder Phase.",
      },
    ],
    not: "Was es nicht ist",
    notText:
      "Tala wird nicht als fertiger Ersatz für etablierte Produktionssprachen dargestellt. Die Spezifikation hält beabsichtigte Semantik fest; der tatsächlich kompilierbare Umfang ist getrennt zu prüfen. Diese Sprachwebsite bietet weder Konten noch Paketverwaltung.",
    next: "Mehr erfahren?",
    nextText:
      "Beginnen Sie mit einem kleinen Programm und lesen Sie anschließend die öffentliche Spezifikation und den Quellcode.",
    start: "Erste Schritte",
    spec: "Spezifikation lesen",
    source: "Quellcode ansehen",
  },
  "ru-RU": {
    navOverview: "Обзор",
    navStart: "Начало работы",
    section: "ДОКУМЕНТАЦИЯ / ОБЗОР",
    title: "Какую задачу решает Tala",
    lead: "Tala строится вокруг простого вопроса: может ли выразительный код оставаться понятным, когда важны владение, типы и нативная компиляция? Эта страница объясняет направление и не обещает, что каждая возможность уже готова.",
    goals: "Цели проектирования",
    modelHeading: "Несколько решений языка",
    modelIntro:
      "Это проектные контракты, описанные в публичной спецификации. Прежде чем считать контракт возможностью, пригодной для реальной работы, проверьте текущий охват компилятора.",
    model: [
      {
        title: "Точка входа принадлежит классу",
        body: "Программа начинается в методе public static void Main() без параметров в настроенном классе входа. Класс может находиться в любом исходном файле; его пространство имён не обязано повторять каталоги.",
      },
      {
        title: "Типы определяют владение",
        body: "Тип остаётся типом-значением, только если каждый вложенный обобщённый аргумент — тип-значение. Ссылочный тип в любом месте обобщённой структуры делает результат ссылочным типом.",
      },
      {
        title: "Единая стандартная библиотека",
        body: "Пространства имён System содержат базовые средства: консольный ввод-вывод, массивы, текст и математику. Пространство имён стандартной библиотеки не является отдельно объявляемой зависимостью-пакетом.",
      },
      {
        title: "Нативный результат без видимости готового конвейера",
        body: "Для реализованного подмножества у компилятора есть путь от исходного кода до нативного кода. Цель — более широкий охват семантики, проверяемые промежуточные границы и надёжная диагностика по мере роста языка.",
      },
    ],
    pipelineHeading: "У компилятора видимые границы",
    pipelineIntro:
      "Архитектура намеренно разделена, чтобы каждая стадия могла отклонить некорректный вход и сохранить установленное предыдущей стадией.",
    pipeline: [
      {
        title: "Исходный код и синтаксис",
        body: "Лексер и парсер на Haskell строят разобранное AST, сохраняя позиции в исходном коде для диагностики.",
      },
      {
        title: "Имена и типы",
        body: "Переименование, разрешение имён и проверка типов создают отдельные формы AST: разрешённую и типизированную.",
      },
      {
        title: "Семантика языка",
        body: "Раскрытие синтаксического сахара и оптимизации Core выполняются до внутреннего адаптера CorePrep.",
      },
      {
        title: "Нативная адаптация",
        body: "Стадии Xpp и Xmm на C++20 переносят проверенное, не зависящее от целевой платформы представление к LLVM.",
      },
      {
        title: "Исполняемый файл",
        body: "LLVM понижает проверенную программу до объектного кода, после чего шаг компоновки для платформы создаёт исполняемый файл системы.",
      },
    ],
    boundariesHeading: "Где проходят границы сегодня",
    boundaries: [
      {
        label: "Публичный контракт языка",
        value: "Примеры в Spec/ и связанные руководства в Documents/",
      },
      {
        label: "Фактическая реализация",
        value: "Тесты компилятора, поддерживаемое подмножество и явная диагностика",
      },
      {
        label: "Описание проекта",
        value:
          "Файл проекта — BUILD.kts или одно из четырёх других имён, — который выполняет Tazel, система сборки",
      },
      {
        label: "Сайт",
        value: "Введение в язык и руководства; без аккаунтов и управления пакетами",
      },
    ],
    questionHeading: "Частые вопросы",
    questions: [
      {
        q: "Готов ли Tala к использованию в продакшене?",
        a: "Общего заявления о готовности к продакшену нет. Компилятор и среда выполнения ещё развиваются. Оценивайте конкретную возможность по тестам репозитория и заметкам к выпускам.",
      },
      {
        q: "Является ли публичная спецификация исполняемым набором тестов?",
        a: "Не целиком. В ней есть задуманные допустимые и недопустимые фрагменты. Некоторые примеры описывают семантику до появления полной поддержки в компиляторе.",
      },
      {
        q: "Зачем показывать промежуточные стадии?",
        a: "У каждой стадии есть владелец и граница проверки. Так поведение компилятора можно проверить, а поздние стадии не придумывают смысл исходного языка.",
      },
      {
        q: "Нужна ли для Tala определённая IDE?",
        a: "Нет. Поддерживаемый процесс разработки использует инструменты командной строки в Windows, macOS и Linux; проект Xide — будущий интерфейс, а не обязательное условие.",
      },
    ],
    items: [
      {
        title: "Семантика важнее обходных путей",
        body: "У исходного языка есть письменная спецификация. Компилятор разделяет разобранный, разрешённый и типизированный синтаксис, чтобы поздние проходы получали явный смысл, а не догадывались.",
      },
      {
        title: "Владение, за которым можно проследить",
        body: "Поведение ссылок и значений определяется составом типов. Автоматический подсчёт ссылок и правила копирования при записи входят в модель языка; поддержка во время выполнения и понижение ещё завершаются.",
      },
      {
        title: "Продуманный нативный конвейер",
        body: "Фронтенд понижает программу через Core и CorePrep, затем Xpp и Xmm подготавливают её к генерации кода LLVM. Границы позволяют выполнять проверку и диагностику на каждой стадии.",
      },
    ],
    not: "Чем он не является",
    notText:
      "Tala не представлен как готовая замена устоявшимся языкам для продакшена. Спецификация фиксирует задуманную семантику; фактически собираемый охват компилятора следует проверять отдельно. На этом сайте языка нет аккаунтов и управления пакетами.",
    next: "Хотите узнать больше?",
    nextText:
      "Начните с небольшой программы, а затем изучите публичную спецификацию и репозиторий с исходным кодом.",
    start: "Начало работы",
    spec: "Читать спецификацию",
    source: "Смотреть исходный код",
  },
  "he-IL": {
    navOverview: "סקירה",
    navStart: "צעדים ראשונים",
    section: "תיעוד / סקירה",
    title: "מה Tala מנסה לפתור",
    lead: "Tala מתוכננת סביב שאלה פשוטה: האם קוד אקספרסיבי יכול להישאר מובן כאשר בעלות, טיפוסים והידור לקוד מכונה חשובים? העמוד הזה מסביר את הכיוון, ואינו הבטחה שכל יכולת כבר מוגמרת.",
    goals: "יעדי התכנון",
    modelHeading: "כמה בחירות של השפה",
    modelIntro:
      "אלה חוזי תכנון שמתוארים במפרט הציבורי. לפני שמתייחסים לחוזה כאל יכולת שמישה בסביבת ייצור, יש לבדוק את הכיסוי הנוכחי של המהדר.",
    model: [
      {
        title: "נקודת הכניסה שייכת למחלקה",
        body: "תוכנית מתחילה במתודה public static void Main() ללא פרמטרים במחלקת הכניסה שהוגדרה. המחלקה יכולה להימצא בכל קובץ מקור; מרחב השמות שלה אינו חייב לשקף את מבנה התיקיות.",
      },
      {
        title: "לטיפוסים יש השלכות על בעלות",
        body: "טיפוס ערך נשאר טיפוס ערך רק כאשר כל ארגומנט גנרי מקונן הוא טיפוס ערך. טיפוס הפניה בכל מקום במבנה הגנרי הופך את התוצאה לטיפוס הפניה.",
      },
      {
        title: "ספרייה סטנדרטית אחת",
        body: "מרחבי השמות של System מחזיקים את היכולות הבסיסיות, כגון קלט ופלט במסוף, מערכים, טקסט ומתמטיקה. מרחב שמות של הספרייה הסטנדרטית אינו תלות חבילה שמצהירים עליה בנפרד.",
      },
      {
        title: "פלט בקוד מכונה, בלי להעמיד פנים שהתהליך מוגמר",
        body: "למהדר יש נתיב מקוד מקור לקוד מכונה עבור תת־הקבוצה שמומשה. היעד הוא כיסוי סמנטי רחב יותר, גבולות ביניים מאומתים והודעות אבחון אמינות ככל שהשפה גדלה.",
      },
    ],
    pipelineHeading: "למהדר יש גבולות גלויים",
    pipelineIntro:
      "הארכיטקטורה מחולקת בכוונה, כך שכל שלב יכול לדחות קלט פגום ולשמר את מה שהשלב הקודם קבע.",
    pipeline: [
      {
        title: "קוד מקור ותחביר",
        body: "המנתח הלקסיקלי והמנתח התחבירי, הכתובים ב-Haskell, מפיקים AST מנותח ושומרים את מיקומי המקור לצורך הודעות אבחון.",
      },
      {
        title: "שמות וטיפוסים",
        body: "שינוי שמות, פענוח שמות ובדיקת טיפוסים מפיקים צורות AST נפרדות: מפוענחת ובעלת טיפוסים.",
      },
      {
        title: "סמנטיקת השפה",
        body: "פירוק הסוכר התחבירי והאופטימיזציות של Core פועלים לפני המתאם הפרטי CorePrep.",
      },
      {
        title: "התאמה לקוד מכונה",
        body: "השלבים Xpp ו-Xmm, הכתובים ב-C++20, נושאים ייצוג מאומת ובלתי תלוי ביעד לקראת LLVM.",
      },
      {
        title: "קובץ הרצה",
        body: "LLVM מתרגם את התוכנית המאומתת לקוד אובייקט, ולאחר מכן שלב קישור של הפלטפורמה יוצר קובץ הרצה של המערכת.",
      },
    ],
    boundariesHeading: "היכן עוברים הגבולות היום",
    boundaries: [
      {
        label: "חוזה השפה הציבורי",
        value: "הדוגמאות ב-Spec/‎ והמדריכים הקשורים ב-Documents/‎",
      },
      {
        label: "האמת של המימוש",
        value: "בדיקות המהדר, תת־הקבוצה הנתמכת והודעות אבחון מפורשות",
      },
      {
        label: "הגדרת הפרויקט",
        value: "קובץ פרויקט, BUILD.kts או אחד מארבעה שמות אחרים, ש-Tazel, מערכת הבנייה, מריצה",
      },
      {
        label: "האתר",
        value: "היכרות עם השפה ומדריכים; בלי חשבונות ובלי ניהול חבילות",
      },
    ],
    questionHeading: "שאלות נפוצות",
    questions: [
      {
        q: "האם Tala מוכנה לסביבת ייצור?",
        a: "אין כאן הצהרה כללית על מוכנות לסביבת ייצור. המהדר וסביבת זמן הריצה עדיין מתפתחים. כדי להעריך יכולת מסוימת, היעזרו בשערי הבדיקות של המאגר ובהערות הגרסה.",
      },
      {
        q: "האם המפרט הציבורי הוא חבילת בדיקות שאפשר להריץ?",
        a: "לא במלואו. הוא כולל קטעים תקינים ושגויים מתוכננים. חלק מהדוגמאות מתעדות סמנטיקה לפני שקיימת לה תמיכה מלאה במהדר.",
      },
      {
        q: "למה להציג את שלבי הביניים?",
        a: "לכל שלב יש בעלים וגבול אימות. המטרה היא שאפשר יהיה לבקר את התנהגות המהדר, ושהשלבים המאוחרים לא ימציאו משמעות לשפת המקור.",
      },
      {
        q: "האם Tala דורשת סביבת פיתוח מסוימת?",
        a: "לא. תהליך הפיתוח הנתמך משתמש בכלי שורת פקודה ב-Windows, ב-macOS וב-Linux; הפרויקט Xide הוא ממשק עתידי, לא דרישה מוקדמת.",
      },
    ],
    items: [
      {
        title: "סמנטיקה לפני קיצורי דרך",
        body: "לשפת המקור יש מפרט כתוב. המהדר מפריד בין תחביר מנותח, מפוענח ובעל טיפוסים, כך שהמעברים המאוחרים מקבלים משמעות מפורשת במקום לנחש.",
      },
      {
        title: "בעלות שאפשר לעקוב אחריה",
        body: "ההתנהגות של הפניות ושל ערכים מוגדרת דרך הרכב הטיפוסים. ספירת הפניות אוטומטית וכללי העתקה־בעת־כתיבה הם חלק ממודל השפה; התמיכה בזמן ריצה ובתרגום לשלבים הנמוכים עדיין בהשלמה.",
      },
      {
        title: "תהליך הידור מכוון לקוד מכונה",
        body: "ה-frontend מתרגם את התוכנית דרך Core ו-CorePrep, ולאחר מכן Xpp ו-Xmm מתאימים אותה ליצירת הקוד של LLVM. הגבולות מאפשרים אימות והודעות אבחון בכל שלב.",
      },
    ],
    not: "מה היא איננה",
    notText:
      "Tala אינה מוצגת כתחליף מוגמר לשפות ייצור מבוססות. המפרט מתעד את הסמנטיקה המיועדת; את הכיסוי שהמהדר אכן בונה יש לבדוק בנפרד. אתר השפה הזה אינו מארח חשבונות או ניהול חבילות.",
    next: "רוצים להתעמק?",
    nextText: "התחילו בתוכנית קטנה, ואז עיינו במפרט הציבורי ובמאגר קוד המקור.",
    start: "צעדים ראשונים",
    spec: "לקריאת המפרט",
    source: "לצפייה בקוד המקור",
  },
} as const;
const c = computed(() => text[locale.value]);
</script>

<template>
  <DocShell path="/docs/overview" edit-path="src/pages/OverviewPage.vue">
    <h1>{{ c.title }}</h1>
    <p class="doc-lead">{{ c.lead }}</p>
    <h2>{{ c.goals }}</h2>
    <div class="doc-points">
      <section v-for="item in c.items" :key="item.title">
        <h3>{{ item.title }}</h3>
        <p>{{ item.body }}</p>
      </section>
    </div>
    <h2>{{ c.modelHeading }}</h2>
    <p>{{ c.modelIntro }}</p>
    <div class="doc-points">
      <section v-for="item in c.model" :key="item.title">
        <h3>{{ item.title }}</h3>
        <p>{{ item.body }}</p>
      </section>
    </div>
    <h2>{{ c.pipelineHeading }}</h2>
    <p>{{ c.pipelineIntro }}</p>
    <ol class="doc-pipeline">
      <li v-for="step in c.pipeline" :key="step.title">
        <h3>{{ step.title }}</h3>
        <p>{{ step.body }}</p>
      </li>
    </ol>
    <h2>{{ c.boundariesHeading }}</h2>
    <dl class="doc-boundaries">
      <div v-for="boundary in c.boundaries" :key="boundary.label">
        <dt>{{ boundary.label }}</dt>
        <dd>{{ boundary.value }}</dd>
      </div>
    </dl>
    <h2>{{ c.not }}</h2>
    <p>{{ c.notText }}</p>
    <h2>{{ c.questionHeading }}</h2>
    <div class="doc-points">
      <section v-for="question in c.questions" :key="question.q">
        <h3>{{ question.q }}</h3>
        <p>{{ question.a }}</p>
      </section>
    </div>
    <div class="doc-next">
      <h2>{{ c.next }}</h2>
      <p>{{ c.nextText }}</p>
      <div class="doc-actions">
        <RouterLink class="button button-primary" to="/docs/getting-started"
          >{{ c.start }} {{ arrow }}</RouterLink
        ><a class="button button-quiet" href="https://github.com/Progmasoft/tala/tree/main/Spec"
          >{{ c.spec }} ↗</a
        ><a class="inline-link" href="https://github.com/Progmasoft/tala">{{ c.source }} ↗</a>
      </div>
    </div>
  </DocShell>
</template>