Fix --git-since not detecting first file change in filtered directories

The VFS only sets up file watches via read() and read_dir(), not metadata(). When git filtering caused snapshot_from_vfs to return early for $path directories, read_dir was never called, so no file watch was established. This meant file modifications never generated VFS events and were silently ignored until the server was restarted. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Fix --git-since live sync not detecting changes and creating duplicates
2026-02-13 18:04:27 +01:00 · 2026-02-13 16:19:01 +01:00 · 2026-02-13 14:11:17 +01:00 · 2026-02-13 13:09:30 +00:00 · 2026-02-12 19:17:28 -08:00 · 2026-02-12 18:37:24 -08:00
73 changed files with 1465 additions and 210 deletions
--- a/.gitmodules
+++ b/.gitmodules
@@ -16,3 +16,6 @@
 [submodule "plugin/Packages/Highlighter"]
 	path = plugin/Packages/Highlighter
 	url = https://github.com/boatbomber/highlighter.git
+[submodule "plugin/Packages/msgpack-luau"]
+	path = plugin/Packages/msgpack-luau
+	url = https://github.com/cipharius/msgpack-luau/
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,13 +30,26 @@ Making a new release? Simply add the new header with the version and date undern
 -->

 ## Unreleased
-* Fixed a bug caused by having reference properties (such as `ObjectValue.Value`) that point to an Instance not included in syncback. ([#1179])
-* Fixed instance replacement fallback failing when too many instances needed to be replaced. ([#1192])
-* Fixed a bug where MacOS paths weren't being handled correctly. ([#1201])

+* `inf` and `nan` values in properties are now synced ([#1176])
+* Fixed a bug caused by having reference properties (such as `ObjectValue.Value`) that point to an Instance not included in syncback. ([#1179])
+* Implemented support for the "name" property in meta/model JSON files. ([#1187])
+* Fixed instance replacement fallback failing when too many instances needed to be replaced. ([#1192])
+* Added actors and bindable/remote event/function variants to be synced back as JSON files. ([#1199])
+* Fixed a bug where MacOS paths weren't being handled correctly. ([#1201])
+* Fixed a bug where the notification timeout thread would fail to cancel on unmount ([#1211])
+* Added a "Forget" option to the sync reminder notification to avoid being reminded for that place in the future ([#1215])
+* Improves relative path calculation for sourcemap generation to avoid issues with Windows UNC paths. ([#1217])
+
+[#1176]: https://github.com/rojo-rbx/rojo/pull/1176
 [#1179]: https://github.com/rojo-rbx/rojo/pull/1179
+[#1187]: https://github.com/rojo-rbx/rojo/pull/1187
 [#1192]: https://github.com/rojo-rbx/rojo/pull/1192
+[#1199]: https://github.com/rojo-rbx/rojo/pull/1199
 [#1201]: https://github.com/rojo-rbx/rojo/pull/1201
+[#1211]: https://github.com/rojo-rbx/rojo/pull/1211
+[#1215]: https://github.com/rojo-rbx/rojo/pull/1215
+[#1217]: https://github.com/rojo-rbx/rojo/pull/1217

 ## [7.7.0-rc.1] (November 27th, 2025)

--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -14,6 +14,7 @@ Code contributions are welcome for features and bugs that have been reported in
 You'll want these tools to work on Rojo:

 * Latest stable Rust compiler
+  * Rustfmt and Clippy are used for code formatting and linting.
 * Latest stable [Rojo](https://github.com/rojo-rbx/rojo)
 * [Rokit](https://github.com/rojo-rbx/rokit)
 * [Luau Language Server](https://github.com/JohnnyMorganz/luau-lsp) (Only needed if working on the Studio plugin.)
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1520,6 +1520,12 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"

+[[package]]
+name = "pathdiff"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
+
 [[package]]
 name = "percent-encoding"
 version = "2.3.2"
@@ -2068,6 +2074,7 @@ dependencies = [
 "num_cpus",
 "opener",
 "paste",
+ "pathdiff",
 "pretty_assertions",
 "profiling",
 "rayon",
@@ -2078,10 +2085,12 @@ dependencies = [
 "rbx_xml",
 "reqwest",
 "ritz",
+ "rmp-serde",
 "roblox_install",
 "rojo-insta-ext",
 "semver",
 "serde",
+ "serde_bytes",
 "serde_json",
 "serde_yaml",
 "strum",
@@ -2222,6 +2231,16 @@ dependencies = [
 "serde_derive",
 ]

+[[package]]
+name = "serde_bytes"
+version = "0.11.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
 [[package]]
 name = "serde_cbor"
 version = "0.11.2"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -100,10 +100,13 @@ clap = { version = "3.2.25", features = ["derive"] }
 profiling = "1.0.15"
 yaml-rust2 = "0.10.3"
 data-encoding = "2.8.0"
+pathdiff = "0.2.3"

 blake3 = "1.5.0"
 float-cmp = "0.9.0"
 indexmap = { version = "2.10.0", features = ["serde"] }
+rmp-serde = "1.3.0"
+serde_bytes = "0.11.19"

 [target.'cfg(windows)'.dependencies]
 winreg = "0.10.1"
@@ -122,7 +125,7 @@ semver = "1.0.22"
 rojo-insta-ext = { path = "crates/rojo-insta-ext" }

 criterion = "0.3.6"
-insta = { version = "1.36.1", features = ["redactions", "yaml"] }
+insta = { version = "1.36.1", features = ["redactions", "yaml", "json"] }
 paste = "1.0.14"
 pretty_assertions = "1.4.0"
 serde_yaml = "0.8.26"
--- a/build.rs
+++ b/build.rs
@@ -30,6 +30,11 @@ fn snapshot_from_fs_path(path: &Path) -> io::Result<VfsSnapshot> {
                continue;
            }

+            // Ignore images in msgpack-luau because they aren't UTF-8 encoded.
+            if file_name.ends_with(".png") {
+                continue;
+            }
+
            let child_snapshot = snapshot_from_fs_path(&entry.path())?;
            children.push((file_name, child_snapshot));
        }
--- a/plugin/Packages/msgpack-luau
+++ b/plugin/Packages/msgpack-luau
--- a/plugin/http/Response.lua
+++ b/plugin/http/Response.lua
@@ -1,5 +1,7 @@
 local HttpService = game:GetService("HttpService")

+local msgpack = require(script.Parent.Parent.msgpack)
+
 local stringTemplate = [[
 Http.Response {
 	code: %d
@@ -31,4 +33,8 @@ function Response:json()
 	return HttpService:JSONDecode(self.body)
 end

+function Response:msgpack()
+	return msgpack.decode(self.body)
+end
+
 return Response
--- a/plugin/http/init.lua
+++ b/plugin/http/init.lua
@@ -1,7 +1,8 @@
 local HttpService = game:GetService("HttpService")

-local Promise = require(script.Parent.Promise)
 local Log = require(script.Parent.Log)
+local msgpack = require(script.Parent.msgpack)
+local Promise = require(script.Parent.Promise)

 local HttpError = require(script.Error)
 local HttpResponse = require(script.Response)
@@ -68,4 +69,12 @@ function Http.jsonDecode(source)
 	return HttpService:JSONDecode(source)
 end

+function Http.msgpackEncode(object)
+	return msgpack.encode(object)
+end
+
+function Http.msgpackDecode(source)
+	return msgpack.decode(source)
+end
+
 return Http
--- a/plugin/src/ApiContext.lua
+++ b/plugin/src/ApiContext.lua
@@ -145,7 +145,7 @@ function ApiContext:connect()

 	return Http.get(url)
 		:andThen(rejectFailedRequests)
-		:andThen(Http.Response.json)
+		:andThen(Http.Response.msgpack)
 		:andThen(rejectWrongProtocolVersion)
 		:andThen(function(body)
 			assert(validateApiInfo(body))
@@ -163,7 +163,7 @@ end
 function ApiContext:read(ids)
 	local url = ("%s/api/read/%s"):format(self.__baseUrl, table.concat(ids, ","))

-	return Http.get(url):andThen(rejectFailedRequests):andThen(Http.Response.json):andThen(function(body)
+	return Http.get(url):andThen(rejectFailedRequests):andThen(Http.Response.msgpack):andThen(function(body)
 		if body.sessionId ~= self.__sessionId then
 			return Promise.reject("Server changed ID")
 		end
@@ -191,9 +191,9 @@ function ApiContext:write(patch)
 		table.insert(updated, fixedUpdate)
 	end

-	-- Only add the 'added' field if the table is non-empty, or else Roblox's
-	-- JSON implementation will turn the table into an array instead of an
-	-- object, causing API validation to fail.
+	-- Only add the 'added' field if the table is non-empty, or else the msgpack
+	-- encode implementation will turn the table into an array instead of a map,
+	-- causing API validation to fail.
 	local added
 	if next(patch.added) ~= nil then
 		added = patch.added
@@ -206,13 +206,16 @@ function ApiContext:write(patch)
 		added = added,
 	}

-	body = Http.jsonEncode(body)
+	body = Http.msgpackEncode(body)

-	return Http.post(url, body):andThen(rejectFailedRequests):andThen(Http.Response.json):andThen(function(responseBody)
-		Log.info("Write response: {:?}", responseBody)
+	return Http.post(url, body)
+		:andThen(rejectFailedRequests)
+		:andThen(Http.Response.msgpack)
+		:andThen(function(responseBody)
+			Log.info("Write response: {:?}", responseBody)

-		return responseBody
-	end)
+			return responseBody
+		end)
 end

 function ApiContext:connectWebSocket(packetHandlers)
@@ -234,7 +237,7 @@ function ApiContext:connectWebSocket(packetHandlers)
 		local closed, errored, received

 		received = self.__wsClient.MessageReceived:Connect(function(msg)
-			local data = Http.jsonDecode(msg)
+			local data = Http.msgpackDecode(msg)
 			if data.sessionId ~= self.__sessionId then
 				Log.warn("Received message with wrong session ID; ignoring")
 				return
@@ -280,7 +283,7 @@ end
 function ApiContext:open(id)
 	local url = ("%s/api/open/%s"):format(self.__baseUrl, id)

-	return Http.post(url, ""):andThen(rejectFailedRequests):andThen(Http.Response.json):andThen(function(body)
+	return Http.post(url, ""):andThen(rejectFailedRequests):andThen(Http.Response.msgpack):andThen(function(body)
 		if body.sessionId ~= self.__sessionId then
 			return Promise.reject("Server changed ID")
 		end
@@ -291,11 +294,11 @@ end

 function ApiContext:serialize(ids: { string })
 	local url = ("%s/api/serialize"):format(self.__baseUrl)
-	local request_body = Http.jsonEncode({ sessionId = self.__sessionId, ids = ids })
+	local request_body = Http.msgpackEncode({ sessionId = self.__sessionId, ids = ids })

 	return Http.post(url, request_body)
 		:andThen(rejectFailedRequests)
-		:andThen(Http.Response.json)
+		:andThen(Http.Response.msgpack)
 		:andThen(function(response_body)
 			if response_body.sessionId ~= self.__sessionId then
 				return Promise.reject("Server changed ID")
@@ -309,11 +312,11 @@ end

 function ApiContext:refPatch(ids: { string })
 	local url = ("%s/api/ref-patch"):format(self.__baseUrl)
-	local request_body = Http.jsonEncode({ sessionId = self.__sessionId, ids = ids })
+	local request_body = Http.msgpackEncode({ sessionId = self.__sessionId, ids = ids })

 	return Http.post(url, request_body)
 		:andThen(rejectFailedRequests)
-		:andThen(Http.Response.json)
+		:andThen(Http.Response.msgpack)
 		:andThen(function(response_body)
 			if response_body.sessionId ~= self.__sessionId then
 				return Promise.reject("Server changed ID")
--- a/plugin/src/App/Components/Notifications/FullscreenNotification.lua
+++ b/plugin/src/App/Components/Notifications/FullscreenNotification.lua
@@ -19,9 +19,15 @@ local FullscreenNotification = Roact.Component:extend("FullscreeFullscreenNotifi
 function FullscreenNotification:init()
 	self.transparency, self.setTransparency = Roact.createBinding(0)
 	self.lifetime = self.props.timeout
+	self.dismissed = false
 end

 function FullscreenNotification:dismiss()
+	if self.dismissed then
+		return
+	end
+	self.dismissed = true
+
 	if self.props.onClose then
 		self.props.onClose()
 	end
@@ -59,7 +65,7 @@ function FullscreenNotification:didMount()
 end

 function FullscreenNotification:willUnmount()
-	if self.timeout and coroutine.status(self.timeout) ~= "dead" then
+	if self.timeout and coroutine.status(self.timeout) == "suspended" then
 		task.cancel(self.timeout)
 	end
 end
--- a/plugin/src/App/Components/Notifications/Notification.lua
+++ b/plugin/src/App/Components/Notifications/Notification.lua
@@ -25,6 +25,7 @@ function Notification:init()
 	self.binding = bindingUtil.fromMotor(self.motor)

 	self.lifetime = self.props.timeout
+	self.dismissed = false

 	self.motor:onStep(function(value)
 		if value <= 0 and self.props.onClose then
@@ -34,6 +35,11 @@ function Notification:init()
 end

 function Notification:dismiss()
+	if self.dismissed then
+		return
+	end
+	self.dismissed = true
+
 	self.motor:setGoal(Flipper.Spring.new(0, {
 		frequency = 5,
 		dampingRatio = 1,
@@ -75,7 +81,7 @@ function Notification:didMount()
 end

 function Notification:willUnmount()
-	if self.timeout and coroutine.status(self.timeout) ~= "dead" then
+	if self.timeout and coroutine.status(self.timeout) == "suspended" then
 		task.cancel(self.timeout)
 	end
 end
--- a/plugin/src/App/init.lua
+++ b/plugin/src/App/init.lua
@@ -301,6 +301,19 @@ function App:setPriorSyncInfo(host: string, port: string, projectName: string)
 	Settings:set("priorEndpoints", priorSyncInfos)
 end

+function App:forgetPriorSyncInfo()
+	local priorSyncInfos = Settings:get("priorEndpoints")
+	if not priorSyncInfos then
+		priorSyncInfos = {}
+	end
+
+	local id = tostring(game.PlaceId)
+	priorSyncInfos[id] = nil
+	Log.trace("Erased last used endpoint for {}", game.PlaceId)
+
+	Settings:set("priorEndpoints", priorSyncInfos)
+end
+
 function App:getHostAndPort()
 	local host = self.host:getValue()
 	local port = self.port:getValue()
@@ -435,7 +448,8 @@ function App:checkSyncReminder()
 	self:findActiveServer()
 		:andThen(function(serverInfo, host, port)
 			self:sendSyncReminder(
-				`Project '{serverInfo.projectName}' is serving at {host}:{port}.\nWould you like to connect?`
+				`Project '{serverInfo.projectName}' is serving at {host}:{port}.\nWould you like to connect?`,
+				{ "Connect", "Dismiss" }
 			)
 		end)
 		:catch(function()
@@ -446,7 +460,8 @@ function App:checkSyncReminder()

 				local timeSinceSync = timeUtil.elapsedToText(os.time() - priorSyncInfo.timestamp)
 				self:sendSyncReminder(
-					`You synced project '{priorSyncInfo.projectName}' to this place {timeSinceSync}.\nDid you mean to run 'rojo serve' and then connect?`
+					`You synced project '{priorSyncInfo.projectName}' to this place {timeSinceSync}.\nDid you mean to run 'rojo serve' and then connect?`,
+					{ "Connect", "Forget", "Dismiss" }
 				)
 			end
 		end)
@@ -486,12 +501,16 @@ function App:stopSyncReminderPolling()
 	end
 end

-function App:sendSyncReminder(message: string)
+function App:sendSyncReminder(message: string, shownActions: { string })
 	local syncReminderMode = Settings:get("syncReminderMode")
 	if syncReminderMode == "None" then
 		return
 	end

+	local connectIndex = table.find(shownActions, "Connect")
+	local forgetIndex = table.find(shownActions, "Forget")
+	local dismissIndex = table.find(shownActions, "Dismiss")
+
 	self.dismissSyncReminder = self:addNotification({
 		text = message,
 		timeout = 120,
@@ -500,24 +519,39 @@ function App:sendSyncReminder(message: string)
 			self.dismissSyncReminder = nil
 		end,
 		actions = {
-			Connect = {
-				text = "Connect",
-				style = "Solid",
-				layoutOrder = 1,
-				onClick = function()
-					self:startSession()
-				end,
-			},
-			Dismiss = {
-				text = "Dismiss",
-				style = "Bordered",
-				layoutOrder = 2,
-				onClick = function()
-					-- If the user dismisses the reminder,
-					-- then we don't need to remind them again
-					self:stopSyncReminderPolling()
-				end,
-			},
+			Connect = if connectIndex
+				then {
+					text = "Connect",
+					style = "Solid",
+					layoutOrder = connectIndex,
+					onClick = function()
+						self:startSession()
+					end,
+				}
+				else nil,
+			Forget = if forgetIndex
+				then {
+					text = "Forget",
+					style = "Bordered",
+					layoutOrder = forgetIndex,
+					onClick = function()
+						-- The user doesn't want to be reminded again about this sync
+						self:forgetPriorSyncInfo()
+					end,
+				}
+				else nil,
+			Dismiss = if dismissIndex
+				then {
+					text = "Dismiss",
+					style = "Bordered",
+					layoutOrder = dismissIndex,
+					onClick = function()
+						-- If the user dismisses the reminder,
+						-- then we don't need to remind them again
+						self:stopSyncReminderPolling()
+					end,
+				}
+				else nil,
 		},
 	})
 end
--- a/plugin/src/Reconciler/diff.lua
+++ b/plugin/src/Reconciler/diff.lua
@@ -54,6 +54,10 @@ local function trueEquals(a, b): boolean
 		end
 		return true

+	-- For NaN, check if both values are not equal to themselves
+	elseif a ~= a and b ~= b then
+		return true
+
 	-- For numbers, compare with epsilon of 0.0001 to avoid floating point inequality
 	elseif typeA == "number" and typeB == "number" then
 		return fuzzyEq(a, b, 0.0001)
--- a/plugin/src/Reconciler/reify.lua
+++ b/plugin/src/Reconciler/reify.lua
@@ -41,14 +41,41 @@ function reifyInstanceInner(unappliedPatch, deferredRefs, instanceMap, virtualIn
 		invariant("Cannot reify an instance not present in virtualInstances\nID: {}", id)
 	end

-	-- Instance.new can fail if we're passing in something that can't be
-	-- created, like a service, something enabled with a feature flag, or
-	-- something that requires higher security than we have.
-	local createSuccess, instance = pcall(Instance.new, virtualInstance.ClassName)
+	-- Before creating a new instance, check if the parent already has an
+	-- untracked child with the same Name and ClassName. This enables "late
+	-- adoption" of instances that exist in Studio but weren't in the initial
+	-- Rojo tree (e.g., when using --git-since filtering). Without this,
+	-- newly acknowledged files would create duplicate instances.
+	local adoptedExisting = false
+	local instance = nil

-	if not createSuccess then
-		addAllToPatch(unappliedPatch, virtualInstances, id)
-		return
+	for _, child in ipairs(parentInstance:GetChildren()) do
+		local accessSuccess, name, className = pcall(function()
+			return child.Name, child.ClassName
+		end)
+
+		if accessSuccess
+			and name == virtualInstance.Name
+			and className == virtualInstance.ClassName
+			and instanceMap.fromInstances[child] == nil
+		then
+			instance = child
+			adoptedExisting = true
+			break
+		end
+	end
+
+	if not adoptedExisting then
+		-- Instance.new can fail if we're passing in something that can't be
+		-- created, like a service, something enabled with a feature flag, or
+		-- something that requires higher security than we have.
+		local createSuccess
+		createSuccess, instance = pcall(Instance.new, virtualInstance.ClassName)
+
+		if not createSuccess then
+			addAllToPatch(unappliedPatch, virtualInstances, id)
+			return
+		end
 	end

 	-- TODO: Can this fail? Previous versions of Rojo guarded against this, but
@@ -96,7 +123,9 @@ function reifyInstanceInner(unappliedPatch, deferredRefs, instanceMap, virtualIn
 		reifyInstanceInner(unappliedPatch, deferredRefs, instanceMap, virtualInstances, childId, instance)
 	end

-	instance.Parent = parentInstance
+	if not adoptedExisting then
+		instance.Parent = parentInstance
+	end
 	instanceMap:insert(id, instance)
 end

--- a/rojo-test/build-test-snapshots/end_to_endtestsbuild__json_model_legacy_name.snap
+++ b/rojo-test/build-test-snapshots/end_to_endtestsbuild__json_model_legacy_name.snap
@@ -1,16 +0,0 @@
---
-source: tests/tests/build.rs
-expression: contents
---
-<roblox version="4">
-  <Item class="Folder" referent="0">
-    <Properties>
-      <string name="Name">json_model_legacy_name</string>
-    </Properties>
-    <Item class="Folder" referent="1">
-      <Properties>
-        <string name="Name">Expected Name</string>
-      </Properties>
-    </Item>
-  </Item>
-</roblox>
--- a/rojo-test/build-test-snapshots/end_to_endtestsbuild__model_json_name_input.snap
+++ b/rojo-test/build-test-snapshots/end_to_endtestsbuild__model_json_name_input.snap
@@ -0,0 +1,23 @@
+---
+source: tests/tests/build.rs
+assertion_line: 109
+expression: contents
+---
+<roblox version="4">
+  <Item class="DataModel" referent="0">
+    <Properties>
+      <string name="Name">model_json_name_input</string>
+    </Properties>
+    <Item class="Workspace" referent="1">
+      <Properties>
+        <string name="Name">Workspace</string>
+        <bool name="NeedsPivotMigration">false</bool>
+      </Properties>
+      <Item class="StringValue" referent="2">
+        <Properties>
+          <string name="Name">/Bar</string>
+        </Properties>
+      </Item>
+    </Item>
+  </Item>
+</roblox>
--- a/rojo-test/build-test-snapshots/end_to_endtestsbuild__slugified_name_roundtrip.snap
+++ b/rojo-test/build-test-snapshots/end_to_endtestsbuild__slugified_name_roundtrip.snap
@@ -0,0 +1,20 @@
+---
+source: tests/tests/build.rs
+assertion_line: 108
+expression: contents
+---
+<roblox version="4">
+  <Item class="Folder" referent="0">
+    <Properties>
+      <string name="Name">slugified_name_roundtrip</string>
+    </Properties>
+    <Item class="Script" referent="1">
+      <Properties>
+        <string name="Name">/Script</string>
+        <token name="RunContext">0</token>
+        <string name="Source"><![CDATA[print("Hello world!")
+]]></string>
+      </Properties>
+    </Item>
+  </Item>
+</roblox>
--- a/rojo-test/build-tests/json_model_legacy_name/default.project.json
+++ b/rojo-test/build-tests/json_model_legacy_name/default.project.json
@@ -1,6 +0,0 @@
-{
-  "name": "json_model_legacy_name",
-  "tree": {
-    "$path": "folder"
-  }
-}
--- a/rojo-test/build-tests/json_model_legacy_name/folder/Expected
+++ b/rojo-test/build-tests/json_model_legacy_name/folder/Expected
@@ -1,4 +0,0 @@
-{
-  "Name": "Overridden Name",
-  "ClassName": "Folder"
-}
--- a/rojo-test/build-tests/model_json_name_input/default.project.json
+++ b/rojo-test/build-tests/model_json_name_input/default.project.json
@@ -0,0 +1,11 @@
+{
+  "name": "model_json_name_input",
+  "tree": {
+    "$className": "DataModel",
+    "Workspace": {
+      "$className": "Workspace",
+      "$path": "src"
+    }
+  }
+}
+
--- a/rojo-test/build-tests/model_json_name_input/src/Bar.model.json
+++ b/rojo-test/build-tests/model_json_name_input/src/Bar.model.json
@@ -0,0 +1,5 @@
+{
+  "name": "/Bar",
+  "className": "StringValue"
+}
+
--- a/rojo-test/build-tests/slugified_name_roundtrip/_Script/init.meta.json
+++ b/rojo-test/build-tests/slugified_name_roundtrip/_Script/init.meta.json
@@ -0,0 +1,4 @@
+{
+  "name": "/Script"
+}
+
--- a/rojo-test/build-tests/slugified_name_roundtrip/_Script/init.server.luau
+++ b/rojo-test/build-tests/slugified_name_roundtrip/_Script/init.server.luau
@@ -0,0 +1,2 @@
+print("Hello world!")
+
--- a/rojo-test/build-tests/slugified_name_roundtrip/default.project.json
+++ b/rojo-test/build-tests/slugified_name_roundtrip/default.project.json
@@ -0,0 +1,6 @@
+{
+  "name": "slugified_name_roundtrip",
+  "tree": {
+    "$path": "src"
+  }
+}
--- a/rojo-test/build-tests/slugified_name_roundtrip/src/_Script/init.meta.json
+++ b/rojo-test/build-tests/slugified_name_roundtrip/src/_Script/init.meta.json
@@ -0,0 +1,3 @@
+{
+  "name": "/Script"
+}
--- a/rojo-test/build-tests/slugified_name_roundtrip/src/_Script/init.server.luau
+++ b/rojo-test/build-tests/slugified_name_roundtrip/src/_Script/init.server.luau
@@ -0,0 +1 @@
+print("Hello world!")
--- a/rojo-test/syncback-test-snapshots/end_to_end__rojo_test__syncback_util__model_json_name-stdout.snap
+++ b/rojo-test/syncback-test-snapshots/end_to_end__rojo_test__syncback_util__model_json_name-stdout.snap
@@ -0,0 +1,6 @@
+---
+source: tests/rojo_test/syncback_util.rs
+assertion_line: 101
+expression: "String::from_utf8_lossy(&output.stdout)"
+---
+
--- a/rojo-test/syncback-test-snapshots/end_to_end__rojo_test__syncback_util__slugified_name-stdout.snap
+++ b/rojo-test/syncback-test-snapshots/end_to_end__rojo_test__syncback_util__slugified_name-stdout.snap
@@ -0,0 +1,13 @@
+---
+source: tests/rojo_test/syncback_util.rs
+assertion_line: 101
+expression: "String::from_utf8_lossy(&output.stdout)"
+---
+Writing default.project.json
+Writing src/Camera.rbxm
+Writing src/Terrain.rbxm
+Writing src/_Folder/init.meta.json
+Writing src/_Script.meta.json
+Writing src/_Script.server.luau
+Writing src
+Writing src/_Folder
--- a/rojo-test/syncback-test-snapshots/end_to_endtestssyncback__model_json_name-src__foo.model.json.snap
+++ b/rojo-test/syncback-test-snapshots/end_to_endtestssyncback__model_json_name-src__foo.model.json.snap
@@ -0,0 +1,9 @@
+---
+source: tests/tests/syncback.rs
+assertion_line: 31
+expression: src/foo.model.json
+---
+{
+  "name": "/Bar",
+  "className": "StringValue"
+}
--- a/rojo-test/syncback-test-snapshots/end_to_endtestssyncback__slugified_name-src___Folder.model.json.snap
+++ b/rojo-test/syncback-test-snapshots/end_to_endtestssyncback__slugified_name-src___Folder.model.json.snap
@@ -0,0 +1,8 @@
+---
+source: tests/tests/syncback.rs
+assertion_line: 31
+expression: src/_Folder.model.json
+---
+{
+  "className": "Folder"
+}
--- a/rojo-test/syncback-test-snapshots/end_to_endtestssyncback__slugified_name-src_Folderinit.meta.json.snap
+++ b/rojo-test/syncback-test-snapshots/end_to_endtestssyncback__slugified_name-src_Folderinit.meta.json.snap
@@ -0,0 +1,8 @@
+---
+source: tests/tests/syncback.rs
+assertion_line: 31
+expression: src/_Folder/init.meta.json
+---
+{
+  "name": "/Folder"
+}
--- a/rojo-test/syncback-test-snapshots/end_to_endtestssyncback__slugified_name-src___Script.meta.json.snap
+++ b/rojo-test/syncback-test-snapshots/end_to_endtestssyncback__slugified_name-src___Script.meta.json.snap
@@ -0,0 +1,8 @@
+---
+source: tests/tests/syncback.rs
+assertion_line: 31
+expression: src/_Script.meta.json
+---
+{
+  "name": "/Script"
+}
--- a/rojo-test/syncback-test-snapshots/end_to_endtestssyncback__slugified_name-src___Script.server.luau.snap
+++ b/rojo-test/syncback-test-snapshots/end_to_endtestssyncback__slugified_name-src___Script.server.luau.snap
@@ -0,0 +1,6 @@
+---
+source: tests/tests/syncback.rs
+assertion_line: 31
+expression: src/_Script.server.luau
+---
+print("Hello world!")
--- a/rojo-test/syncback-test-snapshots/end_to_endtestssyncback__slugified_name-src_Scriptinit.meta.json.snap
+++ b/rojo-test/syncback-test-snapshots/end_to_endtestssyncback__slugified_name-src_Scriptinit.meta.json.snap
@@ -0,0 +1,8 @@
+---
+source: tests/tests/syncback.rs
+assertion_line: 31
+expression: src/_Script/init.meta.json
+---
+{
+  "name": "/Script"
+}
--- a/rojo-test/syncback-test-snapshots/end_to_endtestssyncback__slugified_name-src_Scriptinit.server.luau.snap
+++ b/rojo-test/syncback-test-snapshots/end_to_endtestssyncback__slugified_name-src_Scriptinit.server.luau.snap
@@ -0,0 +1,6 @@
+---
+source: tests/tests/syncback.rs
+assertion_line: 31
+expression: src/_Script/init.server.luau
+---
+print("Hello world!")
--- a/rojo-test/syncback-tests/model_json_name/input-project/default.project.json
+++ b/rojo-test/syncback-tests/model_json_name/input-project/default.project.json
@@ -0,0 +1,11 @@
+{
+  "name": "model_json_name",
+  "tree": {
+    "$className": "DataModel",
+    "Workspace": {
+      "$className": "Workspace",
+      "$path": "src"
+    }
+  }
+}
+
--- a/rojo-test/syncback-tests/model_json_name/input-project/src/foo.model.json
+++ b/rojo-test/syncback-tests/model_json_name/input-project/src/foo.model.json
@@ -0,0 +1,5 @@
+{
+  "name": "/Bar",
+  "className": "StringValue"
+}
+
--- a/rojo-test/syncback-tests/model_json_name/input.rbxl
+++ b/rojo-test/syncback-tests/model_json_name/input.rbxl
--- a/rojo-test/syncback-tests/slugified_name/input-project/default.project.json
+++ b/rojo-test/syncback-tests/slugified_name/input-project/default.project.json
@@ -0,0 +1,10 @@
+{
+  "name": "slugified_name",
+  "tree": {
+    "$className": "DataModel",
+    "Workspace": {
+      "$className": "Workspace",
+      "$path": "src"
+    }
+  }
+}
--- a/rojo-test/syncback-tests/slugified_name/input-project/src/.gitkeep
+++ b/rojo-test/syncback-tests/slugified_name/input-project/src/.gitkeep
--- a/rojo-test/syncback-tests/slugified_name/input.rbxl
+++ b/rojo-test/syncback-tests/slugified_name/input.rbxl
--- a/src/change_processor.rs
+++ b/src/change_processor.rs
@@ -9,6 +9,7 @@ use std::{
 };

 use crate::{
+    git::SharedGitFilter,
    message_queue::MessageQueue,
    snapshot::{
        apply_patch_set, compute_patch_set, AppliedPatchSet, InstigatingSource, PatchSet, RojoTree,
@@ -46,11 +47,15 @@ pub struct ChangeProcessor {
 impl ChangeProcessor {
    /// Spin up the ChangeProcessor, connecting it to the given tree, VFS, and
    /// outbound message queue.
+    ///
+    /// If `git_filter` is provided, it will be refreshed on every VFS event
+    /// to ensure newly changed files are acknowledged.
    pub fn start(
        tree: Arc<Mutex<RojoTree>>,
        vfs: Arc<Vfs>,
        message_queue: Arc<MessageQueue<AppliedPatchSet>>,
        tree_mutation_receiver: Receiver<PatchSet>,
+        git_filter: Option<SharedGitFilter>,
    ) -> Self {
        let (shutdown_sender, shutdown_receiver) = crossbeam_channel::bounded(1);
        let vfs_receiver = vfs.event_receiver();
@@ -58,6 +63,7 @@ impl ChangeProcessor {
            tree,
            vfs,
            message_queue,
+            git_filter,
        };

        let job_thread = jod_thread::Builder::new()
@@ -111,6 +117,10 @@ struct JobThreadContext {
    /// Whenever changes are applied to the DOM, we should push those changes
    /// into this message queue to inform any connected clients.
    message_queue: Arc<MessageQueue<AppliedPatchSet>>,
+
+    /// Optional Git filter for --git-since mode. When set, will be refreshed
+    /// on every VFS event to ensure newly changed files are acknowledged.
+    git_filter: Option<SharedGitFilter>,
 }

 impl JobThreadContext {
@@ -160,6 +170,14 @@ impl JobThreadContext {
    fn handle_vfs_event(&self, event: VfsEvent) {
        log::trace!("Vfs event: {:?}", event);

+        // If we have a git filter, refresh it to pick up any new changes.
+        // This ensures that files modified during the session will be acknowledged.
+        if let Some(ref git_filter) = self.git_filter {
+            if let Err(err) = git_filter.refresh() {
+                log::warn!("Failed to refresh git filter: {:?}", err);
+            }
+        }
+
        // Update the VFS immediately with the event.
        self.vfs
            .commit_event(&event)
--- a/src/cli/build.rs
+++ b/src/cli/build.rs
@@ -81,7 +81,7 @@ impl BuildCommand {
        let vfs = Vfs::new_default();
        vfs.set_watch_enabled(self.watch);

-        let session = ServeSession::new(vfs, project_path)?;
+        let session = ServeSession::new(vfs, project_path, None)?;
        let mut cursor = session.message_queue().cursor();

        write_model(&session, &output_path, output_kind)?;
--- a/src/cli/plugin.rs
+++ b/src/cli/plugin.rs
@@ -54,7 +54,7 @@ fn initialize_plugin() -> anyhow::Result<ServeSession> {
    in_memory_fs.load_snapshot("/plugin", plugin_snapshot)?;

    let vfs = Vfs::new(in_memory_fs);
-    Ok(ServeSession::new(vfs, "/plugin")?)
+    Ok(ServeSession::new(vfs, "/plugin", None)?)
 }

 fn install_plugin() -> anyhow::Result<()> {
--- a/src/cli/serve.rs
+++ b/src/cli/serve.rs
@@ -9,7 +9,7 @@ use clap::Parser;
 use memofs::Vfs;
 use termcolor::{BufferWriter, Color, ColorChoice, ColorSpec, WriteColor};

-use crate::{serve_session::ServeSession, web::LiveServer};
+use crate::{git::GitFilter, serve_session::ServeSession, web::LiveServer};

 use super::{resolve_path, GlobalOptions};

@@ -31,6 +31,19 @@ pub struct ServeCommand {
    /// it has none.
    #[clap(long)]
    pub port: Option<u16>,
+
+    /// Only sync files that have changed since the given Git reference.
+    ///
+    /// When this option is set, Rojo will only include files that have been
+    /// modified, added, or are untracked since the specified Git reference
+    /// (e.g., "HEAD", "main", a commit hash). This is useful for working with
+    /// large projects where you only want to sync your local changes.
+    ///
+    /// Scripts that have not changed will still be acknowledged if modified
+    /// during the session, and all synced instances will have
+    /// ignoreUnknownInstances set to true to preserve descendants in Studio.
+    #[clap(long, value_name = "REF")]
+    pub git_since: Option<String>,
 }

 impl ServeCommand {
@@ -39,7 +52,19 @@ impl ServeCommand {

        let vfs = Vfs::new_default();

-        let session = Arc::new(ServeSession::new(vfs, project_path)?);
+        // Set up Git filter if --git-since was specified
+        let git_filter = if let Some(ref base_ref) = self.git_since {
+            let repo_root = GitFilter::find_repo_root(&project_path)?;
+            log::info!(
+                "Git filter enabled: only syncing files changed since '{}'",
+                base_ref
+            );
+            Some(Arc::new(GitFilter::new(repo_root, base_ref.clone(), &project_path)?))
+        } else {
+            None
+        };
+
+        let session = Arc::new(ServeSession::new(vfs, project_path, git_filter)?);

        let ip = self
            .address
@@ -53,17 +78,25 @@ impl ServeCommand {

        let server = LiveServer::new(session);

-        let _ = show_start_message(ip, port, global.color.into());
+        let _ = show_start_message(ip, port, self.git_since.as_deref(), global.color.into());
        server.start((ip, port).into());

        Ok(())
    }
 }

-fn show_start_message(bind_address: IpAddr, port: u16, color: ColorChoice) -> io::Result<()> {
+fn show_start_message(
+    bind_address: IpAddr,
+    port: u16,
+    git_since: Option<&str>,
+    color: ColorChoice,
+) -> io::Result<()> {
    let mut green = ColorSpec::new();
    green.set_fg(Some(Color::Green)).set_bold(true);

+    let mut yellow = ColorSpec::new();
+    yellow.set_fg(Some(Color::Yellow)).set_bold(true);
+
    let writer = BufferWriter::stdout(color);
    let mut buffer = writer.buffer();

@@ -84,6 +117,13 @@ fn show_start_message(bind_address: IpAddr, port: u16, color: ColorChoice) -> io
    buffer.set_color(&green)?;
    writeln!(&mut buffer, "{}", port)?;

+    if let Some(base_ref) = git_since {
+        buffer.set_color(&ColorSpec::new())?;
+        write!(&mut buffer, "  Mode:    ")?;
+        buffer.set_color(&yellow)?;
+        writeln!(&mut buffer, "git-since ({})", base_ref)?;
+    }
+
    writeln!(&mut buffer)?;

    buffer.set_color(&ColorSpec::new())?;
--- a/src/cli/snapshots/librojoclisourcemaptestmaps_absolute_paths.snap
+++ b/src/cli/snapshots/librojoclisourcemaptestmaps_absolute_paths.snap
@@ -0,0 +1,35 @@
+---
+source: src/cli/sourcemap.rs
+expression: sourcemap_contents
+---
+{
+  "name": "default",
+  "className": "DataModel",
+  "filePaths": "[...1 path omitted...]",
+  "children": [
+    {
+      "name": "ReplicatedStorage",
+      "className": "ReplicatedStorage",
+      "children": [
+        {
+          "name": "Project",
+          "className": "ModuleScript",
+          "filePaths": "[...1 path omitted...]",
+          "children": [
+            {
+              "name": "Module",
+              "className": "Folder",
+              "children": [
+                {
+                  "name": "module",
+                  "className": "ModuleScript",
+                  "filePaths": "[...1 path omitted...]"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
--- a/src/cli/snapshots/librojoclisourcemaptestmaps_relative_paths.snap
+++ b/src/cli/snapshots/librojoclisourcemaptestmaps_relative_paths.snap
@@ -0,0 +1,41 @@
+---
+source: src/cli/sourcemap.rs
+expression: sourcemap_contents
+---
+{
+  "name": "default",
+  "className": "DataModel",
+  "filePaths": [
+    "default.project.json"
+  ],
+  "children": [
+    {
+      "name": "ReplicatedStorage",
+      "className": "ReplicatedStorage",
+      "children": [
+        {
+          "name": "Project",
+          "className": "ModuleScript",
+          "filePaths": [
+            "src/init.luau"
+          ],
+          "children": [
+            {
+              "name": "Module",
+              "className": "Folder",
+              "children": [
+                {
+                  "name": "module",
+                  "className": "ModuleScript",
+                  "filePaths": [
+                    "../module/module.luau"
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
--- a/src/cli/sourcemap.rs
+++ b/src/cli/sourcemap.rs
@@ -10,7 +10,7 @@ use fs_err::File;
 use memofs::Vfs;
 use rayon::prelude::*;
 use rbx_dom_weak::{types::Ref, Ustr};
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use tokio::runtime::Runtime;

 use crate::{
@@ -24,19 +24,20 @@ const PATH_STRIP_FAILED_ERR: &str = "Failed to create relative paths for project
 const ABSOLUTE_PATH_FAILED_ERR: &str = "Failed to turn relative path into absolute path!";

 /// Representation of a node in the generated sourcemap tree.
-#[derive(Serialize)]
+#[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct SourcemapNode<'a> {
    name: &'a str,
    class_name: Ustr,

    #[serde(
+        default,
        skip_serializing_if = "Vec::is_empty",
        serialize_with = "crate::path_serializer::serialize_vec_absolute"
    )]
    file_paths: Vec<Cow<'a, Path>>,

-    #[serde(skip_serializing_if = "Vec::is_empty")]
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    children: Vec<SourcemapNode<'a>>,
 }

@@ -70,13 +71,14 @@ pub struct SourcemapCommand {

 impl SourcemapCommand {
    pub fn run(self) -> anyhow::Result<()> {
-        let project_path = resolve_path(&self.project);
+        let project_path = fs_err::canonicalize(resolve_path(&self.project))?;

-        log::trace!("Constructing in-memory filesystem");
+        log::trace!("Constructing filesystem with StdBackend");
        let vfs = Vfs::new_default();
        vfs.set_watch_enabled(self.watch);

-        let session = ServeSession::new(vfs, project_path)?;
+        log::trace!("Setting up session for sourcemap generation");
+        let session = ServeSession::new(vfs, project_path, None)?;
        let mut cursor = session.message_queue().cursor();

        let filter = if self.include_non_scripts {
@@ -87,14 +89,17 @@ impl SourcemapCommand {

        // Pre-build a rayon threadpool with a low number of threads to avoid
        // dynamic creation overhead on systems with a high number of cpus.
+        log::trace!("Setting rayon global threadpool");
        rayon::ThreadPoolBuilder::new()
            .num_threads(num_cpus::get().min(6))
            .build_global()
-            .unwrap();
+            .ok();

+        log::trace!("Writing initial sourcemap");
        write_sourcemap(&session, self.output.as_deref(), filter, self.absolute)?;

        if self.watch {
+            log::trace!("Setting up runtime for watch mode");
            let rt = Runtime::new().unwrap();

            loop {
@@ -208,7 +213,7 @@ fn recurse_create_node<'a>(
    } else {
        for val in file_paths {
            output_file_paths.push(Cow::from(
-                val.strip_prefix(project_dir).expect(PATH_STRIP_FAILED_ERR),
+                pathdiff::diff_paths(val, project_dir).expect(PATH_STRIP_FAILED_ERR),
            ));
        }
    };
@@ -250,3 +255,80 @@ fn write_sourcemap(

    Ok(())
 }
+
+#[cfg(test)]
+mod test {
+    use crate::cli::sourcemap::SourcemapNode;
+    use crate::cli::SourcemapCommand;
+    use insta::internals::Content;
+    use std::path::Path;
+
+    #[test]
+    fn maps_relative_paths() {
+        let sourcemap_dir = tempfile::tempdir().unwrap();
+        let sourcemap_output = sourcemap_dir.path().join("sourcemap.json");
+        let project_path = fs_err::canonicalize(
+            Path::new(env!("CARGO_MANIFEST_DIR"))
+                .join("test-projects")
+                .join("relative_paths")
+                .join("project"),
+        )
+        .unwrap();
+        let sourcemap_command = SourcemapCommand {
+            project: project_path,
+            output: Some(sourcemap_output.clone()),
+            include_non_scripts: false,
+            watch: false,
+            absolute: false,
+        };
+        assert!(sourcemap_command.run().is_ok());
+
+        let raw_sourcemap_contents = fs_err::read_to_string(sourcemap_output.as_path()).unwrap();
+        let sourcemap_contents =
+            serde_json::from_str::<SourcemapNode>(&raw_sourcemap_contents).unwrap();
+        insta::assert_json_snapshot!(sourcemap_contents);
+    }
+
+    #[test]
+    fn maps_absolute_paths() {
+        let sourcemap_dir = tempfile::tempdir().unwrap();
+        let sourcemap_output = sourcemap_dir.path().join("sourcemap.json");
+        let project_path = fs_err::canonicalize(
+            Path::new(env!("CARGO_MANIFEST_DIR"))
+                .join("test-projects")
+                .join("relative_paths")
+                .join("project"),
+        )
+        .unwrap();
+        let sourcemap_command = SourcemapCommand {
+            project: project_path,
+            output: Some(sourcemap_output.clone()),
+            include_non_scripts: false,
+            watch: false,
+            absolute: true,
+        };
+        assert!(sourcemap_command.run().is_ok());
+
+        let raw_sourcemap_contents = fs_err::read_to_string(sourcemap_output.as_path()).unwrap();
+        let sourcemap_contents =
+            serde_json::from_str::<SourcemapNode>(&raw_sourcemap_contents).unwrap();
+        insta::assert_json_snapshot!(sourcemap_contents, {
+            ".**.filePaths" => insta::dynamic_redaction(|mut value, _path| {
+                let mut paths_count = 0;
+
+                match value {
+                    Content::Seq(ref mut vec) => {
+                        for path in vec.iter().map(|i| i.as_str().unwrap()) {
+                            assert_eq!(fs_err::canonicalize(path).is_ok(), true, "path was not valid");
+                            assert_eq!(Path::new(path).is_absolute(), true, "path was not absolute");
+
+                            paths_count += 1;
+                        }
+                    }
+                    _ => panic!("Expected filePaths to be a sequence"),
+                }
+                format!("[...{} path{} omitted...]", paths_count, if paths_count != 1 { "s" } else { "" } )
+            })
+        });
+    }
+}
--- a/src/cli/syncback.rs
+++ b/src/cli/syncback.rs
@@ -73,7 +73,7 @@ impl SyncbackCommand {
        vfs.set_watch_enabled(false);

        let project_start_timer = Instant::now();
-        let session_old = ServeSession::new(vfs, path_old.clone())?;
+        let session_old = ServeSession::new(vfs, path_old.clone(), None)?;
        log::debug!(
            "Finished opening project in {:0.02}s",
            project_start_timer.elapsed().as_secs_f32()
--- a/src/cli/upload.rs
+++ b/src/cli/upload.rs
@@ -42,7 +42,7 @@ impl UploadCommand {

        let vfs = Vfs::new_default();

-        let session = ServeSession::new(vfs, project_path)?;
+        let session = ServeSession::new(vfs, project_path, None)?;

        let tree = session.tree();
        let inner_tree = tree.inner();
--- a/src/git.rs
+++ b/src/git.rs
@@ -0,0 +1,380 @@
+//! Git integration for filtering files based on changes since a reference.
+
+use std::{
+    collections::HashSet,
+    path::{Path, PathBuf},
+    process::Command,
+    sync::{Arc, RwLock},
+};
+
+use anyhow::{bail, Context};
+
+/// A filter that tracks which files have been changed since a Git reference.
+///
+/// When active, only files that have been modified, added, or deleted according
+/// to Git will be "acknowledged" and synced to Studio. This allows users to
+/// work with large projects where they only want to sync their local changes.
+///
+/// Once a file is acknowledged (either initially or during the session), it
+/// stays acknowledged for the entire session. This prevents files from being
+/// deleted in Studio if their content is reverted to match the git reference.
+#[derive(Debug)]
+pub struct GitFilter {
+    /// The Git repository root directory.
+    repo_root: PathBuf,
+
+    /// The Git reference to compare against (e.g., "HEAD", "main", a commit hash).
+    base_ref: String,
+
+    /// Cache of paths that are currently different from the base ref according to git.
+    /// This is refreshed on every VFS event.
+    git_changed_paths: RwLock<HashSet<PathBuf>>,
+
+    /// Paths that have been acknowledged at any point during this session.
+    /// Once a path is added here, it stays acknowledged forever (for this session).
+    /// This prevents files from being deleted if their content is reverted.
+    session_acknowledged_paths: RwLock<HashSet<PathBuf>>,
+}
+
+impl GitFilter {
+    /// Creates a new GitFilter for the given repository root and base reference.
+    ///
+    /// The `repo_root` should be the root of the Git repository (where .git is located).
+    /// The `base_ref` is the Git reference to compare against (e.g., "HEAD", "main").
+    /// The `project_path` is the path to the project being served - it will always be
+    /// acknowledged regardless of git status to ensure the project structure exists.
+    pub fn new(repo_root: PathBuf, base_ref: String, project_path: &Path) -> anyhow::Result<Self> {
+        let filter = Self {
+            repo_root,
+            base_ref,
+            git_changed_paths: RwLock::new(HashSet::new()),
+            session_acknowledged_paths: RwLock::new(HashSet::new()),
+        };
+
+        // Always acknowledge the project path and its directory so the project
+        // structure exists even when there are no git changes
+        filter.acknowledge_project_path(project_path);
+
+        // Initial refresh to populate the cache with git changes
+        filter.refresh()?;
+
+        Ok(filter)
+    }
+
+    /// Acknowledges the project path and its containing directory.
+    /// This ensures the project structure always exists regardless of git status.
+    fn acknowledge_project_path(&self, project_path: &Path) {
+        let mut session = self.session_acknowledged_paths.write().unwrap();
+
+        // Acknowledge the project path itself (might be a directory or .project.json file)
+        let canonical = project_path.canonicalize().unwrap_or_else(|_| project_path.to_path_buf());
+        session.insert(canonical.clone());
+
+        // Acknowledge all ancestor directories
+        let mut current = canonical.parent();
+        while let Some(parent) = current {
+            session.insert(parent.to_path_buf());
+            current = parent.parent();
+        }
+
+        // If it's a directory, also acknowledge default.project.json inside it
+        if project_path.is_dir() {
+            for name in &["default.project.json", "default.project.jsonc"] {
+                let project_file = project_path.join(name);
+                if let Ok(canonical_file) = project_file.canonicalize() {
+                    session.insert(canonical_file);
+                } else {
+                    session.insert(project_file);
+                }
+            }
+        }
+
+        // If it's a .project.json file, also acknowledge its parent directory
+        if let Some(parent) = project_path.parent() {
+            let parent_canonical = parent.canonicalize().unwrap_or_else(|_| parent.to_path_buf());
+            session.insert(parent_canonical);
+        }
+
+        log::debug!(
+            "GitFilter: acknowledged project path {} ({} paths total)",
+            project_path.display(),
+            session.len()
+        );
+    }
+
+    /// Finds the Git repository root for the given path.
+    pub fn find_repo_root(path: &Path) -> anyhow::Result<PathBuf> {
+        let output = Command::new("git")
+            .args(["rev-parse", "--show-toplevel"])
+            .current_dir(path)
+            .output()
+            .context("Failed to execute git rev-parse")?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            bail!("Failed to find Git repository root: {}", stderr.trim());
+        }
+
+        let root = String::from_utf8_lossy(&output.stdout)
+            .trim()
+            .to_string();
+
+        Ok(PathBuf::from(root))
+    }
+
+    /// Refreshes the cache of acknowledged paths by querying Git.
+    ///
+    /// This should be called when files change to ensure newly modified files
+    /// are properly acknowledged. Once a path is acknowledged, it stays
+    /// acknowledged for the entire session (even if the file is reverted).
+    pub fn refresh(&self) -> anyhow::Result<()> {
+        let mut git_changed = HashSet::new();
+
+        // Get files changed since the base ref (modified, added, deleted)
+        let diff_output = Command::new("git")
+            .args(["diff", "--name-only", &self.base_ref])
+            .current_dir(&self.repo_root)
+            .output()
+            .context("Failed to execute git diff")?;
+
+        if !diff_output.status.success() {
+            let stderr = String::from_utf8_lossy(&diff_output.stderr);
+            bail!("git diff failed: {}", stderr.trim());
+        }
+
+        let diff_files = String::from_utf8_lossy(&diff_output.stdout);
+        let diff_count = diff_files.lines().filter(|l| !l.is_empty()).count();
+        if diff_count > 0 {
+            log::debug!("git diff found {} changed files", diff_count);
+        }
+        for line in diff_files.lines() {
+            if !line.is_empty() {
+                let path = self.repo_root.join(line);
+                log::trace!("git diff: acknowledging {}", path.display());
+                self.acknowledge_path(&path, &mut git_changed);
+            }
+        }
+
+        // Get untracked files (new files not yet committed)
+        let untracked_output = Command::new("git")
+            .args(["ls-files", "--others", "--exclude-standard"])
+            .current_dir(&self.repo_root)
+            .output()
+            .context("Failed to execute git ls-files")?;
+
+        if !untracked_output.status.success() {
+            let stderr = String::from_utf8_lossy(&untracked_output.stderr);
+            bail!("git ls-files failed: {}", stderr.trim());
+        }
+
+        let untracked_files = String::from_utf8_lossy(&untracked_output.stdout);
+        for line in untracked_files.lines() {
+            if !line.is_empty() {
+                let path = self.repo_root.join(line);
+                self.acknowledge_path(&path, &mut git_changed);
+            }
+        }
+
+        // Get staged files (files added to index but not yet committed)
+        let staged_output = Command::new("git")
+            .args(["diff", "--name-only", "--cached", &self.base_ref])
+            .current_dir(&self.repo_root)
+            .output()
+            .context("Failed to execute git diff --cached")?;
+
+        if staged_output.status.success() {
+            let staged_files = String::from_utf8_lossy(&staged_output.stdout);
+            for line in staged_files.lines() {
+                if !line.is_empty() {
+                    let path = self.repo_root.join(line);
+                    self.acknowledge_path(&path, &mut git_changed);
+                }
+            }
+        }
+
+        // Update the git changed paths cache
+        {
+            let mut cache = self.git_changed_paths.write().unwrap();
+            *cache = git_changed.clone();
+        }
+
+        // Merge newly changed paths into session acknowledged paths
+        // Once acknowledged, a path stays acknowledged for the entire session
+        {
+            let mut session = self.session_acknowledged_paths.write().unwrap();
+            for path in git_changed {
+                session.insert(path);
+            }
+            log::debug!(
+                "GitFilter refreshed: {} paths acknowledged in session",
+                session.len()
+            );
+        }
+
+        Ok(())
+    }
+
+    /// Acknowledges a path and all its ancestors, plus associated meta files.
+    fn acknowledge_path(&self, path: &Path, acknowledged: &mut HashSet<PathBuf>) {
+        // Canonicalize the path if possible, otherwise use as-is
+        let path = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
+
+        // Add the path itself
+        acknowledged.insert(path.clone());
+
+        // Add all ancestor directories
+        let mut current = path.parent();
+        while let Some(parent) = current {
+            acknowledged.insert(parent.to_path_buf());
+            current = parent.parent();
+        }
+
+        // Add associated meta files
+        self.acknowledge_meta_files(&path, acknowledged);
+    }
+
+    /// Acknowledges associated meta files for a given path.
+    fn acknowledge_meta_files(&self, path: &Path, acknowledged: &mut HashSet<PathBuf>) {
+        if let Some(file_name) = path.file_name().and_then(|n| n.to_str()) {
+            if let Some(parent) = path.parent() {
+                // For a file like "foo.lua", also acknowledge "foo.meta.json"
+                // Strip known extensions to get the base name
+                let base_name = strip_lua_extension(file_name);
+
+                let meta_path = parent.join(format!("{}.meta.json", base_name));
+                if let Ok(canonical) = meta_path.canonicalize() {
+                    acknowledged.insert(canonical);
+                } else {
+                    acknowledged.insert(meta_path);
+                }
+
+                // For init files, also acknowledge "init.meta.json" in the same directory
+                if file_name.starts_with("init.") {
+                    let init_meta = parent.join("init.meta.json");
+                    if let Ok(canonical) = init_meta.canonicalize() {
+                        acknowledged.insert(canonical);
+                    } else {
+                        acknowledged.insert(init_meta);
+                    }
+                }
+            }
+        }
+    }
+
+    /// Checks if a path is acknowledged (should be synced).
+    ///
+    /// Returns `true` if the path or any of its descendants have been changed
+    /// at any point during this session. Once a file is acknowledged, it stays
+    /// acknowledged even if its content is reverted to match the git reference.
+    pub fn is_acknowledged(&self, path: &Path) -> bool {
+        let session = self.session_acknowledged_paths.read().unwrap();
+
+        // Try to canonicalize the path
+        let canonical = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
+
+        // Check if this exact path is acknowledged
+        if session.contains(&canonical) {
+            log::trace!("Path {} is directly acknowledged", path.display());
+            return true;
+        }
+
+        // Also check without canonicalization in case of path differences
+        if session.contains(path) {
+            log::trace!("Path {} is acknowledged (non-canonical)", path.display());
+            return true;
+        }
+
+        // For directories, check if any descendant is acknowledged
+        // This is done by checking if any acknowledged path starts with this path
+        for acknowledged in session.iter() {
+            if acknowledged.starts_with(&canonical) {
+                log::trace!(
+                    "Path {} has acknowledged descendant {}",
+                    path.display(),
+                    acknowledged.display()
+                );
+                return true;
+            }
+            // Also check non-canonical
+            if acknowledged.starts_with(path) {
+                log::trace!(
+                    "Path {} has acknowledged descendant {} (non-canonical)",
+                    path.display(),
+                    acknowledged.display()
+                );
+                return true;
+            }
+        }
+
+        log::trace!(
+            "Path {} is NOT acknowledged (canonical: {})",
+            path.display(),
+            canonical.display()
+        );
+        false
+    }
+
+    /// Returns the base reference being compared against.
+    pub fn base_ref(&self) -> &str {
+        &self.base_ref
+    }
+
+    /// Returns the repository root path.
+    pub fn repo_root(&self) -> &Path {
+        &self.repo_root
+    }
+
+    /// Explicitly acknowledges a path and all its ancestors.
+    /// This is useful for ensuring certain paths are always synced regardless of git status.
+    pub fn force_acknowledge(&self, path: &Path) {
+        let mut acknowledged = HashSet::new();
+        self.acknowledge_path(path, &mut acknowledged);
+
+        let mut session = self.session_acknowledged_paths.write().unwrap();
+        for p in acknowledged {
+            session.insert(p);
+        }
+    }
+}
+
+/// Strips Lua-related extensions from a file name to get the base name.
+fn strip_lua_extension(file_name: &str) -> &str {
+    const EXTENSIONS: &[&str] = &[
+        ".server.luau",
+        ".server.lua",
+        ".client.luau",
+        ".client.lua",
+        ".luau",
+        ".lua",
+    ];
+
+    for ext in EXTENSIONS {
+        if let Some(base) = file_name.strip_suffix(ext) {
+            return base;
+        }
+    }
+
+    // If no Lua extension, try to strip the regular extension
+    file_name
+        .rsplit_once('.')
+        .map(|(base, _)| base)
+        .unwrap_or(file_name)
+}
+
+/// A wrapper around GitFilter that can be shared across threads.
+pub type SharedGitFilter = Arc<GitFilter>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_strip_lua_extension() {
+        assert_eq!(strip_lua_extension("foo.server.lua"), "foo");
+        assert_eq!(strip_lua_extension("foo.client.luau"), "foo");
+        assert_eq!(strip_lua_extension("foo.lua"), "foo");
+        assert_eq!(strip_lua_extension("init.server.lua"), "init");
+        assert_eq!(strip_lua_extension("bar.txt"), "bar");
+        assert_eq!(strip_lua_extension("noextension"), "noextension");
+    }
+}
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -9,6 +9,7 @@ mod tree_view;

 mod auth_cookie;
 mod change_processor;
+mod git;
 mod glob;
 mod json;
 mod lua_ast;
@@ -28,6 +29,7 @@ mod web;

 // TODO: Work out what we should expose publicly

+pub use git::{GitFilter, SharedGitFilter};
 pub use project::*;
 pub use rojo_ref::*;
 pub use session_id::SessionId;
--- a/src/serve_session.rs
+++ b/src/serve_session.rs
@@ -13,6 +13,7 @@ use thiserror::Error;

 use crate::{
    change_processor::ChangeProcessor,
+    git::SharedGitFilter,
    message_queue::MessageQueue,
    project::{Project, ProjectError},
    session_id::SessionId,
@@ -94,7 +95,14 @@ impl ServeSession {
    /// The project file is expected to be loaded out-of-band since it's
    /// currently loaded from the filesystem directly instead of through the
    /// in-memory filesystem layer.
-    pub fn new<P: AsRef<Path>>(vfs: Vfs, start_path: P) -> Result<Self, ServeSessionError> {
+    ///
+    /// If `git_filter` is provided, only files that have changed since the
+    /// specified Git reference will be synced.
+    pub fn new<P: AsRef<Path>>(
+        vfs: Vfs,
+        start_path: P,
+        git_filter: Option<SharedGitFilter>,
+    ) -> Result<Self, ServeSessionError> {
        let start_path = start_path.as_ref();
        let start_time = Instant::now();

@@ -102,12 +110,28 @@ impl ServeSession {

        let root_project = Project::load_initial_project(&vfs, start_path)?;

+        // If git filter is active, ensure the project file location is acknowledged
+        // This is necessary so the project structure exists even with no git changes
+        if let Some(ref filter) = git_filter {
+            filter.force_acknowledge(start_path);
+            filter.force_acknowledge(&root_project.file_location);
+            filter.force_acknowledge(root_project.folder_location());
+            log::debug!(
+                "Force acknowledged project at {}",
+                root_project.file_location.display()
+            );
+        }
+
        let mut tree = RojoTree::new(InstanceSnapshot::new());

        let root_id = tree.get_root_id();

-        let instance_context =
-            InstanceContext::with_emit_legacy_scripts(root_project.emit_legacy_scripts);
+        let instance_context = match &git_filter {
+            Some(filter) => {
+                InstanceContext::with_git_filter(root_project.emit_legacy_scripts, Arc::clone(filter))
+            }
+            None => InstanceContext::with_emit_legacy_scripts(root_project.emit_legacy_scripts),
+        };

        log::trace!("Generating snapshot of instances from VFS");
        let snapshot = snapshot_from_vfs(&instance_context, &vfs, start_path)?;
@@ -133,6 +157,7 @@ impl ServeSession {
            Arc::clone(&vfs),
            Arc::clone(&message_queue),
            tree_mutation_receiver,
+            git_filter,
        );

        Ok(Self {
--- a/src/snapshot/metadata.rs
+++ b/src/snapshot/metadata.rs
@@ -8,6 +8,7 @@ use anyhow::Context;
 use serde::{Deserialize, Serialize};

 use crate::{
+    git::SharedGitFilter,
    glob::Glob,
    path_serializer,
    project::ProjectNode,
@@ -70,6 +71,12 @@ pub struct InstanceMetadata {
    /// A schema provided via a JSON file, if one exists. Will be `None` for
    /// all non-JSON middleware.
    pub schema: Option<String>,
+
+    /// A custom name specified via meta.json or model.json files. If present,
+    /// this name will be used for the instance while the filesystem name will
+    /// be slugified to remove illegal characters.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub specified_name: Option<String>,
 }

 impl InstanceMetadata {
@@ -82,6 +89,7 @@ impl InstanceMetadata {
            specified_id: None,
            middleware: None,
            schema: None,
+            specified_name: None,
        }
    }

@@ -130,6 +138,13 @@ impl InstanceMetadata {
    pub fn schema(self, schema: Option<String>) -> Self {
        Self { schema, ..self }
    }
+
+    pub fn specified_name(self, specified_name: Option<String>) -> Self {
+        Self {
+            specified_name,
+            ..self
+        }
+    }
 }

 impl Default for InstanceMetadata {
@@ -138,13 +153,27 @@ impl Default for InstanceMetadata {
    }
 }

-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct InstanceContext {
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub path_ignore_rules: Arc<Vec<PathIgnoreRule>>,
    pub emit_legacy_scripts: bool,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub sync_rules: Vec<SyncRule>,
+    /// Optional Git filter for --git-since mode. When set, only files that have
+    /// changed since the specified Git reference will be synced.
+    #[serde(skip)]
+    pub git_filter: Option<SharedGitFilter>,
+}
+
+impl PartialEq for InstanceContext {
+    fn eq(&self, other: &Self) -> bool {
+        // Note: git_filter is intentionally excluded from comparison
+        // since it's runtime state, not configuration
+        self.path_ignore_rules == other.path_ignore_rules
+            && self.emit_legacy_scripts == other.emit_legacy_scripts
+            && self.sync_rules == other.sync_rules
+    }
 }

 impl InstanceContext {
@@ -153,6 +182,7 @@ impl InstanceContext {
            path_ignore_rules: Arc::new(Vec::new()),
            emit_legacy_scripts: emit_legacy_scripts_default().unwrap(),
            sync_rules: Vec::new(),
+            git_filter: None,
        }
    }

@@ -165,6 +195,36 @@ impl InstanceContext {
        }
    }

+    /// Creates a new InstanceContext with a Git filter for --git-since mode.
+    pub fn with_git_filter(
+        emit_legacy_scripts: Option<bool>,
+        git_filter: SharedGitFilter,
+    ) -> Self {
+        Self {
+            git_filter: Some(git_filter),
+            ..Self::with_emit_legacy_scripts(emit_legacy_scripts)
+        }
+    }
+
+    /// Sets the Git filter for this context.
+    pub fn set_git_filter(&mut self, git_filter: Option<SharedGitFilter>) {
+        self.git_filter = git_filter;
+    }
+
+    /// Returns true if the given path should be acknowledged (synced).
+    /// If no git filter is set, all paths are acknowledged.
+    pub fn is_path_acknowledged(&self, path: &Path) -> bool {
+        match &self.git_filter {
+            Some(filter) => filter.is_acknowledged(path),
+            None => true,
+        }
+    }
+
+    /// Returns true if a git filter is active.
+    pub fn has_git_filter(&self) -> bool {
+        self.git_filter.is_some()
+    }
+
    /// Extend the list of ignore rules in the context with the given new rules.
    pub fn add_path_ignore_rules<I>(&mut self, new_rules: I)
    where
--- a/src/snapshot/patch_compute.rs
+++ b/src/snapshot/patch_compute.rs
@@ -8,7 +8,7 @@ use rbx_dom_weak::{
    ustr, HashMapExt as _, UstrMap, UstrSet,
 };

-use crate::{RojoRef, REF_POINTER_ATTRIBUTE_PREFIX};
+use crate::{variant_eq::variant_eq, RojoRef, REF_POINTER_ATTRIBUTE_PREFIX};

 use super::{
    patch::{PatchAdd, PatchSet, PatchUpdate},
@@ -127,7 +127,7 @@ fn compute_property_patches(

        match instance.properties().get(&name) {
            Some(instance_value) => {
-                if &snapshot_value != instance_value {
+                if !variant_eq(&snapshot_value, instance_value) {
                    changed_properties.insert(name, Some(snapshot_value));
                }
            }
--- a/src/snapshot_middleware/json_model.rs
+++ b/src/snapshot_middleware/json_model.rs
@@ -35,20 +35,14 @@ pub fn snapshot_json_model(
        format!("File is not a valid JSON model: {}", path.display())
    })?;

-    if let Some(top_level_name) = &instance.name {
-        let new_name = format!("{}.model.json", top_level_name);
+    // If the JSON has a name property, preserve it in metadata for syncback
+    let specified_name = instance.name.clone();

-        log::warn!(
-            "Model at path {} had a top-level Name field. \
-            This field has been ignored since Rojo 6.0.\n\
-            Consider removing this field and renaming the file to {}.",
-            new_name,
-            path.display()
-        );
+    // Use the name from JSON if present, otherwise fall back to filename-derived name
+    if instance.name.is_none() {
+        instance.name = Some(name.to_owned());
    }

-    instance.name = Some(name.to_owned());
-
    let id = instance.id.take().map(RojoRef::new);
    let schema = instance.schema.take();

@@ -62,7 +56,8 @@ pub fn snapshot_json_model(
        .relevant_paths(vec![vfs.canonicalize(path)?])
        .context(context)
        .specified_id(id)
-        .schema(schema);
+        .schema(schema)
+        .specified_name(specified_name);

    Ok(Some(snapshot))
 }
@@ -81,6 +76,7 @@ pub fn syncback_json_model<'sync>(
        // schemas will ever exist in one project for it to matter, but it
        // could have a performance cost.
        model.schema = old_inst.metadata().schema.clone();
+        model.name = old_inst.metadata().specified_name.clone();
    }

    Ok(SyncbackReturn {
--- a/src/snapshot_middleware/lua.rs
+++ b/src/snapshot_middleware/lua.rs
@@ -158,8 +158,16 @@ pub fn syncback_lua<'sync>(

        if !meta.is_empty() {
            let parent_location = snapshot.path.parent_err()?;
+            let instance_name = &snapshot.new_inst().name;
+            let slugified;
+            let meta_name = if crate::syncback::validate_file_name(instance_name).is_err() {
+                slugified = crate::syncback::slugify_name(instance_name);
+                &slugified
+            } else {
+                instance_name
+            };
            fs_snapshot.add_file(
-                parent_location.join(format!("{}.meta.json", new_inst.name)),
+                parent_location.join(format!("{}.meta.json", meta_name)),
                serde_json::to_vec_pretty(&meta).context("cannot serialize metadata")?,
            );
        }
--- a/src/snapshot_middleware/meta_file.rs
+++ b/src/snapshot_middleware/meta_file.rs
@@ -10,7 +10,10 @@ use rbx_dom_weak::{
 use serde::{Deserialize, Serialize};

 use crate::{
-    json, resolution::UnresolvedValue, snapshot::InstanceSnapshot, syncback::SyncbackSnapshot,
+    json,
+    resolution::UnresolvedValue,
+    snapshot::InstanceSnapshot,
+    syncback::{validate_file_name, SyncbackSnapshot},
    RojoRef,
 };

@@ -36,6 +39,9 @@ pub struct AdjacentMetadata {
    #[serde(default, skip_serializing_if = "IndexMap::is_empty")]
    pub attributes: IndexMap<String, UnresolvedValue>,

+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+
    #[serde(skip)]
    pub path: PathBuf,
 }
@@ -144,6 +150,24 @@ impl AdjacentMetadata {
            }
        }

+        let name = snapshot
+            .old_inst()
+            .and_then(|inst| inst.metadata().specified_name.clone())
+            .or_else(|| {
+                // If this is a new instance and its name is invalid for the filesystem,
+                // we need to specify the name in meta.json so it can be preserved
+                if snapshot.old_inst().is_none() {
+                    let instance_name = &snapshot.new_inst().name;
+                    if validate_file_name(instance_name).is_err() {
+                        Some(instance_name.clone())
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            });
+
        Ok(Some(Self {
            ignore_unknown_instances: if ignore_unknown_instances {
                Some(true)
@@ -155,6 +179,7 @@ impl AdjacentMetadata {
            path,
            id: None,
            schema,
+            name,
        }))
    }

@@ -213,11 +238,26 @@ impl AdjacentMetadata {
        Ok(())
    }

+    fn apply_name(&mut self, snapshot: &mut InstanceSnapshot) -> anyhow::Result<()> {
+        if self.name.is_some() && snapshot.metadata.specified_name.is_some() {
+            anyhow::bail!(
+                "cannot specify a name using {} (instance has a name from somewhere else)",
+                self.path.display()
+            );
+        }
+        if let Some(name) = &self.name {
+            snapshot.name = name.clone().into();
+        }
+        snapshot.metadata.specified_name = self.name.take();
+        Ok(())
+    }
+
    pub fn apply_all(&mut self, snapshot: &mut InstanceSnapshot) -> anyhow::Result<()> {
        self.apply_ignore_unknown_instances(snapshot);
        self.apply_properties(snapshot)?;
        self.apply_id(snapshot)?;
        self.apply_schema(snapshot)?;
+        self.apply_name(snapshot)?;
        Ok(())
    }

@@ -226,11 +266,13 @@ impl AdjacentMetadata {
    ///
    /// - The number of properties and attributes is 0
    /// - `ignore_unknown_instances` is None
+    /// - `name` is None
    #[inline]
    pub fn is_empty(&self) -> bool {
        self.attributes.is_empty()
            && self.properties.is_empty()
            && self.ignore_unknown_instances.is_none()
+            && self.name.is_none()
    }

    // TODO: Add method to allow selectively applying parts of metadata and
@@ -262,6 +304,9 @@ pub struct DirectoryMetadata {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub class_name: Option<Ustr>,

+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+
    #[serde(skip)]
    pub path: PathBuf,
 }
@@ -372,6 +417,24 @@ impl DirectoryMetadata {
            }
        }

+        let name = snapshot
+            .old_inst()
+            .and_then(|inst| inst.metadata().specified_name.clone())
+            .or_else(|| {
+                // If this is a new instance and its name is invalid for the filesystem,
+                // we need to specify the name in meta.json so it can be preserved
+                if snapshot.old_inst().is_none() {
+                    let instance_name = &snapshot.new_inst().name;
+                    if validate_file_name(instance_name).is_err() {
+                        Some(instance_name.clone())
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            });
+
        Ok(Some(Self {
            ignore_unknown_instances: if ignore_unknown_instances {
                Some(true)
@@ -384,6 +447,7 @@ impl DirectoryMetadata {
            path,
            id: None,
            schema,
+            name,
        }))
    }

@@ -393,6 +457,7 @@ impl DirectoryMetadata {
        self.apply_properties(snapshot)?;
        self.apply_id(snapshot)?;
        self.apply_schema(snapshot)?;
+        self.apply_name(snapshot)?;

        Ok(())
    }
@@ -464,17 +529,33 @@ impl DirectoryMetadata {
        snapshot.metadata.schema = self.schema.take();
        Ok(())
    }
+
+    fn apply_name(&mut self, snapshot: &mut InstanceSnapshot) -> anyhow::Result<()> {
+        if self.name.is_some() && snapshot.metadata.specified_name.is_some() {
+            anyhow::bail!(
+                "cannot specify a name using {} (instance has a name from somewhere else)",
+                self.path.display()
+            );
+        }
+        if let Some(name) = &self.name {
+            snapshot.name = name.clone().into();
+        }
+        snapshot.metadata.specified_name = self.name.take();
+        Ok(())
+    }
    /// Returns whether the metadata is 'empty', meaning it doesn't have anything
    /// worth persisting in it. Specifically:
    ///
    /// - The number of properties and attributes is 0
    /// - `ignore_unknown_instances` is None
    /// - `class_name` is either None or not Some("Folder")
+    /// - `name` is None
    #[inline]
    pub fn is_empty(&self) -> bool {
        self.attributes.is_empty()
            && self.properties.is_empty()
            && self.ignore_unknown_instances.is_none()
+            && self.name.is_none()
            && if let Some(class) = &self.class_name {
                class == "Folder"
            } else {
--- a/src/snapshot_middleware/mod.rs
+++ b/src/snapshot_middleware/mod.rs
@@ -61,6 +61,10 @@ pub use self::{
 /// This will inspect the path and find the appropriate middleware for it,
 /// taking user-written rules into account. Then, it will attempt to convert
 /// the path into an InstanceSnapshot using that middleware.
+///
+/// If a git filter is active in the context and the path is not acknowledged
+/// (i.e., the file hasn't changed since the base git reference), this function
+/// returns `Ok(None)` to skip syncing that file.
 #[profiling::function]
 pub fn snapshot_from_vfs(
    context: &InstanceContext,
@@ -72,6 +76,16 @@ pub fn snapshot_from_vfs(
        None => return Ok(None),
    };

+    // Check if this path is acknowledged by the git filter.
+    // If not, skip this path entirely.
+    if !context.is_path_acknowledged(path) {
+        log::trace!(
+            "Skipping path {} (not acknowledged by git filter)",
+            path.display()
+        );
+        return Ok(None);
+    }
+
    if meta.is_dir() {
        let (middleware, dir_name, init_path) = get_dir_middleware(vfs, path)?;
        // TODO: Support user defined init paths
@@ -213,6 +227,10 @@ pub enum Middleware {
 impl Middleware {
    /// Creates a snapshot for the given path from the Middleware with
    /// the provided name.
+    ///
+    /// When a git filter is active in the context, `ignore_unknown_instances`
+    /// will be set to `true` on all generated snapshots to preserve descendants
+    /// in Studio that are not tracked by Rojo.
    fn snapshot(
        &self,
        context: &InstanceContext,
@@ -262,6 +280,14 @@ impl Middleware {
        };
        if let Ok(Some(ref mut snapshot)) = output {
            snapshot.metadata.middleware = Some(*self);
+
+            // When git filter is active, force ignore_unknown_instances to true
+            // so that we don't delete children in Studio that aren't tracked.
+            if context.has_git_filter() {
+                snapshot.metadata.ignore_unknown_instances = true;
+                // Also apply this recursively to all children
+                set_ignore_unknown_instances_recursive(&mut snapshot.children);
+            }
        }
        output
    }
@@ -365,6 +391,16 @@ impl Middleware {
    }
 }

+/// Recursively sets `ignore_unknown_instances` to `true` on all children.
+/// This is used when git filter is active to ensure we don't delete
+/// children in Studio that aren't tracked by Rojo.
+fn set_ignore_unknown_instances_recursive(children: &mut [InstanceSnapshot]) {
+    for child in children {
+        child.metadata.ignore_unknown_instances = true;
+        set_ignore_unknown_instances_recursive(&mut child.children);
+    }
+}
+
 /// A helper for easily defining a SyncRule. Arguments are passed literally
 /// to this macro in the order `include`, `middleware`, `suffix`,
 /// and `exclude`. Both `suffix` and `exclude` are optional.
--- a/src/snapshot_middleware/project.rs
+++ b/src/snapshot_middleware/project.rs
@@ -83,6 +83,19 @@ pub fn snapshot_project(
            // file being updated.
            snapshot.metadata.relevant_paths.push(path.to_path_buf());

+            // When git filter is active, also register the project folder as a
+            // relevant path. This serves as a catch-all so that file changes
+            // not under any specific $path node can still walk up the directory
+            // tree and trigger a re-snapshot of the entire project.
+            if context.has_git_filter() {
+                if let Some(folder) = path.parent() {
+                    let normalized = vfs
+                        .canonicalize(folder)
+                        .unwrap_or_else(|_| folder.to_path_buf());
+                    snapshot.metadata.relevant_paths.push(normalized);
+                }
+            }
+
            Ok(Some(snapshot))
        }
        None => Ok(None),
@@ -137,6 +150,26 @@ pub fn snapshot_project_node(
            // Take the snapshot's metadata as-is, which will be mutated later
            // on.
            metadata = snapshot.metadata;
+        } else if context.has_git_filter() {
+            // When the git filter is active and the $path was filtered out
+            // (no acknowledged files yet), we still need to register the path
+            // in relevant_paths. This allows the change processor to map file
+            // changes in this directory back to this project node instance,
+            // triggering a re-snapshot that will pick up newly modified files.
+            let normalized = vfs
+                .canonicalize(full_path.as_ref())
+                .unwrap_or_else(|_| full_path.to_path_buf());
+            metadata.relevant_paths.push(normalized);
+
+            // The VFS only sets up file watches via read() and read_dir(),
+            // not via metadata(). Since the git filter caused snapshot_from_vfs
+            // to return early (before read_dir was called), the VFS is not
+            // watching this path. We must read the directory here to ensure
+            // the VFS sets up a recursive watch, otherwise file change events
+            // will never fire and live sync won't detect modifications.
+            if full_path.is_dir() {
+                let _ = vfs.read_dir(&full_path);
+            }
        }
    }

@@ -192,6 +225,17 @@ pub fn snapshot_project_node(
        }

        (_, None, _, Some(PathNode::Required(path))) => {
+            // If git filter is active and the path was filtered out, treat it
+            // as if the path was optional and skip this node.
+            if context.has_git_filter() {
+                log::trace!(
+                    "Skipping project node '{}' because its path was filtered by git filter: {}",
+                    instance_name,
+                    path.display()
+                );
+                return Ok(None);
+            }
+
            anyhow::bail!(
                "Rojo project referred to a file using $path that could not be turned into a Roblox Instance by Rojo.\n\
                Check that the file exists and is a file type known by Rojo.\n\
@@ -282,7 +326,12 @@ pub fn snapshot_project_node(
    // If the user didn't specify it AND $path was not specified (meaning
    // there's no existing value we'd be stepping on from a project file or meta
    // file), set it to true.
-    if let Some(ignore) = node.ignore_unknown_instances {
+    //
+    // When git filter is active, always set to true to preserve descendants
+    // in Studio that are not tracked by Rojo.
+    if context.has_git_filter() {
+        metadata.ignore_unknown_instances = true;
+    } else if let Some(ignore) = node.ignore_unknown_instances {
        metadata.ignore_unknown_instances = ignore;
    } else if node.path.is_none() {
        // TODO: Introduce a strict mode where $ignoreUnknownInstances is never
--- a/src/syncback/file_names.rs
+++ b/src/syncback/file_names.rs
@@ -8,11 +8,11 @@ use rbx_dom_weak::Instance;

 use crate::{snapshot::InstanceWithMeta, snapshot_middleware::Middleware};

-pub fn name_for_inst<'old>(
+pub fn name_for_inst<'a>(
    middleware: Middleware,
-    new_inst: &Instance,
-    old_inst: Option<InstanceWithMeta<'old>>,
-) -> anyhow::Result<Cow<'old, str>> {
+    new_inst: &'a Instance,
+    old_inst: Option<InstanceWithMeta<'a>>,
+) -> anyhow::Result<Cow<'a, str>> {
    if let Some(old_inst) = old_inst {
        if let Some(source) = old_inst.metadata().relevant_paths.first() {
            source
@@ -35,14 +35,24 @@ pub fn name_for_inst<'old>(
            | Middleware::CsvDir
            | Middleware::ServerScriptDir
            | Middleware::ClientScriptDir
-            | Middleware::ModuleScriptDir => Cow::Owned(new_inst.name.clone()),
+            | Middleware::ModuleScriptDir => {
+                if validate_file_name(&new_inst.name).is_err() {
+                    Cow::Owned(slugify_name(&new_inst.name))
+                } else {
+                    Cow::Borrowed(&new_inst.name)
+                }
+            }
            _ => {
                let extension = extension_for_middleware(middleware);
-                let name = &new_inst.name;
-                validate_file_name(name).with_context(|| {
-                    format!("name '{name}' is not legal to write to the file system")
-                })?;
-                Cow::Owned(format!("{name}.{extension}"))
+                let slugified;
+                let final_name = if validate_file_name(&new_inst.name).is_err() {
+                    slugified = slugify_name(&new_inst.name);
+                    &slugified
+                } else {
+                    &new_inst.name
+                };
+
+                Cow::Owned(format!("{final_name}.{extension}"))
            }
        })
    }
@@ -94,6 +104,39 @@ const INVALID_WINDOWS_NAMES: [&str; 22] = [
 /// in a file's name.
 const FORBIDDEN_CHARS: [char; 9] = ['<', '>', ':', '"', '/', '|', '?', '*', '\\'];

+/// Slugifies a name by replacing forbidden characters with underscores
+/// and ensuring the result is a valid file name
+pub fn slugify_name(name: &str) -> String {
+    let mut result = String::with_capacity(name.len());
+
+    for ch in name.chars() {
+        if FORBIDDEN_CHARS.contains(&ch) {
+            result.push('_');
+        } else {
+            result.push(ch);
+        }
+    }
+
+    // Handle Windows reserved names by appending an underscore
+    let result_lower = result.to_lowercase();
+    for forbidden in INVALID_WINDOWS_NAMES {
+        if result_lower == forbidden.to_lowercase() {
+            result.push('_');
+            break;
+        }
+    }
+
+    while result.ends_with(' ') || result.ends_with('.') {
+        result.pop();
+    }
+
+    if result.is_empty() || result.chars().all(|c| c == '_') {
+        result = "instance".to_string();
+    }
+
+    result
+}
+
 /// Validates a provided file name to ensure it's allowed on the file system. An
 /// error is returned if the name isn't allowed, indicating why.
 /// This takes into account rules for Windows, MacOS, and Linux.
--- a/src/syncback/mod.rs
+++ b/src/syncback/mod.rs
@@ -28,7 +28,7 @@ use crate::{
    Project,
 };

-pub use file_names::{extension_for_middleware, name_for_inst, validate_file_name};
+pub use file_names::{extension_for_middleware, name_for_inst, slugify_name, validate_file_name};
 pub use fs_snapshot::FsSnapshot;
 pub use hash::*;
 pub use property_filter::{filter_properties, filter_properties_preallocated};
@@ -301,6 +301,7 @@ pub fn get_best_middleware(snapshot: &SyncbackSnapshot) -> Middleware {
    static JSON_MODEL_CLASSES: OnceLock<HashSet<&str>> = OnceLock::new();
    let json_model_classes = JSON_MODEL_CLASSES.get_or_init(|| {
        [
+            "Actor",
            "Sound",
            "SoundGroup",
            "Sky",
@@ -318,6 +319,11 @@ pub fn get_best_middleware(snapshot: &SyncbackSnapshot) -> Middleware {
            "ChatInputBarConfiguration",
            "BubbleChatConfiguration",
            "ChannelTabsConfiguration",
+            "RemoteEvent",
+            "UnreliableRemoteEvent",
+            "RemoteFunction",
+            "BindableEvent",
+            "BindableFunction",
        ]
        .into()
    });
--- a/src/web/api.rs
+++ b/src/web/api.rs
@@ -13,7 +13,6 @@ use rbx_dom_weak::{
 };

 use crate::{
-    json,
    serve_session::ServeSession,
    snapshot::{InstanceWithMeta, PatchSet, PatchUpdate},
    web::{
@@ -22,11 +21,10 @@ use crate::{
            ServerInfoResponse, SocketPacket, SocketPacketBody, SocketPacketType, SubscribeMessage,
            WriteRequest, WriteResponse, PROTOCOL_VERSION, SERVER_VERSION,
        },
-        util::{json, json_ok},
+        util::{deserialize_msgpack, msgpack, msgpack_ok, serialize_msgpack},
    },
    web_api::{
-        BufferEncode, InstanceUpdate, RefPatchRequest, RefPatchResponse, SerializeRequest,
-        SerializeResponse,
+        InstanceUpdate, RefPatchRequest, RefPatchResponse, SerializeRequest, SerializeResponse,
    },
 };

@@ -42,7 +40,7 @@ pub async fn call(serve_session: Arc<ServeSession>, mut request: Request<Body>)
            if is_upgrade_request(&request) {
                service.handle_api_socket(&mut request).await
            } else {
-                json(
+                msgpack(
                    ErrorResponse::bad_request(
                        "/api/socket must be called as a websocket upgrade request",
                    ),
@@ -58,7 +56,7 @@ pub async fn call(serve_session: Arc<ServeSession>, mut request: Request<Body>)
        }
        (&Method::POST, "/api/write") => service.handle_api_write(request).await,

-        (_method, path) => json(
+        (_method, path) => msgpack(
            ErrorResponse::not_found(format!("Route not found: {}", path)),
            StatusCode::NOT_FOUND,
        ),
@@ -79,7 +77,7 @@ impl ApiService {
        let tree = self.serve_session.tree();
        let root_instance_id = tree.get_root_id();

-        json_ok(&ServerInfoResponse {
+        msgpack_ok(&ServerInfoResponse {
            server_version: SERVER_VERSION.to_owned(),
            protocol_version: PROTOCOL_VERSION,
            session_id: self.serve_session.session_id(),
@@ -98,7 +96,7 @@ impl ApiService {
        let input_cursor: u32 = match argument.parse() {
            Ok(v) => v,
            Err(err) => {
-                return json(
+                return msgpack(
                    ErrorResponse::bad_request(format!("Malformed message cursor: {}", err)),
                    StatusCode::BAD_REQUEST,
                );
@@ -109,7 +107,7 @@ impl ApiService {
        let (response, websocket) = match upgrade(request, None) {
            Ok(result) => result,
            Err(err) => {
-                return json(
+                return msgpack(
                    ErrorResponse::internal_error(format!("WebSocket upgrade failed: {}", err)),
                    StatusCode::INTERNAL_SERVER_ERROR,
                );
@@ -136,10 +134,10 @@ impl ApiService {

        let body = body::to_bytes(request.into_body()).await.unwrap();

-        let request: WriteRequest = match json::from_slice(&body) {
+        let request: WriteRequest = match deserialize_msgpack(&body) {
            Ok(request) => request,
            Err(err) => {
-                return json(
+                return msgpack(
                    ErrorResponse::bad_request(format!("Invalid body: {}", err)),
                    StatusCode::BAD_REQUEST,
                );
@@ -147,7 +145,7 @@ impl ApiService {
        };

        if request.session_id != session_id {
-            return json(
+            return msgpack(
                ErrorResponse::bad_request("Wrong session ID"),
                StatusCode::BAD_REQUEST,
            );
@@ -173,7 +171,7 @@ impl ApiService {
            })
            .unwrap();

-        json_ok(WriteResponse { session_id })
+        msgpack_ok(WriteResponse { session_id })
    }

    async fn handle_api_read(&self, request: Request<Body>) -> Response<Body> {
@@ -183,7 +181,7 @@ impl ApiService {
        let requested_ids = match requested_ids {
            Ok(ids) => ids,
            Err(_) => {
-                return json(
+                return msgpack(
                    ErrorResponse::bad_request("Malformed ID list"),
                    StatusCode::BAD_REQUEST,
                );
@@ -207,7 +205,7 @@ impl ApiService {
            }
        }

-        json_ok(ReadResponse {
+        msgpack_ok(ReadResponse {
            session_id: self.serve_session.session_id(),
            message_cursor,
            instances,
@@ -225,10 +223,10 @@ impl ApiService {
        let session_id = self.serve_session.session_id();
        let body = body::to_bytes(request.into_body()).await.unwrap();

-        let request: SerializeRequest = match json::from_slice(&body) {
+        let request: SerializeRequest = match deserialize_msgpack(&body) {
            Ok(request) => request,
            Err(err) => {
-                return json(
+                return msgpack(
                    ErrorResponse::bad_request(format!("Invalid body: {}", err)),
                    StatusCode::BAD_REQUEST,
                );
@@ -236,7 +234,7 @@ impl ApiService {
        };

        if request.session_id != session_id {
-            return json(
+            return msgpack(
                ErrorResponse::bad_request("Wrong session ID"),
                StatusCode::BAD_REQUEST,
            );
@@ -269,7 +267,7 @@ impl ApiService {

                response_dom.transfer_within(child_ref, object_value);
            } else {
-                json(
+                msgpack(
                    ErrorResponse::bad_request(format!("provided id {id} is not in the tree")),
                    StatusCode::BAD_REQUEST,
                );
@@ -280,9 +278,9 @@ impl ApiService {
        let mut source = Vec::new();
        rbx_binary::to_writer(&mut source, &response_dom, &[response_dom.root_ref()]).unwrap();

-        json_ok(SerializeResponse {
+        msgpack_ok(SerializeResponse {
            session_id: self.serve_session.session_id(),
-            model_contents: BufferEncode::new(source),
+            model_contents: source,
        })
    }

@@ -294,10 +292,10 @@ impl ApiService {
        let session_id = self.serve_session.session_id();
        let body = body::to_bytes(request.into_body()).await.unwrap();

-        let request: RefPatchRequest = match json::from_slice(&body) {
+        let request: RefPatchRequest = match deserialize_msgpack(&body) {
            Ok(request) => request,
            Err(err) => {
-                return json(
+                return msgpack(
                    ErrorResponse::bad_request(format!("Invalid body: {}", err)),
                    StatusCode::BAD_REQUEST,
                );
@@ -305,7 +303,7 @@ impl ApiService {
        };

        if request.session_id != session_id {
-            return json(
+            return msgpack(
                ErrorResponse::bad_request("Wrong session ID"),
                StatusCode::BAD_REQUEST,
            );
@@ -338,7 +336,7 @@ impl ApiService {
            }
        }

-        json_ok(RefPatchResponse {
+        msgpack_ok(RefPatchResponse {
            session_id: self.serve_session.session_id(),
            patch: SubscribeMessage {
                added: HashMap::new(),
@@ -354,7 +352,7 @@ impl ApiService {
        let requested_id = match Ref::from_str(argument) {
            Ok(id) => id,
            Err(_) => {
-                return json(
+                return msgpack(
                    ErrorResponse::bad_request("Invalid instance ID"),
                    StatusCode::BAD_REQUEST,
                );
@@ -366,7 +364,7 @@ impl ApiService {
        let instance = match tree.get_instance(requested_id) {
            Some(instance) => instance,
            None => {
-                return json(
+                return msgpack(
                    ErrorResponse::bad_request("Instance not found"),
                    StatusCode::NOT_FOUND,
                );
@@ -376,7 +374,7 @@ impl ApiService {
        let script_path = match pick_script_path(instance) {
            Some(path) => path,
            None => {
-                return json(
+                return msgpack(
                    ErrorResponse::bad_request(
                        "No appropriate file could be found to open this script",
                    ),
@@ -389,7 +387,7 @@ impl ApiService {
            Ok(()) => {}
            Err(error) => match error {
                OpenError::Io(io_error) => {
-                    return json(
+                    return msgpack(
                        ErrorResponse::internal_error(format!(
                            "Attempting to open {} failed because of the following io error: {}",
                            script_path.display(),
@@ -403,7 +401,7 @@ impl ApiService {
                    status,
                    stderr,
                } => {
-                    return json(
+                    return msgpack(
                        ErrorResponse::internal_error(format!(
                            r#"The command '{}' to open '{}' failed with the error code '{}'.
                            Error logs:
@@ -419,7 +417,7 @@ impl ApiService {
            },
        };

-        json_ok(OpenResponse {
+        msgpack_ok(OpenResponse {
            session_id: self.serve_session.session_id(),
        })
    }
@@ -483,7 +481,7 @@ async fn handle_websocket_subscription(
                match result {
                    Ok((new_cursor, messages)) => {
                        if !messages.is_empty() {
-                            let json_message = {
+                            let msgpack_message = {
                                let tree = tree_handle.lock().unwrap();
                                let api_messages = messages
                                    .into_iter()
@@ -499,12 +497,12 @@ async fn handle_websocket_subscription(
                                    }),
                                };

-                                serde_json::to_string(&response)?
+                                serialize_msgpack(response)?
                            };

                            log::debug!("Sending batch of messages over WebSocket subscription");

-                            if websocket.send(Message::Text(json_message)).await.is_err() {
+                            if websocket.send(Message::Binary(msgpack_message)).await.is_err() {
                                // Client disconnected
                                log::debug!("WebSocket subscription closed by client");
                                break;
--- a/src/web/interface.rs
+++ b/src/web/interface.rs
@@ -249,31 +249,8 @@ pub struct SerializeRequest {
 #[serde(rename_all = "camelCase")]
 pub struct SerializeResponse {
    pub session_id: SessionId,
-    pub model_contents: BufferEncode,
-}
-
-/// Using this struct we can force Roblox to JSONDecode this as a buffer.
-/// This is what Roblox's serde APIs use, so it saves a step in the plugin.
-#[derive(Debug, Serialize, Deserialize)]
-pub struct BufferEncode {
-    m: (),
-    t: Cow<'static, str>,
-    base64: String,
-}
-
-impl BufferEncode {
-    pub fn new(content: Vec<u8>) -> Self {
-        let base64 = data_encoding::BASE64.encode(&content);
-        Self {
-            m: (),
-            t: Cow::Borrowed("buffer"),
-            base64,
-        }
-    }
-
-    pub fn model(&self) -> &str {
-        &self.base64
-    }
+    #[serde(with = "serde_bytes")]
+    pub model_contents: Vec<u8>,
 }

 #[derive(Debug, Serialize, Deserialize)]
--- a/src/web/util.rs
+++ b/src/web/util.rs
@@ -1,8 +1,48 @@
 use hyper::{header::CONTENT_TYPE, Body, Response, StatusCode};
-use serde::Serialize;
+use serde::{Deserialize, Serialize};

-pub fn json_ok<T: Serialize>(value: T) -> Response<Body> {
-    json(value, StatusCode::OK)
+pub fn msgpack_ok<T: Serialize>(value: T) -> Response<Body> {
+    msgpack(value, StatusCode::OK)
+}
+
+pub fn msgpack<T: Serialize>(value: T, code: StatusCode) -> Response<Body> {
+    let mut serialized = Vec::new();
+    let mut serializer = rmp_serde::Serializer::new(&mut serialized)
+        .with_human_readable()
+        .with_struct_map();
+
+    if let Err(err) = value.serialize(&mut serializer) {
+        return Response::builder()
+            .status(StatusCode::INTERNAL_SERVER_ERROR)
+            .header(CONTENT_TYPE, "text/plain")
+            .body(Body::from(err.to_string()))
+            .unwrap();
+    };
+
+    Response::builder()
+        .status(code)
+        .header(CONTENT_TYPE, "application/msgpack")
+        .body(Body::from(serialized))
+        .unwrap()
+}
+
+pub fn serialize_msgpack<T: Serialize>(value: T) -> anyhow::Result<Vec<u8>> {
+    let mut serialized = Vec::new();
+    let mut serializer = rmp_serde::Serializer::new(&mut serialized)
+        .with_human_readable()
+        .with_struct_map();
+
+    value.serialize(&mut serializer)?;
+
+    Ok(serialized)
+}
+
+pub fn deserialize_msgpack<'a, T: Deserialize<'a>>(
+    input: &'a [u8],
+) -> Result<T, rmp_serde::decode::Error> {
+    let mut deserializer = rmp_serde::Deserializer::new(input).with_human_readable();
+
+    T::deserialize(&mut deserializer)
 }

 pub fn json<T: Serialize>(value: T, code: StatusCode) -> Response<Body> {
--- a/test-projects/relative_paths/default.project.json
+++ b/test-projects/relative_paths/default.project.json
@@ -0,0 +1,14 @@
+{
+  "name": "default",
+  "tree": {
+    "$className": "DataModel",
+    "ReplicatedStorage": {
+      "Project": {
+        "$path": "project/src",
+        "Module": {
+          "$path": "module"
+        }
+      }
+    }
+  }
+}
--- a/test-projects/relative_paths/module/module.luau
+++ b/test-projects/relative_paths/module/module.luau
@@ -0,0 +1 @@
+return nil
--- a/test-projects/relative_paths/project/default.project.json
+++ b/test-projects/relative_paths/project/default.project.json
@@ -0,0 +1,14 @@
+{
+  "name": "default",
+  "tree": {
+    "$className": "DataModel",
+    "ReplicatedStorage": {
+      "Project": {
+        "$path": "src/",
+        "Module": {
+          "$path": "../module"
+        }
+      }
+    }
+  }
+}
--- a/test-projects/relative_paths/project/src/init.luau
+++ b/test-projects/relative_paths/project/src/init.luau
@@ -0,0 +1 @@
+return nil
--- a/tests/rojo_test/serve_util.rs
+++ b/tests/rojo_test/serve_util.rs
@@ -10,6 +10,7 @@ use std::{
 use hyper_tungstenite::tungstenite::{connect, Message};
 use rbx_dom_weak::types::Ref;

+use serde::{Deserialize, Serialize};
 use tempfile::{tempdir, TempDir};

 use librojo::{
@@ -161,22 +162,16 @@ impl TestServeSession {

    pub fn get_api_rojo(&self) -> Result<ServerInfoResponse, reqwest::Error> {
        let url = format!("http://localhost:{}/api/rojo", self.port);
-        let body = reqwest::blocking::get(url)?.text()?;
+        let body = reqwest::blocking::get(url)?.bytes()?;

-        let value = jsonc_parser::parse_to_serde_value(&body, &Default::default())
-            .expect("Failed to parse JSON")
-            .expect("No JSON value");
-        Ok(serde_json::from_value(value).expect("Server returned malformed response"))
+        Ok(deserialize_msgpack(&body).expect("Server returned malformed response"))
    }

    pub fn get_api_read(&self, id: Ref) -> Result<ReadResponse<'_>, reqwest::Error> {
        let url = format!("http://localhost:{}/api/read/{}", self.port, id);
-        let body = reqwest::blocking::get(url)?.text()?;
+        let body = reqwest::blocking::get(url)?.bytes()?;

-        let value = jsonc_parser::parse_to_serde_value(&body, &Default::default())
-            .expect("Failed to parse JSON")
-            .expect("No JSON value");
-        Ok(serde_json::from_value(value).expect("Server returned malformed response"))
+        Ok(deserialize_msgpack(&body).expect("Server returned malformed response"))
    }

    pub fn get_api_socket_packet(
@@ -198,8 +193,8 @@ impl TestServeSession {
            }

            match socket.read() {
-                Ok(Message::Text(text)) => {
-                    let packet: SocketPacket = serde_json::from_str(&text)?;
+                Ok(Message::Binary(binary)) => {
+                    let packet: SocketPacket = deserialize_msgpack(&binary)?;
                    if packet.packet_type != packet_type {
                        continue;
                    }
@@ -212,7 +207,7 @@ impl TestServeSession {
                    return Err("WebSocket closed before receiving messages".into());
                }
                Ok(_) => {
-                    // Ignore other message types (ping, pong, binary)
+                    // Ignore other message types (ping, pong, text)
                    continue;
                }
                Err(hyper_tungstenite::tungstenite::Error::Io(e))
@@ -236,15 +231,37 @@ impl TestServeSession {
    ) -> Result<SerializeResponse, reqwest::Error> {
        let client = reqwest::blocking::Client::new();
        let url = format!("http://localhost:{}/api/serialize", self.port);
-        let body = serde_json::to_string(&SerializeRequest {
+        let body = serialize_msgpack(&SerializeRequest {
            session_id,
            ids: ids.to_vec(),
-        });
+        })
+        .unwrap();

-        client.post(url).body((body).unwrap()).send()?.json()
+        let body = client.post(url).body(body).send()?.bytes()?;
+
+        Ok(deserialize_msgpack(&body).expect("Server returned malformed response"))
    }
 }

+fn serialize_msgpack<T: Serialize>(value: T) -> Result<Vec<u8>, rmp_serde::encode::Error> {
+    let mut serialized = Vec::new();
+    let mut serializer = rmp_serde::Serializer::new(&mut serialized)
+        .with_human_readable()
+        .with_struct_map();
+
+    value.serialize(&mut serializer)?;
+
+    Ok(serialized)
+}
+
+fn deserialize_msgpack<'a, T: Deserialize<'a>>(
+    input: &'a [u8],
+) -> Result<T, rmp_serde::decode::Error> {
+    let mut deserializer = rmp_serde::Deserializer::new(input).with_human_readable();
+
+    T::deserialize(&mut deserializer)
+}
+
 /// Probably-okay way to generate random enough port numbers for running the
 /// Rojo live server.
 ///
@@ -262,11 +279,7 @@ fn get_port_number() -> usize {
 /// Since the provided structure intentionally includes unredacted referents,
 /// some post-processing is done to ensure they don't show up in the model.
 pub fn serialize_to_xml_model(response: &SerializeResponse, redactions: &RedactionMap) -> String {
-    let model_content = data_encoding::BASE64
-        .decode(response.model_contents.model().as_bytes())
-        .unwrap();
-
-    let mut dom = rbx_binary::from_reader(model_content.as_slice()).unwrap();
+    let mut dom = rbx_binary::from_reader(response.model_contents.as_slice()).unwrap();
    // This makes me realize that maybe we need a `descendants_mut` iter.
    let ref_list: Vec<Ref> = dom.descendants().map(|inst| inst.referent()).collect();
    for referent in ref_list {
--- a/tests/tests/build.rs
+++ b/tests/tests/build.rs
@@ -41,7 +41,6 @@ gen_build_tests! {
    issue_546,
    json_as_lua,
    json_model_in_folder,
-    json_model_legacy_name,
    module_in_folder,
    module_init,
    nested_runcontext,
@@ -55,6 +54,8 @@ gen_build_tests! {
    script_meta_disabled,
    server_in_folder,
    server_init,
+    slugified_name_roundtrip,
+    model_json_name_input,
    txt,
    txt_in_folder,
    unresolved_values,
--- a/tests/tests/syncback.rs
+++ b/tests/tests/syncback.rs
@@ -86,4 +86,9 @@ syncback_tests! {
    sync_rules => ["src/module.modulescript", "src/text.text"],
    // Ensures that the `syncUnscriptable` setting works
    unscriptable_properties => ["default.project.json"],
+    // Ensures that instances with names containing illegal characters get slugified filenames
+    // and preserve their original names in meta.json without forcing directories for leaf scripts
+    slugified_name => ["src/_Script.meta.json", "src/_Script.server.luau", "src/_Folder/init.meta.json"],
+    // Ensures that .model.json files preserve the name property
+    model_json_name => ["src/foo.model.json"],
 }
Author	SHA1	Message	Date
astrid	b8106354b0	Fix --git-since not detecting first file change in filtered directories The VFS only sets up file watches via read() and read_dir(), not metadata(). When git filtering caused snapshot_from_vfs to return early for $path directories, read_dir was never called, so no file watch was established. This meant file modifications never generated VFS events and were silently ignored until the server was restarted. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-13 18:04:27 +01:00
astrid	0dc37ac848	Fix --git-since live sync not detecting changes and creating duplicates Two issues prevented --git-since from working correctly during live sync: 1. Server: File changes weren't detected because git-filtered project nodes had empty relevant_paths, so the change processor couldn't map VFS events back to tree instances. Fixed by registering $path directories and the project folder in relevant_paths even when filtered. 2. Plugin: When a previously-filtered file was first acknowledged, it appeared as an ADD patch. The plugin created a new instance instead of adopting the existing one in Studio, causing duplicates. Fixed by checking for untracked children with matching Name+ClassName before calling Instance.new. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-13 16:19:01 +01:00
astrid	891b74b135	Merge branch 'git-track' into master	2026-02-13 14:11:17 +01:00
ari	18fdbce8b0	name-prop (#1 ) Reviewed-on: #1 Co-authored-by: ari <git@astrid.email> Co-committed-by: ari <git@astrid.email>	2026-02-13 13:09:30 +00:00
Ivan Matthew	a2adf2b517	Improves sourcemap path handling with pathdiff (#1217 )	2026-02-12 19:17:28 -08:00
Micah	4deda0e155	Use msgpack for API (#1176 )	2026-02-12 18:37:24 -08:00
ari	4df2d3c5f8	Add actor, bindables and remotes to json_model_classes (#1199 )	2026-02-12 17:34:32 -08:00
boatbomber	4965165ad5	Add option to forget prior info for place in reminder notif (#1215 )	2026-01-23 21:15:34 +00:00
boatbomber	68eab3479a	Fix notification unmount thread cancel bug (#1211 )	2026-01-19 16:35:19 -08:00
Astrid	8053909bd0	Add --git-since option to rojo serve - Add new GitFilter struct for tracking files changed since a Git reference - Only sync changed (added/deleted/modified) files to Roblox Studio - Files remain acknowledged once synced, even if content is reverted - Add enhanced logging for debugging sync issues - Force acknowledge project structure to prevent 'Cannot sync a model as a place' errors	2026-01-19 22:02:59 +01:00