@typetorch/framework 0.5.2 → 0.5.4

package/out/analytics/SCHEMA.md

@@ -65,6 +65,7 @@ First-ever-session detail, one row per packed chunk.
 | tech | `load` (src client) | `secs`: from the client starting to the engine starting (first client generation only) |
 | tech | `error` | Server or client (src). `msg` (first 300 chars, player names replaced by `<player>`), `n` (times in the window). At most 10 per tech tick (server), 5 per 30 s and 100 per session (client) |
 | tech | `start` | First generation of a server that runs the engine: `gen`, `kernel`, `load?` |
+| tech | `assets` | Each generation whose artifact has hot assets (or an unusable manifest), at its start: `gen`, `boot` (the server's first generation), `manifest` (`ok`, `invalid`, `unread`), `place?` (`same`: the manifest names this place version; `vouched`: the place's backup vouches for it; `differs`: keys without a matching baked copy load from their uploads; `unknown`), `mpv?` (the manifest's place version), `pv?` (game.PlaceVersion), `keys`, `kept`, `baked`, `loaded`, `failed`, `loading` (keys per AssetSync source), `missing` (keys with nothing live), `late` (loaded after the start-up wait), `timedOut`, `ms?`, `first?` (the first failure or manifest error) |
 | tech | `swap` / `rollback` | A generation started by a hot swap (`rollback` for rollback reasons), 5 s after it started: `reason`, `from?` (previous artifact id), `gen`, `load?`, `stop?`, `swap?` (seconds), `players` |
 | tech | `swap_out` | Just before a generation stops: `reason`, `next?` (next artifact id), `players` |
 | zone | `enter` | `zone`, `from` (previous zone or `""`) |

package/out/analytics/server.luau

@@ -19,6 +19,8 @@ local _typetorch = TS.import(script, script.Parent.Parent, "typetorch")
 local closeHooksSupported = _typetorch.closeHooksSupported
 local onGenerationClose = _typetorch.onGenerationClose
 local TypeTorch = _typetorch.TypeTorch
+local assetCounts = TS.import(script, script.Parent.Parent, "assets", "manifest").assetCounts
+local assetReport = TS.import(script, script.Parent.Parent, "assets", "sync").assetReport
 local toBase64 = TS.import(script, script.Parent, "codec").toBase64
 local _props = TS.import(script, script.Parent, "props")
 local encodeProps = _props.encodeProps
@@ -495,7 +497,7 @@ do
 	end
 	function ServerAnalytics:track(player, kind, name, props)
 		if not isEventName(name) then
-			warn("[src/analytics/server.ts:471]", `[analytics] {kind} event name must be 1-64 characters: {string.sub(tostring(name), 1, 80)}`)
+			warn("[src/analytics/server.ts:473]", `[analytics] {kind} event name must be 1-64 characters: {string.sub(tostring(name), 1, 80)}`)
 			return nil
 		end
 		local session = if player then self:sessionOf(player) else nil
@@ -603,7 +605,7 @@ do
 		end
 		local control = _condition
 		if not isExperimentName(name) or not isVariantList(variants) then
-			warn("[src/analytics/server.ts:523]", `[analytics] experiment("{string.sub(tostring(name), 1, 64)}"): bad name or variants (1-16 distinct names)`)
+			warn("[src/analytics/server.ts:525]", `[analytics] experiment("{string.sub(tostring(name), 1, 64)}"): bad name or variants (1-16 distinct names)`)
 			return control
 		end
 		local session = self:sessionOf(player)
@@ -668,7 +670,7 @@ do
 	function ServerAnalytics:applySettings(parsed)
 		local errorsText = table.concat(parsed.errors, "; ")
 		if errorsText ~= table.concat(self.settingsErrors, "; ") and errorsText ~= "" then
-			warn("[src/analytics/server.ts:558]", `[analytics] the sink settings (settings.backend or settings.analytics): {errorsText}`)
+			warn("[src/analytics/server.ts:560]", `[analytics] the sink settings (settings.backend or settings.analytics): {errorsText}`)
 		end
 		self.settingsErrors = parsed.errors
 		local hadSettings = self.settings ~= nil
@@ -698,7 +700,7 @@ do
 		-- `new AnalyticsEngine({ settings })`.
 		if not settingsSupported() then
 			if self.kernel ~= nil and self.kernel.test ~= true then
-				warn("[src/analytics/server.ts:585]", `[analytics] no sink settings: they come from the signed settings record (kernel 0.3.8+, "typetorch backend setup"); this server runs kernel {self.kernel.kernelVersion}. Or pass new AnalyticsEngine(\{ settings \})`)
+				warn("[src/analytics/server.ts:587]", `[analytics] no sink settings: they come from the signed settings record (kernel 0.3.8+, "typetorch backend setup"); this server runs kernel {self.kernel.kernelVersion}. Or pass new AnalyticsEngine(\{ settings \})`)
 			end
 			self.settingsTried = true
 			return nil
@@ -1227,6 +1229,20 @@ do
 					load = start.loadSeconds,
 				}))
 			end
