occam-verify-cli 1.0.185 → 1.0.198

package/src/dom/axiom.js

@@ -4,34 +4,12 @@ import { arrayUtilities } from "necessary";
 
 import TopLevelAssertion  from "./topLevelAssertion";
 
-import { nodeQuery } from "../utilities/query";
-import { SATISFIABLE } from "../constants";
 import { domAssigned } from "../dom";
-import { labelsFromJSON,
-         deductionFromJSON,
-         satisfiableFromJSON,
-         labelsToLabelsJSON,
-         suppositionsFromJSON,
-         deductionToDeductionJSON,
-         suppositionsToSuppositionsJSON } from "../utilities/json";
 import { satisfiesAssertionFromStatement } from "../utilities/context";
-import { proofFromNode, labelsFromNode, deductionFromNode, suppositionsFromNode, stringFromLabelsAndDeduction } from "./topLevelAssertion";
 
 const { match, backwardsSome } = arrayUtilities;
 
-const firstPrimaryKeywordTerminalNodeQuery = nodeQuery("/axiom/@primary-keyword[0]");
-
 export default domAssigned(class Axiom extends TopLevelAssertion {
-  constructor(fileContext, string, labels, suppositions, deduction, proof, satisfiable) {
-    super(fileContext, string, labels, suppositions, deduction, proof);
-
-    this.satisfiable = satisfiable;
-  }
-
-  isSatisfiable() {
-    return this.satisfiable;
-  }
-
   verify() {
     let verified;
 
@@ -163,7 +141,9 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     statementAndStepsOrSubproofsUnified = super.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
 
     if (statementAndStepsOrSubproofsUnified) {
-      if (this.satisfiable) {
+      const satisfiable = this.isSatisfiable();
+
+      if (satisfiable) {
         const substitutionsMatch = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {
           const stepSubstep = stepOrSubproof.isStep();
 
@@ -189,64 +169,14 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     return statementAndStepsOrSubproofsUnified;
   }
 
-  toJSON() {
-    let labels = this.getLabels(),
-        deduction = this.getDeduction(),
-        suppositions = this.getSuppositions();
-
-    const labelsJSON = labelsToLabelsJSON(labels),
-          deductionJSON = deductionToDeductionJSON(deduction),
-          suppositionsJSON = suppositionsToSuppositionsJSON(suppositions);
-
-    labels = labelsJSON;  ///
-    deduction = deductionJSON;  ///
-    suppositions = suppositionsJSON;  ///
-
-    const satisfiable = this.satisfiable,
-          json = {
-            labels,
-            deduction,
-            suppositions,
-            satisfiable
-          };
-
-    return json;
-  }
-
   static name = "Axiom";
 
-  static fromJSON(json, fileContext) {
-    const labels = labelsFromJSON(json, fileContext),
-          suppositions = suppositionsFromJSON(json, fileContext),
-          deduction = deductionFromJSON(json, fileContext),
-          proof = null,
-          satisfiable = satisfiableFromJSON(json, fileContext),
-          string = stringFromLabelsAndDeduction(labels, deduction),
-          topLevelAssertion = new Axiom(fileContext, string, labels, suppositions, deduction, proof, satisfiable);
-
-    return topLevelAssertion;
-  }
+  static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Axiom, json, fileContext); }
 
   static fromAxiomNode(axiomNode, fileContext) {
     const node = axiomNode, ///
-          proof = proofFromNode(node, fileContext),
-          labels = labelsFromNode(node, fileContext),
-          deduction = deductionFromNode(node, fileContext),
-          satisfiable = satisfiableFromNode(node, fileContext),
-          suppositions = suppositionsFromNode(node, fileContext),
-          string = stringFromLabelsAndDeduction(labels, deduction),
-          topLevelAssertion = new Axiom(fileContext, string, labels, suppositions, deduction, proof, satisfiable);
-
-    return topLevelAssertion;
+          axiom = TopLevelAssertion.fromNode(Axiom, node, fileContext);
+
+    return axiom;
   }
 });
-
-export function satisfiableFromNode(node, fileContext) {
-  const firstPrimaryKeywordTerminalNode = firstPrimaryKeywordTerminalNodeQuery(node),
-        content = firstPrimaryKeywordTerminalNode.getContent(),
-        contentSatisfiable = (content === SATISFIABLE),
-        satisfiable = contentSatisfiable; ///
-
-  return satisfiable;
-}
-

package/src/dom/conjecture.js

@@ -31,5 +31,10 @@ export default domAssigned(class Conjecture extends TopLevelAssertion {
 
   static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Conjecture, json, fileContext); }
 
-  static fromNode(node, fileContext) { return TopLevelAssertion.fromNode(Conjecture, node, fileContext); }
+  static fromConjectureNode(conjectureNode, fileContext) {
+    const node = conjectureNode,  ///
+          conjecture = TopLevelAssertion.fromNode(Conjecture, node, fileContext);
+
+    return conjecture;
+  }
 });

