Release 6.0.0-rc.1

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

.gitmodules

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

CHANGELOG.md

@@ -1,6 +1,10 @@
 # Rojo Changelog
 
-## Unreleased Changes for 0.6.x
+## Unreleased Changes
+
+## [6.0.0 Release Candidate 1](https://github.com/rojo-rbx/rojo/releases/tag/v6.0.0-rc.1) (March 29, 2020)
+This release jumped from 0.6.0 to 6.0.0. Rojo has been in use in production for many users for quite a long times, and so 6.0 is a more accurate reflection of Rojo's version than a pre-1.0 version.
+
 * Added basic settings panel to plugin, with two settings:
     * "Open Scripts Externally": When enabled, opening a script in Studio will instead open it in your default text editor.
     * "Two-Way Sync": When enabled, Rojo will attempt to save changes to your place back to the filesystem. **Very early feature, very broken, beware!**

Cargo.lock

@@ -1083,7 +1083,7 @@ dependencies = [
 
 [[package]]
 name = "memofs"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "crossbeam-channel",
  "fs-err",
@@ -1923,7 +1923,7 @@ dependencies = [
 
 [[package]]
 name = "rojo"
-version = "0.6.0-alpha.3"
+version = "6.0.0-rc.1"
 dependencies = [
  "anyhow",
  "backtrace",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rojo"
-version = "0.6.0-alpha.3"
+version = "6.0.0-rc.1"
 authors = ["Lucien Greathouse <me@lpghatguy.com>"]
 description = "Enables professional-grade development tools for Roblox developers"
 license = "MPL-2.0"
@@ -11,7 +11,6 @@ readme = "README.md"
 edition = "2018"
 
 exclude = [
-    "/plugin/**",
     "/test-projects/**",
 ]
 
@@ -58,7 +57,7 @@ name = "build"
 harness = false
 
 [dependencies]
-memofs = { version = "0.1.1", path = "memofs" }
+memofs = { version = "0.1.2", path = "memofs" }
 
 anyhow = "1.0.27"
 backtrace = "0.3"
@@ -102,6 +101,7 @@ memofs = { version = "0.1.0", path = "memofs" }
 
 anyhow = "1.0.27"
 bincode = "1.2.1"
+fs-err = "2.3.0"
 maplit = "1.0.1"
 
 [dev-dependencies]

README.md

@@ -14,7 +14,7 @@
         <img src="https://img.shields.io/crates/v/rojo.svg?label=latest%20release" alt="Latest server version" />
     </a>
     <a href="https://rojo.space/docs">
-        <img src="https://img.shields.io/badge/docs-website-brightgreen.svg" alt="Rojo 0.5.x Documentation" />
+        <img src="https://img.shields.io/badge/docs-website-brightgreen.svg" alt="Rojo Documentation" />
     </a>
 </div>
 

build.rs

@@ -1,10 +1,10 @@
 use std::{
-    env,
-    fs::{self, File},
-    io,
+    env, io,
     path::{Path, PathBuf},
 };
 
+use fs_err as fs;
+use fs_err::File;
 use maplit::hashmap;
 use memofs::VfsSnapshot;
 
@@ -50,6 +50,7 @@ fn main() -> Result<(), anyhow::Error> {
         "fmt" => snapshot_from_fs_path(&plugin_root.join("fmt"))?,
         "http" => snapshot_from_fs_path(&plugin_root.join("http"))?,
         "log" => snapshot_from_fs_path(&plugin_root.join("log"))?,
+        "rbx_dom_lua" => snapshot_from_fs_path(&plugin_root.join("rbx_dom_lua"))?,
         "src" => snapshot_from_fs_path(&plugin_root.join("src"))?,
         "modules" => VfsSnapshot::dir(hashmap! {
             "roact" => VfsSnapshot::dir(hashmap! {
@@ -61,11 +62,6 @@ fn main() -> Result<(), anyhow::Error> {
             "t" => VfsSnapshot::dir(hashmap! {
                 "lib" => snapshot_from_fs_path(&plugin_modules.join("t").join("lib"))?
             }),
-            "rbx-dom" => VfsSnapshot::dir(hashmap! {
-                "rbx_dom_lua" => VfsSnapshot::dir(hashmap! {
-                    "src" => snapshot_from_fs_path(&plugin_modules.join("rbx-dom").join("rbx_dom_lua").join("src"))?
-                })
-            }),
         }),
     });
 

memofs/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "memofs"
 description = "Virtual filesystem with configurable backends."
-version = "0.1.1"
+version = "0.1.2"
 authors = ["Lucien Greathouse <me@lpghatguy.com>"]
 edition = "2018"
 readme = "README.md"

plugin/default.project.json

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

plugin/rbx_dom_lua/.luacheckrc

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

plugin/rbx_dom_lua/README.md

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

plugin/rbx_dom_lua/default.project.json

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

plugin/rbx_dom_lua/src/EncodedValue.lua

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

plugin/rbx_dom_lua/src/EncodedValue.spec.lua

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

plugin/rbx_dom_lua/src/Error.lua

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

plugin/rbx_dom_lua/src/PropertyDescriptor.lua

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

plugin/rbx_dom_lua/src/ReflectionDatabase/init.lua

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

plugin/rbx_dom_lua/src/base64.lua

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

plugin/rbx_dom_lua/src/base64.spec.lua

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

plugin/rbx_dom_lua/src/customProperties.lua

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

plugin/rbx_dom_lua/src/init.lua

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

plugin/rbx_dom_lua/src/init.spec.lua

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

plugin/rbx_dom_lua/test-place.project.json

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

plugin/rbx_dom_lua/test.server.lua

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

plugin/src/Config.lua

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