+			-- Hot assets: how this generation's AssetSync went (it ran before the modules loaded), so "every new server
+			-- loads its hot assets from uploads" shows in the events table (2026-10-13 incident).
+			local assets = assetReport()
+			if assets.manifest ~= "none" or #assets.errors > 0 then
+				local _self = self
+				local _object = {
+					gen = generation,
+					boot = start.kind ~= "swap",
+				}
+				for _k, _v in assetCounts(assets) do
+					_object[_k] = _v
+				end
+				_self:emit(nil, "tech", "assets", encodeProps(_object))
+			end
 		end
 		self.trove:add(TypeTorch:onSwapOut(function(info)
 			local _self = self
@@ -1500,7 +1516,7 @@ do
 				end
 			end)
 			if not ok then
-				warn("[src/analytics/server.ts:1078]", `[analytics] client message failed: {string.sub(tostring(err), 1, 200)}`)
+				warn("[src/analytics/server.ts:1086]", `[analytics] client message failed: {string.sub(tostring(err), 1, 200)}`)
 			end
 		end)
 		self.trove:add(function()
@@ -1783,7 +1799,7 @@ do
 		self.lastWarnAt = now
 		local more = if self.suppressed > 0 then ` (+{self.suppressed} more in the last minute)` else ""
 		self.suppressed = 0
-		warn("[src/analytics/server.ts:1273]", `[analytics] {message}{more}`)
+		warn("[src/analytics/server.ts:1281]", `[analytics] {message}{more}`)
 		return true
 	end
 	function ServerAnalytics:noteSuccess()

package/out/assets/dom.d.ts

@@ -13,5 +13,13 @@ export declare function resolveParent(path: string, create: boolean): Instance |
  * cloning a UI template into PlayerGui) keep the tag and the attributes but live elsewhere, so they never count.
  */
 export declare function isLiveCopy(instance: Instance): boolean;
+/**
+ * Copies the CollectionService tags of `from` and its descendants onto the instances at the same place in `to` (matched
+ * by name, and by order among siblings of the same name); AssetSync's own `__typetorch_asset:` tags stay out. A loaded
+ * hot-asset version arrives without the tags its place copy has (2026-10-13: a game that finds its UI by tag lost it
+ * on every server that loaded the uploads), so the load gives them back from the place's copy before it goes live.
+ * Returns how many tags were added.
+ */
+export declare function restoreTags(from: Instance, to: Instance): number;
 /** The live copies tagged for `key` (normally one; two for a moment while a new version replaces the old). */
 export declare function liveCopies(key: string): Instance[];

package/out/assets/dom.luau

@@ -2,6 +2,7 @@
 local TS = _G[script]
 local CollectionService = TS.import(script, TS.getModule(script, "@rbxts", "services")).CollectionService
 local _manifest = TS.import(script, script.Parent, "manifest")
+local ASSET_TAG_PREFIX = _manifest.ASSET_TAG_PREFIX
 local assetTag = _manifest.assetTag
 local ATTR_PATH = _manifest.ATTR_PATH
 local pathSegments = _manifest.pathSegments
