npm - aontu - Versions diffs - 0.68.0 → 0.69.0 - Mend

aontu 0.68.0 → 0.69.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (74) hide show

package/dist/alias.d.ts +12 -1
package/dist/alias.js +176 -6
package/dist/alias.js.map +1 -1
package/dist/aliasname.d.ts +19 -0
package/dist/aliasname.js +65 -0
package/dist/aliasname.js.map +1 -0
package/dist/aontu.d.ts +1 -1
package/dist/aontu.js +21 -8
package/dist/aontu.js.map +1 -1
package/dist/aontumodel.js +1 -1
package/dist/aontumodel.js.map +1 -1
package/dist/ctx.d.ts +1 -0
package/dist/ctx.js +1 -0
package/dist/ctx.js.map +1 -1
package/dist/err.js +18 -1
package/dist/err.js.map +1 -1
package/dist/format.js +14 -0
package/dist/format.js.map +1 -1
package/dist/hints.js +36 -7
package/dist/hints.js.map +1 -1
package/dist/lang.js +289 -35
package/dist/lang.js.map +1 -1
package/dist/lsp.d.ts +10 -4
package/dist/lsp.js +116 -7
package/dist/lsp.js.map +1 -1
package/dist/site.d.ts +9 -0
package/dist/site.js +2 -1
package/dist/site.js.map +1 -1
package/dist/subsume.js +6 -1
package/dist/subsume.js.map +1 -1
package/dist/val/BagVal.d.ts +1 -0
package/dist/val/BagVal.js +3 -0
package/dist/val/BagVal.js.map +1 -1
package/dist/val/EmitFuncVal.js +2 -1
package/dist/val/EmitFuncVal.js.map +1 -1
package/dist/val/FilterFuncVal.js +1 -1
package/dist/val/FilterFuncVal.js.map +1 -1
package/dist/val/FuncBaseVal.d.ts +2 -1
package/dist/val/FuncBaseVal.js +25 -1
package/dist/val/FuncBaseVal.js.map +1 -1
package/dist/val/MapVal.js +10 -4
package/dist/val/MapVal.js.map +1 -1
package/dist/val/MatchFuncVal.js +2 -1
package/dist/val/MatchFuncVal.js.map +1 -1
package/dist/val/NilVal.js +3 -0
package/dist/val/NilVal.js.map +1 -1
package/dist/val/RecurseVal.d.ts +1 -0
package/dist/val/RecurseVal.js +7 -3
package/dist/val/RecurseVal.js.map +1 -1
package/dist/val/RefVal.d.ts +1 -0
package/dist/val/RefVal.js +29 -12
package/dist/val/RefVal.js.map +1 -1
package/package.json +1 -1
package/src/alias.ts +214 -6
package/src/aliasname.ts +95 -0
package/src/aontu.ts +23 -9
package/src/aontumodel.ts +1 -1
package/src/ctx.ts +4 -1
package/src/err.ts +19 -1
package/src/format.ts +14 -0
package/src/hints.ts +40 -7
package/src/lang.ts +334 -30
package/src/lsp.ts +136 -6
package/src/site.ts +15 -1
package/src/subsume.ts +9 -2
package/src/val/BagVal.ts +4 -0
package/src/val/EmitFuncVal.ts +3 -2
package/src/val/FilterFuncVal.ts +2 -2
package/src/val/FuncBaseVal.ts +30 -1
package/src/val/MapVal.ts +10 -4
package/src/val/MatchFuncVal.ts +3 -2
package/src/val/NilVal.ts +3 -0
package/src/val/RecurseVal.ts +8 -3
package/src/val/RefVal.ts +31 -12

package/src/lang.ts CHANGED Viewed

@@ -190,12 +190,34 @@ const CC_d = 100
 const CC_D = 68
 const CC_PCT = 37
-// Hyphen separates segments; not leading or trailing, as `-` prefixes negation.
-const ALIAS_RE = /^%[A-Za-z_][A-Za-z0-9_]*(?:-[A-Za-z0-9_]+)*/
+import type { AliasBind } from './aliasname'
+import {
+  ALIAS_RE,
+  ALIAS_SET,
+  ALIAS_SHORTHAND_RE,
+  EXPORT_DECL_NAME,
+  RESERVED_KEY_PREFIX,
+  exportHoldKey,
+  aliasBareName,
+  aliasScopedKey,
+  aliasSetItems,
+} from './aliasname'
 const CC_EQ = 61
 const CC_SP = 32
 const CC_TAB = 9
