@bablr/agast-vm 0.6.1 → 0.7.0

package/lib/context.js

@@ -1,31 +1,15 @@
-import { reifyExpressionShallow, reifyExpression } from '@bablr/agast-vm-helpers';
-import {
-  getCooked as getCookedFromTree,
-  sourceTextFor as sourceTextForTree,
-} from '@bablr/agast-helpers/tree';
-import { getCooked as getCookedFromStream } from '@bablr/agast-helpers/stream';
-import { OpenNodeTag, CloseNodeTag } from '@bablr/agast-helpers/symbols';
-import { facades, actuals } from './facades.js';
-
-const { isArray } = Array;
-
-function* allTagsFor(range, nextTags) {
-  if (!range) return;
-  const { 0: start, 1: end } = range;
-
-  const pastEnd = nextTags.get(end);
+import { reifyExpression } from '@bablr/agast-vm-helpers';
+import { sourceTextFor as sourceTextForTree } from '@bablr/agast-helpers/tree';
 
-  for (let tag = start; tag && tag !== pastEnd; tag = nextTags.get(tag)) {
-    yield tag;
-  }
-}
+import { allTagPathsFor } from './path.js';
+import { facades, actuals } from './facades.js';
 
 export const ContextFacade = class AgastContextFacade {
-  getPreviousTag(token) {
+  getPreviousTagPath(token) {
     return actuals.get(this).prevTags.get(token);
   }
 
-  getNextTag(token) {
+  getNextTagPath(token) {
     return actuals.get(this).nextTags.get(token);
   }
 
@@ -33,10 +17,6 @@ export const ContextFacade = class AgastContextFacade {
     return actuals.get(this).allTagsFor(range);
   }
 
-  getCooked(range) {
-    return actuals.get(this).getCooked(range);
-  }
-
   reifyExpression(range) {
     return actuals.get(this).reifyExpression(range);
   }
@@ -52,10 +32,6 @@ export const ContextFacade = class AgastContextFacade {
   nodeForTag(tag) {
     return actuals.get(this).nodeForTag(tag);
   }
-
-  unbox(value) {
-    return actuals.get(this).unbox(value);
-  }
 };
 
 export const Context = class AgastContext {
@@ -64,42 +40,18 @@ export const Context = class AgastContext {
   }
 
   constructor() {
-    this.prevTags = new WeakMap();
-    this.nextTags = new WeakMap();
     this.tagNodes = new WeakMap();
-    this.unboxedValues = new WeakMap();
     this.facade = new ContextFacade();
 
     facades.set(this, this.facade);
   }
 
-  isEmpty(range) {
-    const { path, parent } = this;
-
-    if (range[0]?.type === OpenNodeTag && path !== parent.path) {
-      const nextTag = this.nextTags.get(range[0]);
-      if (!nextTag || nextTag.type === CloseNodeTag) {
-        return null;
-      }
-    } else {
-      return range[0] === range[1];
-    }
-  }
-
   allTagsFor(range) {
-    return allTagsFor(range, this.nextTags);
+    return allTagPathsFor(range);
   }
 
   allTagsReverseFor(range) {
-    return allTagsFor([...range].reverse(), this.prevTags);
-  }
-
-  getPreviousTag(token) {
-    return this.prevTags.get(token);
-  }
-
-  getNextTag(token) {
-    return this.nextTags.get(token);
+    throw new Error('not implemented');
   }
 
   nodeForTag(tag) {
@@ -130,22 +82,7 @@ export const Context = class AgastContext {
     return start ? [start, end] : null;
   }
 
-  unbox(value) {
-    const { unboxedValues } = this;
-    if (!unboxedValues.has(value)) {
-      unboxedValues.set(value, reifyExpressionShallow(value));
-    }
-
-    return unboxedValues.get(value);
-  }
-
   reifyExpression(value) {
     return reifyExpression(value);
   }
-
-  getCooked(nodeOrRange) {
-    return isArray(nodeOrRange)
-      ? getCookedFromStream(this.allTagsFor(nodeOrRange))
-      : getCookedFromTree(nodeOrRange);
-  }
 };

package/lib/evaluate.js

@@ -5,21 +5,14 @@ import {
   buildShiftTag,
   buildReferenceTag,
   buildLiteralTag,
-  buildWriteEffect,
   buildDoctypeTag,
-  buildNodeOpenTag,
-  buildNodeCloseTag,
+  buildOpenNodeTag,
+  buildCloseNodeTag,
 } from '@bablr/agast-vm-helpers/internal-builders';
-import { getEmbeddedExpression } from '@bablr/agast-vm-helpers/deembed';
+import { getEmbeddedTag } from '@bablr/agast-vm-helpers/deembed';
 import { StreamIterable, getStreamIterator } from '@bablr/agast-helpers/stream';
 import { printExpression } from '@bablr/agast-helpers/print';
-import {
-  getRange,
-  getOpenTag,
-  buildArrayTag,
-  buildFragmentCloseTag,
-  buildFragmentOpenTag,
-} from '@bablr/agast-helpers/tree';
+import { buildArrayInitializerTag } from '@bablr/agast-helpers/tree';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -28,22 +21,22 @@ import {
   ShiftTag,
   GapTag,
   NullTag,
-  ArrayTag,
+  ArrayInitializerTag,
   LiteralTag,
-  CloseFragmentTag,
-  OpenFragmentTag,
 } from '@bablr/agast-helpers/symbols';
-import * as btree from '@bablr/agast-helpers/btree';
 import { State } from './state.js';
+import { Context } from './context.js';
 import { facades } from './facades.js';
 
-export const evaluate = (ctx, strategy, options) =>
-  new StreamIterable(__evaluate(ctx, strategy, options));
-
-const __evaluate = function* agast(ctx, strategy, options = {}) {
+export const agast = (strategy, options = {}) => {
+  const ctx = Context.create();
   let s = State.from(ctx, options.expressions);
 
-  const co = new Coroutine(getStreamIterator(strategy(facades.get(ctx), facades.get(s))));
+  return new StreamIterable(__agast(ctx, s, strategy(facades.get(ctx), facades.get(s))));
+};
+
+function* __agast(ctx, s, instructions) {
+  const co = new Coroutine(getStreamIterator(instructions));
 
   co.advance();
 
@@ -61,35 +54,10 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
     const { verb, arguments: args = [] } = instr;
 
     switch (verb) {
-      case 'branch': {
-        s = s.branch();
-
-        returnValue = facades.get(s);
-        break;
-      }
-
-      case 'accept': {
-        s = s.accept();
-
-        if (s.depth === 0) {
-          yield* s.emit(options);
-        }
-
-        returnValue = facades.get(s);
-        break;
-      }
-
-      case 'reject': {
-        s = s.reject();
-
-        returnValue = facades.get(s);
-        break;
-      }
-
       case 'advance': {
-        const { 0: embeddedTag, 1: advanceOptions } = args;
+        const { 0: embeddedTags } = args;
 
-        const tag = embeddedTag.value;
+        const tag = getEmbeddedTag(embeddedTags);
 
         if (
           s.held &&
@@ -102,7 +70,7 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
           case DoctypeTag: {
             const { attributes } = tag.value;
 
-            if (s.path) {
+            if (s.path.depth !== 0) {
               throw new Error();
             }
 
@@ -124,56 +92,47 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
           }
 
           case ReferenceTag: {
-            const { name, isArray, hasGap } = tag.value;
+            const { name, isArray, flags } = tag.value;
 
-            if (s.result.type === ReferenceTag) {
-              throw new Error('A reference must have a non-reference value');
-            }
-
-            if (s.node?.flags.token) {
+            if (s.node?.flags.token && name !== '@') {
               throw new Error('A token node cannot contain a reference');
             }
 
-            returnValue = s.advance(buildReferenceTag(name, isArray, hasGap));
+            returnValue = s.advance(buildReferenceTag(name, isArray, flags));
             break;
           }
 
           case GapTag: {
-            const reference = s.result;
-
-            if (reference?.type !== ReferenceTag) throw new Error();
-
             returnValue = s.advance(buildGapTag());
             break;
           }
 
           case NullTag: {
-            const reference = s.result;
-
-            if (reference?.type !== ReferenceTag) throw new Error();
-
             returnValue = s.advance(buildNullTag());
             break;
           }
 
-          case ArrayTag: {
-            const reference = s.result;
+          case ArrayInitializerTag: {
+            const { reference } = s;
 
             if (reference?.type !== ReferenceTag) throw new Error();
             if (!reference.value.isArray) throw new Error();
 
-            returnValue = s.advance(buildArrayTag());
+            returnValue = s.advance(buildArrayInitializerTag());
             break;
           }
 
           case ShiftTag: {
-            const finishedNode = s.nodeForTag(s.result);
+            const { index } = tag.value;
+            if (s.resultPath.tag.type !== GapTag) throw new Error();
+
+            const refPath = s.resultPath.previousSibling;
 
-            if (!getOpenTag(finishedNode).value.flags.expression) {
+            if (!refPath.tag.value.flags.expression) {
               throw new Error();
             }
 
-            returnValue = s.advance(buildShiftTag());
+            returnValue = s.advance(buildShiftTag(index));
             break;
           }
 
@@ -184,32 +143,12 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
               throw new Error('Expected an absolute-language tag');
             }
 
-            returnValue = s.advance(
-              buildNodeOpenTag(flags, language, type, attributes),
-              getEmbeddedExpression(advanceOptions),
-            );
-            break;
-          }
-
-          case OpenFragmentTag: {
-            const { flags } = tag.value;
-
-            returnValue = s.advance(
-              buildFragmentOpenTag(flags),
-              getEmbeddedExpression(advanceOptions),
-            );
+            returnValue = s.advance(buildOpenNodeTag(flags, language, type, attributes));
             break;
           }
 
           case CloseNodeTag: {
-            const { type, language } = tag.value;
-
-            returnValue = s.advance(buildNodeCloseTag(type, language));
-            break;
-          }
-
-          case CloseFragmentTag: {
-            returnValue = s.advance(buildFragmentCloseTag());
+            returnValue = s.advance(buildCloseNodeTag());
             break;
           }
 
@@ -217,90 +156,11 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
             throw new Error();
         }
 
-        yield* s.emit(options);
+        yield returnValue;
 
         break;
       }
 
-      case 'bindAttribute': {
-        const { 0: key, 1: value } = args;
-
-        const { unboundAttributes } = s;
-
-        if (!unboundAttributes || !unboundAttributes.has(key)) {
-          throw new Error('No unbound attribute to bind');
-        }
-
-        if (!s.node.type) {
-          throw new Error('Cannot bind attribute to fragment');
-        }
-
-        if (key === 'span') throw new Error('too late');
-
-        // if (stateIsDifferent) {
-        //   // we can't allow effects to cross state branches
-        //   throw new Error();
-        // }
-
-        unboundAttributes.delete(key);
-
-        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.nextTags.get(openTag);
-          let startPrev = ctx.prevTags.get(openTag);
-
-          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();
-
-          s.node.attributes = attributes;
-
-          s.tagNodes.set(newOpenTag, s.node);
-          s.tagPaths.set(newOpenTag, s.path);
-
-          if (openNext) {
-            ctx.nextTags.set(newOpenTag, openNext);
-            ctx.prevTags.set(openNext, newOpenTag);
-          } else {
-            // could this tag be stored anywhere else?
-            s.result = newOpenTag;
-          }
-
-          s.node.children = btree.replaceAt(0, s.node.children, newOpenTag);
-        }
-
-        if (!unboundAttributes.size) {
-          yield* s.emit(options);
-        }
-
-        returnValue = getRange(s.node);
-        break;
-      }
-
-      case 'getState': {
-        returnValue = facades.get(s);
-        break;
-      }
-
-      case 'getContext': {
-        returnValue = facades.get(ctx);
-        break;
-      }
-
-      case 'write': {
-        if (options.emitEffects) {
-          yield buildWriteEffect(args[0], args[1].value);
-        }
-        break;
-      }
-
       default: {
         throw new Error(`Unexpected call of {type: ${printExpression(verb)}}`);
       }
@@ -313,9 +173,9 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
     throw new Error('Did not unwind state stack');
   }
 
-  if (s.path?.depth > 0) {
+  if (s.path) {
     throw new Error('Did not unwind path stack');
   }
 
-  return s.nodeForTag(s.result);
-};
+  return s.resultPath.path.node;
+}

package/lib/index.js

@@ -1,3 +1,3 @@
-export { evaluate } from './evaluate.js';
+export { agast } from './evaluate.js';
 
 export { Context } from './context.js';

package/lib/path.js

@@ -1,76 +1,3 @@
-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';
+export { Path } from '@bablr/agast-helpers/path';
 
-export const PathFacade = class AgastPathFacade {
-  constructor(path) {
-    facades.set(path, this);
-  }
-
-  get reference() {
-    return actuals.get(this).reference;
-  }
-
-  get parent() {
-    return facades.get(actuals.get(this).parent);
-  }
-
-  get depth() {
-    return actuals.get(this).depth;
-  }
-
-  at(depth) {
-    return facades.get(actuals.get(this).at(depth));
-  }
-
-  *parents(includeSelf = false) {
-    if (includeSelf) yield this;
-    let parent = this;
-    while ((parent = parent.parent)) {
-      yield parent;
-    }
-  }
-};
-
-export const Path = class AgastPath extends WeakStackFrame {
-  static from(context, tag, childrenIndex) {
-    return Path.create(context, tag, childrenIndex);
-  }
-
-  constructor(context, reference, childrenIndex = -1) {
-    super();
-
-    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);
-
-    new PathFacade(this);
-  }
-
-  get name() {
-    return this.reference?.value.name;
-  }
-
-  get isArray() {
-    return this.reference?.value.isArray || false;
-  }
-
-  at(depth) {
-    return skipToDepth(depth, this);
-  }
-
-  *parents(includeSelf = false) {
-    if (includeSelf) yield this;
-    let parent = this;
-    while ((parent = parent.parent)) {
-      yield parent;
-    }
-  }
-};
+export { allTagPathsFor, ownTagPathsFor } from '@bablr/agast-helpers/path';

package/lib/state.js

@@ -1,25 +1,18 @@
-import emptyStack from '@iter-tools/imm-stack';
+import isArray from 'iter-tools-es/methods/is-array';
 import { WeakStackFrame } from '@bablr/weak-stack';
 import {
   Resolver,
   add,
-  createNode,
-  getOpenTag,
-  getCloseTag,
-  branchNode,
-  acceptNode,
   finalizeNode,
   getRoot,
-  printType,
   buildStubNode,
+  getRange,
+  buildNullTag,
+  treeFromStream,
+  createNode,
 } from '@bablr/agast-helpers/tree';
 import * as btree from '@bablr/agast-helpers/btree';
-import {
-  buildBeginningOfStreamToken,
-  buildEmbeddedNode,
-  buildEffect,
-  buildYieldEffect,
-} from '@bablr/agast-vm-helpers/internal-builders';
+import { TagPath, updatePath } from '@bablr/agast-helpers/path';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -28,25 +21,12 @@ import {
   ShiftTag,
   GapTag,
   NullTag,
-  ArrayTag,
+  ArrayInitializerTag,
   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 createNodeWithState = (openTag, options = {}) => {
-  const { unboundAttributes } = options;
-  const node = createNode(openTag);
-  nodeStates.set(node, {
-    unboundAttributes: new Set(unboundAttributes || []),
-  });
-  return node;
-};
+import { Coroutine } from '@bablr/coroutine';
 
 export const StateFacade = class AgastStateFacade {
   constructor(state) {
@@ -57,8 +37,16 @@ export const StateFacade = class AgastStateFacade {
     return State.from(actuals.get(context));
   }
 
-  get result() {
-    return actuals.get(this).result;
+  get resultPath() {
+    return actuals.get(this).resultPath;
+  }
+
+  get reference() {
+    return actuals.get(this).reference;
+  }
+
+  get referencePath() {
+    return actuals.get(this).referencePath;
   }
 
   get context() {
@@ -66,7 +54,7 @@ export const StateFacade = class AgastStateFacade {
   }
 
   get path() {
-    return facades.get(actuals.get(this).path);
+    return actuals.get(this).path;
   }
 
   get node() {
@@ -89,16 +77,8 @@ export const StateFacade = class AgastStateFacade {
     return this.context;
   }
 
-  nodeForPath(path) {
-    return actuals.get(this).nodeForPath(actuals.get(path));
-  }
-
-  pathForTag(tag) {
-    return facades.get(actuals.get(this).pathForTag(tag));
-  }
-
-  nodeForTag(tag) {
-    return actuals.get(this).nodeForTag(tag);
+  get parent() {
+    return facades.get(actuals.get(this).parent);
   }
 };
 
@@ -106,346 +86,230 @@ export const nodeStates = new WeakMap();
 
 export const State = class AgastState extends WeakStackFrame {
   constructor(
+    parent,
     context,
-    expressions = emptyStack,
-    path = null,
-    node = null,
-    result = buildBeginningOfStreamToken(),
-    emitted = null,
+    expressions = [],
+    path = Path.from(createNode()),
     held = null,
+    resultPath = null,
     resolver = new Resolver(),
-    internalContext = {
-      pathNodes: new WeakMap(),
-      tagPaths: new WeakMap(),
-      tagNodes: new WeakMap(),
-    },
   ) {
-    super();
+    super(parent);
 
-    if (!context) throw new Error('invalid args to tagState');
+    if (!context || !path || !expressions) throw new Error('invalid args to tagState');
 
     this.context = context;
-    this.expressions = expressions;
+    this.expressions = new Coroutine(expressions[Symbol.iterator]());
     this.path = path;
-    this.node = node;
-    this.result = result;
-    this.emitted = emitted;
     this.held = held;
+    this.resultPath = resultPath;
     this.resolver = resolver;
-    this.internalContext = internalContext;
+
+    if (!this.node) throw new Error();
 
     new StateFacade(this);
   }
 
   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.context.tagNodes;
-  }
-
-  get unboundAttributes() {
-    return nodeStates.get(this.node).unboundAttributes;
+    return State.create(context, expressions);
   }
 
   get holding() {
     return !!this.held;
   }
 
-  nodeForPath(path) {
-    return this.pathNodes.get(path);
-  }
-
-  pathForTag(ref) {
-    return this.tagPaths.get(ref);
-  }
-
-  nodeForTag(tag) {
-    return this.tagNodes.get(tag);
-  }
-
-  advance(tag, options = {}) {
+  advance(tag) {
     const ctx = this.context;
-    const { prevTags, nextTags } = ctx;
 
-    if (tag) {
-      if (prevTags.has(tag)) {
-        throw new Error('Double emit');
-      }
+    if (!tag) throw new Error();
 
-      if (
-        this.result?.type === ReferenceTag &&
-        ![OpenNodeTag, GapTag, NullTag, ArrayTag].includes(tag.type)
-      ) {
-        throw new Error(`${printType(tag.type)} is not a valid reference target`);
-      }
-
-      prevTags.set(tag, this.result);
-      nextTags.set(this.result, tag);
+    let targetPath = this.path;
 
-      this.resolver.advance(tag);
+    switch (tag.type) {
+      case DoctypeTag: {
+        const { path, node } = this;
 
-      switch (tag.type) {
-        case DoctypeTag: {
-          this.path = Path.from(ctx, tag);
+        node.children = btree.push(node.children, tag);
+        node.attributes = tag.value.attributes;
 
-          this.tagPaths.set(tag, this.path);
-          break;
-        }
+        this.resolver.advance(tag);
+        updatePath(this.path, tag);
 
-        case OpenNodeTag: {
-          const openTag = tag;
-          const { flags } = tag.value;
-          this.node = createNodeWithState(tag, options);
-
-          const reference = this.result;
+        targetPath = path;
+        break;
+      }
 
-          this.node.children = btree.push(this.node.children, tag);
+      case ReferenceTag: {
+        this.resolver.advance(tag);
 
-          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.node.children = btree.push(this.node.children, tag);
+        updatePath(this.path, tag);
 
-          this.pathNodes.set(this.node, this.path);
-          this.pathNodes.set(this.path, this.node);
+        const { hasGap } = tag.value;
 
-          this.tagNodes.set(openTag, this.node);
-          this.tagPaths.set(openTag, this.path);
-          break;
+        if (hasGap && !this.node.flags.hasGap) {
+          throw new Error('gap reference in gapless node');
         }
 
-        case OpenFragmentTag: {
-          const openTag = tag;
-          this.node = createNodeWithState(tag, options);
+        break;
+      }
 
-          const reference = this.result;
+      case OpenNodeTag: {
+        const parentNode = this.node;
 
-          this.node.attributes = this.result.value.attributes;
-          this.node.children = btree.push(this.node.children, reference);
+        targetPath = this.path;
 
+        if (!this.path.depth) {
+          this.node.flags = tag.value.flags;
           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;
+          this.node.type = tag.value.type;
+          this.node.language = tag.value.language;
+          this.node.attributes = tag.value.attributes || {};
+        } else {
+          let node = createNode(tag);
+          this.path = this.path.push(node, btree.getSum(parentNode.children) - 2);
+          add(parentNode, this.reference, node);
         }
 
-        case CloseNodeTag: {
-          const openTag = getOpenTag(this.node);
-          const { flags, type: openType } = openTag.value;
-          const closeTag = tag;
-          const { type } = closeTag.value;
-
-          this.node.children = btree.push(this.node.children, tag);
-
-          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 !== openType)
-            throw new Error(
-              `Grammar close {type: ${printType(type)}} did not match open {type: ${printType(
-                openType,
-              )}}`,
-            );
-
-          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),
-            );
-          }
+        this.resolver.advance(tag);
+        updatePath(this.path, tag);
 
-          this.tagNodes.set(closeTag, this.node);
-          this.tagPaths.set(closeTag, this.path);
-
-          finalizeNode(this.node);
+        break;
+      }
 
-          this.node = this.parentNode;
-          this.path = this.path.parent;
-          break;
-        }
+      case CloseNodeTag: {
+        this.resolver.advance(tag);
+        this.node.children = btree.push(this.node.children, tag);
+        updatePath(this.path, tag);
 
-        case CloseFragmentTag: {
-          const closeTag = tag;
+        if (this.node.unboundAttributes?.size)
+          throw new Error('Grammar failed to bind all attributes');
 
-          this.node.children = btree.push(this.node.children, tag);
+        finalizeNode(this.node);
 
-          this.tagNodes.set(closeTag, this.node);
-          this.tagPaths.set(closeTag, this.path);
+        this.path = this.path.parent;
+        break;
+      }
 
-          finalizeNode(this.node);
+      case GapTag: {
+        let target;
+        let lastTagPath = TagPath.from(this.path, -1);
+        let refPath = lastTagPath;
 
-          this.node = this.parentNode;
-          this.path = this.path.parent;
-          break;
+        while (refPath && refPath.tag.type !== ReferenceTag) {
+          refPath = refPath.previousSibling;
         }
 
-        case ReferenceTag: {
-          this.node.children = btree.push(this.node.children, tag);
-
-          const { isArray, name, hasGap } = tag.value;
-
-          if (hasGap && !this.node.flags.hasGap) {
-            throw new Error('gap reference in gapless node');
-          }
+        this.resolver.advance(tag);
 
-          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;
-        }
+        let wasHeld = this.held;
 
-        case GapTag: {
-          this.tagPaths.set(tag, this.path);
+        if (this.held && lastTagPath.tag.type !== ShiftTag) {
+          target = this.held.node;
 
-          let target;
-          let ref = btree.getAt(-1, this.node.children);
+          this.held = null;
+        } else if (refPath) {
+          this.expressions.advance();
 
-          if (ref.type !== ReferenceTag) throw new Error();
+          if (!this.expressions.done) {
+            const expression = this.expressions.value;
 
-          if (this.held) {
-            target = this.held.node;
+            if (isArray(expression)) {
+              throw new Error('Invalid array interpolation');
+            }
 
-            this.held = null;
+            if (expression == null) {
+              target = treeFromStream(buildNullTag());
+            } else {
+              target = getRoot(expression);
+            }
           } else {
             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);
+            target = buildStubNode(tag);
+          }
 
-                this.expressions = this.expressions.pop();
-              }
+          this.held = null;
+        } else {
+          this.node.language = null;
+          this.node.type = null;
+          target = this.node;
+        }
 
-              // const range = ctx.buildRange(streamFromTree(target));
+        const range = getRange(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.resultPath = range ? range[1] : this.resultPath;
 
-          this.tagNodes.set(tag, target);
+        if (refPath) {
+          add(this.path.node, refPath.tag, target, wasHeld);
+        }
 
-          this.pathNodes.set(this.pathForTag(ref), target);
-          add(this.node, ref, target);
+        updatePath(this.path, tag);
+        break;
+      }
 
-          this.path = this.path.parent;
-          break;
-        }
+      case NullTag: {
+        const { node: parentNode, reference } = this;
+        const { name } = reference.value;
 
-        case NullTag: {
-          this.tagPaths.set(tag, this.path);
+        this.resolver.advance(tag);
+        updatePath(this.path, tag);
 
-          const { properties } = this.node;
-          const { isArray, name } = this.result.value;
+        if (!name) throw new Error();
 
-          const newNode = buildStubNode(tag);
+        let stubNode = buildStubNode(tag);
 
-          if (!hasOwn(properties, name)) {
-            properties[name] = newNode;
-          }
+        add(parentNode, reference, stubNode);
 
-          this.pathNodes.set(this.path, newNode);
+        targetPath = this.path.push(stubNode, btree.getSum(this.node.children) - 2);
+        break;
+      }
 
-          this.path = this.path.parent;
-          break;
-        }
+      case ArrayInitializerTag: {
+        const { node, reference } = this;
+        this.resolver.advance(tag);
 
-        case ShiftTag: {
-          const finishedNode = this.nodeForTag(this.result);
-          const ref = ctx.getPreviousTag(getOpenTag(finishedNode));
-          const finishedPath = this.pathForTag(ref);
-          const { properties } = this.node;
+        add(node, reference, []);
+        updatePath(this.path, tag);
+        break;
+      }
 
-          this.pathNodes.set(finishedPath, null);
+      case ShiftTag: {
+        this.resolver.advance(tag);
+        updatePath(this.path, tag);
 
-          this.held = { node: finishedNode, path: finishedPath };
+        const finishedPath = this.resultPath.innerPath;
+        const finishedNode = finishedPath.node;
+        const ref = this.resultPath.previousSibling.tag;
 
-          let node = properties[ref.value.name];
+        this.held = { node: finishedNode, path: finishedPath };
 
-          if (ref.value.isArray) {
-            node = btree.getAt(-1, node);
-            properties[ref.value.name] = btree.pop(properties[ref.value.name]);
-          } else {
-            properties[ref.value.name] = null;
-          }
+        if (!ref.value.name) throw new Error();
 
-          this.path = finishedPath;
-          break;
-        }
+        if (!ref.value.flags.expression) throw new Error();
 
-        case LiteralTag:
-        case ArrayTag:
-          this.node.children = btree.push(this.node.children, tag);
-          break;
+        this.node.children = btree.push(this.node.children, tag);
 
-        default:
-          throw new Error();
+        // this.path = finishedPath;
+        targetPath = this.path;
+        break;
       }
+
+      case LiteralTag:
+        this.resolver.advance(tag);
+        updatePath(this.path, tag);
+        this.node.children = btree.push(this.node.children, tag);
+        break;
+
+      default:
+        throw new Error();
     }
 
-    this.result = tag;
+    this.resultPath = TagPath.from(targetPath, -1);
 
     return tag;
   }
 
-  *emit(options) {
-    const { nextTags } = this.context;
-    if (!this.depth) {
-      let emittable = this.emitted ? nextTags.get(this.emitted) : this.result;
-
-      while (
-        emittable &&
-        !(
-          emittable.type === OpenNodeTag &&
-          emittable.value.type &&
-          nodeStates.get(this.nodeForTag(emittable)).unboundAttributes?.size
-        )
-      ) {
-        yield options.emitEffects ? buildYieldEffect(emittable) : emittable;
-
-        this.emitted = emittable;
-        emittable = nextTags.get(this.emitted);
-      }
-    }
-  }
-
   get ctx() {
     return this.context;
   }
@@ -459,80 +323,18 @@ export const State = class AgastState extends WeakStackFrame {
   }
 
   get parentNode() {
-    return this.pathNodes.has(this.path) ? this.pathNodes.get(this.path.parent) : this.node;
+    return this.path.parent.node;
   }
 
-  branch() {
-    const { context, expressions, path, node, result, emitted, held, resolver, internalContext } =
-      this;
-    const { pathNodes } = internalContext;
-
-    const newNode = node && branchNode(node);
-
-    const nodeState = nodeStates.get(node);
-
-    pathNodes.set(path, newNode);
-    pathNodes.set(newNode, path);
-
-    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,
-      resolver.branch(),
-      internalContext,
-    );
+  get reference() {
+    return this.resolver.reference;
   }
 
-  accept() {
-    const { parent } = this;
-
-    if (!parent) {
-      return null;
-    }
-
-    if (this.node && parent.node) {
-      acceptNode(parent.node, this.node);
-      const nodeState = nodeStates.get(this.node);
-      Object.assign(nodeStates.get(parent.node), nodeState);
-    } else {
-      parent.node = this.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;
-    parent.node = this.node;
-    parent.resolver = this.resolver;
-
-    return parent;
+  get referencePath() {
+    return this.reference && this.path.referencePath;
   }
 
-  reject() {
-    const { parent, context, pathNodes, tagNodes } = this;
-
-    if (!parent) throw new Error('rejected root state');
-
-    context.nextTags.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;
+  get node() {
+    return this.path?.node;
   }
 };

package/lib/utils/iterable.js

@@ -0,0 +1,13 @@
+export function first(iter) {
+  for (const value of iter) {
+    return value;
+  }
+}
+
+export function* drop(n, iterable) {
+  let i = -1;
+  for (const value of iterable) {
+    ++i;
+    if (i >= n) yield value;
+  }
+}

package/package.json

@@ -1,17 +1,19 @@
 {
   "name": "@bablr/agast-vm",
   "description": "A VM providing DOM-like guarantees about agAST trees",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
-  "files": ["lib"],
+  "files": [
+    "lib"
+  ],
   "exports": {
     ".": "./lib/index.js"
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "^0.5.0",
-    "@bablr/agast-vm-helpers": "^0.5.0",
+    "@bablr/agast-helpers": "0.6.0",
+    "@bablr/agast-vm-helpers": "0.6.0",
     "@bablr/coroutine": "0.1.0",
     "@bablr/weak-stack": "0.1.0",
     "@iter-tools/imm-stack": "1.1.0"