@@ -73,6 +74,68 @@ local function isLiveCopy(instance)
 	local parent = instance.Parent
 	return path ~= nil and parent ~= nil and resolveParent(path, false) == parent
 end
+--[[
+	*
+	 * Copies the CollectionService tags of `from` and its descendants onto the instances at the same place in `to` (matched
+	 * by name, and by order among siblings of the same name); AssetSync's own `__typetorch_asset:` tags stay out. A loaded
+	 * hot-asset version arrives without the tags its place copy has (2026-10-13: a game that finds its UI by tag lost it
+	 * on every server that loaded the uploads), so the load gives them back from the place's copy before it goes live.
+	 * Returns how many tags were added.
+	 
+]]
+local function restoreTags(from, to)
+	local added = 0
+	local visit
+	visit = function(source, target)
+		for _, tag in source:GetTags() do
+			local _arg1 = #ASSET_TAG_PREFIX
+			local _condition = string.sub(tag, 1, _arg1) == ASSET_TAG_PREFIX
+			if not _condition then
+				_condition = target:HasTag(tag)
+			end
+			if _condition then
+				continue
+			end
+			target:AddTag(tag)
+			added += 1
+		end
+		local byName = {}
+		for _, child in target:GetChildren() do
+			local _name = child.Name
+			local list = byName[_name]
+			if list == nil then
+				local _name_1 = child.Name
+				local _arg1 = { child }
+				byName[_name_1] = _arg1
+			else
+				table.insert(list, child)
+			end
+		end
+		local seen = {}
+		for _, child in source:GetChildren() do
+			local _name = child.Name
+			local _condition = seen[_name]
+			if _condition == nil then
+				_condition = 0
+			end
+			local index = _condition
+			local _name_1 = child.Name
+			local _arg1 = index + 1
+			seen[_name_1] = _arg1
+			local _name_2 = child.Name
+			local _match = byName[_name_2]
+			if _match ~= nil then
+				_match = _match[index + 1]
+			end
+			local match = _match
+			if match ~= nil then
+				visit(child, match)
+			end
+		end
+	end
+	visit(from, to)
+	return added
+end
 --* The live copies tagged for `key` (normally one; two for a moment while a new version replaces the old). 
 local function liveCopies(key)
 	local _exp = CollectionService:GetTagged(assetTag(key))
@@ -93,5 +156,6 @@ return {
 	stringAttribute = stringAttribute,
 	resolveParent = resolveParent,
 	isLiveCopy = isLiveCopy,
+	restoreTags = restoreTags,
 	liveCopies = liveCopies,
 }

package/out/assets/manifest.d.ts

@@ -23,6 +23,14 @@ export declare const ATTR_VERSION = "TypeTorchAssetVersion";
  * a template are tagged too: only an instance whose Parent is still this path counts as the live one.
  */
 export declare const ATTR_PATH = "TypeTorchAssetPath";
+/**
+ * The place's backup build (ServerStorage.TypeTorchBackup) vouches for the place's hot-asset copies after the CLI's
+ * backup refresh published the place (cli commands/backup.ts, kernelpatch-task step 4b): `HotAssetsPlaceVersion` is the
+ * lockfile placeVersion the copies match, `HotAssetsSavedAs` the place version that save became.
+ */
+export declare const BACKUP_NAME = "TypeTorchBackup";
+export declare const ATTR_BACKUP_PLACE_VERSION = "HotAssetsPlaceVersion";
+export declare const ATTR_BACKUP_SAVED_AS = "HotAssetsSavedAs";
 export declare const MAX_KEY_LENGTH = 64;
 export type AssetRealm = "replicated" | "server";
 /** One manifest entry (one key), validated. */
@@ -95,6 +103,20 @@ export interface AssetDecision {
      */
     fallbackBaked?: number;
 }
