aontu 0.62.0 → 0.64.0

package/src/val/ArithFuncVal.ts

@@ -15,17 +15,6 @@ import { arith } from './arith'
 import type { ArithOp } from './arith'
 
 
-// ONE CLASS FOR SIX FUNCTIONS, because every rule they obey is a rule
-// about arithmetic rather than about any one operation (see arith.ts).
-// Six near-identical classes would be six places for the exact ladder,
-// the zero divisor and the storage contract to drift apart, and the
-// number tower's whole point is that they cannot.
-//
-// The op is carried on the instance and answered by `funcname()`, which
-// is what canon renders and what an error names. The six one-line
-// subclasses below exist only because the parser's registry constructs
-// with `new funcval({peg: args})` and has nowhere to put a name; every
-// line of behaviour is here.
 class ArithFuncVal extends FuncBaseVal {
   isArithFunc = true
 
@@ -60,18 +49,9 @@ class ArithFuncVal extends FuncBaseVal {
   }
 
 
-  // NO superior() OVERRIDE, deliberately. An arithmetic call could only
-  // advertise a kind once both its operands were concrete scalars -- and
-  // at that point it has RESOLVED, so what `super()` sees is the result,
-  // whose own superior is already the right answer:
-  // `super(mul(2,3))` is `integer` and `super(mul(2,1.5))` is `float`,
-  // through the value rather than through a promise about it. The
-  // override was written and then removed as unreachable; the same is
-  // true of FuncVal.superior in the Go port.
 }
 
 
-// The six the registry names. Each is its operation and nothing else.
 class AddFuncVal extends ArithFuncVal {
   constructor(spec: ValSpec, ctx?: AontuContext) { super(spec, ctx, 'add') }
 }

package/src/val/BagVal.ts

