@tsplc/build 0.2.6 → 0.2.7

package/python/build.py

@@ -15,6 +15,8 @@ except NameError:
 import shutil
 import time
 
+from hardware import apply_controller, configure_device_tree, import_device_description, verify_pinned
+
 
 class CompilerError(RuntimeError):
 	def __init__(self, diagnostics):
@@ -98,14 +100,18 @@ def object_key(spec):
 		tuple(object_key(child) for child in spec.get("children", [])))
 
 
-def project_key(request):
+def template_key(request):
+	"""Everything a build imports into besides its source objects."""
 	return (request["templateHash"], request["entry"], request["task"],
 		tuple(request["removeObjects"]), request["symbols"], tuple(request.get("libraryReferences", [])),
 		json.dumps(request.get("deviceTree"), sort_keys=True),
 		json.dumps(request.get("controller"), sort_keys=True),
         tuple((item["title"],item["sha256"],item.get("namespace")) for item in request.get("libraries", [])),
-		tuple((task["name"], task["intervalNanoseconds"], task["priority"], tuple(task["programs"])) for task in request.get("tasks", [])),
-		tuple(object_key(spec) for spec in request["objects"]))
+		tuple((task["name"], task["intervalNanoseconds"], task["priority"], tuple(task["programs"])) for task in request.get("tasks", [])))
+
+
+def project_key(request):
+	return template_key(request) + (tuple(object_key(spec) for spec in request["objects"]),)
 
 
 def unique_child(parent, name):
@@ -150,14 +156,21 @@ def create_object(engine, parent, spec):
 	raise RuntimeError("Unsupported IEC object kind " + kind)
 
 
-def import_object(engine, parent, spec):
+def import_object(engine, parent, spec, previous):
+	"""Writes the object's text unless `previous`, the spec the project already holds, has the same.
+	Each write costs a parse, and a compiler model that sees nothing changed builds and transfers less.
+	Returns how many objects were written."""
 	obj = unique_child(parent, spec["name"])
 	if obj is None:
 		obj = create_object(engine, parent, spec)
-	if spec["kind"] != "action":
-		obj.textual_declaration.replace(spec["declaration"])
-	if "implementation" in spec:
-		obj.textual_implementation.replace(spec["implementation"])
+		previous = None
+	written = 0
+	if previous is None or any(previous.get(key) != spec.get(key) for key in ("declaration", "implementation")):
+		if spec["kind"] != "action":
+			obj.textual_declaration.replace(spec["declaration"])
+		if "implementation" in spec:
+			obj.textual_implementation.replace(spec["implementation"])
+		written = 1
 	children = spec.get("children", [])
 	if spec["kind"] == "property":
 		# Remove default accessors absent from source (e.g. a read-only property).
@@ -165,8 +178,10 @@ def import_object(engine, parent, spec):
 		for child in list(obj.get_children()):
 			if child.get_name().lower() in ("get", "set") and child.get_name().lower() not in names:
 				child.remove()
+	held = dict((child["name"].lower(), child) for child in previous.get("children", [])) if previous else {}
 	for child in children:
-		import_object(engine, obj, child)
+		written += import_object(engine, obj, child, held.get(child["name"].lower()))
+	return written
 
 
 def install_project_libraries(engine, application, libraries, progress):
@@ -215,14 +230,62 @@ def install_project_libraries(engine, application, libraries, progress):
 			refs[0].namespace = namespace
 
 
