@graphvideo/kernel 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1104 @@
+//#region kernel/src/observation.ts
+var e = 2, t = {
+	now: () => Date.now(),
+	monotonicNow: () => typeof performance < "u" ? performance.now() : Date.now()
+}, n = { next: () => Math.random() }, r = class {
+	clock;
+	randomSource;
+	counter = 0;
+	constructor(e = t, r = n) {
+		this.clock = e, this.randomSource = r;
+	}
+	nextId(e) {
+		return `${e}-${this.clock.now()}-${++this.counter}-${Math.floor(this.randomSource.next() * 65536).toString(16).padStart(4, "0")}`;
+	}
+}, i = class {
+	defaultOptions;
+	constructor(e = {}) {
+		this.defaultOptions = e;
+	}
+	encode(e, t = {}) {
+		let n = {
+			...this.defaultOptions,
+			...t
+		};
+		return this._encodeValue(e, n.maxDepth ?? 8, n.rootPath ?? [], n);
+	}
+	_encodeValue(e, t, n, r) {
+		if (e == null) return {
+			$type: "primitive",
+			value: e
+		};
+		let i = typeof e;
+		if (i === "string" || i === "number" || i === "boolean") return {
+			$type: "primitive",
+			value: e
+		};
+		if (i === "bigint" || i === "symbol" || i === "function") return {
+			$type: "ref",
+			kind: i,
+			summary: String(e)
+		};
+		if (t <= 0) return {
+			$type: "truncated",
+			originalType: i,
+			summary: "[Max Depth Reached]"
+		};
+		if (e instanceof Map) {
+			let i = [];
+			for (let [a, o] of e.entries()) i.push([this._encodeValue(a, t - 1, [...n, String(a)], r), this._encodeValue(o, t - 1, [...n, String(a)], r)]);
+			return {
+				$type: "map",
+				entries: i
+			};
+		}
+		if (e instanceof Set) return {
+			$type: "set",
+			values: Array.from(e.values()).map((e, i) => this._encodeValue(e, t - 1, [...n, String(i)], r))
+		};
+		if (Array.isArray(e)) {
+			let i = r.maxArrayLength ?? 100;
+			return {
+				$type: "array",
+				value: e.slice(0, i).map((e, i) => this._encodeValue(e, t - 1, [...n, String(i)], r))
+			};
+		}
+		if (e instanceof Uint8Array || typeof Buffer < "u" && Buffer.isBuffer(e)) return {
+			$type: "bytes",
+			value: typeof Buffer < "u" ? Buffer.from(e).toString("base64") : "",
+			byteLength: e.byteLength
+		};
+		if (i === "object") {
+			let i = {}, a = e, o = Object.keys(a);
+			for (let e of o) i[e] = r.redactedKeys?.includes(e) ? {
+				$type: "ref",
+				kind: "redacted",
+				summary: "[REDACTED]"
+			} : this._encodeValue(a[e], t - 1, [...n, e], r);
+			return {
+				$type: "object",
+				value: i
+			};
+		}
+		return {
+			$type: "primitive",
+			value: String(e)
+		};
+	}
+	decode(e) {
+		if (!e || typeof e != "object") return e;
+		switch (e.$type) {
+			case "primitive": return e.value;
+			case "array": return e.value.map((e) => this.decode(e));
+			case "map": {
+				let t = /* @__PURE__ */ new Map();
+				for (let [n, r] of e.entries) t.set(this.decode(n), this.decode(r));
+				return t;
+			}
+			case "set": {
+				let t = /* @__PURE__ */ new Set();
+				for (let n of e.values) t.add(this.decode(n));
+				return t;
+			}
+			case "object": {
+				let t = {};
+				for (let [n, r] of Object.entries(e.value)) t[n] = this.decode(r);
+				return t;
+			}
+			case "bytes": return typeof Buffer < "u" ? Buffer.from(e.value, "base64") : e.value;
+			case "ref":
+			case "truncated": return e.summary;
+			default: return e;
+		}
+	}
+}, a = new i();
+function o(e) {
+	let t = 2166136261;
+	for (let n = 0; n < e.length; n++) t ^= e.charCodeAt(n), t += (t << 1) + (t << 4) + (t << 7) + (t << 8) + (t << 24);
+	return `fnv1a32:${(t >>> 0).toString(16).padStart(8, "0")}`;
+}
+var s = class {
+	events = [];
+	append(e) {
+		this.events.push(e);
+	}
+	getEvents() {
+		return [...this.events];
+	}
+	clear() {
+		this.events = [];
+	}
+}, c = class {
+	traceId;
+	runId;
+	idProvider;
+	clock;
+	traceStore;
+	sequence = 0;
+	events = [];
+	records = [];
+	constructor(e, t, n, r, i) {
+		this.traceId = e, this.runId = t, this.idProvider = n, this.clock = r, this.traceStore = i;
+	}
+	record(e) {
+		let t = {
+			schemaVersion: 2,
+			traceId: this.traceId,
+			runId: this.runId,
+			eventId: this.idProvider.nextId("event"),
+			sequence: ++this.sequence,
+			timestamp: this.clock.now(),
+			...e
+		};
+		if (this.events.push(t), this.traceStore) try {
+			this.traceStore.append(t);
+		} catch {}
+		return t;
+	}
+	recordChange(e) {
+		this.records.push(e);
+	}
+};
+function l(e, t) {
+	if (typeof e != "object" || !e || e.$type !== "object") throw Error("StateDelta 只能应用到对象 State Snapshot");
+	let n = { ...e.value };
+	for (let e of t) {
+		let t = n[e.field];
+		if (JSON.stringify(t) !== JSON.stringify(e.before)) throw Error(`StateDelta 基线不匹配: ${e.field}#${e.ordinal}`);
+		n[e.field] = e.after;
+	}
+	return {
+		$type: "object",
+		value: n
+	};
+}
+//#endregion
+//#region kernel/src/internal-access.ts
+var u = Symbol("node-runtime-capability"), d = Symbol("change-context-capability"), f = class {
+	node;
+	rawInfo;
+	changeId;
+	envelope;
+	signal;
+	reads = /* @__PURE__ */ new Set();
+	writes = /* @__PURE__ */ new Set();
+	spans = [];
+	stateDeltas = [];
+	traceValues = /* @__PURE__ */ new Map();
+	constructor(e, t, n, r, i) {
+		this.node = e, this.rawInfo = t, this.changeId = n, this.envelope = r, this.signal = i;
+		let a = e.getState();
+		if (a && typeof a == "object") for (let e of Object.keys(a)) this.traceValues.set(e, this.node.encodeTraceValue(e, a[e]));
+	}
+	read(e) {
+		this.signal?.throwIfAborted();
+		let t = String(e);
+		return this.reads.add(t), this.node.getState()[e];
+	}
+	write(e, t) {
+		this.signal?.throwIfAborted();
+		let n = String(e);
+		this.writes.add(n);
+		let r = this.traceValues.get(n) ?? this.node.encodeTraceValue(n, void 0), i = this.node.encodeTraceValue(n, t);
+		this.node.commitStateFromChange(d, this.changeId, { [e]: t }, this.rawInfo), this.traceValues.set(n, i), this.stateDeltas.push({
+			ordinal: this.stateDeltas.length + 1,
+			field: n,
+			before: r,
+			after: i
+		});
+	}
+	patchState(e) {
+		this.signal?.throwIfAborted();
+		let t = Object.keys(e);
+		for (let e of t) this.writes.add(e);
+		let n = new Map(t.map((e) => [e, this.traceValues.get(e) ?? this.node.encodeTraceValue(e, void 0)])), r = new Map(t.map((t) => [t, this.node.encodeTraceValue(t, e[t])]));
+		this.node.commitStateFromChange(d, this.changeId, e, this.rawInfo);
+		for (let e of t) {
+			let t = r.get(e);
+			this.traceValues.set(e, t), this.stateDeltas.push({
+				ordinal: this.stateDeltas.length + 1,
+				field: e,
+				before: n.get(e),
+				after: t
+			});
+		}
+	}
+	send(e, t) {
+		if (this.signal?.throwIfAborted(), !t) return;
+		let n = this.node.runtimeId("info");
+		this.node._sendFromChange(d, e, t, {
+			infoId: n,
+			causedByChangeId: this.changeId,
+			causeInfoId: this.envelope?.infoId,
+			submissionId: this.envelope?.submissionId,
+			signal: this.signal
+		});
+	}
+	async effectAdapter(e, t, n = {}) {
+		if (this.signal?.throwIfAborted(), !this.node.isWorldNode) throw Error(`[Architecture Violation]: Pure domain node "${this.node.name}" (${this.node.id}) cannot execute physical effect! Side effects are strictly restricted to World nodes.`);
+		if (!e.id.trim()) throw Error("EffectAdapter id 不能为空");
+		let r = n.signal ?? this.signal;
+		r?.throwIfAborted();
+		let i = this.node.runtimeValueRef("effect-request", t), a = e.id, o = this.node.runtimeId("effect");
+		this.node.recordEffectRequested({
+			effectId: o,
+			changeId: this.changeId,
+			nodeId: this.node.id,
+			name: a,
+			adapterId: e.id,
+			requestRef: i
+		});
+		try {
+			let n = await e.execute(t, {
+				clock: {
+					now: () => this.node.runtimeNow(),
+					monotonicNow: () => this.node.runtimeMonotonicNow()
+				},
+				signal: r
+			});
+			r?.throwIfAborted();
+			let s = this.node.runtimeValueRef("effect-observation", n);
+			return this.node.recordEffectObserved({
+				effectId: o,
+				changeId: this.changeId,
+				nodeId: this.node.id,
+				name: a,
+				status: "succeeded",
+				adapterId: e.id,
+				requestRef: i,
+				observationRef: s
+			}), n;
+		} catch (t) {
+			throw this.node.recordEffectObserved({
+				effectId: o,
+				changeId: this.changeId,
+				nodeId: this.node.id,
+				name: a,
+				status: "failed",
+				adapterId: e.id,
+				requestRef: i
+			}), t;
+		}
+	}
+	async span(e, t) {
+		this.signal?.throwIfAborted();
+		let n = this.node.runtimeMonotonicNow(), r = this.node.runtimeNow();
+		try {
+			let i = await t(), a = this.node.runtimeMonotonicNow() - n;
+			return this.spans.push({
+				name: e,
+				durationMs: a,
+				timestamp: r
+			}), i;
+		} catch (t) {
+			let i = this.node.runtimeMonotonicNow() - n;
+			throw this.spans.push({
+				name: `${e}:failed`,
+				durationMs: i,
+				timestamp: r
+			}), t;
+		}
+	}
+}, p = new r(t, n);
+function m(e) {
+	if (e.reason instanceof Error) return e.reason;
+	if (e.reason && typeof e.reason == "object") {
+		let t = e.reason;
+		if (typeof t.message == "string") {
+			let e = Error(t.message);
+			return typeof t.name == "string" && (e.name = t.name), e;
+		}
+	}
+	let t = Error(typeof e.reason == "string" ? e.reason : "Graph execution canceled");
+	return t.name = "AbortError", t;
+}
+var h = class {
+	id;
+	name;
+	factoryKey;
+	isWorldNode = !1;
+	status = "IDLE";
+	executionCount = 0;
+	lastActiveTime = 0;
+	lastErrorMessage = null;
+	state;
+	regionVersions = /* @__PURE__ */ new Map();
+	globalVersion = 0;
+	mailbox = [];
+	drainingMailbox = !1;
+	activeChangeId;
+	disposers = /* @__PURE__ */ new Set();
+	abortController = new AbortController();
+	kernel = null;
+	constructor(e, t, n = {}, r) {
+		this.id = e, this.name = t, this.factoryKey = r || e, this.state = { ...n };
+	}
+	getState() {
+		return this.state;
+	}
+	getStateRegionVersions() {
+		return Object.fromEntries(this.regionVersions.entries());
+	}
+	getGlobalStateVersion() {
+		return this.globalVersion;
+	}
+	getMailboxSize() {
+		return this.mailbox.length;
+	}
+	getActiveChangeId() {
+		return this.activeChangeId;
+	}
+	_restoreStateSnapshot(e, t, n) {
+		if (e !== u) throw Error("[Kernel]: Invalid runtime capability");
+		if (t.nodeId !== this.id) throw Error(`State Snapshot 节点不匹配: 期望 ${this.id}，实际 ${t.nodeId}`);
+		this.state = n, this.globalVersion = t.globalVersion, this.regionVersions = new Map(Object.entries(t.regionVersions || {}));
+	}
+	_mountKernel(e, t) {
+		if (e !== u) throw Error("[Kernel]: Invalid runtime capability");
+		if (this.kernel && this.kernel !== t) throw Error(`[Kernel]: Node "${this.name}" (${this.id}) 已挂载到其他 Runtime`);
+		this.kernel = t;
+	}
+	_unmountKernel(e, t) {
+		if (e !== u) throw Error("[Kernel]: Invalid runtime capability");
+		this.kernel === t && (this.kernel = null);
+	}
+	_enqueueMailbox(e, t, n, r = {}) {
+		return e === u ? new Promise((e, i) => {
+			this.mailbox.push({
+				info: t,
+				envelope: n,
+				options: r,
+				resolve: e,
+				reject: i
+			});
+		}) : Promise.reject(/* @__PURE__ */ Error("[Kernel]: Invalid runtime capability"));
+	}
+	async _drainMailbox(e) {
+		if (e !== u) throw Error("[Kernel]: Invalid runtime capability");
+		if (!this.drainingMailbox) {
+			this.drainingMailbox = !0;
+			try {
+				for (; this.mailbox.length > 0;) {
+					let e = this.mailbox.shift();
+					try {
+						if (e.options.signal?.aborted) {
+							e.reject(m(e.options.signal));
+							continue;
+						}
+						await this.runWithinChangeContext(e.info, e.envelope, e.options), e.resolve();
+					} catch (t) {
+						e.reject(t);
+					}
+				}
+			} finally {
+				this.drainingMailbox = !1;
+			}
+		}
+	}
+	async runWithinChangeContext(e, t, n = {}) {
+		if (this.activeChangeId) throw Error(`[Single-Flight Violation]: 节点 "${this.name}" (${this.id}) 正在运行变迁 ${this.activeChangeId}，严禁并发执行 change`);
+		let r = this.runtimeId("change");
+		this.activeChangeId = r;
+		let i = this.globalVersion, a = t?.infoId || this.runtimeId("info-root"), o = e.type || "Info";
+		this.recordChangeStarted({
+			changeId: r,
+			nodeId: this.id,
+			causeInfoId: a,
+			causeInfoType: o,
+			stateVersionBefore: i
+		}), this.kernel?.beginChangeExecution?.(r);
+		let s = this.createChangeContext(e, r, t, n.signal), c = this.runtimeMonotonicNow(), l = this.runtimeNow();
+		this.status = "RUNNING";
+		try {
+			await this.change(e, s), s.stateDeltas.length > 0 && this.kernel?.traceSession?.record?.({
+				type: "StateDeltaCommitted",
+				changeId: r,
+				nodeId: this.id,
+				stateVersionAfter: this.globalVersion,
+				deltas: s.stateDeltas
+			}), this.status = "IDLE", this.executionCount++, this.lastActiveTime = this.runtimeNow();
+			let n = {
+				changeId: r,
+				nodeId: this.id,
+				causeInfoId: a,
+				causeInfoType: o,
+				causedByChangeId: t?.causedByChangeId,
+				stateVersionBefore: i,
+				stateVersionAfter: this.globalVersion,
+				reads: Array.from(s.reads),
+				writes: Array.from(s.writes),
+				stateDeltas: s.stateDeltas,
+				spans: s.spans,
+				durationMs: this.runtimeMonotonicNow() - c,
+				timestamp: l
+			};
+			this.recordChange(n);
+		} catch (e) {
+			let u = n.signal?.aborted || e?.name === "AbortError" || typeof e?.message == "string" && e.message.toLowerCase().includes("abort");
+			this.status = u ? "ABORTED" : "ERROR", this.lastErrorMessage = e?.message || String(e);
+			let d = {
+				changeId: r,
+				nodeId: this.id,
+				causeInfoId: a,
+				causeInfoType: o,
+				causedByChangeId: t?.causedByChangeId,
+				stateVersionBefore: i,
+				stateVersionAfter: this.globalVersion,
+				reads: Array.from(s.reads),
+				writes: Array.from(s.writes),
+				stateDeltas: s.stateDeltas,
+				spans: s.spans,
+				durationMs: this.runtimeMonotonicNow() - c,
+				timestamp: l,
+				error: this.lastErrorMessage || void 0
+			};
+			throw this.recordChange(d), e;
+		} finally {
+			this.kernel?.endChangeExecution?.(r), this.activeChangeId = void 0;
+		}
+	}
+	createChangeContext(e, t, n, r) {
+		return new f(this, e, t, n, r);
+	}
+	get stateVersion() {
+		return this.globalVersion;
+	}
+	commitStateFromChange(e, t, n, r) {
+		if (e !== d) throw Error(`[State Write Violation]: Node ${this.id} 拒绝非 ChangeContext 写入`);
+		if (!this.activeChangeId || this.activeChangeId !== t) throw Error(`[State Write Violation]: Node ${this.id} 只能在 change context 内提交 State`);
+		let i = r?.type || "change";
+		this.regionVersions.set(i, (this.regionVersions.get(i) || 0) + 1), this.globalVersion += 1, this.state = {
+			...this.state,
+			...n
+		};
+	}
+	_sendFromChange(e, t, n, r) {
+		if (e !== d) throw Error(`[Send Violation]: Node ${this.id} 拒绝非 ChangeContext 发信`);
+		if (!this.activeChangeId || r?.causedByChangeId !== this.activeChangeId) throw Error(`[Send Violation]: Node ${this.id} 只能通过当前 change context 发信`);
+		if (!this.kernel) throw Error(`[Kernel]: Node "${this.name}" (${this.id}) 尚未挂载，无法发信`);
+		this.kernel._deliverSendFromChange(this, t, n, r);
+	}
+	change(e, t) {}
+	runtimeNow() {
+		return this.kernel?.now?.() ?? t.now();
+	}
+	runtimeMonotonicNow() {
+		return this.kernel?.monotonicNow?.() ?? t.monotonicNow();
+	}
+	runtimeId(e) {
+		return this.kernel?.nextId?.(e) ?? p.nextId(e);
+	}
+	encodeTraceValue(e, t) {
+		return this.kernel?.encodeTraceValue?.(this.id, e, t) ?? {
+			$type: "primitive",
+			value: t ?? null
+		};
+	}
+	runtimeValueRef(e, t) {
+		return this.kernel?.recordValueRef?.(e, t) ?? `${e}:${this.runtimeId("effect")}`;
+	}
+	recordChangeStarted(e) {
+		this.kernel?.recordChangeStarted?.(e);
+	}
+	recordChange(e) {
+		this.kernel?.recordChange?.(e);
+	}
+	recordEffectRequested(e) {
+		this.kernel?.recordEffectRequested?.(e);
+	}
+	recordEffectObserved(e) {
+		this.kernel?.recordEffectObserved?.(e);
+	}
+	onMount() {}
+	onUnmount() {}
+	registerDisposer(e) {
+		this.disposers.add(e);
+	}
+	async dispose() {
+		this.abort();
+		for (let e of this.disposers) try {
+			await e();
+		} catch (e) {
+			console.error(`[Node ${this.id}] Disposer failed:`, e);
+		}
+		this.disposers.clear(), this.onUnmount(), this.status = "IDLE";
+	}
+	abort(e) {
+		this.abortController.abort(e), this.status = "ABORTED", this.lastErrorMessage = e || "Execution aborted", this.abortController = new AbortController();
+	}
+	reset() {
+		this.status = "IDLE", this.lastErrorMessage = null, this.mailbox.length = 0;
+	}
+}, g = class extends h {
+	isWorldNode = !0;
+};
+//#endregion
+//#region kernel/src/scheduler.ts
+function _(e) {
+	if (e.reason instanceof Error) return e.reason;
+	let t = Error(typeof e.reason == "string" ? e.reason : "等待 Kernel 静止已取消");
+	return t.name = "AbortError", t;
+}
+function v(e) {
+	return {
+		pendingDeliveries: e.pendingDeliveryCount,
+		activeChanges: e.activeChangeIds.size,
+		scheduledGraphMicrotasks: e.scheduledGraphMicrotaskCount,
+		isQuiescent: e.pendingDeliveryCount === 0 && e.activeChangeIds.size === 0 && e.scheduledGraphMicrotaskCount === 0
+	};
+}
+function y(e, t) {
+	return e.schedulerListeners.add(t), () => {
+		e.schedulerListeners.delete(t);
+	};
+}
+function b(e) {
+	let t = v(e);
+	for (let n of e.schedulerListeners) try {
+		n(t);
+	} catch {}
+}
+function x(e, t) {
+	return e.scheduledGraphMicrotaskCount += 1, b(e), new Promise((n, r) => {
+		queueMicrotask(async () => {
+			try {
+				n(await t());
+			} catch (e) {
+				r(e);
+			} finally {
+				--e.scheduledGraphMicrotaskCount, b(e);
+			}
+		});
+	});
+}
+async function S(e, t = {}) {
+	for (;;) {
+		if (t.signal?.aborted) throw _(t.signal);
+		let n = v(e);
+		if (n.isQuiescent) return n;
+		await new Promise((n, r) => {
+			let i = () => void 0, a = y(e, (e) => {
+				e.isQuiescent && (i(), n());
+			}), o = () => {
+				i(), r(_(t.signal));
+			};
+			i = () => {
+				a(), t.signal?.removeEventListener("abort", o);
+			}, t.signal?.addEventListener("abort", o, { once: !0 }), t.signal?.aborted && o();
+		});
+	}
+}
+//#endregion
+//#region kernel/src/delivery.ts
+function C(e, t, n, r, i) {
+	e.ensureInitialStateSnapshot();
+	let a = typeof r == "string" ? e.nodes.get(r) : r;
+	if (!a) {
+		console.warn(`[Kernel]: Target node "${String(r)}" not found for send from "${t.name}" (${t.id})`);
+		return;
+	}
+	let o = e.now(), s = i?.infoId ?? e.nextId("info");
+	e.logicalClock++;
+	let c = {
+		infoId: s,
+		senderNodeId: t.id,
+		targetNodeId: a.id,
+		causedByChangeId: i?.causedByChangeId,
+		causeInfoId: i?.causeInfoId,
+		submissionId: i?.submissionId,
+		sequence: e.logicalClock,
+		timestamp: o,
+		payload: n
+	};
+	e.envelopes.length >= 1e3 && e.envelopes.shift(), e.envelopes.push(c), c.causedByChangeId && e.traceSession.record({
+		type: "InfoEmitted",
+		envelope: c
+	}), e.traceSession.record({
+		type: "InfoDelivered",
+		envelope: c
+	}), T(e, a, n, c, { signal: i?.signal });
+}
+function w(e, t, n, r = {}) {
+	r.signal?.throwIfAborted(), e.ensureInitialStateSnapshot();
+	let i = e.now(), a = {
+		infoId: e.nextId("info-root"),
+		senderNodeId: "external-root",
+		targetNodeId: t.id,
+		submissionId: r.submissionId,
+		sequence: ++e.logicalClock,
+		timestamp: i,
+		payload: n
+	};
+	e.envelopes.length >= 1e3 && e.envelopes.shift(), e.envelopes.push(a), e.traceSession.record({
+		type: "InfoDelivered",
+		envelope: a
+	}), T(e, t, n, a, { signal: r?.signal });
+}
+function T(e, t, n, r, i) {
+	e.trackSubmissionDeliveryEnqueued(r.submissionId), e.pendingDeliveryCount += 1, e.publishSchedulerState(), t._enqueueMailbox(u, n, r, i).then(() => D(e, r.submissionId), (t) => D(e, r.submissionId, t)), E(e, t);
+}
+function E(e, t) {
+	e.scheduledMailboxNodeIds.has(t.id) || (e.scheduledMailboxNodeIds.add(t.id), queueMicrotask(async () => {
+		try {
+			await t._drainMailbox(u);
+		} finally {
+			e.scheduledMailboxNodeIds.delete(t.id), t.getMailboxSize() > 0 && E(e, t);
+		}
+	}));
+}
+function D(e, t, n) {
+	e.pendingDeliveryCount = Math.max(0, e.pendingDeliveryCount - 1), e.trackSubmissionDeliverySettled(t, n), e.publishSchedulerState();
+}
+//#endregion
+//#region kernel/src/snapshot.ts
+function O(e, t = "manual", n) {
+	let r = (n ? n.map((t) => {
+		let n = e.nodes.get(t);
+		if (!n) throw Error(`State Snapshot 找不到 Node: ${t}`);
+		return n;
+	}) : [...e.nodes.values()]).sort((e, t) => e.id.localeCompare(t.id)), i = {
+		snapshotId: e.nextId("snapshot"),
+		traceId: e.traceSession.traceId,
+		runId: e.traceSession.runId,
+		capturedAt: e.now(),
+		reason: t,
+		nodes: r.map((t) => ({
+			nodeId: t.id,
+			factoryKey: t.factoryKey,
+			state: e.valueCodec.encode(t.getState(), {
+				...e.valueCodecOptions,
+				rootPath: [t.id, "$state"]
+			}),
+			globalVersion: t.getGlobalStateVersion(),
+			regionVersions: { ...t.getStateRegionVersions() }
+		}))
+	};
+	return e.traceSession.record({
+		type: "StateSnapshotCaptured",
+		snapshot: i
+	}), i;
+}
+function k(e, t) {
+	let n = t.nodes.map((t) => {
+		let n = e.nodes.get(t.nodeId);
+		if (!n) throw Error(`State Snapshot 找不到已挂载 Node: ${t.nodeId}`);
+		if (n.factoryKey !== t.factoryKey) throw Error(`State Snapshot 工厂不匹配: ${n.id} 期望 ${n.factoryKey}，实际 ${t.factoryKey}`);
+		if (!Number.isSafeInteger(t.globalVersion) || t.globalVersion < 0) throw Error(`State Snapshot globalVersion 非法: ${n.id}`);
+		for (let [e, r] of Object.entries(t.regionVersions)) if (!e || !Number.isSafeInteger(r) || r < 0) throw Error(`State Snapshot regionVersion 非法: ${n.id}.${e}`);
+		return {
+			node: n,
+			nodeSnapshot: t,
+			state: e.valueCodec.decode(t.state)
+		};
+	});
+	for (let e of n) e.node._restoreStateSnapshot(u, e.nodeSnapshot, e.state);
+	e.traceSession.record({
+		type: "StateSnapshotRestored",
+		snapshotId: t.snapshotId,
+		nodeIds: n.map(({ node: e }) => e.id)
+	});
+}
+//#endregion
+//#region kernel/src/runtime.ts
+function A(e) {
+	return e instanceof Error ? e : Error(String(e));
+}
+var j = class {
+	nodes = /* @__PURE__ */ new Map();
+	envelopes = [];
+	probes = [];
+	clock;
+	idProvider;
+	randomSource;
+	valueCodec;
+	valueCodecOptions;
+	traceStore;
+	traceSession;
+	logicalClock = 0;
+	pendingDeliveryCount = 0;
+	activeChangeIds = /* @__PURE__ */ new Set();
+	scheduledGraphMicrotaskCount = 0;
+	schedulerListeners = /* @__PURE__ */ new Set();
+	scheduledMailboxNodeIds = /* @__PURE__ */ new Set();
+	projectionListeners = /* @__PURE__ */ new Set();
+	projectionRevision = 0;
+	submissions = /* @__PURE__ */ new Map();
+	captureInitialStateSnapshot = !0;
+	initialStateSnapshotCaptured = !1;
+	isDisposed = !1;
+	constructor(e = {}) {
+		this.clock = e.clock ?? t, this.randomSource = e.randomSource ?? n, this.idProvider = e.idProvider ?? new r(this.clock, this.randomSource), this.valueCodec = e.valueCodec ?? a, this.valueCodecOptions = e.valueCodecOptions ?? {}, this.traceStore = e.traceStore, this.captureInitialStateSnapshot = e.stateSnapshots?.captureInitial ?? !0;
+		let i = this.idProvider.nextId("trace"), o = this.idProvider.nextId("run");
+		this.traceSession = new c(i, o, this.idProvider, this.clock, this.traceStore), this.traceSession.record({
+			type: "TraceStarted",
+			runtimeVersion: "2.0.0-in-process"
+		});
+	}
+	now() {
+		return this.clock.now();
+	}
+	monotonicNow() {
+		return this.clock.monotonicNow();
+	}
+	nextId(e) {
+		return this.idProvider.nextId(e);
+	}
+	mount(...e) {
+		for (let t of e) {
+			if (!t.id) throw Error("挂载节点必须具有非空 id");
+			if (this.nodes.has(t.id)) throw Error(`不能挂载重复的 Node ID: ${t.id}`);
+			this.nodes.set(t.id, t), t._mountKernel(u, this), t.onMount();
+		}
+		return this.traceSession.record({
+			type: "GraphMounted",
+			nodeIds: e.map((e) => e.id),
+			nodeFactories: Object.fromEntries(e.map((e) => [e.id, e.factoryKey]))
+		}), this;
+	}
+	unmount(...e) {
+		for (let t of e) {
+			let e = this.nodes.get(t);
+			e && (e._unmountKernel(u, this), e.onUnmount(), this.nodes.delete(t));
+		}
+		return this;
+	}
+	getNode(e) {
+		return this.nodes.get(e);
+	}
+	getNodes() {
+		return Array.from(this.nodes.values());
+	}
+	_deliverSendFromChange(e, t, n, r) {
+		C(this, e, t, n, r);
+	}
+	injectRootInfo(e, t, n = {}) {
+		let r = n.submissionId ?? this.nextId("submission"), i = this.createSubmission(r, n.signal);
+		try {
+			w(this, e, t, {
+				signal: i.controller.signal,
+				submissionId: r
+			});
+		} catch (e) {
+			throw i.failure = A(e), this.settleSubmissionIfComplete(i), e;
+		}
+		return r;
+	}
+	async inject(e) {
+		let t = this.getNode(e.targetNodeId);
+		if (!t) return {
+			status: "rejected",
+			submissionId: e.submissionId,
+			reason: `Target node not found: ${e.targetNodeId}`
+		};
+		try {
+			this.injectRootInfo(t, e.info, {
+				signal: e.signal,
+				submissionId: e.submissionId
+			});
+		} catch (t) {
+			return {
+				status: "rejected",
+				submissionId: e.submissionId,
+				reason: A(t).message
+			};
+		}
+		return {
+			status: "accepted",
+			submissionId: e.submissionId
+		};
+	}
+	cancel(e) {
+		let t = this.submissions.get(e);
+		if (!t || t.settled || t.cancelled) return !1;
+		t.cancelled = !0;
+		let n = /* @__PURE__ */ Error(`Submission cancelled: ${e}`);
+		return n.name = "AbortError", t.controller.abort(n), this.settleSubmissionIfComplete(t), !0;
+	}
+	async waitForSubmission(e) {
+		let t = this.submissions.get(e);
+		if (!t) throw Error(`Submission not found: ${e}`);
+		let n = await t.completion;
+		if (n.status !== "completed") throw n.error;
+	}
+	trackSubmissionDeliveryEnqueued(e) {
+		if (!e) return;
+		let t = this.submissions.get(e);
+		if (!t || t.settled) throw Error(`Submission delivery has no active scope: ${e}`);
+		t.pendingDeliveries += 1;
+	}
+	trackSubmissionDeliverySettled(e, t) {
+		if (!e) return;
+		let n = this.submissions.get(e);
+		n && !n.settled && (t && !n.failure && (n.failure = A(t), n.controller.abort(n.failure)), n.pendingDeliveries = Math.max(0, n.pendingDeliveries - 1), this.settleSubmissionIfComplete(n));
+	}
+	snapshot() {
+		return this.captureStateSnapshot("manual");
+	}
+	publishSchedulerState() {
+		b(this), this.publishProjection();
+	}
+	readProjection() {
+		let e = [];
+		for (let t of this.nodes.values()) e.push({
+			nodeId: t.id,
+			state: this.valueCodec.encode(t.getState(), {
+				...this.valueCodecOptions,
+				maxDepth: Infinity,
+				maxArrayLength: Infinity,
+				rootPath: [t.id, "$projection"]
+			}),
+			version: t.getGlobalStateVersion(),
+			status: t.status
+		});
+		let t = this.getSchedulerSnapshot();
+		return {
+			revision: this.projectionRevision,
+			scheduler: {
+				pendingDeliveries: t.pendingDeliveries,
+				activeChanges: t.activeChanges,
+				scheduledGraphMicrotasks: t.scheduledGraphMicrotasks
+			},
+			nodes: e
+		};
+	}
+	subscribeProjection(e) {
+		return this.projectionListeners.add(e), () => {
+			this.projectionListeners.delete(e);
+		};
+	}
+	publishProjection() {
+		this.projectionRevision++;
+		let e = this.readProjection();
+		for (let t of this.projectionListeners) try {
+			t(e);
+		} catch (e) {
+			console.error("[KernelRuntime] Projection listener error:", e);
+		}
+	}
+	getSchedulerSnapshot() {
+		return v(this);
+	}
+	subscribeScheduler(e) {
+		return y(this, e);
+	}
+	scheduleMicrotask(e) {
+		return x(this, e);
+	}
+	waitForQuiescence(e = {}) {
+		return S(this, e);
+	}
+	captureStateSnapshot(e = "manual", t) {
+		let n = O(this, e, t);
+		return e === "initial" && (this.initialStateSnapshotCaptured = !0), n;
+	}
+	restoreStateSnapshot(e) {
+		k(this, e);
+	}
+	ensureInitialStateSnapshot() {
+		this.captureInitialStateSnapshot && !this.initialStateSnapshotCaptured && this.captureStateSnapshot("initial");
+	}
+	encodeTraceValue(e, t, n) {
+		return this.valueCodec.encode(n, {
+			...this.valueCodecOptions,
+			rootPath: [e, t]
+		});
+	}
+	recordValueRef(e, t) {
+		let n = this.valueCodec.encode(t, {
+			...this.valueCodecOptions,
+			maxBytes: 1024,
+			rootPath: ["ref", e]
+		});
+		return `${e}:${o(JSON.stringify(n))}`;
+	}
+	beginChangeExecution(e) {
+		this.activeChangeIds.add(e), this.publishSchedulerState();
+	}
+	endChangeExecution(e) {
+		this.activeChangeIds.delete(e), this.publishSchedulerState();
+	}
+	recordChangeStarted(e) {
+		this.traceSession.record({
+			type: "ChangeStarted",
+			...e
+		});
+	}
+	get causalRecords() {
+		return this.traceSession.records;
+	}
+	get events() {
+		return this.traceSession.events;
+	}
+	recordChange(e) {
+		this.traceSession.recordChange(e), this.traceSession.record({
+			type: "ChangeCompleted",
+			record: e
+		});
+		for (let t of this.probes) try {
+			t.onChangeRecord?.(e);
+		} catch {}
+	}
+	recordEffectRequested(e) {
+		this.traceSession.record({
+			type: "EffectRequested",
+			...e
+		});
+	}
+	recordEffectObserved(e) {
+		this.traceSession.record({
+			type: "EffectObserved",
+			...e
+		});
+	}
+	addProbe(e) {
+		return this.probes.push(e), this;
+	}
+	removeProbe(e) {
+		let t = this.probes.indexOf(e);
+		return t !== -1 && this.probes.splice(t, 1), this;
+	}
+	async dispose() {
+		if (!this.isDisposed) {
+			this.isDisposed = !0;
+			for (let e of this.submissions.values()) e.settled || this.cancel(e.id);
+			for (let e of this.nodes.values()) try {
+				await e.dispose();
+			} catch (t) {
+				console.error(`[KernelRuntime]: Failed to dispose node ${e.id}:`, t);
+			}
+			this.nodes.clear(), this.schedulerListeners.clear(), this.projectionListeners.clear(), this.probes.length = 0, this.traceSession.record({
+				type: "TraceCompleted",
+				status: "completed"
+			});
+		}
+	}
+	createSubmission(e, t) {
+		if (!e.trim()) throw Error("submissionId 不能为空");
+		if (this.submissions.has(e)) throw Error(`submissionId 已存在: ${e}`);
+		let n = new AbortController(), r, i = new Promise((e) => {
+			r = e;
+		}), a = () => {
+			let r = this.submissions.get(e);
+			r && !r.settled && (r.cancelled = !0, n.abort(t?.reason), this.settleSubmissionIfComplete(r));
+		};
+		t?.addEventListener("abort", a, { once: !0 });
+		let o = {
+			id: e,
+			controller: n,
+			completion: i,
+			resolve: r,
+			removeExternalAbort: () => t?.removeEventListener("abort", a),
+			pendingDeliveries: 0,
+			settled: !1,
+			cancelled: !1
+		};
+		return this.submissions.set(e, o), t?.aborted && a(), o;
+	}
+	settleSubmissionIfComplete(e) {
+		if (!(e.settled || e.pendingDeliveries > 0)) {
+			if (e.settled = !0, e.removeExternalAbort(), e.cancelled) {
+				let t = A(e.controller.signal.reason ?? "Submission cancelled");
+				t.name = "AbortError", e.resolve({
+					status: "cancelled",
+					error: t
+				});
+			} else e.failure ? e.resolve({
+				status: "failed",
+				error: e.failure
+			}) : e.resolve({ status: "completed" });
+			if (this.submissions.size > 1e3) {
+				let e = Array.from(this.submissions.values()).find((e) => e.settled);
+				e && this.submissions.delete(e.id);
+			}
+		}
+	}
+};
+function M(e) {
+	return new j(e);
+}
+//#endregion
+//#region kernel/src/effect-harness.ts
+var N = 65536, P = 2048, F = class {
+	clock;
+	valueCodec;
+	valueCodecOptions;
+	maxFixtureBytes;
+	maxRawSummaryCharacters;
+	constructor(e = {}) {
+		if (this.clock = e.clock ?? t, this.valueCodec = e.valueCodec ?? new i(), this.valueCodecOptions = e.valueCodecOptions ?? {}, this.maxFixtureBytes = e.maxFixtureBytes ?? N, this.maxRawSummaryCharacters = e.maxRawSummaryCharacters ?? P, !Number.isSafeInteger(this.maxFixtureBytes) || this.maxFixtureBytes <= 0) throw Error("EffectHarness maxFixtureBytes 必须是正安全整数");
+		if (!Number.isSafeInteger(this.maxRawSummaryCharacters) || this.maxRawSummaryCharacters <= 0) throw Error("EffectHarness maxRawSummaryCharacters 必须是正安全整数");
+	}
+	async run(e, t, n = {}) {
+		if (!e.id.trim()) throw Error("EffectAdapter id 不能为空");
+		if (t.schemaVersion !== 1) throw Error(`EffectFixture schemaVersion 不支持: ${t.schemaVersion}`);
+		if (!t.fixtureId.trim()) throw Error("EffectFixture fixtureId 不能为空");
+		if (n.signal?.aborted) throw n.signal.reason ?? /* @__PURE__ */ Error("Effect 已取消");
+		let r = this.valueCodec.encode(t.request, {
+			...this.valueCodecOptions,
+			maxBytes: Math.min(this.valueCodecOptions.maxBytes ?? this.maxFixtureBytes, this.maxFixtureBytes),
+			rootPath: ["fixture", "request"]
+		}), i = [], a = [], o = this.clock.now(), s = this.clock.monotonicNow(), c = `${t.fixtureId}/${e.id}`, l = {
+			clock: this.clock,
+			signal: n.signal,
+			recordTransport: (e) => {
+				i.push(this.valueCodec.encode(e, {
+					...this.valueCodecOptions,
+					maxBytes: this.maxFixtureBytes,
+					rootPath: ["transportMetadata", String(i.length)]
+				}));
+			},
+			recordRawSummary: (e) => {
+				if (!e.kind.trim()) throw Error("Effect raw summary kind 不能为空");
+				if (e.text.length > this.maxRawSummaryCharacters) throw Error(`Effect raw summary 超过 ${this.maxRawSummaryCharacters} 字符限制`);
+				a.push({
+					kind: e.kind,
+					text: e.text,
+					redacted: e.redacted ?? !1
+				});
+			}
+		};
+		try {
+			let n = await e.execute(t.request, l), u = this.valueCodec.encode(n, {
+				...this.valueCodecOptions,
+				maxBytes: this.maxFixtureBytes,
+				rootPath: ["fixture", "observation"]
+			}), d = this.clock.now(), f = this.clock.monotonicNow() - s;
+			return {
+				observation: n,
+				record: {
+					schemaVersion: 1,
+					fixtureId: t.fixtureId,
+					executionId: c,
+					adapterId: e.id,
+					request: r,
+					observation: u,
+					transportMetadata: i,
+					rawSummaries: a,
+					startedAt: o,
+					completedAt: d,
+					durationMs: f,
+					status: "succeeded",
+					...t.expectedObservation === void 0 ? {} : { expectedMatched: JSON.stringify(u) === JSON.stringify(t.expectedObservation) }
+				}
+			};
+		} catch (n) {
+			let l = this.clock.now();
+			return { record: {
+				schemaVersion: 1,
+				fixtureId: t.fixtureId,
+				executionId: c,
+				adapterId: e.id,
+				request: r,
+				transportMetadata: i,
+				rawSummaries: a,
+				startedAt: o,
+				completedAt: l,
+				durationMs: this.clock.monotonicNow() - s,
+				status: "failed",
+				error: n instanceof Error ? n.message : String(n)
+			} };
+		}
+	}
+};
+//#endregion
+export { f as ChangeContextImpl, F as EffectHarness, j as KernelRuntime, s as MemoryTraceStore, h as Node, r as TimeRandomIdProvider, c as TraceSession, i as ValueCodec, g as WorldNode, l as applyStateDeltas, v as computeSchedulerSnapshot, M as createKernelRuntime, a as defaultValueCodec, o as fnv1a32, b as publishSchedulerStateHelper, x as scheduleGraphMicrotaskHelper, _ as schedulerCancellationError, y as subscribeSchedulerHelper, t as systemClock, n as systemRandomSource, e as traceSchemaVersion, S as waitForQuiescenceHelper };