diff --git a/packages/groq/src/index.test.ts b/packages/groq/src/index.test.ts
index 2c4d521b..27229431 100644
--- a/packages/groq/src/index.test.ts
+++ b/packages/groq/src/index.test.ts
@@ -5,60 +5,52 @@ import type { DocumentValue } from "@sanity-typed/types";
 
 import type { ExecuteQuery, Scope } from ".";
 
+type Empty = { [key: string]: never };
+
 describe("groq", () => {
   it("null", () =>
-    expectType<
-      ExecuteQuery<"null", { [key: string]: never }>
-    >().toStrictEqual<null>());
+    expectType<ExecuteQuery<"null", Empty>>().toStrictEqual<null>());
 
   it("true", () =>
-    expectType<
-      ExecuteQuery<"true", { [key: string]: never }>
-    >().toStrictEqual<true>());
+    expectType<ExecuteQuery<"true", Empty>>().toStrictEqual<true>());
 
   it("false", () =>
-    expectType<
-      ExecuteQuery<"false", { [key: string]: never }>
-    >().toStrictEqual<false>());
+    expectType<ExecuteQuery<"false", Empty>>().toStrictEqual<false>());
 
   it("-5.6", () =>
-    expectType<
-      ExecuteQuery<"-5.6", { [key: string]: never }>
-    >().toStrictEqual<-5.6>());
+    expectType<ExecuteQuery<"-5.6", Empty>>().toStrictEqual<-5.6>());
 
   it('"double quoted string"', () =>
     expectType<
-      ExecuteQuery<'"double quoted string"', { [key: string]: never }>
+      ExecuteQuery<'"double quoted string"', Empty>
     >().toStrictEqual<"double quoted string">());
 
   it("'single quoted string'", () =>
     expectType<
-      ExecuteQuery<"'single quoted string'", { [key: string]: never }>
+      ExecuteQuery<"'single quoted string'", Empty>
     >().toStrictEqual<"single quoted string">());
 
-  it("[]", () =>
-    expectType<ExecuteQuery<"[]", { [key: string]: never }>>().toStrictEqual<
-      []
-    >());
+  it("[]", () => expectType<ExecuteQuery<"[]", Empty>>().toStrictEqual<[]>());
 
   it("[null,true,false,-5.6,\"double quoted string\",'single quoted string']", () =>
     expectType<
       ExecuteQuery<
         "[null,true,false,-5.6,\"double quoted string\",'single quoted string']",
-        { [key: string]: never }
+        Empty
       >
     >().toStrictEqual<
       [null, true, false, -5.6, "double quoted string", "single quoted string"]
     >());
 
