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

aontu 0.68.0 → 0.70.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/dist/lang.js CHANGED Viewed

@@ -95,11 +95,20 @@ const CC_0 = 48;
 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_]+)*/;
+const aliasname_1 = require("./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 = aliasname_1.RESERVED_KEY_PREFIX + 'merge';
+const ALIAS_MARK_KEY = aliasname_1.RESERVED_KEY_PREFIX + 'alias';
+const OPTIONAL_MARK_KEY = aliasname_1.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('^(' + aliasname_1.ALIAS_SET + ')[ \\t]*=(?!=)');
+const EXPORT_RE = /^export[ \t]*\([ \t]*([^()\s][^()]*?)[ \t]*\)/;
 const CC_9 = 57;
 const CC_A = 65;
 const CC_Z = 90;
@@ -178,7 +187,7 @@ let AontuJsonic = function AontuLang(jsonic) {
             const segs = Array.isArray(t.peg) ? t.peg :
                 ('string' === typeof t.peg ? [t.peg] : []);
             for (const seg of segs) {
-                if ('string' === typeof seg && ALIAS_RE.test(seg)) {
+                if ('string' === typeof seg && aliasname_1.ALIAS_RE.test(seg)) {
                     return addsite(new NilVal_1.NilVal({ why: 'alias_in_path' }), r, ctx);
                 }
             }
@@ -212,13 +221,67 @@ let AontuJsonic = function AontuLang(jsonic) {
             },
         },
     });
