Разбор суждений попал в основную проверку, и пакет получил существующий scope

Две вещи, обе про то, что правильное решение молчало.

ПЕРВОЕ. Анализ, находивший настоящие дефекты, требовал отдельного запуска.
tools/ftsmap умеет разбирать утилиту от входов и точно, а не на выборке:
intervals.mjs решает задачу покоординатно за линейное время и честно называет
класс, который не берёт. Именно им были пойманы два дефекта в моделях учебного
курса — недостижимый процентный предел и нарушение на отрицательной сумме. Но
`fts check` про это молчал, и увидеть находку можно было, только зная, что надо
запустить ftsmap.

Теперь check говорит сам, предупреждением, а не ошибкой — модель с недостижимым
свойством валидна:

  FTS_COVERAGE_HOLE  при «сумма» ∈ (−∞, 10000) не срабатывает ни одно правило —
                     результат остаётся начальным (0)                  строка 6
  FTS_PROPERTY_VIOLATED  свойство «Скидка ограничена» нарушается при
                     «сумма» ∈ (−∞, 0): результат 0 против предела −200000
                                                                      строка 15
  FTS_PROPERTY_UNATTAINABLE  предел «результат ≤ 20 % от поля «сумма»» не
                     берётся нигде, где правила меняют результат       строка 15

У каждой находки свой код, а не общий FTS_UTILITY_*: по коду машина понимает,
что чинить, и это прямо нужно для связки «разработчик и ИИ». Появилось место —
строка, которой у находок ftsmap не было вовсе, хотя у диагностик компилятора
она есть. Появилась конкретика: не «свойство нарушается», а на каком интервале
и какое число против какого.

ВТОРОЕ. Пакет объявлял scope @digitable, которого в реестре не существует, —
организация называется @digitable-lol. Я проверил @digitable, получил 404 и
сделал вывод «организации нет», не догадавшись проверить второе имя. Имя пакета
исправлено в 12 файлах, включая манифест вендорной сборки, документацию и
workflow публикации.

Проверено: 71 тест ядра, 405 инструментов (4 пропуска — нет dotnet и Go),
сборка TypeScript без ошибок.

Author: the-homeless-god

.github/actions/fts-check/lib/annotate.mjs

