Release 6.0.0-rc.1

This change also includes some minor packaging changes in order to make Cargo happy.

.github/workflows/ci.yml

@@ -1,6 +1,9 @@
 name: CI
 
-on: [push]
+on:
+  pull_request:
+  push:
+    branches: ["*"]
 
 jobs:
   build:
@@ -13,6 +16,8 @@ jobs:
 
     steps:
     - uses: actions/checkout@v1
+      with:
+        submodules: true
 
     - name: Setup Rust toolchain
       run: rustup default ${{ matrix.rust_version }}

.gitmodules

@@ -9,7 +9,4 @@
 	url = https://github.com/LPGhatguy/roblox-lua-promise.git
 [submodule "plugin/modules/t"]
 	path = plugin/modules/t
-	url = https://github.com/osyrisrblx/t.git
-[submodule "plugin/modules/rbx-dom"]
-	path = plugin/modules/rbx-dom
-	url = http://github.com/rojo-rbx/rbx-dom
+	url = https://github.com/osyrisrblx/t.git

CHANGELOG.md

@@ -1,8 +1,32 @@
 # Rojo Changelog
 
-## Unreleased Changes for 0.6.x
+## Unreleased Changes
+
+## [6.0.0 Release Candidate 1](https://github.com/rojo-rbx/rojo/releases/tag/v6.0.0-rc.1) (March 29, 2020)
+This release jumped from 0.6.0 to 6.0.0. Rojo has been in use in production for many users for quite a long times, and so 6.0 is a more accurate reflection of Rojo's version than a pre-1.0 version.
+
+* Added basic settings panel to plugin, with two settings:
+    * "Open Scripts Externally": When enabled, opening a script in Studio will instead open it in your default text editor.
+    * "Two-Way Sync": When enabled, Rojo will attempt to save changes to your place back to the filesystem. **Very early feature, very broken, beware!**
+* Added `--color` option to force-enable or force-disable color in Rojo's output.
+* Added support for turning `.json` files into `ModuleScript` instances ([#308](https://github.com/rojo-rbx/rojo/pull/308))
+* Added `rojo plugin install` and `rojo plugin uninstall` to allow Rojo to manage its Roblox Studio plugin. ([#304](https://github.com/rojo-rbx/rojo/pull/304))
+* Class names no longer need to be specified for Roblox services in Rojo projects. ([#210](https://github.com/rojo-rbx/rojo/pull/210))
+* The server half of **experimental** two-way sync is now enabled by default.
+* Increased default logging verbosity in commands like `rojo build`.
+* Rojo now requires a project file again, just like 0.5.4.
+
+## [0.6.0 Alpha 3](https://github.com/rojo-rbx/rojo/releases/tag/v0.6.0-alpha.3) (March 13, 2020)
 * Added `--watch` argument to `rojo build`. ([#284](https://github.com/rojo-rbx/rojo/pull/284))
 * Added dark theme support to plugin. ([#241](https://github.com/rojo-rbx/rojo/issues/241))
+* Added a revamped `rojo init` command, which will now create more complete projects.
+* Added the `rojo doc` command, which opens Rojo's documentation in your browser.
+* Fixed many crashes from malformed projects and filesystem edge cases in `rojo serve`.
+* Simplified filesystem access code dramatically.
+* Improved error reporting and logging across the board.
+    * Log messages have a less noisy prefix.
+    * Any thread panicking now causes Rojo to abort instead of existing as a zombie.
+    * Errors now have a list of causes, helping make many errors more clear.
 
 ## [0.6.0 Alpha 2](https://github.com/rojo-rbx/rojo/releases/tag/v0.6.0-alpha.2) (March 6, 2020)
 * Fixed `rojo upload` command always uploading models.

CONTRIBUTING.md

@@ -33,15 +33,13 @@ Please file issues and we'll try to help figure out what the best way forward is
 ## Pushing a Rojo Release
 The Rojo release process is pretty manual right now. If you need to do it, here's how:
 
-1. Bump server version in [`server/Cargo.toml`](server/Cargo.toml)
+1. Bump server version in [`Cargo.toml`](Cargo.toml)
 2. Bump plugin version in [`plugin/src/Config.lua`](plugin/src/Config.lua)
 3. Run `cargo test` to update `Cargo.lock` and double-check tests
 4. Update [`CHANGELOG.md`](CHANGELOG.md)
 5. Commit!
     * `git add . && git commit -m "Release vX.Y.Z"`
 6. Tag the commit with the version from `Cargo.toml` prepended with a v, like `v0.4.13`
-7. Build Windows release build of CLI
-    * `cargo build --release`
 7. Publish the CLI
     * `cargo publish`
 8. Build and upload the plugin
@@ -52,4 +50,5 @@ The Rojo release process is pretty manual right now. If you need to do it, here'
 10. Copy GitHub release content from previous release
     * Update the leading text with a summary about the release
     * Paste the changelog notes (as-is!) from [`CHANGELOG.md`](CHANGELOG.md)
-    * Write a small summary of each major feature
+    * Write a small summary of each major feature
+    * Attach release artifacts from GitHub Actions for each platform

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rojo"
-version = "0.6.0-alpha.2"
+version = "6.0.0-rc.1"
 authors = ["Lucien Greathouse <me@lpghatguy.com>"]
 description = "Enables professional-grade development tools for Roblox developers"
 license = "MPL-2.0"
@@ -11,19 +11,21 @@ readme = "README.md"
 edition = "2018"
 
 exclude = [
-    "/plugin/**",
     "/test-projects/**",
 ]
 
+[profile.dev]
+panic = "abort"
+
+[profile.release]
+panic = "abort"
+
 [features]
 default = []
 
 # Turn on support for specifying glob ignore path rules in the project format.
 unstable_glob_ignore_paths = []
 
-# Turn on the server half of Rojo's unstable two-way sync feature.
-unstable_two_way_sync = []
-
 # Enable this feature to live-reload assets from the web UI.
 dev_live_assets = []
 
@@ -55,9 +57,15 @@ name = "build"
 harness = false
 
 [dependencies]
+memofs = { version = "0.1.2", path = "memofs" }
+
+anyhow = "1.0.27"
+backtrace = "0.3"
+bincode = "1.2.1"
 crossbeam-channel = "0.4.0"
 csv = "1.1.1"
 env_logger = "0.7.1"
+fs-err = "2.2.0"
 futures = "0.1.29"
 globset = "0.4.4"
 humantime = "1.3.0"
@@ -67,6 +75,7 @@ lazy_static = "1.4.0"
 log = "0.4.8"
 maplit = "1.0.1"
 notify = "4.0.14"
+opener = "0.4.1"
 rbx_binary = "0.5.0"
 rbx_dom_weak = "1.10.1"
 rbx_reflection = "3.3.408"
@@ -75,18 +84,26 @@ regex = "1.3.1"
 reqwest = "0.9.20"
 ritz = "0.1.0"
 rlua = "0.17.0"
+roblox_install = "0.2.2"
 serde = { version = "1.0", features = ["derive", "rc"] }
 serde_json = "1.0"
-snafu = "0.6.0"
 structopt = "0.3.5"
 termcolor = "1.0.5"
+thiserror = "1.0.11"
 tokio = "0.1.22"
 uuid = { version = "0.8.1", features = ["v4", "serde"] }
-memofs = { path = "memofs" }
 
 [target.'cfg(windows)'.dependencies]
 winreg = "0.6.2"
 
+[build-dependencies]
+memofs = { version = "0.1.0", path = "memofs" }
+
+anyhow = "1.0.27"
+bincode = "1.2.1"
+fs-err = "2.3.0"
+maplit = "1.0.1"
+
 [dev-dependencies]
 rojo-insta-ext = { path = "rojo-insta-ext" }
 

README.md

@@ -13,8 +13,8 @@
     <a href="https://crates.io/crates/rojo">
         <img src="https://img.shields.io/crates/v/rojo.svg?label=latest%20release" alt="Latest server version" />
     </a>
-    <a href="https://rojo.space/docs/0.5.x">
-        <img src="https://img.shields.io/badge/docs-0.5.x-brightgreen.svg" alt="Rojo 0.5.x Documentation" />
+    <a href="https://rojo.space/docs">
+        <img src="https://img.shields.io/badge/docs-website-brightgreen.svg" alt="Rojo Documentation" />
     </a>
 </div>
 
@@ -34,11 +34,10 @@ Rojo enables:
 * Streaming `rbxmx` and `rbxm` models into your game in real time
 * Packaging and deploying your project to Roblox.com from the command line
 
-Soon, Rojo will be able to:
+In the future, Rojo will be able to:
 
-* Automatically convert your existing game to work with Rojo
 * Sync instances from Roblox Studio to the filesystem
-* Automatically manage your assets on Roblox.com, like images and sounds
+* Automatically convert your existing game to work with Rojo
 * Import custom instances like MoonScript code
 
 ## [Documentation](https://rojo.space/docs)

assets/default-model-project/README.md

@@ -0,0 +1,11 @@
+# {project_name}
+Generated by [Rojo](https://github.com/rojo-rbx/rojo) {rojo_version}.
+
+## Getting Started
+To build this library or plugin, use:
+
+```bash
+rojo build -o "{project_name}.rbxmx"
+```
+
+For more help, check out [the Rojo documentation](https://rojo.space/docs).

assets/default-model-project/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "{project_name}",
+  "tree": {
+    "$path": "src"
+  }
+}

assets/default-model-project/gitignore.txt

@@ -0,0 +1,3 @@
+# Roblox Studio lock files
+/*.rbxlx.lock
+/*.rbxl.lock

assets/default-model-project/src-init.lua

@@ -0,0 +1,5 @@
+return {
+	hello = function()
+		print("Hello world, from {project_name}!")
+	end,
+}

assets/default-place-project/README.md

@@ -0,0 +1,17 @@
+# {project_name}
+Generated by [Rojo](https://github.com/rojo-rbx/rojo) {rojo_version}.
+
+## Getting Started
+To build the place from scratch, use:
+
+```bash
+rojo build -o "{project_name}.rbxlx"
+```
+
+Next, open `{project_name}.rbxlx` in Roblox Studio and start the Rojo server:
+
+```bash
+rojo serve
+```
+
+For more help, check out [the Rojo documentation](https://rojo.space/docs).

assets/default-place-project/default.project.json

@@ -1,39 +1,36 @@
 {
-  "name": "[placeholder]",
+  "name": "{project_name}",
   "tree": {
     "$className": "DataModel",
-    "HttpService": {
-      "$className": "HttpService",
-      "$properties": {
-        "HttpEnabled": true
-      }
-    },
-    "Lighting": {
-      "$className": "Lighting",
-      "$properties": {
-        "Ambient": [
-          0,
-          0,
-          0
-        ],
-        "Brightness": 2,
-        "GlobalShadows": true,
-        "Outlines": false,
-        "Technology": "Voxel"
-      }
-    },
+
     "ReplicatedStorage": {
       "$className": "ReplicatedStorage",
-      "Source": {
-        "$path": "src"
+
+      "Common": {
+        "$path": "src/shared"
       }
     },
-    "SoundService": {
-      "$className": "SoundService",
-      "$properties": {
-        "RespectFilteringEnabled": true
+
+    "ServerScriptService": {
+      "$className": "ServerScriptService",
+
+      "Server": {
+        "$path": "src/server"
       }
     },
+
+    "StarterPlayer": {
+      "$className": "StarterPlayer",
+
+      "StarterPlayerScripts": {
+        "$className": "StarterPlayerScripts",
+
+        "Client": {
+          "$path": "src/client"
+        }
+      }
+    },
+
     "Workspace": {
       "$className": "Workspace",
       "$properties": {
@@ -61,6 +58,32 @@
           ]
         }
       }
+    },
+    "Lighting": {
+      "$className": "Lighting",
+      "$properties": {
+        "Ambient": [
+          0,
+          0,
+          0
+        ],
+        "Brightness": 2,
+        "GlobalShadows": true,
+        "Outlines": false,
+        "Technology": "Voxel"
+      }
+    },
+    "SoundService": {
+      "$className": "SoundService",
+      "$properties": {
+        "RespectFilteringEnabled": true
+      }
+    },
+    "HttpService": {
+      "$className": "HttpService",
+      "$properties": {
+        "HttpEnabled": true
+      }
     }
   }
 }

assets/default-place-project/gitignore.txt

@@ -0,0 +1,6 @@
+# Project place file
+/{project_name}.rbxlx
+
+# Roblox Studio lock files
+/*.rbxlx.lock
+/*.rbxl.lock

build.rs

@@ -0,0 +1,74 @@
+use std::{
+    env, io,
+    path::{Path, PathBuf},
+};
+
+use fs_err as fs;
+use fs_err::File;
+use maplit::hashmap;
+use memofs::VfsSnapshot;
+
+fn snapshot_from_fs_path(path: &Path) -> io::Result<VfsSnapshot> {
+    println!("cargo:rerun-if-changed={}", path.display());
+
+    if path.is_dir() {
+        let mut children = Vec::new();
+
+        for entry in fs::read_dir(path)? {
+            let entry = entry?;
+
+            let file_name = entry.file_name().to_str().unwrap().to_owned();
+
+            // We can skip any TestEZ test files since they aren't necessary for
+            // the plugin to run.
+            if file_name.ends_with(".spec.lua") {
+                continue;
+            }
+
+            let child_snapshot = snapshot_from_fs_path(&entry.path())?;
+            children.push((file_name, child_snapshot));
+        }
+
+        Ok(VfsSnapshot::dir(children))
+    } else {
+        let content = fs::read_to_string(path)?;
+
+        Ok(VfsSnapshot::file(content))
+    }
+}
+
+fn main() -> Result<(), anyhow::Error> {
+    let out_dir = env::var_os("OUT_DIR").unwrap();
+
+    let root_dir = env::var_os("CARGO_MANIFEST_DIR").unwrap();
+    let plugin_root = PathBuf::from(root_dir).join("plugin");
+
+    let plugin_modules = plugin_root.join("modules");
+
+    let snapshot = VfsSnapshot::dir(hashmap! {
+        "default.project.json" => snapshot_from_fs_path(&plugin_root.join("default.project.json"))?,
+        "fmt" => snapshot_from_fs_path(&plugin_root.join("fmt"))?,
+        "http" => snapshot_from_fs_path(&plugin_root.join("http"))?,
+        "log" => snapshot_from_fs_path(&plugin_root.join("log"))?,
+        "rbx_dom_lua" => snapshot_from_fs_path(&plugin_root.join("rbx_dom_lua"))?,
+        "src" => snapshot_from_fs_path(&plugin_root.join("src"))?,
+        "modules" => VfsSnapshot::dir(hashmap! {
+            "roact" => VfsSnapshot::dir(hashmap! {
+                "src" => snapshot_from_fs_path(&plugin_modules.join("roact").join("src"))?
+            }),
+            "promise" => VfsSnapshot::dir(hashmap! {
+                "lib" => snapshot_from_fs_path(&plugin_modules.join("promise").join("lib"))?
+            }),
+            "t" => VfsSnapshot::dir(hashmap! {
+                "lib" => snapshot_from_fs_path(&plugin_modules.join("t").join("lib"))?
+            }),
+        }),
+    });
+
+    let out_path = Path::new(&out_dir).join("plugin.bincode");
+    let out_file = File::create(&out_path)?;
+
+    bincode::serialize_into(out_file, &snapshot)?;
+
+    Ok(())
+}

design.gv

@@ -1,30 +0,0 @@
-digraph Rojo {
-	concentrate = true;
-	node [fontname = "sans-serif"];
-
-	plugin [label="Roblox Studio Plugin"]
-	session [label="Session"]
-	rbx_tree [label="Instance Tree"]
-	imfs [label="In-Memory Filesystem"]
-	fs_impl [label="Filesystem Implementation\n(stubbed in tests)"]
-	fs [label="Real Filesystem"]
-	snapshot_subsystem [label="Snapshot Subsystem\n(reconciler)"]
-	snapshot_generator [label="Snapshot Generator"]
-	user_middleware [label="User Middleware\n(MoonScript, etc.)"]
-	builtin_middleware [label="Built-in Middleware\n(.lua, .rbxm, etc.)"]
-	api [label="Web API"]
-	file_watcher [label="File Watcher"]
-
-	session -> imfs
-	session -> rbx_tree
-	session -> snapshot_subsystem
-	session -> snapshot_generator
-	session -> file_watcher [dir="both"]
-	file_watcher -> imfs
-	snapshot_generator -> user_middleware
-	snapshot_generator -> builtin_middleware
-	plugin -> api [style="dotted"; dir="both"; minlen=2]
-	api -> session
-	imfs -> fs_impl
-	fs_impl -> fs
-}

memofs/CHANGELOG.md

@@ -0,0 +1,9 @@
+# memofs Changelog
+
+## Unreleased Changes
+
+## 0.1.1 (2020-03-18)
+* Improved error messages using the [fs-err](https://crates.io/crates/fs-err) crate.
+
+## 0.1.0 (2020-03-10)
+* Initial release

memofs/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "memofs"
 description = "Virtual filesystem with configurable backends."
-version = "0.1.0"
+version = "0.1.2"
 authors = ["Lucien Greathouse <me@lpghatguy.com>"]
 edition = "2018"
 readme = "README.md"
@@ -11,5 +11,7 @@ homepage = "https://github.com/rojo-rbx/rojo/tree/master/memofs"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-notify = "4.0.15"
 crossbeam-channel = "0.4.0"
+fs-err = "2.3.0"
+notify = "4.0.15"
+serde = { version = "1.0", features = ["derive"] }

memofs/src/snapshot.rs

@@ -1,8 +1,9 @@
+use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
 /// A slice of a tree of files. Can be loaded into an
 /// [`InMemoryFs`](struct.InMemoryFs.html).
-#[derive(Debug)]
+#[derive(Debug, Serialize, Deserialize)]
 #[non_exhaustive]
 pub enum VfsSnapshot {
     File {

memofs/src/std_backend.rs

@@ -1,4 +1,3 @@
-use std::fs;
 use std::io;
 use std::path::Path;
 use std::sync::mpsc;
@@ -55,15 +54,15 @@ impl StdBackend {
 
 impl VfsBackend for StdBackend {
     fn read(&mut self, path: &Path) -> io::Result<Vec<u8>> {
-        fs::read(path)
+        fs_err::read(path)
     }
 
     fn write(&mut self, path: &Path, data: &[u8]) -> io::Result<()> {
-        fs::write(path, data)
+        fs_err::write(path, data)
     }
 
     fn read_dir(&mut self, path: &Path) -> io::Result<ReadDir> {
-        let entries: Result<Vec<_>, _> = fs::read_dir(path)?.collect();
+        let entries: Result<Vec<_>, _> = fs_err::read_dir(path)?.collect();
         let mut entries = entries?;
 
         entries.sort_by_cached_key(|entry| entry.file_name());
@@ -78,15 +77,15 @@ impl VfsBackend for StdBackend {
     }
 
     fn remove_file(&mut self, path: &Path) -> io::Result<()> {
-        fs::remove_file(path)
+        fs_err::remove_file(path)
     }
 
     fn remove_dir_all(&mut self, path: &Path) -> io::Result<()> {
-        fs::remove_dir_all(path)
+        fs_err::remove_dir_all(path)
     }
 
     fn metadata(&mut self, path: &Path) -> io::Result<Metadata> {
-        let inner = fs::metadata(path)?;
+        let inner = fs_err::metadata(path)?;
 
         Ok(Metadata {
             is_file: inner.is_file(),

plugin/default.project.json

@@ -14,6 +14,9 @@
     "Fmt": {
       "$path": "fmt"
     },
+    "RbxDom": {
+      "$path": "rbx_dom_lua"
+    },
     "Roact": {
       "$path": "modules/roact/src"
     },
@@ -22,9 +25,6 @@
     },
     "t": {
       "$path": "modules/t/lib"
-    },
-    "RbxDom": {
-      "$path": "modules/rbx-dom/rbx_dom_lua/src"
     }
   }
 }

plugin/rbx_dom_lua/.luacheckrc

@@ -0,0 +1,44 @@
+stds.roblox = {
+	read_globals = {
+		game = {
+			other_fields = true,
+		},
+
+		-- Roblox globals
+		"script",
+
+		-- Extra functions
+		"tick", "warn",
+		"wait", "typeof",
+
+		-- Types
+		"CFrame",
+		"Color3",
+		"Enum",
+		"Instance",
+		"NumberRange",
+		"Rect",
+		"UDim", "UDim2",
+		"Vector2", "Vector3",
+		"Vector2int16", "Vector3int16",
+	}
+}
+
+stds.testez = {
+	read_globals = {
+		"describe",
+		"it", "itFOCUS", "itSKIP",
+		"FOCUS", "SKIP", "HACK_NO_XPCALL",
+		"expect",
+	}
+}
+
+ignore = {
+	"212", -- unused arguments
+}
+
+std = "lua51+roblox"
+
+files["**/*.spec.lua"] = {
+	std = "+testez",
+}

plugin/rbx_dom_lua/README.md

@@ -0,0 +1,2 @@
+# rbx\_dom\_lua
+Roblox Lua implementation of rbx-dom mechanisms, intended to work with rbx\_dom\_weak and friends.

plugin/rbx_dom_lua/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "rbx_dom_lua",
+  "tree": {
+    "$path": "src"
+  }
+}

plugin/rbx_dom_lua/src/EncodedValue.lua

@@ -0,0 +1,242 @@
+local base64 = require(script.Parent.base64)
+
+local function identity(...)
+	return ...
+end
+
+local function unpackDecoder(f)
+	return function(value)
+		return f(unpack(value))
+	end
+end
+
+local function serializeFloat(value)
+	-- TODO: Figure out a better way to serialize infinity and NaN, neither of
+	-- which fit into JSON.
+	if value == math.huge or value == -math.huge then
+		return 999999999 * math.sign(value)
+	end
+
+	return value
+end
+
+local encoders
+encoders = {
+	Bool = identity,
+	Content = identity,
+	Float32 = serializeFloat,
+	Float64 = serializeFloat,
+	Int32 = identity,
+	Int64 = identity,
+	String = identity,
+
+	BinaryString = base64.encode,
+	SharedString = base64.encode,
+
+	BrickColor = function(value)
+		return value.Number
+	end,
+
+	CFrame = function(value)
+		return {value:GetComponents()}
+	end,
+	Color3 = function(value)
+		return {value.r, value.g, value.b}
+	end,
+	NumberRange = function(value)
+		return {value.Min, value.Max}
+	end,
+	NumberSequence = function(value)
+		local keypoints = {}
+
+		for index, keypoint in ipairs(value.Keypoints) do
+			keypoints[index] = {
+				Time = keypoint.Time,
+				Value = keypoint.Value,
+				Envelope = keypoint.Envelope,
+			}
+		end
+
+		return {
+			Keypoints = keypoints,
+		}
+	end,
+	ColorSequence = function(value)
+		local keypoints = {}
+
+		for index, keypoint in ipairs(value.Keypoints) do
+			keypoints[index] = {
+				Time = keypoint.Time,
+				Color = encoders.Color3(keypoint.Value),
+			}
+		end
+
+		return {
+			Keypoints = keypoints,
+		}
+	end,
+	Rect = function(value)
+		return {
+			Min = {value.Min.X, value.Min.Y},
+			Max = {value.Max.X, value.Max.Y},
+		}
+	end,
+	UDim = function(value)
+		return {value.Scale, value.Offset}
+	end,
+	UDim2 = function(value)
+		return {value.X.Scale, value.X.Offset, value.Y.Scale, value.Y.Offset}
+	end,
+	Vector2 = function(value)
+		return {
+			serializeFloat(value.X),
+			serializeFloat(value.Y),
+		}
+	end,
+	Vector2int16 = function(value)
+		return {value.X, value.Y}
+	end,
+	Vector3 = function(value)
+		return {
+			serializeFloat(value.X),
+			serializeFloat(value.Y),
+			serializeFloat(value.Z),
+		}
+	end,
+	Vector3int16 = function(value)
+		return {value.X, value.Y, value.Z}
+	end,
+
+	PhysicalProperties = function(value)
+		if value == nil then
+			return nil
+		else
+			return {
+				Density = value.Density,
+				Friction = value.Friction,
+				Elasticity = value.Elasticity,
+				FrictionWeight = value.FrictionWeight,
+				ElasticityWeight = value.ElasticityWeight,
+			}
+		end
+	end,
+
+	Ref = function(value)
+		return nil
+	end,
+}
+
+local decoders = {
+	Bool = identity,
+	Content = identity,
+	Enum = identity,
+	Float32 = identity,
+	Float64 = identity,
+	Int32 = identity,
+	Int64 = identity,
+	String = identity,
+
+	BinaryString = base64.decode,
+	SharedString = base64.decode,
+
+	BrickColor = BrickColor.new,
+
+	CFrame = unpackDecoder(CFrame.new),
+	Color3 = unpackDecoder(Color3.new),
+	Color3uint8 = unpackDecoder(Color3.fromRGB),
+	NumberRange = unpackDecoder(NumberRange.new),
+	UDim = unpackDecoder(UDim.new),
+	UDim2 = unpackDecoder(UDim2.new),
+	Vector2 = unpackDecoder(Vector2.new),
+	Vector2int16 = unpackDecoder(Vector2int16.new),
+	Vector3 = unpackDecoder(Vector3.new),
+	Vector3int16 = unpackDecoder(Vector3int16.new),
+
+	Rect = function(value)
+		return Rect.new(value.Min[1], value.Min[2], value.Max[1], value.Max[2])
+	end,
+
+	NumberSequence = function(value)
+		local keypoints = {}
+
+		for index, keypoint in ipairs(value.Keypoints) do
+			keypoints[index] = NumberSequenceKeypoint.new(
+				keypoint.Time,
+				keypoint.Value,
+				keypoint.Envelope
+			)
+		end
+
+		return NumberSequence.new(keypoints)
+	end,
+
+	ColorSequence = function(value)
+		local keypoints = {}
+
+		for index, keypoint in ipairs(value.Keypoints) do
+			keypoints[index] = ColorSequenceKeypoint.new(
+				keypoint.Time,
+				Color3.new(unpack(keypoint.Color))
+			)
+		end
+
+		return ColorSequence.new(keypoints)
+	end,
+
+	PhysicalProperties = function(properties)
+		if properties == nil then
+			return nil
+		else
+			return PhysicalProperties.new(
+				properties.Density,
+				properties.Friction,
+				properties.Elasticity,
+				properties.FrictionWeight,
+				properties.ElasticityWeight
+			)
+		end
+	end,
+
+	Ref = function()
+		return nil
+	end,
+}
+
+local EncodedValue = {}
+
+function EncodedValue.decode(encodedValue)
+	local decoder = decoders[encodedValue.Type]
+	if decoder ~= nil then
+		return true, decoder(encodedValue.Value)
+	end
+
+	return false, "Couldn't decode value " .. tostring(encodedValue.Type)
+end
+
+function EncodedValue.encode(rbxValue, propertyType)
+	assert(propertyType ~= nil, "Property type descriptor is required")
+
+	if propertyType.type == "Data" then
+		local encoder = encoders[propertyType.name]
+
+		if encoder == nil then
+			return false, ("Missing encoder for property type %q"):format(propertyType.name)
+		end
+
+		if encoder ~= nil then
+			return true, {
+				Type = propertyType.name,
+				Value = encoder(rbxValue),
+			}
+		end
+	elseif propertyType.type == "Enum" then
+		return true, {
+			Type = "Enum",
+			Value = rbxValue.Value,
+		}
+	end
+
+	return false, ("Unknown property descriptor type %q"):format(tostring(propertyType.type))
+end
+
+return EncodedValue

plugin/rbx_dom_lua/src/EncodedValue.spec.lua

@@ -0,0 +1,127 @@
+return function()
+	local RbxDom = require(script.Parent)
+	local EncodedValue = require(script.Parent.EncodedValue)
+
+	it("should decode Rect values", function()
+		local input = {
+			Type = "Rect",
+			Value = {
+				Min = {1, 2},
+				Max = {3, 4},
+			},
+		}
+
+		local output = Rect.new(1, 2, 3, 4)
+
+		local ok, decoded = EncodedValue.decode(input)
+
+		assert(ok, decoded)
+		expect(decoded).to.equal(output)
+	end)
+
+	it("should decode ColorSequence values", function()
+		local input = {
+			Type = "ColorSequence",
+			Value = {
+				Keypoints = {
+					{
+						Time = 0,
+						Color = { 0.12, 0.34, 0.56 },
+					},
+
+					{
+						Time = 1,
+						Color = { 0.13, 0.33, 0.37 },
+					},
+				}
+			},
+		}
+
+		local output = ColorSequence.new({
+			ColorSequenceKeypoint.new(0, Color3.new(0.12, 0.34, 0.56)),
+			ColorSequenceKeypoint.new(1, Color3.new(0.13, 0.33, 0.37)),
+		})
+
+		local ok, decoded = EncodedValue.decode(input)
+		assert(ok, decoded)
+		expect(decoded).to.equal(output)
+	end)
+
+	it("should decode NumberSequence values", function()
+		local input = {
+			Type = "NumberSequence",
+			Value = {
+				Keypoints = {
+					{
+						Time = 0,
+						Value = 0.5,
+						Envelope = 0,
+					},
+
+					{
+						Time = 1,
+						Value = 0.5,
+						Envelope = 0,
+					},
+				}
+			},
+		}
+
+		local output = NumberSequence.new({
+			NumberSequenceKeypoint.new(0, 0.5, 0),
+			NumberSequenceKeypoint.new(1, 0.5, 0),
+		})
+
+		local ok, decoded = EncodedValue.decode(input)
+		assert(ok, decoded)
+		expect(decoded).to.equal(output)
+	end)
+
+	it("should decode PhysicalProperties values", function()
+		local input = {
+			Type = "PhysicalProperties",
+			Value = {
+				Density = 0.1,
+				Friction = 0.2,
+				Elasticity = 0.3,
+				FrictionWeight = 0.4,
+				ElasticityWeight = 0.5,
+			},
+		}
+
+		local output = PhysicalProperties.new(
+			0.1,
+			0.2,
+			0.3,
+			0.4,
+			0.5
+		)
+
+		local ok, decoded = EncodedValue.decode(input)
+		assert(ok, decoded)
+		expect(decoded).to.equal(output)
+	end)
+
+	-- This part of rbx_dom_lua needs some work still.
+	itSKIP("should encode Rect values", function()
+		local input = Rect.new(10, 20, 30, 40)
+
+		local output = {
+			Type = "Rect",
+			Value = {
+				Min = {10, 20},
+				Max = {30, 40},
+			},
+		}
+
+		local descriptor = RbxDom.findCanonicalPropertyDescriptor("ImageLabel", "SliceCenter")
+		local ok, encoded = EncodedValue.encode(input, descriptor)
+
+		assert(ok, encoded)
+		expect(encoded.Type).to.equal(output.Type)
+		expect(encoded.Value.Min[1]).to.equal(output.Value.Min[1])
+		expect(encoded.Value.Min[2]).to.equal(output.Value.Min[2])
+		expect(encoded.Value.Max[1]).to.equal(output.Value.Max[1])
+		expect(encoded.Value.Max[2]).to.equal(output.Value.Max[2])
+	end)
+end

plugin/rbx_dom_lua/src/Error.lua

@@ -0,0 +1,28 @@
+local Error = {}
+Error.__index = Error
+
+Error.Kind = {
+	UnknownProperty = "UnknownProperty",
+	PropertyNotReadable = "PropertyNotReadable",
+	PropertyNotWritable = "PropertyNotWritable",
+	Roblox = "Roblox",
+}
+
+setmetatable(Error.Kind, {
+	__index = function(_, key)
+		error(("%q is not a valid member of Error.Kind"):format(tostring(key)), 2)
+	end,
+})
+
+function Error.new(kind, extra)
+	return setmetatable({
+		kind = kind,
+		extra = extra,
+	}, Error)
+end
+
+function Error:__tostring()
+	return ("Error(%s: %s)"):format(self.kind, tostring(self.extra))
+end
+
+return Error

plugin/rbx_dom_lua/src/PropertyDescriptor.lua

@@ -0,0 +1,80 @@
+local Error = require(script.Parent.Error)
+local customProperties = require(script.Parent.customProperties)
+
+-- A wrapper around a property descriptor from the reflection database with some
+-- extra convenience methods.
+--
+-- The aim of this API is to facilitate looking up a property once, then reading
+-- from it or writing to it multiple times. It's also useful when a consumer
+-- wants to check additional constraints on the property before trying to use
+-- it, like scriptability.
+local PropertyDescriptor = {}
+PropertyDescriptor.__index = PropertyDescriptor
+
+local function get(container, key)
+	return container[key]
+end
+
+local function set(container, key, value)
+	container[key] = value
+end
+
+function PropertyDescriptor.fromRaw(data, className, propertyName)
+	return setmetatable({
+		scriptability = data.scriptability,
+		className = className,
+		name = propertyName,
+	}, PropertyDescriptor)
+end
+
+function PropertyDescriptor:read(instance)
+	if self.scriptability == "ReadWrite" or self.scriptability == "Read" then
+		local success, value = xpcall(get, debug.traceback, instance, self.name)
+
+		if success then
+			return success, value
+		else
+			return false, Error.new(Error.Kind.Roblox, value)
+		end
+	end
+
+	if self.scriptability == "Custom" then
+		local interface = customProperties[self.className][self.name]
+
+		return interface.read(instance, self.name)
+	end
+
+	if self.scriptability == "None" or self.scriptability == "Write" then
+		local fullName = ("%s.%s"):format(instance.className, self.name)
+
+		return false, Error.new(Error.Kind.PropertyNotReadable, fullName)
+	end
+
+	error(("Internal error: unexpected value of 'scriptability': %s"):format(tostring(self.scriptability)), 2)
+end
+
+function PropertyDescriptor:write(instance, value)
+	if self.scriptability == "ReadWrite" or self.scriptability == "Write" then
+		local success, err = xpcall(set, debug.traceback, instance, self.name, value)
+
+		if success then
+			return success
+		else
+			return false, Error.new(Error.Kind.Roblox, err)
+		end
+	end
+
+	if self.scriptability == "Custom" then
+		local interface = customProperties[self.className][self.name]
+
+		return interface.write(instance, self.name, value)
+	end
+
+	if self.scriptability == "None" or self.scriptability == "Read" then
+		local fullName = ("%s.%s"):format(instance.className, self.name)
+
+		return false, Error.new(Error.Kind.PropertyNotWritable, fullName)
+	end
+end
+
+return PropertyDescriptor

plugin/rbx_dom_lua/src/ReflectionDatabase/init.lua

@@ -0,0 +1,3 @@
+return {
+	classes = require(script.classes)
+}

plugin/rbx_dom_lua/src/base64.lua

@@ -0,0 +1,139 @@
+-- Thanks to Tiffany352 for this base64 implementation!
+
+local floor = math.floor
+local char = string.char
+
+local function encodeBase64(str)
+	local out = {}
+	local nOut = 0
+	local alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+	local strLen = #str
+
+	-- 3 octets become 4 hextets
+	for i = 1, strLen - 2, 3 do
+		local b1, b2, b3 = str:byte(i, i + 3)
+		local word = b3 + b2 * 256 + b1 * 256 * 256
+
+		local h4 = word % 64 + 1
+		word = floor(word / 64)
+		local h3 = word % 64 + 1
+		word = floor(word / 64)
+		local h2 = word % 64 + 1
+		word = floor(word / 64)
+		local h1 = word % 64 + 1
+
+		out[nOut + 1] = alphabet:sub(h1, h1)
+		out[nOut + 2] = alphabet:sub(h2, h2)
+		out[nOut + 3] = alphabet:sub(h3, h3)
+		out[nOut + 4] = alphabet:sub(h4, h4)
+		nOut = nOut + 4
+	end
+
+	local remainder = strLen % 3
+
+	if remainder == 2 then
+		-- 16 input bits -> 3 hextets (2 full, 1 partial)
+		local b1, b2 = str:byte(-2, -1)
+		-- partial is 4 bits long, leaving 2 bits of zero padding ->
+		-- offset = 4
+		local word = b2 * 4 + b1 * 4 * 256
+
+		local h3 = word % 64 + 1
+		word = floor(word / 64)
+		local h2 = word % 64 + 1
+		word = floor(word / 64)
+		local h1 = word % 64 + 1
+
+		out[nOut + 1] = alphabet:sub(h1, h1)
+		out[nOut + 2] = alphabet:sub(h2, h2)
+		out[nOut + 3] = alphabet:sub(h3, h3)
+		out[nOut + 4] = "="
+	elseif remainder == 1 then
+		-- 8 input bits -> 2 hextets (2 full, 1 partial)
+		local b1 = str:byte(-1, -1)
+		-- partial is 2 bits long, leaving 4 bits of zero padding ->
+		-- offset = 16
+		local word = b1 * 16
+
+		local h2 = word % 64 + 1
+		word = floor(word / 64)
+		local h1 = word % 64 + 1
+
+		out[nOut + 1] = alphabet:sub(h1, h1)
+		out[nOut + 2] = alphabet:sub(h2, h2)
+		out[nOut + 3] = "="
+		out[nOut + 4] = "="
+	end
+	-- if the remainder is 0, then no work is needed
+
+	return table.concat(out, "")
+end
+
+local function decodeBase64(str)
+	local out = {}
+	local nOut = 0
+	local alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+	local strLen = #str
+	local acc = 0
+	local nAcc = 0
+
+	local alphabetLut = {}
+	for i = 1, #alphabet do
+		alphabetLut[alphabet:sub(i, i)] = i - 1
+	end
+
+	-- 4 hextets become 3 octets
+	for i = 1, strLen do
+		local ch = str:sub(i, i)
+		local byte = alphabetLut[ch]
+		if byte then
+			acc = acc * 64 + byte
+			nAcc = nAcc + 1
+		end
+
+		if nAcc == 4 then
+			local b3 = acc % 256
+			acc = floor(acc / 256)
+			local b2 = acc % 256
+			acc = floor(acc / 256)
+			local b1 = acc % 256
+
+			out[nOut + 1] = char(b1)
+			out[nOut + 2] = char(b2)
+			out[nOut + 3] = char(b3)
+			nOut = nOut + 3
+			nAcc = 0
+			acc = 0
+		end
+	end
+
+	if nAcc == 3 then
+		-- 3 hextets -> 16 bit output
+		acc = acc * 64
+		acc = floor(acc / 256)
+		local b2 = acc % 256
+		acc = floor(acc / 256)
+		local b1 = acc % 256
+
+		out[nOut + 1] = char(b1)
+		out[nOut + 2] = char(b2)
+	elseif nAcc == 2 then
+		-- 2 hextets -> 8 bit output
+		acc = acc * 64
+		acc = floor(acc / 256)
+		acc = acc * 64
+		acc = floor(acc / 256)
+		local b1 = acc % 256
+
+		out[nOut + 1] = char(b1)
+	elseif nAcc == 1 then
+		error("Base64 has invalid length")
+	end
+
+	return table.concat(out, "")
+end
+
+return {
+	decode = decodeBase64,
+	encode = encodeBase64,
+}

plugin/rbx_dom_lua/src/base64.spec.lua

@@ -0,0 +1,29 @@
+return function()
+	local base64 = require(script.Parent.base64)
+
+	it("should encode and decode", function()
+		local function try(str, expected)
+			local encoded = base64.encode(str)
+			expect(encoded).to.equal(expected)
+			expect(base64.decode(encoded)).to.equal(str)
+		end
+
+		try("Man", "TWFu")
+		try("Ma", "TWE=")
+		try("M", "TQ==")
+		try("ManM", "TWFuTQ==")
+		try(
+			[[Man is distinguished, not only by his reason, but by this ]]..
+			[[singular passion from other animals, which is a lust of the ]]..
+			[[mind, that by a perseverance of delight in the continued and ]]..
+			[[indefatigable generation of knowledge, exceeds the short ]]..
+			[[vehemence of any carnal pleasure.]],
+			[[TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sI]]..
+			[[GJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYW]]..
+			[[xzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJ]]..
+			[[zZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRl]]..
+			[[ZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZ]]..
+			[[SBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=]]
+		)
+	end)
+end

plugin/rbx_dom_lua/src/customProperties.lua

@@ -0,0 +1,47 @@
+local CollectionService = game:GetService("CollectionService")
+
+-- Defines how to read and write properties that aren't directly scriptable.
+--
+-- The reflection database refers to these as having scriptability = "Custom"
+return {
+	Instance = {
+		Tags = {
+			read = function(instance, key)
+				local tagList = CollectionService:GetTags(instance)
+
+				return true, table.concat(tagList, "\0")
+			end,
+			write = function(instance, key, value)
+				local existingTags = CollectionService:GetTags(instance)
+
+				local unseenTags = {}
+				for _, tag in ipairs(existingTags) do
+					unseenTags[tag] = true
+				end
+
+				local tagList = string.split(value, "\0")
+				for _, tag in ipairs(tagList) do
+					unseenTags[tag] = nil
+					CollectionService:AddTag(instance, tag)
+				end
+
+				for tag in pairs(unseenTags) do
+					CollectionService:RemoveTag(instance, tag)
+				end
+
+				return true
+			end,
+		},
+	},
+	LocalizationTable = {
+		Contents = {
+			read = function(instance, key)
+				return true, instance:GetContents()
+			end,
+			write = function(instance, key, value)
+				instance:SetContents(value)
+				return true
+			end,
+		},
+	},
+}

plugin/rbx_dom_lua/src/init.lua

@@ -0,0 +1,67 @@
+local ReflectionDatabase = require(script.ReflectionDatabase)
+local Error = require(script.Error)
+local PropertyDescriptor = require(script.PropertyDescriptor)
+
+local function findCanonicalPropertyDescriptor(className, propertyName)
+	local currentClassName = className
+
+	repeat
+		local currentClass = ReflectionDatabase.classes[currentClassName]
+
+		if currentClass == nil then
+			return currentClass
+		end
+
+		local propertyData = currentClass.properties[propertyName]
+		if propertyData ~= nil then
+			if propertyData.isCanonical then
+				return PropertyDescriptor.fromRaw(propertyData, currentClassName, propertyName)
+			end
+
+			if propertyData.canonicalName ~= nil then
+				return PropertyDescriptor.fromRaw(
+					currentClass.properties[propertyData.canonicalName],
+					currentClassName,
+					propertyData.canonicalName)
+			end
+
+			return nil
+		end
+
+		currentClassName = currentClass.superclass
+	until currentClassName == nil
+
+	return nil
+end
+
+local function readProperty(instance, propertyName)
+	local descriptor = findCanonicalPropertyDescriptor(instance.ClassName, propertyName)
+
+	if descriptor == nil then
+		local fullName = ("%s.%s"):format(instance.className, propertyName)
+
+		return false, Error.new(Error.Kind.UnknownProperty, fullName)
+	end
+
+	return descriptor:read(instance)
+end
+
+local function writeProperty(instance, propertyName, value)
+	local descriptor = findCanonicalPropertyDescriptor(instance.ClassName, propertyName)
+
+	if descriptor == nil then
+		local fullName = ("%s.%s"):format(instance.className, propertyName)
+
+		return false, Error.new(Error.Kind.UnknownProperty, fullName)
+	end
+
+	return descriptor:write(instance, value)
+end
+
+return {
+	readProperty = readProperty,
+	writeProperty = writeProperty,
+	findCanonicalPropertyDescriptor = findCanonicalPropertyDescriptor,
+	Error = Error,
+	EncodedValue = require(script.EncodedValue),
+}

plugin/rbx_dom_lua/src/init.spec.lua

@@ -0,0 +1,7 @@
+return function()
+	local RbxDom = require(script.Parent)
+
+	it("should load", function()
+		expect(RbxDom).to.be.ok()
+	end)
+end

plugin/rbx_dom_lua/test-place.project.json

@@ -0,0 +1,35 @@
+{
+  "name": "rbx_dom_lua test place",
+  "tree": {
+    "$className": "DataModel",
+    "ReplicatedStorage": {
+      "$className": "ReplicatedStorage",
+
+      "RbxDom": {
+        "$path": "src"
+      },
+      "TestEZ": {
+        "$path": "modules/testez/lib"
+      }
+    },
+    "ServerScriptService": {
+      "$className": "ServerScriptService",
+
+      "Run Tests": {
+        "$path": "test.server.lua"
+      }
+    },
+    "Players": {
+      "$className": "Players",
+      "$properties": {
+        "CharacterAutoLoads": false
+      }
+    },
+    "HttpService": {
+      "$className": "HttpService",
+      "$properties": {
+        "HttpEnabled": true
+      }
+    }
+  }
+}

plugin/rbx_dom_lua/test.server.lua

@@ -0,0 +1,7 @@
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+local LIB_ROOT = ReplicatedStorage.RbxDom
+
+local TestEZ = require(ReplicatedStorage.TestEZ)
+
+TestEZ.TestBootstrap:run({LIB_ROOT})

plugin/src/ApiContext.lua

@@ -233,4 +233,19 @@ function ApiContext:retrieveMessages()
 		end)
 end
 
+function ApiContext:open(id)
+	local url = ("%s/api/open/%s"):format(self.__baseUrl, id)
+
+	return Http.post(url, "")
+		:andThen(rejectFailedRequests)
+		:andThen(Http.Response.json)
+		:andThen(function(body)
+			if body.sessionId ~= self.__sessionId then
+				return Promise.reject("Server changed ID")
+			end
+
+			return nil
+		end)
+end
+
 return ApiContext

plugin/src/Components/App.lua

@@ -13,11 +13,11 @@ local Version = require(Plugin.Version)
 local preloadAssets = require(Plugin.preloadAssets)
 local strict = require(Plugin.strict)
 
-local Theme = require(Plugin.Components.Theme)
 local ConnectPanel = require(Plugin.Components.ConnectPanel)
 local ConnectingPanel = require(Plugin.Components.ConnectingPanel)
 local ConnectionActivePanel = require(Plugin.Components.ConnectionActivePanel)
 local ErrorPanel = require(Plugin.Components.ErrorPanel)
+local SettingsPanel = require(Plugin.Components.SettingsPanel)
 
 local e = Roact.createElement
 
@@ -62,6 +62,7 @@ local AppStatus = strict("AppStatus", {
 	Connecting = "Connecting",
 	Connected = "Connected",
 	Error = "Error",
+	Settings = "Settings",
 })
 
 local App = Roact.Component:extend("App")
@@ -74,10 +75,7 @@ function App:init()
 
 	self.signals = {}
 	self.serveSession = nil
-
-	self.displayedVersion = DevSettings:isEnabled()
-		and Config.codename
-		or Version.display(Config.version)
+	self.displayedVersion = Version.display(Config.version)
 
 	local toolbar = self.props.plugin:CreateToolbar("Rojo " .. self.displayedVersion)
 
@@ -109,12 +107,14 @@ function App:init()
 	end)
 end
 
-function App:startSession(address, port)
+function App:startSession(address, port, sessionOptions)
 	Log.trace("Starting new session")
 
 	local baseUrl = ("http://%s:%s"):format(address, port)
 	self.serveSession = ServeSession.new({
 		apiContext = ApiContext.new(baseUrl),
+		openScriptsExternally = sessionOptions.openScriptsExternally,
+		twoWaySync = sessionOptions.twoWaySync,
 	})
 
 	self.serveSession:onStatusChanged(function(status, details)
@@ -155,8 +155,13 @@ function App:render()
 	if self.state.appStatus == AppStatus.NotStarted then
 		children = {
 			ConnectPanel = e(ConnectPanel, {
-				startSession = function(address, port)
-					self:startSession(address, port)
+				startSession = function(address, port, settings)
+					self:startSession(address, port, settings)
+				end,
+				openSettings = function()
+					self:setState({
+						appStatus = AppStatus.Settings,
+					})
 				end,
 				cancel = function()
 					Log.trace("Canceling session configuration")
@@ -169,7 +174,7 @@ function App:render()
 		}
 	elseif self.state.appStatus == AppStatus.Connecting then
 		children = {
-			ConnectingPanel = Roact.createElement(ConnectingPanel),
+			ConnectingPanel = e(ConnectingPanel),
 		}
 	elseif self.state.appStatus == AppStatus.Connected then
 		children = {
@@ -187,9 +192,19 @@ function App:render()
 				end,
 			}),
 		}
+	elseif self.state.appStatus == AppStatus.Settings then
+		children = {
+			e(SettingsPanel, {
+				back = function()
+					self:setState({
+						appStatus = AppStatus.NotStarted,
+					})
+				end,
+			}),
+		}
 	elseif self.state.appStatus == AppStatus.Error then
 		children = {
-			ErrorPanel = Roact.createElement(ErrorPanel, {
+			ErrorPanel = e(ErrorPanel, {
 				errorMessage = self.state.errorMessage,
 				onDismiss = function()
 					self:setState({
@@ -200,11 +215,9 @@ function App:render()
 		}
 	end
 
-	return Roact.createElement(Theme.StudioProvider, nil, {
-		UI = Roact.createElement(Roact.Portal, {
-			target = self.dockWidget,
-		}, children),
-	})
+	return e(Roact.Portal, {
+		target = self.dockWidget,
+	}, children)
 end
 
 function App:didMount()

plugin/src/Components/Checkbox.lua

@@ -0,0 +1,39 @@
+local Rojo = script:FindFirstAncestor("Rojo")
+local Plugin = Rojo.Plugin
+
+local Roact = require(Rojo.Roact)
+
+local Theme = require(Plugin.Components.Theme)
+
+local e = Roact.createElement
+
+local function Checkbox(props)
+	local checked = props.checked
+	local layoutOrder = props.layoutOrder
+	local onChange = props.onChange
+
+	return Theme.with(function(theme)
+		return e("ImageButton", {
+			LayoutOrder = layoutOrder,
+			Size = UDim2.new(0, 20, 0, 20),
+			BorderSizePixel = 2,
+			BorderColor3 = theme.Text2,
+			BackgroundColor3 = theme.Background2,
+
+			[Roact.Event.Activated] = function()
+				onChange(not checked)
+			end,
+		}, {
+			Indicator = e("Frame", {
+				Size = UDim2.new(0, 18, 0, 18),
+				Position = UDim2.new(0.5, 0, 0.5, 0),
+				AnchorPoint = Vector2.new(0.5, 0.5),
+				BorderSizePixel = 0,
+				BackgroundColor3 = theme.Brand1,
+				BackgroundTransparency = checked and 0 or 1,
+			})
+		})
+	end)
+end
+
+return Checkbox

plugin/src/Components/ConnectPanel.lua

@@ -11,6 +11,7 @@ local FitList = require(Plugin.Components.FitList)
 local FitText = require(Plugin.Components.FitText)
 local FormButton = require(Plugin.Components.FormButton)
 local FormTextInput = require(Plugin.Components.FormTextInput)
+local PluginSettings = require(Plugin.Components.PluginSettings)
 
 local e = Roact.createElement
 
@@ -25,138 +26,157 @@ end
 
 function ConnectPanel:render()
 	local startSession = self.props.startSession
+	local openSettings = self.props.openSettings
 
 	return Theme.with(function(theme)
-		return e(Panel, nil, {
-			Layout = e("UIListLayout", {
-				SortOrder = Enum.SortOrder.LayoutOrder,
-				HorizontalAlignment = Enum.HorizontalAlignment.Center,
-				VerticalAlignment = Enum.VerticalAlignment.Center,
-			}),
+		return PluginSettings.with(function(settings)
+			return e(Panel, nil, {
+				Layout = e("UIListLayout", {
+					SortOrder = Enum.SortOrder.LayoutOrder,
+					HorizontalAlignment = Enum.HorizontalAlignment.Center,
+					VerticalAlignment = Enum.VerticalAlignment.Center,
+				}),
 
-			Inputs = e(FitList, {
-				containerProps = {
-					BackgroundTransparency = 1,
-					LayoutOrder = 1,
-				},
-				layoutProps = {
-					FillDirection = Enum.FillDirection.Horizontal,
-					Padding = UDim.new(0, 8),
-				},
-				paddingProps = {
-					PaddingTop = UDim.new(0, 20),
-					PaddingBottom = UDim.new(0, 10),
-					PaddingLeft = UDim.new(0, 24),
-					PaddingRight = UDim.new(0, 24),
-				},
-			}, {
-				Address = e(FitList, {
+				Inputs = e(FitList, {
 					containerProps = {
-						LayoutOrder = 1,
 						BackgroundTransparency = 1,
+						LayoutOrder = 1,
 					},
 					layoutProps = {
-						Padding = UDim.new(0, 4),
+						FillDirection = Enum.FillDirection.Horizontal,
+						Padding = UDim.new(0, 8),
+					},
+					paddingProps = {
+						PaddingTop = UDim.new(0, 20),
+						PaddingBottom = UDim.new(0, 10),
+						PaddingLeft = UDim.new(0, 24),
+						PaddingRight = UDim.new(0, 24),
 					},
 				}, {
-					Label = e(FitText, {
-						Kind = "TextLabel",
-						LayoutOrder = 1,
-						BackgroundTransparency = 1,
-						TextXAlignment = Enum.TextXAlignment.Left,
-						Font = theme.TitleFont,
-						TextSize = 20,
-						Text = "Address",
-						TextColor3 = theme.Text1,
+					Address = e(FitList, {
+						containerProps = {
+							LayoutOrder = 1,
+							BackgroundTransparency = 1,
+						},
+						layoutProps = {
+							Padding = UDim.new(0, 4),
+						},
+					}, {
+						Label = e(FitText, {
+							Kind = "TextLabel",
+							LayoutOrder = 1,
+							BackgroundTransparency = 1,
+							TextXAlignment = Enum.TextXAlignment.Left,
+							Font = theme.TitleFont,
+							TextSize = 20,
+							Text = "Address",
+							TextColor3 = theme.Text1,
+						}),
+
+						Input = e(FormTextInput, {
+							layoutOrder = 2,
+							width = UDim.new(0, 220),
+							value = self.state.address,
+							placeholderValue = Config.defaultHost,
+							onValueChange = function(newValue)
+								self:setState({
+									address = newValue,
+								})
+							end,
+						}),
 					}),
 
-					Input = e(FormTextInput, {
-						layoutOrder = 2,
-						width = UDim.new(0, 220),
-						value = self.state.address,
-						placeholderValue = Config.defaultHost,
-						onValueChange = function(newValue)
-							self:setState({
-								address = newValue,
-							})
-						end,
+					Port = e(FitList, {
+						containerProps = {
+							LayoutOrder = 2,
+							BackgroundTransparency = 1,
+						},
+						layoutProps = {
+							Padding = UDim.new(0, 4),
+						},
+					}, {
+						Label = e(FitText, {
+							Kind = "TextLabel",
+							LayoutOrder = 1,
+							BackgroundTransparency = 1,
+							TextXAlignment = Enum.TextXAlignment.Left,
+							Font = theme.TitleFont,
+							TextSize = 20,
+							Text = "Port",
+							TextColor3 = theme.Text1,
+						}),
+
+						Input = e(FormTextInput, {
+							layoutOrder = 2,
+							width = UDim.new(0, 80),
+							value = self.state.port,
+							placeholderValue = Config.defaultPort,
+							onValueChange = function(newValue)
+								self:setState({
+									port = newValue,
+								})
+							end,
+						}),
 					}),
 				}),
 
-				Port = e(FitList, {
+				Buttons = e(FitList, {
+					fitAxes = "Y",
 					containerProps = {
+						BackgroundTransparency = 1,
 						LayoutOrder = 2,
-						BackgroundTransparency = 1,
+						Size = UDim2.new(1, 0, 0, 0),
 					},
 					layoutProps = {
-						Padding = UDim.new(0, 4),
+						FillDirection = Enum.FillDirection.Horizontal,
+						HorizontalAlignment = Enum.HorizontalAlignment.Right,
+						Padding = UDim.new(0, 8),
+					},
+					paddingProps = {
+						PaddingTop = UDim.new(0, 0),
+						PaddingBottom = UDim.new(0, 20),
+						PaddingLeft = UDim.new(0, 24),
+						PaddingRight = UDim.new(0, 24),
 					},
 				}, {
-					Label = e(FitText, {
-						Kind = "TextLabel",
-						LayoutOrder = 1,
-						BackgroundTransparency = 1,
-						TextXAlignment = Enum.TextXAlignment.Left,
-						Font = theme.TitleFont,
-						TextSize = 20,
-						Text = "Port",
-						TextColor3 = theme.Text1,
+					e(FormButton, {
+						layoutOrder = 1,
+						text = "Settings",
+						secondary = true,
+						onClick = function()
+							if openSettings ~= nil then
+								openSettings()
+							end
+						end,
 					}),
 
-					Input = e(FormTextInput, {
+					e(FormButton, {
 						layoutOrder = 2,
-						width = UDim.new(0, 80),
-						value = self.state.port,
-						placeholderValue = Config.defaultPort,
-						onValueChange = function(newValue)
-							self:setState({
-								port = newValue,
-							})
+						text = "Connect",
+						onClick = function()
+							if startSession ~= nil then
+								local address = self.state.address
+								if address:len() == 0 then
+									address = Config.defaultHost
+								end
+
+								local port = self.state.port
+								if port:len() == 0 then
+									port = Config.defaultPort
+								end
+
+								local sessionOptions = {
+									openScriptsExternally = settings:get("openScriptsExternally"),
+									twoWaySync = settings:get("twoWaySync"),
+								}
+
+								startSession(address, port, sessionOptions)
+							end
 						end,
 					}),
 				}),
-			}),
-
-			Buttons = e(FitList, {
-				fitAxes = "Y",
-				containerProps = {
-					BackgroundTransparency = 1,
-					LayoutOrder = 2,
-					Size = UDim2.new(1, 0, 0, 0),
-				},
-				layoutProps = {
-					FillDirection = Enum.FillDirection.Horizontal,
-					HorizontalAlignment = Enum.HorizontalAlignment.Right,
-					Padding = UDim.new(0, 8),
-				},
-				paddingProps = {
-					PaddingTop = UDim.new(0, 0),
-					PaddingBottom = UDim.new(0, 20),
-					PaddingLeft = UDim.new(0, 24),
-					PaddingRight = UDim.new(0, 24),
-				},
-			}, {
-				e(FormButton, {
-					layoutOrder = 2,
-					text = "Connect",
-					onClick = function()
-						if startSession ~= nil then
-							local address = self.state.address
-							if address:len() == 0 then
-								address = Config.defaultHost
-							end
-
-							local port = self.state.port
-							if port:len() == 0 then
-								port = Config.defaultPort
-							end
-
-							startSession(address, port)
-						end
-					end,
-				}),
-			}),
-		})
+			})
+		end)
 	end)
 end
 

plugin/src/Components/Panel.lua

@@ -17,7 +17,8 @@ function Panel:render()
 	return Theme.with(function(theme)
 		return e("Frame", {
 			Size = UDim2.new(1, 0, 1, 0),
-			BackgroundTransparency = 1,
+			BackgroundColor3 = theme.Background1,
+			BorderSizePixel = 1,
 		}, {
 			Layout = Roact.createElement("UIListLayout", {
 				HorizontalAlignment = Enum.HorizontalAlignment.Center,
@@ -26,8 +27,7 @@ function Panel:render()
 
 			Body = e("Frame", {
 				Size = UDim2.new(0, 360, 1, -32),
-				BackgroundColor3 = theme.Background1,
-				BorderSizePixel = 0,
+				BackgroundTransparency = 1,
 			}, self.props[Roact.Children]),
 
 			Footer = e(RojoFooter),

plugin/src/Components/PluginSettings.lua

@@ -0,0 +1,121 @@
+--[[
+	Persistent plugin settings that can be accessed via Roact context.
+]]
+
+local Rojo = script:FindFirstAncestor("Rojo")
+
+local Roact = require(Rojo.Roact)
+
+local defaultSettings = {
+	openScriptsExternally = false,
+	twoWaySync = false,
+}
+
+local Settings = {}
+Settings.__index = Settings
+
+function Settings.fromPlugin(plugin)
+	local values = {}
+
+	for name, defaultValue in pairs(defaultSettings) do
+		local savedValue = plugin:GetSetting("Rojo_" .. name)
+
+		if savedValue == nil then
+			plugin:SetSetting("Rojo_" .. name, defaultValue)
+			values[name] = defaultValue
+		else
+			values[name] = savedValue
+		end
+	end
+
+	return setmetatable({
+		__values = values,
+		__plugin = plugin,
+		__updateListeners = {},
+	}, Settings)
+end
+
+function Settings:get(name)
+	if defaultSettings[name] == nil then
+		error("Invalid setings name " .. tostring(name), 2)
+	end
+
+	return self.__values[name]
+end
+
+function Settings:set(name, value)
+	self.__plugin:SetSetting("Rojo_" .. name, value)
+	self.__values[name] = value
+
+	for callback in pairs(self.__updateListeners) do
+		callback(name, value)
+	end
+end
+
+function Settings:onUpdate(newCallback)
+	local newListeners = {}
+	for callback in pairs(self.__updateListeners) do
+		newListeners[callback] = true
+	end
+
+	newListeners[newCallback] = true
+	self.__updateListeners = newListeners
+
+	return function()
+		local newListeners = {}
+		for callback in pairs(self.__updateListeners) do
+			if callback ~= newCallback then
+				newListeners[callback] = true
+			end
+		end
+
+		self.__updateListeners = newListeners
+	end
+end
+
+local Context = Roact.createContext(nil)
+
+local StudioProvider = Roact.Component:extend("StudioProvider")
+
+function StudioProvider:init()
+	self.settings = Settings.fromPlugin(self.props.plugin)
+end
+
+function StudioProvider:render()
+	return Roact.createElement(Context.Provider, {
+		value = self.settings,
+	}, self.props[Roact.Children])
+end
+
+local InternalConsumer = Roact.Component:extend("InternalConsumer")
+
+function InternalConsumer:render()
+	return self.props.render(self.props.settings)
+end
+
+function InternalConsumer:didMount()
+	self.disconnect = self.props.settings:onUpdate(function()
+		-- Trigger a dummy state update to update the settings consumer.
+		self:setState({})
+	end)
+end
+
+function InternalConsumer:willUnmount()
+	self.disconnect()
+end
+
+local function with(callback)
+	return Roact.createElement(Context.Consumer, {
+		render = function(settings)
+			return Roact.createElement(InternalConsumer, {
+				settings = settings,
+				render = callback,
+			})
+		end,
+	})
+end
+
+return {
+	StudioProvider = StudioProvider,
+	with = with,
+}

plugin/src/Components/SettingsPanel.lua

@@ -0,0 +1,119 @@
+local Roact = require(script:FindFirstAncestor("Rojo").Roact)
+
+local Plugin = script:FindFirstAncestor("Plugin")
+
+local Checkbox = require(Plugin.Components.Checkbox)
+local FitList = require(Plugin.Components.FitList)
+local FitText = require(Plugin.Components.FitText)
+local FormButton = require(Plugin.Components.FormButton)
+local Panel = require(Plugin.Components.Panel)
+local PluginSettings = require(Plugin.Components.PluginSettings)
+local Theme = require(Plugin.Components.Theme)
+
+local e = Roact.createElement
+
+local SettingsPanel = Roact.Component:extend("SettingsPanel")
+
+function SettingsPanel:render()
+	local back = self.props.back
+
+	return Theme.with(function(theme)
+		return PluginSettings.with(function(settings)
+			return e(Panel, nil, {
+				Layout = Roact.createElement("UIListLayout", {
+					HorizontalAlignment = Enum.HorizontalAlignment.Center,
+					VerticalAlignment = Enum.VerticalAlignment.Center,
+					SortOrder = Enum.SortOrder.LayoutOrder,
+					Padding = UDim.new(0, 16),
+				}),
+
+				OpenScriptsExternally = e(FitList, {
+					containerProps = {
+						LayoutOrder = 1,
+						BackgroundTransparency = 1,
+					},
+					layoutProps = {
+						Padding = UDim.new(0, 4),
+						FillDirection = Enum.FillDirection.Horizontal,
+						HorizontalAlignment = Enum.HorizontalAlignment.Left,
+						VerticalAlignment = Enum.VerticalAlignment.Center,
+					},
+				}, {
+					Label = e(FitText, {
+						Kind = "TextLabel",
+						LayoutOrder = 1,
+						BackgroundTransparency = 1,
+						TextXAlignment = Enum.TextXAlignment.Left,
+						Font = theme.MainFont,
+						TextSize = 16,
+						Text = "Open Scripts Externally",
+						TextColor3 = theme.Text1,
+					}),
+
+					Padding = e("Frame", {
+						Size = UDim2.new(0, 8, 0, 0),
+						BackgroundTransparency = 1,
+						LayoutOrder = 2,
+					}),
+
+					Input = e(Checkbox, {
+						layoutOrder = 3,
+						checked = settings:get("openScriptsExternally"),
+						onChange = function(newValue)
+							settings:set("openScriptsExternally", not settings:get("openScriptsExternally"))
+						end,
+					}),
+				}),
+
+				TwoWaySync = e(FitList, {
+					containerProps = {
+						LayoutOrder = 2,
+						BackgroundTransparency = 1,
+					},
+					layoutProps = {
+						Padding = UDim.new(0, 4),
+						FillDirection = Enum.FillDirection.Horizontal,
+						HorizontalAlignment = Enum.HorizontalAlignment.Left,
+						VerticalAlignment = Enum.VerticalAlignment.Center,
+					},
+				}, {
+					Label = e(FitText, {
+						Kind = "TextLabel",
+						LayoutOrder = 1,
+						BackgroundTransparency = 1,
+						TextXAlignment = Enum.TextXAlignment.Left,
+						Font = theme.MainFont,
+						TextSize = 16,
+						Text = "Two-Way Sync (Experimental!)",
+						TextColor3 = theme.Text1,
+					}),
+
+					Padding = e("Frame", {
+						Size = UDim2.new(0, 8, 0, 0),
+						BackgroundTransparency = 1,
+						LayoutOrder = 2,
+					}),
+
+					Input = e(Checkbox, {
+						layoutOrder = 3,
+						checked = settings:get("twoWaySync"),
+						onChange = function(newValue)
+							settings:set("twoWaySync", not settings:get("twoWaySync"))
+						end,
+					}),
+				}),
+
+				BackButton = e(FormButton, {
+					layoutOrder = 4,
+					text = "Okay",
+					secondary = true,
+					onClick = function()
+						back()
+					end,
+				}),
+			})
+		end)
+	end)
+end
+
+return SettingsPanel

plugin/src/Config.lua

@@ -5,8 +5,8 @@ local isDevBuild = script.Parent.Parent:FindFirstChild("ROJO_DEV_BUILD") ~= nil
 return strict("Config", {
 	isDevBuild = isDevBuild,
 	codename = "Epiphany",
-	version = {0, 6, 0, "-alpha.2"},
-	expectedServerVersionString = "0.6.0 or newer",
+	version = {6, 0, 0, "-rc.1"},
+	expectedServerVersionString = "6.0 or newer",
 	protocolVersion = 3,
 	defaultHost = "localhost",
 	defaultPort = 34872,

plugin/src/DevSettings.lua

@@ -25,14 +25,6 @@ local VALUES = {
 			[Environment.Test] = true,
 		},
 	},
-	UnstableTwoWaySync = {
-		type = "BoolValue",
-		values = {
-			[Environment.User] = false,
-			[Environment.Dev] = false,
-			[Environment.Test] = false,
-		},
-	},
 }
 
 local CONTAINER_NAME = "RojoDevSettings" .. Config.codename
@@ -140,10 +132,6 @@ function DevSettings:shouldTypecheck()
 	return getValue("TypecheckingEnabled")
 end
 
-function DevSettings:twoWaySyncEnabled()
-	return getValue("UnstableTwoWaySync")
-end
-
 function _G.ROJO_DEV_CREATE()
 	DevSettings:createDevSettings()
 end

plugin/src/InstanceMap.lua

@@ -11,9 +11,22 @@ InstanceMap.__index = InstanceMap
 
 function InstanceMap.new(onInstanceChanged)
 	local self = {
+		-- A map from IDs to instances.
 		fromIds = {},
+
+		-- A map from instances to IDs.
 		fromInstances = {},
+
+		-- A set of all instances that updates should be paused for. This set
+		-- should generally be empty, and will be filled by pauseInstance
+		-- temporarily.
+		pausedUpdateInstances = {},
+
+		-- A map from instances to a signal or list of signals connected to it.
 		instancesToSignal = {},
+
+		-- Callback that's invoked whenever an instance is changed and it was
+		-- not paused.
 		onInstanceChanged = onInstanceChanged,
 	}
 
@@ -118,6 +131,32 @@ function InstanceMap:destroyId(id)
 	end
 end
 
+--[[
+	Pause updates for an instance momentarily and invoke a callback.
+
+	If the callback throws an error, InstanceMap will still be kept in a
+	consistent state.
+]]
+function InstanceMap:pauseInstance(instance, callback)
+	local id = self.fromInstances[instance]
+
+	-- If we don't know about this instance, ignore it and do not invoke the
+	-- callback.
+	if id == nil then
+		return
+	end
+
+	self.pausedUpdateInstances[instance] = true
+	local success, result = xpcall(callback, debug.traceback)
+	self.pausedUpdateInstances[instance] = false
+
+	if success then
+		return result
+	else
+		error(result, 2)
+	end
+end
+
 function InstanceMap:__connectSignals(instance)
 	-- ValueBase instances have an overriden version of the Changed signal that
 	-- only detects changes to their Value property.
@@ -150,9 +189,15 @@ end
 function InstanceMap:__maybeFireInstanceChanged(instance, propertyName)
 	Log.trace("{}.{} changed", instance:GetFullName(), propertyName)
 
-	if self.onInstanceChanged ~= nil then
-		self.onInstanceChanged(instance, propertyName)
+	if self.pausedUpdateInstances[instance] then
+		return
 	end
+
+	if self.onInstanceChanged == nil then
+		return
+	end
+
+	self.onInstanceChanged(instance, propertyName)
 end
 
 function InstanceMap:__disconnectSignals(instance)

plugin/src/PatchSet.lua

@@ -0,0 +1,25 @@
+--[[
+	Methods to operate on either a patch created by the hydrate method, or a
+	patch returned from the API.
+]]
+
+local t = require(script.Parent.Parent.t)
+
+local Types = require(script.Parent.Types)
+
+local PatchSet = {}
+
+PatchSet.validate = t.interface({
+	removed = t.array(t.union(Types.RbxId, t.Instance)),
+	added = t.map(Types.RbxId, Types.ApiInstance),
+	updated = t.array(Types.ApiInstanceUpdate),
+})
+
+--[[
+	Invert the given PatchSet using the given instance map.
+]]
+function PatchSet.invert(patchSet, instanceMap)
+	error("not yet implemented", 2)
+end
+
+return PatchSet

plugin/src/Reconciler.lua

@@ -5,24 +5,12 @@
 
 local RbxDom = require(script.Parent.Parent.RbxDom)
 local t = require(script.Parent.Parent.t)
-local Log = require(script.Parent.Parent.Log)
 
 local Types = require(script.Parent.Types)
 local invariant = require(script.Parent.invariant)
 local getCanonicalProperty = require(script.Parent.getCanonicalProperty)
 local setCanonicalProperty = require(script.Parent.setCanonicalProperty)
-
---[[
-	This interface represents either a patch created by the hydrate method, or a
-	patch returned from the API.
-
-	This type should be a subset of Types.ApiInstanceUpdate.
-]]
-local IPatch = t.interface({
-	removed = t.array(t.union(Types.RbxId, t.Instance)),
-	added = t.map(Types.RbxId, Types.ApiInstance),
-	updated = t.array(Types.ApiInstanceUpdate),
-})
+local PatchSet = require(script.Parent.PatchSet)
 
 --[[
 	Attempt to safely set the parent of an instance.
@@ -86,7 +74,7 @@ end
 	editable by scripts.
 ]]
 local applyPatchSchema = Types.ifEnabled(t.tuple(
-	IPatch
+	PatchSet.validate
 ))
 function Reconciler:applyPatch(patch)
 	assert(applyPatchSchema(patch))
@@ -287,7 +275,7 @@ local hydrateSchema = Types.ifEnabled(t.tuple(
 	t.map(Types.RbxId, Types.VirtualInstance),
 	Types.RbxId,
 	t.Instance,
-	IPatch
+	PatchSet.validate
 ))
 function Reconciler:__hydrateInternal(apiInstances, id, instance, hydratePatch)
 	assert(hydrateSchema(apiInstances, id, instance, hydratePatch))

plugin/src/ServeSession.lua

@@ -1,8 +1,9 @@
+local StudioService = game:GetService("StudioService")
+
 local Log = require(script.Parent.Parent.Log)
 local Fmt = require(script.Parent.Parent.Fmt)
 local t = require(script.Parent.Parent.t)
 
-local DevSettings = require(script.Parent.DevSettings)
 local InstanceMap = require(script.Parent.InstanceMap)
 local Reconciler = require(script.Parent.Reconciler)
 local strict = require(script.Parent.strict)
@@ -43,6 +44,8 @@ ServeSession.Status = Status
 
 local validateServeOptions = t.strictInterface({
 	apiContext = t.table,
+	openScriptsExternally = t.boolean,
+	twoWaySync = t.boolean,
 })
 
 function ServeSession.new(options)
@@ -57,12 +60,28 @@ function ServeSession.new(options)
 	local instanceMap = InstanceMap.new(onInstanceChanged)
 	local reconciler = Reconciler.new(instanceMap)
 
+	local connections = {}
+
+	local connection = StudioService
+		:GetPropertyChangedSignal("ActiveScript")
+		:Connect(function()
+			local activeScript = StudioService.ActiveScript
+
+			if activeScript ~= nil then
+				self:__onActiveScriptChanged(activeScript)
+			end
+		end)
+	table.insert(connections, connection)
+
 	self = {
 		__status = Status.NotStarted,
 		__apiContext = options.apiContext,
+		__openScriptsExternally = options.openScriptsExternally,
+		__twoWaySync = options.twoWaySync,
 		__reconciler = reconciler,
 		__instanceMap = instanceMap,
 		__statusChangedCallback = nil,
+		__connections = connections,
 	}
 
 	setmetatable(self, ServeSession)
@@ -108,8 +127,39 @@ function ServeSession:stop()
 	self:__stopInternal()
 end
 
+function ServeSession:__onActiveScriptChanged(activeScript)
+	if not self.__openScriptsExternally then
+		Log.trace("Not opening script {} because feature not enabled.", activeScript)
+
+		return
+	end
+
+	if self.__status ~= Status.Connected then
+		Log.trace("Not opening script {} because session is not connected.", activeScript)
+
+		return
+	end
+
+	local scriptId = self.__instanceMap.fromInstances[activeScript]
+	if scriptId == nil then
+		Log.trace("Not opening script {} because it is not known by Rojo.", activeScript)
+
+		return
+	end
+
+	Log.debug("Trying to open script {} externally...", activeScript)
+
+	-- Force-close the script inside Studio
+	local existingParent = activeScript.Parent
+	activeScript.Parent = nil
+	activeScript.Parent = existingParent
+
+	-- Notify the Rojo server to open this script
+	self.__apiContext:open(scriptId)
+end
+
 function ServeSession:__onInstanceChanged(instance, propertyName)
-	if not DevSettings:twoWaySyncEnabled() then
+	if not self.__twoWaySync then
 		return
 	end
 
@@ -200,6 +250,11 @@ function ServeSession:__stopInternal(err)
 	self:__setStatus(Status.Disconnected, err)
 	self.__apiContext:disconnect()
 	self.__instanceMap:stop()
+
+	for _, connection in ipairs(self.__connections) do
+		connection:Disconnect()
+	end
+	self.__connections = {}
 end
 
 function ServeSession:__setStatus(status, detail)

plugin/src/createSignal.lua

@@ -0,0 +1,53 @@
+--[[
+	Create a new signal that can be connected to, disconnected from, and fired.
+
+	Usage:
+
+		local signal = createSignal()
+		local disconnect = signal:connect(function(...)
+			print("fired:", ...)
+		end)
+
+		signal:fire("a", "b", "c")
+		disconnect()
+
+	Avoids mutating listeners list directly to prevent iterator invalidation if
+	a listener is disconnected while the signal is firing.
+]]
+local function createSignal()
+	local listeners = {}
+
+	local function connect(newListener)
+		local nextListeners = {}
+		for listener in pairs(listeners) do
+			nextListeners[listener] = true
+		end
+
+		nextListeners[newListener] = true
+		listeners = nextListeners
+
+		return function()
+			local nextListeners = {}
+			for listener in pairs(listeners) do
+				if listener ~= newListener then
+					nextListeners[listener] = true
+				end
+			end
+
+			listeners = nextListeners
+		end
+	end
+
+	local function fire(...)
+		for listener in pairs(listeners) do
+			listener(...)
+		end
+	end
+
+	return {
+		connect = connect,
+		fire = fire,
+	}
+end
+
+return createSignal

plugin/src/getCanonicalProperty.lua

@@ -1,7 +1,7 @@
 local RbxDom = require(script.Parent.Parent.RbxDom)
 
 --[[
-	Attempts to set a property on the given instance.
+	Attempts to read a property from the given instance.
 ]]
 local function getCanonincalProperty(instance, propertyName)
 	local descriptor = RbxDom.findCanonicalPropertyDescriptor(instance.ClassName, propertyName)

plugin/src/init.server.lua

@@ -14,9 +14,17 @@ local Roact = require(script.Parent.Roact)
 
 local Config = require(script.Config)
 local App = require(script.Components.App)
+local Theme = require(script.Components.Theme)
+local PluginSettings = require(script.Components.PluginSettings)
 
-local app = Roact.createElement(App, {
-	plugin = plugin,
+local app = Roact.createElement(Theme.StudioProvider, nil, {
+	Roact.createElement(PluginSettings.StudioProvider, {
+		plugin = plugin,
+	}, {
+		RojoUI = Roact.createElement(App, {
+			plugin = plugin,
+		}),
+	})
 })
 
 local tree = Roact.mount(app, nil, "Rojo UI")

rojo-test/Cargo.toml

@@ -11,7 +11,7 @@ default = []
 unstable_glob_ignore_paths = []
 
 [dependencies]
-env_logger = "0.6.2"
+env_logger = "0.7.1"
 insta = { version = "0.13.1", features = ["redactions"] }
 log = "0.4.8"
 paste = "0.1.5"

rojo-test/build-test-snapshots/rojo_test__build_test__infer_service_name.snap

@@ -0,0 +1,28 @@
+---
+source: rojo-test/src/build_test.rs
+expression: contents
+---
+<roblox version="4">
+  <Item class="DataModel" referent="0">
+    <Properties>
+      <string name="Name">infer-service-name</string>
+    </Properties>
+    <Item class="HttpService" referent="1">
+      <Properties>
+        <string name="Name">HttpService</string>
+        <bool name="HttpEnabled">true</bool>
+      </Properties>
+    </Item>
+    <Item class="ReplicatedStorage" referent="2">
+      <Properties>
+        <string name="Name">ReplicatedStorage</string>
+      </Properties>
+      <Item class="ModuleScript" referent="3">
+        <Properties>
+          <string name="Name">Main</string>
+          <string name="Source">-- hello, from main</string>
+        </Properties>
+      </Item>
+    </Item>
+  </Item>
+</roblox>

rojo-test/build-test-snapshots/rojo_test__build_test__infer_starter_player.snap

@@ -0,0 +1,26 @@
+---
+source: rojo-test/src/build_test.rs
+expression: contents
+---
+<roblox version="4">
+  <Item class="DataModel" referent="0">
+    <Properties>
+      <string name="Name">infer-service-name</string>
+    </Properties>
+    <Item class="StarterPlayer" referent="1">
+      <Properties>
+        <string name="Name">StarterPlayer</string>
+      </Properties>
+      <Item class="StarterCharacterScripts" referent="2">
+        <Properties>
+          <string name="Name">StarterCharacterScripts</string>
+        </Properties>
+      </Item>
+      <Item class="StarterPlayerScripts" referent="3">
+        <Properties>
+          <string name="Name">StarterPlayerScripts</string>
+        </Properties>
+      </Item>
+    </Item>
+  </Item>
+</roblox>

rojo-test/build-test-snapshots/rojo_test__build_test__json_as_lua.snap

@@ -0,0 +1,23 @@
+---
+source: rojo-test/src/build_test.rs
+expression: contents
+---
+<roblox version="4">
+  <Item class="ModuleScript" referent="0">
+    <Properties>
+      <string name="Name">json_as_lua</string>
+      <string name="Source">return {
+	["1invalidident"] = "nice",
+	array = {1, 2, 3},
+	["false"] = false,
+	float = 1234.5452,
+	int = 1234,
+	null = nil,
+	object = {
+		hello = "world",
+	},
+	["true"] = true,
+}</string>
+    </Properties>
+  </Item>
+</roblox>

rojo-test/build-tests/deep_nesting/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "deep_nesting",
+  "tree": {
+    "$path": "src"
+  }
+}

rojo-test/build-tests/infer_service_name/default.project.json

@@ -0,0 +1,16 @@
+{
+  "name": "infer-service-name",
+  "tree": {
+    "$className": "DataModel",
+    "ReplicatedStorage": {
+      "Main": {
+        "$path": "main.lua"
+      }
+    },
+    "HttpService": {
+      "$properties": {
+        "HttpEnabled": true
+      }
+    }
+  }
+}

rojo-test/build-tests/infer_service_name/main.lua

@@ -0,0 +1 @@
+-- hello, from main

rojo-test/build-tests/infer_starter_player/default.project.json

@@ -0,0 +1,11 @@
+{
+  "name": "infer-service-name",
+  "tree": {
+    "$className": "DataModel",
+
+    "StarterPlayer": {
+      "StarterPlayerScripts": {},
+      "StarterCharacterScripts": {}
+    }
+  }
+}

rojo-test/build-tests/infer_starter_player/main.lua

@@ -0,0 +1 @@
+-- hello, from main

rojo-test/build-tests/init_with_children/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "init_with_children",
+  "tree": {
+    "$path": "src"
+  }
+}

rojo-test/build-tests/json_as_lua/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "json_as_lua",
+  "tree": {
+    "$path": "make-me-a-script.json"
+  }
+}

rojo-test/build-tests/json_as_lua/make-me-a-script.json

@@ -0,0 +1,12 @@
+{
+  "array": [1, 2, 3],
+  "object": {
+    "hello": "world"
+  },
+  "true": true,
+  "false": false,
+  "null": null,
+  "int": 1234,
+  "float": 1234.5452,
+  "1invalidident": "nice"
+}

rojo-test/build-tests/plain.txt

@@ -1 +0,0 @@
-This is a bare text file with no project.

rojo-test/build-tests/rbxmx_ref/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "rbxmx_ref",
+  "tree": {
+    "$path": "model.rbxmx"
+  }
+}

rojo-test/serve-tests/add_folder/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "add_folder",
+  "tree": {
+    "$path": "src"
+  }
+}

rojo-test/serve-tests/edit_init/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "edit_init",
+  "tree": {
+    "$path": "src"
+  }
+}

rojo-test/serve-tests/just_txt.txt

@@ -1 +0,0 @@
-Hello, world!

rojo-test/serve-tests/move_folder_of_stuff/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "move_folder_of_stuff",
+  "tree": {
+    "$path": "src"
+  }
+}

rojo-test/serve-tests/remove_file/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "remove_file",
+  "tree": {
+    "$path": "src"
+  }
+}

rojo-test/serve-tests/scripts/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "scripts",
+  "tree": {
+    "$path": "src"
+  }
+}

rojo-test/src/build_test.rs

@@ -28,16 +28,19 @@ gen_build_tests! {
     csv_in_folder,
     deep_nesting,
     gitkeep,
+    infer_service_name,
+    infer_starter_player,
     init_meta_class_name,
     init_meta_properties,
     init_with_children,
+    json_as_lua,
     json_model_in_folder,
     json_model_legacy_name,
     module_in_folder,
     module_init,
-    plain_gitkeep,
     rbxm_in_folder,
     rbxmx_in_folder,
+    rbxmx_ref,
     script_meta_disabled,
     server_in_folder,
     server_init,
@@ -52,16 +55,6 @@ gen_build_tests! {
     ignore_glob_spec,
 }
 
-#[test]
-fn build_plain_txt() {
-    run_build_test("plain.txt");
-}
-
-#[test]
-fn build_rbxmx_ref() {
-    run_build_test("rbxmx_ref.rbxmx");
-}
-
 fn run_build_test(test_name: &str) {
     let build_test_path = get_build_tests_path();
     let working_dir = get_working_dir_path();

rojo-test/src/serve_test.rs

@@ -35,7 +35,7 @@ fn scripts() {
             read_response.intern_and_redact(&mut redactions, root_id)
         );
 
-        fs::write(session.path().join("foo.lua"), "Updated foo!").unwrap();
+        fs::write(session.path().join("src/foo.lua"), "Updated foo!").unwrap();
 
         let subscribe_response = session.get_api_subscribe(0).unwrap();
         assert_yaml_snapshot!(
@@ -51,26 +51,6 @@ fn scripts() {
     });
 }
 
-#[test]
-fn just_txt() {
-    run_serve_test("just_txt.txt", |session, mut redactions| {
-        let info = session.get_api_rojo().unwrap();
-        let root_id = info.root_instance_id;
-
-        assert_yaml_snapshot!("just_txt_info", redactions.redacted_yaml(info));
-
-        let read_response = session.get_api_read(root_id).unwrap();
-        assert_yaml_snapshot!(
-            "just_txt_all",
-            read_response.intern_and_redact(&mut redactions, root_id)
-        );
-
-        fs::write(session.path(), "Changed content!").unwrap();
-
-        // TODO: Directly served files currently don't trigger changed events!
-    });
-}
-
 #[test]
 fn add_folder() {
     run_serve_test("add_folder", |session, mut redactions| {
@@ -85,7 +65,7 @@ fn add_folder() {
             read_response.intern_and_redact(&mut redactions, root_id)
         );
 
-        fs::create_dir(session.path().join("my-new-folder")).unwrap();
+        fs::create_dir(session.path().join("src/my-new-folder")).unwrap();
 
         let subscribe_response = session.get_api_subscribe(0).unwrap();
         assert_yaml_snapshot!(
@@ -115,7 +95,7 @@ fn remove_file() {
             read_response.intern_and_redact(&mut redactions, root_id)
         );
 
-        fs::remove_file(session.path().join("hello.txt")).unwrap();
+        fs::remove_file(session.path().join("src/hello.txt")).unwrap();
 
         let subscribe_response = session.get_api_subscribe(0).unwrap();
         assert_yaml_snapshot!(
@@ -145,7 +125,7 @@ fn edit_init() {
             read_response.intern_and_redact(&mut redactions, root_id)
         );
 
-        fs::write(session.path().join("init.lua"), b"-- Edited contents").unwrap();
+        fs::write(session.path().join("src/init.lua"), b"-- Edited contents").unwrap();
 
         let subscribe_response = session.get_api_subscribe(0).unwrap();
         assert_yaml_snapshot!(
@@ -191,7 +171,7 @@ fn move_folder_of_stuff() {
 
         // We're hoping that this rename gets picked up as one event. This test
         // will fail otherwise.
-        fs::rename(stuff_path, session.path().join("new-stuff")).unwrap();
+        fs::rename(stuff_path, session.path().join("src/new-stuff")).unwrap();
 
         let subscribe_response = session.get_api_subscribe(0).unwrap();
         assert_yaml_snapshot!(

src/bin.rs

@@ -1,65 +1,95 @@
-use std::{error::Error, panic, process};
+use std::{env, error::Error, panic, process};
 
-use log::error;
+use backtrace::Backtrace;
 use structopt::StructOpt;
 
-use librojo::cli::{self, Options, Subcommand};
+use librojo::cli::{self, GlobalOptions, Options, Subcommand};
 
-fn main() {
-    let options = Options::from_args();
-
-    {
-        let log_filter = match options.verbosity {
-            0 => "warn",
-            1 => "warn,librojo=info",
-            2 => "warn,librojo=trace",
-            _ => "trace",
-        };
-
-        let log_env = env_logger::Env::default().default_filter_or(log_filter);
-
-        env_logger::Builder::from_env(log_env)
-            .format_timestamp(None)
-            .init();
-    }
-
-    let panic_result = panic::catch_unwind(|| {
-        if let Err(err) = run(options.subcommand) {
-            log::error!("{}", err);
-            process::exit(1);
-        }
-    });
-
-    if let Err(error) = panic_result {
-        let message = match error.downcast_ref::<&str>() {
-            Some(message) => message.to_string(),
-            None => match error.downcast_ref::<String>() {
-                Some(message) => message.clone(),
-                None => "<no message>".to_string(),
-            },
-        };
-
-        show_crash_message(&message);
-        process::exit(1);
-    }
-}
-
-fn run(subcommand: Subcommand) -> Result<(), Box<dyn Error>> {
+fn run(global: GlobalOptions, subcommand: Subcommand) -> Result<(), Box<dyn Error>> {
     match subcommand {
         Subcommand::Init(init_options) => cli::init(init_options)?,
-        Subcommand::Serve(serve_options) => cli::serve(serve_options)?,
+        Subcommand::Serve(serve_options) => cli::serve(global, serve_options)?,
         Subcommand::Build(build_options) => cli::build(build_options)?,
         Subcommand::Upload(upload_options) => cli::upload(upload_options)?,
+        Subcommand::Doc => cli::doc()?,
+        Subcommand::Plugin(plugin_options) => cli::plugin(plugin_options)?,
     }
 
     Ok(())
 }
 
-fn show_crash_message(message: &str) {
-    error!("Rojo crashed!");
-    error!("This is a bug in Rojo.");
-    error!("");
-    error!("Please consider filing a bug: https://github.com/rojo-rbx/rojo/issues");
-    error!("");
-    error!("Details: {}", message);
+fn main() {
+    panic::set_hook(Box::new(|panic_info| {
+        // PanicInfo's payload is usually a &'static str or String.
+        // See: https://doc.rust-lang.org/beta/std/panic/struct.PanicInfo.html#method.payload
+        let message = match panic_info.payload().downcast_ref::<&str>() {
+            Some(&message) => message.to_string(),
+            None => match panic_info.payload().downcast_ref::<String>() {
+                Some(message) => message.clone(),
+                None => "<no message>".to_string(),
+            },
+        };
+
+        log::error!("Rojo crashed!");
+        log::error!("This is probably a Rojo bug.");
+        log::error!("");
+        log::error!(
+            "Please consider filing an issue: {}/issues",
+            env!("CARGO_PKG_REPOSITORY")
+        );
+        log::error!("");
+        log::error!("Details: {}", message);
+
+        if let Some(location) = panic_info.location() {
+            log::error!("in file {} on line {}", location.file(), location.line());
+        }
+
+        // When using the backtrace crate, we need to check the RUST_BACKTRACE
+        // environment variable ourselves. Once we switch to the (currently
+        // unstable) std::backtrace module, we won't need to do this anymore.
+        let should_backtrace = env::var("RUST_BACKTRACE")
+            .map(|var| var == "1")
+            .unwrap_or(false);
+
+        if should_backtrace {
+            eprintln!("{:?}", Backtrace::new());
+        } else {
+            eprintln!(
+                "note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace."
+            );
+        }
+
+        process::exit(1);
+    }));
+
+    let options = Options::from_args();
+
+    let log_filter = match options.global.verbosity {
+        0 => "info",
+        1 => "info,librojo=debug",
+        2 => "info,librojo=trace",
+        _ => "trace",
+    };
+
+    let log_env = env_logger::Env::default().default_filter_or(log_filter);
+
+    env_logger::Builder::from_env(log_env)
+        .format_module_path(false)
+        .format_timestamp(None)
+        // Indent following lines equal to the log level label, like `[ERROR] `
+        .format_indent(Some(8))
+        .write_style(options.global.color.into())
+        .init();
+
+    if let Err(err) = run(options.global, options.subcommand) {
+        log::error!("{}", err);
+
+        let mut current_err: &dyn Error = &*err;
+        while let Some(source) = current_err.source() {
+            log::error!("  caused by {}", source);
+            current_err = &*source;
+        }
+
+        process::exit(1);
+    }
 }

src/change_processor.rs

@@ -9,6 +9,7 @@ use memofs::{IoResultExt, Vfs, VfsEvent};
 use rbx_dom_weak::{RbxId, RbxValue};
 
 use crate::{
+    error::ErrorDisplay,
     message_queue::MessageQueue,
     snapshot::{
         apply_patch_set, compute_patch_set, AppliedPatchSet, InstigatingSource, PatchSet, RojoTree,
@@ -62,15 +63,6 @@ impl ChangeProcessor {
             .spawn(move || {
                 log::trace!("ChangeProcessor thread started");
 
-                #[allow(
-                    // Crossbeam's select macro generates code that Clippy doesn't like,
-                    // and Clippy blames us for it.
-                    clippy::drop_copy,
-
-                    // Crossbeam uses 0 as *const _ and Clippy doesn't like that either,
-                    // but this isn't our fault.
-                    clippy::zero_ptr,
-                )]
                 loop {
                     select! {
                         recv(vfs_receiver) -> event => {
@@ -186,7 +178,7 @@ impl JobThreadContext {
                     if let Some(instigating_source) = &instance.metadata().instigating_source {
                         match instigating_source {
                             InstigatingSource::Path(path) => fs::remove_file(path).unwrap(),
-                            InstigatingSource::ProjectNode(_, _, _) => {
+                            InstigatingSource::ProjectNode(_, _, _, _) => {
                                 log::warn!(
                                     "Cannot remove instance {}, it's from a project file",
                                     id
@@ -234,7 +226,7 @@ impl JobThreadContext {
                                             log::warn!("Cannot change Source to non-string value.");
                                         }
                                     }
-                                    InstigatingSource::ProjectNode(_, _, _) => {
+                                    InstigatingSource::ProjectNode(_, _, _, _) => {
                                         log::warn!(
                                             "Cannot remove instance {}, it's from a project file",
                                             id
@@ -271,12 +263,11 @@ fn compute_and_apply_changes(tree: &mut RojoTree, vfs: &Vfs, id: RbxId) -> Optio
     let instigating_source = match &metadata.instigating_source {
         Some(path) => path,
         None => {
-            log::warn!(
+            log::error!(
                 "Instance {} did not have an instigating source, but was considered for an update.",
                 id
             );
-            log::warn!("This is a Rojo bug. Please file an issue!");
-
+            log::error!("This is a bug. Please file an issue!");
             return None;
         }
     };
@@ -284,51 +275,75 @@ fn compute_and_apply_changes(tree: &mut RojoTree, vfs: &Vfs, id: RbxId) -> Optio
     // How we process a file change event depends on what created this
     // file/folder in the first place.
     let applied_patch_set = match instigating_source {
-        InstigatingSource::Path(path) => {
-            let maybe_meta = vfs.metadata(path).with_not_found().unwrap();
+        InstigatingSource::Path(path) => match vfs.metadata(path).with_not_found() {
+            Ok(Some(_)) => {
+                // Our instance was previously created from a path and that
+                // path still exists. We can generate a snapshot starting at
+                // that path and use it as the source for our patch.
 
-            match maybe_meta {
-                Some(_meta) => {
-                    // Our instance was previously created from a path and
-                    // that path still exists. We can generate a snapshot
-                    // starting at that path and use it as the source for
-                    // our patch.
+                let snapshot = match snapshot_from_vfs(&metadata.context, &vfs, &path) {
+                    Ok(Some(snapshot)) => snapshot,
+                    Ok(None) => {
+                        log::error!(
+                            "Snapshot did not return an instance from path {}",
+                            path.display()
+                        );
+                        log::error!("This may be a bug!");
+                        return None;
+                    }
+                    Err(err) => {
+                        log::error!("Snapshot error: {}", ErrorDisplay(err));
+                        return None;
+                    }
+                };
 
-                    let snapshot = snapshot_from_vfs(&metadata.context, &vfs, &path)
-                        .expect("snapshot failed")
-                        .expect("snapshot did not return an instance");
-
-                    let patch_set = compute_patch_set(&snapshot, &tree, id);
-                    apply_patch_set(tree, patch_set)
-                }
-                None => {
-                    // Our instance was previously created from a path, but
-                    // that path no longer exists.
-                    //
-                    // We associate deleting the instigating file for an
-                    // instance with deleting that instance.
-
-                    let mut patch_set = PatchSet::new();
-                    patch_set.removed_instances.push(id);
-
-                    apply_patch_set(tree, patch_set)
-                }
+                let patch_set = compute_patch_set(&snapshot, &tree, id);
+                apply_patch_set(tree, patch_set)
             }
-        }
-        InstigatingSource::ProjectNode(project_path, instance_name, project_node) => {
+            Ok(None) => {
+                // Our instance was previously created from a path, but that
+                // path no longer exists.
+                //
+                // We associate deleting the instigating file for an
+                // instance with deleting that instance.
+
+                let mut patch_set = PatchSet::new();
+                patch_set.removed_instances.push(id);
+
+                apply_patch_set(tree, patch_set)
+            }
+            Err(err) => {
+                log::error!("Error processing filesystem change: {}", ErrorDisplay(err));
+                return None;
+            }
+        },
+
+        InstigatingSource::ProjectNode(project_path, instance_name, project_node, parent_class) => {
             // This instance is the direct subject of a project node. Since
             // there might be information associated with our instance from
             // the project file, we snapshot the entire project node again.
 
-            let snapshot = snapshot_project_node(
+            let snapshot_result = snapshot_project_node(
                 &metadata.context,
                 &project_path,
                 instance_name,
                 project_node,
                 &vfs,
-            )
-            .expect("snapshot failed")
-            .expect("snapshot did not return an instance");
+                parent_class.as_ref().map(|name| name.as_str()),
+            );
+
+            let snapshot = match snapshot_result {
+                Ok(Some(snapshot)) => snapshot,
+                Ok(None) => {
+                    log::error!("Snapshot did not return an instance from a project node.");
+                    log::error!("This is a bug!");
+                    return None;
+                }
+                Err(err) => {
+                    log::error!("{}", ErrorDisplay(err));
+                    return None;
+                }
+            };
 
             let patch_set = compute_patch_set(&snapshot, &tree, id);
             apply_patch_set(tree, patch_set)

src/cli/build.rs

@@ -1,15 +1,13 @@
 use std::{
     fs::File,
-    io::{self, BufWriter, Write},
+    io::{BufWriter, Write},
 };
 
 use memofs::Vfs;
-use snafu::{ResultExt, Snafu};
+use thiserror::Error;
 use tokio::runtime::Runtime;
 
-use crate::{
-    cli::BuildCommand, project::ProjectError, serve_session::ServeSession, snapshot::RojoTree,
-};
+use crate::{cli::BuildCommand, serve_session::ServeSession, snapshot::RojoTree};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum OutputKind {
@@ -31,50 +29,22 @@ fn detect_output_kind(options: &BuildCommand) -> Option<OutputKind> {
     }
 }
 
-#[derive(Debug, Snafu)]
-pub struct BuildError(Error);
-
-#[derive(Debug, Snafu)]
+#[derive(Debug, Error)]
 enum Error {
-    #[snafu(display("Could not detect what kind of file to create"))]
+    #[error("Could not detect what kind of file to build. Expected output file to end in .rbxl, .rbxlx, .rbxm, or .rbxmx.")]
     UnknownOutputKind,
-
-    #[snafu(display("{}", source))]
-    Io { source: io::Error },
-
-    #[snafu(display("{}", source))]
-    XmlModelEncode { source: rbx_xml::EncodeError },
-
-    #[snafu(display("Binary model error: {:?}", source))]
-    BinaryModelEncode {
-        #[snafu(source(false))]
-        source: rbx_binary::EncodeError,
-    },
-
-    #[snafu(display("{}", source))]
-    Project { source: ProjectError },
-}
-
-impl From<rbx_binary::EncodeError> for Error {
-    fn from(source: rbx_binary::EncodeError) -> Self {
-        Error::BinaryModelEncode { source }
-    }
 }
 
 fn xml_encode_config() -> rbx_xml::EncodeOptions {
     rbx_xml::EncodeOptions::new().property_behavior(rbx_xml::EncodePropertyBehavior::WriteUnknown)
 }
 
-pub fn build(options: BuildCommand) -> Result<(), BuildError> {
-    Ok(build_inner(options)?)
-}
-
-fn build_inner(options: BuildCommand) -> Result<(), Error> {
+pub fn build(options: BuildCommand) -> Result<(), anyhow::Error> {
     log::trace!("Constructing in-memory filesystem");
 
     let vfs = Vfs::new_default();
 
-    let session = ServeSession::new(vfs, &options.absolute_project());
+    let session = ServeSession::new(vfs, &options.absolute_project())?;
     let mut cursor = session.message_queue().cursor();
 
     {
@@ -98,14 +68,14 @@ fn build_inner(options: BuildCommand) -> Result<(), Error> {
     Ok(())
 }
 
-fn write_model(tree: &RojoTree, options: &BuildCommand) -> Result<(), Error> {
+fn write_model(tree: &RojoTree, options: &BuildCommand) -> Result<(), anyhow::Error> {
     let output_kind = detect_output_kind(&options).ok_or(Error::UnknownOutputKind)?;
     log::debug!("Hoping to generate file of type {:?}", output_kind);
 
     let root_id = tree.get_root_id();
 
     log::trace!("Opening output file for write");
-    let file = File::create(&options.output).context(Io)?;
+    let file = File::create(&options.output)?;
     let mut file = BufWriter::new(file);
 
     match output_kind {
@@ -113,8 +83,7 @@ fn write_model(tree: &RojoTree, options: &BuildCommand) -> Result<(), Error> {
             // Model files include the root instance of the tree and all its
             // descendants.
 
-            rbx_xml::to_writer(&mut file, tree.inner(), &[root_id], xml_encode_config())
-                .context(XmlModelEncode)?;
+            rbx_xml::to_writer(&mut file, tree.inner(), &[root_id], xml_encode_config())?;
         }
         OutputKind::Rbxlx => {
             // Place files don't contain an entry for the DataModel, but our
@@ -123,8 +92,7 @@ fn write_model(tree: &RojoTree, options: &BuildCommand) -> Result<(), Error> {
             let root_instance = tree.get_instance(root_id).unwrap();
             let top_level_ids = root_instance.children();
 
-            rbx_xml::to_writer(&mut file, tree.inner(), top_level_ids, xml_encode_config())
-                .context(XmlModelEncode)?;
+            rbx_xml::to_writer(&mut file, tree.inner(), top_level_ids, xml_encode_config())?;
         }
         OutputKind::Rbxm => {
             rbx_binary::encode(tree.inner(), &[root_id], &mut file)?;
@@ -141,7 +109,14 @@ fn write_model(tree: &RojoTree, options: &BuildCommand) -> Result<(), Error> {
         }
     }
 
-    file.flush().context(Io)?;
+    file.flush()?;
+
+    let filename = options
+        .output
+        .file_name()
+        .and_then(|name| name.to_str())
+        .unwrap_or("<invalid utf-8>");
+    log::info!("Built project to {}", filename);
 
     Ok(())
 }

src/cli/doc.rs

@@ -0,0 +1,4 @@
+pub fn doc() -> Result<(), anyhow::Error> {
+    opener::open("https://rojo.space/docs")?;
+    Ok(())
+}

src/cli/init.rs

@@ -1,17 +1,213 @@
-use snafu::Snafu;
+use std::{
+    fs::{self, OpenOptions},
+    io::{self, Write},
+    path::Path,
+    process::{Command, Stdio},
+};
 
-use crate::cli::InitCommand;
+use thiserror::Error;
 
-#[derive(Debug, Snafu)]
-pub struct InitError(Error);
+use crate::cli::{InitCommand, InitKind};
 
-#[derive(Debug, Snafu)]
-enum Error {}
+static MODEL_PROJECT: &str =
+    include_str!("../../assets/default-model-project/default.project.json");
+static MODEL_README: &str = include_str!("../../assets/default-model-project/README.md");
+static MODEL_INIT: &str = include_str!("../../assets/default-model-project/src-init.lua");
+static MODEL_GIT_IGNORE: &str = include_str!("../../assets/default-model-project/gitignore.txt");
 
-pub fn init(options: InitCommand) -> Result<(), InitError> {
-    Ok(init_inner(options)?)
+static PLACE_PROJECT: &str =
+    include_str!("../../assets/default-place-project/default.project.json");
+static PLACE_README: &str = include_str!("../../assets/default-place-project/README.md");
+static PLACE_GIT_IGNORE: &str = include_str!("../../assets/default-place-project/gitignore.txt");
+
+#[derive(Debug, Error)]
+enum Error {
+    #[error("A project file named default.project.json already exists in this folder")]
+    AlreadyExists,
+
+    #[error("git init failed")]
+    GitInit,
 }
 
-fn init_inner(_options: InitCommand) -> Result<(), Error> {
-    unimplemented!("init command");
+pub fn init(options: InitCommand) -> Result<(), anyhow::Error> {
+    let base_path = options.absolute_path();
+    fs::create_dir_all(&base_path)?;
+
+    let canonical = fs::canonicalize(&base_path)?;
+    let project_name = canonical
+        .file_name()
+        .and_then(|name| name.to_str())
+        .unwrap_or("new-project");
+
+    let project_params = ProjectParams {
+        name: project_name.to_owned(),
+    };
+
+    match options.kind {
+        InitKind::Place => init_place(&base_path, project_params),
+        InitKind::Model => init_model(&base_path, project_params),
+    }
+}
+
+fn init_place(base_path: &Path, project_params: ProjectParams) -> Result<(), anyhow::Error> {
+    eprintln!("Creating new place project '{}'", project_params.name);
+
+    let project_file = project_params.render_template(PLACE_PROJECT);
+    try_create_project(base_path, &project_file)?;
+
+    let readme = project_params.render_template(PLACE_README);
+    write_if_not_exists(&base_path.join("README.md"), &readme)?;
+
+    let src = base_path.join("src");
+    fs::create_dir_all(&src)?;
+
+    let src_shared = src.join("shared");
+    fs::create_dir_all(src.join(&src_shared))?;
+
+    let src_server = src.join("server");
+    fs::create_dir_all(src.join(&src_server))?;
+
+    let src_client = src.join("client");
+    fs::create_dir_all(src.join(&src_client))?;
+
+    write_if_not_exists(
+        &src_shared.join("Hello.lua"),
+        "return function()\n\tprint(\"Hello, world!\")\nend",
+    )?;
+
+    write_if_not_exists(
+        &src_server.join("init.server.lua"),
+        "print(\"Hello world, from server!\")",
+    )?;
+
+    write_if_not_exists(
+        &src_client.join("init.client.lua"),
+        "print(\"Hello world, from client!\")",
+    )?;
+
+    let git_ignore = project_params.render_template(PLACE_GIT_IGNORE);
+    try_git_init(base_path, &git_ignore)?;
+
+    eprintln!("Created project successfully.");
+
+    Ok(())
+}
+
+fn init_model(base_path: &Path, project_params: ProjectParams) -> Result<(), anyhow::Error> {
+    eprintln!("Creating new model project '{}'", project_params.name);
+
+    let project_file = project_params.render_template(MODEL_PROJECT);
+    try_create_project(base_path, &project_file)?;
+
+    let readme = project_params.render_template(MODEL_README);
+    write_if_not_exists(&base_path.join("README.md"), &readme)?;
+
+    let src = base_path.join("src");
+    fs::create_dir_all(&src)?;
+
+    let init = project_params.render_template(MODEL_INIT);
+    write_if_not_exists(&src.join("init.lua"), &init)?;
+
+    let git_ignore = project_params.render_template(MODEL_GIT_IGNORE);
+    try_git_init(base_path, &git_ignore)?;
+
+    eprintln!("Created project successfully.");
+
+    Ok(())
+}
+
+/// Contains parameters used in templates to create a project.
+struct ProjectParams {
+    name: String,
+}
+
+impl ProjectParams {
+    /// Render a template by replacing variables with project parameters.
+    fn render_template(&self, template: &str) -> String {
+        template
+            .replace("{project_name}", &self.name)
+            .replace("{rojo_version}", env!("CARGO_PKG_VERSION"))
+    }
+}
+
+/// Attempt to initialize a Git repository if necessary, and create .gitignore.
+fn try_git_init(path: &Path, git_ignore: &str) -> Result<(), anyhow::Error> {
+    if should_git_init(path) {
+        log::debug!("Initializing Git repository...");
+
+        let status = Command::new("git").arg("init").current_dir(path).status()?;
+
+        if !status.success() {
+            return Err(Error::GitInit.into());
+        }
+    }
+
+    write_if_not_exists(&path.join(".gitignore"), git_ignore)?;
+
+    Ok(())
+}
+
+/// Tells whether we should initialize a Git repository inside the given path.
+///
+/// Will return false if the user doesn't have Git installed or if the path is
+/// already inside a Git repository.
+fn should_git_init(path: &Path) -> bool {
+    let result = Command::new("git")
+        .args(&["rev-parse", "--is-inside-work-tree"])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .current_dir(path)
+        .status();
+
+    match result {
+        // If the command ran, but returned a non-zero exit code, we are not in
+        // a Git repo and we should initialize one.
+        Ok(status) => !status.success(),
+
+        // If the command failed to run, we probably don't have Git installed.
+        Err(_) => false,
+    }
+}
+
+/// Write a file if it does not exist yet, otherwise, leave it alone.
+fn write_if_not_exists(path: &Path, contents: &str) -> Result<(), anyhow::Error> {
+    let file_res = OpenOptions::new().write(true).create_new(true).open(path);
+
+    let mut file = match file_res {
+        Ok(file) => file,
+        Err(err) => {
+            return match err.kind() {
+                io::ErrorKind::AlreadyExists => return Ok(()),
+                _ => Err(err.into()),
+            }
+        }
+    };
+
+    file.write_all(contents.as_bytes())?;
+
+    Ok(())
+}
+
+/// Try to create a project file and fail if it already exists.
+fn try_create_project(base_path: &Path, contents: &str) -> Result<(), anyhow::Error> {
+    let project_path = base_path.join("default.project.json");
+
+    let file_res = OpenOptions::new()
+        .write(true)
+        .create_new(true)
+        .open(project_path);
+
+    let mut file = match file_res {
+        Ok(file) => file,
+        Err(err) => {
+            return match err.kind() {
+                io::ErrorKind::AlreadyExists => Err(Error::AlreadyExists.into()),
+                _ => Err(err.into()),
+            }
+        }
+    };
+
+    file.write_all(contents.as_bytes())?;
+
+    Ok(())
 }

src/cli/mod.rs

@@ -1,7 +1,9 @@
 //! Defines Rojo's CLI through structopt types.
 
 mod build;
+mod doc;
 mod init;
+mod plugin;
 mod serve;
 mod upload;
 
@@ -15,9 +17,12 @@ use std::{
 };
 
 use structopt::StructOpt;
+use thiserror::Error;
 
 pub use self::build::*;
+pub use self::doc::*;
 pub use self::init::*;
+pub use self::plugin::*;
 pub use self::serve::*;
 pub use self::upload::*;
 
@@ -25,16 +30,73 @@ pub use self::upload::*;
 #[derive(Debug, StructOpt)]
 #[structopt(name = "Rojo", about, author)]
 pub struct Options {
-    /// Sets verbosity level. Can be specified multiple times.
-    #[structopt(long = "verbose", short, global(true), parse(from_occurrences))]
-    pub verbosity: u8,
+    #[structopt(flatten)]
+    pub global: GlobalOptions,
 
     /// Subcommand to run in this invocation.
     #[structopt(subcommand)]
     pub subcommand: Subcommand,
 }
 
-/// All of Rojo's subcommands.
+#[derive(Debug, StructOpt)]
+pub struct GlobalOptions {
+    /// Sets verbosity level. Can be specified multiple times.
+    #[structopt(long("verbose"), short, global(true), parse(from_occurrences))]
+    pub verbosity: u8,
+
+    /// Set color behavior. Valid values are auto, always, and never.
+    #[structopt(long("color"), global(true), default_value("auto"))]
+    pub color: ColorChoice,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum ColorChoice {
+    Auto,
+    Always,
+    Never,
+}
+
+impl FromStr for ColorChoice {
+    type Err = ColorChoiceParseError;
+
+    fn from_str(source: &str) -> Result<Self, Self::Err> {
+        match source {
+            "auto" => Ok(ColorChoice::Auto),
+            "always" => Ok(ColorChoice::Always),
+            "never" => Ok(ColorChoice::Never),
+            _ => Err(ColorChoiceParseError {
+                attempted: source.to_owned(),
+            }),
+        }
+    }
+}
+
+impl From<ColorChoice> for termcolor::ColorChoice {
+    fn from(value: ColorChoice) -> Self {
+        match value {
+            ColorChoice::Auto => termcolor::ColorChoice::Auto,
+            ColorChoice::Always => termcolor::ColorChoice::Always,
+            ColorChoice::Never => termcolor::ColorChoice::Never,
+        }
+    }
+}
+
+impl From<ColorChoice> for env_logger::WriteStyle {
+    fn from(value: ColorChoice) -> Self {
+        match value {
+            ColorChoice::Auto => env_logger::WriteStyle::Auto,
+            ColorChoice::Always => env_logger::WriteStyle::Always,
+            ColorChoice::Never => env_logger::WriteStyle::Never,
+        }
+    }
+}
+
+#[derive(Debug, Error)]
+#[error("Invalid color choice '{attempted}'. Valid values are: auto, always, never")]
+pub struct ColorChoiceParseError {
+    attempted: String,
+}
+
 #[derive(Debug, StructOpt)]
 pub enum Subcommand {
     /// Creates a new Rojo project.
@@ -48,6 +110,12 @@ pub enum Subcommand {
 
     /// Generates a place or model file out of the project and uploads it to Roblox.
     Upload(UploadCommand),
+
+    /// Open Rojo's documentation in your browser.
+    Doc,
+
+    /// Manages Rojo's Roblox Studio plugin.
+    Plugin(PluginCommand),
 }
 
 /// Initializes a new Rojo project.
@@ -224,3 +292,21 @@ fn resolve_path(path: &Path) -> Cow<'_, Path> {
         Cow::Owned(env::current_dir().unwrap().join(path))
     }
 }
+
+#[derive(Debug, StructOpt)]
+pub enum PluginSubcommand {
+    /// Install the plugin in Roblox Studio's plugins folder. If the plugin is
+    /// already installed, installing it again will overwrite the current plugin
+    /// file.
+    Install,
+
+    /// Removes the plugin if it is installed.
+    Uninstall,
+}
+
+/// Install Rojo's plugin.
+#[derive(Debug, StructOpt)]
+pub struct PluginCommand {
+    #[structopt(subcommand)]
+    subcommand: PluginSubcommand,
+}

src/cli/plugin.rs

@@ -0,0 +1,70 @@
+use std::{
+    fs::{self, File},
+    io::BufWriter,
+};
+
+use anyhow::Result;
+use memofs::{InMemoryFs, Vfs, VfsSnapshot};
+use roblox_install::RobloxStudio;
+
+use crate::{
+    cli::{PluginCommand, PluginSubcommand},
+    serve_session::ServeSession,
+};
+
+static PLUGIN_BINCODE: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/plugin.bincode"));
+static PLUGIN_FILE_NAME: &str = "RojoManagedPlugin.rbxm";
+
+pub fn plugin(options: PluginCommand) -> Result<()> {
+    match options.subcommand {
+        PluginSubcommand::Install => install_plugin(),
+        PluginSubcommand::Uninstall => uninstall_plugin(),
+    }
+}
+
+pub fn install_plugin() -> Result<()> {
+    let plugin_snapshot: VfsSnapshot = bincode::deserialize(PLUGIN_BINCODE)
+        .expect("Rojo's plugin was not properly packed into Rojo's binary");
+
+    let studio = RobloxStudio::locate()?;
+
+    let plugins_folder_path = studio.plugins_path();
+
+    if !plugins_folder_path.exists() {
+        log::debug!("Creating Roblox Studio plugins folder");
+        fs::create_dir(plugins_folder_path)?;
+    }
+
+    let mut in_memory_fs = InMemoryFs::new();
+    in_memory_fs.load_snapshot("plugin", plugin_snapshot)?;
+
+    let vfs = Vfs::new(in_memory_fs);
+    let session = ServeSession::new(vfs, "plugin")?;
+
+    let plugin_path = plugins_folder_path.join(PLUGIN_FILE_NAME);
+    log::debug!("Writing plugin to {}", plugin_path.display());
+
+    let mut file = BufWriter::new(File::create(plugin_path)?);
+
+    let tree = session.tree();
+    let root_id = tree.get_root_id();
+
+    rbx_binary::encode(tree.inner(), &[root_id], &mut file)?;
+
+    Ok(())
+}
+
+fn uninstall_plugin() -> Result<()> {
+    let studio = RobloxStudio::locate()?;
+
+    let plugin_path = studio.plugins_path().join(PLUGIN_FILE_NAME);
+
+    if plugin_path.exists() {
+        log::debug!("Removing existing plugin from {}", plugin_path.display());
+        fs::remove_file(plugin_path)?;
+    } else {
+        log::debug!("Plugin not installed at {}", plugin_path.display());
+    }
+
+    Ok(())
+}

src/cli/serve.rs

@@ -3,28 +3,22 @@ use std::{
     sync::Arc,
 };
 
+use anyhow::Result;
 use memofs::Vfs;
-use snafu::Snafu;
 use termcolor::{BufferWriter, Color, ColorChoice, ColorSpec, WriteColor};
 
-use crate::{cli::ServeCommand, serve_session::ServeSession, web::LiveServer};
+use crate::{
+    cli::{GlobalOptions, ServeCommand},
+    serve_session::ServeSession,
+    web::LiveServer,
+};
 
 const DEFAULT_PORT: u16 = 34872;
 
-#[derive(Debug, Snafu)]
-pub struct ServeError(Error);
-
-#[derive(Debug, Snafu)]
-enum Error {}
-
-pub fn serve(options: ServeCommand) -> Result<(), ServeError> {
-    Ok(serve_inner(options)?)
-}
-
-fn serve_inner(options: ServeCommand) -> Result<(), Error> {
+pub fn serve(global: GlobalOptions, options: ServeCommand) -> Result<()> {
     let vfs = Vfs::new_default();
 
-    let session = Arc::new(ServeSession::new(vfs, &options.absolute_project()));
+    let session = Arc::new(ServeSession::new(vfs, &options.absolute_project())?);
 
     let port = options
         .port
@@ -33,14 +27,14 @@ fn serve_inner(options: ServeCommand) -> Result<(), Error> {
 
     let server = LiveServer::new(session);
 
-    let _ = show_start_message(port);
+    let _ = show_start_message(port, global.color.into());
     server.start(port);
 
     Ok(())
 }
 
-fn show_start_message(port: u16) -> io::Result<()> {
-    let writer = BufferWriter::stdout(ColorChoice::Auto);
+fn show_start_message(port: u16, color: ColorChoice) -> io::Result<()> {
+    let writer = BufferWriter::stdout(color);
     let mut buffer = writer.buffer();
 
     writeln!(&mut buffer, "Rojo server listening:")?;

src/cli/upload.rs

@@ -1,45 +1,30 @@
 use memofs::Vfs;
 use reqwest::header::{ACCEPT, CONTENT_TYPE, COOKIE, USER_AGENT};
-use snafu::{ResultExt, Snafu};
+use thiserror::Error;
 
-use crate::{auth_cookie::get_auth_cookie, cli::UploadCommand, common_setup};
+use crate::{auth_cookie::get_auth_cookie, cli::UploadCommand, serve_session::ServeSession};
 
-#[derive(Debug, Snafu)]
-pub struct UploadError(Error);
-
-#[derive(Debug, Snafu)]
+#[derive(Debug, Error)]
 enum Error {
-    #[snafu(display(
-        "Rojo could not find your Roblox auth cookie. Please pass one via --cookie.",
-    ))]
+    #[error("Rojo could not find your Roblox auth cookie. Please pass one via --cookie.")]
     NeedAuthCookie,
 
-    #[snafu(display("XML model file encode error: {}", source))]
-    XmlModel { source: rbx_xml::EncodeError },
-
-    #[snafu(display("HTTP error: {}", source))]
-    Http { source: reqwest::Error },
-
-    #[snafu(display("Roblox API error: {}", body))]
+    #[error("The Roblox API returned an unexpected error: {body}")]
     RobloxApi { body: String },
 }
 
-pub fn upload(options: UploadCommand) -> Result<(), UploadError> {
-    Ok(upload_inner(options)?)
-}
-
-fn upload_inner(options: UploadCommand) -> Result<(), Error> {
+pub fn upload(options: UploadCommand) -> Result<(), anyhow::Error> {
     let cookie = options
         .cookie
         .clone()
         .or_else(get_auth_cookie)
         .ok_or(Error::NeedAuthCookie)?;
 
-    log::trace!("Constructing in-memory filesystem");
     let vfs = Vfs::new_default();
 
-    let (_maybe_project, tree) = common_setup::start(&options.absolute_project(), &vfs);
+    let session = ServeSession::new(vfs, &options.absolute_project())?;
 
+    let tree = session.tree();
     let inner_tree = tree.inner();
     let root_id = inner_tree.get_root_id();
     let root_instance = inner_tree.get_instance(root_id).unwrap();
@@ -55,7 +40,7 @@ fn upload_inner(options: UploadCommand) -> Result<(), Error> {
     let config = rbx_xml::EncodeOptions::new()
         .property_behavior(rbx_xml::EncodePropertyBehavior::WriteUnknown);
 
-    rbx_xml::to_writer(&mut buffer, tree.inner(), &encode_ids, config).context(XmlModel)?;
+    rbx_xml::to_writer(&mut buffer, tree.inner(), &encode_ids, config)?;
 
     let url = format!(
         "https://data.roblox.com/Data/Upload.ashx?assetid={}",
@@ -72,13 +57,13 @@ fn upload_inner(options: UploadCommand) -> Result<(), Error> {
         .header(CONTENT_TYPE, "application/xml")
         .header(ACCEPT, "application/json")
         .body(buffer)
-        .send()
-        .context(Http)?;
+        .send()?;
 
     if !response.status().is_success() {
         return Err(Error::RobloxApi {
-            body: response.text().context(Http)?,
-        });
+            body: response.text()?,
+        }
+        .into());
     }
 
     Ok(())

src/common_setup.rs

@@ -1,57 +0,0 @@
-//! Initialization routines that are used by more than one Rojo command or
-//! utility.
-
-use std::path::Path;
-
-use memofs::Vfs;
-use rbx_dom_weak::RbxInstanceProperties;
-
-use crate::{
-    project::Project,
-    snapshot::{
-        apply_patch_set, compute_patch_set, InstanceContext, InstancePropertiesWithMeta,
-        PathIgnoreRule, RojoTree,
-    },
-    snapshot_middleware::snapshot_from_vfs,
-};
-
-pub fn start(fuzzy_project_path: &Path, vfs: &Vfs) -> (Option<Project>, RojoTree) {
-    log::trace!("Loading project file from {}", fuzzy_project_path.display());
-    let maybe_project = Project::load_fuzzy(fuzzy_project_path).expect("TODO: Project load failed");
-
-    log::trace!("Constructing initial tree");
-    let mut tree = RojoTree::new(InstancePropertiesWithMeta {
-        properties: RbxInstanceProperties {
-            name: "ROOT".to_owned(),
-            class_name: "Folder".to_owned(),
-            properties: Default::default(),
-        },
-        metadata: Default::default(),
-    });
-
-    let root_id = tree.get_root_id();
-
-    let mut instance_context = InstanceContext::default();
-
-    if let Some(project) = &maybe_project {
-        let rules = project.glob_ignore_paths.iter().map(|glob| PathIgnoreRule {
-            glob: glob.clone(),
-            base_path: project.folder_location().to_path_buf(),
-        });
-
-        instance_context.add_path_ignore_rules(rules);
-    }
-
-    log::trace!("Generating snapshot of instances from VFS");
-    let snapshot = snapshot_from_vfs(&instance_context, vfs, &fuzzy_project_path)
-        .expect("snapshot failed")
-        .expect("snapshot did not return an instance");
-
-    log::trace!("Computing patch set");
-    let patch_set = compute_patch_set(&snapshot, &tree, root_id);
-
-    log::trace!("Applying patch set");
-    apply_patch_set(&mut tree, patch_set);
-
-    (maybe_project, tree)
-}

src/error.rs

@@ -0,0 +1,18 @@
+use std::{error::Error, fmt};
+
+/// Wrapper type to print errors with source-chasing.
+pub struct ErrorDisplay<E>(pub E);
+
+impl<E: Error> fmt::Display for ErrorDisplay<E> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        writeln!(formatter, "{}", self.0)?;
+
+        let mut current_err: &dyn Error = &self.0;
+        while let Some(source) = current_err.source() {
+            writeln!(formatter, "  caused by {}", source)?;
+            current_err = &*source;
+        }
+
+        Ok(())
+    }
+}

src/lib.rs

@@ -9,8 +9,9 @@ mod tree_view;
 
 mod auth_cookie;
 mod change_processor;
-mod common_setup;
+mod error;
 mod glob;
+mod lua_ast;
 mod message_queue;
 mod multimap;
 mod path_serializer;