dougong 0.8.3 → 0.10.0

package/dist/serial-queue-DjEs2KFf.js

@@ -0,0 +1,559 @@
+import { listenForAbort as e } from "#abort-listener";
+// src/internal/disposal-runtime.ts
+function t(e) {
+	if (typeof e != "function") throw Error("Unsupported JavaScript runtime: Promise.withResolvers is required");
+}
+function n(e, t) {
+	return e ?? Symbol.for(t);
+}
+t(Promise.withResolvers);
+var r = n(Symbol.dispose, "Symbol.dispose"), i = n(Symbol.asyncDispose, "Symbol.asyncDispose"), a = Promise.prototype, o = a.then;
+async function s(e) {
+	return l(e) ?? Object.freeze({ value: e });
+}
+function c(e, t) {
+	let n = l(e);
+	if (n) throw n.then(() => void 0, () => void 0), TypeError(t);
+}
+function l(e) {
+	if (e === null || typeof e != "object" && typeof e != "function") return;
+	if (u(e)) {
+		let t = Promise.withResolvers();
+		return Reflect.apply(o, e, [(e) => t.resolve(Object.freeze({ value: e })), t.reject]), t.promise;
+	}
+	let t = e.then;
+	if (typeof t != "function") return;
+	let n = Promise.withResolvers();
+	return queueMicrotask(() => {
+		try {
+			Reflect.apply(t, e, [n.resolve, n.reject]);
+		} catch (e) {
+			n.reject(e);
+		}
+	}), n.promise.then((e) => Object.freeze({ value: e }));
+}
+function u(e) {
+	let t = /* @__PURE__ */ new Set();
+	for (let n = Object.getPrototypeOf(e); n !== null; n = Object.getPrototypeOf(n)) {
+		if (n === a) return !0;
+		if (t.has(n)) throw TypeError("Result has a cyclic prototype chain");
+		t.add(n);
+	}
+	return !1;
+}
+// src/internal/abort.ts
+function d(e) {
+	return Reflect.get(AbortSignal.prototype, "aborted", e);
+}
+function f(e) {
+	return Reflect.get(AbortSignal.prototype, "reason", e);
+}
+function p(t, n) {
+	if (typeof n != "function") throw TypeError("Abort listener must be a function");
+	if (d(t)) return n(f(t)), () => {};
+	let r = {
+		signal: t,
+		callback: n
+	}, i;
+	function a() {
+		r = void 0, i?.(), i = void 0;
+	}
+	function o() {
+		if (!r || !d(r.signal)) return;
+		let { signal: e, callback: t } = r, n = f(e);
+		a(), t(n);
+	}
+	return i = e(t, o), r ? o() : a(), a;
+}
+// src/internal/data-array.ts
+function m(e, t) {
+	if (!Array.isArray(e)) throw TypeError(`${t} must be an array`);
+	let n = Reflect.ownKeys(e), r = n.length - 1;
+	if (r !== Reflect.getOwnPropertyDescriptor(e, "length")?.value) throw TypeError(`${t} must be a dense array`);
+	let i = [];
+	for (let a of n) {
+		if (a === "length") continue;
+		let n = typeof a == "string" ? Number(a) : NaN;
+		if (!Number.isInteger(n) || n < 0 || n >= r || String(n) !== a) throw TypeError(`${t} must contain only dense array indices`);
+		let o = Reflect.getOwnPropertyDescriptor(e, a);
+		if (!o || !("value" in o)) throw TypeError(`${t} must contain data properties`);
+		i[n] = o.value;
+	}
+	return Object.freeze(i);
+}
+// src/contracts/errors.ts
+var h = "BUSY", g = "CHANGE_CONFLICT", _ = "CHANGE_FOREIGN", v = "CONFIGURATION_INVALID", y = "CONTRACT_CONFLICT", b = "CONTRIBUTION_UNAVAILABLE", x = "EVENT_BEFORE_COMMIT", S = "GROUP_CONFLICT", C = "GROUP_CYCLE", w = "GROUP_FOREIGN", T = "GROUP_MISSING", E = "GROUP_REMOVED", D = "HOST_BUSY", O = "HOST_QUARANTINED", ee = "INSTALLATION_CONFLICT", te = "INSTALLATION_FOREIGN", ne = "INSTALLATION_REMOVED", k = "LIFETIME_DISPOSED", re = "PLAN_CONSUMED", ie = "PLAN_FOREIGN", ae = "PLAN_STALE", oe = "PROVIDES_INVALID", se = "SERVICE_CONFLICT", ce = "SERVICE_CYCLE", le = "SERVICE_MISSING", ue = "SERVICE_UNAVAILABLE", de = "SHUTDOWN_TIMEOUT", fe = "TRANSITION_FAILED", A = 8, j = 256, M = 256, pe = 8, me = 4, he = 32, ge = 256, _e = 256, N = 4096, ve = 16384, ye = 8, be = 8, xe = 16, Se = 256, P = 256, Ce = 32, F = {
+	outcome: "outcome",
+	phase: "text",
+	installation: "text",
+	contract: "text",
+	dependencyPath: "path",
+	affectedInstallations: "path",
+	stateRevision: "revision",
+	expectedRevision: "revision"
+}, we = [
+	"rejected",
+	"restored",
+	"quarantined"
+];
+function I(e, t) {
+	let n = {};
+	for (let r of t ? Object.keys(F) : Reflect.ownKeys(e)) {
+		if (typeof r != "string" || !Object.hasOwn(F, r)) throw TypeError(`Unknown error detail '${String(r)}'`);
+		let i = t ? V(e, r) : Reflect.get(e, r);
+		if (i === void 0) continue;
+		let a;
+		switch (F[r]) {
+			case "outcome":
+				a = we.find((e) => e === i);
+				break;
+			case "text":
+				typeof i == "string" && (a = t ? t.clip(i, P) : i);
+				break;
+			case "revision":
+				typeof i == "number" && Number.isSafeInteger(i) && i >= 0 && (a = i);
+				break;
+			case "path": if (t) a = t.strings(i, Ce, P);
+			else {
+				let e = m(i, r);
+				e.every((e) => typeof e == "string") && (a = e);
+			}
+		}
+		if (a !== void 0) n[r] = a;
+		else if (!t) throw TypeError(`Invalid error detail '${r}'`);
+	}
+	return Object.freeze(n);
+}
+var L = class extends Error {
+	name = "DougongError";
+	code;
+	details;
+	constructor(e, t, n) {
+		if (typeof e != "string" || e.trim() !== e || e.length === 0) throw TypeError("DougongError code must be a non-empty trimmed string");
+		if (typeof t != "string") throw TypeError("DougongError message must be a string");
+		super(t, n), this.code = e;
+		let r = n?.details;
+		if (r !== void 0 && (!r || typeof r != "object" || Array.isArray(r))) throw TypeError("Error details must be an object");
+		this.details = I(r ?? {});
+	}
+};
+function Te(e) {
+	return new L(O, "Host execution is permanently quarantined", { details: {
+		outcome: "quarantined",
+		stateRevision: e
+	} });
+}
+var R = class e extends Error {
+	name = "RecordedFailure";
+	code;
+	#e;
+	get snapshot() {
+		return this.#e;
+	}
+	static #t(e) {
+		return typeof e == "object" && e && #e in e ? e.#e : void 0;
+	}
+	constructor(t, n = []) {
+		let r = m(n, "Diagnostic field names");
+		if (r.length > A || r.some((e) => typeof e != "string" || !e || e.length > j)) throw TypeError(`Select at most ${A} diagnostic field names of 1–${j} characters each`);
+		let i = e.#t(t) ?? Ee(t, e.#t, new Set(r));
+		super(i.message), this.code = i.code, this.#e = i, this.stack = i.stack ?? `${this.name}: ${i.message}`, Object.freeze(this);
+	}
+};
+function Ee(e, t, n) {
+	let r = /* @__PURE__ */ new Set(), i = he, a = (e, o, s = !1) => {
+		let c = s ? e : t(e), l = c ?? e;
+		if (o > me || i-- <= 0 || r.has(l)) return Object.freeze({
+			name: "TruncatedError",
+			message: "Error chain truncated",
+			truncated: !0
+		});
+		if (!c && !z(l)) {
+			let e = l === null || [
+				"string",
+				"number",
+				"boolean",
+				"undefined",
+				"bigint",
+				"symbol"
+			].includes(typeof l) ? String(l) : "Non-Error object omitted";
+			return Object.freeze({
+				name: "NonError",
+				message: e.slice(0, N),
+				...e.length > N ? { truncated: !0 } : {}
+			});
+		}
+		r.add(l);
+		let u = c?.truncated ?? !1, d = (e, t) => (e.length > t && (u = !0), e.slice(0, t)), f = (e, t) => {
+			let n = V(l, e);
+			return typeof n == "string" ? d(n, t) : void 0;
+		}, p = (e, t) => {
+			if (!De(e)) return;
+			let n = V(e, "length");
+			if (!(typeof n != "number" || !Number.isSafeInteger(n) || n < 0)) return n > t && (u = !0), Array.from({ length: Math.min(n, t) }, (t, n) => V(e, n));
+		}, m = f("name", ge) ?? "Error", h = f("message", N) ?? "", g = f("stack", ve), _ = f("code", _e), v = V(l, "cause"), y = p(V(l, "errors"), ye), b = (e, t, n) => {
+			let r = p(e, t);
+			return r && Object.freeze(r.filter((e) => typeof e == "string").map((e) => d(e, n)));
+		}, x = c?.fields;
+		if (!c && n.size) {
+			let e = [];
+			for (let t of n) {
+				let n = B(l, t)?.value, r = typeof n == "string" ? d(n, M) : b(n, pe, M);
+				r !== void 0 && e.push([t, r]);
+			}
+			e.length && (x = Object.freeze(Object.fromEntries(e)));
+		}
+		let S = p(V(l, "issues"), be)?.map((e) => {
+			let t = V(e, "message"), n = p(V(e, "path"), xe)?.map((e) => {
+				let t = e && typeof e == "object" ? V(e, "key") : e;
+				return typeof t == "number" ? t : typeof t == "string" || typeof t == "symbol" ? d(String(t), Se) : "[omitted]";
+			});
+			return Object.freeze({
+				message: typeof t == "string" ? d(t, N) : "",
+				...n ? { path: Object.freeze(n) } : {}
+			});
+		}), C = V(l, "details"), w = typeof C == "object" && C ? I(C, {
+			clip: d,
+			strings: b
+		}) : void 0, T = (e) => a(e, o + 1, !!c), E = B(l, "error"), D = E && B(l, "suppressed");
+		return Object.freeze({
+			name: m,
+			message: h,
+			..._ === void 0 ? {} : { code: _ },
+			...g === void 0 ? {} : { stack: g },
+			...v === void 0 ? {} : { cause: T(v) },
+			...y === void 0 ? {} : { errors: Object.freeze(y.map(T)) },
+			...E && D ? {
+				error: T(E.value),
+				suppressed: T(D.value)
+			} : {},
+			...x === void 0 ? {} : { fields: x },
+			...S === void 0 ? {} : { issues: Object.freeze(S) },
+			...w === void 0 ? {} : { details: w },
+			...u ? { truncated: !0 } : {}
+		});
+	};
+	return a(e, 0);
+}
+function z(e) {
+	try {
+		return e instanceof Error ? !0 : typeof e != "object" || !e ? !1 : "isError" in Error && typeof Error.isError == "function" ? Error.isError(e) : !(Symbol.toStringTag in e) && Object.prototype.toString.call(e) === "[object Error]";
+	} catch {
+		return !1;
+	}
+}
+function De(e) {
+	try {
+		return Array.isArray(e);
+	} catch {
+		return !1;
+	}
+}
+function B(e, t) {
+	try {
+		let n = Object.getOwnPropertyDescriptor(e, t);
+		return n && "value" in n ? n : void 0;
+	} catch {
+		return;
+	}
+}
+function V(e, t) {
+	try {
+		return e && typeof e == "object" ? e[t] : void 0;
+	} catch {
+		return;
+	}
+}
+function Oe(e, t) {
+	try {
+		if (!d(e)) return !1;
+	} catch (e) {
+		throw TypeError("Cancellation classifier expects an AbortSignal", { cause: e });
+	}
+	let n = f(e);
+	return Object.is(t, n) ? !0 : z(t) && V(t, "name") === "AbortError" && Object.is(B(t, "cause")?.value, n);
+}
+var ke = class extends L {
+	name = "ConfigurationValidationError";
+	issues;
+	constructor(e, t) {
+		let n = Ae(e);
+		super(v, `Invalid Plugin configuration:\n${n.map((e) => `  - ${e.message}`).join("\n")}`, t), this.issues = n;
+	}
+};
+function Ae(e) {
+	return Object.freeze(H(e, "Configuration validation issues").map((e, t) => {
+		if (!e || typeof e != "object" && typeof e != "function") throw TypeError(`Configuration validation issue at index ${t} must be an object`);
+		let n = e, r = n.message;
+		if (typeof r != "string") throw TypeError(`Configuration validation issue at index ${t} message must be a string`);
+		let i = n.path;
+		return Object.freeze({
+			message: r,
+			...i === void 0 ? {} : { path: je(i, t) }
+		});
+	}));
+}
+function je(e, t) {
+	return Object.freeze(H(e, `Configuration validation issue at index ${t} path`).map((e, n) => {
+		if (U(e)) return e;
+		if (!e || typeof e != "object" && typeof e != "function") throw TypeError(`Configuration validation issue at index ${t} path segment ${n} must be a property key`);
+		let r = e.key;
+		if (!U(r)) throw TypeError(`Configuration validation issue at index ${t} path segment ${n} must contain a property key`);
+		return Object.freeze({ key: r });
+	}));
+}
+function H(e, t) {
+	if (!Array.isArray(e)) throw TypeError(`${t} must be an array`);
+	let n = e.length;
+	if (typeof n != "number" || !Number.isSafeInteger(n) || n < 0) throw TypeError(`${t} must have a valid array length`);
+	let r = [];
+	for (let i = 0; i < n; i++) {
+		if (!(i in e)) throw TypeError(`${t} must be a dense array`);
+		r.push(e[i]);
+	}
+	return Object.freeze(r);
+}
+function U(e) {
+	return typeof e == "string" || typeof e == "number" || typeof e == "symbol";
+}
+// src/internal/record.ts
+function Me() {
+	return (...e) => new Set(e);
+}
+var Ne = Function.prototype.toString.call(Object);
+function Pe(e) {
+	let t = Object.getPrototypeOf(e);
+	if (t === Object.prototype || t === null) return !0;
+	if (Object.getPrototypeOf(t) !== null) return !1;
+	let n = Object.getOwnPropertyDescriptor(t, "constructor")?.value;
+	return typeof n == "function" && Function.prototype.toString.call(n) === Ne && Object.getOwnPropertyDescriptor(n, "prototype")?.value === t;
+}
+function Fe(e, t, n = {}) {
+	if (!e || typeof e != "object" || Array.isArray(e) || !Pe(e)) throw W(n, `${t} must be a plain record`);
+	let r = Object.create(null);
+	for (let i of Reflect.ownKeys(e)) {
+		let a = Reflect.getOwnPropertyDescriptor(e, i);
+		if (typeof i != "string" || !a?.enumerable) throw W(n, `${t} keys must be enumerable strings`);
+		if (!("value" in a)) throw W(n, `${t} field '${i}' must be a data property`);
+		if (n.fields && !n.fields.has(i)) throw W(n, `${t}: unknown field '${i}'`);
+		r[i] = a.value;
+	}
+	return Object.freeze(r);
+}
+function W(e, t) {
+	return e.createError?.(t) ?? TypeError(t);
+}
+// src/observation/snapshot-view.ts
+var G = /* @__PURE__ */ new WeakMap(), K = /* @__PURE__ */ new Set(), q = 0, J = !1;
+function Y(e) {
+	q++;
+	let t = [];
+	try {
+		c(e(), "Snapshot notification batches must be synchronous");
+	} catch (e) {
+		t.push(e);
+	} finally {
+		if (q--, !q) try {
+			X();
+		} catch (e) {
+			t.push(e);
+		}
+	}
+	if (t.length === 1) throw t[0];
+	if (t.length > 1) throw AggregateError(t, "Snapshot batch failed");
+}
+function X() {
+	if (J) return;
+	J = !0;
+	let e = [];
+	try {
+		for (; K.size;) {
+			let t = K.values().next().value;
+			K.delete(t), Le(t, e);
+		}
+	} finally {
+		J = !1, K.clear();
+	}
+	if (e.length) throw AggregateError(e, "Snapshot error reporting failed");
+}
+var Ie = class {
+	#e = /* @__PURE__ */ new Set();
+	#t;
+	#n;
+	#r = !1;
+	#i = !1;
+	constructor(e, t) {
+		if (typeof e != "function") throw TypeError("Snapshot reader must be a function");
+		if (typeof t != "function") throw TypeError("Snapshot error reporter must be a function");
+		this.#t = {
+			phase: "active",
+			read: e,
+			report: t
+		}, this.#n = {
+			phase: "value",
+			value: e()
+		}, Object.freeze(this);
+	}
+	view = Object.freeze({
+		get: () => this.#a(),
+		subscribe: (e) => this.#o(e)
+	});
+	invalidate() {
+		this.#c(), this.#r = !0;
+		for (let e of this.#e) K.add(e);
+		q || X();
+	}
+	[r]() {
+		let e = this.#t;
+		if (e.phase !== "disposed") {
+			if (this.#i) throw TypeError("Cannot dispose a snapshot publisher while its reader is running");
+			this.#t = { phase: "disposed" };
+			try {
+				this.#s(e.read);
+			} finally {
+				this.#r = !1;
+				let e = [...this.#e];
+				this.#e.clear();
+				for (let t of e) Q(t);
+			}
+		}
+	}
+	#a() {
+		if (this.#i) throw TypeError("Circular snapshot read");
+		let e = this.#t;
+		e.phase === "active" && this.#s(e.read);
+		let t = this.#n;
+		if (t.phase === "error") throw t.error;
+		return t.value;
+	}
+	#o(e) {
+		if (typeof e != "function") throw TypeError("Subscriber must be a function");
+		let { report: t } = this.#c(), n = new Z(e, t, (e) => {
+			this.#e.delete(e);
+		});
+		return this.#e.add(n), n;
+	}
+	#s(e) {
+		this.#r && Y(() => {
+			this.#r = !1, this.#i = !0;
+			try {
+				this.#n = {
+					phase: "value",
+					value: e()
+				};
+			} catch (e) {
+				throw this.#r = !0, this.#t.phase === "disposed" && (this.#n = {
+					phase: "error",
+					error: new R(e)
+				}), e;
+			} finally {
+				this.#i = !1;
+			}
+		});
+	}
+	#c() {
+		let e = this.#t;
+		if (e.phase === "disposed") throw TypeError("Snapshot publisher is disposed");
+		return e;
+	}
+}, Z = class {
+	constructor(e, t, n) {
+		G.set(this, {
+			listener: e,
+			report: t,
+			detach: n
+		}), Object.freeze(this);
+	}
+	[r]() {
+		let e = G.get(this);
+		e && (Q(this), e.detach(this));
+	}
+};
+function Le(e, t) {
+	let n = G.get(e);
+	if (n) try {
+		let { listener: e } = n;
+		c(e(), "Snapshot subscribers must be synchronous");
+	} catch (e) {
+		try {
+			let { report: t } = n;
+			c(t(e), "Snapshot error reporters must be synchronous");
+		} catch (n) {
+			t.push(e, n);
+		}
+	}
+}
+function Q(e) {
+	K.delete(e), G.delete(e);
+}
+// src/contracts/logging.ts
+function $(e) {
+	if (!e || typeof e != "object" && typeof e != "function") throw TypeError("Logger must implement debug/info/warn/error");
+	let t = (t) => {
+		let n = e[t];
+		if (typeof n != "function") throw TypeError("Logger must implement debug/info/warn/error");
+		return (...t) => Reflect.apply(n, e, t);
+	};
+	return Object.freeze({
+		debug: t("debug"),
+		info: t("info"),
+		warn: t("warn"),
+		error: t("error")
+	});
+}
+function Re(e) {
+	try {
+		return $(e), !0;
+	} catch {
+		return !1;
+	}
+}
+var ze = class {
+	handle = Object.freeze({
+		debug: (e, ...t) => this.#t("debug", e, t),
+		info: (e, ...t) => this.#t("info", e, t),
+		warn: (e, ...t) => this.#t("warn", e, t),
+		error: (e, ...t) => this.#t("error", e, t)
+	});
+	#e;
+	constructor(e, t) {
+		this.#e = {
+			logger: e,
+			metadata: t
+		};
+	}
+	[r]() {
+		this.#e = void 0;
+	}
+	#t(e, t, n) {
+		let r = this.#e;
+		if (!r) throw new L(k, "Logger scope has ended");
+		c(r.logger[e](t, r.metadata, ...n), "Logger methods must be synchronous");
+	}
+}, Be = class {
+	#e = /* @__PURE__ */ new Set();
+	#t = !1;
+	get settled() {
+		return this.run(() => void 0).then(() => void 0);
+	}
+	run(e, t) {
+		if (typeof e != "function") throw TypeError("SerialQueue operation must be a function");
+		let n = Promise.withResolvers(), r = n.promise.then(() => void 0, () => void 0), i = () => {
+			a?.();
+			try {
+				s(e()).then(n.resolve, n.reject);
+			} catch (e) {
+				n.reject(e);
+			}
+			return r;
+		}, a = t === void 0 ? void 0 : p(t, (e) => {
+			this.#e.delete(i), n.reject(e);
+		});
+		return t !== void 0 && d(t) || (this.#e.add(i), this.#t || (this.#t = !0, queueMicrotask(() => void this.#n()))), n.promise;
+	}
+	async #n() {
+		for (let e of this.#e) this.#e.delete(e), await e();
+		this.#t = !1;
+	}
+};
+export { k as A, de as B, O as C, Oe as D, ne as E, Te as F, p as G, m as H, se as I, i as J, c as K, ce as L, ie as M, ae as N, z as O, oe as P, le as R, D as S, te as T, f as U, fe as V, d as W, r as Y, S as _, Ie as a, T as b, Me as c, R as d, g as f, x as g, b as h, Re as i, re as j, h as k, ke as l, y as m, ze as n, Y as o, _ as p, s as q, $ as r, Fe as s, Be as t, L as u, C as v, ee as w, E as x, w as y, ue as z };

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "dougong",
-  "version": "0.8.3",
+  "version": "0.10.0",
   "type": "module",
   "engines": {
-    "node": ">=22"
+    "node": "^24.22.0 || >=26.10.0"
   },
   "browserslist": [
     "Chrome >= 119",
     "Edge >= 119",
-    "Firefox >= 121",
+    "Firefox >= 124",
     "Safari >= 17.4"
   ],
   "sideEffects": false,
   "files": [
     "dist",
+    "runtime",
     "README.md",
     "LICENSE"
   ],
@@ -21,14 +22,22 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./advanced": {
+      "types": "./dist/advanced.d.ts",
+      "import": "./dist/advanced.js"
+    }
+  },
+  "imports": {
+    "#abort-listener": {
+      "types": "./runtime/abort-listener.d.mts",
+      "default": "./runtime/abort-listener.mjs"
     }
   },
   "dependencies": {
-    "@dougongjs/core": "0.8.3",
-    "@dougongjs/platform": "0.8.3",
-    "@dougongjs/reactive": "0.8.3"
+    "@standard-schema/spec": "^1.1.0"
   },
