0.5.0-alpha.1

* HTTP responses in the error range (400+) now properly turn into errors
* ROJO_EPIPHANY_DEV_CREATE now creates more verbose configuration
* Default configuration values are now much more explicit
* Errors that cause session termination are labeled more clearly.

.editorconfig

@@ -3,19 +3,16 @@ root = true
 [*]
 end_of_line = lf
 charset = utf-8
-
-[*.lua]
-indent_style = tab
+insert_final_newline = false
 trim_trailing_whitespace = true
-insert_final_newline = true
 
-[*.rs]
-indent_style = space
-indent_size = 4
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.json]
+[*.{json,js,css}]
 indent_style = space
 indent_size = 2
-trim_trailing_whitespace = true
+
+[*.{md,rs}]
+indent_style = space
+indent_size = 4
+
+[*.lua]
+indent_style = tab

.gitignore

@@ -1,2 +1,5 @@
-/target/
+/site
+/target
+/server/scratch
 **/*.rs.bk
+/generate-docs.run

.gitmodules

@@ -0,0 +1,18 @@
+[submodule "plugin/modules/roact"]
+	path = plugin/modules/roact
+	url = https://github.com/Roblox/roact.git
+[submodule "plugin/modules/rodux"]
+	path = plugin/modules/rodux
+	url = https://github.com/Roblox/rodux.git
+[submodule "plugin/modules/roact-rodux"]
+	path = plugin/modules/roact-rodux
+	url = https://github.com/Roblox/roact-rodux.git
+[submodule "plugin/modules/testez"]
+	path = plugin/modules/testez
+	url = https://github.com/Roblox/testez.git
+[submodule "plugin/modules/lemur"]
+	path = plugin/modules/lemur
+	url = https://github.com/LPGhatguy/lemur.git
+[submodule "plugin/modules/promise"]
+	path = plugin/modules/promise
+	url = https://github.com/LPGhatguy/roblox-lua-promise.git

.travis.yml

@@ -0,0 +1,38 @@
+matrix:
+  include:
+    - language: python
+      env:
+        - LUA="lua=5.1"
+
+      before_install:
+        - pip install hererocks
+        - hererocks lua_install -r^ --$LUA
+        - export PATH=$PATH:$PWD/lua_install/bin
+
+      install:
+        - luarocks install luafilesystem
+        - luarocks install busted
+        - luarocks install luacov
+        - luarocks install luacov-coveralls
+        - luarocks install luacheck
+
+      script:
+        - cd plugin
+        - luacheck src
+        - lua -lluacov spec.lua
+
+      after_success:
+        - cd plugin
+        - luacov-coveralls -e $TRAVIS_BUILD_DIR/lua_install
+
+    - language: rust
+      rust: stable
+
+      script:
+        - cargo test --verbose
+
+    - language: rust
+      rust: beta
+
+      script:
+        - cargo test --verbose

CHANGELOG.md

@@ -0,0 +1,139 @@
+# Rojo Changelog
+
+## [Unreleased]
+
+## [0.5.0 Alpha 1](https://github.com/LPGhatguy/rojo/releases/tag/v0.5.0-alpha.1) (January 14, 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
+* Removed unused 'Config' button in plugin UI
+* 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)
+* "Epiphany" rewrite, in progress since the beginning of time
+* New live sync protocol
+    * Uses HTTP long polling to reduce request count and improve responsiveness
+* New project format
+    * Hierarchical, preventing overlapping partitions
+* Added `rojo build` command
+    * Generates `rbxm`, `rbxmx`, `rbxl`, or `rbxlx` files out of your project
+    * Usage: `rojo build <PROJECT> --output <OUTPUT>.rbxm`
+* Added `rojo upload` command
+    * Generates and uploads a place or model to roblox.com out of your project
+    * Usage: `rojo upload <PROJECT> --cookie "<ROBLOSECURITY>" --asset_id <PLACE_ID>`
+* New plugin
+    * Only one button now, "Connect"
+    * New UI to pick server address and port
+    * Better error reporting
+* Added support for `.csv` files turning into `LocalizationTable` instances
+* Added support for `.txt` files turning into `StringValue` instances
+* Added debug visualization code to diagnose problems
+    * `/visualize/rbx` and `/visualize/imfs` show instance and file state respectively; they require GraphViz to be installed on your machine.
+* Added optional place ID restrictions to project files
+    * This helps prevent syncing in content to the wrong place
+    * 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)
+* 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.11](https://github.com/LPGhatguy/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))
+* 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))
+* 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)
+* 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.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))
+* 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)
+* 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))
+
+## [0.4.4](https://github.com/LPGhatguy/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))
+* 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)
+* 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)
+* 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)
+* 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))
+
+## [0.3.2](https://github.com/LPGhatguy/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)
+* 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)
+* 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)
+* 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)
+* 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)
+* Plugin only release
+* Changes default port to 8000
+
+## [0.2.0](https://github.com/LPGhatguy/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)

CHANGES.md

@@ -1,19 +0,0 @@
-# Rojo Change Log
-
-## Current Master
-* *No changes*
-
-## 0.2.2
-* Plugin only release
-* Fixed broken reconciliation behavior with `init` files
-
-## 0.2.1
-* Plugin only release
-* Changes default port to 8000
-
-## 0.2.0
-* Support for `init.lua` like rbxfs and rbxpacker
-* More robust syncing with a new reconciler
-
-## 0.1.0
-* Initial release, functionally very similar to [rbxfs](https://github.com/LPGhatguy/rbxfs)

Cargo.toml

@@ -1,20 +1,5 @@
-[package]
-name = "rojo"
-version = "0.2.0"
-authors = ["Lucien Greathouse <me@lpghatguy.com>"]
-description = "A tool to create robust Roblox projects"
-license = "MIT"
-repository = "https://github.com/LPGhatguy/rojo"
-
-[[bin]]
-name = "rojo"
-path = "src/bin.rs"
-
-[dependencies]
-clap = "2.27.1"
-rouille = "1.0"
-serde = "1.0"
-serde_derive = "1.0"
-serde_json = "1.0"
-notify = "4.0.0"
-rand = "0.3"
+[workspace]
+members = [
+	"server",
+	"rojo-e2e",
+]

LICENSE.md

@@ -1,9 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2017 Lucien Greathouse
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

LICENSE.txt

@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.

README.md

@@ -1,140 +1,68 @@
-<h1 align="center">Rojo</h1>
 <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>
+    <img src="assets/rojo-logo.png" alt="Rojo" height="217" />
 </div>
 
 <div>&nbsp;</div>
 
-Rojo is a flexible multi-tool designed for creating robust Roblox projects. It's in early development, but is still useful for many projects.
+<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>
+    <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>
+    <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>
+</div>
 
-It's designed for power users who want to use the **best tools available** for building games, libraries, and plugins.
+<hr />
+
+**Rojo** is a flexible multi-tool designed for creating robust Roblox projects.
+
+It lets Roblox developers use industry-leading tools like Git and VS Code, and crucial utilities like Luacheck.
+
+Rojo is designed for **power users** who want to use the **best tools available** for building games, libraries, and plugins.
 
 ## Features
-
-Rojo has a number of desirable features *right now*:
+Rojo lets you:
 
 * Work on scripts from the filesystem, in your favorite editor
-* Version your place, library, or plugin using Git or another VCS
+* 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
 
 Soon, Rojo will be able to:
 
-* Sync Roblox objects (including models) bi-directionally between the filesystem and Roblox Studio
-* Create installation scripts for libraries to be used in standalone places
-	* Similar to [rbxpacker](https://github.com/LPGhatguy/rbxpacker), another one of my projects
-* Add strongly-versioned dependencies to your project
+* Sync instances from Roblox Studio to the filesystem
+* Compile MoonScript and other custom things for your project
 
-## Installation
-Rojo has two components:
-* The command line tool, written in Rust
-* The [Roblox Studio plugin](https://www.roblox.com/library/1211549683/Rojo-v0-0-0), written in Lua
+## [Documentation](https://lpghatguy.github.io/rojo/0.4.x)
+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.
 
-To install the command line tool, there are two options:
-* Cargo, if you have Rust installed
-	* Use `cargo install rojo` -- Rojo will be available with the `rojo` command
-* Download a pre-built Windows binary from [the GitHub releases page](https://github.com/LPGhatguy/rojo/releases)
-
-## Usage
-For more help, use `rojo help`.
-
-### New Project
-Just create a new folder and tell Rojo to initialize it!
-
-```sh
-mkdir my-new-project
-cd my-new-project
-
-rojo init
-```
-
-Rojo will create an empty project in the directory.
-
-The default project looks like this:
-
-```json
-{
-  "name": "my-new-project",
-  "servePort": 8000,
-  "partitions": {}
-}
-```
-
-### Start Dev Server
-To create a server that allows the Rojo Dev Plugin to access your project, use:
-
-```sh
-rojo serve
-```
-
-The tool will tell you whether it found an existing project. You should then be able to connect and use the project from within Roblox Studio!
-
-### Migrating an Existing Roblox Project
-**Coming soon!**
-
-### Syncing into Roblox
-In order to sync code into Roblox, you'll need to add one or more "partitions" to your configuration. A partition tells Rojo how to map directories to Roblox objects.
-
-Each entry in the partitions table has a unique name, a filesystem path, and the full name of the Roblox object to sync into.
-
-For example, if you want to map your `src` directory to an object named `My Cool Game` in `ReplicatedStorage`, you could use this configuration:
-
-```json
-{
-  "name": "rojo",
-  "servePort": 8000,
-  "partitions": {
-    "game": {
-      "path": "src",
-      "target": "ReplicatedStorage.My Cool Game"
-    }
-  }
-}
-```
-
-The `path` parameter is relative to the project file.
-
-The `target` starts at `game` and crawls down the tree. If any objects don't exist along the way, they'll be created as `Folder` instances.
-
-Run `rojo serve` in the directory containing this project, then press the "Sync In" or "Toggle Polling" buttons in the Roblox Studio plugin to move code into your game.
-
-### Sync Details
-The structure of files and folders on the filesystem are preserved when syncing into game.
-
-Creation of Roblox instances follows a simple set of rules. The first rule that matches the file name is chosen:
-
-| File Name      | Instance Type  | Notes                                     |
-| -------------- | -------------- | ----------------------------------------- |
-| `*.server.lua` | `Script`       | `Source` will contain the file's contents |
-| `*.client.lua` | `LocalScript`  | `Source` will contain the file's contents |
-| `*.lua`        | `ModuleScript` | `Source` will contain the file's contents |
-| `*`            | `StringValue`  | `Value` will contain the file's contents  |
-
-Any folders on the filesystem will turn into `Folder` objects unless they contain a file named `init` with any extension. Following the convention of Lua, those objects will instead be whatever the `init` file would turn into.
-
-For example, this file tree:
-
-* my-game
-	* init.lua
-	* foo.lua
-
-Will turn into this tree in Roblox:
-
-* `my-game` (`ModuleScript` with source from `my-game/init.lua`)
-	* `foo` (`ModuleScript` with source from `my-game/foo.lua`)
-
-## Inspiration
-There are lots of other tools that sync scripts into Roblox, or otherwise work to improve the development flow outside of Roblox Studio.
+## 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)
-* [RbxRefresh by Osyris](https://github.com/osyrisrblx/RbxRefresh)
-* [RbxSync by evaera](https://github.com/evaera/RbxSync)
-* [CodeSync](https://github.com/MemoryPenguin/CodeSync) and [rbx-exteditor](https://github.com/MemoryPenguin/rbx-exteditor) by [MemoryPenguin](https://github.com/MemoryPenguin)
 
-I also have a couple tools that Rojo intends to replace:
-* [rbxfs](https://github.com/LPGhatguy/rbxfs), which has been deprecated by Rojo
-* [rbxpacker](https://github.com/LPGhatguy/rbxpacker), which is still useful
+* [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.
+
+## Contributing
+Pull requests are welcome!
+
+All pull requests are run against a test suite on Travis CI. That test suite should always pass!
 
 ## License
-Rojo is available under the terms of the MIT license. See [LICENSE.md](LICENSE.md) for details.
+Rojo is available under the terms of the Mozilla Public License, Version 2.0. See [LICENSE.txt](LICENSE.txt) for details.

assets/kenney-ui-gray-sheet.xml

@@ -0,0 +1,41 @@
+<TextureAtlas imagePath="sheet.png">
+	<SubTexture name="grey_arrowDownGrey.png" x="78" y="498" width="15" height="10"/>
+	<SubTexture name="grey_arrowDownWhite.png" x="123" y="496" width="15" height="10"/>
+	<SubTexture name="grey_arrowUpGrey.png" x="108" y="498" width="15" height="10"/>
+	<SubTexture name="grey_arrowUpWhite.png" x="93" y="498" width="15" height="10"/>
+	<SubTexture name="grey_box.png" x="147" y="433" width="38" height="36"/>
+	<SubTexture name="grey_boxCheckmark.png" x="147" y="469" width="38" height="36"/>
+	<SubTexture name="grey_boxCross.png" x="185" y="433" width="38" height="36"/>
+	<SubTexture name="grey_boxTick.png" x="190" y="198" width="36" height="36"/>
+	<SubTexture name="grey_button00.png" x="0" y="143" width="190" height="45"/>
+	<SubTexture name="grey_button01.png" x="0" y="188" width="190" height="49"/>
+	<SubTexture name="grey_button02.png" x="0" y="98" width="190" height="45"/>
+	<SubTexture name="grey_button03.png" x="0" y="331" width="190" height="49"/>
+	<SubTexture name="grey_button04.png" x="0" y="286" width="190" height="45"/>
+	<SubTexture name="grey_button05.png" x="0" y="0" width="195" height="49"/>
+	<SubTexture name="grey_button06.png" x="0" y="49" width="191" height="49"/>
+	<SubTexture name="grey_button07.png" x="195" y="0" width="49" height="49"/>
+	<SubTexture name="grey_button08.png" x="240" y="49" width="49" height="49"/>
+	<SubTexture name="grey_button09.png" x="98" y="433" width="49" height="45"/>
+	<SubTexture name="grey_button10.png" x="191" y="49" width="49" height="49"/>
+	<SubTexture name="grey_button11.png" x="0" y="433" width="49" height="45"/>
+	<SubTexture name="grey_button12.png" x="244" y="0" width="49" height="49"/>
+	<SubTexture name="grey_button13.png" x="49" y="433" width="49" height="45"/>
+	<SubTexture name="grey_button14.png" x="0" y="384" width="190" height="49"/>
+	<SubTexture name="grey_button15.png" x="0" y="237" width="190" height="49"/>
+	<SubTexture name="grey_checkmarkGrey.png" x="99" y="478" width="21" height="20"/>
+	<SubTexture name="grey_checkmarkWhite.png" x="78" y="478" width="21" height="20"/>
+	<SubTexture name="grey_circle.png" x="185" y="469" width="36" height="36"/>
+	<SubTexture name="grey_crossGrey.png" x="120" y="478" width="18" height="18"/>
+	<SubTexture name="grey_crossWhite.png" x="190" y="318" width="18" height="18"/>
+	<SubTexture name="grey_panel.png" x="190" y="98" width="100" height="100"/>
+	<SubTexture name="grey_sliderDown.png" x="190" y="234" width="28" height="42"/>
+	<SubTexture name="grey_sliderEnd.png" x="138" y="478" width="8" height="10"/>
+	<SubTexture name="grey_sliderHorizontal.png" x="0" y="380" width="190" height="4"/>
+	<SubTexture name="grey_sliderLeft.png" x="0" y="478" width="39" height="31"/>
+	<SubTexture name="grey_sliderRight.png" x="39" y="478" width="39" height="31"/>
+	<SubTexture name="grey_sliderUp.png" x="190" y="276" width="28" height="42"/>
+	<SubTexture name="grey_sliderVertical.png" x="208" y="318" width="4" height="100"/>
+	<SubTexture name="grey_tickGrey.png" x="190" y="336" width="17" height="17"/>
+	<SubTexture name="grey_tickWhite.png" x="190" y="353" width="17" height="17"/>
+</TextureAtlas>

design.gv

@@ -0,0 +1,39 @@
+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/getting-started/creating-a-place.md

@@ -0,0 +1,64 @@
+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 `roblox-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/getting-started/installation.md

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

docs/index.md

@@ -0,0 +1,11 @@
+This is the documentation home for Rojo.
+
+Available versions of these docs:
+
+* [0.5.x](https://lpghatguy.github.io/rojo/0.5.x)
+* [0.4.x](https://lpghatguy.github.io/rojo/0.4.x)
+* [`master` branch](https://lpghatguy.github.io/rojo/master)
+
+**Rojo** is a flexible multi-tool designed for creating robust Roblox projects.
+
+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)!

docs/migrating-to-epiphany.md

@@ -0,0 +1,59 @@
+Rojo underwent a large refactor during most of 2018 to enable a bunch of new features and lay groundwork for lots more in 2019. As such, Rojo **0.5.x** projects are not compatible with Rojo **0.4.x** projects.
+
+## Supporting Both 0.4.x and 0.5.x
+Rojo 0.5.x uses a different name for its project format. While 0.4.x used `rojo.json`, 0.5.x uses `roblox-project.json`, which allows them to coexist.
+
+If you aren't sure about upgrading or want to upgrade gradually, it's possible to keep both files in the same project without causing problems.
+
+## Upgrading Your Project File
+Project files in 0.5.x are more explicit and flexible than they were in 0.4.x. Project files can now describe models and plugins in addition to places.
+
+This new project file format also guards against two of the biggest pitfalls when writing a config file:
+
+* Using a service as a partition target directly, which often wiped away extra instances
+* Defining two partitions that overlapped, which made Rojo act unpredictably
+
+The biggest change is that the `partitions` field has been replaced with a new field, `tree`, that describes the entire hierarchy of your project from the top-down.
+
+A project for 0.4.x that syncs from the `src` directory into `ReplicatedStorage.Source` would look like this:
+
+```json
+{
+    "name": "Rojo 0.4.x Example",
+    "partitions": {
+        "path": "src",
+        "target": "ReplicatedStorage.Source"
+    }
+}
+```
+
+In 0.5.x, the project format is more explicit:
+
+```json
+{
+    "name": "Rojo 0.5.x Example",
+    "tree": {
+        "$className": "DataModel",
+        "ReplicatedStorage": {
+            "$className": "ReplicatedStorage",
+            "Source": {
+                "$path": "src"
+            }
+        }
+    }
+}
+```
+
+For each object in the tree, we define *metadata* and *children*.
+
+Metadata begins with a dollar sign (`$`), like `$className`. This is so that children and metadata can coexist without creating too many nested layers.
+
+All other values are considered children, where the key is the instance's name, and the value is an object, repeating the process.
+
+## Migrating `.model.json` Files
+No upgrade path yet, stay tuned.
+
+## 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.

docs/requirements.txt

@@ -0,0 +1,3 @@
+mkdocs
+mkdocs-material
+pymdown-extensions

docs/sync-details.md

@@ -0,0 +1,35 @@
+This page aims to describe how Rojo turns files on the filesystem into Roblox objects.
+
+## Overview
+| File Name      | Instance Type       |
+| -------------- | ------------------- |
+| any directory  | `Folder`            |
+| `*.server.lua` | `Script`            |
+| `*.client.lua` | `LocalScript`       |
+| `*.lua`        | `ModuleScript`      |
+| `*.csv`        | `LocalizationTable` |
+| `*.txt`        | `StringValue`       |
+
+## 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:
+
+* my-game
+    * init.client.lua
+    * foo.lua
+
+Will turn into these instances in Roblox:
+
+![Example of Roblox instances](/images/sync-example.png)
+
+## 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.

docs/why-rojo.md

@@ -0,0 +1,20 @@
+There are a number of existing plugins for Roblox that move code from the filesystem into Roblox.
+
+Besides Rojo, there is:
+
+* [Studio Bridge](https://github.com/vocksel/studio-bridge) by [Vocksel](https://github.com/vocksel)
+* [RbxRefresh](https://github.com/osyrisrblx/RbxRefresh) by [Osyris](https://github.com/osyrisrblx)
+* [RbxSync](https://github.com/evaera/RbxSync) by [evaera](https://github.com/evaera)
+* [CodeSync](https://github.com/MemoryPenguin/CodeSync) and [rbx-exteditor](https://github.com/MemoryPenguin/rbx-exteditor) by [MemoryPenguin](https://github.com/MemoryPenguin)
+* [rbxmk](https://github.com/anaminus/rbxmk) by [Anaminus](https://github.com/anaminus)
+
+So why did I build Rojo?
+
+Each of these tools solves what is essentially the same problem from a few different angles. The goal of Rojo is to take all of the lessons and ideas learned from these projects and build a tool that can solve the problem for good.
+
+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.

generate-docs

@@ -0,0 +1,25 @@
+#!/bin/sh
+
+# Kludged documentation generator to support multiple versions.
+# Make sure the `site` folder is a checkout of this repository's `gh-pages`
+# branch.
+# To use, copy this file to `generate-docs.run` so that Git will leave it alone,
+# then run `generate-docs.run` in the root of the repository.
+
+set -e
+
+CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
+
+echo "Building 0.4.x"
+git checkout v0.4.x
+git pull
+mkdocs build --site-dir site/0.4.x
+
+echo "Building master"
+git checkout master
+mkdocs build --site-dir site/master
+
+echo "Building 0.5.x"
+mkdocs build --site-dir site/0.5.x
+
+git checkout "$CURRENT_BRANCH"

mkdocs.yml

@@ -0,0 +1,26 @@
+site_name: Rojo Documentation
+repo_name: LPGhatguy/rojo
+repo_url: https://github.com/LPGhatguy/rojo
+
+theme:
+  name: material
+  palette:
+    primary: 'Red'
+    accent: 'Red'
+
+nav:
+  - Home: index.md
+  - Why Rojo?: why-rojo.md
+  - Getting Started:
+    - Installation: getting-started/installation.md
+    - Creating a Place with Rojo: getting-started/creating-a-place.md
+  - Sync Details: sync-details.md
+  - Migrating from 0.4.x to 0.5.x: migrating-to-epiphany.md
+
+markdown_extensions:
+  - attr_list
+  - admonition
+  - codehilite:
+      guess_lang: false
+  - toc:
+      permalink: true

plugin/.gitignore

@@ -0,0 +1 @@
+/luacov.*

plugin/.luacheckrc

@@ -9,7 +9,7 @@ stds.roblox = {
 
 		-- Extra functions
 		"tick", "warn", "spawn",
-		"wait", "settings",
+		"wait", "settings", "typeof",
 
 		-- Types
 		"Vector2", "Vector3",
@@ -51,6 +51,6 @@ files["**/*.server.lua"] = {
 	std = "+plugin",
 }
 