+    // THE FIXED MATCHER'S CHECK RUNS AT EVERY POSITION: `{` opens a fixed
+    // token the text check never sees.
+    jsonic.options({
+        fixed: {
+            check: (lex) => {
+                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, ctx) => addsite(new RefVal_1.RefVal({ peg: [(0, aliasname_1.aliasScopedKey)(sh.name, srcUrl(ctx))], absolute: true }), r, ctx), sh.name, pnt)
+                    };
+                }
+                if (CC_OB === lex.src.charCodeAt(pnt.sI)) {
+                    const sres = aliasname_1.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: (0, aliasname_1.aliasSetItems)(hsrc),
+                        });
+                        pnt.sI += hsrc.length;
+                        pnt.cI += hsrc.length;
+                        return { done: true, token: htkn };
+                    }
+                }
+                return undefined;
+            },
+        },
+    });
     jsonic.options({
         text: {
             check: (lex) => {
                 const pnt = lex.pnt;
                 const src = lex.src;
                 const ares = CC_PCT === src.charCodeAt(pnt.sI) ?
-                    ALIAS_RE.exec(lex.refwd()) : null;
+                    aliasname_1.ALIAS_RE.exec(lex.refwd()) : null;
                 if (null != ares) {
                     const asrc = ares[0];
                     let j = pnt.sI + asrc.length;
@@ -229,11 +292,45 @@ let AontuJsonic = function AontuLang(jsonic) {
                     if (CC_EQ === src.charCodeAt(j) && CC_EQ !== src.charCodeAt(j + 1)) {
                         lex.aontu_eq_at = j;
                     }
-                    const atkn = lex.token('#VL', (r, ctx) => addsite(new RefVal_1.RefVal({ peg: [asrc], absolute: true }), r, ctx), asrc, pnt);
+                    // 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, ctx) => addsite(new RefVal_1.RefVal({ peg: [(0, aliasname_1.aliasScopedKey)(asrc, srcUrl(ctx))], absolute: true }), r, ctx), asrc, pnt);
                     pnt.sI += asrc.length;
                     pnt.cI += asrc.length;
                     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', (0, aliasname_1.exportHoldKey)(), aliasname_1.EXPORT_DECL_NAME, pnt, { aontu_export: true, aontu_export_items: (0, aliasname_1.aliasSetItems)(eres[1]) });
+                        pnt.sI += aliasname_1.EXPORT_DECL_NAME.length;
+                        pnt.cI += aliasname_1.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 });
@@ -294,6 +391,24 @@ let AontuJsonic = function AontuLang(jsonic) {
         v.site.len = ts.len;
         return v;
     };
+    // `export` publishes a name; it renames none, and `{%}` is theirs.
+    const publishedNames = (items) => 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) => {
+        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) => {
+        const url = ctx.meta.multisource && ctx.meta.multisource.path;
+        return url ? url : (ctx.meta.aontu_scope ??= '#' + (++SCOPE_SEQ));
+    };
     let addsite = (v, r, ctx) => {
         // The source text comes from the SAME token the row and column
         // come from. jsonic has carried it all along; not reading it is
@@ -304,14 +419,20 @@ let AontuJsonic = function AontuLang(jsonic) {
         v.path = r.k ? [...r.k.path] : [];
         return v;
     };
-    const isAliasDecl = (ktkn, sep) => null != ktkn && VL === ktkn.tin && ALIAS_RE.test('' + ktkn.src) &&
+    const isAliasDecl = (ktkn, sep) => null != ktkn && VL === ktkn.tin && aliasname_1.ALIAS_RE.test('' + ktkn.src) &&
         true === sep?.use?.aontu_eq;
+    const keyName = (ktkn) => 'string' === typeof ktkn?.val ? ktkn.val : '' + ktkn?.src;
     const keyRefusalOf = (ktkn, sep) => {
+        // THE SENTINEL NAMESPACE IS THE ENGINE'S; it writes `export` here.
+        if (keyName(ktkn).startsWith(aliasname_1.RESERVED_KEY_PREFIX) &&
+            true !== ktkn.use?.aontu_export) {
+            return { why: 'reserved_key' };
+        }
         if (null == ktkn || VL !== ktkn.tin) {
             return undefined;
         }
         const kname = '' + ktkn.src;
-        if (ALIAS_RE.test(kname)) {
+        if (aliasname_1.ALIAS_RE.test(kname)) {
             return isAliasDecl(ktkn, sep) ? undefined : { why: 'alias_colon' };
         }
         const bad = ktkn.use?.aontu_bad;
@@ -413,18 +534,18 @@ help isolate the syntax error.`,
                                 (prev[type_1.SPREAD] || { o: '&', v: [] });
                             prev[type_1.SPREAD].v.push(lm.spread.cj);
                         }
-                        prev.___optional = (prev.___optional || []);
+                        prev[OPTIONAL_MARK_KEY] = (prev[OPTIONAL_MARK_KEY] || []);
                         for (const k of lm.optionalKeys) {
-                            prev.___optional.push(k);
+                            prev[OPTIONAL_MARK_KEY].push(k);
                         }
-                        prev.___alias = (prev.___alias || []);
+                        prev[ALIAS_MARK_KEY] = (prev[ALIAS_MARK_KEY] || []);
                         for (const k of lm.aliasKeys) {
-                            prev.___alias.push(k);
+                            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;
                 }
             }
@@ -557,7 +678,7 @@ help isolate the syntax error.`,
             // as the alias reference rather than through the dot rule, and
             // is refused for the same reason.
             if (terms[0] instanceof RefVal_1.RefVal &&
-                terms[0].peg.some((seg) => 'string' === typeof seg && ALIAS_RE.test(seg))) {
+                terms[0].peg.some((seg) => 'string' === typeof seg && aliasname_1.ALIAS_RE.test(seg))) {
                 return addsite(new NilVal_1.NilVal({ why: 'alias_in_path' }), r, ctx);
             }
             if (terms[0] instanceof RefVal_1.RefVal) {
@@ -786,7 +907,7 @@ help isolate the syntax error.`,
             const aname = r.u.aontu_alias_val;
             if (null != aname && null != valnode) {
                 const hoist = (ctx.aontu_alias_hoist ||= []);
-                hoist.push({ name: '' + aname, val: valnode });
+                hoist.push({ name: (0, aliasname_1.aliasScopedKey)('' + aname, srcUrl(ctx)), val: valnode });
             }
             return undefined;
         })
@@ -801,11 +922,24 @@ help isolate the syntax error.`,
         ])
             .bc((r, ctx) => {
             const optionalKeys = r.u.aontu_optional_keys ?? [];
-            const aliasKeys = r.u.aontu_alias_keys ?? [];
+            const aliasDecls = r.u.aontu_alias_keys ?? [];
+            const aliasKeys = [];
+            const exportKeys = [];
             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 ?? [])) {
+                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
@@ -829,29 +963,124 @@ help isolate the syntax error.`,
                 r.node = addsite(new NilVal_1.NilVal({ why: 'elided_value' }), r, ctx);
                 return undefined;
             }
-            for (const { key, tkn, why, details } of (r.u.aontu_key_refusals ?? [])) {
+            const reservedRefusals = [];
+            for (const { key, tkn, why, details, url } of (r.u.aontu_key_refusals ?? [])) {
                 const en = siteAt(addsite(new NilVal_1.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[(0, aliasname_1.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();
+            for (const { name, key } of aliasDecls) {
+                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;
+                        (0, Val_1.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 ?? [])) {
+                delete mo[tkn.val];
+                const names = publishedNames(items);
+                if (undefined === names) {
+                    const en = siteAt(addsite(new NilVal_1.NilVal({ why: 'export_arg' }), r, ctx), tokenSite(tkn));
+                    en.path = [...(r.k?.path ?? []), aliasname_1.EXPORT_DECL_NAME];
+                    mo[aliasname_1.EXPORT_DECL_NAME] = en;
+                }
+                else {
+                    exportKeys.push(...names.map((n) => (0, aliasname_1.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 ?? [])) {
+                const hoist = (ctx.aontu_alias_hoist ||= []);
+                const iv = mo[im.key];
+                delete mo[im.key];
+                const dv = declaringMap(iv);
+                const ex = dv.exportKeys ?? [];
+                const ak = 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 = [];
+                }
+                (0, Val_1.repathInstance)(iv, [...(r.k?.path ?? [])]);
+                (mo[MERGE_KEY] = mo[MERGE_KEY] || []).push(iv);
+                const binds = 0 === im.names.length ?
+                    ex.map((k) => ({ local: (0, aliasname_1.aliasBareName)(k), remote: (0, aliasname_1.aliasBareName)(k) })) : im.names;
+                for (const { local, remote } of binds) {
+                    const from = ex.find((k) => (0, aliasname_1.aliasBareName)(k) === remote);
+                    let bind;
+                    if (undefined === from || !ak.includes(from)) {
+                        bind = siteAt(addsite(new NilVal_1.NilVal({ why: 'import_not_exported' }), r, ctx), tokenSite(im.tkn));
+                        bind.details = { name: remote };
+                        const en = siteAt(addsite(new NilVal_1.NilVal({ why: 'import_not_exported' }), r, ctx), tokenSite(im.tkn));
+                        en.details = { name: remote };
+                        mo[MERGE_KEY].push(en);
+                    }
+                    else {
+                        bind = addsite(new RefVal_1.RefVal({ peg: [from], absolute: true }), r, ctx);
+                    }
+                    hoist.push({ name: (0, aliasname_1.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
             // (ALIASES.0.md), as a copy pathed at its name.
@@ -868,19 +1097,24 @@ 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_1.MapVal({ peg: mop });
                 mopv.optionalKeys = optionalKeys;
                 mopv.aliasKeys = aliasKeys;
+                mopv.exportKeys = exportKeys;
                 r.node =
-                    addsite(new ConjunctVal_1.ConjunctVal({ peg: [mopv, ...mo.___merge] }), r, ctx);
+                    addsite(new ConjunctVal_1.ConjunctVal({ peg: [mopv, ...merge] }), r, ctx);
             }
             else {
                 r.node = addsite(new MapVal_1.MapVal({ peg: mo }), r, ctx);
                 r.node.optionalKeys = optionalKeys;
                 r.node.aliasKeys = aliasKeys;
+                r.node.exportKeys = exportKeys;
             }
             return undefined;
         })
@@ -900,7 +1134,7 @@ help isolate the syntax error.`,
                     ao[i] = en;
                 }
             }
-            // 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.
             {
@@ -976,18 +1210,36 @@ help isolate the syntax error.`,
                 r.child.k.key = '&';
             }
         })
-            .bc((rule) => {
+            .bc((rule, ctx) => {
             // TRAVERSE PARENTS TO GET PATH
-            const ktkn = rule.o0;
+            // AN OPTIONAL PAIR OPENS ON ITS `?`: the rule before read the key.
+            const ktkn = true === rule.prev?.u?.aontu_optional ?
+                rule.prev.o0 : rule.o0;
             const holder = 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: (0, aliasname_1.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) {
                 rule.node[type_1.SPREAD] =
@@ -1089,7 +1341,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.aontu_alias_hoist ||= []).push({ name: key, val: v });
+                    (ctx.aontu_alias_hoist ||= [])
+                        .push({ name: (0, aliasname_1.aliasScopedKey)(key, srcUrl(ctx)), val: v });
                     rule.node.push(v);
                     return undefined;
                 }
@@ -1099,7 +1352,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);