+  it("[1,notvalid]", () =>
+    expectType<never>().toStrictEqual<ExecuteQuery<"[1,notvalid]", Empty>>());
+
   it("[...[null]]", () =>
-    expectType<
-      ExecuteQuery<"[...[null]]", { [key: string]: never }>
-    >().toStrictEqual<[null]>());
+    expectType<ExecuteQuery<"[...[null]]", Empty>>().toStrictEqual<[null]>());
 
   it("[[null,null],[null,null,null]]", () =>
     expectType<
-      ExecuteQuery<"[[null,null],[null,null,null]]", { [key: string]: never }>
+      ExecuteQuery<"[[null,null],[null,null,null]]", Empty>
     >().toStrictEqual<[[null, null], [null, null, null]]>());
 
   it("@", () => {
@@ -136,10 +128,24 @@ describe("groq", () => {
     >().toStrictEqual<typeof UNIQUE_VALUE>();
   });
 
-  it("(*)", () =>
+  it("(10)", () =>
+    expectType<ExecuteQuery<"(10)", Empty>>().toStrictEqual<10>());
+
+  it("(((10)))", () =>
+    expectType<ExecuteQuery<"(((10)))", Empty>>().toStrictEqual<10>());
+
+  it("false[@]", () =>
+    expectType<ExecuteQuery<"false[@]", Empty>>().toStrictEqual<false>());
+
+  it("[true,false][@]", () =>
+    expectType<ExecuteQuery<"[true,false][@]", Empty>>().toStrictEqual<
+      [true]
+    >());
+
+  it("*[true]", () =>
     expectType<
       ExecuteQuery<
-        "(*)",
+        "*[true]",
         {
           bar: DocumentValue<"bar", never>;
           foo: DocumentValue<"foo", never>;
@@ -150,53 +156,67 @@ describe("groq", () => {
       (DocumentValue<"bar", never> | DocumentValue<"foo", never>)[]
     >());
 
-  it("count(5)", () =>
+  it('*[_type=="foo"]', () =>
     expectType<
-      ExecuteQuery<"count(5)", { [key: string]: never }>
-    >().toStrictEqual<null>());
+      ExecuteQuery<
+        '*[_type=="foo"]',
+        {
+          bar: DocumentValue<"bar", never>;
+          foo: DocumentValue<"foo", never>;
+          qux: { _type: "qux" };
+        }
+      >
+    >().toStrictEqual<DocumentValue<"foo", never>[]>());
+
+  it("4==5", () =>
+    expectType<ExecuteQuery<"4==5", Empty>>().toStrictEqual<false>());
+
+  it("4!=5", () =>
+    expectType<ExecuteQuery<"4!=5", Empty>>().toStrictEqual<true>());
+
+  it("5==5", () =>
+    expectType<ExecuteQuery<"5==5", Empty>>().toStrictEqual<true>());
+
+  it("5!=5", () =>
+    expectType<ExecuteQuery<"5!=5", Empty>>().toStrictEqual<false>());
+
+  it("count(5)", () =>
+    expectType<ExecuteQuery<"count(5)", Empty>>().toStrictEqual<null>());
 
   it("count([1,2,3,4])", () =>
-    expectType<
-      ExecuteQuery<"count([1,2,3,4])", { [key: string]: never }>
-    >().toStrictEqual<4>());
+    expectType<ExecuteQuery<"count([1,2,3,4])", Empty>>().toStrictEqual<4>());
 
   it("global::count([1,2,3,4])", () =>
     expectType<
-      ExecuteQuery<"global::count([1,2,3,4])", { [key: string]: never }>
+      ExecuteQuery<"global::count([1,2,3,4])", Empty>
     >().toStrictEqual<4>());
 
   it("defined(null)", () =>
-    expectType<
-      ExecuteQuery<"defined(null)", { [key: string]: never }>
-    >().toStrictEqual<false>());
+    expectType<ExecuteQuery<"defined(null)", Empty>>().toStrictEqual<false>());
 
   it("defined(5)", () =>
-    expectType<
-      ExecuteQuery<"defined(5)", { [key: string]: never }>
-    >().toStrictEqual<true>());
+    expectType<ExecuteQuery<"defined(5)", Empty>>().toStrictEqual<true>());
 
   it("global::defined(5)", () =>
     expectType<
-      ExecuteQuery<"global::defined(5)", { [key: string]: never }>
+      ExecuteQuery<"global::defined(5)", Empty>
     >().toStrictEqual<true>());
 
   it("length(10)", () =>
-    expectType<
-      ExecuteQuery<"length(10)", { [key: string]: never }>
-    >().toStrictEqual<null>());
+    expectType<ExecuteQuery<"length(10)", Empty>>().toStrictEqual<null>());
 
   it("length([null,null,null])", () =>
     expectType<
-      ExecuteQuery<"length([null,null,null])", { [key: string]: never }>
+      ExecuteQuery<"length([null,null,null])", Empty>
     >().toStrictEqual<3>());
 
   it('length("string")', () =>
     expectType<
-      ExecuteQuery<'length("string")', { [key: string]: never }>
+      ExecuteQuery<'length("string")', Empty>
     >().toStrictEqual<number>());
 
   it('global::length("string")', () =>
     expectType<
-      ExecuteQuery<'global::length("string")', { [key: string]: never }>
+      ExecuteQuery<'global::length("string")', Empty>
     >().toStrictEqual<number>());
 });