-def import_objects(engine, application, request, reusing, progress):
+def same_kind(old, fresh):
+	return old["kind"] == fresh["kind"] and bool(old.get("persistent")) == bool(fresh.get("persistent"))
+
+
+def remove_deleted(parent, previous, current, gone):
+	"""Reconcile only source-owned objects; preserve GUIDs of unchanged objects."""
+	new = {item["name"].lower(): item for item in current}
+	for old in previous:
+		obj = unique_child(parent, old["name"])
+		fresh = new.get(old["name"].lower())
+		if obj is None:
+			raise RuntimeError("Saved source object is missing: " + old["name"])
+		if fresh is None:
+			gone.append(obj)
+		elif not same_kind(old, fresh):
+			obj.remove()
+		else:
+			remove_deleted(obj, old.get("children", []), fresh.get("children", []), gone)
+
+
+def reconcile(application, previous, current):
+	"""Removes the source objects the import recreates: those whose kind changed, and those moved to
+	another folder. Returns the objects gone from the source. Remove them once the import has rewritten
+	what used them: CODESYS fails ("Value cannot be null") removing a type or POU that is still in use."""
+	new = {(tuple(item["folder"]), item["name"].lower()): item for item in current}
+	names = set(item["name"].lower() for item in current)
+	gone = []
+	for old in previous:
+		parent = application
+		for name in old["folder"]:
+			parent = unique_child(parent, name)
+			if parent is None:
+				raise RuntimeError("Saved source folder is missing: " + name)
+		fresh = new.get((tuple(old["folder"]), old["name"].lower()))
+		if fresh is None and old["name"].lower() in names:
+			# A folder move changes placement rather than text. Remove/recreate just
+			# that moved object, letting the vendor decide whether the update is valid.
+			moved = unique_child(parent, old["name"])
+			if moved is None:
+				raise RuntimeError("Saved source object is missing: " + old["name"])
+			moved.remove()
+		else:
+			remove_deleted(parent, [old], [fresh] if fresh else [], gone)
+	return gone
+
+
+def import_objects(engine, application, request, previous, progress):
+	"""`previous` lists the source objects the project already holds, reconciled with this request;
+	None imports every object afresh."""
 	install_project_libraries(engine, application, request.get("libraries", []), progress)
 	if request.get("libraryReferences"):
 		manager = application.get_library_manager()
 		for reference in request["libraryReferences"]:
 			manager.add_library(reference)
 	progress("Importing source objects")
-	if not reusing:
+	if previous is None:
 		for name in request["removeObjects"]:
 			for obj in application.find_ignore_transient_objects(name, True):
 				obj.remove()
@@ -233,6 +296,8 @@ def import_objects(engine, application, request, reusing, progress):
 				raise RuntimeError("Ambiguous IEC object " + spec["name"])
 			for obj in existing:
 				obj.remove()
+	held = dict(((tuple(item["folder"]), item["name"].lower()), item) for item in previous or [])
+	written = 0
 	for spec in request["objects"]:
 		parent = application
 		for name in spec["folder"]:
@@ -246,7 +311,8 @@ def import_objects(engine, application, request, reusing, progress):
 			elif not folder.is_folder:
 				raise RuntimeError("Source folder conflicts with IEC object " + name)
 			parent = folder
-		import_object(engine, parent, spec)
+		written += import_object(engine, parent, spec, held.get((tuple(spec["folder"]), spec["name"].lower())))
+	progress("Wrote {0} source objects".format(written))
 	if "tasks" in request:
 		return configure_tasks(engine, application, request["tasks"], request["objects"])
 	matches = application.find_ignore_transient_objects(request["task"], True)
@@ -337,268 +403,34 @@ def configure_tasks(engine, application, tasks, objects):
 	return tasks
 
 
