dougong 0.8.3 → 0.10.0

package/dist/index.js

@@ -1,9 +1,2272 @@
-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 { A as e, B as t, C as n, D as r, E as i, F as a, G as o, H as s, I as c, J as l, K as u, L as d, M as f, N as p, O as m, P as ee, R as te, S as ne, T as re, U as ie, V as ae, W as h, Y as g, _, a as oe, b as v, c as y, d as b, f as x, g as se, h as S, i as ce, j as le, k as ue, l as C, m as de, n as fe, o as w, p as pe, q as T, r as me, s as E, t as he, u as D, v as ge, w as _e, x as ve, y as ye, z as O } from "./serial-queue-DjEs2KFf.js";
+// src/contracts/contracts.ts
+function be(e, t) {
+	if (!xe(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 xe(e) {
+	return typeof e == "string" && e.length > 0 && e === e.trim();
+}
+function k(e, t) {
+	return be("Contract", t), Object.freeze({
+		id: t,
+		kind: e
+	});
+}
+function A(e, t) {
+	let n = Object.getOwnPropertyDescriptor(e, t);
+	if (n && !("value" in n)) throw TypeError(`Contract field '${t}' must be a data property`);
+	return n?.value;
+}
+function j(e, t) {
+	let n = A(e, "id");
+	if (xe(n) && (t === "service" || t === "extensionPoint" || t === "event")) return {
+		id: n,
+		kind: t
+	};
+}
+function M(e, t, n) {
+	let r = e && typeof e == "object" ? j(e, A(e, "kind")) : void 0;
+	if (!r || t !== void 0 && r.kind !== t) throw TypeError(n ?? (t ? `Expected ${Se(t)}` : "Invalid contract"));
+	return Object.freeze(r);
+}
+function Se(e) {
+	return e === "extensionPoint" ? "an ExtensionPoint" : e === "event" ? "an Event" : "a Service";
+}
+function Ce(e) {
+	return k("service", e);
+}
+function we(e) {
+	return k("event", e);
+}
+function Te(e) {
+	return k("extensionPoint", e);
+}
+function Ee(e) {
+	return Object.freeze({
+		kind: "optional",
+		service: M(e, "service", "optional() expects a Service")
+	});
+}
+function De(e, t = "Expected a Service or ExtensionPoint", n = "Expected a Service") {
+	if (!e || typeof e != "object") throw TypeError(t);
+	let r = A(e, "kind");
+	if (r === "optional") return Object.freeze({
+		kind: r,
+		service: M(A(e, "service"), "service", n)
+	});
+	let i = j(e, r);
+	if (!i || i.kind === "event") throw TypeError(t);
+	return Object.freeze(i);
+}
+// src/contracts/resource.ts
+var N = /* @__PURE__ */ new WeakMap(), Oe = Object.freeze({ kind: "control" });
+function P(e) {
+	return N.set(e, Oe), e;
+}
+function ke(e) {
+	let t = N.get(e);
+	if (t) throw TypeError(t.kind === "control" ? "Owned control handles cannot be adopted as resources" : "Resource already has a Lifetime owner");
+	let n = { kind: "claim" };
+	return N.set(e, n), () => {
+		N.get(e) === n && N.delete(e);
+	};
+}
+function Ae(e) {
+	if (typeof e != "object" && typeof e != "function" || e === null) throw TypeError("Resource must implement Symbol.dispose or Symbol.asyncDispose");
+	let t = e[l];
+	if (t != null) {
+		if (typeof t != "function") throw TypeError("Symbol.asyncDispose must be a function");
+		return () => Reflect.apply(t, e, []);
+	}
+	let n = e[g];
+	if (typeof n != "function") throw TypeError("Resource must implement Symbol.dispose or Symbol.asyncDispose");
+	return () => u(Reflect.apply(n, e, []), "Symbol.dispose must be synchronous");
+}
+// src/lifetime/lifetime.ts
+var je = y()("lifetime"), F = /* @__PURE__ */ new WeakMap(), Me = class {
+	published = !1;
 };
+function I() {
+	let e = new DOMException("Resource disposed", "AbortError");
+	return Reflect.set(e, "stack", void 0), Object.freeze(e);
+}
+var Ne = class {
+	id;
+	kind;
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a;
+	constructor(e, t, n, r, i, a) {
+		this.#i = i, this.#a = a, 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(() => T(e())).then(() => {
+			this.#e = void 0;
+			let e = this.#t;
+			this.#t = void 0, this.#i = void 0, this.#a = void 0, e?.(), t.resolve();
+		}, (e) => {
+			this.#i?.(e), this.#r = new b(e), this.#a?.(), t.reject(e);
+		}), t.promise;
+	}
+	forget() {
+		if (this.#n) return;
+		this.#e = void 0, this.#i = void 0, this.#a = void 0;
+		let e = this.#t;
+		this.#t = void 0, e?.();
+	}
+}, Pe = class {
+	id;
+	publication;
+	failure;
+	#e;
+	constructor(e, t, n) {
+		this.id = e, this.publication = t, this.#e = n;
+	}
+	withdraw() {
+		if (this.failure) return !1;
+		try {
+			u(this.publication[g](), "Publication withdrawal must be synchronous");
+		} catch (e) {
+			return this.failure = {
+				reason: e,
+				recorded: void 0
+			}, this.#e?.(e), this.failure.recorded = new b(e), !1;
+		}
+		return this.#e = void 0, !0;
+	}
+}, Fe = class {
+	handle;
+	#e;
+	#t;
+	settled;
+	constructor(e, t, n) {
+		let i = new AbortController();
+		this.#e = i, this.#t = n;
+		let a = t, o = (e) => {
+			if (!a) return;
+			let t = a;
+			a = void 0;
+			try {
+				r(i.signal, e) || t(e);
+			} catch (e) {
+				queueMicrotask(() => {
+					throw e;
+				});
+			}
+		}, s = Promise.resolve().then(() => T(e(i.signal)));
+		this.settled = Object.freeze(s.then(() => this.#n(), (e) => {
+			o(e), this.#n();
+		})), this.handle = P(Object.freeze({
+			result: s,
+			[l]: this.#r.bind(this)
+		}));
+	}
+	#n() {
+		this.#e = void 0;
+		let e = this.#t;
+		this.#t = void 0, e?.();
+	}
+	#r() {
+		return this.cancel(I()), this.settled;
+	}
+	cancel(e) {
+		let t = this.#e;
+		this.#e = void 0, t?.abort(e);
+	}
+}, Ie = class n {
+	#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;
+	#p = "active";
+	#m = 0;
+	#h = 0;
+	#g;
+	#_;
+	#v;
+	#y;
+	#b;
+	#x;
+	constructor(e, t) {
+		if (Re(e.label), typeof e.report != "function") throw TypeError("Lifetime error reporter must be a function");
+		this.#e = e.label, this.#u = e.report, this.#d = e.releaseFailed, this.#f = e.changed, this.#l = L(e.shutdownTimeoutMilliseconds), this.#n = t?.visibility ?? new Me(), this.#_ = t?.detach, e.parentSignal && (this.#g = o(e.parentSignal, (e) => {
+			this.block(), this.#O(e);
+		}));
+	}
+	get handle() {
+		return this.#x ??= this.#S({});
+	}
+	#S(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 F.set(n, this), n;
+	}
+	resolveOwner(e) {
+		let t = e === void 0 ? void 0 : E(e, "Lifetime ownership", { fields: je }).lifetime;
+		if (this.#F(), t === void 0) return this;
+		let n = F.get(t);
+		if (!n || !this.#w(n)) throw TypeError("Lifetime owner must belong to the current scope tree");
+		return n.#F(), n;
+	}
+	*#C() {
+		let e = [this];
+		for (; e.length;) {
+			let t = e.pop();
+			yield t;
+			for (let n of [...t.#r].reverse()) e.push(n);
+		}
+	}
+	#w(e) {
+		for (let t of this.#C()) if (t === e) return !0;
+		return !1;
+	}
+	get signal() {
+		return this.#t.signal;
+	}
+	get phase() {
+		return this.#p;
+	}
+	get acceptsWork() {
+		return this.#p === "active" && !h(this.signal);
+	}
+	get published() {
+		return this.#n.published;
+	}
+	get busy() {
+		for (let e of this.#C()) if (e.#m > 0) return !0;
+		return !1;
+	}
+	snapshot() {
+		let e = /* @__PURE__ */ new Map();
+		for (let t of [...this.#C()].reverse()) e.set(t, t.#T([...t.#r].map((t) => e.get(t))));
+		return e.get(this);
+	}
+	#T(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.#b), Object.freeze({
+			label: this.#e,
+			phase: this.#p,
+			cleanups: this.#i.size,
+			interrupts: this.#a.size,
+			tasks: this.#s.size,
+			acquisitions: this.#c.size,
+			publications: this.#o.size,
+			foreground: this.#m,
+			unresolved: Object.freeze(t),
+			children: Object.freeze(e)
+		});
+	}
+	use(e) {
+		return this.#E(e), e;
+	}
+	own(e) {
+		let t = this.#E(e);
+		return () => t.forget();
+	}
+	#E(e, t = !1) {
+		if (t || this.#F(), F.has(e)) throw TypeError("Lifetime handles cannot be adopted as resources");
+		let n = ke(e), r;
+		try {
+			r = Ae(e), t || this.#F();
+		} catch (e) {
+			throw n(), e;
+		}
+		return this.#M(r, "cleanup", n);
+	}
+	defer(e) {
+		if (this.#F(), typeof e != "function") throw TypeError("Cleanup must be a function");
+		let t = this.#M(e, "cleanup");
+		return P(Object.freeze({ [l]: () => t.dispose() }));
+	}
+	interrupt(e) {
+		if (this.#F(), typeof e != "function") throw TypeError("Interrupt must be a function");
+		let t = this.#M(e, "interrupt");
+		return P(Object.freeze({ [g]: () => t.forget() }));
+	}
+	child(e) {
+		this.#F();
+		let t = new n({
+			label: e,
+			report: this.#u,
+			...this.#d && { releaseFailed: this.#d },
+			...this.#f && { changed: this.#f },
+			...this.#l === void 0 ? {} : { shutdownTimeoutMilliseconds: this.#l }
+		}, {
+			visibility: this.#n,
+			detach: (e) => this.#r.delete(e)
+		});
+		this.#r.add(t), this.#f?.();
+		let r = t.#S({ [l]: t.dispose.bind(t) });
+		return t.#x = r, r;
+	}
+	spawn(e) {
+		return this.#D(e, (e) => this.#N(e));
+	}
+	prepare(e) {
+		return this.#D(e).result;
+	}
+	#D(e, t) {
+		if (this.#F(), typeof e != "function") throw TypeError("Task must be a function");
+		let n = new Fe(e, t, () => {
+			this.#s.delete(n), this.#f?.();
+		});
+		return this.#s.add(n), this.#f?.(), n.handle;
+	}
+	acquire(e) {
+		if (this.#F(), typeof e != "function") throw TypeError("Acquisition must be a function");
+		let t = Promise.resolve().then(() => T(e(this.signal))).then(async ({ value: e }) => {
+			let t = this.#E(e, !0);
+			if (h(this.signal)) {
+				let e = ie(this.signal);
+				throw await t.dispose(), e;
+			}
+			return Object.freeze({ resource: e });
+		}), n = () => {
+			this.#c.delete(r), this.#f?.();
+		}, r = t.then(n, n);
+		return this.#c.add(r), this.#f?.(), t;
+	}
+	stage(e) {
+		this.#F();
+		let t, n = e(() => {
+			t && !t.failure && this.#o.delete(t), this.#f?.();
+		});
+		return t = new Pe(++this.#h, n, (e) => this.#P(e, "publication")), this.#o.add(t), w(() => {
+			this.#f?.(), this.published && n.publish();
+		}), n;
+	}
+	borrow(e) {
+		if (this.#F(), typeof e != "function") throw TypeError("Borrow callback must be a function");
+		this.#m++, this.#f?.();
+		let t = () => {
+			this.#m--, this.#f?.();
+		};
+		try {
+			let n = T(e());
+			return n.then(t, t), n;
+		} catch (e) {
+			return t(), Promise.reject(e);
+		}
+	}
+	seal() {
+		if (this.busy) throw new D(ue, "Lifetime has in-flight foreground work");
+		this.block();
+	}
+	block() {
+		for (let e of this.#C()) e.#p === "active" && (e.#p = "sealed");
+	}
+	#O(e) {
+		for (let t of this.#C()) {
+			t.#t.abort?.(e);
+			for (let n of t.#s) n.cancel(e);
+		}
+	}
+	publish() {
+		if (this.#F(), this.#_) throw TypeError("Only the root Lifetime may publish declarations");
+		if (!this.#n.published) {
+			this.#n.published = !0;
+			for (let e of this.#C()) for (let t of e.#o) t.publication.publish();
+		}
+	}
+	detachStartupSignal() {
+		this.#g?.(), this.#g = void 0;
+	}
+	dispose() {
+		if (this.#v) return this.#v;
+		if (this.#p === "disposed") return Promise.resolve();
+		try {
+			this.seal();
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		let e = [...this.#C()].filter((e) => !e.#v), t = [];
+		for (let n = e.length - 1; n >= 0; n--) {
+			let r = e[n];
+			r.#k(r === this ? t : []);
+		}
+		try {
+			w(() => {
+				for (let t of e) t.#j();
+				this.#f?.();
+			});
+		} catch (e) {
+			t.push(e);
+		}
+		return this.#O(I()), this.#v;
+	}
+	#k(e) {
+		this.#p = "disposing", this.detachStartupSignal();
+		let n = Promise.resolve().then(() => this.#A(e));
+		if (this.#y = n, this.#l === void 0) {
+			this.#v = Object.freeze(n);
+			return;
+		}
+		let r = Promise.withResolvers();
+		this.#v = Object.freeze(r.promise), r.promise.catch(() => void 0);
+		let i = setTimeout(() => {
+			let e = new D(t, "Lifetime shutdown did not complete before its deadline");
+			this.#p = "quarantined", this.#P(e, "shutdown"), this.#b = new b(e), this.#f?.(), r.reject(e);
+		}, this.#l);
+		n.then(() => {
+			clearTimeout(i), r.resolve();
+		}, (e) => {
+			clearTimeout(i), r.reject(e);
+		});
+	}
+	async #A(e) {
+		for (let t of this.#o) t.failure && e.push(t.failure.reason);
+		let t = Promise.allSettled([...this.#r].map((e) => e.#y)), 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.#b = void 0, e.length) throw this.#p = "quarantined", this.#f?.(), AggregateError(e, "Lifetime has unresolved cleanup obligations");
+		this.#p = "disposed", this.#t = { signal: AbortSignal.abort(I()) };
+		let a = this.#_;
+		this.#_ = void 0, a?.(this), this.#u = void 0, this.#d = void 0, this.#f?.(), this.#f = void 0;
+	}
+	#j() {
+		for (let e of [...this.#o].reverse()) e.withdraw() ? this.#o.delete(e) : this.#o.add(e);
+	}
+	#M(e, t, n) {
+		let r = t === "cleanup" ? this.#i : this.#a, i;
+		return i = new Ne(++this.#h, t, e, () => {
+			r.delete(i), n?.(), this.#f?.();
+		}, (e) => this.#P(e, t), () => this.#f?.()), r.add(i), this.#f?.(), i;
+	}
+	#N(e) {
+		let t = this.#u;
+		t && u(t(e), "Lifetime error reporters must be synchronous");
+	}
+	#P(e, t) {
+		this.#d?.(Object.freeze({
+			owner: this,
+			kind: t,
+			error: e
+		}));
+	}
+	#F() {
+		if (!this.acceptsWork) throw new D(e, "Lifetime is closed to new work");
+	}
+}, Le = 2 ** 31 - 1;
+function L(e) {
+	if (e !== void 0) {
+		if (typeof e != "number" || !Number.isFinite(e) || e <= 0 || e > Le) throw TypeError(`shutdownTimeoutMilliseconds must be a positive finite number no greater than ${Le}`);
+		return e;
+	}
+}
+function Re(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 ze = class {
+	#e = /* @__PURE__ */ new Map();
+	assertKinds(e) {
+		for (let [t, n] of e) this.assertCompatible({
+			id: t,
+			kind: n
+		});
+	}
+	assertCompatible(e) {
+		z(this.#e, e);
+	}
+	remember(e) {
+		R(this.#e, e);
+	}
+	writer(e) {
+		return new Be(this, e);
+	}
+	commit(e) {
+		this.assertKinds(e);
+		for (let [t, n] of e) this.#e.set(t, n);
+	}
+}, Be = 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), R(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 R(e, t) {
+	z(e, t), e.set(t.id, t.kind);
+}
+function z(e, t) {
+	let n = e.get(t.id);
+	if (n && n !== t.kind) throw new D(de, `Contract '${t.id}' is used as both '${n}' and '${t.kind}'`);
+}
+// src/events/event-hub.ts
+var Ve = class {
+	#e;
+	#t;
+	handle;
+	constructor(e, t, n, r, i) {
+		this.#e = t, this.#t = {
+			hub: e,
+			listener: n,
+			owner: r,
+			detach: i
+		}, this.handle = P(Object.freeze({ [g]: () => this[g]() }));
+	}
+	publish() {
+		let e = this.#t;
+		e && e.hub.add(this.#e, this);
+	}
+	invoke(e) {
+		let t = this.#t;
+		if (!t?.owner.acceptsWork) return Promise.resolve();
+		let { owner: n, listener: r } = t;
+		return n.borrow(() => r(e));
+	}
+	[g]() {
+		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 = M(e, "event"), a = r.owner.resolveOwner(n);
+		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 D(se, "Candidate setup cannot emit into the committed event graph");
+		let r = M(e, "event");
+		this.#t(), n.remember(r), await n.hub.emit(r.id, t[0]);
+	}
+	#t() {
+		let t = this.#e;
+		if (!t || !t.owner.acceptsWork) throw new D(e, "Event scope is closed");
+		return t;
+	}
+}, Ue = class {
+	#e = /* @__PURE__ */ new Map();
+	scope(e, t) {
+		return new He(this, e, t);
+	}
+	stage(e, t, n) {
+		return n.stage((r) => new Ve(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`);
+	}
+}, B = 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 t = this.#e.binding;
+		if (!t) throw new D(e, "Contribution view has been disposed");
+		if (t.owner && !t.owner.acceptsWork) throw new D(e, "Contribution view owner is closed");
+		return t;
+	}
+}, We = class {
+	#e;
+	constructor(e) {
+		this.#e = e, Object.freeze(this);
+	}
+	update = (e) => this.#e.update(e);
+	[g]() {
+		this.#e[g]();
+	}
+}, Ge = 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 = P(new We(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 D(S, "Contribution is no longer available");
+		let { owner: n, value: r } = t;
+		return n.borrow(() => e(r));
+	}
+	update(t) {
+		let n = this.#e;
+		if (n.phase === "disposed") throw TypeError(`Contribution '${this.#t}' has been disposed`);
+		if (!n.owner.acceptsWork) throw new D(e, "Contribution owner is closed");
+		Object.is(n.value, t) || (n.value = t, n.store.valueChanged(this.#t, this));
+	}
+	[g]() {
+		let e = this.#e;
+		e.phase !== "disposed" && (this.#e = { phase: "disposed" }, w(() => {
+			try {
+				e.store.removeContribution(this.#t, this);
+			} finally {
+				e.detachFromOwner();
+			}
+		}));
+	}
+}, Ke = 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 oe(() => this.#i, t);
+	}
+	stage(e, t, n, r, i) {
+		try {
+			Xe(t);
+			let a = Ze(e, t);
+			if (this.#n.has(a)) throw TypeError(`Duplicate contribution '${a}'`);
+			return r.stage((e) => {
+				i?.();
+				let t = new Ge(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 qe(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 B(n);
+	}
+	hostView() {
+		return this.#s ??= new B({ binding: { store: this } });
+	}
+	use(e, t) {
+		let n = this.#n.get(e);
+		if (n?.phase !== "published") throw new D(S, `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 n = this.#r.view.subscribe(e);
+		if (!t) return n;
+		this.#o++;
+		let r, i = new Je(n, () => {
+			let e = r;
+			r = void 0;
+			try {
+				e?.();
+			} finally {
+				this.#o--, this.#u();
+			}
+		});
+		try {
+			r = t(i), P(i);
+		} catch (e) {
+			throw i[g](), e;
+		}
+		return i;
+	}
+	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[g]();
+			} finally {
+				this.#t(this);
+			}
+		}
+	}
+}, qe = class {
+	#e;
+	constructor(e, t) {
+		this.#e = {
+			state: e,
+			release: t
+		}, Object.freeze(this);
+	}
+	[g]() {
+		let e = this.#e;
+		e && (this.#e = void 0, e.state.binding = void 0, e.release());
+	}
+}, Je = class {
+	#e;
+	constructor(e, t) {
+		this.#e = {
+			subscription: e,
+			release: t
+		}, Object.freeze(this);
+	}
+	[g]() {
+		let e = this.#e;
+		if (e) {
+			this.#e = void 0;
+			try {
+				e.subscription[g]();
+			} finally {
+				e.release();
+			}
+		}
+	}
+}, Ye = 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 Ke((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 Qe(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(), w(() => {
+			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 Xe(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 Ze(e, t) {
+	return `${V(e)}/${V(t)}`;
+}
+function V(e) {
+	return e.replaceAll("%", "%25").replaceAll("/", "%2F");
+}
+var Qe = 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(t, n, r, i) {
+		let a = this.#e;
+		if (!a || !a.owner.acceptsWork) throw new D(e, "Contribution scope is closed");
+		let o = M(t, "extensionPoint"), s = a.owner.resolveOwner(i);
+		return a.registry.get(o).stage(a.installationId, n, r, s, () => a.remember(o));
+	}
+}, $e = 64;
+function H(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) > $e) throw TypeError("Configuration exceeds the supported nesting depth");
+		if (a) return a;
+		t.add(e);
+		let o = 1, c = (e, t) => {
+			let n = r(e, t);
+			return o = Math.max(o, n.height + 1), n.value;
+		}, l;
+		if (Array.isArray(e)) {
+			let t = s(e, `Configuration array at ${i}`);
+			l = Object.freeze(t.map((e, t) => c(e, `${i}[${t}]`)));
+		} else {
+			let t = E(e, i), n = Object.create(null);
+			for (let [e, r] of Object.entries(t)) r !== void 0 && (n[e] = c(r, `${i}.${e}`));
+			l = Object.freeze(n);
+		}
+		t.delete(e);
+		let u = {
+			value: l,
+			height: o
+		};
+		return n.set(e, u), u;
+	};
+	return e === void 0 ? void 0 : r(e, "configuration").value;
+}
+async function et(e, t, n, r) {
+	if (r?.throwIfAborted(), !e) return Object.freeze({ value: t });
+	let i = e["~standard"].validate(t), a = r ? (await tt(i, r)).value : (await T(i)).value;
+	if (r?.throwIfAborted(), !a || typeof a != "object" && typeof a != "function") throw TypeError(`Installation '${n}' configuration validator returned a non-object result`);
+	let o = a.issues;
+	if (o !== void 0) throw Array.isArray(o) ? new C(o, { details: {
+		installation: n,
+		phase: "configuration",
+		outcome: "rejected"
+	} }) : TypeError(`Installation '${n}' configuration validator returned non-array issues`);
+	if (!("value" in a)) throw TypeError(`Installation '${n}' configuration validator returned neither value nor issues`);
+	let s = a.value;
+	return Object.freeze({ value: Object.is(s, t) ? t : H(s) });
+}
+function tt(e, t) {
+	let n = Promise.withResolvers(), { promise: r } = n, i = o(t, (e) => {
+		n?.reject(e), n = void 0;
+	});
+	return T(e).then((e) => n?.resolve(e), (e) => n?.reject(e)), r.finally(() => {
+		n = void 0, i();
+	});
+}
+// src/composition/plugin.ts
+var nt = y()("name", "configuration", "requires", "provides", "setup");
+function rt(e) {
+	return W(e);
+}
+var U = /* @__PURE__ */ new WeakSet();
+function W(e) {
+	if (U.has(e)) return e;
+	let t = E(e, "Plugin declaration", { fields: nt }), { 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 : it(r, n), o = t.requires === void 0 ? void 0 : E(t.requires, `Plugin '${n}' requires`), s = t.provides === void 0 ? void 0 : E(t.provides, `Plugin '${n}' provides`), c = new ot(n), l = c.normalizeRequirements(o ?? {}), u = c.normalizeProvisions(s ?? {}), d = Object.freeze({
+		name: n,
+		...a === void 0 ? {} : { configuration: a },
+		requires: l,
+		provides: u,
+		setup: i
+	});
+	return U.add(d), d;
+}
+var G = /* @__PURE__ */ new WeakSet();
+function it(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 (G.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 : at(s, t), u = Object.freeze({ "~standard": Object.freeze({
+		version: 1,
+		vendor: a,
+		validate: c,
+		...l === void 0 ? {} : { jsonSchema: l }
+	}) });
+	return G.add(u), u;
+}
+function at(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 ot = 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)) {
+			this.#t(n, "requirement");
+			let e = De(r, `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 = M(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 ${K(r.kind)} and ${K(n.kind)}`);
+		let i = K(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 K(e) {
+	return e === "extensionPoint" ? "ExtensionPoint" : e === "event" ? "Event" : "Service";
+}
+function q(e) {
+	return W(e);
+}
+// src/composition/installation.ts
+function J(e, t) {
+	if (e.has(t)) throw new D(_e, "Installation id is already installed: " + t);
+	e.add(t);
+}
+function st(e, t, n) {
+	return Object.freeze({
+		plugin: q(e),
+		configuration: H(t),
+		origin: ct(n)
+	});
+}
+function ct(e) {
+	let t = H(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 Y = class {
+	#e = {
+		status: "pending",
+		origin: void 0
+	};
+	attach(e) {
+		let t = this.#e;
+		e.attach(() => t);
+	}
+	retire() {
+		this.#e.status = "removed";
+	}
+}, lt = class {
+	id;
+	group;
+	facade;
+	#e;
+	#t = Object.freeze({
+		status: "pending",
+		origin: void 0
+	});
+	constructor(e, t) {
+		this.id = e, this.group = t;
+		let n = this;
+		this.facade = Object.freeze({
+			id: e,
+			groupId: t?.id,
+			get status() {
+				return n.#n().status;
+			},
+			get origin() {
+				return n.#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;
+	}
+}, ut = y()("id", "configuration", "origin", "group"), dt = y()("plugin", "configuration", "origin");
+function X(e, t) {
+	if (typeof e != "string" || !e.trim() || e.trim() !== e) throw TypeError(t + " must be a non-empty trimmed string");
+}
+var ft = class {
+	#e = /* @__PURE__ */ new WeakMap();
+	#t = new Y();
+	create(e) {
+		let t = new pt(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 D(pe, "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 a(this.#e);
+		return this.#e;
+	}
+}, pt = 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 = E(t, "Installation options", { fields: ut });
+		X(r.id, "Installation id");
+		let i = r.group === void 0 ? void 0 : n.resolveGroup(r.group), a = st(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 = E(t, "Installation update", { fields: dt }), 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 ? {
+			kind: "replace",
+			plugin: q(r.plugin),
+			origin: ct(r.origin),
+			...a ? { configuration: H(r.configuration) } : {}
+		} : {
+			kind: "configure",
+			configuration: H(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();
+		X(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);
+	}
+}, mt = 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()], r = /* @__PURE__ */ new Map(), i = ht(t, r), a = gt(t, i, r), { order: o, layers: s } = _t(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 ht(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let [r, i] of e) for (let e of Object.values(i.plugin.provides)) {
+		R(t, e);
+		let i = n.get(e.id);
+		if (i) throw new D(c, `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 gt(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 (R(n, o), o.kind === "extensionPoint") continue;
+		let s = t.get(o.id);
+		if (!s) {
+			if (e.kind === "optional") continue;
+			throw new D(te, `Installation '${a.id}' requires missing Service '${o.id}'`, { details: {
+				outcome: "rejected",
+				installation: a.id,
+				contract: o.id
+			} });
+		}
+		if (s === a) throw new D(d, `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 _t(e, t, n) {
+	let r = new Map(e.map((e, t) => [e, t])), i = e.filter((e) => n.get(e) === 0), a = [], o = [];
+	for (; i.length;) {
+		i.sort((e, t) => r.get(e) - r.get(t));
+		let e = i;
+		i = [], o.push(e);
+		for (let r of e) {
+			a.push(r);
+			for (let e of t.get(r) ?? []) {
+				let t = (n.get(e) ?? 0) - 1;
+				n.set(e, t), t || i.push(e);
+			}
+		}
+	}
+	if (a.length !== e.length) {
+		let e = vt(t, n);
+		throw new D(d, `Installation dependency cycle: ${e.map((e) => e.id).join(" -> ")}`, { details: {
+			outcome: "rejected",
+			dependencyPath: e.map((e) => e.id)
+		} });
+	}
+	return {
+		order: a,
+		layers: o
+	};
+}
+function vt(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 yt = 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 bt(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 D(v, "Initial Group is missing: " + a);
+			if (i.has(a)) throw new D(ge, "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 Z(e, t) {
+	return new D(p, "Host state changed during or after planning", { details: {
+		outcome: "rejected",
+		expectedRevision: e,
+		stateRevision: t
+	} });
+}
+var xt = class {
+	#e = /* @__PURE__ */ new WeakMap();
+	#t = /* @__PURE__ */ new WeakMap();
+	#n = new Y();
+	#r;
+	get validationSignal() {
+		return (this.#r ??= new AbortController()).signal;
+	}
+	issue(e, t) {
+		let { report: n } = e;
+		if (n.baseStateRevision !== t.revision) throw Z(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 D(f, "Plan was not issued by this Host");
+		if (n === "consumed") throw new D(le, "Plan has already been executed");
+		let r = this.#t.get(e);
+		if (!r) throw this.consume(e), Z(e.report.baseStateRevision, t);
+		return r;
+	}
+	consume(e) {
+		this.#e.set(e, "consumed"), this.#t.delete(e);
+	}
+	invalidate(e, t) {
+		this.#r?.abort(Object.freeze(t ? a(e) : Z(e - 1, e))), this.#r = void 0, this.#n.retire(), this.#n = new Y(), this.#t = /* @__PURE__ */ new WeakMap();
+	}
+};
+function St(e, t, n) {
+	return Object.freeze(e.map((e) => {
+		switch (e.kind) {
+			case "install": return Object.freeze({
+				kind: e.kind,
+				id: e.installation.id,
+				before: void 0,
+				after: $(n.declarationFor(e.installation))
+			});
+			case "update": return Object.freeze({
+				kind: e.kind,
+				id: e.installation.id,
+				before: $(t.declarationFor(e.installation)),
+				after: $(n.declarationFor(e.installation))
+			});
+			case "remove": return Object.freeze({
+				kind: e.kind,
+				id: e.installation.id,
+				before: $(t.declarationFor(e.installation)),
+				after: void 0
+			});
+			case "group":
+			case "remove-group": return Object.freeze({
+				kind: e.kind,
+				id: e.group.id,
+				parentId: e.group.parentId
+			});
+		}
+	}));
+}
+function Q(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, i = e.providers.get(r.id);
+		return [Object.freeze({
+			installation: t.id,
+			contract: r.id,
+			...n.kind === "optional" ? {
+				optional: !0,
+				provider: i?.id
+			} : {
+				optional: !1,
+				provider: i.id
+			}
+		})];
+	})));
+}
+function Ct(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), l;
+			if (c && n.has(c)) l = {
+				provider: c.id,
+				...s && { previousProvider: s.id }
+			};
+			else if (s && n.has(s)) l = {
+				previousProvider: s.id,
+				...c && { provider: c.id }
+			};
+			else continue;
+			i.push(Object.freeze({
+				installation: a.id,
+				kind: "provider_changed",
+				contract: o,
+				...l
+			}));
+		}
+	}
+	return Object.freeze(i);
+}
+function $(e) {
+	return Object.freeze({
+		pluginName: e.plugin.name,
+		origin: e.origin
+	});
+}
+// src/composition/planner.ts
+async function wt(e, t, n, r, a) {
+	let o = new Map(e.graph.declarations), s = new Map(e.groups), c = new Set(e.graph.byId.keys()), l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Set();
+	for (let n of t) {
+		if (n.kind === "group") {
+			if (s.has(n.group.id)) throw new D(_, "Group id is already installed: " + n.group.id);
+			s.set(n.group.id, n.group);
+			continue;
+		}
+		if (n.kind === "remove-group") {
+			if (e.groups.get(n.group.id) !== n.group) throw new D(ve, "Group is not committed: " + n.group.id);
+			u.add(n.group);
+			continue;
+		}
+		let t = n.installation;
+		if (n.kind === "install") J(c, t.id), o.set(t, n.declaration), l.set(t, "installed");
+		else {
+			let e = o.get(t);
+			if (!e) throw new D(i, "Installation is not committed: " + t.id);
+			if (n.kind === "remove") o.delete(t), l.set(t, "removed");
+			else {
+				let r = n.update;
+				o.set(t, Object.freeze(r.kind === "replace" ? {
+					plugin: r.plugin,
+					configuration: Object.hasOwn(r, "configuration") ? r.configuration : e.configuration,
+					origin: r.origin
+				} : {
+					...e,
+					configuration: r.configuration
+				})), l.set(t, "updated");
+			}
+		}
+	}
+	if (u.size) {
+		let t = Map.groupBy(s.values(), (e) => e.parent);
+		for (let n of u) {
+			if (e.groups.get(n.id) !== n) throw new D(x, "Group creation conflicts with ancestor removal: " + n.id);
+			s.delete(n.id);
+			for (let e of t.get(n) ?? []) u.add(e);
+		}
+		for (let e of o.keys()) if (e.group && u.has(e.group)) {
+			if (l.has(e)) throw new D(x, "Installation change conflicts with Group removal: " + e.id);
+			o.delete(e), l.set(e, "removed");
+		}
+	}
+	Tt(s, o);
+	let d = mt.build(o);
+	r.assertKinds(d.contractKinds);
+	let f = n === "change" ? e.graph.affectedByTransitionTo(d, [...l.keys()]) : new Set(d.order), p = /* @__PURE__ */ new Map();
+	for (let [t, r] of o) {
+		let i = e.graph.declarations.get(t) === r ? e.configurations.get(t) : void 0;
+		i ? p.set(t, i) : (n === "start" || l.has(t)) && p.set(t, await et(r.plugin.configuration, r.configuration, t.id, a));
+	}
+	if (n !== "change") for (let e of f) l.set(e, n);
+	let m = Object.freeze(n === "stop" || n === "change" && e.phase === "stopped" ? [] : d.order.filter((e) => f.has(e)).map((e) => e.id)), ee = Object.freeze({
+		baseStateRevision: e.revision,
+		intent: n,
+		operations: St(t, e.graph, d),
+		bindings: Object.freeze({
+			before: Q(e.graph),
+			after: Q(d)
+		}),
+		affectedInstallations: Object.freeze([...f].map((e) => e.id)),
+		reasons: Ct(e.graph, d, f, l),
+		stopOrder: Object.freeze(e.phase === "running" ? e.graph.order.filter((e) => f.has(e)).reverse().map((e) => e.id) : []),
+		prepareOrder: m,
+		publishOrder: m,
+		execution: Object.freeze({
+			atomicPublication: !0,
+			externalEffectsRollback: !1
+		})
+	});
+	return Object.freeze({
+		groups: s,
+		graph: d,
+		affected: f,
+		configurations: p,
+		report: ee
+	});
+}
+function Tt(e, t) {
+	for (let t of e.values()) {
+		let n = t.parent;
+		if (n && e.get(n.id) !== n) throw new D(v, "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 D(v, "Installation Group is not committed: " + n.group.id);
+}
+// src/execution/instance.ts
+var Et = 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 Ie({
+			label: e.id + "@" + n,
+			report: r.report,
+			releaseFailed: r.releaseFailed,
+			changed: r.changed,
+			parentSignal: r.startupSignal,
+			...r.shutdownTimeoutMilliseconds === void 0 ? {} : { shutdownTimeoutMilliseconds: r.shutdownTimeoutMilliseconds }
+		});
+	}
+	async prepare(e, t) {
+		let n = this.lifetime.signal, r = this.environment, i = Object.freeze({
+			hostName: r.hostName,
+			installationId: this.installation.id,
+			pluginName: this.declaration.plugin.name,
+			generation: this.generation,
+			groupId: this.installation.groupId
+		}), a = Object.freeze({
+			dependencies: e,
+			lifetime: this.lifetime.handle,
+			events: r.events.scope(this.lifetime, (e) => r.contracts.remember(e)),
+			contributions: r.contributions.scope(this.lifetime, this.installation.id, (e) => r.contracts.remember(e)),
+			metadata: i,
+			logger: this.lifetime.use(new fe(r.logger, i)).handle
+		}), { setup: o } = this.declaration.plugin, { value: s } = await this.lifetime.prepare(() => o(a, t));
+		AbortSignal.prototype.throwIfAborted.call(n);
+		let c = Object.entries(this.declaration.plugin.provides), l = (e, t) => new D(ee, e, {
+			...t,
+			details: { installation: this.installation.id }
+		});
+		if (!c.length) {
+			if (s !== void 0) throw l("Plugin without provisions must return undefined");
+			return;
+		}
+		let u;
+		try {
+			u = E(s, "Provided Services", { fields: new Set(c.map(([e]) => e)) });
+		} catch (e) {
+			throw l("Plugin returned invalid or unreadable provided Services", { cause: e });
+		}
+		AbortSignal.prototype.throwIfAborted.call(n);
+		for (let [e, t] of c) {
+			if (!Object.hasOwn(u, e)) throw l("Plugin did not provide " + e);
+			this.#e.set(t.id, u[e]);
+		}
+	}
+	read(e) {
+		if (!this.#e.has(e)) throw new D(O, "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();
+		}
+	}
+}, Dt = y()("name", "installations", "groups", "logger", "onError", "shutdownTimeoutMilliseconds"), Ot = y()("id", "parentId"), kt = y()("id", "plugin", "configuration", "origin", "groupId"), At = 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;
+	}
+}, jt = class {
+	name;
+	#e;
+	#t;
+	#n;
+	#r = new ze();
+	#i = new Ue();
+	#a;
+	#o = new he();
+	#s = new xt();
+	#c = new ft();
+	#l = /* @__PURE__ */ new WeakMap();
+	#u = /* @__PURE__ */ new WeakMap();
+	#d;
+	#f;
+	#p;
+	#m;
+	#h = 0;
+	constructor(e = {}) {
+		let t = E(e, "Host options", { fields: Dt }), n = t.name === void 0 ? "host" : t.name;
+		if (X(n, "Host name"), this.name = n, t.onError !== void 0 && typeof t.onError != "function") throw TypeError("Host onError must be a function");
+		this.#e = me(t.logger === void 0 ? console : t.logger), this.#t = t.onError ?? ((e) => this.#e.error(e)), this.#n = L(t.shutdownTimeoutMilliseconds), this.#a = new Ye((e) => this.#z(e));
+		let r = /* @__PURE__ */ new Map(), i = s(t.groups === void 0 ? [] : t.groups, "Initial Groups"), a = s(t.installations === void 0 ? [] : t.installations, "Initial Installations"), o = /* @__PURE__ */ new Map();
+		for (let e of i) {
+			let t = E(e, "Initial Group", { fields: Ot });
+			if (X(t.id, "Group id"), t.parentId !== void 0 && X(t.parentId, "Parent Group id"), o.has(t.id)) throw new D(_, "Duplicate initial Group: " + t.id);
+			o.set(t.id, t.parentId);
+		}
+		let c = bt(o, (e, t) => this.#N(e, t)), l = /* @__PURE__ */ new Set();
+		for (let e of a) {
+			let t = E(e, "Initial Installation", { fields: kt });
+			X(t.id, "Installation id"), t.groupId !== void 0 && X(t.groupId, "Installation Group id"), J(l, t.id);
+			let n = t.groupId === void 0 ? void 0 : c.get(t.groupId);
+			if (t.groupId !== void 0 && !n) throw new D(v, "Initial Group is missing: " + t.groupId);
+			let i = this.#A(t.id, n);
+			r.set(i, st(t.plugin, t.configuration, t.origin));
+		}
+		this.#f = Object.freeze({
+			revision: 0,
+			groups: c,
+			graph: mt.build(r),
+			configurations: /* @__PURE__ */ new Map(),
+			phase: "stopped",
+			instances: /* @__PURE__ */ new Map(),
+			unresolved: Object.freeze([]),
+			error: void 0
+		}), this.#d = new oe(() => this.#L(), (e) => this.#z(e)), this.#r.commit(this.#f.graph.contractKinds);
+		for (let e of r.keys()) this.#j(e);
+		Object.freeze(this);
+	}
+	get status() {
+		return this.#D() ? "quarantined" : 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 Q(t, n ? [n] : []);
+	}
+	change() {
+		return this.#O(), this.#c.create({
+			create: (e, t) => this.#A(e, t),
+			resolve: (e) => this.#P(e),
+			createGroup: (e, t) => this.#N(e, t),
+			resolveGroup: (e) => {
+				let t = this.#u.get(e);
+				if (!t) throw new D(ye, "Group belongs to another Host");
+				return t;
+			}
+		});
+	}
+	async plan(e, t) {
+		this.#O();
+		let n = this.#c.take(e), r = this.#s.validationSignal, i, a;
+		try {
+			if (t !== void 0) {
+				let e = new AbortController(), n = (t) => e.abort(t);
+				a = o(r, n), i = o(t, n), r = e.signal, r.throwIfAborted();
+			}
+			let e = await wt(this.#f, n, "change", this.#r, r);
+			return r.throwIfAborted(), this.#r.assertKinds(e.graph.contractKinds), this.#s.issue(e, this.#f);
+		} catch (e) {
+			throw this.#F(n), e;
+		} finally {
+			a?.(), i?.();
+		}
+	}
+	apply(e) {
+		return this.#D() ? Promise.reject(a(this.#f.revision)) : this.#p ? Promise.reject(this.#k()) : this.#o.run(() => this.#_(e)).then(({ value: e }) => 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 = De(e);
+			if (n.kind === "extensionPoint") throw TypeError("Expected a Service");
+			let r = n.kind === "optional" ? n.service : n;
+			if (this.#r.assertCompatible(r), this.#O(), this.#f.phase !== "running") throw new D(O, "Host is not running");
+			let i = this.#f.graph.providers.get(r.id);
+			if (!i) {
+				if (n.kind === "optional") return T(t(void 0));
+				throw new D(O, "No provider for " + r.id);
+			}
+			if (this.#p?.affected.has(i)) throw new D(O, "Service is changing: " + r.id);
+			let a = this.#f.instances.get(i);
+			if (!a) throw new D(O, "Service is not running: " + r.id);
+			return a.use(r.id, t);
+		} catch (e) {
+			return Promise.reject(e);
+		}
+	}
+	contributions(e) {
+		let t = M(e, "extensionPoint");
+		return this.#r.remember(t), this.#a.view(t);
+	}
+	#g(e) {
+		return this.#D() ? Promise.reject(a(this.#f.revision)) : this.#p ? Promise.reject(this.#k()) : this.#o.run(async () => {
+			if (this.#O(), e === "start" && this.#f.phase === "running" || e === "stop" && this.#f.phase === "stopped") return this.#E([]);
+			e === "start" && (this.#p = {
+				phase: "starting",
+				affected: new Set(this.#f.graph.declarations.keys()),
+				scopes: []
+			}, this.#R());
+			try {
+				let t = await wt(this.#f, [], e, this.#r);
+				return await this.#_(this.#s.issue(t, this.#f));
+			} finally {
+				this.#p && (this.#p = void 0, this.#R());
+			}
+		}).then(({ value: e }) => e);
+	}
+	async #_(e) {
+		this.#O();
+		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.#E([]);
+		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 D(ne, "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.#M(t.graph.declarations.keys()), e;
+		}
+		for (let e of r) e.lifetime.seal();
+		let a = this.#p;
+		this.#p = a ?? {
+			phase: t.report.intent === "stop" ? "stopping" : "changing",
+			affected: t.affected,
+			scopes: []
+		}, this.#p.scopes.push(n), this.#a.beginBatch(), a || this.#R();
+		try {
+			if (n.phase === "stopped" && t.report.intent !== "start") return i.commit(), this.#b(t, /* @__PURE__ */ new Map(), "stopped"), this.#E(t.report.affectedInstallations);
+			let e = await this.#w([n], new Set(r));
+			if (this.#D() || e.length || r.some((e) => e.lifetime.phase !== "disposed")) throw i.discard(), await this.#C(n, e, t, "stop");
+			if (t.report.intent === "stop") return i.commit(), this.#b(t, /* @__PURE__ */ new Map(), "stopped"), this.#E(t.report.affectedInstallations);
+			let a = new Map(n.instances);
+			for (let e of t.affected) a.delete(e);
+			let o = new Map(a), s = {
+				graph: t.graph,
+				instances: o
+			};
+			this.#p.scopes.push(s);
+			let c = new At((e) => this.#z(e));
+			try {
+				await this.#v(t, o, i, c), i.commit(), c.seal();
+			} catch (e) {
+				i.discard();
+				let r = c.seal(e);
+				if (this.#D()) throw await this.#C(n, [r], t, "prepare");
+				let l = new Set([...o.values()].filter((e) => t.affected.has(e.installation))), u = await this.#w([s], l);
+				throw this.#D() || u.length || [...l].some((e) => e.lifetime.phase !== "disposed") ? await this.#C(n, [r, ...u], t, "prepare") : n.phase === "stopped" ? (this.#x({
+					...n,
+					error: new b(r).snapshot
+				}), this.#T("Startup failed", r, "restored", t.report.affectedInstallations, "prepare")) : (await this.#y(n, a, t, r), this.#T("Change failed; previous declarations were restored", r, "restored", t.report.affectedInstallations, "prepare"));
+			}
+			try {
+				this.#b(t, o, "running");
+			} catch (e) {
+				throw i.discard(), await this.#C(this.#f, [e], t, "publish");
+			}
+			return this.#E(t.report.affectedInstallations);
+		} finally {
+			this.#p = void 0, this.#M(t.graph.declarations.keys()), w(() => {
+				this.#a.endBatch(), this.#R();
+			});
+		}
+	}
+	async #v(e, t, n, i) {
+		let a = new AbortController(), o = ++this.#h;
+		for (let s of e.graph.layers) {
+			this.#O();
+			let c = s.filter((t) => e.affected.has(t)).map((r) => {
+				let i = new Et(r, e.graph.declarationFor(r), o, {
+					hostName: this.name,
+					logger: this.#e,
+					report: (e) => this.#z(e),
+					releaseFailed: (e) => this.#S(i, e),
+					changed: () => {
+						(this.#f.instances.get(r) === i || this.#f.unresolved.includes(i)) && this.#R();
+					},
+					events: this.#i,
+					contributions: this.#a,
+					contracts: n,
+					startupSignal: a.signal,
+					shutdownTimeoutMilliseconds: this.#n
+				});
+				return t.set(r, i), i;
+			});
+			try {
+				await Promise.all(c.map(async (n) => {
+					let o = n.lifetime.signal, s = Object.create(null);
+					for (let [r, i] of Object.entries(n.declaration.plugin.requires)) {
+						if (i.kind === "extensionPoint") {
+							s[r] = this.#a.view(i, n.lifetime);
+							continue;
+						}
+						let a = i.kind === "optional" ? i.service : i, o = e.graph.providers.get(a.id);
+						s[r] = o ? t.get(o)?.read(a.id) : void 0;
+					}
+					try {
+						await n.prepare(Object.freeze(s), e.configurations.get(n.installation)?.value);
+					} catch (e) {
+						throw r(o, e) || i.add(e), a.abort(e), e;
+					}
+				})), this.#O();
+				for (let e of c) AbortSignal.prototype.throwIfAborted.call(e.lifetime.signal);
+			} catch (e) {
+				throw a.abort(e), e;
+			}
+		}
+	}
+	async #y(e, t, n, r) {
+		this.#O();
+		let i = new Map(t), a = {
+			graph: e.graph,
+			instances: i
+		};
+		this.#p.scopes.push(a);
+		let o = new At((e) => this.#z(e)), s = this.#r.writer(e.graph.contractKinds);
+		try {
+			await this.#v({
+				graph: e.graph,
+				affected: n.affected,
+				configurations: e.configurations
+			}, i, s, o), o.seal(), s.commit(), this.#x({
+				...e,
+				instances: i,
+				error: new b(r).snapshot
+			});
+			for (let [e, t] of i) n.affected.has(e) && t.publish(), this.#O();
+		} catch (t) {
+			s.discard();
+			let c = this.#D() ? [] : await this.#w([a], new Set([...i.values()].filter((e) => n.affected.has(e.installation))));
+			throw await this.#C(e, [
+				r,
+				o.seal(t),
+				...c
+			], n, "restore");
+		}
+	}
+	#b(e, t, n) {
+		let r = this.#f;
+		this.#x({
+			groups: e.groups,
+			graph: e.graph,
+			configurations: e.configurations,
+			phase: n,
+			instances: t,
+			unresolved: Object.freeze([]),
+			error: void 0
+		}), this.#O();
+		for (let t of e.graph.declarations.keys()) r.graph.declarations.has(t) || this.#j(t);
+		for (let t of r.graph.declarations.keys()) e.graph.declarations.has(t) || t.detach({
+			status: "removed",
+			origin: void 0
+		});
+		for (let [n, r] of t) e.affected.has(n) && r.publish(), this.#O();
+	}
+	#x(e) {
+		this.#O(), 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
+			});
+		}
+	}
+	#S(e, t) {
+		if (this.#D()) return;
+		let n = e.lifetime;
+		if ((t.kind !== "shutdown" || t.owner === n) && n.phase !== "active" && n.phase !== "sealed") return;
+		let r = e.installation;
+		(this.#f.instances.get(r) === e || this.#p?.scopes.some((t) => t.instances.get(r) === e)) && this.#C(this.#f, [t.error], void 0, "release").then((e) => this.#z(e), (e) => this.#z(e));
+	}
+	#C(e, t, n, r) {
+		if (this.#m || this.#D()) {
+			let e = this.#m ?? Promise.resolve(a(this.#f.revision));
+			return t.length ? e.then((e) => this.#T("Operation failed while Host was quarantined", AggregateError([...t, e], "Execution failed during quarantine"), "quarantined", n?.report.affectedInstallations ?? [], r)) : e;
+		}
+		let i = [e, ...this.#p?.scopes ?? []], o = [...new Set(i.flatMap((e) => [...e.instances.values()]))].filter((e) => e.lifetime.phase !== "disposed"), s = n?.report.affectedInstallations ?? [...new Set(o.map((e) => e.installation.id))], c = "Execution could not establish a healthy state", l = Promise.resolve().then(async () => {
+			let e = await this.#w(i, new Set(o)), n = AggregateError([...t, ...e], c);
+			return this.#f = Object.freeze({
+				...this.#f,
+				unresolved: Object.freeze(o.filter((e) => e.lifetime.phase !== "disposed")),
+				error: new b(n).snapshot
+			}), this.#R(), this.#T("Host is quarantined after execution could not establish a healthy state", n, "quarantined", s, r);
+		});
+		this.#m = l;
+		let u = () => {
+			this.#m = void 0;
+		};
+		l.then(u, u);
+		for (let e of o) e.lifetime.block();
+		return this.#x({
+			...e,
+			phase: "quarantined",
+			instances: /* @__PURE__ */ new Map(),
+			unresolved: Object.freeze(o),
+			error: void 0
+		}), this.#R(), this.#f = Object.freeze({
+			...this.#f,
+			error: new b(AggregateError(t, c)).snapshot
+		}), this.#R(), l;
+	}
+	async #w(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] : []);
+	}
+	#T(e, t, r, i, a) {
+		return new D(r === "restored" ? ae : n, e, {
+			cause: t,
+			details: {
+				outcome: r,
+				phase: a,
+				stateRevision: this.#f.revision,
+				affectedInstallations: i
+			}
+		});
+	}
+	#E(e) {
+		return Object.freeze({
+			stateRevision: this.#f.revision,
+			affectedInstallations: Object.freeze([...e])
+		});
+	}
+	#D() {
+		return this.#f.phase === "quarantined";
+	}
+	#O() {
+		if (this.#D()) throw a(this.#f.revision);
+	}
+	#k() {
+		return new D(ne, "Another Host transition is in progress", { details: {
+			outcome: "rejected",
+			stateRevision: this.#f.revision
+		} });
+	}
+	#A(e, t) {
+		let n = new lt(e, t);
+		return this.#l.set(n.facade, n), n;
+	}
+	#j(e) {
+		e.attach(() => ({
+			status: this.#I(e),
+			origin: this.#f.graph.declarations.get(e)?.origin
+		}));
+	}
+	#M(e) {
+		for (let t of e) this.#f.graph.declarations.has(t) || t.detach({
+			status: "removed",
+			origin: void 0
+		});
+	}
+	#N(e, t) {
+		let n = new yt(e, t);
+		return this.#u.set(n.facade, n), n;
+	}
+	#P(e) {
+		let t = this.#l.get(e);
+		if (!t) throw new D(re, "Installation belongs to another Host");
+		return t;
+	}
+	#F(e) {
+		this.#M(e.flatMap((e) => e.kind === "install" ? [e.installation] : []));
+	}
+	#I(e) {
+		return this.#f.graph.declarations.has(e) ? this.#D() ? "quarantined" : this.#p?.affected.has(e) ? "changing" : this.#f.instances.has(e) ? "running" : "stopped" : "pending";
+	}
+	#L() {
+		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.#I(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: Q(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
+		});
+	}
+	#R() {
+		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.#z(e);
+		}
+	}
+	#z(e) {
+		let t = this.#e, n = (n) => {
+			try {
+				T(t.error(AggregateError([e, n], "Host error reporter failed"))).catch(() => void 0);
+			} catch {}
+		};
+		try {
+			let t = this.#t;
+			T(t(e)).catch(n);
+		} catch (e) {
+			n(e);
+		}
+	}
+};
+// src/execution/host.ts
+function Mt(e) {
+	let t = new jt(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),
+		[l]: async () => {
+			await t.stop();
+		}
+	});
+}
+// src/composition/plugin-description.ts
+var Nt = y()("jsonSchemaTarget");
+function Pt(e, t = {}) {
+	let n = E(t, "Plugin description options", { fields: Nt }), 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 = q(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: Ft(a.jsonSchema.input(e)),
+			output: Ft(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 Ft(e) {
+	u(e, "JSON Schema exporters must be synchronous");
+	let t = H(e);
+	if (typeof t != "object" || !t || Array.isArray(t)) throw TypeError("JSON Schema exporters must return a plain data record");
+	return t;
+}
+export { C as ConfigurationValidationError, D as DougongError, b as RecordedFailure, l as asyncDisposeSymbol, H as captureConfiguration, Mt as createHost, rt as definePlugin, Pt as describePlugin, g as disposeSymbol, we as event, Te as extensionPoint, r as isCancellationReason, m as isError, ce as isLogger, Ee as optional, Ce as service };