0.5.0-alpha.5

Upgrade dependencies
Add missing CHANGELOG note
2026-04-20 20:55:50 +00:00 · 2019-03-01 15:40:30 -08:00 · 2019-03-01 15:34:16 -08:00 · 2019-02-27 17:32:36 -08:00 · 2019-02-27 14:54:05 -08:00 · 2019-02-27 14:51:53 -08:00
74 changed files with 2519 additions and 1337 deletions
--- a/.cargo/config
+++ b/.cargo/config
@@ -0,0 +1,2 @@
+[target.x86_64-pc-windows-msvc]
+rustflags = ["-Ctarget-feature=+crt-static"]
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,38 +1,54 @@
 matrix:
  include:
-    - language: python
-      env:
-        - LUA="lua=5.1"
+    # Lua tests are currently disabled because of holes in Lemur that are pretty
+    # tedious to fix. It should be fixed by either adding missing features to
+    # Lemur or by migrating to a CI system based on real Roblox instead.

-      before_install:
-        - pip install hererocks
-        - hererocks lua_install -r^ --$LUA
-        - export PATH=$PATH:$PWD/lua_install/bin
+    # - language: python
+    #   env:
+    #     - LUA="lua=5.1"

-      install:
-        - luarocks install luafilesystem
-        - luarocks install busted
-        - luarocks install luacov
-        - luarocks install luacov-coveralls
-        - luarocks install luacheck
+    #   before_install:
+    #     - pip install hererocks
+    #     - hererocks lua_install -r^ --$LUA
+    #     - export PATH=$PATH:$PWD/lua_install/bin

-      script:
-        - cd plugin
-        - luacheck src
-        - lua -lluacov spec.lua
+    #   install:
+    #     - luarocks install luafilesystem
+    #     - luarocks install busted
+    #     - luarocks install luacov
+    #     - luarocks install luacov-coveralls
+    #     - luarocks install luacheck

-      after_success:
-        - cd plugin
-        - luacov-coveralls -e $TRAVIS_BUILD_DIR/lua_install
+    #   script:
+    #     - cd plugin
+    #     - luacheck src
+    #     - lua -lluacov spec.lua
+
+    #   after_success:
+    #     - cd plugin
+    #     - luacov-coveralls -e $TRAVIS_BUILD_DIR/lua_install

    - language: rust
-      rust: stable
+      rust: 1.32.0
+      cache: cargo

      script:
        - cargo test --verbose
+        - cargo test --verbose --all-features
+
+    - language: rust
+      rust: stable
+      cache: cargo
+
+      script:
+        - cargo test --verbose
+        - cargo test --verbose --all-features

    - language: rust
      rust: beta
+      cache: cargo

      script:
-        - cargo test --verbose
+        - cargo test --verbose
+        - cargo test --verbose --all-features
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,24 @@

 ## [Unreleased]

