aontu 0.63.0 → 0.64.0

package/src/mcp.ts

@@ -25,7 +25,6 @@ import { jsonSchema } from './jsonschema'
 import { relationCheck } from './relation'
 import { reachCheck } from './reach'
 import { view } from './view'
-import { render } from './render'
 import { patch } from './patch'
 
 
@@ -600,44 +599,6 @@ const TOOLS: ToolDef[] = [
         at: null == a.at ? undefined : str(a.at), path: paths.source,
       }),
   },
-  {
-    name: 'render',
-    description:
-      'Render a document that evaluates to an aontu:code instance: ' +
-      'evaluate it, vet the value at `at` against the bundled ' +
-      'vocabulary, and fold code.units into bytes. Returns verdict ' +
-      '(ok | lossy | error), the units -- each a path, a language and ' +
-      'its text -- and a `lossy` list of what the renderer could not ' +
-      'check (a fragment says nothing about the target\'s syntax; a ' +
-      'text escape or a raw block is verbatim). The tool never writes: ' +
-      'the caller receives the units as text and places them itself.',
-    properties: {
-      source: { type: 'string', description: 'The document' },
-      at: {
-        type: 'string',
-        description: 'Render the value at this path of the document ($.a.b)',
-      },
-      unit: {
-        type: 'string',
-        description: 'Render only the unit with this path',
-      },
-      strict: {
-        type: 'boolean',
-        description: 'Refuse the opaque escapes (a text declaration, a raw block)',
-      },
-    },
-    required: ['source'],
-    docs: ['source'],
-    refuse: (_a, finding) =>
-      ({ verdict: 'error', units: [], lossy: [], errors: [finding] }),
-    run: (a, _trust, paths) =>
-      render(str(a.source), {
-        at: null == a.at ? undefined : str(a.at),
-        unit: null == a.unit ? undefined : str(a.unit),
-        strict: true === a.strict,
-        path: paths.source,
-      }),
-  },
 ]
 
 

package/src/mod-tool.ts

@@ -502,7 +502,24 @@ export function modManifest(
   }
 
   const newSrc = readFileSync(main, 'utf8')