-# CODESYS EDS Import's converter factory; plain import_device expects device XML.
-EDS_CONVERTER = "1ce4a9c1-37d3-496c-9e80-cd99ad3807ee"
-ETHERNET = ("Ethernet", 110, "0000 0002", "4.2.0.0")
-SCANNER = ("EtherNet_IP_Scanner", 100, "0000 100B", "4.9.0.0")
-# Ethernet adapter interface settings and EtherNet/IP adapter parameter IDs.
-# The interface name is a STRING (10) and a WSTRING (12); the device editor and runtime read the WSTRING.
-ETHERNET_PARAMETERS = (("address", 0), ("subnet", 1), ("gateway", 2), ("interface", 10), ("interface", 12))
-TARGET_ADDRESS = 256
-CONNECTION_SETTINGS = 268435457
-MODBUS_CLIENT = ("Modbus_TCP_Client", 88, "0000 0003", "4.6.0.0")
-MODBUS_SERVER = (89, "0000 0005", "4.6.0.0")
-MODBUS_EDITOR = r"C:\CODESYS-3.5.22.30\CODESYS\PlugIns\7e343689-9a5f-46aa-bf56-5903c4efec59\4.6.0.0\DeviceEditorModbus.plugin.dll"
-# Modbus client and server parameter IDs.
-MODBUS_AUTO_RECONNECT = 9002
-MODBUS_CHANNEL_STATUS = 9003
-MODBUS_ADDRESS = 9102
-MODBUS_PORT = 9103
-# The editor's parameter IDs for channel number n: n * 2^24 plus these.
-MODBUS_CHANNEL = 1 << 24
-MODBUS_TRIGGER = 0x200001
-MODBUS_STATUS = 0x200002
-MODBUS_REQUESTS = 0x200003
-MODBUS_HOLDING_WRITE = 0x840000
-MODBUS_WRITE_SINGLE_REGISTER = 6
-MODBUS_RISING_EDGE = 6
-
-
-def host_parameters(device):
-	connectors = [connector for connector in device.connectors if len(list(connector.host_parameters))]
-	if len(connectors) != 1:
-		raise RuntimeError("Expected one configurable connector on " + device.get_name())
-	return dict((parameter.id, parameter) for parameter in connectors[0].host_parameters)
-
-
-def child_device(engine, parent, spec):
-	name, kind, identifier, version = spec
-	parent.add(name, kind, identifier, version)
-	matches = [child for child in parent.find(name, False) if getattr(child, "is_device", False)]
-	if len(matches) != 1:
-		raise RuntimeError("Could not add device " + name)
-	return matches[0]
-
-
-def set_parameter(parameter, value):
-	parameter.value = value
-	if unicode(parameter.value).replace(" ", "") != unicode(value).replace(" ", ""):
-		raise RuntimeError("{0} reads back {1}, not {2}".format(parameter.visible_name, parameter.value, value))
-
-
-def string_literal(parameter, text):
-	return ('"{0}"' if parameter.type_string == "WSTRING" else "'{0}'").format(text)
-
-
-def ip_array(address, hexadecimal=False):
-	octets = [int(octet) for octet in address.split(".")]
-	return "[" + ",".join("16#{0:02X}".format(octet) if hexadecimal else str(octet) for octet in octets) + "]"
-
-
-def pin(channel, address):
-	# CODESYS validates a manual address against the automatic one until it is disabled.
-	channel.io_mapping.manual_iec_address = address
-	channel.io_mapping.automatic_iec_address = False
-
-
-def settle(pinned):
-	"""Pin only channels whose automatic address differs; each write revalidates the whole tree."""
-	for address, channel in sorted(pinned.items()):
-		# An automatic mapping reports its assigned address here.
-		if channel.io_mapping.manual_iec_address != address:
-			pin(channel, address)
-
-
-def pin_channels(engine, adapter, parameters, device):
-	"""Give each raw payload byte the address of its offset, so AT declarations read it."""
-	pinned = {}
-	for direction, region, kind in (("inputs", "I", engine.ChannelType.Input), ("outputs", "Q", engine.ChannelType.Output)):
-		channels = sorted((parameter for parameter in parameters.values() if parameter.channel_type == kind), key=lambda parameter: parameter.id)
-		area = device.get(direction)
-		if not area:
-			if channels:
-				raise RuntimeError("{0} has {1} without a configured address".format(device["name"], direction))
-			continue
-		if len(channels) != area["size"] or any(channel.bit_size != 8 for channel in channels):
-			raise RuntimeError("{0} {1} are not {2} raw byte channels".format(device["name"], direction, area["size"]))
-		base = int(area["address"][3:])
-		# Later automatic channels follow the first one consecutively.
-		pin(channels[0], "%{0}B{1}".format(region, base))
-		for offset, channel in enumerate(channels):
-			pinned["%{0}B{1}".format(region, base + offset)] = channel
-	settle(pinned)
-	return pinned
-
-
-def channel_at(pinned, address):
-	if address in pinned:
-		return pinned[address]
-	match = re.match(r"^%([IQ])(X|B)(\d+)(?:\.([0-7]))?$", address)
-	channel = pinned.get("%{0}B{1}".format(match.group(1), match.group(3)))
-	if channel is None:
-		raise RuntimeError("No generated channel at " + address)
-	return list(channel)[int(match.group(4))] if match.group(2) == "X" else channel
-
-
-def map_channels(pinned, tree, application):
-	"""Map bound bits and bytes to their variables; comment the channels of IO that keeps AT."""
-	mapped = set()
-	for mapping in tree.get("mappings", []):
-		channel_at(pinned, mapping["address"]).io_mapping.variable = application + "." + mapping["variable"]
-		mapped.add(mapping["address"])
-	for device in tree["devices"]:
-		for comment in device.get("comments", []):
-			if comment["address"] not in mapped:
-				channel_at(pinned, comment["address"]).user_comment = comment["text"]
-
-
-def add_modbus_channel(project, server, register):
-	"""Add a write channel with the editor's own routine: CODESYS scripting has no API for channels."""
-	from System import Activator, Array, Enum, Object, UInt16, UInt32
-	from System.Reflection import Assembly, BindingFlags
-	flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static
-	editor = Assembly.LoadFrom(MODBUS_EDITOR)
-	def named(name):
-		return editor.GetType("_3S.CoDeSys.DeviceEditorModbus." + name, True)
-	def call(owner, target, name, *arguments):
-		return owner.GetMethod(name, flags).Invoke(target, Array[Object](list(arguments)))
-	manager = named("APEnvironment").GetProperty("ObjectMgr", flags).GetValue(None, None)
-	meta = manager.GetObjectToModify(project.handle, server.guid)
-	connector = [item for item in meta.Object.Connectors if str(item.ConnectorRole) == "Child"][0]
-	data = call(named("New.ChannelDataBase"), None, "Create", connector)
-	item_type = named("ModbusChannelItem")
-	item = Activator.CreateInstance(item_type)
-	fields = (
-		("stName", register["name"]),
-		("usFunctionCode", UInt16(MODBUS_WRITE_SINGLE_REGISTER)),
-		("usWriteOffset", UInt16(register["offset"])),
-		("usWriteLength", UInt16(1)),
-		("usReadLength", UInt16(0)),
-		("triggerType", Enum.ToObject(named("TriggerType"), MODBUS_RISING_EDGE)),
-		("uiParamID", call(data.GetType(), data, "GetNextAvailableParamID", call(data.GetType(), data, "LoadSlaveChannels", connector))),
-	)
-	for name, value in fields:
-		item_type.GetField(name).SetValue(item, value)
-	factory = call(named("New.PresetFactory"), None, "Create", connector, False)
-	call(data.GetType(), data, "CreateSlaveChannel", connector, item, factory)
-	manager.SetObject(meta, True, None)
-	return int(UInt32(item_type.GetField("uiParamID").GetValue(item))) // MODBUS_CHANNEL
-
-
-def configure_modbus(engine, project, ethernet, devices):
-	"""One Modbus TCP server per card with registers, with channels pinned like the EtherNet/IP bytes."""
-	pinned = {}
-	client = child_device(engine, ethernet, MODBUS_CLIENT)
-	parameters = host_parameters(client)
-	# The line runs unattended, so a card that restarts must come back on its own.
-	set_parameter(parameters[MODBUS_AUTO_RECONNECT], "TRUE")
-	# Status and request count are how the program learns a write finished.
-	set_parameter(parameters[MODBUS_CHANNEL_STATUS], "TRUE")
-	for device in devices:
-		server = child_device(engine, client, (device["name"] + "_Modbus",) + MODBUS_SERVER)
-		server.driver_info.always_update_variables = engine.AlwaysUpdateVariablesMode.OnlyIfUnused
-		parameters = host_parameters(server)
-		set_parameter(parameters[MODBUS_ADDRESS], ip_array(device["address"]))
-		set_parameter(parameters[MODBUS_PORT], str(device["modbus"]["port"]))
-		for register in device["modbus"]["registers"]:
-			channel = add_modbus_channel(project, server, register) * MODBUS_CHANNEL
-			parameters = host_parameters(server)
-			pinned[register["write"]] = parameters[channel + MODBUS_TRIGGER]
-			pinned[register["status"]] = parameters[channel + MODBUS_STATUS]
-			pinned[register["requests"]] = parameters[channel + MODBUS_REQUESTS]
-			pinned[register["value"]] = parameters[channel + MODBUS_HOLDING_WRITE + register["offset"]]
-	settle(pinned)
-	return pinned
-
-
-def template_controller(project):
-	controllers = [child for child in project.get_children() if getattr(child, "is_device", False)]
-	if len(controllers) != 1:
-		raise RuntimeError("The template must contain one controller device")
-	return controllers[0]
-
-
-def apply_controller(project, identity, progress):
-	controller = template_controller(project)
-	wanted = (identity["type"], identity["id"], identity["version"])
-	current = controller.get_device_identification()
-	if (current.type, current.id, current.version) == wanted:
-		return
-	progress("Updating controller to {0} {1} {2}".format(*wanted))
-	# Update Device keeps the Application and its children under the new device.
-	controller.update(*wanted)
-	updated = controller.get_device_identification()
-	if (updated.type, updated.id, updated.version) != wanted:
-		raise RuntimeError("CODESYS kept controller {0} {1} {2}; install the device description for {3} {4} {5}".format(
-			updated.type, updated.id, updated.version, *wanted))
-
-
-def import_device_description(engine, device, root):
-	from System import Guid
-	repository = engine.device_repository
-	identity = repository.import_device(os.path.join(root, device["eds"]), repository.sources[0], Guid(EDS_CONVERTER), True)
-	if identity is None:
-		raise RuntimeError("CODESYS could not import the EDS of " + device["name"])
-	return identity
-
-
-def configure_device_tree(engine, project, tree, root, progress):
-	controller = template_controller(project)
-	for child in controller.get_children(True):
-		if getattr(child, "is_device", False) and child.get_device_identification().type in (ETHERNET[1], SCANNER[1]):
-			raise RuntimeError("Template already configures " + child.get_name() + "; remove it or codesys.deviceTree")
-	progress("Generating EtherNet/IP device tree")
-	ethernet = child_device(engine, controller, ETHERNET)
-	parameters = host_parameters(ethernet)
-	for key, identifier in ETHERNET_PARAMETERS:
-		value = tree.get("ethernet", {}).get(key)
-		if value is not None:
-			set_parameter(parameters[identifier], string_literal(parameters[identifier], value) if key == "interface" else ip_array(value))
-	scanner = child_device(engine, ethernet, SCANNER)
-	pinned = {}
-	for device in tree["devices"]:
-		identity = import_device_description(engine, device, root)
-		adapter = child_device(engine, scanner, (device["name"], identity.type, identity.id, identity.version))
-		# CODESYS otherwise skips mapped variables no IEC code reads, such as inputs only clients observe.
-		adapter.driver_info.always_update_variables = engine.AlwaysUpdateVariablesMode.OnlyIfUnused
-		parameters = host_parameters(adapter)
-		if device.get("address"):
-			set_parameter(parameters[TARGET_ADDRESS], ip_array(device["address"], True))
-		if device.get("rpiMicroseconds"):
-			fields = [field for field in parameters[CONNECTION_SETTINGS] if field.identifier == "RPI"]
-			set_parameter(fields[0], str(device["rpiMicroseconds"]))
-		for address, channel in pin_channels(engine, adapter, parameters, device).items():
-			if address in pinned:
-				raise RuntimeError("{0} overlaps another adapter".format(address))
-			pinned[address] = channel
-	registers = [device for device in tree["devices"] if device.get("modbus")]
-	if registers:
-		progress("Generating Modbus TCP devices")
-		pinned.update(configure_modbus(engine, project, ethernet, registers))
-	# Adding a later adapter can reflow earlier automatic addresses.
-	settle(pinned)
-	map_channels(pinned, tree, project.active_application.get_name())
-	return pinned
-
-
-def verify_pinned(pinned):
-	for address, channel in pinned.items():
-		if channel.io_mapping.manual_iec_address != address:
-			raise RuntimeError("Channel {0} moved to {1}".format(address, channel.io_mapping.manual_iec_address))
-
-
-def device_tree_cache(request, workspace):
-	"""The project as it stands once its device tree is generated, kept beside the worker, which each
-	container starts afresh. Generating the tree takes most of a build, and the same template,
-	controller, tree and generator always produce the same one."""
-	with io.open(__file__, "rb") as source:
-		generator = hashlib.sha256(source.read()).hexdigest()
-	inputs = json.dumps([generator, request["templateHash"], request.get("controller"), request["deviceTree"]], sort_keys=True)
-	return os.path.join(os.path.dirname(workspace), "device-tree", hashlib.sha256(inputs.encode("utf-8")).hexdigest() + ".project")
+def scripts_hash(*names):
+	"""A cached project is only as current as the scripts that made it."""
+	digest = hashlib.sha256()
+	for name in names:
+		with io.open(os.path.join(os.path.dirname(__file__), name), "rb") as source:
+			digest.update(source.read())
+	return digest.hexdigest()
+
+
+def cache_path(directory, kind, scripts, inputs):
+	key = hashlib.sha256(json.dumps([scripts_hash(*scripts)] + inputs, sort_keys=True).encode("utf-8")).hexdigest()
+	return os.path.join(directory, kind, key + ".project")
+
+
+def device_tree_cache(request, directory):
+	"""The project as it stands once its device tree is generated. Generating the tree takes most of
+	a build, and the same template, controller, tree and hardware.py always produce the same one."""
+	return cache_path(directory, "device-tree", ["hardware.py"], [request["templateHash"], request.get("controller"), request["deviceTree"]])
+
+
+def build_cache(request, directory):
+	"""The last successful build's project, beside the source objects it holds (`.json`). Most builds
+	change a few objects, and writing only those is much faster than importing every one."""
+	return cache_path(directory, "last-build", ["build.py", "hardware.py"], list(template_key(request)))
 
 
 def keep_device_tree(pending, cache):