+/**
+ * Whether this server's place holds exactly the copies the manifest was exported from:
+ * - same: the manifest names this place version;
+ * - vouched: it names another one, but the place's backup says this version is a save of that one that changed nothing
+ *   outside the kernel slots (`backup` = its HotAssetsPlaceVersion / HotAssetsSavedAs);
+ * - differs: neither (new servers load every key whose baked copy has no matching hash);
+ * - unknown: the manifest names no place version.
+ */
+export type PlaceMatch = "same" | "vouched" | "differs" | "unknown";
+export interface BackupVouch {
+    placeVersion?: number;
+    savedAs?: number;
+}
+export declare function placeMatchesManifest(manifestVersion: number | undefined, placeVersion: number, backup?: BackupVouch): PlaceMatch;
 /**
  * What AssetSync does for one key:
  * 1. keep the tagged copy whose TypeTorchAssetVersion is the manifest's `ver` (the newest one if several);
@@ -122,12 +144,19 @@ export interface AssetStatus {
     ms?: number;
     /** Loaded after the start-up wait ran out. */
     late?: boolean;
+    /** CollectionService tags a loaded copy got back from the place's copy (restoreTags). */
+    tags?: number;
 }
 export interface AssetSyncReport {
     /** none: the artifact has no Assets attribute; invalid: unusable; unread: reading it failed (see errors). */
     manifest: "none" | "ok" | "invalid" | "unread";
     /** Where the manifest was found: "mount", "Server" (the payload's Server folder) or "payload" (re-read). */
     from?: string;
+    /** placeMatchesManifest: whether the place's copies are the manifest's ("differs": the upload path). */
+    place?: PlaceMatch;
+    /** The manifest's placeVersion and this server's game.PlaceVersion. */
+    manifestPlaceVersion?: number;
+    placeVersion?: number;
     errors: string[];
     /** AssetSync is still holding the generation's start. */
     running: boolean;
@@ -138,6 +167,8 @@ export interface AssetSyncReport {
     /** Tagged keys this manifest doesn't name: left as they are. */
     unmanaged: string[];
 }
+/** Keys per source, and the rest of what the `tech` / `assets` analytics row carries (SCHEMA.md). */
+export declare function assetCounts(report: AssetSyncReport): Record<string, unknown>;
 /** What Server > Status needs (devtools ServerFacts.assets). */
 export interface AssetFacts {
     failed: number;

package/out/assets/manifest.luau

@@ -28,6 +28,16 @@ local ATTR_VERSION = "TypeTorchAssetVersion"
 	 
 ]]
 local ATTR_PATH = "TypeTorchAssetPath"
+--[[
+	*
+	 * The place's backup build (ServerStorage.TypeTorchBackup) vouches for the place's hot-asset copies after the CLI's
+	 * backup refresh published the place (cli commands/backup.ts, kernelpatch-task step 4b): `HotAssetsPlaceVersion` is the
+	 * lockfile placeVersion the copies match, `HotAssetsSavedAs` the place version that save became.
+	 
+]]
+local BACKUP_NAME = "TypeTorchBackup"
+local ATTR_BACKUP_PLACE_VERSION = "HotAssetsPlaceVersion"
+local ATTR_BACKUP_SAVED_AS = "HotAssetsSavedAs"
 local MAX_KEY_LENGTH = 64
 local MAX_ASSETS = 1000
 local MAX_ERRORS = 20
@@ -255,6 +265,28 @@ end
 -- The decision --------------------------------------------------------------------------------------------------------
 --* A live (tagged) copy of the key: its TypeTorchAssetVersion. Only copies whose Parent is their own path count. 
 --* An untagged copy of the key under the entry's path (the place's baked copy): its TypeTorchAssetHash. 