diff --git a/packages/groq/src/index.ts b/packages/groq/src/index.ts
index 8f01d882..e1495066 100644
--- a/packages/groq/src/index.ts
+++ b/packages/groq/src/index.ts
@@ -23,6 +23,39 @@ export type Scope<
   this: Value;
 };
 
+type NestedScope<
+  Value,
+  TScope extends Scope<any, any, any>
+> = TScope extends Scope<infer TContext, any, any>
+  ? Scope<TContext, Value, TScope>
+  : never;
+
+/**
+ * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#Evaluate()
+ */
+type Evaluate<TExpression extends string, TScope extends Scope<any, any, any>> =
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Evaluate should be at the bottom but, because of recursion, it's cleanest to put it here
+  Expression<TExpression, TScope>;
+
+/**
+ * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#Boolean
+ * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#Null
+ * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#Number
+ */
+type Primitives<TExpression extends string> =
+  TExpression extends `${infer TBoolean extends boolean | number | null}`
+    ? TBoolean
+    : never;
+
+/**
+ * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#String
+ */
+type StringType<TExpression extends string> = TExpression extends  // FIXME Should check for specific characters
+  | `'${infer TString extends string}'`
+  | `"${infer TString extends string}"`
+  ? TString
+  : never;
+
 /**
  * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#ArrayElement
  */
@@ -30,18 +63,10 @@ type ArrayElement<
   TExpression extends string,
   TScope extends Scope<any, any, any>
 > = TExpression extends `...${infer TArrayElement}`
-  ? // eslint-disable-next-line @typescript-eslint/no-use-before-define -- recursion
-    Evaluate<TArrayElement, TScope> extends any[]
-    ? // eslint-disable-next-line @typescript-eslint/no-use-before-define -- recursion
-      Evaluate<TArrayElement, TScope>
-    : [
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define -- recursion
-        Evaluate<TArrayElement, TScope>
-      ]
-  : [
-      // eslint-disable-next-line @typescript-eslint/no-use-before-define -- recursion
-      Evaluate<TExpression, TScope>
-    ];
+  ? Evaluate<TArrayElement, TScope> extends any[]
+    ? Evaluate<TArrayElement, TScope>
+    : [Evaluate<TArrayElement, TScope>]
+  : [Evaluate<TExpression, TScope>];
 
 /**
  * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#ArrayElements
@@ -53,10 +78,14 @@ type ArrayElements<
 > = TExpression extends `${infer TArrayElement},${infer TArrayElements}`
   ? ArrayElement<`${TPrefix}${TArrayElement}`, TScope> extends [never]
     ? ArrayElements<TArrayElements, TScope, `${TPrefix}${TArrayElement},`>
+    : ArrayElements<TArrayElements, TScope> extends never
+    ? never
     : [
         ...ArrayElement<`${TPrefix}${TArrayElement}`, TScope>,
         ...ArrayElements<TArrayElements, TScope>
       ]
+  : ArrayElement<`${TPrefix}${TExpression}`, TScope> extends [never]
+  ? never
   : ArrayElement<`${TPrefix}${TExpression}`, TScope>;
 
 /**
@@ -71,25 +100,6 @@ type ArrayType<
     : ArrayElements<TArrayElements, TScope>
   : never;
 
-/**
- * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#String
- */
-type StringType<TExpression extends string> = TExpression extends  // FIXME Should check for specific characters
-  | `'${infer TString extends string}'`
-  | `"${infer TString extends string}"`
-  ? TString
-  : never;
-
-/**
- * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#Boolean
- * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#Null
- * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#Number
- */
-type Primitives<TExpression extends string> =
-  TExpression extends `${infer TBoolean extends boolean | number | null}`
-    ? TBoolean
-    : never;
-
 /**
  * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#Literal
  *
@@ -100,43 +110,82 @@ type Literal<TExpression extends string, TScope extends Scope<any, any, any>> =
   | Primitives<TExpression>
   | StringType<TExpression>;
 
+type Negate<TBoolean extends boolean> = TBoolean extends true ? false : true;
+
 /**
- * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#sec-global-count-
+ * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#Equality
+ *
+ * @todo Test Equality cases in https://sanity-io.github.io/GROQ/GROQ-1.revision1/#PartialCompare()
  */