-	"""Replace the previous tree once a build with this one succeeds, so the cache holds one verified tree."""
+	"""Replace the previous tree once a project with this one works, so the cache holds one verified tree."""
 	directory = os.path.dirname(cache)
 	for name in os.listdir(directory):
 		if os.path.join(directory, name) != pending:
@@ -606,22 +438,33 @@ def keep_device_tree(pending, cache):
 	os.rename(pending, cache)
 
 
-def open_project(engine, request, workspace, progress):
-	"""Opens the template with its controller and device tree, from the cache when the tree's inputs match it.
-	Returns the project, the channels it pinned, and a newly generated tree to keep if the build succeeds."""
-	working = os.path.join(workspace, "project")
-	if os.path.isdir(working):
-		shutil.rmtree(working)
-	os.mkdir(working)
-	path = os.path.join(working, "Application.project")
+def keep_build(project, objects, cache):
+	directory = os.path.dirname(cache)
+	if os.path.isdir(directory):
+		shutil.rmtree(directory)
+	os.makedirs(directory)
+	# The project appears last: a cache without its objects would import into unknown source.
+	with io.open(os.path.splitext(cache)[0] + ".json", "w", encoding="utf-8") as output:
+		output.write(u"{0}".format(json.dumps(objects, ensure_ascii=False)))
+	shutil.copyfile(project, cache + ".pending")
+	os.rename(cache + ".pending", cache)
+
+
+def describe_devices(engine, tree, root):
+	"""A saved tree's adapters need their descriptions in this container's device repository."""
+	for device in tree["devices"] if tree else []:
+		import_device_description(engine, device, root)
+
+
+def open_template(engine, request, path, devices, caches, progress):
+	"""Opens the template as `path` with its controller and device tree, whose descriptions are in
+	`devices`; from the cache in `caches` when it holds this tree. Returns the project, the channels
+	it pinned, and a newly generated tree to keep once the project works."""
 	tree = request.get("deviceTree")
