aontu 0.62.0 → 0.63.0

package/src/subsume.ts

@@ -1,27 +1,6 @@
 /* Copyright (c) 2025 Richard Rodger, MIT License */
 import { includeOpts } from './utility'
 
-// Subsumption as a first-class query (G3 phases 1-2,
-// docs/capability-review/g3-subsumption-evolution.md): does the GENERAL
-// value admit every instance the SPECIFIC value admits?
-//
-// The recursion is a dedicated structural walk over EVALUATED values —
-// design option B. It never mutates its inputs (it runs after
-// evaluation, on finished trees), carries no fixpoint, and returns a
-// THREE-VALUED verdict: `subsumes`, `does_not_subsume` (with the
-// failing path and both sides' canons as the witness), or `undecided`
-// (with a reason code, never silently). Where a rule cannot decide the
-// answer folds toward "not subsumed" or "undecided" — the safe
-// directions: a compatibility gate that wrongly reports "breaking"
-// costs a second look, one that wrongly reports "compatible" ships the
-// break (docs/reference-language.md, "Subsumption").
-//
-// Findings reuse G2's report vocabulary (the vet finding object), with
-// the G3 codes appended to the shared registry: `compat_narrowed`,
-// `compat_required_added`, `compat_default_changed`,
-// `compat_marks_changed`, and the `sub_*` undecided reasons — all
-// class `compat`.
-
 
 import type { TrustOptions } from './type'
 import { Aontu } from './aontu'
