occam-verify-cli 0.0.1089 → 0.0.1091

package/src/declaration.js

@@ -28,13 +28,13 @@ class Declaration {
     return this.statement;
   }
 
-  unifyStatement(statement, localContext) {
+  unifyStatement(statement, context) {
     let statementUnified;
 
     const statementString = statement.getString(),
           declarationStatementString = this.statement.getString(); ///
 
-    localContext.trace(`Unifying the '${statementString}' statement with the '${declarationStatementString}' statement...`);
+    context.trace(`Unifying the '${statementString}' statement with the '${declarationStatementString}' statement...`);
 
     let statementNode = statement.getNode();
 
@@ -45,19 +45,19 @@ class Declaration {
     statementUnified = statementNodeMatches;  ///
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the '${declarationStatementString}' statement.`);
+      context.debug(`...unified the '${statementString}' statement with the '${declarationStatementString}' statement.`);
     }
 
     return statementUnified;
   }
 
-  unifyMetavariable(metavariable, localContext) {
+  unifyMetavariable(metavariable, context) {
     let metavariableUnified;
 
     const referenceString = this.reference.getString(),
           metavariableString = metavariable.getString();
 
-    localContext.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
+    context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
 
     const metavariableNode = metavariable.getNode(),
           metavariableNodeMatches = this.reference.matchMetavariableNode(metavariableNode);
@@ -65,61 +65,61 @@ class Declaration {
     metavariableUnified = metavariableNodeMatches;  ///
 
     if (metavariableUnified) {
-      localContext.debug(`...unified the '${metavariableString}' metavariable with the '${referenceString}' reference.`);
+      context.debug(`...unified the '${metavariableString}' metavariable with the '${referenceString}' reference.`);
     }
 
     return metavariableUnified;
   }
 
-  unifySubstitution(substitution, localContext) {
+  unifySubstitution(substitution, context) {
     let substitutionUnified;
 
     const declarationString = this.string,  ///
           substitutionString = substitution.getString();
 
-    localContext.trace(`Unifying the '${substitutionString}' substitution with the '${declarationString}' declaration...`);
+    context.trace(`Unifying the '${substitutionString}' substitution with the '${declarationString}' declaration...`);
 
     const statement = substitution.getStatement(),
           metavariable = substitution.getMetavariable(),
-          statementUnified = this.unifyStatement(statement, localContext),
-          metavariableUnified = this.unifyMetavariable(metavariable, localContext);
+          statementUnified = this.unifyStatement(statement, context),
+          metavariableUnified = this.unifyMetavariable(metavariable, context);
 
     substitutionUnified = (metavariableUnified && statementUnified);
 
     if (substitutionUnified) {
-      localContext.debug(`...unified the '${declarationString}' substitution with the '${substitutionString}' declaration.`);
+      context.debug(`...unified the '${declarationString}' substitution with the '${substitutionString}' declaration.`);
     }
 
     return substitutionUnified;
   }
 
-  verify(assignments, stated, localContext) {
+  verify(assignments, stated, context) {
     let verified = false;
 
     const declarationString = this.string;  ///
 
-    localContext.trace(`Verifying the '${declarationString}' declaration...`);
+    context.trace(`Verifying the '${declarationString}' declaration...`);
 
     stated = true;  ///
 
     assignments = null; ///
 
-    const referenceVerified = this.reference.verify(localContext);
+    const referenceVerified = this.reference.verify(context);
 
     if (referenceVerified) {
-      const statementVerified = this.statement.verify(assignments, stated, localContext);
+      const statementVerified = this.statement.verify(assignments, stated, context);
 
       verified = statementVerified; ///
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${declarationString}' declaration.`);
+      context.debug(`...verified the '${declarationString}' declaration.`);
     }
 
     return verified;
   }
 