@@ -30,15 +30,6 @@ abstract class BagVal extends FeatureVal {
   closed: boolean = false
   optionalKeys: string[] = []
 
-  // ALIAS DECLARATIONS, by key. `%uint8 = …` binds a name for this file
-  // and is not a field of the document: it does not generate and does
-  // not appear in canon, so a document using aliases and its expanded
-  // twin are the SAME document and hash identically
-  // (docs/design/ALIASES.0.md §4).
-  //
-  // Keyed on the map rather than marked on the value, because a
-  // reference copies the value it resolves to -- a mark riding the
-  // value would erase the referring field along with the declaration.
   aliasKeys: string[] = []
 
   spread = {
@@ -60,30 +51,9 @@ abstract class BagVal extends FeatureVal {
 
 
   handleExpectedVal(key: string, val: Val, parent: Val, ctx: AontuContext): Val {
-    // A MARKED value is carried, never expected (ADR-005 era, BUGS.md
-    // §12's include form): a type()/hide()-marked child legitimately
-    // participates in unification without ever generating — that is
-    // the marks contract — so wrapping one as an expectation turned a
-    // schema field arriving through an include's map meet into a
-    // bogus `mapval_spread_required` naming a spread that exists in
-    // neither file. The bag's gen already skips marked children.
-    //
-    // An OPERATOR is carried too (BUGS.md §36): an expression is a
-    // computation that resolves by itself once its operands do — the
-    // bag's own-key loop drives it every pass — so `m:{y:.x+1}`
-    // arriving as a peer key must keep computing exactly as it does
-    // written inline. Wrapping it froze the op (an expectation only
-    // advances when a peer arrives) and the residue then reported the
-    // phantom `mapval_spread_required` naming a spread that exists
-    // nowhere. An op that truly never resolves is honest *_no_gen
-    // residue naming the expression itself.
     if (val.isGenable || val.isOp || val.mark.type || val.mark.hide) {
       return val
     }
-    // An expectation baked into a combined spread template (the
-    // 'map-self' meet of two unequal templates) is re-wrapped FRESH, so
-    // key/parent name THIS bag and the template's own node is never
-    // stored at a destination.
     const expectVal = new ExpectVal({ peg: val.isExpect ? val.peg : val }, ctx)
     expectVal.key = key
     expectVal.parent = parent
@@ -91,20 +61,6 @@ abstract class BagVal extends FeatureVal {
   }
 
 
-  // TWO BAGS ARE THE SAME VALUE WHEN THEY HAVE THE SAME SHAPE. Val.same
-  // falls back to object IDENTITY, which no two separately built maps
-  // share -- so `x:*{a:1}|{a:number}` met by `x:{a:2}` left
-  // `{"a":2}|{"a":2}`, a disjunction of one value spelled twice, past
-  // the DisjunctVal dedup. Generation's old member FOLD hid that
-  // (folding a value with itself is that value); ADR-007 does not, and
-  // a disjunction whose alternatives are all the SAME value is
-  // resolved, not ambiguous. Canon prints the collapse too, which is
-  // the more honest text.
-  //
-  // Structural, and deliberately strict: container kind, closedness,
-  // the marks, the optional keys and the key set must all agree before
-  // the children are compared pairwise. Recursion terminates because a
-  // reference is not a bag -- RefVal keeps the identity comparison.
   same(peer: any): boolean {
     if (this === peer) {
       return true
@@ -118,11 +74,6 @@ abstract class BagVal extends FeatureVal {
       this.mark.hide !== peer.mark.hide) {
       return false
     }
-    // The SPREAD is part of the shape (BUGS.md §52 regime 4): `[]`
-    // and `[&: T]` share an empty key set, and calling them the same
-    // value collapsed the disjunction to its first arm before any
-    // data could pick -- the vacuous-schema hole. Two spreads are the
-    // same when their canons are.
     const scj: any = (this as any).spread?.cj
     const pcj: any = peer.spread?.cj
     if ((null == scj) !== (null == pcj) ||
@@ -158,12 +109,6 @@ abstract class BagVal extends FeatureVal {
       return undefined
     }
 
-    // Maps emit their keys in CODE POINT order so the generated output
-    // is independent of insertion/unification order and matches the Go
-    // port. Lists keep their numeric index order.
-    //
-    // The keys are String()-coerced because a list entry carries a
-    // numeric index here; the coercion is a no-op for every map key.
     let entries = items(this.peg)
     if (this.isMap) {
       entries = entries
@@ -214,22 +159,7 @@ abstract class BagVal extends FeatureVal {
         put(cval)
       }
 
-      // A CONJUNCT IS GENERABLE WHEN IT IS A SETTLED SIZING RESIDUE
-      // (the review's finding C, use-cases/BUGS.md §16). `length` and
-      // `unique` over a container keep the readings more members could
-      // still change, so `a: length(3) a:[1,2,3]` is a conjunct of the
-      // atom and the list right up to generation -- which is where the
-      // atom decides, in ConjunctVal.gen. Any OTHER conjunct is
-      // unresolved and falls through to the residue error below,
-      // exactly as before.
       else if (bagGenable(child)) {
-        // An optional child is generated in an isolated collect context so an
-        // unresolved inner value (a bare type that survived unification, e.g.
-        // an absent optional sub-map's `field: string`) is dropped rather than
-        // raised: the optional subtree is simply omitted. Without isolation
-        // such inner errors pollute the shared ctx.err and make generate()
-        // throw even though the key is skipped below. Mirrors the
-        // optional-disjunct path above.
         const cctx = optional ? ctx.clone({ err: [], collect: true }) : ctx
 
         let cval = child.gen(cctx)
@@ -273,7 +203,6 @@ abstract class BagVal extends FeatureVal {
         break
       }
 
-      // else optional so we can ignore it
     }
 
     return out
@@ -304,13 +233,6 @@ export function sizingResidue(v: any): { con: any, bag: any } | undefined {
     { con, bag } : undefined
 }
 
-// bagGenable is the bag's generability whitelist. A graph atom
-// (RELATIONS P2) is exactly as generable as the value it carries: the
-// atom is transparent at generation, so wrapping a field's value in
-// acyclic() must not change whether the bag accepts it -- an unmet
-// rel() refuses required generation with or without the atom, and a
-// BARE atom generates nothing and is dropped, exactly as an unmet
-// rel() under an optional key is.
 export function bagGenable(child: any): boolean {
   if (true === child.isGraphAtom) {
     return undefined === child.held || bagGenable(child.held)
@@ -322,6 +244,7 @@ export function bagGenable(child: any): boolean {
     return true
   }
   return true === child.isScalar
+    || true === child.isAbsent
     || true === child.isMap
     || true === child.isList
     || true === child.isPref

package/src/val/BigDecimalVal.ts

@@ -22,15 +22,6 @@ import {
 } from '../utility'
 
 
-// The exact base-10 decimal leaf of the number tower, reached only by a
-// `0d` literal carrying a `.` or an exponent (`0d1.5`, `0d1e3`) or by
-// direct construction.
-//
-// Its peg is a Decimal -- an OBJECT, so unlike every other scalar leaf
-// its identity cannot be `===` on the peg. Two bigdecimals are the same
-// value when their NUMBERS are equal (D2), which normalisation at
-// construction reduces to a two-field comparison; `samePeg` and `unify`
-// below are the two places that must not forget it.
 class BigDecimalVal extends ScalarVal {
   isBigDecimal = true
 
@@ -40,10 +31,6 @@ class BigDecimalVal extends ScalarVal {
     spec: ValSpec,
     ctx?: AontuContext
   ) {
-    // Exact-input construction (D8): a Decimal, or a decimal literal as
-    // text (`'1.5'`, `'0d1e3'`). A JS `number` is deliberately NOT
-    // accepted -- binary64 has already rounded it, so `0.1` could never
-    // arrive exact.
     let peg = spec.peg
     if ('string' === typeof peg) {
       try {
@@ -78,9 +65,6 @@ class BigDecimalVal extends ScalarVal {
         peer.kind === this.kind &&
         this.peg.equals(peer.peg)
       ) {
-        // Same kind and equal NUMBER. Never `peer.peg === this.peg`:
-        // that is object identity, and `0d0.10 & 0d0.1` (two Decimals
-        // holding one value) has to succeed.
         out = this
       }
       else if (peer.isTop) {

package/src/val/BigIntegerVal.ts

@@ -21,18 +21,6 @@ import {
 } from '../utility'
 
 
-// The unbounded exact integer leaf of the number tower, reached only by
-// a `0d` literal with no fraction and no exponent (`0d5`, `-0d5`,
-// `0d123456789012345678901234567890`) or by direct construction.
-//
-// Its peg is a native bigint: exact at any magnitude, immutable, and
-// compared by VALUE with `===` (D2 -- two separately built bigints
-// holding the same number are `===`, which is exactly the property the
-// Go port has to reproduce by hand for `*big.Int`).
-//
-// `biginteger` is DISJOINT from `integer`: `5 & 0d5` is an error, since
-// a successful meet would have to pick one of the two kinds and either
-// choice makes `&` asymmetric in kind.
 class BigIntegerVal extends ScalarVal {
   isBigInteger = true
 
@@ -42,10 +30,6 @@ class BigIntegerVal extends ScalarVal {
     spec: ValSpec,
     ctx?: AontuContext
   ) {
-    // Exact-input construction (D8): a bigint, or the digits as text. A
-    // JS `number` is deliberately NOT accepted -- it has already been
-    // rounded before this library could inspect it, so an exact value
-    // above 2^53 could never arrive that way intact.
     let peg = spec.peg
     if ('string' === typeof peg) {
       if (!/^[-+]?[0-9]+$/.test(peg)) {

package/src/val/CloseFuncVal.ts

@@ -46,16 +46,7 @@ class CloseFuncVal extends FuncBaseVal {
     }
 
     if (argval.isMap || argval.isList) {
-      // The in-place write is safe BECAUSE of the per-destination
-      // instantiation rule (ADR-005): everywhere a close() call is
-      // multiplied — a pack/each template, a spread constraint — the
-      // clone now owns its argument (`dup`), so `closed` lands on that
-      // instance alone. Cloning the bag here instead was tried and
-      // rejected: the re-path it implies corrupts the source
-      // attribution of children inside nested spread templates (the
-      // 06-k8s use case's env findings named the wrong path).
       (argval as BagVal).closed = true
-      // console.log('CLOSED', argval.canon)
     }
 
     return argval

package/src/val/CmpFuncVal.ts

@@ -1,97 +1,5 @@
 /* Copyright (c) 2026 Richard Rodger, MIT License */
 
-// THE COMPONENT PRIMITIVES -- SPIKE (docs/design/JOSTRACA.0.md).
-//
-// `Folder`, `File` and `Content` are the first three of jostraca's
-// component set, spelled as aontu functions and keeping jostraca's
-// own capitalisation. They are the authoring surface an aontu
-// document uses to say what FILES it produces:
-//
-//   out: folder("src", [
-//     file("main.ts", [
-//       content("export const x = 1")
-//     ])
-//   ])
-//
-// WHAT THIS REPLACES. `aontu:code` (ts/src/std.ts, test/spec/
-// aontu-code.tsv) is a hand-written vocabulary an author fills in as
-// DATA -- `aontu: Code: units: [{path, lang, decls}]` -- and `aontu
-// render` folds that instance into bytes. The instance is checked by
-// unification against the vocabulary, which is the good half; the bad
-// half is that an author writes a schema instance rather than a
-// generator, the vocabulary owns every construct the renderer will
-// ever emit, and nothing in it corresponds to a component someone can
-// already write in jostraca. These primitives take the other road:
-// the CALL is the construct, the call's own resolve is where the
-// shape is refused, and the value it lands is a jostraca component
-// tree that jostraca's build phase already knows how to walk.
-//
-// THE VALUE IS AN ORDINARY MAP, which is the whole reason this can be
-// a spike at all. A component call resolves to
-//
-//   {cmp: "Folder", props: {name: "src"}, children: [...]}
-//
-// so nothing downstream needs new machinery: `generate()` emits the
-// tree as JSON, `canon` renders the calls back, references and
-// spreads reach into a tree as they reach into any map, and `each()`
-// over model data drops straight into a `children` list -- which is
-// the point, and is why the second argument must BE a list rather
-// than accepting a bare node as a convenience. `each($.fields,
-// content(...))` is already the list; a one-child special case would
-// make `file(n, each(...))` and `file(n, [each(...)])` both legal and
-// different.
-//
-// CHILDREN FLATTEN, for the same reason. A generator's output lands
-// in the MIDDLE of a written list --
-//
-//   file("planet.ts", [
-//     content("export interface Planet {"),
-//     each($.fields, content("  " + _ + ": string")),
-//     content("}")
-//   ])
-//
-// -- and that list therefore holds two nodes and a LIST OF NODES. A
-// list is not a node and could only be an error otherwise, so
-// splicing is the total rule and nesting is not: children are
-// flattened to any depth before the containment grammar is checked.
-// This is the finding the spike's worked example produced; every
-// component system that takes children arrives at it.
-//
-// THE NODE MAP IS CLOSED and its `props` map is not. The three keys
-// are the vocabulary and a fourth is a mistake, so a typo in
-// `folder(...) & {childrn: []}` is refused where every other mistake
-// in an aontu document is refused. Props are the COMPONENT's business
-// -- jostraca's File already reads `mode` and `exclude`, and a
-// component the spike does not implement will read its own -- so they
-// pass through, and only the one prop each primitive cannot work
-// without is checked here.
-//
-// THE CONTAINMENT GRAMMAR IS CHECKED AT THE CALL. A Folder holds
-// folders and files, a File holds content, and Content holds nothing.
-// Unification cannot state that on its own -- a node is a map, and
-// every node map unifies with every other -- so the constructor
-// states it, at the site the author wrote, which is the argument for
-// making these functions rather than another vocabulary.
-//
-// NOT STAGED, deliberately. A component call answers from its
-// arguments alone: it has no dependence on WHERE it sits (unlike
-// `key()`) and it reads no bag that a sibling may still merge into
-// (unlike `pack`/`each`). A children list BUILT by one of
-// those combinators still waits, because the combinator residuates
-// and the enclosing call is not `pegdone` until it fires -- so the
-// ordinary args-done gate is the correct one and the staging rule
-// costs nothing here.
-//
-// SPIKE SCOPE. TypeScript only; no Go port yet, and so:
-// deliberately absent from `test/spec/signature.tsv`, from
-// `BUILTIN_FUNCS` (ts/src/lsp.ts) and from the `grammar/` files, all
-// three of which are pinned in cross-port parity and would go red on
-// a TS-only change. Argument arity and shape are therefore refused
-// HERE rather than by the parse-time arity table or the signature
-// gate, both of which read the declaration this spike does not have.
-// Failures are `invalid-arg` for the same reason -- a new code needs
-// a row in test/spec/errcodes.tsv and an entry in BOTH ports' code
-// tables (AGENTS.md, "The shared test suite").
 
 import type {
   Val,
@@ -110,110 +18,88 @@ import { StringVal } from './StringVal'
 import { FuncBaseVal } from './FuncBaseVal'
 
 
-// The component names this spike serves, each with the children it
-// admits and the one prop it cannot work without. Adding a fourth
-// primitive is an entry here plus the two-line subclass below.
 type CmpDef = {
-  // The jostraca component this call builds. CAPITALISED, because it
-  // names a component in the other project's exported set and the
-  // bridge looks it up by that name -- while the aontu FUNCTION is
-  // lower case, like every other builtin in this language. The two
-  // spellings say what they are: `file(...)` is aontu, `"File"` is
-  // jostraca's.
   cmp: string
   // The children this component admits, by aontu function name. Empty
   // means a leaf: any child at all is a mistake.
   children: string[]
-  // The prop a bare string argument fills. ABSENT means the component
-  // has no one-string spelling and its spec must be a map: `listitems`
-  // is driven by a LIST, and there is no sensible string to promote.
   text?: string
   // Whether that prop is required. `project`'s folder is the one that
-  // is not: jostraca defaults it to `.`, and the data path must not be
-  // stricter than the component it drives.
+  // is not: Jostraca defaults it to `.`.
   req: boolean
+  // Whether that prop is a SPAN of target text rather than a name. A
+  // blank line is a span; a folder called "" is a mistake.
+  span?: boolean
   // A prop that must be present and must be a list.
   bag?: string
+  // Hand-kept: no jostraca dependency to derive it from.
+  props: string[]
 }
 
-// EIGHT OF JOSTRACA'S TEN COMPONENTS. `Copy` and `List` are missing and
-// cannot be added under these rules: `copy` and `list` are already
-// aontu builtins with settled, unrelated meanings -- `copy(v)` copies a
-// VALUE and `list()` is the list container kind, both declared in
-// test/spec/signature.tsv and implemented in both ports. Lower-casing
-// jostraca's names onto them would either shadow landed language
-// surface or make one name mean two things by arity, and neither is a
-// trade a spike gets to make. See docs/design/JOSTRACA.0.md.
+
+const SPAN_PROPS =
+  ['arg', 'src', 'name', 'indent', 'extra', 'replace', 'raw']
+
 const CMP_DEF: Record<string, CmpDef> = {
   // The output root. Its `folder` is refused an absolute path or a
-  // `..` segment on the jostraca side, where the tree is data.
+  // `..` segment on the Jostraca side, where the tree is data.
   project: {
     cmp: 'Project', text: 'folder', req: false,
     children: ['project', 'folder', 'file', 'copyfiles'],
+    props: ['name', 'folder'],
   },
   folder: {
     cmp: 'Folder', text: 'name', req: true,
     children: ['folder', 'file', 'copyfiles'],
+    props: ['name'],
   },
   file: {
     cmp: 'File', text: 'name', req: true,
     children: ['content', 'line', 'fragment', 'inject', 'listitems', 'copyfiles'],
+    props: ['name', 'exclude', 'mode'],
   },
-  // A span of text, exactly as written. `FileOp` joins a file's spans
-  // with the empty string, so a `content` carries its own terminator.
   content: {
-    cmp: 'Content', text: 'src', req: true,
+    cmp: 'Content', text: 'src', req: true, span: true,
     children: [],
+    props: SPAN_PROPS,
   },
   // A span with a newline added, which is the whole difference.
   line: {
-    cmp: 'Line', text: 'src', req: true,
+    cmp: 'Line', text: 'src', req: true, span: true,
     children: [],
+    props: SPAN_PROPS,
   },
   // A file read from disk with its `<[SLOT]>` markers filled.
   fragment: {
     cmp: 'Fragment', text: 'from', req: true,
     children: ['slot', 'content', 'line', 'listitems'],
+    props: ['from', 'indent', 'replace', 'eject'],
   },
   slot: {
     cmp: 'Slot', text: 'name', req: true,
     children: ['content', 'line', 'fragment', 'listitems'],
+    props: ['name'],
   },
   // A body written between markers in a file that already exists.
   inject: {
     cmp: 'Inject', text: 'name', req: true,
     children: ['content', 'line', 'listitems'],
+    props: ['name', 'markers', 'exclude'],
   },
   // `Copy` under a name aontu has free: `copy` is taken by the builtin
   // that copies a VALUE, and a file copy is a different verb.
   copyfiles: {
     cmp: 'CopyFiles', text: 'from', req: true,
     children: [],
+    props: ['from', 'to', 'replace', 'exclude'],
   },
-  // `List` under a name that says what it does: it renders its children
-  // ONCE PER ELEMENT of `item`, binding jostraca's `{item}` and
-  // `{item.path}` macros, and adds a trailing blank line unless
-  // `line: false`.
-  //
-  // IT IS THE ONE COMPONENT THE AONTU SIDE ALREADY SUBSUMES, and a
-  // generator should reach for `each()` first. `each($.rows, content(...))`
-  // repeats in the MODEL, so the repetition is finished before the tree
-  // exists and every produced node is data a document can reference,
-  // vet and diff. `listitems` defers it into jostraca's define phase behind
-  // a string macro aontu cannot see into -- which is the layer this
-  // spike exists to remove. It is here so the component set is
-  // complete, not because it is the better spelling.
   listitems: {
     cmp: 'ListItems', req: true, bag: 'item',
     children: ['content', 'line', 'fragment'],
+    props: ['item', 'line', 'indent'],
   },
 }
 
-// The component name a value carries, when the value is a node this
-// vocabulary built. Read structurally rather than by class, because a
-// node reaches a children list as a MAP -- through a reference, a
-// `each()` instance, a spread -- long after the call that made it has
-// resolved away.
 const BY_CMP: Record<string, string> = {}
 for (const fname of Object.keys(CMP_DEF)) {
   BY_CMP[CMP_DEF[fname].cmp] = fname
@@ -232,7 +118,29 @@ function nodeCmp(v: any): string | undefined {
 }
 
 
-// A prop's text, when the prop is a concrete string.
+function cmpNode(cmp: string, props: Val, children: Val,
+  ctx: AontuContext): MapVal {
+  const node = new MapVal({ peg: { cmp: new StringVal({ peg: cmp }, ctx), props, children } }, ctx)
+  node.closed = true
+  return node
+}
+
+
+// A bare string child is a LINE: `Content` writes no newline, and the
+// emit mark rides across or `aontu trace` loses the line's rule.
+function lineNode(from: any, src: string, ctx: AontuContext): MapVal {
+  const node = cmpNode(
+    CMP_DEF.line.cmp,
+    new MapVal({ peg: { src: new StringVal({ peg: src }, ctx) } }, ctx),
+    new ListVal({ peg: [] }, ctx),
+    ctx)
+  if (null != from?.emitted) {
+    ; (node as any).emitted = from.emitted
+  }
+  return node
+}
+
+
 function propText(props: any, key: string): string | undefined {
   const v: any = props?.peg?.[key]
   return (true === v?.isScalar && 'string' === typeof v.peg) ? v.peg : undefined
@@ -242,9 +150,7 @@ function propText(props: any, key: string): string | undefined {
 class CmpFuncVal extends FuncBaseVal {
   isCmpFunc = true
 
-  // The component this call builds: the function's own name, which is
-  // also the `cmp` key of the node and the jostraca component the
-  // bridge looks up.
+  // The function's own name, which is also the node's `cmp` key.
   cmp: string
 
   constructor(
@@ -264,24 +170,8 @@ class CmpFuncVal extends FuncBaseVal {
 
   resolve(ctx: AontuContext, args: Val[]): Val {
     const def: CmpDef = CMP_DEF[this.cmp]
-    const leaf = 0 === def.children.length
-
-    // ARITY, refused here (see the spike-scope note above): a leaf
-    // takes its spec alone, a container takes a spec and an optional
-    // children list.
-    // A component whose text prop is OPTIONAL may be called with
-    // nothing at all: `project()` is the defaulted root, as
-    // `project({})` is on the other side. Everything else needs its
-    // spec.
-    if (args.length < (def.req ? 1 : 0) || args.length > (leaf ? 1 : 2)) {
-      return makeNilErr(ctx, 'invalid-arg', this, undefined, 'arity')
-    }
 
-    // THE SPEC IS A STRING OR A PROPS MAP. The string spelling fills
-    // the one prop the component cannot work without, so the common
-    // case reads as the component does -- `file("main.ts", ...)` --
-    // and the map spelling is there the moment a second prop is
-    // wanted: `file({name: "run.sh", mode: 0o755}, ...)`.
+    // Arity is checked at parse (funcArity); args[0] can be undefined.
     const spec: any = args[0]
     let props: Val
     if (undefined === spec) {
@@ -300,15 +190,21 @@ class CmpFuncVal extends FuncBaseVal {
       return makeNilErr(ctx, 'invalid-arg', this, spec, 'spec')
     }
 
-    // The one prop that is not the component's own business: without
-    // it there is no file to write and no content to write into one.
+    // An unknown prop is a silently dropped `indent` or `mode`.
+    for (const key of Object.keys((props as any).peg)) {
+      if (!def.props.includes(key)) {
+        return makeNilErr(ctx, 'invalid-arg', this, props, key)
+      }
+    }
+
     if (undefined !== def.text) {
       const text = propText(props, def.text)
-      if (def.req && (undefined === text || '' === text)) {
+      if (def.req &&
+        (undefined === text || ('' === text && true !== def.span))) {
         return makeNilErr(ctx, 'invalid-arg', this, props, def.text)
       }
       if (!def.req && undefined !== (props as any).peg?.[def.text] &&
-        undefined === text) {
+        (undefined === text || ('' === text && true !== def.span))) {
         return makeNilErr(ctx, 'invalid-arg', this, props, def.text)
       }
     }
@@ -323,10 +219,6 @@ class CmpFuncVal extends FuncBaseVal {
       }
     }
 
-    // THE CHILDREN, flattened, then the containment grammar. Absent
-    // is empty -- an empty folder and a file with no content are both
-    // things a model may legitimately say -- and every node that
-    // survives the flattening must be one this component admits.
     const kids: any = args[1]
     let children: Val
     if (undefined === kids) {
@@ -343,6 +235,15 @@ class CmpFuncVal extends FuncBaseVal {
             }
             continue
           }
+          const text = (true === (kid as any)?.isScalar &&
+            'string' === typeof (kid as any).peg) ? (kid as any).peg : undefined
+          if (undefined !== text) {
+            if (!def.children.includes('line')) {
+              return kid
+            }
+            flat.push(lineNode(kid, text, ctx))
+            continue
+          }
           const kcmp = nodeCmp(kid)
           if (undefined === kcmp || !def.children.includes(kcmp)) {
             return kid
@@ -361,29 +262,12 @@ class CmpFuncVal extends FuncBaseVal {
       return makeNilErr(ctx, 'invalid-arg', this, kids, 'children')
     }
 
-    const node = new MapVal({
-      peg: {
-        cmp: new StringVal({ peg: def.cmp }, ctx),
-        props,
-        children,
-      }
-    }, ctx)
-
-    // Closed: the three keys ARE the node vocabulary (see the note
-    // above). `props` is left open on purpose.
-    node.closed = true
-
-    return this.place(node)
+    return this.place(cmpNode(def.cmp, props, children, ctx))
   }
 
 } /* node:coverage ignore next 3 */
 
 
-// ONE CLASS PER COMPONENT, generated from the table, because the
-// registry constructs by `new funcval({peg: args})` and so needs a
-// constructor per name. Written as a factory rather than eight
-// near-identical subclasses: the table is the single statement of what
-// exists, and a ninth component is a row in it and nothing else.
 function cmpFuncClass(fname: string): any {
   class Cmp extends CmpFuncVal {
     constructor(spec: ValSpec, ctx?: AontuContext) {