@bablr/agast-vm 0.10.0 → 0.11.0

package/lib/evaluate.js

@@ -1,3 +1,4 @@
+/* global WeakSet */
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -6,24 +7,33 @@ import {
   ShiftTag,
   GapTag,
   NullTag,
-  InitializerTag,
   LiteralTag,
   AttributeDefinition,
   BindingTag,
   Property,
-  PropertyWrapper,
+  TreeNode,
+  NullNode,
+  GapNode,
 } from '@bablr/agast-helpers/symbols';
 import { State } from './state.js';
-import { facades } from './facades.js';
-import { getFirstNode, TagPath } from '@bablr/agast-helpers/path';
+import {
+  getAttributes,
+  getFirstNode,
+  isGapNode,
+  isNodeTag,
+  TagPath,
+} from '@bablr/agast-helpers/path';
+import * as BTree from '@bablr/agast-helpers/btree';
 import * as Tags from '@bablr/agast-helpers/tags';
-import { NodeFacade } from './node.js';
+import { isObject } from '@bablr/agast-helpers/object';
+
+const validNodes = new WeakSet();
+
+export const isKnownValid = (node) => validNodes.has(node);
 
 let { isArray } = Array;
 
 export const agast = (options = {}) => {
-  if (options.held?.tags) throw new Error();
-
   let state = State.from(options.held);
 
   let vm = __agast(state, options);
@@ -32,7 +42,14 @@ export const agast = (options = {}) => {
 
   Object.freeze(options);
 
-  return Object.freeze({ options, state: facades.get(state), vm });
+  let getState = () => ({
+    path: state.path,
+    node: state.path.node,
+    resultPath: state.resultPath,
+    held: state.held,
+  });
+
+  return Object.freeze({ options, getState, vm });
 };
 
 function* __agast(s) {
@@ -40,24 +57,19 @@ function* __agast(s) {
   for (;;) {
     let returnValue = null;
 
-    if (s.resultPath && !s.path) {
-      throw new Error('Cannot advance after completion');
-    }
-
-    if (
-      s.held &&
-      ![OpenNodeTag, ReferenceTag, InitializerTag, Property, BindingTag, PropertyWrapper].includes(
-        tag.type,
-      ) &&
-      !(
-        (tag.type === Property &&
-          (Tags.getSize(tag.value.node.tags) <= 1 ||
-            getFirstNode(tag.value.node) === s.held.node)) ||
-        tag.value.node === s.held.node
-      )
-    ) {
-      throw new Error('Cannot advance while holding');
-    }
+    // if (
+    //   s.held &&
+    //   ![OpenNodeTag, ReferenceTag, TreeNode, GapNode, BindingTag, Property, GapTag].includes(
+    //     tag.type,
+    //   ) &&
+    //   !(
+    //     (isNodeTag(tag) &&
+    //       (Tags.getSize(tag.value.tags) <= 1 || getFirstNode(tag.value) === s.held)) ||
+    //     tag.value === s.held
+    //   )
+    // ) {
+    //   throw new Error('Cannot advance while holding');
+    // }
 
     switch (tag.type) {
       case DoctypeTag: {
@@ -65,134 +77,125 @@ function* __agast(s) {
           throw new Error();
         }
 
-        s.advance(tag);
+        s.path = s.path.advance(tag);
         break;
       }
 
-      case LiteralTag: {
-        if (!s.node.flags.token) {
-          throw new Error('literals must occur inside tokens');
-        }
-
-        if (s.held) {
-          throw new Error('Cannot consume input while hold register is full');
-        }
-
-        s.advance(tag);
+      case ReferenceTag: {
+        s.path = s.path.advance(tag);
+        s.resultPath = s.path.tagPathAt(-1, -1);
         break;
       }
 
-      case ReferenceTag: {
-        const { type } = tag.value;
-
-        if (s.node?.flags.token && type !== '@') {
-          throw new Error('A token node cannot contain a reference');
-        }
+      case LiteralTag: {
+        s.path = s.path.advance(tag);
+        s.resultPath = s.path.tagPathAt(-1, -1);
+        break;
+      }
 
-        s.advance(tag);
+      case AttributeDefinition: {
+        s.path = s.path.advance(tag);
+        s.resultPath = s.path.tagPathAt(-1, -1);
         break;
       }
 
       case BindingTag: {
-        const { languagePath } = tag.value;
-
-        if (languagePath && !isArray(languagePath)) throw new Error();
+        const { segments } = tag.value;
 
-        s.held = null;
+        if (segments && !isArray(segments)) throw new Error();
 
-        s.advance(tag);
+        s.path = s.path.advance(tag);
+        s.resultPath = s.path.tagPathAt(-1, [-1, -1]);
         break;
       }
 
       case NullTag:
       case GapTag: {
-        s.advance(tag);
-        returnValue = new NodeFacade(s.resultPath.node);
+        s.path = s.path.advance(tag);
+        s.resultPath = s.path.tagPathAt(-1, -1);
+        returnValue = s.resultPath.node;
         break;
       }
 
       case AttributeDefinition: {
-        if (s.atReference) throw new Error();
-
-        s.advance(tag);
+        s.path = s.path.advance(tag);
         break;
       }
 
-      case InitializerTag: {
-        if (!s.atReference) throw new Error();
-
-        s.advance(tag);
+      case ShiftTag: {
+        let previousPropertyPath = s.path.tagPathAt(-1);
+        s.path = s.path.advance(tag);
+        s.resultPath = s.path.tagPathAt(-1, -1);
+        s.held = previousPropertyPath.inner.node;
         break;
       }
 
-      case ShiftTag: {
-        const { index } = tag.value;
-        if (s.resultPath.tag.type !== Property) throw new Error();
-
-        let { path, tagsIndex } = s.resultPath;
-
-        let prevRef = TagPath.from(path, tagsIndex, 0);
-        let refPath = prevRef;
-
-        if (prevRef.tag.type === ShiftTag) {
-          if (prevRef.tag.value.index + 1 !== index) throw new Error('bad shift index');
+      case OpenNodeTag: {
+        s.path = !s.path ? TagPath.fromTag(tag).path : s.path.advance(tag);
+        s.resultPath = s.path.tagPathAt(-1, -1);
 
-          refPath = TagPath.from(path, tagsIndex + 1 - index, 0);
+        if (s.path) {
+          let queue = [getAttributes(s.node)];
+          while (queue.length) {
+            for (let value of Object.values(queue[queue.length - 1])) {
+              if (value === undefined) {
+              } else if (isArray(value) || isObject(value)) {
+                queue.push(value);
+              }
+            }
+            queue.pop();
+          }
         }
 
-        if (refPath.tag.type !== ReferenceTag) throw new Error();
+        returnValue = s.node || s.resultPath.node;
+        break;
+      }
 
-        if (!refPath.tag.value.flags.expression) {
-          throw new Error();
+      case CloseNodeTag: {
+        if (!s.path) {
+          s.done = true;
         }
 
-        s.advance(tag);
-        break;
-      }
+        validNodes.add(s.node);
 
-      case OpenNodeTag: {
-        s.advance(tag);
+        returnValue = s.node;
 
-        returnValue = new NodeFacade(s.node || s.resultPath.node);
-        break;
-      }
+        let donePath = s.path;
 
-      case CloseNodeTag: {
-        returnValue = new NodeFacade(s.node);
+        s.path = s.path.advance(tag);
 
-        s.advance(tag);
+        s.resultPath = donePath.tagPathAt(-1, -1);
         break;
       }
 
-      case PropertyWrapper: {
-        let { tags, property } = tag.value;
-        let { node, reference } = property;
-
-        if (reference.type === '_') {
-          returnValue = node;
-          s.node.tags = Tags.push(s.node.tags, node);
+      case Property: {
+        let { tags, node } = tag.value;
 
-          s.resultPath = TagPath.from(s.path, -1, -1);
-          if (Tags.getAt(-1, s.node.tags).type === PropertyWrapper) {
-            s.referenceTagPath = TagPath.from(s.path, -1, 0);
-          }
-          s.held = null;
-        } else {
-          for (tag of tags) {
-            s.advance(tag);
-          }
-          returnValue = new NodeFacade(node);
+        for (tag of Tags.traverse(tags)) {
+          s.path = s.path.advance(tag);
         }
+        returnValue = node;
 
         break;
       }
 
-      case Property: {
-        let { node } = tag.value;
+      case NullNode:
+      case GapNode:
+      case TreeNode: {
+        let node = tag;
 
-        s.advance(tag);
+        // let clearedHeld =
+        //   s.held &&
+        //   (node.type === GapNode ||
+        //     BTree.getAt(-BTree.getSize(s.held.value.bounds[0]), node.value.bounds[0]));
+
+        // if (s.held && !s.path.held) throw new Error();
+
+        s.path = s.path.advance(s.held && isGapNode(node) ? s.held : tag);
+        s.resultPath = s.path.tagPathAt(-1, -1);
+        s.held = null;
 
-        returnValue = Array.isArray(node) ? node : new NodeFacade(node);
+        returnValue = s.path.node;
         break;
       }
 

package/lib/index.js

@@ -1,4 +1 @@
-export { agast } from './evaluate.js';
-
-export { PathFacade, TagPathFacade } from './path.js';
-export { NodeFacade } from './node.js';
+export { agast, isKnownValid } from './evaluate.js';

package/lib/state.js

@@ -1,176 +1,25 @@
-import emptyStack from '@iter-tools/imm-stack';
-import {
-  addProperty,
-  finalizeNode,
-  buildStubNode,
-  getRange,
-  createNode,
-  buildNullNode,
-  buildOpenNodeTag,
-  shiftProperty,
-  buildProperty,
-  add,
-  buildAttributeDefinition,
-  buildBinding,
-  buildGapTag,
-  getOr,
-  has as nodeHas,
-  buildReferenceTag,
-  buildReference,
-  buildBounds,
-  buildChild,
-  buildPropertyWrapper,
-} from '@bablr/agast-helpers/tree';
-import * as Tags from '@bablr/agast-helpers/tags';
-import * as BTree from '@bablr/agast-helpers/btree';
-import {
-  getInitializerTagsIndex,
-  getOpenTag,
-  getOriginalFirstNode,
-  getProperty,
-  getPropertyTagsIndex,
-  isGapNode,
-  isStubNode,
-  offsetForTag,
-  referencesAreEqual,
-  TagPath,
-} from '@bablr/agast-helpers/path';
-import {
-  DoctypeTag,
-  OpenNodeTag,
-  CloseNodeTag,
-  ReferenceTag,
-  ShiftTag,
-  GapTag,
-  NullTag,
-  InitializerTag,
-  LiteralTag,
-  AttributeDefinition,
-  BindingTag,
-  Property,
-  PropertyWrapper,
-} from '@bablr/agast-helpers/symbols';
-import { facades, actuals } from './facades.js';
-import { Path, PathFacade, TagPathFacade } from './path.js';
-import { get, has, immSet, isObject } from '@bablr/agast-helpers/object';
-import { NodeFacade } from './node.js';
-
-const { isArray } = Array;
-
-const defineAttribute = (node, tag) => {
-  if (tag.type !== AttributeDefinition) throw new Error();
-
-  let { path, value } = tag.value;
-  let openTag = getOpenTag(node);
-  let { attributes } = node;
-
-  if (!has(attributes, path) && get(attributes, path) !== undefined)
-    throw new Error('Can only define undefined attributes');
-
-  if (value === undefined) throw new Error('cannot define attribute to undefined');
-
-  let { flags, type } = openTag.value;
-  attributes = immSet(attributes, path, value);
-  let newOpenTag = buildOpenNodeTag(flags, type, attributes);
-
-  node.attributes = attributes;
-
-  node.tags = Tags.replaceAt(0, node.tags, newOpenTag);
-  node.tags = Tags.push(node.tags, tag);
-};
-
-export const StateFacade = class AgastStateFacade {
-  constructor(state) {
-    facades.set(state, this);
-  }
-
-  static create() {
-    return State.create();
-  }
-
-  get resultPath() {
-    let { resultPath } = actuals.get(this);
-    return resultPath && new TagPathFacade(resultPath);
-  }
-
-  get referenceTag() {
-    return actuals.get(this).referenceTag;
-  }
-
-  get referenceTagPath() {
-    let { referenceTagPath } = actuals.get(this);
-    return referenceTagPath && new TagPathFacade(referenceTagPath);
-  }
-
-  get path() {
-    let { path } = actuals.get(this);
-    return path && new PathFacade(path);
-  }
-
-  get node() {
-    let { node } = actuals.get(this);
-    return node && new NodeFacade(node);
-  }
-
-  get done() {
-    return actuals.get(this).done;
-  }
-
-  get parentNode() {
-    let { parentNode } = actuals.get(this);
-    return parentNode && new NodeFacade(parentNode);
-  }
-
-  get held() {
-    let { held } = actuals.get(this);
-    return held && new NodeFacade(held.node);
-  }
-
-  get holding() {
-    return actuals.get(this).holding;
-  }
-
-  get depth() {
-    return actuals.get(this).depth;
-  }
-
-  get parent() {
-    return facades.get(actuals.get(this).parent);
-  }
-};
-
-export const nodeStates = new WeakMap();
+import { offsetForTag, TagPath } from '@bablr/agast-helpers/path';
+import { DoctypeTag, Property } from '@bablr/agast-helpers/symbols';
 
 export const State = class AgastState {
   static create() {
     return new State();
   }
 
+  static from(held) {
+    return new State(held);
+  }
+
   constructor(held = null, path = null, resultPath = null) {
     this.held = held;
     this.path = path;
     this.resultPath = resultPath;
     this.done = false;
-    this.referenceTagPath = null;
     this.doctype = null;
-
-    new StateFacade(this);
-  }
-
-  static from(held) {
-    return new State(held);
   }
 
-  get holding() {
-    return !!this.held;
-  }
-
-  get atReference() {
-    return [ReferenceTag, ShiftTag].includes(this.resultPath?.tag.type);
-  }
-
-  get atBinding() {
-    return this.resultPath?.tag.type === BindingTag;
+  get node() {
+    return this.path.node;
   }
 
   advance(tag) {
@@ -192,343 +41,6 @@ export const State = class AgastState {
         break;
       }
 
-      case ReferenceTag: {
-        let { type, isArray, name, flags } = tag.value;
-
-        if (this.atReference) throw new Error('invalid location for reference');
-        if (!name && !type) throw new Error();
-        if (type && !['.', '#', '@'].includes(type)) throw new Error();
-        if (type === '@' && isArray) throw new Error();
-
-        if (this.held && Tags.getAt(2, this.node.tags)?.type === InitializerTag) {
-          if (
-            !referencesAreEqual(Tags.getAt(1, this.node.tags).value, tag.value) ||
-            Tags.getSize(this.node.tags) > 3
-          ) {
-            throw new Error();
-          }
-        }
-
-        if (tag.value.name) {
-          if (
-            getOr(null, tag.value.name, this.node) &&
-            !referencesAreEqual(tag.value, getProperty(tag.value.name, this.node).reference)
-          ) {
-            throw new Error('mismatched references');
-          }
-        } else if (tag.value.type === '.') {
-          let rootIdx = getPropertyTagsIndex(this.node, '.', null, 0);
-
-          if (
-            rootIdx != null &&
-            !referencesAreEqual(
-              tag.value,
-              Tags.getAt(rootIdx, this.node.tags).value.property.reference,
-            )
-          ) {
-            throw new Error('mismatched references');
-          }
-        }
-
-        let initIndex = getInitializerTagsIndex(this.node, tag);
-        if (initIndex != null) {
-          let initReferenceTag = Tags.getAt(initIndex, this.node.tags, 0);
-          if (!referencesAreEqual(tag.value, initReferenceTag.value)) {
-            throw new Error("reference didn't match initializer");
-          }
-        }
-
-        let tagProperty = buildProperty(tag.value);
-
-        this.node.tags = Tags.push(
-          this.node.tags,
-          buildChild(PropertyWrapper, buildPropertyWrapper([tag], tagProperty)),
-        );
-
-        if (flags.hasGap && !this.node.flags.hasGap) {
-          throw new Error('gap reference in gapless node');
-        }
-
-        this.referenceTagPath = TagPath.from(this.path, -1, 0);
-
-        break;
-      }
-
-      case BindingTag: {
-        if (!this.atReference && this.parent) {
-          throw new Error('Invalid location for BindingTag');
-        }
-
-        let refPath = this.referenceTagPath;
-        let propPath = TagPath.from(refPath.path, refPath.tagsIndex);
-
-        if (refPath.tag.type === ShiftTag) {
-          refPath = TagPath.from(refPath.path, refPath.tagsIndex - refPath.tag.value.index, 0);
-        }
-
-        let refTag = refPath.tag;
-
-        let tagProperty = buildProperty(refTag.value, tag.value, undefined);
-        let tags = [propPath.tag.value.tags[0], tag];
-
-        this.node.tags = Tags.replaceAt(
-          this.referenceTagPath.tagsIndex,
-          this.node.tags,
-          buildChild(PropertyWrapper, buildPropertyWrapper(tags, tagProperty)),
-        );
-        break;
-      }
-
-      case OpenNodeTag: {
-        let { literalValue } = tag.value;
-        let parentNode = this.node;
-
-        if (!this.atBinding && this.parent) {
-          throw new Error('Invalid location for OpenNodeTag');
-        }
-
-        let bindingTag = parentNode && Tags.getAt(-1, parentNode.tags, 1);
-
-        if (bindingTag && !bindingTag.value.languagePath) throw new Error();
-
-        let node = createNode(tag);
-
-        if (!this.path) {
-          this.path = Path.create(node);
-        } else {
-          this.path = this.path.push(node, Tags.getSize(parentNode.tags) - 1);
-          add(parentNode, this.referenceTag, node, bindingTag);
-        }
-
-        if (literalValue) {
-          finalizeNode(node);
-
-          let oldPath = this.path;
-          this.path = this.path.parent;
-
-          if (!this.path) {
-            this.done = true;
-            this.resultPath = TagPath.from(oldPath, 0);
-            return tag;
-          }
-        }
-
-        targetPath = this.path;
-
-        if (this.path) {
-          let undefinedAttributes = 0;
-
-          let queue = [this.node.attributes];
-          while (queue.length) {
-            for (let value of Object.values(queue[queue.length - 1])) {
-              if (value === undefined) {
-                undefinedAttributes++;
-              } else if (isArray(value) || isObject(value)) {
-                queue.push(value);
-              }
-            }
-            queue.pop();
-          }
-
-          nodeStates.set(this.node, { undefinedAttributes });
-        }
-
-        break;
-      }
-
-      case CloseNodeTag: {
-        if (this.atReference) throw new Error('invalid location for close tag');
-
-        if (this.node.type) {
-          for (const { 0: key, 1: count } of Tags.getSums(this.node.tags).references) {
-            if (count === 1) {
-              let property = getProperty(key, this.node);
-              if (!property && nodeHas(key, this.node)) {
-                let refIndex = getInitializerTagsIndex(this.node, buildReferenceTag(null, key));
-                let ref = Tags.getAt(refIndex, this.node.tags, 0);
-                if (!ref.value.isArray) {
-                  let reference = Tags.getAt(refIndex, this.node.tags, 0).value;
-
-                  addProperty(this.node, buildProperty(reference, buildBinding(), buildNullNode()));
-                }
-              }
-            }
-          }
-        }
-
-        let list = emptyStack.push(this.node.attributes);
-        while (list.size) {
-          let item = list.value;
-          list = list.pop();
-
-          for (const value of Object.values(item)) {
-            if (isObject(value)) {
-              list = list.push(value);
-            }
-          }
-
-          Object.freeze(item);
-        }
-
-        this.node.tags = Tags.push(this.node.tags, tag);
-
-        if (!this.path) {
-          this.done = true;
-        }
-
-        finalizeNode(this.node);
-
-        this.path = this.path.parent;
-        break;
-      }
-
-      case Property: {
-        let target;
-        let property = tag.value;
-
-        if (!this.atBinding && !isStubNode(property.node)) {
-          throw new Error('Invalid location for Property');
-        }
-
-        let { node } = this.path;
-        let lastTagPath = TagPath.from(this.path, -1, 0);
-        let refOrShift = lastTagPath.tag;
-
-        if (![ShiftTag, ReferenceTag].includes(refOrShift.type)) throw new Error();
-
-        if (this.held) {
-          if (isGapNode(property.node)) {
-            property = buildProperty(property.reference, this.held.binding, this.held.node);
-          } else {
-            let { height } = refOrShift.value;
-            let matchesHeld =
-              isGapNode(property.node) ||
-              this.held.node === property.node ||
-              this.held.node === getOriginalFirstNode(property.node, (height ?? 1) - 1);
-            if (!matchesHeld) {
-              throw new Error();
-            }
-          }
-
-          let openStack = node.bounds[0];
-
-          openStack = BTree.replaceAt(-1, openStack, property);
-          openStack = BTree.push(
-            openStack,
-            buildProperty(buildReference('.'), buildBinding(), buildStubNode(buildGapTag())),
-          );
-
-          node.bounds = buildBounds(openStack, node.bounds[1]);
-        }
-
-        target = this.held ? this.held.node : buildStubNode(buildGapTag());
-
-        const range = getRange(target);
-
-        this.resultPath = range ? range[1] : this.resultPath;
-        this.referenceTagPath = null;
-
-        if (refOrShift.type === ShiftTag) {
-          shiftProperty(node, property);
-        } else {
-          addProperty(node, property);
-        }
-
-        this.held = null;
-        break;
-      }
-
-      case GapTag:
-      case NullTag: {
-        const { node: parentNode, referenceTag } = this;
-
-        if (this.held) throw new Error();
-
-        if (!this.atReference && this.parent) {
-          throw new Error('Invalid location for NullTag');
-        }
-
-        let stubNode = buildStubNode(tag);
-
-        add(parentNode, referenceTag, stubNode);
-
-        targetPath = this.path.push(stubNode, Tags.getSize(this.node.tags) - 1);
-        break;
-      }
-
-      case AttributeDefinition: {
-        if (this.held) throw new Error('invalid place for an atrribute binding');
-
-        let nodeState = nodeStates.get(this.node);
-
-        nodeState.undefinedAttributes--;
-
-        // add undefined attributes from value
-
-        defineAttribute(this.node, tag);
-
-        break;
-      }
-
-      case InitializerTag: {
-        const { node, referenceTag } = this;
-
-        if (!this.atReference && this.parent) {
-          throw new Error('Invalid location for InitializerTag');
-        }
-
-        if (this.held && Tags.getAt(1, node.tags, 0)?.type === InitializerTag) {
-          throw new Error();
-        }
-
-        if (getInitializerTagsIndex(node, referenceTag) != null) {
-          throw new Error();
-        }
-
-        let currentProperty = Tags.getAt(-1, node.tags).value.property;
-
-        let tags = [referenceTag, tag];
-
-        let propertyWrapper = buildChild(
-          PropertyWrapper,
-          buildPropertyWrapper(tags, currentProperty),
-        );
-
-        node.tags = Tags.replaceAt(-1, node.tags, propertyWrapper);
-        break;
-      }
-
-      case ShiftTag: {
-        if (this.resultPath.tag.type !== Property) throw new Error('invalid location for shift');
-
-        let heldProperty = this.resultPath.tag.value;
-
-        if (!this.held) {
-          this.held = heldProperty;
-        }
-
-        if (!heldProperty.reference.flags.expression) throw new Error();
-
-        let tagProperty = buildProperty(heldProperty.reference);
-
-        this.node.tags = Tags.push(
-          this.node.tags,
-          buildChild(PropertyWrapper, buildPropertyWrapper([tag], tagProperty)),
-        );
-
-        this.referenceTagPath = TagPath.from(this.path, -1, 0);
-
-        // this.path = finishedPath;
-        targetPath = this.path;
-        break;
-      }
-
-      case LiteralTag:
-        if (typeof tag.value !== 'string') throw new Error();
-
-        this.node.tags = Tags.push(this.node.tags, tag);
-        break;
-
       default:
         throw new Error();
     }
@@ -538,33 +50,4 @@ export const State = class AgastState {
 
     return tag;
   }
-
-  get isGap() {
-    return this.tag.type === GapTag;
-  }
-
-  get speculative() {
-    return !!this.parent;
-  }
-
-  get parentNode() {
-    return this.path.parent.node;
-  }
-
-  get referenceTag() {
-    return this.referenceTagPath?.tag;
-  }
-
-  get bindingPath() {
-    let path = this.referenceTagPath.nextSibling;
-    return path.tag.type === BindingTag ? path : null;
-  }
-
-  get binding() {
-    return this.bindingPath?.tag;
-  }
-
-  get node() {
-    return this.path?.node;
-  }
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-vm",
   "description": "A VM providing DOM-like guarantees about agAST trees",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -11,21 +11,30 @@
     ".": "./lib/index.js"
   },
   "sideEffects": false,
+  "scripts": {
+    "test": "mocha test/*.test.js"
+  },
   "dependencies": {
     "@iter-tools/imm-stack": "1.2.0",
-    "@bablr/agast-helpers": "0.9.0",
-    "@bablr/agast-vm-helpers": "0.9.0"
+    "@bablr/agast-helpers": "0.10.0",
+    "@bablr/agast-vm-helpers": "0.10.0"
   },
   "devDependencies": {
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",
+    "@bablr/boot": "*",
     "enhanced-resolve": "^5.12.0",
+    "expect": "30.1.2",
     "eslint": "^8.32.0",
     "eslint-import-resolver-enhanced-resolve": "^1.0.5",
     "eslint-plugin-import": "^2.27.5",
     "iter-tools-es": "^7.3.1",
+    "mocha": "11.7.2",
     "prettier": "^2.6.2"
   },
-  "repository": "github:bablr-lang/agast-vm",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bablr-lang/agast-vm.git"
+  },
   "homepage": "https://github.com/bablr-lang/agast-vm",
   "license": "MIT"
 }

package/lib/facades.js

@@ -1,3 +0,0 @@
-import { buildFacadeLayer } from '@bablr/agast-vm-helpers/facades';
-
-export const { facades, actuals } = buildFacadeLayer();

package/lib/node.js

@@ -1,215 +0,0 @@
-import {
-  buildPathSegment,
-  get,
-  has,
-  countList,
-  getChildPropertyIndex,
-  getCloseTag,
-  getInitializerTagsIndex,
-  getProperty,
-  getPropertyTagsIndex,
-  relatedNodes,
-  getOpenTag,
-} from '@bablr/agast-helpers/path';
-import * as Tags from '@bablr/agast-helpers/tags';
-import * as BTree from '@bablr/agast-helpers/btree';
-import { CloseNodeTag, GapTag, NullTag, OpenNodeTag } from '@bablr/agast-helpers/symbols';
-import { buildReferenceTag, nodeFlags } from '@bablr/agast-helpers/builders';
-import { nodeStates } from './state.js';
-
-let { freeze } = Object;
-
-export const nodes = new WeakMap();
-
-export class BTreeNodeFacade {}
-
-export class NodeTagsFacade {
-  constructor(node) {
-    nodes.set(this, node);
-
-    if (!Object.isFrozen(node)) throw new Error(); // just a sanity check right now
-
-    let nodeValues = Tags.getValues(node);
-
-    this.openTag = nodeValues[0];
-    this.childrenNode = nodeValues[1];
-    this.closeTag = nodeValues[2];
-
-    this.size = Tags.getSize(node);
-    this.node = node;
-
-    freeze(this);
-  }
-
-  *children() {
-    for (const child of this) {
-      if (![OpenNodeTag, CloseNodeTag, NullTag, GapTag].includes(child.type)) {
-        yield child;
-      }
-    }
-  }
-
-  at(idx, offsetIdx) {
-    return Tags.getAt(idx, this.node, offsetIdx);
-  }
-
-  find(reference, index) {
-    let node = this.node;
-
-    let idx = this.findIndex(reference, index);
-
-    return idx == null ? null : Tags.getAt(idx, node);
-  }
-
-  findIndex(reference, index) {
-    let { type, name } = reference;
-
-    return getPropertyTagsIndex(this.node, type, name, index);
-  }
-
-  [Symbol.iterator]() {
-    return Tags.traverse(this.node);
-  }
-}
-
-export class ListFacade {
-  constructor(tree) {
-    nodes.set(this, tree);
-
-    this.size = BTree.getSize(tree);
-
-    freeze(this);
-  }
-
-  at(idx) {
-    return BTree.getAt(idx, nodes.get(this));
-  }
-
-  [Symbol.iterator]() {
-    return BTree.traverse(nodes.get(this));
-  }
-}
-
-export class NodePropertiesFacade {
-  constructor(node) {
-    nodes.set(this, node);
-
-    freeze(this);
-  }
-
-  get(name, index = undefined, shiftIndex = undefined) {
-    let node = nodes.get(this);
-
-    let prop = getProperty(buildPathSegment(name, index, shiftIndex), node);
-    if (prop) {
-      if (Array.isArray(prop.node) && index === undefined) {
-        return new ListFacade(prop.node);
-      }
-
-      if (Array.isArray(prop.node)) {
-        prop = BTree.getAt(index ?? -1, prop.node);
-      }
-
-      if (!prop) return index === -1 ? prop : null;
-
-      return NodeFacade.from(prop.node);
-    }
-    return null;
-  }
-
-  referenceAt(name, index = undefined) {
-    let path = index == null ? name : buildPathSegment(name, index);
-    return getProperty(path, nodes.get(this))?.reference;
-  }
-
-  has(name, index = undefined) {
-    let path = index == null ? name : buildPathSegment(name, index);
-    return (
-      !!getProperty(path, nodes.get(this)) ||
-      getInitializerTagsIndex(nodes.get(this), buildReferenceTag(null, name)) != null
-    );
-  }
-
-  [Symbol.iterator]() {
-    return relatedNodes(nodes.get(this));
-  }
-}
-
-export class NodeFacade {
-  static from(node) {
-    return node && new NodeFacade(node);
-  }
-
-  constructor(node) {
-    let sigilTag = getOpenTag(node);
-
-    this.sigilTag = sigilTag;
-
-    if ([NullTag, GapTag].includes(sigilTag.type)) {
-      this.flags = nodeFlags;
-      this.type = null;
-    } else if (sigilTag.type === OpenNodeTag) {
-      let { flags, type } = sigilTag.value;
-
-      this.flags = flags;
-      this.type = type;
-    } else {
-      throw new Error();
-    }
-
-    nodes.set(this, node);
-
-    freeze(this);
-  }
-
-  get tags() {
-    return new NodeTagsFacade(nodes.get(this).tags);
-  }
-
-  get properties() {
-    return new NodePropertiesFacade(nodes.get(this));
-  }
-
-  get attributes() {
-    return nodes.get(this).attributes;
-  }
-
-  get undefinedAttributes() {
-    return nodeStates.get(nodes.get(this)).undefinedAttributes;
-  }
-
-  get node() {
-    let node = nodes.get(this);
-
-    let openTag = getOpenTag(node);
-
-    return getCloseTag(node) ||
-      (openTag && ([NullTag, GapTag].includes(openTag.type) || openTag.value.literalValue))
-      ? node
-      : undefined;
-  }
-
-  get(path) {
-    return NodeFacade.from(get(path, nodes.get(this)));
-  }
-
-  has(path) {
-    return NodeFacade.from(has(path, nodes.get(this)));
-  }
-
-  countList(path) {
-    return countList(path, nodes.get(this));
-  }
-
-  getChildPropertyIndex(tagsIndex) {
-    return getChildPropertyIndex(nodes.get(this), tagsIndex);
-  }
-
-  getPropertyTagsIndex(type, name) {
-    return getPropertyTagsIndex(nodes.get(this), type, name);
-  }
-
-  equalTo(node) {
-    return nodes.get(this) === nodes.get(node);
-  }
-}

package/lib/path.js

@@ -1,194 +0,0 @@
-import { Property } from '@bablr/agast-helpers/symbols';
-import { NodeFacade, nodes } from './node.js';
-import { Path, TagPath } from '@bablr/agast-helpers/path';
-import { buildChild, buildFacadeProperty, buildProperty } from '@bablr/agast-helpers/builders';
-
-export { Path, TagPath } from '@bablr/agast-helpers/path';
-
-export { allTagPathsFor, ownTagPathsFor } from '@bablr/agast-helpers/path';
-
-let { freeze } = Object;
-
-let paths = new WeakMap();
-
-export class TagPathFacade {
-  static from(path, tagsIndex, wrapperIndex) {
-    let tagPath = path && TagPath.from(paths.get(path), tagsIndex, wrapperIndex);
-    return tagPath && new TagPathFacade(tagPath);
-  }
-
-  static fromNode(node, tagsIndex, wrapperIndex) {
-    let path = node && TagPath.fromNode(nodes.get(node), tagsIndex, wrapperIndex);
-    return path && new TagPathFacade(path);
-  }
-
-  static wrap(tagPath) {
-    return tagPath && new TagPathFacade(tagPath);
-  }
-
-  constructor(tagPath) {
-    if (!(tagPath instanceof TagPath)) throw new Error();
-    paths.set(this, tagPath);
-
-    let { tag } = tagPath;
-
-    this.path = new PathFacade(tagPath.path);
-    this.node = new NodeFacade(tagPath.node);
-    this.tag =
-      tag.type === Property
-        ? buildChild(
-            Property,
-            buildFacadeProperty(
-              tag.value.reference,
-              tag.value.binding,
-              new NodeFacade(tag.value.node),
-            ),
-          )
-        : tag;
-    this.tagsIndex = tagPath.tagsIndex;
-    this.wrapperIndex = tagPath.wrapperIndex;
-
-    freeze(this);
-  }
-
-  get child() {
-    return this.tag;
-  }
-
-  siblingAt(index) {
-    return TagPathFacade.wrap(paths.get(this).siblingAt(index));
-  }
-
-  get nextSibling() {
-    return TagPathFacade.wrap(paths.get(this).nextSibling);
-  }
-
-  get next() {
-    return TagPathFacade.wrap(paths.get(this).next);
-  }
-
-  get nextUnshifted() {
-    return TagPathFacade.wrap(paths.get(this).nextUnshifted);
-  }
-
-  get previousSibling() {
-    return TagPathFacade.wrap(paths.get(this).previousSibling);
-  }
-
-  get previous() {
-    return TagPathFacade.wrap(paths.get(this).previous);
-  }
-
-  get previousUnshifted() {
-    return TagPathFacade.wrap(paths.get(this).previousUnshifted);
-  }
-
-  get inner() {
-    return PathFacade.wrap(paths.get(this).inner);
-  }
-
-  getWrapped() {}
-
-  equalTo(tagPath) {
-    if (tagPath == null) return false;
-
-    let { path, tagsIndex, wrapperIndex } = paths.get(this);
-    let tagPath_ = paths.get(tagPath);
-    return (
-      path.node === tagPath_.path.node &&
-      tagsIndex === tagPath_.tagsIndex &&
-      wrapperIndex === tagPath_.wrapperIndex
-    );
-  }
-}
-
-export class PathFacade {
-  static from(node) {
-    return node && new PathFacade(Path.from(nodes.get(node)));
-  }
-
-  static wrap(path) {
-    return path && new PathFacade(path);
-  }
-
-  constructor(path) {
-    if (!(path instanceof Path)) throw new Error();
-    this.depth = path.depth;
-
-    this.node = new NodeFacade(path.node);
-    this.parentIndex = path.parentIndex;
-
-    paths.set(this, path);
-
-    freeze(this);
-  }
-
-  get parent() {
-    // not a stable reference. can/should it be?
-    return PathFacade.wrap(paths.get(this).parent);
-  }
-
-  get openTagPath() {
-    return TagPathFacade.wrap(paths.get(this).openTagPath);
-  }
-
-  get openTag() {
-    return paths.get(this).openTag;
-  }
-
-  get closeTagPath() {
-    return TagPathFacade.wrap(paths.get(this).closeTagPath);
-  }
-
-  get closeTag() {
-    return paths.get(this).closeTag;
-  }
-
-  get bindingTag() {
-    return paths.get(this).bindingTag;
-  }
-
-  get binding() {
-    return paths.get(this).binding;
-  }
-
-  get bindingTagPath() {
-    return TagPathFacade.wrap(paths.get(this).bindingTagPath);
-  }
-
-  get parentProperty() {
-    return this.parentPropertyPath.tag;
-  }
-
-  get parentPropertyPath() {
-    return TagPathFacade.wrap(paths.get(this).parentPropertyPath);
-  }
-
-  get referenceTag() {
-    return paths.get(this).referenceTag;
-  }
-
-  get reference() {
-    return paths.get(this).reference;
-  }
-
-  get referenceTagPath() {
-    return TagPathFacade.wrap(paths.get(this).referenceTagPath);
-  }
-
-  get(path, shiftIndex = null) {
-    return new PathFacade(paths.get(this).get(path, shiftIndex));
-  }
-
-  tagPathAt(tagsIndex, wrapperIndex) {
-    return TagPathFacade.wrap(TagPath.from(paths.get(this), tagsIndex, wrapperIndex));
-  }
-
-  tagAt(tagsIndex, wrapperIndex) {
-    return this.tagPathAt(tagsIndex, wrapperIndex).tag;
-  }
-
-  atDepth(depth) {
-    return new PathFacade(paths.get(this).atDepth(depth));
-  }
-}