+--[[
+	*
+	 * Whether this server's place holds exactly the copies the manifest was exported from:
+	 * - same: the manifest names this place version;
+	 * - vouched: it names another one, but the place's backup says this version is a save of that one that changed nothing
+	 *   outside the kernel slots (`backup` = its HotAssetsPlaceVersion / HotAssetsSavedAs);
+	 * - differs: neither (new servers load every key whose baked copy has no matching hash);
+	 * - unknown: the manifest names no place version.
+	 
+]]
+local function placeMatchesManifest(manifestVersion, placeVersion, backup)
+	if manifestVersion == nil then
+		return "unknown"
+	end
+	if manifestVersion == placeVersion then
+		return "same"
+	end
+	if backup ~= nil and backup.placeVersion == manifestVersion and backup.savedAs == placeVersion then
+		return "vouched"
+	end
+	return "differs"
+end
 local function indexes(count, except)
 	local list = {}
 	do
@@ -328,6 +360,61 @@ local function decideAsset(entry, tagged, baked, placeMatches)
 end
 -- Status (devtools op "assets", Server > Status) ------------------------------------------------------------------------
 --* kept: already live with the manifest version; baked: the place's copy adopted; loaded; failed (see `error`). 
+--* Keys per source, and the rest of what the `tech` / `assets` analytics row carries (SCHEMA.md). 
+local function assetCounts(report)
+	local counts = {
+		kept = 0,
+		baked = 0,
+		loaded = 0,
+		failed = 0,
+		loading = 0,
+	}
+	local missing = 0
+	local late = 0
+	local first
+	for _, status in report.entries do
+		local _condition = counts[status.source]
+		if _condition == nil then
+			_condition = 0
+		end
+		counts[status.source] = _condition + 1
+		if not status.live then
+			missing += 1
+		end
+		if status.late == true then
+			late += 1
+		end
+		if status.source == "failed" and first == nil then
+			local _exp = status.key
+			local _condition_1 = status.error
+			if _condition_1 == nil then
+				_condition_1 = "failed"
+			end
+			first = `{_exp}: {_condition_1}`
+		end
+	end
+	local _object = {
+		manifest = report.manifest,
+		place = report.place,
+		mpv = report.manifestPlaceVersion,
+		pv = report.placeVersion,
+		keys = #report.entries,
+	}
+	for _k, _v in counts do
+		_object[_k] = _v
+	end
+	_object.missing = missing
+	_object.late = late
+	_object.timedOut = report.timedOut == true
+	_object.ms = report.ms
+	local _left = "first"
+	local _condition = first
+	if _condition == nil then
+		_condition = report.errors[1]
+	end
+	_object[_left] = _condition
+	return _object
+end
 --* What Server > Status needs (devtools ServerFacts.assets). 
 local function summarizeAssets(report)
 	if report.manifest == "none" and #report.errors == 0 then