-  const canon = options.eval(newSrc, main).hash
+  const got = options.eval(newSrc, main)
+
+  // Nothing to pin: `tidy` refuses the same way.
+  if (!got.ok) {
+    return {
+      verdict: 'error',
+      mod,
+      version: self.version,
+      canon: '',
+      config: MODULE_CONFIG_MEDIA_TYPE,
+      files: [],
+      annotations: {},
+      missing: [self.main],
+      findings: [],
+    }
+  }
+
+  const canon = got.hash
 
   const report: ModManifestReport = {
     verdict: 'ok',

package/src/profile.ts

@@ -0,0 +1,42 @@
+/* Copyright (c) 2026 Richard Rodger, MIT License */
+
+
+import { Aontu } from './aontu'
+import { vet, failureFinding } from './vet'
+import { hcanon } from './hcanon'
+import { includeOpts } from './utility'
+
+import type { IncludeOptions } from './utility'
+import type { VetFinding } from './vet'
+
+
+export type ProfileOptions = IncludeOptions & {
+  // Where the document CAME FROM, so a relative `@"file"` load inside
+  // it resolves from its own directory.
+  path?: string
+}
+
+
+const PROFILE_VOCABULARY = '@"aontu:profile"'
+
+
+// A language declared as data, vetted, or the findings that refuse it.
+export function loadProfile(src: string, options?: ProfileOptions):
+  { profile?: any, errors?: VetFinding[] } {
+  const opts = options ?? {}
+  const aontu = new Aontu(includeOpts(opts))
+  const actx = aontu.ctx({ collect: true })
+  const root: any = aontu.unify(src, { path: opts.path, collect: true }, actx)
+  if (0 < actx.err.length || true === root?.isNil) {
+    return { errors: [failureFinding(actx, opts.path, root)] }
+  }
+  const report = vet(PROFILE_VOCABULARY, hcanon(root))
+  if ('valid' !== report.verdict) {
+    return { errors: report.findings }
+  }
+  // The meet: the vocabulary requires `lang`, so a value the vet
+  // admitted has a `Lang`.
+  const instance = new Aontu().generate(
+    PROFILE_VOCABULARY + '\naontu: Lang: ' + hcanon(root.peg.aontu.peg.Lang))
+  return { profile: instance.aontu.Lang }
+}

package/src/trace.ts

@@ -0,0 +1,157 @@
+/* Copyright (c) 2026 Richard Rodger, MIT License */
+
+
+import type { Val } from './type'
+
+import { Aontu } from './aontu'
+import { cmpCodePoint } from './keyorder'
+import { includeOpts } from './utility'
+import { anchorAt, failureFinding } from './vet'
+import { makeNilErr } from './err'
+
+import type { IncludeOptions } from './utility'
+import type { VetFinding } from './vet'
+
+
+export type TraceOptions = IncludeOptions & {
+  path?: string
+  at?: string
+}
+
+
+export type TraceReport = {
+  verdict: 'ok' | 'error'
+  trace: TraceEntry[]
+  errors?: VetFinding[]
+}
+
+
+// WHAT A TRACE ENTRY CARRIES. The file it reached, the rule set that
+// wrote it, and the model node the dispatch matched.
+export type TraceEntry = {
+  at: string
+  file: string
+  node: string
+  rule: string
+}
+
+
+function walkVals(root: any, fn: (v: any, path: string[]) => void): void {
+  const walk = (v: any, path: string[]): void => {
+    fn(v, path)
+    if (true === v.isList && null != v.peg) {
+      for (let i = 0; i < v.peg.length; i++) {
+        walk(v.peg[i], [...path, String(i)])
+      }
+    }
+    else if (true === v.isMap && null != v.peg) {
+      for (const k of Object.keys(v.peg).sort(cmpCodePoint)) {
+        if (!v.aliasKeys?.includes(k)) {
+          walk(v.peg[k], [...path, k])
+        }
+      }
+    }
+  }
+  walk(root, [])
+}
+
+
+function addr(path: string[]): string {
+  return '$' + path.map((seg) => '.' + seg).join('')
+}
+
+
+function scalar(v: any): string | undefined {
+  return (true === v?.isScalar && 'string' === typeof v.peg) ? v.peg : undefined
+}
+
+
+function fileName(v: any): string | undefined {
+  if (true !== v?.isMap) {
+    return undefined
+  }
+  return 'File' === scalar(v.peg?.cmp) ? scalar(v.peg?.props?.peg?.name) :
+    undefined
+}
+
+
+// THE INNERMOST FILE WINS: the longest matching prefix, not the first.
+function enclosing(files: { at: string, name: string }[],
+  path: string): string | undefined {
+  let best: string | undefined
+  let long = -1
+  for (const f of files) {
+    if ((path === f.at || path.startsWith(f.at + '.')) && f.at.length > long) {
+      best = f.name
+      long = f.at.length
+    }
+  }
+  return best
+}
+
+
+// Every piece a dispatch stamped, attributed to the file it reached.
+// One pass: `walkVals` is depth-first in document order, so a file is
+// always seen before the marks beneath it.
+function traceTree(root: Val): TraceEntry[] {
+  const files: { at: string, name: string }[] = []
+  const marks: { at: string, mark: any }[] = []
+  walkVals(root, (v: any, path: string[]) => {
+    const name = fileName(v)
+    if (undefined !== name) {
+      files.push({ at: addr(path), name })
+    }
+    if (null != v.emitted) {
+      marks.push({ at: addr(path), mark: v.emitted })
+    }
+  })
+
+  const out: TraceEntry[] = []
+  for (const m of marks) {
+    const file = enclosing(files, m.at)
+    if (undefined === file) {
+      continue
+    }
+    out.push({ at: m.at, file, node: m.mark.node, rule: m.mark.rule })
+  }
+  return out
+}
+
+
+// THE MARKS ARE OPT-IN. `emit` stamps a piece only when the context
+// carries a `reads` set, so the verb asks for one the way `render
+// --trace` did.
+function traceRun(src: string, options?: TraceOptions): TraceReport {
+  const opts = options ?? {}
+  const aontu = new Aontu(includeOpts(opts))
+  const actx = aontu.ctx({ collect: true, reads: new Set<string>() })
+  const root: any = aontu.unify(
+    src, { path: opts.path, collect: true }, actx)
+  if (0 < actx.err.length || true === root?.isNil) {
+    return {
+      verdict: 'error', trace: [],
+      errors: [failureFinding(actx, opts.path, root)],
+    }
+  }
+
+  let node: any = root
+  const at = opts.at ?? '$.out'
+  const found: any = anchorAt(root, at)
+  if (null == found) {
+    const nil: any = makeNilErr(actx, 'no_path', root, undefined, 'at')
+    actx.err.push(nil)
+    return {
+      verdict: 'error', trace: [],
+      errors: [failureFinding(actx, opts.path, root)],
+    }
+  }
+  node = found
+
+  return { verdict: 'ok', trace: traceTree(node) }
+} /* node:coverage ignore next 6 */
+
+
+export {
+  traceTree,
+  traceRun,
+}

package/src/unify.ts

@@ -67,6 +67,7 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
             && !a.isConjunct && !a.isDisjunct
             && !a.isRef && !a.isPref && !a.isFunc && !a.isExpect
             && !a.isTop && !b.isTop
+            && !a.isRefer
             && !a.isRel && !a.isGraphAtom && !a.isRecurse) {
           // The deprecation record survives the fast path too (G3):
           // `deprecate(5) & 5` short-circuits here.
@@ -242,12 +243,6 @@ function riders(a: any, b: any, to: any): void {
       to.origin = org
     }
   }
