@weborigami/language 0.3.3-jse.3 → 0.3.4-jse.4

package/test/compiler/parse.test.js

@@ -21,38 +21,47 @@ describe("Origami parser", () => {
 
   describe("angleBracketLiteral", () => {
     test("with path", () => {
+      assertParse("angleBracketLiteral", "<index.html>", [
+        markers.traverse,
+        [markers.external, "index.html"],
+      ]);
       assertParse(
         "angleBracketLiteral",
-        "<index.html>",
-        [[ops.scope], [ops.literal, "index.html"]],
-        "jse"
-      );
-      assertParse(
-        "angleBracketLiteral",
-        "<foo/bar/baz>",
+        "<Path with spaces (and parens).html>",
         [
-          [ops.scope],
-          [ops.literal, "foo/"],
-          [ops.literal, "bar/"],
-          [ops.literal, "baz"],
-        ],
-        "jse"
+          markers.traverse,
+          [markers.external, "Path with spaces (and parens).html"],
+        ]
       );
+      assertParse("angleBracketLiteral", "<foo/bar/baz>", [
+        markers.traverse,
+        [markers.external, "foo/"],
+        [ops.literal, "bar/"],
+        [ops.literal, "baz"],
+      ]);
     });
 
     test("root directory", () => {
-      assertParse("angleBracketLiteral", "</>", [ops.rootDirectory]);
+      assertParse("angleBracketLiteral", "</>", [
+        markers.traverse,
+        [markers.external, "/"],
+      ]);
       assertParse("angleBracketLiteral", "</etc/passwd>", [
-        [ops.rootDirectory],
+        markers.traverse,
+        [markers.external, "/"],
         [ops.literal, "etc/"],
         [ops.literal, "passwd"],
       ]);
     });
 
     test("home directory", () => {
-      assertParse("angleBracketLiteral", "<~>", [ops.homeDirectory]);
+      assertParse("angleBracketLiteral", "<~>", [
+        markers.traverse,
+        [markers.external, "~"],
+      ]);
       assertParse("angleBracketLiteral", "<~/.bash_profile>", [
-        [ops.homeDirectory],
+        markers.traverse,
+        [markers.external, "~/"],
         [ops.literal, ".bash_profile"],
       ]);
     });
@@ -117,12 +126,12 @@ describe("Origami parser", () => {
     assertParse("arrowFunction", "() => foo", [
       ops.lambda,
       [],
-      [markers.reference, [ops.literal, "foo"]],
+      [markers.traverse, [markers.reference, "foo"]],
     ]);
     assertParse("arrowFunction", "x => y", [
       ops.lambda,
       [[ops.literal, "x"]],
-      [markers.reference, [ops.literal, "y"]],
+      [markers.traverse, [markers.reference, "y"]],
     ]);
     assertParse("arrowFunction", "(a, b, c) ⇒ fn(a, b, c)", [
       ops.lambda,
@@ -132,10 +141,10 @@ describe("Origami parser", () => {
         [ops.literal, "c"],
       ],
       [
-        [markers.global, "fn"],
-        [markers.reference, [ops.literal, "a"]],
-        [markers.reference, [ops.literal, "b"]],
-        [markers.reference, [ops.literal, "c"]],
+        [markers.traverse, [markers.reference, "fn"]],
+        [markers.traverse, [markers.reference, "a"]],
+        [markers.traverse, [markers.reference, "b"]],
+        [markers.traverse, [markers.reference, "c"]],
       ],
     ]);
     assertParse("arrowFunction", "a => b => fn(a, b)", [
@@ -145,9 +154,9 @@ describe("Origami parser", () => {
         ops.lambda,
         [[ops.literal, "b"]],
         [
-          [markers.global, "fn"],
-          [markers.reference, [ops.literal, "a"]],
-          [markers.reference, [ops.literal, "b"]],
+          [markers.traverse, [markers.reference, "fn"]],
+          [markers.traverse, [markers.reference, "a"]],
+          [markers.traverse, [markers.reference, "b"]],
         ],
       ],
     ]);
@@ -180,75 +189,74 @@ describe("Origami parser", () => {
   describe("callExpression", () => {
     test("with parentheses arguments", () => {
       assertParse("callExpression", "fn()", [
-        [markers.global, "fn"],
+        [markers.traverse, [markers.reference, "fn"]],
         undefined,
       ]);
       assertParse("callExpression", "foo.js(arg)", [
-        [markers.reference, [ops.literal, "foo.js"]],
-        [markers.reference, [ops.literal, "arg"]],
+        [markers.traverse, [markers.reference, "foo.js"]],
+        [markers.traverse, [markers.reference, "arg"]],
       ]);
       assertParse("callExpression", "fn(a, b)", [
-        [markers.global, "fn"],
-        [markers.reference, [ops.literal, "a"]],
-        [markers.reference, [ops.literal, "b"]],
+        [markers.traverse, [markers.reference, "fn"]],
+        [markers.traverse, [markers.reference, "a"]],
+        [markers.traverse, [markers.reference, "b"]],
       ]);
       assertParse("callExpression", "foo.js( a , b )", [
-        [markers.reference, [ops.literal, "foo.js"]],
-        [markers.reference, [ops.literal, "a"]],
-        [markers.reference, [ops.literal, "b"]],
+        [markers.traverse, [markers.reference, "foo.js"]],
+        [markers.traverse, [markers.reference, "a"]],
+        [markers.traverse, [markers.reference, "b"]],
       ]);
       assertParse("callExpression", "fn()(arg)", [
-        [[markers.global, "fn"], undefined],
-        [markers.reference, [ops.literal, "arg"]],
+        [[markers.traverse, [markers.reference, "fn"]], undefined],
+        [markers.traverse, [markers.reference, "arg"]],
       ]);
     });
+
     test("call chains", () => {
       assertParse("callExpression", "(foo.js())('arg')", [
-        [[markers.reference, [ops.literal, "foo.js"]], undefined],
+        [[markers.traverse, [markers.reference, "foo.js"]], undefined],
         [ops.literal, "arg"],
       ]);
       assertParse("callExpression", "fn('a')('b')", [
         [
-          [markers.global, "fn"],
+          [markers.traverse, [markers.reference, "fn"]],
           [ops.literal, "a"],
         ],
         [ops.literal, "b"],
       ]);
       assertParse("callExpression", "(foo.js())(a, b)", [
-        [[markers.reference, [ops.literal, "foo.js"]], undefined],
-        [markers.reference, [ops.literal, "a"]],
-        [markers.reference, [ops.literal, "b"]],
+        [[markers.traverse, [markers.reference, "foo.js"]], undefined],
+        [markers.traverse, [markers.reference, "a"]],
+        [markers.traverse, [markers.reference, "b"]],
       ]);
     });
+
     test("with paths", () => {
-      assertParse("callExpression", "/", [ops.rootDirectory]);
       assertParse("callExpression", "tree/", [
         ops.unpack,
-        [markers.reference, [ops.literal, "tree/"]],
+        [markers.traverse, [markers.reference, "tree/"]],
       ]);
       assertParse("callExpression", "tree/foo/bar", [
-        markers.reference,
-        [ops.literal, "tree/"],
+        markers.traverse,
+        [markers.reference, "tree/"],
         [ops.literal, "foo/"],
         [ops.literal, "bar"],
       ]);
       assertParse("callExpression", "tree/foo/bar/", [
-        markers.reference,
-        [ops.literal, "tree/"],
-        [ops.literal, "foo/"],
-        [ops.literal, "bar/"],
+        ops.unpack,
+        [
+          markers.traverse,
+          [markers.reference, "tree/"],
+          [ops.literal, "foo/"],
+          [ops.literal, "bar/"],
+        ],
       ]);
       // Consecutive slahes in a path are removed
-      assertParse("callExpression", "path//key", [
-        markers.reference,
-        [ops.literal, "path/"],
+      assertParse("callExpression", "tree//key", [
+        markers.traverse,
+        [markers.reference, "tree/"],
         [ops.literal, "key"],
       ]);
-      assertParse("callExpression", "/foo/bar", [
-        [ops.rootDirectory],
-        [ops.literal, "foo/"],
-        [ops.literal, "bar"],
-      ]);
       assertParse("callExpression", "{ a: 1, b: 2}/b", [
         [ops.object, ["a", [ops.literal, 1]], ["b", [ops.literal, 2]]],
         [ops.literal, "b"],
@@ -259,22 +267,19 @@ describe("Origami parser", () => {
         [ops.literal, "bar"],
       ]);
     });
+
     test("path and parentheses chains", () => {
       assertParse("callExpression", "foo.js()/key", [
-        [[markers.reference, [ops.literal, "foo.js"]], undefined],
+        [[markers.traverse, [markers.reference, "foo.js"]], undefined],
         [ops.literal, "key"],
       ]);
       assertParse("callExpression", "tree/key()", [
-        [markers.reference, [ops.literal, "tree/"], [ops.literal, "key"]],
+        [markers.traverse, [markers.reference, "tree/"], [ops.literal, "key"]],
         undefined,
       ]);
-      assertParse("callExpression", "(tree)/", [
-        ops.unpack,
-        [markers.reference, [ops.literal, "tree/"]],
-      ]);
       assertParse("callExpression", "fn()/key()", [
         [
-          [[markers.global, "fn"], undefined],
+          [[markers.traverse, [markers.reference, "fn"]], undefined],
           [ops.literal, "key"],
         ],
         undefined,
@@ -286,68 +291,44 @@ describe("Origami parser", () => {
           [ops.literal, "dropbox/"],
           [ops.literal, "auth"],
         ],
-        [markers.reference, [ops.literal, "creds"]],
+        [markers.traverse, [markers.reference, "creds"]],
       ]);
     });
+
     test("tagged templates", () => {
       assertParse("callExpression", "indent`hello`", [
-        [markers.global, "indent"],
+        [markers.traverse, [markers.reference, "indent"]],
         [ops.literal, ["hello"]],
       ]);
       assertParse("callExpression", "fn.js`Hello, world.`", [
-        [markers.reference, [ops.literal, "fn.js"]],
+        [markers.traverse, [markers.reference, "fn.js"]],
         [ops.literal, ["Hello, world."]],
       ]);
     });
+
     test("protocols", () => {
       assertParse("callExpression", "files:src/assets", [
         [markers.global, "files:"],
         [ops.literal, "src/"],
         [ops.literal, "assets"],
       ]);
-      assertParse("callExpression", "new:(js:Date, '2025-01-01')", [
-        [markers.global, "new:"],
+      assertParse("callExpression", "<node:process>.env", [
         [
-          [markers.global, "js:"],
-          [ops.literal, "Date"],
+          [markers.global, "node:"],
+          [ops.literal, "process"],
         ],
-        [ops.literal, "2025-01-01"],
+        [ops.literal, "env"],
       ]);
     });
   });
 
-  test("callExpression using property acccess", () => {
-    assertParse("callExpression", "(foo).bar", [
-      markers.reference,
-      [ops.literal, "foo/"],
-      [ops.literal, "bar"],
-    ]);
-    assertParse("callExpression", "(foo).bar.baz", [
-      markers.reference,
-      [ops.literal, "foo/"],
-      [ops.literal, "bar/"],
-      [ops.literal, "baz"],
-    ]);
-    assertParse("callExpression", "foo[bar]", [
-      markers.reference,
-      [ops.literal, "foo/"],
-      [markers.reference, [ops.literal, "bar"]],
-    ]);
-    assertParse(
-      "callExpression",
-      "Tree.map",
-      [markers.reference, [ops.literal, "Tree/"], [ops.literal, "map"]],
-      "jse"
-    );
-  });
-
   test("commaExpression", () => {
     assertParse("commaExpression", "1", [ops.literal, 1]);
     assertParse("commaExpression", "a, b, c", [
       ops.comma,
-      [markers.reference, [ops.literal, "a"]],
-      [markers.reference, [ops.literal, "b"]],
-      [markers.reference, [ops.literal, "c"]],
+      [markers.traverse, [markers.reference, "a"]],
+      [markers.traverse, [markers.reference, "b"]],
+      [markers.traverse, [markers.reference, "c"]],
     ]);
   });
 
@@ -355,19 +336,19 @@ describe("Origami parser", () => {
     assertParse("conditionalExpression", "1", [ops.literal, 1]);
     assertParse("conditionalExpression", "true ? 1 : 0", [
       ops.conditional,
-      [markers.reference, [ops.literal, "true"]],
+      [markers.traverse, [markers.reference, "true"]],
       [ops.literal, 1],
       [ops.literal, 0],
     ]);
     assertParse("conditionalExpression", "false ? () => 1 : 0", [
       ops.conditional,
-      [markers.reference, [ops.literal, "false"]],
+      [markers.traverse, [markers.reference, "false"]],
       [ops.lambda, [], [ops.lambda, [], [ops.literal, 1]]],
       [ops.literal, 0],
     ]);
     assertParse("conditionalExpression", "false ? =1 : 0", [
       ops.conditional,
-      [markers.reference, [ops.literal, "false"]],
+      [markers.traverse, [markers.reference, "false"]],
       [ops.lambda, [], [ops.lambda, [[ops.literal, "_"]], [ops.literal, 1]]],
       [ops.literal, 0],
     ]);
@@ -383,10 +364,10 @@ describe("Origami parser", () => {
       ops.strictEqual,
       [
         ops.strictEqual,
-        [markers.reference, [ops.literal, "a"]],
-        [markers.reference, [ops.literal, "b"]],
+        [markers.traverse, [markers.reference, "a"]],
+        [markers.traverse, [markers.reference, "b"]],
       ],
-      [markers.reference, [ops.literal, "c"]],
+      [markers.traverse, [markers.reference, "c"]],
     ]);
     assertParse("equalityExpression", "1 !== 1", [
       ops.notStrictEqual,
@@ -440,182 +421,244 @@ Body`,
     ]);
   });
 
-  test("expression", () => {
-    assertParse(
-      "expression",
-      `{
+  describe("expression", () => {
+    test("slash with and without spaces", () => {
+      assertParse("expression", "x/y", [
+        markers.traverse,
+        [markers.reference, "x/"],
+        [ops.literal, "y"],
+      ]);
+      assertParse("expression", "x / y", [
+        ops.division,
+        [markers.traverse, [markers.reference, "x"]],
+        [markers.traverse, [markers.reference, "y"]],
+      ]);
+      // Parses as a call, not a path
+      assertParse("expression", "(x)/y", [
+        [markers.traverse, [markers.reference, "x"]],
+        [ops.literal, "y"],
+      ]);
+    });
+
+    test("operators with spaces = math", () => {
+      assertParse("expression", "a + b", [
+        ops.addition,
+        [markers.traverse, [markers.reference, "a"]],
+        [markers.traverse, [markers.reference, "b"]],
+      ]);
+      assertParse("expression", "a - b", [
+        ops.subtraction,
+        [markers.traverse, [markers.reference, "a"]],
+        [markers.traverse, [markers.reference, "b"]],
+      ]);
+      assertParse("expression", "a & b", [
+        ops.bitwiseAnd,
+        [markers.traverse, [markers.reference, "a"]],
+        [markers.traverse, [markers.reference, "b"]],
+      ]);
+    });
+
+    test("operators without spaces = reference", () => {
+      assertParse("expression", "a+b", [
+        markers.traverse,
+        [markers.reference, "a+b"],
+      ]);
+      assertParse("expression", "a-b", [
+        markers.traverse,
+        [markers.reference, "a-b"],
+      ]);
+      assertParse("expression", "a&b", [
+        markers.traverse,
+        [markers.reference, "a&b"],
+      ]);
+    });
+
+    test("property acccess", () => {
+      assertParse("expression", "(foo).bar", [
+        [markers.traverse, [markers.reference, "foo"]],
+        [ops.literal, "bar"],
+      ]);
+      assertParse("expression", "(foo).bar.baz", [
+        [
+          [markers.traverse, [markers.reference, "foo"]],
+          [ops.literal, "bar"],
+        ],
+        [ops.literal, "baz"],
+      ]);
+      assertParse("expression", "foo[bar]", [
+        [markers.traverse, [markers.reference, "foo"]],
+        [markers.traverse, [markers.reference, "bar"]],
+      ]);
+      assertParse("expression", "Tree.map", [
+        markers.traverse,
+        [markers.reference, "Tree.map"],
+      ]);
+    });
+
+    test("consecutive slashes at start of something = comment", () => {
+      assertParse(
+        "expression",
+        "x //comment",
+        [markers.traverse, [markers.reference, "x"]],
+        "jse",
+        false
+      );
+    });
+
+    test("complex expressions", () => {
+      assertParse("expression", "page.ori(mdHtml(about.md))", [
+        [markers.traverse, [markers.reference, "page.ori"]],
+        [
+          [markers.traverse, [markers.reference, "mdHtml"]],
+          [markers.traverse, [markers.reference, "about.md"]],
+        ],
+      ]);
+
+      assertParse("expression", "keys(</>)", [
+        [markers.traverse, [markers.reference, "keys"]],
+        [markers.traverse, [markers.external, "/"]],
+      ]);
+
+      assertParse("expression", "'Hello' -> test.ori.html", [
+        [markers.traverse, [markers.reference, "test.ori.html"]],
+        [ops.literal, "Hello"],
+      ]);
+      assertParse("expression", "obj.json", [
+        markers.traverse,
+        [markers.reference, "obj.json"],
+      ]);
+      assertParse("expression", "(fn a, b, c)", [
+        [markers.traverse, [markers.reference, "fn"]],
+        [markers.traverse, [markers.reference, "a"]],
+        [markers.traverse, [markers.reference, "b"]],
+        [markers.traverse, [markers.reference, "c"]],
+      ]);
+      assertParse("expression", "foo.bar('hello', 'world')", [
+        [markers.traverse, [markers.reference, "foo.bar"]],
+        [ops.literal, "hello"],
+        [ops.literal, "world"],
+      ]);
+      assertParse("expression", "(key)('a')", [
+        [markers.traverse, [markers.reference, "key"]],
+        [ops.literal, "a"],
+      ]);
+      assertParse("expression", "1", [ops.literal, 1]);
+      assertParse("expression", "{ a: 1, b: 2 }", [
+        ops.object,
+        ["a", [ops.literal, 1]],
+        ["b", [ops.literal, 2]],
+      ]);
+      assertParse("expression", "serve { index.html: 'hello' }", [
+        [markers.traverse, [markers.reference, "serve"]],
+        [ops.object, ["index.html", [ops.literal, "hello"]]],
+      ]);
+      assertParse("expression", "fn =`x`", [
+        [markers.traverse, [markers.reference, "fn"]],
+        [
+          ops.lambda,
+          [[ops.literal, "_"]],
+          [ops.templateTree, [ops.literal, ["x"]]],
+        ],
+      ]);
+      assertParse("expression", "copy app.js(formulas), files:snapshot", [
+        [markers.traverse, [markers.reference, "copy"]],
+        [
+          [markers.traverse, [markers.reference, "app.js"]],
+          [markers.traverse, [markers.reference, "formulas"]],
+        ],
+        [
+          [markers.global, "files:"],
+          [ops.literal, "snapshot"],
+        ],
+      ]);
+      assertParse("expression", "map =`<li>${_}</li>`", [
+        [markers.traverse, [markers.reference, "map"]],
+        [
+          ops.lambda,
+          [[ops.literal, "_"]],
+          [
+            ops.templateTree,
+            [ops.literal, ["<li>", "</li>"]],
+            [markers.traverse, [markers.reference, "_"]],
+          ],
+        ],
+      ]);
+      assertParse("expression", `https://example.com/about/`, [
+        [markers.global, "https:"],
+        [ops.literal, "example.com/"],
+        [ops.literal, "about/"],
+      ]);
+      assertParse("expression", "tag`Hello, ${name}!`", [
+        [markers.traverse, [markers.reference, "tag"]],
+        [ops.literal, ["Hello, ", "!"]],
+        [ops.concat, [markers.traverse, [markers.reference, "name"]]],
+      ]);
+      assertParse("expression", "=tag`Hello, ${_}!`", [
+        ops.lambda,
+        [[ops.literal, "_"]],
+        [
+          [markers.traverse, [markers.reference, "tag"]],
+          [ops.literal, ["Hello, ", "!"]],
+          [ops.concat, [markers.traverse, [markers.reference, "_"]]],
+        ],
+      ]);
+      assertParse("expression", "(post, slug) => fn.js(post, slug)", [
+        ops.lambda,
+        [
+          [ops.literal, "post"],
+          [ops.literal, "slug"],
+        ],
+        [
+          [markers.traverse, [markers.reference, "fn.js"]],
+          [markers.traverse, [markers.reference, "post"]],
+          [markers.traverse, [markers.reference, "slug"]],
+        ],
+      ]);
+      assertParse("expression", "keys(<~>)", [
+        [markers.traverse, [markers.reference, "keys"]],
+        [markers.traverse, [markers.external, "~"]],
+      ]);
+    });
+
+    test("complex object", () => {
+      assertParse(
+        "expression",
+        `{
         index.html = index.ori(teamData.yaml)
         thumbnails = map(images, { value: thumbnail.js })
       }`,
-      [
-        ops.object,
         [
-          "index.html",
+          ops.object,
           [
-            ops.getter,
+            "index.html",
             [
-              [markers.reference, [ops.literal, "index.ori"]],
-              [markers.reference, [ops.literal, "teamData.yaml"]],
+              ops.getter,
+              [
+                [markers.traverse, [markers.reference, "index.ori"]],
+                [markers.traverse, [markers.reference, "teamData.yaml"]],
+              ],
             ],
           ],
-        ],
-        [
-          "thumbnails",
           [
-            ops.getter,
+            "thumbnails",
             [
-              [markers.global, "map"],
-              [markers.reference, [ops.literal, "images"]],
+              ops.getter,
               [
-                ops.object,
-                ["value", [markers.reference, [ops.literal, "thumbnail.js"]]],
+                [markers.traverse, [markers.reference, "map"]],
+                [markers.traverse, [markers.reference, "images"]],
+                [
+                  ops.object,
+                  [
+                    "value",
+                    [markers.traverse, [markers.reference, "thumbnail.js"]],
+                  ],
+                ],
               ],
             ],
           ],
-        ],
-      ]
-    );
-
-    // Builtin on its own is the function itself, not a function call
-    assertParse("expression", "mdHtml:", [markers.global, "mdHtml:"]);
-
-    // Consecutive slashes at start of something = comment
-    assertParse(
-      "expression",
-      "x //comment",
-      [markers.reference, [ops.literal, "x"]],
-      "jse",
-      false
-    );
-
-    assertParse("expression", "page.ori(mdHtml:(about.md))", [
-      [markers.reference, [ops.literal, "page.ori"]],
-      [
-        [markers.global, "mdHtml:"],
-        [markers.reference, [ops.literal, "about.md"]],
-      ],
-    ]);
-
-    // Slash on its own is the root folder
-    assertParse("expression", "keys /", [
-      [markers.global, "keys"],
-      [ops.rootDirectory],
-    ]);
-
-    assertParse("expression", "'Hello' -> test.orit", [
-      [markers.reference, [ops.literal, "test.orit"]],
-      [ops.literal, "Hello"],
-    ]);
-    assertParse("expression", "obj.json", [
-      markers.reference,
-      [ops.literal, "obj.json"],
-    ]);
-    assertParse("expression", "(fn a, b, c)", [
-      [markers.global, "fn"],
-      [markers.reference, [ops.literal, "a"]],
-      [markers.reference, [ops.literal, "b"]],
-      [markers.reference, [ops.literal, "c"]],
-    ]);
-    assertParse("expression", "foo.bar('hello', 'world')", [
-      [markers.reference, [ops.literal, "foo.bar"]],
-      [ops.literal, "hello"],
-      [ops.literal, "world"],
-    ]);
-    // assertParse("expression", "(key)('a')", [
-    //   [markers.reference, [ops.literal, "key"]],
-    //   [ops.literal, "a"],
-    // ]);
-    assertParse("expression", "1", [ops.literal, 1]);
-    assertParse("expression", "{ a: 1, b: 2 }", [
-      ops.object,
-      ["a", [ops.literal, 1]],
-      ["b", [ops.literal, 2]],
-    ]);
-    assertParse("expression", "serve { index.html: 'hello' }", [
-      [markers.global, "serve"],
-      [ops.object, ["index.html", [ops.literal, "hello"]]],
-    ]);
-    assertParse("expression", "fn =`x`", [
-      [markers.global, "fn"],
-      [
-        ops.lambda,
-        [[ops.literal, "_"]],
-        [ops.templateTree, [ops.literal, ["x"]]],
-      ],
-    ]);
-    assertParse("expression", "copy app.js(formulas), files:snapshot", [
-      [markers.global, "copy"],
-      [
-        [markers.reference, [ops.literal, "app.js"]],
-        [markers.reference, [ops.literal, "formulas"]],
-      ],
-      [
-        [markers.global, "files:"],
-        [ops.literal, "snapshot"],
-      ],
-    ]);
-    assertParse("expression", "map =`<li>${_}</li>`", [
-      [markers.global, "map"],
-      [
-        ops.lambda,
-        [[ops.literal, "_"]],
-        [
-          ops.templateTree,
-          [ops.literal, ["<li>", "</li>"]],
-          [markers.reference, [ops.literal, "_"]],
-        ],
-      ],
-    ]);
-    assertParse("expression", `https://example.com/about/`, [
-      [markers.global, "https:"],
-      [ops.literal, "example.com/"],
-      [ops.literal, "about/"],
-    ]);
-    assertParse("expression", "tag`Hello, ${name}!`", [
-      [markers.global, "tag"],
-      [ops.literal, ["Hello, ", "!"]],
-      [ops.concat, [markers.reference, [ops.literal, "name"]]],
-    ]);
-    assertParse("expression", "(post, slug) => fn.js(post, slug)", [
-      ops.lambda,
-      [
-        [ops.literal, "post"],
-        [ops.literal, "slug"],
-      ],
-      [
-        [markers.reference, [ops.literal, "fn.js"]],
-        [markers.reference, [ops.literal, "post"]],
-        [markers.reference, [ops.literal, "slug"]],
-      ],
-    ]);
-    assertParse("expression", "keys ~", [
-      [markers.global, "keys"],
-      [ops.homeDirectory],
-    ]);
-    assertParse("expression", "keys /Users/alice", [
-      [markers.global, "keys"],
-      [[ops.rootDirectory], [ops.literal, "Users/"], [ops.literal, "alice"]],
-    ]);
-
-    // Verify parser treatment of identifiers containing operators
-    assertParse("expression", "a + b", [
-      ops.addition,
-      [markers.reference, [ops.literal, "a"]],
-      [markers.reference, [ops.literal, "b"]],
-    ]);
-    assertParse("expression", "a+b", [markers.reference, [ops.literal, "a+b"]]);
-    assertParse("expression", "a - b", [
-      ops.subtraction,
-      [markers.reference, [ops.literal, "a"]],
-      [markers.reference, [ops.literal, "b"]],
-    ]);
-    assertParse("expression", "a-b", [markers.reference, [ops.literal, "a-b"]]);
-    assertParse("expression", "a&b", [markers.reference, [ops.literal, "a&b"]]);
-    assertParse("expression", "a & b", [
-      ops.bitwiseAnd,
-      [markers.reference, [ops.literal, "a"]],
-      [markers.reference, [ops.literal, "b"]],
-    ]);
+        ]
+      );
+    });
   });
 
   test("frontMatterExpression", () => {
@@ -628,7 +671,7 @@ Body`,
       [
         ops.lambda,
         [[ops.literal, "name"]],
-        [[markers.reference, [ops.literal, "_template"]], undefined],
+        [[markers.traverse, [markers.reference, "_template"]], undefined],
       ],
       "jse",
       false
@@ -637,90 +680,98 @@ Body`,
 
   test("group", () => {
     assertParse("group", "(hello)", [
-      markers.reference,
-      [ops.literal, "hello"],
+      markers.traverse,
+      [markers.reference, "hello"],
     ]);
     assertParse("group", "(((nested)))", [
-      markers.reference,
-      [ops.literal, "nested"],
+      markers.traverse,
+      [markers.reference, "nested"],
+    ]);
+    assertParse("group", "(fn())", [
+      [markers.traverse, [markers.reference, "fn"]],
+      undefined,
     ]);
-    assertParse("group", "(fn())", [[markers.global, "fn"], undefined]);
     assertParse("group", "(a -> b)", [
-      [markers.global, "b"],
-      [markers.reference, [ops.literal, "a"]],
+      [markers.traverse, [markers.reference, "b"]],
+      [markers.traverse, [markers.reference, "a"]],
     ]);
   });
 
-  test("homeDirectory", () => {
-    assertParse("homeDirectory", "~", [ops.homeDirectory]);
-  });
-
   test("host", () => {
     assertParse("host", "abc", [ops.literal, "abc"]);
     assertParse("host", "abc:123", [ops.literal, "abc:123"]);
-    assertParse("host", "foo\\ bar", [ops.literal, "foo bar"]);
   });
 
   test("identifier", () => {
-    assertParse("identifier", "abc", "abc", "shell", false);
-    assertParse("identifier", "index.html", "index.html", "shell", false);
-    assertParse("identifier", "foo\\ bar", "foo bar", "shell", false);
-    assertParse("identifier", "x-y-z", "x-y-z", "shell", false);
+    assertParse("identifier", "foo", "foo", "jse", false);
+    assertParse("identifier", "$Δelta", "$Δelta", "jse", false);
+    assertThrows(
+      "identifier",
+      "1stCharacterIsNumber",
+      "Expected JavaScript identifier start"
+    );
+    assertThrows(
+      "identifier",
+      "has space",
+      "Expected JavaScript identifier continuation"
+    );
+    assertThrows(
+      "identifier",
+      "foo.bar",
+      "Expected JavaScript identifier continuation"
+    );
   });
 
   test("implicitParenthesesCallExpression", () => {
     assertParse("implicitParenthesesCallExpression", "fn arg", [
-      [markers.global, "fn"],
-      [markers.reference, [ops.literal, "arg"]],
+      [markers.traverse, [markers.reference, "fn"]],
+      [markers.traverse, [markers.reference, "arg"]],
     ]);
     assertParse("implicitParenthesesCallExpression", "page.ori 'a', 'b'", [
-      [markers.reference, [ops.literal, "page.ori"]],
+      [markers.traverse, [markers.reference, "page.ori"]],
       [ops.literal, "a"],
       [ops.literal, "b"],
     ]);
     assertParse("implicitParenthesesCallExpression", "fn a(b), c", [
-      [markers.global, "fn"],
+      [markers.traverse, [markers.reference, "fn"]],
       [
-        [markers.global, "a"],
-        [markers.reference, [ops.literal, "b"]],
+        [markers.traverse, [markers.reference, "a"]],
+        [markers.traverse, [markers.reference, "b"]],
       ],
-      [markers.reference, [ops.literal, "c"]],
+      [markers.traverse, [markers.reference, "c"]],
     ]);
     assertParse("implicitParenthesesCallExpression", "(fn()) 'arg'", [
-      [[markers.global, "fn"], undefined],
+      [[markers.traverse, [markers.reference, "fn"]], undefined],
       [ops.literal, "arg"],
     ]);
-    assertParse("implicitParenthesesCallExpression", "tree/key arg", [
-      [markers.reference, [ops.literal, "tree/"], [ops.literal, "key"]],
-      [markers.reference, [ops.literal, "arg"]],
-    ]);
+    assertParse(
+      "implicitParenthesesCallExpression",
+      "tree/key arg",
+      [
+        [markers.traverse, [markers.reference, "tree/"], [ops.literal, "key"]],
+        [markers.traverse, [markers.reference, "arg"]],
+      ],
+      "shell"
+    );
     assertParse("implicitParenthesesCallExpression", "foo.js bar.ori 'arg'", [
-      [markers.reference, [ops.literal, "foo.js"]],
+      [markers.traverse, [markers.reference, "foo.js"]],
       [
-        [markers.reference, [ops.literal, "bar.ori"]],
+        [markers.traverse, [markers.reference, "bar.ori"]],
         [ops.literal, "arg"],
       ],
     ]);
   });
 
-  test("jsIdentifier", () => {
-    assertParse("jsIdentifier", "foo", [ops.literal, "foo"], "jse");
-    assertParse("jsIdentifier", "$Δelta", [ops.literal, "$Δelta"], "jse");
-    assertThrows(
-      "jsIdentifier",
-      "1stCharacterIsNumber",
-      "Expected JavaScript identifier start"
-    );
-    assertThrows(
-      "jsIdentifier",
-      "has space",
-      "Expected JavaScript identifier continuation"
-    );
-    assertThrows(
-      "jsIdentifier",
-      "foo.bar",
-      "Expected JavaScript identifier continuation"
-    );
+  test("key", () => {
+    assertParse("key", "a", "a");
+    assertParse("key", "_b", "_b");
+    assertParse("key", ".ssh", ".ssh");
+    assertParse("key", "index.html", "index.html");
+    assertParse("key", "404.html", "404.html");
+    assertParse("key", "1a2b3c", "1a2b3c");
+    assertParse("key", "a~b", "a~b");
+    assertParse("key", "foo-bar", "foo-bar");
+    assertParse("key", "package-lock.json", "package-lock.json");
   });
 
   test("list", () => {
@@ -755,8 +806,8 @@ Body`,
   test("logicalAndExpression", () => {
     assertParse("logicalAndExpression", "true && false", [
       ops.logicalAnd,
-      [markers.reference, [ops.literal, "true"]],
-      [ops.lambda, [], [markers.reference, [ops.literal, "false"]]],
+      [markers.traverse, [markers.reference, "true"]],
+      [ops.lambda, [], [markers.traverse, [markers.reference, "false"]]],
     ]);
   });
 
@@ -768,9 +819,9 @@ Body`,
     ]);
     assertParse("logicalOrExpression", "false || false || true", [
       ops.logicalOr,
-      [markers.reference, [ops.literal, "false"]],
-      [ops.lambda, [], [markers.reference, [ops.literal, "false"]]],
-      [ops.lambda, [], [markers.reference, [ops.literal, "true"]]],
+      [markers.traverse, [markers.reference, "false"]],
+      [ops.lambda, [], [markers.traverse, [markers.reference, "false"]]],
+      [ops.lambda, [], [markers.traverse, [markers.reference, "true"]]],
     ]);
     assertParse("logicalOrExpression", "1 || 2 && 0", [
       ops.logicalOr,
@@ -807,32 +858,28 @@ Body`,
     ]);
   });
 
-  test("namespace", () => {
-    assertParse("namespace", "js:", [markers.global, "js:"]);
-  });
-
   test("newExpression", () => {
     assertParse("newExpression", "new Foo()", [
       ops.construct,
-      [markers.reference, [ops.literal, "Foo"]],
+      [markers.traverse, [markers.reference, "Foo"]],
     ]);
     assertParse("newExpression", "new:Foo()", [
       ops.construct,
-      [markers.reference, [ops.literal, "Foo"]],
+      [markers.traverse, [markers.reference, "Foo"]],
     ]);
   });
 
   test("nullishCoalescingExpression", () => {
     assertParse("nullishCoalescingExpression", "a ?? b", [
       ops.nullishCoalescing,
-      [markers.reference, [ops.literal, "a"]],
-      [ops.lambda, [], [markers.reference, [ops.literal, "b"]]],
+      [markers.traverse, [markers.reference, "a"]],
+      [ops.lambda, [], [markers.traverse, [markers.reference, "b"]]],
     ]);
     assertParse("nullishCoalescingExpression", "a ?? b ?? c", [
       ops.nullishCoalescing,
-      [markers.reference, [ops.literal, "a"]],
-      [ops.lambda, [], [markers.reference, [ops.literal, "b"]]],
-      [ops.lambda, [], [markers.reference, [ops.literal, "c"]]],
+      [markers.traverse, [markers.reference, "a"]],
+      [ops.lambda, [], [markers.traverse, [markers.reference, "b"]]],
+      [ops.lambda, [], [markers.traverse, [markers.reference, "c"]]],
     ]);
   });
 
@@ -847,7 +894,7 @@ Body`,
     assertParse("objectLiteral", "{ a: 1, b }", [
       ops.object,
       ["a", [ops.literal, 1]],
-      ["b", [markers.reference, "b"]],
+      ["b", [markers.traverse, [markers.reference, "b"]]],
     ]);
     assertParse("objectLiteral", "{ sub: { a: 1 } }", [
       ops.object,
@@ -864,7 +911,7 @@ Body`,
     ]);
     assertParse("objectLiteral", "{ a = b, b = 2 }", [
       ops.object,
-      ["a", [ops.getter, [markers.reference, [ops.literal, "b"]]]],
+      ["a", [ops.getter, [markers.traverse, [markers.reference, "b"]]]],
       ["b", [ops.literal, 2]],
     ]);
     assertParse(
@@ -875,7 +922,7 @@ Body`,
       }`,
       [
         ops.object,
-        ["a", [ops.getter, [markers.reference, [ops.literal, "b"]]]],
+        ["a", [ops.getter, [markers.traverse, [markers.reference, "b"]]]],
         ["b", [ops.literal, 2]],
       ]
     );
@@ -891,7 +938,16 @@ Body`,
       ops.object,
       [
         "a",
-        [ops.object, ["b", [ops.getter, [[markers.global, "fn"], undefined]]]],
+        [
+          ops.object,
+          [
+            "b",
+            [
+              ops.getter,
+              [[markers.traverse, [markers.reference, "fn"]], undefined],
+            ],
+          ],
+        ],
       ],
     ]);
     assertParse("objectLiteral", "{ x = fn.js('a') }", [
@@ -901,7 +957,7 @@ Body`,
         [
           ops.getter,
           [
-            [markers.reference, [ops.literal, "fn.js"]],
+            [markers.traverse, [markers.reference, "fn.js"]],
             [ops.literal, "a"],
           ],
         ],
@@ -911,13 +967,13 @@ Body`,
       [
         ops.object,
         ["a", [ops.literal, 1]],
-        ["c", [markers.reference, [ops.literal, "a"]]],
+        ["c", [markers.traverse, [markers.reference, "a"]]],
         [
           "_result",
           [
             ops.merge,
             [ops.object, ["a", [ops.getter, [[ops.context, 1], "a"]]]],
-            [markers.reference, [ops.literal, "more"]],
+            [markers.traverse, [markers.reference, "more"]],
             [ops.object, ["c", [ops.getter, [[ops.context, 1], "c"]]]],
           ],
         ],
@@ -941,8 +997,8 @@ Body`,
         [
           "file.txt",
           [
-            [ops.scope],
-            [ops.literal, "path/"],
+            markers.traverse,
+            [markers.external, "path/"],
             [ops.literal, "to/"],
             [ops.literal, "file.txt"],
           ],
@@ -953,14 +1009,17 @@ Body`,
   });
 
   test("objectEntry", () => {
-    assertParse("objectEntry", "foo", ["foo", [markers.reference, "foo"]]);
-    assertParse("objectEntry", "x: y", [
-      "x",
-      [markers.reference, [ops.literal, "y"]],
+    assertParse("objectEntry", "foo", [
+      "foo",
+      [markers.traverse, [markers.reference, "foo"]],
+    ]);
+    assertParse("objectEntry", "index.html: x", [
+      "index.html",
+      [markers.traverse, [markers.reference, "x"]],
     ]);
     assertParse("objectEntry", "a: a", [
       "a",
-      [markers.reference, [ops.literal, "a"]],
+      [markers.traverse, [markers.reference, "a"]],
     ]);
     assertParse(
       "objectEntry",
@@ -968,8 +1027,8 @@ Body`,
       [
         "file.txt",
         [
-          [ops.scope],
-          [ops.literal, "path/"],
+          markers.traverse,
+          [markers.external, "path/"],
           [ops.literal, "to/"],
           [ops.literal, "file.txt"],
         ],
@@ -981,15 +1040,15 @@ Body`,
       [
         ops.lambda,
         [[ops.literal, "a"]],
-        [markers.reference, [ops.literal, "a"]],
+        [markers.traverse, [markers.reference, "a"]],
       ],
     ]);
     assertParse("objectEntry", "posts/: map(posts, post.ori)", [
       "posts/",
       [
-        [markers.global, "map"],
-        [markers.reference, [ops.literal, "posts"]],
-        [markers.reference, [ops.literal, "post.ori"]],
+        [markers.traverse, [markers.reference, "map"]],
+        [markers.traverse, [markers.reference, "posts"]],
+        [markers.traverse, [markers.reference, "post.ori"]],
       ],
     ]);
   });
@@ -997,15 +1056,15 @@ Body`,
   test("objectGetter", () => {
     assertParse("objectGetter", "data = obj.json", [
       "data",
-      [ops.getter, [markers.reference, [ops.literal, "obj.json"]]],
+      [ops.getter, [markers.traverse, [markers.reference, "obj.json"]]],
     ]);
-    assertParse("objectGetter", "foo = page.ori 'bar'", [
-      "foo",
+    assertParse("objectGetter", "index.html = index.ori(teamData.yaml)", [
+      "index.html",
       [
         ops.getter,
         [
-          [markers.reference, [ops.literal, "page.ori"]],
-          [ops.literal, "bar"],
+          [markers.traverse, [markers.reference, "index.ori"]],
+          [markers.traverse, [markers.reference, "teamData.yaml"]],
         ],
       ],
     ]);
@@ -1013,26 +1072,27 @@ Body`,
 
   test("objectProperty", () => {
     assertParse("objectProperty", "a: 1", ["a", [ops.literal, 1]]);
-    assertParse("objectProperty", "name: 'Alice'", [
-      "name",
+    assertParse("objectProperty", "data.json: 'Alice'", [
+      "data.json",
       [ops.literal, "Alice"],
     ]);
     assertParse("objectProperty", "x: fn('a')", [
       "x",
       [
-        [markers.global, "fn"],
+        [markers.traverse, [markers.reference, "fn"]],
         [ops.literal, "a"],
       ],
     ]);
   });
 
   test("objectPublicKey", () => {
-    assertParse("objectPublicKey", "a", "a", "jse", false);
-    assertParse("objectPublicKey", "markdown/", "markdown/", "jse", false);
-    assertParse("objectPublicKey", "foo\\ bar", "foo bar", "jse", false);
+    assertParse("objectPublicKey", "a", "a", "shell", false);
+    assertParse("objectPublicKey", "index.html", "index.html", "shell", false);
+    assertParse("objectPublicKey", "markdown/", "markdown/", "shell", false);
+    assertParse("objectPublicKey", `"foo bar"`, "foo bar", "shell", false);
   });
 
-  test("optionalChaining", () => {
+  test.skip("optionalChaining", () => {
     assertParse("optionalChaining", "?.key", [
       ops.optionalTraverse,
       [ops.literal, "key"],
@@ -1042,27 +1102,53 @@ Body`,
   test("parenthesesArguments", () => {
     assertParse("parenthesesArguments", "()", [undefined]);
     assertParse("parenthesesArguments", "(a, b, c)", [
-      [markers.reference, [ops.literal, "a"]],
-      [markers.reference, [ops.literal, "b"]],
-      [markers.reference, [ops.literal, "c"]],
+      [markers.traverse, [markers.reference, "a"]],
+      [markers.traverse, [markers.reference, "b"]],
+      [markers.traverse, [markers.reference, "c"]],
     ]);
   });
 
-  test("path", () => {
-    assertParse("path", "/tree/", [[ops.literal, "tree/"]]);
-    assertParse("path", "/month/12", [
-      [ops.literal, "month/"],
-      [ops.literal, "12"],
-    ]);
-    assertParse("path", "/tree/foo/bar", [
-      [ops.literal, "tree/"],
-      [ops.literal, "foo/"],
-      [ops.literal, "bar"],
-    ]);
-    assertParse("path", "/a///b", [
-      [ops.literal, "a/"],
-      [ops.literal, "b"],
-    ]);
+  test("pathKeys", () => {
+    assertParse(
+      "pathKeys",
+      "tree/",
+      [[ops.literal, "tree/"]],
+      undefined,
+      false
+    );
+    assertParse(
+      "pathKeys",
+      "month/12",
+      [
+        [ops.literal, "month/"],
+        [ops.literal, "12"],
+      ],
+      undefined,
+      false
+    );
+    assertParse(
+      "pathKeys",
+      "tree/foo/bar",
+      [
+        [ops.literal, "tree/"],
+        [ops.literal, "foo/"],
+        [ops.literal, "bar"],
+      ],
+      undefined,
+      false
+    );
+    assertParse(
+      "pathKeys",
+      "a///b",
+      [
+        [ops.literal, "a/"],
+        [ops.literal, "/"],
+        [ops.literal, "/"],
+        [ops.literal, "b"],
+      ],
+      undefined,
+      false
+    );
   });
 
   test("pathArguments", () => {
@@ -1077,50 +1163,80 @@ Body`,
     ]);
   });
 
+  test("pathLiteral", () => {
+    assertParse("pathLiteral", "tree", [
+      markers.traverse,
+      [markers.reference, "tree"],
+    ]);
+    assertParse("pathLiteral", "tree/", [
+      ops.unpack,
+      [markers.traverse, [markers.reference, "tree/"]],
+    ]);
+    assertParse("pathLiteral", "month/12", [
+      markers.traverse,
+      [markers.reference, "month/"],
+      [ops.literal, "12"],
+    ]);
+    assertParse("pathLiteral", "a/b/c/", [
+      ops.unpack,
+      [
+        markers.traverse,
+        [markers.reference, "a/"],
+        [ops.literal, "b/"],
+        [ops.literal, "c/"],
+      ],
+    ]);
+    assertParse("pathLiteral", "~/.cshrc", [
+      markers.traverse,
+      [markers.reference, "~/"],
+      [ops.literal, ".cshrc"],
+    ]);
+  });
+
   test("pipelineExpression", () => {
     assertParse("pipelineExpression", "foo", [
-      markers.reference,
-      [ops.literal, "foo"],
+      markers.traverse,
+      [markers.reference, "foo"],
     ]);
     assertParse("pipelineExpression", "a -> b", [
-      [markers.global, "b"],
-      [markers.reference, [ops.literal, "a"]],
+      [markers.traverse, [markers.reference, "b"]],
+      [markers.traverse, [markers.reference, "a"]],
     ]);
     assertParse("pipelineExpression", "input → one.js → two.js", [
-      [markers.reference, [ops.literal, "two.js"]],
+      [markers.traverse, [markers.reference, "two.js"]],
       [
-        [markers.reference, [ops.literal, "one.js"]],
-        [markers.reference, [ops.literal, "input"]],
+        [markers.traverse, [markers.reference, "one.js"]],
+        [markers.traverse, [markers.reference, "input"]],
       ],
     ]);
     assertParse("pipelineExpression", "fn a -> b", [
-      [markers.global, "b"],
+      [markers.traverse, [markers.reference, "b"]],
       [
-        [markers.global, "fn"],
-        [markers.reference, [ops.literal, "a"]],
+        [markers.traverse, [markers.reference, "fn"]],
+        [markers.traverse, [markers.reference, "a"]],
       ],
     ]);
   });
 
   test("primary", () => {
+    assertParse("primary", "123", [ops.literal, 123]);
+    assertParse("primary", "123.html", [
+      markers.traverse,
+      [markers.reference, "123.html"],
+    ]);
     assertParse("primary", "foo.js", [
-      markers.reference,
-      [ops.literal, "foo.js"],
+      markers.traverse,
+      [markers.reference, "foo.js"],
     ]);
     assertParse("primary", "[1, 2]", [
       ops.array,
       [ops.literal, 1],
       [ops.literal, 2],
     ]);
-    // Only in JSE
-    assertParse(
-      "primary",
-      "<index.html>",
-      [[ops.scope], [ops.literal, "index.html"]],
-      "jse",
-      false
-    );
-    assertThrows("primary", "<index.html>", `but "<" found`, 0, "shell");
+    assertParse("primary", "<index.html>", [
+      markers.traverse,
+      [markers.external, "index.html"],
+    ]);
   });
 
   test("program", () => {
@@ -1135,47 +1251,6 @@ Body`,
     );
   });
 
-  test("protocolExpression", () => {
-    assertParse("protocolExpression", "foo://bar/baz", [
-      [markers.global, "foo:"],
-      [ops.literal, "bar/"],
-      [ops.literal, "baz"],
-    ]);
-    assertParse("protocolExpression", "http://example.com", [
-      [markers.global, "http:"],
-      [ops.literal, "example.com"],
-    ]);
-    assertParse("protocolExpression", "https://example.com/about/", [
-      [markers.global, "https:"],
-      [ops.literal, "example.com/"],
-      [ops.literal, "about/"],
-    ]);
-    assertParse("protocolExpression", "https://example.com/about/index.html", [
-      [markers.global, "https:"],
-      [ops.literal, "example.com/"],
-      [ops.literal, "about/"],
-      [ops.literal, "index.html"],
-    ]);
-    assertParse("protocolExpression", "http://localhost:5000/foo", [
-      [markers.global, "http:"],
-      [ops.literal, "localhost:5000/"],
-      [ops.literal, "foo"],
-    ]);
-    assertParse("protocolExpression", "files:///foo/bar.txt", [
-      [markers.global, "files:"],
-      [ops.literal, "/"],
-      [ops.literal, "foo/"],
-      [ops.literal, "bar.txt"],
-    ]);
-  });
-
-  test("qualifiedReference", () => {
-    assertParse("qualifiedReference", "js:Date", [
-      [markers.global, "js:"],
-      [ops.literal, "Date"],
-    ]);
-  });
-
   test("regexLiteral", () => {
     assertParse("regexLiteral", "/abc+/g", [ops.literal, /abc+/g]);
   });
@@ -1203,17 +1278,6 @@ Body`,
     ]);
   });
 
-  test("scopeReference", () => {
-    assertParse("scopeReference", "keys", [
-      markers.reference,
-      [ops.literal, "keys"],
-    ]);
-    assertParse("scopeReference", "greet.js", [
-      markers.reference,
-      [ops.literal, "greet.js"],
-    ]);
-  });
-
   test("shiftExpression", () => {
     assertParse("shiftExpression", "1 << 2", [
       ops.shiftLeft,
@@ -1236,7 +1300,7 @@ Body`,
     assertParse("shorthandFunction", "=message", [
       ops.lambda,
       [[ops.literal, "_"]],
-      [markers.reference, [ops.literal, "message"]],
+      [markers.traverse, [markers.reference, "message"]],
     ]);
     assertParse("shorthandFunction", "=`Hello, ${name}.`", [
       ops.lambda,
@@ -1244,14 +1308,14 @@ Body`,
       [
         ops.templateTree,
         [ops.literal, ["Hello, ", "."]],
-        [markers.reference, [ops.literal, "name"]],
+        [markers.traverse, [markers.reference, "name"]],
       ],
     ]);
     assertParse("shorthandFunction", "=indent`hello`", [
       ops.lambda,
       [[ops.literal, "_"]],
       [
-        [markers.global, "indent"],
+        [markers.traverse, [markers.reference, "indent"]],
         [ops.literal, ["hello"]],
       ],
     ]);
@@ -1264,11 +1328,11 @@ Body`,
   test("spreadElement", () => {
     assertParse("spreadElement", "...a", [
       ops.spread,
-      [markers.reference, [ops.literal, "a"]],
+      [markers.traverse, [markers.reference, "a"]],
     ]);
     assertParse("spreadElement", "…a", [
       ops.spread,
-      [markers.reference, [ops.literal, "a"]],
+      [markers.traverse, [markers.reference, "a"]],
     ]);
   });
 
@@ -1290,7 +1354,7 @@ Body`,
     assertParse("templateBody", "hello${foo}world", [
       ops.templateIndent,
       [ops.literal, ["hello", "world"]],
-      [markers.reference, [ops.literal, "foo"]],
+      [markers.traverse, [markers.reference, "foo"]],
     ]);
     assertParse("templateBody", "Documents can contain ` backticks", [
       ops.templateIndent,
@@ -1316,7 +1380,8 @@ Body text`,
       [
         ops.object,
         ["title", [ops.literal, "Title goes here"]],
-        ["@text", [ops.templateIndent, [ops.literal, ["Body text"]]]],
+        ["(@text)", [ops.templateIndent, [ops.literal, ["Body text"]]]],
+        ["_body", [ops.templateIndent, [ops.literal, ["Body text"]]]],
       ]
     );
   });
@@ -1340,10 +1405,38 @@ Body text`,
           [
             ops.templateIndent,
             [ops.literal, ["<h1>", "</h1>\n"]],
-            [markers.reference, [ops.literal, "title"]],
+            [markers.traverse, [markers.reference, "title"]],
           ],
         ],
-      ]
+      ],
+      "shell"
+    );
+  });
+
+  test.skip("templateDocument with Origami front matter", () => {
+    assertParse(
+      "templateDocument",
+      `---
+{
+  title: "Title"
+  _body: _template()
+}
+---
+<h1>\${ title }</h1>
+`,
+      [
+        ops.object,
+        ["title", [ops.literal, "Title"]],
+        [
+          "_body",
+          [
+            ops.templateIndent,
+            [ops.literal, ["<h1>", "</h1>\n"]],
+            [markers.traverse, [markers.reference, "title"]],
+          ],
+        ],
+      ],
+      "jse"
     );
   });
 
@@ -1355,32 +1448,32 @@ Body text`,
     assertParse(
       "templateLiteral",
       "`Hello, world.`",
-      [ops.templateStandard, [ops.literal, ["Hello, world."]]],
+      [ops.templateTree, [ops.literal, ["Hello, world."]]],
       "jse"
     );
     assertParse("templateLiteral", "`foo ${x} bar`", [
       ops.templateTree,
       [ops.literal, ["foo ", " bar"]],
-      [markers.reference, [ops.literal, "x"]],
+      [markers.traverse, [markers.reference, "x"]],
     ]);
     assertParse("templateLiteral", "`${`nested`}`", [
       ops.templateTree,
       [ops.literal, ["", ""]],
       [ops.templateTree, [ops.literal, ["nested"]]],
     ]);
-    assertParse("templateLiteral", "`${ map:(people, =`${name}`) }`", [
+    assertParse("templateLiteral", "`${ map(people, =`${name}`) }`", [
       ops.templateTree,
       [ops.literal, ["", ""]],
       [
-        [markers.global, "map:"],
-        [markers.reference, [ops.literal, "people"]],
+        [markers.traverse, [markers.reference, "map"]],
+        [markers.traverse, [markers.reference, "people"]],
         [
           ops.lambda,
           [[ops.literal, "_"]],
           [
             ops.templateTree,
             [ops.literal, ["", ""]],
-            [markers.reference, [ops.literal, "name"]],
+            [markers.traverse, [markers.reference, "name"]],
           ],
         ],
       ],
@@ -1391,12 +1484,53 @@ Body text`,
     assertParse(
       "templateSubstitution",
       "${foo}",
-      [markers.reference, [ops.literal, "foo"]],
+      [markers.traverse, [markers.reference, "foo"]],
       "shell",
       false
     );
   });
 
+  describe("uri", () => {
+    test("with double slashes after colon", () => {
+      assertParse("uri", "foo://bar/baz", [
+        [markers.global, "foo:"],
+        [ops.literal, "bar/"],
+        [ops.literal, "baz"],
+      ]);
+      assertParse("uri", "http://example.com", [
+        [markers.global, "http:"],
+        [ops.literal, "example.com"],
+      ]);
+      assertParse("uri", "https://example.com/about/", [
+        [markers.global, "https:"],
+        [ops.literal, "example.com/"],
+        [ops.literal, "about/"],
+      ]);
+      assertParse("uri", "https://example.com/about/index.html", [
+        [markers.global, "https:"],
+        [ops.literal, "example.com/"],
+        [ops.literal, "about/"],
+        [ops.literal, "index.html"],
+      ]);
+      assertParse("uri", "http://localhost:5000/foo", [
+        [markers.global, "http:"],
+        [ops.literal, "localhost:5000/"],
+        [ops.literal, "foo"],
+      ]);
+    });
+
+    test("without double slashes after colon", () => {
+      assertParse("uri", "files:build", [
+        [markers.global, "files:"],
+        [ops.literal, "build"],
+      ]);
+    });
+  });
+
+  test("uriScheme", () => {
+    assertParse("uriScheme", "https:", [markers.global, "https:"]);
+  });
+
   test("whitespace block", () => {
     assertParse(
       "__",
@@ -1413,12 +1547,19 @@ Body text`,
   test("unaryExpression", () => {
     assertParse("unaryExpression", "!true", [
       ops.logicalNot,
-      [markers.reference, [ops.literal, "true"]],
+      [markers.traverse, [markers.reference, "true"]],
     ]);
     assertParse("unaryExpression", "+1", [ops.unaryPlus, [ops.literal, 1]]);
     assertParse("unaryExpression", "-2", [ops.unaryMinus, [ops.literal, 2]]);
     assertParse("unaryExpression", "~3", [ops.bitwiseNot, [ops.literal, 3]]);
   });
+
+  test("unaryOperator", () => {
+    assertParse("unaryOperator", "!", "!");
+    assertParse("unaryOperator", "+", "+");
+    assertParse("unaryOperator", "-", "-");
+    assertParse("unaryOperator", "~", "~");
+  });
 });
 
 function assertParse(
@@ -1437,7 +1578,7 @@ function assertParse(
   // Verify that the parser returned a `location` property and that it spans the
   // entire source. We skip this check in cases where the source starts or ends
   // with a comment; the parser will strip those.
-  if (checkLocation) {
+  if (typeof code === "object" && checkLocation) {
     assertCodeLocations(code);
     const resultSource = code.location.source.text.slice(
       code.location.start.offset,
@@ -1459,8 +1600,9 @@ function assertCodeLocations(code) {
 }
 
 function assertThrows(startRule, source, message, position, mode = "shell") {
+  let code;
   try {
-    parse(source, {
+    code = parse(source, {
       grammarSource: { text: source },
       mode,
       startRule,