path: root/frontend/src/content/tazel.ts

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

import type { DocRoute, DocTopic } from "./types";

const everyday = `tazel check
tazel build
tazel run -- arguments for the program
tazel fmt -- --check
tazel lint -- --fix`;
const selection = `tazel build --vipkg Name          tazel build -p Name
tazel build --executable Name     tazel build -e Name
tazel build --library Name        tazel build -l Name`;
const machine = `tazel build --jobs 8 --cpus 6 --memory 16g
tazel test --keep-going --profile build/trace.json
tazel build --remote-executor https://build.example.com`;
const custom = `# tazel_custom.txt
fetch:
    ("cargo" "fetch")
    ("tazel" "fetch");

npm-dev-sh: s('npm dev');

build no-cache: ("tazel" "build" "--no-cache");
build with: ("tazel" "build" <1> <2>);
test all: ("tazel" "test" <*>);`;
const customRuns = `tazel custom fetch
tazel custom build no-cache
tazel custom build with -e MyApp`;
const locking = `tazel lock create-dump --path reviews/Locks.sql
tazel lock graph --locked
tazel lock graph --invert Publisher.Name
tazel lock graph --duplicates --depth 1`;
const minimal = `project {
  name = "Example"
}

sources {
  executable {
    entry = "Example.Program"
  }
}`;
const compiler = `compiler {
  standard = talaStandardOf(26)
  buildMode = BuildMode.RELEASE
  warnings = Warnings.ALL
  wshadow = true
  optLevel = OptLevel.O3

  llvm {
    lto = LlvmLto.NONE
  }
}`;
const execution = `execution {
  jobs = 8
  cpus = 6
  memory = "16g"
  keepGoing = true
  incremental = true

  remote {
    url = "https://build.example.com"
    token = System.getenv("TAZEL_REMOTE_TOKEN")
  }
}`;
const dependencies = `dependencies {
  dependency("Publisher") {
    name = "Toml"
    version = "1.0.0"
    feature = "TOML"
  }

  localDependency { path = "Dependency.vipkg" }
  testDependency("Publisher") {
    name = "TestDep"
    version = "0.1.0"
  }
}`;
const workspace = `workspace {
  members("./Server", "../Shared", "Client")
  defaultMembers("./Server")
  exclude("OldProject")
}`;

const commandTerms = (
  d: Record<
    | "check"
    | "build"
    | "run"
    | "test"
    | "fetch"
    | "custom"
    | "resolve"
    | "dump"
    | "graph"
    | "fmt"
    | "lint"
    | "cache"
    | "remote"
    | "daemon"
    | "version"
    | "help"
    | "registry",
    string
  >,
) => [
  { term: "tazel check", detail: d.check },
  { term: "tazel build", detail: d.build },
  { term: "tazel run [-- arguments]", detail: d.run },
  { term: "tazel test", detail: d.test },
  { term: "tazel fetch", detail: d.fetch },
  { term: "tazel custom [name] [arguments]", detail: d.custom },
  { term: "tazel lock resolve", detail: d.resolve },
  { term: "tazel lock create-dump [--path File]", detail: d.dump },
  { term: "tazel lock graph [options]", detail: d.graph },
  { term: "tazel fmt [-- options]", detail: d.fmt },
  { term: "tazel lint [--workspace] [-- options]", detail: d.lint },
  { term: "tazel cache status, clean, push, pull, keygen, serve", detail: d.cache },
  { term: "tazel remote serve", detail: d.remote },
  { term: "tazel jvm start-daemon, restart-daemon, stop-daemon", detail: d.daemon },
  { term: "tazel version", detail: d.version },
  { term: "tazel help [command]", detail: d.help },
  {
    term: "tazel install, update, vipkg create, viget push, viget update, viget vipkg-desc",
    detail: d.registry,
  },
];