-  if (null == to.emitted) {
-    const emt = av.emitted ?? bv.emitted
-    if (null != emt) {
-      to.emitted = emt
-    }
-  }
 }
 
 

package/src/val/CmpFuncVal.ts

@@ -25,60 +25,78 @@ type CmpDef = {
   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.
+  // 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[]
 }
 
+
+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.
   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'],
   },
   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'],
   },
   listitems: {
     cmp: 'ListItems', req: true, bag: 'item',
     children: ['content', 'line', 'fragment'],
+    props: ['item', 'line', 'indent'],
   },
 }
 
@@ -100,6 +118,29 @@ function nodeCmp(v: any): string | undefined {
 }
 
 
+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
@@ -109,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(
@@ -151,13 +190,21 @@ class CmpFuncVal extends FuncBaseVal {
       return makeNilErr(ctx, 'invalid-arg', this, spec, 'spec')
     }
 
+    // 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)
       }
     }
@@ -188,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
@@ -206,17 +262,7 @@ 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)
-
-    node.closed = true
-
-    return this.place(node)
+    return this.place(cmpNode(def.cmp, props, children, ctx))
   }
 
 } /* node:coverage ignore next 3 */

package/src/val/NomFuncVal.ts

@@ -17,7 +17,7 @@ import {
   caseName,
   lowerASCII,
   capitalise,
-} from '../lower'
+} from '../casing'
 
 import { MapVal } from './MapVal'
 import { StringVal } from './StringVal'
@@ -36,10 +36,8 @@ const NOM_STYLES = [
   'upper',   // USER_ID
 ]
 
-// nom's style name -> the `%case` style `caseName` serves. `upper` and
-// `text` are nom's spellings: `screaming` is what `aontu:render` calls
-// SCREAMING_SNAKE and that name is pinned cross-port, so the mapping
-// lives here rather than in the shared vocabulary.
+// nom's style name -> the case style `caseName` serves. `upper` and
+// `text` are nom's spellings.
 const CASENAME_STYLES: Record<string, string> = {
   camel: 'camel',
   kebab: 'kebab',

package/src/val/ReferFuncVal.ts

@@ -181,6 +181,10 @@ class ReferVal extends FeatureVal {
       return makeNilErr(ctx, this.addrcode, this, peer, 'refer')
     }
 
+    if (true === p.isFunc) {
+      return peer.unify(this, ctx)
+    }
+
     return this.with(ctx, {
       held: null == this.held ? peer : unite(ctx, this.held, peer, 'refer-held'),
     }, this)

package/dist/lower.d.ts

@@ -1,23 +0,0 @@
-import type { RenderLoss } from './render';
-export type LowerCtx = {
-    profile: any;
-    family: string;
-    unit: string;
-    lossy: RenderLoss[];
-};
-export declare function splitWords(name: string): string[];
-export declare function lowerASCII(s: string): string;
-export declare function upperASCII(s: string): string;
-export declare function capitalise(word: string, acronyms: string[]): string;
-export declare function caseName(name: string, style: string, acronyms: string[]): string;
-export declare function ident(name: string, role: string, ctx: LowerCtx, path: string, bare: boolean): string;
-export declare function quote(s: string, profile: any): string;
-export declare function literal(v: any, ctx: LowerCtx): string;
-type Expr = {
-    text: string;
-    prec: number;
-};
-export declare function typeExpr(t: any, ctx: LowerCtx, path: string): Expr;
-export declare function lowerHeader(unit: any, source: any, ctx: LowerCtx): any[];
-export declare function lowerDecl(decl: any, path: string, ctx: LowerCtx): any[];
-export {};