-type Count<TArgs extends string, TScope extends Scope<any, any, any>> =
-  // eslint-disable-next-line @typescript-eslint/no-use-before-define -- recursion
-  Evaluate<TArgs, TScope> extends never
+type Equality<
+  TExpression extends string,
+  TScope extends Scope<any, any, any>
+> = TExpression extends `${infer TLeft}!=${infer TRight}`
+  ? Negate<Equality<`${TLeft}==${TRight}`, TScope>>
+  : TExpression extends `${infer TLeft}==${infer TRight}`
+  ? Evaluate<TLeft, TScope> extends never
     ? never
-    : // eslint-disable-next-line @typescript-eslint/no-use-before-define -- recursion
-    Evaluate<TArgs, TScope> extends any[]
-    ? // eslint-disable-next-line @typescript-eslint/no-use-before-define -- recursion
-      Evaluate<TArgs, TScope>["length"]
-    : null;
+    : Evaluate<TRight, TScope> extends never
+    ? never
+    : Evaluate<TLeft, TScope> extends Evaluate<TRight, TScope>
+    ? true
+    : Evaluate<TRight, TScope> extends Evaluate<TLeft, TScope>
+    ? true
+    : false
+  : never;
+
+/**
+ * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#OperatorCall
+ *
+ * @todo And
+ * @todo Asc
+ * @todo Comparison
+ * @todo Desc
+ * @todo In
+ * @todo Match
+ * @todo Minus
+ * @todo Not
+ * @todo Or
+ * @todo Percent
+ * @todo Plus
+ * @todo Slash
+ * @todo Star
+ * @todo StarStar
+ * @todo UnaryMinus
+ * @todo UnaryPlus
+ */
+type OperatorCall<
+  TExpression extends string,
+  TScope extends Scope<any, any, any>
+> = Equality<TExpression, TScope>;
+
+/**
+ * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#sec-global-count-
+ */
+type Count<
+  TArgs extends string,
+  TScope extends Scope<any, any, any>
+> = Evaluate<TArgs, TScope> extends any[]
+  ? Evaluate<TArgs, TScope>["length"]
+  : null;
 
 /**
  * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#sec-global-defined-
  */
-type Defined<TArgs extends string, TScope extends Scope<any, any, any>> =
-  // eslint-disable-next-line @typescript-eslint/no-use-before-define -- recursion
-  Evaluate<TArgs, TScope> extends never
-    ? never
-    : // eslint-disable-next-line @typescript-eslint/no-use-before-define -- recursion
-    Evaluate<TArgs, TScope> extends null
-    ? false
-    : true;
+type Defined<
+  TArgs extends string,
+  TScope extends Scope<any, any, any>
+> = Evaluate<TArgs, TScope> extends null ? false : true;
 
 /**
  * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#sec-global-length-
  */
