@expressive/steps 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,1683 @@
+import { Model, get, has, map, unbind } from "@expressive/mvc";
+import { event, listener, touch, watch } from "@expressive/mvc/observable";
+
+//#region src/steps.ts
+const HOOKS = new Set(["before", "after"]);
+const KEYS = [
+	"status",
+	"active",
+	"queue",
+	"waiting",
+	"runs",
+	"error"
+];
+const SLACK = 8;
+const LONGEST = 2 ** 31 - 1;
+const GATES = /* @__PURE__ */ new WeakMap();
+const UNCAUGHT = ["gate", "end"];
+const UNPLANNED = [
+	"end",
+	"gate",
+	"wait"
+];
+const RESERVED = [
+	"then",
+	"end",
+	"gate",
+	"wait"
+];
+const REFRESH = Symbol.for("@expressive/mvc.refresh");
+const ISSUED = /* @__PURE__ */ new WeakMap();
+const RETRY = /* @__PURE__ */ new WeakSet();
+const RULES = /* @__PURE__ */ new WeakSet();
+const KINDS = [
+	"reset",
+	"catch",
+	"abort",
+	"close"
+];
+const MODES = {
+	failed: "error",
+	aborted: "abort",
+	stopped: "stop"
+};
+const UNITS = {
+	ms: 1,
+	sec: 1e3,
+	min: 6e4,
+	hr: 36e5,
+	day: 864e5
+};
+const TOKEN = { catch(handler) {
+	return ISSUED.get(this).rescue(this, handler);
+} };
+function install(self) {
+	const runner = function(onfulfilled, onrejected) {
+		if (onfulfilled && typeof onfulfilled == "object") throw rule("then(steps) must be called inside a step.");
+		return control.settled().then(onfulfilled, onrejected);
+	};
+	const control = Control.new({
+		_self: self,
+		_runner: runner
+	});
+	const read = {
+		status: () => control.status,
+		active: () => control.active,
+		queue: () => control.queue.map((ticket) => ticket.args),
+		waiting: () => control.run.waits.map(({ id, step, args, answers, until }) => ({
+			id,
+			step,
+			args,
+			answers,
+			...until !== void 0 && { until }
+		})),
+		runs: () => control.runs,
+		error: () => control.error
+	};
+	for (const key of KEYS) Object.defineProperty(runner, key, {
+		enumerable: true,
+		get() {
+			return touch(this, key, read[key]());
+		}
+	});
+	Object.defineProperties(runner, {
+		then: { value: runner },
+		self: { value: self },
+		get: { value: () => Object.fromEntries(KEYS.map((key) => [key, read[key]()])) },
+		end: { value: (...value) => void (valueless(value), control.conclude()) },
+		stop: { value: (reason) => control.stop(false, reason) },
+		abort: { value: (reason) => control.stop(true, reason) },
+		only: { value: () => outside("only") },
+		commit: { value: () => outside("commit") },
+		on: { value: () => outside("on") },
+		restore: { value: () => outside("restore") },
+		signal: { get: () => outside("signal", "read") },
+		retry: { value: () => outside("retry") },
+		retried: { get: () => outside("retried", "read") }
+	});
+	event(runner);
+	Object.defineProperty(self, "then", {
+		configurable: true,
+		get() {
+			const view = touch(this, "then", runner);
+			return view === runner ? runner : Object.setPrototypeOf((...args) => runner(...args), view);
+		}
+	});
+	const { _hooks: hooks, _steps: steps } = control;
+	const wire = () => {
+		for (const key of steps.keys()) delete self[key];
+		steps.clear();
+		hooks.clear();
+		for (let proto = Object.getPrototypeOf(self); proto !== Model.prototype; proto = Object.getPrototypeOf(proto)) for (const [key, desc] of Object.entries(Object.getOwnPropertyDescriptors(proto))) {
+			if (!(desc.get && unbind(desc.get) !== desc.get) || key == "new" || key[0] == "_" || Object.hasOwn(self, key)) continue;
+			if (key == "end") throw rule(`${self.constructor.name} declares end; return the result from run, end early with this.then.end().`);
+			if (RESERVED.includes(key)) throw rule(`${self.constructor.name} declares ${key}; then, end, gate and wait name plan tokens - rename the step.`);
+			if (HOOKS.has(key)) {
+				if (!hooks.has(key)) hooks.set(key, unbind(desc.get));
+				continue;
+			}
+			const step = (...args) => control.call(key, args);
+			steps.set(key, unbind(desc.get));
+			Object.defineProperty(self, key, key == "run" ? {
+				value: step,
+				writable: true,
+				configurable: true
+			} : {
+				configurable: true,
+				get() {
+					touch(this, key);
+					return control.accepts(key) ? step : void 0;
+				}
+			});
+		}
+	};
+	wire();
+	listener(self, (key) => void (key === REFRESH && wire()));
+	self.get(null, () => control.stop());
+}
+var Aborted = class extends Error {
+	name = "Aborted";
+};
+var Stopped = class extends Error {
+	name = "Stopped";
+};
+/**
+* A runnable Model: every method is a step, a step schedules the next by calling it.
+*
+* Fields carry data between steps. Each step is atomic and registers its own reset; a failure unwinds
+* what committed. `run()` starts a run; awaiting the instance joins it. In-process only.
+*
+* @example
+* class Checkout extends Steps {
+*   cart!: Cart;
+*   charge?: Charge = undefined;
+*
+*   async run() {
+*     this.pay();
+*     await this;
+*     return this.charge!.id;
+*   }
+*
+*   protected async pay() {
+*     this.charge = await stripe.charge(this.cart.total);
+*     this.then.on({ reset: () => stripe.refund(this.charge!.id) });
+*   }
+* }
+*
+* const id = await Checkout.new({ cart });
+*/
+var Steps = class extends Model {
+	/** Why a run or subtree ended: `abort()`, or a lost race. */
+	static Aborted = Aborted;
+	/** Why a run or subtree ended: `stop()`. */
+	static Stopped = Stopped;
+	constructor(...args) {
+		super(...args);
+		install(this);
+	}
+};
+var Control = class extends Model {
+	status = "idle";
+	active = void 0;
+	runs = 0;
+	error = void 0;
+	queue = has();
+	run = new Run();
+	_self;
+	_runner;
+	_steps = /* @__PURE__ */ new Map();
+	_hooks = /* @__PURE__ */ new Map();
+	_gates = /* @__PURE__ */ new Map();
+	_current = void 0;
+	new() {
+		const { _runner } = this;
+		listener(this.queue, (key) => {
+			if (signal(key)) event(this, "queue");
+		});
+		return this.set((key) => void event(_runner, key));
+	}
+	call(key, args) {
+		if (key == "run") return this.start(args);
+		const { _current: current } = this;
+		const wait = current && current.route(key, args);
+		if (wait) return current.wake(wait, key, args);
+		throw rule(`${key} cannot be called from outside; call run() to start a run.`);
+	}
+	accepts(key) {
+		return !!this._current?.accepts(key);
+	}
+	hook(key, ...args) {
+		return this._hooks.get(key)?.apply(this._self, args);
+	}
+	start(args) {
+		const ticket = { args };
+		ticket.promise = new Promise((resolve, reject) => {
+			ticket.resolve = resolve;
+			ticket.reject = reject;
+		});
+		ticket.promise.catch(() => {});
+		if (this._current) this.queue.push(ticket);
+		else this.begin(ticket);
+		return handle(ticket, (resolve, reject) => ticket.promise.then(resolve, reject));
+	}
+	begin(ticket) {
+		const run = new Run({ _ticket: ticket });
+		this._current = this.run = run;
+		this.error = void 0;
+		this.status = "running";
+		run.start();
+	}
+	advance() {
+		const next = this.queue.pop(0);
+		if (next) this.begin(next);
+	}
+	tail() {
+		return this.queue.get(-1) || this.run._ticket;
+	}
+	settled() {
+		if (!this._current) {
+			if (this._steps.get("run")?.length) return Promise.reject(/* @__PURE__ */ new Error(`${this._self} is idle. run() takes arguments; call it to start a run.`));
+			this.start([]);
+		}
+		return this.join();
+	}
+	join() {
+		const ticket = this.tail();
+		const tickets = [
+			this._current?._ticket,
+			...this.queue,
+			ticket
+		].filter(Boolean);
+		for (const each of tickets) each.awaited = true;
+		return ticket.promise.then((value) => this.tail() === ticket ? value : this.join(), (error) => this.tail() === ticket ? Promise.reject(error) : this.join());
+	}
+	conclude() {
+		const { _current: run } = this;
+		if (run && !run.stale()) run.terminate(run.node("end", []));
+	}
+	stop(undo, reason) {
+		const { _current: current, queue } = this;
+		if (!current) return;
+		const message = typeof reason == "string" ? reason : `${this._self} was ${undo ? "aborted" : "stopped"}.`;
+		const stopped = new (undo ? Aborted : Stopped)(message, reason === void 0 ? void 0 : { cause: reason });
+		for (const ticket of queue) ticket.reject(stopped);
+		queue.clear();
+		current._stopped = stopped;
+		current.release();
+		current.halt(undo ? "aborted" : "stopped");
+	}
+};
+var Run = class extends Model {
+	control = get(Control);
+	frames = has(Frame);
+	waits = has(Wait);
+	_ticket;
+	_entries = [];
+	_counts = /* @__PURE__ */ new Map();
+	_on = /* @__PURE__ */ new Map();
+	_finished = /* @__PURE__ */ new Set();
+	_reset = /* @__PURE__ */ new Set();
+	_writer = /* @__PURE__ */ new Map();
+	_lost = /* @__PURE__ */ new Set();
+	_losing = /* @__PURE__ */ new Map();
+	_held = /* @__PURE__ */ new Map();
+	_inline = /* @__PURE__ */ new Map();
+	_errors = /* @__PURE__ */ new Map();
+	_owner = /* @__PURE__ */ new Map();
+	_parent = /* @__PURE__ */ new Map();
+	_slots = /* @__PURE__ */ new Map();
+	_catches = /* @__PURE__ */ new Map();
+	_branches = /* @__PURE__ */ new Map();
+	_lineage = /* @__PURE__ */ new Map();
+	_retried = /* @__PURE__ */ new Map();
+	_gates = /* @__PURE__ */ new Map();
+	_groups = /* @__PURE__ */ new Set();
+	_pending = /* @__PURE__ */ new Map();
+	_holding = /* @__PURE__ */ new Map();
+	_dropped = /* @__PURE__ */ new Set();
+	_spent = /* @__PURE__ */ new Set();
+	_unwinding = void 0;
+	_drained = [];
+	_quiet = /* @__PURE__ */ new Set();
+	_halted = void 0;
+	_ending = void 0;
+	_settling = void 0;
+	_error = void 0;
+	_stopped = void 0;
+	_root = void 0;
+	_result = void 0;
+	_tail = void 0;
+	_await = void 0;
+	new() {
+		const { control } = this;
+		listener(this.waits, (key) => {
+			if (!(signal(key) && control._current === this)) return;
+			event(control, "waiting");
+			control.status = this.waits.size ? "waiting" : this._halted || "running";
+		});
+	}
+	start() {
+		const node = this.node("run", this._ticket.args);
+		this._root = node.id;
+		this.exec(node).then(() => {
+			if (!this._halted && !this._ending) this.end();
+		});
+	}
+	node(key, args) {
+		const count = (this._counts.get(key) || 0) + 1;
+		this._counts.set(key, count);
+		return Object.assign(Object.create(TOKEN), {
+			id: `${key}#${count}`,
+			key,
+			args
+		});
+	}
+	route(key, args, from) {
+		const open = this.waits.filter((wait) => wait.answers.includes(key));
+		return open.find((wait) => wait._from === from) || open.find((wait) => wait.args[0] === args[0]) || open[0];
+	}
+	accepts(key, except) {
+		return this.waits.any((wait) => wait !== except && wait._open && wait.answers.includes(key));
+	}
+	flight() {
+		return this.frames.filter((frame) => !frame._undo);
+	}
+	stale() {
+		return !!(this._halted || this._ending);
+	}
+	dropped(id) {
+		return this.line(id).some((at) => this._dropped.has(at) || at !== id && this._dropped.has(at + "^"));
+	}
+	line(id) {
+		const ids = [];
+		for (let at = id; at; at = this._parent.get(at)) ids.push(at);
+		return ids;
+	}
+	async exec(item, from) {
+		if (this.stale() || this.dropped(item.id)) return;
+		const rescue = this._catches.get(item.id);
+		if (rescue && !this._branches.has(item.id)) return this.guard(item, from, rescue);
+		if (item.group) {
+			await Promise.all(item.group.map((member) => this.exec(member, from)));
+			return;
+		}
+		if (item.answers) {
+			const answer = await this.park(item, from);
+			if (answer) {
+				const frame = await answer.frame;
+				await this.cover(frame);
+				await this.complete(frame);
+				answer.done();
+			}
+		} else if (item.key == "end") await this.terminate(item);
+		else {
+			const wait = this.racing(item);
+			if (wait) return void this.wake(wait, item.key, item.args, item);
+			const frame = await this.invoke(item);
+			await this.cover(frame, item);
+			await this.complete(frame);
+		}
+	}
+	async cover(frame, item) {
+		const handler = frame && this._on.get(frame.id)?.find(({ kind }) => kind == "catch");
+		if (!handler) return this.descend(frame);
+		const { id, key, args, _failed: failed } = frame;
+		const shield = id + "^";
+		const branch = { failed };
+		item ||= Object.assign(Object.create(TOKEN), {
+			id,
+			key,
+			args
+		});
+		if (!failed) {
+			this._branches.set(shield, branch);
+			await this.descend(frame);
+			this._branches.delete(shield);
+		}
+		if (!branch.failed) return;
+		const { cause } = branch.failed;
+		const restore = await this.serial(() => failed ? this.rewind(id, cause) : this.recover(item, cause, "error", false));
+		this._dropped.delete(shield);
+		if (this.stale()) return restore();
+		const node = this.given(handler, cause);
+		this._parent.set(node.id, id);
+		this._lineage.set(node.id, {
+			restore,
+			caught: item
+		});
+		this._retried.set(node.id, this.retried(item));
+		await this.exec(node, frame);
+		restore();
+	}
+	async rewind(id, cause) {
+		const entry = this._entries.find((each) => each.id == id);
+		const { prior, log } = this._held.get(id);
+		const kept = /* @__PURE__ */ new Set();
+		this._reset.add(id);
+		this._held.delete(id);
+		try {
+			await this.fire(this._on.get(id), "reset", void 0, kept);
+			entry.unwound = true;
+		} catch (thrown) {
+			entry.unwound = "failed";
+			this.halt("failed", thrown);
+		}
+		const self = this.control._self;
+		let done = false;
+		return (into, all) => {
+			if (done) return;
+			done = true;
+			for (const key in prior) {
+				const wrote = into?._wrote.has(key);
+				if (wrote) into._prior[key] = prior[key];
+				if (all || !wrote && !kept.has(key)) self[key] = prior[key];
+			}
+			for (const [key, undo] of [...log].reverse()) if (all || !into?._changed.has(key)) undo();
+		};
+	}
+	async complete(frame) {
+		const on = frame && this._on.get(frame.id);
+		if (!on) return;
+		const { id } = frame;
+		const losing = [...this._losing].filter(([racer]) => this.line(racer).includes(id));
+		await Promise.all(losing.map(([, unwind]) => unwind));
+		if (this.stale() || this.dropped(id)) return;
+		this._finished.add(id);
+		try {
+			await this.fire(on, "close", void 0, /* @__PURE__ */ new Set());
+		} catch (error) {
+			if (!this.caught(error, id)) this.halt("failed", error);
+		}
+	}
+	async fire(on, kind, cause, kept) {
+		for (const handler of [...on || []].reverse()) if (handler.kind == kind) await this.compensate(this.given(handler, cause), cause, kept, kind == "reset" || kind == "close" || cause === void 0);
+	}
+	given({ node, bare, kind }, cause) {
+		if (bare && (kind == "catch" || kind == "abort" && cause !== void 0)) {
+			node.args = [serial(cause)];
+			this._errors.set(node.id, cause);
+		} else if (kind == "catch" && this._inline.has(node.id)) node.args = [cause];
+		return node;
+	}
+	racing(item) {
+		const line = this.line(item.id);
+		return this.waits.filter((wait) => !!wait._race && line.includes(wait.id) && wait.answers.includes(item.key))[0];
+	}
+	lose(wait, won, answer) {
+		const race = wait._race;
+		const losers = (race.group || [race]).filter((racer) => !won.includes(racer.id));
+		const cause = new Aborted(`${answer.key} answered ${wait.id}.`);
+		for (const racer of losers) {
+			this._dropped.add(racer.id);
+			this._lost.add(racer.id);
+		}
+		for (const frame of this.discard()) frame._abort.abort(cause);
+		for (const [release, from] of this._holding) if (this.dropped(from)) release();
+		for (const racer of losers) this._losing.set(racer.id, this.serial(async () => {
+			await this.quiet(racer.id);
+			(await this.recover(racer, cause, "abort"))(void 0, false, racer.id);
+		}));
+	}
+	quiet(id) {
+		const busy = () => this.flight().some((frame) => this.line(frame.id).includes(id));
+		return new Promise((resolve) => {
+			const check = () => {
+				if (busy()) return;
+				this._quiet.delete(check);
+				resolve();
+			};
+			this._quiet.add(check);
+			check();
+		});
+	}
+	terminate(item) {
+		this.release();
+		return this.end(item);
+	}
+	serial(task) {
+		const prior = this._unwinding;
+		const next = (async () => {
+			await prior;
+			return task();
+		})();
+		this._unwinding = next;
+		return next;
+	}
+	async guard(item, from, rescue) {
+		const branch = {};
+		this._branches.set(item.id, branch);
+		await this.exec(item, from);
+		this._branches.delete(item.id);
+		if (!branch.failed) return;
+		const { cause } = branch.failed;
+		const restore = await this.serial(() => this.recover(item, cause, "error"));
+		const { key, fn } = rescue;
+		const parent = this._parent.get(item.id);
+		if (this.stale() || !fn) return restore();
+		const node = this.node(key || "then", key ? [serial(cause)] : [cause]);
+		if (key) this._errors.set(node.id, cause);
+		this._parent.set(node.id, parent);
+		this._lineage.set(node.id, {
+			restore,
+			caught: item
+		});
+		this._retried.set(node.id, this.retried(item));
+		if (!key) {
+			this._inline.set(node.id, fn);
+			this._owner.set(node.id, from);
+		}
+		await this.exec(node, from);
+		restore();
+	}
+	retried(item) {
+		return this._retried.get(item.id) || 0;
+	}
+	copy(item, retried = this.retried(item) + 1) {
+		const { id, key, args, group, answers, race } = item;
+		const node = this.node(key, args);
+		const rescue = this._catches.get(id);
+		this._retried.set(node.id, retried);
+		if (group) {
+			node.group = group.map((member) => this.copy(member, retried));
+			this._groups.add(node.id);
+			adopt(this._parent, node.group, node.id);
+		}
+		if (answers) node.answers = answers;
+		if (race) {
+			node.race = this.copy(race, retried);
+			adopt(this._parent, [node.race], node.id);
+		}
+		if (rescue) {
+			node.rescue = item.rescue;
+			this._catches.set(node.id, rescue);
+		}
+		return node;
+	}
+	async recover(item, cause, mode, own = true) {
+		const ids = this._entries.filter((entry) => !this._spent.has(entry.id) && (own || entry.id != item.id) && this.line(entry.id).includes(item.id));
+		const unwound = await this.unwind(cause, mode, new Set(ids.map((entry) => entry.id)));
+		let done = false;
+		const restore = (into, all, within) => {
+			if (done) return;
+			done = true;
+			this.refill(unwound, into, all, within);
+		};
+		if (unwound.failed) {
+			const { cause: thrown } = unwound.failed;
+			restore();
+			if (mode == "abort") chain(thrown, cause);
+			this.halt("failed", thrown);
+		}
+		return restore;
+	}
+	caught(error, id) {
+		if (this.stale() || RULES.has(error)) return false;
+		let at;
+		for (const each of this.line(id)) if (each != id && this._branches.has(at = each + "^")) break;
+		else if (this._branches.has(at = each)) break;
+		else at = void 0;
+		if (!at) return false;
+		const branch = this._branches.get(at);
+		if (branch.failed) return true;
+		branch.failed = { cause: error };
+		this._dropped.add(at);
+		for (const frame of this.discard()) frame._abort.abort();
+		return true;
+	}
+	discard() {
+		for (const wait of this.waits.filter((wait) => this.dropped(wait.id))) this.waits.delete(wait);
+		for (const [id, cancel] of this._pending) if (this.dropped(id)) cancel();
+		return this.flight().filter((frame) => this.dropped(frame.id));
+	}
+	async descend(frame) {
+		if (frame) await this.sequence(frame._items, frame);
+	}
+	async sequence(items, from) {
+		for (const [index, item] of items.entries()) {
+			if (item.key != "gate") {
+				await this.exec(item, from);
+				continue;
+			}
+			const release = await this.acquire(item, from);
+			if (!release) return;
+			try {
+				await this.sequence(items.slice(index + 1), from);
+			} finally {
+				release();
+			}
+			return;
+		}
+	}
+	acquire(item, from) {
+		if (this.stale() || this.dropped(item.id)) return;
+		const { id } = item;
+		const { max, key } = this._slots.get(id);
+		const gate = this.gate(from, key);
+		const line = this.line(from.id);
+		const hold = {
+			run: this,
+			from: from.id
+		};
+		const inside = [...gate.held].some((each) => each.run === this && line.includes(each.from));
+		const self = this.control._self;
+		return new Promise((resolve) => {
+			let quiet;
+			let limit = 0;
+			let over = false;
+			const finish = (release) => {
+				over = true;
+				quiet?.();
+				this._pending.delete(id);
+				resolve(release);
+			};
+			const release = () => {
+				if (!gate.held.delete(hold)) return;
+				this._holding.delete(release);
+				pump(gate);
+			};
+			const waiter = {
+				hold,
+				max: typeof max != "function" ? () => max : max.length ? () => limit : max,
+				grant: () => {
+					this._holding.set(release, from.id);
+					finish(release);
+				}
+			};
+			if (inside) return finish(() => {});
+			this._pending.set(id, () => {
+				gate.queue = gate.queue.filter((each) => each !== waiter);
+				finish();
+			});
+			if (typeof max == "function") quiet = max.length ? watch(self, ($) => {
+				limit = max($);
+				pump(gate);
+				return over ? null : void 0;
+			}) : listener(self, (key) => void (signal(key) && pump(gate)));
+			gate.queue.push(waiter);
+			pump(gate);
+		});
+	}
+	gate(from, key) {
+		const { control } = this;
+		if (key instanceof Object) return gate(GATES, key);
+		if (key !== void 0) return gate(control._gates, key);
+		const group = this.line(from.id).find((id) => this._groups.has(id));
+		return group ? gate(this._gates, group) : gate(control._gates, control);
+	}
+	park(item, from) {
+		return new Promise((resolve) => {
+			const { id, answers, race, args } = item;
+			const until = answers.length ? void 0 : Date.now() + args[0];
+			this.waits.add({
+				id,
+				step: from.key,
+				args: from.args,
+				answers,
+				until,
+				_race: race,
+				_from: from,
+				_park: resolve
+			});
+			if (race) this.exec(race, from);
+		});
+	}
+	wake(wait, key, args, node = this.node(key, args)) {
+		const { _ticket } = this;
+		let done;
+		let fail;
+		const answered = handle(_ticket, (res, rej) => {
+			done = res;
+			fail = rej;
+		});
+		const answer = {
+			done: () => this._halted ? fail(this.reason()) : done(),
+			fail
+		};
+		const won = this.line(node.id);
+		wait._answer = answer;
+		this._parent.set(node.id, wait.id);
+		this.waits.delete(wait);
+		if (wait._race) this.lose(wait, won, node);
+		answer.frame = this.invoke(node, wait.id);
+		return answered;
+	}
+	release() {
+		this.waits.clear();
+		for (const cancel of this._pending.values()) cancel();
+		for (const release of this._holding.keys()) release();
+	}
+	async invoke(node, wake, undo) {
+		const { control } = this;
+		const { id, key, args } = node;
+		const inline = this._inline.get(id);
+		const lineage = this._lineage.get(id);
+		const fn = inline || control._steps.get(key);
+		const frame = this.frames.add({
+			id,
+			key,
+			args,
+			_wake: wake,
+			_undo: undo,
+			_owner: this._owner.get(id),
+			_retried: this.retried(node),
+			...lineage && {
+				_restore: lineage.restore,
+				_caught: lineage.caught
+			}
+		});
+		const input = this._errors.has(id) ? [this._errors.get(id)] : args;
+		let body = false;
+		control.active = key;
+		try {
+			control.hook("before", key, args);
+			if (!fn) throw rule(key == "run" ? `${control._self} declares no run - add async run() to start a run.` : `${key} was removed by a hot update.`);
+			for (;;) try {
+				const call = inline ? fn(...input) : fn.apply(frame._proxy, input);
+				const out = id == this._root ? await frame.open(call) : await call;
+				frame._settled = true;
+				const entry = frame.commit(out);
+				frame._restore?.(frame);
+				control.hook("after", key, entry);
+				return frame;
+			} catch (thrown) {
+				if (frame._entry) throw thrown;
+				let error = thrown;
+				let irreversible = [...frame._lost];
+				let fixed = irreversible.length || frame._committed;
+				body = !frame._settled;
+				if (error instanceof Promise && body && !fixed) {
+					await this.fire(frame._on, "reset", void 0, /* @__PURE__ */ new Set());
+					this.reset(frame);
+					const failed = await frame.pause(error);
+					if (!failed) continue;
+					error = failed.cause;
+				}
+				if (fixed) this._entries.push(frame._fixed = {
+					...frame.journal(),
+					error,
+					...irreversible.length && { irreversible }
+				});
+				throw error;
+			}
+		} catch (error) {
+			if (frame._entry && !undo) {
+				frame._restore?.();
+				this.halt("failed", error);
+				return;
+			}
+			const { signal } = frame._abort;
+			const fixed = frame._lost.size || frame._committed;
+			const lost = this.line(id).some((at) => this._lost.has(at));
+			const aborted = signal.aborted && error === signal.reason;
+			const on = !fixed && !undo && frame._on.length ? frame._on : void 0;
+			const defer = on && !aborted && !this.stale();
+			const entry = {
+				id,
+				key,
+				args,
+				next: [],
+				wrote: [],
+				error,
+				...wake && { wake },
+				...frame._retried && { retried: frame._retried }
+			};
+			frame._settled = true;
+			if (!fixed && !defer) this.restore(frame._prior, frame._log);
+			frame._restore?.();
+			if (undo) throw error;
+			if (on) {
+				entry.on = grouped(on);
+				this._on.set(id, on);
+				this._entries.push(entry);
+			}
+			if (defer) this._held.set(id, {
+				prior: frame._prior,
+				log: frame._log
+			});
+			if (aborted) return;
+			if (body && !fixed && !lost && !this.stale() && !RULES.has(error) && !!on?.some(({ kind }) => kind == "catch")) {
+				frame._failed = { cause: error };
+				try {
+					control.hook("after", key, entry);
+				} catch (thrown) {
+					this.halt("failed", thrown);
+				}
+				return frame;
+			}
+			if (body && !fixed && (lost || this.caught(error, id))) {
+				if (!on) this._entries.push(entry);
+				try {
+					control.hook("after", key, entry);
+				} catch (thrown) {
+					this.halt("failed", thrown);
+				}
+			} else this.fault(frame._fixed || entry, !on && !frame._fixed, error);
+		} finally {
+			this.frames.delete(frame);
+			control.active = this.flight().at(-1)?.key;
+			for (const check of [...this._quiet]) check();
+			if (!this.flight().length) for (const resolve of this._drained.splice(0)) resolve();
+		}
+	}
+	fault(entry, push, error) {
+		if (push) this._entries.push(entry);
+		try {
+			this.control.hook("after", entry.key, entry);
+		} catch (thrown) {
+			error = thrown;
+		}
+		this.halt("failed", error);
+	}
+	reset(frame) {
+		this.restore(frame._prior, frame._log);
+		frame._armed++;
+		Object.assign(frame, {
+			_wrappers: /* @__PURE__ */ new Map(),
+			_log: [],
+			_changed: /* @__PURE__ */ new Set(),
+			_items: [],
+			_wrote: /* @__PURE__ */ new Set(),
+			_prior: {},
+			_on: [],
+			_violation: void 0,
+			_late: void 0
+		});
+	}
+	async end(item) {
+		this._ending = true;
+		await this.drain();
+		if (this._unwinding) await this._unwinding;
+		if (this._halted) return;
+		const open = this._entries.filter((entry) => this._on.has(entry.id) && !this._finished.has(entry.id) && !this._spent.has(entry.id));
+		for (const entry of open.reverse()) try {
+			this._finished.add(entry.id);
+			await this.fire(this._on.get(entry.id), "close", void 0, /* @__PURE__ */ new Set());
+		} catch (thrown) {
+			return this.halt("failed", thrown);
+		}
+		const { id } = item || this.node("end", []);
+		const entry = {
+			id,
+			key: "end",
+			args: [],
+			next: [],
+			wrote: [],
+			...!item && { implicit: true }
+		};
+		this._entries.push(entry);
+		if (item) try {
+			this.control.hook("after", "end", entry);
+		} catch (thrown) {
+			return this.halt("failed", thrown);
+		}
+		this.finish();
+	}
+	drain() {
+		if (this.flight().length) return new Promise((resolve) => this._drained.push(resolve));
+	}
+	finish() {
+		const { _tail: tail } = this;
+		this._settling = true;
+		if (!tail) return this.settle(this._result);
+		this._await.resolve();
+		tail.then((value) => this.settle(value), (error) => this.broke(error));
+	}
+	broke(error) {
+		this.blame(error);
+		this.control.status = "failed";
+		this.reject();
+	}
+	settle(value) {
+		const { control } = this;
+		this.close();
+		control.status = "idle";
+		this._ticket.resolve(value);
+		control.advance();
+	}
+	close() {
+		const { control } = this;
+		control._current = void 0;
+		control.runs++;
+		this._entries = [];
+		this._held.clear();
+		this._on.clear();
+		this.frames.clear();
+		this.waits.clear();
+	}
+	halt(status, error) {
+		const { control } = this;
+		if (this._halted || this._settling) return;
+		this._halted = status;
+		control.status = status;
+		for (const frame of this.flight()) frame._abort.abort(status == "failed" ? void 0 : this._stopped);
+		if (status == "failed") {
+			this._error = error;
+			control.error = error;
+		}
+		this.release();
+		this.finalize(MODES[status]);
+	}
+	async finalize(mode) {
+		await this.drain();
+		if (this._unwinding) await this._unwinding;
+		const unwound = await this.unwind(this.reason(), mode);
+		this.refill(unwound);
+		if (unwound.failed) {
+			const { cause } = unwound.failed;
+			if (mode != "error") {
+				chain(cause, this._stopped);
+				this.control.status = "failed";
+			}
+			this.blame(cause);
+		}
+		const { _tail: tail } = this;
+		if (!tail) return this.reject();
+		this._await.reject(this.reason());
+		try {
+			this.salvage(await tail);
+		} catch (thrown) {
+			this.reject(thrown);
+		}
+	}
+	salvage(value) {
+		this.close();
+		this._ticket.resolve(value);
+		this.control.advance();
+	}
+	reason() {
+		const { _error: error } = this;
+		return error === void 0 ? this._stopped : error;
+	}
+	reject(reason = this.reason()) {
+		const { _ticket } = this;
+		let stopped = reason === this._stopped;
+		this.close();
+		_ticket.reject(reason);
+		if (!stopped) queueMicrotask(() => queueMicrotask(() => {
+			if (!_ticket.awaited) throw reason;
+		}));
+		this.control.advance();
+	}
+	async unwind(cause, mode, ids) {
+		const { control, _entries: entries } = this;
+		const pending = entries.filter((entry) => ids ? ids.has(entry.id) : !this._spent.has(entry.id));
+		const kept = /* @__PURE__ */ new Set();
+		const undone = [];
+		let halted = mode == "stop";
+		for (const entry of pending.reverse()) {
+			const on = this._on.get(entry.id);
+			const open = !this._finished.has(entry.id);
+			if (ids && this._halted) break;
+			if (entry.unwound == "failed") break;
+			if (!halted && (entry.irreversible || entry.committed)) {
+				entry.halted = halted = true;
+				if (entry.irreversible) console.warn(`${control._self} stopped unwinding at ${entry.id}: ${entry.irreversible.join(", ")} cannot be restored.`);
+			}
+			if (!on && "error" in entry) continue;
+			try {
+				if (open) await this.fire(on, "abort", mode == "error" ? cause : void 0, kept);
+				if (!halted && !this._reset.has(entry.id)) await this.fire(on, "reset", void 0, kept);
+				this._finished.add(entry.id);
+				if (open) await this.fire(on, "close", void 0, kept);
+			} catch (thrown) {
+				entry.unwound = "failed";
+				return {
+					undone,
+					kept,
+					failed: { cause: thrown }
+				};
+			}
+			this._spent.add(entry.id);
+			if (halted) continue;
+			if (on?.some((handler) => handler.kind == "reset") || this._held.has(entry.id) && entry.wrote.length) entry.unwound = true;
+			undone.push(entry);
+		}
+		return {
+			undone,
+			kept
+		};
+	}
+	async compensate(item, cause, kept, bare) {
+		const fn = this._inline.get(item.id);
+		if (!fn) return this.undo([item], kept);
+		const frame = this.frames.add({
+			id: item.id,
+			key: item.key,
+			args: item.args,
+			_undo: true,
+			_owner: this._owner.get(item.id)
+		});
+		try {
+			await (bare ? fn() : fn(cause));
+		} finally {
+			this.frames.delete(frame);
+			for (const key of frame._wrote) kept.add(key);
+		}
+		await this.undo(frame._items, kept);
+	}
+	async undo(items, kept) {
+		for (const item of items) if (item.group) await Promise.all(item.group.map((member) => this.undo([member], kept)));
+		else {
+			const frame = await this.invoke(item, void 0, true);
+			for (const key of frame._wrote) kept.add(key);
+			await this.undo(frame._items, kept);
+		}
+	}
+	refill({ undone, kept }, into, all, within) {
+		const self = this.control._self;
+		const prior = /* @__PURE__ */ new Map();
+		const log = [];
+		for (const entry of undone) {
+			const held = this._held.get(entry.id);
+			if (!held) continue;
+			for (const key in held.prior) prior.set(key, held.prior[key]);
+			log.push(...[...held.log].reverse());
+		}
+		const since = (key) => !!within && !this.line(this._writer.get(key)).includes(within);
+		for (const [key, value] of prior) {
+			const wrote = into?._wrote.has(key);
+			if (wrote) into._prior[key] = value;
+			if (all || !wrote && !kept.has(key) && !since(key)) self[key] = value;
+		}
+		for (const [key, undo] of log) if (all || !into?._changed.has(key) && !since(key)) undo();
+	}
+	blame(cause) {
+		this._error = cause;
+		this.control.error = cause;
+	}
+	restore(prior, log) {
+		const self = this.control._self;
+		for (const key in prior) self[key] = prior[key];
+		for (const [, undo] of [...log].reverse()) undo();
+	}
+};
+var Frame = class extends Model {
+	run = get(Run);
+	id = "";
+	key = "";
+	args = [];
+	_proxy;
+	_owner = void 0;
+	_view = void 0;
+	_refs = /* @__PURE__ */ new Map();
+	_abort = new AbortController();
+	_items = [];
+	_wrote = /* @__PURE__ */ new Set();
+	_prior = {};
+	_wrappers = /* @__PURE__ */ new Map();
+	_log = [];
+	_on = [];
+	_changed = /* @__PURE__ */ new Set();
+	_lost = /* @__PURE__ */ new Set();
+	_wake = void 0;
+	_undo = void 0;
+	_retried = 0;
+	_restore = void 0;
+	_caught = void 0;
+	_failed = void 0;
+	_committed = void 0;
+	_entry = void 0;
+	_fixed = void 0;
+	_violation = void 0;
+	_late = void 0;
+	_armed = 0;
+	_settled = void 0;
+	_point = void 0;
+	new() {
+		const { _self: self, _steps, _runner } = this.run.control;
+		this._proxy = new Proxy(self, {
+			get: (target, prop) => {
+				const live = this._settled && this.live();
+				if (live) return Reflect.get(live._proxy, prop);
+				if (_steps.has(prop)) return this.ref(prop);
+				const value = Reflect.get(target, prop, target);
+				if (value === _runner) return this.view();
+				return !this._undo && !this._settled && collection(value) ? this.wrap(prop, value) : value;
+			},
+			set: (target, prop, value) => {
+				const key = String(prop);
+				if (this._settled) {
+					const live = this.live();
+					return live ? Reflect.set(live._proxy, prop, value) : Reflect.set(target, prop, value, target);
+				}
+				if (!this._wrote.has(key)) {
+					this._prior[key] = Reflect.get(target, prop, target);
+					this._wrote.add(key);
+				}
+				if (this._items.length) this._violation ||= key;
+				this.run._writer.set(key, this.id);
+				return Reflect.set(target, prop, value, target);
+			}
+		});
+		return () => this._abort.abort();
+	}
+	live() {
+		const { run } = this;
+		if (run.waits.any((wait) => wait._from === this)) return;
+		const live = [...run.frames].filter((frame) => frame.within(this));
+		return live.length == 1 ? live[0] : void 0;
+	}
+	within(owner) {
+		for (let at = this._owner; at; at = at._owner) if (at === owner) return true;
+		return false;
+	}
+	ref(key) {
+		let ref = this._refs.get(key);
+		if (!ref) this._refs.set(key, ref = (...args) => this._settled ? this.answer(key, args) : this.issue(key, args));
+		return ref;
+	}
+	keyOf(fn) {
+		for (const [key, ref] of this._refs) if (ref === fn) return key;
+	}
+	issue(key, args) {
+		const { run } = this;
+		if (this._undo && UNPLANNED.includes(key)) throw rule(`${named(key)} cannot run in an undo.`);
+		if (this._settled) throw rule(`${this.key} has settled; ${key} cannot run.`);
+		if (key == "run") throw rule("run is the entry - loop with a step: a step which schedules itself again.");
+		const token = run.node(key, args);
+		ISSUED.set(token, this);
+		this._items.push(token);
+		this.arm();
+		return token;
+	}
+	answer(key, args) {
+		const { run } = this;
+		const wait = run.control._current === run && run.route(key, args, this);
+		if (wait) return run.wake(wait, key, args);
+		throw rule(`${this.key} has settled; ${key} cannot run.`);
+	}
+	async pause(pending) {
+		const { signal } = this._abort;
+		const abort = new Promise((resolve) => signal.addEventListener("abort", resolve, { once: true }));
+		let failed;
+		if (!signal.aborted) await Promise.race([pending, abort]).catch((cause) => failed = { cause });
+		if (signal.aborted) throw signal.reason;
+		return failed;
+	}
+	open(call) {
+		const { run } = this;
+		const body = Promise.resolve(call);
+		body.catch(() => {});
+		this.arm();
+		return new Promise((resolve, reject) => {
+			this._point = (done, fail) => {
+				if (this._late) {
+					const error = rule("run awaited work before its plan - it takes arguments, calls steps and awaits this.");
+					fail(error);
+					return reject(error);
+				}
+				run._await = {
+					resolve: done,
+					reject: fail
+				};
+				run._tail = body;
+				resolve(void 0);
+			};
+			body.then((value) => {
+				if (run._tail) return;
+				run._result = value;
+				resolve(void 0);
+			}, (error) => {
+				if (!run._tail) reject(error);
+			});
+		});
+	}
+	arm() {
+		const armed = ++this._armed;
+		let hops = SLACK;
+		const tick = () => {
+			if (this._settled || this._armed != armed) return;
+			if (--hops) queueMicrotask(tick);
+			else this._late = true;
+		};
+		queueMicrotask(tick);
+	}
+	view() {
+		if (this._view) return this._view;
+		const retry = () => this.retry();
+		RETRY.add(retry);
+		const view = (...args) => {
+			const [items, each] = args;
+			const fns = args.filter((arg) => typeof arg == "function");
+			const refs = fns.map((fn) => this.keyOf(fn)).filter(Boolean);
+			const tokens = args.filter((arg) => arg && typeof arg == "object");
+			let timed = args.some(plain);
+			let mapped = args.length == 2 && iterable(items) && typeof each == "function";
+			let grouped = args.length && tokens.length == args.length;
+			let waits = refs.length && refs.length == fns.length && refs.length + tokens.length == args.length;
+			if (timed && args.length > 1) throw rule("then() takes a duration alone - this.then({ sec: 10 }).");
+			if (timed) return this.delay(items);
+			if (mapped) return this.group(Array.from(items, each));
+			if (grouped) return this.group(args);
+			if (waits) return this.wait(refs, tokens);
+			if (refs.length) throw rule("then() takes steps uncalled to answer and called ones to race - not other functions.");
+			if (fns.length == 2 && args.length == 2 && this._point && !this._settled) return this._point(fns[0], fns[1]);
+			if (fns.length == 1) throw rule("then() takes steps, not a function - declare the work as a step.");
+			throw rule("a step cannot await its own run.");
+		};
+		Object.setPrototypeOf(view, this.run.control._runner);
+		Object.defineProperties(view, {
+			then: { value: view },
+			end: { value: (...value) => (valueless(value), this.issue("end", [])) },
+			signal: { get: () => this._abort.signal },
+			retried: { get: () => this._retried },
+			retry: { value: retry },
+			only: { value: (max, key) => this.slot(max, key) },
+			on: { value: (handlers) => this.handle(handlers) },
+			restore: { value: () => {
+				if (!this._restore) throw rule("restore() must be called in a .catch handler.");
+				this._restore(this, true);
+			} },
+			commit: { value: () => {
+				if (this._settled) throw rule(`${this.key} has settled; commit cannot run.`);
+				this._committed = true;
+			} }
+		});
+		return this._view = view;
+	}
+	handle(handlers) {
+		const { run } = this;
+		const usage = "then.on() takes steps called for it - { reset: this.release(id) } - or a function.";
+		if (this.id == run._root) throw rule("run cleans up in its tail - try/catch around await this.");
+		if (this._undo) throw rule("then.on() cannot run in a handler step - use try/finally inside it.");
+		if (this._settled) throw rule(`${this.key} has settled; on cannot run.`);
+		if (!plain(handlers)) throw rule(usage);
+		for (const [kind, value] of Object.entries(handlers)) {
+			if (!KINDS.includes(kind)) throw rule(`then.on() takes reset, catch, abort and close - got ${kind}.`);
+			if (value === void 0) continue;
+			if (kind == "catch" && this._on.some((handler) => handler.kind == "catch")) throw rule("then.on() takes one catch per step.");
+			const step = typeof value == "function" && this.keyOf(value);
+			let node;
+			if (step) node = run.node(step, []);
+			else if (typeof value == "function") {
+				node = run.node("then", []);
+				run._inline.set(node.id, value);
+				run._owner.set(node.id, this);
+			} else [node] = this.claimed(Array.isArray(value) ? value : [value], usage, "then.on()");
+			this._on.push({
+				kind,
+				node,
+				bare: !!step
+			});
+		}
+	}
+	claimed(args, usage, verb = "then()") {
+		const { _steps } = this.run.control;
+		const fns = args.filter((arg) => typeof arg == "function");
+		const steps = args.every((arg) => {
+			const node = arg;
+			return this._items.includes(node) && !UNPLANNED.includes(node.key) && (node.group || _steps.has(node.key));
+		});
+		if (fns.length && fns.length < args.length) throw rule(`${verb} takes called steps or step references, not both.`);
+		if (!args.length || !steps) throw rule(usage);
+		return this.claim([args.length > 1 ? this.group(args) : args[0]]);
+	}
+	claim(nodes) {
+		this._items = this._items.filter((item) => !nodes.includes(item));
+		if (this._items.length) this.arm();
+		else {
+			this._armed++;
+			this._late = void 0;
+		}
+		return nodes;
+	}
+	rescue(token, handler) {
+		const key = this.keyOf(handler);
+		if (UNCAUGHT.includes(token.key)) throw rule(`${named(token.key)} cannot be caught.`);
+		if (handler && typeof handler != "function") throw rule("catch() takes a step, a function or nothing.");
+		if (RETRY.has(handler)) throw rule("catch() retries from a handler: .catch(this.rescan), rescan(error) { if (this.then.retried >= 3) throw error; this.then.retry(); }");
+		token.rescue = handler ? key || "then" : true;
+		this.run._catches.set(token.id, {
+			key,
+			fn: handler
+		});
+		return token;
+	}
+	retry() {
+		const { run, _caught: caught } = this;
+		if (!caught) throw rule("retry() must be called in a .catch handler.");
+		if (this._settled) throw rule(`${this.key} has settled; retry cannot run.`);
+		this._items.push(run.copy(caught));
+		this.arm();
+	}
+	slot(max, key) {
+		if (typeof max != "number" && typeof max != "function") throw rule("only() takes a count, or a function returning one.");
+		const token = this.issue("gate", []);
+		this.run._slots.set(token.id, {
+			max,
+			key
+		});
+	}
+	delay(duration) {
+		let ms = 0;
+		if (!Object.keys(duration).length) throw rule("then() takes a duration of ms, sec, min, hr and day as numbers - got none.");
+		for (const [unit, value] of Object.entries(duration)) if (!Object.hasOwn(UNITS, unit) || typeof value != "number" || !(value >= 0)) throw rule(`then() takes a duration of ms, sec, min, hr and day as numbers - got ${unit}.`);
+		else ms += value * UNITS[unit];
+		return Object.assign(this.issue("wait", [ms]), { answers: [] });
+	}
+	group(members) {
+		for (const member of members) if (!this._items.includes(member)) throw rule(`then() takes steps called by ${this.key}.`);
+		const group = Object.assign(this.run.node("then", []), { group: members });
+		ISSUED.set(group, this);
+		this.run._groups.add(group.id);
+		this._items = this._items.filter((item) => !members.includes(item));
+		this._items.push(group);
+		this.arm();
+		return group;
+	}
+	wait(answers, racers) {
+		for (const key of answers) if (key == "run") throw rule("run cannot answer a wait.");
+		const [race] = racers.length ? this.claimed(racers, "then() races steps called for it - this.then(this.allow, this.timeout(call)).") : [];
+		const token = Object.assign(this.issue("wait", []), { answers }, race && { race });
+		if (race) adopt(this.run._parent, [race], token.id);
+		return token;
+	}
+	commit(out) {
+		const { run, id, key, _items: items, _violation, _late, _wake, _lost, _on } = this;
+		if (_violation) throw rule(`${key} wrote ${_violation} after scheduling ${items[0].key}.`);
+		if (_late && !items.length) throw rule("run awaited work before its plan - it takes arguments, calls steps and awaits this.");
+		if (_late) throw rule(`${key} kept working after scheduling ${items[0].key}.`);
+		const root = id == run._root;
+		if (!root && out !== void 0) throw rule(`${key} returned a value; a step returns nothing - its undo is this.then.on({ reset }).`);
+		const end = items.findIndex((item) => item.key == "end");
+		if (end >= 0 && end < items.length - 1) throw rule("end must be the last call in a step.");
+		adopt(run._parent, items, id);
+		const entry = {
+			...this.journal(),
+			next: items
+		};
+		if (_wake) entry.wake = _wake;
+		if (this._retried) entry.retried = this._retried;
+		if (_on.length) {
+			entry.on = grouped(_on);
+			run._on.set(id, _on);
+		}
+		if (_lost.size && !_on.some((handler) => handler.kind == "reset")) entry.irreversible = [..._lost];
+		if (!root) run._held.set(id, {
+			prior: this._prior,
+			log: this._log
+		});
+		if (this._undo) run._spent.add(id);
+		run._entries.push(entry);
+		this._entry = entry;
+		return entry;
+	}
+	journal() {
+		const { id, key, args, _wrote, _changed, _committed } = this;
+		const entry = {
+			id,
+			key,
+			args,
+			next: [],
+			wrote: [...new Set([..._wrote, ..._changed])]
+		};
+		if (_committed) entry.committed = true;
+		return entry;
+	}
+	wrap(key, value) {
+		let wrapper = this._wrappers.get(value);
+		if (wrapper) return wrapper;
+		const ops = mutators(value);
+		wrapper = new Proxy(value, { get: (target, prop) => {
+			const op = ops[prop];
+			if (op) return (...args) => {
+				const out = this.change(key, () => op(...args));
+				return out === target ? wrapper : out;
+			};
+			const got = Reflect.get(target, prop, target);
+			return typeof got == "function" ? got.bind(target) : got;
+		} });
+		this._wrappers.set(value, wrapper);
+		return wrapper;
+	}
+	change(key, op) {
+		const at = this._settled ? this.live() : this;
+		if (!at) return op()[0];
+		const [out, changed, undo, lost] = op();
+		if (!changed) return out;
+		if (at._items.length) at._violation ||= key;
+		if (undo) at._log.push([key, undo]);
+		if (lost) at._lost.add(key);
+		at._changed.add(key);
+		at.run._writer.set(key, at.id);
+		return out;
+	}
+};
+var Wait = class extends Model {
+	run = get(Run);
+	id = "";
+	step = "";
+	args = [];
+	answers = [];
+	until = void 0;
+	_from;
+	_park;
+	_answer = void 0;
+	_race = void 0;
+	_open = true;
+	new() {
+		const { run, answers, until } = this;
+		const { _self: self } = run.control;
+		let timer;
+		const arm = () => {
+			const left = until - Date.now();
+			timer = setTimeout(left > LONGEST ? arm : () => run.waits.delete(this), Math.min(left, LONGEST));
+		};
+		if (until !== void 0) arm();
+		for (const key of answers) if (!run.accepts(key, this)) event(self, key);
+		return () => {
+			this._open = false;
+			clearTimeout(timer);
+			for (const key of answers) if (!run.accepts(key)) event(self, key);
+			this._park(this._answer);
+		};
+	}
+};
+function chain(error, cause) {
+	if (error instanceof Error && error.cause === void 0) error.cause = cause;
+}
+function grouped(on) {
+	const out = {};
+	for (const { kind, node } of on) (out[kind] ||= []).push(node);
+	return out;
+}
+function serial(error) {
+	if (!(error instanceof Error)) return error;
+	const { name, message, cause } = error;
+	return {
+		name,
+		message,
+		...cause !== void 0 && { cause }
+	};
+}
+function rule(message) {
+	const error = new Error(message);
+	RULES.add(error);
+	return error;
+}
+function named(key) {
+	return key == "gate" ? "a gate" : `${key}()`;
+}
+function plain(value) {
+	if (!value || typeof value != "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function signal(key) {
+	return typeof key != "boolean" && key !== null;
+}
+function iterable(value) {
+	return value != null && typeof value[Symbol.iterator] == "function";
+}
+function valueless(args) {
+	if (args.length) throw rule("end() takes no value; the result is what run returns.");
+}
+function outside(key, verb = "called") {
+	throw rule(`${key} must be ${verb} inside a step.`);
+}
+var Handled = class extends Promise {
+	static get [Symbol.species]() {
+		return Promise;
+	}
+	then(...args) {
+		this._ticket.awaited = true;
+		return super.then(...args);
+	}
+};
+function handle(ticket, executor) {
+	const handled = new Handled(executor);
+	handled._ticket = ticket;
+	Promise.prototype.then.call(handled, void 0, () => {});
+	return handled;
+}
+function gate(gates, key) {
+	let gate = gates.get(key);
+	if (!gate) gates.set(key, gate = {
+		held: /* @__PURE__ */ new Set(),
+		queue: []
+	});
+	return gate;
+}
+function pump(gate) {
+	for (let next = gate.queue[0]; next && gate.held.size < next.max(); next = gate.queue[0]) {
+		gate.queue.shift();
+		gate.held.add(next.hold);
+		next.grant();
+	}
+}
+function adopt(parents, items, parent) {
+	for (const item of items) {
+		parents.set(item.id, parent);
+		if (item.group) adopt(parents, item.group, item.id);
+	}
+}
+function collection(value) {
+	return value instanceof has.List || value instanceof has.Pool || value instanceof map.Managed;
+}
+function dead(value) {
+	return value instanceof Model && value.get(null);
+}
+function mutators(value) {
+	if (value instanceof has.List) return listOps(value);
+	if (value instanceof has.Pool) return poolOps(value);
+	return mapOps(value);
+}
+function listOps(list) {
+	const at = (index, size) => index < 0 ? Math.max(size + index, 0) : Math.min(index, size);
+	const unput = (start, values) => () => {
+		for (let i = values.length - 1; i >= 0; i--) {
+			const found = near(list, values[i], start + i);
+			if (found >= 0) list.pop(found);
+		}
+	};
+	return {
+		push: (...values) => {
+			const start = list.size;
+			return [
+				list.push(...values),
+				values.length > 0,
+				unput(start, values)
+			];
+		},
+		put: (index, ...values) => {
+			const start = at(index, list.size);
+			list.put(index, ...values);
+			return [
+				void 0,
+				values.length > 0,
+				unput(start, values)
+			];
+		},
+		pop: (index = -1, count) => {
+			const before = list.get(0, list.size);
+			const start = at(index, before.length);
+			const removed = before.slice(start, start + (count ?? 1));
+			return [
+				count === void 0 ? list.pop(index) : list.pop(index, count),
+				removed.length > 0,
+				() => list.put(start, ...removed)
+			];
+		},
+		set: (index, value) => {
+			const before = list.get(0, list.size);
+			const start = index < 0 ? before.length + index : index;
+			const prior = before[start];
+			list.set(index, value);
+			const restore = () => {
+				const found = near(list, value, start);
+				if (found >= 0) list.set(found, prior);
+			};
+			return [
+				void 0,
+				start >= 0 && start < before.length && prior !== value,
+				restore
+			];
+		},
+		clear: () => {
+			const removed = list.get(0, list.size);
+			list.clear();
+			return [
+				void 0,
+				removed.length > 0,
+				() => list.put(0, ...removed)
+			];
+		}
+	};
+}
+function poolOps(pool) {
+	const added = /* @__PURE__ */ new Set();
+	const lost = (members) => members.filter((member) => !added.delete(member)).length > 0;
+	return {
+		add: (...args) => {
+			const size = pool.size;
+			const made = pool.add(...args);
+			const fresh = pool.size > size;
+			if (fresh) added.add(made);
+			return [
+				made,
+				fresh,
+				() => pool.delete(made)
+			];
+		},
+		delete: (member) => {
+			const had = pool.delete(member);
+			return [
+				had,
+				had,
+				void 0,
+				had && lost([member])
+			];
+		},
+		clear: () => {
+			const members = [...pool];
+			pool.clear();
+			return [
+				void 0,
+				members.length > 0,
+				void 0,
+				lost(members)
+			];
+		}
+	};
+}
+function mapOps(map) {
+	const added = /* @__PURE__ */ new Set();
+	const removed = (entries) => {
+		const kept = entries.filter(([, value]) => !dead(value));
+		const lost = entries.some(([key, value]) => dead(value) && !added.has(key));
+		const restore = () => {
+			for (const [key, value] of kept) if (!map.has(key)) map.set(key, value);
+		};
+		return [
+			void 0,
+			entries.length > 0,
+			restore,
+			lost
+		];
+	};
+	return {
+		set: (key, ...rest) => {
+			const had = map.has(key);
+			const prior = map.get(key);
+			const own = !had || added.has(key);
+			map.set(key, ...rest);
+			const value = map.get(key);
+			const gone = had && dead(prior);
+			const restore = () => {
+				if (map.get(key) !== value) return;
+				if (had && !gone) map.set(key, prior);
+				else if (own) map.delete(key);
+			};
+			added.add(key);
+			return [
+				map,
+				!had || value !== prior,
+				restore,
+				gone && !own
+			];
+		},
+		delete: (key) => {
+			const entry = [key, map.get(key)];
+			const had = map.delete(key);
+			const change = removed(had ? [entry] : []);
+			change[0] = had;
+			return change;
+		},
+		clear: () => {
+			const entries = [...map.entries()];
+			map.clear();
+			return removed(entries);
+		}
+	};
+}
+function near(list, value, at) {
+	let found = -1;
+	list.get(0, list.size).forEach((item, index) => {
+		if (item === value && (found < 0 || Math.abs(index - at) < Math.abs(found - at))) found = index;
+	});
+	return found;
+}
+
+//#endregion
+export { Steps };
+//# sourceMappingURL=index.js.map