-	cache = device_tree_cache(request, workspace) if tree else None
+	cache = device_tree_cache(request, caches) if tree else None
 	if cache and os.path.isfile(cache):
 		progress("Reusing the generated device tree")
-		root = os.path.dirname(request["receipt"])
-		# The tree's adapters need their descriptions in this container's device repository.
-		for device in tree["devices"]:
-			import_device_description(engine, device, root)
+		describe_devices(engine, tree, devices)
 		shutil.copyfile(cache, path)
 		return engine.projects.open(path, primary=True), {}, None
 	progress("Opening project")
@@ -631,7 +474,7 @@ def open_project(engine, request, workspace, progress):
 		apply_controller(project, request["controller"], progress)
 	if not tree:
 		return project, {}, None
-	pinned = configure_device_tree(engine, project, tree, os.path.dirname(request["receipt"]), progress)
+	pinned = configure_device_tree(engine, project, tree, devices, progress)
 	project.save()
 	if not os.path.isdir(os.path.dirname(cache)):
 		os.makedirs(os.path.dirname(cache))
@@ -640,6 +483,29 @@ def open_project(engine, request, workspace, progress):
 	return project, pinned, (pending, cache)
 
 
+def open_project(engine, request, workspace, progress):
+	"""Opens the project to import into: the last build's when only source objects changed since it,
+	else the template. Returns the project, the source objects it already holds (None for none),
+	the channels it pinned, and a newly generated tree to keep if the build succeeds."""
+	working = os.path.join(workspace, "project")
+	if os.path.isdir(working):
+		shutil.rmtree(working)
+	os.mkdir(working)
+	path = os.path.join(working, "Application.project")
+	# Caches live beside the worker, which each container starts afresh.
+	caches, devices = os.path.dirname(workspace), os.path.dirname(request["receipt"])
+	last = build_cache(request, caches)
+	if os.path.isfile(last):
+		progress("Reusing the last build's project")
+		describe_devices(engine, request.get("deviceTree"), devices)
+		with io.open(os.path.splitext(last)[0] + ".json", encoding="utf-8") as source:
+			previous = json.load(source)
+		shutil.copyfile(last, path)
+		return engine.projects.open(path, primary=True), previous, {}, None
+	project, pinned, generated = open_template(engine, request, path, devices, caches, progress)
+	return project, None, pinned, generated
+
+
 def build(engine, request, loaded, workspace):
 	progress_path = os.path.join(os.path.dirname(request["receipt"]), "progress.log")
 
