aontu 0.55.0 → 0.56.0

package/src/cli.ts

@@ -48,6 +48,9 @@ import type {
 import type { QueryView } from './query'
 import type { WhyRecord } from './provenance'
 import { agentsMdSplice } from './agentsmd'
+import { format, unifiedDiff } from './format'
+import { includeOpts } from './utility'
+import type { IncludeOptions } from './utility'
 
 
 type Mode = 'json' | 'canon'
@@ -69,6 +72,7 @@ const HELP = `Usage: aontu [options] [file]
        aontu why <path> [options] <file>
        aontu set <path>=<value>... --entry <file> --overlay <file>
        aontu agentsmd [--write <AGENTS.md>] <file>
+       aontu fmt [-w|-l|--check|-d] <file>...
 
 Evaluate an Aontu source file and print the result as JSON.
 With no file on an interactive terminal, start a REPL.
@@ -91,6 +95,10 @@ Options:
                   Every verb takes it too, and a bare root means the
                   document's own directory
   --include-root <dir>  Shorthand for --trust root:<dir>
+  --text-ext <e>  Read these extensions as text too, comma-separated
+                  and without dots (md,sql). .txt needs no flag; a
+                  named format keeps its meaning, and .js stays
+                  refused. Every verb takes it
 
 Mod options:
   --format <f>    text (default) or json
@@ -182,8 +190,8 @@ Why options:
 Why exit codes mirror get's: 0 explained, 1 the path names nothing,
 2 usage, 4 the document does not stand up on its own.
 
-View kinds: tree, matrix, graph, layer, sets, layers, ladder, poset
-(the poset takes several files). The figure goes to stdout, the loss
+View kinds: doc, lattice, tree, matrix, graph, layer, sets, layers,
+ladder, poset (the poset takes several files). The figure goes to stdout, the loss
 report to stderr. With --views it draws every figure a document
 declares as data, from one evaluation: each declaration names its own
 kind and out file, nothing is written unless every figure rendered,
@@ -191,13 +199,13 @@ and --check gates the committed set.
 
 View options:
   --as <profile>    text | mermaid | dot | er | svg, per kind: doc,
-                    tree, matrix, sets and layers draw text (default)
-                    or svg; graph draws mermaid (default), dot or er;
-                    layer draws text (default), mermaid or svg; ladder
-                    and poset draw mermaid (default) or dot
+                    lattice, tree, matrix, sets and layers draw text
+                    (default) or svg; graph draws mermaid (default),
+                    dot or er; layer draws text (default), mermaid or
+                    svg; ladder and poset draw mermaid (default) or dot
   --at <path>       Restrict the figure to nodes under this path; the
-                    subtree doc draws; the path the ladder draws;
-                    where the poset compares
+                    subtree doc draws; the subtree the lattice counts;
+                    the path the ladder draws; where the poset compares
   --views <path>    Draw every figure the document declares at this
                     path, one evaluation, all or nothing; each
                     declaration names its own kind and out file
@@ -276,6 +284,19 @@ Agentsmd options:
 Agentsmd exit codes: 0 generated, 2 usage, 4 the document does not
 stand up on its own.
 
+Fmt options:
+  -w, --write     Rewrite each file in place, when its form would change
+  -l, --list      Print the name of each file whose form would change
+  --check         Like --list, and exit 1 when any would: the CI gate
+  -d, --diff      Print a unified diff for each file whose form would
+                  change
+
+The fmt verb prints one document in the agreed form; with no file it
+reads standard input. Several files need one of the options above.
+
+Fmt exit codes: 0 formatted or clean, 1 a --check file would change,
+2 usage, 4 a document does not parse.
+
 REPL commands:
   :help           Show REPL help
   :load <file>    Evaluate a document and hold it for the commands below
@@ -333,11 +354,18 @@ function evalSource(
 // entry root or goes through package resolution prints a one-line
 // stderr warning naming the flag a future default will require
 // (phase 6, the staged flip).
-type TrustArg =
+type TrustArg = (
   | { kind: 'system-warn' }
   | { kind: 'system' }
   | { kind: 'none' }
   | { kind: 'root', dir?: string }
+  // EXTENSIONS READ AS TEXT ride with the capability rather than
+  // beside it: both answer "what may an include read", both are
+  // stripped by takeTrust before a verb parses its own tail, and a
+  // verb that threads one and not the other is the G5 defect again --
+  // `aontu vet` running under a flag the bare command honoured and it
+  // did not.
+) & { textExt: string[] }
 
 
 // The one-line warning of the staged default flip. Once per (kind,
@@ -366,15 +394,16 @@ function makeTrustWarn(): (kind: 'escape' | 'pkg', path: string) => void {
 // entryRoot (the entry file's directory, or the working directory for
 // stdin/REPL).
 function trustOpts(trust: TrustArg, entryRoot: string): any {
+  const text = 0 === trust.textExt.length ? {} : { textExt: trust.textExt }
   switch (trust.kind) {
     case 'none':
-      return { trust: { include: 'none' } }
+      return { ...text, trust: { include: 'none' } }
     case 'root':
-      return { trust: { include: { root: trust.dir ?? entryRoot } } }
+      return { ...text, trust: { include: { root: trust.dir ?? entryRoot } } }
     case 'system':
-      return {}
+      return { ...text }
     default:  // system-warn: today's default plus the warning window
-      return { trustWarn: makeTrustWarn(), trustWarnRoot: entryRoot }
+      return { ...text, trustWarn: makeTrustWarn(), trustWarnRoot: entryRoot }
   }
 }
 
@@ -392,7 +421,8 @@ function trustOpts(trust: TrustArg, entryRoot: string): any {
 function takeTrust(argv: string[]):
   { argv: string[], trust: TrustArg } | undefined {
   const rest: string[] = []
-  let trust: TrustArg = { kind: 'system-warn' }
+  let trust: TrustArg = { kind: 'system-warn', textExt: [] }
+  let textExt: string[] = []
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i]
     if ('--trust' === arg) {
@@ -410,21 +440,47 @@ function takeTrust(argv: string[]):
         process.stderr.write('aontu: --include-root needs a directory\n')
         return undefined
       }
-      trust = { kind: 'root', dir }
+      trust = { kind: 'root', dir, textExt }
+    }
+    else if ('--text-ext' === arg) {
+      const list = null == argv[i + 1] ? undefined : parseTextExt(argv[++i])
+      if (null == list) {
+        process.stderr.write(
+          'aontu: --text-ext needs extensions, without dots' +
+          ' (--text-ext md,sql)\n')
+        return undefined
+      }
+      textExt = [...textExt, ...list]
     }
     else {
       rest.push(arg)
     }
   }
-  return { argv: rest, trust }
+  return { argv: rest, trust: { ...trust, textExt } }
+}
+
+
+// `md,sql` or `.md,.sql` -- the dot is accepted and dropped, because a
+// reader who has just written `@"notes.txt"` reaches for one. An empty
+// element, or anything that is not an extension, is a usage error
+// rather than a silently ignored word: a flag that quietly does
+// nothing is how a document ends up refused with no reason visible.
+function parseTextExt(arg: string): string[] | undefined {
+  const out: string[] = []
+  for (const raw of arg.split(',')) {
+    const ext = raw.trim().replace(/^\./, '').toLowerCase()
+    if ('' === ext || !/^[a-z0-9]+$/.test(ext)) {
+      return undefined
+    }
+    out.push(ext)
+  }
+  return out
 }
 
 
 // The evaluator options a REPL session's capability means.
 function replTrust(state: ReplState, entryRoot: string): any {
-  const capability = verbTrust(
-    state.trust ?? { kind: 'system-warn' }, entryRoot)
-  return null == capability ? {} : { trust: capability }
+  return verbOpts(state.trust ?? { kind: 'system-warn', textExt: [] }, entryRoot)
 }
 
 
@@ -444,6 +500,20 @@ function verbTrust(trust: TrustArg, entryRoot: string): any {
 }
 
 
+// THE INCLUDE OPTIONS A VERB RUNS UNDER, spread into its engine call:
+// the capability above, and the extensions `--text-ext` widened. Both
+// are absent when unset rather than present-and-undefined, so a verb's
+// options bag is byte-identical to what it was before either flag
+// existed and no engine sees a key it has to ignore.
+function verbOpts(trust: TrustArg, entryRoot: string): any {
+  const include = verbTrust(trust, entryRoot)
+  return {
+    ...(undefined === include ? {} : { trust: include }),
+    ...(0 === trust.textExt.length ? {} : { textExt: trust.textExt }),
+  }
+}
+
+
 // The directory a bare `--trust root` confines to for a verb: the
 // primary document's own, matching the bare command's entry root.
 function entryRootOf(file: string | undefined): string {
@@ -607,7 +677,7 @@ export function replCommand(
       if (':why' === cmd) {
         const report = why(src, path, {
           path: state.name,
-          trust: verbTrust(state.trust ?? { kind: 'system-warn' },
+          ...verbOpts(state.trust ?? { kind: 'system-warn', textExt: [] },
             entryRootOf(state.name)),
         })
         return report.ok
@@ -618,7 +688,7 @@ export function replCommand(
         ? 'keys' : 'canon' === state.mode ? 'canon' : 'json'
       const report = get(src, path, {
         view, path: state.name,
-        trust: verbTrust(state.trust ?? { kind: 'system-warn' },
+        ...verbOpts(state.trust ?? { kind: 'system-warn', textExt: [] },
           entryRootOf(state.name)),
       })
       return report.ok
@@ -901,7 +971,7 @@ function vetOnce(args: VetArgs, trust: TrustArg): number {
 
   for (const source of sources) {
     const report = vet(schemaSrc, source.src, {
-      trust: verbTrust(trust, entryRootOf(args.schema)),
+      ...verbOpts(trust, entryRootOf(args.schema)),
       at: args.at,
       closed: args.closed,
       partial: args.partial,
@@ -1193,7 +1263,7 @@ function runSubsume(argv: string[]): number {
   }
 
   const report = subsume(generalSrc, specificSrc, {
-    trust: verbTrust(trust, entryRootOf(args.general)),
+    ...verbOpts(trust, entryRootOf(args.general)),
     profile: args.profile,
     at: args.at,
     generalUrl: args.general,
@@ -1417,15 +1487,18 @@ function oldVersion(spec: string, file: string): OldVersion | undefined {
 // a disjunction whose default is the declared mode. Undefined when the
 // key is absent or does not spell a mode.
 function policyCompat(
-  newSrc: string, path: string, trust: any): BreakingMode | undefined {
+  newSrc: string, path: string, include: IncludeOptions
+): BreakingMode | undefined {
   const aontu = new Aontu()
   const ctx = aontu.ctx({ collect: true })
   // The declaration is read by EVALUATING the document, so this leg
-  // runs the include resolver too and has to run it under the verb's
-  // capability -- a `breaking --trust none` that read its own mode
-  // through an unconfined resolver would confine the comparison and
-  // not the question (use-cases/REVIEW.md finding G).
-  const v: any = aontu.unify(newSrc, { path, ...(null == trust ? {} : { trust }) }, ctx)
+  // runs the include resolver too and has to run it under BOTH of the
+  // verb's include options -- a `breaking --trust none` that read its
+  // own mode through an unconfined resolver would confine the
+  // comparison and not the question (use-cases/REVIEW.md finding G),
+  // and one that took the capability alone read no mode at all when
+  // the declaration arrived through a `--text-ext` include.
+  const v: any = aontu.unify(newSrc, { path, ...includeOpts(include) }, ctx)
   if (0 < ctx.err.length || true === v?.isNil) {
     return undefined
   }
@@ -1528,7 +1601,8 @@ function runBreaking(argv: string[]): number {
   // stay valid).
   const mode: BreakingMode =
     args.mode ??
-    policyCompat(newSrc, args.file, verbTrust(trust, entryRootOf(args.file))) ??
+    policyCompat(newSrc, args.file,
+      verbOpts(trust, entryRootOf(args.file))) ??
     'backward'
 
   if ('none' === mode) {
@@ -1578,7 +1652,7 @@ function runBreaking(argv: string[]): number {
 
     for (const check of checks) {
       const report = subsume(check.general[0], check.specific[0], {
-        trust: verbTrust(trust, entryRootOf(args.file)),
+        ...verbOpts(trust, entryRootOf(args.file)),
         at: args.at,
         generalUrl: check.general[1],
         specificUrl: check.specific[1],
@@ -1724,7 +1798,7 @@ function runTrim(argv: string[]): number {
   }
 
   const report = trimCheck(src, {
-    path: files[0], trust: verbTrust(trust, entryRootOf(files[0])),
+    path: files[0], ...verbOpts(trust, entryRootOf(files[0])),
   })
   const text = 'json' === format
     ? renderTrimJson(report)
@@ -1788,8 +1862,8 @@ const VIEW_HELP =
   'aontu view <kind> [options] <file>... (try --help)'
 
 const VIEW_KINDS: ViewKind[] =
-  ['doc', 'tree', 'matrix', 'graph', 'layer', 'sets', 'layers', 'ladder',
-    'poset']
+  ['doc', 'lattice', 'tree', 'matrix', 'graph', 'layer', 'sets', 'layers',
+    'ladder', 'poset']
 
 const VIEW_PROFILES: ViewProfile[] = ['text', 'mermaid', 'dot', 'er', 'svg']
 
@@ -2110,7 +2184,7 @@ function runRelations(argv: string[]): number {
   }
 
   const report = relationCheck(src, {
-    path: files[0], trust: verbTrust(trust, entryRootOf(files[0])),
+    path: files[0], ...verbOpts(trust, entryRootOf(files[0])),
   })
   const text = 'json' === format
     ? renderRelationsJson(report)
@@ -2178,7 +2252,7 @@ function runReaches(argv: string[]): number {
 
   const report = reachCheck(src, rest[0], rest[1], {
     path: rest[2], relation,
-    trust: verbTrust(trust, entryRootOf(rest[2])),
+    ...verbOpts(trust, entryRootOf(rest[2])),
   })
   const text = 'json' === format
     ? renderReachesJson(report)
@@ -2424,7 +2498,7 @@ function runView(argv: string[]): number {
     kind,
     path: files[0],
     roots,
-    trust: verbTrust(trust, entryRootOf(files[0])),
+    ...verbOpts(trust, entryRootOf(files[0])),
     docs: files.slice(1).map((path, i) => ({ src: srcs[i + 1], path })),
   })
 
@@ -2503,7 +2577,7 @@ function runViewSet(
   }
 
   const report = viewSet(src, {
-    ...opts, path: file, trust: verbTrust(trust, entryRootOf(file)),
+    ...opts, path: file, ...verbOpts(trust, entryRootOf(file)),
   })
 
   if ('json' === how.format) {
@@ -2726,7 +2800,7 @@ function runJsonSchema(argv: string[]): number {
   }
 
   const report = jsonSchema(src, {
-    at, path: files[0], trust: verbTrust(trust, entryRootOf(files[0])),
+    at, path: files[0], ...verbOpts(trust, entryRootOf(files[0])),
   })
 
   if ('json' === format) {
@@ -2819,9 +2893,7 @@ function runHash(argv: string[]): number {
 
   // The file's own directory is the include base, as every verb
   // resolves a named file (vet's aontuForPath rule).
-  const capability = verbTrust(trust, entryRootOf(files[0]))
-  const aontu = new Aontu(
-    null == capability ? undefined : { trust: capability })
+  const aontu = new Aontu(verbOpts(trust, entryRootOf(files[0])))
   const ctx = aontu.ctx({ collect: true })
   const v: any = aontu.unify(src, { path: files[0] }, ctx)
   if (0 < ctx.err.length || true === v?.isNil) {
@@ -2937,7 +3009,7 @@ function runGet(argv: string[]): number {
   }
 
   const report = get(src, path, {
-    view, depth, path: file, trust: verbTrust(trust, entryRootOf(file)),
+    view, depth, path: file, ...verbOpts(trust, entryRootOf(file)),
   })
   if ('json' === format) {
     process.stdout.write(exactJSON({
@@ -3021,7 +3093,7 @@ function runWhy(argv: string[]): number {
   }
 
   const report = why(src, path, {
-    path: file, trust: verbTrust(trust, entryRootOf(file)),
+    path: file, ...verbOpts(trust, entryRootOf(file)),
   })
   if ('json' === format) {
     process.stdout.write(exactJSON({
@@ -3156,7 +3228,7 @@ function runSet(argv: string[]): number {
   }
 
   const report = patch(entrySrc, overlaySrc, assignments, {
-    trust: verbTrust(trust, entryRootOf(entry)),
+    ...verbOpts(trust, entryRootOf(entry)),
     entryPath: entry,
     overlayPath: overlayFile,
     inPlace,
@@ -3291,7 +3363,7 @@ function runAgentsMd(argv: string[]): number {
 
   const report = agentsMd(src, {
     name: files[0], path: files[0],
-    trust: verbTrust(trust, entryRootOf(files[0])),
+    ...verbOpts(trust, entryRootOf(files[0])),
   })
   if (!report.ok) {
     process.stderr.write(
@@ -3343,6 +3415,129 @@ function runAgentsMd(argv: string[]): number {
 // on the parity-probe discipline in AGENTS.md, which derives expected
 // spec values by piping BOTH CLIs and comparing. A truncated pipe there
 // reads as a port divergence.
+// ---------------------------------------------------------------------
+// The source formatter (docs/design/FMT.0.md): one agreed form, in the
+// tradition of gofmt. The verb prints, lists, checks, diffs or rewrites;
+// the form itself is the library's (ts/src/format.ts), and the two
+// ports agree on it row by row in test/spec/fmt.tsv.
+
+const FMT_HELP = 'aontu fmt [-w|-l|--check|-d] <file>... (try --help)'
+
+type FmtFlags = { write: boolean, list: boolean, check: boolean, diff: boolean }
+
+function runFmt(argv: string[]): number | Promise<number> {
+  const files: string[] = []
+  const flags: FmtFlags = { write: false, list: false, check: false, diff: false }
+
+  for (const arg of argv) {
+    if ('-h' === arg || '--help' === arg) {
+      process.stdout.write(HELP)
+      return 0
+    }
+    if ('-w' === arg || '--write' === arg) {
+      flags.write = true
+    }
+    else if ('-l' === arg || '--list' === arg) {
+      flags.list = true
+    }
+    else if ('--check' === arg) {
+      flags.check = true
+    }
+    else if ('-d' === arg || '--diff' === arg) {
+      flags.diff = true
+    }
+    else if (arg.startsWith('-')) {
+      process.stderr.write(`aontu: unknown fmt option ${arg} (try --help)\n`)
+      return 2
+    }
+    else {
+      files.push(arg)
+    }
+  }
+
+  if (0 === files.length) {
+    // Standard input: formatted onto standard output, or listed,
+    // checked and diffed under the name <stdin>. It cannot be written
+    // back.
+    if (flags.write) {
+      process.stderr.write(`aontu: --write needs a file\n${FMT_HELP}\n`)
+      return 2
+    }
+    return new Promise((resolve) => {
+      let src = ''
+      process.stdin.setEncoding('utf8')
+      process.stdin.on('data', (d) => (src += d))
+      process.stdin.on('end', () => resolve(fmtOne('<stdin>', src, flags)))
+    })
+  }
+
+  // Several files onto standard output would be one stream nobody can
+  // split again (the note's X-6): the verb refuses unless an option
+  // says what to do with each.
+  if (1 < files.length && !fmtQuiet(flags)) {
+    process.stderr.write(
+      `aontu: fmt prints one file; with ${files.length}, say --write, ` +
+      `--list, --check or --diff\n${FMT_HELP}\n`)
+    return 2
+  }
+
+  let worst = 0
+  for (const file of files) {
+    let src: string
+    try {
+      src = readFileSync(file, 'utf8')
+    }
+    catch (err: any) {
+      process.stderr.write(`aontu: cannot read ${err.path}: ${err.message}\n`)
+      return 2
+    }
+    worst = Math.max(worst, fmtOne(file, src, flags))
+  }
+  return worst
+}
+
+// An option that says what to do with a file that would change, in
+// place of printing it.
+function fmtQuiet(flags: FmtFlags): boolean {
+  return flags.write || flags.list || flags.check || flags.diff
+}
+
+// One document: 0 printed, clean or done; 1 a --check that would
+// change; 2 a file that cannot be written; 4 a document that does not
+// format, with the finding that says why.
+function fmtOne(name: string, src: string, flags: FmtFlags): number {
+  const report = format(src, { path: name })
+  if ('error' === report.verdict) {
+    process.stderr.write(`aontu: ${name} was not formatted\n` +
+      report.errors.map(renderFinding).join('\n') + '\n')
+    return 4
+  }
+  if (!fmtQuiet(flags)) {
+    process.stdout.write(report.text)
+    return 0
+  }
+  if (!report.changed) {
+    return 0
+  }
+  if (flags.list || flags.check) {
+    process.stdout.write(name + '\n')
+  }
+  if (flags.diff) {
+    process.stdout.write(unifiedDiff(name, src, report.text))
+  }
+  if (flags.write) {
+    try {
+      writeFileSync(name, report.text)
+    }
+    catch (err: any) {
+      process.stderr.write(`aontu: cannot write ${name}: ${err.message}\n`)
+      return 2
+    }
+  }
+  return flags.check ? 1 : 0
+}
+
+
 function finish(code: number): void {
   process.exitCode = code
 }
@@ -3352,16 +3547,16 @@ function finish(code: number): void {
 // spelling, so the caller owns the usage error.
 function parseTrustArg(value: string): TrustArg | undefined {
   if ('system' === value) {
-    return { kind: 'system' }
+    return { kind: 'system', textExt: [] }
   }
   if ('none' === value) {
-    return { kind: 'none' }
+    return { kind: 'none', textExt: [] }
   }
   if ('root' === value) {
-    return { kind: 'root' }
+    return { kind: 'root', textExt: [] }
   }
   if (value.startsWith('root:') && 'root:'.length < value.length) {
-    return { kind: 'root', dir: value.slice('root:'.length) }
+    return { kind: 'root', dir: value.slice('root:'.length), textExt: [] }
   }
   return undefined
 }
@@ -3385,7 +3580,8 @@ function main(argv: string[]): void {
   // overwritten twice. In a tool loop that reads as a passing
   // validation. Counting them is what lets the refusal below happen.
   const files: string[] = []
-  let trust: TrustArg = { kind: 'system-warn' }
+  let trust: TrustArg = { kind: 'system-warn', textExt: [] }
+  let textExt: string[] = []
   // The REPL's SESSION protocol (G7 phase 7): one JSON line per
   // answer, so a harness can drive the session. Named --jsonl rather
   // than the design's --json, which would read as the `:json` output
@@ -3413,6 +3609,9 @@ function main(argv: string[]): void {
   if ('agentsmd' === argv[2]) {
     return finish(runAgentsMd(argv.slice(3)))
   }
+  if ('fmt' === argv[2]) {
+    return void Promise.resolve(runFmt(argv.slice(3))).then(finish)
+  }
 
   if ('set' === argv[2]) {
     return finish(runSet(argv.slice(3)))
@@ -3492,7 +3691,17 @@ function main(argv: string[]): void {
         process.stderr.write('aontu: --include-root needs a directory\n')
         return finish(2)
       }
-      trust = { kind: 'root', dir }
+      trust = { kind: 'root', dir, textExt }
+    }
+    else if ('--text-ext' === arg) {
+      const list = null == args[i + 1] ? undefined : parseTextExt(args[++i])
+      if (null == list) {
+        process.stderr.write(
+          'aontu: --text-ext needs extensions, without dots' +
+          ' (--text-ext md,sql)\n')
+        return finish(2)
+      }
+      textExt = [...textExt, ...list]
     }
     else if (arg.startsWith('-')) {
       process.stderr.write(`aontu: unknown option ${arg} (try --help)\n`)
@@ -3519,6 +3728,11 @@ function main(argv: string[]): void {
     return finish(2)
   }
 
+  // The extensions ride with the capability from here on, so the three
+  // entry shapes below (file, REPL, stdin) each get them by threading
+  // the one value they already thread.
+  trust = { ...trust, textExt }
+
   const file = files[0]
   if (null != file) {
     finish(runFile(file, mode, trust))
@@ -3547,6 +3761,6 @@ export {
   runJsonSchema,
   runMod,
   runHash, runGet,
-  runWhy, renderWhyText, runSet, runAgentsMd,
+  runWhy, renderWhyText, runSet, runAgentsMd, runFmt,
   watchChange, watchSignature, vetWaiter, deprecatedAt,
 }

package/src/diff.ts

@@ -1,4 +1,5 @@
 /* Copyright (c) 2025 Richard Rodger, MIT License */
+import { includeOpts } from './utility'
 
 // PATH-ADDRESSED DIFF (G7 phase 6,
 // docs/capability-review/g7-machine-access.md): what changed, at which
@@ -61,6 +62,11 @@ export type DiffOptions = {
   // extension -- but reading is enough.) A server passes
   // `{include:'none'}`.
   trust?: TrustOptions
+
+  // Extensions additionally read as text (the CLI's `--text-ext`).
+  // Rides beside `trust` because it is the other half of what an
+  // include may read.
+  textExt?: string[]
 }
 
 
@@ -182,8 +188,7 @@ function evalSide(
 export function diff(
   leftSrc: string, rightSrc: string, opts?: DiffOptions): DiffReport {
   const options = opts ?? {}
-  const aontu = new Aontu(
-    null == options.trust ? undefined : { trust: options.trust })
+  const aontu = new Aontu(includeOpts(options))
 
   const l = evalSide(aontu, leftSrc, options.leftPath, options.at)
   const r = evalSide(aontu, rightSrc, options.rightPath, options.at)