@bablr/agast-vm 0.1.3 → 0.3.0

package/README.md

@@ -4,7 +4,7 @@ The agAST VM provides consistency guarantees when with CSTML documents to parse
 
 ## API
 
-The VM responds to several instructions, but its primary API is `advance(token)`, where `token` may be a `OpenFragmentTag`, `CloseFragmentTag`, `OpenNodeTag`, `CloseNodeTag`, `Literal`, `Reference`, or `Gap`.
+The VM responds to several instructions, but its primary API is `advance(token)`, where `token` may be a `OpenNodeTag`, `CloseNodeTag`, `Literal`, `Reference`, or `Gap`.
 
 The VM requires the basic invariants of CSTML to be followed, for example that `Reference` must be followed by either a `OpenNodeTag` or a `Gap`. In fact, `agast-vm` is the reference implementation of these invariants.
 
@@ -15,17 +15,7 @@ Finally the VM supports `bindAttribute(key, value)`. A node's attributes start u
 Here are the basic types used by the VM:
 
 ```ts
-type Token = OpenFragmentTag | CloseFragmentTag | OpenNodeTag | CloseNodeTag | Literal | Reference | Gap;
-
-type OpenFragmentTag {
-  type: 'OpenFragmentTag',
-  value: null
-}
-
-type CloseFragmentTag {
-  type: 'CloseFragmentTag',
-  value: null
-}
+type Token = OpenNodeTag | CloseNodeTag | Literal | Reference | Gap;
 
 type OpenNodeTag {
   type: 'OpenNodeTag',
@@ -35,8 +25,8 @@ type OpenNodeTag {
       trivia: boolean,
       escape: boolean
     },
-    language: string,
-    type: string,
+    language: string | null,
+    type: string | null, // null type indicates a fragment
     attributes: { [key: string]: boolean | number | string }
   }
 }

package/lib/context.js

@@ -11,7 +11,8 @@ function* ownTerminalsFor(range, nextTerminals, tagNodes) {
 
   for (let term = start; term && term !== pastEnd; term = nextTerminals.get(term)) {
     if (!(term === range[0] || term === range[1]) && term.type === 'OpenNodeTag') {
-      term = nextTerminals.get(tagNodes.get(term).endTag);
+      term = tagNodes.get(term).closeTag;
+      continue;
     }
 
     yield term;
@@ -24,7 +25,7 @@ function* allTerminalsFor(range, nextTerminals) {
 
   const pastEnd = nextTerminals.get(end);
 
-  for (let tag = start; tag !== pastEnd; tag = nextTerminals.get(tag)) {
+  for (let tag = start; tag && tag !== pastEnd; tag = nextTerminals.get(tag)) {
     yield tag;
   }
 }
@@ -70,6 +71,14 @@ export const ContextFacade = class AgastContextFacade {
     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);
   }
@@ -84,6 +93,8 @@ export const Context = class AgastContext {
     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();
 
@@ -91,7 +102,13 @@ export const Context = class AgastContext {
   }
 
   getProperty(result, name) {
-    return this.tagNodes.get(result[0] || result).properties.get(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) {
@@ -123,10 +140,26 @@ export const Context = class AgastContext {
     return ownTerminalsFor(range, this.prevTerminals, this.tagNodes);
   }
 
+  getPreviousTerminal(token) {
+    return this.prevTerminals.get(token);
+  }
+
+  getNextTerminal(token) {
+    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));
   }

package/lib/evaluate.js

@@ -2,24 +2,26 @@ import { Coroutine } from '@bablr/coroutine';
 import {
   buildNull,
   buildGap,
+  buildShift,
   buildReference,
   buildLiteral,
+  buildWriteEffect,
   buildDoctypeTag,
   buildNodeOpenTag,
-  buildFragmentOpenTag,
-  buildFragmentCloseTag,
   buildNodeCloseTag,
 } from '@bablr/agast-helpers/builders';
 import { StreamIterable, getStreamIterator } from '@bablr/agast-helpers/stream';
 import { printExpression } from '@bablr/agast-helpers/print';
 import { reifyExpression } from '@bablr/agast-vm-helpers';
-import { Path, Node } from './path.js';
+import { Path } from './path.js';
+import { Node } from './node.js';
 import { State } from './state.js';
 import { facades } from './facades.js';
 
-export const evaluate = (ctx, strategy) => new StreamIterable(__evaluate(ctx, strategy));
+export const evaluate = (ctx, strategy, options) =>
+  new StreamIterable(__evaluate(ctx, strategy, options));
 
-const __evaluate = function* agast(ctx, strategy) {
+const __evaluate = function* agast(ctx, strategy, options = {}) {
   let s = State.from(ctx);
 
   const co = new Coroutine(getStreamIterator(strategy(facades.get(ctx), facades.get(s))));
@@ -37,7 +39,7 @@ const __evaluate = function* agast(ctx, strategy) {
     const instr = reifyExpression(sourceInstr);
     let returnValue = undefined;
 
-    const { verb } = instr;
+    const { verb, arguments: args = [] } = instr;
 
     switch (verb) {
       case 'branch': {
@@ -66,13 +68,24 @@ const __evaluate = function* agast(ctx, strategy) {
       }
 
       case 'advance': {
-        const { arguments: { 0: terminal, 1: options } = [] } = instr;
+        const { 0: terminal, 1: options } = args;
+
+        if (
+          s.held &&
+          !(
+            terminal.type === 'OpenNodeTag' ||
+            terminal.type === 'Reference' ||
+            terminal.type === 'Gap'
+          )
+        ) {
+          throw new Error('Cannot advance while holding');
+        }
 
         switch (terminal?.type || 'Null') {
           case 'DoctypeTag': {
             const { attributes } = terminal.value;
             const doctypeTag = buildDoctypeTag(attributes);
-            const rootPath = Path.from(ctx);
+            const rootPath = Path.from(ctx, doctypeTag);
 
             if (s.path) {
               throw new Error();
@@ -109,20 +122,21 @@ const __evaluate = function* agast(ctx, strategy) {
             const tag = buildReference(name, isArray);
 
             if (s.result.type === 'Reference') {
-              throw new Error('double reference');
+              throw new Error('A reference must have a non-reference value');
             }
 
-            if (!s.path.depth) {
+            if (s.node?.flags.token) {
               throw new Error();
             }
 
-            if (s.node.flags.token) {
-              throw new Error();
+            if (s.path.depth) {
+              s.node.resolver.consume(tag);
             }
 
-            s.node.resolver.consume(tag);
-
             s.path = s.path.push(ctx, tag);
+            s.node = null;
+
+            ctx.tagPaths.set(tag, s.path);
 
             yield* s.emit(tag);
 
@@ -135,10 +149,15 @@ const __evaluate = function* agast(ctx, strategy) {
 
             if (reference?.type !== 'Reference') throw new Error();
 
-            s.path = s.path.parent;
-
             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;
@@ -150,33 +169,39 @@ const __evaluate = function* agast(ctx, strategy) {
 
             if (reference?.type !== 'Reference') throw new Error();
 
-            s.path = s.path.parent;
-
             const null_ = buildNull();
 
+            ctx.tagPaths.set(null_, s.path);
+
+            s.node = s.parentNode;
+            s.path = s.path.parent;
+
             yield* s.emit(null_);
 
             returnValue = null_;
             break;
           }
 
-          case 'OpenFragmentTag': {
-            const openTag = buildFragmentOpenTag();
+          case 'Shift': {
+            const tag = buildShift();
 
-            s.node = Node.from(openTag);
+            const finishedNode = ctx.nodeForTag(s.result);
+            const ref = ctx.getPreviousTerminal(finishedNode.openTag);
+            const finishedPath = ctx.pathForTag(ref);
 
-            yield* s.emit(openTag);
+            ctx.pathNodes.set(finishedPath, null);
 
-            returnValue = openTag;
-            break;
-          }
+            s.held = { node: finishedNode, path: finishedPath };
 
-          case 'CloseFragmentTag': {
-            const closeTag = buildFragmentCloseTag();
+            if (!finishedNode.openTag.value.flags.expression) {
+              throw new Error();
+            }
 
-            yield* s.emit(closeTag);
+            s.path = finishedPath;
 
-            returnValue = closeTag;
+            yield* s.emit(tag);
+
+            returnValue = tag;
             break;
           }
 
@@ -186,36 +211,42 @@ const __evaluate = function* agast(ctx, strategy) {
             const reference = s.result;
             const openTag = buildNodeOpenTag(flags, language, type, intrinsicValue, attributes);
 
-            if (!flags.trivia && !flags.escape && s.path.depth > 1) {
-              if (reference.type !== 'Reference' && reference.type !== 'OpenFragmentTag') {
-                throw new Error('Invalid location for OpenNodeTag');
+            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 { flags: openFlags } = openTag.value;
-
-            if (!(openFlags.trivia || openFlags.escape) && !s.path.depth) {
-              const tag = buildReference('root', false);
-              s.path = s.path.push(ctx, tag);
-              s.node.resolver.consume(tag);
-            }
-
-            if (flags.expression && !flags.intrinsic) {
-              s.expressionDepth++;
-            }
+              const newNode = new Node(openTag);
 
-            const newNode = s.node.push(openTag);
+              newNode.unboundAttributes = new Set(unboundAttributes);
 
-            newNode.unboundAttributes = new Set(unboundAttributes);
+              s.node = newNode;
+              if (flags.trivia || flags.escape) {
+                s.path = s.path.push(ctx, null);
+              }
 
-            ctx.tagNodes.set(openTag, newNode);
+              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) {
-              s.node = newNode;
-            } else {
-              s.path = s.path.parent;
+              if (intrinsicValue) {
+                newNode.closeTag = newNode.openTag;
+                s.node = s.parentNode;
+                s.path = s.path.parent;
 
-              if (s.path.depth > 1) {
                 const { properties } = s.node;
                 const { name: refName, isArray } = reference.value;
 
@@ -241,24 +272,23 @@ const __evaluate = function* agast(ctx, strategy) {
             const { openTag } = s.node;
             const { flags, type: openType } = openTag.value;
 
-            if (s.node.unboundAttributes?.size)
-              throw new Error('Grammar failed to bind all attributes');
+            const closeTag = buildNodeCloseTag(type, language);
 
-            if (!type) throw new Error(`CloseNodeTag must have type`);
+            if (openType) {
+              if (s.node.unboundAttributes?.size)
+                throw new Error('Grammar failed to bind all attributes');
 
-            if (s.path.depth > 1 && type !== openType)
-              throw new Error(
-                `Grammar close {type: ${type}} did not match open {type: ${openType}}`,
-              );
+              if (!type) throw new Error(`CloseNodeTag must have type`);
 
-            const closeTag = buildNodeCloseTag(type, language);
+              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;
+              if (!flags.escape && !flags.trivia) {
+                const { name: refName, isArray } = s.path.reference.value;
 
-              // is this right?
-              if (s.path.depth > 2) {
-                const { properties } = s.node.parent;
+                const { properties } = ctx.nodeForPath(s.path.parent);
 
                 if (!isArray) {
                   properties.set(refName, [openTag, closeTag]);
@@ -269,19 +299,14 @@ const __evaluate = function* agast(ctx, strategy) {
                   properties.get(refName).push([openTag, closeTag]);
                 }
               }
-            }
-
-            if (flags.expression) {
-              s.expressionDepth--;
-            }
 
-            ctx.tagNodes.set(closeTag, s.node);
+              ctx.tagNodes.set(closeTag, s.node);
+              ctx.tagPaths.set(closeTag, s.path);
 
-            s.node.closeTag = closeTag;
+              s.node.closeTag = closeTag;
 
-            s.node = s.node.parent;
+              s.node = s.parentNode;
 
-            if (!(flags.trivia || flags.escape)) {
               s.path = s.path.parent;
             }
 
@@ -298,18 +323,8 @@ const __evaluate = function* agast(ctx, strategy) {
         break;
       }
 
-      case 'shift': {
-        s.shift();
-        break;
-      }
-
-      case 'unshift': {
-        s.unshift();
-        break;
-      }
-
       case 'bindAttribute': {
-        const { arguments: { 0: key, 1: value } = [] } = instr;
+        const { 0: key, 1: value } = args;
 
         const { unboundAttributes } = s.node;
 
@@ -317,8 +332,8 @@ const __evaluate = function* agast(ctx, strategy) {
           throw new Error('No unbound attribute to bind');
         }
 
-        if (s.node.openTag.type === 'OpenFragmentTag') {
-          throw new Error();
+        if (!s.node.openTag.value.type) {
+          throw new Error('Cannot bind attribute to fragment');
         }
 
         if (key === 'span') throw new Error('too late');
@@ -339,25 +354,25 @@ const __evaluate = function* agast(ctx, strategy) {
         if (value != null) {
           const { flags, language, type, intrinsicValue } = openTag.value;
           const attributes = { ...openTag.value.attributes, [key]: value };
-          const newStartTag = buildNodeOpenTag(flags, language, type, intrinsicValue, attributes);
+          const newOpenTag = buildNodeOpenTag(flags, language, type, intrinsicValue, attributes);
 
-          let startNext = ctx.nextTerminals.get(openTag);
+          let openNext = ctx.nextTerminals.get(openTag);
           let startPrev = ctx.prevTerminals.get(openTag);
 
-          ctx.prevTerminals.set(newStartTag, startPrev);
-          ctx.nextTerminals.set(startPrev, newStartTag);
+          ctx.prevTerminals.set(newOpenTag, startPrev);
+          ctx.nextTerminals.set(startPrev, newOpenTag);
 
-          ctx.tagNodes.set(newStartTag, s.node);
+          ctx.tagNodes.set(newOpenTag, ctx.tagNodes.get(openTag));
 
-          if (startNext) {
-            ctx.nextTerminals.set(newStartTag, startNext);
-            ctx.prevTerminals.set(startNext, newStartTag);
+          if (openNext) {
+            ctx.nextTerminals.set(newOpenTag, openNext);
+            ctx.prevTerminals.set(openNext, newOpenTag);
           } else {
             // could this terminal be stored anywhere else?
-            s.result = newStartTag;
+            s.result = newOpenTag;
           }
 
-          s.node.openTag = newStartTag;
+          s.node.openTag = newOpenTag;
         }
 
         if (!unboundAttributes.size) {
@@ -378,6 +393,13 @@ const __evaluate = function* agast(ctx, strategy) {
         break;
       }
 
+      case 'write': {
+        if (options.emitEffects) {
+          yield buildWriteEffect(args[0], args[1]);
+        }
+        break;
+      }
+
       default: {
         throw new Error(`Unexpected call of {type: ${printExpression(verb)}}`);
       }

package/lib/node.js

@@ -0,0 +1,99 @@
+import { Resolver } 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 actuals.get(this).range;
+  }
+
+  get openTag() {
+    return actuals.get(this).openTag;
+  }
+
+  get closeTag() {
+    return actuals.get(this).closeTag;
+  }
+
+  get flags() {
+    return actuals.get(this).flags;
+  }
+
+  get attributes() {
+    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/path.js

@@ -1,61 +1,7 @@
 import { WeakStackFrame } from '@bablr/weak-stack';
-import { Resolver } from '@bablr/agast-helpers/tree';
-import { findRight } from './utils/array.js';
+import { skipToDepth, buildSkips } from './utils/skip.js';
 import { facades, actuals } from './facades.js';
 
-const skipLevels = 3;
-const skipShiftExponentGrowth = 4;
-const skipAmounts = new Array(skipLevels)
-  .fill(null)
-  .map((_, i) => 2 >> (i * skipShiftExponentGrowth));
-const skipsByPath = new WeakMap();
-
-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 path() {
-    return actuals.get(this).path;
-  }
-
-  get parent() {
-    return facades.get(actuals.get(this).parent);
-  }
-
-  get range() {
-    return actuals.get(this).range;
-  }
-
-  get openTag() {
-    return actuals.get(this).openTag;
-  }
-
-  get closeTag() {
-    return actuals.get(this).closeTag;
-  }
-
-  get depth() {
-    return actuals.get(this).depth;
-  }
-
-  get flags() {
-    return actuals.get(this).flags;
-  }
-
-  get attributes() {
-    return actuals.get(this).attributes;
-  }
-};
-
 export const PathFacade = class AgastPathFacade {
   constructor(path) {
     facades.set(path, this);
@@ -74,17 +20,7 @@ export const PathFacade = class AgastPathFacade {
   }
 
   at(depth) {
-    let parent = this;
-
-    if (depth > this.depth) throw new Error();
-
-    let d = actuals.get(parent).depth;
-    for (; d > depth; ) {
-      const skips = skipsByPath.get(actuals.get(this));
-      parent = (skips && findRight(skips, (skip) => d - skip > depth)) || parent.parent;
-      d = actuals.get(parent).depth;
-    }
-    return parent;
+    return facades.get(actuals.get(this).at(depth));
   }
 
   *parents(includeSelf = false) {
@@ -96,67 +32,6 @@ export const PathFacade = class AgastPathFacade {
   }
 };
 
-export const Node = class AgastNode extends WeakStackFrame {
-  static from(openTag) {
-    return AgastNode.create(openTag);
-  }
-
-  constructor(
-    openTag,
-    closeTag = null,
-    properties = new Map(),
-    resolver = new Resolver(),
-    unboundAttributes = null,
-  ) {
-    super();
-
-    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 || Symbol.for('@bablr/fragment');
-  }
-
-  get flags() {
-    return this.openTag.value?.flags || {};
-  }
-
-  get attributes() {
-    return this.openTag.value?.attributes || {};
-  }
-
-  branch() {
-    const { openTag, closeTag, properties, resolver, unboundAttributes } = this;
-
-    return this.replace(
-      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;
-  }
-};
-
 export const Path = class AgastPath extends WeakStackFrame {
   static from(context, tag) {
     return Path.create(context, tag);
@@ -165,43 +40,28 @@ export const Path = class AgastPath extends WeakStackFrame {
   constructor(context, reference) {
     super();
 
-    if (reference && reference.type !== 'Reference') {
+    if (reference && reference.type !== 'Reference' && reference.type !== 'DoctypeTag') {
       throw new Error('Invalid reference for path');
     }
 
     this.context = context;
     this.reference = reference;
 
-    let skipIdx = 0;
-    let skipAmount = skipAmounts[skipIdx];
-    let skips;
-    while ((this.depth & skipAmount) === skipAmount) {
-      if (!skips) {
-        skips = [];
-        skipsByPath.set(this, skips);
-      }
-
-      skips[skipIdx] = this.at(this.depth - skipAmount);
-
-      skipIdx++;
-      skipAmount = skipAmounts[skipIdx];
-    }
+    buildSkips(this);
 
     new PathFacade(this);
   }
 
-  at(depth) {
-    let parent = this;
+  get name() {
+    return this.reference?.value.name || '[anonymous]';
+  }
 
-    if (depth > this.depth) throw new Error();
+  get isArray() {
+    return this.reference?.value.isArray || false;
+  }
 
-    let d = this.depth;
-    for (; d > depth; ) {
-      const skips = skipsByPath.get(this);
-      parent = (skips && findRight(skips, (skip) => d - skip > depth)) || parent.parent;
-      d = parent.depth;
-    }
-    return parent;
+  at(depth) {
+    return skipToDepth(depth, this);
   }
 
   *parents(includeSelf = false) {

package/lib/state.js

@@ -1,6 +1,7 @@
 import { WeakStackFrame } from '@bablr/weak-stack';
 import { startsDocument } from '@bablr/agast-helpers/stream';
 import { facades, actuals } from './facades.js';
+import { buildBeginningOfStreamToken } from '@bablr/agast-helpers/builders';
 
 export const StateFacade = class AgastStateFacade {
   constructor(state) {
@@ -27,6 +28,10 @@ export const StateFacade = class AgastStateFacade {
     return actuals.get(this).node;
   }
 
+  get parentNode() {
+    return actuals.get(this).parentNode;
+  }
+
   get holding() {
     return actuals.get(this).holding;
   }
@@ -45,10 +50,9 @@ export const State = class AgastState extends WeakStackFrame {
     context,
     path = null,
     node = null,
-    result = null,
+    result = buildBeginningOfStreamToken(),
     emitted = null,
     held = null,
-    expressionDepth = 0,
   ) {
     super();
 
@@ -60,7 +64,6 @@ export const State = class AgastState extends WeakStackFrame {
     this.result = result;
     this.emitted = emitted;
     this.held = held;
-    this.expressionDepth = expressionDepth;
 
     new StateFacade(this);
   }
@@ -73,41 +76,8 @@ export const State = class AgastState extends WeakStackFrame {
     return !!this.held;
   }
 
-  shift() {
-    const { tagNodes, prevTerminals, nextTerminals } = this.context;
-
-    const finishedNode = tagNodes.get(this.result);
-
-    if (!finishedNode.openTag.value.flags.expression) {
-      throw new Error();
-    }
-
-    this.result = prevTerminals.get(finishedNode.openTag);
-
-    nextTerminals.delete(this.result);
-
-    this.held = finishedNode;
-
-    // put the first expression node into the holding register
-  }
-
-  unshift() {
-    const { tagNodes, prevTerminals, nextTerminals } = this.context;
-
-    if (!this.held) {
-      throw new Error('cannot unshift when no expression is in the holding register');
-    }
-
-    nextTerminals.set(this.result, this.held.openTag);
-    prevTerminals.set(this.held.openTag, this.result);
-
-    this.result = this.held.closeTag;
-
-    this.held = null;
-  }
-
   *emit(terminal, suppressEmit) {
-    const { prevTerminals, nextTerminals, tagNodes } = this.context;
+    const { prevTerminals, nextTerminals } = this.context;
 
     if (terminal) {
       if (prevTerminals.has(terminal)) {
@@ -118,13 +88,11 @@ export const State = class AgastState extends WeakStackFrame {
         this.result?.type === 'Reference' &&
         !['OpenNodeTag', 'Gap', 'Null'].includes(terminal.type)
       ) {
-        throw new Error('Bad reference emit');
+        throw new Error(`${terminal.type} is not a valid reference target`);
       }
 
       prevTerminals.set(terminal, this.result);
-      if (this.result) {
-        nextTerminals.set(this.result, terminal);
-      }
+      nextTerminals.set(this.result, terminal);
 
       this.result = terminal;
 
@@ -135,12 +103,16 @@ export const State = class AgastState extends WeakStackFrame {
       }
     }
 
-    if (!this.depth && !this.expressionDepth && !suppressEmit) {
+    if (!this.depth && !suppressEmit) {
       let emittable = nextTerminals.get(this.emitted);
 
       while (
         emittable &&
-        !(emittable.type === 'OpenNodeTag' && tagNodes.get(emittable).unboundAttributes?.size)
+        !(
+          emittable.type === 'OpenNodeTag' &&
+          emittable.value.type &&
+          this.context.nodeForTag(emittable).unboundAttributes?.size
+        )
       ) {
         yield emittable;
         this.emitted = emittable;
@@ -163,27 +135,42 @@ export const State = class AgastState extends WeakStackFrame {
     return !!this.parent;
   }
 
+  get parentNode() {
+    return this.ctx.nodeForPath(this.path.parent);
+  }
+
   branch() {
-    const { context, path, node, result, emitted, held, expressionDepth } = this;
+    const { context, path, node, result, emitted, held } = this;
+
+    const newNode = node && node.branch();
+
+    if (newNode?.openTag) context.tagNodes.set(newNode.openTag, newNode);
+    if (newNode?.closeTag) context.tagNodes.set(newNode.closeTag, newNode);
 
-    return this.push(context, path, node.branch(), result, emitted, held, expressionDepth);
+    return this.push(context, path, newNode, result, emitted, held);
   }
 
   accept() {
-    const { parent } = this;
+    const { parent, context } = this;
 
     if (!parent) {
-      throw new Error('accepted the root state');
+      return null;
+    }
+
+    if (this.node && parent.node) {
+      parent.node.accept(this.node, context);
+    } else {
+      parent.node = this.node;
     }
 
-    parent.node.accept(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.result = this.result;
     parent.held = this.held;
     parent.path = this.path;
-    parent.expressionDepth = this.expressionDepth;
 
     return parent;
   }

package/lib/utils/skip.js

@@ -0,0 +1,39 @@
+import { findRight } from './array.js';
+
+const skipLevels = 3;
+const skipShiftExponentGrowth = 4;
+const skipAmounts = new Array(skipLevels)
+  .fill(null)
+  .map((_, i) => 2 >> (i * skipShiftExponentGrowth));
+const skipsByFrame = new WeakMap();
+
+export const buildSkips = (frame) => {
+  let skipIdx = 0;
+  let skipAmount = skipAmounts[skipIdx];
+  let skips;
+  while ((frame.depth & skipAmount) === skipAmount) {
+    if (!skips) {
+      skips = [];
+      skipsByFrame.set(frame, skips);
+    }
+
+    skips[skipIdx] = frame.at(frame.depth - skipAmount);
+
+    skipIdx++;
+    skipAmount = skipAmounts[skipIdx];
+  }
+};
+
+export const skipToDepth = (depth, frame) => {
+  let parent = frame;
+
+  if (depth > frame.depth) throw new Error();
+
+  let d = frame.depth;
+  for (; d > depth; ) {
+    const skips = skipsByFrame.get(frame);
+    parent = (skips && findRight(skips, (skip) => d - skip > depth)) || parent.parent;
+    d = parent.depth;
+  }
+  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.1.3",
+  "version": "0.3.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -11,24 +11,19 @@
     ".": "./lib/index.js"
   },
   "sideEffects": false,
-  "scripts": {
-    "test": "node ./test/runner.js"
-  },
   "dependencies": {
-    "@bablr/agast-helpers": "0.1.5",
-    "@bablr/agast-vm-helpers": "0.1.3",
+    "@bablr/agast-helpers": "0.2.0",
+    "@bablr/agast-vm-helpers": "0.2.0",
     "@bablr/coroutine": "0.1.0",
     "@bablr/weak-stack": "0.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",
-    "@bablr/strategy_enhancer-debug-log": "0.1.1",
     "enhanced-resolve": "^5.12.0",
     "eslint": "^8.32.0",
     "eslint-import-resolver-enhanced-resolve": "^1.0.5",
     "eslint-plugin-import": "^2.27.5",
-    "expect": "29.7.0",
     "iter-tools-es": "^7.3.1",
     "prettier": "^2.6.2"
   },