@@ -27,7 +27,10 @@ import { formatCommand } from "./commands.mjs"
  * message text so the location information is not silently dropped.
  */
 export function diagnosticToAnnotation(diagnostic, file, spot = locate(diagnostic, null, { fallback: "none" })) {
-  const severity = diagnostic.severity === "warning" ? "warning" : "error"
+  /* `info` — true and worth printing, but nothing is wrong; GitHub calls that
+     level `notice`. Only an unknown severity is treated as an error. */
+  const severity =
+    diagnostic.severity === "warning" ? "warning" : diagnostic.severity === "info" ? "notice" : "error"
   const properties = {}
   if (file !== undefined) properties.file = file
 
@@ -42,7 +45,10 @@ export function diagnosticToAnnotation(diagnostic, file, spot = locate(diagnosti
   }
   if (diagnostic.code) properties.title = diagnostic.code
 
-  const message = spot || !diagnostic.path ? diagnostic.message : `${diagnostic.message} (${diagnostic.path})`
+  const located = spot || !diagnostic.path ? diagnostic.message : `${diagnostic.message} (${diagnostic.path})`
+  /* A hint is the actionable half of a diagnostic; an annotation that dropped
+     it would send the reader back to the terminal to see what to do. */
+  const message = diagnostic.hint ? `${located}\n${diagnostic.hint}` : located
 
   return formatCommand(severity, properties, message)
 }

.github/actions/fts-check/lib/run.mjs

@@ -102,8 +102,13 @@ export async function run(options) {
   }
 
   const allDiagnostics = [...models.flatMap((m) => m.diagnostics), ...tools.flatMap((t) => t.diagnostics)]
-  const errors = allDiagnostics.filter((d) => d.severity !== "warning").length
-  const warnings = allDiagnostics.length - errors
+  const warnings = allDiagnostics.filter((d) => d.severity === "warning").length
+  /* `info` never fails a build and is not a warning either: it reports
+     something true about the model that is not a defect — two rules that both
+     add to the result and therefore do not care about their order. An unknown
+     severity still counts as an error. */
+  const notices = allDiagnostics.filter((d) => d.severity === "info").length
+  const errors = allDiagnostics.length - warnings - notices
   const examplesFailed = models.reduce((sum, m) => sum + m.examplesFailed, 0)
 
   const failed = errors > 0 || (failOnWarning && warnings > 0)
@@ -118,6 +123,7 @@ export async function run(options) {
       diagnostics: allDiagnostics.length,
       errors,
       warnings,
+      notices,
       examplesFailed,
     },
     failed,

.github/actions/fts-check/lib/summaryReport.mjs

@@ -3,18 +3,23 @@ function cell(text) {
   return String(text).replace(/\|/g, "\\|").replace(/\r?\n/g, " ")
 }
 
+/**
+ * Counted by declared severity, and an unknown severity counts as an error:
+ * a level this action has not heard of must not be quietly downgraded.
+ */
 function countBySeverity(diagnostics) {
-  const errors = diagnostics.filter((d) => d.severity !== "warning").length
-  const warnings = diagnostics.length - errors
-  return { errors, warnings }
+  const warnings = diagnostics.filter((d) => d.severity === "warning").length
+  const notices = diagnostics.filter((d) => d.severity === "info").length
+  return { errors: diagnostics.length - warnings - notices, warnings, notices }
 }
 
 function diagnosticsCell(diagnostics) {
   if (diagnostics.length === 0) return "0"
-  const { errors, warnings } = countBySeverity(diagnostics)
+  const { errors, warnings, notices } = countBySeverity(diagnostics)
   const parts = []
   if (errors > 0) parts.push(`${errors} error${errors === 1 ? "" : "s"}`)
   if (warnings > 0) parts.push(`${warnings} warning${warnings === 1 ? "" : "s"}`)
+  if (notices > 0) parts.push(`${notices} notice${notices === 1 ? "" : "s"}`)
   return parts.join(", ")
 }
 
@@ -44,12 +49,12 @@ export function buildSummaryMarkdown(models, tools = []) {
   const allDiagnostics = [...models.flatMap((m) => m.diagnostics), ...tools.flatMap((t) => t.diagnostics)]
   const totalExamplesFailed = models.reduce((sum, m) => sum + m.examplesFailed, 0)
   const totalExamples = models.reduce((sum, m) => sum + m.examplesTotal, 0)
-  const { errors, warnings } = countBySeverity(allDiagnostics)
+  const { errors, warnings, notices } = countBySeverity(allDiagnostics)
 
   lines.push("")
   lines.push(
     `**${models.length} model(s) checked** · ${totalExamples - totalExamplesFailed}/${totalExamples} example(s) converge · ` +
-      `${errors} error(s), ${warnings} warning(s)`,
+      `${errors} error(s), ${warnings} warning(s), ${notices} notice(s)`,
   )
   lines.push("")
 

.github/actions/fts-check/test/fixtures/judgement.fts

@@ -0,0 +1,24 @@
+// A valid model whose judgement does not hold up: nothing fires below 10000,
+// so the result silently stays at its initial value there, and the declared
+// ceiling of 20 % is never reached — the rules give at most 10 %. Neither is a
+// reason to reject the document, and neither may pass in silence.
+category "Sales"
+
+  object Purchase
+    amount is money
+
+  utility "Calculate discount"
+    accepts Purchase
+    returns money
+    starts with 0
+
+    rule "Large purchase"
+      if amount is at least 10000
+      then add 10 percent of field amount
+
+    property "Discount is capped"
+      result is at most 20 percent of field amount
+
+    example "Large purchase"
+      given amount equals 20000
+      expected result equals 2000

.github/actions/fts-check/test/fixtures/valid.fts

@@ -1,3 +1,7 @@
+// A model with nothing to report: the two rules partition the whole range of
+// "amount" between them, so no input falls through to the initial value and no
+// two rules ever apply at once. `check` reads the input space now, and a
+// fixture that stands for "fully valid" has to be clean by that measure too.
 category "Sales"
 
   object Purchase
@@ -9,9 +13,13 @@ category "Sales"
     returns money
     starts with 0
 
+    rule "Regular purchase"
+      if amount is less than 10000
+      then result equals 0
+
     rule "Large purchase"
       if amount is at least 10000
-      then add 10 percent of field amount
+      then result equals 2000
 
     example "Regular purchase"
       given amount equals 5000

.github/actions/fts-check/test/run.test.mjs

@@ -39,6 +39,39 @@ test("a valid model: zero diagnostics, exit not failed, correct counts", async (
   }
 })
 
+test("a model whose judgement does not hold up: warnings that annotate but do not fail", async () => {
+  const dir = await makeWorkspace()
+  try {
+    await copyFile(join(fixtures, "judgement.fts"), join(dir, "examples", "judgement.fts"))
+    const result = await run({ workspaceDir: dir, paths: "**/*.fts" })
+
+    /* The document is valid and its example converges, so the run must pass.
+       What `check` now adds is its reading of the input space, and it arrives
+       as warnings: a hole below 10000, and a ceiling of 20 % the rules never
+       reach. Neither may fail a build; both must be visible on the pull
+       request, on the line that declares them, together with what to do. */
+    assert.equal(result.failed, false)
+    assert.equal(result.counts.errors, 0)
+    assert.equal(result.counts.examplesFailed, 0)
+
+    const hole = result.annotations.find((line) => line.includes("FTS_COVERAGE_HOLE"))
+    assert.ok(hole, "дыра в покрытии аннотирована")
+    assert.match(hole, /^::warning file=examples\/judgement\.fts,line=10/, "на строке утилиты")
+
+    const unattainable = result.annotations.find((line) => line.includes("FTS_PROPERTY_UNATTAINABLE"))
+    assert.ok(unattainable, "недостижимый предел аннотирован")
+    assert.match(unattainable, /^::warning file=examples\/judgement\.fts,line=19/, "на строке свойства")
+    /* `%0A` и `%25` — экранирование самой GitHub: подсказка идёт второй
+       строкой сообщения, а процент в ней экранирован как `%25`. */
+    assert.match(unattainable, /%0Aправила дотягивают до 10 %25 от поля/u, "подсказка доехала до аннотации")
+
+    const strict = await run({ workspaceDir: dir, paths: "**/*.fts", failOnWarning: true })
+    assert.equal(strict.failed, true, "--fail-on-warning всё же ловит их")
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
 test("a broken model: annotation with the right line, and a failed run", async () => {
   const dir = await makeWorkspace()
   try {

src/browser.ts

@@ -1,11 +1,13 @@
 // Browser-safe public surface. Strict certificate production and verification
 // stay on the trusted server boundary because they use Node.js cryptography.
+export * from "./coverage.js"
 export * from "./diagnostics.js"
 export * from "./domain.js"
 export * from "./interpreter.js"
 export * from "./model.js"
 export * from "./natural-parser.js"
 export * from "./parser.js"
+export * from "./spans.js"
 export * from "./stdlib.js"
 export * from "./templates.js"
 export * from "./utility.js"

src/cli.ts

@@ -23,6 +23,7 @@ interface CliOptions {
   inputFile?: string
   mode: VisualizationMode
   pretty: boolean
+  coverage: boolean
 }
 
 export async function main(argv = process.argv.slice(2)): Promise<number> {
@@ -56,7 +57,7 @@ export async function main(argv = process.argv.slice(2)): Promise<number> {
         output = compile(source)
         break
       case "check": {
-        const result = validate(compile(source))
+        const result = validate(compile(source), { coverage: options.coverage })
         output = result
         if (!result.valid) {
           writeJson(output, options.pretty, process.stderr)
@@ -126,6 +127,7 @@ function parseArgs(argv: string[]): CliOptions {
   let inputFile: string | undefined
   let mode: VisualizationMode = "all"
   let pretty = false
+  let coverage = true
 
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index]!
@@ -150,6 +152,8 @@ function parseArgs(argv: string[]): CliOptions {
       if (inputFile === undefined) throw new Error("--input requires a JSON file")
     } else if (arg === "--pretty") {
       pretty = true
+    } else if (arg === "--no-coverage") {
+      coverage = false
     } else {
       positional.push(arg)
     }
@@ -160,7 +164,9 @@ function parseArgs(argv: string[]): CliOptions {
     file: positional[1] ?? "-",
     mode,
     pretty,
+    coverage,
   }
+  if (!coverage && result.command !== "check") throw new Error("--no-coverage is available only for check")
   if (outDir !== undefined && result.command !== "generate") throw new Error("--out is available only for generate")
   if (utilityName !== undefined && result.command !== "run") throw new Error("--utility is available only for run")
   if (inputFile !== undefined && result.command !== "run") throw new Error("--input is available only for run")
@@ -215,7 +221,7 @@ const helpText = `FTS — Formal Type Surface
 
 Usage:
   fts compile [file|-] [--pretty]
-  fts check [file|-] [--pretty]
+  fts check [file|-] [--pretty] [--no-coverage]
   fts prove [file|-] [--context context.json] [--pretty]
   fts certify [file|-] [--context context.json] [--pretty]
   fts verify [file|-] --context context.json --certificate proof.json [--pretty]
@@ -228,6 +234,10 @@ Usage:
   fts version
 
 Commands emit JSON to stdout. Diagnostics are JSON on stderr and failures use a non-zero exit code.
+
+check also reads the input space of every utility: holes in rule coverage, overlaps whose
+outcome depends on declaration order, property limits no input ever reaches. Those are
+warnings — they never make a document invalid. --no-coverage turns the analysis off.
 `
 
 if (invokedDirectly(import.meta.url)) {