@bablr/agast-vm 0.3.0 → 0.4.0

package/lib/context.js

@@ -1,23 +1,15 @@
 import { reifyExpressionShallow, reifyExpression } from '@bablr/agast-vm-helpers';
-import { getCooked, sourceTextFor } from '@bablr/agast-helpers/stream';
+import {
+  getCooked as getCookedFromTree,
+  sourceTextFor as sourceTextForTree,
+} from '@bablr/agast-helpers/tree';
+import {
+  getCooked as getCookedFromStream,
+  sourceTextFor as sourceTextForStream,
+} from '@bablr/agast-helpers/stream';
 import { facades, actuals } from './facades.js';
 
-function* ownTerminalsFor(range, nextTerminals, tagNodes) {
-  if (!range) return;
-
-  const { 0: start, 1: end } = range;
-
-  const pastEnd = nextTerminals.get(end);
-
-  for (let term = start; term && term !== pastEnd; term = nextTerminals.get(term)) {
-    if (!(term === range[0] || term === range[1]) && term.type === 'OpenNodeTag') {
-      term = tagNodes.get(term).closeTag;
-      continue;
-    }
-
-    yield term;
-  }
-}
+const { isArray } = Array;
 
 function* allTerminalsFor(range, nextTerminals) {
   if (!range) return;
@@ -39,10 +31,6 @@ export const ContextFacade = class AgastContextFacade {
     return actuals.get(this).nextTerminals.get(token);
   }
 
-  ownTerminalsFor(range) {
-    return actuals.get(this).ownTerminalsFor(range);
-  }
-
   allTerminalsFor(range) {
     return actuals.get(this).allTerminalsFor(range);
   }
@@ -55,10 +43,6 @@ export const ContextFacade = class AgastContextFacade {
     return actuals.get(this).reifyExpression(range);
   }
 
-  getProperty(node, name) {
-    return actuals.get(this).getProperty(node, name);
-  }
-
   sourceTextFor(range) {
     return actuals.get(this).sourceTextFor(range);
   }
@@ -67,18 +51,6 @@ export const ContextFacade = class AgastContextFacade {
     return actuals.get(this).buildRange(terminals);
   }
 
-  nodeForTag(tag) {
-    return actuals.get(this).nodeForTag(tag);
-  }
-
-  pathForTag(tag) {
-    return actuals.get(this).pathForTag(tag);
-  }
-
-  nodeForPath(path) {
-    return actuals.get(this).nodeForPath(path);
-  }
-
   unbox(value) {
     return actuals.get(this).unbox(value);
   }
@@ -92,25 +64,12 @@ export const Context = class AgastContext {
   constructor() {
     this.prevTerminals = new WeakMap();
     this.nextTerminals = new WeakMap();
-    this.tagNodes = new WeakMap();
-    this.tagPaths = new WeakMap();
-    this.pathNodes = new WeakMap();
     this.unboxedValues = new WeakMap();
     this.facade = new ContextFacade();
 
     facades.set(this, this.facade);
   }
 
-  getProperty(result, name) {
-    let startTag = result[0] || result;
-
-    if (startTag.type === 'Reference') {
-      startTag = this.nextTerminals.get(startTag);
-    }
-
-    return this.tagNodes.get(startTag).properties.get(name);
-  }
-
   isEmpty(range) {
     const { path, parent } = this;
 
@@ -129,15 +88,7 @@ export const Context = class AgastContext {
   }
 
   allTerminalsReverseFor(range) {
-    return allTerminalsFor(range, this.prevTerminals);
-  }
-
-  ownTerminalsFor(range) {
-    return ownTerminalsFor(range, this.nextTerminals, this.tagNodes);
-  }
-
-  ownTerminalsReverseFor(range) {
-    return ownTerminalsFor(range, this.prevTerminals, this.tagNodes);
+    return allTerminalsFor([...range].reverse(), this.prevTerminals);
   }
 
   getPreviousTerminal(token) {
@@ -148,20 +99,10 @@ export const Context = class AgastContext {
     return this.nextTerminals.get(token);
   }
 
-  nodeForTag(tag) {
-    return this.tagNodes.get(tag);
-  }
-
-  pathForTag(ref) {
-    return this.tagPaths.get(ref);
-  }
-
-  nodeForPath(path) {
-    return this.pathNodes.get(path);
-  }
-
-  sourceTextFor(range) {
-    return sourceTextFor(this.allTerminalsFor(range));
+  sourceTextFor(nodeOrRange) {
+    return isArray(nodeOrRange)
+      ? sourceTextForStream(this.allTerminalsFor(nodeOrRange))
+      : sourceTextForTree(nodeOrRange);
   }
 
   buildRange(terminals) {
@@ -197,7 +138,9 @@ export const Context = class AgastContext {
     return reifyExpression(value);
   }
 
-  getCooked(range) {
-    return getCooked(this.ownTerminalsFor(range));
+  getCooked(nodeOrRange) {
+    return isArray(nodeOrRange)
+      ? getCookedFromStream(this.allTerminalsFor(nodeOrRange))
+      : getCookedFromTree(nodeOrRange);
   }
 };

package/lib/evaluate.js

@@ -9,12 +9,11 @@ import {
   buildDoctypeTag,
   buildNodeOpenTag,
   buildNodeCloseTag,
-} from '@bablr/agast-helpers/builders';
+} from '@bablr/agast-vm-helpers/internal-builders';
+import { deembedExpression } from '@bablr/agast-vm-helpers/deembed';
 import { StreamIterable, getStreamIterator } from '@bablr/agast-helpers/stream';
 import { printExpression } from '@bablr/agast-helpers/print';
-import { reifyExpression } from '@bablr/agast-vm-helpers';
-import { Path } from './path.js';
-import { Node } from './node.js';
+import { getRange, getOpenTag } from '@bablr/agast-helpers/tree';
 import { State } from './state.js';
 import { facades } from './facades.js';
 
@@ -22,7 +21,7 @@ export const evaluate = (ctx, strategy, options) =>
   new StreamIterable(__evaluate(ctx, strategy, options));
 
 const __evaluate = function* agast(ctx, strategy, options = {}) {
-  let s = State.from(ctx);
+  let s = State.from(ctx, options.expressions);
 
   const co = new Coroutine(getStreamIterator(strategy(facades.get(ctx), facades.get(s))));
 
@@ -35,8 +34,8 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
 
     if (co.done) break;
 
-    const sourceInstr = co.value;
-    const instr = reifyExpression(sourceInstr);
+    const instr = co.value;
+
     let returnValue = undefined;
 
     const { verb, arguments: args = [] } = instr;
@@ -68,7 +67,9 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
       }
 
       case 'advance': {
-        const { 0: terminal, 1: options } = args;
+        const { 0: embeddedTerminal, 1: options } = args;
+
+        const terminal = embeddedTerminal.value;
 
         if (
           s.held &&
@@ -84,24 +85,16 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
         switch (terminal?.type || 'Null') {
           case 'DoctypeTag': {
             const { attributes } = terminal.value;
-            const doctypeTag = buildDoctypeTag(attributes);
-            const rootPath = Path.from(ctx, doctypeTag);
 
             if (s.path) {
               throw new Error();
             }
 
-            s.path = rootPath;
-
-            yield* s.emit(doctypeTag);
-
-            returnValue = doctypeTag;
+            returnValue = s.advance(buildDoctypeTag(attributes));
             break;
           }
 
           case 'Literal': {
-            const literal = buildLiteral(terminal.value);
-
             if (!s.node.flags.token) {
               throw new Error('literals must occur inside tokens');
             }
@@ -110,37 +103,22 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
               throw new Error('Cannot consume input while hold register is full');
             }
 
-            yield* s.emit(literal);
-
-            returnValue = literal;
+            returnValue = s.advance(buildLiteral(terminal.value));
             break;
           }
 
           case 'Reference': {
             const { name, isArray } = terminal.value;
 
-            const tag = buildReference(name, isArray);
-
             if (s.result.type === 'Reference') {
               throw new Error('A reference must have a non-reference value');
             }
 
             if (s.node?.flags.token) {
-              throw new Error();
-            }
-
-            if (s.path.depth) {
-              s.node.resolver.consume(tag);
+              throw new Error('A token node cannot contain a reference');
             }
 
-            s.path = s.path.push(ctx, tag);
-            s.node = null;
-
-            ctx.tagPaths.set(tag, s.path);
-
-            yield* s.emit(tag);
-
-            returnValue = tag;
+            returnValue = s.advance(buildReference(name, isArray));
             break;
           }
 
@@ -149,18 +127,7 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
 
             if (reference?.type !== 'Reference') throw new Error();
 
-            const gapTag = buildGap();
-
-            s.held = null;
-
-            ctx.tagPaths.set(gapTag, s.path);
-
-            s.node = s.parentNode;
-            s.path = s.path.parent;
-
-            yield* s.emit(gapTag);
-
-            returnValue = gapTag;
+            returnValue = s.advance(buildGap());
             break;
           }
 
@@ -169,150 +136,39 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
 
             if (reference?.type !== 'Reference') throw new Error();
 
-            const null_ = buildNull();
-
-            ctx.tagPaths.set(null_, s.path);
-
-            s.node = s.parentNode;
-            s.path = s.path.parent;
-
-            yield* s.emit(null_);
-
-            returnValue = null_;
+            returnValue = s.advance(buildNull());
             break;
           }
 
           case 'Shift': {
-            const tag = buildShift();
-
-            const finishedNode = ctx.nodeForTag(s.result);
-            const ref = ctx.getPreviousTerminal(finishedNode.openTag);
-            const finishedPath = ctx.pathForTag(ref);
-
-            ctx.pathNodes.set(finishedPath, null);
+            const finishedNode = s.nodeForTag(s.result);
 
-            s.held = { node: finishedNode, path: finishedPath };
-
-            if (!finishedNode.openTag.value.flags.expression) {
+            if (!getOpenTag(finishedNode).value.flags.expression) {
               throw new Error();
             }
 
-            s.path = finishedPath;
-
-            yield* s.emit(tag);
-
-            returnValue = tag;
+            returnValue = s.advance(buildShift());
             break;
           }
 
           case 'OpenNodeTag': {
-            const { flags, language, type, intrinsicValue, attributes } = terminal.value;
-            const { unboundAttributes } = options || {};
-            const reference = s.result;
-            const openTag = buildNodeOpenTag(flags, language, type, intrinsicValue, attributes);
-
-            if (!type) {
-              s.node = Node.from(openTag);
-              ctx.pathNodes.set(s.path, s.node);
-              ctx.pathNodes.set(s.node, s.path);
-              ctx.tagNodes.set(openTag, s.node);
-              ctx.tagPaths.set(openTag, s.path);
-            } else {
-              if (!flags.trivia && !flags.escape) {
-                if (
-                  reference.type !== 'Reference' &&
-                  reference.type !== 'Shift' &&
-                  reference.type !== 'OpenFragmentTag'
-                ) {
-                  throw new Error('Invalid location for OpenNodeTag');
-                }
-              }
-
-              const newNode = new Node(openTag);
-
-              newNode.unboundAttributes = new Set(unboundAttributes);
-
-              s.node = newNode;
-              if (flags.trivia || flags.escape) {
-                s.path = s.path.push(ctx, null);
-              }
-
-              ctx.pathNodes.set(newNode, s.path);
-              ctx.pathNodes.set(s.path, newNode);
-              ctx.tagNodes.set(openTag, newNode);
-              ctx.tagPaths.set(openTag, s.path);
-
-              if (intrinsicValue) {
-                newNode.closeTag = newNode.openTag;
-                s.node = s.parentNode;
-                s.path = s.path.parent;
-
-                const { properties } = s.node;
-                const { name: refName, isArray } = reference.value;
-
-                if (!isArray) {
-                  properties.set(refName, [openTag, openTag]);
-                } else {
-                  if (!properties.has(refName)) {
-                    properties.set(refName, []);
-                  }
-                  properties.get(refName).push([openTag, openTag]);
-                }
-              }
-            }
+            const { flags, language, type, attributes } = terminal.value;
 
-            yield* s.emit(openTag);
+            if (language && !language.startsWith('https://')) {
+              throw new Error('Expected an absolute-language tag');
+            }
 
-            returnValue = openTag;
+            returnValue = s.advance(
+              buildNodeOpenTag(flags, language, type, attributes),
+              deembedExpression(options),
+            );
             break;
           }
 
           case 'CloseNodeTag': {
             const { type, language } = terminal.value;
-            const { openTag } = s.node;
-            const { flags, type: openType } = openTag.value;
-
-            const closeTag = buildNodeCloseTag(type, language);
-
-            if (openType) {
-              if (s.node.unboundAttributes?.size)
-                throw new Error('Grammar failed to bind all attributes');
-
-              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 (!flags.escape && !flags.trivia) {
-                const { name: refName, isArray } = s.path.reference.value;
-
-                const { properties } = ctx.nodeForPath(s.path.parent);
 
-                if (!isArray) {
-                  properties.set(refName, [openTag, closeTag]);
-                } else {
-                  if (!properties.has(refName)) {
-                    properties.set(refName, []);
-                  }
-                  properties.get(refName).push([openTag, closeTag]);
-                }
-              }
-
-              ctx.tagNodes.set(closeTag, s.node);
-              ctx.tagPaths.set(closeTag, s.path);
-
-              s.node.closeTag = closeTag;
-
-              s.node = s.parentNode;
-
-              s.path = s.path.parent;
-            }
-
-            yield* s.emit(closeTag, flags.expression);
-
-            returnValue = closeTag;
+            returnValue = s.advance(buildNodeCloseTag(type, language));
             break;
           }
 
@@ -320,19 +176,21 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
             throw new Error();
         }
 
+        yield* s.emit();
+
         break;
       }
 
       case 'bindAttribute': {
         const { 0: key, 1: value } = args;
 
-        const { unboundAttributes } = s.node;
+        const { unboundAttributes } = s;
 
         if (!unboundAttributes || !unboundAttributes.has(key)) {
           throw new Error('No unbound attribute to bind');
         }
 
-        if (!s.node.openTag.value.type) {
+        if (!s.node.type) {
           throw new Error('Cannot bind attribute to fragment');
         }
 
@@ -349,12 +207,12 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
 
         unboundAttributes.delete(key);
 
-        const { openTag } = s.node;
+        const openTag = s.node.children[0];
 
         if (value != null) {
-          const { flags, language, type, intrinsicValue } = openTag.value;
+          const { flags, language, type } = openTag.value;
           const attributes = { ...openTag.value.attributes, [key]: value };
-          const newOpenTag = buildNodeOpenTag(flags, language, type, intrinsicValue, attributes);
+          const newOpenTag = buildNodeOpenTag(flags, language, type, attributes);
 
           let openNext = ctx.nextTerminals.get(openTag);
           let startPrev = ctx.prevTerminals.get(openTag);
@@ -362,7 +220,13 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
           ctx.prevTerminals.set(newOpenTag, startPrev);
           ctx.nextTerminals.set(startPrev, newOpenTag);
 
-          ctx.tagNodes.set(newOpenTag, ctx.tagNodes.get(openTag));
+          if (s.node !== s.tagNodes.get(openTag)) throw new Error();
+          if (s.path !== s.tagPaths.get(openTag)) throw new Error();
+
+          s.node.attributes = attributes;
+
+          s.tagNodes.set(newOpenTag, s.node);
+          s.tagPaths.set(newOpenTag, s.path);
 
           if (openNext) {
             ctx.nextTerminals.set(newOpenTag, openNext);
@@ -372,14 +236,14 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
             s.result = newOpenTag;
           }
 
-          s.node.openTag = newOpenTag;
+          s.node.children[0] = newOpenTag;
         }
 
         if (!unboundAttributes.size) {
           yield* s.emit();
         }
 
-        returnValue = s.node.openTag;
+        returnValue = getRange(s.node);
         break;
       }
 
@@ -408,8 +272,6 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
     co.advance(returnValue);
   }
 
-  s.path = s.path.parent;
-
   if (s.depth > 0) {
     throw new Error('Did not unwind state stack');
   }
@@ -417,4 +279,6 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
   if (s.path?.depth > 0) {
     throw new Error('Did not unwind path stack');
   }
+
+  return s.nodeForTag(s.result);
 };

package/lib/node.js

@@ -1,4 +1,4 @@
-import { Resolver } from '@bablr/agast-helpers/tree';
+import { getRange, getOpenTag, getCloseTag } from '@bablr/agast-helpers/tree';
 import { facades, actuals } from './facades.js';
 
 export const NodeFacade = class AgastNodeFacade {
@@ -15,15 +15,15 @@ export const NodeFacade = class AgastNodeFacade {
   }
 
   get range() {
-    return actuals.get(this).range;
+    return getRange(actuals.get(this));
   }
 
   get openTag() {
-    return actuals.get(this).openTag;
+    return getOpenTag(actuals.get(this));
   }
 
   get closeTag() {
-    return actuals.get(this).closeTag;
+    return getCloseTag(actuals.get(this));
   }
 
   get flags() {
@@ -34,66 +34,3 @@ export const NodeFacade = class AgastNodeFacade {
     return actuals.get(this).attributes;
   }
 };
-
-export const Node = class AgastNode {
-  static from(openTag) {
-    return new AgastNode(openTag);
-  }
-
-  constructor(
-    openTag,
-    closeTag = null,
-    properties = new Map(),
-    resolver = new Resolver(),
-    unboundAttributes = null,
-  ) {
-    this.openTag = openTag;
-    this.closeTag = closeTag;
-    this.properties = properties;
-    this.resolver = resolver;
-    this.unboundAttributes = unboundAttributes;
-  }
-
-  get language() {
-    return this.openTag.value?.language;
-  }
-
-  get type() {
-    return this.openTag.value?.type || null;
-  }
-
-  get flags() {
-    return this.openTag.value?.flags || {};
-  }
-
-  get attributes() {
-    return this.openTag.value?.attributes || {};
-  }
-
-  get range() {
-    return [this.openTag, this.closeTag];
-  }
-
-  branch() {
-    const { openTag, closeTag, properties, resolver, unboundAttributes } = this;
-
-    return new Node(
-      openTag,
-      closeTag,
-      new Map(properties), // there is probably a better way
-      resolver.branch(),
-      new Set(unboundAttributes),
-    );
-  }
-
-  accept(node) {
-    this.openTag = node.openTag;
-    this.closeTag = node.closeTag;
-    this.properties = node.properties;
-    this.unboundAttributes = node.unboundAttributes;
-
-    this.resolver.accept(node.resolver);
-
-    return this;
-  }
-};

package/lib/state.js

@@ -1,7 +1,58 @@
+import emptyStack from '@iter-tools/imm-stack';
 import { WeakStackFrame } from '@bablr/weak-stack';
-import { startsDocument } from '@bablr/agast-helpers/stream';
+import {
+  Resolver,
+  add,
+  createNode,
+  getOpenTag,
+  getCloseTag,
+  branchNode,
+  acceptNode,
+  finalizeNode,
+  getRoot,
+} from '@bablr/agast-helpers/tree';
+import {
+  buildBeginningOfStreamToken,
+  buildEmbeddedNode,
+  nodeFlags,
+} from '@bablr/agast-vm-helpers/internal-builders';
+import * as sym from '@bablr/agast-helpers/symbols';
 import { facades, actuals } from './facades.js';
-import { buildBeginningOfStreamToken } from '@bablr/agast-helpers/builders';
+import { Path } from './path.js';
+
+const { hasOwn } = Object;
+
+const arrayLast = (arr) => arr[arr.length - 1];
+
+const createNodeWithState = (startTag, options = {}) => {
+  const { unboundAttributes } = options;
+  const node = createNode(startTag);
+  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) {
@@ -43,41 +94,96 @@ export const StateFacade = class AgastStateFacade {
   get ctx() {
     return this.context;
   }
+
+  nodeForPath(path) {
+    return actuals.get(this).nodeForPath(path);
+  }
+
+  pathForTag(tag) {
+    return actuals.get(this).pathForTag(tag);
+  }
+
+  nodeForTag(tag) {
+    return actuals.get(this).nodeForTag(tag);
+  }
 };
 
+export const nodeStates = new WeakMap();
+
 export const State = class AgastState extends WeakStackFrame {
   constructor(
     context,
+    expressions = emptyStack,
     path = null,
     node = null,
     result = buildBeginningOfStreamToken(),
     emitted = null,
     held = null,
+    internalContext = {
+      pathNodes: new WeakMap(),
+      tagPaths: new WeakMap(),
+      tagNodes: new WeakMap(),
+    },
   ) {
     super();
 
     if (!context) throw new Error('invalid args to tagState');
 
     this.context = context;
+    this.expressions = expressions;
     this.path = path;
     this.node = node;
     this.result = result;
     this.emitted = emitted;
     this.held = held;
+    this.internalContext = internalContext;
 
     new StateFacade(this);
   }
 
-  static from(context) {
-    return State.create(context, null);
+  static from(context, expressions = []) {
+    return State.create(context, emptyStack.push(...[...expressions].reverse()));
+  }
+
+  get pathNodes() {
+    return this.internalContext.pathNodes;
+  }
+
+  get tagPaths() {
+    return this.internalContext.tagPaths;
+  }
+
+  get tagNodes() {
+    return this.internalContext.tagNodes;
+  }
+
+  get unboundAttributes() {
+    return nodeStates.get(this.node).unboundAttributes;
+  }
+
+  get resolver() {
+    return nodeStates.get(this.node).resolver;
   }
 
   get holding() {
     return !!this.held;
   }
 
-  *emit(terminal, suppressEmit) {
-    const { prevTerminals, nextTerminals } = this.context;
+  nodeForPath(path) {
+    return this.pathNodes.get(path);
+  }
+
+  pathForTag(ref) {
+    return this.tagPaths.get(ref);
+  }
+
+  nodeForTag(tag) {
+    return this.tagNodes.get(tag);
+  }
+
+  advance(terminal, options = {}) {
+    const ctx = this.context;
+    const { prevTerminals, nextTerminals } = ctx;
 
     if (terminal) {
       if (prevTerminals.has(terminal)) {
@@ -94,24 +200,203 @@ export const State = class AgastState extends WeakStackFrame {
       prevTerminals.set(terminal, this.result);
       nextTerminals.set(this.result, terminal);
 
-      this.result = terminal;
+      switch (terminal.type) {
+        case 'DoctypeTag': {
+          this.path = Path.from(ctx, terminal);
+
+          this.tagPaths.set(terminal, this.path);
+          break;
+        }
+
+        case 'OpenNodeTag': {
+          const openTag = terminal;
+          const { type, flags } = terminal.value;
+          this.node = createNodeWithState(terminal, options);
+
+          const reference = this.result;
+
+          this.node.children.push(terminal);
+
+          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);
+            }
+          }
+
+          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 = this.node.children[0];
+          const { flags, type: openType } = openTag.value;
+          const closeTag = terminal;
+          const { type } = closeTag.value;
+
+          this.node.children.push(terminal);
+
+          if (openType) {
+            if (this.node.unboundAttributes?.size)
+              throw new Error('Grammar failed to bind all attributes');
+
+            if (!type) throw new Error(`CloseNodeTag must have type`);
 
-      if (!this.emitted) {
-        if (!startsDocument(terminal)) throw new Error();
-        this.emitted = terminal;
-        yield terminal;
+            if (type !== openType)
+              throw new Error(
+                `Grammar close {type: ${type}} did not match open {type: ${openType}}`,
+              );
+
+            if (!flags.escape && !flags.trivia) {
+              const { name: refName, isArray } = this.path.reference.value;
+
+              const { properties } = this.parentNode;
+
+              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));
+            }
+          }
+
+          this.tagNodes.set(closeTag, this.node);
+          this.tagPaths.set(closeTag, this.path);
+
+          finalizeNode(this.node);
+
+          this.node = this.parentNode;
+          this.path = this.path.parent;
+          break;
+        }
+
+        case 'Reference': {
+          if (this.path.depth) {
+            nodeStates.get(this.node).resolver.consume(terminal);
+          }
+
+          this.node.children.push(terminal);
+
+          this.path = this.path.push(ctx, terminal);
+
+          this.tagPaths.set(terminal, this.path);
+          break;
+        }
+
+        case 'Gap': {
+          this.tagPaths.set(terminal, this.path);
+
+          let target;
+          let ref = arrayLast(this.node.children);
+
+          if (ref.type !== 'Reference') 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);
+          }
+
+          this.pathNodes.set(this.pathForTag(ref), target);
+          add(this.node, ref, target);
+
+          this.path = this.path.parent;
+          break;
+        }
+
+        case 'Null': {
+          this.tagPaths.set(terminal, this.path);
+
+          const { properties } = this.node;
+          const { isArray, name } = this.result.value;
+
+          const newNode = buildStubNode(terminal);
+
+          if (!hasOwn(properties, name)) {
+            // TODO is this behavior right
+            properties[name] = isArray ? [] : newNode;
+          }
+
+          this.pathNodes.set(this.path, newNode);
+
+          this.path = this.path.parent;
+          break;
+        }
+
+        case 'Shift': {
+          const finishedNode = this.nodeForTag(this.result);
+          const ref = ctx.getPreviousTerminal(getOpenTag(finishedNode));
+          const finishedPath = this.pathForTag(ref);
+          const { properties } = this.node;
+
+          this.pathNodes.set(finishedPath, null);
+
+          this.held = { node: finishedNode, path: finishedPath };
+
+          let node = properties[ref.value.name];
+
+          if (ref.value.isArray) {
+            node = arrayLast(node);
+            properties[ref.value.name].pop();
+          } else {
+            properties[ref.value.name] = null;
+          }
+
+          this.path = finishedPath;
+          break;
+        }
+
+        case 'Literal': {
+          this.node.children.push(terminal);
+          break;
+        }
+
+        default:
+          throw new Error();
       }
     }
 
-    if (!this.depth && !suppressEmit) {
-      let emittable = nextTerminals.get(this.emitted);
+    this.result = terminal;
+
+    return terminal;
+  }
+
+  *emit() {
+    const { nextTerminals } = this.context;
+    if (!this.depth) {
+      let emittable = this.emitted ? nextTerminals.get(this.emitted) : this.result;
 
       while (
         emittable &&
         !(
           emittable.type === 'OpenNodeTag' &&
           emittable.value.type &&
-          this.context.nodeForTag(emittable).unboundAttributes?.size
+          nodeStates.get(this.nodeForTag(emittable)).unboundAttributes?.size
         )
       ) {
         yield emittable;
@@ -119,8 +404,6 @@ export const State = class AgastState extends WeakStackFrame {
         emittable = nextTerminals.get(this.emitted);
       }
     }
-
-    return terminal;
   }
 
   get ctx() {
@@ -136,38 +419,47 @@ export const State = class AgastState extends WeakStackFrame {
   }
 
   get parentNode() {
-    return this.ctx.nodeForPath(this.path.parent);
+    return this.pathNodes.get(this.path.parent);
   }
 
   branch() {
-    const { context, path, node, result, emitted, held } = this;
+    const { context, expressions, path, node, result, emitted, held, internalContext } = this;
+    const { pathNodes } = internalContext;
+
+    const newNode = node && branchNode(node);
+
+    const nodeState = nodeStates.get(node);
 
-    const newNode = node && node.branch();
+    pathNodes.set(path, newNode);
 
-    if (newNode?.openTag) context.tagNodes.set(newNode.openTag, newNode);
-    if (newNode?.closeTag) context.tagNodes.set(newNode.closeTag, newNode);
+    nodeStates.set(newNode, { ...nodeState, resolver: nodeState.resolver.branch() });
 
-    return this.push(context, path, newNode, result, emitted, held);
+    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);
   }
 
   accept() {
-    const { parent, context } = this;
+    const { parent } = this;
 
     if (!parent) {
       return null;
     }
 
     if (this.node && parent.node) {
-      parent.node.accept(this.node, context);
+      acceptNode(parent.node, this.node);
+      const nodeState = nodeStates.get(this.node);
+      Object.assign(nodeStates.get(parent.node), nodeState);
     } else {
       parent.node = this.node;
     }
 
-    if (this.node?.openTag) context.tagNodes.set(parent.node.openTag, parent.node);
-    if (this.node?.closeTag) context.tagNodes.set(parent.node.closeTag, parent.node);
-
     // emitted isn't used here and probably doesn't need to be part of state
 
+    parent.expressions = this.expressions;
     parent.result = this.result;
     parent.held = this.held;
     parent.path = this.path;
@@ -176,12 +468,17 @@ export const State = class AgastState extends WeakStackFrame {
   }
 
   reject() {
-    const { parent, context } = this;
+    const { parent, context, pathNodes, tagNodes } = this;
 
     if (!parent) throw new Error('rejected root state');
 
     context.nextTerminals.delete(parent.result);
 
+    pathNodes.set(parent.path, parent.node);
+
+    if (getOpenTag(parent.node)) tagNodes.set(getOpenTag(parent.node), parent.node);
+    if (getCloseTag(parent.node)) tagNodes.set(getCloseTag(parent.node), parent.node);
+
     return parent;
   }
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-vm",
   "description": "A VM providing DOM-like guarantees about agAST trees",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -12,10 +12,11 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.2.0",
-    "@bablr/agast-vm-helpers": "0.2.0",
+    "@bablr/agast-helpers": "0.3.0",
+    "@bablr/agast-vm-helpers": "0.3.0",
     "@bablr/coroutine": "0.1.0",
-    "@bablr/weak-stack": "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",