@@ -368,7 +455,9 @@ return {
 	pathSegments = pathSegments,
 	realmOfPath = realmOfPath,
 	parseManifest = parseManifest,
+	placeMatchesManifest = placeMatchesManifest,
 	decideAsset = decideAsset,
+	assetCounts = assetCounts,
 	summarizeAssets = summarizeAssets,
 	ASSET_TAG_PREFIX = ASSET_TAG_PREFIX,
 	ATTR_KEY = ATTR_KEY,
@@ -376,5 +465,8 @@ return {
 	ATTR_HASH = ATTR_HASH,
 	ATTR_VERSION = ATTR_VERSION,
 	ATTR_PATH = ATTR_PATH,
+	BACKUP_NAME = BACKUP_NAME,
+	ATTR_BACKUP_PLACE_VERSION = ATTR_BACKUP_PLACE_VERSION,
+	ATTR_BACKUP_SAVED_AS = ATTR_BACKUP_SAVED_AS,
 	MAX_KEY_LENGTH = MAX_KEY_LENGTH,
 }

package/out/assets/sync.luau

@@ -4,10 +4,12 @@ local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
 local CollectionService = _services.CollectionService
 local HttpService = _services.HttpService
 local InsertService = _services.InsertService
+local ServerStorage = _services.ServerStorage
 local _dom = TS.import(script, script.Parent, "dom")
 local liveCopies = _dom.liveCopies
 local numberAttribute = _dom.numberAttribute
 local resolveParent = _dom.resolveParent
+local restoreTags = _dom.restoreTags
 local stringAttribute = _dom.stringAttribute
 local _manifest = TS.import(script, script.Parent, "manifest")
 local assetTag = _manifest.assetTag
@@ -15,10 +17,14 @@ local ATTR_HASH = _manifest.ATTR_HASH
 local ATTR_ID = _manifest.ATTR_ID
 local ATTR_KEY = _manifest.ATTR_KEY
 local ATTR_PATH = _manifest.ATTR_PATH
+local ATTR_BACKUP_PLACE_VERSION = _manifest.ATTR_BACKUP_PLACE_VERSION
+local ATTR_BACKUP_SAVED_AS = _manifest.ATTR_BACKUP_SAVED_AS
 local ATTR_VERSION = _manifest.ATTR_VERSION
+local BACKUP_NAME = _manifest.BACKUP_NAME
 local decideAsset = _manifest.decideAsset
 local keyOfTag = _manifest.keyOfTag
 local parseManifest = _manifest.parseManifest
+local placeMatchesManifest = _manifest.placeMatchesManifest
 local summarizeAssets = _manifest.summarizeAssets
 --[[
 	*
@@ -217,6 +223,17 @@ local function readManifest(kernel, deadline)
 		from = "payload",
 	}
 end
+--* What the place's backup build says about its hot-asset copies (BackupVouch), if anything. 
+local function backupVouch()
+	local backup = ServerStorage:FindFirstChild(BACKUP_NAME)
+	if backup == nil then
+		return nil
+	end
+	return {
+		placeVersion = numberAttribute(backup, ATTR_BACKUP_PLACE_VERSION),
+		savedAs = numberAttribute(backup, ATTR_BACKUP_SAVED_AS),
+	}
+end
 --* Marks `instance` as the live copy of `entry` (attributes first, so they replicate with the tag). 
 local function stamp(instance, entry, version)
 	instance:SetAttribute(ATTR_KEY, entry.key)
@@ -283,7 +300,7 @@ local function loadCopy(entry)
 	container:Destroy()
 	local removed = stripScripts(root)
 	if removed > 0 then
-		warn("[src/assets/sync.ts:204]", `hot asset {entry.key}: removed {removed} scripts`)
+		warn("[src/assets/sync.ts:215]", `hot asset {entry.key}: removed {removed} scripts`)
 	end
 	return root
 end
@@ -393,6 +410,50 @@ local function syncEntry(entry, status, placeMatches, ownEpoch, threads)
 				if target == nil then
 					error(`no {string.split(entry.path, "/")[1]} service`, 0)
 				end
+				-- The uploaded version has no CollectionService tags: the place's copy (on a hot swap, the copy being
+				-- replaced, which got them the same way) gives them back (restoreTags).
+				local _result_1
+				if fallback ~= nil and fallback.Parent ~= nil then
+					_result_1 = fallback
+				else
+					-- ▼ ReadonlyArray.find ▼
+					local _callback_2 = function(candidate)
+						return candidate.Parent ~= nil
+					end
+					local _result_2
+					for _i, _v in baked do
+						if _callback_2(_v, _i - 1, baked) == true then
+							_result_2 = _v
+							break
+						end
+					end
+					-- ▲ ReadonlyArray.find ▲
+					_result_1 = _result_2
+				end
+				local source = _result_1
+				do
+					local index = #tagged - 1
+					local _shouldIncrement = false
+					while true do
+						if _shouldIncrement then
+							index -= 1
+						else
+							_shouldIncrement = true
+						end
+						if not (source == nil and index >= 0) then
+							break
+						end
+						if tagged[index + 1].Parent ~= nil then
+							source = tagged[index + 1]
+						end
+					end
+				end
+				if source ~= nil then
+					local restored = restoreTags(source, copy)
+					if restored > 0 then
+						status.tags = restored
+					end
+				end
 				stamp(copy, entry, entry.ver)
 				copy.Parent = target
 			end)
@@ -409,7 +470,7 @@ local function syncEntry(entry, status, placeMatches, ownEpoch, threads)
 			if _condition == nil then
 				_condition = entry.ver
 			end