package/src/dom/constructor/bracketed.js

@@ -4,11 +4,8 @@ import dom from "../../dom";
 import Constructor from "../constructor";
 import constructorBracketedContext from "../../context/bracketed/constructor";
 
-import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
 
-const termNodeQuery = nodeQuery("/term/argument/term");
-
 export default domAssigned(class BracketedConstructor extends Constructor {
   unifyTerm(term, context, verifyAhead) {
     let termUnified;
@@ -23,11 +20,13 @@ export default domAssigned(class BracketedConstructor extends Constructor {
       const { Term } = dom,
             bracketedTerm = term, ///
             bracketedTermNode = bracketedTerm.getNode(),
-            termNode = termNodeQuery(bracketedTermNode); ///
+            singularTermNode = bracketedTermNode.getSingularTermNode();
+
+      if (singularTermNode !== null) {
+        const termNode = singularTermNode;  ///
 
-      term = Term.fromTermNode(termNode, context);
+        term = Term.fromTermNode(termNode, context);
 
-      if (term !== null) {
         const termVVerified = term.verify(context, () => {
           let verifiedAhead;
 
@@ -60,8 +59,7 @@ export default domAssigned(class BracketedConstructor extends Constructor {
           context = constructorBracketedContext, ///
           term = Term.fromTermNode(termNode, context),
           string = term.getString(),
-          provisional = null,
-          bracketedConstructor = new BracketedConstructor(string, term, provisional);
+          bracketedConstructor = new BracketedConstructor(string, term);
 
     return bracketedConstructor;
   }

package/src/dom/declaration/complexType.js

@@ -3,7 +3,7 @@
 import dom from "../../dom";
 
 import { domAssigned } from "../../dom";
-import { superTypesStringFromSuperTypes } from "../../utilities/type";
+import { superTypesStringFromSuperTypes, stringFromTypeNameNameAndSuperTypes } from "../../utilities/type";
 
 export default domAssigned(class ComplexTypeDeclaration {
   constructor(fileContext, string, type) {
@@ -145,11 +145,11 @@ export default domAssigned(class ComplexTypeDeclaration {
 
     this.fileContext.trace(`Verifying the '${propertyString}' property...`);
 
-    const propertyNames = property.getNames(),
+    const propertyName = property.getName(),
           count = properties.reduce((count, property) => {
-            const propertyNamesMatch = property.matchPropertyNames(propertyNames);
+            const propertyNameMatches = property.matchPropertyName(propertyName);
 
-            if (propertyNamesMatch) {
+            if (propertyNameMatches) {
               count++;
             }
 
@@ -160,7 +160,7 @@ export default domAssigned(class ComplexTypeDeclaration {
       this.fileContext.debug(`The '${propertyString}' property appears more than once.`);
     } else {
       const superTypeProperty = superTypeProperties.find((superTypeProperty) => {
-        const propertyNameMatches = superTypeProperty.matchPropertyNames(propertyNames);
+        const propertyNameMatches = superTypeProperty.matchPropertyName(propertyName);
 
         if (propertyNameMatches) {
           return true;
@@ -259,9 +259,10 @@ export default domAssigned(class ComplexTypeDeclaration {
 
   static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
     const { Type } = dom,
-          node = complexTypeDeclarationNode,  ///
-          string = fileContext.nodeAsString(node),
           type = Type.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
+          typeName = type.getName(),
+          superTypes = type.getSuperTypes(),
+          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           complexTypeDeclaration = new ComplexTypeDeclaration(fileContext, string, type);
 
     return complexTypeDeclaration;

package/src/dom/declaration/constructor.js

@@ -78,10 +78,9 @@ export default domAssigned(class ConstructorDeclaration {
     type = this.constructor.getType();
 
     const typeName = type.getName(),
-          typeString = type.getString(),
-          constructorString = this.constructor.getString();
+          typeString = type.getString();
 
-    this.fileContext.trace(`Verifying the '${constructorString}' constructor's '${typeString}' type...`);
+    this.fileContext.trace(`Verifying the '${typeString}' type...`);
 
     const includeSupertypes = false,
           provisional = type.isProvisional(includeSupertypes);
@@ -91,14 +90,14 @@ export default domAssigned(class ConstructorDeclaration {
     const typePresent = (type !== null)
 
     if (!typePresent) {
-      this.fileContext.debug(`The '${constructorString}' constructor's '${typeString}' type is not present.`);
+      this.fileContext.debug(`The '${typeString}' type is not present.`);
     } else {
       const provisionalMatches = type.matchProvisional(provisional);
 
       if (!provisionalMatches) {
         provisional ?
-          this.fileContext.debug(`The '${constructorString}' constructor's '${typeString}' type is present but it should be provisional.`) :
-            this.fileContext.debug(`The '${constructorString}' constructor's '${typeString}' type is present but it should not be provisional.`);
+          this.fileContext.debug(`The '${typeString}' type is present but it should be provisional.`) :
+            this.fileContext.debug(`The '${typeString}' type is present but it should not be provisional.`);
       } else {
         this.constructor.setType(type);
 
@@ -107,7 +106,7 @@ export default domAssigned(class ConstructorDeclaration {
     }
 
     if (constructorTypeVerified) {
-      this.fileContext.debug(`...verified the '${constructorString}' constructor's '${typeString}' type.`);
+      this.fileContext.debug(`...verified the '${typeString}' type.`);
     }
 
     return constructorTypeVerified;

package/src/dom/declaration/metavariable.js

@@ -2,12 +2,8 @@
 
 import dom from "../../dom";
 
-import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
 
-const termNodeQuery = nodeQuery("/metavariable/argument/term"),
-      metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType");
-
 export default domAssigned(class MetavariableDeclaration {
   constructor(fileContext, string, metavariable) {
     this.fileContext = fileContext;
@@ -84,7 +80,7 @@ export default domAssigned(class MetavariableDeclaration {
     this.fileContext.trace(`Verifying the '${metavariableString}' metavariable when declared...`);
 
     const metavariableNode = metavariable.getNode(), ///
-          termNode = termNodeQuery(metavariableNode);
+          termNode = metavariableNode.getTermNode();
 
     if (termNode !== null) {
       this.fileContext.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`);
@@ -140,7 +136,7 @@ function stringFromMetavariableAndMetaType(metavariable, metaType) {
 
 function metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
   const { MetaType } = dom,
-        metaTypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
+        metaTypeNode = metavariableDeclarationNode.getMetaTypeNode(),
         metaType = MetaType.fromMetaTypeNode(metaTypeNode, fileContext);
 
   return metaType;

package/src/dom/declaration/type.js

@@ -4,6 +4,7 @@ import dom from "../../dom";
 
 import { domAssigned } from "../../dom";
 import { superTypesStringFromSuperTypes } from "../../utilities/type";
+import { stringFromTypeNameNameAndSuperTypes } from "../../utilities/type";
 
 export default domAssigned(class TypeDeclaration {
   constructor(fileContext, string, type) {
@@ -139,8 +140,9 @@ export default domAssigned(class TypeDeclaration {
   static fromTypeDeclarationNode(typeDeclarationNode, fileContext) {
     const { Type } = dom,
           type = Type.fromTypeDeclarationNode(typeDeclarationNode, fileContext),
-          node = typeDeclarationNode, ///
-          string = fileContext.nodeAsString(node),
+          typeName = type.getName(),
+          superTypes = type.getSuperTypes(),
+          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           typeDeclaration = new TypeDeclaration(fileContext, string, type);
 
     return typeDeclaration;

package/src/dom/declaration/variable.js

@@ -80,10 +80,9 @@ export default domAssigned(class VariableDeclaration {
     type = this.variable.getType();
 
     const typeName = type.getName(),
-          typeString = type.getString(),
-          variableString = this.variable.getString();
+          typeString = type.getString();
 
-    this.fileContext.trace(`Verifying the '${variableString}' variable's '${typeString}' type...`);
+    this.fileContext.trace(`Verifying the '${typeString}' type...`);
 
     const includeSupertypes = false,
           provisional = type.isProvisional(includeSupertypes);
@@ -93,14 +92,14 @@ export default domAssigned(class VariableDeclaration {
     const typePresent = (type !== null)
 
     if (!typePresent) {
-      this.fileContext.debug(`The '${variableString}' variable's '${typeString}' type is not present.`);
+      this.fileContext.debug(`The '${typeString}' type is not present.`);
     } else {
       const provisionalMatches = type.matchProvisional(provisional);
 
       if (!provisionalMatches) {
         provisional ?
-          this.fileContext.debug(`The '${variableString}' variable's '${typeString}' type is present but it should be provisional.`) :
-            this.fileContext.debug(`The '${variableString}' variable's '${typeString}' type is present but it should not be provisional.`);
+          this.fileContext.debug(`The '${typeString}' type is present but it should be provisional.`) :
+            this.fileContext.debug(`The '${typeString}' type is present but it should not be provisional.`);
       } else {
         this.variable.setType(type);
 
@@ -109,7 +108,7 @@ export default domAssigned(class VariableDeclaration {
     }
 
     if (variableTypeVerified) {
-      this.fileContext.debug(`...verified the '${variableString}' variable's '${typeString}' type.`);
+      this.fileContext.debug(`...verified the '${typeString}' type.`);
     }
 
     return variableTypeVerified;

package/src/dom/declaration.js

@@ -3,12 +3,9 @@
 import dom from "../dom";
 import Substitutions from "../substitutions";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { unifyStatementIntrinsically } from "../utilities/unification";
 
-const judgementDeclarationNodeQuery = nodeQuery("/judgement/declaration");
-
 export default domAssigned(class Declaration {
   constructor(string, reference, statement) {
     this.string = string;
@@ -88,15 +85,14 @@ export default domAssigned(class Declaration {
   verifyReference(assignments, stated, context) {
     let referenceVerified;
 
-    const referenceString = this.reference.getString(),
-          declarationString = this.string;  ///
+    const referenceString = this.reference.getString();
 
-    context.trace(`Verifying the '${declarationString}' declaration's '${referenceString}' reference...`);
+    context.trace(`Verifying the '${referenceString}' reference...`);
 
     referenceVerified = this.reference.verify(context);
 
     if (referenceVerified) {
-      context.debug(`...verified the '${declarationString}' declaration's '${referenceString}' reference.`);
+      context.debug(`...verified the '${referenceString}' reference.`);
     }
 
     return referenceVerified;
@@ -105,10 +101,9 @@ export default domAssigned(class Declaration {
   verifyStatement(assignments, stated, context) {
     let statementVerified;
 
-    const statementString = this.statement.getString(),
-          declarationString = this.string;  ///
+    const statementString = this.statement.getString();
 
-    context.trace(`Verifying the '${declarationString}' declaration's '${statementString}' statement...`);
+    context.trace(`Verifying the '${statementString}' statement...`);
 
     stated = true;  ///
 
@@ -117,7 +112,7 @@ export default domAssigned(class Declaration {
     statementVerified = this.statement.verify(assignments, stated, context);
 
     if (statementVerified) {
-      context.debug(`...verified the '${declarationString}' declaration's '${statementString}' statement.`);
+      context.debug(`...verified the '${statementString}' statement.`);
     }
 
     return statementVerified;
@@ -177,10 +172,9 @@ export default domAssigned(class Declaration {
 
     const context = generalContext,  ///
           statementString = statement.getString(),
-          declarationString = this.string,  ///
           declarationStatementString = this.statement.getString();
 
-    context.trace(`Unifying the '${statementString}' statement with the '${declarationString}' declaration's '${declarationStatementString}' statement...`);
+    context.trace(`Unifying the '${statementString}' statement with the '${declarationStatementString}' statement...`);
 
     const generalStatement = this.statement,
           specificStatement = statement,  ///
@@ -189,7 +183,7 @@ export default domAssigned(class Declaration {
     statementUnified = statementUUnifiedIntrinsically;  ///
 
     if (statementUnified) {
-      context.debug(`...unified the '${statementString}' statement with the '${declarationString}' declaration's '${declarationStatementString}' statement.`);
+      context.debug(`...unified the '${statementString}' statement with the '${declarationStatementString}' statement.`);
     }
 
     return statementUnified;
@@ -200,17 +194,16 @@ export default domAssigned(class Declaration {
 
     const context = generalContext, ///
           labelString = label.getString(),
-          referenceString = this.reference.getString(),
-          declarationString = this.string;  ///
+          referenceString = this.reference.getString();
 
-    context.trace(`Unifying the '${labelString}' label with the '${declarationString}' declaration's '${referenceString}' reference...`);
+    context.trace(`Unifying the '${labelString}' label with the '${referenceString}' reference...`);
 
     const labelUnified = this.reference.unifyLabel(label, substitutions, context);
 
     labelUnifiedWithReference = labelUnified; ///
 
     if (labelUnifiedWithReference) {
-      context.debug(`...unified the '${labelString}' label with the '${declarationString}' declaration's '${referenceString}' reference.`);
+      context.debug(`...unified the '${labelString}' label with the '${referenceString}' reference.`);
     }
 
     return labelUnifiedWithReference;
@@ -255,8 +248,7 @@ export default domAssigned(class Declaration {
   static name = "Declaration";
 
   static fromJudgementNode(judgementNode, context) {
-    const judgementDeclarationNode = judgementDeclarationNodeQuery(judgementNode),
-          declarationNode = judgementDeclarationNode, ///
+    const declarationNode = judgementNode.getDeclarationNode(),
           declaration = declarationFromDeclarationNode(declarationNode, context);
 
     return declaration;

package/src/dom/derivation.js

@@ -4,14 +4,11 @@ import { arrayUtilities } from "necessary";
 
 import dom from "../dom";
 
-import { nodesQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { assignAssignments } from "../utilities/assignments";
 
 const { last } = arrayUtilities;
 
-const stepOrSubproofNodesQuery = nodesQuery("/derivation/step|subproof");
-
 export default domAssigned(class Derivation {
   constructor(stepsOrSubproofs) {
     this.stepsOrSubproofs = stepsOrSubproofs;
@@ -65,7 +62,7 @@ export default domAssigned(class Derivation {
 
 function stepsOrSubproofsFromDerivationNode(derivationNode, fileContext) {
   const { Step, Subproof } = dom,
-        stepOrSubproofNodes = stepOrSubproofNodesQuery(derivationNode),
+        stepOrSubproofNodes = derivationNode.getStepOrSubproofNodes(),
         stepsOrSubproofs = stepOrSubproofNodes.map((stepOrSubproofNode) => {
           let stepOrSubproof;
 

package/src/dom/equality.js

@@ -4,15 +4,9 @@ import dom from "../dom";
 import EqualityAssignment from "../assignment/equality";
 import VariableAssignment from "../assignment/variable";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { unifyEquality } from "../utilities/unification";
 
-const equalityNodeQuery = nodeQuery("/statement/equality"),
-      variableNodeQuery = nodeQuery("/term/variable!"),
-      leftTermNodeQuery = nodeQuery("/equality/term[0]"),
-      rightTermNodeQuery = nodeQuery("/equality/term[1]");
-
 export default domAssigned(class Equality {
   constructor(string, leftTerm, rightTerm) {
     this.string = string;
@@ -179,23 +173,25 @@ export default domAssigned(class Equality {
           type = this.getType(),
           leftTermNode = this.leftTerm.getNode(),
           rightTermNode = this.rightTerm.getNode(),
-          leftVariableNode = variableNodeQuery(leftTermNode),
-          rightVariableNode = variableNodeQuery(rightTermNode),
-          leftVariable = Variable.fromVariableNodeAndType(leftVariableNode, type, context),
-          rightVariable = Variable.fromVariableNodeAndType(rightVariableNode, type, context);
+          leftTermNodeSingularVariableNode = leftTermNode.getSingularVariableNode(),
+          rightTermNodeSingularVariableNode = rightTermNode.getSingularVariableNode(),
+          leftVariableNode = leftTermNodeSingularVariableNode,  ///
+          rightVariableNode = rightTermNodeSingularVariableNode;  ///
 
     let assignment;
 
-    if (leftVariable !== null) {
-      const leftVariableAssignment = VariableAssignment.fromVariable(leftVariable);
+    if (leftVariableNode !== null) {
+      const leftVariable = Variable.fromVariableNodeAndType(leftVariableNode, type, context),
+            leftVariableAssignment = VariableAssignment.fromVariable(leftVariable);
 
       assignment = leftVariableAssignment;  ///
 
       assignments.push(assignment);
     }
 
-    if (rightVariable !== null) {
-      const rightVariableAssignment = VariableAssignment.fromVariable(rightVariable);
+    if (rightVariableNode !== null) {
+      const rightVariable = Variable.fromVariableNodeAndType(rightVariableNode, type, context),
+            rightVariableAssignment = VariableAssignment.fromVariable(rightVariable);
 
       assignment = rightVariableAssignment;  ///
 
@@ -215,7 +211,7 @@ export default domAssigned(class Equality {
   static fromStatementNode(statementNode, context) {
     let equality = null;
 
-    const equalityNode = equalityNodeQuery(statementNode);
+    const equalityNode = statementNode.getEqualityNode();
 
     if (equalityNode !== null) {
       const node = equalityNode,  ///
@@ -232,7 +228,7 @@ export default domAssigned(class Equality {
 
 function leftTermFromEqualityNode(equalityNode, context) {
   const { Term } = dom,
-        leftTermNode = leftTermNodeQuery(equalityNode),
+        leftTermNode = equalityNode.getLeftTermNode(),
         leftTerm = Term.fromTermNode(leftTermNode, context);
 
   return leftTerm;
@@ -240,7 +236,7 @@ function leftTermFromEqualityNode(equalityNode, context) {
 
 function rightTermFromEqualityNode(equalityNode, context) {
   const { Term } = dom,
-        rightTermNode = rightTermNodeQuery(equalityNode),
+        rightTermNode = equalityNode.getRightTermNode(),
         rightTerm = Term.fromTermNode(rightTermNode, context);
 
   return rightTerm;

package/src/dom/frame.js

@@ -7,13 +7,6 @@ import dom from "../dom";
 import { S, NOTHING } from "../constants";
 import { domAssigned } from "../dom";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-
-const declarationNodesQuery = nodesQuery("/frame/declaration"),
-      metavariableNodesQuery = nodesQuery("/frame/metavariable"),
-      judgementFrameNodeQuery = nodeQuery("/judgement/frame"),
-      definedAssertionFrameNodeQuery = nodeQuery("/definedAssertion/frame"),
-      containedAssertionFrameNodeQuery = nodeQuery("/containedAssertion/frame");
 
 const { first } = arrayUtilities;
 
@@ -221,10 +214,9 @@ export default domAssigned(class Frame {
       const sOrNothing = (declarationsLength > 1) ?
                            S :
                              NOTHING,
-            frameString = this.string,  ///
             declarationsString = declarationsStringFromDeclarations(this.declarations);
 
-      context.trace(`Verifying the '${frameString}' frame's '${declarationsString}' declaration${sOrNothing}...`);
+      context.trace(`Verifying the '${declarationsString}' declaration${sOrNothing}...`);
 
       stated = true;  ///
 
@@ -237,7 +229,7 @@ export default domAssigned(class Frame {
       });
 
       if (declarationsVerified) {
-        context.debug(`...verified the '${frameString}' frame's '${declarationsString}' declaration${sOrNothing}.`);
+        context.debug(`...verified the '${declarationsString}' declaration${sOrNothing}.`);
       }
     }
 
@@ -253,10 +245,9 @@ export default domAssigned(class Frame {
       const sOrNothing = (metavariablesLength > 1) ?
                            S :
                              NOTHING,
-            frameString = this.string,  ///
             metavariablesString = metavariablesStringFromMetavariables(this.metavariables);
 
-      context.trace(`Verifying the '${frameString}' frame's '${metavariablesString}' metavariable${sOrNothing}...`);
+      context.trace(`Verifying the '${metavariablesString}' metavariable${sOrNothing}...`);
 
       metavariablesVerified = this.metavariables.every((metavariable) => {
         const metavariableVerified = metavariable.verify(context);
@@ -265,7 +256,7 @@ export default domAssigned(class Frame {
       });
 
       if (metavariablesVerified) {
-        context.debug(`...verified the '${frameString}' frame's '${metavariablesString}' metavariable${sOrNothing}.`);
+        context.debug(`...verified the '${metavariablesString}' metavariable${sOrNothing}.`);
       }
     }
 
@@ -308,8 +299,7 @@ export default domAssigned(class Frame {
   }
 
   static fromJudgementNode(judgementNode, context) {
-    const judgementFrameNode = judgementFrameNodeQuery(judgementNode),
-          frameNode = judgementFrameNode,
+    const frameNode = judgementNode.getFrameNode(),
           frame = frameFromFrameNode(frameNode, context);
 
     return frame;
@@ -318,11 +308,9 @@ export default domAssigned(class Frame {
   static fromDefinedAssertionNode(definedAssertionNode, context) {
     let frame = null;
 
-    const definedAssertionFrameNode = definedAssertionFrameNodeQuery(definedAssertionNode);
-
-    if (definedAssertionFrameNode !== null) {
-      const frameNode = definedAssertionFrameNode;  ///
+    const frameNode = definedAssertionNode.getFrameNode();
 
+    if (frameNode !== null) {
       frame = frameFromFrameNode(frameNode, context);
     }
 
@@ -332,11 +320,9 @@ export default domAssigned(class Frame {
   static fromContainedAssertionNode(containedAssertionNode, context) {
     let frame = null;
 
-    const containedAssertionFrameNode = containedAssertionFrameNodeQuery(containedAssertionNode);
-
-    if (containedAssertionFrameNode !== null) {
-      const frameNode = containedAssertionFrameNode;  ///
+    const frameNode = containedAssertionNode.getFrameNode();
 
+    if (frameNode !== null) {
       frame = frameFromFrameNode(frameNode, context)
     }
 
@@ -358,7 +344,7 @@ function frameFromFrameNode(frameNode, context) {
 
 function declarationsFromFrameNode(frameNode, context) {
   const { Declaration } = dom,
-        declarationNodes = declarationNodesQuery(frameNode),
+        declarationNodes = frameNode.getDeclarationNodes(),
         declarations = declarationNodes.map((declarationNode) => {
           const declaration = Declaration.fromDeclarationNode(declarationNode, context);
 
@@ -370,7 +356,7 @@ function declarationsFromFrameNode(frameNode, context) {
 
 function metavariablesFromFrameNode(frameNode, context) {
   const { Metavariable } = dom,
-        metavariableNodes = metavariableNodesQuery(frameNode),
+        metavariableNodes = frameNode.getMetavariableNodes(),
         metavariables = metavariableNodes.map((metavariableNode) => {
           const metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);