-type Length<TArgs extends string, TScope extends Scope<any, any, any>> =
-  // eslint-disable-next-line @typescript-eslint/no-use-before-define -- recursion
-  Evaluate<TArgs, TScope> extends never
-    ? never
-    : // eslint-disable-next-line @typescript-eslint/no-use-before-define -- recursion
-    Evaluate<TArgs, TScope> extends any[] | string
-    ? // eslint-disable-next-line @typescript-eslint/no-use-before-define -- recursion
-      Evaluate<TArgs, TScope>["length"]
-    : null;
+type Length<
+  TArgs extends string,
+  TScope extends Scope<any, any, any>
+> = Evaluate<TArgs, TScope> extends any[] | string
+  ? Evaluate<TArgs, TScope>["length"]
+  : null;
 
 /**
  * @todo array
@@ -259,6 +308,81 @@ type SimpleExpression<
   | This<TExpression, TScope>
   | ThisAttribute<TExpression, TScope>;
 
+/**
+ * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#Filter
+ */
+type Filter<
+  TBase extends any[],
+  TExpression extends string,
+  TScope extends Scope<any, any, any>
+> = TBase extends []
+  ? []
+  : TBase extends [infer TFirst, ...infer TRest]
+  ? Evaluate<TExpression, NestedScope<TFirst, TScope>> extends true
+    ? [TFirst, ...Filter<TRest, TExpression, TScope>]
+    : Filter<TRest, TExpression, TScope>
+  : TBase extends (infer ArrayElement)[]
+  ? (ArrayElement extends never
+      ? never
+      : Evaluate<TExpression, NestedScope<ArrayElement, TScope>> extends true
+      ? ArrayElement
+      : never)[]
+  : [];
+
+type BasicTraversalFilter<
+  TExpression extends string,
+  TScope extends Scope<any, any, any>,
+  TPrefix extends string = ""
+> = TExpression extends `${infer TBase}[${infer TFilterExpression}]`
+  ? Evaluate<`${TPrefix}${TBase}`, TScope> extends never
+    ? BasicTraversalFilter<
+        `${TFilterExpression}]`,
+        TScope,
+        `${TPrefix}${TBase}[`
+      >
+    : Evaluate<`${TPrefix}${TBase}`, TScope> extends any[]
+    ? Filter<Evaluate<`${TPrefix}${TBase}`, TScope>, TFilterExpression, TScope>
+    : Evaluate<`${TPrefix}${TBase}`, TScope>
+  : never;
+
+/**
+ * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#BasicTraversalArray
+ *
+ * @todo Slice
+ * @todo ArrayPostfix
+ */
+type BasicTraversalArray<
+  TExpression extends string,
+  TScope extends Scope<any, any, any>
+> = BasicTraversalFilter<TExpression, TScope>;
+
+/**
+ * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#TraversalArray
+ *
+ * @todo BasicTraversalArray TraversalArray
+ * @todo ElementAccess TraversalArray
+ * @todo ElementAccess TraversalArrayTarget
+ * @todo BasicTraversalArray TraversalPlain
+ * @todo BasicTraversalArray TraversalArrayTarget
+ * @todo Projection TraversalArray
+ */
+type TraversalArray<
+  TExpression extends string,
+  TScope extends Scope<any, any, any>
+> = BasicTraversalArray<TExpression, TScope>;
+
+/**
+ * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#TraversalExpression
+ *
+ * @todo TraversalPlain
+ * @todo TraversalArraySource
+ * @todo TraversalArrayTarget
+ */
+type TraversalExpression<
+  TExpression extends string,
+  TScope extends Scope<any, any, any>
+> = TraversalArray<TExpression, TScope>;
+
 /**
  * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#Parenthesis
  */
@@ -266,25 +390,21 @@ type Parenthesis<
   TExpression extends string,
   TScope extends Scope<any, any, any>
 > = TExpression extends `(${infer TInnerExpression})`
-  ? // eslint-disable-next-line @typescript-eslint/no-use-before-define -- recursion
-    Evaluate<TInnerExpression, TScope>
+  ? Evaluate<TInnerExpression, TScope>
   : never;
 
 /**
  * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#CompoundExpression
  *
  * @todo PipeFuncCall
- * @todo TraversalExpression
  */
 type CompoundExpression<
   TExpression extends string,
   TScope extends Scope<any, any, any>
-> = Parenthesis<TExpression, TScope>;
+> = Parenthesis<TExpression, TScope> | TraversalExpression<TExpression, TScope>;
 
 /**
  * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#Expression
- *
- * @todo OperatorCall
  */
 type Expression<
   TExpression extends string,
@@ -292,16 +412,9 @@ type Expression<
 > =
   | CompoundExpression<TExpression, TScope>
   | Literal<TExpression, TScope>
+  | OperatorCall<TExpression, TScope>
   | SimpleExpression<TExpression, TScope>;
 
-/**
- * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#Evaluate()
- */
-type Evaluate<
-  TExpression extends string,
-  TScope extends Scope<any, any, any>
-> = Expression<TExpression, TScope>;
-
 /**
  * @link https://sanity-io.github.io/GROQ/GROQ-1.revision1/#ExecuteQuery()
  */