-			warn("[src/assets/sync.ts:287]", `hot asset {_exp_1} (version {_condition}) failed: {reason}`)
+			warn("[src/assets/sync.ts:308]", `hot asset {_exp_1} (version {_condition}) failed: {reason}`)
 			return nil
 		end
 		-- The new copy is live: the copies it replaces go.
@@ -422,7 +483,7 @@ local function syncEntry(entry, status, placeMatches, ownEpoch, threads)
 		status.ms = math.floor((os.clock() - started) * 1000)
 		if late then
 			status.late = true
-			print("[src/assets/sync.ts:300]", `hot asset {entry.key} loaded late ({status.ms} ms)`)
+			print("[src/assets/sync.ts:321]", `hot asset {entry.key} loaded late ({status.ms} ms)`)
 		end
 	end)
 	table.insert(_threads, _arg0)
@@ -471,7 +532,16 @@ local function run(kernel, deadline, ownEpoch, threads)
 	end
 	setManifest(manifest)
 	report.manifest = "ok"
-	local placeMatches = manifest.placeVersion ~= nil and manifest.placeVersion == game.PlaceVersion
+	-- A publish that changed nothing outside the kernel slots (the CLI's backup refresh) doesn't move servers to the
+	-- upload path: the backup vouches for the version it saved (2026-10-13 incident).
+	local place = placeMatchesManifest(manifest.placeVersion, game.PlaceVersion, backupVouch())
+	report.place = place
+	report.manifestPlaceVersion = manifest.placeVersion
+	report.placeVersion = game.PlaceVersion
+	local placeMatches = place == "same" or place == "vouched"
+	if place == "differs" then
+		warn("[src/assets/sync.ts:366]", `hot assets: the manifest is for place v{manifest.placeVersion}, this server runs v{game.PlaceVersion}: keys without a matching baked copy load from their uploaded versions (typetorch assets sync --deploy <branch> fixes it)`)
+	end
 	local loads = {}
 	for _, entry in manifest.entries do
 		local status = {
@@ -490,7 +560,7 @@ local function run(kernel, deadline, ownEpoch, threads)
 		if not ok then
 			status.source = "failed"
 			status.error = shortError(result)
-			warn("[src/assets/sync.ts:347]", `hot asset {entry.key} failed: {status.error}`)
+			warn("[src/assets/sync.ts:379]", `hot asset {entry.key} failed: {status.error}`)
 		elseif result ~= nil then
 			table.insert(loads, result)
 		end
@@ -524,7 +594,7 @@ local function run(kernel, deadline, ownEpoch, threads)
 		end
 		report.timedOut = true
 		load.fail("timed out")
-		warn("[src/assets/sync.ts:356]", `hot asset {load.status.key}: still loading; the old copy stays until it finishes`)
+		warn("[src/assets/sync.ts:388]", `hot asset {load.status.key}: still loading; the old copy stays until it finishes`)
 	end
 	report.unmanaged = unmanagedKeys()
 end
@@ -571,7 +641,7 @@ local function syncHotAssets(kernel, trove)
 		local _errors = report.errors
 		local _arg0 = `AssetSync failed: {shortError(err)}`
 		table.insert(_errors, _arg0)
-		warn("[src/assets/sync.ts:385]", `AssetSync failed: {err}`)
+		warn("[src/assets/sync.ts:417]", `AssetSync failed: {err}`)
 	end
 	report.running = false
 	report.ms = math.floor((os.clock() - started) * 1000)
@@ -592,7 +662,7 @@ local function syncHotAssets(kernel, trove)
 			table.insert(parts, _arg0)
 		end
 		table.sort(parts)
-		print("[src/assets/sync.ts:395]", `hot assets: {table.concat(parts, ", ")} in {report.ms} ms`)
+		print("[src/assets/sync.ts:427]", `hot assets: {table.concat(parts, ", ")} in {report.ms} ms (place {report.place or "?"})`)
 	end
 end
 return {

package/out/devtools/assets-ui.luau

@@ -63,6 +63,19 @@ local function drawServer(target, report)
 		target:field("Manifest", if ok then `{#report.entries} keys{if report.from ~= nil then `  ({report.from})` else ""}` else report.manifest, if ok then COLORS.text else COLORS.warn)
 		local sync = if report.running then "Running" elseif report.ms ~= nil then `{report.ms} ms{if report.timedOut == true then "  timed out" else ""}` else "-"
 		target:field("Sync", sync, if report.timedOut == true then COLORS.warn else COLORS.text)
+		if report.place ~= nil then
+			local _condition = report.manifestPlaceVersion
+			if _condition == nil then
+				_condition = "?"
+			end
+			local _condition_1 = report.placeVersion
+			if _condition_1 == nil then
+				_condition_1 = "?"
+			end
+			local versions = `manifest v{_condition}, place v{_condition_1}`
+			local place = if report.place == "differs" then `differs ({versions}): keys load from uploads` elseif report.place == "vouched" then `vouched by the backup ({versions})` else report.place
+			target:field("Place", place, if report.place == "differs" then COLORS.warn else COLORS.text)
+		end
 		for _, why in report.errors do
 			target:text(why, COLORS.warn)
 		end
@@ -188,7 +201,7 @@ local function renderAssetsTab(tab, options)
 					end
 				end)
 				if not ok then
-					warn("[src/devtools/assets-ui.ts:138]", `[devtools] assets refresh failed: {err}`)
+					warn("[src/devtools/assets-ui.ts:143]", `[devtools] assets refresh failed: {err}`)
 				end
 				task.wait(REFRESH)
 			end

package/out/devtools/health.d.ts

@@ -2,7 +2,7 @@ import type { AnalyticsStats } from "../analytics/schema";
 import type { AssetFacts } from "../assets/manifest";
 import type { DetachedStatus, ErrorReportsStatus, FleetSenderInfo, HealthInfo, KernelStatus, PerfSummary, SettingsStatus } from "../kernel";
 /** The newest kernel this framework release knows about. Bump it with every kernel release. */
-export declare const LATEST_KERNEL = "0.5.1";
+export declare const LATEST_KERNEL = "0.5.3";
 /**
  * The live health window while it is open (kernel 0.3.7 thresholds; older kernels: 3): "1/3 errors, 24 s left", plus
  * ", no rollback" when a failure would only mark the server degraded. Undefined once the window closed.

package/out/devtools/health.luau

@@ -2,7 +2,7 @@
 local TS = _G[script]
 local describeFleetError = TS.import(script, script.Parent.Parent, "analytics", "hints").describeFleetError
 --* The newest kernel this framework release knows about. Bump it with every kernel release. 
-local LATEST_KERNEL = "0.5.1"
+local LATEST_KERNEL = "0.5.3"
 --* Kernels before 0.3.7 use fixed thresholds: 3 errors within 30 s of ready roll back. 
 local OLD_HEALTH_ERRORS = 3
 local OLD_HEALTH_WINDOW = 30

package/out/version.d.ts

@@ -2,4 +2,4 @@
  * This framework's version, as package.json says (scripts/test-state-inspect.luau checks they match). Shown in
  * uploaded log headers (Logs > Upload); bump it with package.json.
  */
-export declare const FRAMEWORK_VERSION = "0.5.2";
+export declare const FRAMEWORK_VERSION = "0.5.4";

package/out/version.luau

@@ -5,7 +5,7 @@
 	 * uploaded log headers (Logs > Upload); bump it with package.json.
 	 
 ]]
-local FRAMEWORK_VERSION = "0.5.2"
+local FRAMEWORK_VERSION = "0.5.4"
 return {
 	FRAMEWORK_VERSION = FRAMEWORK_VERSION,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@typetorch/framework",
-	"version": "0.5.2",
+	"version": "0.5.4",
 	"description": "TypeTorch framework for roblox-ts: hot-swappable modules (dependency injection, lifecycle, troves), guarded networking, hot assets and the in-game dev menu. Ships inside every TypeTorch artifact.",
 	"license": "MIT",
 	"author": "TypeTorch",