Release 0.5.3

ACTUALLY closes #173.

.gitignore

@@ -1,5 +1,9 @@
-/site
 /target
 /scratch-project
+/server/failed-snapshots/
 **/*.rs.bk
-/server/failed-snapshots/
+/*.rbxm
+/*.rbxmx
+/*.rbxl
+/*.rbxlx
+**/*.snap.new

.gitmodules

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

.travis.yml

@@ -30,25 +30,15 @@ matrix:
     #     - luacov-coveralls -e $TRAVIS_BUILD_DIR/lua_install
 
     - language: rust
-      rust: 1.32.0
+      rust: 1.34.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 --all-features
+        - cargo test --verbose

CHANGELOG.md

@@ -1,8 +1,73 @@
 # Rojo Changelog
 
-## [Unreleased]
+## Unreleased Changes
 
-## [0.5.0 Alpha 8](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.8) (March 29, 2019)
+## [0.5.3](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.3) (October 15, 2019)
+* Fixed an issue where Rojo would throw an error when encountering recently-added instance classes.
+
+## [0.5.2](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.2) (October 14, 2019)
+* Fixed an issue where `LocalizationTable` instances would have their column order randomized. ([#173](https://github.com/rojo-rbx/rojo/issues/173))
+
+## [0.5.1](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.1) (October 4, 2019)
+* Fixed an issue where Rojo would drop changes if they happened too quickly ([#252](https://github.com/rojo-rbx/rojo/issues/252))
+* Improved diagnostics for when the Rojo plugin cannot create an instance.
+* Updated dependencies
+    * This brings Rojo's reflection database from client release 395 to client release 404.
+
+## [0.5.0](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0) (August 27, 2019)
+* Changed `.model.json` naming, which may require projects to migrate ambiguous cases:
+    * The file name now takes precedence over the `Name` field in the model, like Rojo 0.4.x.
+    * The `Name` field of the top-level instance is now optional. It's recommended that you remove it from your models.
+    * Rojo will emit a warning when `Name` is specified and does not match the name from the file.
+* Fixed `Rect` values being set to `0, 0, 0, 0` when synced with the Rojo plugin. ([#201](https://github.com/rojo-rbx/rojo/issues/201))
+* Fixed live-syncing of `PhysicalProperties`, `NumberSequence`, and `ColorSequence` values
+
+## [0.5.0 Alpha 13](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.13) (August 2, 2019)
+* Bumped minimum Rust version to 1.34.0.
+* Fixed default port documentation in `rojo serve --help` ([#219](https://github.com/rojo-rbx/rojo/issues/219))
+* Fixed BrickColor support by upgrading Roblox-related dependencies
+
+## [0.5.0 Alpha 12](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.12) (July 2, 2019)
+* Added `.meta.json` files
+    * `init.meta.json` files replace `init.model.json` files from Rojo 0.4.x ([#183](https://github.com/rojo-rbx/rojo/pull/183))
+    * Other `.meta.json` files allow attaching extra data to other files ([#189](https://github.com/rojo-rbx/rojo/pull/189))
+* Added support for infinite and NaN values in types like `Vector2` when building models and places.
+    * These types aren't supported for live-syncing yet due to limitations around JSON encoding.
+* Added support for using `SharedString` values when building XML models and places.
+* Added support for live-syncing `CollectionService` tags.
+* Added a warning when building binary place files, since they're still experimental and have bugs.
+* Added a warning when trying to use Rojo 0.5.x with a Rojo 0.4.x-only project.
+* Added a warning when a Rojo project contains keys that start with `$`, which are reserved names. ([#191](https://github.com/rojo-rbx/rojo/issues/191))
+* Rojo now throws an error if unknown keys are found most files.
+* Added an icon to the plugin's toolbar button
+* Changed the plugin to use a docking widget for all UI.
+* Changed the plugin to ignore unknown properties when live-syncing.
+    * Rojo's approach to this problem might change later, like with a strict model mode ([#190](https://github.com/rojo-rbx/rojo/issues/190)) or another approach.
+* Upgraded to reflection database from client release 388.
+* Updated Rojo's branding to shift the color palette to make it work better on dark backgrounds
+
+## [0.5.0 Alpha 11](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.11) (May 29, 2019)
+* Added support for implicit property values in JSON model files ([#154](https://github.com/rojo-rbx/rojo/pull/154))
+* `Content` propertyes can now be specified in projects and model files as regular string literals.
+* Added support for `BrickColor` properties.
+* Added support for properties added in client release 384, like `Lighting.Technology` being set to `"ShadowMap"`.
+* Improved performance when working with XML models and places
+* Fixed serializing empty `Content` properties as XML
+* Fixed serializing infinite and NaN floating point properties in XML
+* Improved compatibility with XML models
+* Plugin should now be able to live-sync more properties, and ignore ones it can't, like `Lighting.Technology`.
+
+## 0.5.0 Alpha 10
+* This release was a dud due to [issue #176](https://github.com/rojo-rbx/rojo/issues/176) and was rolled back.
+
+## [0.5.0 Alpha 9](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.9) (April 4, 2019)
+* Changed `rojo build` to use buffered I/O, which can make it up to 2x faster in some cases.
+    * Building [*Road Not Taken*](https://github.com/rojo-rbx/roads) to an `rbxlx` file dropped from 150ms to 70ms on my machine
+* Fixed `LocalizationTable` instances being made from `csv` files incorrectly interpreting empty rows and columns. ([#149](https://github.com/rojo-rbx/rojo/pull/149))
+* Fixed CSV files with entries that parse as numbers causing Rojo to panic. ([#152](https://github.com/rojo-rbx/rojo/pull/152))
+* Improved error messages when malformed CSV files are found in a Rojo project.
+
+## [0.5.0 Alpha 8](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.8) (March 29, 2019)
 * Added support for a bunch of new types when dealing with XML model/place files:
     * `ColorSequence`
     * `Float64`
@@ -13,13 +78,13 @@
     * `Ray`
     * `Rect`
     * `Ref`
-* Improved server instance ordering behavior when files are added during a live session ([#135](https://github.com/LPGhatguy/rojo/pull/135))
+* Improved server instance ordering behavior when files are added during a live session ([#135](https://github.com/rojo-rbx/rojo/pull/135))
 * Fixed error being thrown when trying to unload the Rojo plugin.
-* Added partial fix for [issue #141](https://github.com/LPGhatguy/rojo/issues/141) for `Lighting.Technology`, which should restore live sync functionality for the default project file.
+* Added partial fix for [issue #141](https://github.com/rojo-rbx/rojo/issues/141) for `Lighting.Technology`, which should restore live sync functionality for the default project file.
 
-## [0.5.0 Alpha 6](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.6) (March 19, 2019)
+## [0.5.0 Alpha 6](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.6) (March 19, 2019)
 * Fixed `rojo init` giving unexpected results by upgrading to `rbx_dom_weak` 1.1.0
-* Fixed live server not responding when the Rojo plugin is connected ([#133](https://github.com/LPGhatguy/rojo/issues/133))
+* Fixed live server not responding when the Rojo plugin is connected ([#133](https://github.com/rojo-rbx/rojo/issues/133))
 * Updated default place file:
     * Improved default properties to be closer to Studio's built-in 'Baseplate' template
     * Added a baseplate to the project file (Thanks, [@AmaranthineCodices](https://github.com/AmaranthineCodices/)!)
@@ -27,40 +92,40 @@
 * Fixed some cases where the Rojo plugin would leave around objects that it knows should be deleted
 * Updated plugin to correctly listen to `Plugin.Unloading` when installing or uninstalling new plugins
 
-## [0.5.0 Alpha 5](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.5) (March 1, 2019)
+## [0.5.0 Alpha 5](https://github.com/rojo-rbx/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))
+* Fixed plugin assets flashing in on first load ([#121](https://github.com/rojo-rbx/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))
+* Added property type inference to projects, which makes specifying services a lot easier ([#130](https://github.com/rojo-rbx/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 4](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.4) (February 8, 2019)
+* Added support for nested partitions ([#102](https://github.com/rojo-rbx/rojo/issues/102))
+* Added support for 'transmuting' partitions ([#112](https://github.com/rojo-rbx/rojo/issues/112))
+* Added support for aliasing filesystem paths ([#105](https://github.com/rojo-rbx/rojo/issues/105))
+* Changed Windows builds to statically link the CRT ([#89](https://github.com/rojo-rbx/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))
+## [0.5.0 Alpha 3](https://github.com/rojo-rbx/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/rojo-rbx/rojo/pull/120))
     * The old file name will still be supported until 0.5.0 is fully released.
 * Added warning when loading project files that don't end in `.project.json`
     * This new extension enables Rojo to distinguish project files from random JSON files, which is necessary to support nested projects.
 * Added new (empty) diagnostic page served from the server
 * Added better error messages for when a file is missing that's referenced by a Rojo project
 * Added support for visualization endpoints returning GraphViz source when Dot is not available
-* Fixed an in-memory filesystem regression introduced recently ([#119](https://github.com/LPGhatguy/rojo/pull/119))
+* Fixed an in-memory filesystem regression introduced recently ([#119](https://github.com/rojo-rbx/rojo/pull/119))
 
-## [0.5.0 Alpha 2](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.2) (January 28, 2019)
+## [0.5.0 Alpha 2](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.2) (January 28, 2019)
 * Added support for `.model.json` files, compatible with 0.4.x
 * Fixed in-memory filesystem not handling out-of-order filesystem change events
-* Fixed long-polling error caused by a promise mixup ([#110](https://github.com/LPGhatguy/rojo/issues/110))
+* Fixed long-polling error caused by a promise mixup ([#110](https://github.com/rojo-rbx/rojo/issues/110))
 
-## [0.5.0 Alpha 1](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.1) (January 25, 2019)
+## [0.5.0 Alpha 1](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.1) (January 25, 2019)
 * Changed plugin UI to be way prettier
     * Thanks to [Reselim](https://github.com/Reselim) for the design!
 * Changed plugin error messages to be a little more useful
@@ -68,7 +133,7 @@
 * Fixed bug where bad server responses could cause the plugin to be in a bad state
 * Upgraded to rbx\_tree, rbx\_xml, and rbx\_binary 0.2.0, which dramatically expands the kinds of properties that Rojo can handle, especially in XML.
 
-## [0.5.0 Alpha 0](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.0) (January 14, 2019)
+## [0.5.0 Alpha 0](https://github.com/rojo-rbx/rojo/releases/tag/v0.5.0-alpha.0) (January 14, 2019)
 * "Epiphany" rewrite, in progress since the beginning of time
 * New live sync protocol
     * Uses HTTP long polling to reduce request count and improve responsiveness
@@ -93,105 +158,105 @@
     * Multiple places can be specified, like when building a multi-place game
 * Added support for specifying properties on services in project files
 
-## [0.4.13](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.13) (November 12, 2018)
+## [0.4.13](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.13) (November 12, 2018)
 * When `rojo.json` points to a file or directory that does not exist, Rojo now issues a warning instead of throwing an error and exiting
 
-## [0.4.12](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.12) (June 21, 2018)
-* Fixed obscure assertion failure when renaming or deleting files ([#78](https://github.com/LPGhatguy/rojo/issues/78))
-* Added a `PluginAction` for the sync in command, which should help with some automation scripts ([#80](https://github.com/LPGhatguy/rojo/pull/80))
+## [0.4.12](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.12) (June 21, 2018)
+* Fixed obscure assertion failure when renaming or deleting files ([#78](https://github.com/rojo-rbx/rojo/issues/78))
+* Added a `PluginAction` for the sync in command, which should help with some automation scripts ([#80](https://github.com/rojo-rbx/rojo/pull/80))
 
-## [0.4.11](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.11) (June 10, 2018)
+## [0.4.11](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.11) (June 10, 2018)
 * Defensively insert existing instances into RouteMap; should fix most duplication cases when syncing into existing trees.
 * Fixed incorrect synchronization from `Plugin:_pull` that would cause polling to create issues
 * Fixed incorrect file routes being assigned to `init.lua` and `init.model.json` files
 * Untangled route handling-internals slightly
 
-## [0.4.10](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.10) (June 2, 2018)
-* Added support for `init.model.json` files, which enable versioning `Tool` instances (among other things) with Rojo. ([#66](https://github.com/LPGhatguy/rojo/issues/66))
+## [0.4.10](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.10) (June 2, 2018)
+* Added support for `init.model.json` files, which enable versioning `Tool` instances (among other things) with Rojo. ([#66](https://github.com/rojo-rbx/rojo/issues/66))
 * Fixed obscure error when syncing into an invalid service.
 * Fixed multiple sync processes occurring when a server ID mismatch is detected.
 
-## [0.4.9](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.9) (May 26, 2018)
-* Fixed warning when renaming or removing files that would sometimes corrupt the instance cache ([#72](https://github.com/LPGhatguy/rojo/pull/72))
+## [0.4.9](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.9) (May 26, 2018)
+* Fixed warning when renaming or removing files that would sometimes corrupt the instance cache ([#72](https://github.com/rojo-rbx/rojo/pull/72))
 * JSON models are no longer as strict -- `Children` and `Properties` are now optional.
 
-## [0.4.8](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.8) (May 26, 2018)
+## [0.4.8](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.8) (May 26, 2018)
 * Hotfix to prevent errors from being thrown when objects managed by Rojo are deleted
 
-## [0.4.7](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.7) (May 25, 2018)
-* Added icons to the Rojo plugin, made by [@Vorlias](https://github.com/Vorlias)! ([#70](https://github.com/LPGhatguy/rojo/pull/70))
-* Server will now issue a warning if no partitions are specified in `rojo serve` ([#40](https://github.com/LPGhatguy/rojo/issues/40))
+## [0.4.7](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.7) (May 25, 2018)
+* Added icons to the Rojo plugin, made by [@Vorlias](https://github.com/Vorlias)! ([#70](https://github.com/rojo-rbx/rojo/pull/70))
+* Server will now issue a warning if no partitions are specified in `rojo serve` ([#40](https://github.com/rojo-rbx/rojo/issues/40))
 
-## [0.4.6](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.6) (May 21, 2018)
-* Rojo handles being restarted by Roblox Studio more gracefully ([#67](https://github.com/LPGhatguy/rojo/issues/67))
+## [0.4.6](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.6) (May 21, 2018)
+* Rojo handles being restarted by Roblox Studio more gracefully ([#67](https://github.com/rojo-rbx/rojo/issues/67))
 * Folders should no longer get collapsed when syncing occurs.
 * **Significant** robustness improvements with regards to caching.
     * **This should catch all existing script duplication bugs.**
     * If there are any bugs with script duplication or caching in the future, restarting the Rojo server process will fix them for that session.
 * Fixed message in plugin not being prefixed with `Rojo: `.
 
-## [0.4.5](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.5) (May 1, 2018)
+## [0.4.5](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.5) (May 1, 2018)
 * Rojo messages are now prefixed with `Rojo: ` to make them stand out in the output more.
 * Fixed server to notice file changes *much* more quickly. (200ms vs 1000ms)
 * Server now lists name of project when starting up.
-* Rojo now throws an error if no project file is found. ([#63](https://github.com/LPGhatguy/rojo/issues/63))
-* Fixed multiple sync operations occuring at the same time. ([#61](https://github.com/LPGhatguy/rojo/issues/61))
-* Partitions targeting files directly now work as expected. ([#57](https://github.com/LPGhatguy/rojo/issues/57))
+* Rojo now throws an error if no project file is found. ([#63](https://github.com/rojo-rbx/rojo/issues/63))
+* Fixed multiple sync operations occuring at the same time. ([#61](https://github.com/rojo-rbx/rojo/issues/61))
+* Partitions targeting files directly now work as expected. ([#57](https://github.com/rojo-rbx/rojo/issues/57))
 
-## [0.4.4](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.4) (April 7, 2018)
+## [0.4.4](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.4) (April 7, 2018)
 * Fix small regression introduced in 0.4.3
 
-## [0.4.3](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.3) (April 7, 2018)
-* Plugin now automatically selects `HttpService` if it determines that HTTP isn't enabled ([#58](https://github.com/LPGhatguy/rojo/pull/58))
+## [0.4.3](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.3) (April 7, 2018)
+* Plugin now automatically selects `HttpService` if it determines that HTTP isn't enabled ([#58](https://github.com/rojo-rbx/rojo/pull/58))
 * Plugin now has much more robust handling and will wipe all state when the server changes.
     * This should fix issues that would otherwise be solved by restarting Roblox Studio.
 
-## [0.4.2](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.2) (April 4, 2018)
+## [0.4.2](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.2) (April 4, 2018)
 * Fixed final case of duplicated instance insertion, caused by reconciled instances not being inserted into `RouteMap`.
     * The reconciler is still not a perfect solution, especially if script instances get moved around without being destroyed. I don't think this can be fixed before a big refactor.
 
-## [0.4.1](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.1) (April 1, 2018)
+## [0.4.1](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.1) (April 1, 2018)
 * Merged plugin repository into main Rojo repository for easier tracking.
 * Improved `RouteMap` object tracking; this should fix some cases of duplicated instances being synced into the tree.
 
-## [0.4.0](https://github.com/LPGhatguy/rojo/releases/tag/v0.4.0) (March 27, 2018)
+## [0.4.0](https://github.com/rojo-rbx/rojo/releases/tag/v0.4.0) (March 27, 2018)
 * Protocol version 1, which shifts more responsibility onto the server
     * This is a **major breaking** change!
     * The server now has a content of 'filter plugins', which transform data at various stages in the pipeline
     * The server now exposes Roblox instance objects instead of file contents, which lines up with how `rojo pack` will work, and paves the way for more robust syncing.
 * Added `*.model.json` files, which let you embed small Roblox objects into your Rojo tree.
-* Improved error messages in some cases ([#46](https://github.com/LPGhatguy/rojo/issues/46))
+* Improved error messages in some cases ([#46](https://github.com/rojo-rbx/rojo/issues/46))
 
-## [0.3.2](https://github.com/LPGhatguy/rojo/releases/tag/v0.3.2) (December 20, 2017)
+## [0.3.2](https://github.com/rojo-rbx/rojo/releases/tag/v0.3.2) (December 20, 2017)
 * Fixed `rojo serve` failing to correctly construct an absolute root path when passed as an argument
 * Fixed intense CPU usage when running `rojo serve`
 
-## [0.3.1](https://github.com/LPGhatguy/rojo/releases/tag/v0.3.1) (December 14, 2017)
+## [0.3.1](https://github.com/rojo-rbx/rojo/releases/tag/v0.3.1) (December 14, 2017)
 * Improved error reporting when invalid JSON is found in a `rojo.json` project
     * These messages are passed on from Serde
 
-## [0.3.0](https://github.com/LPGhatguy/rojo/releases/tag/v0.3.0) (December 12, 2017)
+## [0.3.0](https://github.com/rojo-rbx/rojo/releases/tag/v0.3.0) (December 12, 2017)
 * Factored out the plugin into a separate repository
 * Fixed server when using a file as a partition
     * Previously, trailing slashes were put on the end of a partition even if the read request was an empty string. This broke file reading on Windows when a partition pointed to a file instead of a directory!
 * Started running automatic tests on Travis CI (#9)
 
-## [0.2.3](https://github.com/LPGhatguy/rojo/releases/tag/v0.2.3) (December 4, 2017)
+## [0.2.3](https://github.com/rojo-rbx/rojo/releases/tag/v0.2.3) (December 4, 2017)
 * Plugin only release
 * Tightened `init` file rules to only match script files
     * Previously, Rojo would sometimes pick up the wrong file when syncing
 
-## [0.2.2](https://github.com/LPGhatguy/rojo/releases/tag/v0.2.2) (December 1, 2017)
+## [0.2.2](https://github.com/rojo-rbx/rojo/releases/tag/v0.2.2) (December 1, 2017)
 * Plugin only release
 * Fixed broken reconciliation behavior with `init` files
 
-## [0.2.1](https://github.com/LPGhatguy/rojo/releases/tag/v0.2.1) (December 1, 2017)
+## [0.2.1](https://github.com/rojo-rbx/rojo/releases/tag/v0.2.1) (December 1, 2017)
 * Plugin only release
 * Changes default port to 8000
 
-## [0.2.0](https://github.com/LPGhatguy/rojo/releases/tag/v0.2.0) (December 1, 2017)
+## [0.2.0](https://github.com/rojo-rbx/rojo/releases/tag/v0.2.0) (December 1, 2017)
 * Support for `init.lua` like rbxfs and rbxpacker
 * More robust syncing with a new reconciler
 
-## [0.1.0](https://github.com/LPGhatguy/rojo/releases/tag/v0.1.0) (November 29, 2017)
-* Initial release, functionally very similar to [rbxfs](https://github.com/LPGhatguy/rbxfs)
+## [0.1.0](https://github.com/rojo-rbx/rojo/releases/tag/v0.1.0) (November 29, 2017)
+* Initial release, functionally very similar to [rbxfs](https://github.com/rojo-rbx/rbxfs)

CONTRIBUTING.md

@@ -0,0 +1,48 @@
+# Contributing to the Rojo Project
+Rojo is a big project and can always use more help! This guide covers all repositories underneath the [rojo-rbx organization on GitHub](https://github.com/rojo-rbx).
+
+Some of the repositories covered are:
+
+* https://github.com/rojo-rbx/rojo
+* https://github.com/rojo-rbx/rbx-dom
+* https://github.com/rojo-rbx/vscode-rojo
+* https://github.com/rojo-rbx/rbxlx-to-rojo
+
+## Code
+Code contributions are welcome for features and bugs that have been reported in the project's bug tracker. We want to make sure that no one wastes their time, so be sure to talk with maintainers about what changes would be accepted before doing any work!
+
+## Documentation
+Documentation impacts way more people than the individual lines of code we write.
+
+If you find any problems in documentation, including typos, bad grammar, misleading phrasing, or missing content, feel free to file issues and pull requests to fix them.
+
+## Bug Reports and Feature Requests
+Most of the tools around Rojo try to be clear when an issue is a bug. Even if they aren't, sometimes things don't work quite right.
+
+Sometimes there's something that Rojo doesn't do that it probably should.
+
+Please file issues and we'll try to help figure out what the best way forward is.
+
+## Pushing a Rojo Release
+The Rojo release process is pretty manual right now. If you need to do it, here's how:
+
+1. Bump server version in [`server/Cargo.toml`](server/Cargo.toml)
+2. Bump plugin version in [`plugin/src/Config.lua`](plugin/src/Config.lua)
+3. Run `cargo test` to update `Cargo.lock` and double-check tests
+4. Update [`CHANGELOG.md`](CHANGELOG.md)
+5. Commit!
+    * `git add . && git commit -m "Release vX.Y.Z"`
+6. Tag the commit with the version from `Cargo.toml` prepended with a v, like `v0.4.13`
+7. Build Windows release build of CLI
+    * `cargo build --release`
+7. Publish the CLI
+    * `cargo publish`
+8. Build and upload the plugin
+    * `rojo build plugin -o Rojo.rbxm`
+    * Upload `Rojo.rbxm` to Roblox.com, keep it for later
+9. Push commits and tags
+    * `git push && git push --tags`
+10. Copy GitHub release content from previous release
+    * Update the leading text with a summary about the release
+    * Paste the changelog notes (as-is!) from [`CHANGELOG.md`](CHANGELOG.md)
+    * Write a small summary of each major feature

Cargo.toml

@@ -1,5 +1,8 @@
 [workspace]
 members = [
 	"server",
-	"rojo-e2e",
-]
+	"rojo-test",
+]
+
+[profile.dev]
+opt-level = 1

README.md

@@ -1,68 +1,58 @@
 <div align="center">
-    <img src="assets/rojo-logo.png" alt="Rojo" height="217" />
+    <a href="https://rojo.space">
+        <img src="assets/logo-512.png" alt="Rojo" height="217" />
+    </a>
 </div>
 
 <div>&nbsp;</div>
 
 <div align="center">
-    <a href="https://travis-ci.org/LPGhatguy/rojo">
-        <img src="https://api.travis-ci.org/LPGhatguy/rojo.svg?branch=master" alt="Travis-CI Build Status" />
+    <a href="https://travis-ci.org/rojo-rbx/rojo">
+        <img src="https://api.travis-ci.org/rojo-rbx/rojo.svg?branch=master" alt="Travis-CI Build Status" />
     </a>
     <a href="https://crates.io/crates/rojo">
         <img src="https://img.shields.io/crates/v/rojo.svg?label=version" alt="Latest server version" />
     </a>
-    <a href="https://lpghatguy.github.io/rojo/0.4.x">
-        <img src="https://img.shields.io/badge/docs-0.4.x-brightgreen.svg" alt="Rojo Documentation" />
+    <a href="https://rojo.space/docs/0.4.x">
+        <img src="https://img.shields.io/badge/docs-0.4.x-brightgreen.svg" alt="Rojo 0.4.x Documentation" />
     </a>
-    <a href="https://lpghatguy.github.io/rojo/0.5.x">
-        <img src="https://img.shields.io/badge/docs-0.5.x-brightgreen.svg" alt="Rojo Documentation" />
+    <a href="https://rojo.space/docs/0.5.x">
+        <img src="https://img.shields.io/badge/docs-0.5.x-brightgreen.svg" alt="Rojo 0.5.x Documentation" />
     </a>
 </div>
 
 <hr />
 
-**Rojo** is a flexible multi-tool designed for creating robust Roblox projects.
+**Rojo** is a tool designed to enable Roblox developers to use professional-grade software engineering tools.
 
-It lets Roblox developers use industry-leading tools like Git and VS Code, and crucial utilities like Luacheck.
+With Rojo, it's possible to use industry-leading tools like **Visual Studio Code** and **Git**.
 
-Rojo is designed for **power users** who want to use the **best tools available** for building games, libraries, and plugins.
+Rojo is designed for power users who want to use the best tools available for building games, libraries, and plugins.
 
 ## Features
-Rojo lets you:
+Rojo enables:
 
-* Work on scripts from the filesystem, in your favorite editor
-* Version your place, model, or plugin using Git or another VCS
-* Sync `rbxmx` and `rbxm` models into your game in real time
-* Package and deploy your project to Roblox.com from the command line
+* Working on scripts and models from the filesystem, in your favorite editor
+* Versioning your game, library, or plugin using Git or another VCS
+* Streaming `rbxmx` and `rbxm` models into your game in real time
+* Packaging and deploying your project to Roblox.com from the command line
 
 Soon, Rojo will be able to:
 
+* Automatically convert your existing game to work with Rojo
 * Sync instances from Roblox Studio to the filesystem
-* Compile MoonScript and other custom things for your project
+* Automatically manage your assets on Roblox.com, like images and sounds
+* Import custom instances like MoonScript code
 
-## [Documentation](https://lpghatguy.github.io/rojo)
-You can also view the documentation by browsing the [docs](https://github.com/LPGhatguy/rojo/tree/master/docs) folder of the repository, but because it uses a number of Markdown extensions, it may not be very readable.
-
-## Inspiration and Alternatives
-There are lots of other tools that sync scripts into Roblox or provide other tools for working with Roblox places.
-
-Here are a few, if you're looking for alternatives or supplements to Rojo:
-
-* [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)
-
-If you use a plugin that _isn't_ Rojo for syncing code, open an issue and let me know why! I'd like Rojo to be the end-all tool so that people stop reinventing solutions to this problem.
+## [Documentation](https://rojo.space/docs/latest)
+If you find any mistakes, feel free to make changes in the [docs](https://github.com/rojo-rbx/rojo/tree/master/docs) folder of this repository and submit a pull request!
 
 ## Contributing
+Check out our [contribution guide](CONTRIBUTING.md) for detailed instructions for helping work on Rojo!
+
 Pull requests are welcome!
 
-Rojo supports Rust 1.32 and newer. Any changes to the minimum required compiler version require a _minor_ version bump.
+Rojo supports Rust 1.34.0 and newer. The minimum supported version of Rust is based on the latest versions of the dependencies that Rojo has.
 
 ## License
 Rojo is available under the terms of the Mozilla Public License, Version 2.0. See [LICENSE.txt](LICENSE.txt) for details.

design.gv

@@ -1,39 +0,0 @@
-digraph G {
-	graph [
-		ranksep = "0.7",
-		nodesep = "1.0",
-	];
-	node [
-		fontname = "Hack",
-		shape = "record",
-	];
-
-	roblox_studio -> plugin [dir = "both"];
-	plugin -> web_server [style = "dashed", dir = "both"];
-
-	web_server -> session;
-
-	session -> rbx_session;
-	session -> fs_watcher;
-	session -> message_queue;
-
-	fs_watcher -> imfs [weight = "10"];
-	fs_watcher -> rbx_session [constraint = "false"];
-
-	imfs -> fs;
-
-	rbx_session -> imfs;
-	rbx_session -> middlewares [weight = "10"];
-	rbx_session -> message_queue [constraint = "false"];
-
-	plugin [label = "Studio Plugin"];
-	roblox_studio [label = "Roblox Studio"];
-	fs [label = "Filesystem"];
-	fs_watcher [label = "Filesystem Watcher"];
-	session [label = "Session"];
-	web_server [label = "Web API"];
-	imfs [label = "In-Memory Filesystem"];
-	rbx_session [label = "RbxSession"];
-	message_queue [label = "MessageQueue"];
-	middlewares [label = "Middlewares"];
-}

docs/creating-a-place.md

@@ -1,68 +0,0 @@
-[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.
-
-```sh
-mkdir my-new-project
-cd my-new-project
-
-rojo init
-```
-
-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:
-
-```sh
-mkdir src
-echo 'print("Hello, world!")' > src/hello.lua
-```
-
-## Building Your Place
-Now that we have a project, one thing we can do is build a Roblox place file for our project. This is a great way to get started with a project quickly with no fuss.
-
-All we have to do is call `rojo build`:
-
-```sh
-rojo build -o MyNewProject.rbxl
-```
-
-If you open `MyNewProject.rbxl` in Roblox Studio now, you should see a `Folder` containing a `ModuleScript` under `ReplicatedStorage`!
-
-!!! info
-    To generate an XML place file instead, like if you're checking the place file into version control, just use `rbxlx` as the extension on the output file instead.
-
-## Live-Syncing into Studio
-Building a place file is great for the initial build, but for actively working on your place, you'll want something quicker.
-
-In Roblox Studio, make sure the Rojo plugin is installed. If you need it, check out [the installation guide](installation) to learn how to install it.
-
-To expose your project to the plugin, you'll need to _serve_ it from the command line:
-
-```sh
-rojo serve
-```
-
-This will start up a web server that tells Roblox Studio what instances are in your project and sends notifications if any of them change.
-
-Note the port number, then switch into Roblox Studio and press the Rojo **Connect** button in the plugins tab. Type in the port number, if necessary, and press **Start**.
-
-If everything went well, you should now be able to change files in the `src` directory and watch them sync into Roblox Studio in real time!
-
-## Uploading Your Place
-Aimed at teams that want serious levels of automation, Rojo can upload places to Roblox.com automatically.
-
-You'll need an existing place on Roblox.com as well as the `.ROBLOSECURITY` cookie of an account that has write access to that place.
-
-!!! warning
-    It's recommended that you set up a Roblox account dedicated to deploying your place instead of your personal account in case your security cookie is compromised.
-
-Generating and uploading your place file is as simple as:
-
-```sh
-rojo upload --asset_id [PLACE ID] --cookie "[SECURITY COOKIE]"
-```

docs/extra.css

@@ -1,3 +1,13 @@
 .md-typeset__table {
   width: 100%;
+}
+
+.feature-image img {
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  box-shadow: 1px 1px 4px rgba(0, 0, 0, 0.2);
+}
+
+.codehilite {
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  box-shadow: 1px 1px 4px rgba(0, 0, 0, 0.2);
 }

docs/guide/existing-game.md

@@ -0,0 +1,11 @@
+**This page is under construction!**
+
+## Summary
+* Tools to port existing games are in progress!
+    * [rbxlx-to-rojo](https://github.com/rojo-rbx/rbxlx-to-rojo)
+    * `rojo export` ([issue #208](https://github.com/rojo-rbx/rojo/issues/208))
+* Can port as much or as little of your game as you like
+    * Rojo can manage just a slice of your game!
+* Some Roblox idioms aren't very well supported
+    * Redundant copies of scripts don't work well with files
+    * Having only a couple places with scripts simplifies your project dramatically!

docs/guide/installation.md

@@ -1,7 +1,8 @@
+This is this installation guide for Rojo **0.5.x**.
+
 [TOC]
 
 ## Overview
-
 Rojo has two components:
 
 * The command line interface (CLI)
@@ -12,6 +13,9 @@ Rojo has two components:
 
     The plugin will show errors in the Roblox Studio output window if there is a version mismatch.
 
+## Visual Studio Code Extension
+If you use Visual Studio Code, you can install [the Rojo VS Code 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 sync files and start/stop the Rojo server!
+
 ## Installing the CLI
 
 ### Installing from GitHub
@@ -22,24 +26,23 @@ The Rojo CLI must be run from the command line, like Terminal.app on MacOS or `c
 ### 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:
+To install the latest 0.5.x release, use:
 
 ```sh
-cargo install rojo --version 0.5.0-alpha.8
+cargo install rojo
 ```
 
+If you're upgrading from a previous version of Rojo, you may need to pass `--force` to tell Cargo to overwrite your existing version.
+
 ## 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).
+The Rojo Roblox Studio plugin is 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)
+!['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!
+Visit [Rojo's Roblox.com Plugin page](https://www.roblox.com/library/1997686364) in Roblox Studio and press **Install**.

docs/guide/migrating-to-epiphany.md

@@ -55,4 +55,9 @@ All other values are considered children, where the key is the instance's name,
 ## Migrating Unknown Files
 If you used Rojo to sync in files as `StringValue` objects, you'll need to make sure those files end with the `txt` extension to preserve this in Rojo 0.5.x.
 
-Unknown files are now ignored in Rojo instead of being converted to `StringValue` objects.
+Unknown files are now ignored in Rojo instead of being converted to `StringValue` objects.
+
+## Migrating `init.model.json` files
+In Rojo 0.4.x, it's possible to create a file named `init.model.json` that lets you describe a model that becomes the container for all of the other files in the folder, just like `init.lua`.
+
+In Rojo 0.5.x, this feature has been replaced with `init.meta.json` files. See [Sync Details](../../reference/sync-details) for more information about these new files.

docs/guide/new-game.md

@@ -0,0 +1,90 @@
+[TOC]
+
+## Creating the Rojo Project
+To use Rojo to build a game, you'll need to create a new project file, which tells Rojo how to turn your files into a Roblox place.
+
+First, create a new folder to contain the files for your game and open up a new terminal inside of it, like cmd.exe or Bash.
+
+It's convenient to make the folder from the command line:
+
+```sh
+mkdir my-new-project
+cd my-new-project
+```
+
+Inside the folder, initialize a new Rojo project:
+
+```sh
+rojo init
+```
+
+Rojo will make a small project file in your directory, named `default.project.json`. It matches the "Baseplate" template from Roblox Studio, except that it'll take any files you put in a folder called `src` and put it into `ReplicatedStorage.Source`.
+
+Speaking of files, make sure to create a directory named `src` in this folder, or Rojo will be upset about missing files!
+
+```sh
+mkdir src
+```
+
+Let's also add a Lua file, `hello.lua` to the `src` folder, so that we can make this project our own.
+
+```sh
+echo 'return "Hello, Rojo!"' > src/hello.lua
+```
+
+## Building Your Place
+Now that we have a project, one thing we can do is build a Roblox place file for our project. This is a great way to get started with a project quickly with no fuss.
+
+All we have to do is call `rojo build`:
+
+```sh
+rojo build -o MyNewProject.rbxlx
+```
+
+If you open `MyNewProject.rbxlx` in Roblox Studio now, you should see a `Folder` named "Source" containing a `ModuleScript` under `ReplicatedStorage`.
+
+!!! info
+    To generate a binary place file instead, use `rbxl`. Note that support for binary model/place files (`rbxm` and `rbxl`) is very limited in Rojo presently.
+
+## Live-Syncing into Studio
+Building a place file is great for starting to work on a game, but for active iteration, you'll want something faster.
+
+In Roblox Studio, make sure the Rojo plugin is installed. If you need it, check out [the installation guide](../installation) to learn how to install it.
+
+To expose your project to the plugin, you'll need to start a new **live sync session** from the command line:
+
+```sh
+rojo serve
+```
+
+You should see output like this in your terminal:
+
+```sh
+$ rojo serve
+Rojo server listening on port 34872
+```
+
+Switch into Roblox Studio and press the **Connect** button on the Rojo plugin toolbar. A dialog should appear:
+
+![Rojo plugin connection dialog](../images/connection-dialog.png)
+{: class="feature-image" align="center" }
+
+If the port number doesn't match the output from the command line, change it, and then press **Connect**.
+
+If all went well, you should now be able to change files in the `src` directory and watch them sync into Roblox Studio in real time!
+
+## Uploading Your Place
+Aimed at teams that want serious levels of automation, Rojo can upload places to Roblox.com automatically.
+
+You'll need an existing game on Roblox.com as well as the `.ROBLOSECURITY` cookie of an account that has write access to that game.
+
+!!! warning
+    It's recommended that you set up a Roblox account dedicated to deploying your game instead of your personal account in case your security cookie is compromised.
+
+Generating and publishing your game is as simple as:
+
+```sh
+rojo upload --asset_id [PLACE ID] --cookie "[SECURITY COOKIE]"
+```
+
+An example project is available on GitHub that deploys to Roblox.com from GitHub and Travis-CI automatically: [https://github.com/LPGhatguy/roads](https://github.com/LPGhatguy/roads)

docs/help.md

@@ -0,0 +1,7 @@
+Rojo is a fairly complex tool to adopt, but there's a community willing to help!
+
+The [Roblox Open Source Community Discord](https://discord.gg/wH5ncNS) currently hosts a Rojo support channel, **#rojo**, that is a great place to get help as problems come up.
+
+If you find anything that looks like a bug or have ideas for how to improve Rojo, feel free to file an issue on [Rojo's GitHub issue tracker](https://github.com/rojo-rbx/rojo/issues).
+
+Rojo's primary maintainer is also available on Twitter, [@LPGhatguy](https://twitter.com/LPGhatguy).

docs/index.md

@@ -1,11 +1,11 @@
-This is the documentation home for Rojo 0.5.x.
+This is the documentation home for **Rojo 0.5.x**.
 
 Available versions of these docs:
 
-* [Latest version (currently 0.5.x)](https://lpghatguy.github.io/rojo)
-* [0.5.x](https://lpghatguy.github.io/rojo/0.5.x)
-* [0.4.x](https://lpghatguy.github.io/rojo/0.4.x)
+* [Latest version from `master` branch](https://rojo.space/docs/latest)
+* [0.5.x](https://rojo.space/docs/0.5.x)
+* [0.4.x](https://rojo.space/docs/0.4.x)
 
-**Rojo** is a flexible multi-tool designed for creating robust Roblox projects.
+**Rojo** is a tool designed to enable Roblox developers to use professional-grade software engineering tools.
 
-This documentation is a continual work in progress. If you find any issues, please file an issue on [Rojo's issue tracker](https://github.com/LPGhatguy/rojo/issues)!
+This documentation is a continual work in progress. If you find any issues, please file an issue on [Rojo's issue tracker](https://github.com/rojo-rbx/rojo/issues)!

docs/project-format.md

@@ -1,100 +0,0 @@
-[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"
-            }
-        }
-    }
-}
-```

docs/reference/full-vs-partial.md

@@ -0,0 +1,37 @@
+Rojo is designed to be adopted incrementally. How much of your project Rojo manages is up to you!
+
+There are two primary categories of ways to use Rojo: *Fully Managed*, where everything is managed by Rojo, and *Partially Managed*, where Rojo only manages a slice of your project.
+
+## Fully Managed
+In a fully managed game project, Rojo controls every instance. A fully managed Rojo project can be built from scratch using `rojo build`.
+
+Fully managed projects are most practical for libraries, plugins, and simple games.
+
+Rojo's goal is to make it practical and easy for _every_ project to be fully managed, but we're not quite there yet!
+
+### Pros
+* Fully reproducible builds from scratch
+* Everything checked into version control
+
+### Cons
+* Without two-way sync, models have to be saved manually
+    * This can be done with the 'Save to File...' menu in Roblox Studio
+    * This will be solved by Two-Way Sync ([issue #164](https://github.com/LPGhatguy/rojo/issues/164))
+* Rojo can't manage everything yet
+    * Refs are currently broken ([issue #142](https://github.com/LPGhatguy/rojo/issues/142))
+
+## Partially Managed
+In a partially managed project, Rojo only handles a slice of the game. This could be as small as a couple scripts, or as large as everything except `Workspace`!
+
+The rest of the place's content can be versioned using Team Create or checked into source control.
+
+Partially managed projects are most practical for complicated games, or games that are migrating to use Rojo.
+
+### Pros
+* Easier to adopt gradually
+* Integrates with Team Create
+
+### Cons
+* Not everything is in version control, which makes merges tougher
+* Rojo can't live-sync instances like Terrain, MeshPart, or CSG operations yet
+    * Will be fixed with plugin escalation ([issue #169](https://github.com/LPGhatguy/rojo/issues/169))

docs/reference/project-format.md

@@ -0,0 +1,151 @@
+[TOC]
+
+## Project File
+Rojo projects are JSON files that have the `.project.json` extension. They have the following fields:
+
+* `name`: A string indicating the name of the project. This name is used when building the project into a model or place file.
+    * **Required**
+* `tree`: An [Instance Description](#instance-description) describing the root instance of the project.
+    * **Required**
+* `servePort`: The port that `rojo serve` should listen on. Passing `--port` will override this setting.
+    * **Optional**
+    * Default is `34872`
+* `servePlaceIds`: A list of place IDs that this project may be live-synced to. This feature can help prevent overwriting the wrong game with source from Rojo.
+    * **Optional**
+    * Default is `null`
+
+## Instance Description
+Instance Descriptions correspond one-to-one with the actual Roblox Instances in the project.
+
+* `$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`](https://github.com/LPGhatguy/rojo/issues/179).
+
+## Instance Property Value
+There are two kinds of property values on instances, **implicit** and **explicit**.
+
+In the vast majority of cases, you should be able to use **implicit** property values. To use them, just use a value that's the same shape as the type that the property has:
+
+```json
+"MyPart": {
+    "$className": "Part",
+    "$properties": {
+        "Size": [3, 5, 3],
+        "Color": [0.5, 0, 0.5],
+        "Anchored": true,
+        "Material": "Granite"
+    }
+}
+```
+
+`Vector3` and `Color3` properties can just be arrays of numbers, as can types like `Vector2`, `CFrame`, and more!
+
+Enums can be set to a string containing the enum variant. Rojo will raise an error if the string isn't a valid variant for the enum.
+
+There are some cases where this syntax for assigning properties _doesn't_ work. In these cases, Rojo requires you to use the **explicit** property syntax.
+
+Some reasons why you might need to use an **explicit** property:
+
+* Using exotic property types like `BinaryString`
+* Using properties added to Roblox recently that Rojo doesn't know about yet
+
+The shape of explicit property values is defined by the [rbx-dom](https://github.com/LPGhatguy/rbx-dom) 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, while `BinaryString` expects a base64-encoded string, for example.
+
+Here's the same object, but with explicit properties:
+
+```json
+"MyPart": {
+    "$className": "Part",
+    "$properties": {
+        "Size": {
+            "Type": "Vector3",
+            "Value": [3, 5, 3]
+        },
+        "Color": {
+            "Type": "Color3",
+            "Value": [0.5, 0, 0.5]
+        },
+        "Anchored": {
+            "Type": "Bool",
+            "Value": true
+        },
+        "Material": {
+            "Type": "Enum",
+            "Value": 832
+        }
+    }
+}
+```
+
+## 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": true
+            }
+        },
+
+        "ReplicatedStorage": {
+            "$className": "ReplicatedStorage",
+            "$path": "src/ReplicatedStorage"
+        },
+
+        "StarterPlayer": {
+            "$className": "StarterPlayer",
+
+            "StarterPlayerScripts": {
+                "$className": "StarterPlayerScripts",
+                "$path": "src/StarterPlayerScripts"
+            }
+        },
+
+        "Workspace": {
+            "$className": "Workspace",
+            "$properties": {
+                "Gravity": 67.3
+            },
+
+            "Terrain": {
+                "$path": "Terrain.rbxm"
+            }
+        }
+    }
+}
+```

docs/reference/sync-details.md

@@ -0,0 +1,157 @@
+This page aims to describe how Rojo turns files on the filesystem into Roblox objects.
+
+[TOC]
+
+## Overview
+| File Name      | Instance Type             |
+| -------------- | ------------------------- |
+| any directory  | `Folder`                  |
+| `*.server.lua` | `Script`                  |
+| `*.client.lua` | `LocalScript`             |
+| `*.lua`        | `ModuleScript`            |
+| `*.csv`        | `LocalizationTable`       |
+| `*.txt`        | `StringValue`             |
+| `*.model.json` | Any                       |
+| `*.rbxm`       | Any                       |
+| `*.rbxmx`      | Any                       |
+| `*.meta.json`  | Modifies another instance |
+
+## Limitations
+Not all property types can be synced by Rojo in real-time due to limitations of the Roblox Studio plugin API. In these cases, you can usually generate a place file and open it when you start working on a project.
+
+Some common cases you might hit are:
+
+* Binary data (Terrain, CSG, CollectionService tags)
+* `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-dom's type coverage chart](https://github.com/rojo-rbx/rbx-dom#property-type-coverage).
+
+This limitation may be solved by [issue #205](https://github.com/rojo-rbx/rojo/issues/205) in the future.
+
+## Folders
+Any directory on the filesystem will turn into a `Folder` instance unless it contains an 'init' script, described below.
+
+## Scripts
+The default script type in Rojo projects is `ModuleScript`, since most scripts in well-structued Roblox projects will be modules.
+
+If a directory contains a file named `init.server.lua`, `init.client.lua`, or `init.lua`, that folder will be transformed into a `*Script` instance with the contents of the 'init' file. This can be used to create scripts inside of scripts.
+
+For example, these files:
+
+![Tree of files on disk](../images/sync-example-files.svg)
+{: align="center" }
+
+Will turn into these instances in Roblox:
+
+![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.
+
+## Plain Text Files
+Plain text files (`.txt`) files are transformed into `StringValue` instances. This is useful for bringing in text data that can be read by scripts at runtime.
+
+## JSON Models
+Files ending in `.model.json` can be used to describe simple models. They're designed to be hand-written and are useful for instances like `RemoteEvent`.
+
+A JSON model describing a folder containing a `Part` and a `RemoteEvent` could be described as:
+
+```json
+{
+    "Name": "My Cool Model",
+    "ClassName": "Folder",
+    "Children": [
+        {
+            "Name": "RootPart",
+            "ClassName": "Part",
+            "Properties": {
+                "Size": {
+                    "Type": "Vector3",
+                    "Value": [4, 4, 4]
+                }
+            }
+        },
+        {
+            "Name": "SendMoney",
+            "ClassName": "RemoteEvent"
+        }
+    ]
+}
+```
+
+It would turn into instances in this shape:
+
+![Tree of instances in Roblox](../images/sync-example-json-model.svg)
+{: align="center" }
+
+!!! warning
+    Starting in Rojo 0.5.0 (stable), the `Name` field is no longer required. The name of the top-level instance in a JSON model is now based on its file name, and the `Name` field is now ignored.
+
+    Rojo will emit a warning if the `Name` field is specified and does not match the file's name.
+
+## Binary and XML Models
+Rojo supports both binary (`.rbxm`) and XML (`.rbxmx`) models generated by Roblox Studio or another tool.
+
+Support for the `rbxmx` is very good, while support for `rbxm` is still very early, buggy, and lacking features.
+
+For a rundown of supported types, check out [rbx-dom's type coverage chart](https://github.com/rojo-rbx/rbx-dom#property-type-coverage).
+
+## Meta Files
+New in Rojo 0.5.0-alpha.12 are meta files, named `.meta.json`.
+
+Meta files allow attaching extra Rojo data to models defined in other formats, like Roblox's `rbxm` and `rbxmx` model formats, or even Lua scripts.
+
+This can be used to set Rojo-specific settings like `ignoreUnknownInstances`, or can be used to set properties like `Disabled` on a script.
+
+Meta files can contain:
+
+* `className`: Changes the `className` of a containing `Folder` into something else.
+    * Usable only in `init.meta.json` files
+* `properties`: A map of properties to set on the instance, just like projects
+    * Usable on anything except `.rbxmx`, `.rbxm`, and `.model.json` files, which already have properties
+* `ignoreUnknownInstances`: Works just like `$ignoreUnknownInstances` in project files
+
+### Meta Files to set Rojo metadata
+Sometimes it's useful to apply properties like `ignoreUnknownInstances` on instances that are defined on the filesystem instead of within the project itself.
+
+If your project has `hello.txt` and there are instances underneath it that you want Rojo to ignore when live-syncing, you could create `hello.meta.json` with:
+
+```json
+{
+    "ignoreUnknownInstances": true
+}
+```
+
+### Meta Files for Disabled Scripts
+Meta files can be used to set properties on `Script` instances, like `Disabled`.
+
+If your project has `foo.server.lua` and you want to make sure it would be disabled, you could create a `foo.meta.json` next to it with:
+
+```json
+{
+    "properties": {
+        "Disabled": true
+    }
+}
+```
+
+### Meta Files for Tools
+If you wanted to represent a tool containing a script and a model for its handle, create a directory with an `init.meta.json` file in it:
+
+```json
+{
+    "className": "Tool",
+    "properties": {
+        "Grip": [
+            0, 0, 0,
+            1, 0, 0,
+            0, 1, 0,
+            0, 0, 1
+        ]
+    }
+}
+```
+
+Instead of a `Folder` instance, you'll end up with a `Tool` instance with the `Grip` property set!

docs/rojo-alternatives.md

@@ -0,0 +1,23 @@
+There are a number of existing plugins for Roblox that move code from the filesystem into Roblox.
+
+Besides Rojo, you might consider:
+
+* [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 this problem for good.
+
+Additionally:
+
+* I think that this tool needs to be built in a compiled language without a runtime, for easy distribution and good performance.
+* I think that the conventions promoted by other sync plugins (`.module.lua` for modules, as well a single sync point) are sub-optimal.
+* I think that I have a good enough understanding of the problem to build something robust.
+* I think that Rojo should be able to do more than just sync code.

docs/sync-details.md

@@ -1,91 +0,0 @@
-This page aims to describe how Rojo turns files on the filesystem into Roblox objects.
-
-[TOC]
-
-## Overview
-| File Name      | Instance Type       |
-| -------------- | ------------------- |
-| any directory  | `Folder`            |
-| `*.server.lua` | `Script`            |
-| `*.client.lua` | `LocalScript`       |
-| `*.lua`        | `ModuleScript`      |
-| `*.csv`        | `LocalizationTable` |
-| `*.txt`        | `StringValue`       |
-| `*.model.json` | Any                 |
-| `*.rbxm`       | Any                 |
-| `*.rbxmx`      | Any                 |
-
-## Limitations
-Not all property types can be synced by Rojo in real-time due to limitations of the Roblox Studio plugin API. In these cases, you can usually generate a place file and open it when you start working on a project.
-
-Some common cases you might hit are:
-
-* Binary data (Terrain, CSG, CollectionService tags)
-* `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 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.
-
-## Scripts
-The default script type in Rojo projects is `ModuleScript`, since most scripts in well-structued Roblox projects will be modules.
-
-If a directory contains a file named `init.server.lua`, `init.client.lua`, or `init.lua`, that folder will be transformed into a `*Script` instance with the contents of the 'init' file. This can be used to create scripts inside of scripts.
-
-For example, these files:
-
-![Tree of files on disk](images/sync-example-files.svg)
-{: align="center" }
-
-Will turn into these instances in Roblox:
-
-![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.
-
-## Plain Text Files
-Plain text files (`.txt`) files are transformed into `StringValue` instances. This is useful for bringing in text data that can be read by scripts at runtime.
-
-## JSON Models
-Files ending in `.model.json` can be used to describe simple models. They're designed to be hand-written and are useful for instances like `RemoteEvent`.
-
-A JSON model describing a folder containing a `Part` and a `RemoteEvent` could be described as:
-
-```json
-{
-    "Name": "My Cool Model",
-    "ClassName": "Folder",
-    "Children": [
-        {
-            "Name": "RootPart",
-            "ClassName": "Part",
-            "Properties": {
-                "Size": {
-                    "Type": "Vector3",
-                    "Value": [4, 4, 4]
-                }
-            }
-        },
-        {
-            "Name": "SendMoney",
-            "ClassName": "RemoteEvent"
-        }
-    ]
-}
-```
-
-It would turn into instances in this shape:
-
-![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 for all formats!
-
-For a rundown of supported types, check out [rbx_tree's type coverage chart](https://github.com/LPGhatguy/rbx-tree#property-type-coverage).

docs/why-rojo.md

@@ -1,23 +1,44 @@
-There are a number of existing plugins for Roblox that move code from the filesystem into Roblox.
+Adding a tool like Rojo to your Roblox workflow can be daunting, but it comes with some key advantages.
 
-Besides Rojo, you might consider:
+[TOC]
 
-* [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)
+## Rojo at RDC 2019
+Nathan Riemer (Kampfkarren) gave a talk at RDC 2019 talking about some of the benefits of using a tool like Rojo.
 
-So why did I build Rojo?
+<iframe style="margin: 0 auto; max-width: 100%" width="560" height="315" src="https://www.youtube-nocookie.com/embed/czlvzEyhaBc" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
 
-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.
+## External Text Editors
+Rojo opens the door to use the absolute best text editors in the world and their rich plugin ecosystems.
 
-Additionally:
+Some very popular editors include [Visual Studio Code](https://code.visualstudio.com) and [Sublime Text](https://www.sublimetext.com).
 
-* I think that this tool needs to be built in a compiled language without a runtime, for easy distribution and good performance.
-* I think that the conventions promoted by other sync plugins (`.module.lua` for modules, as well a single sync point) are sub-optimal.
-* I think that I have a good enough understanding of the problem to build something robust.
-* I think that Rojo should be able to do more than just sync code.
+These advanced text editors have features like multi-cursor editing, goto symbol, multi-file regex find and replace, bookmarks and much more.
+
+Many Rojo VS Code users also use extensions like:
+
+* [vscode-rbxlua](https://marketplace.visualstudio.com/items?itemName=AmaranthineCodices.vscode-rbxlua)
+* [Roblox Lua Autocompletes](https://marketplace.visualstudio.com/items?itemName=Kampfkarren.roblox-lua-autofills)
+* [TabNine](https://tabnine.com)
+
+## Version Control
+By building your game (or just the scripts) as individual files on the filesystem, it becomes easy to start using professional-grade version control tools like [Git](https://git-scm.com) and [GitHub](https://github.com).
+
+Hundreds of thousands of companies and individual developers use Git to version their software projects. With Rojo, Roblox developers can take advantage of the best collaboration tool around.
+
+Using a repository hosting service like GitHub or GitLab brings powerful features to Roblox developers like code reviews and issue tracking that professional engineers can't live without.
+
+## TypeScript
+TypeScript enables static type safety, which helps prevent typos and adds unparalleled autocompletion. It also brings features like arrow functions, object destructuring, functional programming methods, and more!
+
+With Rojo, you can use [roblox-ts](https://roblox-ts.github.io) to compile TypeScript to Lua and take advantage of a huge ecosystem of TypeScript tooling.
+
+It's also possible to use other languages that compile to Lua like [MoonScript](https://moonscript.org) and [Haxe](https://haxe.org).
+
+## Other Tools
+There are decades of excellent tools available that operate on files. With Rojo, it's possible to take advantage of any of them!
+
+Popular tools include:
+
+* [luacheck](https://github.com/mpeterv/luacheck), a static analysis tool to help you write better Lua
+* [ripgrep](https://github.com/BurntSushi/ripgrep), an extremely fast code search tool
+* [Tokei](https://github.com/XAMPPRocky/tokei), a tool for statistics like lines of code

generate-docs

@@ -1,35 +0,0 @@
-#!/bin/sh
-
-# Kludged documentation generator to support multiple versions.
-# Make sure the `site` folder is a checkout of this repository's `gh-pages`
-# branch.
-
-set -e
-
-REMOTE=$(git remote get-url origin)
-CHECKOUT="$(mktemp -d)"
-OUTPUT="$(pwd)/site"
-
-if [ -d site ]
-then
-	cd site
-	git pull
-else
-	git clone "$REMOTE" site
-	cd site
-	git checkout gh-pages
-fi
-
-git clone "$REMOTE" "$CHECKOUT"
-cd "$CHECKOUT"
-
-echo "Building master"
-git checkout master
-mkdocs build --site-dir "$OUTPUT"
-
-echo "Building 0.5.x"
-mkdocs build --site-dir "$OUTPUT/0.5.x"
-
-echo "Building 0.4.x"
-git checkout v0.4.x
-mkdocs build --site-dir "$OUTPUT/0.4.x"

mkdocs.yml

@@ -1,6 +1,6 @@
 site_name: Rojo Documentation
-repo_name: LPGhatguy/rojo
-repo_url: https://github.com/LPGhatguy/rojo
+repo_name: rojo-rbx/rojo
+repo_url: https://github.com/rojo-rbx/rojo
 
 theme:
   name: material
@@ -11,11 +11,17 @@ theme:
 nav:
   - Home: index.md
   - Why Rojo?: why-rojo.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
+  - Get Help with Rojo: help.md
+  - Guide:
+    - Installation: guide/installation.md
+    - Creating a Game with Rojo: guide/new-game.md
+    - Porting an Existing Game to Rojo: guide/existing-game.md
+    - Migrating from 0.4.x to 0.5.x: guide/migrating-to-epiphany.md
+  - Reference:
+    - Fully vs Partially Managed Rojo: reference/full-vs-partial.md
+    - Project Format: reference/project-format.md
+    - Sync Details: reference/sync-details.md
+  - Rojo Alternatives: rojo-alternatives.md
   - Rojo Internals:
     - Internals Overview: internals/overview.md
 

plugin/README.md

@@ -1,5 +0,0 @@
-# Rojo Plugin
-
-This is the source to the Rojo Roblox Studio plugin.
-
-Documentation is WIP.

plugin/default.project.json

@@ -6,13 +6,16 @@
       "$path": "src"
     },
     "Roact": {
-      "$path": "modules/roact/lib"
+      "$path": "modules/roact/src"
     },
     "Promise": {
       "$path": "modules/promise/lib"
     },
     "t": {
-      "$path": "modules/t/lib/t.lua"
+      "$path": "modules/t/lib"
+    },
+    "RbxDom": {
+      "$path": "modules/rbx-dom/rbx_dom_lua/src"
     }
   }
 }

plugin/place.project.json

@@ -13,13 +13,13 @@
           "$path": "src"
         },
         "Roact": {
-          "$path": "modules/roact/lib"
+          "$path": "modules/roact/src"
         },
         "Promise": {
           "$path": "modules/promise/lib"
         },
         "t": {
-          "$path": "modules/t/lib/t.lua"
+          "$path": "modules/t/lib"
         }
       },
       "TestEZ": {

plugin/rojo.json

@@ -1,34 +0,0 @@
-{
-  "name": "rojo",
-  "servePort": 8000,
-  "partitions": {
-    "plugin": {
-      "path": "src",
-      "target": "ReplicatedStorage.Rojo.Plugin"
-    },
-    "modules/roact": {
-      "path": "modules/roact/lib",
-      "target": "ReplicatedStorage.Rojo.Roact"
-    },
-    "modules/rodux": {
-      "path": "modules/rodux/lib",
-      "target": "ReplicatedStorage.Rojo.Rodux"
-    },
-    "modules/roact-rodux": {
-      "path": "modules/roact-rodux/lib",
-      "target": "ReplicatedStorage.Rojo.RoactRodux"
-    },
-    "modules/promise": {
-      "path": "modules/promise/lib",
-      "target": "ReplicatedStorage.Rojo.Promise"
-    },
-    "modules/testez": {
-      "path": "modules/testez/lib",
-      "target": "ReplicatedStorage.TestEZ"
-    },
-    "tests": {
-      "path": "testBootstrap.server.lua",
-      "target": "TestService.testBootstrap"
-    }
-  }
-}

plugin/src/ApiContext.lua

@@ -131,13 +131,15 @@ function ApiContext:read(ids)
 				return Promise.reject("Server changed ID")
 			end
 
-			self.messageCursor = body.messageCursor
-
 			return body
 		end)
 end
 
-function ApiContext:retrieveMessages()
+function ApiContext:retrieveMessages(initialCursor)
+	if initialCursor ~= nil then
+		self.messageCursor = initialCursor
+	end
+
 	local url = ("%s/api/subscribe/%s"):format(self.baseUrl, self.messageCursor)
 
 	local function sendRequest()

plugin/src/Assets.lua

@@ -15,7 +15,8 @@ local Assets = {
 		},
 	},
 	Images = {
-		Logo = "rbxassetid://2773210620",
+		Logo = "rbxassetid://3405346157",
+		Icon = "rbxassetid://3405341609",
 	},
 	StartSession = "",
 	SessionActive = "",

plugin/src/Components/App.lua

@@ -1,13 +1,14 @@
-local Roact = require(script:FindFirstAncestor("Rojo").Roact)
+local Rojo = script:FindFirstAncestor("Rojo")
+local Plugin = Rojo.Plugin
 
-local Plugin = script:FindFirstAncestor("Plugin")
+local Roact = require(Rojo.Roact)
 
 local Assets = require(Plugin.Assets)
-local Session = require(Plugin.Session)
 local Config = require(Plugin.Config)
-local Version = require(Plugin.Version)
-local Logging = require(Plugin.Logging)
 local DevSettings = require(Plugin.DevSettings)
+local Logging = require(Plugin.Logging)
+local Session = require(Plugin.Session)
+local Version = require(Plugin.Version)
 local preloadAssets = require(Plugin.preloadAssets)
 
 local ConnectPanel = require(Plugin.Components.ConnectPanel)
@@ -54,8 +55,6 @@ end
 local SessionStatus = {
 	Disconnected = "Disconnected",
 	Connected = "Connected",
-	ConfiguringSession = "ConfiguringSession",
-	-- TODO: Error?
 }
 
 setmetatable(SessionStatus, {
@@ -71,12 +70,41 @@ function App:init()
 		sessionStatus = SessionStatus.Disconnected,
 	})
 
-	self.connectButton = nil
+	self.signals = {}
 	self.currentSession = nil
 
 	self.displayedVersion = DevSettings:isEnabled()
 		and Config.codename
 		or Version.display(Config.version)
+
+	local toolbar = self.props.plugin:CreateToolbar("Rojo " .. self.displayedVersion)
+
+	self.toggleButton = toolbar:CreateButton(
+		"Rojo",
+		"Show or hide the Rojo panel",
+		Assets.Images.Icon)
+	self.toggleButton.ClickableWhenViewportHidden = true
+	self.toggleButton.Click:Connect(function()
+		self.dockWidget.Enabled = not self.dockWidget.Enabled
+	end)
+
+	local widgetInfo = DockWidgetPluginGuiInfo.new(
+		Enum.InitialDockState.Right,
+		false, -- Initially enabled state
+		false, -- Whether to override the widget's previous state
+		360, 190, -- Floating size
+		360, 190 -- Minimum size
+	)
+
+	self.dockWidget = self.props.plugin:CreateDockWidgetPluginGui("Rojo-0.5.x", widgetInfo)
+	self.dockWidget.Name = "Rojo " .. self.displayedVersion
+	self.dockWidget.Title = "Rojo " .. self.displayedVersion
+	self.dockWidget.AutoLocalize = false
+	self.dockWidget.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
+
+	self.signals.dockWidgetEnabled = self.dockWidget:GetPropertyChangedSignal("Enabled"):Connect(function()
+		self.toggleButton:SetActive(self.dockWidget.Enabled)
+	end)
 end
 
 function App:render()
@@ -98,7 +126,7 @@ function App:render()
 				end,
 			}),
 		}
-	elseif self.state.sessionStatus == SessionStatus.ConfiguringSession then
+	elseif self.state.sessionStatus == SessionStatus.Disconnected then
 		children = {
 			ConnectPanel = e(ConnectPanel, {
 				startSession = function(address, port)
@@ -135,50 +163,15 @@ function App:render()
 		}
 	end
 
-	return e("ScreenGui", {
-		AutoLocalize = false,
-		ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
+	return Roact.createElement(Roact.Portal, {
+		target = self.dockWidget,
 	}, children)
 end
 
 function App:didMount()
 	Logging.trace("Rojo %s initializing", self.displayedVersion)
 
-	local toolbar = self.props.plugin:CreateToolbar("Rojo " .. self.displayedVersion)
-
-	self.connectButton = toolbar:CreateButton(
-		"Connect",
-		"Connect to a running Rojo session",
-		Assets.StartSession)
-	self.connectButton.ClickableWhenViewportHidden = false
-	self.connectButton.Click:Connect(function()
-		checkUpgrade(self.props.plugin)
-
-		if self.state.sessionStatus == SessionStatus.Connected then
-			Logging.trace("Disconnecting session")
-
-			self.currentSession:disconnect()
-			self.currentSession = nil
-			self:setState({
-				sessionStatus = SessionStatus.Disconnected,
-			})
-
-			Logging.trace("Session terminated by user")
-		elseif self.state.sessionStatus == SessionStatus.Disconnected then
-			Logging.trace("Starting session configuration")
-
-			self:setState({
-				sessionStatus = SessionStatus.ConfiguringSession,
-			})
-		elseif self.state.sessionStatus == SessionStatus.ConfiguringSession then
-			Logging.trace("Canceling session configuration")
-
-			self:setState({
-				sessionStatus = SessionStatus.Disconnected,
-			})
-		end
-	end)
-
+	checkUpgrade(self.props.plugin)
 	preloadAssets()
 end
 
@@ -187,18 +180,9 @@ function App:willUnmount()
 		self.currentSession:disconnect()
 		self.currentSession = nil
 	end
-end
 
-function App:didUpdate()
-	local connectActive = self.state.sessionStatus == SessionStatus.ConfiguringSession
-		or self.state.sessionStatus == SessionStatus.Connected
-
-	self.connectButton:SetActive(connectActive)
-
-	if self.state.sessionStatus == SessionStatus.Connected then
-		self.connectButton.Icon = Assets.SessionActive
-	else
-		self.connectButton.Icon = Assets.StartSession
+	for _, signal in pairs(self.signals) do
+		signal:Disconnect()
 	end
 end
 

plugin/src/Components/ConnectPanel.lua

@@ -4,39 +4,19 @@ local Plugin = Rojo.Plugin
 local Roact = require(Rojo.Roact)
 
 local Config = require(Plugin.Config)
-local Version = require(Plugin.Version)
-local Assets = require(Plugin.Assets)
 local Theme = require(Plugin.Theme)
-local joinBindings = require(Plugin.joinBindings)
 
+local Panel = require(Plugin.Components.Panel)
 local FitList = require(Plugin.Components.FitList)
 local FitText = require(Plugin.Components.FitText)
 local FormButton = require(Plugin.Components.FormButton)
 local FormTextInput = require(Plugin.Components.FormTextInput)
 
-local RoundBox = Assets.Slices.RoundBox
-
 local e = Roact.createElement
 
 local ConnectPanel = Roact.Component:extend("ConnectPanel")
 
 function ConnectPanel:init()
-	self.footerSize, self.setFooterSize = Roact.createBinding(Vector2.new())
-	self.footerVersionSize, self.setFooterVersionSize = Roact.createBinding(Vector2.new())
-
-	-- This is constructed in init because 'joinBindings' is a hack and we'd
-	-- leak memory constructing it every render. When this kind of feature lands
-	-- in Roact properly, we can do this inline in render without fear.
-	self.footerRestSize = joinBindings(
-		{
-			self.footerSize,
-			self.footerVersionSize,
-		},
-		function(container, other)
-			return UDim2.new(0, container.X - other.X - 16, 0, 32)
-		end
-	)
-
 	self:setState({
 		address = "",
 		port = "",
@@ -45,24 +25,14 @@ end
 
 function ConnectPanel:render()
 	local startSession = self.props.startSession
-	local cancel = self.props.cancel
 
-	return e(FitList, {
-		containerKind = "ImageLabel",
-		containerProps = {
-			Image = RoundBox.asset,
-			ImageRectOffset = RoundBox.offset,
-			ImageRectSize = RoundBox.size,
-			SliceCenter = RoundBox.center,
-			ScaleType = Enum.ScaleType.Slice,
-			BackgroundTransparency = 1,
-			Position = UDim2.new(0.5, 0, 0.5, 0),
-			AnchorPoint = Vector2.new(0.5, 0.5),
-		},
-		layoutProps = {
+	return e(Panel, nil, {
+		Layout = e("UIListLayout", {
+			SortOrder = Enum.SortOrder.LayoutOrder,
 			HorizontalAlignment = Enum.HorizontalAlignment.Center,
-		},
-	}, {
+			VerticalAlignment = Enum.VerticalAlignment.Center,
+		}),
+
 		Inputs = e(FitList, {
 			containerProps = {
 				BackgroundTransparency = 1,
@@ -96,7 +66,7 @@ function ConnectPanel:render()
 					Font = Theme.TitleFont,
 					TextSize = 20,
 					Text = "Address",
-					TextColor3 = Theme.AccentColor,
+					TextColor3 = Theme.PrimaryColor,
 				}),
 
 				Input = e(FormTextInput, {
@@ -129,7 +99,7 @@ function ConnectPanel:render()
 					Font = Theme.TitleFont,
 					TextSize = 20,
 					Text = "Port",
-					TextColor3 = Theme.AccentColor,
+					TextColor3 = Theme.PrimaryColor,
 				}),
 
 				Input = e(FormTextInput, {
@@ -165,17 +135,6 @@ function ConnectPanel:render()
 				PaddingRight = UDim.new(0, 24),
 			},
 		}, {
-			e(FormButton, {
-				layoutOrder = 1,
-				text = "Cancel",
-				onClick = function()
-					if cancel ~= nil then
-						cancel()
-					end
-				end,
-				secondary = true,
-			}),
-
 			e(FormButton, {
 				layoutOrder = 2,
 				text = "Connect",
@@ -196,65 +155,6 @@ function ConnectPanel:render()
 				end,
 			}),
 		}),
-
-		Footer = e(FitList, {
-			fitAxes = "Y",
-			containerKind = "ImageLabel",
-			containerProps = {
-				Image = RoundBox.asset,
-				ImageRectOffset = RoundBox.offset + Vector2.new(0, RoundBox.size.Y / 2),
-				ImageRectSize = RoundBox.size * Vector2.new(1, 0.5),
-				SliceCenter = RoundBox.center,
-				ScaleType = Enum.ScaleType.Slice,
-				ImageColor3 = Theme.SecondaryColor,
-				Size = UDim2.new(1, 0, 0, 0),
-				LayoutOrder = 3,
-				BackgroundTransparency = 1,
-
-				[Roact.Change.AbsoluteSize] = function(rbx)
-					self.setFooterSize(rbx.AbsoluteSize)
-				end,
-			},
-			layoutProps = {
-				FillDirection = Enum.FillDirection.Horizontal,
-				HorizontalAlignment = Enum.HorizontalAlignment.Center,
-				VerticalAlignment = Enum.VerticalAlignment.Center,
-			},
-			paddingProps = {
-				PaddingTop = UDim.new(0, 4),
-				PaddingBottom = UDim.new(0, 4),
-				PaddingLeft = UDim.new(0, 8),
-				PaddingRight = UDim.new(0, 8),
-			},
-		}, {
-			LogoContainer = e("Frame", {
-				BackgroundTransparency = 1,
-
-				Size = self.footerRestSize,
-			}, {
-				Logo = e("ImageLabel", {
-					Image = Assets.Images.Logo,
-					Size = UDim2.new(0, 80, 0, 40),
-					ScaleType = Enum.ScaleType.Fit,
-					BackgroundTransparency = 1,
-					Position = UDim2.new(0, 0, 1, -10),
-					AnchorPoint = Vector2.new(0, 1),
-				}),
-			}),
-
-			Version = e(FitText, {
-				Font = Theme.TitleFont,
-				TextSize = 18,
-				Text = Version.display(Config.version),
-				TextXAlignment = Enum.TextXAlignment.Right,
-				TextColor3 = Theme.LightTextColor,
-				BackgroundTransparency = 1,
-
-				[Roact.Change.AbsoluteSize] = function(rbx)
-					self.setFooterVersionSize(rbx.AbsoluteSize)
-				end,
-			}),
-		}),
 	})
 end
 

plugin/src/Components/ConnectionActivePanel.lua

@@ -3,63 +3,42 @@ local Roact = require(script:FindFirstAncestor("Rojo").Roact)
 local Plugin = script:FindFirstAncestor("Plugin")
 
 local Theme = require(Plugin.Theme)
-local Assets = require(Plugin.Assets)
 
-local FitList = require(Plugin.Components.FitList)
+local Panel = require(Plugin.Components.Panel)
 local FitText = require(Plugin.Components.FitText)
+local FormButton = require(Plugin.Components.FormButton)
 
 local e = Roact.createElement
 
-local RoundBox = Assets.Slices.RoundBox
-local WhiteCross = Assets.Sprites.WhiteCross
+local ConnectionActivePanel = Roact.Component:extend("ConnectionActivePanel")
 
-local function ConnectionActivePanel(props)
-	local stopSession = props.stopSession
+function ConnectionActivePanel:render()
+	local stopSession = self.props.stopSession
 
-	return e(FitList, {
-		containerKind = "ImageLabel",
-		containerProps = {
-			Image = RoundBox.asset,
-			ImageRectOffset = RoundBox.offset + Vector2.new(0, RoundBox.size.Y / 2),
-			ImageRectSize = RoundBox.size * Vector2.new(1, 0.5),
-			SliceCenter = Rect.new(4, 4, 4, 4),
-			ScaleType = Enum.ScaleType.Slice,
-			BackgroundTransparency = 1,
-			Position = UDim2.new(0.5, 0, 0, 0),
-			AnchorPoint = Vector2.new(0.5, 0),
-		},
-		layoutProps = {
-			FillDirection = Enum.FillDirection.Horizontal,
+	return e(Panel, nil, {
+		Layout = Roact.createElement("UIListLayout", {
+			HorizontalAlignment = Enum.HorizontalAlignment.Center,
 			VerticalAlignment = Enum.VerticalAlignment.Center,
-		},
-	}, {
+			SortOrder = Enum.SortOrder.LayoutOrder,
+			Padding = UDim.new(0, 8),
+		}),
+
 		Text = e(FitText, {
 			Padding = Vector2.new(12, 6),
 			Font = Theme.ButtonFont,
 			TextSize = 18,
-			Text = "Rojo Connected",
+			Text = "Connected to Live-Sync Server",
 			TextColor3 = Theme.PrimaryColor,
 			BackgroundTransparency = 1,
 		}),
 
-		CloseContainer = e("ImageButton", {
-			Size = UDim2.new(0, 30, 0, 30),
-			BackgroundTransparency = 1,
-
-			[Roact.Event.Activated] = function()
+		DisconnectButton = e(FormButton, {
+			layoutOrder = 2,
+			text = "Disconnect",
+			secondary = true,
+			onClick = function()
 				stopSession()
 			end,
-		}, {
-			CloseImage = e("ImageLabel", {
-				Size = UDim2.new(0, 16, 0, 16),
-				Position = UDim2.new(0.5, 0, 0.5, 0),
-				AnchorPoint = Vector2.new(0.5, 0.5),
-				Image = WhiteCross.asset,
-				ImageRectOffset = WhiteCross.offset,
-				ImageRectSize = WhiteCross.size,
-				ImageColor3 = Theme.PrimaryColor,
-				BackgroundTransparency = 1,
-			}),
 		}),
 	})
 end

plugin/src/Components/FormTextInput.lua

@@ -57,8 +57,8 @@ function FormTextInput:render()
 			TextSize = TEXT_SIZE,
 			Text = value,
 			PlaceholderText = shownPlaceholder,
-			PlaceholderColor3 = Theme.AccentLightColor,
-			TextColor3 = Theme.AccentColor,
+			PlaceholderColor3 = Theme.LightTextColor,
+			TextColor3 = Theme.PrimaryColor,
 
 			[Roact.Change.Text] = function(rbx)
 				onValueChange(rbx.Text)

plugin/src/Components/Panel.lua

@@ -0,0 +1,34 @@
+local Roact = require(script:FindFirstAncestor("Rojo").Roact)
+
+local Plugin = script:FindFirstAncestor("Plugin")
+
+local RojoFooter = require(Plugin.Components.RojoFooter)
+
+local e = Roact.createElement
+
+local Panel = Roact.Component:extend("Panel")
+
+function Panel:init()
+	self.footerSize, self.setFooterSize = Roact.createBinding(Vector2.new())
+end
+
+function Panel:render()
+	return e("Frame", {
+		Size = UDim2.new(1, 0, 1, 0),
+		BackgroundTransparency = 1,
+	}, {
+		Layout = Roact.createElement("UIListLayout", {
+			HorizontalAlignment = Enum.HorizontalAlignment.Center,
+			SortOrder = Enum.SortOrder.LayoutOrder,
+		}),
+
+		Body = e("Frame", {
+			Size = UDim2.new(0, 360, 1, -32),
+			BackgroundTransparency = 1,
+		}, self.props[Roact.Children]),
+
+		Footer = e(RojoFooter),
+	})
+end
+
+return Panel

plugin/src/Components/RojoFooter.lua

@@ -0,0 +1,69 @@
+local Rojo = script:FindFirstAncestor("Rojo")
+local Plugin = Rojo.Plugin
+
+local Roact = require(Rojo.Roact)
+
+local Config = require(Plugin.Config)
+local Version = require(Plugin.Version)
+local Assets = require(Plugin.Assets)
+local Theme = require(Plugin.Theme)
+
+local FitText = require(Plugin.Components.FitText)
+
+local e = Roact.createElement
+
+local RojoFooter = Roact.Component:extend("RojoFooter")
+
+function RojoFooter:init()
+	self.footerSize, self.setFooterSize = Roact.createBinding(Vector2.new())
+	self.footerVersionSize, self.setFooterVersionSize = Roact.createBinding(Vector2.new())
+end
+
+function RojoFooter:render()
+	return e("Frame", {
+		LayoutOrder = 3,
+		Size = UDim2.new(1, 0, 0, 32),
+		BackgroundColor3 = Theme.SecondaryColor,
+		BorderSizePixel = 0,
+	}, {
+		Padding = e("UIPadding", {
+			PaddingTop = UDim.new(0, 4),
+			PaddingBottom = UDim.new(0, 4),
+			PaddingLeft = UDim.new(0, 8),
+			PaddingRight = UDim.new(0, 8),
+		}),
+
+		LogoContainer = e("Frame", {
+			BackgroundTransparency = 1,
+
+			Size = UDim2.new(0, 0, 0, 32),
+		}, {
+			Logo = e("ImageLabel", {
+				Image = Assets.Images.Logo,
+				Size = UDim2.new(0, 80, 0, 40),
+				ScaleType = Enum.ScaleType.Fit,
+				BackgroundTransparency = 1,
+				Position = UDim2.new(0, 0, 1, -10),
+				AnchorPoint = Vector2.new(0, 1),
+			}),
+		}),
+
+		Version = e("TextLabel", {
+			Position = UDim2.new(1, 0, 0, 0),
+			Size = UDim2.new(0, 0, 1, 0),
+			AnchorPoint = Vector2.new(1, 0),
+			Font = Theme.TitleFont,
+			TextSize = 18,
+			Text = Version.display(Config.version),
+			TextXAlignment = Enum.TextXAlignment.Right,
+			TextColor3 = Theme.LightTextColor,
+			BackgroundTransparency = 1,
+
+			[Roact.Change.AbsoluteSize] = function(rbx)
+				self.setFooterVersionSize(rbx.AbsoluteSize)
+			end,
+		}),
+	})
+end
+
+return RojoFooter

plugin/src/Config.lua

@@ -1,6 +1,6 @@
 return {
 	codename = "Epiphany",
-	version = {0, 5, 0, "-alpha.8"},
+	version = {0, 5, 3},
 	expectedServerVersionString = "0.5.0 or newer",
 	protocolVersion = 2,
 	defaultHost = "localhost",

plugin/src/Reconciler.lua

@@ -6,6 +6,12 @@ local setCanonicalProperty = require(script.Parent.setCanonicalProperty)
 local rojoValueToRobloxValue = require(script.Parent.rojoValueToRobloxValue)
 local Types = require(script.Parent.Types)
 
+local function setParent(instance, newParent)
+	pcall(function()
+		instance.Parent = newParent
+	end)
+end
+
 local Reconciler = {}
 Reconciler.__index = Reconciler
 
@@ -44,6 +50,8 @@ function Reconciler:reconcile(virtualInstancesById, id, instance)
 	-- If an instance changes ClassName, we assume it's very different. That's
 	-- not always the case!
 	if virtualInstance.ClassName ~= instance.ClassName then
+		Logging.trace("Switching to reify for %s because ClassName is different", instance:GetFullName())
+
 		-- TODO: Preserve existing children instead?
 		local parent = instance.Parent
 		self.instanceMap:destroyId(id)
@@ -87,6 +95,12 @@ function Reconciler:reconcile(virtualInstancesById, id, instance)
 			unvisitedExistingChildren[existingChildInstance] = nil
 			self:reconcile(virtualInstancesById, childId, existingChildInstance)
 		else
+			Logging.trace(
+				"Switching to reify for %s.%s because it does not exist",
+				instance:GetFullName(),
+				virtualInstancesById[childId].Name
+			)
+
 			self:__reify(virtualInstancesById, childId, instance)
 		end
 	end
@@ -117,7 +131,7 @@ 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.
-		setCanonicalProperty(instance, "Parent", parent)
+		setParent(instance, parent)
 	end
 
 	return instance
@@ -142,7 +156,13 @@ function Reconciler:__reify(virtualInstancesById, id, parent)
 
 	local virtualInstance = virtualInstancesById[id]
 
-	local instance = Instance.new(virtualInstance.ClassName)
+	local ok, instance = pcall(function()
+		return Instance.new(virtualInstance.ClassName)
+	end)
+
+	if not ok then
+		error(("Couldn't create an Instance of type %q, a child of %s"):format(virtualInstance.ClassName, parent:GetFullName()))
+	end
 
 	for key, value in pairs(virtualInstance.Properties) do
 		setCanonicalProperty(instance, key, rojoValueToRobloxValue(value))
@@ -154,7 +174,7 @@ function Reconciler:__reify(virtualInstancesById, id, parent)
 		self:__reify(virtualInstancesById, childId, instance)
 	end
 
-	setCanonicalProperty(instance, "Parent", parent)
+	setParent(instance, parent)
 	self.instanceMap:insert(id, instance)
 
 	return instance

plugin/src/Session.lua

@@ -33,7 +33,7 @@ function Session.new(config)
 			end
 
 			self.reconciler:reconcile(response.instances, api.rootInstanceId, game)
-			return self:__processMessages()
+			return self:__processMessages(response.messageCursor)
 		end)
 		:catch(function(message)
 			self.disconnected = true
@@ -43,12 +43,12 @@ function Session.new(config)
 	return not self.disconnected, setmetatable(self, Session)
 end
 
-function Session:__processMessages()
+function Session:__processMessages(initialCursor)
 	if self.disconnected then
 		return Promise.resolve()
 	end
 
-	return self.api:retrieveMessages()
+	return self.api:retrieveMessages(initialCursor)
 		:andThen(function(messages)
 			local promise = Promise.resolve(nil)
 

plugin/src/Theme.lua

@@ -4,11 +4,11 @@ local Theme = {
 	TitleFont = Enum.Font.GothamBold,
 	MainFont = Enum.Font.Gotham,
 
-	AccentColor = Color3.fromRGB(136, 0, 27),
-	AccentLightColor = Color3.fromRGB(210, 145, 157),
-	PrimaryColor = Color3.fromRGB(20, 20, 20),
+	AccentColor = Color3.fromRGB(225, 56, 53),
+	AccentLightColor = Color3.fromRGB(255, 146, 145),
+	PrimaryColor = Color3.fromRGB(64, 64, 64),
 	SecondaryColor = Color3.fromRGB(235, 235, 235),
-	LightTextColor = Color3.fromRGB(140, 140, 140),
+	LightTextColor = Color3.fromRGB(160, 160, 160),
 }
 
 setmetatable(Theme, {

plugin/src/joinBindings.lua

@@ -1,34 +0,0 @@
---[[
-	joinBindings is a crazy hack that allows combining multiple Roact bindings
-	in the same spirit as `map`.
-
-	It's implemented in terms of Roact internals that will probably break at
-	some point; please don't do that or use this module in your own code!
-]]
-
-local Binding = require(script:FindFirstAncestor("Rojo").Roact.Binding)
-
-local function evaluate(fun, bindings)
-	local input = {}
-
-	for index, binding in ipairs(bindings) do
-		input[index] = binding:getValue()
-	end
-
-	return fun(unpack(input, 1, #bindings))
-end
-
-local function joinBindings(bindings, joinFunction)
-	local initialValue = evaluate(joinFunction, bindings)
-	local binding, setValue = Binding.create(initialValue)
-
-	for _, binding in ipairs(bindings) do
-		Binding.subscribe(binding, function()
-			setValue(evaluate(joinFunction, bindings))
-		end)
-	end
-
-	return binding
-end
-
-return joinBindings

plugin/src/rojoValueToRobloxValue.lua

@@ -1,38 +1,19 @@
-local primitiveTypes = {
-	Bool = true,
-	Enum = true,
-	Float32 = true,
-	Float64 = true,
-	Int32 = true,
-	Int64 = true,
-	String = true,
-}
-
-local directConstructors = {
-	CFrame = CFrame.new,
-	Color3 = Color3.new,
-	Color3uint8 = Color3.fromRGB,
-	Rect = Rect.new,
-	UDim = UDim.new,
-	UDim2 = UDim2.new,
-	Vector2 = Vector2.new,
-	Vector2int16 = Vector2int16.new,
-	Vector3 = Vector3.new,
-	Vector3int16 = Vector3int16.new,
-}
+local RbxDom = require(script:FindFirstAncestor("Rojo").RbxDom)
 
 local function rojoValueToRobloxValue(value)
-	if primitiveTypes[value.Type] then
-		return value.Value
+	-- TODO: Manually decode this value by looking up its GUID The Rojo server
+	-- doesn't give us valid ref values yet, so this isn't important yet.
+	if value.Type == "Ref" then
+		return nil
 	end
 
-	local constructor = directConstructors[value.Type]
-	if constructor ~= nil then
-		return constructor(unpack(value.Value))
+	local success, decodedValue = RbxDom.EncodedValue.decode(value)
+
+	if not success then
+		error(decodedValue, 2)
 	end
 
-	local errorMessage = ("The Rojo plugin doesn't know how to handle values of type %q yet!"):format(tostring(value.Type))
-	error(errorMessage)
+	return decodedValue
 end
 
 return rojoValueToRobloxValue

plugin/src/setCanonicalProperty.lua

@@ -1,54 +1,34 @@
-local Logging = require(script.Parent.Logging)
+local RbxDom = require(script:FindFirstAncestor("Rojo").RbxDom)
 
 --[[
 	Attempts to set a property on the given instance.
-
-	This method deals in terms of what Rojo calls 'canonical properties', which
-	don't necessarily exist either in serialization or in Lua-reflected APIs,
-	but may be present in the API dump.
-
-	Ideally, canonical properties map 1:1 with properties we can assign, but in
-	some cases like LocalizationTable contents and CollectionService tags, we
-	have to read/write properties a little differently.
 ]]
-local function setCanonicalProperty(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
+local function setCanonicalProperty(instance, propertyName, value)
+	local descriptor = RbxDom.findCanonicalPropertyDescriptor(instance.ClassName, propertyName)
+
+	-- We can skip unknown properties; they're not likely reflected to Lua.
+	--
+	-- A good example of a property like this is `Model.ModelInPrimary`, which
+	-- is serialized but not reflected to Lua.
+	if descriptor == nil then
+		return false, "unknown property"
 	end
 
-	-- Temporary workaround for fixing issue #141 in this specific case.
-	if instance.ClassName == "Lighting" and key == "Technology" then
-		return
+	if descriptor.scriptability == "None" or descriptor.scriptability == "Read" then
+		return false, "unwritable property"
 	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)
+	local success, err = descriptor:write(instance, value)
 
-	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)
+	if not success then
+		-- If we don't have permission to write a property, we just silently
+		-- ignore it.
+		if err.kind == RbxDom.Error.Kind.Roblox and err.extra:find("lacking permission") then
+			return false, "permission error"
 		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)
+		local message = ("Invalid property %s.%s: %s"):format(descriptor.className, descriptor.name, tostring(err))
+		error(message, 2)
 	end
 
 	return true

rojo-e2e/Cargo.toml

@@ -1,6 +0,0 @@
-[package]
-name = "rojo-e2e"
-version = "0.1.0"
-authors = ["Lucien Greathouse <me@lpghatguy.com>"]
-
-[dependencies]

rojo-e2e/README.md

@@ -1,2 +0,0 @@
-# Rojo End-to-End
-This is a WIP test runner designed for Rojo. It will eventually start up the Rojo server and plugin and test functionality end-to-end.

rojo-e2e/src/lib.rs

@@ -1,32 +0,0 @@
-use std::{
-    path::Path,
-    process::Command,
-    thread,
-    time::Duration,
-};
-
-fn main() {
-    let plugin_path = Path::new("../plugin");
-    let server_path = Path::new("../server");
-    let tests_path = Path::new("../tests");
-
-    let server = Command::new("cargo")
-        .args(&["run", "--", "serve", "../test-projects/empty"])
-        .current_dir(server_path)
-        .spawn();
-
-    thread::sleep(Duration::from_millis(1000));
-
-    // TODO: Wait for server to start responding on the right port
-
-    let test_client = Command::new("lua")
-        .args(&["runTest.lua", "tests/empty.lua"])
-        .current_dir(plugin_path)
-        .spawn();
-
-    thread::sleep(Duration::from_millis(300));
-
-    // TODO: Collect output from the client for success/failure?
-
-    println!("Dying!");
-}

rojo-test/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "rojo-test"
+version = "0.1.0"
+authors = ["Lucien Greathouse <me@lpghatguy.com>"]
+edition = "2018"
+publish = false
+
+[dependencies]
+insta = "0.10.0"
+paste = "0.1.5"
+tempfile = "3.1.0"
+
+# We execute Rojo via std::process::Command, so depend on it so it's built!
+rojo = { path = "../server" }

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

@@ -0,0 +1,6 @@
+{
+  "name": "client_in_folder",
+  "tree": {
+    "$path": "folder"
+  }
+}

rojo-test/build-tests/client_in_folder/folder/localScript.client.lua

@@ -0,0 +1 @@
+-- This is a Lua client script

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

@@ -0,0 +1,6 @@
+{
+  "name": "client_init",
+  "tree": {
+    "$path": "folder"
+  }
+}

rojo-test/build-tests/client_init/folder/init.client.lua

@@ -0,0 +1 @@
+return "From folder/init.client.lua"

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

@@ -0,0 +1,6 @@
+{
+  "name": "csv_bug_145",
+  "tree": {
+    "$path": "folder"
+  }
+}

rojo-test/build-tests/csv_bug_145/folder/normal.csv

@@ -0,0 +1,2 @@
+Key,Source,Context,Example,es
+Count,3,,A number demonstrating issue 145,7

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

@@ -0,0 +1,6 @@
+{
+  "name": "csv_bug_147",
+  "tree": {
+    "$path": "folder"
+  }
+}

rojo-test/build-tests/csv_bug_147/folder/normal.csv

@@ -0,0 +1,17 @@
+,Key,Source,Context,Example
+,,,,
+Metadata,Language.Name,English,,
+,Language.Region,United States,,
+,,,,
+Options,Label.Thickness,Thickness,,
+,Label.Opacity,Opacity,,
+,,,,
+Toolbar,Toolbar.Undo,Undo,,
+,Toolbar.Redo,Redo,,
+,,,,
+,Toolbar.Camera,Top-down camera,,
+,Toolbar.Saves,Saved drawings,,
+,Toolbar.Preferences,Settings,,
+,,,,
+,Toolbar.Mode.Vector,Vector mode,,
+,Toolbar.Mode.Pixel,Pixel mode,,

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

@@ -0,0 +1,6 @@
+{
+  "name": "csv_in_folder",
+  "tree": {
+    "$path": "folder"
+  }
+}

rojo-test/build-tests/csv_in_folder/folder/normal.csv

@@ -0,0 +1,2 @@
+Key,Source,Context,Example,es
+Ack,Ack!,,An exclamation of despair,¡Ay!

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

@@ -1,5 +1,5 @@
 {
-  "name": "malformed-stuff",
+  "name": "gitkeep",
   "tree": {
     "$path": "src"
   }

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

@@ -0,0 +1,6 @@
+{
+  "name": "init_meta_class_name",
+  "tree": {
+    "$path": "should-be-a-model"
+  }
+}

rojo-test/build-tests/init_meta_class_name/should-be-a-model/init.meta.json

@@ -0,0 +1,3 @@
+{
+  "className": "Model"
+}

rojo-test/build-tests/init_meta_properties/Lighting/init.meta.json

@@ -0,0 +1,6 @@
+{
+  "className": "Lighting",
+  "properties": {
+    "Technology": "Voxel"
+  }
+}

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

@@ -0,0 +1,6 @@
+{
+  "name": "init_meta_properties",
+  "tree": {
+    "$path": "Lighting"
+  }
+}

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

@@ -0,0 +1,6 @@
+{
+  "name": "json_model_in_folder",
+  "tree": {
+    "$path": "folder"
+  }
+}

rojo-test/build-tests/json_model_in_folder/folder/simple-model.model.json

@@ -0,0 +1,12 @@
+{
+  "ClassName": "IntValue",
+  "Properties": {
+    "Value": 5
+  },
+  "Children": [
+    {
+      "Name": "A Child",
+      "ClassName": "Folder"
+    }
+  ]
+}

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

@@ -0,0 +1,6 @@
+{
+  "name": "json_model_legacy_name",
+  "tree": {
+    "$path": "folder"
+  }
+}

rojo-test/build-tests/json_model_legacy_name/folder/Expected Name.model.json

@@ -0,0 +1,4 @@
+{
+  "Name": "Overridden Name",
+  "ClassName": "Folder"
+}

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

@@ -0,0 +1,6 @@
+{
+  "name": "module_in_folder",
+  "tree": {
+    "$path": "folder"
+  }
+}

rojo-test/build-tests/module_in_folder/folder/aModule.lua

@@ -0,0 +1 @@
+-- This is a Lua module

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

@@ -0,0 +1,6 @@
+{
+  "name": "module_init",
+  "tree": {
+    "$path": "folder"
+  }
+}

rojo-test/build-tests/module_init/folder/init.lua

@@ -0,0 +1 @@
+return "From folder/init.lua"

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

@@ -0,0 +1,6 @@
+{
+  "name": "rbxm_in_folder",
+  "tree": {
+    "$path": "folder"
+  }
+}

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

@@ -0,0 +1,6 @@
+{
+  "name": "rbxmx_in_folder",
+  "tree": {
+    "$path": "folder"
+  }
+}

rojo-test/build-tests/rbxmx_in_folder/folder/test-model.rbxmx

@@ -0,0 +1,33 @@
+<roblox xmlns:xmime="http://www.w3.org/2005/05/xmlmime" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.roblox.com/roblox.xsd" version="4">
+	<Meta name="ExplicitAutoJoints">true</Meta>
+	<External>null</External>
+	<External>nil</External>
+	<Item class="Model" referent="RBX7E9D90237E87493FB533B16578969429">
+		<Properties>
+			<CoordinateFrame name="ModelInPrimary">
+				<X>0</X>
+				<Y>0</Y>
+				<Z>0</Z>
+				<R00>1</R00>
+				<R01>0</R01>
+				<R02>0</R02>
+				<R10>0</R10>
+				<R11>1</R11>
+				<R12>0</R12>
+				<R20>0</R20>
+				<R21>0</R21>
+				<R22>1</R22>
+			</CoordinateFrame>
+			<string name="Name">Awesome Model</string>
+			<Ref name="PrimaryPart">null</Ref>
+			<BinaryString name="Tags"></BinaryString>
+		</Properties>
+		<Item class="StringValue" referent="RBXD2A682F437C84BE89C7B356CF5E4D92E">
+			<Properties>
+				<string name="Name">Cool StringValue</string>
+				<BinaryString name="Tags"></BinaryString>
+				<string name="Value">Did you know that BaseValue.Changed is different than Instance.Changed?</string>
+			</Properties>
+		</Item>
+	</Item>
+</roblox>

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

@@ -0,0 +1,6 @@
+{
+  "name": "script_meta_disabled",
+  "tree": {
+    "$path": "folder"
+  }
+}

rojo-test/build-tests/script_meta_disabled/folder/hello.meta.json

@@ -0,0 +1,5 @@
+{
+  "properties": {
+    "Disabled": true
+  }
+}

rojo-test/build-tests/script_meta_disabled/folder/hello.server.lua

@@ -0,0 +1 @@
+-- This script should be marked 'Disabled'

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

@@ -0,0 +1,6 @@
+{
+  "name": "server_in_folder",
+  "tree": {
+    "$path": "folder"
+  }
+}

rojo-test/build-tests/server_in_folder/folder/serverScript.server.lua

@@ -0,0 +1 @@
+-- This is a Lua server script

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

@@ -0,0 +1,6 @@
+{
+  "name": "server_init",
+  "tree": {
+    "$path": "folder"
+  }
+}

rojo-test/build-tests/server_init/folder/init.server.lua

@@ -0,0 +1 @@
+return "From folder/init.server.lua"

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

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

rojo-test/src/build_test.rs

@@ -0,0 +1,72 @@
+use std::{fs, path::Path, process::Command};
+
+use insta::assert_snapshot_matches;
+use tempfile::tempdir;
+
+macro_rules! gen_build_tests {
+    ( $($test_name: ident,)* ) => {
+        $(
+            paste::item! {
+                #[test]
+                fn [<build_ $test_name>]() {
+                    run_build_test(stringify!($test_name));
+                }
+            }
+        )*
+    };
+}
+
+gen_build_tests! {
+    client_in_folder,
+    client_init,
+    csv_bug_145,
+    csv_bug_147,
+    csv_in_folder,
+    gitkeep,
+    init_meta_class_name,
+    init_meta_properties,
+    json_model_in_folder,
+    json_model_legacy_name,
+    module_in_folder,
+    module_init,
+    rbxm_in_folder,
+    rbxmx_in_folder,
+    script_meta_disabled,
+    server_in_folder,
+    server_init,
+    txt_in_folder,
+}
+
+fn run_build_test(test_name: &str) {
+    let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
+    let build_test_path = manifest_dir.join("build-tests");
+    let working_dir = manifest_dir.parent().unwrap();
+
+    let output_dir = tempdir().expect("couldn't create temporary directory");
+
+    let input_path = build_test_path.join(test_name);
+    let output_path = output_dir.path().join(format!("{}.rbxmx", test_name));
+
+    let mut exe_path = working_dir.join("target/debug/rojo");
+    if cfg!(windows) {
+        exe_path.set_extension("exe");
+    }
+
+    let status = Command::new(exe_path)
+        .args(&[
+            "build",
+            input_path.to_str().unwrap(),
+            "-o",
+            output_path.to_str().unwrap(),
+        ])
+        .env("RUST_LOG", "error")
+        .current_dir(working_dir)
+        .status()
+        .expect("Couldn't start Rojo");
+
+    assert!(status.success(), "Rojo did not exit successfully");
+
+    let contents = fs::read_to_string(&output_path).expect("Couldn't read output file");
+
+    assert_snapshot_matches!(test_name, contents);
+}

rojo-test/src/lib.rs

@@ -0,0 +1,2 @@
+#[cfg(test)]
+mod build_test;

rojo-test/src/snapshots/build_test__client_in_folder.snap

@@ -0,0 +1,19 @@
+---
+created: "2019-08-09T01:29:47.650277200Z"
+creator: insta@0.10.0
+source: rojo-test/src/build_test.rs
+expression: contents
+---
+<roblox version="4">
+  <Item class="Folder" referent="0">
+    <Properties>
+      <string name="Name">client_in_folder</string>
+    </Properties>
+    <Item class="LocalScript" referent="1">
+      <Properties>
+        <string name="Name">localScript</string>
+        <string name="Source">-- This is a Lua client script</string>
+      </Properties>
+    </Item>
+  </Item>
+</roblox>