@bablr/agast-vm 0.4.2 → 0.6.0

package/lib/context.js

@@ -7,32 +7,33 @@ import {
   getCooked as getCookedFromStream,
   sourceTextFor as sourceTextForStream,
 } from '@bablr/agast-helpers/stream';
+import { OpenNodeTag, CloseNodeTag } from '@bablr/agast-helpers/symbols';
 import { facades, actuals } from './facades.js';
 
 const { isArray } = Array;
 
-function* allTerminalsFor(range, nextTerminals) {
+function* allTagsFor(range, nextTags) {
   if (!range) return;
   const { 0: start, 1: end } = range;
 
-  const pastEnd = nextTerminals.get(end);
+  const pastEnd = nextTags.get(end);
 
-  for (let tag = start; tag && tag !== pastEnd; tag = nextTerminals.get(tag)) {
+  for (let tag = start; tag && tag !== pastEnd; tag = nextTags.get(tag)) {
     yield tag;
   }
 }
 
 export const ContextFacade = class AgastContextFacade {
-  getPreviousTerminal(token) {
-    return actuals.get(this).prevTerminals.get(token);
+  getPreviousTag(token) {
+    return actuals.get(this).prevTags.get(token);
   }
 
-  getNextTerminal(token) {
-    return actuals.get(this).nextTerminals.get(token);
+  getNextTag(token) {
+    return actuals.get(this).nextTags.get(token);
   }
 
-  allTerminalsFor(range) {
-    return actuals.get(this).allTerminalsFor(range);
+  allTagsFor(range) {
+    return actuals.get(this).allTagsFor(range);
   }
 
   getCooked(range) {
@@ -47,8 +48,8 @@ export const ContextFacade = class AgastContextFacade {
     return actuals.get(this).sourceTextFor(range);
   }
 
-  buildRange(terminals) {
-    return actuals.get(this).buildRange(terminals);
+  buildRange(tags) {
+    return actuals.get(this).buildRange(tags);
   }
 
   unbox(value) {
@@ -62,8 +63,8 @@ export const Context = class AgastContext {
   }
 
   constructor() {
-    this.prevTerminals = new WeakMap();
-    this.nextTerminals = new WeakMap();
+    this.prevTags = new WeakMap();
+    this.nextTags = new WeakMap();
     this.unboxedValues = new WeakMap();
     this.facade = new ContextFacade();
 
@@ -73,9 +74,9 @@ export const Context = class AgastContext {
   isEmpty(range) {
     const { path, parent } = this;
 
-    if (range[0]?.type === 'OpenNodeTag' && path !== parent.path) {
-      const nextTag = this.nextTerminals.get(range[0]);
-      if (!nextTag || nextTag.type === 'CloseNodeTag') {
+    if (range[0]?.type === OpenNodeTag && path !== parent.path) {
+      const nextTag = this.nextTags.get(range[0]);
+      if (!nextTag || nextTag.type === CloseNodeTag) {
         return null;
       }
     } else {
@@ -83,44 +84,42 @@ export const Context = class AgastContext {
     }
   }
 
-  allTerminalsFor(range) {
-    return allTerminalsFor(range, this.nextTerminals);
+  allTagsFor(range) {
+    return allTagsFor(range, this.nextTags);
   }
 
-  allTerminalsReverseFor(range) {
-    return allTerminalsFor([...range].reverse(), this.prevTerminals);
+  allTagsReverseFor(range) {
+    return allTagsFor([...range].reverse(), this.prevTags);
   }
 
-  getPreviousTerminal(token) {
-    return this.prevTerminals.get(token);
+  getPreviousTag(token) {
+    return this.prevTags.get(token);
   }
 
-  getNextTerminal(token) {
-    return this.nextTerminals.get(token);
+  getNextTag(token) {
+    return this.nextTags.get(token);
   }
 
-  sourceTextFor(nodeOrRange) {
-    return isArray(nodeOrRange)
-      ? sourceTextForStream(this.allTerminalsFor(nodeOrRange))
-      : sourceTextForTree(nodeOrRange);
+  sourceTextFor(node) {
+    return sourceTextForTree(node);
   }
 
-  buildRange(terminals) {
-    const { prevTerminals, nextTerminals } = this;
+  buildRange(tags) {
+    const { prevTags, nextTags } = this;
 
     let start, end;
-    for (const terminal of terminals) {
-      if (prevTerminals.has(terminal) || nextTerminals.has(terminal)) {
+    for (const tag of tags) {
+      if (prevTags.has(tag) || nextTags.has(tag)) {
         throw new Error('buildRange must not overwrite linkages');
       }
 
       if (end) {
-        prevTerminals.set(terminal, end);
-        nextTerminals.set(end, terminal);
+        prevTags.set(tag, end);
+        nextTags.set(end, tag);
       }
 
-      start = start || terminal;
-      end = terminal || end;
+      start = start || tag;
+      end = tag || end;
     }
     return start ? [start, end] : null;
   }
@@ -140,7 +139,7 @@ export const Context = class AgastContext {
 
   getCooked(nodeOrRange) {
     return isArray(nodeOrRange)
-      ? getCookedFromStream(this.allTerminalsFor(nodeOrRange))
+      ? getCookedFromStream(this.allTagsFor(nodeOrRange))
       : getCookedFromTree(nodeOrRange);
   }
 };

package/lib/evaluate.js

@@ -1,10 +1,10 @@
 import { Coroutine } from '@bablr/coroutine';
 import {
-  buildNull,
-  buildGap,
-  buildShift,
-  buildReference,
-  buildLiteral,
+  buildNullTag,
+  buildGapTag,
+  buildShiftTag,
+  buildReferenceTag,
+  buildLiteralTag,
   buildWriteEffect,
   buildDoctypeTag,
   buildNodeOpenTag,
@@ -13,7 +13,27 @@ import {
 import { getEmbeddedExpression } from '@bablr/agast-vm-helpers/deembed';
 import { StreamIterable, getStreamIterator } from '@bablr/agast-helpers/stream';
 import { printExpression } from '@bablr/agast-helpers/print';
-import { getRange, getOpenTag } from '@bablr/agast-helpers/tree';
+import {
+  getRange,
+  getOpenTag,
+  buildArrayTag,
+  buildFragmentCloseTag,
+  buildFragmentOpenTag,
+} from '@bablr/agast-helpers/tree';
+import {
+  DoctypeTag,
+  OpenNodeTag,
+  CloseNodeTag,
+  ReferenceTag,
+  ShiftTag,
+  GapTag,
+  NullTag,
+  ArrayTag,
+  LiteralTag,
+  CloseFragmentTag,
+  OpenFragmentTag,
+} from '@bablr/agast-helpers/symbols';
+import * as btree from '@bablr/agast-helpers/btree';
 import { State } from './state.js';
 import { facades } from './facades.js';
 
@@ -67,24 +87,20 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
       }
 
       case 'advance': {
-        const { 0: embeddedTerminal, 1: options } = args;
+        const { 0: embeddedTag, 1: options } = args;
 
-        const terminal = embeddedTerminal.value;
+        const tag = embeddedTag.value;
 
         if (
           s.held &&
-          !(
-            terminal.type === 'OpenNodeTag' ||
-            terminal.type === 'Reference' ||
-            terminal.type === 'Gap'
-          )
+          !(tag.type === OpenNodeTag || tag.type === ReferenceTag || tag.type === GapTag)
         ) {
           throw new Error('Cannot advance while holding');
         }
 
-        switch (terminal?.type || 'Null') {
-          case 'DoctypeTag': {
-            const { attributes } = terminal.value;
+        switch (tag?.type || NullTag) {
+          case DoctypeTag: {
+            const { attributes } = tag.value;
 
             if (s.path) {
               throw new Error();
@@ -94,7 +110,7 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
             break;
           }
 
-          case 'Literal': {
+          case LiteralTag: {
             if (!s.node.flags.token) {
               throw new Error('literals must occur inside tokens');
             }
@@ -103,14 +119,14 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
               throw new Error('Cannot consume input while hold register is full');
             }
 
-            returnValue = s.advance(buildLiteral(terminal.value));
+            returnValue = s.advance(buildLiteralTag(tag.value));
             break;
           }
 
-          case 'Reference': {
-            const { name, isArray } = terminal.value;
+          case ReferenceTag: {
+            const { name, isArray, hasGap } = tag.value;
 
-            if (s.result.type === 'Reference') {
+            if (s.result.type === ReferenceTag) {
               throw new Error('A reference must have a non-reference value');
             }
 
@@ -118,41 +134,51 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
               throw new Error('A token node cannot contain a reference');
             }
 
-            returnValue = s.advance(buildReference(name, isArray));
+            returnValue = s.advance(buildReferenceTag(name, isArray, hasGap));
             break;
           }
 
-          case 'Gap': {
+          case GapTag: {
             const reference = s.result;
 
-            if (reference?.type !== 'Reference') throw new Error();
+            if (reference?.type !== ReferenceTag) throw new Error();
 
-            returnValue = s.advance(buildGap());
+            returnValue = s.advance(buildGapTag());
             break;
           }
 
-          case 'Null': {
+          case NullTag: {
             const reference = s.result;
 
-            if (reference?.type !== 'Reference') throw new Error();
+            if (reference?.type !== ReferenceTag) throw new Error();
 
-            returnValue = s.advance(buildNull());
+            returnValue = s.advance(buildNullTag());
             break;
           }
 
-          case 'Shift': {
+          case ArrayTag: {
+            const reference = s.result;
+
+            if (reference?.type !== ReferenceTag) throw new Error();
+            if (!reference.value.isArray) throw new Error();
+
+            returnValue = s.advance(buildArrayTag());
+            break;
+          }
+
+          case ShiftTag: {
             const finishedNode = s.nodeForTag(s.result);
 
             if (!getOpenTag(finishedNode).value.flags.expression) {
               throw new Error();
             }
 
-            returnValue = s.advance(buildShift());
+            returnValue = s.advance(buildShiftTag());
             break;
           }
 
-          case 'OpenNodeTag': {
-            const { flags, language, type, attributes } = terminal.value;
+          case OpenNodeTag: {
+            const { flags, language, type, attributes } = tag.value;
 
             if (language && !language.startsWith('https://')) {
               throw new Error('Expected an absolute-language tag');
@@ -165,13 +191,25 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
             break;
           }
 
-          case 'CloseNodeTag': {
-            const { type, language } = terminal.value;
+          case OpenFragmentTag: {
+            const { flags } = tag.value;
+
+            returnValue = s.advance(buildFragmentOpenTag(flags), getEmbeddedExpression(options));
+            break;
+          }
+
+          case CloseNodeTag: {
+            const { type, language } = tag.value;
 
             returnValue = s.advance(buildNodeCloseTag(type, language));
             break;
           }
 
+          case CloseFragmentTag: {
+            returnValue = s.advance(buildFragmentCloseTag());
+            break;
+          }
+
           default:
             throw new Error();
         }
@@ -196,10 +234,6 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
 
         if (key === 'span') throw new Error('too late');
 
-        if (key === 'balancedSpan') {
-          throw new Error('not implemented');
-        }
-
         // if (stateIsDifferent) {
         //   // we can't allow effects to cross state branches
         //   throw new Error();
@@ -207,18 +241,18 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
 
         unboundAttributes.delete(key);
 
-        const openTag = s.node.children[0];
+        const openTag = getOpenTag(s.node);
 
         if (value != null) {
           const { flags, language, type } = openTag.value;
           const attributes = { ...openTag.value.attributes, [key]: value };
           const newOpenTag = buildNodeOpenTag(flags, language, type, attributes);
 
-          let openNext = ctx.nextTerminals.get(openTag);
-          let startPrev = ctx.prevTerminals.get(openTag);
+          let openNext = ctx.nextTags.get(openTag);
+          let startPrev = ctx.prevTags.get(openTag);
 
-          ctx.prevTerminals.set(newOpenTag, startPrev);
-          ctx.nextTerminals.set(startPrev, newOpenTag);
+          ctx.prevTags.set(newOpenTag, startPrev);
+          ctx.nextTags.set(startPrev, newOpenTag);
 
           if (s.node !== s.tagNodes.get(openTag)) throw new Error();
           if (s.path !== s.tagPaths.get(openTag)) throw new Error();
@@ -229,14 +263,14 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
           s.tagPaths.set(newOpenTag, s.path);
 
           if (openNext) {
-            ctx.nextTerminals.set(newOpenTag, openNext);
-            ctx.prevTerminals.set(openNext, newOpenTag);
+            ctx.nextTags.set(newOpenTag, openNext);
+            ctx.prevTags.set(openNext, newOpenTag);
           } else {
-            // could this terminal be stored anywhere else?
+            // could this tag be stored anywhere else?
             s.result = newOpenTag;
           }
 
-          s.node.children[0] = newOpenTag;
+          s.node.children = btree.replaceAt(0, s.node.children, newOpenTag);
         }
 
         if (!unboundAttributes.size) {
@@ -259,7 +293,7 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
 
       case 'write': {
         if (options.emitEffects) {
-          yield buildWriteEffect(args[0], getEmbeddedExpression(args[1]));
+          yield buildWriteEffect(args[0], args[1].value);
         }
         break;
       }

package/lib/path.js

@@ -1,4 +1,5 @@
 import { WeakStackFrame } from '@bablr/weak-stack';
+import { DoctypeTag, ReferenceTag } from '@bablr/agast-helpers/symbols';
 import { skipToDepth, buildSkips } from './utils/skip.js';
 import { facades, actuals } from './facades.js';
 
@@ -33,19 +34,20 @@ export const PathFacade = class AgastPathFacade {
 };
 
 export const Path = class AgastPath extends WeakStackFrame {
-  static from(context, tag) {
-    return Path.create(context, tag);
+  static from(context, tag, childrenIndex) {
+    return Path.create(context, tag, childrenIndex);
   }
 
-  constructor(context, reference) {
+  constructor(context, reference, childrenIndex = -1) {
     super();
 
-    if (reference && reference.type !== 'Reference' && reference.type !== 'DoctypeTag') {
+    if (reference && reference.type !== ReferenceTag && reference.type !== DoctypeTag) {
       throw new Error('Invalid reference for path');
     }
 
     this.context = context;
     this.reference = reference;
+    this.childrenIndex = childrenIndex;
 
     buildSkips(this);
 
@@ -53,7 +55,7 @@ export const Path = class AgastPath extends WeakStackFrame {
   }
 
   get name() {
-    return this.reference?.value.name || '[anonymous]';
+    return this.reference?.value.name;
   }
 
   get isArray() {

package/lib/state.js

@@ -10,50 +10,42 @@ import {
   acceptNode,
   finalizeNode,
   getRoot,
+  printType,
+  buildStubNode,
 } from '@bablr/agast-helpers/tree';
+import * as btree from '@bablr/agast-helpers/btree';
 import {
   buildBeginningOfStreamToken,
   buildEmbeddedNode,
-  nodeFlags,
 } from '@bablr/agast-vm-helpers/internal-builders';
-import * as sym from '@bablr/agast-helpers/symbols';
+import {
+  DoctypeTag,
+  OpenNodeTag,
+  CloseNodeTag,
+  ReferenceTag,
+  ShiftTag,
+  GapTag,
+  NullTag,
+  ArrayTag,
+  LiteralTag,
+  OpenFragmentTag,
+  CloseFragmentTag,
+} from '@bablr/agast-helpers/symbols';
 import { facades, actuals } from './facades.js';
 import { Path } from './path.js';
+import { isArray } from 'iter-tools-es';
 
 const { hasOwn } = Object;
 
-const arrayLast = (arr) => arr[arr.length - 1];
-
-const createNodeWithState = (startTag, options = {}) => {
+const createNodeWithState = (openTag, options = {}) => {
   const { unboundAttributes } = options;
-  const node = createNode(startTag);
+  const node = createNode(openTag);
   nodeStates.set(node, {
-    resolver: new Resolver(node),
     unboundAttributes: new Set(unboundAttributes || []),
   });
   return node;
 };
 
-const symbolTypeFor = (type) => {
-  // prettier-ignore
-  switch (type) {
-    case 'Null': return sym.null;
-    case 'Gap': return sym.gap;
-    default: throw new Error();
-  }
-};
-
-const buildStubNode = (tag) => {
-  return {
-    flags: nodeFlags,
-    language: null,
-    type: symbolTypeFor(tag.type),
-    children: [tag],
-    properties: {},
-    attributes: {},
-  };
-};
-
 export const StateFacade = class AgastStateFacade {
   constructor(state) {
     facades.set(state, this);
@@ -96,11 +88,11 @@ export const StateFacade = class AgastStateFacade {
   }
 
   nodeForPath(path) {
-    return actuals.get(this).nodeForPath(path);
+    return actuals.get(this).nodeForPath(actuals.get(path));
   }
 
   pathForTag(tag) {
-    return actuals.get(this).pathForTag(tag);
+    return facades.get(actuals.get(this).pathForTag(tag));
   }
 
   nodeForTag(tag) {
@@ -119,6 +111,7 @@ export const State = class AgastState extends WeakStackFrame {
     result = buildBeginningOfStreamToken(),
     emitted = null,
     held = null,
+    resolver = new Resolver(),
     internalContext = {
       pathNodes: new WeakMap(),
       tagPaths: new WeakMap(),
@@ -136,6 +129,7 @@ export const State = class AgastState extends WeakStackFrame {
     this.result = result;
     this.emitted = emitted;
     this.held = held;
+    this.resolver = resolver;
     this.internalContext = internalContext;
 
     new StateFacade(this);
@@ -161,10 +155,6 @@ export const State = class AgastState extends WeakStackFrame {
     return nodeStates.get(this.node).unboundAttributes;
   }
 
-  get resolver() {
-    return nodeStates.get(this.node).resolver;
-  }
-
   get holding() {
     return !!this.held;
   }
@@ -181,57 +171,55 @@ export const State = class AgastState extends WeakStackFrame {
     return this.tagNodes.get(tag);
   }
 
-  advance(terminal, options = {}) {
+  advance(tag, options = {}) {
     const ctx = this.context;
-    const { prevTerminals, nextTerminals } = ctx;
+    const { prevTags, nextTags } = ctx;
 
-    if (terminal) {
-      if (prevTerminals.has(terminal)) {
+    if (tag) {
+      if (prevTags.has(tag)) {
         throw new Error('Double emit');
       }
 
       if (
-        this.result?.type === 'Reference' &&
-        !['OpenNodeTag', 'Gap', 'Null'].includes(terminal.type)
+        this.result?.type === ReferenceTag &&
+        ![OpenNodeTag, GapTag, NullTag, ArrayTag].includes(tag.type)
       ) {
-        throw new Error(`${terminal.type} is not a valid reference target`);
+        throw new Error(`${printType(tag.type)} is not a valid reference target`);
       }
 
-      prevTerminals.set(terminal, this.result);
-      nextTerminals.set(this.result, terminal);
+      prevTags.set(tag, this.result);
+      nextTags.set(this.result, tag);
+
+      this.resolver.advance(tag);
 
-      switch (terminal.type) {
-        case 'DoctypeTag': {
-          this.path = Path.from(ctx, terminal);
+      switch (tag.type) {
+        case DoctypeTag: {
+          this.path = Path.from(ctx, tag);
 
-          this.tagPaths.set(terminal, this.path);
+          this.tagPaths.set(tag, this.path);
           break;
         }
 
-        case 'OpenNodeTag': {
-          const openTag = terminal;
-          const { type, flags } = terminal.value;
-          this.node = createNodeWithState(terminal, options);
+        case OpenNodeTag: {
+          const openTag = tag;
+          const { flags } = tag.value;
+          this.node = createNodeWithState(tag, options);
 
           const reference = this.result;
 
-          this.node.children.push(terminal);
+          this.node.children = btree.push(this.node.children, tag);
 
-          if (!type) {
-            this.node.attributes = this.result.value.attributes;
-          } else {
-            if (!flags.trivia && !flags.escape) {
-              if (
-                reference.type !== 'Reference' &&
-                reference.type !== 'Shift' &&
-                reference.type !== 'OpenNodeTag' &&
-                !reference.value.type
-              ) {
-                throw new Error('Invalid location for OpenNodeTag');
-              }
-            } else {
-              this.path = this.path.push(ctx, null);
+          if (!flags.trivia && !flags.escape) {
+            if (
+              reference.type !== ReferenceTag &&
+              reference.type !== ShiftTag &&
+              reference.type !== OpenNodeTag &&
+              !reference.value.type
+            ) {
+              throw new Error('Invalid location for OpenNodeTag');
             }
+          } else {
+            this.path = this.path.push(ctx, null, btree.getSum(this.node.children));
           }
 
           this.pathNodes.set(this.node, this.path);
@@ -242,42 +230,68 @@ export const State = class AgastState extends WeakStackFrame {
           break;
         }
 
-        case 'CloseNodeTag': {
-          const openTag = this.node.children[0];
+        case OpenFragmentTag: {
+          const openTag = tag;
+          this.node = createNodeWithState(tag, options);
+
+          const reference = this.result;
+
+          this.node.attributes = this.result.value.attributes;
+          this.node.children = btree.push(this.node.children, reference);
+
+          this.node.children = btree.push(this.node.children, tag);
+
+          this.pathNodes.set(this.node, this.path);
+          this.pathNodes.set(this.path, this.node);
+
+          this.tagNodes.set(openTag, this.node);
+          this.tagPaths.set(openTag, this.path);
+          break;
+        }
+
+        case CloseNodeTag: {
+          const openTag = getOpenTag(this.node);
           const { flags, type: openType } = openTag.value;
-          const closeTag = terminal;
+          const closeTag = tag;
           const { type } = closeTag.value;
 
-          this.node.children.push(terminal);
+          this.node.children = btree.push(this.node.children, tag);
 
-          if (openType) {
-            if (this.node.unboundAttributes?.size)
-              throw new Error('Grammar failed to bind all attributes');
+          if (this.node.unboundAttributes?.size)
+            throw new Error('Grammar failed to bind all attributes');
 
-            if (!type) throw new Error(`CloseNodeTag must have type`);
+          if (!type) throw new Error(`CloseNodeTag must have type`);
 
-            if (type !== openType)
-              throw new Error(
-                `Grammar close {type: ${type}} did not match open {type: ${openType}}`,
-              );
+          if (type !== openType)
+            throw new Error(
+              `Grammar close {type: ${printType(type)}} did not match open {type: ${printType(
+                openType,
+              )}}`,
+            );
 
-            if (!flags.escape && !flags.trivia) {
-              const { name: refName, isArray } = this.path.reference.value;
+          if (!flags.escape && !flags.trivia) {
+            add(this.parentNode, this.path.reference, this.node);
+          } else if (this.parentNode) {
+            this.parentNode.children = btree.push(
+              this.parentNode.children,
+              buildEmbeddedNode(this.node),
+            );
+          }
 
-              const { properties } = this.parentNode;
+          this.tagNodes.set(closeTag, this.node);
+          this.tagPaths.set(closeTag, this.path);
 
-              if (!isArray) {
-                properties[refName] = this.node;
-              } else {
-                if (!hasOwn(properties, refName)) {
-                  properties[refName] = [];
-                }
-                properties[refName].push(this.node);
-              }
-            } else {
-              this.parentNode.children.push(buildEmbeddedNode(this.node));
-            }
-          }
+          finalizeNode(this.node);
+
+          this.node = this.parentNode;
+          this.path = this.path.parent;
+          break;
+        }
+
+        case CloseFragmentTag: {
+          const closeTag = tag;
+
+          this.node.children = btree.push(this.node.children, tag);
 
           this.tagNodes.set(closeTag, this.node);
           this.tagPaths.set(closeTag, this.path);
@@ -289,39 +303,63 @@ export const State = class AgastState extends WeakStackFrame {
           break;
         }
 
-        case 'Reference': {
-          if (this.path.depth) {
-            nodeStates.get(this.node).resolver.consume(terminal);
-          }
+        case ReferenceTag: {
+          this.node.children = btree.push(this.node.children, tag);
 
-          this.node.children.push(terminal);
+          const { isArray, name, hasGap } = tag.value;
 
-          this.path = this.path.push(ctx, terminal);
+          if (hasGap && !this.node.flags.hasGap) {
+            throw new Error('gap reference in gapless node');
+          }
 
-          this.tagPaths.set(terminal, this.path);
+          if (isArray && !hasOwn(this.node.properties, name)) {
+            this.node.properties[name] = [];
+          } else {
+            this.path = this.path.push(ctx, tag, btree.getSum(this.node.children));
+          }
+
+          this.tagPaths.set(tag, this.path);
           break;
         }
 
-        case 'Gap': {
-          this.tagPaths.set(terminal, this.path);
+        case GapTag: {
+          this.tagPaths.set(tag, this.path);
 
           let target;
-          let ref = arrayLast(this.node.children);
+          let ref = btree.getAt(-1, this.node.children);
 
-          if (ref.type !== 'Reference') throw new Error();
+          if (ref.type !== ReferenceTag) throw new Error();
 
           if (this.held) {
             target = this.held.node;
 
             this.held = null;
-          } else if (this.expressions.size) {
-            const expression = this.expressions.value;
-            target = getRoot(expression);
-            this.expressions = this.expressions.pop();
           } else {
-            target = buildStubNode(terminal);
+            if (!this.node.flags.hasGap) throw new Error('Node must allow gaps');
+
+            if (this.expressions.size) {
+              const expression = this.expressions.value;
+
+              if (isArray(expression)) {
+                throw new Error('Invalid array interpolation');
+              } else {
+                target = expression != null ? getRoot(expression) : buildStubNode(tag);
+
+                this.expressions = this.expressions.pop();
+              }
+
+              // const range = ctx.buildRange(streamFromTree(target));
+
+              // this node is only interpolated into the tree, not the stream
+              // the stream still contains a gap token, even if expressions were specified
+              // get rid of the gap token in the stream!
+            } else {
+              target = buildStubNode(tag);
+            }
           }
 
+          this.tagNodes.set(tag, target);
+
           this.pathNodes.set(this.pathForTag(ref), target);
           add(this.node, ref, target);
 
@@ -329,17 +367,16 @@ export const State = class AgastState extends WeakStackFrame {
           break;
         }
 
-        case 'Null': {
-          this.tagPaths.set(terminal, this.path);
+        case NullTag: {
+          this.tagPaths.set(tag, this.path);
 
           const { properties } = this.node;
           const { isArray, name } = this.result.value;
 
-          const newNode = buildStubNode(terminal);
+          const newNode = buildStubNode(tag);
 
           if (!hasOwn(properties, name)) {
-            // TODO is this behavior right
-            properties[name] = isArray ? [] : newNode;
+            properties[name] = newNode;
           }
 
           this.pathNodes.set(this.path, newNode);
@@ -348,9 +385,9 @@ export const State = class AgastState extends WeakStackFrame {
           break;
         }
 
-        case 'Shift': {
+        case ShiftTag: {
           const finishedNode = this.nodeForTag(this.result);
-          const ref = ctx.getPreviousTerminal(getOpenTag(finishedNode));
+          const ref = ctx.getPreviousTag(getOpenTag(finishedNode));
           const finishedPath = this.pathForTag(ref);
           const { properties } = this.node;
 
@@ -361,8 +398,8 @@ export const State = class AgastState extends WeakStackFrame {
           let node = properties[ref.value.name];
 
           if (ref.value.isArray) {
-            node = arrayLast(node);
-            properties[ref.value.name].pop();
+            node = btree.getAt(-1, node);
+            properties[ref.value.name] = btree.pop(properties[ref.value.name]);
           } else {
             properties[ref.value.name] = null;
           }
@@ -371,37 +408,37 @@ export const State = class AgastState extends WeakStackFrame {
           break;
         }
 
-        case 'Literal': {
-          this.node.children.push(terminal);
+        case LiteralTag:
+        case ArrayTag:
+          this.node.children = btree.push(this.node.children, tag);
           break;
-        }
 
         default:
           throw new Error();
       }
     }
 
-    this.result = terminal;
+    this.result = tag;
 
-    return terminal;
+    return tag;
   }
 
   *emit() {
-    const { nextTerminals } = this.context;
+    const { nextTags } = this.context;
     if (!this.depth) {
-      let emittable = this.emitted ? nextTerminals.get(this.emitted) : this.result;
+      let emittable = this.emitted ? nextTags.get(this.emitted) : this.result;
 
       while (
         emittable &&
         !(
-          emittable.type === 'OpenNodeTag' &&
+          emittable.type === OpenNodeTag &&
           emittable.value.type &&
           nodeStates.get(this.nodeForTag(emittable)).unboundAttributes?.size
         )
       ) {
         yield emittable;
         this.emitted = emittable;
-        emittable = nextTerminals.get(this.emitted);
+        emittable = nextTags.get(this.emitted);
       }
     }
   }
@@ -411,7 +448,7 @@ export const State = class AgastState extends WeakStackFrame {
   }
 
   get isGap() {
-    return this.tag.type === 'NodeGapTag';
+    return this.tag.type === GapTag;
   }
 
   get speculative() {
@@ -419,11 +456,12 @@ export const State = class AgastState extends WeakStackFrame {
   }
 
   get parentNode() {
-    return this.pathNodes.get(this.path.parent);
+    return this.pathNodes.has(this.path) ? this.pathNodes.get(this.path.parent) : this.node;
   }
 
   branch() {
-    const { context, expressions, path, node, result, emitted, held, internalContext } = this;
+    const { context, expressions, path, node, result, emitted, held, resolver, internalContext } =
+      this;
     const { pathNodes } = internalContext;
 
     const newNode = node && branchNode(node);
@@ -431,15 +469,26 @@ export const State = class AgastState extends WeakStackFrame {
     const nodeState = nodeStates.get(node);
 
     pathNodes.set(path, newNode);
+    pathNodes.set(newNode, path);
 
-    nodeStates.set(newNode, { ...nodeState, resolver: nodeState.resolver.branch() });
+    nodeStates.set(newNode, { ...nodeState });
 
     const nodeOpen = getOpenTag(node);
     const nodeClose = getCloseTag(node);
     if (nodeOpen) this.tagNodes.set(nodeOpen, newNode);
     if (nodeClose) this.tagNodes.set(nodeClose, newNode);
 
-    return this.push(context, expressions, path, newNode, result, emitted, held, internalContext);
+    return this.push(
+      context,
+      expressions,
+      path,
+      newNode,
+      result,
+      emitted,
+      held,
+      resolver.branch(),
+      internalContext,
+    );
   }
 
   accept() {
@@ -463,6 +512,8 @@ export const State = class AgastState extends WeakStackFrame {
     parent.result = this.result;
     parent.held = this.held;
     parent.path = this.path;
+    parent.node = this.node;
+    parent.resolver = this.resolver;
 
     return parent;
   }
@@ -472,7 +523,7 @@ export const State = class AgastState extends WeakStackFrame {
 
     if (!parent) throw new Error('rejected root state');
 
-    context.nextTerminals.delete(parent.result);
+    context.nextTags.delete(parent.result);
 
     pathNodes.set(parent.path, parent.node);
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-vm",
   "description": "A VM providing DOM-like guarantees about agAST trees",
-  "version": "0.4.2",
+  "version": "0.6.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -12,14 +12,13 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.3.1",
-    "@bablr/agast-vm-helpers": "0.3.2",
+    "@bablr/agast-helpers": "^0.5.0",
+    "@bablr/agast-vm-helpers": "^0.5.0",
     "@bablr/coroutine": "0.1.0",
     "@bablr/weak-stack": "0.1.0",
     "@iter-tools/imm-stack": "1.1.0"
   },
   "devDependencies": {
-    "@bablr/agast-vm-strategy-passthrough": "github:bablr-lang/agast-vm-strategy-passthrough#2bd3a0c7311037af92c5b81941c79161499f6c9e",
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",
     "enhanced-resolve": "^5.12.0",
     "eslint": "^8.32.0",

package/lib/node.js

@@ -1,36 +0,0 @@
-import { getRange, getOpenTag, getCloseTag } from '@bablr/agast-helpers/tree';
-import { facades, actuals } from './facades.js';
-
-export const NodeFacade = class AgastNodeFacade {
-  constructor(path) {
-    facades.set(path, this);
-  }
-
-  get language() {
-    return actuals.get(this).language;
-  }
-
-  get type() {
-    return actuals.get(this).type;
-  }
-
-  get range() {
-    return getRange(actuals.get(this));
-  }
-
-  get openTag() {
-    return getOpenTag(actuals.get(this));
-  }
-
-  get closeTag() {
-    return getCloseTag(actuals.get(this));
-  }
-
-  get flags() {
-    return actuals.get(this).flags;
-  }
-
-  get attributes() {
-    return actuals.get(this).attributes;
-  }
-};