const commands: DocTopic = {
  "en-US": {
    nav: "Commands",
    title: "Commands · Tazel",
    description:
      "The commands of Tazel, the build system and package manager of Tala, and how they select targets.",
    section: "TAZEL / COMMANDS",
    heading: "The build system and its commands",
    lead: "Tazel reads the project file, finds the sources and starts Talac, talafmt or talalint as separate programs. It compiles nothing itself. The name joins Tala and Bazel.",
    blocks: [
      { kind: "code", code: everyday },
      {
        kind: "terms",
        items: commandTerms({
          check:
            "Starts Talac with --emit=metadata and the compiler options of the project. Writes no executable.",
          build:
            "Builds the executables into the output directory of the build mode, under the name of the target.",
          run: "Builds the executables and runs them; what follows -- goes to the program.",
          test: "Builds and runs the test suites.",
          fetch:
            "Fetches plugins of ViGet into .tazel/plugins ahead of time, and fails if a local package is missing.",
          custom: "Runs a command of tazel_custom.txt, or lists them.",
          resolve: "Records the declared dependencies in LOCK.sqlite3.",
          dump: "Writes the lockfile as SQL text: to LOCK.dump, or to the file --path names. The folder of that file has to exist.",
          graph:
            "Prints the dependency graph and renews LOCK.sqlite3 first, unless --locked forbids it.",
          fmt: "Formats the sources with talafmt.",
          lint: "Lints the sources with talalint.",
          cache:
            "Show, clean, send or fetch the results of the build cache, and serve one for a team.",
          remote: "Compiles for other machines, on the sources they send.",
          daemon: "Keep Tazel warm between commands, or stop it.",
          version: "Prints the version of Tazel.",
          help: "Prints the help, or the help of one command.",
          registry:
            "Commands that need ViGet or a library build; they are refused by name until those exist.",
        }),
      },
      { kind: "heading", text: "Spending the machine" },
      {
        kind: "text",
        text: "check, build, run and test run compiler runs and test suites side by side, one job per processor. --jobs, --cpus and --memory limit them, --keep-going goes on after a failure, and --profile writes a trace for chrome://tracing or Perfetto. Each project's plugin steps, compilations and test suites are units of one graph, so a unit waits only for what it depends on.",
      },
      { kind: "code", code: machine },
      {
        kind: "text",
        text: "--remote-executor compiles on another machine, one you trust, that runs tazel remote serve. Programs and test suites still run here, and if the server cannot help, Tazel warns once and compiles here.",
      },
      { kind: "heading", text: "Custom commands" },
      {
        kind: "text",
        text: "tazel custom runs the commands of tazel_custom.txt, from the current folder or the nearest one above it. They need no project file and do not have to involve Tazel.",
      },
      { kind: "code", code: custom },
      { kind: "code", code: customRuns },
      {
        kind: "text",
        text: "Steps run in order. (...) starts a program directly, with no shell, and s(...) hands one command line, unchanged, to CMD on Windows and sh elsewhere, so any escapes in it are for that shell. A name may hold several words, and the longest name that fits wins; the first -- ends the name, so tazel custom first -- second passes second to first even if a command first second exists. The -- is neither an argument nor one of the 191 words. <N> passes the Nth argument, from 1, and <*> passes all of them; neither works in s(...). The name and its arguments are at most 191 words.",
      },
      { kind: "heading", text: "Selecting targets" },
      {
        kind: "text",
        text: "check, build, run, test and lint work on everything unless a selection names what to work on. A flag of Tazel takes its value from the next argument and may be written several times. A name that selects nothing is an error.",
      },
      { kind: "code", code: selection },
      { kind: "heading", text: "Passing arguments on" },
      {
        kind: "text",
        text: "Everything after -- goes unread to the program a command starts: tazel lint -- --fix hands --fix to talalint, tazel run -- --port 8080 hands --port 8080 to the program.",
      },
      { kind: "heading", text: "The lockfile and the graph" },
      {
        kind: "text",
        text: "tazel lock graph prints what each project depends on. --all-features turns every feature of the project on, --duplicates shows the packages declared in more than one version, --depth limits the levels, and --invert shows who depends on one package: Publisher.Name for a ViGet package, a path ending in .vipkg for a local one, or the project.name of a project below the current folder.",
      },
      { kind: "code", code: locking },
      { kind: "heading", text: "Mistyped words" },
      {
        kind: "text",
        text: "A mistyped command, flag or name gets a hint under the error, such as: did you mean tazel build?",
      },
      { kind: "heading", text: "Workspaces and tools" },
      {
        kind: "text",
        text: "At the root of a workspace, build, check, run and test work on every member; fmt and lint on the default members, or on the root when there are none; tazel lint --workspace on every member. Tazel finds a tool through TAZEL_TALAC, TAZEL_TALAFMT or TAZEL_TALALINT, then in its own installation, then on PATH.",
      },
      {
        kind: "note",
        title: "Not implemented yet",
        text: "Library targets, projects with dependencies, .vipkg creation and every command that needs packages of ViGet are refused by name with exit code 1. check, build and run compile for the host.",
      },
    ],
  },
  "de-DE": {
    nav: "Befehle",
    title: "Befehle · Tazel",
    description:
      "Die Befehle von Tazel, dem Build-System und Paketmanager von Tala, und wie sie Ziele auswählen.",
    section: "TAZEL / BEFEHLE",
    heading: "Das Build-System und seine Befehle",
    lead: "Tazel liest die Projektdatei, findet die Quellen und startet Talac, talafmt oder talalint als eigene Programme. Selbst kompiliert es nichts. Der Name verbindet Tala und Bazel.",
    blocks: [
      { kind: "code", code: everyday },
      {
        kind: "terms",
        items: commandTerms({
          check:
            "Startet Talac mit --emit=metadata und den Compiler-Optionen des Projekts. Schreibt keine ausführbare Datei.",
          build:
            "Baut die ausführbaren Dateien in das Ausgabeverzeichnis des Build-Modus, unter dem Namen des Ziels.",
          run: "Baut die ausführbaren Dateien und startet sie; was nach -- folgt, geht an das Programm.",
          test: "Baut die Testsuiten und führt sie aus.",
          fetch:
            "Holt Plugins aus ViGet vorab nach .tazel/plugins und schlägt fehl, wenn ein lokales Paket fehlt.",
          custom: "Führt einen Befehl aus tazel_custom.txt aus oder listet sie auf.",
          resolve: "Hält die deklarierten Abhängigkeiten in LOCK.sqlite3 fest.",
          dump: "Schreibt die Lockdatei als SQL-Text: nach LOCK.dump oder in die Datei, die --path nennt. Deren Ordner muss bereits existieren.",
          graph:
            "Gibt den Abhängigkeitsgraphen aus und erneuert vorher LOCK.sqlite3, außer --locked verbietet es.",
          fmt: "Formatiert die Quellen mit talafmt.",
          lint: "Prüft die Quellen mit talalint.",
          cache:
            "Zeigen, leeren, senden oder holen die Ergebnisse des Build-Caches und stellen einen für ein Team bereit.",
          remote: "Kompiliert für andere Rechner die Quellen, die sie schicken.",
          daemon: "Halten Tazel zwischen Befehlen warm oder beenden es.",
          version: "Gibt die Version von Tazel aus.",
          help: "Gibt die Hilfe aus, oder die Hilfe eines Befehls.",
          registry:
            "Befehle, die ViGet oder einen Bibliotheks-Build brauchen; sie werden mit Namen abgelehnt, bis es beides gibt.",
        }),
      },
      { kind: "heading", text: "Die Maschine nutzen" },
      {
        kind: "text",
        text: "check, build, run und test führen Compiler-Läufe und Testsuiten nebeneinander aus, ein Job pro Prozessor. --jobs, --cpus und --memory begrenzen sie, --keep-going macht nach einem Fehler weiter, und --profile schreibt einen Trace für chrome://tracing oder Perfetto. Plugin-Schritte, Kompilierungen und Testsuiten eines Projekts sind Einheiten eines Graphen, daher wartet eine Einheit nur auf das, wovon sie abhängt.",
      },
      { kind: "code", code: machine },
      {
        kind: "text",
        text: "--remote-executor kompiliert auf einem anderen Rechner, dem Sie vertrauen und auf dem tazel remote serve läuft. Programme und Testsuiten laufen weiterhin hier, und wenn der Server nicht helfen kann, warnt Tazel einmal und kompiliert hier.",
      },
      { kind: "heading", text: "Eigene Befehle" },
      {
        kind: "text",
        text: "tazel custom führt die Befehle aus tazel_custom.txt aus, aus dem aktuellen Ordner oder dem nächsten darüber. Sie brauchen keine Projektdatei und müssen Tazel nicht betreffen.",
      },
      { kind: "code", code: custom },
      { kind: "code", code: customRuns },
      {
        kind: "text",
        text: "Schritte laufen der Reihe nach. (...) startet ein Programm direkt, ohne Shell, und s(...) gibt eine Befehlszeile unverändert an CMD unter Windows und sonst an sh, Escapes darin liest also diese Shell. Ein Name darf mehrere Wörter haben, und der längste passende Name gilt; das erste -- beendet den Namen, sodass tazel custom first -- second das Argument second an first übergibt, auch wenn es einen Befehl first second gibt. Das -- ist weder Argument noch eines der 191 Wörter. <N> übergibt das N-te Argument, ab 1, und <*> alle; beides geht nicht in s(...). Name und Argumente sind zusammen höchstens 191 Wörter.",
      },
      { kind: "heading", text: "Ziele auswählen" },
      {
        kind: "text",
        text: "check, build, run, test und lint arbeiten an allem, sofern keine Auswahl etwas benennt. Eine Option von Tazel nimmt ihren Wert aus dem nächsten Argument und darf mehrfach geschrieben werden. Ein Name, der nichts auswählt, ist ein Fehler.",
      },
      { kind: "code", code: selection },
      { kind: "heading", text: "Argumente weiterreichen" },
      {
        kind: "text",
        text: "Alles nach -- geht ungelesen an das Programm, das ein Befehl startet: tazel lint -- --fix reicht --fix an talalint weiter, tazel run -- --port 8080 reicht --port 8080 an das Programm weiter.",
      },
      { kind: "heading", text: "Lockdatei und Graph" },
      {
        kind: "text",
        text: "tazel lock graph zeigt, wovon jedes Projekt abhängt. --all-features schaltet jedes Feature des Projekts ein, --duplicates zeigt die Pakete, die in mehr als einer Version deklariert sind, --depth begrenzt die Ebenen, und --invert zeigt, wer von einem Paket abhängt: Publisher.Name für ein ViGet-Paket, ein Pfad auf .vipkg für ein lokales, oder der project.name eines Projekts unterhalb des aktuellen Ordners.",
      },
      { kind: "code", code: locking },
      { kind: "heading", text: "Vertippte Wörter" },
      {
        kind: "text",
        text: "Ein vertippter Befehl, eine Option oder ein Name bekommt unter dem Fehler einen Hinweis, etwa: did you mean tazel build?",
      },
      { kind: "heading", text: "Workspaces und Werkzeuge" },
      {
        kind: "text",
        text: "In der Wurzel eines Workspace arbeiten build, check, run und test an jedem Mitglied; fmt und lint an den Standardmitgliedern oder, wenn es keine gibt, an der Wurzel; tazel lint --workspace an jedem Mitglied. Tazel findet ein Werkzeug über TAZEL_TALAC, TAZEL_TALAFMT oder TAZEL_TALALINT, dann in seiner eigenen Installation, dann über PATH.",
      },
      {
        kind: "note",
        title: "Noch nicht umgesetzt",
        text: "Bibliotheksziele, Projekte mit Abhängigkeiten, die Erstellung von .vipkg und jeder Befehl, der Pakete aus ViGet braucht, werden mit Namen und Exit-Code 1 abgelehnt. check, build und run kompilieren für den Host.",
      },
    ],
  },
  "ru-RU": {
    nav: "Команды",
    title: "Команды · Tazel",
    description: "Команды Tazel, системы сборки и менеджера пакетов Tala, и как они выбирают цели.",
    section: "TAZEL / КОМАНДЫ",
    heading: "Система сборки и её команды",
    lead: "Tazel читает файл проекта, находит исходники и запускает Talac, talafmt или talalint как отдельные программы. Сам он ничего не компилирует. Название соединяет Tala и Bazel.",
    blocks: [
      { kind: "code", code: everyday },
      {
        kind: "terms",
        items: commandTerms({
          check:
            "Запускает Talac с --emit=metadata и параметрами компилятора из проекта. Исполняемый файл не создаётся.",
          build: "Собирает исполняемые файлы в каталог результатов режима сборки под именем цели.",
          run: "Собирает исполняемые файлы и запускает их; всё после -- передаётся программе.",
          test: "Собирает и запускает наборы тестов.",
          fetch:
            "Заранее загружает плагины ViGet в .tazel/plugins и завершается ошибкой, если локального пакета нет.",
          custom: "Запускает команду из tazel_custom.txt или выводит их список.",
          resolve: "Записывает объявленные зависимости в LOCK.sqlite3.",
          dump: "Записывает lock-файл в виде SQL-текста: в LOCK.dump или в файл, указанный в --path. Его каталог должен уже существовать.",
          graph:
            "Выводит граф зависимостей и сначала обновляет LOCK.sqlite3, если --locked этого не запрещает.",
          fmt: "Форматирует исходники с помощью talafmt.",
          lint: "Проверяет исходники с помощью talalint.",
          cache:
            "Показывают, очищают, отправляют или получают результаты кэша сборки и обслуживают кэш для команды.",
          remote: "Компилирует для других машин присланные ими исходники.",
          daemon: "Держат Tazel запущенным между командами или останавливают его.",
          version: "Выводит версию Tazel.",
          help: "Выводит справку или справку по одной команде.",
          registry:
            "Команды, которым нужны ViGet или сборка библиотек; пока их нет, они отклоняются по имени.",
        }),
      },
      { kind: "heading", text: "Ресурсы машины" },
      {
        kind: "text",
        text: "check, build, run и test выполняют запуски компилятора и наборы тестов параллельно, по одной задаче на процессор. --jobs, --cpus и --memory их ограничивают, --keep-going продолжает работу после сбоя, а --profile записывает трассировку для chrome://tracing или Perfetto. Шаги плагинов, компиляции и наборы тестов проекта — единицы одного графа, поэтому единица ждёт только то, от чего зависит.",
      },
      { kind: "code", code: machine },
      {
        kind: "text",
        text: "--remote-executor компилирует на другой машине, которой вы доверяете и на которой работает tazel remote serve. Программы и наборы тестов по-прежнему выполняются здесь, а если сервер не может помочь, Tazel предупреждает один раз и компилирует здесь.",
      },
      { kind: "heading", text: "Свои команды" },
      {
        kind: "text",
        text: "tazel custom запускает команды из tazel_custom.txt, найденного в текущем каталоге или ближайшем выше. Файл проекта им не нужен, и они не обязаны быть связаны с Tazel.",
      },
      { kind: "code", code: custom },
      { kind: "code", code: customRuns },
      {
        kind: "text",
        text: "Шаги выполняются по порядку. (...) запускает программу напрямую, без оболочки, а s(...) передаёт одну командную строку без изменений в CMD в Windows и в sh в остальных системах, поэтому экранирование в ней читает сама оболочка. Имя может состоять из нескольких слов, и выбирается самое длинное подходящее; первое -- завершает имя, поэтому tazel custom first -- second передаёт second команде first, даже если есть команда first second. Само -- не является ни аргументом, ни одним из 191 слова. <N> передаёт N-й аргумент, начиная с 1, а <*> — все; в s(...) они не работают. Имя вместе с аргументами — не более 191 слова.",
      },
      { kind: "heading", text: "Выбор целей" },
      {
        kind: "text",
        text: "check, build, run, test и lint работают со всем, если выбор не называет конкретные цели. Параметр Tazel берёт значение из следующего аргумента и может повторяться. Имя, которое ничего не выбирает, — ошибка.",
      },
      { kind: "code", code: selection },
      { kind: "heading", text: "Передача аргументов" },
      {
        kind: "text",
        text: "Всё после -- без разбора передаётся программе, которую запускает команда: tazel lint -- --fix передаёт --fix в talalint, tazel run -- --port 8080 передаёт --port 8080 программе.",
      },
      { kind: "heading", text: "Lock-файл и граф" },
      {
        kind: "text",
        text: "tazel lock graph показывает, от чего зависит каждый проект. --all-features включает все возможности проекта, --duplicates показывает пакеты, объявленные в нескольких версиях, --depth ограничивает число уровней, а --invert показывает, кто зависит от пакета: Publisher.Name для пакета ViGet, путь с окончанием .vipkg для локального или project.name проекта ниже текущего каталога.",
      },
      { kind: "code", code: locking },
      { kind: "heading", text: "Опечатки" },
      {
        kind: "text",
        text: "Команда, параметр или имя с опечаткой получают подсказку под ошибкой, например: did you mean tazel build?",
      },
      { kind: "heading", text: "Рабочие пространства и инструменты" },
      {
        kind: "text",
        text: "В корне рабочего пространства build, check, run и test работают с каждым участником; fmt и lint — с участниками по умолчанию, а если их нет, с корнем; tazel lint --workspace — с каждым участником. Инструмент Tazel ищет через TAZEL_TALAC, TAZEL_TALAFMT или TAZEL_TALALINT, затем в своей установке, затем в PATH.",
      },
      {
        kind: "note",
        title: "Пока не реализовано",
        text: "Библиотечные цели, проекты с зависимостями, создание .vipkg и все команды, которым нужны пакеты ViGet, отклоняются по имени с кодом выхода 1. check, build и run компилируют для текущей системы.",
      },
    ],
  },
  "he-IL": {
    nav: "פקודות",
    title: "פקודות · Tazel",
    description: "הפקודות של Tazel, מערכת הבנייה ומנהל החבילות של Tala, ואיך הן בוחרות יעדים.",
    section: "TAZEL / פקודות",
    heading: "מערכת הבנייה והפקודות שלה",
    lead: "Tazel קורא את קובץ הפרויקט, מוצא את קבצי המקור ומפעיל את Talac, ‏talafmt או talalint כתוכניות נפרדות. הוא עצמו אינו מהדר דבר. השם מחבר את Tala ואת Bazel.",
    blocks: [
      { kind: "code", code: everyday },
      {
        kind: "terms",
        items: commandTerms({
          check:
            "מפעיל את Talac עם ‎--emit=metadata ועם אפשרויות המהדר של הפרויקט. אינו כותב קובץ הרצה.",
          build: "בונה את קובצי ההרצה לתיקיית הפלט של מצב הבנייה, בשם היעד.",
          run: "בונה את קובצי ההרצה ומריץ אותם; מה שאחרי ‎-- עובר לתוכנית.",
          test: "בונה ומריץ את חבילות הבדיקה.",
          fetch: "מוריד מראש תוספים של ViGet אל ‎.tazel/plugins, ונכשל אם חבילה מקומית חסרה.",
          custom: "מריץ פקודה מתוך tazel_custom.txt, או מציג את רשימתן.",
          resolve: "רושם את התלויות המוצהרות ב-LOCK.sqlite3.",
          dump: "כותב את קובץ הנעילה כטקסט SQL: ל-LOCK.dump, או לקובץ ש-‎--path מציין. התיקייה של הקובץ חייבת להיות קיימת.",
          graph: "מדפיס את גרף התלויות ומחדש קודם את LOCK.sqlite3, אלא אם ‎--locked אוסר זאת.",
          fmt: "מעצב את קבצי המקור עם talafmt.",
          lint: "בודק את קבצי המקור עם talalint.",
          cache: "מציגות, מנקות, שולחות או מורידות את תוצאות מטמון הבנייה, ומגישות מטמון לצוות.",
          remote: "מהדר עבור מחשבים אחרים את קבצי המקור שהם שולחים.",
          daemon: "משאירות את Tazel פעיל בין פקודות, או עוצרות אותו.",
          version: "מדפיס את גרסת Tazel.",
          help: "מדפיס את העזרה, או את העזרה של פקודה אחת.",
          registry: "פקודות שזקוקות ל-ViGet או לבניית ספרייה; הן נדחות בשמן עד שאלה יהיו קיימים.",
        }),
      },
      { kind: "heading", text: "ניצול המחשב" },
      {
        kind: "text",
        text: "check, ‏build, ‏run ו-test מריצות הידורים וחבילות בדיקה זו לצד זו, משימה אחת לכל מעבד. ‎--jobs, ‏‎--cpus ו-‎--memory מגבילים אותן, ‎--keep-going ממשיך אחרי כישלון, ו-‎--profile כותב עקבה עבור chrome://tracing או Perfetto. צעדי תוספים, הידורים וחבילות בדיקה של פרויקט הם יחידות בגרף אחד, ולכן יחידה ממתינה רק למה שהיא תלויה בו.",
      },
      { kind: "code", code: machine },
      {
        kind: "text",
        text: "‎--remote-executor מהדר במחשב אחר שאתם סומכים עליו ושמריץ tazel remote serve. תוכניות וחבילות בדיקה עדיין רצות כאן, ואם השרת אינו יכול לעזור, Tazel מזהיר פעם אחת ומהדר כאן.",
      },
      { kind: "heading", text: "פקודות מותאמות" },
      {
        kind: "text",
        text: "tazel custom מריץ את הפקודות מתוך tazel_custom.txt, שנמצא בתיקייה הנוכחית או בקרובה ביותר מעליה. הן אינן צריכות קובץ פרויקט ואינן חייבות להיות קשורות ל-Tazel.",
      },
      { kind: "code", code: custom },
      { kind: "code", code: customRuns },
      {
        kind: "text",
        text: "הצעדים רצים לפי הסדר. (...) מפעיל תוכנית ישירות, בלי מעטפת, ו-s(...) מעביר שורת פקודה אחת ל-CMD ב-Windows ול-sh בשאר המערכות. שם יכול להכיל כמה מילים, והשם הארוך ביותר שמתאים הוא הקובע. <N> מעביר את הארגומנט ה-N, החל מ-1, ו-<*> מעביר את כולם; שניהם אינם פועלים בתוך s(...). השם והארגומנטים יחד הם לכל היותר 191 מילים.",
      },
      { kind: "heading", text: "בחירת יעדים" },
      {
        kind: "text",
        text: "check, ‏build, ‏run, ‏test ו-lint פועלות על הכול, אלא אם בחירה מציינת על מה לפעול. אפשרות של Tazel לוקחת את ערכה מהארגומנט הבא ואפשר לכתוב אותה כמה פעמים. שם שאינו בוחר דבר הוא שגיאה.",
      },
      { kind: "code", code: selection },
      { kind: "heading", text: "העברת ארגומנטים הלאה" },
      {
        kind: "text",
        text: "כל מה שאחרי ‎-- עובר בלי קריאה לתוכנית שהפקודה מפעילה: ‏tazel lint -- --fix מעביר ‎--fix ל-talalint, ו-tazel run -- --port 8080 מעביר ‎--port 8080 לתוכנית.",
      },
      { kind: "heading", text: "קובץ הנעילה והגרף" },
      {
        kind: "text",
        text: "tazel lock graph מציג במה תלוי כל פרויקט. ‎--all-features מפעיל את כל התכונות של הפרויקט, ‎--duplicates מציג חבילות שהוצהרו ביותר מגרסה אחת, ‎--depth מגביל את מספר הרמות, ו-‎--invert מציג מי תלוי בחבילה: ‏Publisher.Name לחבילת ViGet, נתיב שמסתיים ב-‎.vipkg לחבילה מקומית, או ה-project.name של פרויקט מתחת לתיקייה הנוכחית.",
      },
      { kind: "code", code: locking },
      { kind: "heading", text: "שגיאות הקלדה" },
      {
        kind: "text",
        text: "פקודה, אפשרות או שם עם שגיאת הקלדה מקבלים רמז מתחת לשגיאה, למשל: ‏did you mean tazel build?",
      },
      { kind: "heading", text: "סביבות עבודה וכלים" },
      {
        kind: "text",
        text: "בשורש של סביבת עבודה, build, ‏check, ‏run ו-test פועלות על כל חבר; fmt ו-lint על חברי ברירת המחדל, או על השורש כשאין כאלה; ‏tazel lint --workspace על כל חבר. Tazel מוצא כלי דרך TAZEL_TALAC, ‏TAZEL_TALAFMT או TAZEL_TALALINT, אחר כך בהתקנה שלו עצמו, ואחר כך ב-PATH.",
      },
      {
        kind: "note",
        title: "עוד לא מומש",
        text: "יעדי ספרייה, פרויקטים עם תלויות, יצירת ‎.vipkg וכל פקודה שזקוקה לחבילות של ViGet נדחים בשמם עם קוד יציאה 1. ‏check, ‏build ו-run מהדרים עבור המערכת הנוכחית.",
      },
    ],
  },
};