-files["**/*-spec.lua"] = {
+files["**/*.spec.lua"] = {
 	std = "+testez",
 }

plugin/.luacov

@@ -0,0 +1,8 @@
+return {
+	include = {
+		"^src",
+	},
+	exclude = {
+		"%.spec$",
+	},
+}

plugin/README.md

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

plugin/loadEnvironment.lua

@@ -0,0 +1,37 @@
+--[[
+	Loads the Rojo plugin and all of its dependencies.
+]]
+
+local function loadEnvironment()
+	-- If you add any dependencies, add them to this table so they'll be loaded!
+	local LOAD_MODULES = {
+		{"src", "Rojo"},
+		{"modules/promise/lib", "Promise"},
+		{"modules/testez/lib", "TestEZ"},
+	}
+
+	-- This makes sure we can load Lemur and other libraries that depend on init.lua
+	package.path = package.path .. ";?/init.lua"
+
+	-- If this fails, make sure you've run `lua bin/install-dependencies.lua` first!
+	local lemur = require("modules.lemur")
+
+	-- Create a virtual Roblox tree
+	local habitat = lemur.Habitat.new()
+
+	-- We'll put all of our library code and dependencies here
+	local modules = lemur.Instance.new("Folder")
+	modules.Name = "Modules"
+	modules.Parent = habitat.game:GetService("ReplicatedStorage")
+
+	-- Load all of the modules specified above
+	for _, module in ipairs(LOAD_MODULES) do
+		local container = habitat:loadFromFs(module[1])
+		container.Name = module[2]
+		container.Parent = modules
+	end
+
+	return habitat, modules
+end
+
+return loadEnvironment

plugin/place-project.json

@@ -0,0 +1,51 @@
+{
+  "name": "rojo",
+  "tree": {
+    "$className": "DataModel",
+
+    "ReplicatedStorage": {
+      "$className": "ReplicatedStorage",
+
+      "Rojo": {
+        "$className": "Folder",
+
+        "Plugin": {
+          "$path": "src"
+        },
+        "Roact": {
+          "$path": "modules/roact/lib"
+        },
+        "Rodux": {
+          "$path": "modules/rodux/lib"
+        },
+        "RoactRodux": {
+          "$path": "modules/roact-rodux/lib"
+        },
+        "Promise": {
+          "$path": "modules/promise/lib"
+        }
+      },
+      "TestEZ": {
+        "$path": "modules/testez/lib"
+      }
+    },
+
+    "HttpService": {
+      "$className": "HttpService",
+      "$properties": {
+        "HttpEnabled": {
+          "Type": "Bool",
+          "Value": true
+        }
+      }
+    },
+
+    "TestService": {
+      "$className": "TestService",
+
+      "TestBootstrap": {
+        "$path": "testBootstrap.server.lua"
+      }
+    }
+  }
+}

plugin/roblox-project.json

@@ -0,0 +1,21 @@
+{
+  "name": "Rojo",
+  "tree": {
+    "$className": "Folder",
+    "Plugin": {
+      "$path": "src"
+    },
+    "Roact": {
+      "$path": "modules/roact/lib"
+    },
+    "Rodux": {
+      "$path": "modules/rodux/lib"
+    },
+    "RoactRodux": {
+      "$path": "modules/roact-rodux/lib"
+    },
+    "Promise": {
+      "$path": "modules/promise/lib"
+    }
+  }
+}

plugin/rojo.json

@@ -0,0 +1,34 @@
+{
+  "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/runTest.lua

@@ -0,0 +1,15 @@
+local loadEnvironment = require("loadEnvironment")
+
+local testPath = assert((...), "Please specify a path to a test file.")
+
+local habitat = loadEnvironment()
+
+local testModule = habitat:loadFromFs(testPath)
+
+if testModule == nil then
+	error("Couldn't find test file at " .. testPath)
+end
+
+print("Starting test module.")
+
+habitat:require(testModule)

plugin/spec.lua

@@ -0,0 +1,17 @@
+--[[
+	Loads our library and all of its dependencies, then runs tests using TestEZ.
+]]
+
+local loadEnvironment = require("loadEnvironment")
+
+local habitat, modules = loadEnvironment()
+
+-- Load TestEZ and run our tests
+local TestEZ = habitat:require(modules.TestEZ)
+
+local results = TestEZ.TestBootstrap:run({modules.Rojo}, TestEZ.Reporters.TextReporter)
+
+-- Did something go wrong?
+if results.failureCount > 0 then
+	os.exit(1)
+end

plugin/src/ApiContext.lua

@@ -0,0 +1,165 @@
+local Promise = require(script.Parent.Parent.Promise)
+
+local Config = require(script.Parent.Config)
+local Version = require(script.Parent.Version)
+local Http = require(script.Parent.Http)
+local HttpError = require(script.Parent.HttpError)
+
+local ApiContext = {}
+ApiContext.__index = ApiContext
+
+-- TODO: Audit cases of errors and create enum values for each of them.
+ApiContext.Error = {
+	ServerIdMismatch = "ServerIdMismatch",
+
+	-- The server gave an unexpected 400-category error, which may be the
+	-- client's fault.
+	ClientError = "ClientError",
+
+	-- The server gave an unexpected 500-category error, which may be the
+	-- server's fault.
+	ServerError = "ServerError",
+}
+
+setmetatable(ApiContext.Error, {
+	__index = function(_, key)
+		error("Invalid ApiContext.Error name " .. key, 2)
+	end
+})
+
+local function rejectFailedRequests(response)
+	if response.code >= 400 then
+		if response.code < 500 then
+			return Promise.reject(ApiContext.Error.ClientError)
+		else
+			return Promise.reject(ApiContext.Error.ServerError)
+		end
+	end
+
+	return response
+end
+
+function ApiContext.new(baseUrl)
+	assert(type(baseUrl) == "string")
+
+	local self = {
+		baseUrl = baseUrl,
+		serverId = nil,
+		rootInstanceId = nil,
+		messageCursor = -1,
+		partitionRoutes = nil,
+	}
+
+	setmetatable(self, ApiContext)
+
+	return self
+end
+
+function ApiContext:onMessage(callback)
+	self.onMessageCallback = callback
+end
+
+function ApiContext:connect()
+	local url = ("%s/api/rojo"):format(self.baseUrl)
+
+	return Http.get(url)
+		:andThen(rejectFailedRequests)
+		:andThen(function(response)
+			local body = response:json()
+
+			if body.protocolVersion ~= Config.protocolVersion then
+				local message = (
+					"Found a Rojo dev server, but it's using a different protocol version, and is incompatible." ..
+					"\nMake sure you have matching versions of both the Rojo plugin and server!" ..
+					"\n\nYour client is version %s, with protocol version %s. It expects server version %s." ..
+					"\nYour server is version %s, with protocol version %s." ..
+					"\n\nGo to https://github.com/LPGhatguy/rojo for more details."
+				):format(
+					Version.display(Config.version), Config.protocolVersion,
+					Config.expectedApiContextVersionString,
+					body.serverVersion, body.protocolVersion
+				)
+
+				return Promise.reject(message)
+			end
+
+			if body.expectedPlaceIds ~= nil then
+				local foundId = false
+
+				for _, id in ipairs(body.expectedPlaceIds) do
+					if id == game.PlaceId then
+						foundId = true
+						break
+					end
+				end
+
+				if not foundId then
+					local idList = {}
+					for _, id in ipairs(body.expectedPlaceIds) do
+						table.insert(idList, "- " .. tostring(id))
+					end
+
+					local message = (
+						"Found a Rojo server, but its project is set to only be used with a specific list of places." ..
+						"\nYour place ID is %s, but needs to be one of these:" ..
+						"\n%s" ..
+						"\n\nTo change this list, edit 'servePlaceIds' in roblox-project.json"
+					):format(
+						tostring(game.PlaceId),
+						table.concat(idList, "\n")
+					)
+
+					return Promise.reject(message)
+				end
+			end
+
+			self.serverId = body.serverId
+			self.partitionRoutes = body.partitions
+			self.rootInstanceId = body.rootInstanceId
+		end)
+end
+
+function ApiContext:read(ids)
+	local url = ("%s/api/read/%s"):format(self.baseUrl, table.concat(ids, ","))
+
+	return Http.get(url)
+		:andThen(rejectFailedRequests)
+		:andThen(function(response)
+			local body = response:json()
+
+			if body.serverId ~= self.serverId then
+				return Promise.reject("Server changed ID")
+			end
+
+			self.messageCursor = body.messageCursor
+
+			return body
+		end)
+end
+
+function ApiContext:retrieveMessages()
+	local url = ("%s/api/subscribe/%s"):format(self.baseUrl, self.messageCursor)
+
+	return Http.get(url)
+		:catch(function(err)
+			if err.type == HttpError.Error.Timeout then
+				return self:retrieveMessages()
+			end
+
+			return Promise.reject(err)
+		end)
+		:andThen(rejectFailedRequests)
+		:andThen(function(response)
+			local body = response:json()
+
+			if body.serverId ~= self.serverId then
+				return Promise.reject("Server changed ID")
+			end
+
+			self.messageCursor = body.messageCursor
+
+			return body.messages
+		end)
+end
+
+return ApiContext

plugin/src/Assets.lua

@@ -0,0 +1,43 @@
+local sheetAsset = "rbxassetid://2738712459"
+
+local Assets = {
+	Sprites = {
+		WhiteCross = {
+			asset = sheetAsset,
+			offset = Vector2.new(190, 318),
+			size = Vector2.new(18, 18),
+		},
+	},
+	Slices = {
+		RoundBox = {
+			asset = "rbxassetid://2773204550",
+			offset = Vector2.new(0, 0),
+			size = Vector2.new(32, 32),
+			center = Rect.new(4, 4, 4, 4),
+		},
+	},
+	Images = {
+		Logo = "rbxassetid://2773210620",
+	},
+	StartSession = "",
+	SessionActive = "",
+	Configure = "",
+}
+
+local function guardForTypos(name, map)
+	setmetatable(map, {
+		__index = function(_, key)
+			error(("%q is not a valid member of %s"):format(tostring(key), name), 2)
+		end
+	})
+
+	for key, child in pairs(map) do
+		if type(child) == "table" then
+			guardForTypos(("%s.%s"):format(name, key), child)
+		end
+	end
+end
+
+guardForTypos("Assets", Assets)
+
+return Assets

plugin/src/Components/App.lua

@@ -0,0 +1,195 @@
+local Roact = require(script:FindFirstAncestor("Rojo").Roact)
+
+local Plugin = script:FindFirstAncestor("Plugin")
+
+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 ConnectPanel = require(Plugin.Components.ConnectPanel)
+local ConnectionActivePanel = require(Plugin.Components.ConnectionActivePanel)
+
+local e = Roact.createElement
+
+local function showUpgradeMessage(lastVersion)
+	local message = (
+		"Rojo detected an upgrade from version %s to version %s." ..
+		"\nMake sure you have also upgraded your server!" ..
+		"\n\nRojo plugin version %s is intended for use with server version %s."
+	):format(
+		Version.display(lastVersion), Version.display(Config.version),
+		Version.display(Config.version), Config.expectedServerVersionString
+	)
+
+	Logging.info(message)
+end
+
+--[[
+	Check if the user is using a newer version of Rojo than last time. If they
+	are, show them a reminder to make sure they check their server version.
+]]
+local function checkUpgrade(plugin)
+	-- When developing Rojo, there's no use in doing version checks
+	if DevSettings:isEnabled() then
+		return
+	end
+
+	local lastVersion = plugin:GetSetting("LastRojoVersion")
+
+	if lastVersion then
+		local wasUpgraded = Version.compare(Config.version, lastVersion) == 1
+
+		if wasUpgraded then
+			showUpgradeMessage(lastVersion)
+		end
+	end
+
+	plugin:SetSetting("LastRojoVersion", Config.version)
+end
+
+local SessionStatus = {
+	Disconnected = "Disconnected",
+	Connected = "Connected",
+	ConfiguringSession = "ConfiguringSession",
+	-- TODO: Error?
+}
+
+setmetatable(SessionStatus, {
+	__index = function(_, key)
+		error(("%q is not a valid member of SessionStatus"):format(tostring(key)), 2)
+	end,
+})
+
+local App = Roact.Component:extend("App")
+
+function App:init()
+	self:setState({
+		sessionStatus = SessionStatus.Disconnected,
+	})
+
+	self.connectButton = nil
+	self.currentSession = nil
+
+	self.displayedVersion = DevSettings:isEnabled()
+		and Config.codename
+		or Version.display(Config.version)
+end
+
+function App:render()
+	local children
+
+	if self.state.sessionStatus == SessionStatus.Connected then
+		children = {
+			ConnectionActivePanel = e(ConnectionActivePanel, {
+				stopSession = function()
+					Logging.trace("Disconnecting session")
+
+					self.currentSession:disconnect()
+					self.currentSession = nil
+					self:setState({
+						sessionStatus = SessionStatus.Disconnected,
+					})
+
+					Logging.trace("Session terminated by user")
+				end,
+			}),
+		}
+	elseif self.state.sessionStatus == SessionStatus.ConfiguringSession then
+		children = {
+			ConnectPanel = e(ConnectPanel, {
+				startSession = function(address, port)
+					Logging.trace("Starting new session")
+
+					local success, session = Session.new({
+						address = address,
+						port = port,
+						onError = function(message)
+							Logging.warn("Rojo session terminated because of an error:\n%s", tostring(message))
+							self.currentSession = nil
+
+							self:setState({
+								sessionStatus = SessionStatus.Disconnected,
+							})
+						end
+					})
+
+					if success then
+						self.currentSession = session
+						self:setState({
+							sessionStatus = SessionStatus.Connected,
+						})
+					end
+				end,
+				cancel = function()
+					Logging.trace("Canceling session configuration")
+
+					self:setState({
+						sessionStatus = SessionStatus.Disconnected,
+					})
+				end,
+			}),
+		}
+	end
+
+	return e("ScreenGui", {
+		AutoLocalize = false,
+		ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
+	}, 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)
+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
+	end
+end
+
+return App

plugin/src/Components/ConnectPanel.lua

@@ -0,0 +1,261 @@
+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 joinBindings = require(Plugin.joinBindings)
+
+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 = "",
+	})
+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 = {
+			HorizontalAlignment = Enum.HorizontalAlignment.Center,
+		},
+	}, {
+		Inputs = e(FitList, {
+			containerProps = {
+				BackgroundTransparency = 1,
+				LayoutOrder = 1,
+			},
+			layoutProps = {
+				FillDirection = Enum.FillDirection.Horizontal,
+				Padding = UDim.new(0, 8),
+			},
+			paddingProps = {
+				PaddingTop = UDim.new(0, 20),
+				PaddingBottom = UDim.new(0, 10),
+				PaddingLeft = UDim.new(0, 24),
+				PaddingRight = UDim.new(0, 24),
+			},
+		}, {
+			Address = e(FitList, {
+				containerProps = {
+					LayoutOrder = 1,
+					BackgroundTransparency = 1,
+				},
+				layoutProps = {
+					Padding = UDim.new(0, 4),
+				},
+			}, {
+				Label = e(FitText, {
+					Kind = "TextLabel",
+					LayoutOrder = 1,
+					BackgroundTransparency = 1,
+					TextXAlignment = Enum.TextXAlignment.Left,
+					Font = Theme.TitleFont,
+					TextSize = 20,
+					Text = "Address",
+					TextColor3 = Theme.AccentColor,
+				}),
+
+				Input = e(FormTextInput, {
+					layoutOrder = 2,
+					width = UDim.new(0, 220),
+					value = self.state.address,
+					placeholderValue = Config.defaultHost,
+					onValueChange = function(newValue)
+						self:setState({
+							address = newValue,
+						})
+					end,
+				}),
+			}),
+
+			Port = e(FitList, {
+				containerProps = {
+					LayoutOrder = 2,
+					BackgroundTransparency = 1,
+				},
+				layoutProps = {
+					Padding = UDim.new(0, 4),
+				},
+			}, {
+				Label = e(FitText, {
+					Kind = "TextLabel",
+					LayoutOrder = 1,
+					BackgroundTransparency = 1,
+					TextXAlignment = Enum.TextXAlignment.Left,
+					Font = Theme.TitleFont,
+					TextSize = 20,
+					Text = "Port",
+					TextColor3 = Theme.AccentColor,
+				}),
+
+				Input = e(FormTextInput, {
+					layoutOrder = 2,
+					width = UDim.new(0, 80),
+					value = self.state.port,
+					placeholderValue = Config.defaultPort,
+					onValueChange = function(newValue)
+						self:setState({
+							port = newValue,
+						})
+					end,
+				}),
+			}),
+		}),
+
+		Buttons = e(FitList, {
+			fitAxes = "Y",
+			containerProps = {
+				BackgroundTransparency = 1,
+				LayoutOrder = 2,
+				Size = UDim2.new(1, 0, 0, 0),
+			},
+			layoutProps = {
+				FillDirection = Enum.FillDirection.Horizontal,
+				HorizontalAlignment = Enum.HorizontalAlignment.Right,
+				Padding = UDim.new(0, 8),
+			},
+			paddingProps = {
+				PaddingTop = UDim.new(0, 0),
+				PaddingBottom = UDim.new(0, 20),
+				PaddingLeft = UDim.new(0, 24),
+				PaddingRight = UDim.new(0, 24),
+			},
+		}, {
+			e(FormButton, {
+				layoutOrder = 1,
+				text = "Cancel",
+				onClick = function()
+					if cancel ~= nil then
+						cancel()
+					end
+				end,
+				secondary = true,
+			}),
+
+			e(FormButton, {
+				layoutOrder = 2,
+				text = "Connect",
+				onClick = function()
+					if startSession ~= nil then
+						local address = self.state.address
+						if address:len() == 0 then
+							address = Config.defaultHost
+						end
+
+						local port = self.state.port
+						if port:len() == 0 then
+							port = Config.defaultPort
+						end
+
+						startSession(address, port)
+					end
+				end,
+			}),
+		}),
+
+		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
+
+return ConnectPanel

plugin/src/Components/ConnectionActivePanel.lua

@@ -0,0 +1,67 @@
+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 FitText = require(Plugin.Components.FitText)
+
+local e = Roact.createElement
+
+local RoundBox = Assets.Slices.RoundBox
+local WhiteCross = Assets.Sprites.WhiteCross
+
+local function ConnectionActivePanel(props)
+	local stopSession = 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,
+			VerticalAlignment = Enum.VerticalAlignment.Center,
+		},
+	}, {
+		Text = e(FitText, {
+			Padding = Vector2.new(12, 6),
+			Font = Theme.ButtonFont,
+			TextSize = 18,
+			Text = "Rojo Connected",
+			TextColor3 = Theme.PrimaryColor,
+			BackgroundTransparency = 1,
+		}),
+
+		CloseContainer = e("ImageButton", {
+			Size = UDim2.new(0, 30, 0, 30),
+			BackgroundTransparency = 1,
+
+			[Roact.Event.Activated] = 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
+
+return ConnectionActivePanel

plugin/src/Components/FitList.lua

@@ -0,0 +1,63 @@
+local Roact = require(script:FindFirstAncestor("Rojo").Roact)
+
+local Dictionary = require(script.Parent.Parent.Dictionary)
+
+local e = Roact.createElement
+
+local FitList = Roact.Component:extend("FitList")
+
+function FitList:init()
+	self.sizeBinding, self.setSize = Roact.createBinding(UDim2.new())
+end
+
+function FitList:render()
+	local containerKind = self.props.containerKind or "Frame"
+	local fitAxes = self.props.fitAxes or "XY"
+	local containerProps = self.props.containerProps
+	local layoutProps = self.props.layoutProps
+	local paddingProps = self.props.paddingProps
+
+	local padding
+	if paddingProps ~= nil then
+		padding = e("UIPadding", paddingProps)
+	end
+
+	local children = Dictionary.merge(self.props[Roact.Children], {
+		["$Layout"] = e("UIListLayout", Dictionary.merge({
+			SortOrder = Enum.SortOrder.LayoutOrder,
+			[Roact.Change.AbsoluteContentSize] = function(instance)
+				local contentSize = instance.AbsoluteContentSize
+
+				if paddingProps ~= nil then
+					contentSize = contentSize + Vector2.new(
+						paddingProps.PaddingLeft.Offset + paddingProps.PaddingRight.Offset,
+						paddingProps.PaddingTop.Offset + paddingProps.PaddingBottom.Offset)
+				end
+
+				local combinedSize
+
+				if fitAxes == "X" then
+					combinedSize = UDim2.new(0, contentSize.X, containerProps.Size.Y.Scale, containerProps.Size.Y.Offset)
+				elseif fitAxes == "Y" then
+					combinedSize = UDim2.new(containerProps.Size.X.Scale, containerProps.Size.X.Offset, 0, contentSize.Y)
+				elseif fitAxes == "XY" then
+					combinedSize = UDim2.new(0, contentSize.X, 0, contentSize.Y)
+				else
+					error("Invalid fitAxes value")
+				end
+
+				self.setSize(combinedSize)
+			end,
+		}, layoutProps)),
+
+		["$Padding"] = padding,
+	})
+
+	local fullContainerProps = Dictionary.merge(containerProps, {
+		Size = self.sizeBinding,
+	})
+
+	return e(containerKind, fullContainerProps, children)
+end
+
+return FitList

plugin/src/Components/FitText.lua

@@ -0,0 +1,52 @@
+local TextService = game:GetService("TextService")
+
+local Roact = require(script:FindFirstAncestor("Rojo").Roact)
+
+local Dictionary = require(script.Parent.Parent.Dictionary)
+
+local e = Roact.createElement
+
+local FitText = Roact.Component:extend("FitText")
+
+function FitText:init()
+	self.sizeBinding, self.setSize = Roact.createBinding(UDim2.new())
+end
+
+function FitText:render()
+	local kind = self.props.Kind or "TextLabel"
+
+	local containerProps = Dictionary.merge(self.props, {
+		Kind = Dictionary.None,
+		Padding = Dictionary.None,
+		MinSize = Dictionary.None,
+		Size = self.sizeBinding
+	})
+
+	return e(kind, containerProps)
+end
+
+function FitText:didMount()
+	self:updateTextMeasurements()
+end
+
+function FitText:didUpdate()
+	self:updateTextMeasurements()
+end
+
+function FitText:updateTextMeasurements()
+	local minSize = self.props.MinSize or Vector2.new(0, 0)
+	local padding = self.props.Padding or Vector2.new(0, 0)
+
+	local text = self.props.Text or ""
+	local font = self.props.Font or Enum.Font.Legacy
+	local textSize = self.props.TextSize or 12
+
+	local measuredText = TextService:GetTextSize(text, textSize, font, Vector2.new(9e6, 9e6))
+	local totalSize = UDim2.new(
+		0, math.max(minSize.X, padding.X * 2 + measuredText.X),
+		0, math.max(minSize.Y, padding.Y * 2 + measuredText.Y))
+
+	self.setSize(totalSize)
+end
+
+return FitText

plugin/src/Components/FormButton.lua

@@ -0,0 +1,62 @@
+local Rojo = script:FindFirstAncestor("Rojo")
+local Plugin = Rojo.Plugin
+
+local Roact = require(Rojo.Roact)
+
+local Assets = require(Plugin.Assets)
+local Theme = require(Plugin.Theme)
+local FitList = require(Plugin.Components.FitList)
+local FitText = require(Plugin.Components.FitText)
+
+local e = Roact.createElement
+
+local RoundBox = Assets.Slices.RoundBox
+
+local function FormButton(props)
+	local text = props.text
+	local layoutOrder = props.layoutOrder
+	local onClick = props.onClick
+
+	local textColor
+	local backgroundColor
+
+	if props.secondary then
+		textColor = Theme.AccentColor
+		backgroundColor = Theme.SecondaryColor
+	else
+		textColor = Theme.SecondaryColor
+		backgroundColor = Theme.AccentColor
+	end
+
+	return e(FitList, {
+		containerKind = "ImageButton",
+		containerProps = {
+			LayoutOrder = layoutOrder,
+			BackgroundTransparency = 1,
+			Image = RoundBox.asset,
+			ImageRectOffset = RoundBox.offset,
+			ImageRectSize = RoundBox.size,
+			SliceCenter = RoundBox.center,
+			ScaleType = Enum.ScaleType.Slice,
+			ImageColor3 = backgroundColor,
+
+			[Roact.Event.Activated] = function()
+				if onClick ~= nil then
+					onClick()
+				end
+			end,
+		},
+	}, {
+		Text = e(FitText, {
+			Kind = "TextLabel",
+			Text = text,
+			TextSize = 18,
+			TextColor3 = textColor,
+			Font = Theme.ButtonFont,
+			Padding = Vector2.new(16, 8),
+			BackgroundTransparency = 1,
+		}),
+	})
+end
+
+return FormButton

plugin/src/Components/FormTextInput.lua

@@ -0,0 +1,80 @@
+local Rojo = script:FindFirstAncestor("Rojo")
+local Plugin = Rojo.Plugin
+
+local Roact = require(Rojo.Roact)
+
+local Assets = require(Plugin.Assets)
+local Theme = require(Plugin.Theme)
+
+local e = Roact.createElement
+
+local RoundBox = Assets.Slices.RoundBox
+
+local TEXT_SIZE = 22
+local PADDING = 8
+
+local FormTextInput = Roact.Component:extend("FormTextInput")
+
+function FormTextInput:init()
+	self:setState({
+		focused = false,
+	})
+end
+
+function FormTextInput:render()
+	local value = self.props.value
+	local placeholderValue = self.props.placeholderValue
+	local onValueChange = self.props.onValueChange
+	local layoutOrder = self.props.layoutOrder
+	local width = self.props.width
+
+	local shownPlaceholder
+	if self.state.focused then
+		shownPlaceholder = ""
+	else
+		shownPlaceholder = placeholderValue
+	end
+
+	return e("ImageLabel", {
+		LayoutOrder = layoutOrder,
+		Image = RoundBox.asset,
+		ImageRectOffset = RoundBox.offset,
+		ImageRectSize = RoundBox.size,
+		ScaleType = Enum.ScaleType.Slice,
+		SliceCenter = RoundBox.center,
+		ImageColor3 = Theme.SecondaryColor,
+		Size = UDim2.new(width.Scale, width.Offset, 0, TEXT_SIZE + PADDING * 2),
+		BackgroundTransparency = 1,
+	}, {
+		InputInner = e("TextBox", {
+			BackgroundTransparency = 1,
+			Size = UDim2.new(1, -PADDING * 2, 1, -PADDING * 2),
+			Position = UDim2.new(0.5, 0, 0.5, 0),
+			AnchorPoint = Vector2.new(0.5, 0.5),
+			Font = Theme.InputFont,
+			ClearTextOnFocus = false,
+			TextXAlignment = Enum.TextXAlignment.Center,
+			TextSize = TEXT_SIZE,
+			Text = value,
+			PlaceholderText = shownPlaceholder,
+			PlaceholderColor3 = Theme.AccentLightColor,
+			TextColor3 = Theme.AccentColor,
+
+			[Roact.Change.Text] = function(rbx)
+				onValueChange(rbx.Text)
+			end,
+			[Roact.Event.Focused] = function()
+				self:setState({
+					focused = true,
+				})
+			end,
+			[Roact.Event.FocusLost] = function()
+				self:setState({
+					focused = false,
+				})
+			end,
+		}),
+	})
+end
+
+return FormTextInput

plugin/src/Config.lua

@@ -1,4 +1,8 @@
 return {
-	pollingRate = 0.3,
-	version = "0.2.2",
-}
+	codename = "Epiphany",
+	version = {0, 5, 0, "-alpha.1"},
+	expectedServerVersionString = "0.5.0 or newer",
+	protocolVersion = 2,
+	defaultHost = "localhost",
+	defaultPort = 34872,
+}

plugin/src/DevSettings.lua

@@ -0,0 +1,71 @@
+local Config = require(script.Parent.Config)
+
+local VALUES = {
+	LogLevel = {
+		type = "IntValue",
+		defaultUserValue = 2,
+		defaultDevValue = 3,
+	},
+}
+
+local CONTAINER_NAME = "RojoDevSettings" .. Config.codename
+
+local function getValueContainer()
+	return game:FindFirstChild(CONTAINER_NAME)
+end
+
+local valueContainer = getValueContainer()
+
+local function getStoredValue(name)
+	if valueContainer == nil then
+		return nil
+	end
+
+	local valueObject = valueContainer:FindFirstChild(name)
+
+	if valueObject == nil then
+		return nil
+	end
+
+	return valueObject.Value
+end
+
+local function setStoredValue(name, kind, value)
+	local object = valueContainer:FindFirstChild(name)
+
+	if object == nil then
+		object = Instance.new(kind)
+		object.Name = name
+		object.Parent = valueContainer
+	end
+
+	object.Value = value
+end
+
+local function createAllValues()
+	valueContainer = getValueContainer()
+
+	if valueContainer == nil then
+		valueContainer = Instance.new("Folder")
+		valueContainer.Name = CONTAINER_NAME
+		valueContainer.Parent = game
+	end
+
+	for name, value in pairs(VALUES) do
+		setStoredValue(name, value.type, value.defaultDevValue)
+	end
+end
+
+_G[("ROJO_%s_DEV_CREATE"):format(Config.codename:upper())] = createAllValues
+
+local DevSettings = {}
+
+function DevSettings:isEnabled()
+	return valueContainer ~= nil
+end
+
+function DevSettings:getLogLevel()
+	return getStoredValue("LogLevel") or VALUES.LogLevel.defaultUserValue
+end
+
+return DevSettings

plugin/src/Dictionary.lua

@@ -0,0 +1,33 @@
+--[[
+	This is a placeholder module waiting for Cryo to become available.
+]]
+
+local None = newproxy(true)
+getmetatable(None).__tostring = function()
+	return "None"
+end
+
+local function merge(...)
+	local output = {}
+
+	for i = 1, select("#", ...) do
+		local source = select(i, ...)
+
+		if source ~= nil then
+			for key, value in pairs(source) do
+				if value == None then
+					output[key] = nil
+				else
+					output[key] = value
+				end
+			end
+		end
+	end
+
+	return output
+end
+
+return {
+	None = None,
+	merge = merge,
+}

plugin/src/Http.lua

@@ -1,67 +1,75 @@
 local HttpService = game:GetService("HttpService")
 
-local HTTP_DEBUG = false
+local Promise = require(script.Parent.Parent.Promise)
 
-local Promise = require(script.Parent.Promise)
+local Logging = require(script.Parent.Logging)
 local HttpError = require(script.Parent.HttpError)
 local HttpResponse = require(script.Parent.HttpResponse)
 
-local function dprint(...)
-	if HTTP_DEBUG then
-		print(...)
-	end
-end
+local lastRequestId = 0
 
+-- TODO: Factor out into separate library, especially error handling
 local Http = {}
-Http.__index = Http
 
-function Http.new(baseUrl)
-	assert(type(baseUrl) == "string", "Http.new needs a baseUrl!")
+function Http.get(url)
+	local requestId = lastRequestId + 1
+	lastRequestId = requestId
 
-	local http = {
-		baseUrl = baseUrl
-	}
+	Logging.trace("GET(%d) %s", requestId, url)
 
-	setmetatable(http, Http)
-
-	return http
-end
-
-function Http:get(endpoint)
-	dprint("\nGET", endpoint)
 	return Promise.new(function(resolve, reject)
-		spawn(function()
-			local ok, result = pcall(function()
-				return HttpService:GetAsync(self.baseUrl .. endpoint, true)
+		coroutine.wrap(function()
+			local success, response = pcall(function()
+				return HttpService:RequestAsync({
+					Url = url,
+					Method = "GET",
+				})
 			end)
 
-			if ok then
-				dprint("\t", result, "\n")
-				resolve(HttpResponse.new(result))
+			if success then
+				Logging.trace("Request %d success: status code %s", requestId, response.StatusCode)
+				resolve(HttpResponse.fromRobloxResponse(response))
 			else
-				reject(HttpError.fromErrorString(result))
+				Logging.trace("Request %d failure: %s", requestId, response)
+				reject(HttpError.fromErrorString(response))
 			end
-		end)
+		end)()
 	end)
 end
 
-function Http:post(endpoint, body)
-	dprint("\nPOST", endpoint)
-	dprint(body)
+function Http.post(url, body)
+	local requestId = lastRequestId + 1
+	lastRequestId = requestId
+
+	Logging.trace("POST(%d) %s\n%s", requestId, url, body)
+
 	return Promise.new(function(resolve, reject)
-		spawn(function()
-			local ok, result = pcall(function()
-				return HttpService:PostAsync(self.baseUrl .. endpoint, body)
+		coroutine.wrap(function()
+			local success, response = pcall(function()
+				return HttpService:RequestAsync({
+					Url = url,
+					Method = "POST",
+					Body = body,
+				})
 			end)
 
-			if ok then
-				dprint("\t", result, "\n")
-				resolve(HttpResponse.new(result))
+			if success then
+				Logging.trace("Request %d success: status code %s", requestId, response.StatusCode)
+				resolve(HttpResponse.fromRobloxResponse(response))
 			else
-				reject(HttpError.fromErrorString(result))
+				Logging.trace("Request %d failure: %s", requestId, response)
+				reject(HttpError.fromErrorString(response))
 			end
-		end)
+		end)()
 	end)
 end
 
-return Http
+function Http.jsonEncode(object)
+	return HttpService:JSONEncode(object)
+end
+
+function Http.jsonDecode(source)
+	return HttpService:JSONDecode(source)
+end
+
+return Http

plugin/src/HttpError.lua

@@ -1,3 +1,5 @@
+local Logging = require(script.Parent.Logging)
+
 local HttpError = {}
 HttpError.__index = HttpError
 
@@ -7,14 +9,23 @@ HttpError.Error = {
 			"Check your game settings, located in the 'Home' tab of Studio.",
 	},
 	ConnectFailed = {
-		message = "Rojo plugin couldn't connect to the Rojo server.\n" ..
-			"Make sure the server is running -- use 'Rojo serve' to run it!",
+		message = "Couldn't connect to the Rojo server.\n" ..
+			"Make sure the server is running -- use 'rojo serve' to run it!",
+	},
+	Timeout = {
+		message = "Request timed out.",
 	},
 	Unknown = {
-		message = "Rojo encountered an unknown error: {{message}}",
+		message = "Unknown error: {{message}}",
 	},
 }
 
+setmetatable(HttpError.Error, {
+	__index = function(_, key)
+		error(("%q is not a valid member of HttpError.Error"):format(tostring(key)), 2)
+	end,
+})
+
 function HttpError.new(type, extraMessage)
 	extraMessage = extraMessage or ""
 	local message = type.message:gsub("{{message}}", extraMessage)
@@ -36,22 +47,26 @@ end
 --[[
 	This method shouldn't have to exist. Ugh.
 ]]
-function HttpError.fromErrorString(err)
-	err = err:lower()
+function HttpError.fromErrorString(message)
+	local lower = message:lower()
 
-	if err:find("^http requests are not enabled") then
+	if lower:find("^http requests are not enabled") then
 		return HttpError.new(HttpError.Error.HttpNotEnabled)
 	end
 
-	if err:find("^curl error") then
+	if lower:find("^httperror: timedout") then
+		return HttpError.new(HttpError.Error.Timeout)
+	end
+
+	if lower:find("^httperror: connectfail") then
 		return HttpError.new(HttpError.Error.ConnectFailed)
 	end
 
-	return HttpError.new(HttpError.Error.Unknown, err)
+	return HttpError.new(HttpError.Error.Unknown, message)
 end
 
 function HttpError:report()
-	warn(self.message)
+	Logging.warn(self.message)
 end
 
-return HttpError
+return HttpError

plugin/src/HttpResponse.lua

@@ -1,20 +1,34 @@
 local HttpService = game:GetService("HttpService")
 
+local stringTemplate = [[
+HttpResponse {
+	code: %d
+	body: %s
+}]]
+
 local HttpResponse = {}
 HttpResponse.__index = HttpResponse
 
-function HttpResponse.new(body)
-	local response = {
-		body = body,
+function HttpResponse:__tostring()
+	return stringTemplate:format(self.code, self.body)
+end
+
+function HttpResponse.fromRobloxResponse(response)
+	local self = {
+		body = response.Body,
+		code = response.StatusCode,
+		headers = response.Headers,
 	}
 
-	setmetatable(response, HttpResponse)
+	return setmetatable(self, HttpResponse)
+end
 
-	return response
+function HttpResponse:isSuccess()
+	return self.code >= 200 and self.code < 300
 end
 
 function HttpResponse:json()
 	return HttpService:JSONDecode(self.body)
 end
 
-return HttpResponse
+return HttpResponse

plugin/src/Logging.lua

@@ -0,0 +1,50 @@
+local DevSettings = require(script.Parent.DevSettings)
+
+local Level = {
+	Error = 0,
+	Warning = 1,
+	Info = 2,
+	Trace = 3,
+}
+
+local testLogLevel = nil
+
+local function getLogLevel()
+	if testLogLevel ~= nil then
+		return testLogLevel
+	end
+
+	return DevSettings:getLogLevel()
+end
+
+local function addTags(tag, message)
+	return tag .. message:gsub("\n", "\n" .. tag)
+end
+
+local INFO_TAG = (" "):rep(15) .. "[Rojo-Info] "
+local TRACE_TAG = (" "):rep(15) .. "[Rojo-Trace] "
+local WARN_TAG = "[Rojo-Warn] "
+
+local Log = {}
+
+Log.Level = Level
+
+function Log.trace(template, ...)
+	if getLogLevel() >= Level.Trace then
+		print(addTags(TRACE_TAG, string.format(template, ...)))
+	end
+end
+
+function Log.info(template, ...)
+	if getLogLevel() >= Level.Info then
+		print(addTags(INFO_TAG, string.format(template, ...)))
+	end
+end
+
+function Log.warn(template, ...)
+	if getLogLevel() >= Level.Warning then
+		warn(addTags(WARN_TAG, string.format(template, ...)))
+	end
+end
+
+return Log

plugin/src/Main.server.lua

@@ -1,40 +0,0 @@
-if not plugin then
-	return
-end
-
-local Plugin = require(script.Parent.Plugin)
-local Config = require(script.Parent.Config)
-
-local function main()
-	local pluginInstance = Plugin.new()
-
-	local toolbar = plugin:CreateToolbar("Rojo Plugin v" .. Config.version)
-
-	toolbar:CreateButton("Test Connection", "Connect to Rojo Server", "")
-		.Click:Connect(function()
-			pluginInstance:connect()
-				:catch(function(err)
-					warn(err)
-				end)
-		end)
-
-	toolbar:CreateButton("Sync In", "Sync into Roblox Studio", "")
-		.Click:Connect(function()
-			pluginInstance:syncIn()
-				:catch(function(err)
-					warn(err)
-				end)
-		end)
-
-	toolbar:CreateButton("Toggle Polling", "Poll server for changes", "")
-		.Click:Connect(function()
-			spawn(function()
-				pluginInstance:togglePolling()
-					:catch(function(err)
-						warn(err)
-					end)
-			end)
-		end)
-end
-
-main()

plugin/src/Plugin.lua

@@ -1,178 +0,0 @@
-local Config = require(script.Parent.Config)
-local Http = require(script.Parent.Http)
-local Server = require(script.Parent.Server)
-local Promise = require(script.Parent.Promise)
-local Reconciler = require(script.Parent.Reconciler)
-
-local function collectMatch(source, pattern)
-	local result = {}
-
-	for match in source:gmatch(pattern) do
-		table.insert(result, match)
-	end
-
-	return result
-end
-
-local Plugin = {}
-Plugin.__index = Plugin
-
-function Plugin.new()
-	local address = "localhost"
-	local port = 8000
-
-	local remote = ("http://%s:%d"):format(address, port)
-
-	local foop = {
-		_http = Http.new(remote),
-		_server = nil,
-		_polling = false,
-	}
-
-	setmetatable(foop, Plugin)
-
-	do
-		local screenGui = Instance.new("ScreenGui")
-		screenGui.Name = "Rojo UI"
-		screenGui.Parent = game.CoreGui
-		screenGui.DisplayOrder = -1
-		screenGui.Enabled = false
-
-		local label = Instance.new("TextLabel")
-		label.Font = Enum.Font.SourceSans
-		label.TextSize = 20
-		label.Text = "Rojo polling..."
-		label.BackgroundColor3 = Color3.fromRGB(31, 31, 31)
-		label.BackgroundTransparency = 0.5
-		label.BorderSizePixel = 0
-		label.TextColor3 = Color3.new(1, 1, 1)
-		label.Size = UDim2.new(0, 120, 0, 28)
-		label.Position = UDim2.new(0, 0, 0, 0)
-		label.Parent = screenGui
-
-		foop._label = screenGui
-	end
-
-	return foop
-end
-
-function Plugin:server()
-	if not self._server then
-		self._server = Server.connect(self._http)
-			:catch(function(err)
-				self._server = nil
-				return Promise.reject(err)
-			end)
-	end
-
-	return self._server
-end
-
-function Plugin:connect()
-	print("Testing connection...")
-
-	return self:server()
-		:andThen(function(server)
-			return server:getInfo()
-		end)
-		:andThen(function(result)
-			print("Server found!")
-			print("Protocol version:", result.protocolVersion)
-			print("Server version:", result.serverVersion)
-		end)
-end
-
-function Plugin:togglePolling()
-	if self._polling then
-		self:stopPolling()
-
-		return Promise.resolve(nil)
-	else
-		return self:startPolling()
-	end
-end
-
-function Plugin:stopPolling()
-	if not self._polling then
-		return
-	end
-
-	print("Stopped polling.")
-
-	self._polling = false
-	self._label.Enabled = false
-end
-
-function Plugin:_pull(server, project, routes)
-	local items = server:read(routes):await()
-
-	for index = 1, #routes do
-		local route = routes[index]
-		local partitionName = route[1]
-		local partition = project.partitions[partitionName]
-		local item = items[index]
-
-		local fullRoute = collectMatch(partition.target, "[^.]+")
-		for i = 2, #route do
-			table.insert(fullRoute, routes[index][i])
-		end
-
-		Reconciler.reconcileRoute(fullRoute, item)
-	end
-end
-
-function Plugin:startPolling()
-	if self._polling then
-		return
-	end
-
-	print("Starting to poll...")
-
-	self._polling = true
-	self._label.Enabled = true
-
-	return self:server()
-		:andThen(function(server)
-			self:syncIn():await()
-
-			local project = server:getInfo():await().project
-
-			while self._polling do
-				local changes = server:getChanges():await()
-
-				local routes = {}
-
-				for _, change in ipairs(changes) do
-					table.insert(routes, change.route)
-				end
-
-				self:_pull(server, project, routes)
-
-				wait(Config.pollingRate)
-			end
-		end)
-		:catch(function()
-			self:stopPolling()
-		end)
-end
-
-function Plugin:syncIn()
-	print("Syncing from server...")
-
-	return self:server()
-		:andThen(function(server)
-			local project = server:getInfo():await().project
-
-			local routes = {}
-
-			for name in pairs(project.partitions) do
-				table.insert(routes, {name})
-			end
-
-			self:_pull(server, project, routes)
-
-			print("Sync successful!")
-		end)
-end
-
-return Plugin

plugin/src/Promise-spec.lua

@@ -1,70 +0,0 @@
-return function()
-	local Promise = require(script.Parent.Promise)
-
-	describe("Promise.new", function()
-		it("should instantiate with a callback", function()
-			local promise = Promise.new(function() end)
-
-			expect(promise).to.be.ok()
-		end)
-
-		it("should invoke the given callback with resolve and reject", function()
-			local callCount = 0
-			local resolveArg
-			local rejectArg
-
-			local promise = Promise.new(function(resolve, reject)
-				callCount = callCount + 1
-				resolveArg = resolve
-				rejectArg = reject
-			end)
-
-			expect(promise).to.be.ok()
-
-			expect(callCount).to.equal(1)
-			expect(resolveArg).to.be.a("function")
-			expect(rejectArg).to.be.a("function")
-			expect(promise._status).to.equal(Promise.Status.Started)
-		end)
-
-		it("should resolve promises on resolve()", function()
-			local callCount = 0
-
-			local promise = Promise.new(function(resolve)
-				callCount = callCount + 1
-				resolve()
-			end)
-
-			expect(promise).to.be.ok()
-			expect(callCount).to.equal(1)
-			expect(promise._status).to.equal(Promise.Status.Resolved)
-		end)
-
-		it("should reject promises on reject()", function()
-			local callCount = 0
-
-			local promise = Promise.new(function(resolve, reject)
-				callCount = callCount + 1
-				reject()
-			end)
-
-			expect(promise).to.be.ok()
-			expect(callCount).to.equal(1)
-			expect(promise._status).to.equal(Promise.Status.Rejected)
-		end)
-
-		it("should reject on error in callback", function()
-			local callCount = 0
-
-			local promise = Promise.new(function()
-				callCount = callCount + 1
-				error("hahah")
-			end)
-
-			expect(promise).to.be.ok()
-			expect(callCount).to.equal(1)
-			expect(promise._status).to.equal(Promise.Status.Rejected)
-			expect(promise._value[1]:find("hahah")).to.be.ok()
-		end)
-	end)
-end

plugin/src/Promise.lua

@@ -1,308 +0,0 @@
---[[
-	An implementation of Promises similar to Promise/A+.
-]]
-
-local PROMISE_DEBUG = false
-
--- If promise debugging is on, use a version of pcall that warns on failure.
--- This is useful for finding errors that happen within Promise itself.
-local wpcall
-if PROMISE_DEBUG then
-	wpcall = function(f, ...)
-		local result = { pcall(f, ...) }
-
-		if not result[1] then
-			warn(result[2])
-		end
-
-		return unpack(result)
-	end
-else
-	wpcall = pcall
-end
-
---[[
-	Creates a function that invokes a callback with correct error handling and
-	resolution mechanisms.
-]]
-local function createAdvancer(callback, resolve, reject)
-	return function(...)
-		local result = { wpcall(callback, ...) }
-		local ok = table.remove(result, 1)
-
-		if ok then
-			resolve(unpack(result))
-		else
-			reject(unpack(result))
-		end
-	end
-end
-
-local function isEmpty(t)
-	return next(t) == nil
-end
-
-local Promise = {}
-Promise.__index = Promise
-
-Promise.Status = {
-	Started = "Started",
-	Resolved = "Resolved",
-	Rejected = "Rejected",
-}
-
---[[
-	Constructs a new Promise with the given initializing callback.
-
-	This is generally only called when directly wrapping a non-promise API into
-	a promise-based version.
-
-	The callback will receive 'resolve' and 'reject' methods, used to start
-	invoking the promise chain.
-
-	For example:
-
-		local function get(url)
-			return Promise.new(function(resolve, reject)
-				spawn(function()
-					resolve(HttpService:GetAsync(url))
-				end)
-			end)
-		end
-
-		get("https://google.com")
-			:andThen(function(stuff)
-				print("Got some stuff!", stuff)
-			end)
-]]
-function Promise.new(callback)
-	local promise = {
-		-- Used to locate where a promise was created
-		_source = debug.traceback(),
-
-		-- A tag to identify us as a promise
-		_type = "Promise",
-
-		_status = Promise.Status.Started,
-
-		-- A table containing a list of all results, whether success or failure.
-		-- Only valid if _status is set to something besides Started
-		_value = nil,
-
-		-- If an error occurs with no observers, this will be set.
-		_unhandledRejection = false,
-
-		-- Queues representing functions we should invoke when we update!
-		_queuedResolve = {},
-		_queuedReject = {},
-	}
-
-	setmetatable(promise, Promise)
-
-	local function resolve(...)
-		promise:_resolve(...)
-	end
-
-	local function reject(...)
-		promise:_reject(...)
-	end
-
-	local ok, err = wpcall(callback, resolve, reject)
-
-	if not ok and promise._status == Promise.Status.Started then
-		reject(err)
-	end
-
-	return promise
-end
-
---[[
-	Create a promise that represents the immediately resolved value.
-]]
-function Promise.resolve(value)
-	return Promise.new(function(resolve)
-		resolve(value)
-	end)
-end
-
---[[
-	Create a promise that represents the immediately rejected value.
-]]
-function Promise.reject(value)
-	return Promise.new(function(_, reject)
-		reject(value)
-	end)
-end
-
---[[
-	Returns a new promise that:
-		* is resolved when all input promises resolve
-		* is rejected if ANY input promises reject
-]]
-function Promise.all(...)
-	error("unimplemented", 2)
-end
-
---[[
-	Is the given object a Promise instance?
-]]
-function Promise.is(object)
-	if type(object) ~= "table" then
-		return false
-	end
-
-	return object._type == "Promise"
-end
-
---[[
-	Creates a new promise that receives the result of this promise.
-
-	The given callbacks are invoked depending on that result.
-]]
-function Promise:andThen(successHandler, failureHandler)
-	self._unhandledRejection = false
-
-	-- Create a new promise to follow this part of the chain
-	return Promise.new(function(resolve, reject)
-		-- Our default callbacks just pass values onto the next promise.
-		-- This lets success and failure cascade correctly!
-
-		local successCallback = resolve
-		if successHandler then
-			successCallback = createAdvancer(successHandler, resolve, reject)
-		end
-
-		local failureCallback = reject
-		if failureHandler then
-			failureCallback = createAdvancer(failureHandler, resolve, reject)
-		end
-
-		if self._status == Promise.Status.Started then
-			-- If we haven't resolved yet, put ourselves into the queue
-			table.insert(self._queuedResolve, successCallback)
-			table.insert(self._queuedReject, failureCallback)
-		elseif self._status == Promise.Status.Resolved then
-			-- This promise has already resolved! Trigger success immediately.
-			successCallback(unpack(self._value))
-		elseif self._status == Promise.Status.Rejected then
-			-- This promise died a terrible death! Trigger failure immediately.
-			failureCallback(unpack(self._value))
-		end
-	end)
-end
-
---[[
-	Used to catch any errors that may have occurred in the promise.
-]]
-function Promise:catch(failureCallback)
-	return self:andThen(nil, failureCallback)
-end
-
---[[
-	Yield until the promise is completed.
-
-	This matches the execution model of normal Roblox functions.
-]]
-function Promise:await()
-	self._unhandledRejection = false
-
-	if self._status == Promise.Status.Started then
-		local result
-		local bindable = Instance.new("BindableEvent")
-
-		self:andThen(function(...)
-			result = {...}
-			bindable:Fire(true)
-		end, function(...)
-			result = {...}
-			bindable:Fire(false)
-		end)
-
-		local ok = bindable.Event:Wait()
-		bindable:Destroy()
-
-		if not ok then
-			error(tostring(result[1]), 2)
-		end
-
-		return unpack(result)
-	elseif self._status == Promise.Status.Resolved then
-		return unpack(self._value)
-	elseif self._status == Promise.Status.Rejected then
-		error(tostring(self._value[1]), 2)
-	end
-end
-
-function Promise:_resolve(...)
-	if self._status ~= Promise.Status.Started then
-		return
-	end
-
-	-- If the resolved value was a Promise, we chain onto it!
-	if Promise.is((...)) then
-		-- Without this warning, arguments sometimes mysteriously disappear
-		if select("#", ...) > 1 then
-			local message = ("When returning a Promise from andThen, extra arguments are discarded! See:\n\n%s"):format(
-				self._source
-			)
-			warn(message)
-		end
-
-		(...):andThen(function(...)
-			self:_resolve(...)
-		end, function(...)
-			self:_reject(...)
-		end)
-
-		return
-	end
-
-	self._status = Promise.Status.Resolved
-	self._value = {...}
-
-	-- We assume that these callbacks will not throw errors.
-	for _, callback in ipairs(self._queuedResolve) do
-		callback(...)
-	end
-end
-
-function Promise:_reject(...)
-	if self._status ~= Promise.Status.Started then
-		return
-	end
-
-	self._status = Promise.Status.Rejected
-	self._value = {...}
-
-	-- If there are any rejection handlers, call those!
-	if not isEmpty(self._queuedReject) then
-		-- We assume that these callbacks will not throw errors.
-		for _, callback in ipairs(self._queuedReject) do
-			callback(...)
-		end
-	else
-		-- At this point, no one was able to observe the error.
-		-- An error handler might still be attached if the error occurred
-		-- synchronously. We'll wait one tick, and if there are still no
-		-- observers, then we should put a message in the console.
-
-		self._unhandledRejection = true
-		local err = tostring((...))
-
-		spawn(function()
-			-- Someone observed the error, hooray!
-			if not self._unhandledRejection then
-				return
-			end
-
-			-- Build a reasonable message
-			local message = ("Unhandled promise rejection:\n\n%s\n\n%s"):format(
-				err,
-				self._source
-			)
-			warn(message)
-		end)
-	end
-end
-
-return Promise

plugin/src/Reconciler.lua

@@ -1,237 +1,281 @@
-local Reconciler = {}
+local Logging = require(script.Parent.Logging)
 
-local function isInit(item, itemFileName)
-	if item and item.type == "dir" then
+local function makeInstanceMap()
+	local self = {
+		fromIds = {},
+		fromInstances = {},
+	}
+
+	function self:insert(id, instance)
+		self.fromIds[id] = instance
+		self.fromInstances[instance] = id
+	end
+
+	function self:removeId(id)
+		local instance = self.fromIds[id]
+
+		if instance ~= nil then
+			self.fromIds[id] = nil
+			self.fromInstances[instance] = nil
+		else
+			Logging.warn("Attempted to remove nonexistant ID %s", tostring(id))
+		end
+	end
+
+	function self:removeInstance(instance)
+		local id = self.fromInstances[instance]
+
+		if id ~= nil then
+			self.fromInstances[instance] = nil
+			self.fromIds[id] = nil
+		else
+			Logging.warn("Attempted to remove nonexistant instance %s", tostring(instance))
+		end
+	end
+
+	function self:destroyId(id)
+		local instance = self.fromIds[id]
+		self:removeId(id)
+
+		if instance ~= nil then
+			local descendantsToDestroy = {}
+
+			for otherInstance in pairs(self.fromInstances) do
+				if otherInstance:IsDescendantOf(instance) then
+					table.insert(descendantsToDestroy, otherInstance)
+				end
+			end
+
+			for _, otherInstance in ipairs(descendantsToDestroy) do
+				self:removeInstance(otherInstance)
+			end
+
+			instance:Destroy()
+		else
+			Logging.warn("Attempted to destroy nonexistant ID %s", tostring(id))
+		end
+	end
+
+	return self
+end
+
+local function setProperty(instance, key, value)
+	-- The 'Contents' property of LocalizationTable isn't directly exposed, but
+	-- has corresponding (deprecated) getters and setters.
+	if key == "Contents" and instance.ClassName == "LocalizationTable" then
+		instance:SetContents(value)
 		return
 	end
 
-	return not not itemFileName:find("^init%.")
-end
-
-local function findInit(item)
-	if item.type ~= "dir" then
-		return nil, nil
-	end
-
-	for childFileName, childItem in pairs(item.children) do
-		if isInit(childItem, childFileName) then
-			return childItem, childFileName
-		end
-	end
-
-	return nil, nil
-end
-
-local function itemToName(item, fileName)
-	if item and item.type == "dir" then
-		return fileName, "Folder"
-	elseif item and item.type == "file" or not item then
-		if fileName:find("%.server%.lua$") then
-			return fileName:match("^(.-)%.server%.lua$"), "Script"
-		elseif fileName:find("%.client%.lua$") then
-			return fileName:match("^(.-)%.client%.lua$"), "LocalScript"
-		elseif fileName:find("%.lua") then
-			return fileName:match("^(.-)%.lua$"), "ModuleScript"
-		else
-			return fileName, "StringValue"
-		end
-	else
-		error("unknown item type " .. tostring(item.type))
-	end
-end
-
-local function setValues(rbx, item, fileName)
-	local _, className = itemToName(item, fileName)
-
-	if className:find("Script") then
-		rbx.Source = item.contents
-	else
-		rbx.Value = item.contents
-	end
-end
-
-function Reconciler._reifyShallow(item, fileName)
-	if item.type == "dir" then
-		local initItem, initFileName = findInit(item)
-
-		if initItem then
-			local rbx = Reconciler._reify(initItem, initFileName)
-			rbx.Name = fileName
-
-			return rbx
-		else
-			local rbx = Instance.new("Folder")
-			rbx.Name = fileName
-
-			return rbx
-		end
-	elseif item.type == "file" then
-		local objectName, className = itemToName(item, fileName)
-
-		local rbx = Instance.new(className)
-		rbx.Name = objectName
-
-		setValues(rbx, item, fileName)
-
-		return rbx
-	else
-		error("unknown item type " .. tostring(item.type))
-	end
-end
-
-function Reconciler._reify(item, fileName, parent)
-	local rbx = Reconciler._reifyShallow(item, fileName)
-
-	if item.type == "dir" then
-		for childFileName, childItem in pairs(item.children) do
-			if not isInit(childItem, childFileName) then
-				local childRbx = Reconciler._reify(childItem, childFileName)
-				childRbx.Parent = rbx
-			end
-		end
-	end
-
-	rbx.Parent = parent
-
-	return rbx
-end
-
-function Reconciler.reconcile(rbx, item, fileName, parent)
-	-- Item was deleted!
-	if not item then
-		if isInit(item, fileName) then
-			if not parent then
-				return
-			end
-
-			-- Un-usurp parent!
-			local newParent = Instance.new("Folder")
-			newParent.Name = parent.Name
-
-			for _, child in ipairs(parent:GetChildren()) do
-				child.Parent = newParent
-			end
-
-			newParent.Parent = parent.Parent
-			parent:Destroy()
+	-- If we don't have permissions to access this value at all, we can skip it.
+	local readSuccess, existingValue = pcall(function()
+		return instance[key]
+	end)
 
+	if not readSuccess then
+		-- An error will be thrown if there was a permission issue or if the
+		-- property doesn't exist. In the latter case, we should tell the user
+		-- because it's probably their fault.
+		if existingValue:find("lacking permission") then
+			Logging.trace("Permission error reading property %s on class %s", tostring(key), instance.ClassName)
 			return
 		else
-			if rbx then
-				rbx:Destroy()
-			end
-
-			return
+			error(("Invalid property %s on class %s: %s"):format(tostring(key), instance.ClassName, existingValue), 2)
 		end
 	end
 
-	if item.type == "dir" then
-		-- Folder was created!
-		if not rbx then
-			return Reconciler._reify(item, fileName, parent)
+	local writeSuccess, err = pcall(function()
+		if existingValue ~= value then
+			instance[key] = value
 		end
+	end)
 
-		local initItem, initFileName = findInit(item)
+	if not writeSuccess then
+		error(("Cannot set property %s on class %s: %s"):format(tostring(key), instance.ClassName, err), 2)
+	end
 
-		if initItem then
-			local _, initClassName = itemToName(initItem, initFileName)
+	return true
+end
 
-			if rbx.ClassName == initClassName then
-				setValues(rbx, initItem, initFileName)
-			else
-				rbx:Destroy()
-				return Reconciler._reify(item, fileName, parent)
-			end
-		else
-			if rbx.ClassName ~= "Folder" then
-				rbx:Destroy()
-				return Reconciler._reify(item, fileName, parent)
-			end
-		end
+local Reconciler = {}
+Reconciler.__index = Reconciler
 
-		local visitedChildren = {}
+function Reconciler.new()
+	local self = {
+		instanceMap = makeInstanceMap(),
+	}
 
-		for childFileName, childItem in pairs(item.children) do
-			if not isInit(childItem, childFileName) then
-				local childName = itemToName(childItem, childFileName)
+	return setmetatable(self, Reconciler)
+end
 
-				visitedChildren[childName] = true
+function Reconciler:applyUpdate(requestedIds, virtualInstancesById)
+	-- This function may eventually be asynchronous; it will require calls to
+	-- the server to resolve instances that don't exist yet.
+	local visitedIds = {}
 
-				Reconciler.reconcile(rbx:FindFirstChild(childName), childItem, childFileName, rbx)
-			end
-		end
+	for _, id in ipairs(requestedIds) do
+		self:__applyUpdatePiece(id, visitedIds, virtualInstancesById)
+	end
+end
 
-		for _, childRbx in ipairs(rbx:GetChildren()) do
-			-- Child was deleted!
-			if not visitedChildren[childRbx.Name] then
-				childRbx:Destroy()
-			end
-		end
+--[[
+	Update an existing instance, including its properties and children, to match
+	the given information.
+]]
+function Reconciler:reconcile(virtualInstancesById, id, instance)
+	local virtualInstance = virtualInstancesById[id]
 
-		return rbx
-	elseif item.type == "file" then
-		if isInit(item, fileName) then
-			-- Usurp our container!
-			local _, className = itemToName(item, fileName)
+	-- If an instance changes ClassName, we assume it's very different. That's
+	-- not always the case!
+	if virtualInstance.ClassName ~= instance.ClassName then
+		-- TODO: Preserve existing children instead?
+		local parent = instance.Parent
+		self.instanceMap:destroyId(id)
+		return self:__reify(virtualInstancesById, id, parent)
+	end
 
-			if parent.ClassName == className then
-				rbx = parent
-			else
-				rbx = Reconciler._reify(item, fileName, parent.Parent)
-				rbx.Name = parent.Name
+	self.instanceMap:insert(id, instance)
 
-				for _, child in ipairs(parent:GetChildren()) do
-					child.Parent = rbx
+	-- Some instances don't like being named, even if their name already matches
+	setProperty(instance, "Name", virtualInstance.Name)
+
+	for key, value in pairs(virtualInstance.Properties) do
+		setProperty(instance, key, value.Value)
+	end
+
+	local existingChildren = instance:GetChildren()
+
+	local unvisitedExistingChildren = {}
+	for _, child in ipairs(existingChildren) do
+		unvisitedExistingChildren[child] = true
+	end
+
+	for _, childId in ipairs(virtualInstance.Children) do
+		local childData = virtualInstancesById[childId]
+
+		local existingChildInstance
+		for instance in pairs(unvisitedExistingChildren) do
+			local ok, name, className = pcall(function()
+				return instance.Name, instance.ClassName
+			end)
+
+			if ok then
+				if name == childData.Name and className == childData.ClassName then
+					existingChildInstance = instance
+					break
 				end
-
-				parent:Destroy()
 			end
+		end
 
-			setValues(rbx, item, fileName)
-
-			return rbx
+		if existingChildInstance ~= nil then
+			unvisitedExistingChildren[existingChildInstance] = nil
+			self:reconcile(virtualInstancesById, childId, existingChildInstance)
 		else
-			if not rbx then
-				return Reconciler._reify(item, fileName, parent)
-			end
-
-			local _, className = itemToName(item, fileName)
-
-			if rbx.ClassName ~= className then
-				rbx:Destroy()
-				return Reconciler._reify(item, fileName, parent)
-			end
-
-			setValues(rbx, item, fileName)
-
-			return rbx
+			self:__reify(virtualInstancesById, childId, instance)
 		end
+	end
+
+	if self:__shouldClearUnknownInstances(virtualInstance) then
+		for existingChildInstance in pairs(unvisitedExistingChildren) do
+			self.instanceMap:removeInstance(existingChildInstance)
+			existingChildInstance:Destroy()
+		end
+	end
+
+	-- The root instance of a project won't have a parent, like the DataModel,
+	-- so we need to be careful here.
+	if virtualInstance.Parent ~= nil then
+		local parent = self.instanceMap.fromIds[virtualInstance.Parent]
+
+		if parent == nil then
+			Logging.info("Instance %s wanted parent of %s", tostring(id), tostring(virtualInstance.Parent))
+			error("Rojo bug: During reconciliation, an instance referred to an instance ID as parent that does not exist.")
+		end
+
+		-- Some instances, like services, don't like having their Parent
+		-- property poked, even if we're setting it to the same value.
+		setProperty(instance, "Parent", parent)
+		if instance.Parent ~= parent then
+			instance.Parent = parent
+		end
+	end
+
+	return instance
+end
+
+function Reconciler:__shouldClearUnknownInstances(virtualInstance)
+	if virtualInstance.Metadata ~= nil then
+		return not virtualInstance.Metadata.ignoreUnknownInstances
 	else
-		error("unknown item type " .. tostring(item.type))
+		return true
 	end
 end
 
-function Reconciler.reconcileRoute(route, item)
-	local location = game
+function Reconciler:__reify(virtualInstancesById, id, parent)
+	local virtualInstance = virtualInstancesById[id]
 
-	for i = 1, #route - 1 do
-		local piece = route[i]
-		local newLocation = location:FindFirstChild(piece)
+	local instance = Instance.new(virtualInstance.ClassName)
 
-		if not newLocation then
-			newLocation = Instance.new("Folder")
-			newLocation.Name = piece
-			newLocation.Parent = location
+	for key, value in pairs(virtualInstance.Properties) do
+		-- TODO: Branch on value.Type
+		setProperty(instance, key, value.Value)
+	end
+
+	instance.Name = virtualInstance.Name
+
+	for _, childId in ipairs(virtualInstance.Children) do
+		self:__reify(virtualInstancesById, childId, instance)
+	end
+
+	setProperty(instance, "Parent", parent)
+	self.instanceMap:insert(id, instance)
+
+	return instance
+end
+
+function Reconciler:__applyUpdatePiece(id, visitedIds, virtualInstancesById)
+	if visitedIds[id] then
+		return
+	end
+
+	visitedIds[id] = true
+
+	local virtualInstance = virtualInstancesById[id]
+	local instance = self.instanceMap.fromIds[id]
+
+	-- The instance was deleted in this update
+	if virtualInstance == nil then
+		self.instanceMap:destroyId(id)
+		return
+	end
+
+	-- An instance we know about was updated
+	if instance ~= nil then
+		self:reconcile(virtualInstancesById, id, instance)
+		return instance
+	end
+
+	-- If the instance's parent already exists, we can stick it there
+	local parentInstance = self.instanceMap.fromIds[virtualInstance.Parent]
+	if parentInstance ~= nil then
+		self:__reify(virtualInstancesById, id, parentInstance)
+		return
+	end
+
+	-- Otherwise, we can check if this response payload contained the parent and
+	-- work from there instead.
+	local parentData = virtualInstancesById[virtualInstance.Parent]
+	if parentData ~= nil then
+		if visitedIds[virtualInstance.Parent] then
+			error("Rojo bug: An instance was present and marked as visited but its instance was missing")
 		end
 
-		location = newLocation
+		self:__applyUpdatePiece(virtualInstance.Parent, visitedIds, virtualInstancesById)
+		return
 	end
 
-	local fileName = route[#route]
-
-	local name = itemToName(item, fileName)
-	local rbx = location:FindFirstChild(name)
-	Reconciler.reconcile(rbx, item, fileName, location)
+	Logging.trace("Instance ID %s, parent ID %s", tostring(id), tostring(virtualInstance.Parent))
+	error("Rojo NYI: Instances with parents that weren't mentioned in an update payload")
 end
 
-return Reconciler
+return Reconciler

plugin/src/Server.lua

@@ -1,69 +0,0 @@
-local HttpService = game:GetService("HttpService")
-
-local Server = {}
-Server.__index = Server
-
---[[
-	Create a new Server using the given HTTP implementation and replacer.
-
-	If the context becomes invalid, `replacer` will be invoked with a new
-	context that should be suitable to replace this one.
-
-	Attempting to invoke methods on an invalid conext will throw errors!
-]]
-function Server.connect(http)
-	local context = {
-		http = http,
-		serverId = nil,
-		currentTime = 0,
-	}
-
-	setmetatable(context, Server)
-
-	return context:_start()
-end
-
-function Server:_start()
-	return self:getInfo()
-		:andThen(function(response)
-			self.serverId = response.serverId
-			self.currentTime = response.currentTime
-
-			return self
-		end)
-end
-
-function Server:getInfo()
-	return self.http:get("/")
-		:andThen(function(response)
-			response = response:json()
-
-			return response
-		end)
-end
-
-function Server:read(paths)
-	local body = HttpService:JSONEncode(paths)
-
-	return self.http:post("/read", body)
-		:andThen(function(response)
-			response = response:json()
-
-			return response.items
-		end)
-end
-
-function Server:getChanges()
-	local url = ("/changes/%f"):format(self.currentTime)
-
-	return self.http:get(url)
-		:andThen(function(response)
-			response = response:json()
-
-			self.currentTime = response.currentTime
-
-			return response.changes
-		end)
-end
-
-return Server

plugin/src/Session.lua

@@ -0,0 +1,97 @@
+local Rojo = script:FindFirstAncestor("Rojo")
+
+local Promise = require(Rojo.Promise)
+
+local ApiContext = require(script.Parent.ApiContext)
+local Reconciler = require(script.Parent.Reconciler)
+
+local Session = {}
+Session.__index = Session
+
+function Session.new(config)
+	local remoteUrl = ("http://%s:%s"):format(config.address, config.port)
+	local api = ApiContext.new(remoteUrl)
+
+	local self = {
+		onError = config.onError,
+		disconnected = false,
+		reconciler = Reconciler.new(),
+		api = api,
+	}
+
+	api:connect()
+		:andThen(function()
+			if self.disconnected then
+				return
+			end
+
+			return api:read({api.rootInstanceId})
+		end)
+		:andThen(function(response)
+			if self.disconnected then
+				return
+			end
+
+			self.reconciler:reconcile(response.instances, api.rootInstanceId, game)
+			return self:__processMessages()
+		end)
+		:catch(function(message)
+			self.disconnected = true
+			self.onError(message)
+		end)
+
+	return not self.disconnected, setmetatable(self, Session)
+end
+
+function Session:__processMessages()
+	if self.disconnected then
+		return Promise.resolve()
+	end
+
+	return self.api:retrieveMessages()
+		:andThen(function(messages)
+			local promise = Promise.resolve(nil)
+
+			for _, message in ipairs(messages) do
+				promise = promise:andThen(function()
+					return self:__onMessage(message)
+				end)
+			end
+
+			return promise
+		end)
+		:andThen(function()
+			return self:__processMessages()
+		end)
+end
+
+function Session:__onMessage(message)
+	if self.disconnected then
+		return Promise.resolve()
+	end
+
+	local requestedIds = {}
+
+	for _, id in ipairs(message.added) do
+		table.insert(requestedIds, id)
+	end
+
+	for _, id in ipairs(message.updated) do
+		table.insert(requestedIds, id)
+	end
+
+	for _, id in ipairs(message.removed) do
+		table.insert(requestedIds, id)
+	end
+
+	return self.api:read(requestedIds)
+		:andThen(function(response)
+			return self.reconciler:applyUpdate(requestedIds, response.instances)
+		end)
+end
+
+function Session:disconnect()
+	self.disconnected = true
+end
+
+return Session

plugin/src/Theme.lua

@@ -0,0 +1,20 @@
+local Theme = {
+	ButtonFont = Enum.Font.GothamSemibold,
+	InputFont = Enum.Font.Code,
+	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),
+	SecondaryColor = Color3.fromRGB(235, 235, 235),
+	LightTextColor = Color3.fromRGB(140, 140, 140),
+}
+
+setmetatable(Theme, {
+	__index = function(_, key)
+		error(("%s is not a valid member of Theme"):format(key), 2)
+	end
+})
+
+return Theme

plugin/src/Version.lua

@@ -0,0 +1,46 @@
+local function compare(a, b)
+	if a > b then
+		return 1
+	elseif a < b then
+		return -1
+	end
+
+	return 0
+end
+
+local Version = {}
+
+--[[
+	Compares two versions of the form {major, minor, revision}.
+
+	If a is newer than b, 1.
+	If a is older than b, -1.
+	If a and b are the same, 0.
+]]
+function Version.compare(a, b)
+	local major = compare(a[1], b[1])
+	local minor = compare(a[2] or 0, b[2] or 0)
+	local revision = compare(a[3] or 0, b[3] or 0)
+
+	if major ~= 0 then
+		return major
+	end
+
+	if minor ~= 0 then
+		return minor
+	end
+
+	return revision
+end
+
+function Version.display(version)
+	local output = ("%d.%d.%d"):format(version[1], version[2], version[3])
+
+	if version[4] ~= nil then
+		output = output .. version[4]
+	end
+
+	return output
+end
+
+return Version

plugin/src/Version.spec.lua

@@ -0,0 +1,28 @@
+return function()
+	local Version = require(script.Parent.Version)
+
+	it("should compare equal versions", function()
+		expect(Version.compare({1, 2, 3}, {1, 2, 3})).to.equal(0)
+		expect(Version.compare({0, 4, 0}, {0, 4})).to.equal(0)
+		expect(Version.compare({0, 0, 123}, {0, 0, 123})).to.equal(0)
+		expect(Version.compare({26}, {26})).to.equal(0)
+		expect(Version.compare({26, 42}, {26, 42})).to.equal(0)
+		expect(Version.compare({1, 0, 0}, {1})).to.equal(0)
+	end)
+
+	it("should compare newer, older versions", function()
+		expect(Version.compare({1}, {0})).to.equal(1)
+		expect(Version.compare({1, 1}, {1, 0})).to.equal(1)
+	end)
+
+	it("should compare different major versions", function()
+		expect(Version.compare({1, 3, 2}, {2, 2, 1})).to.equal(-1)
+		expect(Version.compare({1, 2}, {2, 1})).to.equal(-1)
+		expect(Version.compare({1}, {2})).to.equal(-1)
+	end)
+
+	it("should compare different minor versions", function()
+		expect(Version.compare({1, 2, 3}, {1, 3, 2})).to.equal(-1)
+		expect(Version.compare({50, 1}, {50, 2})).to.equal(-1)
+	end)
+end

plugin/src/init.server.lua

@@ -0,0 +1,19 @@
+if not plugin then
+	return
+end
+
+local Roact = require(script.Parent.Roact)
+
+Roact.setGlobalConfig({
+	elementTracing = true,
+})
+
+local App = require(script.Components.App)
+
+local app = Roact.createElement(App, {
+	plugin = plugin,
+})
+
+Roact.mount(app, game:GetService("CoreGui"), "Rojo UI")
+
+-- TODO: Detect another instance of Rojo coming online and shut down this one.

plugin/src/joinBindings.lua

@@ -0,0 +1,34 @@
+--[[
+	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/runTests.lua

@@ -0,0 +1,4 @@
+return function()
+	local TestEZ = require(script.Parent.Parent.TestEZ)
+	TestEZ.TestBootstrap:run(script.Parent)
+end

plugin/testBootstrap.server.lua

@@ -0,0 +1,2 @@
+local TestEZ = require(game.ReplicatedStorage.TestEZ)
+TestEZ.TestBootstrap:run(game.ReplicatedStorage.Rojo.plugin)

plugin/tests/empty.lua

@@ -0,0 +1,5 @@
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+local Session = require(ReplicatedStorage.Modules.Rojo.Session)
+
+Session.new()

rojo-e2e/Cargo.toml

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

rojo-e2e/README.md

@@ -0,0 +1,2 @@
+# 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

@@ -0,0 +1,32 @@
+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.json

@@ -1,10 +0,0 @@
-{
-  "name": "rojo",
-  "servePort": 8000,
-  "partitions": {
-    "plugin": {
-      "path": "plugin/src",
-      "target": "ReplicatedStorage.Rojo Plugin"
-    }
-  }
-}

server/Cargo.toml

@@ -0,0 +1,45 @@
+[package]
+name = "rojo"
+version = "0.5.0-alpha.1"
+authors = ["Lucien Greathouse <me@lpghatguy.com>"]
+description = "A tool to create robust Roblox projects"
+license = "MIT"
+repository = "https://github.com/LPGhatguy/rojo"
+edition = "2018"
+
+[lib]
+name = "librojo"
+path = "src/lib.rs"
+
+[[bin]]
+name = "rojo"
+path = "src/bin.rs"
+
+[features]
+default = []
+bundle-plugin = []
+
+[dependencies]
+clap = "2.27"
+csv = "1.0"
+env_logger = "0.5"
+failure = "0.1.3"
+log = "0.4"
+maplit = "1.0.1"
+notify = "4.0"
+rand = "0.4"
+regex = "1.0"
+reqwest = "0.9.5"
+rouille = "2.1"
+serde = "1.0"
+serde_derive = "1.0"
+serde_json = "1.0"
+uuid = { version = "0.7", features = ["v4", "serde"] }
+rbx_tree = "0.2.0"
+rbx_xml = "0.2.0"
+rbx_binary = "0.2.0"
+
+[dev-dependencies]
+tempfile = "3.0"
+walkdir = "2.1"
+lazy_static = "1.2"

server/README.md

@@ -0,0 +1,4 @@
+# Rojo Server
+This is the source to the Rojo server.
+
+Documentation is WIP.

server/src/bin.rs

@@ -0,0 +1,199 @@
+use std::{
+    env,
+    panic,
+    path::{Path, PathBuf},
+    process,
+};
+
+use log::error;
+use clap::{clap_app, ArgMatches};
+
+use librojo::commands;
+
+fn make_path_absolute(value: &Path) -> PathBuf {
+    if value.is_absolute() {
+        PathBuf::from(value)
+    } else {
+        let current_dir = env::current_dir().unwrap();
+        current_dir.join(value)
+    }
+}
+
+fn main() {
+    env_logger::Builder::from_default_env()
+        .default_format_timestamp(false)
+        .init();
+
+    let app = clap_app!(Rojo =>
+        (version: env!("CARGO_PKG_VERSION"))
+        (author: env!("CARGO_PKG_AUTHORS"))
+        (about: env!("CARGO_PKG_DESCRIPTION"))
+
+        (@subcommand init =>
+            (about: "Creates a new Rojo project")
+            (@arg PATH: "Path to the place to create the project. Defaults to the current directory.")
+            (@arg kind: --kind +takes_value "The kind of project to create, 'place' or 'model'. Defaults to place.")
+        )
+
+        (@subcommand serve =>
+            (about: "Serves the project's files for use with the Rojo Studio plugin.")
+            (@arg PROJECT: "Path to the project to serve. Defaults to the current directory.")
+            (@arg port: --port +takes_value "The port to listen on. Defaults to 8000.")
+        )
+
+        (@subcommand build =>
+            (about: "Generates an rbxmx model file from the project.")
+            (@arg PROJECT: "Path to the project to serve. Defaults to the current directory.")
+            (@arg output: --output -o +takes_value +required "Where to output the result.")
+        )
+
+        (@subcommand upload =>
+            (about: "Generates a place or model file out of the project and uploads it to Roblox.")
+            (@arg PROJECT: "Path to the project to upload. Defaults to the current directory.")
+            (@arg kind: --kind +takes_value "The kind of asset to generate, 'place', or 'model'. Defaults to place.")
+            (@arg cookie: --cookie +takes_value +required "Security cookie to authenticate with.")
+            (@arg asset_id: --asset_id +takes_value +required "Asset ID to upload to.")
+        )
+    );
+
+    let matches = app.get_matches();
+
+    let result = panic::catch_unwind(|| match matches.subcommand() {
+        ("init", Some(sub_matches)) => start_init(sub_matches),
+        ("serve", Some(sub_matches)) => start_serve(sub_matches),
+        ("build", Some(sub_matches)) => start_build(sub_matches),
+        ("upload", Some(sub_matches)) => start_upload(sub_matches),
+        _ => eprintln!("Usage: rojo <SUBCOMMAND>\nUse 'rojo help' for more help."),
+    });
+
+    if let Err(error) = result {
+        let message = match error.downcast_ref::<&str>() {
+            Some(message) => message.to_string(),
+            None => match error.downcast_ref::<String>() {
+                Some(message) => message.clone(),
+                None => "<no message>".to_string(),
+            },
+        };
+
+        show_crash_message(&message);
+        process::exit(1);
+    }
+}
+
+fn show_crash_message(message: &str) {
+    error!("Rojo crashed!");
+    error!("This is a bug in Rojo.");
+    error!("");
+    error!("Please consider filing a bug: https://github.com/LPGhatguy/rojo/issues");
+    error!("");
+    error!("Details: {}", message);
+}
+
+fn start_init(sub_matches: &ArgMatches) {
+    let fuzzy_project_path = make_path_absolute(Path::new(sub_matches.value_of("PATH").unwrap_or("")));
+    let kind = sub_matches.value_of("kind");
+
+    let options = commands::InitOptions {
+        fuzzy_project_path,
+        kind,
+    };
+
+    match commands::init(&options) {
+        Ok(_) => {},
+        Err(e) => {
+            error!("{}", e);
+            process::exit(1);
+        },
+    }
+}
+
+fn start_serve(sub_matches: &ArgMatches) {
+    let fuzzy_project_path = match sub_matches.value_of("PROJECT") {
+        Some(v) => make_path_absolute(Path::new(v)),
+        None => std::env::current_dir().unwrap(),
+    };
+
+    let port = match sub_matches.value_of("port") {
+        Some(v) => match v.parse::<u16>() {
+            Ok(port) => Some(port),
+            Err(_) => {
+                error!("Invalid port {}", v);
+                process::exit(1);
+            },
+        },
+        None => None,
+    };
+
+    let options = commands::ServeOptions {
+        fuzzy_project_path,
+        port,
+    };
+
+    match commands::serve(&options) {
+        Ok(_) => {},
+        Err(e) => {
+            error!("{}", e);
+            process::exit(1);
+        },
+    }
+}
+
+fn start_build(sub_matches: &ArgMatches) {
+    let fuzzy_project_path = match sub_matches.value_of("PROJECT") {
+        Some(v) => make_path_absolute(Path::new(v)),
+        None => std::env::current_dir().unwrap(),
+    };
+
+    let output_file = make_path_absolute(Path::new(sub_matches.value_of("output").unwrap()));
+
+    let options = commands::BuildOptions {
+        fuzzy_project_path,
+        output_file,
+        output_kind: None, // TODO: Accept from argument
+    };
+
+    match commands::build(&options) {
+        Ok(_) => {},
+        Err(e) => {
+            error!("{}", e);
+            process::exit(1);
+        },
+    }
+}
+
+fn start_upload(sub_matches: &ArgMatches) {
+    let fuzzy_project_path = match sub_matches.value_of("PROJECT") {
+        Some(v) => make_path_absolute(Path::new(v)),
+        None => std::env::current_dir().unwrap(),
+    };
+
+    let kind = sub_matches.value_of("kind");
+    let security_cookie = sub_matches.value_of("cookie").unwrap();
+
+    let asset_id: u64 = {
+        let arg = sub_matches.value_of("asset_id").unwrap();
+
+        match arg.parse() {
+            Ok(v) => v,
+            Err(_) => {
+                error!("Invalid place ID {}", arg);
+                process::exit(1);
+            },
+        }
+    };
+
+    let options = commands::UploadOptions {
+        fuzzy_project_path,
+        security_cookie: security_cookie.to_string(),
+        asset_id,
+        kind,
+    };
+
+    match commands::upload(&options) {
+        Ok(_) => {},
+        Err(e) => {
+            error!("{}", e);
+            process::exit(1);
+        },
+    }
+}

server/src/commands/build.rs

@@ -0,0 +1,115 @@
+use std::{
+    path::PathBuf,
+    fs::File,
+    io,
+};
+
+use log::info;
+use failure::Fail;
+
+use crate::{
+    rbx_session::construct_oneoff_tree,
+    project::{Project, ProjectLoadFuzzyError},
+    imfs::Imfs,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum OutputKind {
+    Rbxmx,
+    Rbxlx,
+    Rbxm,
+    Rbxl,
+}
+
+fn detect_output_kind(options: &BuildOptions) -> Option<OutputKind> {
+    let extension = options.output_file.extension()?.to_str()?;
+
+    match extension {
+        "rbxlx" => Some(OutputKind::Rbxlx),
+        "rbxmx" => Some(OutputKind::Rbxmx),
+        "rbxl" => Some(OutputKind::Rbxl),
+        "rbxm" => Some(OutputKind::Rbxm),
+        _ => None,
+    }
+}
+
+#[derive(Debug)]
+pub struct BuildOptions {
+    pub fuzzy_project_path: PathBuf,
+    pub output_file: PathBuf,
+    pub output_kind: Option<OutputKind>,
+}
+
+#[derive(Debug, Fail)]
+pub enum BuildError {
+    #[fail(display = "Could not detect what kind of file to create")]
+    UnknownOutputKind,
+
+    #[fail(display = "Project load error: {}", _0)]
+    ProjectLoadError(#[fail(cause)] ProjectLoadFuzzyError),
+
+    #[fail(display = "IO error: {}", _0)]
+    IoError(#[fail(cause)] io::Error),
+
+    #[fail(display = "XML model file error")]
+    XmlModelEncodeError(rbx_xml::EncodeError),
+
+    #[fail(display = "Binary model file error")]
+    BinaryModelEncodeError(rbx_binary::EncodeError)
+}
+
+impl_from!(BuildError {
+    ProjectLoadFuzzyError => ProjectLoadError,
+    io::Error => IoError,
+    rbx_xml::EncodeError => XmlModelEncodeError,
+    rbx_binary::EncodeError => BinaryModelEncodeError
+});
+
+pub fn build(options: &BuildOptions) -> Result<(), BuildError> {
+    let output_kind = options.output_kind
+        .or_else(|| detect_output_kind(options))
+        .ok_or(BuildError::UnknownOutputKind)?;
+
+    info!("Hoping to generate file of type {:?}", output_kind);
+
+    info!("Looking for project at {}", options.fuzzy_project_path.display());
+
+    let project = Project::load_fuzzy(&options.fuzzy_project_path)?;
+
+    info!("Found project at {}", project.file_location.display());
+    info!("Using project {:#?}", project);
+
+    let mut imfs = Imfs::new();
+    imfs.add_roots_from_project(&project)?;
+    let tree = construct_oneoff_tree(&project, &imfs);
+    let mut file = File::create(&options.output_file)?;
+
+    match output_kind {
+        OutputKind::Rbxmx => {
+            // Model files include the root instance of the tree and all its
+            // descendants.
+
+            let root_id = tree.get_root_id();
+            rbx_xml::encode(&tree, &[root_id], &mut file)?;
+        },
+        OutputKind::Rbxlx => {
+            // Place files don't contain an entry for the DataModel, but our
+            // RbxTree representation does.
+
+            let root_id = tree.get_root_id();
+            let top_level_ids = tree.get_instance(root_id).unwrap().get_children_ids();
+            rbx_xml::encode(&tree, top_level_ids, &mut file)?;
+        },
+        OutputKind::Rbxm => {
+            let root_id = tree.get_root_id();
+            rbx_binary::encode(&tree, &[root_id], &mut file)?;
+        },
+        OutputKind::Rbxl => {
+            let root_id = tree.get_root_id();
+            let top_level_ids = tree.get_instance(root_id).unwrap().get_children_ids();
+            rbx_binary::encode(&tree, top_level_ids, &mut file)?;
+        },
+    }
+
+    Ok(())
+}

server/src/commands/init.rs

@@ -0,0 +1,44 @@
+use std::{
+    path::PathBuf,
+};
+
+use failure::Fail;
+
+use crate::project::{Project, ProjectInitError};
+
+#[derive(Debug, Fail)]
+pub enum InitError {
+    #[fail(display = "Invalid project kind '{}', valid kinds are 'place' and 'model'", _0)]
+    InvalidKind(String),
+
+    #[fail(display = "Project init error: {}", _0)]
+    ProjectInitError(#[fail(cause)] ProjectInitError)
+}
+
+impl_from!(InitError {
+    ProjectInitError => ProjectInitError,
+});
+
+#[derive(Debug)]
+pub struct InitOptions<'a> {
+    pub fuzzy_project_path: PathBuf,
+    pub kind: Option<&'a str>,
+}
+
+pub fn init(options: &InitOptions) -> Result<(), InitError> {
+    let (project_path, project_kind) = match options.kind {
+        Some("place") | None => {
+            let path = Project::init_place(&options.fuzzy_project_path)?;
+            (path, "place")
+        },
+        Some("model") => {
+            let path = Project::init_model(&options.fuzzy_project_path)?;
+            (path, "model")
+        },
+        Some(invalid) => return Err(InitError::InvalidKind(invalid.to_string())),
+    };
+
+    println!("Created new {} project file at {}", project_kind, project_path.display());
+
+    Ok(())
+}

server/src/commands/mod.rs

@@ -0,0 +1,9 @@
+mod serve;
+mod init;
+mod build;
+mod upload;
+
+pub use self::serve::*;
+pub use self::init::*;
+pub use self::build::*;
+pub use self::upload::*;

server/src/commands/serve.rs

@@ -0,0 +1,53 @@
+use std::{
+    path::PathBuf,
+    sync::Arc,
+};
+
+use log::info;
+use failure::Fail;
+
+use crate::{
+    project::{Project, ProjectLoadFuzzyError},
+    web::Server,
+    live_session::LiveSession,
+};
+
+const DEFAULT_PORT: u16 = 34872;
+
+#[derive(Debug)]
+pub struct ServeOptions {
+    pub fuzzy_project_path: PathBuf,
+    pub port: Option<u16>,
+}
+
+#[derive(Debug, Fail)]
+pub enum ServeError {
+   #[fail(display = "Project load error: {}", _0)]
+   ProjectLoadError(#[fail(cause)] ProjectLoadFuzzyError),
+}
+
+impl_from!(ServeError {
+    ProjectLoadFuzzyError => ProjectLoadError,
+});
+
+pub fn serve(options: &ServeOptions) -> Result<(), ServeError> {
+    info!("Looking for project at {}", options.fuzzy_project_path.display());
+
+    let project = Arc::new(Project::load_fuzzy(&options.fuzzy_project_path)?);
+
+    info!("Found project at {}", project.file_location.display());
+    info!("Using project {:#?}", project);
+
+    let live_session = Arc::new(LiveSession::new(Arc::clone(&project)).unwrap());
+    let server = Server::new(Arc::clone(&live_session));
+
+    let port = options.port
+        .or(project.serve_port)
+        .unwrap_or(DEFAULT_PORT);
+
+    println!("Rojo server listening on port {}", port);
+
+    server.listen(port);
+
+    Ok(())
+}

server/src/commands/upload.rs

@@ -0,0 +1,98 @@
+use std::{
+    path::PathBuf,
+    io,
+};
+
+use log::info;
+use failure::Fail;
+
+use reqwest::header::{ACCEPT, USER_AGENT, CONTENT_TYPE, COOKIE};
+
+use crate::{
+    rbx_session::construct_oneoff_tree,
+    project::{Project, ProjectLoadFuzzyError},
+    imfs::Imfs,
+};
+
+#[derive(Debug, Fail)]
+pub enum UploadError {
+    #[fail(display = "Roblox API Error: {}", _0)]
+    RobloxApiError(String),
+
+    #[fail(display = "Invalid asset kind: {}", _0)]
+    InvalidKind(String),
+
+    #[fail(display = "Project load error: {}", _0)]
+    ProjectLoadError(#[fail(cause)] ProjectLoadFuzzyError),
+
+    #[fail(display = "IO error: {}", _0)]
+    IoError(#[fail(cause)] io::Error),
+
+    #[fail(display = "HTTP error: {}", _0)]
+    HttpError(#[fail(cause)] reqwest::Error),
+
+    #[fail(display = "XML model file error")]
+    XmlModelEncodeError(rbx_xml::EncodeError),
+}
+
+impl_from!(UploadError {
+    ProjectLoadFuzzyError => ProjectLoadError,
+    io::Error => IoError,
+    reqwest::Error => HttpError,
+    rbx_xml::EncodeError => XmlModelEncodeError,
+});
+
+#[derive(Debug)]
+pub struct UploadOptions<'a> {
+    pub fuzzy_project_path: PathBuf,
+    pub security_cookie: String,
+    pub asset_id: u64,
+    pub kind: Option<&'a str>,
+}
+
+pub fn upload(options: &UploadOptions) -> Result<(), UploadError> {
+    // TODO: Switch to uploading binary format?
+
+    info!("Looking for project at {}", options.fuzzy_project_path.display());
+
+    let project = Project::load_fuzzy(&options.fuzzy_project_path)?;
+
+    info!("Found project at {}", project.file_location.display());
+    info!("Using project {:#?}", project);
+
+    let mut imfs = Imfs::new();
+    imfs.add_roots_from_project(&project)?;
+    let tree = construct_oneoff_tree(&project, &imfs);
+
+    let root_id = tree.get_root_id();
+    let mut contents = Vec::new();
+
+    match options.kind {
+        Some("place") | None => {
+            let top_level_ids = tree.get_instance(root_id).unwrap().get_children_ids();
+            rbx_xml::encode(&tree, top_level_ids, &mut contents)?;
+        },
+        Some("model") => {
+            rbx_xml::encode(&tree, &[root_id], &mut contents)?;
+        },
+        Some(invalid) => return Err(UploadError::InvalidKind(invalid.to_owned())),
+    }
+
+    let url = format!("https://data.roblox.com/Data/Upload.ashx?assetid={}", options.asset_id);
+
+    let client = reqwest::Client::new();
+    let mut response = client.post(&url)
+        .header(COOKIE, format!(".ROBLOSECURITY={}", &options.security_cookie))
+        .header(USER_AGENT, "Roblox/WinInet")
+        .header("Requester", "Client")
+        .header(CONTENT_TYPE, "application/xml")
+        .header(ACCEPT, "application/json")
+        .body(contents)
+        .send()?;
+
+    if !response.status().is_success() {
+        return Err(UploadError::RobloxApiError(response.text()?));
+    }
+
+    Ok(())
+}

server/src/fs_watcher.rs

@@ -0,0 +1,116 @@
+use std::{
+    sync::{mpsc, Arc, Mutex},
+    time::Duration,
+    thread,
+};
+
+use log::info;
+use notify::{
+    self,
+    DebouncedEvent,
+    RecommendedWatcher,
+    RecursiveMode,
+    Watcher,
+};
+
+use crate::{
+    imfs::Imfs,
+    rbx_session::RbxSession,
+};
+
+const WATCH_TIMEOUT: Duration = Duration::from_millis(100);
+
+fn handle_event(imfs: &Mutex<Imfs>, rbx_session: &Mutex<RbxSession>, event: DebouncedEvent) {
+    match event {
+        DebouncedEvent::Create(path) => {
+            {
+                let mut imfs = imfs.lock().unwrap();
+                imfs.path_created(&path).unwrap();
+            }
+
+            {
+                let mut rbx_session = rbx_session.lock().unwrap();
+                rbx_session.path_created(&path);
+            }
+        },
+        DebouncedEvent::Write(path) => {
+            {
+                let mut imfs = imfs.lock().unwrap();
+                imfs.path_updated(&path).unwrap();
+            }
+
+            {
+                let mut rbx_session = rbx_session.lock().unwrap();
+                rbx_session.path_updated(&path);
+            }
+        },
+        DebouncedEvent::Remove(path) => {
+            {
+                let mut imfs = imfs.lock().unwrap();
+                imfs.path_removed(&path).unwrap();
+            }
+
+            {
+                let mut rbx_session = rbx_session.lock().unwrap();
+                rbx_session.path_removed(&path);
+            }
+        },
+        DebouncedEvent::Rename(from_path, to_path) => {
+            {
+                let mut imfs = imfs.lock().unwrap();
+                imfs.path_moved(&from_path, &to_path).unwrap();
+            }
+
+            {
+                let mut rbx_session = rbx_session.lock().unwrap();
+                rbx_session.path_renamed(&from_path, &to_path);
+            }
+        },
+        _ => {},
+    }
+}
+
+/// Watches for changes on the filesystem and links together the in-memory
+/// filesystem and in-memory Roblox tree.
+pub struct FsWatcher {
+    #[allow(unused)]
+    watchers: Vec<RecommendedWatcher>,
+}
+
+impl FsWatcher {
+    pub fn start(imfs: Arc<Mutex<Imfs>>, rbx_session: Arc<Mutex<RbxSession>>) -> FsWatcher {
+        let mut watchers = Vec::new();
+
+        {
+            let imfs_temp = imfs.lock().unwrap();
+
+            for root_path in imfs_temp.get_roots() {
+                let (watch_tx, watch_rx) = mpsc::channel();
+
+                let mut watcher = notify::watcher(watch_tx, WATCH_TIMEOUT)
+                    .expect("Could not create `notify` watcher");
+
+                watcher.watch(root_path, RecursiveMode::Recursive)
+                    .expect("Could not watch directory");
+
+                watchers.push(watcher);
+
+                let imfs = Arc::clone(&imfs);
+                let rbx_session = Arc::clone(&rbx_session);
+                let root_path = root_path.clone();
+
+                thread::spawn(move || {
+                    info!("Watcher thread ({}) started", root_path.display());
+                    while let Ok(event) = watch_rx.recv() {
+                        handle_event(&imfs, &rbx_session, event);
+                    }
+                    info!("Watcher thread ({}) stopped", root_path.display());
+                });
+            }
+        }
+
+        FsWatcher {
+            watchers,
+        }
+    }
+}

server/src/imfs.rs

@@ -0,0 +1,225 @@
+use std::{
+    collections::{HashMap, HashSet},
+    path::{Path, PathBuf},
+    fs,
+    io,
+};
+
+use serde_derive::{Serialize, Deserialize};
+
+use crate::project::{Project, ProjectNode};
+
+fn add_sync_points(imfs: &mut Imfs, project_node: &ProjectNode) -> io::Result<()> {
+    match project_node {
+        ProjectNode::Instance(node) => {
+            for child in node.children.values() {
+                add_sync_points(imfs, child)?;
+            }
+        },
+        ProjectNode::SyncPoint(node) => {
+            imfs.add_root(&node.path)?;
+        },
+    }
+
+    Ok(())
+}
+
+/// The in-memory filesystem keeps a mirror of all files being watcher by Rojo
+/// in order to deduplicate file changes in the case of bidirectional syncing
+/// from Roblox Studio.
+#[derive(Debug, Clone)]
+pub struct Imfs {
+    items: HashMap<PathBuf, ImfsItem>,
+    roots: HashSet<PathBuf>,
+}
+
+impl Imfs {
+    pub fn new() -> Imfs {
+        Imfs {
+            items: HashMap::new(),
+            roots: HashSet::new(),
+        }
+    }
+
+    pub fn add_roots_from_project(&mut self, project: &Project) -> io::Result<()> {
+        add_sync_points(self, &project.tree)
+    }
+
+    pub fn get_roots(&self) -> &HashSet<PathBuf> {
+        &self.roots
+    }
+
+    pub fn get_items(&self) -> &HashMap<PathBuf, ImfsItem> {
+        &self.items
+    }
+
+    pub fn get(&self, path: &Path) -> Option<&ImfsItem> {
+        debug_assert!(path.is_absolute());
+        debug_assert!(self.is_within_roots(path));
+
+        self.items.get(path)
+    }
+
+    pub fn add_root(&mut self, path: &Path) -> io::Result<()> {
+        debug_assert!(path.is_absolute());
+        debug_assert!(!self.is_within_roots(path));
+
+        self.roots.insert(path.to_path_buf());
+
+        self.read_from_disk(path)
+    }
+
+    pub fn path_created(&mut self, path: &Path) -> io::Result<()> {
+        debug_assert!(path.is_absolute());
+        debug_assert!(self.is_within_roots(path));
+
+        self.read_from_disk(path)
+    }
+
+    pub fn path_updated(&mut self, path: &Path) -> io::Result<()> {
+        debug_assert!(path.is_absolute());
+        debug_assert!(self.is_within_roots(path));
+
+        self.read_from_disk(path)
+    }
+
+    pub fn path_removed(&mut self, path: &Path) -> io::Result<()> {
+        debug_assert!(path.is_absolute());
+        debug_assert!(self.is_within_roots(path));
+
+        self.remove_item(path);
+
+        if let Some(parent_path) = path.parent() {
+            self.unlink_child(parent_path, path);
+        }
+
+        Ok(())
+    }
+
+    pub fn path_moved(&mut self, from_path: &Path, to_path: &Path) -> io::Result<()> {
+        debug_assert!(from_path.is_absolute());
+        debug_assert!(self.is_within_roots(from_path));
+        debug_assert!(to_path.is_absolute());
+        debug_assert!(self.is_within_roots(to_path));
+
+        self.path_removed(from_path)?;
+        self.path_created(to_path)?;
+        Ok(())
+    }
+
+    pub fn get_root_for_path<'a>(&'a self, path: &Path) -> Option<&'a Path> {
+        for root_path in &self.roots {
+            if path.starts_with(root_path) {
+                return Some(root_path);
+            }
+        }
+
+        None
+    }
+
+    fn remove_item(&mut self, path: &Path) {
+        if let Some(ImfsItem::Directory(directory)) = self.items.remove(path) {
+            for child_path in &directory.children {
+                self.remove_item(child_path);
+            }
+        }
+    }
+
+    fn unlink_child(&mut self, parent: &Path, child: &Path) {
+        let parent_item = self.items.get_mut(parent);
+
+        match parent_item {
+            Some(ImfsItem::Directory(directory)) => {
+                directory.children.remove(child);
+            },
+            _ => {
+                panic!("Tried to unlink child of path that wasn't a directory!");
+            },
+        }
+    }
+
+    fn link_child(&mut self, parent: &Path, child: &Path) {
+        if self.is_within_roots(parent) {
+            let parent_item = self.items.get_mut(parent);
+
+            match parent_item {
+                Some(ImfsItem::Directory(directory)) => {
+                    directory.children.insert(child.to_path_buf());
+                },
+                _ => {
+                    panic!("Tried to link child of path that wasn't a directory!");
+                },
+            }
+        }
+    }
+
+    fn read_from_disk(&mut self, path: &Path) -> io::Result<()> {
+        let metadata = fs::metadata(path)?;
+
+        if metadata.is_file() {
+            let contents = fs::read(path)?;
+            let item = ImfsItem::File(ImfsFile {
+                path: path.to_path_buf(),
+                contents,
+            });
+
+            self.items.insert(path.to_path_buf(), item);
+
+            if let Some(parent_path) = path.parent() {
+                self.link_child(parent_path, path);
+            }
+
+            Ok(())
+        } else if metadata.is_dir() {
+            let item = ImfsItem::Directory(ImfsDirectory {
+                path: path.to_path_buf(),
+                children: HashSet::new(),
+            });
+
+            self.items.insert(path.to_path_buf(), item);
+
+            for entry in fs::read_dir(path)? {
+                let entry = entry?;
+                let child_path = entry.path();
+
+                self.read_from_disk(&child_path)?;
+            }
+
+            if let Some(parent_path) = path.parent() {
+                self.link_child(parent_path, path);
+            }
+
+            Ok(())
+        } else {
+            panic!("Unexpected non-file, non-directory item");
+        }
+    }
+
+    fn is_within_roots(&self, path: &Path) -> bool {
+        for root_path in &self.roots {
+            if path.starts_with(root_path) {
+                return true;
+            }
+        }
+
+        false
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ImfsFile {
+    pub path: PathBuf,
+    pub contents: Vec<u8>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ImfsDirectory {
+    pub path: PathBuf,
+    pub children: HashSet<PathBuf>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum ImfsItem {
+    File(ImfsFile),
+    Directory(ImfsDirectory),
+}

server/src/impl_from.rs

@@ -0,0 +1,18 @@
+/// Implements 'From' for a list of variants, intended for use with error enums
+/// that are wrapping a number of errors from other methods.
+#[macro_export]
+macro_rules! impl_from {
+    (
+        $enum_name: ident {
+            $($error_type: ty => $variant_name: ident),* $(,)*
+        }
+    ) => {
+        $(
+            impl From<$error_type> for $enum_name {
+                fn from(error: $error_type) -> $enum_name {
+                    $enum_name::$variant_name(error)
+                }
+            }
+        )*
+    }
+}

server/src/lib.rs

@@ -0,0 +1,19 @@
+// Macros
+#[macro_use]
+pub mod impl_from;
+
+// Other modules
+pub mod commands;
+pub mod fs_watcher;
+pub mod imfs;
+pub mod message_queue;
+pub mod path_map;
+pub mod project;
+pub mod rbx_session;
+pub mod rbx_snapshot;
+pub mod live_session;
+pub mod session_id;
+pub mod snapshot_reconciler;
+pub mod visualize;
+pub mod web;
+pub mod web_util;

server/src/live_session.rs

@@ -0,0 +1,62 @@
+use std::{
+    sync::{Arc, Mutex},
+    io,
+};
+
+use crate::{
+    message_queue::MessageQueue,
+    project::Project,
+    imfs::Imfs,
+    session_id::SessionId,
+    rbx_session::RbxSession,
+    snapshot_reconciler::InstanceChanges,
+    fs_watcher::FsWatcher,
+};
+
+/// Contains all of the state for a Rojo live-sync session.
+pub struct LiveSession {
+    pub project: Arc<Project>,
+    pub session_id: SessionId,
+    pub message_queue: Arc<MessageQueue<InstanceChanges>>,
+    pub rbx_session: Arc<Mutex<RbxSession>>,
+    pub imfs: Arc<Mutex<Imfs>>,
+    _fs_watcher: FsWatcher,
+}
+
+impl LiveSession {
+    pub fn new(project: Arc<Project>) -> io::Result<LiveSession> {
+        let imfs = {
+            let mut imfs = Imfs::new();
+            imfs.add_roots_from_project(&project)?;
+
+            Arc::new(Mutex::new(imfs))
+        };
+        let message_queue = Arc::new(MessageQueue::new());
+
+        let rbx_session = Arc::new(Mutex::new(RbxSession::new(
+            Arc::clone(&project),
+            Arc::clone(&imfs),
+            Arc::clone(&message_queue),
+        )));
+
+        let fs_watcher = FsWatcher::start(
+            Arc::clone(&imfs),
+            Arc::clone(&rbx_session),
+        );
+
+        let session_id = SessionId::new();
+
+        Ok(LiveSession {
+            project,
+            session_id,
+            message_queue,
+            rbx_session,
+            imfs,
+            _fs_watcher: fs_watcher,
+        })
+    }
+
+    pub fn get_project(&self) -> &Project {
+        &self.project
+    }
+}

server/src/message_queue.rs

@@ -0,0 +1,83 @@
+use std::{
+    collections::HashMap,
+    sync::{
+        mpsc,
+        atomic::{AtomicUsize, Ordering},
+        RwLock,
+        Mutex,
+    },
+};
+
+/// A unique identifier, not guaranteed to be generated in any order.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ListenerId(usize);
+
+/// Generate a new ID, which has no defined ordering.
+pub fn get_listener_id() -> ListenerId {
+    static LAST_ID: AtomicUsize = AtomicUsize::new(0);
+
+    ListenerId(LAST_ID.fetch_add(1, Ordering::SeqCst))
+}
+
+/// A message queue with persistent history that can be subscribed to.
+///
+/// Definitely non-optimal, but a simple design that works well for the
+/// synchronous web server Rojo uses, Rouille.
+#[derive(Default)]
+pub struct MessageQueue<T> {
+   messages: RwLock<Vec<T>>,
+   message_listeners: Mutex<HashMap<ListenerId, mpsc::Sender<()>>>,
+}
+
+impl<T: Clone> MessageQueue<T> {
+    pub fn new() -> MessageQueue<T> {
+        MessageQueue {
+            messages: RwLock::new(Vec::new()),
+            message_listeners: Mutex::new(HashMap::new()),
+        }
+    }
+
+    pub fn push_messages(&self, new_messages: &[T]) {
+        let message_listeners = self.message_listeners.lock().unwrap();
+
+        {
+            let mut messages = self.messages.write().unwrap();
+            messages.extend_from_slice(new_messages);
+        }
+
+        for listener in message_listeners.values() {
+            listener.send(()).unwrap();
+        }
+    }
+
+    pub fn subscribe(&self, sender: mpsc::Sender<()>) -> ListenerId {
+        let id = get_listener_id();
+
+        let mut message_listeners = self.message_listeners.lock().unwrap();
+        message_listeners.insert(id, sender);
+
+        id
+    }
+
+    pub fn unsubscribe(&self, id: ListenerId) {
+        let mut message_listeners = self.message_listeners.lock().unwrap();
+        message_listeners.remove(&id);
+    }
+
+    pub fn get_message_cursor(&self) -> u32 {
+        self.messages.read().unwrap().len() as u32
+    }
+
+    pub fn get_messages_since(&self, cursor: u32) -> (u32, Vec<T>) {
+        let messages = self.messages.read().unwrap();
+
+        let current_cursor = messages.len() as u32;
+
+        // Cursor is out of bounds or there are no new messages
+        if cursor >= current_cursor {
+            return (current_cursor, Vec::new());
+        }
+
+        (current_cursor, messages[(cursor as usize)..].to_vec())
+    }
+}

server/src/path_map.rs

@@ -0,0 +1,143 @@
+use std::{
+    collections::hash_map,
+    path::{self, Path, PathBuf},
+    collections::{HashMap, HashSet},
+};
+
+use serde_derive::Serialize;
+use log::warn;
+
+#[derive(Debug, Serialize)]
+struct PathMapNode<T> {
+    value: T,
+    children: HashSet<PathBuf>,
+}
+
+/// A map from paths to another type, like instance IDs, with a bit of
+/// additional data that enables removing a path and all of its child paths from
+/// the tree more quickly.
+#[derive(Debug, Serialize)]
+pub struct PathMap<T> {
+    nodes: HashMap<PathBuf, PathMapNode<T>>,
+}
+
+impl<T> PathMap<T> {
+    pub fn new() -> PathMap<T> {
+        PathMap {
+            nodes: HashMap::new(),
+        }
+    }
+
+    pub fn get(&self, path: &Path) -> Option<&T> {
+        self.nodes.get(path).map(|v| &v.value)
+    }
+
+    pub fn get_mut(&mut self, path: &Path) -> Option<&mut T> {
+        self.nodes.get_mut(path).map(|v| &mut v.value)
+    }
+
+    pub fn entry<'a>(&'a mut self, path: PathBuf) -> Entry<'a, T> {
+        Entry {
+            internal: self.nodes.entry(path),
+        }
+    }
+
+    pub fn insert(&mut self, path: PathBuf, value: T) {
+        if let Some(parent_path) = path.parent() {
+            if let Some(parent) = self.nodes.get_mut(parent_path) {
+                parent.children.insert(path.to_path_buf());
+            }
+        }
+
+        self.nodes.insert(path, PathMapNode {
+            value,
+            children: HashSet::new(),
+        });
+    }
+
+    pub fn remove(&mut self, root_path: &Path) -> Option<T> {
+        if let Some(parent_path) = root_path.parent() {
+            if let Some(parent) = self.nodes.get_mut(parent_path) {
+                parent.children.remove(root_path);
+            }
+        }
+
+        let mut root_node = match self.nodes.remove(root_path) {
+            Some(node) => node,
+            None => return None,
+        };
+
+        let root_value = root_node.value;
+        let mut to_visit: Vec<PathBuf> = root_node.children.drain().collect();
+
+        while let Some(path) = to_visit.pop() {
+            match self.nodes.remove(&path) {
+                Some(mut node) => {
+                    for child in node.children.drain() {
+                        to_visit.push(child);
+                    }
+                },
+                None => {
+                    warn!("Consistency issue; tried to remove {} but it was already removed", path.display());
+                },
+            }
+        }
+
+        Some(root_value)
+    }
+
+    /// Traverses the route between `start_path` and `target_path` and returns
+    /// the path closest to `target_path` in the tree.
+    ///
+    /// This is useful when trying to determine what paths need to be marked as
+    /// altered when a change to a path is registered. Depending on the order of
+    /// FS events, a file remove event could be followed by that file's
+    /// directory being removed, in which case we should process that
+    /// directory's parent.
+    pub fn descend(&self, start_path: &Path, target_path: &Path) -> PathBuf {
+        let relative_path = target_path.strip_prefix(start_path)
+            .expect("target_path did not begin with start_path");
+        let mut current_path = start_path.to_path_buf();
+
+        for component in relative_path.components() {
+            match component {
+                path::Component::Normal(name) => {
+                    let next_path = current_path.join(name);
+
+                    if self.nodes.contains_key(&next_path) {
+                        current_path = next_path;
+                    } else {
+                        return current_path;
+                    }
+                },
+                _ => unreachable!(),
+            }
+        }
+
+        current_path
+    }
+}
+
+pub struct Entry<'a, T> {
+    internal: hash_map::Entry<'a, PathBuf, PathMapNode<T>>,
+}
+
+impl<'a, T> Entry<'a, T> {
+    pub fn or_insert(self, value: T) -> &'a mut T {
+        &mut self.internal.or_insert(PathMapNode {
+            value,
+            children: HashSet::new(),
+        }).value
+    }
+}
+
+impl<'a, T> Entry<'a, T>
+    where T: Default
+{
+    pub fn or_default(self) -> &'a mut T {
+        &mut self.internal.or_insert(PathMapNode {
+            value: Default::default(),
+            children: HashSet::new(),
+        }).value
+    }
+}

server/src/project.rs

@@ -0,0 +1,416 @@
+use std::{
+    collections::{HashMap, HashSet},
+    fmt,
+    fs::{self, File},
+    io,
+    path::{Path, PathBuf},
+};
+
+use failure::Fail;
+use maplit::hashmap;
+use rbx_tree::RbxValue;
+use serde_derive::{Serialize, Deserialize};
+
+pub static PROJECT_FILENAME: &'static str = "roblox-project.json";
+
+// Methods used for Serde's default value system, which doesn't support using
+// value literals directly, only functions that return values.
+const fn yeah() -> bool {
+    true
+}
+
+const fn is_true(value: &bool) -> bool {
+    *value
+}
+
+/// SourceProject is the format that users author projects on-disk. Since we
+/// want to do things like transforming paths to be absolute before handing them
+/// off to the rest of Rojo, we use this intermediate struct.
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct SourceProject {
+    name: String,
+    tree: SourceProjectNode,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    serve_port: Option<u16>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    serve_place_ids: Option<HashSet<u64>>,
+}
+
+impl SourceProject {
+    /// Consumes the SourceProject and yields a Project, ready for prime-time.
+    pub fn into_project(self, project_file_location: &Path) -> Project {
+        let tree = self.tree.into_project_node(project_file_location);
+
+        Project {
+            name: self.name,
+            tree,
+            serve_port: self.serve_port,
+            serve_place_ids: self.serve_place_ids,
+            file_location: PathBuf::from(project_file_location),
+        }
+    }
+}
+
+/// Similar to SourceProject, the structure of nodes in the project tree is
+/// slightly different on-disk than how we want to handle them in the rest of
+/// Rojo.
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(untagged)]
+enum SourceProjectNode {
+    Instance {
+        #[serde(rename = "$className")]
+        class_name: String,
+
+        #[serde(rename = "$properties", default = "HashMap::new", skip_serializing_if = "HashMap::is_empty")]
+        properties: HashMap<String, RbxValue>,
+
+        #[serde(rename = "$ignoreUnknownInstances", default = "yeah", skip_serializing_if = "is_true")]
+        ignore_unknown_instances: bool,
+
+        #[serde(flatten)]
+        children: HashMap<String, SourceProjectNode>,
+    },
+    SyncPoint {
+        #[serde(rename = "$path")]
+        path: String,
+    }
+}
+
+impl SourceProjectNode {
+    /// Consumes the SourceProjectNode and turns it into a ProjectNode.
+    pub fn into_project_node(self, project_file_location: &Path) -> ProjectNode {
+        match self {
+            SourceProjectNode::Instance { class_name, mut children, properties, ignore_unknown_instances } => {
+                let mut new_children = HashMap::new();
+
+                for (node_name, node) in children.drain() {
+                    new_children.insert(node_name, node.into_project_node(project_file_location));
+                }
+
+                ProjectNode::Instance(InstanceProjectNode {
+                    class_name,
+                    children: new_children,
+                    properties,
+                    metadata: InstanceProjectNodeMetadata {
+                        ignore_unknown_instances,
+                    },
+                })
+            },
+            SourceProjectNode::SyncPoint { path: source_path } => {
+                let path = if Path::new(&source_path).is_absolute() {
+                    PathBuf::from(source_path)
+                } else {
+                    let project_folder_location = project_file_location.parent().unwrap();
+                    project_folder_location.join(source_path)
+                };
+
+                ProjectNode::SyncPoint(SyncPointProjectNode {
+                    path,
+                })
+            },
+        }
+    }
+}
+
+/// Error returned by Project::load_exact
+#[derive(Debug, Fail)]
+pub enum ProjectLoadExactError {
+    #[fail(display = "IO error: {}", _0)]
+    IoError(#[fail(cause)] io::Error),
+
+    #[fail(display = "JSON error: {}", _0)]
+    JsonError(#[fail(cause)] serde_json::Error),
+}
+
+/// Error returned by Project::load_fuzzy
+#[derive(Debug, Fail)]
+pub enum ProjectLoadFuzzyError {
+    #[fail(display = "Project not found")]
+    NotFound,
+
+    #[fail(display = "IO error: {}", _0)]
+    IoError(#[fail(cause)] io::Error),
+
+    #[fail(display = "JSON error: {}", _0)]
+    JsonError(#[fail(cause)] serde_json::Error),
+}
+
+impl From<ProjectLoadExactError> for ProjectLoadFuzzyError {
+    fn from(error: ProjectLoadExactError) -> ProjectLoadFuzzyError {
+        match error {
+            ProjectLoadExactError::IoError(inner) => ProjectLoadFuzzyError::IoError(inner),
+            ProjectLoadExactError::JsonError(inner) => ProjectLoadFuzzyError::JsonError(inner),
+        }
+    }
+}
+
+/// Error returned by Project::init_place and Project::init_model
+#[derive(Debug, Fail)]
+pub enum ProjectInitError {
+    AlreadyExists(PathBuf),
+    IoError(#[fail(cause)] io::Error),
+    SaveError(#[fail(cause)] ProjectSaveError),
+}
+
+impl fmt::Display for ProjectInitError {
+    fn fmt(&self, output: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ProjectInitError::AlreadyExists(path) => write!(output, "Path {} already exists", path.display()),
+            ProjectInitError::IoError(inner) => write!(output, "IO error: {}", inner),
+            ProjectInitError::SaveError(inner) => write!(output, "{}", inner),
+        }
+    }
+}
+
+/// Error returned by Project::save
+#[derive(Debug, Fail)]
+pub enum ProjectSaveError {
+    #[fail(display = "JSON error: {}", _0)]
+    JsonError(#[fail(cause)] serde_json::Error),
+
+    #[fail(display = "IO error: {}", _0)]
+    IoError(#[fail(cause)] io::Error),
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct InstanceProjectNodeMetadata {
+    pub ignore_unknown_instances: bool,
+}
+
+impl Default for InstanceProjectNodeMetadata {
+    fn default() -> InstanceProjectNodeMetadata {
+        InstanceProjectNodeMetadata {
+            ignore_unknown_instances: true,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum ProjectNode {
+    Instance(InstanceProjectNode),
+    SyncPoint(SyncPointProjectNode),
+}
+
+impl ProjectNode {
+    fn to_source_node(&self, project_file_location: &Path) -> SourceProjectNode {
+        match self {
+            ProjectNode::Instance(node) => {
+                let mut children = HashMap::new();
+
+                for (key, child) in &node.children {
+                    children.insert(key.clone(), child.to_source_node(project_file_location));
+                }
+
+                SourceProjectNode::Instance {
+                    class_name: node.class_name.clone(),
+                    children,
+                    properties: node.properties.clone(),
+                    ignore_unknown_instances: node.metadata.ignore_unknown_instances,
+                }
+            },
+            ProjectNode::SyncPoint(sync_node) => {
+                let project_folder_location = project_file_location.parent().unwrap();
+
+                let friendly_path = match sync_node.path.strip_prefix(project_folder_location) {
+                    Ok(stripped) => stripped.to_str().unwrap().replace("\\", "/"),
+                    Err(_) => format!("{}", sync_node.path.display()),
+                };
+
+                SourceProjectNode::SyncPoint {
+                    path: friendly_path,
+                }
+            },
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct InstanceProjectNode {
+    pub class_name: String,
+    pub children: HashMap<String, ProjectNode>,
+    pub properties: HashMap<String, RbxValue>,
+    pub metadata: InstanceProjectNodeMetadata,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SyncPointProjectNode {
+    pub path: PathBuf,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Project {
+    pub name: String,
+    pub tree: ProjectNode,
+    pub serve_port: Option<u16>,
+    pub serve_place_ids: Option<HashSet<u64>>,
+    pub file_location: PathBuf,
+}
+
+impl Project {
+    pub fn init_place(project_fuzzy_path: &Path) -> Result<PathBuf, ProjectInitError> {
+        let project_path = Project::init_pick_path(project_fuzzy_path)?;
+        let project_folder_path = project_path.parent().unwrap();
+        let project_name = if project_fuzzy_path == project_path {
+            project_fuzzy_path.parent().unwrap().file_name().unwrap().to_str().unwrap()
+        } else {
+            project_fuzzy_path.file_name().unwrap().to_str().unwrap()
+        };
+
+        let tree = ProjectNode::Instance(InstanceProjectNode {
+            class_name: "DataModel".to_string(),
+            children: hashmap! {
+                String::from("ReplicatedStorage") => ProjectNode::Instance(InstanceProjectNode {
+                    class_name: String::from("ReplicatedStorage"),
+                    children: hashmap! {
+                        String::from("Source") => ProjectNode::SyncPoint(SyncPointProjectNode {
+                            path: project_folder_path.join("src"),
+                        }),
+                    },
+                    properties: HashMap::new(),
+                    metadata: Default::default(),
+                }),
+                String::from("HttpService") => ProjectNode::Instance(InstanceProjectNode {
+                    class_name: String::from("HttpService"),
+                    children: HashMap::new(),
+                    properties: hashmap! {
+                        String::from("HttpEnabled") => RbxValue::Bool {
+                            value: true,
+                        },
+                    },
+                    metadata: Default::default(),
+                }),
+            },
+            properties: HashMap::new(),
+            metadata: Default::default(),
+        });
+
+        let project = Project {
+            name: project_name.to_string(),
+            tree,
+            serve_port: None,
+            serve_place_ids: None,
+            file_location: project_path.clone(),
+        };
+
+        project.save()
+            .map_err(ProjectInitError::SaveError)?;
+
+        Ok(project_path)
+    }
+
+    pub fn init_model(project_fuzzy_path: &Path) -> Result<PathBuf, ProjectInitError> {
+        let project_path = Project::init_pick_path(project_fuzzy_path)?;
+        let project_folder_path = project_path.parent().unwrap();
+        let project_name = if project_fuzzy_path == project_path {
+            project_fuzzy_path.parent().unwrap().file_name().unwrap().to_str().unwrap()
+        } else {
+            project_fuzzy_path.file_name().unwrap().to_str().unwrap()
+        };
+
+        let tree = ProjectNode::SyncPoint(SyncPointProjectNode {
+            path: project_folder_path.join("src"),
+        });
+
+        let project = Project {
+            name: project_name.to_string(),
+            tree,
+            serve_port: None,
+            serve_place_ids: None,
+            file_location: project_path.clone(),
+        };
+
+        project.save()
+            .map_err(ProjectInitError::SaveError)?;
+
+        Ok(project_path)
+    }
+
+    fn init_pick_path(project_fuzzy_path: &Path) -> Result<PathBuf, ProjectInitError> {
+        let is_exact = project_fuzzy_path.extension().is_some();
+
+        let project_path = if is_exact {
+            project_fuzzy_path.to_path_buf()
+        } else {
+            project_fuzzy_path.join(PROJECT_FILENAME)
+        };
+
+        match fs::metadata(&project_path) {
+            Err(error) => match error.kind() {
+                io::ErrorKind::NotFound => {},
+                _ => return Err(ProjectInitError::IoError(error)),
+            },
+            Ok(_) => return Err(ProjectInitError::AlreadyExists(project_path)),
+        }
+
+        Ok(project_path)
+    }
+
+    pub fn locate(start_location: &Path) -> Option<PathBuf> {
+        // TODO: Check for specific error kinds, convert 'not found' to Result.
+        let location_metadata = fs::metadata(start_location).ok()?;
+
+        // If this is a file, assume it's the config the user was looking for.
+        if location_metadata.is_file() {
+            return Some(start_location.to_path_buf());
+        } else if location_metadata.is_dir() {
+            let with_file = start_location.join(PROJECT_FILENAME);
+
+            if let Ok(with_file_metadata) = fs::metadata(&with_file) {
+                if with_file_metadata.is_file() {
+                    return Some(with_file);
+                } else {
+                    return None;
+                }
+            }
+        }
+
+        match start_location.parent() {
+            Some(parent_location) => Self::locate(parent_location),
+            None => None,
+        }
+    }
+
+    pub fn load_fuzzy(fuzzy_project_location: &Path) -> Result<Project, ProjectLoadFuzzyError> {
+        let project_path = Self::locate(fuzzy_project_location)
+            .ok_or(ProjectLoadFuzzyError::NotFound)?;
+
+        Self::load_exact(&project_path).map_err(From::from)
+    }
+
+    pub fn load_exact(project_file_location: &Path) -> Result<Project, ProjectLoadExactError> {
+        let contents = fs::read_to_string(project_file_location)
+            .map_err(ProjectLoadExactError::IoError)?;
+
+        let parsed: SourceProject = serde_json::from_str(&contents)
+            .map_err(ProjectLoadExactError::JsonError)?;
+
+        Ok(parsed.into_project(project_file_location))
+    }
+
+    pub fn save(&self) -> Result<(), ProjectSaveError> {
+        let source_project = self.to_source_project();
+        let mut file = File::create(&self.file_location)
+            .map_err(ProjectSaveError::IoError)?;
+
+        serde_json::to_writer_pretty(&mut file, &source_project)
+            .map_err(ProjectSaveError::JsonError)?;
+
+        Ok(())
+    }
+
+    fn to_source_project(&self) -> SourceProject {
+        SourceProject {
+            name: self.name.clone(),
+            tree: self.tree.to_source_node(&self.file_location),
+            serve_port: self.serve_port,
+            serve_place_ids: self.serve_place_ids.clone(),
+        }
+    }
+}