-  static fromDeclarationNode(declarationNode, localContext) {
+  static fromDeclarationNode(declarationNode, context) {
     let declaration = null;
 
     if (declarationNode !== null) {
@@ -130,10 +130,10 @@ class Declaration {
 
       statementNode = stripBracketsFromStatementNode(statementNode);  ///
 
-      const reference = Reference.fromReferenceNode(referenceNode, localContext),
-            statement = Statement.fromStatementNode(statementNode, localContext),
+      const reference = Reference.fromReferenceNode(referenceNode, context),
+            statement = Statement.fromStatementNode(statementNode, context),
             node = declarationNode,  ///
-            string = localContext.nodeAsString(node);
+            string = context.nodeAsString(node);
 
       declaration = new Declaration(string, reference, statement);
     }

package/src/derivation.js

@@ -25,11 +25,11 @@ class Derivation {
     return lastProofStep;
   }
 
-  verify(substitutions, localContext) {
+  verify(substitutions, context) {
     let verified;
 
     verified = this.proofSteps.every((proofStep) => { ///
-      const proofStepVerified = proofStep.verify(substitutions, localContext);
+      const proofStepVerified = proofStep.verify(substitutions, context);
 
       if (proofStepVerified) {
         return true;

package/src/equality.js

@@ -57,32 +57,32 @@ class Equality {
     return reflexive;
   }
 
-  isEqual(localContext) {
+  isEqual(context) {
     const leftTermNode = this.leftTerm.getNode(),
           rightTermNode = this.rightTerm.getNode(),
-          equalityUnified = equalityUnifier.unify(leftTermNode, rightTermNode, localContext),
+          equalityUnified = equalityUnifier.unify(leftTermNode, rightTermNode, context),
           equal = equalityUnified;  ///
 
     return equal;
   }
 
-  verify(assignments, stated, localContext) {
+  verify(assignments, stated, context) {
     let verified = false;
 
     const equalityString = this.string; ///
 
-    localContext.trace(`Verifying the '${equalityString}' equality...`);
+    context.trace(`Verifying the '${equalityString}' equality...`);
 
-    const termsVerified = this.verifyTerms(localContext);
+    const termsVerified = this.verifyTerms(context);
 
     if (termsVerified) {
       let verifiedWhenStated = false,
           verifiedWhenDerived = false;
 
       if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(localContext);
+        verifiedWhenStated = this.verifyWhenStated(context);
       } else {
-        verifiedWhenDerived = this.verifyWhenDerived(localContext);
+        verifiedWhenDerived = this.verifyWhenDerived(context);
       }
 
       if (verifiedWhenStated || verifiedWhenDerived) {
@@ -93,8 +93,8 @@ class Equality {
                 rightTermNode = this.rightTerm.getNode(),
                 leftVariableNode = variableNodeQuery(leftTermNode),
                 rightVariableNode = variableNodeQuery(rightTermNode),
-                leftVariable = Variable.fromVariableNodeAndType(leftVariableNode, type, localContext),
-                rightVariable = Variable.fromVariableNodeAndType(rightVariableNode, type, localContext);
+                leftVariable = Variable.fromVariableNodeAndType(leftVariableNode, type, context),
+                rightVariable = Variable.fromVariableNodeAndType(rightVariableNode, type, context);
 
           let assignment;
 
@@ -127,23 +127,23 @@ class Equality {
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${equalityString}' equality.`);
+      context.debug(`...verified the '${equalityString}' equality.`);
     }
 
     return verified;
   }
 
-  verifyTerms(localContext) {
+  verifyTerms(context) {
     let termsVerified;
 
     const equalityString = this.string; ///
 
-    localContext.trace(`Verifying the '${equalityString}' equality's terms...`);
+    context.trace(`Verifying the '${equalityString}' equality's terms...`);
 
-    const leftTermVerified = this.leftTerm.verify(localContext, () => {
+    const leftTermVerified = this.leftTerm.verify(context, () => {
       let verifiedAhead;
 
-      const rightTermVerified = this.rightTerm.verify(localContext, () => {
+      const rightTermVerified = this.rightTerm.verify(context, () => {
         let verifiedAhead;
 
         const leftTermType = this.leftTerm.getType(),
@@ -163,57 +163,57 @@ class Equality {
     termsVerified = leftTermVerified; ///
 
     if (termsVerified) {
-      localContext.debug(`...verified the '${equalityString}' equality's terms.`);
+      context.debug(`...verified the '${equalityString}' equality's terms.`);
     }
 
     return termsVerified;
   }
 
-  verifyWhenStated(localContext) {
+  verifyWhenStated(context) {
     let verifiedWhenStated;
 
     const equalityString = this.string; ///
 
-    localContext.trace(`Verifying the '${equalityString}' stated equality...`);
+    context.trace(`Verifying the '${equalityString}' stated equality...`);
 
     verifiedWhenStated = true;
 
     if (verifiedWhenStated) {
-      localContext.debug(`...verified the '${equalityString}' stated equality.`);
+      context.debug(`...verified the '${equalityString}' stated equality.`);
     }
 
     return verifiedWhenStated;
   }
 
-  verifyWhenDerived(localContext) {
+  verifyWhenDerived(context) {
     let verifiedWhenDerived;
 
     const equalityString = this.string; ///
 
-    localContext.trace(`Verifying the '${equalityString}' derived equality...`);
+    context.trace(`Verifying the '${equalityString}' derived equality...`);
 
-    const equal = this.isEqual(localContext);
+    const equal = this.isEqual(context);
 
     verifiedWhenDerived = equal;  ///
 
     if (verifiedWhenDerived) {
-      localContext.debug(`...verified the '${equalityString}' derived equality.`);
+      context.debug(`...verified the '${equalityString}' derived equality.`);
     }
 
     return verifiedWhenDerived;
   }
 
-  static fromEqualityNode(equalityNode, localContext) {
+  static fromEqualityNode(equalityNode, context) {
     let equality = null;
 
     if (equalityNode !== null) {
       const { Term } = shim,
             leftTermNode = leftTermNodeQuery(equalityNode),
             rightTermNode = rightTermNodeQuery(equalityNode),
-            leftTerm = Term.fromTermNode(leftTermNode, localContext),
-            rightTerm = Term.fromTermNode(rightTermNode, localContext),
+            leftTerm = Term.fromTermNode(leftTermNode, context),
+            rightTerm = Term.fromTermNode(rightTermNode, context),
             node = equalityNode,  ///
-            string = localContext.nodeAsString(node);
+            string = context.nodeAsString(node);
 
       equality = new Equality(string, leftTerm, rightTerm);
     }

package/src/equivalence.js

@@ -14,11 +14,11 @@ export default class Equivalence {
     return this.terms;
   }
 
-  addTerm(term, localContext) {
+  addTerm(term, context) {
     const termString = term.getString(),
           equivalenceString = this.asString();  ///
 
-    localContext.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence.`);
+    context.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence.`);
 
     this.terms.push(term);
   }
@@ -115,9 +115,9 @@ export default class Equivalence {
     return termNodesMatch;
   }
 
-  getGroundedTerms(definedVariables, groundedTerms, localContext) {
+  getGroundedTerms(definedVariables, groundedTerms, context) {
     this.terms.forEach((term) => {
-      const termGrounded = term.isGrounded(definedVariables, localContext);
+      const termGrounded = term.isGrounded(definedVariables, context);
 
       if (termGrounded) {
         const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
@@ -138,25 +138,25 @@ export default class Equivalence {
     });
   }
 
-  isInitiallyGrounded(localContext) {
-    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(localContext),
+  isInitiallyGrounded(context) {
+    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(context),
           initiallyGroundedTermsLength = initiallyGroundedTerms.length,
           initiallyGrounded = (initiallyGroundedTermsLength > 0);
 
     return initiallyGrounded;
   }
 
-  isImplicitlyGrounded(definedVariables, localContext) {
-    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables, localContext),
+  isImplicitlyGrounded(definedVariables, context) {
+    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables, context),
           implicitlyGroundedTermsLength = implicitlyGroundedTerms.length,
           implicitlyGrounded = (implicitlyGroundedTermsLength > 0);
 
     return implicitlyGrounded;
   }
 
-  getInitiallyGroundedTerms(localContext) {
+  getInitiallyGroundedTerms(context) {
     const initiallyGroundedTerms = this.terms.reduce((initiallyGroundedTerms, term) => {
-      const termInitiallyGrounded = term.isInitiallyGrounded(localContext);
+      const termInitiallyGrounded = term.isInitiallyGrounded(context);
 
       if (termInitiallyGrounded) {
         const initiallyGroundedTerm = term; ///
@@ -170,9 +170,9 @@ export default class Equivalence {
     return initiallyGroundedTerms;
   }
 
-  getImplicitlyGroundedTerms(definedVariables, localContext) {
+  getImplicitlyGroundedTerms(definedVariables, context) {
     const implicitlyGroundedTerms = this.terms.reduce((implicitlyGroundedTerms, term) => {
-      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables, localContext);
+      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables, context);
 
       if (termImplicitlyGrounded) {
         const implicitlyGroundedTerm = term; ///

package/src/frame.js

@@ -86,16 +86,16 @@ class Frame {
     return metavariableNodeMatches;
   }
 
-  unifySubstitution(substitution, localContext) {
+  unifySubstitution(substitution, context) {
     let substitutionUnified = false;
 
     const substitutionString = substitution.getString();
 
-    localContext.trace(`Unifying the '${substitutionString}' substitution...`)
+    context.trace(`Unifying the '${substitutionString}' substitution...`)
 
     if (!substitutionUnified) {
       substitutionUnified = this.declarations.some((declaration) => {
-        const substitutionUnified = declaration.unifySubstitution(substitution, localContext);
+        const substitutionUnified = declaration.unifySubstitution(substitution, context);
 
         if (substitutionUnified) {
           return true;
@@ -105,7 +105,7 @@ class Frame {
 
     if (!substitutionUnified) {
       substitutionUnified = this.metavariables.some((metavariable) => {
-        const substitutionUnified = metavariable.unifySubstitution(substitution, localContext);
+        const substitutionUnified = metavariable.unifySubstitution(substitution, context);
 
         if (substitutionUnified) {
           return true;
@@ -114,22 +114,22 @@ class Frame {
     }
 
     if (substitutionUnified) {
-      localContext.debug(`...unified the '${substitutionString}' substitution...`)
+      context.debug(`...unified the '${substitutionString}' substitution...`)
     }
 
     return substitutionUnified;
   }
 
-  unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem, localContext) {
+  unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem, context) {
     let metaLemmaMetatheoremUnified;
 
     const metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
 
-    localContext.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem...`);
+    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem...`);
 
     const substitutions = metaLemmaMetatheorem.getSubstitutions(),
           substitutionsUnified = substitutions.everySubstitution((substitution) => {
-            const substitutionUnified = this.unifySubstitution(substitution, localContext);
+            const substitutionUnified = this.unifySubstitution(substitution, context);
 
             if (substitutionUnified) {
               return true;
@@ -139,22 +139,22 @@ class Frame {
     metaLemmaMetatheoremUnified = substitutionsUnified; ///
 
     if (metaLemmaMetatheoremUnified) {
-      localContext.debug(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem.`);
+      context.debug(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem.`);
     }
 
     return metaLemmaMetatheoremUnified;
   }
 
-  unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, localContext) {
+  unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, context) {
     let axiomLemmaTheoremOrConjectureUnified;
 
     const axiomLemmaTheoremStringOrConjecture = axiomLemmaTheoremOrConjecture.getString();
 
-    localContext.trace(`Unifying the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture...`);
+    context.trace(`Unifying the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture...`);
 
     const substitutions = axiomLemmaTheoremOrConjecture.getSubstitutions(),
           substitutionsUnified = substitutions.everySubstitution((substitution) => {
-            const substitutionUnified = this.unifySubstitution(substitution, localContext);
+            const substitutionUnified = this.unifySubstitution(substitution, context);
 
             if (substitutionUnified) {
               return true;
@@ -164,28 +164,28 @@ class Frame {
     axiomLemmaTheoremOrConjectureUnified = substitutionsUnified; ///
 
     if (axiomLemmaTheoremOrConjectureUnified) {
-      localContext.debug(`...unified the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture.`);
+      context.debug(`...unified the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture.`);
     }
 
     return axiomLemmaTheoremOrConjectureUnified;
   }
 
-  verify(assignments, stated, localContext) {
+  verify(assignments, stated, context) {
     let verified = false;
 
     const frameString = this.string;  ///
 
-    localContext.trace(`Verifying the '${frameString}' frame...`);
+    context.trace(`Verifying the '${frameString}' frame...`);
 
     const declarationsVerified = this.declarations.every((declaration) => {
-      const declarationVerified = declaration.verify(assignments, stated, localContext);
+      const declarationVerified = declaration.verify(assignments, stated, context);
 
       return declarationVerified;
     });
 
     if (declarationsVerified) {
       const  metavariablesVerified = this.metavariables.every((metavariable) => {
-        const metavariableVerified = metavariable.verify(localContext);
+        const metavariableVerified = metavariable.verify(context);
 
         return metavariableVerified;
       });
@@ -195,9 +195,9 @@ class Frame {
             verifiedWhenDerived = false;
 
         if (stated) {
-          verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
+          verifiedWhenStated = this.verifyWhenStated(assignments, context);
         } else {
-          verifiedWhenDerived = this.verifyWhenDerived(assignments, localContext);
+          verifiedWhenDerived = this.verifyWhenDerived(assignments, context);
         }
 
         if (verifiedWhenStated || verifiedWhenDerived) {
@@ -207,80 +207,80 @@ class Frame {
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${frameString}' frame.`);
+      context.debug(`...verified the '${frameString}' frame.`);
     }
 
     return verified;
   }
 
-  verifyWhenStated(assignments, localContext) {
+  verifyWhenStated(assignments, context) {
     let verifiedWhenStated = false;
 
     const frameString = this.string;  ///
 
-    localContext.trace(`Verifying the '${frameString}' frame when stated...`);
+    context.trace(`Verifying the '${frameString}' frame when stated...`);
 
     const declarationsLength = this.declarations.length;
 
     if (declarationsLength > 0) {
-      localContext.trace(`The '${frameString}' stated frame cannot have declarations.`);
+      context.trace(`The '${frameString}' stated frame cannot have declarations.`);
     } else {
       const metavariablesLength = this.metavariables.length;
 
       if (metavariablesLength > 1) {
-        localContext.trace(`The '${frameString}' stated frame cannot have more than one metavariable.`);
+        context.trace(`The '${frameString}' stated frame cannot have more than one metavariable.`);
       } else {
         verifiedWhenStated = true;
       }
     }
 
     if (verifiedWhenStated) {
-      localContext.debug(`...verified the '${frameString}' frame when stated.`);
+      context.debug(`...verified the '${frameString}' frame when stated.`);
     }
 
     return verifiedWhenStated;
   }
 
-  verifyWhenDerived(assignments, localContext) {
+  verifyWhenDerived(assignments, context) {
     let verifiedWhenDerived;
 
     const frameString = this.string;  ///
 
-    localContext.trace(`Verifying the '${frameString}' frame when derived...`);
+    context.trace(`Verifying the '${frameString}' frame when derived...`);
 
     verifiedWhenDerived = true;
 
     if (verifiedWhenDerived) {
-      localContext.debug(`...verified the '${frameString}' frame when derived.`);
+      context.debug(`...verified the '${frameString}' frame when derived.`);
     }
 
     return verifiedWhenDerived;
   }
 
-  verifyGivenMetaType(metaType, assignments, stated, localContext) {
+  verifyGivenMetaType(metaType, assignments, stated, context) {
     let verifiedGivenMetaType = false;
 
     const frameString = this.string,  ///
           metaTypeString = metaType.getString();
 
-    localContext.trace(`Verifying the '${frameString}' frame given the '${metaTypeString}' meta-type...`);
+    context.trace(`Verifying the '${frameString}' frame given the '${metaTypeString}' meta-type...`);
 
     const metaTypeName = metaType.getName();
 
     if (metaTypeName === FRAME_META_TYPE_NAME) {
-      const verified = this.verify(assignments, stated, localContext)
+      const verified = this.verify(assignments, stated, context)
 
       verifiedGivenMetaType = verified; ///
     }
 
     if (verifiedGivenMetaType) {
-      localContext.debug(`...verified the '${frameString}' frame given the '${metaTypeString}' meta-type.`);
+      context.debug(`...verified the '${frameString}' frame given the '${metaTypeString}' meta-type.`);
     }
 
     return verifiedGivenMetaType;
   }
 
-  static fromFrameNode(frameNode, localContext) {
+  static fromFrameNode(frameNode, context) {
     let frame = null;
 
     if (frameNode !== null) {
@@ -288,17 +288,17 @@ class Frame {
             declarationNodes = declarationNodesQuery(frameNode),
             metavariableNodes = metavariableNodesQuery(frameNode),
             declarations = declarationNodes.map((declarationNode) => {
-              const declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
+              const declaration = Declaration.fromDeclarationNode(declarationNode, context);
 
               return declaration;
             }),
             metavariables = metavariableNodes.map((metavariableNode) => {
-              const metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext);
+              const metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
 
               return metavariable;
             }),
             node = frameNode, ///
-            string = localContext.nodeAsString(node);
+            string = context.nodeAsString(node);
 
       frame = new Frame(string, node, declarations, metavariables);
     }
@@ -306,7 +306,7 @@ class Frame {
     return frame;
   }
 
-  static fromDefinedAssertionNode(definedAssertionNode, localContext) {
+  static fromDefinedAssertionNode(definedAssertionNode, context) {
     let frame = null;
 
     const frameNode = frameNodeQuery(definedAssertionNode);
@@ -316,13 +316,13 @@ class Frame {
 
       if (metavariableNode !== null) {
         const { Metavariable } = shim,
-              metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+              metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
               declarations = [],
               metavariables = [
                 metavariable
               ],
               node = frameNode,  ///
-              string = localContext.nodeAsString(node);
+              string = context.nodeAsString(node);
 
         frame = new Frame(string, node, declarations, metavariables);
       }
@@ -331,7 +331,7 @@ class Frame {
     return frame;
   }
 
-  static fromContainedAssertionNode(containedAssertionNode, localContext) {
+  static fromContainedAssertionNode(containedAssertionNode, context) {
     let frame = null;
 
     const frameNode = frameNodeQuery(containedAssertionNode);
@@ -341,13 +341,13 @@ class Frame {
 
       if (metavariableNode !== null) {
         const { Metavariable } = shim,
-              metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+              metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
               declarations = [],
               metavariables = [
                 metavariable
               ],
               node = frameNode,  ///
-              string = localContext.nodeAsString(node);
+              string = context.nodeAsString(node);
 
         frame = new Frame(string, node, declarations, metavariables);
       }

package/src/index.js

@@ -33,6 +33,7 @@ import Substitutions from "./substitutions";
 import SubDerivation from "./subDerivation";
 import QualifiedStatement from "./statement/qualified";
 import UnqualifiedStatement from "./statement/unqualified";
+import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
 
 export { default as Log } from "./log";
 export { default as ReleaseContext } from "./context/release";