const projectFile: DocTopic = {
  "en-US": {
    nav: "Project file",
    title: "Project file · Tazel",
    description:
      "The project file of Tazel: its names, the project, compiler and sources blocks, dependencies and workspaces.",
    section: "TAZEL / PROJECT FILE",
    heading: "The project file",
    lead: "A project is described by one Kotlin script that Tazel evaluates itself; no Kotlin installation is needed. The compiler never reads it.",
    blocks: [
      {
        kind: "text",
        text: "The file has one of five names, looked for in this order: BUILD.kts, BUILD.tzl, BUILD.tazel, BUILD and Tazel.build. The first that exists is used; the names are case-sensitive. A command works on the project of the nearest directory, upward, that holds one.",
      },
      { kind: "code", code: minimal },
      {
        kind: "text",
        text: "This compiles every .tala file below Sources/ and writes build/debug/Example (Example.exe on Windows). entry names a class by its namespace; that class provides the parameterless public static void Main(). Neither file names nor directories have to mirror namespaces.",
      },
      { kind: "heading", text: "Compiler settings" },
      {
        kind: "text",
        text: "Tazel writes every setting onto the command line of Talac, the defaults too. optLevel is O0, O1, O2, O3, OG, OS or OZ, and defaults to O0 in a debug build and O3 in a release build. No warning level turns wshadow on, and wshadow with Warnings.NONE is rejected.",
      },
      { kind: "code", code: compiler },
      { kind: "heading", text: "Execution" },
      {
        kind: "text",
        text: "The execution block is optional and sets what the flags of a command set; a flag goes before it. In a workspace, the block of the root counts.",
      },
      { kind: "code", code: execution },
      { kind: "heading", text: "Dependencies" },
      {
        kind: "text",
        text: "A dependency is a package of ViGet written as a publisher, a name and an exact version: A.B.C, then .D, .E and -METADATA if needed. feature makes it optional. localDependency names a .vipkg inside the project, and testDependency and localTestDependency serve the test suites only. LOCK.sqlite3 records what is declared.",
      },
      { kind: "code", code: dependencies },
      { kind: "heading", text: "Workspaces" },
      {
        kind: "text",
        text: "Each member is a directory with a project file of its own, written relative to this one. A project that only gathers members needs no sources.",
      },
      { kind: "code", code: workspace },
      {
        kind: "note",
        title: "Host values",
        text: "OS and ARCH are the operating system and architecture Tazel runs on, compared with values such as OperatingSystem.WINDOWS. panic(message) stops the evaluation, and eprint(value) writes to standard error.",
      },
    ],
  },
  "de-DE": {
    nav: "Projektdatei",
    title: "Projektdatei · Tazel",
    description:
      "Die Projektdatei von Tazel: ihre Namen, die Blöcke project, compiler und sources, Abhängigkeiten und Workspaces.",
    section: "TAZEL / PROJEKTDATEI",
    heading: "Die Projektdatei",
    lead: "Ein Projekt wird von einem Kotlin-Skript beschrieben, das Tazel selbst auswertet; eine Kotlin-Installation ist nicht nötig. Der Compiler liest es nie.",
    blocks: [
      {
        kind: "text",
        text: "Die Datei hat einen von fünf Namen, gesucht in dieser Reihenfolge: BUILD.kts, BUILD.tzl, BUILD.tazel, BUILD und Tazel.build. Der erste vorhandene gilt; die Namen unterscheiden Groß- und Kleinschreibung. Ein Befehl arbeitet am Projekt des nächsten Verzeichnisses darüber, das eine solche Datei enthält.",
      },
      { kind: "code", code: minimal },
      {
        kind: "text",
        text: "Das kompiliert jede .tala-Datei unter Sources/ und schreibt build/debug/Example (unter Windows Example.exe). entry benennt eine Klasse mit ihrem Namespace; diese Klasse stellt das paramete