aontu 0.66.0 → 0.68.0

package/src/lang.ts

@@ -106,6 +106,8 @@ import { DisjunctVal } from './val/DisjunctVal'
 import { IntegerVal } from './val/IntegerVal'
 import { ListVal } from './val/ListVal'
 import { MapVal } from './val/MapVal'
+import { repathInstance } from './val/Val'
+import { AontuContext } from './ctx'
 import { NilVal } from './val/NilVal'
 import { NullVal } from './val/NullVal'
 import { NumberVal } from './val/NumberVal'
@@ -188,7 +190,8 @@ const CC_d = 100
 const CC_D = 68
 
 const CC_PCT = 37
-const ALIAS_RE = /^%[A-Za-z_][A-Za-z0-9_]*/
+// Hyphen separates segments; not leading or trailing, as `-` prefixes negation.
+const ALIAS_RE = /^%[A-Za-z_][A-Za-z0-9_]*(?:-[A-Za-z0-9_]+)*/
 
 const CC_EQ = 61
 const CC_SP = 32
@@ -940,6 +943,16 @@ help isolate the syntax error.`,
   jsonic.rule('val', (rs: RuleSpec) => {
 
     rs
+      // Before the core implicit-map alts: a value prefix, not a key.
+      .open([
+        {
+          s: [VL, CL],
+          c: (r: Rule) => 0 !== r.d && isAliasDecl(r.o0, r.o1),
+          p: 'val',
+          a: (r: Rule) => { r.u.aontu_alias_val = '' + r.o0.src },
+          g: 'aontu-alias-val',
+        },
+      ], { append: false })
       .open([
         {
           s: [CJ, CL], p: 'map', b: 2, n: { pk: 1 },
@@ -1017,6 +1030,12 @@ help isolate the syntax error.`,
 
         r.node = valnode
 
+        const aname = r.u.aontu_alias_val
+        if (null != aname && null != valnode) {
+          const hoist = ((ctx as any).aontu_alias_hoist ||= [])
+          hoist.push({ name: '' + aname, val: valnode })
+        }
+
         return undefined
       })
 
@@ -1093,6 +1112,19 @@ help isolate the syntax error.`,
           delete mo.___alias
         }
 
+        // A value-prefix declaration lands here, at the document root
+        // (ALIASES.0.md), as a copy pathed at its name.
+        if (1 === r.d) {
+          for (const { name, val } of ((ctx as any).aontu_alias_hoist ?? [])) {
+            const acx = new AontuContext({ path: [name] })
+            const copy: any = (val as any).clone(acx, { path: [name] })
+            repathInstance(copy, [name])
+            mo[name] = null == mo[name] ? copy :
+              addsite(new ConjunctVal({ peg: [mo[name], copy] }), r, ctx)
+            if (!aliasKeys.includes(name)) { aliasKeys.push(name) }
+          }
+        }
+
         //  Handle defered conjuncts, e.g. `{x:1 @"foo"}`
         if (mo.___merge) {
           let mop = { ...mo }
@@ -1360,6 +1392,13 @@ help isolate the syntax error.`,
             v.path = [...(rule.k?.path ?? []),
               '' + rule.node.length, key]
           }
+          // An element is a value position, so the prefix form applies.
+          if (null == kr && isAliasDecl(ktkn, rule.o1)) {
+            ; ((ctx as any).aontu_alias_hoist ||= []).push({ name: key, val: v })
+            rule.node.push(v)
+            return undefined
+          }
+
           const mv: any = addsite(
             new MapVal({ peg: { [key]: v } }), rule, ctx)
           // The element's path is the list's plus its index, as any
@@ -1370,12 +1409,6 @@ help isolate the syntax error.`,
           if (true === rule.u.aontu_optional_elem) {
             mv.optionalKeys = [key]
           }
-          // ... and a declaration is a declaration IN the element, which
-          // is where MapVal.unify refuses it: a list element is not the
-          // top level.
-          if (isAliasDecl(ktkn, rule.o1)) {
-            mv.aliasKeys = [key]
-          }
           rule.node.push(mv)
         }
 
@@ -1544,9 +1577,13 @@ function makeModelResolver(options: any) {
 
   const memCapability =
     'object' === typeof capability && null != (capability as any).mem
+  // An EMPTY root denies: resolving it yields the process directory.
+  const emptyRoot =
+    'object' === typeof capability && '' === (capability as any).root
   const rootDir: string | undefined =
     'object' === typeof capability &&
-      'string' === typeof (capability as any).root
+      'string' === typeof (capability as any).root &&
+      '' !== (capability as any).root
       ? pathResolve((capability as any).root) : undefined
 
   let memResolver = makeMemResolver(memCapability
@@ -1584,7 +1621,7 @@ function makeModelResolver(options: any) {
   const deny = (path: string): never => {
     // Only 'none' and 'root' can deny: the mem capability's misses are
     // not-found (its set is the whole world), so there is no third arm.
-    const capname = 'none' === capability ? 'none' : 'root:' + rootDir
+    const capname = null == rootDir ? 'none' : 'root:' + rootDir
     const err: any = new Error(
       'include denied: ' + path + ' (capability: ' + capname + ')')
     err.code = 'include_denied'
@@ -1679,7 +1716,7 @@ function makeModelResolver(options: any) {
       return { found: false, path: '' + (path ?? ''), search: [] }
     }
 
-    if ('none' === capability) {
+    if ('none' === capability || emptyRoot) {
       deny(path)
     }
 

package/src/mcp-server.ts

@@ -33,7 +33,7 @@ export function parseArgs(argv: string[]): ServerArgs {
     }
     if ('--root' === arg) {
       const dir = argv[++i]
-      if (null == dir) {
+      if (null == dir || '' === dir) {
         return { err: 'aontu-mcp: --root needs a directory' }
       }
       root = dir

package/src/mcp.ts

@@ -653,7 +653,7 @@ function hashOf(
   const v: any = aontu.unify(
     src, null == path ? undefined : { path }, ctx)
   if (0 < ctx.err.length || null == v || true === v.isNil) {
-    return { ok: false, hash: '', findings: [evalFailure(ctx)] }
+    return { ok: false, hash: '', findings: [evalFailure(ctx, v)] }
   }
   return {
     ok: true,

package/src/query.ts

@@ -5,7 +5,7 @@ import { includeOpts } from './utility'
 import { Aontu } from './aontu'
 import type { TrustOptions } from './type'
 import { exactJSON } from './exactjson'
-import { anchorAt } from './vet'
+import { anchorAt, engineFinding } from './vet'
 import type { VetFinding } from './vet'
 import { cmpCodePoint } from './keyorder'
 import { Provenance } from './provenance'
@@ -87,9 +87,6 @@ export function pathParts(path: string): string[] {
 }
 
 
-// The queried path, normalised the way anchorAt reads it — so a
-// finding names `$.a.b` whether the caller wrote that, `a.b` or
-// `$.a.b.` — and `$` for the root.
 function pathText(path: string): string {
   const parts = pathParts(path)
   return '$' + (0 < parts.length ? '.' + parts.join('.') : '')
@@ -170,9 +167,10 @@ function finding(
 }
 
 
-export function evalFailure(ctx: any): VetFinding {
-  const err: any = ctx.err[0]
-  return finding(err.why, '$', err.msg)
+// A document that does not stand up, reported at the root: a literal
+// nil adds nothing to `ctx.err`, so `failed` carries the only code.
+export function evalFailure(ctx: any, failed?: any): VetFinding {
+  return engineFinding(ctx.err[0] ?? failed, ctx, '$')
 }
 
 
@@ -216,7 +214,7 @@ export function get(
   const root: any = aontu.unify(src, parseOpts, ctx)
 
   if (0 < ctx.err.length || null == root || true === root.isNil) {
-    return { ok: false, out: '', findings: [evalFailure(ctx)] }
+    return { ok: false, out: '', findings: [evalFailure(ctx, root)] }
   }
 
   const node: any = anchorAt(root, path)
@@ -232,10 +230,7 @@ export function get(
       return {
         ok: false,
         out: '',
-        findings: [finding(
-          err?.why ?? 'no_gen',
-          pathText(path),
-          err?.msg ?? 'The value at this path is not concrete.')],
+        findings: [engineFinding(err, ctx, pathText(path))],
       }
     }
     return { ok: true, out: exactJSON(gen, 2), findings: [] }
@@ -274,7 +269,7 @@ export function why(
 
   const root: any = aontu.unify(parsed, parseOpts, ctx)
   if (0 < ctx.err.length || null == root || true === root.isNil) {
-    return { ok: false, findings: [evalFailure(ctx)] }
+    return { ok: false, findings: [evalFailure(ctx, root)] }
   }
 
   const node: any = anchorAt(root, path)

package/src/tsconfig.json

@@ -18,6 +18,7 @@
     "types": [
       "node"
     ],
-    "composite": true
+    "composite": true,
+    "tsBuildInfoFile": "../.tsbuild/src.tsbuildinfo"
   }
 }

package/src/val/RefVal.ts

@@ -316,16 +316,27 @@ class RefVal extends FeatureVal {
         refpath = this.path.slice(0, -1).concat(parts)
       }
 
-      let sep = '.'
-      refpath = refpath
-        .reduce(((a: string[], p: string) =>
-          (p === sep ? a.length = a.length - 1 : a.push(p), a)), [])
+      // A PARENT STEP OFF THE TOP names nothing, and underflows.
+      let offtop = false
+      const reduced: string[] = []
+      for (const part of refpath) {
+        if ('.' === part) {
+          if (0 === reduced.length) {
+            offtop = true
+            break
+          }
+          reduced.length = reduced.length - 1
+          continue
+        }
+        reduced.push(part)
+      }
+      refpath = reduced
 
       let node = ctx.root as Val
 
-      let nopath = false
+      let nopath = offtop
 
-      if (null != node) {
+      if (!offtop && null != node) {
         for (; pI < refpath.length; pI++) {
           let part = refpath[pI]
 
@@ -378,7 +389,7 @@ class RefVal extends FeatureVal {
       }
 
       const fixroot: any = (ctx as any)._fixroot
-      if (this.absolute && null != fixroot
+      if (this.absolute && !offtop && null != fixroot
         && (nopath || pI !== refpath.length)) {
         nopath = false
         pI = 0

package/src/vet.ts

@@ -10,6 +10,7 @@ import {
 } from 'node:path'
 
 import { descErr, getHint } from './err'
+import { codeClass } from './hints'
 import { ConjunctVal } from './val/ConjunctVal'
 import { walkVals, collectNils } from './walk'
 import { sizingResidue } from './val/BagVal'
@@ -204,6 +205,9 @@ function materialise(nil: any, ctx: any): void {
 }
 
 
+const UNSHAPED = 'unify_failed'
+
+
 // The terminal colour escapes the parser puts in its message text. A
 // RegExp built from a string, not a literal: the escape is a control
 // character, and spelling it `\u001b` keeps the source readable.
@@ -214,16 +218,10 @@ function stripAnsi(s: string): string {
 }
 
 
-function findingOf(nil: any, prov: Prov): VetFinding {
+// The registry's hint and a code's own `details` fields: the same set
+// on every finding reporting an ENGINE code.
+function fromRegistry(finding: VetFinding, nil: any): VetFinding {
   const details = nil.details ?? {}
-  const finding: VetFinding = {
-    code: nil.why,
-    class: nil.class,
-    severity: 'error',
-    path: pathText(nil.path),
-    message: stripAnsi(nil.msg.split('\n')[0]),
-    sites: sitesOf(nil, prov),
-  }
 
   const hint = getHint(nil.why, nil.details)
   if (null != hint && '' !== hint) {
@@ -244,6 +242,18 @@ function findingOf(nil: any, prov: Prov): VetFinding {
 }
 
 
+function findingOf(nil: any, prov: Prov): VetFinding {
+  return fromRegistry({
+    code: nil.why,
+    class: nil.class,
+    severity: 'error',
+    path: pathText(nil.path),
+    message: stripAnsi(nil.msg.split('\n')[0]),
+    sites: sitesOf(nil, prov),
+  }, nil)
+}
+
+
 const ORDER_PAD = 9
 
 
@@ -265,6 +275,34 @@ function orderKey(f: VetFinding, index: number): string {
 }
 
 
+// An ENGINE code at a path the caller names: class from the registry
+// through NilVal.class, message materialised first (a `gen` nil has none).
+export function engineFinding(
+  nil: any, ctx: any, path: string): VetFinding {
+  if (null == nil) {
+    return fromRegistry({
+      code: UNSHAPED,
+      class: codeClass(UNSHAPED),
+      severity: 'error',
+      path,
+      message: 'The document does not evaluate.',
+      sites: [],
+    }, { why: UNSHAPED })
+  }
+
+  materialise(nil, ctx)
+
+  return fromRegistry({
+    code: nil.why,
+    class: nil.class,
+    severity: 'error',
+    path,
+    message: stripAnsi(nil.msg.split('\n')[0]),
+    sites: [],
+  }, nil)
+}
+
+
 export function failureFinding(
   ctx: any, url?: string, failed?: any): VetFinding {
   const nil: any = ctx.err[0] ?? failed
@@ -385,14 +423,62 @@ function coverDataPaths(
 }
 
 
+// A spread or a key can carry a shape-preserving call or a reference,
+// and coverage wants the bag under it; the seen set settles a cycle.
+export function coverThrough(v: any, root: any): any {
+  let at = v
+  const seen = new Set<any>()
+  while (null != at && !seen.has(at)) {
+    if (true === at.isMap || true === at.isList) {
+      return at
+    }
+    seen.add(at)
+    if ((true === at.isCloseFunc || true === at.isTypeFunc) &&
+      Array.isArray(at.peg)) {
+      at = at.peg[0]
+      continue
+    }
+    // A relative reference reads from where it was WRITTEN, not where
+    // the template lands, so the engine's own resolution is the rule.
+    if (true === at.isRef) {
+      at = coverRefTarget(root, at.plainRefPath())
+      continue
+    }
+    if (true === at.isRecurse) {
+      at = coverRefTarget(root, at.target)
+      continue
+    }
+    return undefined
+  }
+  return undefined
+}
+
+
+// A reference descends a list by the segment AS WRITTEN: `$.Defs.0`.
+function coverRefTarget(root: any, segs: string[] | undefined): any {
+  if (null == segs) {
+    return undefined
+  }
+  let at = root
+  for (const seg of segs) {
+    at = true === at?.isMap || true === at?.isList ? at.peg?.[seg] : undefined
+  }
+  return at
+}
+
+
 // Walk one data path down the schema, naming the declaration that
 // constrains it -- the exact key where the schema has one, else the
 // covering template. Undefined when the schema declares nothing there.
 function coverMatch(
-  anchor: any, segs: string[]): string | undefined {
+  anchor: any, segs: string[], root: any): string | undefined {
   let at: any = anchor
   let decl = ''
   for (const seg of segs) {
+    at = coverThrough(at, root)
+    if (null == at) {
+      return undefined
+    }
     const named = true === at.isMap && null != at.peg ? at.peg[seg]
       : true === at.isList && Array.isArray(at.peg) ? at.peg[Number(seg)]
         : undefined
@@ -432,7 +518,8 @@ function coverShallowest(paths: string[]): string[] {
 // The accounting itself: what the schema declared, what the data holds,
 // and which of each the other met.
 export function vetCoverage(
-  anchor: any, dataVal: any, coverageAt?: string): VetCoverage {
+  anchor: any, dataVal: any, coverageAt: string | undefined,
+  root: any): VetCoverage {
   const declarations = new Map<string, any>()
   coverDeclare(anchor, [], declarations)
 
@@ -461,7 +548,7 @@ export function vetCoverage(
       continue
     }
     const segs = path.replace(/^\$\.?/, '').split('.').filter((x) => '' !== x)
-    const decl = coverMatch(anchor, segs)
+    const decl = coverMatch(anchor, segs, root)
     if (leaf) {
       leaves++
     }
@@ -579,7 +666,7 @@ export function vet(
     // the same paths minus whatever an include would have added.
     const measured = 0 === coverCtx.err.length && true !== settledData?.isNil
       ? settledData : dataVal
-    coverage = vetCoverage(anchor, measured, options.coverageAt)
+    coverage = vetCoverage(anchor, measured, options.coverageAt, schemaVal)
   }
 
   const lintFindings: VetFinding[] = []

package/src/view.ts

@@ -4,7 +4,7 @@
 import { basename, dirname, isAbsolute, relative, resolve } from 'node:path'
 
 import { Aontu } from './aontu'
-import { failureFinding, anchorAt, throughResidue } from './vet'
+import { failureFinding, engineFinding, anchorAt, throughResidue } from './vet'
 import type { VetFinding } from './vet'
 import type { TrustOptions } from './type'
 import { graphOf } from './graph'
@@ -2544,10 +2544,8 @@ function drawLoaded(
       const before = ctx.err.length
       value = root.gen(ctx)
       if (before < ctx.err.length) {
-        const err: any = ctx.err[before]
         return {
-          errors: [finding(err?.why ?? 'unify_failed', 'reference', '$',
-            err?.msg ?? 'The document does not generate.')],
+          errors: [engineFinding(ctx.err[before], ctx, '$')],
         }
       }
     }
@@ -2749,11 +2747,9 @@ export function viewSet(
   const before = ctx.err.length
   const value = root.gen(ctx)
   if (before < ctx.err.length) {
-    const err: any = ctx.err[before]
     return {
       verdict: 'error', views: [],
-      errors: [finding(err?.why ?? 'unify_failed', 'reference', '$',
-        err?.msg ?? 'The document does not generate.')],
+      errors: [engineFinding(ctx.err[before], ctx, '$')],
     }
   }
   const declared = genAt(value, at)