+## [0.5.0 Alpha 5](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.5) (March 1, 2019)
+* Upgraded core dependencies, which improves compatibility for lots of instance types
+    * Upgraded from `rbx_tree` 0.2.0 to `rbx_dom_weak` 1.0.0
+    * Upgraded from `rbx_xml` 0.2.0 to `rbx_xml` 0.4.0
+    * Upgraded from `rbx_binary` 0.2.0 to `rbx_binary` 0.4.0
+* Added support for non-primitive types in the Rojo plugin.
+    * Types like `Color3` and `CFrame` can now be updated live!
+* Fixed plugin assets flashing in on first load ([#121](https://github.com/LPGhatguy/rojo/issues/121))
+* Changed Rojo's HTTP server from Rouille to Hyper, which reduced the release size by around a megabyte.
+* Added property type inference to projects, which makes specifying services a lot easier ([#130](https://github.com/LPGhatguy/rojo/pull/130))
+* Made error messages from invalid and missing files more user-friendly
+
+## [0.5.0 Alpha 4](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.4) (February 8, 2019)
+* Added support for nested partitions ([#102](https://github.com/LPGhatguy/rojo/issues/102))
+* Added support for 'transmuting' partitions ([#112](https://github.com/LPGhatguy/rojo/issues/112))
+* Added support for aliasing filesystem paths ([#105](https://github.com/LPGhatguy/rojo/issues/105))
+* Changed Windows builds to statically link the CRT ([#89](https://github.com/LPGhatguy/rojo/issues/89))
+
 ## [0.5.0 Alpha 3](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.3) (February 1, 2019)
 * Changed default project file name from `roblox-project.json` to `default.project.json` ([#120](https://github.com/LPGhatguy/rojo/pull/120))
    * The old file name will still be supported until 0.5.0 is fully released.
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/README.md
+++ b/README.md
@@ -62,7 +62,7 @@ If you use a plugin that _isn't_ Rojo for syncing code, open an issue and let me
 ## Contributing
 Pull requests are welcome!

-All pull requests are run against a test suite on Travis CI. That test suite should always pass!
+Rojo supports Rust 1.32 and newer. Any changes to the minimum required compiler version require a _minor_ version bump.

 ## License
 Rojo is available under the terms of the Mozilla Public License, Version 2.0. See [LICENSE.txt](LICENSE.txt) for details.
--- a/docs/getting-started/creating-a-place.md
+++ b/docs/getting-started/creating-a-place.md
@@ -1,3 +1,7 @@
+[TOC]
+
+## Creating the Rojo Project
+
 To use Rojo to build a place, you'll need to create a new project file, which tells Rojo how your project is structured on-disk and in Roblox.

 Create a new folder, then run `rojo init` inside that folder to initialize an empty project.
@@ -9,7 +13,7 @@ cd my-new-project
 rojo init
 ```

-Rojo will make a small project file in your directory, named `roblox-project.json`. It'll make sure that any code in the directory `src` will get put into `ReplicatedStorage.Source`.
+Rojo will make a small project file in your directory, named `default.project.json`. It'll make sure that any code in the directory `src` will get put into `ReplicatedStorage.Source`.

 Speaking of, let's make sure we create a directory named `src`, and maybe a Lua file inside of it:

--- a/docs/getting-started/installation.md
+++ b/docs/getting-started/installation.md
@@ -1,25 +0,0 @@
-Rojo has two components:
-
-* The server, a binary written in Rust
-* The plugin, a Roblox Studio plugin written in Lua
-
-It's important that the plugin and server are compatible. The plugin will show errors in the Roblox Studio Output window if there is a version mismatch.
-
-## Installing the Server
-To install the server, either:
-
-* If you have Rust installed, use `cargo install rojo`
-* Or, download a pre-built Windows binary from [the GitHub releases page](https://github.com/LPGhatguy/rojo/releases)
-
-**The Rojo binary must be run from the command line, like Terminal on MacOS or `cmd.exe` on Windows. It's recommended that you put the Rojo binary on your `PATH` to make this easier.**
-
-## Installing the Plugin
-To install the plugin, either:
-
-* Install the plugin from the [Roblox plugin page](https://www.roblox.com/library/1211549683/Rojo).
-  * This gives you less control over what version you install -- you will always have the latest version.
-* Or, download the latest release from [the GitHub releases section](https://github.com/LPGhatguy/rojo/releases) and install it into your Roblox plugins folder
-  * You can open this folder by clicking the "Plugins Folder" button from the Plugins toolbar in Roblox Studio
-
-## Visual Studio Code Extension
-If you use Visual Studio Code on Windows, you can install [Evaera's unofficial Rojo extension](https://marketplace.visualstudio.com/items?itemName=evaera.vscode-rojo), which will install both halves of Rojo for you. It even has a nifty UI to add partitions and start/stop the Rojo server!
--- a/docs/images/plugins-folder-in-studio.png
+++ b/docs/images/plugins-folder-in-studio.png
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,4 +1,4 @@
-This is the documentation home for Rojo.
+This is the documentation home for Rojo 0.5.x.

 Available versions of these docs:

--- a/docs/installation.md
+++ b/docs/installation.md
@@ -0,0 +1,45 @@
+[TOC]
+
+## Overview
+
+Rojo has two components:
+
+* The command line interface (CLI)
+* The Roblox Studio plugin
+
+!!! info
+    It's important that your installed version of the plugin and CLI are compatible.
+
+    The plugin will show errors in the Roblox Studio output window if there is a version mismatch.
+
+## Installing the CLI
+
+### Installing from GitHub
+If you're on Windows, there are pre-built binaries available from Rojo's [GitHub Releases page](https://github.com/LPGhatguy/rojo/releases).
+
+The Rojo CLI must be run from the command line, like Terminal.app on MacOS or `cmd.exe` on Windows. It's recommended that you put the Rojo CLI executable on your `PATH` to make this easier.
+
+### Installing from Cargo
+If you have Rust installed, the easiest way to get Rojo is with Cargo!
+
+To install the latest 0.5.0 alpha, use:
+
+```sh
+cargo install rojo --version 0.5.0-alpha.5
+```
+
+## Installing the Plugin
+
+### Installing from GitHub
+The Rojo Roblox Studio plugin is available available from Rojo's [GitHub Releases page](https://github.com/LPGhatguy/rojo/releases).
+
+Download the attached `rbxm` file and put it into your Roblox Studio plugins folder. You can find that folder by pressing **Plugins Folder** from your Plugins toolbar in Roblox Studio:
+
+!['Plugins Folder' button in Roblox Studio](images/plugins-folder-in-studio.png)
+{: align="center" }
+
+### Installing from Roblox.com
+Visit [Rojo's Roblox.com Plugin page](https://www.roblox.com/library/1997686364/Rojo-0-5-0-alpha-3) in Roblox Studio and press **Install**.
+
+## Visual Studio Code Extension
+If you use Visual Studio Code on Windows, you can install [Evaera's unofficial Rojo extension](https://marketplace.visualstudio.com/items?itemName=evaera.vscode-rojo), which will install both halves of Rojo for you. It even has a nifty UI to add partitions and start/stop the Rojo server!
--- a/docs/internals/overview.md
+++ b/docs/internals/overview.md
@@ -0,0 +1,45 @@
+This document aims to give a general overview of how Rojo works. It's intended for people who want to contribute to the project as well as anyone who's just curious how the tool works!
+
+[TOC]
+
+## CLI
+
+### RbxTree
+Rojo uses a library named [`rbx_tree`](https://github.com/LPGhatguy/rbx-tree) as its implementation of the Roblox DOM. It serves as a common format for serialization to all the formats Rojo supports!
+
+Rojo uses two related libraries to deserialize instances from Roblox's file formats, `rbx_xml` and `rbx_binary`.
+
+### In-Memory Filesystem (IMFS)
+Relevant source files:
+
+* [`server/src/imfs.rs`](https://github.com/LPGhatguy/rojo/blob/master/server/src/imfs.rs)
+* [`server/src/fs_watcher.rs`](https://github.com/LPGhatguy/rojo/blob/master/server/src/fs_watcher.rs)
+
+Rojo keeps an in-memory copy of all files that it needs reasons about. This enables taking fast, stateless, tear-tree snapshots of files to turn them into instances.
+
+Keeping an in-memory copy of file contents will also enable Rojo to debounce changes that are caused by Rojo itself. This'll happen when two-way sync finally happens.
+
+### Snapshot Reconciler
+Relevant source files:
+
+* [`server/src/snapshot_reconciler.rs`](https://github.com/LPGhatguy/rojo/blob/master/server/src/snapshot_reconciler.rs)
+* [`server/src/rbx_snapshot.rs`](https://github.com/LPGhatguy/rojo/blob/master/server/src/rbx_snapshot.rs)
+* [`server/src/rbx_session.rs`](https://github.com/LPGhatguy/rojo/blob/master/server/src/rbx_session.rs)
+
+To simplify incremental updates of instances, Rojo generates lightweight snapshots describing how files map to instances. This means that Rojo can treat file change events similarly to damage painting as opposed to trying to surgically update the correct instances.
+
+This approach reduces the number of desynchronization bugs, reduces the complexity of important pieces of the codebase, and makes writing plugins a lot easier.
+
+### HTTP API
+Relevant source files:
+
+* [`server/src/web.rs`](https://github.com/LPGhatguy/rojo/blob/master/server/src/web.rs)
+
+The Rojo live-sync server and Roblox Studio plugin communicate via HTTP.
+
+Requests sent from the plugin to the server are regular HTTP requests.
+
+Messages sent from the server to the plugin are delivered via HTTP long-polling. This is an approach that uses long-lived HTTP requests that restart on timeout. It's largely been replaced by WebSockets, but Roblox doesn't have support for them.
+
+## Roblox Studio Plugin
+TODO
--- a/docs/migrating-to-epiphany.md
+++ b/docs/migrating-to-epiphany.md
@@ -1,7 +1,9 @@
 Rojo underwent a large refactor during most of 2018 to enable a bunch of new features and lay groundwork for lots more in 2019. As such, Rojo **0.5.x** projects are not compatible with Rojo **0.4.x** projects.

+[TOC]
+
 ## Supporting Both 0.4.x and 0.5.x
-Rojo 0.5.x uses a different name for its project format. While 0.4.x used `rojo.json`, 0.5.x uses `roblox-project.json`, which allows them to coexist.
+Rojo 0.5.x uses a different name for its project format. While 0.4.x used `rojo.json`, 0.5.x uses `default.project.json`, which allows them to coexist.

 If you aren't sure about upgrading or want to upgrade gradually, it's possible to keep both files in the same project without causing problems.

--- a/docs/project-format.md
+++ b/docs/project-format.md
@@ -0,0 +1,100 @@
+[TOC]
+
+## Project File
+
+Rojo projects are JSON files that have the `.project.json` extension. They have these fields:
+
+* `name`: A string indicating the name of the project.
+    * This is only used for diagnostics.
+* `tree`: An [Instance Description](#instance-description) describing the root instance of the project.
+
+## Instance Description
+Instance Descriptions correspond one-to-one with the actual Roblox Instances in the project. They can be specified directly in the project file or be pulled from the filesystem.
+
+* `$className`: The ClassName of the Instance being described.
+    * Optional if `$path` is specified.
+* `$path`: The path on the filesystem to pull files from into the project.
+    * Optional if `$className` is specified.
+    * Paths are relative to the folder containing the project file.
+* `$properties`: Properties to apply to the instance. Values should be [Instance Property Values](#instance-property-value).
+    * Optional
+* `$ignoreUnknownInstances`: Whether instances that Rojo doesn't know about should be deleted.
+    * Optional
+    * Default is `false` if `$path` is specified, otherwise `true`.
+
+All other fields in an Instance Description are turned into instances whose name is the key. These values should also be Instance Descriptions!
+
+Instance Descriptions are fairly verbose and strict. In the future, it'll be possible for Rojo to infer class names for known services like `Workspace`.
+
+## Instance Property Value
+The shape of Instance Property Values is defined by the [rbx_tree](https://github.com/LPGhatguy/rbx-tree) library, so it uses slightly different conventions than the rest of Rojo.
+
+Each value should be an object with the following required fields:
+
+* `Type`: The type of property to represent.
+    * [Supported types can be found here](https://github.com/LPGhatguy/rbx-tree#property-type-coverage).
+* `Value`: The value of the property.
+    * The shape of this field depends on which property type is being used. `Vector3` and `Color3` values are both represented as a list of numbers, for example.
+
+Instance Property Values are intentionally very strict. Rojo will eventually be able to infer types for you!
+
+## Example Projects
+This project bundles up everything in the `src` directory. It'd be suitable for making a plugin or model:
+
+```json
+{
+    "name": "AwesomeLibrary",
+    "tree": {
+        "$path": "src"
+    }
+}
+```
+
+This project describes the layout you might use if you were making the next hit simulator game, *Sisyphus Simulator*:
+
+```json
+{
+    "name": "Sisyphus Simulator",
+    "tree": {
+        "$className": "DataModel",
+
+        "HttpService": {
+            "$className": "HttpService",
+            "$properties": {
+                "HttpEnabled": {
+                    "Type": "Bool",
+                    "Value": true
+                }
+            }
+        },
+
+        "ReplicatedStorage": {
+            "$className": "ReplicatedStorage",
+            "$path": "src/ReplicatedStorage"
+        },
+
+        "StarterPlayer": {
+            "$className": "StarterPlayer",
+
+            "StarterPlayerScripts": {
+                "$className": "StarterPlayerScripts",
+                "$path": "src/StarterPlayerScripts"
+            }
+        },
+
+        "Workspace": {
+            "$className": "Workspace",
+            "$properties": {
+                "Gravity": {
+                    "Type": "Float32",
+                    "Value": 67.3
+                }
+            },
+
+            "Terrain": {
+                "$path": "Terrain.rbxm"
+            }
+        }
+    }
+}
+```
--- a/docs/sync-details.md
+++ b/docs/sync-details.md
@@ -1,5 +1,7 @@
 This page aims to describe how Rojo turns files on the filesystem into Roblox objects.

+[TOC]
+
 ## Overview
 | File Name      | Instance Type       |
 | -------------- | ------------------- |
@@ -22,7 +24,7 @@ Some common cases you might hit are:
 * `MeshPart.MeshId`
 * `HttpService.HttpEnabled`

-For a list of all property types that Rojo can reason about, both when live-syncing and when building place files, look at [rbx_tree's type coverage documentation](https://github.com/LPGhatguy/rbx-tree/tree/master/rbx_tree#coverage).
+For a list of all property types that Rojo can reason about, both when live-syncing and when building place files, look at [rbx_tree's type coverage chart](https://github.com/LPGhatguy/rbx-tree#property-type-coverage).

 ## Folders
 Any directory on the filesystem will turn into a `Folder` instance unless it contains an 'init' script, described below.
@@ -34,19 +36,13 @@ If a directory contains a file named `init.server.lua`, `init.client.lua`, or `i

 For example, these files:

-<div align="center">
-    <a href="../images/sync-example-files.svg">
-        <img src="../images/sync-example-files.svg" alt="Tree of files on disk" />
-    </a>
-</div>
+![Tree of files on disk](images/sync-example-files.svg)
+{: align="center" }

 Will turn into these instances in Roblox:

-<div align="center">
-    <a href="../images/sync-example-instances.svg">
-        <img src="../images/sync-example-instances.svg" alt="Tree of instances in Roblox" />
-    </a>
-</div>
+![Tree of instances in Roblox](images/sync-example-instances.svg)
+{: align="center" }

 ## Localization Tables
 Any CSV files are transformed into `LocalizationTable` instances. Rojo expects these files to follow the same format that Roblox does when importing and exporting localization information.
@@ -84,18 +80,12 @@ A JSON model describing a folder containing a `Part` and a `RemoteEvent` could b

 It would turn into instances in this shape:

-<div align="center">
-    <a href="../images/sync-example-json-model.svg">
-        <img src="../images/sync-example-json-model.svg" alt="Tree of instances in Roblox" />
-    </a>
-</div>
+![Tree of instances in Roblox](images/sync-example-json-model.svg)
+{: align="center" }

 ## Binary and XML Models
 Rojo supports both binary (`.rbxm`) and XML (`.rbxmx`) models generated by Roblox Studio or another tool.

-Not all property types are supported!
+Not all property types are supported for all formats!

-For a rundown of supported types, see:
-
-* [rbxm Type Coverage](https://github.com/LPGhatguy/rbx-tree/tree/master/rbx_binary#coverage)
-* [rbxmx Type Coverage](https://github.com/LPGhatguy/rbx-tree/tree/master/rbx_xml#coverage)
+For a rundown of supported types, check out [rbx_tree's type coverage chart](https://github.com/LPGhatguy/rbx-tree#property-type-coverage).
--- a/docs/why-rojo.md
+++ b/docs/why-rojo.md
@@ -1,16 +1,19 @@
 There are a number of existing plugins for Roblox that move code from the filesystem into Roblox.

-Besides Rojo, there is:
+Besides Rojo, you might consider:

-* [Studio Bridge](https://github.com/vocksel/studio-bridge) by [Vocksel](https://github.com/vocksel)
-* [RbxRefresh](https://github.com/osyrisrblx/RbxRefresh) by [Osyris](https://github.com/osyrisrblx)
-* [RbxSync](https://github.com/evaera/RbxSync) by [evaera](https://github.com/evaera)
-* [CodeSync](https://github.com/MemoryPenguin/CodeSync) and [rbx-exteditor](https://github.com/MemoryPenguin/rbx-exteditor) by [MemoryPenguin](https://github.com/MemoryPenguin)
-* [rbxmk](https://github.com/anaminus/rbxmk) by [Anaminus](https://github.com/anaminus)
+* [rbxmk by Anaminus](https://github.com/anaminus/rbxmk)
+* [Rofresh by Osyris](https://github.com/osyrisrblx/rofresh)
+* [RbxRefresh by Osyris](https://github.com/osyrisrblx/RbxRefresh)
+* [Studio Bridge by Vocksel](https://github.com/vocksel/studio-bridge)
+* [Elixir by Vocksel](https://github.com/vocksel/elixir)
+* [RbxSync by evaera](https://github.com/evaera/RbxSync)
+* [CodeSync by MemoryPenguin](https://github.com/MemoryPenguin/CodeSync)
+* [rbx-exteditor by MemoryPenguin](https://github.com/MemoryPenguin/rbx-exteditor)

 So why did I build Rojo?

-Each of these tools solves what is essentially the same problem from a few different angles. The goal of Rojo is to take all of the lessons and ideas learned from these projects and build a tool that can solve the problem for good.
+Each of these tools solves what is essentially the same problem from a few different angles. The goal of Rojo is to take all of the lessons and ideas learned from these projects and build a tool that can solve this problem for good.

 Additionally:

--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -11,11 +11,13 @@ theme:
 nav:
  - Home: index.md
  - Why Rojo?: why-rojo.md
-  - Getting Started:
-    - Installation: getting-started/installation.md
-    - Creating a Place with Rojo: getting-started/creating-a-place.md
-  - Sync Details: sync-details.md
+  - Installation: installation.md
+  - Creating a Place with Rojo: creating-a-place.md
  - Migrating from 0.4.x to 0.5.x: migrating-to-epiphany.md
+  - Project Format: project-format.md
+  - Sync Details: sync-details.md
+  - Rojo Internals:
+    - Internals Overview: internals/overview.md

 extra_css:
  - extra.css
--- a/plugin/.luacheckrc
+++ b/plugin/.luacheckrc
@@ -13,6 +13,7 @@ stds.roblox = {

 		-- Types
 		"Vector2", "Vector3",
+		"Vector2int16", "Vector3int16",
 		"Color3",
 		"UDim", "UDim2",
 		"Rect",
--- a/plugin/src/Assets.lua
+++ b/plugin/src/Assets.lua
@@ -1,9 +1,7 @@
-local sheetAsset = "rbxassetid://2738712459"
-
 local Assets = {
 	Sprites = {
 		WhiteCross = {
-			asset = sheetAsset,
+			asset = "rbxassetid://2738712459",
 			offset = Vector2.new(190, 318),
 			size = Vector2.new(18, 18),
 		},
--- a/plugin/src/Components/App.lua
+++ b/plugin/src/Components/App.lua
@@ -8,6 +8,7 @@ local Config = require(Plugin.Config)
 local Version = require(Plugin.Version)
 local Logging = require(Plugin.Logging)
 local DevSettings = require(Plugin.DevSettings)
+local preloadAssets = require(Plugin.preloadAssets)

 local ConnectPanel = require(Plugin.Components.ConnectPanel)
 local ConnectionActivePanel = require(Plugin.Components.ConnectionActivePanel)
@@ -177,6 +178,8 @@ function App:didMount()
 			})
 		end
 	end)
+
+	preloadAssets()
 end

 function App:didUpdate()
--- a/plugin/src/Config.lua
+++ b/plugin/src/Config.lua
@@ -1,6 +1,6 @@
 return {
 	codename = "Epiphany",
-	version = {0, 5, 0, "-alpha.3"},
+	version = {0, 5, 0, "-alpha.5"},
 	expectedServerVersionString = "0.5.0 or newer",
 	protocolVersion = 2,
 	defaultHost = "localhost",
--- a/plugin/src/InstanceMap.lua
+++ b/plugin/src/InstanceMap.lua
@@ -0,0 +1,71 @@
+local Logging = require(script.Parent.Logging)
+
+--[[
+	A bidirectional map between instance IDs and Roblox instances. It lets us
+	keep track of every instance we know about.
+
+	TODO: Track ancestry to catch when stuff moves?
+]]
+local InstanceMap = {}
+InstanceMap.__index = InstanceMap
+
+function InstanceMap.new()
+	local self = {
+		fromIds = {},
+		fromInstances = {},
+	}
+
+	return setmetatable(self, InstanceMap)
+end
+
+function InstanceMap:insert(id, instance)
+	self.fromIds[id] = instance
+	self.fromInstances[instance] = id
+end
+
+function InstanceMap:removeId(id)
+	local instance = self.fromIds[id]
+
+	if instance ~= nil then
+		self.fromIds[id] = nil
+		self.fromInstances[instance] = nil
+	else
+		Logging.warn("Attempted to remove nonexistant ID %s", tostring(id))
+	end
+end
+
+function InstanceMap:removeInstance(instance)
+	local id = self.fromInstances[instance]
+
+	if id ~= nil then
+		self.fromInstances[instance] = nil
+		self.fromIds[id] = nil
+	else
+		Logging.warn("Attempted to remove nonexistant instance %s", tostring(instance))
+	end
+end
+
+function InstanceMap:destroyId(id)
+	local instance = self.fromIds[id]
+	self:removeId(id)
+
+	if instance ~= nil then
+		local descendantsToDestroy = {}
+
+		for otherInstance in pairs(self.fromInstances) do
+			if otherInstance:IsDescendantOf(instance) then
+				table.insert(descendantsToDestroy, otherInstance)
+			end
+		end
+
+		for _, otherInstance in ipairs(descendantsToDestroy) do
+			self:removeInstance(otherInstance)
+		end
+
+		instance:Destroy()
+	else
+		Logging.warn("Attempted to destroy nonexistant ID %s", tostring(id))
+	end
+end
+
+return InstanceMap
--- a/plugin/src/Reconciler.lua
+++ b/plugin/src/Reconciler.lua
@@ -1,108 +1,14 @@
+local InstanceMap = require(script.Parent.InstanceMap)
 local Logging = require(script.Parent.Logging)
-
-local function makeInstanceMap()
-	local self = {
-		fromIds = {},
-		fromInstances = {},
-	}
-
-	function self:insert(id, instance)
-		self.fromIds[id] = instance
-		self.fromInstances[instance] = id
-	end
-
-	function self:removeId(id)
-		local instance = self.fromIds[id]
-
-		if instance ~= nil then
-			self.fromIds[id] = nil
-			self.fromInstances[instance] = nil
-		else
-			Logging.warn("Attempted to remove nonexistant ID %s", tostring(id))
-		end
-	end
-
-	function self:removeInstance(instance)
-		local id = self.fromInstances[instance]
-
-		if id ~= nil then
-			self.fromInstances[instance] = nil
-			self.fromIds[id] = nil
-		else
-			Logging.warn("Attempted to remove nonexistant instance %s", tostring(instance))
-		end
-	end
-
-	function self:destroyId(id)
-		local instance = self.fromIds[id]
-		self:removeId(id)
-
-		if instance ~= nil then
-			local descendantsToDestroy = {}
-
-			for otherInstance in pairs(self.fromInstances) do
-				if otherInstance:IsDescendantOf(instance) then
-					table.insert(descendantsToDestroy, otherInstance)
-				end
-			end
-
-			for _, otherInstance in ipairs(descendantsToDestroy) do
-				self:removeInstance(otherInstance)
-			end
-
-			instance:Destroy()
-		else
-			Logging.warn("Attempted to destroy nonexistant ID %s", tostring(id))
-		end
-	end
-
-	return self
-end
-
-local function setProperty(instance, key, value)
-	-- The 'Contents' property of LocalizationTable isn't directly exposed, but
-	-- has corresponding (deprecated) getters and setters.
-	if key == "Contents" and instance.ClassName == "LocalizationTable" then
-		instance:SetContents(value)
-		return
-	end
-
-	-- If we don't have permissions to access this value at all, we can skip it.
-	local readSuccess, existingValue = pcall(function()
-		return instance[key]
-	end)
-
-	if not readSuccess then
-		-- An error will be thrown if there was a permission issue or if the
-		-- property doesn't exist. In the latter case, we should tell the user
-		-- because it's probably their fault.
-		if existingValue:find("lacking permission") then
-			Logging.trace("Permission error reading property %s on class %s", tostring(key), instance.ClassName)
-			return
-		else
-			error(("Invalid property %s on class %s: %s"):format(tostring(key), instance.ClassName, existingValue), 2)
-		end
-	end
-
-	local writeSuccess, err = pcall(function()
-		if existingValue ~= value then
-			instance[key] = value
-		end
-	end)
-
-	if not writeSuccess then
-		error(("Cannot set property %s on class %s: %s"):format(tostring(key), instance.ClassName, err), 2)
-	end
-
-	return true
-end
+local setProperty = require(script.Parent.setProperty)
+local rojoValueToRobloxValue = require(script.Parent.rojoValueToRobloxValue)

 local Reconciler = {}
 Reconciler.__index = Reconciler

 function Reconciler.new()
 	local self = {
-		instanceMap = makeInstanceMap(),
+		instanceMap = InstanceMap.new(),
 	}

 	return setmetatable(self, Reconciler)
@@ -140,7 +46,7 @@ function Reconciler:reconcile(virtualInstancesById, id, instance)
 	setProperty(instance, "Name", virtualInstance.Name)

 	for key, value in pairs(virtualInstance.Properties) do
-		setProperty(instance, key, value.Value)
+		setProperty(instance, key, rojoValueToRobloxValue(value))
 	end

 	local existingChildren = instance:GetChildren()
@@ -195,9 +101,6 @@ function Reconciler:reconcile(virtualInstancesById, id, instance)
 		-- Some instances, like services, don't like having their Parent
 		-- property poked, even if we're setting it to the same value.
 		setProperty(instance, "Parent", parent)
-		if instance.Parent ~= parent then
-			instance.Parent = parent
-		end
 	end

 	return instance
@@ -217,8 +120,7 @@ function Reconciler:__reify(virtualInstancesById, id, parent)
 	local instance = Instance.new(virtualInstance.ClassName)

 	for key, value in pairs(virtualInstance.Properties) do
-		-- TODO: Branch on value.Type
-		setProperty(instance, key, value.Value)
+		setProperty(instance, key, rojoValueToRobloxValue(value))
 	end

 	instance.Name = virtualInstance.Name
--- a/plugin/src/preloadAssets.lua
+++ b/plugin/src/preloadAssets.lua
@@ -0,0 +1,28 @@
+local ContentProvider = game:GetService("ContentProvider")
+
+local Logging = require(script.Parent.Logging)
+local Assets = require(script.Parent.Assets)
+
+local function preloadAssets()
+	local contentUrls = {}
+
+	for _, sprite in pairs(Assets.Sprites) do
+		table.insert(contentUrls, sprite.asset)
+	end
+
+	for _, slice in pairs(Assets.Slices) do
+		table.insert(contentUrls, slice.asset)
+	end
+
+	for _, url in pairs(Assets.Images) do
+		table.insert(contentUrls, url)
+	end
+
+	Logging.trace("Preloading assets: %s", table.concat(contentUrls, ", "))
+
+	coroutine.wrap(function()
+		ContentProvider:PreloadAsync(contentUrls)
+	end)()
+end
+
+return preloadAssets
--- a/plugin/src/rojoValueToRobloxValue.lua
+++ b/plugin/src/rojoValueToRobloxValue.lua
@@ -0,0 +1,32 @@
+local primitiveTypes = {
+	String = true,
+	Bool = true,
+	Int32 = true,
+	Float32 = true,
+	Enum = true,
+}
+
+local directConstructors = {
+	CFrame = CFrame.new,
+	Color3 = Color3.new,
+	Vector2 = Vector2.new,
+	Vector2int16 = Vector2int16.new,
+	Vector3 = Vector3.new,
+	Vector3int16 = Vector3int16.new,
+}
+
+local function rojoValueToRobloxValue(value)
+	if primitiveTypes[value.Type] then
+		return value.Value
+	end
+
+	local constructor = directConstructors[value.Type]
+	if constructor ~= nil then
+		return constructor(unpack(value.Value))
+	end
+
+	local errorMessage = ("The Rojo plugin doesn't know how to handle values of type %q yet!"):format(tostring(value.Type))
+	error(errorMessage)
+end
+
+return rojoValueToRobloxValue
--- a/plugin/src/rojoValueToRobloxValue.spec.lua
+++ b/plugin/src/rojoValueToRobloxValue.spec.lua
@@ -0,0 +1,40 @@
+local rojoValueToRobloxValue = require(script.Parent.rojoValueToRobloxValue)
+
+return function()
+	it("should convert primitives", function()
+		local inputString = {
+			Type = "String",
+			Value = "Hello, world!",
+		}
+
+		local inputFloat32 = {
+			Type = "Float32",
+			Value = 12341.512,
+		}
+
+		expect(rojoValueToRobloxValue(inputString)).to.equal(inputString.Value)
+		expect(rojoValueToRobloxValue(inputFloat32)).to.equal(inputFloat32.Value)
+	end)
+
+	it("should convert properties with direct constructors", function()
+		local inputColor3 = {
+			Type = "Color3",
+			Value = {0, 1, 0.5},
+		}
+		local outputColor3 = Color3.new(0, 1, 0.5)
+
+		local inputCFrame = {
+			Type = "CFrame",
+			Value = {
+				1, 2, 3,
+				4, 5, 6,
+				7, 8, 9,
+				10, 11, 12,
+			},
+		}
+		local outputCFrame = CFrame.new(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
+
+		expect(rojoValueToRobloxValue(inputColor3)).to.equal(outputColor3)
+		expect(rojoValueToRobloxValue(inputCFrame)).to.equal(outputCFrame)
+	end)
+end
--- a/plugin/src/setProperty.lua
+++ b/plugin/src/setProperty.lua
@@ -0,0 +1,45 @@
+local Logging = require(script.Parent.Logging)
+
+--[[
+	Attempts to set a property on the given instance, correctly handling
+	'virtual properties', which aren't reflected directly to Lua.
+]]
+local function setProperty(instance, key, value)
+	-- The 'Contents' property of LocalizationTable isn't directly exposed, but
+	-- has corresponding (deprecated) getters and setters.
+	if instance.ClassName == "LocalizationTable" and key == "Contents" then
+		instance:SetContents(value)
+		return
+	end
+
+	-- If we don't have permissions to access this value at all, we can skip it.
+	local readSuccess, existingValue = pcall(function()
+		return instance[key]
+	end)
+
+	if not readSuccess then
+		-- An error will be thrown if there was a permission issue or if the
+		-- property doesn't exist. In the latter case, we should tell the user
+		-- because it's probably their fault.
+		if existingValue:find("lacking permission") then
+			Logging.trace("Permission error reading property %s on class %s", tostring(key), instance.ClassName)
+			return
+		else
+			error(("Invalid property %s on class %s: %s"):format(tostring(key), instance.ClassName, existingValue), 2)
+		end
+	end
+
+	local writeSuccess, err = pcall(function()
+		if existingValue ~= value then
+			instance[key] = value
+		end
+	end)
+
+	if not writeSuccess then
+		error(("Cannot set property %s on class %s: %s"):format(tostring(key), instance.ClassName, err), 2)
+	end
+
+	return true
+end
+
+return setProperty
--- a/plugin/testBootstrap.server.lua
+++ b/plugin/testBootstrap.server.lua
@@ -1,2 +1,2 @@
 local TestEZ = require(game.ReplicatedStorage.TestEZ)
-TestEZ.TestBootstrap:run(game.ReplicatedStorage.Rojo.plugin)
+TestEZ.TestBootstrap:run({game.ReplicatedStorage.Rojo.Plugin})
--- a/server/Cargo.toml
+++ b/server/Cargo.toml
@@ -1,12 +1,16 @@
 [package]
 name = "rojo"
-version = "0.5.0-alpha.3"
+version = "0.5.0-alpha.5"
 authors = ["Lucien Greathouse <me@lpghatguy.com>"]
 description = "A tool to create robust Roblox projects"
 license = "MIT"
 repository = "https://github.com/LPGhatguy/rojo"
 edition = "2018"

+[features]
+default = []
+server-plugins = []
+
 [lib]
 name = "librojo"
 path = "src/lib.rs"
@@ -15,31 +19,33 @@ path = "src/lib.rs"
 name = "rojo"
 path = "src/bin.rs"

-[features]
-default = []
-bundle-plugin = []
-
 [dependencies]
 clap = "2.27"
 csv = "1.0"
 env_logger = "0.6"
 failure = "0.1.3"
+futures = "0.1"
+hyper = "0.12"
 log = "0.4"
 maplit = "1.0.1"
 notify = "4.0"
 rand = "0.4"
+rbx_binary = "0.4.0"
+rbx_dom_weak = "1.0.0"
+rbx_xml = "0.4.0"
+rbx_reflection = "2.0.374"
 regex = "1.0"
 reqwest = "0.9.5"
-rouille = "2.1"
+rlua = "0.16"
+ritz = "0.1.0"
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
 uuid = { version = "0.7", features = ["v4", "serde"] }
-rbx_tree = "0.2.0"
-rbx_xml = "0.2.0"
-rbx_binary = "0.2.0"

 [dev-dependencies]
 tempfile = "3.0"
 walkdir = "2.1"
-lazy_static = "1.2"
+lazy_static = "1.2"
+pretty_assertions = "0.5.1"
+paste = "0.1"
--- a/server/assets/index.css
+++ b/server/assets/index.css
@@ -0,0 +1,43 @@
+* {
+  margin: 0;
+  padding: 0;
+  font: inherit;
+}
+
+html {
+  font-family: sans-serif;
+  height: 100%;
+}
+
+body {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+}
+
+.main {
+  padding: 1rem;
+  text-align: center;
+  margin: 0 auto;
+  width: 100%;
+  max-width: 60rem;
+  background-color: #efefef;
+  border: 1px solid #666;
+  border-radius: 4px;
+}
+
+.title {
+  font-size: 2rem;
+  font-weight: bold;
+}
+
+.subtitle {
+  font-size: 1.5rem;
+  font-weight: bold;
+}
+
+.docs {
+  font-size: 1.3rem;
+  font-weight: bold;
+}
--- a/server/assets/index.html
+++ b/server/assets/index.html
@@ -1,54 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-	<title>Rojo</title>
-	<style>
-		* {
-			margin: 0;
-			padding: 0;
-			font: inherit;
-		}
-
-		html {
-			font-family: sans-serif;
-			height: 100%;
-		}
-
-		body {
-			height: 100%;
-			display: flex;
-			flex-direction: column;
-			justify-content: center;
-		}
-
-		.main {
-			padding: 1rem;
-			text-align: center;
-			margin: 0 auto;
-			width: 100%;
-			max-width: 60rem;
-			background-color: #efefef;
-			border: 1px solid #666;
-			border-radius: 4px;
-		}
-
-		.title {
-			font-size: 2rem;
-			font-weight: bold;
-		}
-
-		.docs {
-			font-size: 1.5rem;
-			font-weight: bold;
-		}
-	</style>
-</head>
-<body>
-
-<div class="main">
-	<h1 class="title">Rojo Live Sync is up and running!</h1>
-	<a class="docs" href="https://lpghatguy.github.io/rojo">Rojo Documentation</a>
-</div>
-
-</body>
-</html>
--- a/server/src/commands/build.rs
+++ b/server/src/commands/build.rs
@@ -8,9 +8,10 @@ use log::info;
 use failure::Fail;

 use crate::{
-    rbx_session::construct_oneoff_tree,
-    project::{Project, ProjectLoadFuzzyError},
    imfs::{Imfs, FsError},
+    project::{Project, ProjectLoadFuzzyError},
+    rbx_session::construct_oneoff_tree,
+    rbx_snapshot::SnapshotError,
 };

 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -59,6 +60,9 @@ pub enum BuildError {

    #[fail(display = "{}", _0)]
    FsError(#[fail(cause)] FsError),
+
+    #[fail(display = "{}", _0)]
+    SnapshotError(#[fail(cause)] SnapshotError),
 }

 impl_from!(BuildError {
@@ -67,6 +71,7 @@ impl_from!(BuildError {
    rbx_xml::EncodeError => XmlModelEncodeError,
    rbx_binary::EncodeError => BinaryModelEncodeError,
    FsError => FsError,
+    SnapshotError => SnapshotError,
 });

 pub fn build(options: &BuildOptions) -> Result<(), BuildError> {
@@ -86,7 +91,7 @@ pub fn build(options: &BuildOptions) -> Result<(), BuildError> {

    let mut imfs = Imfs::new();
    imfs.add_roots_from_project(&project)?;
-    let tree = construct_oneoff_tree(&project, &imfs);
+    let tree = construct_oneoff_tree(&project, &imfs)?;
    let mut file = File::create(&options.output_file)?;

    match output_kind {
--- a/server/src/commands/serve.rs
+++ b/server/src/commands/serve.rs
@@ -8,9 +8,9 @@ use failure::Fail;

 use crate::{
    project::{Project, ProjectLoadFuzzyError},
-    web::Server,
+    web::LiveServer,
    imfs::FsError,
-    live_session::LiveSession,
+    live_session::{LiveSession, LiveSessionError},
 };

 const DEFAULT_PORT: u16 = 34872;
@@ -28,11 +28,15 @@ pub enum ServeError {

   #[fail(display = "{}", _0)]
   FsError(#[fail(cause)] FsError),
+
+   #[fail(display = "{}", _0)]
+   LiveSessionError(#[fail(cause)] LiveSessionError),
 }

 impl_from!(ServeError {
    ProjectLoadFuzzyError => ProjectLoadError,
    FsError => FsError,
+    LiveSessionError => LiveSessionError,
 });

 pub fn serve(options: &ServeOptions) -> Result<(), ServeError> {
@@ -45,7 +49,7 @@ pub fn serve(options: &ServeOptions) -> Result<(), ServeError> {
    info!("Using project {:#?}", project);

    let live_session = Arc::new(LiveSession::new(Arc::clone(&project))?);
-    let server = Server::new(Arc::clone(&live_session));
+    let server = LiveServer::new(live_session);

    let port = options.port
        .or(project.serve_port)
@@ -53,7 +57,7 @@ pub fn serve(options: &ServeOptions) -> Result<(), ServeError> {

    println!("Rojo server listening on port {}", port);

-    server.listen(port);
+    server.start(port);

    Ok(())
 }
--- a/server/src/commands/upload.rs
+++ b/server/src/commands/upload.rs
@@ -9,9 +9,10 @@ use failure::Fail;
 use reqwest::header::{ACCEPT, USER_AGENT, CONTENT_TYPE, COOKIE};

 use crate::{
-    rbx_session::construct_oneoff_tree,
-    project::{Project, ProjectLoadFuzzyError},
    imfs::{Imfs, FsError},
+    project::{Project, ProjectLoadFuzzyError},
+    rbx_session::construct_oneoff_tree,
+    rbx_snapshot::SnapshotError,
 };

 #[derive(Debug, Fail)]
@@ -36,6 +37,9 @@ pub enum UploadError {

    #[fail(display = "{}", _0)]
    FsError(#[fail(cause)] FsError),
+
+    #[fail(display = "{}", _0)]
+    SnapshotError(#[fail(cause)] SnapshotError),
 }

 impl_from!(UploadError {
@@ -44,6 +48,7 @@ impl_from!(UploadError {
    reqwest::Error => HttpError,
    rbx_xml::EncodeError => XmlModelEncodeError,
    FsError => FsError,
+    SnapshotError => SnapshotError,
 });

 #[derive(Debug)]
@@ -67,7 +72,7 @@ pub fn upload(options: &UploadOptions) -> Result<(), UploadError> {

    let mut imfs = Imfs::new();
    imfs.add_roots_from_project(&project)?;
-    let tree = construct_oneoff_tree(&project, &imfs);
+    let tree = construct_oneoff_tree(&project, &imfs)?;

    let root_id = tree.get_root_id();
    let mut contents = Vec::new();
--- a/server/src/fs_watcher.rs
+++ b/server/src/fs_watcher.rs
@@ -44,13 +44,14 @@ impl FsWatcher {
            let imfs = imfs.lock().unwrap();

            for root_path in imfs.get_roots() {
+                trace!("Watching path {}", root_path.display());
                watcher.watch(root_path, RecursiveMode::Recursive)
                    .expect("Could not watch directory");
            }
        }

        {
-           let imfs = Arc::clone(&imfs);
+            let imfs = Arc::clone(&imfs);
            let rbx_session = rbx_session.as_ref().map(Arc::clone);

            thread::spawn(move || {
--- a/server/src/imfs.rs
+++ b/server/src/imfs.rs
@@ -35,16 +35,13 @@ impl fmt::Display for FsError {
    }
 }

-fn add_sync_points(imfs: &mut Imfs, project_node: &ProjectNode) -> Result<(), FsError> {
-    match project_node {
-        ProjectNode::Instance(node) => {
-            for child in node.children.values() {
-                add_sync_points(imfs, child)?;
-            }
-        },
-        ProjectNode::SyncPoint(node) => {
-            imfs.add_root(&node.path)?;
-        },
+fn add_sync_points(imfs: &mut Imfs, node: &ProjectNode) -> Result<(), FsError> {
+    if let Some(path) = &node.path {
+        imfs.add_root(path)?;
+    }
+
+    for child in node.children.values() {
+        add_sync_points(imfs, child)?;
    }

    Ok(())
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@@ -1,3 +1,5 @@
+#![recursion_limit="128"]
+
 // Macros
 #[macro_use]
 pub mod impl_from;
@@ -6,14 +8,14 @@ pub mod impl_from;
 pub mod commands;
 pub mod fs_watcher;
 pub mod imfs;
+pub mod live_session;
 pub mod message_queue;
 pub mod path_map;
+pub mod path_serializer;
 pub mod project;
 pub mod rbx_session;
 pub mod rbx_snapshot;
-pub mod live_session;
 pub mod session_id;
 pub mod snapshot_reconciler;
 pub mod visualize;
-pub mod web;
-pub mod web_util;
+pub mod web;
--- a/server/src/live_session.rs
+++ b/server/src/live_session.rs
@@ -1,21 +1,40 @@
 use std::{
+    collections::HashSet,
+    mem,
    sync::{Arc, Mutex},
 };

+use failure::Fail;
+
 use crate::{
    fs_watcher::FsWatcher,
    imfs::{Imfs, FsError},
    message_queue::MessageQueue,
    project::Project,
    rbx_session::RbxSession,
+    rbx_snapshot::SnapshotError,
    session_id::SessionId,
    snapshot_reconciler::InstanceChanges,
 };

+#[derive(Debug, Fail)]
+pub enum LiveSessionError {
+    #[fail(display = "{}", _0)]
+    Fs(#[fail(cause)] FsError),
+
+    #[fail(display = "{}", _0)]
+    Snapshot(#[fail(cause)] SnapshotError),
+}
+
+impl_from!(LiveSessionError {
+    FsError => Fs,
+    SnapshotError => Snapshot,
+});
+
 /// Contains all of the state for a Rojo live-sync session.
 pub struct LiveSession {
-    pub project: Arc<Project>,
-    pub session_id: SessionId,
+    project: Arc<Project>,
+    session_id: SessionId,
    pub message_queue: Arc<MessageQueue<InstanceChanges>>,
    pub rbx_session: Arc<Mutex<RbxSession>>,
    pub imfs: Arc<Mutex<Imfs>>,
@@ -23,7 +42,7 @@ pub struct LiveSession {
 }

 impl LiveSession {
-    pub fn new(project: Arc<Project>) -> Result<LiveSession, FsError> {
+    pub fn new(project: Arc<Project>) -> Result<LiveSession, LiveSessionError> {
        let imfs = {
            let mut imfs = Imfs::new();
            imfs.add_roots_from_project(&project)?;
@@ -36,7 +55,7 @@ impl LiveSession {
            Arc::clone(&project),
            Arc::clone(&imfs),
            Arc::clone(&message_queue),
-        )));
+        )?));

        let fs_watcher = FsWatcher::start(
            Arc::clone(&imfs),
@@ -46,8 +65,8 @@ impl LiveSession {
        let session_id = SessionId::new();

        Ok(LiveSession {
-            project,
            session_id,
+            project,
            message_queue,
            rbx_session,
            imfs,
@@ -55,7 +74,22 @@ impl LiveSession {
        })
    }

-    pub fn get_project(&self) -> &Project {
-        &self.project
+    /// Restarts the live session using the given project while preserving the
+    /// internal session ID.
+    pub fn restart_with_new_project(&mut self, project: Arc<Project>) -> Result<(), LiveSessionError> {
+        let mut new_session = LiveSession::new(project)?;
+        new_session.session_id = self.session_id;
+
+        mem::replace(self, new_session);
+
+        Ok(())
+    }
+
+    pub fn session_id(&self) -> SessionId {
+        self.session_id
+    }
+
+    pub fn serve_place_ids(&self) -> &Option<HashSet<u64>> {
+        &self.project.serve_place_ids
    }
 }
--- a/server/src/path_map.rs
+++ b/server/src/path_map.rs
@@ -1,5 +1,4 @@
 use std::{
-    collections::hash_map,
    path::{self, Path, PathBuf},
    collections::{HashMap, HashSet},
 };
@@ -36,12 +35,6 @@ impl<T> PathMap<T> {
        self.nodes.get_mut(path).map(|v| &mut v.value)
    }

-    pub fn entry<'a>(&'a mut self, path: PathBuf) -> Entry<'a, T> {
-        Entry {
-            internal: self.nodes.entry(path),
-        }
-    }
-
    pub fn insert(&mut self, path: PathBuf, value: T) {
        if let Some(parent_path) = path.parent() {
            if let Some(parent) = self.nodes.get_mut(parent_path) {
@@ -116,28 +109,4 @@ impl<T> PathMap<T> {

        current_path
    }
-}
-
-pub struct Entry<'a, T> {
-    internal: hash_map::Entry<'a, PathBuf, PathMapNode<T>>,
-}
-
-impl<'a, T> Entry<'a, T> {
-    pub fn or_insert(self, value: T) -> &'a mut T {
-        &mut self.internal.or_insert(PathMapNode {
-            value,
-            children: HashSet::new(),
-        }).value
-    }
-}
-
-impl<'a, T> Entry<'a, T>
-    where T: Default
-{
-    pub fn or_default(self) -> &'a mut T {
-        &mut self.internal.or_insert(PathMapNode {
-            value: Default::default(),
-            children: HashSet::new(),
-        }).value
-    }
 }
--- a/server/src/path_serializer.rs
+++ b/server/src/path_serializer.rs
@@ -0,0 +1,69 @@
+//! path_serializer is used in cases where we need to serialize relative Path
+//! and PathBuf objects in a way that's cross-platform.
+//!
+//! This is used for the snapshot testing system to make sure that snapshots
+//! that reference local paths that are generated on Windows don't fail when run
+//! in systems that use a different directory separator.
+//!
+//! To use, annotate your PathBuf or Option<PathBuf> field with the correct
+//! serializer function:
+//!
+//! ```
+//! # use std::path::PathBuf;
+//! # use serde_derive::{Serialize, Deserialize};
+//!
+//! #[derive(Serialize, Deserialize)]
+//! struct Mine {
+//!     name: String,
+//!
+//!     // Use 'crate' instead of librojo if writing code inside Rojo
+//!     #[serde(serialize_with = "librojo::path_serializer::serialize")]
+//!     source_path: PathBuf,
+//!
+//!     #[serde(serialize_with = "librojo::path_serializer::serialize_option")]
+//!     maybe_path: Option<PathBuf>,
+//! }
+//! ```
+//!
+//! **The methods in this module can only handle relative paths, since absolute
+//! paths are never portable.**
+
+use std::path::{Component, Path};
+
+use serde::Serializer;
+
+pub fn serialize_option<S, T>(maybe_path: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
+    where S: Serializer,
+          T: AsRef<Path>,
+{
+    match maybe_path {
+        Some(path) => serialize(path, serializer),
+        None => serializer.serialize_none()
+    }
+}
+
+pub fn serialize<S, T>(path: T, serializer: S) -> Result<S::Ok, S::Error>
+    where S: Serializer,
+          T: AsRef<Path>,
+{
+    let path = path.as_ref();
+
+    assert!(path.is_relative(), "path_serializer can only handle relative paths");
+
+    let mut output = String::new();
+
+    for component in path.components() {
+        if !output.is_empty() {
+            output.push('/');
+        }
+
+        match component {
+            Component::CurDir => output.push('.'),
+            Component::ParentDir => output.push_str(".."),
+            Component::Normal(piece) => output.push_str(piece.to_str().unwrap()),
+            _ => panic!("path_serializer cannot handle absolute path components"),
+        }
+    }
+
+    serializer.serialize_str(&output)
+}
--- a/server/src/project.rs
+++ b/server/src/project.rs
@@ -9,22 +9,12 @@ use std::{
 use log::warn;
 use failure::Fail;
 use maplit::hashmap;
-use rbx_tree::RbxValue;
+use rbx_dom_weak::{UnresolvedRbxValue, RbxValue};
 use serde_derive::{Serialize, Deserialize};

 pub static PROJECT_FILENAME: &'static str = "default.project.json";
 pub static COMPAT_PROJECT_FILENAME: &'static str = "roblox-project.json";

-// Methods used for Serde's default value system, which doesn't support using
-// value literals directly, only functions that return values.
-const fn yeah() -> bool {
-    true
-}
-
-const fn is_true(value: &bool) -> bool {
-    *value
-}
-
 /// SourceProject is the format that users author projects on-disk. Since we
 /// want to do things like transforming paths to be absolute before handing them
 /// off to the rest of Rojo, we use this intermediate struct.
@@ -34,6 +24,10 @@ struct SourceProject {
    name: String,
    tree: SourceProjectNode,

+    #[cfg_attr(not(feature = "plugins-enabled"), serde(skip_deserializing))]
+    #[serde(default = "Vec::new", skip_serializing_if = "Vec::is_empty")]
+    plugins: Vec<SourcePlugin>,
+
    #[serde(skip_serializing_if = "Option::is_none")]
    serve_port: Option<u16>,

@@ -43,12 +37,17 @@ struct SourceProject {

 impl SourceProject {
    /// Consumes the SourceProject and yields a Project, ready for prime-time.
-    pub fn into_project(self, project_file_location: &Path) -> Project {
+    pub fn into_project(mut self, project_file_location: &Path) -> Project {
        let tree = self.tree.into_project_node(project_file_location);
+        let plugins = self.plugins
+            .drain(..)
+            .map(|source_plugin| source_plugin.into_plugin(project_file_location))
+            .collect();

        Project {
            name: self.name,
            tree,
+            plugins,
            serve_port: self.serve_port,
            serve_place_ids: self.serve_place_ids,
            file_location: PathBuf::from(project_file_location),
@@ -60,59 +59,67 @@ impl SourceProject {
 /// slightly different on-disk than how we want to handle them in the rest of
 /// Rojo.
 #[derive(Debug, Serialize, Deserialize)]
-#[serde(untagged)]
-enum SourceProjectNode {
-    Instance {
-        #[serde(rename = "$className")]
-        class_name: String,
+struct SourceProjectNode {
+    #[serde(rename = "$className", skip_serializing_if = "Option::is_none")]
+    class_name: Option<String>,

-        #[serde(rename = "$properties", default = "HashMap::new", skip_serializing_if = "HashMap::is_empty")]
-        properties: HashMap<String, RbxValue>,
+    #[serde(rename = "$properties", default = "HashMap::new", skip_serializing_if = "HashMap::is_empty")]
+    properties: HashMap<String, UnresolvedRbxValue>,

-        #[serde(rename = "$ignoreUnknownInstances", default = "yeah", skip_serializing_if = "is_true")]
-        ignore_unknown_instances: bool,
+    #[serde(rename = "$ignoreUnknownInstances", skip_serializing_if = "Option::is_none")]
+    ignore_unknown_instances: Option<bool>,

-        #[serde(flatten)]
-        children: HashMap<String, SourceProjectNode>,
-    },
-    SyncPoint {
-        #[serde(rename = "$path")]
-        path: String,
-    }
+    #[serde(rename = "$path", skip_serializing_if = "Option::is_none")]
+    path: Option<String>,
+
+    #[serde(flatten)]
+    children: HashMap<String, SourceProjectNode>,
 }

 impl SourceProjectNode {
    /// Consumes the SourceProjectNode and turns it into a ProjectNode.
-    pub fn into_project_node(self, project_file_location: &Path) -> ProjectNode {
-        match self {
-            SourceProjectNode::Instance { class_name, mut children, properties, ignore_unknown_instances } => {
-                let mut new_children = HashMap::new();
+    pub fn into_project_node(mut self, project_file_location: &Path) -> ProjectNode {
+        let children = self.children.drain()
+            .map(|(key, value)| (key, value.into_project_node(project_file_location)))
+            .collect();

-                for (node_name, node) in children.drain() {
-                    new_children.insert(node_name, node.into_project_node(project_file_location));
-                }
+        // Make sure that paths are absolute, transforming them by adding the
+        // project folder if they're not already absolute.
+        let path = self.path.as_ref().map(|source_path| {
+            if Path::new(source_path).is_absolute() {
+                PathBuf::from(source_path)
+            } else {
+                let project_folder_location = project_file_location.parent().unwrap();
+                project_folder_location.join(source_path)
+            }
+        });

-                ProjectNode::Instance(InstanceProjectNode {
-                    class_name,
-                    children: new_children,
-                    properties,
-                    metadata: InstanceProjectNodeMetadata {
-                        ignore_unknown_instances,
-                    },
-                })
-            },
-            SourceProjectNode::SyncPoint { path: source_path } => {
-                let path = if Path::new(&source_path).is_absolute() {
-                    PathBuf::from(source_path)
-                } else {
-                    let project_folder_location = project_file_location.parent().unwrap();
-                    project_folder_location.join(source_path)
-                };
+        ProjectNode {
+            class_name: self.class_name,
+            properties: self.properties,
+            ignore_unknown_instances: self.ignore_unknown_instances,
+            path,
+            children,
+        }
+    }
+}

-                ProjectNode::SyncPoint(SyncPointProjectNode {
-                    path,
-                })
-            },
+#[derive(Debug, Serialize, Deserialize)]
+struct SourcePlugin {
+    path: String,
+}
+
+impl SourcePlugin {
+    pub fn into_plugin(self, project_file_location: &Path) -> Plugin {
+        let path = if Path::new(&self.path).is_absolute() {
+            PathBuf::from(self.path)
+        } else {
+            let project_folder_location = project_file_location.parent().unwrap();
+            project_folder_location.join(self.path)
+        };
+
+        Plugin {
+            path,
        }
    }
 }
@@ -177,79 +184,73 @@ pub enum ProjectSaveError {
    IoError(#[fail(cause)] io::Error),
 }

-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct InstanceProjectNodeMetadata {
-    pub ignore_unknown_instances: bool,
-}
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+pub struct ProjectNode {
+    pub class_name: Option<String>,
+    pub children: HashMap<String, ProjectNode>,
+    pub properties: HashMap<String, UnresolvedRbxValue>,
+    pub ignore_unknown_instances: Option<bool>,

-impl Default for InstanceProjectNodeMetadata {
-    fn default() -> InstanceProjectNodeMetadata {
-        InstanceProjectNodeMetadata {
-            ignore_unknown_instances: true,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "type")]
-pub enum ProjectNode {
-    Instance(InstanceProjectNode),
-    SyncPoint(SyncPointProjectNode),
+    #[serde(serialize_with = "crate::path_serializer::serialize_option")]
+    pub path: Option<PathBuf>,
 }

 impl ProjectNode {
    fn to_source_node(&self, project_file_location: &Path) -> SourceProjectNode {
-        match self {
-            ProjectNode::Instance(node) => {
-                let mut children = HashMap::new();
+        let children = self.children.iter()
+            .map(|(key, value)| (key.clone(), value.to_source_node(project_file_location)))
+            .collect();

-                for (key, child) in &node.children {
-                    children.insert(key.clone(), child.to_source_node(project_file_location));
-                }
+        // If paths are relative to the project file, transform them to look
+        // Unixy and write relative paths instead.
+        //
+        // This isn't perfect, since it means that paths like .. will stay as
+        // absolute paths and make projects non-portable. Fixing this probably
+        // means keeping the paths relative in the project format and making
+        // everywhere else in Rojo do the resolution locally.
+        let path = self.path.as_ref().map(|path| {
+            let project_folder_location = project_file_location.parent().unwrap();

-                SourceProjectNode::Instance {
-                    class_name: node.class_name.clone(),
-                    children,
-                    properties: node.properties.clone(),
-                    ignore_unknown_instances: node.metadata.ignore_unknown_instances,
-                }
-            },
-            ProjectNode::SyncPoint(sync_node) => {
-                let project_folder_location = project_file_location.parent().unwrap();
+            match path.strip_prefix(project_folder_location) {
+                Ok(stripped) => stripped.to_str().unwrap().replace("\\", "/"),
+                Err(_) => format!("{}", path.display()),
+            }
+        });

-                let friendly_path = match sync_node.path.strip_prefix(project_folder_location) {
-                    Ok(stripped) => stripped.to_str().unwrap().replace("\\", "/"),
-                    Err(_) => format!("{}", sync_node.path.display()),
-                };
-
-                SourceProjectNode::SyncPoint {
-                    path: friendly_path,
-                }
-            },
+        SourceProjectNode {
+            class_name: self.class_name.clone(),
+            properties: self.properties.clone(),
+            ignore_unknown_instances: self.ignore_unknown_instances,
+            children,
+            path,
        }
    }
 }

 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct InstanceProjectNode {
-    pub class_name: String,
-    pub children: HashMap<String, ProjectNode>,
-    pub properties: HashMap<String, RbxValue>,
-    pub metadata: InstanceProjectNodeMetadata,
+pub struct Plugin {
+    pub path: PathBuf,
 }

-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SyncPointProjectNode {
-    pub path: PathBuf,
+impl Plugin {
+    fn to_source_plugin(&self, project_file_location: &Path) -> SourcePlugin {
+        let project_folder_location = project_file_location.parent().unwrap();
+        let path = match self.path.strip_prefix(project_folder_location) {
+            Ok(stripped) => stripped.to_str().unwrap().replace("\\", "/"),
+            Err(_) => format!("{}", self.path.display()),
+        };
+
+        SourcePlugin {
+            path,
+        }
+    }
 }

 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Project {
    pub name: String,
    pub tree: ProjectNode,
+    pub plugins: Vec<Plugin>,
    pub serve_port: Option<u16>,
    pub serve_place_ids: Option<HashSet<u64>>,
    pub file_location: PathBuf,
@@ -265,37 +266,36 @@ impl Project {
            project_fuzzy_path.file_name().unwrap().to_str().unwrap()
        };

-        let tree = ProjectNode::Instance(InstanceProjectNode {
-            class_name: "DataModel".to_string(),
+        let tree = ProjectNode {
+            class_name: Some(String::from("DataModel")),
            children: hashmap! {
-                String::from("ReplicatedStorage") => ProjectNode::Instance(InstanceProjectNode {
-                    class_name: String::from("ReplicatedStorage"),
+                String::from("ReplicatedStorage") => ProjectNode {
+                    class_name: Some(String::from("ReplicatedStorage")),
                    children: hashmap! {
-                        String::from("Source") => ProjectNode::SyncPoint(SyncPointProjectNode {
-                            path: project_folder_path.join("src"),
-                        }),
+                        String::from("Source") => ProjectNode {
+                            path: Some(project_folder_path.join("src")),
+                            ..Default::default()
+                        },
                    },
-                    properties: HashMap::new(),
-                    metadata: Default::default(),
-                }),
-                String::from("HttpService") => ProjectNode::Instance(InstanceProjectNode {
-                    class_name: String::from("HttpService"),
-                    children: HashMap::new(),
+                    ..Default::default()
+                },
+                String::from("HttpService") => ProjectNode {
+                    class_name: Some(String::from("HttpService")),
                    properties: hashmap! {
                        String::from("HttpEnabled") => RbxValue::Bool {
                            value: true,
-                        },
+                        }.into(),
                    },
-                    metadata: Default::default(),
-                }),
+                    ..Default::default()
+                },
            },
-            properties: HashMap::new(),
-            metadata: Default::default(),
-        });
+            ..Default::default()
+        };

        let project = Project {
            name: project_name.to_string(),
            tree,
+            plugins: Vec::new(),
            serve_port: None,
            serve_place_ids: None,
            file_location: project_path.clone(),
@@ -316,13 +316,15 @@ impl Project {
            project_fuzzy_path.file_name().unwrap().to_str().unwrap()
        };

-        let tree = ProjectNode::SyncPoint(SyncPointProjectNode {
-            path: project_folder_path.join("src"),
-        });
+        let tree = ProjectNode {
+            path: Some(project_folder_path.join("src")),
+            ..Default::default()
+        };

        let project = Project {
            name: project_name.to_string(),
            tree,
+            plugins: Vec::new(),
            serve_port: None,
            serve_place_ids: None,
            file_location: project_path.clone(),
@@ -433,9 +435,15 @@ impl Project {
    }

    fn to_source_project(&self) -> SourceProject {
+        let plugins = self.plugins
+            .iter()
+            .map(|plugin| plugin.to_source_plugin(&self.file_location))
+            .collect();
+
        SourceProject {
            name: self.name.clone(),
            tree: self.tree.to_source_node(&self.file_location),
+            plugins,
            serve_port: self.serve_port,
            serve_place_ids: self.serve_place_ids.clone(),
        }
--- a/server/src/rbx_session.rs
+++ b/server/src/rbx_session.rs
@@ -1,21 +1,30 @@
 use std::{
    borrow::Cow,
-    collections::HashMap,
+    collections::{HashSet, HashMap},
    path::{Path, PathBuf},
    str,
    sync::{Arc, Mutex},
 };

+use rlua::Lua;
 use serde_derive::{Serialize, Deserialize};
-use log::{info, trace};
-use rbx_tree::{RbxTree, RbxId};
+use log::{info, trace, error};
+use rbx_dom_weak::{RbxTree, RbxId};

 use crate::{
-    project::Project,
+    project::{Project, ProjectNode},
    message_queue::MessageQueue,
    imfs::{Imfs, ImfsItem},
    path_map::PathMap,
-    rbx_snapshot::{SnapshotContext, snapshot_project_tree, snapshot_imfs_path},
+    rbx_snapshot::{
+        SnapshotError,
+        SnapshotContext,
+        SnapshotPluginContext,
+        SnapshotPluginEntry,
+        snapshot_project_tree,
+        snapshot_project_node,
+        snapshot_imfs_path,
+    },
    snapshot_reconciler::{InstanceChanges, reify_root, reconcile_subtree},
 };

@@ -23,24 +32,31 @@ const INIT_SCRIPT: &str = "init.lua";
 const INIT_SERVER_SCRIPT: &str = "init.server.lua";
 const INIT_CLIENT_SCRIPT: &str = "init.client.lua";

-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
-pub struct MetadataPerPath {
-    pub instance_id: Option<RbxId>,
-    pub instance_name: Option<String>,
-}
-
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+/// `source_path` or `project_definition` or both must both be Some.
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
 pub struct MetadataPerInstance {
-    pub source_path: Option<PathBuf>,
    pub ignore_unknown_instances: bool,
+
+    /// The path on the filesystem that the instance was read from the
+    /// filesystem if it came from the filesystem.
+    #[serde(serialize_with = "crate::path_serializer::serialize_option")]
+    pub source_path: Option<PathBuf>,
+
+    /// Information about the instance that came from the project that defined
+    /// it, if that's where it was defined.
+    ///
+    /// A key-value pair where the key should be the name of the instance and
+    /// the value is the ProjectNode from the instance's project.
+    pub project_definition: Option<(String, ProjectNode)>,
 }

+/// Contains all of the state needed to update an `RbxTree` in real time using
+/// the in-memory filesystem, as well as messaging to Rojo clients what
+/// instances have actually updated at any point.
 pub struct RbxSession {
    tree: RbxTree,

-    // TODO(#105): Change metadata_per_path to PathMap<Vec<MetadataPerPath>> for
-    // path aliasing.
-    metadata_per_path: PathMap<MetadataPerPath>,
+    instances_per_path: PathMap<HashSet<RbxId>>,
    metadata_per_instance: HashMap<RbxId, MetadataPerInstance>,
    message_queue: Arc<MessageQueue<InstanceChanges>>,
    imfs: Arc<Mutex<Imfs>>,
@@ -51,22 +67,60 @@ impl RbxSession {
        project: Arc<Project>,
        imfs: Arc<Mutex<Imfs>>,
        message_queue: Arc<MessageQueue<InstanceChanges>>,
-    ) -> RbxSession {
-        let mut metadata_per_path = PathMap::new();
+    ) -> Result<RbxSession, SnapshotError> {
+        let mut instances_per_path = PathMap::new();
        let mut metadata_per_instance = HashMap::new();

+        let plugin_context = if cfg!(feature = "server-plugins") {
+            let lua = Lua::new();
+            let mut callback_key = None;
+
+            lua.context(|context| {
+                let callback = context.load(r#"
+                    return function(snapshot)
+                        print("got my snapshot:", snapshot)
+                        print("name:", snapshot.name, "class name:", snapshot.className)
+                    end"#)
+                    .set_name("a cool plugin").unwrap()
+                    .call::<(), rlua::Function>(()).unwrap();
+
+                callback_key = Some(context.create_registry_value(callback).unwrap());
+            });
+
+            let plugins = vec![
+                SnapshotPluginEntry {
+                    file_name_filter: String::new(),
+                    callback: callback_key.unwrap(),
+                }
+            ];
+
+            Some(SnapshotPluginContext { lua, plugins })
+        } else {
+            None
+        };
+
+        let context = SnapshotContext {
+            plugin_context,
+        };
+
        let tree = {
            let temp_imfs = imfs.lock().unwrap();
-            reify_initial_tree(&project, &temp_imfs, &mut metadata_per_path, &mut metadata_per_instance)
+            reify_initial_tree(
+                &project,
+                &context,
+                &temp_imfs,
+                &mut instances_per_path,
+                &mut metadata_per_instance,
+            )?
        };

-        RbxSession {
+        Ok(RbxSession {
            tree,
-            metadata_per_path,
+            instances_per_path,
            metadata_per_instance,
            message_queue,
            imfs,
-        }
+        })
    }

    fn path_created_or_updated(&mut self, path: &Path) {
@@ -80,7 +134,7 @@ impl RbxSession {
                .expect("Path was outside in-memory filesystem roots");

            // Find the closest instance in the tree that currently exists
-            let mut path_to_snapshot = self.metadata_per_path.descend(root_path, path);
+            let mut path_to_snapshot = self.instances_per_path.descend(root_path, path);

            // If this is a file that might affect its parent if modified, we
            // should snapshot its parent instead.
@@ -93,42 +147,54 @@ impl RbxSession {

            trace!("Snapshotting path {}", path_to_snapshot.display());

-            let path_metadata = self.metadata_per_path.get(&path_to_snapshot).unwrap();
+            let instances_at_path = self.instances_per_path.get(&path_to_snapshot)
+                .expect("Metadata did not exist for path")
+                .clone();

-            trace!("Metadata for path: {:?}", path_metadata);
-
-            let instance_id = path_metadata.instance_id
-                .expect("Instance did not exist in tree");
-
-            // If this instance is a sync point, pull its name out of our
-            // per-path metadata store.
-            let instance_name = path_metadata.instance_name.as_ref()
-                .map(|value| Cow::Owned(value.to_owned()));
-
-            let mut context = SnapshotContext {
-                metadata_per_path: &mut self.metadata_per_path,
-            };
-            let maybe_snapshot = snapshot_imfs_path(&imfs, &mut context, &path_to_snapshot, instance_name)
-                .unwrap_or_else(|_| panic!("Could not generate instance snapshot for path {}", path_to_snapshot.display()));
-
-            let snapshot = match maybe_snapshot {
-                Some(snapshot) => snapshot,
-                None => {
-                    trace!("Path resulted in no snapshot being generated.");
-                    return;
-                },
+            let context = SnapshotContext {
+                plugin_context: None,
            };

-            trace!("Snapshot: {:#?}", snapshot);
+            for instance_id in &instances_at_path {
+                let instance_metadata = self.metadata_per_instance.get(&instance_id)
+                    .expect("Metadata for instance ID did not exist");

-            reconcile_subtree(
-                &mut self.tree,
-                instance_id,
-                &snapshot,
-                &mut self.metadata_per_path,
-                &mut self.metadata_per_instance,
-                &mut changes,
-            );
+                let maybe_snapshot = match &instance_metadata.project_definition {
+                    Some((instance_name, project_node)) => {
+                        snapshot_project_node(&context, &imfs, &project_node, Cow::Owned(instance_name.clone()))
+                            // .unwrap_or_else(|_| panic!("Could not generate instance snapshot for path {}", path_to_snapshot.display()))
+                    },
+                    None => {
+                        snapshot_imfs_path(&context, &imfs, &path_to_snapshot, None)
+                            // .unwrap_or_else(|_| panic!("Could not generate instance snapshot for path {}", path_to_snapshot.display()))
+                    },
+                };
+
+                let snapshot = match maybe_snapshot {
+                    Ok(Some(snapshot)) => snapshot,
+                    Ok(None) => {
+                        trace!("Path resulted in no snapshot being generated.");
+                        return;
+                    },
+                    Err(err) => {
+                        error!("Rojo couldn't turn one of the project's files into Roblox instances.");
+                        error!("Any changes to the file have been ignored.");
+                        error!("{}", err);
+                        return;
+                    },
+                };
+
+                trace!("Snapshot: {:#?}", snapshot);
+
+                reconcile_subtree(
+                    &mut self.tree,
+                    *instance_id,
+                    &snapshot,
+                    &mut self.instances_per_path,
+                    &mut self.metadata_per_instance,
+                    &mut changes,
+                );
+            }
        }

        if changes.is_empty() {
@@ -170,13 +236,13 @@ impl RbxSession {

    pub fn path_removed(&mut self, path: &Path) {
        info!("Path removed: {}", path.display());
-        self.metadata_per_path.remove(path);
+        self.instances_per_path.remove(path);
        self.path_created_or_updated(path);
    }

    pub fn path_renamed(&mut self, from_path: &Path, to_path: &Path) {
        info!("Path renamed from {} to {}", from_path.display(), to_path.display());
-        self.metadata_per_path.remove(from_path);
+        self.instances_per_path.remove(from_path);
        self.path_created_or_updated(from_path);
        self.path_created_or_updated(to_path);
    }
@@ -188,33 +254,32 @@ impl RbxSession {
    pub fn get_instance_metadata(&self, id: RbxId) -> Option<&MetadataPerInstance> {
        self.metadata_per_instance.get(&id)
    }
-
-    pub fn debug_get_metadata_per_path(&self) -> &PathMap<MetadataPerPath> {
-        &self.metadata_per_path
-    }
 }

-pub fn construct_oneoff_tree(project: &Project, imfs: &Imfs) -> RbxTree {
-    let mut metadata_per_path = PathMap::new();
+pub fn construct_oneoff_tree(project: &Project, imfs: &Imfs) -> Result<RbxTree, SnapshotError> {
+    let mut instances_per_path = PathMap::new();
    let mut metadata_per_instance = HashMap::new();
-    reify_initial_tree(project, imfs, &mut metadata_per_path, &mut metadata_per_instance)
+    let context = SnapshotContext {
+        plugin_context: None,
+    };
+
+    reify_initial_tree(project, &context, imfs, &mut instances_per_path, &mut metadata_per_instance)
 }

 fn reify_initial_tree(
    project: &Project,
+    context: &SnapshotContext,
    imfs: &Imfs,
-    metadata_per_path: &mut PathMap<MetadataPerPath>,
+    instances_per_path: &mut PathMap<HashSet<RbxId>>,
    metadata_per_instance: &mut HashMap<RbxId, MetadataPerInstance>,
-) -> RbxTree {
-    let mut context = SnapshotContext {
-        metadata_per_path,
+) -> Result<RbxTree, SnapshotError> {
+    let snapshot = match snapshot_project_tree(&context, imfs, project)? {
+        Some(snapshot) => snapshot,
+        None => panic!("Project did not produce any instances"),
    };
-    let snapshot = snapshot_project_tree(imfs, &mut context, project)
-        .expect("Could not snapshot project tree")
-        .expect("Project did not produce any instances");

    let mut changes = InstanceChanges::default();
-    let tree = reify_root(&snapshot, metadata_per_path, metadata_per_instance, &mut changes);
+    let tree = reify_root(&snapshot, instances_per_path, metadata_per_instance, &mut changes);

-    tree
+    Ok(tree)
 }
--- a/server/src/rbx_snapshot.rs
+++ b/server/src/rbx_snapshot.rs
@@ -1,3 +1,6 @@
+//! Defines how Rojo transforms files into instances through the snapshot
+//! system.
+
 use std::{
    borrow::Cow,
    collections::HashMap,
@@ -6,11 +9,13 @@ use std::{
    str,
 };

+use rlua::Lua;
 use failure::Fail;
 use log::info;
 use maplit::hashmap;
-use rbx_tree::{RbxTree, RbxValue, RbxInstanceProperties};
+use rbx_dom_weak::{RbxTree, RbxValue, RbxInstanceProperties};
 use serde_derive::{Serialize, Deserialize};
+use rbx_reflection::{try_resolve_value, ValueResolveError};

 use crate::{
    imfs::{
@@ -22,28 +27,68 @@ use crate::{
    project::{
        Project,
        ProjectNode,
-        InstanceProjectNode,
-        SyncPointProjectNode,
    },
    snapshot_reconciler::{
        RbxSnapshotInstance,
        snapshot_from_tree,
    },
-    path_map::PathMap,
-    // TODO: Move MetadataPerPath into this module?
-    rbx_session::{MetadataPerPath, MetadataPerInstance},
+    // TODO: Move MetadataPerInstance into this module?
+    rbx_session::MetadataPerInstance,
 };

 const INIT_MODULE_NAME: &str = "init.lua";
 const INIT_SERVER_NAME: &str = "init.server.lua";
 const INIT_CLIENT_NAME: &str = "init.client.lua";

-pub type SnapshotResult<'a> = Result<Option<RbxSnapshotInstance<'a>>, SnapshotError>;
-
-pub struct SnapshotContext<'meta> {
-    pub metadata_per_path: &'meta mut PathMap<MetadataPerPath>,
+pub struct SnapshotContext {
+    pub plugin_context: Option<SnapshotPluginContext>,
 }

+/// Context that's only relevant to generating snapshots if there are plugins
+/// associated with the project.
+///
+/// It's possible that this needs some sort of extra nesting/filtering to
+/// support nested projects, since their plugins should only apply to
+/// themselves.
+pub struct SnapshotPluginContext {
+    pub lua: Lua,
+    pub plugins: Vec<SnapshotPluginEntry>,
+}
+
+pub struct SnapshotPluginEntry {
+    /// Simple file name suffix filter to avoid running plugins on every file
+    /// change.
+    pub file_name_filter: String,
+
+    /// A key into the Lua registry created by [`create_registry_value`] that
+    /// refers to a function that can be called to transform a file/instance
+    /// pair according to how the plugin needs to operate.
+    ///
+    /// [`create_registry_value`]: https://docs.rs/rlua/0.16.2/rlua/struct.Context.html#method.create_registry_value
+    pub callback: rlua::RegistryKey,
+}
+
+#[derive(Debug, Clone)]
+struct LuaRbxSnapshot(RbxSnapshotInstance<'static>);
+
+impl rlua::UserData for LuaRbxSnapshot {
+    fn add_methods<'lua, M: rlua::UserDataMethods<'lua, Self>>(methods: &mut M) {
+        methods.add_meta_method(rlua::MetaMethod::Index, |_context, this, key: String| {
+            match key.as_str() {
+                "name" => Ok(this.0.name.clone().into_owned()),
+                "className" => Ok(this.0.class_name.clone().into_owned()),
+                _ => Err(rlua::Error::RuntimeError(format!("{} is not a valid member of RbxSnapshotInstance", &key))),
+            }
+        });
+
+        methods.add_meta_method(rlua::MetaMethod::ToString, |_context, _this, _args: ()| {
+            Ok("RbxSnapshotInstance")
+        });
+    }
+}
+
+pub type SnapshotResult<'a> = Result<Option<RbxSnapshotInstance<'a>>, SnapshotError>;
+
 #[derive(Debug, Fail)]
 pub enum SnapshotError {
    DidNotExist(PathBuf),
@@ -55,6 +100,7 @@ pub enum SnapshotError {
    },

    JsonModelDecodeError {
+        #[fail(cause)]
        inner: serde_json::Error,
        path: PathBuf,
    },
@@ -68,6 +114,25 @@ pub enum SnapshotError {
        inner: rbx_binary::DecodeError,
        path: PathBuf,
    },
+
+    ProjectNodeUnusable,
+
+    ProjectNodeInvalidTransmute {
+        partition_path: PathBuf,
+    },
+
+    PropertyResolveError {
+        #[fail(cause)]
+        inner: ValueResolveError,
+    },
+}
+
+impl From<ValueResolveError> for SnapshotError {
+    fn from(inner: ValueResolveError) -> SnapshotError {
+        SnapshotError::PropertyResolveError {
+            inner,
+        }
+    }
 }

 impl fmt::Display for SnapshotError {
@@ -78,7 +143,7 @@ impl fmt::Display for SnapshotError {
                write!(output, "Invalid UTF-8: {} in path {}", inner, path.display())
            },
            SnapshotError::JsonModelDecodeError { inner, path } => {
-                write!(output, "Malformed .model.json model: {:?} in path {}", inner, path.display())
+                write!(output, "Malformed .model.json model: {} in path {}", inner, path.display())
            },
            SnapshotError::XmlModelDecodeError { inner, path } => {
                write!(output, "Malformed rbxmx model: {:?} in path {}", inner, path.display())
@@ -86,107 +151,138 @@ impl fmt::Display for SnapshotError {
            SnapshotError::BinaryModelDecodeError { inner, path } => {
                write!(output, "Malformed rbxm model: {:?} in path {}", inner, path.display())
            },
+            SnapshotError::ProjectNodeUnusable => {
+                write!(output, "Rojo project nodes must specify either $path or $className.")
+            },
+            SnapshotError::ProjectNodeInvalidTransmute { partition_path } => {
+                writeln!(output, "Rojo project nodes that specify both $path and $className require that the")?;
+                writeln!(output, "instance produced by the files pointed to by $path has a ClassName of")?;
+                writeln!(output, "Folder.")?;
+                writeln!(output, "")?;
+                writeln!(output, "Partition target ($path): {}", partition_path.display())
+            },
+            SnapshotError::PropertyResolveError { inner } => write!(output, "{}", inner),
        }
    }
 }

 pub fn snapshot_project_tree<'source>(
+    context: &SnapshotContext,
    imfs: &'source Imfs,
-    context: &mut SnapshotContext,
    project: &'source Project,
 ) -> SnapshotResult<'source> {
-    snapshot_project_node(imfs, context, &project.tree, Cow::Borrowed(&project.name))
+    snapshot_project_node(context, imfs, &project.tree, Cow::Borrowed(&project.name))
 }

-fn snapshot_project_node<'source>(
+pub fn snapshot_project_node<'source>(
+    context: &SnapshotContext,
    imfs: &'source Imfs,
-    context: &mut SnapshotContext,
-    node: &'source ProjectNode,
+    node: &ProjectNode,
    instance_name: Cow<'source, str>,
 ) -> SnapshotResult<'source> {
-    match node {
-        ProjectNode::Instance(instance_node) => snapshot_instance_node(imfs, context, instance_node, instance_name),
-        ProjectNode::SyncPoint(sync_node) => snapshot_sync_point_node(imfs, context, sync_node, instance_name),
-    }
-}
+    let maybe_snapshot = match &node.path {
+        Some(path) => snapshot_imfs_path(context, imfs, &path, Some(instance_name.clone()))?,
+        None => match &node.class_name {
+            Some(_class_name) => Some(RbxSnapshotInstance {
+                name: instance_name.clone(),

-fn snapshot_instance_node<'source>(
-    imfs: &'source Imfs,
-    context: &mut SnapshotContext,
-    node: &'source InstanceProjectNode,
-    instance_name: Cow<'source, str>,
-) -> SnapshotResult<'source> {
-    let mut children = Vec::new();
-
-    for (child_name, child_project_node) in &node.children {
-        if let Some(child) = snapshot_project_node(imfs, context, child_project_node, Cow::Borrowed(child_name))? {
-            children.push(child);
-        }
-    }
-
-    Ok(Some(RbxSnapshotInstance {
-        class_name: Cow::Borrowed(&node.class_name),
-        name: instance_name,
-        properties: node.properties.clone(),
-        children,
-        metadata: MetadataPerInstance {
-            source_path: None,
-            ignore_unknown_instances: node.metadata.ignore_unknown_instances,
+                // These properties are replaced later in the function to
+                // reduce code duplication.
+                class_name: Cow::Borrowed("Folder"),
+                properties: HashMap::new(),
+                children: Vec::new(),
+                metadata: MetadataPerInstance {
+                    source_path: None,
+                    ignore_unknown_instances: true,
+                    project_definition: None,
+                },
+            }),
+            None => {
+                return Err(SnapshotError::ProjectNodeUnusable);
+            },
        },
-    }))
-}
-
-fn snapshot_sync_point_node<'source>(
-    imfs: &'source Imfs,
-    context: &mut SnapshotContext,
-    node: &'source SyncPointProjectNode,
-    instance_name: Cow<'source, str>,
-) -> SnapshotResult<'source> {
-    let maybe_snapshot = snapshot_imfs_path(imfs, context, &node.path, Some(instance_name))?;
+    };

    // If the snapshot resulted in no instances, like if it targets an unknown
    // file or an empty model file, we can early-return.
-    let snapshot = match maybe_snapshot {
+    //
+    // In the future, we might want to issue a warning if the project also
+    // specified fields like class_name, since the user will probably be
+    // confused as to why nothing showed up in the tree.
+    let mut snapshot = match maybe_snapshot {
        Some(snapshot) => snapshot,
-        None => return Ok(None),
+        None => {
+            // TODO: Return some other sort of marker here instead? If a node
+            // transitions from None into Some, it's possible that configuration
+            // from the ProjectNode might be lost since there's nowhere to put
+            // it!
+            return Ok(None);
+        },
    };

-    // Otherwise, we can log the name of the sync point we just snapshotted.
-    let path_meta = context.metadata_per_path.entry(node.path.to_owned()).or_default();
-    path_meta.instance_name = Some(snapshot.name.clone().into_owned());
+    // Applies the class name specified in `class_name` from the project, if it's
+    // set.
+    if let Some(class_name) = &node.class_name {
+        // This can only happen if `path` was specified in the project node and
+        // that path represented a non-Folder instance.
+        if snapshot.class_name != "Folder" {
+            return Err(SnapshotError::ProjectNodeInvalidTransmute {
+                partition_path: node.path.as_ref().unwrap().to_owned(),
+            });
+        }
+
+        snapshot.class_name = Cow::Owned(class_name.to_owned());
+    }
+
+    for (child_name, child_project_node) in &node.children {
+        if let Some(child) = snapshot_project_node(context, imfs, child_project_node, Cow::Owned(child_name.clone()))? {
+            snapshot.children.push(child);
+        }
+    }
+
+    for (key, value) in &node.properties {
+        let resolved_value = try_resolve_value(&snapshot.class_name, key, value)?;
+        snapshot.properties.insert(key.clone(), resolved_value);
+    }
+
+    if let Some(ignore_unknown_instances) = node.ignore_unknown_instances {
+        snapshot.metadata.ignore_unknown_instances = ignore_unknown_instances;
+    }
+
+    snapshot.metadata.project_definition = Some((instance_name.into_owned(), node.clone()));

    Ok(Some(snapshot))
 }

 pub fn snapshot_imfs_path<'source>(
+    context: &SnapshotContext,
    imfs: &'source Imfs,
-    context: &mut SnapshotContext,
    path: &Path,
    instance_name: Option<Cow<'source, str>>,
 ) -> SnapshotResult<'source> {
    // If the given path doesn't exist in the in-memory filesystem, we consider
    // that an error.
    match imfs.get(path) {
-        Some(imfs_item) => snapshot_imfs_item(imfs, context, imfs_item, instance_name),
+        Some(imfs_item) => snapshot_imfs_item(context, imfs, imfs_item, instance_name),
        None => return Err(SnapshotError::DidNotExist(path.to_owned())),
    }
 }

 fn snapshot_imfs_item<'source>(
+    context: &SnapshotContext,
    imfs: &'source Imfs,
-    context: &mut SnapshotContext,
    item: &'source ImfsItem,
    instance_name: Option<Cow<'source, str>>,
 ) -> SnapshotResult<'source> {
    match item {
-        ImfsItem::File(file) => snapshot_imfs_file(file, instance_name),
-        ImfsItem::Directory(directory) => snapshot_imfs_directory(imfs, context, directory, instance_name),
+        ImfsItem::File(file) => snapshot_imfs_file(context, file, instance_name),
+        ImfsItem::Directory(directory) => snapshot_imfs_directory(context, imfs, directory, instance_name),
    }
 }

 fn snapshot_imfs_directory<'source>(
+    context: &SnapshotContext,
    imfs: &'source Imfs,
-    context: &mut SnapshotContext,
    directory: &'source ImfsDirectory,
    instance_name: Option<Cow<'source, str>>,
 ) -> SnapshotResult<'source> {
@@ -202,11 +298,11 @@ fn snapshot_imfs_directory<'source>(
        });

    let mut snapshot = if directory.children.contains(&init_path) {
-        snapshot_imfs_path(imfs, context, &init_path, Some(snapshot_name))?.unwrap()
+        snapshot_imfs_path(context, imfs, &init_path, Some(snapshot_name))?.unwrap()
    } else if directory.children.contains(&init_server_path) {
-        snapshot_imfs_path(imfs, context, &init_server_path, Some(snapshot_name))?.unwrap()
+        snapshot_imfs_path(context, imfs, &init_server_path, Some(snapshot_name))?.unwrap()
    } else if directory.children.contains(&init_client_path) {
-        snapshot_imfs_path(imfs, context, &init_client_path, Some(snapshot_name))?.unwrap()
+        snapshot_imfs_path(context, imfs, &init_client_path, Some(snapshot_name))?.unwrap()
    } else {
        RbxSnapshotInstance {
            class_name: Cow::Borrowed("Folder"),
@@ -216,6 +312,7 @@ fn snapshot_imfs_directory<'source>(
            metadata: MetadataPerInstance {
                source_path: None,
                ignore_unknown_instances: false,
+                project_definition: None,
            },
        }
    };
@@ -234,7 +331,7 @@ fn snapshot_imfs_directory<'source>(
                // them here.
            },
            _ => {
-                if let Some(child) = snapshot_imfs_path(imfs, context, child_path, None)? {
+                if let Some(child) = snapshot_imfs_path(context, imfs, child_path, None)? {
                    snapshot.children.push(child);
                }
            },
@@ -245,6 +342,7 @@ fn snapshot_imfs_directory<'source>(
 }

 fn snapshot_imfs_file<'source>(
+    context: &SnapshotContext,
    file: &'source ImfsFile,
    instance_name: Option<Cow<'source, str>>,
 ) -> SnapshotResult<'source> {
@@ -280,6 +378,20 @@ fn snapshot_imfs_file<'source>(
        info!("File generated no snapshot: {}", file.path.display());
    }

+    if let Some(snapshot) = maybe_snapshot.as_ref() {
+        if let Some(plugin_context) = &context.plugin_context {
+            for plugin in &plugin_context.plugins {
+                let owned_snapshot = snapshot.get_owned();
+                let registry_key = &plugin.callback;
+
+                plugin_context.lua.context(move |context| {
+                    let callback: rlua::Function = context.registry_value(registry_key).unwrap();
+                    callback.call::<_, ()>(LuaRbxSnapshot(owned_snapshot)).unwrap();
+                });
+            }
+        }
+    }
+
    Ok(maybe_snapshot)
 }

@@ -316,6 +428,7 @@ fn snapshot_lua_file<'source>(
        metadata: MetadataPerInstance {
            source_path: Some(file.path.to_path_buf()),
            ignore_unknown_instances: false,
+            project_definition: None,
        },
    }))
 }
@@ -354,6 +467,7 @@ fn snapshot_txt_file<'source>(
        metadata: MetadataPerInstance {
            source_path: Some(file.path.to_path_buf()),
            ignore_unknown_instances: false,
+            project_definition: None,
        },
    }))
 }
@@ -387,6 +501,7 @@ fn snapshot_csv_file<'source>(
        metadata: MetadataPerInstance {
            source_path: Some(file.path.to_path_buf()),
            ignore_unknown_instances: false,
+            project_definition: None,
        },
    }))
 }
--- a/server/src/snapshot_reconciler.rs
+++ b/server/src/snapshot_reconciler.rs
@@ -1,18 +1,25 @@
+//! Defines the snapshot subsystem of Rojo, which defines a lightweight instance
+//! representation (`RbxSnapshotInstance`) and a system to incrementally update
+//! an `RbxTree` based on snapshots.
+
 use std::{
-    str,
    borrow::Cow,
+    cmp::Ordering,
    collections::{HashMap, HashSet},
    fmt,
+    str,
 };

-use rbx_tree::{RbxTree, RbxId, RbxInstanceProperties, RbxValue};
+use rbx_dom_weak::{RbxTree, RbxId, RbxInstanceProperties, RbxValue};
 use serde_derive::{Serialize, Deserialize};

 use crate::{
    path_map::PathMap,
-    rbx_session::{MetadataPerPath, MetadataPerInstance},
+    rbx_session::MetadataPerInstance,
 };

+/// Contains all of the IDs that were modified when the snapshot reconciler
+/// applied an update.
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct InstanceChanges {
    pub added: HashSet<RbxId>,
@@ -55,7 +62,9 @@ impl InstanceChanges {
    }
 }

-#[derive(Debug)]
+/// A lightweight, hierarchical representation of an instance that can be
+/// applied to the tree.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct RbxSnapshotInstance<'a> {
    pub name: Cow<'a, str>,
    pub class_name: Cow<'a, str>,
@@ -64,6 +73,34 @@ pub struct RbxSnapshotInstance<'a> {
    pub metadata: MetadataPerInstance,
 }

+impl<'a> RbxSnapshotInstance<'a> {
+    pub fn get_owned(&'a self) -> RbxSnapshotInstance<'static> {
+        let children: Vec<RbxSnapshotInstance<'static>> = self.children.iter()
+            .map(RbxSnapshotInstance::get_owned)
+            .collect();
+
+        RbxSnapshotInstance {
+            name: Cow::Owned(self.name.clone().into_owned()),
+            class_name: Cow::Owned(self.class_name.clone().into_owned()),
+            properties: self.properties.clone(),
+            children,
+            metadata: self.metadata.clone(),
+        }
+    }
+}
+
+impl<'a> PartialOrd for RbxSnapshotInstance<'a> {
+    fn partial_cmp(&self, other: &RbxSnapshotInstance) -> Option<Ordering> {
+        Some(self.name.cmp(&other.name)
+            .then(self.class_name.cmp(&other.class_name)))
+    }
+}
+
+/// Generates an `RbxSnapshotInstance` from an existing `RbxTree` and an ID to
+/// use as the root of the snapshot.
+///
+/// This is used to transform instances created by rbx_xml and rbx_binary into
+/// snapshots that can be applied to the tree to reduce instance churn.
 pub fn snapshot_from_tree(tree: &RbxTree, id: RbxId) -> Option<RbxSnapshotInstance<'static>> {
    let instance = tree.get_instance(id)?;

@@ -80,81 +117,93 @@ pub fn snapshot_from_tree(tree: &RbxTree, id: RbxId) -> Option<RbxSnapshotInstan
        metadata: MetadataPerInstance {
            source_path: None,
            ignore_unknown_instances: false,
+            project_definition: None,
        },
    })
 }

+/// Constructs a new `RbxTree` out of a snapshot and places to attach metadata.
 pub fn reify_root(
    snapshot: &RbxSnapshotInstance,
-    metadata_per_path: &mut PathMap<MetadataPerPath>,
-    instance_metadata_map: &mut HashMap<RbxId, MetadataPerInstance>,
+    instance_per_path: &mut PathMap<HashSet<RbxId>>,
+    metadata_per_instance: &mut HashMap<RbxId, MetadataPerInstance>,
    changes: &mut InstanceChanges,
 ) -> RbxTree {
    let instance = reify_core(snapshot);
    let mut tree = RbxTree::new(instance);
-    let root_id = tree.get_root_id();
+    let id = tree.get_root_id();

-    if let Some(source_path) = &snapshot.metadata.source_path {
-        let path_meta = metadata_per_path.entry(source_path.to_owned()).or_default();
-        path_meta.instance_id = Some(root_id);
-    }
+    reify_metadata(snapshot, id, instance_per_path, metadata_per_instance);

-    instance_metadata_map.insert(root_id, snapshot.metadata.clone());
-
-    changes.added.insert(root_id);
+    changes.added.insert(id);

    for child in &snapshot.children {
-        reify_subtree(child, &mut tree, root_id, metadata_per_path, instance_metadata_map, changes);
+        reify_subtree(child, &mut tree, id, instance_per_path, metadata_per_instance, changes);
    }

    tree
 }

+/// Adds instances to a portion of the given `RbxTree`, used for when new
+/// instances are created.
 pub fn reify_subtree(
    snapshot: &RbxSnapshotInstance,
    tree: &mut RbxTree,
    parent_id: RbxId,
-    metadata_per_path: &mut PathMap<MetadataPerPath>,
-    instance_metadata_map: &mut HashMap<RbxId, MetadataPerInstance>,
+    instance_per_path: &mut PathMap<HashSet<RbxId>>,
+    metadata_per_instance: &mut HashMap<RbxId, MetadataPerInstance>,
    changes: &mut InstanceChanges,
 ) {
    let instance = reify_core(snapshot);
    let id = tree.insert_instance(instance, parent_id);

-    if let Some(source_path) = &snapshot.metadata.source_path {
-        let path_meta = metadata_per_path.entry(source_path.clone()).or_default();
-        path_meta.instance_id = Some(id);
-    }
-
-    instance_metadata_map.insert(id, snapshot.metadata.clone());
+    reify_metadata(snapshot, id, instance_per_path, metadata_per_instance);

    changes.added.insert(id);

    for child in &snapshot.children {
-        reify_subtree(child, tree, id, metadata_per_path, instance_metadata_map, changes);
+        reify_subtree(child, tree, id, instance_per_path, metadata_per_instance, changes);
    }
 }

+fn reify_metadata(
+    snapshot: &RbxSnapshotInstance,
+    instance_id: RbxId,
+    instance_per_path: &mut PathMap<HashSet<RbxId>>,
+    metadata_per_instance: &mut HashMap<RbxId, MetadataPerInstance>,
+) {
+    if let Some(source_path) = &snapshot.metadata.source_path {
+        let path_metadata = match instance_per_path.get_mut(&source_path) {
+            Some(v) => v,
+            None => {
+                instance_per_path.insert(source_path.clone(), Default::default());
+                instance_per_path.get_mut(&source_path).unwrap()
+            },
+        };
+
+        path_metadata.insert(instance_id);
+    }
+
+    metadata_per_instance.insert(instance_id, snapshot.metadata.clone());
+}
+
+/// Updates existing instances in an existing `RbxTree`, potentially adding,
+/// updating, or removing children and properties.
 pub fn reconcile_subtree(
    tree: &mut RbxTree,
    id: RbxId,
    snapshot: &RbxSnapshotInstance,
-    metadata_per_path: &mut PathMap<MetadataPerPath>,
-    instance_metadata_map: &mut HashMap<RbxId, MetadataPerInstance>,
+    instance_per_path: &mut PathMap<HashSet<RbxId>>,
+    metadata_per_instance: &mut HashMap<RbxId, MetadataPerInstance>,
    changes: &mut InstanceChanges,
 ) {
-    if let Some(source_path) = &snapshot.metadata.source_path {
-        let path_meta = metadata_per_path.entry(source_path.to_owned()).or_default();
-        path_meta.instance_id = Some(id);
-    }
-
-    instance_metadata_map.insert(id, snapshot.metadata.clone());
+    reify_metadata(snapshot, id, instance_per_path, metadata_per_instance);

    if reconcile_instance_properties(tree.get_instance_mut(id).unwrap(), snapshot) {
        changes.updated.insert(id);
    }

-    reconcile_instance_children(tree, id, snapshot, metadata_per_path, instance_metadata_map, changes);
+    reconcile_instance_children(tree, id, snapshot, instance_per_path, metadata_per_instance, changes);
 }

 fn reify_core(snapshot: &RbxSnapshotInstance) -> RbxInstanceProperties {
@@ -234,8 +283,8 @@ fn reconcile_instance_children(
    tree: &mut RbxTree,
    id: RbxId,
    snapshot: &RbxSnapshotInstance,
-    metadata_per_path: &mut PathMap<MetadataPerPath>,
-    instance_metadata_map: &mut HashMap<RbxId, MetadataPerInstance>,
+    instance_per_path: &mut PathMap<HashSet<RbxId>>,
+    metadata_per_instance: &mut HashMap<RbxId, MetadataPerInstance>,
    changes: &mut InstanceChanges,
 ) {
    let mut visited_snapshot_indices = HashSet::new();
@@ -287,19 +336,19 @@ fn reconcile_instance_children(
    }

    for child_snapshot in &children_to_add {
-        reify_subtree(child_snapshot, tree, id, metadata_per_path, instance_metadata_map, changes);
+        reify_subtree(child_snapshot, tree, id, instance_per_path, metadata_per_instance, changes);
    }

    for child_id in &children_to_remove {
        if let Some(subtree) = tree.remove_instance(*child_id) {
            for id in subtree.iter_all_ids() {
-                instance_metadata_map.remove(&id);
+                metadata_per_instance.remove(&id);
                changes.removed.insert(id);
            }
        }
    }

    for (child_id, child_snapshot) in &children_to_update {
-        reconcile_subtree(tree, *child_id, child_snapshot, metadata_per_path, instance_metadata_map, changes);
+        reconcile_subtree(tree, *child_id, child_snapshot, instance_per_path, metadata_per_instance, changes);
    }
 }
--- a/server/src/visualize.rs
+++ b/server/src/visualize.rs
@@ -6,12 +6,12 @@ use std::{
 };

 use log::warn;
-use rbx_tree::RbxId;
+use rbx_dom_weak::RbxId;

 use crate::{
    imfs::{Imfs, ImfsItem},
    rbx_session::RbxSession,
-    web::InstanceMetadata,
+    web::api::PublicInstanceMetadata,
 };

 static GRAPHVIZ_HEADER: &str = r#"
@@ -74,7 +74,7 @@ fn visualize_rbx_node(session: &RbxSession, id: RbxId, output: &mut fmt::Formatt
    let mut node_label = format!("{}|{}|{}", node.name, node.class_name, id);

    if let Some(session_metadata) = session.get_instance_metadata(id) {
-        let metadata = InstanceMetadata::from_session_metadata(session_metadata);
+        let metadata = PublicInstanceMetadata::from_session_metadata(session_metadata);
        node_label.push('|');
        node_label.push_str(&serde_json::to_string(&metadata).unwrap());
    }
--- a/server/src/web/api.rs
+++ b/server/src/web/api.rs
@@ -1,46 +1,49 @@
+//! Defines Rojo's HTTP API, all under /api. These endpoints generally return
+//! JSON.
+
 use std::{
    borrow::Cow,
    collections::{HashMap, HashSet},
    sync::{mpsc, Arc},
 };

-use serde_derive::{Serialize, Deserialize};
-use log::trace;
-use rouille::{
-    self,
-    router,
+use futures::{future, Future};
+use hyper::{
+    service::Service,
+    header,
+    StatusCode,
+    Method,
+    Body,
    Request,
    Response,
 };
-use rbx_tree::{RbxId, RbxInstance};
+use serde_derive::{Serialize, Deserialize};
+use rbx_dom_weak::{RbxId, RbxInstance};

 use crate::{
    live_session::LiveSession,
    session_id::SessionId,
    snapshot_reconciler::InstanceChanges,
-    visualize::{VisualizeRbxSession, VisualizeImfs, graphviz_to_svg},
    rbx_session::{MetadataPerInstance},
 };

-static HOME_CONTENT: &str = include_str!("../assets/index.html");
-
 /// Contains the instance metadata relevant to Rojo clients.
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct InstanceMetadata {
+pub struct PublicInstanceMetadata {
    ignore_unknown_instances: bool,
 }

-impl InstanceMetadata {
-    pub fn from_session_metadata(meta: &MetadataPerInstance) -> InstanceMetadata {
-        InstanceMetadata {
+impl PublicInstanceMetadata {
+    pub fn from_session_metadata(meta: &MetadataPerInstance) -> PublicInstanceMetadata {
+        PublicInstanceMetadata {
            ignore_unknown_instances: meta.ignore_unknown_instances,
        }
    }
 }

 /// Used to attach metadata specific to Rojo to instances, which come from the
-/// rbx_tree crate.
+/// rbx_dom_weak crate.
 ///
 /// Both fields are wrapped in Cow in order to make owned-vs-borrowed simpler
 /// for tests.
@@ -50,7 +53,7 @@ pub struct InstanceWithMetadata<'a> {
    pub instance: Cow<'a, RbxInstance>,

    #[serde(rename = "Metadata")]
-    pub metadata: Option<InstanceMetadata>,
+    pub metadata: Option<PublicInstanceMetadata>,
 }

 #[derive(Debug, Serialize, Deserialize)]
@@ -79,81 +82,89 @@ pub struct SubscribeResponse<'a> {
    pub messages: Cow<'a, [InstanceChanges]>,
 }

-pub struct Server {
+fn response_json<T: serde::Serialize>(value: T) -> Response<Body> {
+    let serialized = match serde_json::to_string(&value) {
+        Ok(v) => v,
+        Err(err) => {
+            return Response::builder()
+                .status(StatusCode::BAD_REQUEST)
+                .header(header::CONTENT_TYPE, "text/plain")
+                .body(Body::from(err.to_string()))
+                .unwrap();
+        },
+    };
+
+    Response::builder()
+        .header(header::CONTENT_TYPE, "application/json")
+        .body(Body::from(serialized))
+        .unwrap()
+}
+
+pub struct ApiService {
    live_session: Arc<LiveSession>,
    server_version: &'static str,
 }

-impl Server {
-    pub fn new(live_session: Arc<LiveSession>) -> Server {
-        Server {
+impl Service for ApiService {
+    type ReqBody = Body;
+    type ResBody = Body;
+    type Error = hyper::Error;
+    type Future = Box<dyn Future<Item = hyper::Response<Self::ReqBody>, Error = Self::Error> + Send>;
+
+    fn call(&mut self, request: hyper::Request<Self::ReqBody>) -> Self::Future {
+        let response = match (request.method(), request.uri().path()) {
+            (&Method::GET, "/api/rojo") => self.handle_api_rojo(),
+            (&Method::GET, path) if path.starts_with("/api/subscribe/") => self.handle_api_subscribe(request),
+            (&Method::GET, path) if path.starts_with("/api/read/") => self.handle_api_read(request),
+            _ => {
+                Response::builder()
+                    .status(StatusCode::NOT_FOUND)
+                    .body(Body::empty())
+                    .unwrap()
+            },
+        };
+
+        Box::new(future::ok(response))
+    }
+}
+
+impl ApiService {
+    pub fn new(live_session: Arc<LiveSession>) -> ApiService {
+        ApiService {
            live_session,
            server_version: env!("CARGO_PKG_VERSION"),
        }
    }

-    #[allow(unreachable_code)]
-    pub fn handle_request(&self, request: &Request) -> Response {
-        trace!("Request {} {}", request.method(), request.url());
-
-        router!(request,
-            (GET) (/) => {
-                self.handle_home()
-            },
-            (GET) (/api/rojo) => {
-                self.handle_api_rojo()
-            },
-            (GET) (/api/subscribe/{ cursor: u32 }) => {
-                self.handle_api_subscribe(cursor)
-            },
-            (GET) (/api/read/{ id_list: String }) => {
-                let requested_ids: Option<Vec<RbxId>> = id_list
-                    .split(',')
-                    .map(RbxId::parse_str)
-                    .collect();
-
-                self.handle_api_read(requested_ids)
-            },
-            (GET) (/visualize/rbx) => {
-                self.handle_visualize_rbx()
-            },
-            (GET) (/visualize/imfs) => {
-                self.handle_visualize_imfs()
-            },
-            (GET) (/visualize/path_metadata) => {
-                self.handle_visualize_path_metadata()
-            },
-            _ => Response::empty_404()
-        )
-    }
-
-    pub fn listen(self, port: u16) {
-        let address = format!("0.0.0.0:{}", port);
-
-        rouille::start_server(address, move |request| self.handle_request(request));
-    }
-
-    fn handle_home(&self) -> Response {
-        Response::html(HOME_CONTENT)
-    }
-
    /// Get a summary of information about the server
-    fn handle_api_rojo(&self) -> Response {
+    fn handle_api_rojo(&self) -> Response<Body> {
        let rbx_session = self.live_session.rbx_session.lock().unwrap();
        let tree = rbx_session.get_tree();

-        Response::json(&ServerInfoResponse {
+        response_json(&ServerInfoResponse {
            server_version: self.server_version,
            protocol_version: 2,
-            session_id: self.live_session.session_id,
-            expected_place_ids: self.live_session.project.serve_place_ids.clone(),
+            session_id: self.live_session.session_id(),
+            expected_place_ids: self.live_session.serve_place_ids().clone(),
            root_instance_id: tree.get_root_id(),
        })
    }

    /// Retrieve any messages past the given cursor index, and if
    /// there weren't any, subscribe to receive any new messages.
-    fn handle_api_subscribe(&self, cursor: u32) -> Response {
+    fn handle_api_subscribe(&self, request: Request<Body>) -> Response<Body> {
+        let argument = &request.uri().path()["/api/subscribe/".len()..];
+        let cursor: u32 = match argument.parse() {
+            Ok(v) => v,
+            Err(err) => {
+                return Response::builder()
+                    .status(StatusCode::BAD_REQUEST)
+                    .header(header::CONTENT_TYPE, "text/plain")
+                    .body(Body::from(err.to_string()))
+                    .unwrap();
+            },
+        };
+
        let message_queue = Arc::clone(&self.live_session.message_queue);

        // Did the client miss any messages since the last subscribe?
@@ -161,21 +172,24 @@ impl Server {
            let (new_cursor, new_messages) = message_queue.get_messages_since(cursor);

            if !new_messages.is_empty() {
-                return Response::json(&SubscribeResponse {
-                    session_id: self.live_session.session_id,
+                return response_json(&SubscribeResponse {
+                    session_id: self.live_session.session_id(),
                    messages: Cow::Borrowed(&new_messages),
                    message_cursor: new_cursor,
                })
            }
        }

+        // TOOD: Switch to futures mpsc instead to not block this task
        let (tx, rx) = mpsc::channel();
-
        let sender_id = message_queue.subscribe(tx);

        match rx.recv() {
            Ok(_) => (),
-            Err(_) => return Response::text("error!").with_status_code(500),
+            Err(_) => return Response::builder()
+                .status(500)
+                .body(Body::from("error!"))
+                .unwrap(),
        }

        message_queue.unsubscribe(sender_id);
@@ -183,20 +197,32 @@ impl Server {
        {
            let (new_cursor, new_messages) = message_queue.get_messages_since(cursor);

-            return Response::json(&SubscribeResponse {
-                session_id: self.live_session.session_id,
+            return response_json(&SubscribeResponse {
+                session_id: self.live_session.session_id(),
                messages: Cow::Owned(new_messages),
                message_cursor: new_cursor,
            })
        }
    }

-    fn handle_api_read(&self, requested_ids: Option<Vec<RbxId>>) -> Response {
+    fn handle_api_read(&self, request: Request<Body>) -> Response<Body> {
+        let argument = &request.uri().path()["/api/read/".len()..];
+        let requested_ids: Option<Vec<RbxId>> = argument
+            .split(',')
+            .map(RbxId::parse_str)
+            .collect();
+
        let message_queue = Arc::clone(&self.live_session.message_queue);

        let requested_ids = match requested_ids {
            Some(id) => id,
-            None => return rouille::Response::text("Malformed ID list").with_status_code(400),
+            None => {
+                return Response::builder()
+                    .status(StatusCode::BAD_REQUEST)
+                    .header(header::CONTENT_TYPE, "text/plain")
+                    .body(Body::from("Malformed ID list"))
+                    .unwrap();
+            },
        };

        let rbx_session = self.live_session.rbx_session.lock().unwrap();
@@ -209,7 +235,7 @@ impl Server {
        for &requested_id in &requested_ids {
            if let Some(instance) = tree.get_instance(requested_id) {
                let metadata = rbx_session.get_instance_metadata(requested_id)
-                    .map(InstanceMetadata::from_session_metadata);
+                    .map(PublicInstanceMetadata::from_session_metadata);

                instances.insert(instance.get_id(), InstanceWithMetadata {
                    instance: Cow::Borrowed(instance),
@@ -218,7 +244,7 @@ impl Server {

                for descendant in tree.descendants(requested_id) {
                    let descendant_meta = rbx_session.get_instance_metadata(descendant.get_id())
-                        .map(InstanceMetadata::from_session_metadata);
+                        .map(PublicInstanceMetadata::from_session_metadata);

                    instances.insert(descendant.get_id(), InstanceWithMetadata {
                        instance: Cow::Borrowed(descendant),
@@ -228,35 +254,10 @@ impl Server {
            }
        }

-        Response::json(&ReadResponse {
-            session_id: self.live_session.session_id,
+        response_json(&ReadResponse {
+            session_id: self.live_session.session_id(),
            message_cursor,
            instances,
        })
    }
-
-    fn handle_visualize_rbx(&self) -> Response {
-        let rbx_session = self.live_session.rbx_session.lock().unwrap();
-        let dot_source = format!("{}", VisualizeRbxSession(&rbx_session));
-
-        match graphviz_to_svg(&dot_source) {
-            Some(svg) => Response::svg(svg),
-            None => Response::text(dot_source),
-        }
-    }
-
-    fn handle_visualize_imfs(&self) -> Response {
-        let imfs = self.live_session.imfs.lock().unwrap();
-        let dot_source = format!("{}", VisualizeImfs(&imfs));
-
-        match graphviz_to_svg(&dot_source) {
-            Some(svg) => Response::svg(svg),
-            None => Response::text(dot_source),
-        }
-    }
-
-    fn handle_visualize_path_metadata(&self) -> Response {
-        let rbx_session = self.live_session.rbx_session.lock().unwrap();
-        Response::json(&rbx_session.debug_get_metadata_per_path())
-    }
 }
--- a/server/src/web/interface.rs
+++ b/server/src/web/interface.rs
@@ -0,0 +1,121 @@
+//! Defines the HTTP-based UI. These endpoints generally return HTML and SVG.
+
+use std::sync::Arc;
+
+use futures::{future, Future};
+use hyper::{
+    service::Service,
+    header,
+    Body,
+    Method,
+    StatusCode,
+    Request,
+    Response,
+};
+use ritz::html;
+
+use crate::{
+    live_session::LiveSession,
+    visualize::{VisualizeRbxSession, VisualizeImfs, graphviz_to_svg},
+};
+
+static HOME_CSS: &str = include_str!("../../assets/index.css");
+
+pub struct InterfaceService {
+    live_session: Arc<LiveSession>,
+    server_version: &'static str,
+}
+
+impl Service for InterfaceService {
+    type ReqBody = Body;
+    type ResBody = Body;
+    type Error = hyper::Error;
+    type Future = Box<dyn Future<Item = Response<Self::ReqBody>, Error = Self::Error> + Send>;
+
+    fn call(&mut self, request: Request<Self::ReqBody>) -> Self::Future {
+        let response = match (request.method(), request.uri().path()) {
+            (&Method::GET, "/") => self.handle_home(),
+            (&Method::GET, "/visualize/rbx") => self.handle_visualize_rbx(),
+            (&Method::GET, "/visualize/imfs") => self.handle_visualize_imfs(),
+            _ => Response::builder()
+                .status(StatusCode::NOT_FOUND)
+                .body(Body::empty())
+                .unwrap(),
+        };
+
+        Box::new(future::ok(response))
+    }
+}
+
+impl InterfaceService {
+    pub fn new(live_session: Arc<LiveSession>) -> InterfaceService {
+        InterfaceService {
+            live_session,
+            server_version: env!("CARGO_PKG_VERSION"),
+        }
+    }
+
+    fn handle_home(&self) -> Response<Body> {
+        let page = html! {
+            <html>
+                <head>
+                    <title>"Rojo"</title>
+                    <style>
+                        { ritz::UnescapedText::new(HOME_CSS) }
+                    </style>
+                </head>
+
+                <body>
+                    <div class="main">
+                        <h1 class="title">
+                            "Rojo Live Sync is up and running!"
+                        </h1>
+                        <h2 class="subtitle">
+                            "Version " { self.server_version }
+                        </h2>
+                        <a class="docs" href="https://lpghatguy.github.io/rojo">
+                            "Rojo Documentation"
+                        </a>
+                    </div>
+                </body>
+            </html>
+        };
+
+        Response::builder()
+            .header(header::CONTENT_TYPE, "text/html")
+            .body(Body::from(format!("<!DOCTYPE html>{}", page)))
+            .unwrap()
+    }
+
+    fn handle_visualize_rbx(&self) -> Response<Body> {
+        let rbx_session = self.live_session.rbx_session.lock().unwrap();
+        let dot_source = format!("{}", VisualizeRbxSession(&rbx_session));
+
+        match graphviz_to_svg(&dot_source) {
+            Some(svg) => Response::builder()
+                .header(header::CONTENT_TYPE, "image/svg+xml")
+                .body(Body::from(svg))
+                .unwrap(),
+            None => Response::builder()
+                .header(header::CONTENT_TYPE, "text/plain")
+                .body(Body::from(dot_source))
+                .unwrap(),
+        }
+    }
+
+    fn handle_visualize_imfs(&self) -> Response<Body> {
+        let imfs = self.live_session.imfs.lock().unwrap();
+        let dot_source = format!("{}", VisualizeImfs(&imfs));
+
+        match graphviz_to_svg(&dot_source) {
+            Some(svg) => Response::builder()
+                .header(header::CONTENT_TYPE, "image/svg+xml")
+                .body(Body::from(svg))
+                .unwrap(),
+            None => Response::builder()
+                .header(header::CONTENT_TYPE, "text/plain")
+                .body(Body::from(dot_source))
+                .unwrap(),
+        }
+    }
+}
--- a/server/src/web/mod.rs
+++ b/server/src/web/mod.rs
@@ -0,0 +1,85 @@
+// TODO: This module needs to be public for visualize, we should move
+// PublicInstanceMetadata and switch this private!
+pub mod api;
+mod interface;
+
+use std::sync::Arc;
+
+use log::trace;
+use futures::{
+    future::{self, FutureResult},
+    Future,
+};
+use hyper::{
+    service::Service,
+    Body,
+    Request,
+    Response,
+    Server,
+};
+
+use crate::{
+    live_session::LiveSession,
+};
+
+use self::{
+    api::ApiService,
+    interface::InterfaceService,
+};
+
+pub struct RootService {
+    api: api::ApiService,
+    interface: interface::InterfaceService,
+}
+
+impl Service for RootService {
+    type ReqBody = Body;
+    type ResBody = Body;
+    type Error = hyper::Error;
+    type Future = Box<dyn Future<Item = Response<Self::ReqBody>, Error = Self::Error> + Send>;
+
+    fn call(&mut self, request: Request<Self::ReqBody>) -> Self::Future {
+        trace!("{} {}", request.method(), request.uri().path());
+
+        if request.uri().path().starts_with("/api") {
+            self.api.call(request)
+        } else {
+            self.interface.call(request)
+        }
+    }
+}
+
+impl RootService {
+    pub fn new(live_session: Arc<LiveSession>) -> RootService {
+        RootService {
+            api: ApiService::new(Arc::clone(&live_session)),
+            interface: InterfaceService::new(Arc::clone(&live_session)),
+        }
+    }
+}
+
+pub struct LiveServer {
+    live_session: Arc<LiveSession>,
+}
+
+impl LiveServer {
+    pub fn new(live_session: Arc<LiveSession>) -> LiveServer {
+        LiveServer {
+            live_session,
+        }
+    }
+
+    pub fn start(self, port: u16) {
+        let address = ([127, 0, 0, 1], port).into();
+
+        let server = Server::bind(&address)
+            .serve(move || {
+                let service: FutureResult<_, hyper::Error> =
+                    future::ok(RootService::new(Arc::clone(&self.live_session)));
+                service
+            })
+            .map_err(|e| eprintln!("Server error: {}", e));
+
+        hyper::rt::run(server);
+    }
+}
--- a/server/src/web_util.rs
+++ b/server/src/web_util.rs
@@ -1,43 +0,0 @@
-use std::io::Read;
-
-use rouille;
-use serde;
-use serde_json;
-
-static MAX_BODY_SIZE: usize = 100 * 1024 * 1024; // 100 MiB
-
-/// Pulls text that may be JSON out of a Rouille Request object.
-///
-/// Doesn't do any actual parsing -- all this method does is verify the content
-/// type of the request and read the request's body.
-fn read_json_text(request: &rouille::Request) -> Option<String> {
-    // Bail out if the request body isn't marked as JSON
-    let content_type = request.header("Content-Type")?;
-
-    if !content_type.starts_with("application/json") {
-        return None;
-    }
-
-    let body = request.data()?;
-
-    // Allocate a buffer and read up to MAX_BODY_SIZE+1 bytes into it.
-    let mut out = Vec::new();
-    body.take(MAX_BODY_SIZE.saturating_add(1) as u64).read_to_end(&mut out).ok()?;
-
-    // If the body was too big (MAX_BODY_SIZE+1), we abort instead of trying to
-    // process it.
-    if out.len() > MAX_BODY_SIZE {
-        return None;
-    }
-
-    String::from_utf8(out).ok()
-}
-
-/// Reads the body out of a Rouille Request and attempts to turn it into JSON.
-pub fn read_json<T>(request: &rouille::Request) -> Option<T>
-where
-    T: serde::de::DeserializeOwned,
-{
-    let body = read_json_text(&request)?;
-    serde_json::from_str(&body).ok()?
-}
--- a/server/tests/read_projects.rs
+++ b/server/tests/read_projects.rs
@@ -1,16 +1,15 @@
 #[macro_use] extern crate lazy_static;

-extern crate librojo;
-
 use std::{
    collections::HashMap,
    path::{Path, PathBuf},
 };

-use rbx_tree::RbxValue;
+use pretty_assertions::assert_eq;
+use rbx_dom_weak::RbxValue;

 use librojo::{
-    project::{Project, ProjectNode, InstanceProjectNode, SyncPointProjectNode},
+    project::{Project, ProjectNode},
 };

 lazy_static! {
@@ -44,54 +43,53 @@ fn empty_fuzzy_folder() {
 }

 #[test]
-fn single_sync_point() {
-    let project_file_location = TEST_PROJECTS_ROOT.join("single-sync-point/default.project.json");
-    let project = Project::load_exact(&project_file_location).unwrap();
+fn single_partition_game() {
+    let project_location = TEST_PROJECTS_ROOT.join("single_partition_game");
+    let project = Project::load_fuzzy(&project_location).unwrap();

    let expected_project = {
-        let foo = ProjectNode::SyncPoint(SyncPointProjectNode {
-            path: project_file_location.parent().unwrap().join("lib"),
-        });
+        let foo = ProjectNode {
+            path: Some(project_location.join("lib")),
+            ..Default::default()
+        };

        let mut replicated_storage_children = HashMap::new();
        replicated_storage_children.insert("Foo".to_string(), foo);

-        let replicated_storage = ProjectNode::Instance(InstanceProjectNode {
-            class_name: "ReplicatedStorage".to_string(),
+        let replicated_storage = ProjectNode {
+            class_name: Some(String::from("ReplicatedStorage")),
            children: replicated_storage_children,
-            properties: HashMap::new(),
-            metadata: Default::default(),
-        });
+            ..Default::default()
+        };

        let mut http_service_properties = HashMap::new();
        http_service_properties.insert("HttpEnabled".to_string(), RbxValue::Bool {
            value: true,
-        });
+        }.into());

-        let http_service = ProjectNode::Instance(InstanceProjectNode {
-            class_name: "HttpService".to_string(),
-            children: HashMap::new(),
+        let http_service = ProjectNode {
+            class_name: Some(String::from("HttpService")),
            properties: http_service_properties,
-            metadata: Default::default(),
-        });
+            ..Default::default()
+        };

        let mut root_children = HashMap::new();
        root_children.insert("ReplicatedStorage".to_string(), replicated_storage);
        root_children.insert("HttpService".to_string(), http_service);

-        let root_node = ProjectNode::Instance(InstanceProjectNode {
-            class_name: "DataModel".to_string(),
+        let root_node = ProjectNode {
+            class_name: Some(String::from("DataModel")),
            children: root_children,
-            properties: HashMap::new(),
-            metadata: Default::default(),
-        });
+            ..Default::default()
+        };

        Project {
            name: "single-sync-point".to_string(),
            tree: root_node,
+            plugins: Vec::new(),
            serve_port: None,
            serve_place_ids: None,
-            file_location: project_file_location.clone(),
+            file_location: project_location.join("default.project.json"),
        }
    };

@@ -99,9 +97,17 @@ fn single_sync_point() {
 }

 #[test]
-fn test_model() {
-    let project_file_location = TEST_PROJECTS_ROOT.join("test-model/default.project.json");
-    let project = Project::load_exact(&project_file_location).unwrap();
+fn single_partition_model() {
+    let project_file_location = TEST_PROJECTS_ROOT.join("single_partition_model");
+    let project = Project::load_fuzzy(&project_file_location).unwrap();

    assert_eq!(project.name, "test-model");
+}
+
+#[test]
+fn composing_models() {
+    let project_file_location = TEST_PROJECTS_ROOT.join("composing_models");
+    let project = Project::load_fuzzy(&project_file_location).unwrap();
+
+    assert_eq!(project.name, "composing-models");
 }
--- a/server/tests/snapshots.rs
+++ b/server/tests/snapshots.rs
@@ -0,0 +1,128 @@
+use std::{
+    fs::{self, File},
+    path::{Path, PathBuf},
+};
+
+use pretty_assertions::assert_eq;
+
+use librojo::{
+    imfs::Imfs,
+    project::{Project, ProjectNode},
+    rbx_snapshot::{SnapshotContext, snapshot_project_tree},
+    snapshot_reconciler::{RbxSnapshotInstance},
+};
+
+macro_rules! generate_snapshot_tests {
+    ($($name: ident),*) => {
+        $(
+            paste::item! {
+                #[test]
+                fn [<snapshot_ $name>]() {
+                    let tests_folder = Path::new(env!("CARGO_MANIFEST_DIR")).join("../test-projects");
+                    let project_folder = tests_folder.join(stringify!($name));
+                    run_snapshot_test(&project_folder);
+                }
+            }
+        )*
+    };
+}
+
+generate_snapshot_tests!(
+    empty,
+    nested_partitions,
+    single_partition_game,
+    single_partition_model,
+    transmute_partition
+);
+
+const SNAPSHOT_EXPECTED_NAME: &str = "expected-snapshot.json";
+
+fn run_snapshot_test(path: &Path) {
+    println!("Running snapshot from project: {}", path.display());
+
+    let project = Project::load_fuzzy(path)
+        .expect("Couldn't load project file for snapshot test");
+
+    let mut imfs = Imfs::new();
+    imfs.add_roots_from_project(&project)
+        .expect("Could not add IMFS roots to snapshot project");
+
+    let context = SnapshotContext {
+        plugin_context: None,
+    };
+
+    let mut snapshot = snapshot_project_tree(&context, &imfs, &project)
+        .expect("Could not generate snapshot for snapshot test");
+
+    if let Some(snapshot) = snapshot.as_mut() {
+        anonymize_snapshot(path, snapshot);
+    }
+
+    match read_expected_snapshot(path) {
+        Some(expected_snapshot) => assert_eq!(snapshot, expected_snapshot),
+        None => write_expected_snapshot(path, &snapshot),
+    }
+}
+
+/// Snapshots contain absolute paths, which simplifies much of Rojo.
+///
+/// For saving snapshots to the disk, we should strip off the project folder
+/// path to make them machine-independent. This doesn't work for paths that fall
+/// outside of the project folder, but that's okay here.
+///
+/// We also need to sort children, since Rojo tends to enumerate the filesystem
+/// in an unpredictable order.
+fn anonymize_snapshot(project_folder_path: &Path, snapshot: &mut RbxSnapshotInstance) {
+    match snapshot.metadata.source_path.as_mut() {
+        Some(path) => *path = anonymize_path(project_folder_path, path),
+        None => {},
+    }
+
+    match snapshot.metadata.project_definition.as_mut() {
+        Some((_, project_node)) => anonymize_project_node(project_folder_path, project_node),
+        None => {},
+    }
+
+    snapshot.children.sort_by(|a, b| a.partial_cmp(b).unwrap());
+
+    for child in snapshot.children.iter_mut() {
+        anonymize_snapshot(project_folder_path, child);
+    }
+}
+
+fn anonymize_project_node(project_folder_path: &Path, project_node: &mut ProjectNode) {
+    match project_node.path.as_mut() {
+        Some(path) => *path = anonymize_path(project_folder_path, path),
+        None => {},
+    }
+
+    for child_node in project_node.children.values_mut() {
+        anonymize_project_node(project_folder_path, child_node);
+    }
+}
+
+fn anonymize_path(project_folder_path: &Path, path: &Path) -> PathBuf {
+    if path.is_absolute() {
+        path.strip_prefix(project_folder_path)
+            .expect("Could not anonymize absolute path")
+            .to_path_buf()
+    } else {
+        path.to_path_buf()
+    }
+}
+
+fn read_expected_snapshot(path: &Path) -> Option<Option<RbxSnapshotInstance<'static>>> {
+    let contents = fs::read(path.join(SNAPSHOT_EXPECTED_NAME)).ok()?;
+    let snapshot: Option<RbxSnapshotInstance<'static>> = serde_json::from_slice(&contents)
+        .expect("Could not deserialize snapshot");
+
+    Some(snapshot)
+}
+
+fn write_expected_snapshot(path: &Path, snapshot: &Option<RbxSnapshotInstance>) {
+    let mut file = File::create(path.join(SNAPSHOT_EXPECTED_NAME))
+        .expect("Could not open file to write snapshot");
+
+    serde_json::to_writer_pretty(&mut file, snapshot)
+        .expect("Could not serialize snapshot to file");
+}
--- a/test-projects/composing_models/default.project.json
+++ b/test-projects/composing_models/default.project.json
--- a/test-projects/composing_models/src/Binary.rbxm
+++ b/test-projects/composing_models/src/Binary.rbxm
--- a/test-projects/composing_models/src/Remotes.model.json
+++ b/test-projects/composing_models/src/Remotes.model.json
--- a/test-projects/composing_models/src/XML.rbxmx
+++ b/test-projects/composing_models/src/XML.rbxmx
--- a/test-projects/empty/expected-snapshot.json
+++ b/test-projects/empty/expected-snapshot.json
@@ -0,0 +1,20 @@
+{
+  "name": "empty",
+  "class_name": "DataModel",
+  "properties": {},
+  "children": [],
+  "metadata": {
+    "ignore_unknown_instances": true,
+    "source_path": null,
+    "project_definition": [
+      "empty",
+      {
+        "class_name": "DataModel",
+        "children": {},
+        "properties": {},
+        "ignore_unknown_instances": null,
+        "path": null
+      }
+    ]
+  }
+}
--- a/test-projects/malformed-stuff/default.project.json
+++ b/test-projects/malformed-stuff/default.project.json
@@ -0,0 +1,6 @@
+{
+  "name": "malformed-stuff",
+  "tree": {
+    "$path": "src"
+  }
+}
--- a/test-projects/malformed-stuff/src/bad-model.model.json
+++ b/test-projects/malformed-stuff/src/bad-model.model.json
@@ -0,0 +1,2 @@
+ahhh this isn't a JSON model
+bamboozled again
--- a/test-projects/missing_files/default.project.json
+++ b/test-projects/missing_files/default.project.json
--- a/test-projects/nested_partitions/default.project.json
+++ b/test-projects/nested_partitions/default.project.json
@@ -0,0 +1,9 @@
+{
+  "name": "nested-partitions",
+  "tree": {
+    "$path": "outer",
+    "inner": {
+      "$path": "inner"
+    }
+  }
+}
--- a/test-projects/nested_partitions/expected-snapshot.json
+++ b/test-projects/nested_partitions/expected-snapshot.json
@@ -0,0 +1,82 @@
+{
+  "name": "nested-partitions",
+  "class_name": "Folder",
+  "properties": {},
+  "children": [
+    {
+      "name": "inner",
+      "class_name": "Folder",
+      "properties": {},
+      "children": [
+        {
+          "name": "hello",
+          "class_name": "ModuleScript",
+          "properties": {
+            "Source": {
+              "Type": "String",
+              "Value": "-- inner/hello.lua"
+            }
+          },
+          "children": [],
+          "metadata": {
+            "ignore_unknown_instances": false,
+            "source_path": "inner/hello.lua",
+            "project_definition": null
+          }
+        }
+      ],
+      "metadata": {
+        "ignore_unknown_instances": false,
+        "source_path": "inner",
+        "project_definition": [
+          "inner",
+          {
+            "class_name": null,
+            "children": {},
+            "properties": {},
+            "ignore_unknown_instances": null,
+            "path": "inner"
+          }
+        ]
+      }
+    },
+    {
+      "name": "world",
+      "class_name": "ModuleScript",
+      "properties": {
+        "Source": {
+          "Type": "String",
+          "Value": "-- outer/world.lua"
+        }
+      },
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": false,
+        "source_path": "outer/world.lua",
+        "project_definition": null
+      }
+    }
+  ],
+  "metadata": {
+    "ignore_unknown_instances": false,
+    "source_path": "outer",
+    "project_definition": [
+      "nested-partitions",
+      {
+        "class_name": null,
+        "children": {
+          "inner": {
+            "class_name": null,
+            "children": {},
+            "properties": {},
+            "ignore_unknown_instances": null,
+            "path": "inner"
+          }
+        },
+        "properties": {},
+        "ignore_unknown_instances": null,
+        "path": "outer"
+      }
+    ]
+  }
+}
--- a/test-projects/nested_partitions/inner/hello.lua
+++ b/test-projects/nested_partitions/inner/hello.lua
@@ -0,0 +1 @@
+-- inner/hello.lua
--- a/test-projects/nested_partitions/outer/world.lua
+++ b/test-projects/nested_partitions/outer/world.lua
@@ -0,0 +1 @@
+-- outer/world.lua
--- a/test-projects/single-sync-point/lib/sampleTranslation.csv
+++ b/test-projects/single-sync-point/lib/sampleTranslation.csv
@@ -1,6 +0,0 @@
-Key,Context,Example,Source,es-es,de
-,ClickableGroup:BuilderGui:TextLabel,You got 22 hearts!,You got {1} hearts!,,
-,,"Team ""Red"" wins!","Team ""{1}"" wins!","¡Gana el equipo ""{1}""!","¡Gana el equipo ""{1}""!"
-,Frame:TextLabel,,"{1} killed {2}, with a {3}","{1} mató a {2} con
-una escopeta","{1} mató a {2} con
-una escopeta"
--- a/test-projects/single_partition_game/default.project.json
+++ b/test-projects/single_partition_game/default.project.json
@@ -11,10 +11,7 @@
    "HttpService": {
      "$className": "HttpService",
      "$properties": {
-        "HttpEnabled": {
-          "Type": "Bool",
-          "Value": true
-        }
+        "HttpEnabled": true
      }
    }
  }
--- a/test-projects/single_partition_game/expected-snapshot.json
+++ b/test-projects/single_partition_game/expected-snapshot.json
@@ -0,0 +1,161 @@
+{
+  "name": "single-sync-point",
+  "class_name": "DataModel",
+  "properties": {},
+  "children": [
+    {
+      "name": "HttpService",
+      "class_name": "HttpService",
+      "properties": {
+        "HttpEnabled": {
+          "Type": "Bool",
+          "Value": true
+        }
+      },
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": true,
+        "source_path": null,
+        "project_definition": [
+          "HttpService",
+          {
+            "class_name": "HttpService",
+            "children": {},
+            "properties": {
+              "HttpEnabled": {
+                "Type": "Bool",
+                "Value": true
+              }
+            },
+            "ignore_unknown_instances": null,
+            "path": null
+          }
+        ]
+      }
+    },
+    {
+      "name": "ReplicatedStorage",
+      "class_name": "ReplicatedStorage",
+      "properties": {},
+      "children": [
+        {
+          "name": "Foo",
+          "class_name": "Folder",
+          "properties": {},
+          "children": [
+            {
+              "name": "foo",
+              "class_name": "StringValue",
+              "properties": {
+                "Value": {
+                  "Type": "String",
+                  "Value": "Hello world, from foo.txt"
+                }
+              },
+              "children": [],
+              "metadata": {
+                "ignore_unknown_instances": false,
+                "source_path": "lib/foo.txt",
+                "project_definition": null
+              }
+            },
+            {
+              "name": "main",
+              "class_name": "ModuleScript",
+              "properties": {
+                "Source": {
+                  "Type": "String",
+                  "Value": "-- hello, from main"
+                }
+              },
+              "children": [],
+              "metadata": {
+                "ignore_unknown_instances": false,
+                "source_path": "lib/main.lua",
+                "project_definition": null
+              }
+            }
+          ],
+          "metadata": {
+            "ignore_unknown_instances": false,
+            "source_path": "lib",
+            "project_definition": [
+              "Foo",
+              {
+                "class_name": null,
+                "children": {},
+                "properties": {},
+                "ignore_unknown_instances": null,
+                "path": "lib"
+              }
+            ]
+          }
+        }
+      ],
+      "metadata": {
+        "ignore_unknown_instances": true,
+        "source_path": null,
+        "project_definition": [
+          "ReplicatedStorage",
+          {
+            "class_name": "ReplicatedStorage",
+            "children": {
+              "Foo": {
+                "class_name": null,
+                "children": {},
+                "properties": {},
+                "ignore_unknown_instances": null,
+                "path": "lib"
+              }
+            },
+            "properties": {},
+            "ignore_unknown_instances": null,
+            "path": null
+          }
+        ]
+      }
+    }
+  ],
+  "metadata": {
+    "ignore_unknown_instances": true,
+    "source_path": null,
+    "project_definition": [
+      "single-sync-point",
+      {
+        "class_name": "DataModel",
+        "children": {
+          "HttpService": {
+            "class_name": "HttpService",
+            "children": {},
+            "properties": {
+              "HttpEnabled": {
+                "Type": "Bool",
+                "Value": true
+              }
+            },
+            "ignore_unknown_instances": null,
+            "path": null
+          },
+          "ReplicatedStorage": {
+            "class_name": "ReplicatedStorage",
+            "children": {
+              "Foo": {
+                "class_name": null,
+                "children": {},
+                "properties": {},
+                "ignore_unknown_instances": null,
+                "path": "lib"
+              }
+            },
+            "properties": {},
+            "ignore_unknown_instances": null,
+            "path": null
+          }
+        },
+        "properties": {},
+        "ignore_unknown_instances": null,
+        "path": null
+      }
+    ]
+  }
+}
--- a/test-projects/single_partition_game/lib/foo.txt
+++ b/test-projects/single_partition_game/lib/foo.txt
--- a/test-projects/single_partition_game/lib/main.lua
+++ b/test-projects/single_partition_game/lib/main.lua
--- a/test-projects/single_partition_model/default.project.json
+++ b/test-projects/single_partition_model/default.project.json
--- a/test-projects/single_partition_model/expected-snapshot.json
+++ b/test-projects/single_partition_model/expected-snapshot.json
@@ -0,0 +1,53 @@
+{
+  "name": "test-model",
+  "class_name": "Folder",
+  "properties": {},
+  "children": [
+    {
+      "name": "main",
+      "class_name": "Script",
+      "properties": {
+        "Source": {
+          "Type": "String",
+          "Value": "local other = require(script.Parent.other)\n\nprint(other)"
+        }
+      },
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": false,
+        "source_path": "src/main.server.lua",
+        "project_definition": null
+      }
+    },
+    {
+      "name": "other",
+      "class_name": "ModuleScript",
+      "properties": {
+        "Source": {
+          "Type": "String",
+          "Value": "return \"Hello, world!\""
+        }
+      },
+      "children": [],
+      "metadata": {
+        "ignore_unknown_instances": false,
+        "source_path": "src/other.lua",
+        "project_definition": null
+      }
+    }
+  ],
+  "metadata": {
+    "ignore_unknown_instances": false,
+    "source_path": "src",
+    "project_definition": [
+      "test-model",
+      {
+        "class_name": null,
+        "children": {},
+        "properties": {},
+        "ignore_unknown_instances": null,
+        "path": "src"
+      }
+    ]
+  }
+}
--- a/test-projects/single_partition_model/src/main.server.lua
+++ b/test-projects/single_partition_model/src/main.server.lua
--- a/test-projects/single_partition_model/src/other.lua
+++ b/test-projects/single_partition_model/src/other.lua
--- a/test-projects/transmute_partition/ReplicatedStorage/hello.lua
+++ b/test-projects/transmute_partition/ReplicatedStorage/hello.lua
@@ -0,0 +1 @@
+-- ReplicatedStorage/hello.lua
--- a/test-projects/transmute_partition/default.project.json
+++ b/test-projects/transmute_partition/default.project.json
@@ -0,0 +1,11 @@
+{
+  "name": "transmute-partition",
+  "tree": {
+    "$className": "DataModel",
+
+    "ReplicatedStorage": {
+      "$className": "ReplicatedStorage",
+      "$path": "ReplicatedStorage"
+    }
+  }
+}
--- a/test-projects/transmute_partition/expected-snapshot.json
+++ b/test-projects/transmute_partition/expected-snapshot.json
@@ -0,0 +1,66 @@
+{
+  "name": "transmute-partition",
+  "class_name": "DataModel",
+  "properties": {},
+  "children": [
+    {
+      "name": "ReplicatedStorage",
+      "class_name": "ReplicatedStorage",
+      "properties": {},
+      "children": [
+        {
+          "name": "hello",
+          "class_name": "ModuleScript",
+          "properties": {
+            "Source": {
+              "Type": "String",
+              "Value": "-- ReplicatedStorage/hello.lua"
+            }
+          },
+          "children": [],
+          "metadata": {
+            "ignore_unknown_instances": false,
+            "source_path": "ReplicatedStorage/hello.lua",
+            "project_definition": null
+          }
+        }
+      ],
+      "metadata": {
+        "ignore_unknown_instances": false,
+        "source_path": "ReplicatedStorage",
+        "project_definition": [
+          "ReplicatedStorage",
+          {
+            "class_name": "ReplicatedStorage",
+            "children": {},
+            "properties": {},
+            "ignore_unknown_instances": null,
+            "path": "ReplicatedStorage"
+          }
+        ]
+      }
+    }
+  ],
+  "metadata": {
+    "ignore_unknown_instances": true,
+    "source_path": null,
+    "project_definition": [
+      "transmute-partition",
+      {
+        "class_name": "DataModel",
+        "children": {
+          "ReplicatedStorage": {
+            "class_name": "ReplicatedStorage",
+            "children": {},
+            "properties": {},
+            "ignore_unknown_instances": null,
+            "path": "ReplicatedStorage"
+          }
+        },
+        "properties": {},
+        "ignore_unknown_instances": null,
+        "path": null
+      }
+    ]
+  }
+}
Author	SHA1	Message	Date
Lucien Greathouse	b65a8ce680	0.5.0-alpha.5	2019-03-01 15:40:30 -08:00
Lucien Greathouse	5fc4f63238	Upgrade dependencies	2019-03-01 15:34:16 -08:00
Lucien Greathouse	9b0e0c175b	Add missing CHANGELOG note	2019-02-27 17:32:36 -08:00
Lucien Greathouse	eb97e925e6	Flip LiveSession::session_id private, add getter	2019-02-27 14:54:05 -08:00
Lucien Greathouse	16f8975b18	Flip project field of LiveSession private to prepare for multi-project future	2019-02-27 14:51:53 -08:00
Lucien Greathouse	5073fce2f7	Implement LiveSession::restart_with_new_project as foundation for reloading	2019-02-27 14:42:41 -08:00
Lucien Greathouse	cf5036eec6	Fix warnings compiling server	2019-02-27 00:49:38 -08:00
Lucien Greathouse	20be37dd8b	Improve error messages from bad snapshots	2019-02-27 00:47:02 -08:00
Lucien Greathouse	93349ae2dc	Use rbx_reflection to allow type inference on projects (#130 ) * Start dependency on rbx_reflection * Alive and working, all tests pass * Update CHANGELOG	2019-02-26 22:51:21 -08:00
Lucien Greathouse	be81de74cd	Disable Lua tests for now, since they need features Lemur doesn't have	2019-02-24 00:58:02 -08:00
Lucien Greathouse	88e739090d	WIP: Server plugins via rlua (Lua 5.3) (#125 ) * Add 'plugins' field to project and add rlua * Scaffold out new SnapshotContext type (again) with plugin state * Almost functional snapshot system with rlua proof-of-concept * Gate plugin config on 'plugins-enabled' feature, tell Travis to test all features * Guard remaining plugin setup code behind feature * Bump minimum version to 1.33, should've caught this before * Whoops, latest Rust is 1.32, not 1.33	2019-02-24 00:31:58 -08:00
Lucien Greathouse	7f324f1957	Update CHANGELOG	2019-02-22 15:57:46 -08:00
Lucien Greathouse	4f31c9e72f	Fix /api/read and /api/subscribe, re-add debug output	2019-02-22 15:56:24 -08:00
Lucien Greathouse	c9a663ed39	Remove Rouille and port everything to Hyper	2019-02-22 15:11:27 -08:00
Lucien Greathouse	105d8aeb6b	Start to stub out sub-services	2019-02-22 13:08:07 -08:00
Lucien Greathouse	6ea1211bc5	It's alive!	2019-02-22 10:50:14 -08:00
Lucien Greathouse	c13291a598	Break apart web interface between UI and API	2019-02-19 11:44:24 -08:00
Lucien Greathouse	aaa78c618c	Move diagnostics page to use Ritz, show server version	2019-02-19 11:27:22 -08:00
Lucien Greathouse	2890c677d4	Bump dependency from rbx_tree 0.2.0 to rbx_dom_weak 0.3.0	2019-02-14 17:22:44 -08:00
Lucien Greathouse	51a010de00	Update CHANGELOG	2019-02-11 13:48:20 -08:00
Lucien Greathouse	ca0aabd814	Preload plugin assets at start. Closes #121.	2019-02-11 13:47:49 -08:00
Lucien Greathouse	91d1ba1910	Add test for rojoValueToRobloxValue, fails Lemur because of missing APIs right now	2019-02-11 11:43:17 -08:00
Lucien Greathouse	c7c739dc00	Fix test bootstrap script for testing in Studio	2019-02-11 11:43:06 -08:00
Lucien Greathouse	7a8389bf11	Update CHANGELOG	2019-02-11 11:42:40 -08:00
Lucien Greathouse	5f062b8ea3	Make the plugin support non-primitive types	2019-02-11 10:55:03 -08:00
Lucien Greathouse	b9ee14a0f9	Remove unused Cargo features section	2019-02-11 10:27:09 -08:00
Lucien Greathouse	c3baf73455	Update documentation for alpha 4	2019-02-08 18:29:23 -08:00
Lucien Greathouse	4a597e0ba7	0.5.0-alpha.4	2019-02-08 18:20:48 -08:00
Lucien Greathouse	d5f3e25bea	New docs	2019-02-08 18:03:46 -08:00
Lucien Greathouse	5e4c1a8359	Flatten out docs	2019-02-08 15:41:17 -08:00
Lucien Greathouse	d86e655ad2	Update CHANGELOG	2019-02-08 14:07:21 -08:00
Lucien Greathouse	80154bbf9f	Build with static CRT on Windows, fixes #89 .	2019-02-08 13:52:57 -08:00
Lucien Greathouse	be853ba2a7	Improve docs, add internals guide	2019-02-07 17:11:35 -08:00
Lucien Greathouse	4d3036d030	Add more design documentation into the codebase for high-level concepts	2019-02-07 15:26:01 -08:00
Lucien Greathouse	ecb9b5e28f	Support nested partitions and partitions directly targeting services (#122 ) * Do the nested partition thing * Tidy up touched code * Add nested partition test project, not fully functional * Clean up variable names, move path_metadata mutation strictly into snapshot_reconciler * Remove path_metadata, snapshotting is now pure * Factor out snapshot metadata storage to fix a missing case * Pull instance_name out of per_path_metadata, closer to what we need * Refactor to make metadata make more sense, part one * All appears to be well * Cull 'metadata_per_path' in favor of 'instances_per_path' * Remove SnapshotContext * InstanceMetadata -> PublicInstanceMetadata in web module * Build in snapshot testing system for testing... snapshots? * Remove pretty_assertions to see if it fixes a snapshot comparison bug * Reintroduce pretty assertions, it's not the cause of inequality * Fix snapshot tests with custom relative path serializer	2019-02-07 14:55:01 -08:00
Lucien Greathouse	38e3c198f2	Update README	2019-02-05 10:30:09 -08:00
Lucien Greathouse	2f64501556	Add Rust 1.31.1 as fixed build target to Travis-CI	2019-02-05 10:17:13 -08:00
Lucien Greathouse	2c2554d73d	Update docs to talk about default.project.json	2019-02-01 18:03:41 -08:00