+const CC_OB = 123
+const WS_RE = /\s/
+let SCOPE_SEQ = 0
+const MERGE_KEY = RESERVED_KEY_PREFIX + 'merge'
+const ALIAS_MARK_KEY = RESERVED_KEY_PREFIX + 'alias'
+const OPTIONAL_MARK_KEY = RESERVED_KEY_PREFIX + 'optional'
+// `{ %a } = @"f.aon"` is the pair `<head>: <include>`, so the head is
+// one token and the grammar needs nothing new.
+const IMPORT_HEAD_RE = new RegExp('^(' + ALIAS_SET + ')[ \\t]*=(?!=)')
+const EXPORT_RE = /^export[ \t]*\([ \t]*([^()\s][^()]*?)[ \t]*\)/
 const CC_9 = 57
 const CC_A = 65
@@ -329,6 +351,72 @@ let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
     },
   })
+  // THE FIXED MATCHER'S CHECK RUNS AT EVERY POSITION: `{` opens a fixed
+  // token the text check never sees.
+  jsonic.options({
+    fixed: {
+      check: (lex: any) => {
+        const pnt = lex.pnt
+        const ex = lex.aontu_export
+        // The `(` is the pair's separator, the argument its value.
+        if (null != ex && pnt.sI === ex.cl) {
+          const cltkn = lex.token('#CL', undefined, '(', pnt)
+          pnt.cI += ex.arg - pnt.sI
+          pnt.sI = ex.arg
+          return { done: true, token: cltkn }
+        }
+        if (null != ex && pnt.sI === ex.arg) {
+          delete lex.aontu_export
+          const atkn = lex.token('#TX', ex.src, ex.src, pnt)
+          pnt.cI += ex.end - pnt.sI
+          pnt.sI = ex.end
+          return { done: true, token: atkn }
+        }
+        // THE SHORTHAND IS READ OFF THE SOURCE: a name lexes as its pair.
+        const sh = lex.aontu_shorthand
+        if (null != sh && pnt.sI === sh.at) {
+          if (1 === sh.stage) {
+            sh.stage = 2
+            return { done: true, token: lex.token('#CL', undefined, ':', pnt) }
+          }
+          delete lex.aontu_shorthand
+          return {
+            done: true, token: lex.token(
+              '#VL',
+              (r: Rule, ctx: JsonicContext) =>
+                addsite(new RefVal(
+                  { peg: [aliasScopedKey(sh.name, srcUrl(ctx))], absolute: true }),
+                  r, ctx),
+              sh.name, pnt)
+          }
+        }
+        if (CC_OB === lex.src.charCodeAt(pnt.sI)) {
+          const sres = ALIAS_SHORTHAND_RE.exec(lex.refwd())
+          if (null != sres) {
+            lex.aontu_shorthand_end = pnt.sI + sres[0].length
+          }
+          const hres = IMPORT_HEAD_RE.exec(lex.refwd())
+          if (null != hres) {
+            const hsrc = hres[1]
+            lex.aontu_eq_at = pnt.sI + hres[0].length - 1
+            const htkn = lex.token('#TX', hsrc, hsrc, pnt, {
+              aontu_import: aliasSetItems(hsrc) as AliasBind[],
+            })
+            pnt.sI += hsrc.length
+            pnt.cI += hsrc.length
+            return { done: true, token: htkn }
+          }
+        }
+        return undefined
+      },
+    },
+  })
   jsonic.options({
     text: {
       check: (lex: any) => {
@@ -349,10 +437,29 @@ let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
             lex.aontu_eq_at = j
           }
+          // The name is the KEY; separator and reference follow it.
+          const shend = lex.aontu_shorthand_end
+          if (null != shend && pnt.sI < shend) {
+            let k = pnt.sI + asrc.length
+            while (k < src.length && WS_RE.test(src[k])) {
+              k++
+            }
+            const ktkn = lex.token('#TX', asrc.substring(1), asrc, pnt)
+            pnt.cI += k - pnt.sI
+            pnt.sI = k
+            lex.aontu_shorthand = { at: k, name: asrc, stage: 1 }
+            if (shend - 1 <= k) {
+              delete lex.aontu_shorthand_end
+            }
+            return { done: true, token: ktkn }
+          }
           const atkn = lex.token(
             '#VL',
             (r: Rule, ctx: JsonicContext) =>
-              addsite(new RefVal({ peg: [asrc], absolute: true }), r, ctx),
+              addsite(new RefVal(
+                { peg: [aliasScopedKey(asrc, srcUrl(ctx))], absolute: true }),
+                r, ctx),
             asrc,
             pnt)
           pnt.sI += asrc.length
@@ -360,6 +467,27 @@ let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
           return { done: true, token: atkn }
         }
+        // `export(...)`: the word is the key, spelled unwritably.
+        if (CC_e === src.charCodeAt(pnt.sI)) {
+          const eres = EXPORT_RE.exec(lex.refwd())
+          if (null != eres) {
+            const open = eres[0].indexOf('(')
+            const arg = eres[0].indexOf(eres[1], open)
+            lex.aontu_export = {
+              cl: pnt.sI + open,
+              arg: pnt.sI + arg,
+              end: pnt.sI + eres[0].length,
+              src: eres[1],
+            }
+            const etkn = lex.token(
+              '#TX', exportHoldKey(), EXPORT_DECL_NAME, pnt,
+              { aontu_export: true, aontu_export_items: aliasSetItems(eres[1]) })
+            pnt.sI += EXPORT_DECL_NAME.length
+            pnt.cI += EXPORT_DECL_NAME.length
+            return { done: true, token: etkn }
+          }
+        }
         if (CC_EQ === src.charCodeAt(pnt.sI) && lex.aontu_eq_at === pnt.sI) {
           delete lex.aontu_eq_at
           const eqtkn = lex.token('#CL', undefined, '=', pnt, { aontu_eq: true })
@@ -437,6 +565,28 @@ let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
     return v
   }
+  // `export` publishes a name; it renames none, and `{%}` is theirs.
+  const publishedNames = (items?: AliasBind[]): string[] | undefined =>
+    undefined === items || 0 === items.length ? undefined :
+      items.every((i) => i.local === i.remote) ?
+        items.map((i) => i.local) : undefined
+  // A ROOT MAY BE WRAPPED: a file's names are its MAP'S, not open()'s.
+  const declaringMap = (val: any): any => {
+    let cur = val
+    while (true === cur?.isFunc && 1 === cur.peg?.length) {
+      cur = cur.peg[0]
+    }
+    return cur
+  }
+  // The file a value was written in, and so any alias name's scope. A
+  // DOCUMENT IS ITS OWN SCOPE too, so a fileless parse is tagged.
+  const srcUrl = (ctx: JsonicContext): string => {
+    const url = ctx.meta.multisource && ctx.meta.multisource.path
+    return url ? url : ((ctx.meta as any).aontu_scope ??= '#' + (++SCOPE_SEQ))
+  }
   let addsite = (v: Val, r: Rule, ctx: JsonicContext) => {
     // The source text comes from the SAME token the row and column
     // come from. jsonic has carried it all along; not reading it is
@@ -452,8 +602,16 @@ let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
   const isAliasDecl = (ktkn: any, sep: any): boolean =>
     null != ktkn && VL === ktkn.tin && ALIAS_RE.test('' + ktkn.src) &&
     true === sep?.use?.aontu_eq
+  const keyName = (ktkn: any): string =>
+    'string' === typeof ktkn?.val ? ktkn.val : '' + ktkn?.src
   const keyRefusalOf = (ktkn: any, sep: any):
     { why: string, details?: Record<string, any> } | undefined => {
+    // THE SENTINEL NAMESPACE IS THE ENGINE'S; it writes `export` here.
+    if (keyName(ktkn).startsWith(RESERVED_KEY_PREFIX) &&
+      true !== ktkn.use?.aontu_export) {
+      return { why: 'reserved_key' }
+    }
     if (null == ktkn || VL !== ktkn.tin) {
       return undefined
     }
@@ -579,14 +737,14 @@ help isolate the syntax error.`,
                 ((prev as any)[SPREAD] || { o: '&', v: [] })
               ;(prev as any)[SPREAD].v.push(lm.spread.cj)
             }
-            prev.___optional = (prev.___optional || [])
-            for (const k of lm.optionalKeys) { prev.___optional.push(k) }
-            prev.___alias = (prev.___alias || [])
-            for (const k of lm.aliasKeys) { prev.___alias.push(k) }
+            prev[OPTIONAL_MARK_KEY] = (prev[OPTIONAL_MARK_KEY] || [])
+            for (const k of lm.optionalKeys) { prev[OPTIONAL_MARK_KEY].push(k) }
+            prev[ALIAS_MARK_KEY] = (prev[ALIAS_MARK_KEY] || [])
+            for (const k of lm.aliasKeys) { prev[ALIAS_MARK_KEY].push(k) }
             return prev
           }
-          prev.___merge = (prev.___merge || [])
-          prev.___merge.push(curr)
+          prev[MERGE_KEY] = (prev[MERGE_KEY] || [])
+          prev[MERGE_KEY].push(curr)
           return prev
         }
       }
@@ -1033,7 +1191,8 @@ help isolate the syntax error.`,
         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 })
+          hoist.push(
+            { name: aliasScopedKey('' + aname, srcUrl(ctx)), val: valnode })
         }
         return undefined
@@ -1055,13 +1214,27 @@ help isolate the syntax error.`,
       .bc((r: Rule, ctx: JsonicContext) => {
         const optionalKeys = r.u.aontu_optional_keys ?? []
-        const aliasKeys = r.u.aontu_alias_keys ?? []
+        const aliasDecls = r.u.aontu_alias_keys ?? []
+        const aliasKeys: string[] = []
+        const exportKeys: string[] = []
         let mo = r.node
+        // A REFUSED KEY TAKES NO KEY and is not OPTIONAL: its name is a
+        // mark's, and the elision below would put it back.
+        for (const kr of (r.u.aontu_key_refusals ?? []) as any[]) {
+          if ('reserved_key' === kr.why) {
+            delete mo[kr.key]
+            const oi = optionalKeys.indexOf(kr.key)
+            if (-1 !== oi) {
+              optionalKeys.splice(oi, 1)
+            }
+          }
+        }
         for (const k in mo) {
-          if (null == mo[k] && '___merge' !== k &&
-            '___optional' !== k && '___alias' !== k) {
+          if (null == mo[k] && MERGE_KEY !== k &&
+            OPTIONAL_MARK_KEY !== k && ALIAS_MARK_KEY !== k) {
             // Pathed at the KEY, not at the enclosing map. addsite takes
             // the rule's path, which here is the map's, so the error
             // would otherwise name the container and leave the reader to
@@ -1089,27 +1262,129 @@ help isolate the syntax error.`,
           return undefined
         }
