@trioforge/crucible 0.0.0-stage → 0.2.0

package/out/internal/lifecycle.luau

@@ -0,0 +1,912 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _runner = TS.import(script, script.Parent, "runner")
+local call = _runner.call
+local disown = _runner.disown
+local own = _runner.own
+local ownerOf = _runner.ownerOf
+--[[
+	*
+	 * @internal
+	 * Pure transition function. The drain calls it until it returns undefined. It reads only the current state,
+	 * so re-running it after a request converges on the same end state, and asking twice for the state an object
+	 * already has finds no step.
+	 
+]]
+local function nextStep(s)
+	local ending = s.fault ~= nil or s.want == 2
+	local _exp = s.phase
+	repeat
+		if _exp == 0 then
+			if ending then
+				return 10
+			end
+			return if s.gate >= 1 then 0 else nil
+		end
+		if _exp == 1 then
+			if ending then
+				return 10
+			end
+			return if s.gate >= 2 then 1 else nil
+		end
+		if _exp == 2 then
+			if ending then
+				return 9
+			end
+			if s.gate < 3 then
+				return nil
+			end
+			return if s.want == 0 then 2 else 3
+		end
+		if _exp == 3 then
+			if s.fault ~= nil or s.want ~= 0 then
+				return if s.joined or s.ticking then 7 else 8
+			end
+			if not s.joined then
+				return 4
+			end
+			if s.start == 0 then
+				return if s.gate >= 4 then 5 else nil
+			end
+			return if s.start == 2 and not s.ticking then 6 else nil
+		end
+		if _exp == 4 then
+			if ending then
+				return 9
+			end
+			return if s.want == 0 then 2 else nil
+		end
+	until true
+	return nil
+end
+local installed
+local states = {}
+--* @internal 
+local function useEffects(effects)
+	installed = effects
+end
+local function effects()
+	return installed or error("Crucible lifecycle used before boot")
+end
+--* @internal 
+local function stateOf(object)
+	local _object = object
+	return states[_object]
+end
+local enablingNow
+--* @internal The generation whose Enable step is running. What it creates belongs to its enable interval. 
+local function enabling()
+	return enablingNow
+end
+--* @internal Awake, not faulted, and not asked to go. `get` and queries see only live objects. 
+local function isLive(s)
+	return s.fault == nil and s.want ~= 2 and (s.phase == 2 or s.phase == 3 or s.phase == 4)
+end
+--* @internal Faulted or Destroyed. 
+local function hasEnded(s)
+	return s.phase == 5 or s.phase == 6
+end
+--* @internal A new generation, before its constructor runs. `admit` gives it a batch. 
+local function track(record, instance, attributes)
+	return {
+		work = 0,
+		phase = 0,
+		start = 0,
+		gate = 0,
+		want = 0,
+		joined = false,
+		ticking = false,
+		record = record,
+		instance = instance,
+		attributes = attributes,
+		queued = false,
+		transitions = 0,
+	}
+end
+--[[
+	*
+	 * @internal
+	 * The object whose code is running: the owner of a runner worker during a hook or callback, or of a start
+	 * thread for its whole life. A thread made with `task.spawn` inside a hook has no owner.
+	 
+]]
+local function current()
+	return ownerOf(coroutine.running())
+end
+local function note(s, hook, err)
+	if s.fault == nil then
+		s.fault = {
+			hook = hook,
+			error = err,
+			cleanup = {},
+		}
+	else
+		local _cleanup = s.fault.cleanup
+		local _arg0 = {
+			hook = hook,
+			error = err,
+		}
+		table.insert(_cleanup, _arg0)
+	end
+end
+--* A teardown failure attaches to the fault, or is diagnosed without faulting a clean generation. 
+local function cleanup(s, hook, err)
+	if s.fault ~= nil then
+		local _cleanup = s.fault.cleanup
+		local _arg0 = {
+			hook = hook,
+			error = err,
+		}
+		table.insert(_cleanup, _arg0)
+	else
+		effects().diagnose(s, hook, err)
+	end
+end
+local subsystemLacks = {
+	[2] = true,
+	[4] = true,
+	[5] = true,
+}
+local function run(s, hook)
+	local _condition = s.record.kind == 0
+	if _condition then
+		local _hook = hook
+		_condition = subsystemLacks[_hook] ~= nil
+	end
+	if _condition then
+		return nil
+	end
+	local caller = effects().hook(s, hook)
+	if caller == nil then
+		return nil
+	end
+	local result, value = call(caller, s, nil, s)
+	if result ~= 0 then
+		note(s, hook, value)
+	end
+end
+local function construct(s)
+	return effects().construct(s)
+end
+local function release(s)
+	if s.object ~= nil then
+		local _object = s.object
+		states[_object] = nil
+	end
+	local disabled = effects().disabled
+	if disabled ~= nil then
+		pcall(disabled, s)
+	end
+	local subscriptions = s.subscriptions
+	s.subscriptions = nil
+	if subscriptions == nil then
+		return nil
+	end
+	for _, disconnect in subscriptions do
+		local ok, err = pcall(disconnect)
+		if not ok then
+			cleanup(s, 11, err)
+		end
+	end
+end
+local function finish(s)
+	s.phase = if s.fault == nil then 6 else 5
+	release(s)
+	effects().ended(s)
+end
+local function traceback(err)
+	return debug.traceback(tostring(err), 2)
+end
+local finishStart
+local function runStart(s)
+	local ok, err = xpcall(effects().start, traceback, s)
+	disown(coroutine.running())
+	finishStart(s, ok, err)
+end
+local function cancelSuspended(thread)
+	disown(thread)
+	return pcall(effects().cancel, thread)
+end
+--[[
+	*
+	 * Only a suspended thread can be closed. A start thread that is running, or normal because it resumed the
+	 * thread now draining, keeps its owner, so `current()` sees an ended object and `observe` subscribes nothing.
+	 * A deferred check cancels it at its next yield, and `finishStart` ignores it if it returns first.
+	 
+]]
+local function stopStart(s, thread)
+	if coroutine.status(thread) == "suspended" then
+		local ok, err = cancelSuspended(thread)
+		if not ok then
+			cleanup(s, 10, err)
+		end
+		return nil
+	end
+	local fx = effects()
+	fx.defer(function()
+		if coroutine.status(thread) ~= "suspended" then
+			return nil
+		end
+		local ok, err = cancelSuspended(thread)
+		if not ok then
+			fx.diagnose(s, 10, err)
+		end
+	end)
+end
+local function perform(s, step)
+	local fx = effects()
+	repeat
+		if step == 0 then
+			local result, value = call(construct, s, nil, s)
+			if result ~= 0 then
+				note(s, 0, value)
+			else
+				local object = value
+				s.object = object
+				local _s = s
+				states[object] = _s
+				s.phase = 1
+			end
+			return nil
+		end
+		if step == 1 then
+			s.phase = 2
+			run(s, 1)
+			return nil
+		end
+		if step == 2 then
+			s.phase = 3
+			local previous = enablingNow
+			enablingNow = s
+			run(s, 2)
+			enablingNow = previous
+			return nil
+		end
+		if step == 3 then
+			s.phase = 4
+			return nil
+		end
+		if step == 4 then
+			s.joined = true
+			fx.join(s)
+			return nil
+		end
+		if step == 5 then
+			s.start = 1
+			local thread = coroutine.create(runStart)
+			s.startThread = thread
+			own(thread, s)
+			local ok, err = coroutine.resume(thread, s)
+			if not ok then
+				note(s, 3, err)
+			end
+			return nil
+		end
+		if step == 6 then
+			s.ticking = true
+			fx.tick(s)
+			return nil
+		end
+		if step == 7 then
+			if s.ticking then
+				s.ticking = false
+				fx.untick(s)
+			end
+			if s.joined then
+				s.joined = false
+				fx.leave(s)
+			end
+			return nil
+		end
+		if step == 8 then
+			s.phase = 4
+			run(s, 4)
+			local _result = fx.disabled
+			if _result ~= nil then
+				_result(s)
+			end
+			return nil
+		end
+		if step == 9 then
+			local thread = s.startThread
+			s.startThread = nil
+			if s.start == 1 and thread ~= nil then
+				stopStart(s, thread)
+			end
+			run(s, 5)
+			finish(s)
+			return nil
+		end
+		if step == 10 then
+			finish(s)
+			return nil
+		end
+	until true
+end
+--* Ends a generation with no user hooks, after its own teardown failed again. Every effect is protected. 
+local function forceEnd(s)
+	local fx = effects()
+	local thread = s.startThread
+	s.startThread = nil
+	if s.start == 1 and thread ~= nil then
+		pcall(stopStart, s, thread)
+	end
+	if s.ticking then
+		s.ticking = false
+		pcall(fx.untick, s)
+	end
+	if s.joined then
+		s.joined = false
+		pcall(fx.leave, s)
+	end
+	s.phase = if s.fault == nil then 6 else 5
+	pcall(release, s)
+	pcall(fx.ended, s)
+end
+--* @internal Steps one causal chain may take on one object before it faults. Fault cleanup runs past it. 
+local MAX_TRANSITIONS = 64
+--* @internal Creation that never settles is a failure after this many awake waves in one batch. 
+local MAX_AWAKE_WAVES = 1024
+--* @internal Batches one drain may start. A chain of objects creating objects in `start` stops here. 
+local MAX_BATCHES = 1024
+--[[
+	*
+	 * @internal
+	 * Requests that steps may make in one drain. C5 bounds an object that undoes itself, not objects that undo each
+	 * other; this cap ends such a cycle. Like the batch cap it is a failure, and its value waits on a Studio measurement.
+	 
+]]
+local MAX_CHAINED_REQUESTS = 65_536
+--* @internal Reconcile rounds one drain may run. Binding that queues pairs on every round stops here. 
+local MAX_RECONCILE_ROUNDS = 1024
+--* @internal Consecutive internal errors that fault or force-end nothing before the drain gives up on its work. 
+local MAX_RECOVERIES = 1
+local function awaking(batch)
+	return batch.sweep == 0 or batch.sweep == 1
+end
+local function settle(reconciler)
+	reconciler:settle()
+end
+--[[
+	*
+	 * The single reconciler. Every lifecycle and binding change happens in a drain, and one drain runs at a time.
+	 * A drain starts at an outermost entry point: an engine signal, boot, a frame dispatch, or a public call made
+	 * outside a drain. A request made inside a drain only enqueues, so no hook ever runs while another object's
+	 * hook is on the stack. The stack holds objects to settle and batches to advance. What one step asks for
+	 * collects in `fresh` and moves onto the stack when the step ends, first request on top. So requests run in
+	 * the order they were made, after the hook that made them returns and before its object takes its next step.
+	 
+]]
+local request, fault
+local Reconciler
+do
+	Reconciler = setmetatable({}, {
+		__tostring = function()
+			return "Reconciler"
+		end,
+	})
+	Reconciler.__index = Reconciler
+	function Reconciler.new(...)
+		local self = setmetatable({}, Reconciler)
+		return self:constructor(...) or self
+	end
+	function Reconciler:constructor()
+		self.stack = {}
+		self.fresh = {}
+		self.depth = 0
+		self.pairsQueued = false
+		self.rounds = 0
+		self.batches = 0
+		self.requests = 0
+	end
+	function Reconciler:isDraining()
+		return self.depth > 0
+	end
+	function Reconciler:open()
+		self.depth += 1
+	end
+	function Reconciler:leave()
+		self.depth -= 1
+		return self.depth == 0 and (#self.stack > 0 or #self.fresh > 0 or self.pairsQueued)
+	end
+	function Reconciler:enter(callback, a, b, owner)
+		self.depth += 1
+		local result, value = call(callback, a, b, owner)
+		self.depth -= 1
+		return result, value
+	end
+	function Reconciler:fail(message)
+		if self.failure == nil then
+			self.failure = message
+		end
+	end
+	function Reconciler:notePairs()
+		self.pairsQueued = true
+	end
+	function Reconciler:push(s)
+		if s.queued then
+			return nil
+		end
+		s.queued = true
+		local _fresh = self.fresh
+		local _s = s
+		table.insert(_fresh, _s)
+	end
+	function Reconciler:chain(s)
+		local stepping = self.stepping
+		if stepping ~= s then
+			s.transitions = 0
+		end
+		if stepping == nil then
+			return nil
+		end
+		self.requests += 1
+		if self.requests <= MAX_CHAINED_REQUESTS or stepping.fault ~= nil then
+			return nil
+		end
+		-- A cycle's members keep requesting while a passive target never does, so the requester is the one to end.
+		self.requests = 0
+		local message = `Crucible: objects kept changing each other through {MAX_CHAINED_REQUESTS} requests in one drain`
+		self:fail(message)
+		note(stepping, 9, message)
+	end
+	function Reconciler:raise(s, gate)
+		if s.gate < gate then
+			s.gate = gate
+		end
+		self:push(s)
+	end
+	function Reconciler:innermostBatch()
+		for i = #self.fresh - 1, 0, -1 do
+			local entry = self.fresh[i + 1]
+			if entry.work == 1 then
+				return entry
+			end
+		end
+		for i = #self.stack - 1, 0, -1 do
+			local entry = self.stack[i + 1]
+			if entry.work == 1 then
+				return entry
+			end
+		end
+		return nil
+	end
+	function Reconciler:admit(created)
+		if #created == 0 then
+			return nil
+		end
+		local open = self:innermostBatch()
+		if open ~= nil and awaking(open) then
+			for _, s in created do
+				local _exp = open.pending
+				table.insert(_exp, s)
+			end
+			return nil
+		end
+		if self.batches == MAX_BATCHES then
+			for _, s in created do
+				request(s, 2)
+			end
+			self:fail(`Crucible: objects kept creating objects for {MAX_BATCHES} batches in one drain; the rest were dropped`)
+			return nil
+		end
+		self.batches += 1
+		local _fresh = self.fresh
+		local _object = {
+			work = 1,
+			members = {},
+			wave = {},
+		}
+		local _left = "pending"
+		local _array = {}
+		local _length = #_array
+		table.move(created, 1, #created, _length + 1, _array)
+		_object[_left] = _array
+		_object.sweep = 1
+		_object.cursor = 0
+		_object.waves = 0
+		table.insert(_fresh, _object)
+		self:drain()
+	end
+	function Reconciler:abandon()
+		local _array = {}
+		local _length = #_array
+		local _array_1 = self.stack
+		table.move(_array_1, 1, #_array_1, _length + 1, _array)
+		local _array_2 = {}
+		local _length_1 = #_array_2
+		local _array_3 = self.fresh
+		table.move(_array_3, 1, #_array_3, _length_1 + 1, _array_2)
+		for _, list in { _array, _array_2 } do
+			for _1, entry in list do
+				if entry.work ~= 1 then
+					continue
+				end
+				for _2, s in entry.members do
+					request(s, 2)
+				end
+				for _2, s in entry.pending do
+					request(s, 2)
+				end
+			end
+		end
+	end
+	function Reconciler:advance(batch)
+		local _exp = batch.sweep
+		repeat
+			local _fallthrough = false
+			if _exp == 0 then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == 1 then
+				if batch.cursor < #batch.wave then
+					local s = batch.wave[batch.cursor + 1]
+					batch.cursor += 1
+					self:raise(s, if batch.sweep == 0 then 1 else 2)
+					return true
+				end
+				batch.cursor = 0
+				if batch.sweep == 0 then
+					batch.sweep = 1
+					return true
+				end
+				local wave = batch.pending
+				batch.pending = {}
+				if #wave == 0 then
+					batch.sweep = 2
+				elseif batch.waves == MAX_AWAKE_WAVES then
+					for _, s in wave do
+						request(s, 2)
+					end
+					self:fail(`Crucible: objects kept creating objects during awake for {MAX_AWAKE_WAVES} waves; the last wave was dropped`)
+					batch.sweep = 2
+				else
+					batch.waves += 1
+					batch.wave = wave
+					for _, s in wave do
+						local _exp_1 = batch.members
+						table.insert(_exp_1, s)
+					end
+					batch.sweep = 0
+				end
+				return true
+			end
+			if _exp == 2 then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == 3 then
+				if batch.cursor < #batch.members then
+					local s = batch.members[batch.cursor + 1]
+					batch.cursor += 1
+					self:raise(s, if batch.sweep == 2 then 3 else 4)
+					return true
+				end
+				if batch.sweep == 3 then
+					return false
+				end
+				batch.cursor = 0
+				batch.sweep = 3
+				return true
+			end
+		until true
+		return false
+	end
+	function Reconciler:settleStep(s)
+		local step = nextStep(s)
+		if step == nil then
+			return false
+		end
+		s.transitions += 1
+		if s.fault == nil then
+			if s.transitions > MAX_TRANSITIONS then
+				note(s, 9, `did not settle after {MAX_TRANSITIONS} transitions since a request from outside it`)
+				return true
+			end
+		end
+		self.stepping = s
+		perform(s, step)
+		self.stepping = nil
+		return true
+	end
+	function Reconciler:settle()
+		while true do
+			while #self.fresh > 0 do
+				local _stack = self.stack
+				local _exp = self.fresh
+				-- ▼ Array.pop ▼
+				local _length = #_exp
+				local _result = _exp[_length]
+				_exp[_length] = nil
+				-- ▲ Array.pop ▲
+				table.insert(_stack, _result)
+			end
+			local top = self.stack[#self.stack]
+			if top == nil or top.work == 1 then
+				if self.pairsQueued then
+					self.pairsQueued = false
+					if self.rounds == MAX_RECONCILE_ROUNDS then
+						self:fail(`Crucible: binding kept queueing pairs for {MAX_RECONCILE_ROUNDS} reconcile rounds in one drain; the rest wait for the next drain`)
+					else
+						self.rounds += 1
+						self:admit(effects().reconcile())
+					end
+					continue
+				end
+				if top == nil then
+					return nil
+				end
+				if not self:advance(top) then
+					local _exp = self.stack
+					_exp[#_exp] = nil
+				end
+				continue
+			end
+			if not self:settleStep(top) then
+				local _exp = self.stack
+				_exp[#_exp] = nil
+				top.queued = false
+			end
+		end
+	end
+	function Reconciler:unwind()
+		local stranded = {}
+		local rest = {}
+		local _array = {}
+		local _length = #_array
+		local _array_1 = self.fresh
+		table.move(_array_1, 1, #_array_1, _length + 1, _array)
+		local order = _array
+		for i = #self.stack - 1, 0, -1 do
+			local _arg0 = self.stack[i + 1]
+			table.insert(order, _arg0)
+		end
+		table.clear(self.fresh)
+		table.clear(self.stack)
+		for _, entry in order do
+			if entry.work == 0 then
+				entry.queued = false
+				table.insert(rest, entry)
+				continue
+			end
+			for _1, s in entry.members do
+				if s.gate < 4 then
+					table.insert(stranded, s)
+				end
+			end
+			for _1, s in entry.pending do
+				if s.gate < 4 then
+					table.insert(stranded, s)
+				end
+			end
+		end
+		return stranded, rest
+	end
+	function Reconciler:drain()
+		if self.depth > 0 or (#self.stack == 0 and #self.fresh == 0 and not self.pairsQueued) then
+			return nil
+		end
+		local errors = {}
+		local faulted = {}
+		local idle = 0
+		local result, err = self:enter(settle, self, nil)
+		while result ~= 0 do
+			local _arg0 = tostring(err)
+			table.insert(errors, _arg0)
+			local culprit = self.stepping
+			self.stepping = nil
+			local stranded, rest = self:unwind()
+			local progressed = false
+			if culprit ~= nil and not hasEnded(culprit) then
+				if faulted[culprit] ~= nil then
+					forceEnd(culprit)
+				else
+					faulted[culprit] = true
+					note(culprit, 11, err)
+				end
+				progressed = true
+			end
+			for _, s in stranded do
+				if hasEnded(s) or faulted[s] ~= nil then
+					continue
+				end
+				faulted[s] = true
+				note(s, 11, err)
+				progressed = true
+			end
+			idle = if progressed then 0 else idle + 1
+			local _array = {}
+			local _length = #_array
+			local _strandedLength = #stranded
+			table.move(stranded, 1, _strandedLength, _length + 1, _array)
+			_length += _strandedLength
+			table.move(rest, 1, #rest, _length + 1, _array)
+			-- ▼ ReadonlyArray.filter ▼
+			local _newValue = {}
+			local _callback = function(s)
+				return not hasEnded(s)
+			end
+			local _length_1 = 0
+			for _k, _v in _array do
+				if _callback(_v, _k - 1, _array) == true then
+					_length_1 += 1
+					_newValue[_length_1] = _v
+				end
+			end
+			-- ▲ ReadonlyArray.filter ▲
+			local left = _newValue
+			if idle > MAX_RECOVERIES then
+				self.pairsQueued = false
+				for _, s in left do
+					if hasEnded(s) then
+						continue
+					end
+					if not (faulted[s] ~= nil) then
+						note(s, 11, err)
+					end
+					forceEnd(s)
+				end
+				break
+			end
+			for _, s in left do
+				self:push(s)
+			end
+			result, err = self:enter(settle, self, nil)
+		end
+		self.rounds = 0
+		self.batches = 0
+		self.requests = 0
+		self.stepping = nil
+		local failure = self.failure
+		self.failure = nil
+		local fx = effects()
+		for _, e in errors do
+			fx.failed(`Crucible: internal error; the reconciler recovered: {e}`)
+		end
+		if failure ~= nil then
+			fx.failed(failure)
+		end
+	end
+	function Reconciler:within(owner, blame, hook, callback, a, b)
+		local outer = self.depth > 0
+		local result, value = self:enter(callback, a, b, owner)
+		if result ~= 0 and blame ~= nil then
+			fault(blame, hook, value)
+		end
+		if not outer then
+			self:drain()
+		end
+		return result, value
+	end
+end
+local reconciler = Reconciler.new()
+--* @internal True while a drain runs, including inside every hook and callback it calls. 
+local function isDraining()
+	return reconciler:isDraining()
+end
+--[[
+	*
+	 * @internal
+	 * Opens a scope like `within` for a caller that runs its own worker: requests made until `closeScope` wait for it.
+	 * Pair the two, with nothing between them that can throw.
+	 
+]]
+local function openScope()
+	reconciler:open()
+end
+--* @internal Closes the scope `openScope` opened. True when it was the outermost and requests wait: call `drain`. 
+local function closeScope()
+	return reconciler:leave()
+end
+--[[
+	*
+	 * @internal
+	 * Runs every queued change to rest. Returns at once when a drain is already running: that drain processes the
+	 * queue before it returns. Never throws. A cap or an internal error goes to `effects.failed` after recovery.
+	 
+]]
+local function drain()
+	reconciler:drain()
+end
+--[[
+	*
+	 * @internal
+	 * Binding has queued pairs. The drain reconciles them when its top is a batch or it is empty. Past the round
+	 * cap the drain drops the note, so binding calls this again whenever it queues.
+	 
+]]
+local function notePairs()
+	reconciler:notePairs()
+end
+--[[
+	*
+	 * @internal
+	 * Runs one callback as its own scope: a frame hook, an `All<T>` visit, or an observer callback. Requests it
+	 * makes apply after it returns. A failure faults `blame`; with no blame the caller logs the returned failure.
+	 * Outside a drain, the scope drains when it ends, so the next frame hook in a lane sees the effects of the one
+	 * before.
+	 
+]]
+local function within(owner, blame, hook, callback, a, b)
+	return reconciler:within(owner, blame, hook, callback, a, b)
+end
+--* @internal Updates `want` and queues the object. Called by `setEnabled`, `remove()` and binding. Ignored once Destroyed is wanted. 
+function request(s, want)
+	if s.want == 2 then
+		return nil
+	end
+	s.want = want
+	reconciler:chain(s)
+	reconciler:push(s)
+	reconciler:drain()
+end
+--* @internal Faults the object from outside a lifecycle step: a frame hook, `accepts`, or an `All<T>` callback. 
+function fault(s, hook, err)
+	if hasEnded(s) then
+		return nil
+	end
+	note(s, hook, err)
+	reconciler:chain(s)
+	reconciler:push(s)
+	reconciler:drain()
+end
+--* @internal Called by the start thread when `start` returns or throws. A start that outlived its generation is ignored. 
+function finishStart(s, ok, err)
+	if hasEnded(s) then
+		return nil
+	end
+	s.startThread = nil
+	s.start = 2
+	if not ok then
+		note(s, 3, err)
+	end
+	reconciler:chain(s)
+	reconciler:push(s)
+	reconciler:drain()
+end
+--[[
+	*
+	 * @internal
+	 * Gives new generations a batch. Inside the awake closure of the innermost batch they join its next wave, so
+	 * every object a batch creates during awake is awake before any of the batch is enabled. Otherwise they form
+	 * a new batch, which runs to rest before the code that created them continues.
+	 
+]]
+local function admit(created)
+	reconciler:admit(created)
+end
+--* @internal Asks every generation in an unfinished batch to end. Boot calls it when a Subsystem faults. 
+local function abandon()
+	reconciler:abandon()
+end
+--* @internal Forwards to the installed effects' `defer`, so networking defers ClientReady cleanups as lifecycle does. 
+local function defer(callback)
+	effects().defer(callback)
+end
+return {
+	nextStep = nextStep,
+	useEffects = useEffects,
+	stateOf = stateOf,
+	enabling = enabling,
+	isLive = isLive,
+	hasEnded = hasEnded,
+	track = track,
+	current = current,
+	isDraining = isDraining,
+	openScope = openScope,
+	closeScope = closeScope,
+	drain = drain,
+	notePairs = notePairs,
+	within = within,
+	request = request,
+	fault = fault,
+	finishStart = finishStart,
+	admit = admit,
+	abandon = abandon,
+	defer = defer,
+	MAX_TRANSITIONS = MAX_TRANSITIONS,
+	MAX_AWAKE_WAVES = MAX_AWAKE_WAVES,
+	MAX_BATCHES = MAX_BATCHES,
+	MAX_CHAINED_REQUESTS = MAX_CHAINED_REQUESTS,
+	MAX_RECONCILE_ROUNDS = MAX_RECONCILE_ROUNDS,
+	MAX_RECOVERIES = MAX_RECOVERIES,
+}