@@ -45,7 +24,7 @@ export type SubsumeProfile = 'values' | 'defaults' | 'gen'
 export type SubsumeOptions = {
   profile?: SubsumeProfile
   at?: string
-  generalUrl?: string   // provenance label for general sites
+  generalUrl?: string
   specificUrl?: string  // provenance label for specific sites
   // Where each document CAME FROM, so a relative `@"file"` load inside
   // it resolves from its own directory — vet's schemaPath/dataPath
@@ -73,8 +52,6 @@ const DEFAULT_GENERAL_URL = 'general'
 const DEFAULT_SPECIFIC_URL = 'specific'
 
 
-// One comparison's running state: the finding list, the two provenance
-// labels, and the profile.
 type SubState = {
   profile: SubsumeProfile
   // Set inside a distribution trial: see trialSubsume.
@@ -94,10 +71,6 @@ function pathText(path: string[]): string {
 }
 
 
-// Every recorded operand is a real evaluated Val or the sited topLike
-// stand-in, so no null guards: a Val's site is always an object, and a
-// value parsed without a usable frame (a disjunct, say) already carries
-// the -1 coordinates in it.
 function siteOf(v: any, role: string, url: string): VetSite {
   return {
     file: url,
@@ -133,50 +106,17 @@ function record(
 }
 
 
-// The admission view of a value under a profile: a BARE preference
-// admits what its superior admits (the engine's own PrefVal.superpeg
-// semantics, and the docs' "a bare preference is gated by kind"); the
-// default itself is compared separately, by the `defaults` and `gen`
-// profiles.
 function admission(v: any): any {
   return true === v?.isPref ? v.superpeg : v
 }
 
 
-// A PREFERRED BRANCH CONTRIBUTES EXACTLY ITS OWN VALUE (ADR-004). The
-// admission gate made that the engine's rule -- `*'auto'|'literal'|'data'`
-// admits those three strings and nothing else -- and the subsumption
-// walk kept comparing a pref MEMBER by its kind superior, the
-// pre-ADR-004 reading. So a disjunction with a default did not subsume
-// ITSELF: every member of the specific side widened to `string`, which
-// no general member admits, and the walk answered the distribution
-// case. `aontu_policy: hide({compat: *backward|forward|full|none})` --
-// the verbatim idiom from reference-api.md -- failed self-subsumption
-// under --profile gen (use-cases/BUGS.md §29).
-//
-// Only for a member of a disjunction: a bare `*x` standing alone is
-// still gated by kind, which is the rule above and the documented one.
 function memberAdmission(v: any): any {
   return true === v?.isPref ? prefInnerPeg(v) : v
 }
 
 
-// The effective default of a value, or undefined when it has none, or
-// 'indeterminate' when equal-rank preferences disagree (which the
-// engine itself refuses only at generation).
-// Exported (with subsumeNode) for the default-validity lint in
-// ts/src/vet.ts (G3 phase 5): the lint asks exactly this walk's two
-// questions — what is the effective default, and does a member admit
-// it.
 export function effectiveDefault(v: any): any {
-  // EVERY pref layer is unwrapped (prefInnerPeg), not just one: a
-  // ranked default's effective value is the innermost peg — `**member`
-  // generates "member" exactly as `*member` does (the rank-uniform
-  // meet, ADR-004). The one-layer unwrap left a rank-2 default wearing
-  // a `*`-wrapper no plain alternative subsumes, which is the
-  // pref_not_instance lint's ranked false positive of
-  // use-cases/BUGS.md §4 (`**member|member|admin|owner` warned while
-  // generating a value its own branch admits).
   if (true === v?.isPref) {
     return prefInnerPeg(v)
   }
@@ -225,10 +165,6 @@ function unresolved(v: any): boolean {
 }
 
 
-// Exported for the defensive-arm unit test (ADR-002,
-// ts/test/coverage3.test.ts): the no-rule fold at the walk's tail is
-// unreachable through subsume() today — the ladder is total for every
-// evaluated former — and the walk is otherwise private.
 export function subsumeNode(
   state: SubState, path: string[], g0: any, s0: any): Tri {
 
@@ -247,32 +183,11 @@ export function subsumeNode(
     return 'no'
   }
 
-  // TOP admits everything. There is no nil rule: an error-free
-  // evaluated document carries no nil (failing disjunct members are
-  // discarded, every other nil collects an error, and subsume() answers
-  // `error` for a source that does not stand alone), so a nil handed to
-  // the walk by a future caller falls to the no-rule fold below —
-  // `undecided`, the safe direction.
   if (true === g?.isTop) {
     return 'yes'
   }
 
   if (unresolved(g) || unresolved(s)) {
-    // REFLEXIVITY IS A LAW, not a rule the ladder gets to skip. Every
-    // value admits itself, residue included: the set admitted by
-    // `integer & min(0)` is exactly the set admitted by
-    // `integer & min(0)`. Without this, a constraint inside a spread
-    // template made a contract non-SELF-subsumable -- expected and
-    // actual byte-identical, verdict `undecided` -- so `breaking` on
-    // the documented close-per-entry idiom hard-failed reflexivity and
-    // had to run --allow-undecided, which then masks the genuine
-    // undecideds it exists to surface (use-cases/BUGS.md §28).
-    //
-    // Identity is the HASH FORM, not the canon: canon drops closedness
-    // and the marks, so `close({a:1})` and `{a:1}` share a canon while
-    // admitting different sets. Computed only on this branch, where
-    // the answer would otherwise be undecided, so the hot path is
-    // untouched.
     if (hcanon(g) === hcanon(s)) {
       return 'yes'
     }
@@ -281,10 +196,6 @@ export function subsumeNode(
     return 'undecided'
   }
 
-  // Disjunctions. General side first: a specific member must be
-  // subsumed by SOME general member; member-wise failure is not proof
-  // (the distribution case), so a concrete failing member becomes the
-  // witness and anything else is honestly undecided.
   if (true === s?.isDisjunct) {
     let out: Tri = 'yes'
     for (const raw of s.peg as any[]) {
@@ -343,11 +254,6 @@ export function subsumeNode(
       return 'no'
     }
     if (true === s?.isConstraint) {
-      // A kind covers a residual of its own domain: `number` admits any
-      // numeric residual (the supertype admits every leaf a bound can
-      // pin), a numeric LEAF kind admits only a residual pinned to that
-      // leaf, and `string` admits any pattern residual. A residual with
-      // no domain (sizing-only) admits containers no kind covers.
       const dom = (s as any).domain
       const skind = (s as any).kind
       if ('number' === dom &&
@@ -383,7 +289,6 @@ export function subsumeNode(
     return 'no'
   }
 
-  // Constraint residuals.
   if (true === g?.isConstraint) {
     if (true === s?.isConstraint) {
       const r = constraintSubsumesConstraint(g, s)
@@ -460,26 +365,6 @@ export function subsumeNode(
       (v: any, k: string) => v.peg[Number(k)])
   }
 
-  // THE LADDER IS NOT TOTAL, and the formers that fall past it are the
-  // ones the evaluator MEANS to leave standing: a recursion, a
-  // relation and its graph atom, a `refer()` target constraint. None
-  // of them describes a set of values a structural walk can compare,
-  // so `undecided` is the honest answer for two DIFFERENT ones.
-  //
-  // For two IDENTICAL ones it is not. REFLEXIVITY IS A LAW -- every
-  // value admits itself -- and identity is the HASH FORM, the same
-  // rule the unresolved branch above applies and for the same reason:
-  // it costs nothing, because it runs only where the answer would
-  // otherwise be `undecided`. Without it a document that declares a
-  // relation, shares a template by reference or alias, or recurses did
-  // not subsume ITSELF, so `breaking` on the idiom the language exists
-  // for hard-failed and had to run --allow-undecided, which masks the
-  // genuine undecideds it exists to surface (use-cases/BUGS.md 64,
-  // and 28 before it).
-  //
-  // A NIL is the exception, and the reason the law is spelled here
-  // rather than in `unresolved`: a nil is not a value, so it admits
-  // nothing, itself included.
   if (true !== g?.isNil && true !== s?.isNil && hcanon(g) === hcanon(s)) {
     return 'yes'
   }
@@ -554,16 +439,6 @@ function subsumeBag(
     }
   }
 
-  // Spread templates: a path-dependent template's meaning depends on
-  // where it lands, which no structural comparison can decide -- UNLESS
-  // the two templates are the same template. REFLEXIVITY IS A LAW and
-  // identity is the HASH FORM (the same rule the unresolved branch of
-  // subsumeNode applies): two byte-identical templates admit the same
-  // set wherever they land, so a document with a reference- or
-  // alias-valued template subsumes itself, and the comparison either
-  // side of the template is decided on its own merits rather than
-  // dragged to `undecided` (use-cases/BUGS.md 64). Where they are NOT
-  // identical, nothing structural can decide them and the fold stands.
   const gcj = g.spread?.cj
   const scj = s.spread?.cj
   if (null != gcj || null != scj) {
@@ -596,12 +471,6 @@ function subsumeBag(
 let topVal: any
 function topLike(): any {
   if (null == topVal) {
-    // A full site, not a partial one: `len` and `src` are as much part
-    // of the shape as row and col, and leaving them undefined dropped
-    // both keys from the emitted report — so this stand-in was the one
-    // site in either port with no `len` at all, and the Go twin (which
-    // has no undefined) disagreed. It occupies no source, so the values
-    // are the "unknown" ones.
     topVal = {
       isTop: true, canon: 'top',
       site: { row: -1, col: -1, len: -1, src: '' },
@@ -611,20 +480,6 @@ function topLike(): any {
 }
 
 
-// A trial comparison whose findings are DISCARDED: disjunct
-// member-matching asks many "would this member do?" questions, and only
-// the aggregated outcome is a finding.
-// A DISTRIBUTION TRIAL IS NOT A NODE CORRESPONDENCE. It asks whether
-// one ALTERNATIVE of one side admits one alternative of the other,
-// which is a question about admitted sets; the two values it compares
-// are not the same node of the two documents. The `gen` profile's mark
-// rule is a correspondence question -- did a field that used to be
-// generated become hidden -- and firing it here compared a whole
-// disjunction (carrying its enclosing bag's mark) against a member
-// extracted out of one (which does not), so `hide({c: *a|b})` stopped
-// subsuming ITSELF under --profile gen (use-cases/BUGS.md §29). The
-// enclosing node's marks are compared where they correspond: at that
-// node, by the ordinary walk.
 function trialSubsume(
   state: SubState, path: string[], g: any, s: any): Tri {
   const trial: SubState = { ...state, findings: [], distributing: true }
@@ -632,11 +487,6 @@ function trialSubsume(
 }
 
 
-// The defaults comparison (the `defaults` and `gen` profiles): the
-// specific side's effective default must survive into the general side
-// unchanged. Adding a default where none existed is compatible;
-// changing or removing one is not (removal turns previously generable
-// documents incomplete).
 function subsumeDefaults(
   state: SubState, path: string[], g: any, s: any): Tri {
   const sd = effectiveDefault(s)
@@ -682,16 +532,6 @@ function subsumeDefaultsWalk(
 }
 
 
-/**
- * Does `generalSrc` subsume `specificSrc` — is every instance the
- * specific admits admitted by the general too?
- *
- * Both sources are evaluated fresh (single-use trees make this
- * mandatory), and the recursion runs on the finished values. The
- * verdict is three-valued plus `error` (a source that does not stand up
- * on its own, mirroring vet's schema-error verdict); findings reuse
- * G2's object with class `compat`.
- */
 export function subsume(
   generalSrc: string, specificSrc: string, opts?: SubsumeOptions,
 ): SubsumeReport {

package/src/template.ts

@@ -1,70 +1,6 @@
 /* Copyright (c) 2025 Richard Rodger, MIT License */
 
 
-// THE TEMPLATE SURFACE (docs/design/TEMPLATE.0.md; RENDER.0.md P8).
-// A generator written in the TARGET's own syntax: a marked line is
-// aontu source, and every other line is a line of output.
-//
-//   //- code: units: [{ path: "hi.ts", lang: "typescript", decls: [{
-//   //-   k: "frag", of: emit($.svc, { match: { n: string }, body: [
-//   export const NAME = "world"
-//   //- ]}) }] }]
-//
-// That is the whole desugaring, and it is LINE-ORIENTED: nothing here
-// parses aontu, and nothing here reads the target's syntax beyond its
-// comment token. A marker line contributes its text to the document; an
-// unmarked line contributes one quoted string, which is a body element
-// where the marker lines left a list open.
-//
-// WHY A COMMENT TOKEN PLUS A DASH (D2). The generator file must stay
-// valid in its own language -- so an editor highlights it, a compiler
-// parses it, and a reviewer reads it -- and the one thing every
-// language has that the target's own tools already ignore is a
-// comment. Adding a dash distinguishes a marker from an ordinary
-// comment, and derives for a language this table has never seen: the
-// caller passes the token.
-//
-// A MARKER IS RECOGNISED AFTER LEADING WHITESPACE, AND THE INDENTATION
-// THE RESUGARING WRITES IS THE AONTU'S (D2, amended 2026-09-07). An
-// output line is verbatim -- a line indented two spaces in the template
-// is indented two spaces in the generated file (D7) -- and that is the
-// half a reader of the TARGET needs. The other half is the document:
-// the marker lines carry a tree, and a tree nobody can see the shape of
-// is the one thing this surface took away. So the marker stands at the
-// left margin and the aontu is indented AFTER it, which `aontu fmt`
-// (FMT.0.md M-BM-'3.14) is what writes.
-//
-// Reading is unchanged and stays generous: a marker after leading
-// whitespace is a marker, and its own indentation still counts toward
-// the aontu it carries, so a template written the other way desugars to
-// the same document. What changes is the spelling the round trip
-// answers, and `template --check` names the difference as the drift it
-// is.
-//
-// THE SUGAR IS THE FIXPOINT OF THE TWO TRANSFORMS (D6), and that is
-// the whole of the resugaring's safety. A canonical line that looks
-// like a body element is rebuilt as a target line, the rebuild is
-// desugared, and the rebuild is taken ONLY if that reproduces the
-// canonical line. A line no target line can carry -- one that would
-// itself read as a marker -- fails that test and stays where it is, so
-// there is no table of escapes to get wrong and no line the round trip
-// can lose.
-//
-// WHITESPACE CONTROL IS ABSENT AND UNNEEDED (D8): a marker line is not
-// an output line at all, so no construct can leak a newline into the
-// output. What IS significant is the template's own trailing
-// whitespace -- a line of two spaces is two spaces of output -- which
-// is why the canonical form quotes every body line explicitly. Note
-// what `template --check` does and does not catch: it holds the FILE
-// to the spelling these two transforms answer, so a marker written
-// without its space or with its aontu indented after it is named; a
-// body line an editor trimmed is still a valid template, and what
-// names that is `render --check` against the committed output.
-
-
-// A marker is a comment token plus a dash. These are the tokens the
-// verb derives from a file's extension; any other language passes its
-// own, which is why the surface needs no table of languages.
 const MARKERS: Record<string, string> = {
   c: '//-',
   cc: '//-',
@@ -79,6 +15,8 @@ const MARKERS: Record<string, string> = {
   jsx: '//-',
   kt: '//-',
   lua: '---',
+  markdown: '<!---',
+  md: '<!---',
   php: '//-',
   pl: '#-',
   py: '#-',
@@ -99,36 +37,70 @@ const MARKERS: Record<string, string> = {
 // C-family line comment, which is the one the note is written in.
 const DEFAULT_MARKER = '//-'
 
-// A BLOCK MARKER CLOSES ITSELF. A language with no line comment (CSS
-// is the one in the table) marks with `/*- … */`, and the closer is
-// implied by the opener rather than named separately: there is one
-// block form, and a marker that opens `/*-` ends `*/`.
-const BLOCK_CLOSE = '*/'
+// A marker outside this table names its closer itself.
+const IMPLIED_CLOSE: [string, string][] = [
+  ['<!--', '-->'],
+  ['/*', '*/'],
+]
+
+
+function extensionOf(path: string): string {
+  const dot = path.lastIndexOf('.')
+  const slash = Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\'))
+  return dot > slash ? path.slice(dot + 1).toLowerCase() : ''
+}
 
 
 // The marker for a file, by its extension, or the C-family default.
 // The extension decides, exactly as it decides what an include is
 // (ADR-012) -- one rule, and no flag to remember for the common case.
 function markerFor(path: string): string {
-  const dot = path.lastIndexOf('.')
-  const slash = Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\'))
-  const ext = dot > slash ? path.slice(dot + 1).toLowerCase() : ''
-  return MARKERS[ext] ?? DEFAULT_MARKER
+  return MARKERS[extensionOf(path)] ?? DEFAULT_MARKER
+}
+
+
+// What reaches a language the table has no entry for by FILENAME
+// rather than by a flag on every call.
+function markerFromProfiles(
+  profiles: any[], path: string
+): string | undefined {
+  const ext = extensionOf(path)
+  if ('' === ext) {
+    return undefined
+  }
+  for (const profile of profiles) {
+    const tmpl = profile?.template
+    if (null == tmpl || !Array.isArray(tmpl.ext) || !tmpl.ext.includes(ext)) {
+      continue
+    }
+    return null == tmpl.close ? tmpl.marker : tmpl.marker + ' ' + tmpl.close
+  }
+  return undefined
 }
 
 
-// Is this marker the block form?
-function isBlock(marker: string): boolean {
-  return marker.startsWith('/*')
+// A marker may carry its own closer after a space, which no comment
+// opener holds. An empty closer is the line form.
+type MarkerForm = { open: string, close: string }
+
+
+function markerForm(marker: string): MarkerForm {
+  const cut = marker.indexOf(' ')
+  if (-1 < cut) {
+    return {
+      open: marker.slice(0, cut),
+      close: trimLine(marker.slice(cut + 1)),
+    }
+  }
+  for (const [open, close] of IMPLIED_CLOSE) {
+    if (marker.startsWith(open)) {
+      return { open: marker, close }
+    }
+  }
+  return { open: marker, close: '' }
 }
 
 
-// INDENTATION IS SPACES AND TABS, and nothing else. A host trim is not
-// the same set in the two ports -- JavaScript's trims every Unicode
-// space, Go's `TrimSpace` trims a different list -- and a line of a
-// template file that began with one of the characters they disagree
-// about would be a marker line in one engine and a line of output in
-// the other. Twin of templateIndent in go/template.go.
 function indentOf(line: string): number {
   let i = 0
   while (i < line.length && (' ' === line[i] || '\t' === line[i])) {
@@ -164,31 +136,21 @@ type Line = {
 }
 
 
-function readLine(line: string, marker: string): Line {
+function readLine(line: string, form: MarkerForm): Line {
   const cut = indentOf(line)
   const indent = line.slice(0, cut)
   const rest = line.slice(cut)
-  if (!rest.startsWith(marker)) {
+  if (!rest.startsWith(form.open)) {
     return { marker: false, indent: '', text: line }
   }
-  let body = rest.slice(marker.length)
-  // The block form's closer is part of the marker, not of the aontu.
-  // A block marker line that never closes is not a marker line: the
-  // language's own parser would not read it as a comment either.
-  // Only the TRAILING space goes: what stands between the opener and
-  // the aontu is the aontu's indentation, exactly as it is for a line
-  // marker, and the one-space rule below takes the marker's own.
-  if (isBlock(marker)) {
-    const end = body.lastIndexOf(BLOCK_CLOSE)
+  let body = rest.slice(form.open.length)
+  if ('' !== form.close) {
+    const end = body.lastIndexOf(form.close)
     if (end < 0) {
       return { marker: false, indent: '', text: line }
     }
     body = trimEnd(body.slice(0, end))
   }
-  // ONE SPACE AFTER THE MARKER IS THE MARKER'S, so `//- x: 1` carries
-  // `x: 1` and the resugaring writes the space back. A marker written
-  // without it carries the same aontu and is normalised on the round
-  // trip, which `--check` reports as the drift it is.
   if (body.startsWith(' ')) {
     body = body.slice(1)
   }
@@ -196,16 +158,6 @@ function readLine(line: string, marker: string): Line {
 }
 
 
-// THE CANONICAL QUOTE IS CHOSEN PER LINE (D6). A backtick string
-// carries `"` and `'` unescaped, which is most of what target code
-// holds, so a line takes one unless it holds a backtick itself.
-//
-// A BACKSLASH IS ESCAPED IN EITHER QUOTE, and that is not what the
-// design note assumed: this engine reads the escapes of a backtick
-// string exactly as it reads a quoted one, and an unknown escape drops
-// its backslash (`\p` is `p`), so a target line holding `\n` inside a
-// string of its own would arrive in the output as a newline. Only the
-// delimiter differs between the two forms.
 function quoteLine(text: string): string {
   const escaped = text.replace(/\\/g, '\\\\')
   return text.includes('`') ?
@@ -214,10 +166,6 @@ function quoteLine(text: string): string {
 }
 
 
-// The line a quoted body element carries, or undefined when the line
-// is not one: anything but a lone string literal, and any escape the
-// quoting above does not write. The fixpoint test below is what makes
-// being conservative here safe -- a line this refuses stays aontu.
 function unquoteLine(text: string): string | undefined {
   const t = trimLine(text)
   if (2 > t.length) {
@@ -249,12 +197,8 @@ function unquoteLine(text: string): string | undefined {
 }
 
 
-// DESUGAR: a template file becomes the canonical aontu document.
-// A marker line is its own text, at its own indentation; every other
-// line is one quoted string, which lands wherever the marker lines
-// left a list open.
 function desugarTemplate(src: string, marker?: string): string {
-  const mark = marker ?? DEFAULT_MARKER
+  const form = markerForm(marker ?? DEFAULT_MARKER)
   const lines = src.split('\n')
   // A trailing newline is the file's, not a line of output: a text
   // file ends with one, and the round trip must not grow an empty
@@ -264,30 +208,22 @@ function desugarTemplate(src: string, marker?: string): string {
     lines.pop()
   }
   const out = lines.map((line) => {
-    const read = readLine(line, mark)
+    const read = readLine(line, form)
     return read.marker ? read.indent + read.text : quoteLine(read.text)
   })
   return out.join('\n') + (tail ? '\n' : '')
 }
 
 
-// RESUGAR: the canonical document becomes a template file. Every line
-// is a marker line unless it is a body element that survives the
-// fixpoint -- rebuild the target line, desugar the rebuild, and take
-// it only if that answers the canonical line back.
 function resugarTemplate(src: string, marker?: string): string {
   const mark = marker ?? DEFAULT_MARKER
+  const form = markerForm(mark)
   const lines = src.split('\n')
   const tail = 1 < lines.length && '' === lines[lines.length - 1]
   if (tail) {
     lines.pop()
   }
   const out = lines.map((line) => {
-    // THE ELEMENT'S OWN INDENTATION IS NOT PART OF IT: the target line
-    // is the string's content, and where the canonical form puts the
-    // element on the page is the formatter's business. Comparing the
-    // whole line instead would refuse every body element of a document
-    // `aontu fmt` had indented, which is every document it has seen.
     const target = unquoteLine(line)
     if (undefined !== target && desugarTemplate(target, mark) === trimLine(line)) {
       return target
@@ -296,30 +232,22 @@ function resugarTemplate(src: string, marker?: string): string {
     // is written after it, so the aontu's own shape is on the page.
     // The one space is the marker's, which the reading takes back.
     const text = trimEnd(line)
-    const close = isBlock(mark) ? ' ' + BLOCK_CLOSE : ''
-    return '' === text ? mark + close : mark + ' ' + text + close
+    const close = '' === form.close ? '' : ' ' + form.close
+    return '' === text ? form.open + close :
+      form.open + ' ' + text + close
   })
   return out.join('\n') + (tail ? '\n' : '')
 }
 
 
-// WHICH LINES OF THE DESUGARED DOCUMENT ARE THE TARGET'S. The
-// desugaring is line for line, so this is one flag per line of what
-// `desugarTemplate` returns: true where the template's line was not a
-// marker, and so where the document's line is one quoted line of the
-// generated file.
-//
-// `aontu fmt` reads it (FMT.0.md M-BM-'3.14) to hold those lines on lines of
-// their own. A body element is a string like any other, and the packing
-// budget would put three of them on one line -- which is aontu where
-// three lines of output were, and a generator that writes them as one.
 function templateOutputs(src: string, marker: string): boolean[] {
+  const form = markerForm(marker)
   const lines = src.split('\n')
   if (1 < lines.length && '' === lines[lines.length - 1]) {
     lines.pop()
   }
-  return lines.map((line) => !readLine(line, marker).marker)
-} /* node:coverage ignore next 9 */
+  return lines.map((line) => !readLine(line, form).marker)
+} /* node:coverage ignore next 10 */
 
 
 export {
@@ -327,5 +255,6 @@ export {
   resugarTemplate,
   templateOutputs,
   markerFor,
+  markerFromProfiles,
   DEFAULT_MARKER,
 }