-  "description": "Capability composition and structured lifetime kernel, plus its plugin distribution layer.",
+  "description": "Capability composition and structured lifetime kernel for JavaScript/TypeScript.",
   "license": "MIT",
   "author": "Dougong contributors",
   "homepage": "https://tangerg.github.io/dougong/",
@@ -52,6 +61,6 @@
     "access": "public"
   },
   "scripts": {
-    "build": "vite build"
+    "build": "node ../../tooling/generate-internal.mjs && vite build"
   }
 }

package/runtime/abort-listener.d.mts

@@ -0,0 +1,2 @@
+// Generated from tooling/internal/abort-listener.d.mts. Run pnpm generate:internal.
+export function listenForAbort(signal: AbortSignal, notify: () => void): () => void;

package/runtime/abort-listener.mjs

@@ -0,0 +1,27 @@
+// Generated from tooling/internal/abort-listener.mjs. Run pnpm generate:internal.
+// A separate closure prevents the dependent from retaining the source through its registration.
+function weakAbortListener(reference) {
+  return () => reference.deref()?.();
+}
+
+export function listenForAbort(signal, notify) {
+  const dependent = AbortSignal.any([signal]);
+  const listener = weakAbortListener(new WeakRef(notify));
+  let registration = { signal, notify, dependent, listener };
+  function detach() {
+    if (!registration) return;
+    const attached = registration;
+    registration = undefined;
+    EventTarget.prototype.removeEventListener.call(attached.signal, "abort", attached.notify);
+    attached.dependent.removeEventListener("abort", attached.listener);
+  }
+  try {
+    // Source listeners preserve native composite lifetimes; the private dependent bypasses stopped events.
+    EventTarget.prototype.addEventListener.call(signal, "abort", notify);
+    dependent.addEventListener("abort", listener);
+  } catch (error) {
+    detach();
+    throw error;
+  }
+  return detach;
+}