@@ -652,24 +518,26 @@ def build(engine, request, loaded, workspace):
 	# Reopen when the template or object membership changes, so removed/renamed
 	# declarations cannot survive from an earlier build. Text changes are imported below.
 	key = project_key(request)
-	reusing = loaded.get("key") == key
 	project = None
 	# Only a tree generated in this build has channels to verify; a reused or cached one passed when it was made.
 	pinned, generated = {}, None
 	try:
-		if reusing:
+		if loaded.get("key") == key:
 			progress("Reusing loaded project")
-			project = loaded["project"]
+			project, previous = loaded["project"], loaded["objects"]
 		else:
 			if loaded.get("project") is not None:
 				loaded["project"].close()
 			loaded.clear()
-			project, pinned, generated = open_project(engine, request, workspace, progress)
+			project, previous, pinned, generated = open_project(engine, request, workspace, progress)
 		loaded.clear()
 		application = project.active_application
 		if application is None:
 			raise RuntimeError("Template must have an active Application")
-		configured_tasks = import_objects(engine, application, request, reusing, progress)
+		gone = reconcile(application, previous, request["objects"]) if previous is not None else []
+		configured_tasks = import_objects(engine, application, request, previous, progress)
+		for obj in gone:
+			obj.remove()
 		if request["symbols"] and not any(
 			getattr(child, "is_symbol_config", False)
 			for child in application.get_children()
@@ -707,13 +575,14 @@ def build(engine, request, loaded, workspace):
 			raise RuntimeError("Compiler did not produce a non-empty boot application")
 		if generated:
 			keep_device_tree(*generated)
+		keep_build(project.path, request["objects"], build_cache(request, os.path.dirname(workspace)))
 		progress("Build complete")
 		with io.open(request["receipt"], "w", encoding="utf-8") as receipt:
 			receipt.write(json.dumps(
 				dict({"mode": request["mode"], "application": application.get_name()}, **({"tasks": configured_tasks} if configured_tasks is not None else {})),
 				ensure_ascii=False,
 			))
-		loaded.update({"key": key, "project": project})
+		loaded.update({"key": key, "objects": request["objects"], "project": project})
 	except Exception:
 		loaded.clear()
 		if project is not None: