occam-verify-cli 0.0.317 → 0.0.319

package/src/verify/declaration/topLevel.js

@@ -1,7 +1,5 @@
 "use strict";
 
-import { nodeQuery } from "../../utilities/query";
-
 import verifyRule from "../../verify/rule";
 import verifyAxiom from "../../verify/axiom";
 import verifyTypeDeclaration from "../../verify/declaration/type";
@@ -9,6 +7,8 @@ import verifyVariableDeclaration from "../../verify/declaration/variable";
 import verifyCombinatorDeclaration from "../../verify/declaration/combinator";
 import verifyConstructorDeclaration from "../../verify/declaration/constructor";
 
+import { nodeQuery } from "../../utilities/query";
+
 const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
       axiomNodeQuery = nodeQuery("/topLevelDeclaration/axiom!"),
       typeDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/typeDeclaration!"),
@@ -16,9 +16,11 @@ const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
       combinatorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/combinatorDeclaration!"),
       constructorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/constructorDeclaration!");
 
-export default function verifyTopLevelDeclaration(topLevelDeclarationNode, context) {
+export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileContext) {
   let topLevelDeclarationVerified = false;
 
+  fileContext.begin(topLevelDeclarationNode);
+
   const node = topLevelDeclarationNode, ///
         ruleNode = ruleNodeQuery(node),
         axiomNode = axiomNodeQuery(node),
@@ -30,30 +32,34 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, conte
   if (false) {
     ///
   } else if (ruleNode !== null) {
-    const ruleVerified = verifyRule(ruleNode, context);
+    const ruleVerified = verifyRule(ruleNode, fileContext);
 
     topLevelDeclarationVerified = ruleVerified;  ///
   } else if (axiomNode !== null) {
-    const axiomVerified = verifyAxiom(axiomNode, context);
+    const axiomVerified = verifyAxiom(axiomNode, fileContext);
 
     topLevelDeclarationVerified = axiomVerified;  ///
   } else if (typeDeclarationNode !== null) {
-    const typeDeclarationVerified = verifyTypeDeclaration(typeDeclarationNode, context);
+    const typeDeclarationVerified = verifyTypeDeclaration(typeDeclarationNode, fileContext);
 
     topLevelDeclarationVerified = typeDeclarationVerified;  ///
   } else if (variableDeclarationNode !== null) {
-    const variableDeclarationVerified = verifyVariableDeclaration(variableDeclarationNode, context);
+    const variableDeclarationVerified = verifyVariableDeclaration(variableDeclarationNode, fileContext);
 
     topLevelDeclarationVerified = variableDeclarationVerified;  ///
   } else if (combinatorDeclarationNode !== null) {
-    const combinatorDeclarationVerified = verifyCombinatorDeclaration(combinatorDeclarationNode, context);
+    const combinatorDeclarationVerified = verifyCombinatorDeclaration(combinatorDeclarationNode, fileContext);
 
     topLevelDeclarationVerified = combinatorDeclarationVerified;  ///
   } else if (constructorDeclarationNode !== null) {
-    const constructorDeclarationVerified = verifyConstructorDeclaration(constructorDeclarationNode, context);
+    const constructorDeclarationVerified = verifyConstructorDeclaration(constructorDeclarationNode, fileContext);
 
     topLevelDeclarationVerified = constructorDeclarationVerified;  ///
   }
 
+  topLevelDeclarationVerified ?
+    fileContext.complete(topLevelDeclarationNode) :
+      fileContext.halt(topLevelDeclarationNode);
+
   return topLevelDeclarationVerified;
 }

package/src/verify/declaration/type.js

@@ -7,13 +7,23 @@ import { nodeQuery } from "../../utilities/query";
 const firstTypeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
       secondTypeNodeQuery = nodeQuery("/typeDeclaration/type[1]");
 
-export default function verifyTypeDeclaration(typeDeclarationNode, context) {
+export default function verifyTypeDeclaration(typeDeclarationNode, fileContext) {
+  let typeDeclarationVerified;
+
+  fileContext.begin(typeDeclarationNode);
+
   const firstTypeNode = firstTypeNodeQuery(typeDeclarationNode),
         secondTypeNode = secondTypeNodeQuery(typeDeclarationNode),
         typeNode = firstTypeNode, ///
-        superTypeNode = secondTypeNode, ///
-        typeVerified = verifyType(typeNode, superTypeNode, context),
-        typeDeclarationVerified = typeVerified; ///
+        superTypeNode = secondTypeNode; ///
+
+  const typeVerified = verifyType(typeNode, superTypeNode, fileContext);
+
+  typeDeclarationVerified = typeVerified; ///
+
+  typeDeclarationVerified ?
+    fileContext.complete(typeDeclarationNode) :
+      fileContext.halt(typeDeclarationNode);
 
   return typeDeclarationVerified;
 }

package/src/verify/declaration/variable.js

@@ -7,11 +7,20 @@ import { nodeQuery } from "../../utilities/query";
 const typeNodeQuery = nodeQuery("/variableDeclaration/type"),
       variableNodeQuery = nodeQuery("/variableDeclaration/variable");
 
-export default function verifyVariableDeclaration(variableDeclarationNode, context) {
+export default function verifyVariableDeclaration(variableDeclarationNode, fileContext) {
+  let variableDeclarationVerified;
+
+  fileContext.begin(variableDeclarationNode);
+
   const typeNode = typeNodeQuery(variableDeclarationNode),
         variableNode = variableNodeQuery(variableDeclarationNode),
-        variableVVerified = verifyVariable(variableNode, typeNode, context),
-        variableDeclarationVerified = variableVVerified;  ///
+        variableVVerified = verifyVariable(variableNode, typeNode, fileContext);
+
+  variableDeclarationVerified = variableVVerified;  ///
+
+  variableDeclarationVerified ?
+    fileContext.complete(variableDeclarationNode) :
+      fileContext.halt(variableDeclarationNode);
 
   return variableDeclarationVerified;
 }

package/src/verify/equality.js

@@ -8,11 +8,14 @@ import { first, second } from "../utilities/array";
 const firstTermNodeQuery = nodeQuery("/equality/term[0]"),
       secondTermNodeQuery = nodeQuery("/equality/term[1]");
 
-export default function verifyEquality(equalityNode, context) {
+export default function verifyEquality(equalityNode, proofContext) {
   let equalityVerified = false;
 
+  proofContext.begin(equalityNode);
+
   const types = [],
         values = [],
+        context = proofContext,
         firstTermNode = firstTermNodeQuery(equalityNode),
         secondTermNode = secondTermNodeQuery(equalityNode),
         firstTermVerified = verifyTerm(firstTermNode, types, values, context),
@@ -24,10 +27,10 @@ export default function verifyEquality(equalityNode, context) {
           firstTypeEqualToSubTypeOfOrSuperTypeOfSecondType = firstType.isEqualToSubTypeOfOrSuperTypeOf(secondType);
 
     if (firstTypeEqualToSubTypeOfOrSuperTypeOfSecondType) {
-      const derived = context.isDerived();
+      const derived = proofContext.isDerived();
 
       if (derived) {
-        const termsEqual = equateTerms(firstTermNode, secondTermNode, context);
+        const termsEqual = equateTerms(firstTermNode, secondTermNode, proofContext);
 
         if (termsEqual) {
           equalityVerified = true;
@@ -38,10 +41,14 @@ export default function verifyEquality(equalityNode, context) {
     }
   }
 
+  equalityVerified ?
+    proofContext.complete(equalityNode) :
+      proofContext.halt(equalityNode);
+
   return equalityVerified;
 }
 
-function equateTerms(firstTermNode, secondTermNode, context) {
+function equateTerms(firstTermNode, secondTermNode, proofContext) {
   let termsEqual = true;  ///
 
   debugger

package/src/verify/file.js

@@ -1,35 +1,33 @@
 "use strict";
 
 import FileContext from "../context/file";
-import ReleaseContext from "../context/release";
-import verifyTopLevelDeclaration from "../verify/declaration/topLevel";
+import verifyTopLevelDeclaration from "./declaration/topLevel";
 
 import { nodesQuery } from "../utilities/query";
 
 const topLevelDeclarationNodesQuery = nodesQuery("/document/topLevelDeclaration");
 
-export default function verifyFile(filePath, releaseContext = ReleaseContext.fromNothing()) {
-  let fileVerified = false;
+export default function verifyFile(filePath, releaseContext) {
+  let fileVerified;
 
   releaseContext.debug(`Verifying the '${filePath}' file...`);
 
   const fileContext = FileContext.fromReleaseContextAndFilePath(releaseContext, filePath),
-        context = fileContext,  ///
         node = fileContext.getNode(),
         topLevelDeclarationNodes = topLevelDeclarationNodesQuery(node),
         topLevelDeclarationsVerified = topLevelDeclarationNodes.every((topLevelDeclarationNode) => {
-          const topLevelDeclarationVerified = verifyTopLevelDeclaration(topLevelDeclarationNode, context);
+          const topLevelDeclarationVerified = verifyTopLevelDeclaration(topLevelDeclarationNode, fileContext);
 
           if (topLevelDeclarationVerified) {
             return true;
           }
         })
 
+  fileVerified = topLevelDeclarationsVerified;  ///
+
   if (topLevelDeclarationsVerified) {
     releaseContext.addFileContext(fileContext);
 
-    fileVerified = true;
-
     releaseContext.info(`Verified the '${filePath}' file.`);
   }
 

package/src/verify/label.js

@@ -2,20 +2,26 @@
 
 import { labelNameFromLabelNode } from "../utilities/query";
 
-export default function verifyLabel(labelNode, labels, context) {
+export default function verifyLabel(labelNode, labels, fileContext) {
   let labelVerified = false;
 
+  fileContext.begin(labelNode);
+
   const labelName = labelNameFromLabelNode(labelNode),
         label = labelName,  ///
-        labelPresent = context.isLabelPresent(label);
+        labelPresent = fileContext.isLabelPresent(label);
 
   if (labelPresent) {
-    context.error(`The label ${label} is already present`, labelNode);
+    fileContext.error(`The label ${label} is already present`, labelNode);
   } else {
     labels.push(label);
 
     labelVerified = true;
   }
 
+  labelVerified ?
+    fileContext.complete(labelNode) :
+      fileContext.halt(labelNode);
+
   return labelVerified;
 }

package/src/verify/labels.js

@@ -2,9 +2,11 @@
 
 import verifyLabel from "../verify/label";
 
-export default function verifyLabels(labelNodes, labels, context) {
-  const labelsVerified = labelNodes.every((labelNode) => {
-    const labelVerified = verifyLabel(labelNode, labels, context);
+export default function verifyLabels(labelNodes, labels, fileContext) {
+  let labelsVerified;
+
+  labelsVerified = labelNodes.every((labelNode) => {
+    const labelVerified = verifyLabel(labelNode, labels, fileContext);
 
     if (labelVerified) {
       return true;

package/src/verify/metaDerivation.js

@@ -15,10 +15,14 @@ const metaDerivationNodeQuery = nodeQuery("/metaSubproof/metaDerivation!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/unqualifiedMetastatement!"),
       qualifiedOrUnqualifiedMetastatementNodesQuery = nodesQuery("/metaSubproof/qualifiedMetastatement|unqualifiedMetastatement")
 
-export default function verifyMetaDerivation(metaDerivationNode, context) {
+export default function verifyMetaDerivation(metaDerivationNode, metaproofContext) {
+  let metaDerivationVerified;
+
+  metaproofContext.begin(metaDerivationNode);
+
   const derived = true;
 
-  context.setDerived(derived);
+  metaproofContext.setDerived(derived);
 
   const metaDerivationChildNodes = metaDerivationChildNodesQuery(metaDerivationNode),
         metaDerivationChildNodesVerified = metaDerivationChildNodes.every((metaDerivationChildNode) => {
@@ -29,12 +33,12 @@ export default function verifyMetaDerivation(metaDerivationNode, context) {
           switch (ruleName) {
             case META_SUBPROOF_RULE_NAME: {
               const metaSubproofNode = metaDerivationChildNode,  ///
-                    metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, context);
+                    metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, metaproofContext);
 
               if (metaSubproofVerified) {
                 const metaAssertion = MetaAssertion.fromMetaSubproofNode(metaSubproofNode);
 
-                context.addMetaAssertion(metaAssertion);
+                metaproofContext.addMetaAssertion(metaAssertion);
 
                 metaDerivationChildNodeVerified = true;
               }
@@ -44,12 +48,12 @@ export default function verifyMetaDerivation(metaDerivationNode, context) {
 
             case QUALIFIED_METASTATEMENT_RULE_NAME: {
               const qualifiedMetastatementNode = metaDerivationChildNode,  ///
-                    qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
+                    qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext);
 
               if (qualifiedMetastatementVerified) {
                 const metaAssertion = MetaAssertion.fromQualifiedMetastatementNode(qualifiedMetastatementNode);
 
-                context.addMetaAssertion(metaAssertion);
+                metaproofContext.addMetaAssertion(metaAssertion);
 
                 metaDerivationChildNodeVerified = qualifiedMetastatementVerified; ///
               }
@@ -59,12 +63,12 @@ export default function verifyMetaDerivation(metaDerivationNode, context) {
 
             case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
               const unqualifiedMetastatementNode = metaDerivationChildNode,  ///
-                    unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+                    unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext);
 
               if (unqualifiedMetastatementVerified) {
                 const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
 
-                context.addMetaAssertion(metaAssertion);
+                metaproofContext.addMetaAssertion(metaAssertion);
 
                 metaDerivationChildNodeVerified = true;
               }
@@ -74,35 +78,38 @@ export default function verifyMetaDerivation(metaDerivationNode, context) {
           }
 
           return metaDerivationChildNodeVerified;
-        }),
-        metaDerivationVerified = metaDerivationChildNodesVerified;  ///
+        });
+
+  metaDerivationVerified = metaDerivationChildNodesVerified;  ///
+
+  metaDerivationVerified ?
+    metaproofContext.complete(metaDerivationNode) :
+      metaproofContext.halt(metaDerivationNode);
 
   return metaDerivationVerified;
 }
 
-function verifyMetaSubproof(metaSubproofNode, context) {
+function verifyMetaSubproof(metaSubproofNode, metaproofContext) {
   let metaSubproofVerified = false;
 
-  const metaproofContext = MetaproofContext.fromContext(context);
-
-  context = metaproofContext; ///
+  metaproofContext = MetaproofContext.fromMetaproofContext(metaproofContext); ///
 
   const qualifiedOrUnqualifiedMetastatementNodes = qualifiedOrUnqualifiedMetastatementNodesQuery(metaSubproofNode),
         firstQualifiedOrUnqualifiedMetastatementNode = first(qualifiedOrUnqualifiedMetastatementNodes),
         unqualifiedMetastatementNode = firstQualifiedOrUnqualifiedMetastatementNode,  ///
-        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext);
 
   if (unqualifiedMetastatementVerified) {
     const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
 
-    context.addMetaAssertion(metaAssertion);
+    metaproofContext.addMetaAssertion(metaAssertion);
 
     let metaDerivationVerified = true;
 
     const metaDerivationNode = metaDerivationNodeQuery(metaSubproofNode);
 
     if (metaDerivationNode !== null) {
-      metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, context);
+      metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, metaproofContext);
     }
 
     if (metaDerivationVerified) {
@@ -112,13 +119,13 @@ function verifyMetaSubproof(metaSubproofNode, context) {
             unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(qualifiedOrUnqualifiedMetastatementNode);
 
       if (qualifiedMetastatementNode !== null) {
-        const qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
+        const qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext);
 
         metaSubproofVerified = qualifiedMetastatementVerified;  ///
       }
 
       if (unqualifiedMetastatementNode !== null) {
-        const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+        const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext);
 
         metaSubproofVerified = unqualifiedMetastatementVerified;  ///
       }

package/src/verify/metaproof.js

@@ -9,20 +9,22 @@ const metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!"),
       qualifiedStatementNodeQuery = nodeQuery("/metaproof/qualifiedMetastatement!"),
       metaProofMetastatementNodeQuery = nodeQuery("/metaproof/qualifiedMetastatement/metastatement!");
 
-export default function verifyMetaproof(metaproofNode, conclusion, context) {
+export default function verifyMetaproof(metaproofNode, conclusion, metaproofContext) {
   let metaproofVerified = false;
 
+  metaproofContext.begin(metaproofNode);
+
   const metaDerivationNode = metaDerivationNodeQuery(metaproofNode);
 
   let metaDerivationVerified = true;
 
   if (metaDerivationNode !== null) {
-    metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, context);
+    metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, metaproofContext);
   }
 
   if (metaDerivationVerified) {
     const qualifiedMetastatementNode = qualifiedStatementNodeQuery(metaproofNode),
-          qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
+          qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext);
 
     if (qualifiedMetastatementVerified) {
       const metastatementNode = conclusion.getMetastatementNode(),
@@ -33,6 +35,10 @@ export default function verifyMetaproof(metaproofNode, conclusion, context) {
     }
   }
 
+  metaproofVerified ?
+    metaproofContext.complete(metaproofNode) :
+      metaproofContext.complete(metaproofNode);
+
   return metaproofVerified;
 }
 

package/src/verify/metastatement/qualified.js

@@ -6,18 +6,20 @@ import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query
 const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/reference!"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
 
-export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, context) {
+export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext) {
   let qualifiedMetastatementVerified = false;
 
+  metaproofContext.begin(qualifiedMetastatementNode);
+
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
     const referenceNode = referenceNodeQuery(qualifiedMetastatementNode),
           referenceName = referenceNameFromReferenceNode(referenceNode),
-          rule = context.findRuleByReferenceName(referenceName);
+          rule = metaproofContext.findRuleByReferenceName(referenceName);
 
     if (rule !== null) {
-      const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, context);
+      const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metaproofContext);
 
       qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
     }
@@ -26,8 +28,12 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
   if (qualifiedMetastatementVerified) {
     const metastatementString = nodeAsString(metastatementNode);
 
-    context.debug(`Verified the '${metastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
+    metaproofContext.debug(`Verified the '${metastatementString}' qualified metastatement.`);
   }
 
+  qualifiedMetastatementVerified ?
+    metaproofContext.complete(qualifiedMetastatementNode) :
+      metaproofContext.halt(qualifiedMetastatementNode);
+
   return qualifiedMetastatementVerified;
 }

package/src/verify/metastatement/unqualified.js

@@ -7,17 +7,19 @@ import { nodeAsString } from "../../utilities/string";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context) {
+export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext) {
   let unqualifiedMetastatementVerified = false;
 
+  metaproofContext.begin(unqualifiedMetastatementNode);
+
   const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
-    const derived = context.isDerived();
+    const derived = metaproofContext.isDerived();
 
     if (derived) {
       const metaAssertion = MetaAssertion.fromMetastatementNode(metastatementNode),
-            metaAssertionMatches = context.matchMetaAssertion(metaAssertion);
+            metaAssertionMatches = metaproofContext.matchMetaAssertion(metaAssertion);
 
       unqualifiedMetastatementVerified = metaAssertionMatches;  ///
     } else {
@@ -28,8 +30,12 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
   if (unqualifiedMetastatementVerified) {
     const metastatementString = nodeAsString(metastatementNode);
 
-    context.debug(`Verified the '${metastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
+    metaproofContext.debug(`Verified the '${metastatementString}' unqualified metastatement.`);
   }
 
+  unqualifiedMetastatementVerified ?
+    metaproofContext.complete(unqualifiedMetastatementNode) :
+      metaproofContext.halt(unqualifiedMetastatementNode);
+
   return unqualifiedMetastatementVerified;
 }

package/src/verify/premiseOrPremises.js

@@ -9,28 +9,32 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement"),
       unqualifiedMetastatementNodesQuery = nodesQuery("/premise|premises/unqualifiedMetastatement");
 
-export default function verifyPremiseOrPremises(premiseOrPremisesNode, premises, context) {
-  const unqualifiedMetastatementNodes = unqualifiedMetastatementNodesQuery(premiseOrPremisesNode),
-        premiseOrPremisesVerified = unqualifiedMetastatementNodes.every((unqualifiedMetastatementNode) => {
-          const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+export default function verifyPremiseOrPremises(premiseOrPremisesNode, premises, metaproofContext) {
+  let premiseOrPremisesVerified;
 
-          if (unqualifiedMetastatementVerified) {
-            const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
+  metaproofContext.begin(premiseOrPremisesNode);
 
-            context.addMetaAssertion(metaAssertion);
+  const unqualifiedMetastatementNodes = unqualifiedMetastatementNodesQuery(premiseOrPremisesNode);
 
-            return true;
-          }
-        });
+  premiseOrPremisesVerified = unqualifiedMetastatementNodes.every((unqualifiedMetastatementNode) => {
+    const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext);
 
-  if (premiseOrPremisesVerified) {
-    unqualifiedMetastatementNodes.forEach((unqualifiedMetastatementNode) => {
+    if (unqualifiedMetastatementVerified) {
       const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+            metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode),
             premise = Premise.fromMetastatementNode(metastatementNode);
 
       premises.push(premise);
-    });
-  }
+
+      metaproofContext.addMetaAssertion(metaAssertion);
+
+      return true;
+    }
+  });
+
+  premiseOrPremisesVerified ?
+    metaproofContext.complete(premiseOrPremisesNode) :
+      metaproofContext.halt(premiseOrPremisesNode);
 
   return premiseOrPremisesVerified;
 }

package/src/verify/release.js

@@ -2,51 +2,69 @@
 
 import verifyFiles from "../verify/files";
 
-export default function verifyRelease(name, releaseContextMap, releaseContexts = []) {
+export default function verifyRelease(name, releaseContextMap) {
   const releaseContext = releaseContextMap[name],
-        verified = releaseContext.isVerified()
+        verified = releaseContext.isVerified();
 
   let releaseVerified = verified; ///
 
   if (!releaseVerified) {
     releaseContext.debug(`Verifying the '${name}' package...`);
 
-    const dependencies = releaseContext.getDependencies(),
-          dependencyReleasesVVerified = dependencies.everyDependency((dependency) => {
-            const name = dependency.getName(),
-                  releaseVerified = verifyRelease(name, releaseContextMap, releaseContexts);
-
-            if (releaseVerified) {
-              return true;
-            }
-          });
+    const dependencyReleasesVVerified = verifyDependencyReleases(releaseContext, releaseContextMap);
 
     if (dependencyReleasesVVerified) {
-      const releaseContexts = dependencies.mapDependency((dependency) => {
-              const name = dependency.getName(),
-                    releaseContext = releaseContextMap[name];
-
-              return releaseContext;
-            }),
-            dependencyReleaseContexts = retrieveDependencyReleaseContexts(dependencies, releaseContextMap);
-
-      releaseContext.initialise(releaseContexts, dependencyReleaseContexts);
+      const releaseFilesVerified = verifyReleaseFiles(releaseContext, releaseContextMap);
 
-      const filesVerified = verifyFiles(releaseContext);
+      if (releaseFilesVerified) {
+        releaseVerified = true;
+      }
+    }
+  }
 
-      releaseVerified = filesVerified;  ///
+  if (releaseVerified) {
+    const verified = true;
 
-      if (releaseVerified) {
-        releaseContexts.push(releaseContext);
+    releaseContext.setVerified(verified);
 
-        releaseContext.info(`Verified the '${name}' package.`);
-      }
-    }
+    releaseContext.info(`Verified the '${name}' package.`);
   }
 
   return releaseVerified;
 }
 
+function verifyReleaseFiles(releaseContext, releaseContextMap) {
+  const dependencies = releaseContext.getDependencies(),
+        releaseContexts = dependencies.mapDependency((dependency) => {
+          const name = dependency.getName(),
+                releaseContext = releaseContextMap[name];
+
+          return releaseContext;
+        }),
+        dependencyReleaseContexts = retrieveDependencyReleaseContexts(dependencies, releaseContextMap);
+
+  releaseContext.initialise(releaseContexts, dependencyReleaseContexts);
+
+  const filesVerified = verifyFiles(releaseContext),
+        releaseFilesVerified = filesVerified; ///
+
+  return releaseFilesVerified;
+}
+
+function verifyDependencyReleases(releaseContext, releaseContextMap) {
+  const dependencies = releaseContext.getDependencies(),
+        dependencyReleasesVVerified = dependencies.everyDependency((dependency) => {
+          const name = dependency.getName(),
+                releaseVerified = verifyRelease(name, releaseContextMap);
+
+          if (releaseVerified) {
+            return true;
+          }
+        });
+
+  return dependencyReleasesVVerified;
+}
+
 function retrieveDependencyReleaseContexts(dependencies, releaseContextMap, dependencyReleaseContexts = []) {
   dependencies.forEachDependency((dependency) => {
     const dependencyName = dependency.getName(),