diff --git a/README.md b/README.md
index c39eecc..225dbbc 100644
--- a/README.md
+++ b/README.md
@@ -79,6 +79,15 @@ result = router.recognize("/pages/hello/world");
 result === [{ handler: page, params: { path: "hello/world" } }];
 ```
 
+Metadata:
+
+```javascript
+router.add([{ path: "/post/1", handler: page, metadata: { test: 123 } }]);
+
+result = router.recognize("/post/1");
+result === [{ handler: page, params: {}, metadata: { test: 123 } }];
+```
+
 # Sorting
 
 If multiple routes all match a path, `route-recognizer`
diff --git a/lib/route-recognizer.ts b/lib/route-recognizer.ts
index 265f24b..4e0e113 100644
--- a/lib/route-recognizer.ts
+++ b/lib/route-recognizer.ts
@@ -209,12 +209,14 @@ interface EmptyHandler {
   handler: Opaque;
   names: EmptyArray;
   shouldDecodes: EmptyArray;
+  metadata: Opaque;
 }
 
 interface PopulatedHandler {
   handler: Opaque;
   names: string [];
   shouldDecodes: boolean[];
+  metadata: Opaque;
 }
 
 type Handler = EmptyHandler | PopulatedHandler;
@@ -385,6 +387,7 @@ export interface Result {
   handler: Opaque;
   params: Params;
   isDynamic: boolean;
+  metadata: Opaque;
 }
 
 export interface Results extends ArrayLike<Result | undefined> {
@@ -449,6 +452,7 @@ function findHandler(state: State, originalPath: string, queryParams: QueryParam
 
     result[i] = {
       handler: handler.handler,
+      metadata: handler.metadata,
       params,
       isDynamic
     };
@@ -526,8 +530,10 @@ class RouteRecognizer {
         currentState = eachChar[segment.type](segment, currentState);
         pattern += regex[segment.type](segment);
       }
+
       handlers[i] = {
         handler: route.handler,
+        metadata: route.metadata,
         names,
         shouldDecodes
       };
diff --git a/lib/route-recognizer/dsl.ts b/lib/route-recognizer/dsl.ts
index c2412f4..b4ada8f 100644
--- a/lib/route-recognizer/dsl.ts
+++ b/lib/route-recognizer/dsl.ts
@@ -10,6 +10,7 @@ export type Opaque = {} | void | null | undefined;
 export interface Route {
   path: string;
   handler: Opaque;
+  metadata?: Opaque;
   queryParams?: string[];
 }
 
@@ -105,14 +106,14 @@ function generateMatch(startingPath: string, matcher: Matcher, delegate: Delegat
   return match;
 }
 
-function addRoute(routeArray: Route[], path: string, handler: any) {
+function addRoute(routeArray: Route[], path: string, handler: any, metadata: any) {
   let len = 0;
   for (let i = 0; i < routeArray.length; i++) {
     len += routeArray[i].path.length;
   }
 
   path = path.substr(len);
-  let route = { path: path, handler: handler };
+  let route = { path: path, handler: handler, metadata: metadata };
   routeArray.push(route);
 }
 
@@ -122,7 +123,7 @@ function eachRoute<T>(baseRoute: Route[], matcher: Matcher, callback: (this: T,
   for (let i = 0; i < paths.length; i++) {
     let path = paths[i];
     let routeArray = baseRoute.slice();
-    addRoute(routeArray, path, routes[path]);
+    addRoute(routeArray, path, routes[path], routes.metadata);
     let nested = matcher.children[path];
     if (nested) {
       eachRoute(routeArray, nested, callback, binding);
diff --git a/tests/recognizer-tests.ts b/tests/recognizer-tests.ts
index cf284ac..ba74e6a 100644
--- a/tests/recognizer-tests.ts
+++ b/tests/recognizer-tests.ts
@@ -20,7 +20,7 @@ QUnit.test("A simple route recognizes", (assert: Assert) => {
   let router = new RouteRecognizer();
   router.add([{ path: "/foo/bar", handler: handler }]);
 
-  resultsMatch(assert, router.recognize("/foo/bar"), [{ handler: handler, params: {}, isDynamic: false }]);
+  resultsMatch(assert, router.recognize("/foo/bar"), [{ handler: handler, params: {}, isDynamic: false, metadata: undefined }]);
   assert.equal(router.recognize("/foo/baz"), null);
 });
 
@@ -114,7 +114,7 @@ staticExpectations.forEach(function(expectation) {
         let handler = {};
         let router = new RouteRecognizer();
         router.add([{ path: route, handler: handler }]);
-        resultsMatch(assert, router.recognize(match), [{ handler: handler, params: {}, isDynamic: false }]);
+        resultsMatch(assert, router.recognize(match), [{ handler: handler, params: {}, isDynamic: false, metadata: undefined }]);
       });
     });
 
@@ -136,8 +136,8 @@ QUnit.test("Escaping works for path length with trailing slashes.", (assert: Ass
   let router = new RouteRecognizer();
   router.add([{ path: "/foo/:query", handler: handler }]);
 
-  resultsMatch(assert, router.recognize("/foo/%e8%81%8c%e4%bd%8d"), [{ handler: handler, params: { query: "职位" }, isDynamic: true }]);
-  resultsMatch(assert, router.recognize("/foo/%e8%81%8c%e4%bd%8d/"), [{ handler: handler, params: { query: "职位" }, isDynamic: true }]);
+  resultsMatch(assert, router.recognize("/foo/%e8%81%8c%e4%bd%8d"), [{ handler: handler, params: { query: "职位" }, isDynamic: true, metadata: undefined }]);
+  resultsMatch(assert, router.recognize("/foo/%e8%81%8c%e4%bd%8d/"), [{ handler: handler, params: { query: "职位" }, isDynamic: true, metadata: undefined }]);
 });
 
 QUnit.test("A simple route with query params recognizes", (assert: Assert) => {
@@ -145,8 +145,8 @@ QUnit.test("A simple route with query params recognizes", (assert: Assert) => {
   let router = new RouteRecognizer();
   router.add([{ path: "/foo/bar", handler: handler}]);
 
-  resultsMatch(assert, router.recognize("/foo/bar?sort=date&other=something"), [{ handler: handler, params: {}, isDynamic: false }], { sort: "date", other: "something" });
-  resultsMatch(assert, router.recognize("/foo/bar?other=something"), [{ handler: handler, params: {}, isDynamic: false }], { other: "something" });
+  resultsMatch(assert, router.recognize("/foo/bar?sort=date&other=something"), [{ handler: handler, params: {}, isDynamic: false, metadata: undefined }], { sort: "date", other: "something" });
+  resultsMatch(assert, router.recognize("/foo/bar?other=something"), [{ handler: handler, params: {}, isDynamic: false, metadata: undefined }], { other: "something" });
 });
 
 QUnit.test("False query params = 'false'", (assert: Assert) => {
@@ -217,7 +217,7 @@ QUnit.test("A `/` route recognizes", (assert: Assert) => {
   let router = new RouteRecognizer();
   router.add([{ path: "/", handler: handler }]);
 
-  resultsMatch(assert, router.recognize("/"), [{ handler: handler, params: {}, isDynamic: false }]);
+  resultsMatch(assert, router.recognize("/"), [{ handler: handler, params: {}, isDynamic: false, metadata: undefined }]);
 });
 
 QUnit.test("A `/` route with query params recognizes", (assert: Assert) => {
@@ -225,7 +225,7 @@ QUnit.test("A `/` route with query params recognizes", (assert: Assert) => {
   let router = new RouteRecognizer();
   router.add([{ path: "/", handler: handler }]);
 
-  resultsMatch(assert, router.recognize("/?lemon=jello"), [{ handler: handler, params: {}, isDynamic: false }], { lemon: "jello" });
+  resultsMatch(assert, router.recognize("/?lemon=jello"), [{ handler: handler, params: {}, isDynamic: false, metadata: undefined }], { lemon: "jello" });
 });
 
 QUnit.test("A dynamic route recognizes", (assert: Assert) => {
@@ -233,8 +233,8 @@ QUnit.test("A dynamic route recognizes", (assert: Assert) => {
   let router = new RouteRecognizer();
   router.add([{ path: "/foo/:bar", handler: handler }]);
 
-  resultsMatch(assert, router.recognize("/foo/bar"), [{ handler: handler, params: { bar: "bar" }, isDynamic: true }]);
-  resultsMatch(assert, router.recognize("/foo/1"), [{ handler: handler, params: { bar: "1" }, isDynamic: true }]);
+  resultsMatch(assert, router.recognize("/foo/bar"), [{ handler: handler, params: { bar: "bar" }, isDynamic: true, metadata: undefined }]);
+  resultsMatch(assert, router.recognize("/foo/1"), [{ handler: handler, params: { bar: "1" }, isDynamic: true, metadata: undefined }]);
   assert.equal(router.recognize("/zoo/baz"), null);
 });
 
@@ -318,7 +318,7 @@ dynamicExpectations.forEach(expectation => {
       let handler = {};
       let router = new RouteRecognizer();
       router.add([{ path: route, handler: handler }]);
-      resultsMatch(assert, router.recognize(path), [{ handler: handler, params: { bar: match }, isDynamic: true }]);
+      resultsMatch(assert, router.recognize(path), [{ handler: handler, params: { bar: match }, isDynamic: true, metadata: undefined }]);
     });
 
     QUnit.test("When RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS is false, single-segment dynamic route '" + route + "' recognizes path '" + path + "'", (assert: Assert) => {
@@ -327,7 +327,7 @@ dynamicExpectations.forEach(expectation => {
       let handler = {};
       let router = new RouteRecognizer();
       router.add([{ path: route, handler: handler }]);
-      resultsMatch(assert, router.recognize(path), [{ handler: handler, params: { bar: unencodedMatch }, isDynamic: true }]);
+      resultsMatch(assert, router.recognize(path), [{ handler: handler, params: { bar: unencodedMatch }, isDynamic: true, metadata: undefined }]);
 
       RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS = true;
     });
@@ -384,7 +384,7 @@ multiSegmentDynamicExpectations.forEach(expectation => {
       let router = new RouteRecognizer();
       router.add([{ path: route, handler: handler }]);
 
-      resultsMatch(assert, router.recognize(path), [{ handler: handler, params: match, isDynamic: true }]);
+      resultsMatch(assert, router.recognize(path), [{ handler: handler, params: match, isDynamic: true, metadata: undefined }]);
     });
 
     QUnit.test("When RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS is false, multi-segment dynamic route '" + route + "' recognizes path '" + path + "'", (assert: Assert) => {
@@ -394,7 +394,7 @@ multiSegmentDynamicExpectations.forEach(expectation => {
       let router = new RouteRecognizer();
       router.add([{ path: route, handler: handler }]);
 
-      resultsMatch(assert, router.recognize(path), [{ handler: handler, params: unencodedMatch, isDynamic: true }]);
+      resultsMatch(assert, router.recognize(path), [{ handler: handler, params: unencodedMatch, isDynamic: true, metadata: undefined }]);
 
       RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS = true;
     });
@@ -408,7 +408,7 @@ QUnit.test("A dynamic route with unicode match parameters recognizes", (assert:
   let path = "/foo/bar/baz";
 
   let expectedParams = { föo: "foo", bäz: "baz" };
-  resultsMatch(assert, router.recognize(path), [{ handler: handler, params: expectedParams, isDynamic: true }]);
+  resultsMatch(assert, router.recognize(path), [{ handler: handler, params: expectedParams, isDynamic: true, metadata: undefined }]);
 });
 
 let starSimpleExpectations = [
@@ -439,7 +439,7 @@ starSimpleExpectations.forEach(function(value) {
     let handler = {};
     let router = new RouteRecognizer();
     router.add([{ path: route, handler: handler }]);
-    resultsMatch(assert, router.recognize(path), [{ handler: handler, params: { bar: value }, isDynamic: true }]);
+    resultsMatch(assert, router.recognize(path), [{ handler: handler, params: { bar: value }, isDynamic: true, metadata: undefined }]);
   });
 });
 
@@ -467,7 +467,7 @@ starComplexExpectations.forEach(function(expectation) {
     let handler = {};
     router.add([{ path: route, handler: handler }]);
 
-    resultsMatch(assert, router.recognize(path), [{ handler: handler, params: params, isDynamic: true }]);
+    resultsMatch(assert, router.recognize(path), [{ handler: handler, params: params, isDynamic: true, metadata: undefined }]);
   });
 });
 
@@ -479,8 +479,53 @@ QUnit.test("Multiple routes recognize", (assert: Assert) => {
   router.add([{ path: "/foo/:bar", handler: handler1 }]);
   router.add([{ path: "/bar/:baz", handler: handler2 }]);
 
-  resultsMatch(assert, router.recognize("/foo/bar"), [{ handler: handler1, params: { bar: "bar" }, isDynamic: true }]);
-  resultsMatch(assert, router.recognize("/bar/1"), [{ handler: handler2, params: { baz: "1" }, isDynamic: true }]);
+  resultsMatch(assert, router.recognize("/foo/bar"), [{ handler: handler1, params: { bar: "bar" }, isDynamic: true, metadata: undefined }]);
+  resultsMatch(assert, router.recognize("/bar/1"), [{ handler: handler2, params: { baz: "1" }, isDynamic: true, metadata: undefined }]);
+});
+
+QUnit.test("Object metadata returned in recognize", (assert: Assert) => {
+  let handler = {};
+  let metadata = { test: 1 };
+  let router = new RouteRecognizer();
+  router.add([{ path: "/foo/bar", handler: handler, metadata: metadata }]);
+
+  resultsMatch(assert, router.recognize("/foo/bar"), [{ handler: handler, params: {}, isDynamic: false, metadata: metadata]);
+});
+
+QUnit.test("Undefined metadata returned in recognize", (assert: Assert) => {
+  let handler = {};
+  let metadata = undefined;
+  let router = new RouteRecognizer();
+  router.add([{ path: "/foo/bar", handler: handler, metadata: metadata }]);
+
+  resultsMatch(assert, router.recognize("/foo/bar"), [{ handler: handler, params: {}, isDynamic: false, metadata: metadata }]);
+});
+
+QUnit.test("Null metadata returned in recognize", (assert: Assert) => {
+  let handler = {};
+  let metadata = null;
+  let router = new RouteRecognizer();
+  router.add([{ path: "/foo/bar", handler: handler, metadata: metadata }]);
+
+  resultsMatch(assert, router.recognize("/foo/bar"), [{ handler: handler, params: {}, isDynamic: false, metadata: metadata }]);
+});
+
+QUnit.test("Boolean true metadata returned in recognize", (assert: Assert) => {
+  let handler = {};
+  let metadata = true;
+  let router = new RouteRecognizer();
+  router.add([{ path: "/foo/bar", handler: handler, metadata: metadata }]);
+
+  resultsMatch(assert, router.recognize("/foo/bar"), [{ handler: handler, params: {}, isDynamic: false, metadata: metadata }]);
+});
+
+QUnit.test("Boolean false metadata returned in recognize", (assert: Assert) => {
+  let handler = {};
+  let metadata = false;
+  let router = new RouteRecognizer();
+  router.add([{ path: "/foo/bar", handler: handler, metadata: metadata }]);
+
+  resultsMatch(assert, router.recognize("/foo/bar"), [{ handler: handler, params: {}, isDynamic: false, metadata: metadata }]);
 });
 
 QUnit.test("query params ignore the URI malformed error", (assert: Assert) => {
@@ -544,7 +589,7 @@ QUnit.test("Multiple `/` routes recognize", (assert: Assert) => {
   let router = new RouteRecognizer();
 
   router.add([{ path: "/", handler: handler1 }, { path: "/", handler: handler2 }]);
-  resultsMatch(assert, router.recognize("/"), [{ handler: handler1, params: {}, isDynamic: false }, { handler: handler2, params: {}, isDynamic: false }]);
+  resultsMatch(assert, router.recognize("/"), [{ handler: handler1, params: {}, isDynamic: false, metadata: undefined }, { handler: handler2, params: {}, isDynamic: false, metadata: undefined }]);
 });
 
 QUnit.test("Overlapping routes recognize", (assert: Assert) => {
@@ -555,8 +600,8 @@ QUnit.test("Overlapping routes recognize", (assert: Assert) => {
   router.add([{ path: "/foo/:baz", handler: handler2 }]);
   router.add([{ path: "/foo/bar/:bar", handler: handler1 }]);
 
-  resultsMatch(assert, router.recognize("/foo/bar/1"), [{ handler: handler1, params: { bar: "1" }, isDynamic: true }]);
-  resultsMatch(assert, router.recognize("/foo/1"), [{ handler: handler2, params: { baz: "1" }, isDynamic: true }]);
+  resultsMatch(assert, router.recognize("/foo/bar/1"), [{ handler: handler1, params: { bar: "1" }, isDynamic: true, metadata: undefined }]);
+  resultsMatch(assert, router.recognize("/foo/1"), [{ handler: handler2, params: { baz: "1" }, isDynamic: true, metadata: undefined }]);
 });
 
 QUnit.test("Overlapping star routes recognize", (assert: Assert) => {
@@ -567,8 +612,8 @@ QUnit.test("Overlapping star routes recognize", (assert: Assert) => {
   router.add([{ path: "/foo/*bar", handler: handler2 }]);
   router.add([{ path: "/*foo", handler: handler1 }]);
 
-  resultsMatch(assert, router.recognize("/foo/1"), [{ handler: handler2, params: { bar: "1" }, isDynamic: true }]);
-  resultsMatch(assert, router.recognize("/1"), [{ handler: handler1, params: { foo: "1" }, isDynamic: true }]);
+  resultsMatch(assert, router.recognize("/foo/1"), [{ handler: handler2, params: { bar: "1" }, isDynamic: true, metadata: undefined }]);
+  resultsMatch(assert, router.recognize("/1"), [{ handler: handler1, params: { foo: "1" }, isDynamic: true, metadata: undefined }]);
 });
 
 QUnit.test("Prefers single dynamic segments over stars", (assert: Assert) => {
@@ -579,9 +624,9 @@ QUnit.test("Prefers single dynamic segments over stars", (assert: Assert) => {
   router.add([{ path: "/foo/*star", handler: handler1 }]);
   router.add([{ path: "/foo/*star/:dynamic", handler: handler2 }]);
 
-  resultsMatch(assert, router.recognize("/foo/1"), [{ handler: handler1, params: { star: "1" }, isDynamic: true }]);
-  resultsMatch(assert, router.recognize("/foo/suffix"), [{ handler: handler1, params: { star: "suffix" }, isDynamic: true }]);
-  resultsMatch(assert, router.recognize("/foo/bar/suffix"), [{ handler: handler2, params: { star: "bar", dynamic: "suffix" }, isDynamic: true }]);
+  resultsMatch(assert, router.recognize("/foo/1"), [{ handler: handler1, params: { star: "1" }, isDynamic: true, metadata: undefined }]);
+  resultsMatch(assert, router.recognize("/foo/suffix"), [{ handler: handler1, params: { star: "suffix" }, isDynamic: true, metadata: undefined }]);
+  resultsMatch(assert, router.recognize("/foo/bar/suffix"), [{ handler: handler2, params: { star: "bar", dynamic: "suffix" }, isDynamic: true, metadata: undefined }]);
 });
 
 QUnit.test("Handle star routes last when there are trailing `/` routes.", (assert: Assert) => {
@@ -596,9 +641,9 @@ QUnit.test("Handle star routes last when there are trailing `/` routes.", (asser
   router.add([{ path: "/foo/:dynamic", handler: handler1 }, { path: "/*wildcard", handler: handlerWildcard }]);
 
   resultsMatch(assert, router.recognize("/foo/r3/baz/w10"), [
-    { handler: handler1, params: { dynamic: "r3" }, isDynamic: true },
-    { handler: handler2, params: { dynamic: "w10" }, isDynamic: true },
-    { handler: handler3, params: { }, isDynamic: false }
+    { handler: handler1, params: { dynamic: "r3" }, isDynamic: true, metadata: undefined },
+    { handler: handler2, params: { dynamic: "w10" }, isDynamic: true, metadata: undefined },
+    { handler: handler3, params: { }, isDynamic: false, metadata: undefined }
   ]);
 });
 
@@ -611,11 +656,11 @@ QUnit.test("Handle `/` before globs when the route is empty.", (assert: Assert)
   router.add([{ path: "/*notFound", handler: handler2 }]);
 
   resultsMatch(assert, router.recognize("/"), [
-    { handler: handler1, params: { }, isDynamic: false }
+    { handler: handler1, params: { }, isDynamic: false, metadata: undefined }
   ]);
 
   resultsMatch(assert, router.recognize("/hello"), [
-    { handler: handler2, params: { notFound: "hello" }, isDynamic: true }
+    { handler: handler2, params: { notFound: "hello" }, isDynamic: true, metadata: undefined }
   ]);
 });
 
@@ -624,7 +669,7 @@ QUnit.test("Routes with trailing `/` recognize", (assert: Assert) => {
   let router = new RouteRecognizer();
 
   router.add([{ path: "/foo/bar", handler: handler }]);
-  resultsMatch(assert, router.recognize("/foo/bar/"), [{ handler: handler, params: {}, isDynamic: false }]);
+  resultsMatch(assert, router.recognize("/foo/bar/"), [{ handler: handler, params: {}, isDynamic: false, metadata: undefined }]);
 });
 
 QUnit.test("Nested routes recognize", (assert: Assert) => {
@@ -634,7 +679,7 @@ QUnit.test("Nested routes recognize", (assert: Assert) => {
   let router = new RouteRecognizer();
   router.add([{ path: "/foo/:bar", handler: handler1 }, { path: "/baz/:bat", handler: handler2 }], { as: "foo" });
 
-  resultsMatch(assert, router.recognize("/foo/1/baz/2"), [{ handler: handler1, params: { bar: "1" }, isDynamic: true }, { handler: handler2, params: { bat: "2" }, isDynamic: true }]);
+  resultsMatch(assert, router.recognize("/foo/1/baz/2"), [{ handler: handler1, params: { bar: "1" }, isDynamic: true, metadata: undefined }, { handler: handler2, params: { bat: "2" }, isDynamic: true, metadata: undefined }]);
 
   assert.equal(router.hasRoute("foo"), true);
   assert.equal(router.hasRoute("bar"), false);
@@ -647,7 +692,7 @@ QUnit.test("Nested epsilon routes recognize.", (assert: Assert) => {
   router.add([{"path": "/", "handler": "application"}, {"path": "/", "handler": "test1"}, {"path": "/", "handler": "test1.index"}]);
   router.add([{"path": "/", "handler": "application"}, {"path": "/:param", "handler": "misc"}], {"as": "misc"});
 
-  resultsMatch(assert, router.recognize("/test2"), [{ "handler": "application", "isDynamic": false, "params": {} }, { "handler": "test1", "isDynamic": false, "params": {} }, { "handler": "test1.test2", "isDynamic": false, "params": {} }]);
+  resultsMatch(assert, router.recognize("/test2"), [{ "handler": "application", "isDynamic": false, "params": {}, metadata: undefined }, { "handler": "test1", "isDynamic": false, "params": {}, metadata: undefined }, { "handler": "test1.test2", "isDynamic": false, "params": {}, metadata: undefined }]);
 });
 
 QUnit.test("Nested routes with query params recognize", (assert: Assert) => {
@@ -658,17 +703,17 @@ QUnit.test("Nested routes with query params recognize", (assert: Assert) => {
   router.add([{ path: "/foo/:bar", handler: handler1, queryParams: ["a", "b"] }, { path: "/baz/:bat", handler: handler2, queryParams: ["b", "c"] }], { as: "foo" });
 
   resultsMatch(assert, router.recognize("/foo/4/baz/5?a=1"),
-    [{ handler: handler1, params: { bar: "4" }, isDynamic: true }, { handler: handler2, params: { bat: "5" }, isDynamic: true }], { a: "1" });
+    [{ handler: handler1, params: { bar: "4" }, isDynamic: true, metadata: undefined }, { handler: handler2, params: { bat: "5" }, isDynamic: true, metadata: undefined }], { a: "1" });
   resultsMatch(assert, router.recognize("/foo/4/baz/5?a=1&b=2"),
-    [{ handler: handler1, params: { bar: "4" }, isDynamic: true }, { handler: handler2, params: { bat: "5" }, isDynamic: true }], { a: "1", b: "2" });
+    [{ handler: handler1, params: { bar: "4" }, isDynamic: true, metadata: undefined }, { handler: handler2, params: { bat: "5" }, isDynamic: true, metadata: undefined }], { a: "1", b: "2" });
   resultsMatch(assert, router.recognize("/foo/4/baz/5?a=1&b=2&c=3"),
-    [{ handler: handler1, params: { bar: "4" }, isDynamic: true }, { handler: handler2, params: { bat: "5" }, isDynamic: true }], { a: "1", b: "2", c: "3" });
+    [{ handler: handler1, params: { bar: "4" }, isDynamic: true, metadata: undefined }, { handler: handler2, params: { bat: "5" }, isDynamic: true, metadata: undefined }], { a: "1", b: "2", c: "3" });
   resultsMatch(assert, router.recognize("/foo/4/baz/5?b=2&c=3"),
-    [{ handler: handler1, params: { bar: "4" }, isDynamic: true }, { handler: handler2, params: { bat: "5" }, isDynamic: true }], { b: "2", c: "3" });
+    [{ handler: handler1, params: { bar: "4" }, isDynamic: true, metadata: undefined }, { handler: handler2, params: { bat: "5" }, isDynamic: true, metadata: undefined }], { b: "2", c: "3" });
   resultsMatch(assert, router.recognize("/foo/4/baz/5?c=3"),
-    [{ handler: handler1, params: { bar: "4" }, isDynamic: true }, { handler: handler2, params: { bat: "5" }, isDynamic: true }], { c: "3" });
+    [{ handler: handler1, params: { bar: "4" }, isDynamic: true, metadata: undefined }, { handler: handler2, params: { bat: "5" }, isDynamic: true, metadata: undefined }], { c: "3" });
   resultsMatch(assert, router.recognize("/foo/4/baz/5?a=1&c=3"),
-    [{ handler: handler1, params: { bar: "4" }, isDynamic: true }, { handler: handler2, params: { bat: "5" }, isDynamic: true }], { a: "1", c: "3" });
+    [{ handler: handler1, params: { bar: "4" }, isDynamic: true, metadata: undefined }, { handler: handler2, params: { bat: "5" }, isDynamic: true, metadata: undefined }], { a: "1", c: "3" });
 
   assert.equal(router.hasRoute("foo"), true);
   assert.equal(router.hasRoute("bar"), false);
@@ -684,9 +729,9 @@ QUnit.test("If there are multiple matches, the route with the least dynamic segm
   router.add([{ path: "/posts/:id", handler: handler2 }]);
   router.add([{ path: "/posts/edit", handler: handler3 }]);
 
-  resultsMatch(assert, router.recognize("/posts/new"), [{ handler: handler1, params: {}, isDynamic: false }]);
-  resultsMatch(assert, router.recognize("/posts/1"), [{ handler: handler2, params: { id: "1" }, isDynamic: true }]);
-  resultsMatch(assert, router.recognize("/posts/edit"), [{ handler: handler3, params: {}, isDynamic: false }]);
+  resultsMatch(assert, router.recognize("/posts/new"), [{ handler: handler1, params: {}, isDynamic: false, metadata: undefined }]);
+  resultsMatch(assert, router.recognize("/posts/1"), [{ handler: handler2, params: { id: "1" }, isDynamic: true, metadata: undefined }]);
+  resultsMatch(assert, router.recognize("/posts/edit"), [{ handler: handler3, params: {}, isDynamic: false, metadata: undefined }]);
 });
 
 QUnit.test("Empty paths", (assert: Assert) => {
@@ -699,8 +744,8 @@ QUnit.test("Empty paths", (assert: Assert) => {
   router.add([{ path: "/foo", handler: handler1 }, { path: "/", handler: handler2 }, { path: "/bar", handler: handler3 }]);
   router.add([{ path: "/foo", handler: handler1 }, { path: "/", handler: handler2 }, { path: "/baz", handler: handler4 }]);
 
-  resultsMatch(assert, router.recognize("/foo/bar"), [{ handler: handler1, params: {}, isDynamic: false }, { handler: handler2, params: {}, isDynamic: false }, { handler: handler3, params: {}, isDynamic: false }]);
-  resultsMatch(assert, router.recognize("/foo/baz"), [{ handler: handler1, params: {}, isDynamic: false }, { handler: handler2, params: {}, isDynamic: false }, { handler: handler4, params: {}, isDynamic: false }]);
+  resultsMatch(assert, router.recognize("/foo/bar"), [{ handler: handler1, params: {}, isDynamic: false, metadata: undefined }, { handler: handler2, params: {}, isDynamic: false, metadata: undefined }, { handler: handler3, params: {}, isDynamic: false, metadata: undefined }]);
+  resultsMatch(assert, router.recognize("/foo/baz"), [{ handler: handler1, params: {}, isDynamic: false, metadata: undefined }, { handler: handler2, params: {}, isDynamic: false, metadata: undefined }, { handler: handler4, params: {}, isDynamic: false, metadata: undefined }]);
 });
 
 QUnit.test("Repeated empty segments don't confuse the recognizer", (assert: Assert) => {
@@ -713,10 +758,10 @@ QUnit.test("Repeated empty segments don't confuse the recognizer", (assert: Asse
   router.add([{ path: "/", handler: handler1 }, { path: "/", handler: handler2 }, { path: "/", handler: handler3 }]);
   router.add([{ path: "/", handler: handler1 }, { path: "/", handler: handler2 }, { path: "/foo", handler: handler4 }]);
 
-  resultsMatch(assert, router.recognize("/"), [{ handler: handler1, params: {}, isDynamic: false }, { handler: handler2, params: {}, isDynamic: false }, { handler: handler3, params: {}, isDynamic: false }]);
-  resultsMatch(assert, router.recognize(""), [{ handler: handler1, params: {}, isDynamic: false }, { handler: handler2, params: {}, isDynamic: false }, { handler: handler3, params: {}, isDynamic: false }]);
-  resultsMatch(assert, router.recognize("/foo"), [{ handler: handler1, params: {}, isDynamic: false }, { handler: handler2, params: {}, isDynamic: false }, { handler: handler4, params: {}, isDynamic: false }]);
-  resultsMatch(assert, router.recognize("foo"), [{ handler: handler1, params: {}, isDynamic: false }, { handler: handler2, params: {}, isDynamic: false }, { handler: handler4, params: {}, isDynamic: false }]);
+  resultsMatch(assert, router.recognize("/"), [{ handler: handler1, params: {}, isDynamic: false, metadata: undefined }, { handler: handler2, params: {}, isDynamic: false, metadata: undefined }, { handler: handler3, params: {}, isDynamic: false, metadata: undefined }]);
+  resultsMatch(assert, router.recognize(""), [{ handler: handler1, params: {}, isDynamic: false, metadata: undefined }, { handler: handler2, params: {}, isDynamic: false, metadata: undefined }, { handler: handler3, params: {}, isDynamic: false, metadata: undefined }]);
+  resultsMatch(assert, router.recognize("/foo"), [{ handler: handler1, params: {}, isDynamic: false, metadata: undefined }, { handler: handler2, params: {}, isDynamic: false, metadata: undefined }, { handler: handler4, params: {}, isDynamic: false, metadata: undefined }]);
+  resultsMatch(assert, router.recognize("foo"), [{ handler: handler1, params: {}, isDynamic: false, metadata: undefined }, { handler: handler2, params: {}, isDynamic: false, metadata: undefined }, { handler: handler4, params: {}, isDynamic: false, metadata: undefined }]);
 });
 
 // BUG - https://github.com/emberjs/ember.js/issues/2559
@@ -725,7 +770,7 @@ QUnit.test("Dynamic routes without leading `/` and single length param are recog
   let router = new RouteRecognizer();
 
   router.add([{ path: "/foo/:id", handler: handler }]);
-  resultsMatch(assert, router.recognize("foo/1"), [{ handler: handler, params: { id: "1" }, isDynamic: true }]);
+  resultsMatch(assert, router.recognize("foo/1"), [{ handler: handler, params: { id: "1" }, isDynamic: true, metadata: undefined }]);
 });
 
 
@@ -1048,11 +1093,11 @@ QUnit.module("Route Generation", hooks => {
   });
 
   QUnit.test("Getting the handlers for a named route", (assert: Assert) => {
-    assert.deepEqual(router.handlersFor("post"), [ { handler: handlers[0], names: ["id"], shouldDecodes: [true] } ]);
-    assert.deepEqual(router.handlersFor("posts"), [ { handler: handlers[1], names: [], shouldDecodes: [] } ]);
-    assert.deepEqual(router.handlersFor("new_post"), [ { handler: handlers[2], names: [], shouldDecodes: [] } ]);
-    assert.deepEqual(router.handlersFor("edit_post"), [ { handler: handlers[3], names: ["id"], shouldDecodes: [true] } ]);
-    assert.deepEqual(router.handlersFor("catchall"), [ { handler: handlers[5], names: ["catchall"], shouldDecodes: [false] } ]);
+    assert.deepEqual(router.handlersFor("post"), [ { handler: handlers[0], names: ["id"], shouldDecodes: [true], metadata: undefined } ]);
+    assert.deepEqual(router.handlersFor("posts"), [ { handler: handlers[1], names: [], shouldDecodes: [], metadata: undefined } ]);
+    assert.deepEqual(router.handlersFor("new_post"), [ { handler: handlers[2], names: [], shouldDecodes: [], metadata: undefined } ]);
+    assert.deepEqual(router.handlersFor("edit_post"), [ { handler: handlers[3], names: ["id"], shouldDecodes: [true], metadata: undefined } ]);
+    assert.deepEqual(router.handlersFor("catchall"), [ { handler: handlers[5], names: ["catchall"], shouldDecodes: [false], metadata: undefined } ]);
   });
 
   QUnit.test("Getting a handler for an invalid named route raises", (assert: Assert) => {
@@ -1070,8 +1115,8 @@ QUnit.module("Route Generation", hooks => {
     router.add([{ path: "/:dynamic", handler: handler1 }, { path: "/", handler: handler1 }]);
 
     resultsMatch(assert, router.recognize("/static"), [
-      { handler: handler2, params: { }, isDynamic: false },
-      { handler: handler2, params: { }, isDynamic: false }
+      { handler: handler2, params: { }, isDynamic: false, metadata: undefined },
+      { handler: handler2, params: { }, isDynamic: false, metadata: undefined }
     ]);
   });
 
@@ -1099,21 +1144,21 @@ QUnit.module("Route Generation", hooks => {
     ]);
 
     resultsMatch(assert, router.recognize("/5"), [
-      { handler: handler1, params: { }, isDynamic: false },
-      { handler: handler1, params: { }, isDynamic: false },
-      { handler: handler1, params: { post_id: "5" }, isDynamic: true }
+      { handler: handler1, params: { }, isDynamic: false, metadata: undefined },
+      { handler: handler1, params: { }, isDynamic: false, metadata: undefined },
+      { handler: handler1, params: { post_id: "5" }, isDynamic: true, metadata: undefined }
     ]);
 
     resultsMatch(assert, router.recognize("/team"), [
-      { handler: handler2, params: { }, isDynamic: false },
-      { handler: handler2, params: { }, isDynamic: false },
-      { handler: handler2, params: { }, isDynamic: false }
+      { handler: handler2, params: { }, isDynamic: false, metadata: undefined },
+      { handler: handler2, params: { }, isDynamic: false, metadata: undefined },
+      { handler: handler2, params: { }, isDynamic: false, metadata: undefined }
     ]);
 
     resultsMatch(assert, router.recognize("/team/eww_slugs"), [
-      { handler: handler3, params: { }, isDynamic: false },
-      { handler: handler3, params: { }, isDynamic: false },
-      { handler: handler3, params: { user_slug: "eww_slugs" }, isDynamic: true }
+      { handler: handler3, params: { }, isDynamic: false, metadata: undefined },
+      { handler: handler3, params: { }, isDynamic: false, metadata: undefined },
+      { handler: handler3, params: { user_slug: "eww_slugs" }, isDynamic: true, metadata: undefined }
     ]);
   });
 });
diff --git a/tests/router-tests.ts b/tests/router-tests.ts
index 07a9e65..1b1dca9 100644
--- a/tests/router-tests.ts
+++ b/tests/router-tests.ts
@@ -28,9 +28,9 @@ QUnit.module("The match DSL", hooks => {
       match("/posts/edit").to("editPost");
     });
 
-    matchesRoute(assert, "/posts/new", [{ handler: "newPost", params: {}, isDynamic: false }]);
-    matchesRoute(assert, "/posts/1", [{ handler: "showPost", params: { id: "1" }, isDynamic: true }]);
-    matchesRoute(assert, "/posts/edit", [{ handler: "editPost", params: {}, isDynamic: false }]);
+    matchesRoute(assert, "/posts/new", [{ handler: "newPost", params: {}, isDynamic: false, metadata: undefined }]);
+    matchesRoute(assert, "/posts/1", [{ handler: "showPost", params: { id: "1" }, isDynamic: true, metadata: undefined }]);
+    matchesRoute(assert, "/posts/edit", [{ handler: "editPost", params: {}, isDynamic: false, metadata: undefined }]);
   });
 
   QUnit.test("supports multiple calls to match with query params", (assert: Assert) => {
@@ -40,9 +40,9 @@ QUnit.module("The match DSL", hooks => {
       match("/posts/edit").to("editPost");
     });
 
-    matchesRoute(assert, "/posts/new?foo=1&bar=2", [{ handler: "newPost", params: {}, isDynamic: false }], {foo: "1", bar: "2"});
-    matchesRoute(assert, "/posts/1?baz=3", [{ handler: "showPost", params: { id: "1" }, isDynamic: true }], {baz: "3"});
-    matchesRoute(assert, "/posts/edit", [{ handler: "editPost", params: {}, isDynamic: false }], {});
+    matchesRoute(assert, "/posts/new?foo=1&bar=2", [{ handler: "newPost", params: {}, isDynamic: false, metadata: undefined }], {foo: "1", bar: "2"});
+    matchesRoute(assert, "/posts/1?baz=3", [{ handler: "showPost", params: { id: "1" }, isDynamic: true, metadata: undefined }], {baz: "3"});
+    matchesRoute(assert, "/posts/edit", [{ handler: "editPost", params: {}, isDynamic: false, metadata: undefined }], {});
   });
 
   QUnit.test("supports nested match", (assert: Assert) => {
@@ -54,9 +54,9 @@ QUnit.module("The match DSL", hooks => {
       });
     });
 
-    matchesRoute(assert, "/posts/new", [{ handler: "newPost", params: {}, isDynamic: false }]);
-    matchesRoute(assert, "/posts/1", [{ handler: "showPost", params: { id: "1" }, isDynamic: true }]);
-    matchesRoute(assert, "/posts/edit", [{ handler: "editPost", params: {}, isDynamic: false }]);
+    matchesRoute(assert, "/posts/new", [{ handler: "newPost", params: {}, isDynamic: false, metadata: undefined }]);
+    matchesRoute(assert, "/posts/1", [{ handler: "showPost", params: { id: "1" }, isDynamic: true, metadata: undefined }]);
+    matchesRoute(assert, "/posts/edit", [{ handler: "editPost", params: {}, isDynamic: false, metadata: undefined }]);
   });
 
   QUnit.test("support nested dynamic routes and star route", (assert: Assert) => {
@@ -70,18 +70,18 @@ QUnit.module("The match DSL", hooks => {
 
     // fails because it incorrectly matches the wildcard route
     matchesRoute(assert, "/abc", [
-      {handler: "routeId", params: { routeId: "abc" }, isDynamic: true},
-      {handler: "routeId.index", params: {}, isDynamic: false},
+      {handler: "routeId", params: { routeId: "abc" }, isDynamic: true, metadata: undefined},
+      {handler: "routeId.index", params: {}, isDynamic: false, metadata: undefined},
     ]);
 
     // passes
     matchesRoute(assert, "/abc/def", [
-      {handler: "routeId", params: {routeId: "abc"}, isDynamic: true},
-      {handler: "subRouteId", params: {"subRouteId": "def"}, isDynamic: true}
+      {handler: "routeId", params: {routeId: "abc"}, isDynamic: true, metadata: undefined},
+      {handler: "subRouteId", params: {"subRouteId": "def"}, isDynamic: true, metadata: undefined}
     ]);
 
     // fails because no route is recognized
-    matchesRoute(assert, "/abc/def/ghi", [{handler: "wildcard", params: { wildcard: "abc/def/ghi"}, isDynamic: true}]);
+    matchesRoute(assert, "/abc/def/ghi", [{handler: "wildcard", params: { wildcard: "abc/def/ghi"}, isDynamic: true, metadata: undefined}]);
   });
 
   QUnit.test("supports nested match with query params", (assert: Assert) => {
@@ -93,9 +93,9 @@ QUnit.module("The match DSL", hooks => {
       });
     });
 
-    matchesRoute(assert, "/posts/new?foo=1&bar=2", [{ handler: "newPost", params: {}, isDynamic: false }], {foo: "1", bar: "2"});
-    matchesRoute(assert, "/posts/1?baz=3", [{ handler: "showPost", params: { id: "1" }, isDynamic: true }], {baz: "3"});
-    matchesRoute(assert, "/posts/edit", [{ handler: "editPost", params: {}, isDynamic: false }], {});
+    matchesRoute(assert, "/posts/new?foo=1&bar=2", [{ handler: "newPost", params: {}, isDynamic: false, metadata: undefined }], {foo: "1", bar: "2"});
+    matchesRoute(assert, "/posts/1?baz=3", [{ handler: "showPost", params: { id: "1" }, isDynamic: true, metadata: undefined }], {baz: "3"});
+    matchesRoute(assert, "/posts/edit", [{ handler: "editPost", params: {}, isDynamic: false, metadata: undefined }], {});
   });
 
   QUnit.test("not passing a function with `match` as a parameter raises", (assert: Assert) => {
@@ -117,9 +117,9 @@ QUnit.module("The match DSL", hooks => {
       });
     });
 
-    matchesRoute(assert, "/posts/new", [{ handler: "posts", params: {}, isDynamic: false }, { handler: "newPost", params: {}, isDynamic: false }]);
-    matchesRoute(assert, "/posts/1", [{ handler: "posts", params: {}, isDynamic: false }, { handler: "showPost", params: { id: "1" }, isDynamic: true }]);
-    matchesRoute(assert, "/posts/edit", [{ handler: "posts", params: {}, isDynamic: false }, { handler: "editPost", params: {}, isDynamic: false }]);
+    matchesRoute(assert, "/posts/new", [{ handler: "posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "newPost", params: {}, isDynamic: false, metadata: undefined }]);
+    matchesRoute(assert, "/posts/1", [{ handler: "posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "showPost", params: { id: "1" }, isDynamic: true, metadata: undefined }]);
+    matchesRoute(assert, "/posts/edit", [{ handler: "posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "editPost", params: {}, isDynamic: false, metadata: undefined }]);
   });
 
   QUnit.test("supports deeply nested handlers", (assert: Assert) => {
@@ -134,11 +134,11 @@ QUnit.module("The match DSL", hooks => {
       });
     });
 
-    matchesRoute(assert, "/posts/new", [{ handler: "posts", params: {}, isDynamic: false }, { handler: "newPost", params: {}, isDynamic: false }]);
-    matchesRoute(assert, "/posts/1/index", [{ handler: "posts", params: {}, isDynamic: false }, { handler: "showPost", params: { id: "1" }, isDynamic: true }, { handler: "postIndex", params: {}, isDynamic: false }]);
-    matchesRoute(assert, "/posts/1/comments", [{ handler: "posts", params: {}, isDynamic: false }, { handler: "showPost", params: { id: "1" }, isDynamic: true }, { handler: "postComments", params: {}, isDynamic: false }]);
-    matchesRoute(assert, "/posts/ne/comments", [{ handler: "posts", params: {}, isDynamic: false }, { handler: "showPost", params: { id: "ne" }, isDynamic: true }, { handler: "postComments", params: {}, isDynamic: false }]);
-    matchesRoute(assert, "/posts/edit", [{ handler: "posts", params: {}, isDynamic: false }, { handler: "editPost", params: {}, isDynamic: false }]);
+    matchesRoute(assert, "/posts/new", [{ handler: "posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "newPost", params: {}, isDynamic: false, metadata: undefined }]);
+    matchesRoute(assert, "/posts/1/index", [{ handler: "posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "showPost", params: { id: "1" }, isDynamic: true, metadata: undefined }, { handler: "postIndex", params: {}, isDynamic: false, metadata: undefined }]);
+    matchesRoute(assert, "/posts/1/comments", [{ handler: "posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "showPost", params: { id: "1" }, isDynamic: true, metadata: undefined }, { handler: "postComments", params: {}, isDynamic: false, metadata: undefined }]);
+    matchesRoute(assert, "/posts/ne/comments", [{ handler: "posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "showPost", params: { id: "ne" }, isDynamic: true, metadata: undefined }, { handler: "postComments", params: {}, isDynamic: false, metadata: undefined }]);
+    matchesRoute(assert, "/posts/edit", [{ handler: "posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "editPost", params: {}, isDynamic: false, metadata: undefined }]);
   });
 
   QUnit.test("supports index-style routes", (assert: Assert) => {
@@ -153,10 +153,10 @@ QUnit.module("The match DSL", hooks => {
       });
     });
 
-    matchesRoute(assert, "/posts/new", [{ handler: "posts", params: {}, isDynamic: false }, { handler: "newPost", params: {}, isDynamic: false }]);
-    matchesRoute(assert, "/posts/1", [{ handler: "posts", params: {}, isDynamic: false }, { handler: "showPost", params: { id: "1" }, isDynamic: true }, { handler: "postIndex", params: {}, isDynamic: false }]);
-    matchesRoute(assert, "/posts/1/comments", [{ handler: "posts", params: {}, isDynamic: false }, { handler: "showPost", params: { id: "1" }, isDynamic: true }, { handler: "postComments", params: {}, isDynamic: false }]);
-    matchesRoute(assert, "/posts/edit", [{ handler: "posts", params: {}, isDynamic: false }, { handler: "editPost", params: {}, isDynamic: false }]);
+    matchesRoute(assert, "/posts/new", [{ handler: "posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "newPost", params: {}, isDynamic: false, metadata: undefined }]);
+    matchesRoute(assert, "/posts/1", [{ handler: "posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "showPost", params: { id: "1" }, isDynamic: true, metadata: undefined }, { handler: "postIndex", params: {}, isDynamic: false, metadata: undefined }]);
+    matchesRoute(assert, "/posts/1/comments", [{ handler: "posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "showPost", params: { id: "1" }, isDynamic: true, metadata: undefined }, { handler: "postComments", params: {}, isDynamic: false, metadata: undefined }]);
+    matchesRoute(assert, "/posts/edit", [{ handler: "posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "editPost", params: {}, isDynamic: false, metadata: undefined }]);
   });
 
   QUnit.test("supports single `/` routes", (assert: Assert) => {
@@ -164,7 +164,7 @@ QUnit.module("The match DSL", hooks => {
       match("/").to("posts");
     });
 
-    matchesRoute(assert, "/", [{ handler: "posts", params: {}, isDynamic: false }]);
+    matchesRoute(assert, "/", [{ handler: "posts", params: {}, isDynamic: false, metadata: undefined }]);
   });
 
   QUnit.test("supports star routes", (assert: Assert) => {
@@ -175,7 +175,7 @@ QUnit.module("The match DSL", hooks => {
 
     // randomly generated strings
     ["w6PCXxJn20PCSievuP", "v2y0gaByxHjHYJw0pVT1TeqbEJLllVq-3", "DFCR4rm7XMbT6CPZq-d8AU7k", "d3vYEg1AoYaPlM9QbOAxEK6u/H_S-PYH1aYtt"].forEach(function(r) {
-      matchesRoute(assert, "/" + r, [{ handler: "404", params: {everything: r}, isDynamic: true}]);
+      matchesRoute(assert, "/" + r, [{ handler: "404", params: {everything: r}, isDynamic: true, metadata: undefined }]);
     });
   });
 
@@ -188,7 +188,7 @@ QUnit.module("The match DSL", hooks => {
     });
 
     r = "folder1/folder2/folder3/";
-    matchesRoute(assert, "/" + r, [{ handler: "glob", params: {everything: r}, isDynamic: true}]);
+    matchesRoute(assert, "/" + r, [{ handler: "glob", params: {everything: r}, isDynamic: true, metadata: undefined }]);
   });
 
   QUnit.test("support star route before other segment", (assert: Assert) => {
@@ -197,7 +197,7 @@ QUnit.module("The match DSL", hooks => {
     });
 
     ["folder1/folder2/folder3//the-extra-stuff/", "folder1/folder2/folder3//the-extra-stuff"].forEach(function(r) {
-      matchesRoute(assert, "/" + r, [{ handler: "glob", params: {everything: "folder1/folder2/folder3/", extra: "the-extra-stuff"}, isDynamic: true}]);
+      matchesRoute(assert, "/" + r, [{ handler: "glob", params: {everything: "folder1/folder2/folder3/", extra: "the-extra-stuff"}, isDynamic: true, metadata: undefined }]);
     });
   });
 
@@ -209,7 +209,7 @@ QUnit.module("The match DSL", hooks => {
     });
 
     ["folder1/folder2/folder3//the-extra-stuff/", "folder1/folder2/folder3//the-extra-stuff"].forEach(function(r) {
-      matchesRoute(assert, "/" + r, [{ handler: "glob", params: {everything: "folder1/folder2/folder3/"}, isDynamic: true}, { handler: "extra", params: {extra: "the-extra-stuff"}, isDynamic: true}]);
+      matchesRoute(assert, "/" + r, [{ handler: "glob", params: {everything: "folder1/folder2/folder3/"}, isDynamic: true, metadata: undefined }, { handler: "extra", params: {extra: "the-extra-stuff"}, isDynamic: true, metadata: undefined }]);
     });
   });
 
@@ -234,7 +234,7 @@ QUnit.module("The match DSL", hooks => {
 
     assert.deepEqual(passedArguments, ["application", "posts"], "The entered contexts were passed to contextEntered");
 
-    matchesRoute(assert, "/posts", [{ handler: "application", params: {}, isDynamic: false }, { handler: "posts", params: {}, isDynamic: false }, { handler: "index", params: {}, isDynamic: false }]);
+    matchesRoute(assert, "/posts", [{ handler: "application", params: {}, isDynamic: false, metadata: undefined }, { handler: "posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "index", params: {}, isDynamic: false, metadata: undefined }]);
   });
 
   QUnit.test("delegate can change added routes", (assert: Assert) => {
@@ -259,8 +259,8 @@ QUnit.module("The match DSL", hooks => {
       });
     });
 
-    matchesRoute(assert, "/posts", [{ handler: "application", params: {}, isDynamic: false }, { handler: "application.posts", params: {}, isDynamic: false }, { handler: "posts.index", params: {}, isDynamic: false }]);
-    matchesRoute(assert, "/posts/1", [{ handler: "application", params: {}, isDynamic: false }, { handler: "application.posts", params: {}, isDynamic: false }, { handler: "posts.post", params: { post_id: "1" }, isDynamic: true }]);
+    matchesRoute(assert, "/posts", [{ handler: "application", params: {}, isDynamic: false, metadata: undefined }, { handler: "application.posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "posts.index", params: {}, isDynamic: false, metadata: undefined }]);
+    matchesRoute(assert, "/posts/1", [{ handler: "application", params: {}, isDynamic: false, metadata: undefined }, { handler: "application.posts", params: {}, isDynamic: false, metadata: undefined }, { handler: "posts.post", params: { post_id: "1" }, isDynamic: true, metadata: undefined }]);
   });
 
   QUnit.test("supports add-route callback", (assert: Assert) => {
@@ -279,9 +279,9 @@ QUnit.module("The match DSL", hooks => {
         });
         match("/").to("index");
       });
-    }, function (router, route) {
-      invocations.push(route.map(e => e.handler).join("."));
-      router.add(route);
+    }, function (recognizer, routes) {
+      invocations.push(routes.map(e => e.handler).join("."));
+      recognizer.add(routes);
     });
 
     const expected = [
@@ -296,12 +296,26 @@ QUnit.module("The match DSL", hooks => {
 
     assert.deepEqual(expected, invocations, "invokes for the correct set of routes");
     matchesRoute(assert, "/lobby/loading", [
-      { handler: "application", params: {}, isDynamic: false },
-      { handler: "lobby", params: {}, isDynamic: false },
-      { handler: "lobby.loading", params: {}, isDynamic: false }
+      { handler: "application", params: {}, isDynamic: false, metadata: undefined },
+      { handler: "lobby", params: {}, isDynamic: false, metadata: undefined },
+      { handler: "lobby.loading", params: {}, isDynamic: false, metadata: undefined }
     ]);
   });
 
+  QUnit.test("supports passing metadata in route", (assert: Assert) => {
+    let metadata = {};
+
+    router.map(function(match) {
+      match("/posts/new").to("newPost");
+    }, function (recognizer, routes) {
+      recognizer.add(routes.map(e => {
+        e.metadata = metadata;
+        return e;
+      }));
+    });
+
+    matchesRoute(assert, "/posts/new", [{ handler: "newPost", params: {}, isDynamic: false, metadata: metadata }]);
+  });
 });