dougong 0.8.2 → 0.9.0

package/dist/index.js

@@ -1,9 +1,2208 @@
-export * from "@dougongjs/core";
-export * from "@dougongjs/platform";
-import { batch as m, computed as p, observe as f, signal as x } from "@dougongjs/reactive";
-export {
-  m as batch,
-  p as computed,
-  f as observe,
-  x as signal
+import { _ as e, a as t, b as n, c as r, d as i, f as a, g as o, h as s, i as c, l, m as u, n as d, o as f, p, r as m, s as h, t as g, u as _, v, y } from "./record-CZVpq8vk.js";
+// src/contracts/contracts.ts
+function ee(e, t) {
+	if (!b(t)) throw TypeError(typeof t == "string" && t.trim() ? `${e} id cannot start or end with whitespace` : `${e} id must be a non-empty string`);
+}
+function b(e) {
+	return typeof e == "string" && e.length > 0 && e === e.trim();
+}
+function x(e, t) {
+	return ee("Contract", t), Object.freeze({
+		id: t,
+		kind: e
+	});
+}
+function S(e, t) {
+	let n = Object.getOwnPropertyDescriptor(e, t);
+	return n && "value" in n ? n.value : void 0;
+}
+function C(e, t) {
+	let n = S(e, "id");
+	if (b(n) && (t === "service" || t === "extensionPoint" || t === "event")) return {
+		id: n,
+		kind: t
+	};
+}
+function w(e, t, n) {
+	let r = e && typeof e == "object" ? C(e, S(e, "kind")) : void 0;
+	if (!r || t !== void 0 && r.kind !== t) throw TypeError(n ?? (t ? `Expected ${te(t)}` : "Invalid contract"));
+	return Object.freeze(r);
+}
+function te(e) {
+	return e === "extensionPoint" ? "an ExtensionPoint" : e === "event" ? "an Event" : "a Service";
+}
+function ne(e) {
+	return x("service", e);
+}
+function re(e) {
+	return x("event", e);
+}
+function ie(e) {
+	return x("extensionPoint", e);
+}
+function ae(e) {
+	return Object.freeze({
+		kind: "optional",
+		service: w(e, "service", "optional() expects a Service")
+	});
+}
+function T(e, t = "Expected a Service or ExtensionPoint", n = "Expected a Service") {
+	if (!e || typeof e != "object") throw TypeError(t);
+	let r = S(e, "kind");
+	if (r === "optional") return Object.freeze({
+		kind: r,
+		service: w(S(e, "service"), "service", n)
+	});
+	let i = C(e, r);
+	if (!i || i.kind === "event") throw TypeError(t);
+	return Object.freeze(i);
+}
+// src/contracts/resource.ts
+function E(e) {
+	if (typeof e != "object" && typeof e != "function" || e === null) throw TypeError("Resource must implement Symbol.dispose or Symbol.asyncDispose");
+	let t = e[y];
+	if (t != null) {
+		if (typeof t != "function") throw TypeError("Symbol.asyncDispose must be a function");
+		return () => Reflect.apply(t, e, []);
+	}
+	let r = e[n];
+	if (typeof r != "function") throw TypeError("Resource must implement Symbol.dispose or Symbol.asyncDispose");
+	return () => v(Reflect.apply(r, e, []), "Symbol.dispose must be synchronous");
+}
+// src/lifetime/lifetime.ts
+var D = /* @__PURE__ */ new WeakMap(), oe = class {
+	published = !1;
+}, O = Object.freeze(new DOMException("Resource disposed", "AbortError")), se = class {
+	id;
+	kind;
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	constructor(e, t, n, r, i) {
+		this.#i = i, this.id = e, this.kind = t, this.#e = n, this.#t = r;
+	}
+	get failure() {
+		return this.#r;
+	}
+	dispose() {
+		if (this.#n) return this.#n;
+		let e = this.#e;
+		if (!e) return Promise.resolve();
+		let t = Promise.withResolvers();
+		return this.#n = Object.freeze(t.promise), Promise.resolve().then(e).then(() => {
+			this.#e = void 0;
+			let e = this.#t;
+			this.#t = void 0, this.#i = void 0, e?.(), t.resolve();
+		}, (e) => {
+			this.#r = new _(e), this.#i?.(), t.reject(e);
+		}), t.promise;
+	}
+	forget() {
+		if (this.#n) return;
+		this.#e = void 0, this.#i = void 0;
+		let e = this.#t;
+		this.#t = void 0, e?.();
+	}
+}, ce = class {
+	id;
+	publication;
+	failure;
+	constructor(e, t) {
+		this.id = e, this.publication = t;
+	}
+	withdraw() {
+		if (this.failure) return !1;
+		try {
+			v(this.publication[n](), "Publication withdrawal must be synchronous");
+		} catch (e) {
+			return this.failure = {
+				reason: e,
+				recorded: new _(e)
+			}, !1;
+		}
+		return !0;
+	}
+}, le = class {
+	handle;
+	#e;
+	#t;
+	settled;
+	constructor(e, t, n) {
+		let r = new AbortController();
+		this.#e = r, this.#t = n;
+		let a = t, o = (e) => {
+			if (!a) return;
+			let t = a;
+			a = void 0;
+			try {
+				i(r.signal, e) || t(e);
+			} catch (e) {
+				queueMicrotask(() => {
+					throw e;
+				});
+			}
+		}, s = Promise.resolve().then(() => {
+			try {
+				return e(r.signal);
+			} catch (e) {
+				throw o(e), e;
+			}
+		});
+		this.settled = Object.freeze(s.then(() => this.#n(), (e) => {
+			o(e), this.#n();
+		})), this.handle = Object.freeze({
+			result: s,
+			[y]: this.#r.bind(this)
+		});
+	}
+	#n() {
+		this.#e = void 0;
+		let e = this.#t;
+		this.#t = void 0, e?.();
+	}
+	#r() {
+		return this.cancel(O), this.settled;
+	}
+	cancel(e) {
+		let t = this.#e;
+		this.#e = void 0, t?.abort(e);
+	}
+}, ue = class t {
+	#e;
+	#t = new AbortController();
+	#n;
+	#r = /* @__PURE__ */ new Set();
+	#i = /* @__PURE__ */ new Set();
+	#a = /* @__PURE__ */ new Set();
+	#o = /* @__PURE__ */ new Set();
+	#s = /* @__PURE__ */ new Set();
+	#c = /* @__PURE__ */ new Set();
+	#l;
+	#u;
+	#d;
+	#f = "active";
+	#p = 0;
+	#m = 0;
+	#h;
+	#g;
+	#_;
+	#v;
+	#y;
+	#b;
+	constructor(t, n) {
+		if (de(t.label), typeof t.report != "function") throw TypeError("Lifetime error reporter must be a function");
+		this.#e = t.label, this.#u = t.report, this.#d = t.changed, this.#l = A(t.shutdownTimeoutMilliseconds), this.#n = n?.visibility ?? new oe(), this.#g = n?.detach, t.parentSignal && (this.#h = e(t.parentSignal, (e) => {
+			this.block(), this.#D(e);
+		}));
+	}
+	get handle() {
+		return this.#b ??= this.#x({});
+	}
+	#x(e) {
+		let t = this, n = Object.freeze({
+			...e,
+			get signal() {
+				return t.signal;
+			},
+			use: (e) => this.use(e),
+			defer: (e) => this.defer(e),
+			child: (e) => this.child(e),
+			spawn: (e) => this.spawn(e),
+			acquire: (e) => this.acquire(e),
+			interrupt: (e) => this.interrupt(e)
+		});
+		return D.set(n, this), n;
+	}
+	resolveOwner(e) {
+		if (this.#N(), e === void 0) return this;
+		let t = D.get(e);
+		if (!t || !this.#C(t)) throw TypeError("Lifetime owner must belong to the current scope tree");
+		return t.#N(), t;
+	}
+	*#S() {
+		let e = [this];
+		for (; e.length;) {
+			let t = e.pop();
+			yield t;
+			for (let n of [...t.#r].reverse()) e.push(n);
+		}
+	}
+	#C(e) {
+		for (let t of this.#S()) if (t === e) return !0;
+		return !1;
+	}
+	get signal() {
+		return this.#t.signal;
+	}
+	get phase() {
+		return this.#f;
+	}
+	get acceptsWork() {
+		return this.#f === "active" && !o(this.signal);
+	}
+	get published() {
+		return this.#n.published;
+	}
+	get busy() {
+		for (let e of this.#S()) if (e.#p > 0) return !0;
+		return !1;
+	}
+	snapshot() {
+		let e = /* @__PURE__ */ new Map();
+		for (let t of [...this.#S()].reverse()) e.set(t, t.#w([...t.#r].map((t) => e.get(t))));
+		return e.get(this);
+	}
+	#w(e) {
+		let t = [], n = (e, n, r) => {
+			r && t.push(Object.freeze({
+				id: e,
+				kind: n,
+				error: r.snapshot
+			}));
+		};
+		for (let e of this.#i) n(e.id, e.kind, e.failure);
+		for (let e of this.#a) n(e.id, e.kind, e.failure);
+		for (let e of this.#o) n(e.id, "publication", e.failure?.recorded);
+		return n(0, "shutdown", this.#y), Object.freeze({
+			label: this.#e,
+			phase: this.#f,
+			cleanups: this.#i.size,
+			interrupts: this.#a.size,
+			tasks: this.#s.size,
+			acquisitions: this.#c.size,
+			publications: this.#o.size,
+			foreground: this.#p,
+			unresolved: Object.freeze(t),
+			children: Object.freeze(e)
+		});
+	}
+	use(e) {
+		return this.#T(e), e;
+	}
+	own(e) {
+		let t = this.#T(e);
+		return () => t.forget();
+	}
+	#T(e) {
+		this.#N();
+		let t = E(e);
+		return this.#N(), this.#j(t, "cleanup");
+	}
+	defer(e) {
+		if (this.#N(), typeof e != "function") throw TypeError("Cleanup must be a function");
+		let t = this.#j(e, "cleanup");
+		return Object.freeze({ [y]: () => t.dispose() });
+	}
+	interrupt(e) {
+		if (this.#N(), typeof e != "function") throw TypeError("Interrupt must be a function");
+		let t = this.#j(e, "interrupt");
+		return Object.freeze({ [n]: () => t.forget() });
+	}
+	child(e) {
+		this.#N();
+		let n = new t({
+			label: e,
+			report: this.#u,
+			...this.#d && { changed: this.#d },
+			...this.#l === void 0 ? {} : { shutdownTimeoutMilliseconds: this.#l }
+		}, {
+			visibility: this.#n,
+			detach: (e) => {
+				this.#r.delete(e), this.#d?.();
+			}
+		});
+		this.#r.add(n), this.#d?.();
+		let r = n.#x({ [y]: n.dispose.bind(n) });
+		return n.#b = r, r;
+	}
+	spawn(e) {
+		return this.#E(e, (e) => this.#M(e));
+	}
+	prepare(e) {
+		return this.#E(e).result;
+	}
+	#E(e, t) {
+		if (this.#N(), typeof e != "function") throw TypeError("Task must be a function");
+		let n = new le(e, t, () => {
+			this.#s.delete(n), this.#d?.();
+		});
+		return this.#s.add(n), this.#d?.(), n.handle;
+	}
+	acquire(e) {
+		if (this.#N(), typeof e != "function") throw TypeError("Acquisition must be a function");
+		let t = Promise.resolve().then(() => e(this.signal)).then(async (e) => {
+			let t = this.#j(E(e), "cleanup");
+			if (!this.acceptsWork) {
+				let e = o(this.signal) ? s(this.signal) : O;
+				throw await t.dispose(), e;
+			}
+			return Object.freeze({ resource: e });
+		}), n = () => {
+			this.#c.delete(r), this.#d?.();
+		}, r = t.then(n, n);
+		return this.#c.add(r), this.#d?.(), t;
+	}
+	stage(e) {
+		this.#N();
+		let t, n = e(() => {
+			t && !t.failure && this.#o.delete(t), this.#d?.();
+		});
+		return t = new ce(++this.#m, n), this.#o.add(t), this.#d?.(), this.published && n.publish(), n;
+	}
+	borrow(e) {
+		if (this.#N(), typeof e != "function") throw TypeError("Borrow callback must be a function");
+		this.#p++, this.#d?.();
+		let t = () => {
+			this.#p--, this.#d?.();
+		};
+		try {
+			let n = e(), r = new Promise((e) => e(n));
+			return r.then(t, t), r;
+		} catch (e) {
+			return t(), Promise.reject(e);
+		}
+	}
+	seal() {
+		if (this.busy) throw new l("BUSY", "Lifetime has in-flight foreground work");
+		this.block();
+	}
+	block() {
+		for (let e of this.#S()) e.#f === "active" && (e.#f = "sealed");
+	}
+	#D(e) {
+		for (let t of this.#S()) {
+			t.#t.abort?.(e);
+			for (let n of t.#s) n.cancel(e);
+		}
+	}
+	publish() {
+		if (this.#N(), this.#g) throw TypeError("Only the root Lifetime may publish declarations");
+		if (!this.#n.published) {
+			this.#n.published = !0;
+			for (let e of this.#S()) for (let t of e.#o) t.publication.publish();
+		}
+	}
+	detachStartupSignal() {
+		this.#h?.(), this.#h = void 0;
+	}
+	dispose() {
+		if (this.#_) return this.#_;
+		if (this.#f === "disposed") return Promise.resolve();
+		try {
+			this.seal();
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		let e = [...this.#S()].filter((e) => !e.#_), t = [];
+		for (let n = e.length - 1; n >= 0; n--) {
+			let r = e[n];
+			r.#O(r === this ? t : []);
+		}
+		try {
+			h(() => {
+				for (let t of e) t.#A();
+				this.#d?.();
+			});
+		} catch (e) {
+			t.push(e);
+		}
+		return this.#D(O), this.#_;
+	}
+	#O(e) {
+		this.#f = "disposing", this.detachStartupSignal();
+		let t = Promise.resolve().then(() => this.#k(e));
+		if (this.#v = t, this.#l === void 0) {
+			this.#_ = Object.freeze(t);
+			return;
+		}
+		let n = Promise.withResolvers();
+		this.#_ = Object.freeze(n.promise), n.promise.catch(() => void 0);
+		let r = setTimeout(() => {
+			let e = new l("SHUTDOWN_TIMEOUT", "Lifetime shutdown did not complete before its deadline");
+			this.#y = new _(e), this.#f = "quarantined", this.#d?.(), n.reject(e);
+		}, this.#l);
+		t.then(() => {
+			clearTimeout(r), n.resolve();
+		}, (e) => {
+			clearTimeout(r), n.reject(e);
+		});
+	}
+	async #k(e) {
+		for (let t of this.#o) t.failure && e.push(t.failure.reason);
+		let t = Promise.allSettled([...this.#r].map((e) => e.#v)), n = [...this.#a].reverse().map((e) => e.dispose());
+		for (let t of await Promise.allSettled(n)) t.status === "rejected" && e.push(t.reason);
+		let r = [...this.#s].map((e) => e.settled);
+		await Promise.all(r), await Promise.allSettled([...this.#c]);
+		let i = await t;
+		for (let t of i) t.status === "rejected" && e.push(t.reason);
+		if (i.every((e) => e.status === "fulfilled")) for (let t of [...this.#i].reverse()) try {
+			await t.dispose();
+		} catch (t) {
+			e.push(t);
+		}
+		if (this.#y = void 0, e.length) throw this.#f = "quarantined", this.#d?.(), AggregateError(e, "Lifetime has unresolved cleanup obligations");
+		this.#f = "disposed", this.#t = { signal: AbortSignal.abort(O) }, this.#d?.(), this.#d = void 0;
+		let a = this.#g;
+		this.#g = void 0, a?.(this), this.#u = void 0;
+	}
+	#A() {
+		for (let e of [...this.#o].reverse()) e.withdraw() ? this.#o.delete(e) : this.#o.add(e);
+	}
+	#j(e, t) {
+		let n = t === "cleanup" ? this.#i : this.#a, r;
+		return r = new se(++this.#m, t, e, () => {
+			n.delete(r), this.#d?.();
+		}, () => this.#d?.()), n.add(r), this.#d?.(), r;
+	}
+	#M(e) {
+		let t = this.#u;
+		t && v(t(e), "Lifetime error reporters must be synchronous");
+	}
+	#N() {
+		if (!this.acceptsWork) throw new l("LIFETIME_DISPOSED", "Lifetime is closed to new work");
+	}
+}, k = 2 ** 31 - 1;
+function A(e) {
+	if (e !== void 0) {
+		if (typeof e != "number" || !Number.isFinite(e) || e <= 0 || e > k) throw TypeError(`shutdownTimeoutMilliseconds must be a positive finite number no greater than ${k}`);
+		return e;
+	}
+}
+function de(e) {
+	if (typeof e != "string" || !e.trim() || e !== e.trim()) throw TypeError("Lifetime label must be a non-empty trimmed string");
+}
+// src/contracts/contract-registry.ts
+var fe = class {
+	#e = /* @__PURE__ */ new Map();
+	assertKinds(e) {
+		for (let [t, n] of e) this.assertCompatible({
+			id: t,
+			kind: n
+		});
+	}
+	assertCompatible(e) {
+		M(this.#e, e);
+	}
+	remember(e) {
+		j(this.#e, e);
+	}
+	writer(e) {
+		return new pe(this, e);
+	}
+	commit(e) {
+		this.assertKinds(e);
+		for (let [t, n] of e) this.#e.set(t, n);
+	}
+}, pe = class {
+	#e;
+	constructor(e, t) {
+		this.#e = {
+			phase: "staged",
+			registry: e,
+			pending: /* @__PURE__ */ new Map()
+		};
+		for (let [e, n] of t) this.remember({
+			id: e,
+			kind: n
+		});
+	}
+	remember(e) {
+		let t = this.#e;
+		if (t.phase === "committed") t.registry.remember(e);
+		else {
+			if (t.phase === "discarded") throw Error("Contract registry writer has been discarded");
+			t.registry.assertCompatible(e), j(t.pending, e);
+		}
+	}
+	commit() {
+		let e = this.#e;
+		e.phase === "staged" && (e.registry.commit(e.pending), this.#e = {
+			phase: "committed",
+			registry: e.registry
+		});
+	}
+	discard() {
+		this.#e.phase === "staged" && (this.#e = { phase: "discarded" });
+	}
 };
+function j(e, t) {
+	M(e, t), e.set(t.id, t.kind);
+}
+function M(e, t) {
+	let n = e.get(t.id);
+	if (n && n !== t.kind) throw new l("CONTRACT_CONFLICT", `Contract '${t.id}' is used as both '${n}' and '${t.kind}'`);
+}
+// src/events/event-hub.ts
+var me = class {
+	#e;
+	#t;
+	handle;
+	constructor(e, t, r, i, a) {
+		this.#e = t, this.#t = {
+			hub: e,
+			listener: r,
+			owner: i,
+			detach: a
+		}, this.handle = Object.freeze({ [n]: () => this[n]() });
+	}
+	publish() {
+		let e = this.#t;
+		e && e.hub.add(this.#e, this);
+	}
+	invoke(e) {
+		let t = this.#t;
+		if (!t) return Promise.resolve();
+		let { owner: n, listener: r } = t;
+		return n.borrow(() => r(e));
+	}
+	[n]() {
+		let e = this.#t;
+		e && (this.#t = void 0, e.hub.delete(this.#e, this), e.detach());
+	}
+}, he = class {
+	#e;
+	constructor(e, t, n) {
+		this.#e = {
+			hub: e,
+			owner: t,
+			remember: n
+		}, t.defer(() => {
+			this.#e = void 0;
+		}), Object.freeze(this);
+	}
+	on(e, t, n) {
+		let r = this.#t();
+		if (typeof t != "function") throw TypeError("Event listener must be a function");
+		let i = w(e, "event"), a = r.owner.resolveOwner(n?.lifetime);
+		return r.remember(i), r.hub.stage(i.id, t, a);
+	}
+	async emit(e, ...t) {
+		let n = this.#t();
+		if (!n.owner.published) throw new l("EVENT_BEFORE_COMMIT", "Candidate setup cannot emit into the committed event graph");
+		let r = w(e, "event");
+		this.#t(), n.remember(r), await n.hub.emit(r.id, t[0]);
+	}
+	#t() {
+		let e = this.#e;
+		if (!e || !e.owner.acceptsWork) throw new l("LIFETIME_DISPOSED", "Event scope is closed");
+		return e;
+	}
+}, ge = class {
+	#e = /* @__PURE__ */ new Map();
+	scope(e, t) {
+		return new he(this, e, t);
+	}
+	stage(e, t, n) {
+		return n.stage((r) => new me(this, e, t, n, r)).handle;
+	}
+	add(e, t) {
+		let n = this.#e.get(e) ?? /* @__PURE__ */ new Set();
+		n.add(t), this.#e.set(e, n);
+	}
+	delete(e, t) {
+		let n = this.#e.get(e);
+		n && (n.delete(t), n.size || this.#e.delete(e));
+	}
+	async emit(e, t) {
+		let n = [...this.#e.get(e) ?? []], r = (await Promise.allSettled(n.map((e) => {
+			try {
+				return e.invoke(t);
+			} catch (e) {
+				return Promise.reject(e);
+			}
+		}))).flatMap((e) => e.status === "rejected" ? [e.reason] : []);
+		if (r.length) throw AggregateError(r, `Event '${e}' listeners failed`);
+	}
+}, N = class {
+	#e;
+	get;
+	subscribe;
+	use;
+	constructor(e) {
+		this.#e = e, this.get = () => this.#t(), this.subscribe = (e) => this.#n(e), this.use = (e, t) => {
+			try {
+				return this.#r().store.use(e, t);
+			} catch (e) {
+				return Promise.reject(e);
+			}
+		}, Object.freeze(this);
+	}
+	#t() {
+		return this.#r().store.snapshot();
+	}
+	#n(e) {
+		let t = this.#r();
+		if (typeof e != "function") throw TypeError("Contribution subscriber must be a function");
+		return t.store.subscribe(() => {
+			if (!t.owner || t.owner.acceptsWork) return e();
+		}, t.own);
+	}
+	#r() {
+		let e = this.#e.binding;
+		if (!e) throw TypeError("Contribution view has been disposed");
+		if (e.owner && !e.owner.acceptsWork) throw new l("LIFETIME_DISPOSED", "Contribution view owner is closed");
+		return e;
+	}
+}, _e = class {
+	#e;
+	constructor(e) {
+		this.#e = e, Object.freeze(this);
+	}
+	update = (e) => this.#e.update(e);
+	[n]() {
+		this.#e[n]();
+	}
+}, ve = class {
+	#e;
+	#t;
+	handle;
+	constructor(e, t, n, r, i) {
+		this.#t = t, this.#e = {
+			phase: "active",
+			store: e,
+			value: n,
+			owner: r,
+			detachFromOwner: i
+		}, this.handle = new _e(this);
+	}
+	publish() {
+		let e = this.#e;
+		e.phase !== "disposed" && e.store.publishClaim(this.#t, this);
+	}
+	use(e) {
+		let t = this.#e;
+		if (t.phase === "disposed") throw new l("CONTRIBUTION_UNAVAILABLE", "Contribution is no longer available");
+		let { owner: n, value: r } = t;
+		return n.borrow(() => e(r));
+	}
+	update(e) {
+		let t = this.#e;
+		if (t.phase === "disposed") throw TypeError(`Contribution '${this.#t}' has been disposed`);
+		if (!t.owner.acceptsWork) throw new l("LIFETIME_DISPOSED", "Contribution owner is closed");
+		Object.is(t.value, e) || (t.value = e, t.store.valueChanged(this.#t, this));
+	}
+	[n]() {
+		let e = this.#e;
+		if (e.phase !== "disposed") {
+			this.#e = { phase: "disposed" };
+			try {
+				e.store.removeContribution(this.#t, this);
+			} finally {
+				e.detachFromOwner();
+			}
+		}
+	}
+}, ye = class {
+	#e;
+	#t;
+	#n = /* @__PURE__ */ new Map();
+	#r;
+	#i = Object.freeze([]);
+	#a = 0;
+	#o = 0;
+	#s;
+	#c = !1;
+	constructor(e, t, n) {
+		this.#e = e, this.#t = n, this.#r = new f(() => this.#i, t);
+	}
+	stage(e, t, n, r, i) {
+		try {
+			Se(t);
+			let a = Ce(e, t);
+			if (this.#n.has(a)) throw TypeError(`Duplicate contribution '${a}'`);
+			return r.stage((e) => {
+				i?.();
+				let t = new ve(this, a, n, r, e);
+				return this.#n.set(a, {
+					contribution: t,
+					phase: "staged"
+				}), t;
+			}).handle;
+		} catch (e) {
+			throw this.#u(), e;
+		}
+	}
+	view(e, t) {
+		this.#a++;
+		let n = { binding: {
+			store: this,
+			own: e,
+			...t && { owner: t }
+		} }, r, i = new P(n, () => {
+			let e = r;
+			r = void 0;
+			try {
+				e?.();
+			} finally {
+				this.#a--, this.#u();
+			}
+		});
+		try {
+			r = e(i);
+		} catch (e) {
+			throw n.binding = void 0, this.#a--, this.#u(), e;
+		}
+		return new N(n);
+	}
+	hostView() {
+		return this.#s ??= new N({ binding: { store: this } });
+	}
+	use(e, t) {
+		let n = this.#n.get(e);
+		if (n?.phase !== "published") throw new l("CONTRIBUTION_UNAVAILABLE", `Contribution '${e}' is not available`);
+		if (typeof t != "function") throw TypeError("Contribution callback must be a function");
+		return n.contribution.use(t);
+	}
+	snapshot() {
+		return this.#r.view.get();
+	}
+	subscribe(e, t) {
+		if (typeof e != "function") throw TypeError("Contribution subscriber must be a function");
+		let r = this.#r.view.subscribe(e);
+		if (!t) return r;
+		this.#o++;
+		let i, a = new be(r, () => {
+			let e = i;
+			i = void 0;
+			try {
+				e?.();
+			} finally {
+				this.#o--, this.#u();
+			}
+		});
+		try {
+			i = t(a);
+		} catch (e) {
+			throw a[n](), e;
+		}
+		return a;
+	}
+	publishClaim(e, t) {
+		let n = this.#l(e, t);
+		n.phase === "staged" && (n.phase = "pending", this.#n.delete(e), this.#n.set(e, n), this.#e(this));
+	}
+	valueChanged(e, t) {
+		let n = this.#l(e, t);
+		n.phase !== "staged" && (n.phase = "pending", this.#e(this));
+	}
+	removeContribution(e, t) {
+		let n = this.#l(e, t);
+		try {
+			this.#n.delete(e), n.phase !== "staged" && this.#e(this);
+		} finally {
+			this.#u();
+		}
+	}
+	publishSnapshot() {
+		let e = [], t = !1;
+		for (let [n, r] of this.#n) r.phase !== "staged" && ((r.phase === "pending" || this.#i[e.length] !== n) && (t = !0), e.push(n), r.phase = "published");
+		(t || e.length !== this.#i.length) && (this.#i = Object.freeze(e), this.#r.invalidate());
+	}
+	#l(e, t) {
+		let n = this.#n.get(e);
+		if (n?.contribution !== t) throw Error(`Contribution '${e}' is not the current claim`);
+		return n;
+	}
+	#u() {
+		if (!(this.#c || this.#s || this.#n.size || this.#o || this.#a)) {
+			this.#c = !0;
+			try {
+				this.#r[n]();
+			} finally {
+				this.#t(this);
+			}
+		}
+	}
+}, P = class {
+	#e;
+	constructor(e, t) {
+		this.#e = {
+			state: e,
+			release: t
+		}, Object.freeze(this);
+	}
+	[n]() {
+		let e = this.#e;
+		e && (this.#e = void 0, e.state.binding = void 0, e.release());
+	}
+}, be = class {
+	#e;
+	constructor(e, t) {
+		this.#e = {
+			subscription: e,
+			release: t
+		}, Object.freeze(this);
+	}
+	[n]() {
+		let e = this.#e;
+		if (e) {
+			this.#e = void 0;
+			try {
+				e.subscription[n]();
+			} finally {
+				e.release();
+			}
+		}
+	}
+}, xe = class {
+	#e = /* @__PURE__ */ new Map();
+	#t = /* @__PURE__ */ new Set();
+	#n;
+	#r = 0;
+	constructor(e) {
+		this.#n = e;
+	}
+	get(e) {
+		let t = e.id, n = this.#e.get(t);
+		if (n) return n;
+		let r = new ye((e) => this.#i(e), this.#n, (e) => {
+			this.#e.get(t) === e && (this.#t.delete(e), this.#e.delete(t));
+		});
+		return this.#e.set(t, r), r;
+	}
+	view(e, t) {
+		let n = this.get(e);
+		return t ? n.view((e) => t.own(e), t) : n.hostView();
+	}
+	scope(e, t, n) {
+		return new we(this, e, t, n);
+	}
+	beginBatch() {
+		this.#r++;
+	}
+	endBatch() {
+		if (!this.#r) throw Error("Contribution batch is not active");
+		if (this.#r--, this.#r) return;
+		let e = [...this.#t];
+		this.#t.clear(), h(() => {
+			let t = [];
+			for (let n of e) try {
+				n.publishSnapshot();
+			} catch (e) {
+				t.push(e);
+			}
+			if (t.length === 1) throw t[0];
+			if (t.length > 1) throw AggregateError(t, "Contribution batch publication failed");
+		});
+	}
+	#i(e) {
+		this.#t.add(e), !this.#r && (this.#t.delete(e), e.publishSnapshot());
+	}
+};
+function Se(e) {
+	if (typeof e != "string" || !e.trim()) throw TypeError("Contribution key must be a non-empty string");
+	if (e !== e.trim()) throw TypeError("Contribution key cannot start or end with whitespace");
+}
+function Ce(e, t) {
+	return `${F(e)}/${F(t)}`;
+}
+function F(e) {
+	return e.replaceAll("%", "%25").replaceAll("/", "%2F");
+}
+var we = class {
+	#e;
+	constructor(e, t, n, r) {
+		this.#e = {
+			registry: e,
+			owner: t,
+			installationId: n,
+			remember: r
+		}, t.defer(() => {
+			this.#e = void 0;
+		}), Object.freeze(this);
+	}
+	add(e, t, n, r) {
+		let i = this.#e;
+		if (!i || !i.owner.acceptsWork) throw new l("LIFETIME_DISPOSED", "Contribution scope is closed");
+		let a = w(e, "extensionPoint"), o = i.owner.resolveOwner(r?.lifetime);
+		return i.registry.get(a).stage(i.installationId, t, n, o, () => i.remember(a));
+	}
+}, Te = 64;
+function I(e) {
+	let t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Map(), r = (e, i) => {
+		if (e === null || typeof e == "string" || typeof e == "boolean" || typeof e == "number" && Number.isFinite(e)) return {
+			value: e,
+			height: 0
+		};
+		if (typeof e != "object" || !e) throw TypeError(`Unsupported configuration value at ${i}`);
+		if (t.has(e)) throw TypeError(`Circular configuration at ${i}`);
+		let a = n.get(e);
+		if (t.size + (a?.height ?? 1) > Te) throw TypeError("Configuration exceeds the supported nesting depth");
+		if (a) return a;
+		t.add(e);
+		let o = 1, s = (e, t) => {
+			let n = r(e, t);
+			return o = Math.max(o, n.height + 1), n.value;
+		}, c;
+		if (Array.isArray(e)) {
+			let t = u(e, `Configuration array at ${i}`);
+			c = Object.freeze(t.map((e, t) => s(e, `${i}[${t}]`)));
+		} else {
+			let t = Object.getPrototypeOf(e);
+			if (t !== Object.prototype && t !== null) throw TypeError(`Configuration must contain plain records at ${i}`);
+			let n = Object.create(null);
+			for (let t of Reflect.ownKeys(e)) {
+				if (typeof t != "string") throw TypeError(`Configuration keys must be strings at ${i}`);
+				let r = Object.getOwnPropertyDescriptor(e, t);
+				if (!r || !("value" in r) || !r.enumerable) throw TypeError(`Configuration must contain enumerable data properties at ${i}.${t}`);
+				r.value !== void 0 && (n[t] = s(r.value, `${i}.${t}`));
+			}
+			c = Object.freeze(n);
+		}
+		t.delete(e);
+		let l = {
+			value: c,
+			height: o
+		};
+		return n.set(e, l), l;
+	};
+	return e === void 0 ? void 0 : r(e, "configuration").value;
+}
+async function Ee(e, t, n, i) {
+	if (i?.throwIfAborted(), !e) return Object.freeze({ value: t });
+	let a = e["~standard"].validate(t), o = i ? (await De(a, i)).result : await a;
+	if (i?.throwIfAborted(), !o || typeof o != "object") throw TypeError(`Installation '${n}' configuration validator returned a non-object result`);
+	let s = Object.hasOwn(o, "issues") ? o.issues : void 0;
+	if (s !== void 0) throw Array.isArray(s) ? new r(s, { details: {
+		installation: n,
+		phase: "configuration",
+		outcome: "rejected"
+	} }) : TypeError(`Installation '${n}' configuration validator returned non-array issues`);
+	if (!Object.hasOwn(o, "value")) throw TypeError(`Installation '${n}' configuration validator returned neither value nor issues`);
+	let c = o.value;
+	return Object.freeze({ value: Object.is(c, t) ? t : I(c) });
+}
+function De(t, n) {
+	let r = Promise.withResolvers(), { promise: i } = r, a = e(n, (e) => {
+		r?.reject(e), r = void 0;
+	});
+	return Oe(t).then((e) => r?.resolve(e), (e) => r?.reject(e)), i.finally(() => {
+		r = void 0, a();
+	});
+}
+async function Oe(e) {
+	return { result: await e };
+}
+// src/composition/plugin.ts
+var ke = /* @__PURE__ */ new Set([
+	"name",
+	"configuration",
+	"requires",
+	"provides",
+	"setup"
+]);
+function Ae(e) {
+	return L(e);
+}
+function L(e) {
+	let t = g(e, "Plugin declaration", { fields: ke }), { name: n, configuration: r, setup: i } = t;
+	if (typeof n != "string" || !n.trim()) throw TypeError("Plugin name must be a non-empty string");
+	if (n !== n.trim()) throw TypeError("Plugin name cannot start or end with whitespace");
+	if (typeof i != "function") throw TypeError(`Plugin '${n}' must define setup()`);
+	let a = r === void 0 ? void 0 : je(r, n), o = t.requires === void 0 ? void 0 : g(t.requires, `Plugin '${n}' requires`), s = t.provides === void 0 ? void 0 : g(t.provides, `Plugin '${n}' provides`), c = new Ne(n), l = c.normalizeRequirements(o ?? {}), u = c.normalizeProvisions(s ?? {});
+	return Object.freeze({
+		name: n,
+		...a === void 0 ? {} : { configuration: a },
+		requires: l,
+		provides: u,
+		setup: i
+	});
+}
+var R = /* @__PURE__ */ new WeakSet();
+function je(e, t) {
+	let n = () => /* @__PURE__ */ TypeError("Plugin '" + t + "' configuration must implement Standard Schema V1");
+	if (!e || typeof e != "object" && typeof e != "function") throw n();
+	if (R.has(e)) return e;
+	let r = e["~standard"];
+	if (!r || typeof r != "object") throw n();
+	let { version: i, vendor: a, validate: o, jsonSchema: s } = r;
+	if (i !== 1 || typeof a != "string" || typeof o != "function") throw n();
+	let c = (...e) => Reflect.apply(o, r, e), l = s === void 0 ? void 0 : Me(s, t), u = Object.freeze({ "~standard": Object.freeze({
+		version: 1,
+		vendor: a,
+		validate: c,
+		...l === void 0 ? {} : { jsonSchema: l }
+	}) });
+	return R.add(u), u;
+}
+function Me(e, t) {
+	let n = () => /* @__PURE__ */ TypeError("Plugin '" + t + "' jsonSchema must implement Standard JSON Schema input/output exporters");
+	if (!e || typeof e != "object" && typeof e != "function") throw n();
+	let { input: r, output: i } = e;
+	if (typeof r != "function" || typeof i != "function") throw n();
+	return Object.freeze({
+		input: (t) => Reflect.apply(r, e, [t]),
+		output: (t) => Reflect.apply(i, e, [t])
+	});
+}
+var Ne = class {
+	pluginName;
+	#e = /* @__PURE__ */ new Map();
+	constructor(e) {
+		this.pluginName = e;
+	}
+	normalizeRequirements(e) {
+		let t = Object.create(null);
+		for (let [n, r] of Object.entries(e)) {
+			if (this.#t(n, "requirement"), !r || typeof r != "object") throw TypeError(`Plugin requirement '${n}' is not a contract`);
+			let e = T(g(r, `Plugin requirement '${n}'`), `Plugin requirement '${n}' must be a Service or ExtensionPoint`, `Optional requirement '${n}' must wrap a Service`);
+			this.#n("requirement", n, e.kind === "optional" ? e.service : e), t[n] = e;
+		}
+		return Object.freeze(t);
+	}
+	normalizeProvisions(e) {
+		let t = Object.create(null);
+		for (let [n, r] of Object.entries(e)) {
+			if (this.#t(n, "provision"), n === "then") throw TypeError("Plugin provision alias 'then' conflicts with the Promise protocol");
+			let e = w(r, "service", `Plugin provision '${n}' must be a Service`);
+			this.#n("provision", n, e), t[n] = e;
+		}
+		return Object.freeze(t);
+	}
+	#t(e, t) {
+		if (!e.trim()) throw TypeError(`Plugin ${t} alias cannot be empty`);
+		if (e !== e.trim()) throw TypeError(`Plugin ${t} alias cannot start or end with whitespace`);
+	}
+	#n(e, t, n) {
+		let r = this.#e.get(n.id);
+		if (!r) {
+			this.#e.set(n.id, {
+				alias: t,
+				kind: n.kind,
+				role: e
+			});
+			return;
+		}
+		if (r.kind !== n.kind) throw TypeError(`Plugin '${this.pluginName}' uses Contract '${n.id}' as both ${z(r.kind)} and ${z(n.kind)}`);
+		let i = z(n.kind);
+		throw r.role === e ? TypeError(`Plugin '${this.pluginName}' ${e} aliases '${r.alias}' and '${t}' reference the same ${i} '${n.id}'`) : TypeError(`Plugin '${this.pluginName}' cannot both require and provide ${i} '${n.id}'`);
+	}
+};
+function z(e) {
+	return e === "extensionPoint" ? "ExtensionPoint" : e === "event" ? "Event" : "Service";
+}
+function B(e) {
+	return L(e);
+}
+// src/composition/installation.ts
+function V(e, t) {
+	if (e.has(t)) throw new l("INSTALLATION_CONFLICT", "Installation id is already installed: " + t);
+	e.add(t);
+}
+function H(e, t, n) {
+	return Object.freeze({
+		plugin: B(e),
+		configuration: I(t),
+		origin: U(n)
+	});
+}
+function U(e) {
+	let t = I(e);
+	if (t !== void 0) {
+		if (t === null || Array.isArray(t) || typeof t != "object") throw TypeError("Installation origin must be a data record");
+		return t;
+	}
+}
+var W = class {
+	#e = {
+		status: "pending",
+		origin: void 0
+	};
+	attach(e) {
+		let t = this.#e;
+		e.attach(() => t);
+	}
+	retire() {
+		this.#e.status = "removed";
+	}
+}, Pe = class {
+	id;
+	index;
+	group;
+	facade;
+	#e;
+	#t = Object.freeze({
+		status: "pending",
+		origin: void 0
+	});
+	constructor(e, t, n) {
+		this.id = e, this.index = t, this.group = n;
+		let r = this;
+		this.facade = Object.freeze({
+			id: e,
+			groupId: n?.id,
+			get status() {
+				return r.#n().status;
+			},
+			get origin() {
+				return r.#n().origin;
+			}
+		});
+	}
+	get groupId() {
+		return this.group?.id;
+	}
+	attach(e) {
+		this.#e = e;
+	}
+	detach(e) {
+		this.#t = Object.freeze(e), this.#e = void 0;
+	}
+	#n() {
+		return this.#e?.() ?? this.#t;
+	}
+};
+// src/composition/change-set.ts
+function G(e, t) {
+	if (typeof e != "string" || !e.trim() || e.trim() !== e) throw TypeError(t + " must be a non-empty trimmed string");
+}
+var Fe = class {
+	#e = /* @__PURE__ */ new WeakMap();
+	#t = new W();
+	create(e) {
+		let t = new Ie(this);
+		return this.#n().set(t.handle, {
+			port: e,
+			operations: [],
+			targets: /* @__PURE__ */ new Set()
+		}), t.handle;
+	}
+	take(e) {
+		let t = this.#n(), n = t.get(e);
+		if (!n) throw new l("CHANGE_FOREIGN", "ChangeSet belongs to another Host or was already planned");
+		return t.delete(e), Object.freeze(n.operations);
+	}
+	requireOpen(e) {
+		let t = this.#n().get(e);
+		if (!t) throw TypeError("ChangeSet has already been planned");
+		return t;
+	}
+	track(e) {
+		this.#t.attach(e);
+	}
+	close(e) {
+		this.#e = e, this.#t.retire();
+	}
+	#n() {
+		if (typeof this.#e == "number") throw p(this.#e);
+		return this.#e;
+	}
+}, Ie = class {
+	authority;
+	handle = Object.freeze({
+		install: this.install.bind(this),
+		update: this.update.bind(this),
+		remove: this.remove.bind(this),
+		group: this.group.bind(this),
+		removeGroup: this.removeGroup.bind(this)
+	});
+	constructor(e) {
+		this.authority = e, Object.freeze(this);
+	}
+	install(e, t) {
+		let { port: n } = this.#t(), r = g(t, "Installation options", { fields: /* @__PURE__ */ new Set([
+			"id",
+			"configuration",
+			"origin",
+			"group"
+		]) });
+		G(r.id, "Installation id");
+		let i = r.group === void 0 ? void 0 : n.resolveGroup(r.group), a = H(e, r.configuration, r.origin);
+		this.#t();
+		let o = n.create(r.id, i);
+		return this.#e(o, {
+			kind: "install",
+			installation: o,
+			declaration: a
+		}), o.facade;
+	}
+	update(e, t) {
+		let { port: n } = this.#t(), r = g(t, "Installation update", { fields: /* @__PURE__ */ new Set([
+			"plugin",
+			"configuration",
+			"origin"
+		]) }), i = Object.hasOwn(r, "plugin"), a = Object.hasOwn(r, "configuration");
+		if (!i && !a) throw TypeError("Installation update requires plugin or configuration");
+		if (!i && Object.hasOwn(r, "origin")) throw TypeError("Origin can only change with its Plugin");
+		let o = {
+			...i ? {
+				plugin: B(r.plugin),
+				origin: U(r.origin)
+			} : {},
+			...a ? { configuration: I(r.configuration) } : {}
+		}, s = n.resolve(e);
+		this.#e(s, {
+			kind: "update",
+			installation: s,
+			update: Object.freeze(o)
+		});
+	}
+	remove(e) {
+		let t = this.#t().port.resolve(e);
+		this.#e(t, {
+			kind: "remove",
+			installation: t
+		});
+	}
+	group(e, t) {
+		let { port: n } = this.#t();
+		G(e, "Group id");
+		let r = n.createGroup(e, t === void 0 ? void 0 : n.resolveGroup(t));
+		return this.#e(r, {
+			kind: "group",
+			group: r
+		}), r.facade;
+	}
+	removeGroup(e) {
+		let t = this.#t().port.resolveGroup(e);
+		this.#e(t, {
+			kind: "remove-group",
+			group: t
+		});
+	}
+	#e(e, t) {
+		let { targets: n, operations: r } = this.#t();
+		if (n.has(e)) throw TypeError("A target can appear only once in a ChangeSet");
+		t.kind === "install" && this.authority.track(t.installation), n.add(e), r.push(Object.freeze(t));
+	}
+	#t() {
+		return this.authority.requireOpen(this.handle);
+	}
+}, K = class e {
+	declarations;
+	byId;
+	order;
+	layers;
+	providers;
+	dependents;
+	contractKinds;
+	constructor(e, t, n, r, i, a, o) {
+		this.declarations = e, this.byId = t, this.order = n, this.layers = r, this.providers = i, this.dependents = a, this.contractKinds = o;
+	}
+	static build(t) {
+		let n = [...t.keys()].sort((e, t) => e.index - t.index), r = /* @__PURE__ */ new Map(), i = Le(t, r), a = Re(t, i, r), { order: o, layers: s } = ze(n, a.dependents, a.indegree);
+		return new e(t, new Map(n.map((e) => [e.id, e])), Object.freeze(o), Object.freeze(s.map((e) => Object.freeze(e))), i, a.dependents, r);
+	}
+	declarationFor(e) {
+		let t = this.declarations.get(e);
+		if (!t) throw Error(`Installation '${e.id}' is not in this plan`);
+		return t;
+	}
+	affectedByTransitionTo(e, t) {
+		let n = /* @__PURE__ */ new Set();
+		return this.#e(t, n), e.#e(t, n), n;
+	}
+	#e(e, t) {
+		let n = [...e], r = /* @__PURE__ */ new Set();
+		for (let e = 0; e < n.length; e++) {
+			let i = n[e];
+			if (i && !r.has(i)) {
+				r.add(i), t.add(i);
+				for (let e of this.dependents.get(i) ?? []) n.push(e);
+			}
+		}
+	}
+};
+function Le(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let [r, i] of e) for (let e of Object.values(i.plugin.provides)) {
+		j(t, e);
+		let i = n.get(e.id);
+		if (i) throw new l("SERVICE_CONFLICT", `Service '${e.id}' is provided by both '${i.id}' and '${r.id}'`, { details: {
+			outcome: "rejected",
+			contract: e.id,
+			affectedInstallations: [i.id, r.id]
+		} });
+		n.set(e.id, r);
+	}
+	return n;
+}
+function Re(e, t, n) {
+	let r = /* @__PURE__ */ new Map(), i = new Map([...e.keys()].map((e) => [e, 0]));
+	for (let [a, o] of e) for (let e of Object.values(o.plugin.requires)) {
+		let o = e.kind === "optional" ? e.service : e;
+		if (j(n, o), o.kind === "extensionPoint") continue;
+		let s = t.get(o.id);
+		if (!s) {
+			if (e.kind === "optional") continue;
+			throw new l("SERVICE_MISSING", `Installation '${a.id}' requires missing Service '${o.id}'`, { details: {
+				outcome: "rejected",
+				installation: a.id,
+				contract: o.id
+			} });
+		}
+		if (s === a) throw new l("SERVICE_CYCLE", `Installation '${a.id}' cannot require Service '${o.id}' that it provides`, { details: {
+			outcome: "rejected",
+			installation: a.id,
+			contract: o.id,
+			dependencyPath: [a.id, a.id]
+		} });
+		let c = r.get(s) ?? /* @__PURE__ */ new Set();
+		c.has(a) || (c.add(a), r.set(s, c), i.set(a, (i.get(a) ?? 0) + 1));
+	}
+	return {
+		dependents: r,
+		indegree: i
+	};
+}
+function ze(e, t, n) {
+	let r = e.filter((e) => n.get(e) === 0), i = [], a = [];
+	for (; r.length;) {
+		r.sort((e, t) => e.index - t.index);
+		let e = r;
+		r = [], a.push(e);
+		for (let a of e) {
+			i.push(a);
+			for (let e of t.get(a) ?? []) {
+				let t = (n.get(e) ?? 0) - 1;
+				n.set(e, t), t || r.push(e);
+			}
+		}
+	}
+	if (i.length !== e.length) {
+		let e = Be(t, n);
+		throw new l("SERVICE_CYCLE", `Installation dependency cycle: ${e.map((e) => e.id).join(" -> ")}`, { details: {
+			outcome: "rejected",
+			dependencyPath: e.map((e) => e.id)
+		} });
+	}
+	return {
+		order: i,
+		layers: a
+	};
+}
+function Be(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let [r, i] of e) if (t.get(r)) for (let e of i) n.set(e, r);
+	let r = n.keys().next().value, i = /* @__PURE__ */ new Map();
+	for (; !i.has(r);) i.set(r, i.size), r = n.get(r);
+	return [...Array.from(i.keys()).slice(i.get(r)), r].reverse();
+}
+// src/composition/group.ts
+var Ve = class {
+	id;
+	parent;
+	facade;
+	constructor(e, t) {
+		this.id = e, this.parent = t, this.facade = Object.freeze({
+			id: e,
+			parentId: t?.id
+		}), Object.freeze(this);
+	}
+	get parentId() {
+		return this.parent?.id;
+	}
+};
+function He(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let r of e.keys()) {
+		let i = /* @__PURE__ */ new Set(), a = r;
+		for (; a !== void 0 && !n.has(a);) {
+			if (!e.has(a)) throw new l("GROUP_MISSING", "Initial Group is missing: " + a);
+			if (i.has(a)) throw new l("GROUP_CYCLE", "Group ownership must be acyclic");
+			i.add(a), a = e.get(a);
+		}
+		let o = a === void 0 ? void 0 : n.get(a);
+		for (let e of [...i].reverse()) o = t(e, o), n.set(e, o);
+	}
+	return n;
+}
+// src/composition/plan.ts
+function q(e, t) {
+	return new l("PLAN_STALE", "Host state changed during or after planning", { details: {
+		outcome: "rejected",
+		expectedRevision: e,
+		stateRevision: t
+	} });
+}
+var Ue = class {
+	#e = /* @__PURE__ */ new WeakMap();
+	#t = /* @__PURE__ */ new WeakMap();
+	#n = new W();
+	#r;
+	get validationSignal() {
+		return (this.#r ??= new AbortController()).signal;
+	}
+	issue(e, t) {
+		let { report: n } = e;
+		if (n.baseStateRevision !== t.revision) throw q(n.baseStateRevision, t.revision);
+		let r = Object.freeze({ report: n });
+		for (let n of e.graph.declarations.keys()) t.graph.declarations.has(n) || this.#n.attach(n);
+		return this.#e.set(r, "issued"), this.#t.set(r, e), r;
+	}
+	read(e, t) {
+		let n = this.#e.get(e);
+		if (n === void 0) throw new l("PLAN_FOREIGN", "Plan was not issued by this Host");
+		if (n === "consumed") throw new l("PLAN_CONSUMED", "Plan has already been executed");
+		let r = this.#t.get(e);
+		if (!r) throw this.consume(e), q(e.report.baseStateRevision, t);
+		return r;
+	}
+	consume(e) {
+		this.#e.set(e, "consumed"), this.#t.delete(e);
+	}
+	invalidate(e, t) {
+		this.#r?.abort(t ? p(e) : q(e - 1, e)), this.#r = void 0, this.#n.retire(), this.#n = new W(), this.#t = /* @__PURE__ */ new WeakMap();
+	}
+};
+function J(e, t = e.order) {
+	return Object.freeze(t.flatMap((t) => Object.values(e.declarationFor(t).plugin.requires).flatMap((n) => {
+		if (n.kind === "extensionPoint") return [];
+		let r = n.kind === "optional" ? n.service : n;
+		return [Object.freeze({
+			installation: t.id,
+			contract: r.id,
+			optional: n.kind === "optional",
+			provider: e.providers.get(r.id)?.id
+		})];
+	})));
+}
+function We(e, t, n, r) {
+	let i = [];
+	for (let a of n) {
+		let o = r.get(a);
+		if (o) i.push(Object.freeze({
+			installation: a.id,
+			kind: o
+		}));
+		else for (let r of Object.values(t.declarationFor(a).plugin.requires)) {
+			if (r.kind === "extensionPoint") continue;
+			let o = (r.kind === "optional" ? r.service : r).id, s = e.providers.get(o), c = t.providers.get(o);
+			(s && n.has(s) || c && n.has(c)) && i.push(Object.freeze({
+				installation: a.id,
+				kind: "provider_changed",
+				contract: o,
+				...s === void 0 ? {} : { previousProvider: s.id },
+				...c === void 0 ? {} : { provider: c.id }
+			}));
+		}
+	}
+	return Object.freeze(i);
+}
+function Y(e) {
+	return e && Object.freeze({
+		pluginName: e.plugin.name,
+		origin: e.origin
+	});
+}
+// src/composition/planner.ts
+async function X(e, t, n, r, i) {
+	let a = new Map(e.graph.declarations), o = new Map(e.groups), s = new Set(e.graph.byId.keys()), c = /* @__PURE__ */ new Map();
+	for (let e of t) {
+		if (e.kind === "group") {
+			if (o.has(e.group.id)) throw new l("GROUP_CONFLICT", "Group id is already installed: " + e.group.id);
+			o.set(e.group.id, e.group);
+			continue;
+		}
+		if (e.kind === "remove-group") continue;
+		let t = e.installation;
+		if (e.kind === "install") V(s, t.id), a.set(t, e.declaration), c.set(t, "installed");
+		else {
+			let n = a.get(t);
+			if (!n) throw new l("INSTALLATION_REMOVED", "Installation is not committed: " + t.id);
+			if (e.kind === "remove") a.delete(t), c.set(t, "removed");
+			else {
+				let r = e.update, i = Object.hasOwn(r, "plugin");
+				a.set(t, Object.freeze({
+					plugin: r.plugin ?? n.plugin,
+					configuration: Object.hasOwn(r, "configuration") ? r.configuration : n.configuration,
+					origin: i ? r.origin : n.origin
+				})), c.set(t, "updated");
+			}
+		}
+	}
+	for (let n of t) {
+		if (n.kind !== "remove-group") continue;
+		if (e.groups.get(n.group.id) !== n.group) throw new l("GROUP_REMOVED", "Group is not committed: " + n.group.id);
+		let t = /* @__PURE__ */ new Set([n.group.id]), r = !0;
+		for (; r;) {
+			r = !1;
+			for (let e of o.values()) e.parentId && t.has(e.parentId) && !t.has(e.id) && (t.add(e.id), r = !0);
+		}
+		for (let [e] of a) if (e.groupId !== void 0 && t.has(e.groupId)) {
+			if (c.has(e)) throw new l("CHANGE_CONFLICT", "Installation change conflicts with Group removal: " + e.id);
+			a.delete(e), c.set(e, "removed");
+		}
+		for (let n of t) {
+			if (!e.groups.has(n)) throw new l("CHANGE_CONFLICT", "Group creation conflicts with ancestor removal: " + n);
+			o.delete(n);
+		}
+	}
+	Ge(o, a);
+	let u = K.build(a);
+	r.assertKinds(u.contractKinds);
+	let d = n === "change" ? e.graph.affectedByTransitionTo(u, [...c.keys()]) : new Set(u.order), f = /* @__PURE__ */ new Map();
+	for (let [t, r] of a) {
+		let a = e.graph.declarations.get(t) === r ? e.configurations.get(t) : void 0;
+		a ? f.set(t, a) : (n === "start" || c.has(t)) && f.set(t, await Ee(r.plugin.configuration, r.configuration, t.id, i));
+	}
+	if (n !== "change") for (let e of d) c.set(e, n);
+	let p = Object.freeze(n === "stop" || n === "change" && e.phase === "stopped" ? [] : u.order.filter((e) => d.has(e)).map((e) => e.id)), m = Object.freeze({
+		baseStateRevision: e.revision,
+		intent: n,
+		operations: Object.freeze(t.map((t) => "installation" in t ? Object.freeze({
+			kind: t.kind,
+			id: t.installation.id,
+			before: Y(e.graph.declarations.get(t.installation)),
+			after: Y(a.get(t.installation))
+		}) : Object.freeze({
+			kind: t.kind,
+			id: t.group.id,
+			parentId: t.group.parentId
+		}))),
+		bindings: Object.freeze({
+			before: J(e.graph),
+			after: J(u)
+		}),
+		affectedInstallations: Object.freeze([...d].map((e) => e.id)),
+		reasons: We(e.graph, u, d, c),
+		stopOrder: Object.freeze(e.phase === "running" ? e.graph.order.filter((e) => d.has(e)).reverse().map((e) => e.id) : []),
+		prepareOrder: p,
+		publishOrder: p,
+		execution: Object.freeze({
+			atomicPublication: !0,
+			externalEffectsRollback: !1
+		})
+	});
+	return Object.freeze({
+		groups: o,
+		graph: u,
+		affected: d,
+		configurations: f,
+		report: m
+	});
+}
+function Ge(e, t) {
+	for (let t of e.values()) {
+		let n = t.parent;
+		if (n && e.get(n.id) !== n) throw new l("GROUP_MISSING", "Group parent is not committed: " + n.id);
+	}
+	for (let n of t.keys()) if (n.group && e.get(n.group.id) !== n.group) throw new l("GROUP_MISSING", "Installation Group is not committed: " + n.group.id);
+}
+// src/execution/instance.ts
+var Ke = class {
+	installation;
+	declaration;
+	generation;
+	environment;
+	lifetime;
+	#e = /* @__PURE__ */ new Map();
+	constructor(e, t, n, r) {
+		this.installation = e, this.declaration = t, this.generation = n, this.environment = r, this.lifetime = new ue({
+			label: e.id + "@" + n,
+			report: r.report,
+			changed: r.changed,
+			parentSignal: r.startupSignal,
+			...r.shutdownTimeoutMilliseconds === void 0 ? {} : { shutdownTimeoutMilliseconds: r.shutdownTimeoutMilliseconds }
+		});
+	}
+	async prepare(e, t) {
+		let n = this.environment, r = Object.freeze({
+			hostName: n.hostName,
+			installationId: this.installation.id,
+			pluginName: this.declaration.plugin.name,
+			generation: this.generation,
+			groupId: this.installation.groupId
+		}), i = Object.freeze({
+			dependencies: e,
+			lifetime: this.lifetime.handle,
+			events: n.events.scope(this.lifetime, (e) => n.contracts.remember(e)),
+			contributions: n.contributions.scope(this.lifetime, this.installation.id, (e) => n.contracts.remember(e)),
+			metadata: r,
+			logger: this.lifetime.use(new m(n.logger, r)).handle
+		}), { setup: a } = this.declaration.plugin, o = await this.lifetime.prepare(() => a(i, t));
+		AbortSignal.prototype.throwIfAborted.call(this.lifetime.signal);
+		let s = Object.entries(this.declaration.plugin.provides);
+		if (!s.length) {
+			if (o !== void 0) throw new l("PROVIDES_INVALID", "Plugin without provisions must return undefined");
+			return;
+		}
+		let c = g(o, "Provided Services", { fields: new Set(s.map(([e]) => e)) });
+		AbortSignal.prototype.throwIfAborted.call(this.lifetime.signal);
+		for (let [e, t] of s) {
+			if (!Object.hasOwn(c, e)) throw new l("PROVIDES_INVALID", "Plugin did not provide " + e);
+			this.#e.set(t.id, c[e]);
+		}
+	}
+	read(e) {
+		if (!this.#e.has(e)) throw new l("SERVICE_UNAVAILABLE", "Service has not been prepared: " + e);
+		return this.#e.get(e);
+	}
+	use(e, t) {
+		return this.lifetime.borrow(() => t(this.read(e)));
+	}
+	publish() {
+		this.lifetime.detachStartupSignal(), this.lifetime.publish();
+	}
+	async dispose() {
+		try {
+			await this.lifetime.dispose();
+		} finally {
+			this.lifetime.phase === "disposed" && this.#e.clear();
+		}
+	}
+}, Z = class {
+	#e = [];
+	#t;
+	constructor(e) {
+		this.#t = e;
+	}
+	add(e) {
+		this.#e ? this.#e.push(e) : this.#t(e);
+	}
+	seal(e) {
+		let t = this.#e;
+		return this.#e = void 0, t?.length ? t.length === 1 ? t[0] : AggregateError(t, "Plugin preparation failed") : e;
+	}
+}, qe = class {
+	name;
+	#e;
+	#t;
+	#n;
+	#r = new fe();
+	#i = new ge();
+	#a;
+	#o = new d();
+	#s = new Ue();
+	#c = new Fe();
+	#l = /* @__PURE__ */ new WeakMap();
+	#u = /* @__PURE__ */ new WeakMap();
+	#d;
+	#f;
+	#p;
+	#m = 0;
+	#h = 0;
+	constructor(e = {}) {
+		let t = g(e, "Host options", { fields: /* @__PURE__ */ new Set([
+			"name",
+			"installations",
+			"groups",
+			"logger",
+			"onError",
+			"shutdownTimeoutMilliseconds"
+		]) }), n = t.name === void 0 ? "host" : t.name;
+		if (G(n, "Host name"), this.name = n, t.onError !== void 0 && typeof t.onError != "function") throw TypeError("Host onError must be a function");
+		this.#e = c(t.logger === void 0 ? console : t.logger), this.#t = t.onError ?? ((e) => this.#e.error(e)), this.#n = A(t.shutdownTimeoutMilliseconds), this.#a = new xe((e) => this.#L(e));
+		let r = /* @__PURE__ */ new Map(), i = u(t.groups === void 0 ? [] : t.groups, "Initial Groups"), a = u(t.installations === void 0 ? [] : t.installations, "Initial Installations"), o = /* @__PURE__ */ new Map();
+		for (let e of i) {
+			let t = g(e, "Initial Group", { fields: /* @__PURE__ */ new Set(["id", "parentId"]) });
+			if (G(t.id, "Group id"), t.parentId !== void 0 && G(t.parentId, "Parent Group id"), o.has(t.id)) throw new l("GROUP_CONFLICT", "Duplicate initial Group: " + t.id);
+			o.set(t.id, t.parentId);
+		}
+		let s = He(o, (e, t) => this.#j(e, t)), d = /* @__PURE__ */ new Set();
+		for (let e of a) {
+			let t = g(e, "Initial Installation", { fields: /* @__PURE__ */ new Set([
+				"id",
+				"plugin",
+				"configuration",
+				"origin",
+				"groupId"
+			]) });
+			G(t.id, "Installation id"), t.groupId !== void 0 && G(t.groupId, "Installation Group id"), V(d, t.id);
+			let n = t.groupId === void 0 ? void 0 : s.get(t.groupId);
+			if (t.groupId !== void 0 && !n) throw new l("GROUP_MISSING", "Initial Group is missing: " + t.groupId);
+			let i = this.#O(t.id, n);
+			r.set(i, H(t.plugin, t.configuration, t.origin));
+		}
+		this.#f = Object.freeze({
+			revision: 0,
+			groups: s,
+			graph: K.build(r),
+			configurations: /* @__PURE__ */ new Map(),
+			phase: "stopped",
+			instances: /* @__PURE__ */ new Map(),
+			unresolved: Object.freeze([]),
+			error: void 0
+		}), this.#d = new f(() => this.#F(), (e) => this.#L(e)), this.#r.commit(this.#f.graph.contractKinds);
+		for (let e of r.keys()) this.#k(e);
+		Object.freeze(this);
+	}
+	get status() {
+		return this.#p?.phase ?? this.#f.phase;
+	}
+	get stateRevision() {
+		return this.#f.revision;
+	}
+	get diagnostics() {
+		return this.#d.view;
+	}
+	installation(e) {
+		return this.#f.graph.byId.get(e)?.facade;
+	}
+	group(e) {
+		return this.#f.groups.get(e)?.facade;
+	}
+	explain(e) {
+		let { graph: t } = this.#f, n = t.byId.get(e);
+		return J(t, n ? [n] : []);
+	}
+	change() {
+		return this.#E(), this.#c.create({
+			create: (e, t) => this.#O(e, t),
+			resolve: (e) => this.#M(e),
+			createGroup: (e, t) => this.#j(e, t),
+			resolveGroup: (e) => {
+				let t = this.#u.get(e);
+				if (!t) throw new l("GROUP_FOREIGN", "Group belongs to another Host");
+				return t;
+			}
+		});
+	}
+	async plan(t, n) {
+		this.#E();
+		let r = this.#c.take(t), i = this.#s.validationSignal, a, o;
+		try {
+			if (n !== void 0) {
+				let t = new AbortController(), r = (e) => t.abort(e);
+				o = e(i, r), a = e(n, r), i = t.signal, i.throwIfAborted();
+			}
+			let t = await X(this.#f, r, "change", this.#r, i);
+			return i.throwIfAborted(), this.#r.assertKinds(t.graph.contractKinds), this.#s.issue(t, this.#f);
+		} catch (e) {
+			throw this.#N(r), e;
+		} finally {
+			o?.(), a?.();
+		}
+	}
+	apply(e) {
+		return this.#p ? Promise.reject(this.#D()) : this.#o.run(() => this.#_(e));
+	}
+	start() {
+		return this.#g("start");
+	}
+	stop() {
+		return this.#g("stop");
+	}
+	use(e, t) {
+		try {
+			if (typeof t != "function") throw TypeError("Service callback must be a function");
+			let n = T(e);
+			if (n.kind === "extensionPoint") throw TypeError("Expected a Service");
+			let r = n.kind === "optional" ? n.service : n;
+			if (this.#r.assertCompatible(r), this.#E(), this.#f.phase !== "running") throw new l("SERVICE_UNAVAILABLE", "Host is not running");
+			let i = this.#f.graph.providers.get(r.id);
+			if (!i) {
+				if (n.kind === "optional") return Promise.resolve(t(void 0));
+				throw new l("SERVICE_UNAVAILABLE", "No provider for " + r.id);
+			}
+			if (this.#p?.affected.has(i)) throw new l("SERVICE_UNAVAILABLE", "Service is changing: " + r.id);
+			let a = this.#f.instances.get(i);
+			if (!a) throw new l("SERVICE_UNAVAILABLE", "Service is not running: " + r.id);
+			return a.use(r.id, t);
+		} catch (e) {
+			return Promise.reject(e);
+		}
+	}
+	contributions(e) {
+		let t = w(e, "extensionPoint");
+		return this.#r.remember(t), this.#a.view(t);
+	}
+	#g(e) {
+		return this.#p ? Promise.reject(this.#D()) : this.#o.run(async () => {
+			if (this.#E(), e === "start" && this.#f.phase === "running" || e === "stop" && this.#f.phase === "stopped") return this.#T([]);
+			e === "start" && (this.#p = {
+				phase: "starting",
+				affected: new Set(this.#f.graph.declarations.keys())
+			}, this.#I());
+			try {
+				let t = await X(this.#f, [], e, this.#r);
+				return await this.#_(this.#s.issue(t, this.#f));
+			} finally {
+				this.#p && (this.#p = void 0, this.#I());
+			}
+		});
+	}
+	async #_(e) {
+		this.#E();
+		let t = this.#s.read(e, this.#f.revision);
+		if (t.report.intent === "change" && t.report.operations.length === 0) return this.#s.consume(e), this.#T([]);
+		let n = this.#f, r = n.graph.order.filter((e) => t.affected.has(e)).flatMap((e) => n.instances.get(e) ?? []);
+		for (let e of r) if (e.lifetime.busy) throw new l("HOST_BUSY", "Affected work is still in flight", { details: {
+			outcome: "rejected",
+			installation: e.installation.id,
+			stateRevision: n.revision
+		} });
+		this.#s.consume(e);
+		let i;
+		try {
+			i = this.#r.writer(t.graph.contractKinds);
+		} catch (e) {
+			throw this.#A(t.graph.declarations.keys()), e;
+		}
+		for (let e of r) e.lifetime.seal();
+		this.#p = {
+			phase: t.report.intent === "start" ? "starting" : t.report.intent === "stop" ? "stopping" : "changing",
+			affected: t.affected
+		}, this.#a.beginBatch(), this.#I();
+		try {
+			if (n.phase === "stopped" && t.report.intent !== "start") return i.commit(), this.#b(t, /* @__PURE__ */ new Map(), "stopped"), this.#T(t.report.affectedInstallations);
+			let e = await this.#C([n], new Set(r));
+			if (e.length || r.some((e) => e.lifetime.phase !== "disposed")) throw i.discard(), await this.#S(n, [], e, t, "stop");
+			if (t.report.intent === "stop") return i.commit(), this.#b(t, /* @__PURE__ */ new Map(), "stopped"), this.#T(t.report.affectedInstallations);
+			let a = new Map(n.instances);
+			for (let e of t.affected) a.delete(e);
+			let o = /* @__PURE__ */ new Map(), s = new Z((e) => this.#L(e));
+			try {
+				await this.#v(t, a, o, i, s);
+				for (let e of o.values()) AbortSignal.prototype.throwIfAborted.call(e.lifetime.signal);
+				i.commit(), s.seal();
+			} catch (e) {
+				i.discard();
+				let r = {
+					graph: t.graph,
+					instances: new Map([...a, ...o])
+				}, c = await this.#C([r], new Set(o.values())), l = s.seal(e);
+				throw c.length || [...o.values()].some((e) => e.lifetime.phase !== "disposed") ? await this.#S(n, [r], [l, ...c], t, "prepare") : n.phase === "stopped" ? (this.#x({
+					...n,
+					error: new _(l).snapshot
+				}), this.#w("TRANSITION_FAILED", "Startup failed", l, "restored", t, "prepare")) : (await this.#y(n, a, t, l), this.#w("TRANSITION_FAILED", "Change failed; previous declarations were restored", l, "restored", t, "prepare"));
+			}
+			for (let [e, t] of o) a.set(e, t);
+			try {
+				this.#b(t, a, "running", o);
+			} catch (e) {
+				throw i.discard(), await this.#S(this.#f, [{
+					graph: t.graph,
+					instances: new Map(a)
+				}], [e], t, "publish");
+			}
+			return this.#T(t.report.affectedInstallations);
+		} finally {
+			this.#p = void 0, this.#A(t.graph.declarations.keys()), h(() => {
+				this.#a.endBatch(), this.#I();
+			});
+		}
+	}
+	async #v(e, t, n, r, i) {
+		let a = new AbortController(), o = ++this.#h;
+		for (let s of e.graph.layers) {
+			let c = s.filter((t) => e.affected.has(t)).map((t) => {
+				let i = new Ke(t, e.graph.declarationFor(t), o, {
+					hostName: this.name,
+					logger: this.#e,
+					report: (e) => this.#L(e),
+					changed: () => {
+						(this.#f.instances.get(t) === i || this.#f.unresolved.includes(i)) && this.#I();
+					},
+					events: this.#i,
+					contributions: this.#a,
+					contracts: r,
+					startupSignal: a.signal,
+					shutdownTimeoutMilliseconds: this.#n
+				});
+				return n.set(t, i), i;
+			});
+			try {
+				await Promise.all(c.map(async (r) => {
+					let o = Object.create(null);
+					for (let [i, a] of Object.entries(r.declaration.plugin.requires)) {
+						if (a.kind === "extensionPoint") {
+							o[i] = this.#a.view(a, r.lifetime);
+							continue;
+						}
+						let s = a.kind === "optional" ? a.service : a, c = e.graph.providers.get(s.id);
+						o[i] = c ? (n.get(c) ?? t.get(c))?.read(s.id) : void 0;
+					}
+					try {
+						await r.prepare(Object.freeze(o), e.configurations.get(r.installation)?.value);
+					} catch (e) {
+						throw a.signal.aborted && Object.is(e, a.signal.reason) || i.add(e), a.abort(e), e;
+					}
+				}));
+			} catch (e) {
+				throw a.abort(e), e;
+			}
+		}
+	}
+	async #y(e, t, n, r) {
+		let i = /* @__PURE__ */ new Map(), a = new Z((e) => this.#L(e)), o = this.#r.writer(e.graph.contractKinds);
+		try {
+			await this.#v({
+				graph: e.graph,
+				affected: n.affected,
+				configurations: e.configurations
+			}, t, i, o, a);
+			for (let e of i.values()) AbortSignal.prototype.throwIfAborted.call(e.lifetime.signal);
+			a.seal();
+			for (let [e, n] of i) t.set(e, n);
+			o.commit(), this.#x({
+				...e,
+				instances: t,
+				error: new _(r).snapshot
+			});
+			for (let e of i.values()) e.publish();
+		} catch (s) {
+			o.discard();
+			let c = {
+				graph: e.graph,
+				instances: new Map([...t, ...i])
+			}, l = await this.#C([c], new Set(i.values()));
+			throw await this.#S(e, [c], [
+				r,
+				a.seal(s),
+				...l
+			], n, "restore");
+		}
+	}
+	#b(e, t, n, r = /* @__PURE__ */ new Map()) {
+		let i = this.#f;
+		this.#x({
+			groups: e.groups,
+			graph: e.graph,
+			configurations: e.configurations,
+			phase: n,
+			instances: t,
+			unresolved: Object.freeze([]),
+			error: void 0
+		});
+		for (let t of e.graph.declarations.keys()) i.graph.declarations.has(t) || this.#k(t);
+		for (let t of i.graph.declarations.keys()) e.graph.declarations.has(t) || t.detach({
+			status: "removed",
+			origin: void 0
+		});
+		for (let e of r.values()) e.publish();
+	}
+	#x(e) {
+		this.#f = Object.freeze({
+			...e,
+			revision: this.#f.revision + 1
+		});
+		let t = e.phase === "quarantined";
+		if (this.#s.invalidate(this.#f.revision, t), t) {
+			this.#c.close(this.#f.revision);
+			for (let [t, n] of e.graph.declarations) t.detach({
+				status: "quarantined",
+				origin: n.origin
+			});
+		}
+	}
+	async #S(e, t, n, r, i) {
+		let a = [e, ...t], o = [...new Set(a.flatMap((e) => [...e.instances.values()]))].filter((e) => e.lifetime.phase !== "disposed");
+		for (let e of o) e.lifetime.block();
+		this.#p &&= {
+			...this.#p,
+			affected: /* @__PURE__ */ new Set([...this.#p.affected, ...o.map((e) => e.installation)])
+		};
+		let s = await this.#C(a, new Set(o)), c = o.filter((e) => e.lifetime.phase !== "disposed"), l = AggregateError([...n, ...s], "Execution could not establish a healthy state");
+		return this.#x({
+			...e,
+			phase: "quarantined",
+			instances: /* @__PURE__ */ new Map(),
+			unresolved: Object.freeze(c),
+			error: new _(l).snapshot
+		}), this.#w("HOST_QUARANTINED", "Host is quarantined after execution could not establish a healthy state", l, "quarantined", r, i);
+	}
+	async #C(e, t) {
+		let n = /* @__PURE__ */ new Map();
+		for (let { graph: t, instances: r } of e) for (let [e, i] of t.dependents) {
+			let t = r.get(e);
+			if (!t) continue;
+			let a = n.get(t) ?? /* @__PURE__ */ new Set();
+			for (let e of i) {
+				let t = r.get(e);
+				t && a.add(t);
+			}
+			n.set(t, a);
+		}
+		let r = /* @__PURE__ */ new Map();
+		for (let e of [...t].reverse()) r.set(e, Promise.resolve().then(async () => {
+			let t = [...n.get(e) ?? []];
+			await Promise.allSettled(t.map((e) => r.get(e))), !(t.some((e) => e.lifetime.phase !== "disposed") || e.lifetime.busy || e.lifetime.phase === "disposed" || e.lifetime.phase === "quarantined") && await e.dispose();
+		}));
+		return (await Promise.allSettled(r.values())).flatMap((e) => e.status === "rejected" ? [e.reason] : []);
+	}
+	#w(e, t, n, r, i, a) {
+		return new l(e, t, {
+			cause: n,
+			details: {
+				outcome: r,
+				phase: a,
+				stateRevision: this.#f.revision,
+				affectedInstallations: i.report.affectedInstallations
+			}
+		});
+	}
+	#T(e) {
+		return Object.freeze({
+			stateRevision: this.#f.revision,
+			affectedInstallations: Object.freeze([...e])
+		});
+	}
+	#E() {
+		if (this.#f.phase === "quarantined") throw p(this.#f.revision);
+	}
+	#D() {
+		return new l("HOST_BUSY", "Another Host transition is in progress", { details: {
+			outcome: "rejected",
+			stateRevision: this.#f.revision
+		} });
+	}
+	#O(e, t) {
+		let n = new Pe(e, ++this.#m, t);
+		return this.#l.set(n.facade, n), n;
+	}
+	#k(e) {
+		e.attach(() => ({
+			status: this.#P(e),
+			origin: this.#f.graph.declarations.get(e)?.origin
+		}));
+	}
+	#A(e) {
+		for (let t of e) this.#f.graph.declarations.has(t) || t.detach({
+			status: "removed",
+			origin: void 0
+		});
+	}
+	#j(e, t) {
+		let n = new Ve(e, t);
+		return this.#u.set(n.facade, n), n;
+	}
+	#M(e) {
+		let t = this.#l.get(e);
+		if (!t) throw new l("INSTALLATION_FOREIGN", "Installation belongs to another Host");
+		return t;
+	}
+	#N(e) {
+		this.#A(e.flatMap((e) => e.kind === "install" ? [e.installation] : []));
+	}
+	#P(e) {
+		return this.#f.graph.declarations.has(e) ? this.#f.phase === "quarantined" ? "quarantined" : this.#p?.affected.has(e) ? "changing" : this.#f.instances.has(e) ? "running" : "stopped" : "pending";
+	}
+	#F() {
+		let e = [...this.#f.graph.declarations].map(([e, t]) => {
+			let n = this.#f.instances.get(e);
+			return Object.freeze({
+				id: e.id,
+				groupId: e.groupId,
+				pluginName: t.plugin.name,
+				status: this.#P(e),
+				origin: t.origin,
+				generation: n?.generation,
+				requires: Object.freeze(Object.values(t.plugin.requires).map((e) => e.kind === "optional" ? e.service.id : e.id)),
+				provides: Object.freeze(Object.values(t.plugin.provides).map((e) => e.id)),
+				lifetime: n?.lifetime.snapshot()
+			});
+		}), t = Map.groupBy(e, (e) => e.groupId);
+		return Object.freeze({
+			name: this.name,
+			status: this.status,
+			stateRevision: this.#f.revision,
+			installations: Object.freeze(e),
+			groups: Object.freeze([...this.#f.groups.values()].map((e) => Object.freeze({
+				id: e.id,
+				parentId: e.parentId,
+				installations: Object.freeze((t.get(e.id) ?? []).map((e) => e.id))
+			}))),
+			bindings: J(this.#f.graph),
+			unresolved: Object.freeze(this.#f.unresolved.map((e) => Object.freeze({
+				installation: e.installation.id,
+				generation: e.generation,
+				lifetime: e.lifetime.snapshot()
+			}))),
+			error: this.#f.error
+		});
+	}
+	#I() {
+		this.#f.unresolved.some((e) => e.lifetime.phase === "disposed") && (this.#f = Object.freeze({
+			...this.#f,
+			unresolved: Object.freeze(this.#f.unresolved.filter((e) => e.lifetime.phase !== "disposed"))
+		}));
+		try {
+			this.#d.invalidate();
+		} catch (e) {
+			this.#L(e);
+		}
+	}
+	#L(e) {
+		let t = this.#e, n = (n) => {
+			try {
+				Promise.resolve(t.error(AggregateError([e, n], "Host error reporter failed"))).catch(() => void 0);
+			} catch {}
+		};
+		try {
+			let t = this.#t;
+			Promise.resolve(t(e)).catch(n);
+		} catch (e) {
+			n(e);
+		}
+	}
+};
+// src/execution/host.ts
+function Je(e) {
+	let t = new qe(e);
+	return Object.freeze({
+		get name() {
+			return t.name;
+		},
+		get status() {
+			return t.status;
+		},
+		get stateRevision() {
+			return t.stateRevision;
+		},
+		get diagnostics() {
+			return t.diagnostics;
+		},
+		change: () => t.change(),
+		plan: t.plan.bind(t),
+		apply: t.apply.bind(t),
+		start: () => t.start(),
+		stop: () => t.stop(),
+		use: t.use.bind(t),
+		contributions: t.contributions.bind(t),
+		installation: t.installation.bind(t),
+		group: t.group.bind(t),
+		explain: t.explain.bind(t),
+		[y]: async () => {
+			await t.stop();
+		}
+	});
+}
+// src/composition/plugin-description.ts
+var Ye = /* @__PURE__ */ new Set(["jsonSchemaTarget"]);
+function Q(e, t = {}) {
+	let n = g(t, "Plugin description options", { fields: Ye }), r = n.jsonSchemaTarget === void 0 ? "draft-2020-12" : n.jsonSchemaTarget;
+	if (typeof r != "string" || !r || r.trim() !== r) throw TypeError("JSON Schema target must be a non-empty trimmed string");
+	let i = B(e), a = i.configuration?.["~standard"], o;
+	if (!a) o = Object.freeze({ status: "none" });
+	else if (!a.jsonSchema) o = Object.freeze({
+		status: "unavailable",
+		vendor: a.vendor
+	});
+	else {
+		let e = Object.freeze({ target: r });
+		o = Object.freeze({
+			status: "available",
+			vendor: a.vendor,
+			target: r,
+			input: $(a.jsonSchema.input(e)),
+			output: $(a.jsonSchema.output(e))
+		});
+	}
+	return Object.freeze({
+		name: i.name,
+		requires: Object.freeze(Object.entries(i.requires).map(([e, t]) => {
+			let n = t.kind === "optional" ? t.service : t;
+			return Object.freeze({
+				alias: e,
+				id: n.id,
+				kind: n.kind,
+				optional: t.kind === "optional"
+			});
+		})),
+		provides: Object.freeze(Object.entries(i.provides).map(([e, t]) => Object.freeze({
+			alias: e,
+			id: t.id
+		}))),
+		configuration: o
+	});
+}
+function $(e) {
+	v(e, "JSON Schema exporters must be synchronous");
+	let t = I(e);
+	if (typeof t != "object" || !t || Array.isArray(t)) throw TypeError("JSON Schema exporters must return a plain data record");
+	return t;
+}
+export { r as ConfigurationValidationError, l as DougongError, _ as RecordedFailure, y as asyncDisposeSymbol, I as captureConfiguration, Je as createHost, Ae as definePlugin, Q as describePlugin, n as disposeSymbol, re as event, ie as extensionPoint, i as isCancellationReason, a as isError, t as isLogger, ae as optional, ne as service };