aontu 0.61.0 → 0.63.0

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

@@ -0,0 +1,249 @@
+/* Copyright (c) 2026 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { makeNilErr } from '../err'
+
+import { MapVal } from './MapVal'
+import { ListVal } from './ListVal'
+import { StringVal } from './StringVal'
+import { FuncBaseVal } from './FuncBaseVal'
+
+
+type CmpDef = {
+  cmp: string
+  // The children this component admits, by aontu function name. Empty
+  // means a leaf: any child at all is a mistake.
+  children: string[]
+  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.
+  req: boolean
+  // A prop that must be present and must be a list.
+  bag?: string
+}
+
+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.
+  project: {
+    cmp: 'Project', text: 'folder', req: false,
+    children: ['project', 'folder', 'file', 'copyfiles'],
+  },
+  folder: {
+    cmp: 'Folder', text: 'name', req: true,
+    children: ['folder', 'file', 'copyfiles'],
+  },
+  file: {
+    cmp: 'File', text: 'name', req: true,
+    children: ['content', 'line', 'fragment', 'inject', 'listitems', 'copyfiles'],
+  },
+  content: {
+    cmp: 'Content', text: 'src', req: true,
+    children: [],
+  },
+  // A span with a newline added, which is the whole difference.
+  line: {
+    cmp: 'Line', text: 'src', req: true,
+    children: [],
+  },
+  // A file read from disk with its `<[SLOT]>` markers filled.
+  fragment: {
+    cmp: 'Fragment', text: 'from', req: true,
+    children: ['slot', 'content', 'line', 'listitems'],
+  },
+  slot: {
+    cmp: 'Slot', text: 'name', req: true,
+    children: ['content', 'line', 'fragment', 'listitems'],
+  },
+  // A body written between markers in a file that already exists.
+  inject: {
+    cmp: 'Inject', text: 'name', req: true,
+    children: ['content', 'line', 'listitems'],
+  },
+  // `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: [],
+  },
+  listitems: {
+    cmp: 'ListItems', req: true, bag: 'item',
+    children: ['content', 'line', 'fragment'],
+  },
+}
+
+const BY_CMP: Record<string, string> = {}
+for (const fname of Object.keys(CMP_DEF)) {
+  BY_CMP[CMP_DEF[fname].cmp] = fname
+}
+
+function nodeCmp(v: any): string | undefined {
+  if (true !== v?.isMap) {
+    return undefined
+  }
+  const cmp: any = v.peg?.cmp
+  const name = (true === cmp?.isScalar && 'string' === typeof cmp.peg) ?
+    cmp.peg : undefined
+  // The node carries the JOSTRACA name; the grammar is written in aontu
+  // names, so read it back through the one table.
+  return (undefined === name) ? undefined : BY_CMP[name]
+}
+
+
+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
+}
+
+
+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.
+  cmp: string
+
+  constructor(
+    cmp: string,
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+    this.cmp = cmp
+  }
+
+
+  funcname() {
+    return this.cmp
+  }
+
+
+  resolve(ctx: AontuContext, args: Val[]): Val {
+    const def: CmpDef = CMP_DEF[this.cmp]
+
+    // Arity is checked at parse (funcArity); args[0] can be undefined.
+    const spec: any = args[0]
+    let props: Val
+    if (undefined === spec) {
+      props = new MapVal({ peg: {} }, ctx)
+    }
+    else if (true === spec?.isScalar && 'string' === typeof spec.peg) {
+      if (undefined === def.text) {
+        return makeNilErr(ctx, 'invalid-arg', this, spec, 'spec')
+      }
+      props = new MapVal({ peg: { [def.text]: spec } }, ctx)
+    }
+    else if (true === spec?.isMap) {
+      props = spec
+    }
+    else {
+      return makeNilErr(ctx, 'invalid-arg', this, spec, 'spec')
+    }
+
+    if (undefined !== def.text) {
+      const text = propText(props, def.text)
+      if (def.req && (undefined === text || '' === text)) {
+        return makeNilErr(ctx, 'invalid-arg', this, props, def.text)
+      }
+      if (!def.req && undefined !== (props as any).peg?.[def.text] &&
+        undefined === text) {
+        return makeNilErr(ctx, 'invalid-arg', this, props, def.text)
+      }
+    }
+
+    // A bag prop is required and must be a list: `listitems` with no
+    // `item` renders nothing, silently, which is the failure a data
+    // path must not have.
+    if (undefined !== def.bag) {
+      const bag: any = (props as any).peg?.[def.bag]
+      if (true !== bag?.isList) {
+        return makeNilErr(ctx, 'invalid-arg', this, props, def.bag)
+      }
+    }
+
+    const kids: any = args[1]
+    let children: Val
+    if (undefined === kids) {
+      children = new ListVal({ peg: [] }, ctx)
+    }
+    else if (true === kids?.isList) {
+      const flat: Val[] = []
+      const splice = (list: Val[]): Val | undefined => {
+        for (const kid of list) {
+          if (true === (kid as any)?.isList) {
+            const bad = splice((kid as any).peg as Val[])
+            if (undefined !== bad) {
+              return bad
+            }
+            continue
+          }
+          const kcmp = nodeCmp(kid)
+          if (undefined === kcmp || !def.children.includes(kcmp)) {
+            return kid
+          }
+          flat.push(kid)
+        }
+        return undefined
+      }
+      const bad = splice(kids.peg as Val[])
+      if (undefined !== bad) {
+        return makeNilErr(ctx, 'invalid-arg', this, bad, 'children')
+      }
+      children = new ListVal({ peg: flat }, ctx)
+    }
+    else {
+      return makeNilErr(ctx, 'invalid-arg', this, kids, 'children')
+    }
+
+    const node = new MapVal({
+      peg: {
+        cmp: new StringVal({ peg: def.cmp }, ctx),
+        props,
+        children,
+      }
+    }, ctx)
+
+    node.closed = true
+
+    return this.place(node)
+  }
+
+} /* node:coverage ignore next 3 */
+
+
+function cmpFuncClass(fname: string): any {
+  class Cmp extends CmpFuncVal {
+    constructor(spec: ValSpec, ctx?: AontuContext) {
+      super(fname, spec, ctx)
+    }
+
+    make(_ctx: AontuContext, spec: ValSpec): Val {
+      return new Cmp(spec)
+    }
+  }
+  return Cmp
+}
+
+
+const CMP_FUNCS: Record<string, any> = {}
+for (const fname of Object.keys(CMP_DEF)) {
+  CMP_FUNCS[fname] = cmpFuncClass(fname)
+} /* node:coverage ignore next 7 */
+
+
+export {
+  CMP_DEF,
+  CMP_FUNCS,
+  CmpFuncVal,
+}

package/src/val/ConjunctVal.ts

@@ -1,7 +1,6 @@
 /* Copyright (c) 2021-2025 Richard Rodger, MIT License */
 
 
-
 import type {
   Val,
   ValSpec,
@@ -32,14 +31,11 @@ import {
 } from '../utility'
 
 
-
 import {
   top
 } from './top'
 
 
-
-// TODO: move main logic to op/conjunct
 class ConjunctVal extends JunctionVal {
   isConjunct = true
   isGenable = true
@@ -78,7 +74,6 @@ class ConjunctVal extends JunctionVal {
 
     this.peg = norm(this.peg)
 
-    // console.log('\nCONJUNCT', ctx.cc, this.id, this.canon, peer.id, peer.canon)
 
     // Unify each term of conjunct against peer
     let upeer: Val[] = []
@@ -87,7 +82,6 @@ class ConjunctVal extends JunctionVal {
     let newhide = this.mark.hide || peer.mark.hide
 
     for (let vI = 0; vI < this.peg.length; vI++) {
-      // console.log('CONJUNCT-peg', vI, this.peg[vI].canon, this.peg[vI].mark)
       newtype = this.peg[vI].mark.type || newtype
       newhide = this.peg[vI].mark.hide || newhide
     }
@@ -95,7 +89,6 @@ class ConjunctVal extends JunctionVal {
     for (let vI = 0; vI < this.peg.length; vI++) {
       this.peg[vI].mark.type = newtype
       this.peg[vI].mark.hide = newhide
-      // console.log('CONJUNCT-TERM', this.id, vI, this.peg[vI].canon)
 
       upeer[vI] = (this.peg[vI].done && peer.isTop) ? this.peg[vI] :
         unite(te ? ctx.clone({ explain: ec(te, 'OWN') }) : ctx, this.peg[vI], peer, 'cj-own')
@@ -103,17 +96,10 @@ class ConjunctVal extends JunctionVal {
       upeer[vI].mark.type = newtype = newtype || upeer[vI].mark.type
       upeer[vI].mark.hide = newhide = newhide || upeer[vI].mark.hide
 
-      // let prevdone = done
       done = done && (DONE === upeer[vI].dc)
 
       if (upeer[vI].isNil) {
         return upeer[vI]
-        // return Nil.make(
-        //   ctx,
-        //   '&peer[' + upeer[vI].canon + ',' + peer.canon + ']',
-        //   this.peg[vI],
-        //   peer
-        // )
       }
     }
 
@@ -155,7 +141,6 @@ class ConjunctVal extends JunctionVal {
 
       else {
         val = unite(te ? ctx.clone({ explain: ec(te, 'DEF') }) : ctx, t0, t1, 'cj-peer-t0t1')
-        // console.log('CONJUNCT-T', t0.canon, t1?.canon, '->', val.canon)
         done = done && DONE === val.dc
         newtype = this.mark.type || val.mark.type
         newhide = this.mark.hide || val.mark.hide
@@ -184,7 +169,6 @@ class ConjunctVal extends JunctionVal {
       out = top()
     }
 
-    // TODO: corrects CV[CV[1&/x]] issue above, but swaps term order!
     else if (1 === outvals.length) {
       out = outvals[0]
       out.mark.type = newtype
@@ -196,7 +180,6 @@ class ConjunctVal extends JunctionVal {
 
     out.dc = done ? DONE : this.dc + 1
 
-    // console.log('CONJUNCT-unify', this.id, sc, pc, '->', out.canon, 'D=' + out.dc, 'E=', this.err)
 
     explainClose(te, out)
 
@@ -216,19 +199,6 @@ class ConjunctVal extends JunctionVal {
 
 
   gen(ctx?: AontuContext) {
-    // A RESIDUATED SIZING ATOM DECIDES HERE (the review's finding C,
-    // use-cases/BUGS.md §16). `length`/`unique` over a container keep
-    // the readings that MORE MEMBERS COULD STILL CHANGE -- an upper
-    // bound satisfied, a lower bound violated, distinctness so far --
-    // rather than deciding against whatever the container held when it
-    // first settled (ConstraintVal.admitContainer). Generation is where
-    // no more members can arrive, so it is where the provisional
-    // reading becomes the verdict: the container generates if the atom
-    // is satisfied, and the atom's OWN refusal is raised if it is not.
-    //
-    // Without this the conjunct would report `conjunct` for a document
-    // whose only fault is a length -- the constraint's message is the
-    // one the author needs.
     const residue = sizingResidue(this)
     if (undefined !== residue) {
       const settled: any = residue.con.settleContainer(residue.bag, ctx)
@@ -243,13 +213,11 @@ class ConjunctVal extends JunctionVal {
       undefined
     )
 
-    // TODO: refactor to use Site
     nil.path = this.path
     nil.site.url = this.site.url
     nil.site.row = this.site.row
     nil.site.col = this.site.col
 
-    // descErr(nil, ctx)
 
     if (null == ctx) {
       throw new AontuError(nil.msg)
@@ -260,7 +228,6 @@ class ConjunctVal extends JunctionVal {
 }
 
 
-
 // Normalize Conjunct:
 // - flatten child conjuncts
 // - consistent sorting of terms