-        for (const { key, tkn, why, details } of
+        const reservedRefusals: Val[] = []
+        for (const { key, tkn, why, details, url } of
           (r.u.aontu_key_refusals ?? []) as any[]) {
           const en: any = siteAt(addsite(new NilVal({ why }), r, ctx), tokenSite(tkn))
           if (null != details) {
             en.details = details
           }
           en.path = [...(r.k?.path ?? []), key]
-          mo[key] = en
+          // A COLON DECLARATION IS REFUSED AND STILL NAMES SOMETHING, so
+          // the refusal is held under the key that name would have had
+          // and a use of it reports why; not an alias key, so it
+          // generates unused.
+          if ('alias_colon' === why) {
+            delete mo[key]
+            mo[aliasScopedKey(key, url)] = en
+          }
+          // A RESERVED KEY WAITS: its name is where the marks are kept.
+          else if ('reserved_key' === why) {
+            reservedRefusals.push(en)
+          }
+          else {
+            mo[key] = en
+          }
+        }
+        // A NAME BELONGS TO THE FILE THAT DECLARED IT. Renamed here and
+        // not at the key, so an elided value is still reported by the
+        // name the source spells; rebuilt, as key order is resolution.
+        const renamed = new Map<string, string>()
+        for (const { name, key } of aliasDecls as any[]) {
+          renamed.set(name, key)
+          if (!aliasKeys.includes(key)) {
+            aliasKeys.push(key)
+          }
+        }
+        if (0 < renamed.size) {
+          const entries = Object.entries(mo)
+          for (const [k] of entries) {
+            delete mo[k]
+          }
+          for (const [k, v] of entries) {
+            const key = renamed.get(k)
+            if (undefined === key) {
+              mo[k] = v
+            }
+            else {
+              mo[key] = v
+              repathInstance(v, [...(r.k?.path ?? []), key])
+            }
+          }
+        }
+        // `export` PUBLISHES NAMES AND NOTHING ELSE; a bare name, a key
+        // and the wildcard are refused, and the argument is erased.
+        for (const { items, tkn } of (r.u.aontu_export_decls ?? []) as any[]) {
+          delete mo[tkn.val]
+          const names = publishedNames(items)
+          if (undefined === names) {
+            const en: any =
+              siteAt(addsite(new NilVal({ why: 'export_arg' }), r, ctx), tokenSite(tkn))
+            en.path = [...(r.k?.path ?? []), EXPORT_DECL_NAME]
+            mo[EXPORT_DECL_NAME] = en
+          }
+          else {
+            exportKeys.push(...names.map((n) => aliasScopedKey(n, srcUrl(ctx))))
+          }
+        }
+        // THE DESTRUCTURE IS ADDITIVE: the values land where the head
+        // stands, each name binds in THIS file's scope, and a file
+        // publishes only what IT declares. A DECLARATION IS THE
+        // DOCUMENT'S, so the names go to the root and the values may
+        // sit under a key.
+        for (const im of (r.u.aontu_import_decls ?? []) as any[]) {
+          const hoist = ((ctx as any).aontu_alias_hoist ||= [])
+          const iv: any = mo[im.key]
+          delete mo[im.key]
+          const dv: any = declaringMap(iv)
+          const ex: string[] = dv.exportKeys ?? []
+          const ak: string[] = dv.aliasKeys ?? []
+          for (const k of ak) {
+            hoist.push({ name: k, val: dv.peg[k] })
+            delete dv.peg[k]
+          }
+          if (0 < ak.length + ex.length) {
+            dv.aliasKeys = []
+            dv.exportKeys = []
+          }
+          repathInstance(iv, [...(r.k?.path ?? [])])
+          ; (mo[MERGE_KEY] = mo[MERGE_KEY] || []).push(iv)
+          const binds: AliasBind[] = 0 === im.names.length ?
+            ex.map((k: string) =>
+              ({ local: aliasBareName(k), remote: aliasBareName(k) })) : im.names
+          for (const { local, remote } of binds) {
+            const from = ex.find((k: string) => aliasBareName(k) === remote)
+            let bind: Val
+            if (undefined === from || !ak.includes(from)) {
+              bind = siteAt(addsite(
+                new NilVal({ why: 'import_not_exported' }), r, ctx), tokenSite(im.tkn))
+              ; (bind as any).details = { name: remote }
+                  const en: any = siteAt(addsite(
+                new NilVal({ why: 'import_not_exported' }), r, ctx), tokenSite(im.tkn))
+              en.details = { name: remote }
+              mo[MERGE_KEY].push(en)
+            }
+            else {
+              bind = addsite(new RefVal({ peg: [from], absolute: true }), r, ctx)
+            }
+            hoist.push({ name: aliasScopedKey(local, im.url), val: bind })
+          }
         }
         // Marks carried over from a map include folded in the merge
         // hook above, applied here where the MapVal is built.
-        if (mo.___optional || mo.___alias) {
-          for (const k of (mo.___optional || [])) {
+        if (mo[OPTIONAL_MARK_KEY] || mo[ALIAS_MARK_KEY]) {
+          for (const k of (mo[OPTIONAL_MARK_KEY] || [])) {
             if (!optionalKeys.includes(k)) { optionalKeys.push(k) }
           }
-          for (const k of (mo.___alias || [])) {
+          for (const k of (mo[ALIAS_MARK_KEY] || [])) {
             if (!aliasKeys.includes(k)) { aliasKeys.push(k) }
           }
-          delete mo.___optional
-          delete mo.___alias
+          delete mo[OPTIONAL_MARK_KEY]
+          delete mo[ALIAS_MARK_KEY]
         }
         // A value-prefix declaration lands here, at the document root
@@ -1126,21 +1401,28 @@ help isolate the syntax error.`,
         }
         //  Handle defered conjuncts, e.g. `{x:1 @"foo"}`
-        if (mo.___merge) {
+        const deferred = mo[MERGE_KEY]
+        delete mo[MERGE_KEY]
+        const merge = 0 < reservedRefusals.length ?
+          [...(deferred ?? []), ...reservedRefusals] : deferred
+        if (merge) {
           let mop = { ...mo }
-          delete mop.___merge
           let mopv = new MapVal({ peg: mop })
           mopv.optionalKeys = optionalKeys
           mopv.aliasKeys = aliasKeys
+          mopv.exportKeys = exportKeys
           r.node =
-            addsite(new ConjunctVal({ peg: [mopv, ...mo.___merge] }), r, ctx)
+            addsite(new ConjunctVal({ peg: [mopv, ...merge] }), r, ctx)
         }
         else {
           r.node = addsite(new MapVal({ peg: mo }), r, ctx)
           r.node.optionalKeys = optionalKeys
           r.node.aliasKeys = aliasKeys
+          r.node.exportKeys = exportKeys
         }
         return undefined
@@ -1169,7 +1451,7 @@ help isolate the syntax error.`,
           }
         }
-        // No ___merge arm here: the deferred map.merge that writes it
+        // No merge-key arm here: the deferred map.merge that writes it
         // only ever fires for a `pair` rule, whose parent is always a
         // `map` rule with a plain-object node — never a list.
         {
@@ -1263,19 +1545,39 @@ help isolate the syntax error.`,
         }
       })
-      .bc((rule: Rule) => {
+      .bc((rule: Rule, ctx: JsonicContext) => {
         // TRAVERSE PARENTS TO GET PATH
-        const ktkn: any = rule.o0
+        // AN OPTIONAL PAIR OPENS ON ITS `?`: the rule before read the key.
+        const ktkn: any = true === rule.prev?.u?.aontu_optional ?
+          rule.prev.o0 : rule.o0
         const holder: any = rule.parent
         const kr = keyRefusalOf(ktkn, rule.o1)
         if (null != kr) {
           holder.u.aontu_key_refusals = (holder.u.aontu_key_refusals || [])
-          holder.u.aontu_key_refusals.push({ key: '' + ktkn.src, tkn: ktkn, ...kr })
+          holder.u.aontu_key_refusals.push(
+            { key: keyName(ktkn), tkn: ktkn, url: srcUrl(ctx), ...kr })
         }
         else if (isAliasDecl(ktkn, rule.o1)) {
           holder.u.aontu_alias_keys = (holder.u.aontu_alias_keys || [])
-          holder.u.aontu_alias_keys.push('' + ktkn.src)
+          holder.u.aontu_alias_keys.push({
+            name: '' + ktkn.src,
+            key: aliasScopedKey('' + ktkn.src, srcUrl(ctx)),
+          })
+        }
+        else if (true === ktkn?.use?.aontu_export) {
+          holder.u.aontu_export_decls = (holder.u.aontu_export_decls || [])
+          holder.u.aontu_export_decls.push(
+            { items: ktkn.use.aontu_export_items, tkn: ktkn })
+        }
+        else if (null != ktkn?.use?.aontu_import) {
+          holder.u.aontu_import_decls = (holder.u.aontu_import_decls || [])
+          holder.u.aontu_import_decls.push({
+            key: '' + ktkn.src,
+            names: ktkn.use.aontu_import,
+            url: srcUrl(ctx),
+            tkn: ktkn,
+          })
         }
         if (rule.u.spread) {
@@ -1394,7 +1696,8 @@ help isolate the syntax error.`,
           }
           // 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 })
+            ; ((ctx as any).aontu_alias_hoist ||= [])
+              .push({ name: aliasScopedKey(key, srcUrl(ctx)), val: v })
             rule.node.push(v)
             return undefined
           }
@@ -1406,7 +1709,8 @@ help isolate the syntax error.`,
           // "is this the top level" test reads the path, so an element
           // of a top-level list must not read as the root.
           mv.path = [...(rule.k?.path ?? []), '' + rule.node.length]
-          if (true === rule.u.aontu_optional_elem) {
+          // A REFUSED KEY IS NOT OPTIONAL: the refusal would be dropped.
+          if (true === rule.u.aontu_optional_elem && null == kr) {
             mv.optionalKeys = [key]
           }
           rule.node.push(mv)