dougong 0.8.2 → 0.9.0

package/dist/record-CZVpq8vk.js

@@ -0,0 +1,493 @@
+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");
+// src/internal/synchronous-result.ts
+function a(e, t) {
+	let n = o(e);
+	if (n) throw n.then(() => void 0, () => void 0), TypeError(t);
+}
+function o(e) {
+	if (e === null || typeof e != "object" && typeof e != "function") return;
+	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;
+}
+// src/internal/abort.ts
+function s(e) {
+	return Reflect.get(AbortSignal.prototype, "aborted", e);
+}
+function c(e) {
+	return Reflect.get(AbortSignal.prototype, "reason", e);
+}
+function l(t, n) {
+	if (typeof n != "function") throw TypeError("Abort listener must be a function");
+	if (s(t)) return n(c(t)), () => {};
+	let r = {
+		signal: t,
+		callback: n
+	}, i;
+	function a() {
+		r = void 0, i?.(), i = void 0;
+	}
+	function o() {
+		if (!r || !s(r.signal)) return;
+		let { signal: e, callback: t } = r, n = c(e);
+		a(), t(n);
+	}
+	return i = e(t, o), r ? o() : a(), a;
+}
+// src/internal/data-array.ts
+function u(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 d = 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 };
+		r.dependencyPath !== void 0 && (r.dependencyPath = u(r.dependencyPath, "Dependency path")), r.affectedInstallations !== void 0 && (r.affectedInstallations = u(r.affectedInstallations, "Affected Installations")), this.details = Object.freeze(r);
+	}
+};
+function f(e) {
+	return new d("HOST_QUARANTINED", "Host execution is permanently quarantined", { details: {
+		outcome: "quarantined",
+		stateRevision: e
+	} });
+}
+var p = 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 = u(n, "Diagnostic field names");
+		if (r.length > 8 || r.some((e) => typeof e != "string" || !e || e.length > 256)) throw TypeError("Select at most eight diagnostic field names of 1–256 characters each");
+		let i = e.#t(t) ?? m(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 m(e, t, n) {
+	let r = /* @__PURE__ */ new Set(), i = 32, a = (e, o, s = !1) => {
+		let c = s ? e : t(e), l = c ?? e;
+		if (o > 4 || i-- <= 0 || r.has(l)) return Object.freeze({
+			name: "TruncatedError",
+			message: "Error chain truncated",
+			truncated: !0
+		});
+		if (!c && !h(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, 4096),
+				...e.length > 4096 ? { 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 (!g(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", 256) ?? "Error", y = f("message", 4096) ?? "", b = f("stack", 16384), x = f("code", 256), S = v(l, "cause"), C = p(v(l, "errors"), 8), w = (e, t) => {
+			let n = p(e, t);
+			return n && Object.freeze(n.filter((e) => typeof e == "string").map((e) => d(e, 256)));
+		}, T = c?.fields;
+		if (!c && n.size) {
+			let e = [];
+			for (let t of n) {
+				let n = _(l, t), r = typeof n == "string" ? d(n, 256) : w(n, 8);
+				r !== void 0 && e.push([t, r]);
+			}
+			e.length && (T = Object.freeze(Object.fromEntries(e)));
+		}
+		let E = p(v(l, "issues"), 8)?.map((e) => {
+			let t = v(e, "message"), n = p(v(e, "path"), 16)?.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), 256) : "[omitted]";
+			});
+			return Object.freeze({
+				message: typeof t == "string" ? d(t, 4096) : "",
+				...n ? { path: Object.freeze(n) } : {}
+			});
+		}), D = v(l, "details"), O;
+		if (typeof D == "object" && D) {
+			let e = {}, t = v(D, "outcome");
+			(t === "rejected" || t === "restored" || t === "quarantined") && (e.outcome = t);
+			for (let t of [
+				"phase",
+				"installation",
+				"contract"
+			]) {
+				let n = v(D, t);
+				typeof n == "string" && (e[t] = d(n, 256));
+			}
+			for (let t of ["stateRevision", "expectedRevision"]) {
+				let n = v(D, t);
+				typeof n == "number" && Number.isSafeInteger(n) && n >= 0 && (e[t] = n);
+			}
+			for (let t of ["dependencyPath", "affectedInstallations"]) {
+				let n = w(v(D, t), 32);
+				n && (e[t] = n);
+			}
+			O = Object.freeze(e);
+		}
+		return Object.freeze({
+			name: m,
+			message: y,
+			...x === void 0 ? {} : { code: x },
+			...b === void 0 ? {} : { stack: b },
+			...S === void 0 ? {} : { cause: a(S, o + 1, !!c) },
+			...C === void 0 ? {} : { errors: Object.freeze(C.map((e) => a(e, o + 1, !!c))) },
+			...T === void 0 ? {} : { fields: T },
+			...E === void 0 ? {} : { issues: Object.freeze(E) },
+			...O === void 0 ? {} : { details: O },
+			...u ? { truncated: !0 } : {}
+		});
+	};
+	return a(e, 0);
+}
+function h(e) {
+	try {
+		return e instanceof Error;
+	} catch {
+		return !1;
+	}
+}
+function g(e) {
+	try {
+		return Array.isArray(e);
+	} catch {
+		return !1;
+	}
+}
+function _(e, t) {
+	try {
+		return Object.getOwnPropertyDescriptor(e, t)?.value;
+	} catch {
+		return;
+	}
+}
+function v(e, t) {
+	try {
+		return e && typeof e == "object" ? e[t] : void 0;
+	} catch {
+		return;
+	}
+}
+function y(e, t) {
+	try {
+		if (!s(e)) return !1;
+	} catch (e) {
+		throw TypeError("Cancellation classifier expects an AbortSignal", { cause: e });
+	}
+	return Object.is(t, c(e)) ? !0 : h(t) && v(t, "name") === "AbortError";
+}
+var b = class extends d {
+	name = "ConfigurationValidationError";
+	issues;
+	constructor(e, t) {
+		let n = x(e);
+		super("CONFIGURATION_INVALID", `Invalid Plugin configuration:\n${n.map((e) => `  - ${e.message}`).join("\n")}`, t), this.issues = n;
+	}
+};
+function x(e) {
+	return Object.freeze(u(e, "Configuration validation issues").map((e, t) => {
+		if (!e || typeof e != "object") 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: S(i, t) }
+		});
+	}));
+}
+function S(e, t) {
+	return Object.freeze(u(e, `Configuration validation issue at index ${t} path`).map((e, n) => {
+		if (C(e)) return e;
+		if (!e || typeof e != "object") throw TypeError(`Configuration validation issue at index ${t} path segment ${n} must be a property key`);
+		let r = e.key;
+		if (!C(r)) throw TypeError(`Configuration validation issue at index ${t} path segment ${n} must contain a property key`);
+		return Object.freeze({ key: r });
+	}));
+}
+function C(e) {
+	return typeof e == "string" || typeof e == "number" || typeof e == "symbol";
+}
+// src/observation/snapshot-view.ts
+var w = /* @__PURE__ */ new WeakMap(), T = /* @__PURE__ */ new Set(), E = 0, D = !1;
+function O(e) {
+	E++;
+	let t = [];
+	try {
+		a(e(), "Snapshot notification batches must be synchronous");
+	} catch (e) {
+		t.push(e);
+	} finally {
+		if (E--, !E) try {
+			k();
+		} catch (e) {
+			t.push(e);
+		}
+	}
+	if (t.length === 1) throw t[0];
+	if (t.length > 1) throw AggregateError(t, "Snapshot batch failed");
+}
+function k() {
+	if (D) return;
+	D = !0;
+	let e = [];
+	try {
+		for (; T.size;) {
+			let t = T.values().next().value;
+			T.delete(t), M(t, e);
+		}
+	} finally {
+		D = !1, T.clear();
+	}
+	if (e.length) throw AggregateError(e, "Snapshot error reporting failed");
+}
+var A = 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) T.add(e);
+		E || k();
+	}
+	[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) N(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 j(e, t, (e) => {
+			this.#e.delete(e);
+		});
+		return this.#e.add(n), n;
+	}
+	#s(e) {
+		this.#r && O(() => {
+			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 p(e)
+				}), e;
+			} finally {
+				this.#i = !1;
+			}
+		});
+	}
+	#c() {
+		let e = this.#t;
+		if (e.phase === "disposed") throw TypeError("Snapshot publisher is disposed");
+		return e;
+	}
+}, j = class {
+	constructor(e, t, n) {
+		w.set(this, {
+			listener: e,
+			report: t,
+			detach: n
+		}), Object.freeze(this);
+	}
+	[r]() {
+		let e = w.get(this);
+		e && (N(this), e.detach(this));
+	}
+};
+function M(e, t) {
+	let n = w.get(e);
+	if (n) try {
+		let { listener: e } = n;
+		a(e(), "Snapshot subscribers must be synchronous");
+	} catch (e) {
+		try {
+			let { report: t } = n;
+			a(t(e), "Snapshot error reporters must be synchronous");
+		} catch (n) {
+			t.push(e, n);
+		}
+	}
+}
+function N(e) {
+	T.delete(e), w.delete(e);
+}
+// src/contracts/logging.ts
+function P(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 F(e) {
+	try {
+		return P(e), !0;
+	} catch {
+		return !1;
+	}
+}
+var I = 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 d("LIFETIME_DISPOSED", "Logger scope has ended");
+		a(r.logger[e](t, r.metadata, ...n), "Logger methods must be synchronous");
+	}
+}, L = class {
+	#e = /* @__PURE__ */ new Set();
+	#t = !1;
+	get settled() {
+		return this.run(() => 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 {
+				n.resolve(e());
+			} catch (e) {
+				n.reject(e);
+			}
+			return r;
+		}, a = t === void 0 ? void 0 : l(t, (e) => {
+			this.#e.delete(i), n.reject(e);
+		});
+		return t !== void 0 && s(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;
+	}
+};
+// src/internal/record.ts
+function R(e, t, n = {}) {
+	if (!e || typeof e != "object" || Array.isArray(e)) throw z(n, `${t} must be a plain record`);
+	let r = Object.getPrototypeOf(e);
+	if (r !== Object.prototype && r !== null) throw z(n, `${t} must be a plain record`);
+	let i = Object.create(null);
+	for (let r of Reflect.ownKeys(e)) {
+		let a = Reflect.getOwnPropertyDescriptor(e, r);
+		if (typeof r != "string" || !a?.enumerable) throw z(n, `${t} keys must be enumerable strings`);
+		if (!("value" in a)) throw z(n, `${t} field '${r}' must be a data property`);
+		if (n.fields && !n.fields.has(r)) throw z(n, `${t}: unknown field '${r}'`);
+		i[r] = a.value;
+	}
+	return Object.freeze(i);
+}
+function z(e, t) {
+	return e.createError?.(t) ?? TypeError(t);
+}
+export { l as _, F as a, r as b, b as c, y as d, h as f, s as g, c as h, P as i, d as l, u as m, L as n, A as o, f as p, I as r, O as s, R as t, p as u, a as v, i as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dougong",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "type": "module",
   "engines": {
     "node": ">=22"
@@ -8,12 +8,13 @@
   "browserslist": [
     "Chrome >= 119",
     "Edge >= 119",
-    "Firefox >= 121",
+    "Firefox >= 124",
     "Safari >= 17.4"
   ],
   "sideEffects": false,
   "files": [
     "dist",
+    "runtime",
     "README.md",
     "LICENSE"
   ],
@@ -21,14 +22,23 @@
     ".": {
       "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",
+      "node": "./runtime/abort-listener.node.mjs",
+      "default": "./runtime/abort-listener.web.mjs"
     }
   },
   "dependencies": {
-    "@dougongjs/platform": "0.8.2",
-    "@dougongjs/core": "0.8.2",
-    "@dougongjs/reactive": "0.8.2"
+    "@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 +62,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.node.mjs

@@ -0,0 +1,26 @@
+// Generated from tooling/internal/abort-listener.node.mjs. Run pnpm generate:internal.
+import { addAbortListener } from "node:events";
+
+export function listenForAbort(signal, notify) {
+  // Node supplies stop-resistant listener options to this private registration signal.
+  // The caller's genuine EventTarget owns the actual listener and its native GC bookkeeping.
+  const registration = new AbortController().signal;
+  let detach;
+  registration.addEventListener = (type, listener, options) => {
+    detach = () => EventTarget.prototype.removeEventListener.call(signal, type, listener);
+    try {
+      // Only native cancellation may consume the listener. Synthetic abort events can arrive first.
+      EventTarget.prototype.addEventListener.call(signal, type, listener, {
+        ...options,
+        once: false,
+      });
+    } catch (error) {
+      // A native listener hook may throw before or after insertion.
+      detach();
+      throw error;
+    }
+  };
+  addAbortListener(registration, notify);
+  if (!detach) throw new Error("Node did not attach the protected abort listener");
+  return detach;
+}

package/runtime/abort-listener.web.mjs

@@ -0,0 +1,7 @@
+// Generated from tooling/internal/abort-listener.web.mjs. Run pnpm generate:internal.
+// Only the controller can abort this private dependent; other listeners can stop propagation on the source.
+export function listenForAbort(signal, notify) {
+  const dependent = AbortSignal.any([signal]);
+  dependent.addEventListener("abort", notify);
+  return () => dependent.removeEventListener("abort", notify);
+}