@open-wa/runtime-core 5.0.0

package/LICENSE.md

@@ -0,0 +1,67 @@
+### Copyright (c) 2020 Mohammed Shah
+
+# Hippocratic + Do Not Harm (H-DNH) Version 1.1
+
+## Preamble
+
+Most software today is developed with little to no thought of how it will be used, or the consequences for our society and planet.
+
+As software developers, we engineer the infrastructure of the 21st century. We recognise that our infrastructure has great power to shape the world and the lives of those we share it with, and we choose to consciously take responsibility for the social and environmental impacts of what we build.
+
+We envisage a world free from injustice, inequality, and the reckless destruction of lives and our planet. We reject slavery in all its forms, whether by force, indebtedness, or by algorithms that hack human vulnerabilities. We seek a world where humankind is at peace with our neighbours, nature, and ourselves. We want our work to enrich the physical, mental and spiritual wellbeing of all society.
+
+We build software to further this vision of a just world, or at the very least, to not put that vision further from reach.
+
+## Terms
+
+Licensor hereby grants permission by this license ("License"), free of charge, to any person or entity (the "Licensee") obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+1. All redistribution of source code or binary form, including any modifications must be under these terms. You must inform recipients that the code is governed by these conditions, and how they can obtain a copy of this license. You may not attempt to alter the conditions of who may/may not use this software.
+
+2. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+3. This software must not be used by any organisation, website, product or service that:
+
+   a) lobbies for, promotes, or derives a majority of income from actions that support or contribute to:
+      * sex trafficking
+      * human trafficking
+      * slavery
+      * indentured servitude
+      * gambling
+      * tobacco
+      * adversely addictive behaviours
+      * nuclear energy
+      * warfare
+      * weapons manufacturing
+      * war crimes
+      * settler colonialism
+      * apartheid
+      * vaccine misinformation
+      * climate misinformation
+      * child endangerment
+      * violence (except when required to protect public safety)
+      * burning of forests
+      * deforestation
+      * hate speech or discrimination based on age, gender, gender identity, race, sexuality, religion, nationality
+
+   b) lobbies against, or derives a majority of income from actions that discourage or frustrate:
+      * peace
+      * access to the rights set out in the Universal Declaration of Human Rights and the Convention on the Rights of the Child
+      * peaceful assembly and association (including worker associations)
+      * a safe environment or action to curtail the use of fossil fuels or prevent climate change
+      * democratic processes
+
+
+4. Compliance with Human Rights Laws and Human Rights Principles:
+
+   a. **Human Rights Laws**. The Software shall not be used by any person or entity for any systems, activities, or other uses that violate any applicable laws, regulations, or rules that protect human, civil, labor, privacy, political, environmental, security, economic,  due process, or similar rights (the "Human Rights Laws"). Where the Human Rights Laws of more than one jurisdiction are applicable to the use of the Software, the Human Rights Laws that are most protective of the individuals or groups harmed shall apply.
+
+   b. **Human Rights Principles**. Licensee is advised to consult the articles of the United Nations Universal Declaration of Human Rights (https://www.un.org/en/universal-declaration-human-rights/) and the United Nations Global Compact (https://www.unglobalcompact.org/ what-is-gc/mission/principles) that define recognized principles of international human rights (the "Human Rights Principles"). It is Licensor's express intent that all use of the Software be consistent with Human Rights Principles. If Licensor receives notification  or otherwise learns of an alleged violation of any Human Rights Principles relating to Licensee's use of the Software, Licensor may in its discretion and without obligation (i) (a) notify Licensee of such allegation and (b) allow Licensee 90 days from notification  under (i)(a) to investigate and respond to Licensor regarding the allegation and (ii) (a) after the earlier of 90 days from notification under (i)(a), or Licensee's response under (i)(b), notify Licensee of License termination and (b) allow Licensee an additional 90  days from notification under (ii)(a) to cease use of the Software.
+
+   c. **Indemnity**. Licensee shall hold harmless and indemnify Licensor against all losses, damages, liabilities, deficiencies, claims, actions, judgments, settlements, interest, awards, penalties, fines, costs, or expenses of whatever kind, including Licensor's  reasonable attorneys' fees, arising out of or relating to Licensee's non-compliance with this License or use of the Software in violation of Human Rights Laws or Human Rights Principles. 
+
+5. Enforceability: If any portion or provision of this License is determined to be invalid, illegal, or unenforceable by a court of competent jurisdiction, then such invalidity, illegality, or unenforceability shall not affect any other term or provision of this License or invalidate or render unenforceable such term or provision in any other jurisdiction. Upon a determination that any term or provision is invalid, illegal, or unenforceable, to the extent permitted by applicable law, the court may modify this License to affect the original intent of the parties as closely as possible. The section headings are for convenience only and are not intended to affect the construction or interpretation of this License. Any rule of construction to the effect that ambiguities are to be resolved against the drafting party shall not apply in interpreting this License. The language in this License shall be interpreted as to its fair meaning and not strictly for or against any party.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+This license is an extension of the Hippocratic License - an Ethical Source license (https://ethicalsource.dev) and the Do Not Harm License - (https://github.com/raisely/NoHarm)

package/README.md

@@ -0,0 +1,21 @@
+# @open-wa/runtime-core
+
+Portable Effect runtime capabilities for open-wa
+
+Part of the [@open-wa v5 monorepo](https://github.com/open-wa/wa-automate-nodejs).
+
+## Development
+
+- `pnpm --filter @open-wa/runtime-core build`
+- `pnpm --filter @open-wa/runtime-core test`
+- `pnpm --filter @open-wa/runtime-core lint`
+- `pnpm --filter @open-wa/runtime-core typecheck`
+- `pnpm --filter @open-wa/runtime-core clean`
+
+## Documentation
+
+See the [docs site](https://docs.openwa.dev).
+
+## License
+
+[H-DNH 1.1](https://github.com/open-wa/wa-automate-nodejs/blob/master/LICENSE.md) - Hippocratic + Do Not Harm

package/dist/index.cjs

@@ -0,0 +1,568 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let effect = require("effect");
+let effect_unstable_httpapi = require("effect/unstable/httpapi");
+let effect_unstable_rpc = require("effect/unstable/rpc");
+//#region src/errors.ts
+var RuntimeCapabilityError = class extends effect.Data.TaggedError("RuntimeCapabilityError") {};
+var QueueOverloadedError = class extends effect.Data.TaggedError("QueueOverloadedError") {};
+var QueueClosedError = class extends effect.Data.TaggedError("QueueClosedError") {};
+var TaskTimeoutError = class extends effect.Data.TaggedError("TaskTimeoutError") {};
+var TaskExecutionError = class extends effect.Data.TaggedError("TaskExecutionError") {};
+var StartupGraphError = class extends effect.Data.TaggedError("StartupGraphError") {};
+var SandboxPolicyError = class extends effect.Data.TaggedError("SandboxPolicyError") {};
+var SandboxExecutionError = class extends effect.Data.TaggedError("SandboxExecutionError") {};
+var SessionAdmissionError = class extends effect.Data.TaggedError("SessionAdmissionError") {};
+//#endregion
+//#region src/effect-spikes.ts
+const RuntimeHealthSchema = effect.Schema.Struct({
+	sessionId: effect.Schema.String,
+	state: effect.Schema.Literals([
+		"STARTING",
+		"AUTHENTICATING",
+		"READY",
+		"DISCONNECTED",
+		"STOPPED"
+	]),
+	ready: effect.Schema.Boolean
+});
+const RuntimeEventSchema = effect.Schema.Struct({
+	event: effect.Schema.String,
+	sessionId: effect.Schema.String,
+	timestamp: effect.Schema.Number,
+	payload: effect.Schema.Unknown
+});
+const OpenWaHttpApi = effect_unstable_httpapi.HttpApi.make("openwa").add(effect_unstable_httpapi.HttpApiGroup.make("runtime").add(effect_unstable_httpapi.HttpApiEndpoint.get("health", "/health", { success: RuntimeHealthSchema })));
+const OpenWaAskRpc = effect_unstable_rpc.Rpc.make("openwa.ask", {
+	payload: {
+		method: effect.Schema.String,
+		args: effect.Schema.Array(effect.Schema.Unknown)
+	},
+	success: effect.Schema.Unknown
+});
+const decodeRuntimeEvent = effect.Schema.decodeUnknownEffect(RuntimeEventSchema);
+const makeBoundedEventPipeline = (capacity) => effect.Effect.gen(function* () {
+	const pubsub = yield* effect.PubSub.bounded(capacity);
+	return {
+		publish: (event) => effect.PubSub.publish(pubsub, event),
+		events: effect.Stream.fromPubSub(pubsub),
+		shutdown: effect.PubSub.shutdown(pubsub)
+	};
+});
+//#endregion
+//#region src/services.ts
+const RuntimeCapabilities = effect.Context.Service("@open-wa/RuntimeCapabilities");
+const BrowserDriver = effect.Context.Service("@open-wa/BrowserDriver");
+const BrowserSession = effect.Context.Service("@open-wa/BrowserSession");
+const PatchSource = effect.Context.Service("@open-wa/PatchSource");
+const LicenseService = effect.Context.Service("@open-wa/LicenseService");
+const SessionStore = effect.Context.Service("@open-wa/SessionStore");
+const PluginRegistry = effect.Context.Service("@open-wa/PluginRegistry");
+const ChatExecutor = effect.Context.Service("@open-wa/ChatExecutor");
+const SessionAdmission = effect.Context.Service("@open-wa/SessionAdmission");
+const RuntimeObservability = effect.Context.Service("@open-wa/RuntimeObservability");
+const serviceLayer = (key, service) => effect.Layer.succeed(key, service);
+//#endregion
+//#region src/observability.ts
+const serializeCause = (cause, seen = /* @__PURE__ */ new Set()) => {
+	if (!(cause instanceof Error)) return {
+		name: typeof cause,
+		message: String(cause)
+	};
+	if (seen.has(cause)) return {
+		name: cause.name,
+		message: `${cause.message} [circular cause]`
+	};
+	seen.add(cause);
+	const nested = "cause" in cause && cause.cause !== void 0 ? serializeCause(cause.cause, seen) : void 0;
+	const errors = cause instanceof AggregateError ? cause.errors.map((error) => serializeCause(error, seen)) : void 0;
+	return {
+		name: cause.name,
+		message: cause.message,
+		...cause.stack ? { stack: cause.stack } : {},
+		...nested ? { cause: nested } : {},
+		...errors ? { errors } : {}
+	};
+};
+const makeInMemoryObservability = () => {
+	const values = /* @__PURE__ */ new Map();
+	const causes = [];
+	const keyFor = (metric, attributes) => {
+		if (!attributes || Object.keys(attributes).length === 0) return metric;
+		return `${metric}{${Object.entries(attributes).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}=${String(value)}`).join(",")}}`;
+	};
+	return {
+		increment: (metric, value = 1, attributes) => effect.Effect.sync(() => {
+			const key = keyFor(metric, attributes);
+			values.set(key, (values.get(key) ?? 0) + value);
+		}),
+		gauge: (metric, value, attributes) => effect.Effect.sync(() => {
+			values.set(keyFor(metric, attributes), value);
+		}),
+		snapshot: effect.Effect.sync(() => Object.fromEntries(values)),
+		recordCause: (scope, cause, attributes) => effect.Effect.sync(() => {
+			causes.push({
+				scope,
+				recordedAt: Date.now(),
+				...attributes ? { attributes } : {},
+				cause: serializeCause(cause)
+			});
+			const key = keyFor("cause_failures", {
+				scope,
+				...attributes
+			});
+			values.set(key, (values.get(key) ?? 0) + 1);
+		}),
+		causes: effect.Effect.sync(() => causes.map((record) => ({ ...record })))
+	};
+};
+const InMemoryObservabilityLayer = effect.Layer.sync(RuntimeObservability, makeInMemoryObservability);
+const queueMetricsObserver = (observability) => {
+	let previousDropped = 0;
+	let previousFailed = 0;
+	let previousRateLimited = 0;
+	return (metrics) => {
+		const attributes = { queue: metrics.name };
+		effect.Effect.runSync(effect.Effect.all([
+			observability.gauge("queue_depth", metrics.depth, attributes),
+			observability.gauge("queue_active", metrics.active, attributes),
+			observability.gauge("active_fibers", metrics.active, attributes),
+			observability.increment("queue_drops", Math.max(0, metrics.dropped - previousDropped), attributes),
+			observability.increment("queue_failures", Math.max(0, metrics.failed - previousFailed), attributes),
+			observability.increment("rate_decisions", Math.max(0, metrics.rateLimited - previousRateLimited), attributes)
+		]));
+		previousDropped = metrics.dropped;
+		previousFailed = metrics.failed;
+		previousRateLimited = metrics.rateLimited;
+	};
+};
+//#endregion
+//#region src/runtime-capabilities.ts
+const makeRuntimeCapabilities = (runtime, capabilities) => {
+	const supported = new Set(capabilities);
+	return {
+		runtime,
+		supported,
+		has: (capability) => supported.has(capability),
+		require: (capability) => supported.has(capability) ? effect.Effect.void : effect.Effect.fail(new RuntimeCapabilityError({
+			capability,
+			runtime,
+			detail: `${runtime} does not provide ${capability}`
+		}))
+	};
+};
+const runtimeCapabilitiesLayer = (runtime, capabilities) => effect.Layer.succeed(RuntimeCapabilities, makeRuntimeCapabilities(runtime, capabilities));
+//#endregion
+//#region src/sandbox.ts
+const defaultChatSandboxPolicy = {
+	chats: false,
+	isolation: "process",
+	timeoutMs: 3e4,
+	idleTimeoutMs: 3e5,
+	memoryMb: 256,
+	concurrency: 1,
+	filesystem: "none",
+	network: "none",
+	networkAllowlist: [],
+	env: "none",
+	capabilities: ["sendText"]
+};
+const ExecutionSandbox = effect.Context.Service("@open-wa/ExecutionSandbox");
+/** Cause capture only. This function does not provide a security boundary. */
+const captureSandboxCause = (effect$2) => effect.Effect.sandbox(effect$2);
+//#endregion
+//#region src/scoped-task-queue.ts
+var ScopedTaskQueue = class ScopedTaskQueue {
+	policy;
+	queue;
+	scope;
+	activeTasks = /* @__PURE__ */ new Set();
+	metricsState = {
+		depth: 0,
+		active: 0,
+		completed: 0,
+		failed: 0,
+		dropped: 0,
+		rateLimited: 0,
+		closed: false
+	};
+	rateWindowStartedAt = Date.now();
+	rateWindowCount = 0;
+	constructor(policy, queue, scope) {
+		this.policy = policy;
+		this.queue = queue;
+		this.scope = scope;
+	}
+	static async make(policy) {
+		if (!Number.isInteger(policy.capacity) || policy.capacity < 1) throw new RangeError("queue capacity must be a positive integer");
+		if (!Number.isInteger(policy.concurrency) || policy.concurrency < 1) throw new RangeError("queue concurrency must be a positive integer");
+		if (policy.rate && (!Number.isInteger(policy.rate.limit) || policy.rate.limit < 1 || !Number.isFinite(policy.rate.intervalMs) || policy.rate.intervalMs <= 0)) throw new RangeError("queue rate limit and interval must be positive");
+		const normalized = {
+			...policy,
+			ordering: "fifo"
+		};
+		const scope = await effect.Effect.runPromise(effect.Scope.make());
+		const queue = await effect.Effect.runPromise(normalized.overload === "dropping" ? effect.Queue.dropping(normalized.capacity) : effect.Queue.bounded(normalized.capacity));
+		const taskQueue = new ScopedTaskQueue(normalized, queue, scope);
+		for (let index = 0; index < normalized.concurrency; index += 1) await effect.Effect.runPromise(effect.Effect.forkIn(taskQueue.worker(index), scope));
+		return taskQueue;
+	}
+	submit(operation, label) {
+		if (this.metricsState.closed) return Promise.reject(new QueueClosedError({ queue: this.policy.name }));
+		return new Promise((resolve, reject) => {
+			const task = {
+				operation: async () => operation(),
+				resolve: (value) => resolve(value),
+				reject,
+				enqueuedAt: Date.now(),
+				label
+			};
+			this.metricsState.depth += 1;
+			this.notifyObserver();
+			effect.Effect.runPromise(effect.Queue.offer(this.queue, task)).then((accepted) => {
+				if (!accepted) {
+					this.metricsState.depth = Math.max(0, this.metricsState.depth - 1);
+					this.metricsState.dropped += 1;
+					this.notifyObserver();
+					reject(new QueueOverloadedError({
+						queue: this.policy.name,
+						capacity: this.policy.capacity
+					}));
+					return;
+				}
+			}).catch((error) => {
+				this.metricsState.depth = Math.max(0, this.metricsState.depth - 1);
+				this.notifyObserver();
+				reject(this.metricsState.closed ? new QueueClosedError({ queue: this.policy.name }) : error);
+			});
+		});
+	}
+	metrics() {
+		return {
+			name: this.policy.name,
+			capacity: this.policy.capacity,
+			...this.metricsState
+		};
+	}
+	async close() {
+		if (this.metricsState.closed) return;
+		this.metricsState.closed = true;
+		this.notifyObserver();
+		while (true) {
+			const result = effect.Queue.takeUnsafe(this.queue);
+			if (result === void 0) break;
+			if (effect.Exit.isFailure(result)) continue;
+			this.metricsState.depth = Math.max(0, this.metricsState.depth - 1);
+			result.value.reject(new QueueClosedError({ queue: this.policy.name }));
+			this.notifyObserver();
+		}
+		for (const task of this.activeTasks) task.reject(new QueueClosedError({ queue: this.policy.name }));
+		this.activeTasks.clear();
+		this.metricsState.active = 0;
+		this.notifyObserver();
+		await effect.Effect.runPromise(effect.Queue.shutdown(this.queue));
+		await effect.Effect.runPromise(effect.Scope.close(this.scope, effect.Exit.void));
+	}
+	async waitForIdle() {
+		while (this.metricsState.depth > 0 || this.metricsState.active > 0) await effect.Effect.runPromise(effect.Effect.sleep(5));
+	}
+	worker(index) {
+		const self = this;
+		return effect.Effect.gen(function* () {
+			while (true) {
+				const task = yield* effect.Queue.take(self.queue);
+				self.metricsState.depth = Math.max(0, self.metricsState.depth - 1);
+				yield* self.reserveRatePermit();
+				self.activeTasks.add(task);
+				self.metricsState.active += 1;
+				self.notifyObserver();
+				let execution = effect.Effect.tryPromise({
+					try: task.operation,
+					catch: (cause) => new TaskExecutionError({
+						queue: self.policy.name,
+						cause
+					})
+				});
+				if (self.policy.timeoutMs !== void 0) execution = execution.pipe(effect.Effect.timeoutOrElse({
+					duration: self.policy.timeoutMs,
+					orElse: () => effect.Effect.fail(new TaskTimeoutError({
+						queue: self.policy.name,
+						timeoutMs: self.policy.timeoutMs
+					}))
+				}));
+				const result = yield* effect.Effect.exit(execution.pipe(effect.Effect.withSpan(`openwa.queue.${self.policy.name}`, { attributes: {
+					"queue.name": self.policy.name,
+					"queue.worker": index,
+					"queue.wait_ms": Date.now() - task.enqueuedAt,
+					...task.label ? { "task.label": task.label } : {}
+				} })));
+				self.activeTasks.delete(task);
+				self.metricsState.active = Math.max(0, self.metricsState.active - 1);
+				if (effect.Exit.isSuccess(result)) {
+					self.metricsState.completed += 1;
+					task.resolve(result.value);
+				} else {
+					self.metricsState.failed += 1;
+					task.reject(effect.Cause.squash(result.cause));
+				}
+				self.notifyObserver();
+			}
+		}).pipe(effect.Effect.withSpan(`openwa.queue.worker.${self.policy.name}`));
+	}
+	reserveRatePermit() {
+		const rate = this.policy.rate;
+		if (!rate) return effect.Effect.void;
+		const self = this;
+		return effect.Effect.suspend(() => {
+			const now = Date.now();
+			const elapsed = now - self.rateWindowStartedAt;
+			if (elapsed >= rate.intervalMs) {
+				self.rateWindowStartedAt = now;
+				self.rateWindowCount = 0;
+			}
+			if (self.rateWindowCount < rate.limit) {
+				self.rateWindowCount += 1;
+				return effect.Effect.void;
+			}
+			self.metricsState.rateLimited += 1;
+			self.notifyObserver();
+			return effect.Effect.sleep(Math.max(1, rate.intervalMs - elapsed)).pipe(effect.Effect.andThen(self.reserveRatePermit()));
+		});
+	}
+	notifyObserver() {
+		try {
+			this.policy.observe?.(this.metrics());
+		} catch {}
+	}
+};
+//#endregion
+//#region src/session-admission.ts
+const makeSessionAdmission = (options) => effect.Effect.gen(function* () {
+	const memory = yield* effect.Semaphore.make(options.memoryCapacityMb);
+	const launches = yield* effect.Semaphore.make(options.maxConcurrentLaunches);
+	let activeSessions = 0;
+	let availableMemoryMb = options.memoryCapacityMb;
+	return {
+		acquire: (memoryMb) => effect.Effect.gen(function* () {
+			if (memoryMb > options.memoryCapacityMb) return yield* effect.Effect.fail(new SessionAdmissionError({
+				requestedMemoryMb: memoryMb,
+				availableMemoryMb
+			}));
+			yield* effect.Semaphore.take(memory, memoryMb);
+			yield* effect.Semaphore.take(launches, 1);
+			availableMemoryMb -= memoryMb;
+			activeSessions += 1;
+			if (options.observability) yield* options.observability.gauge("session_browser_memory_mb", options.memoryCapacityMb - availableMemoryMb);
+			let released = false;
+			return {
+				memoryMb,
+				release: effect.Effect.suspend(() => {
+					if (released) return effect.Effect.void;
+					released = true;
+					activeSessions = Math.max(0, activeSessions - 1);
+					availableMemoryMb = Math.min(options.memoryCapacityMb, availableMemoryMb + memoryMb);
+					return effect.Effect.all([
+						effect.Semaphore.release(memory, memoryMb),
+						effect.Semaphore.release(launches, 1),
+						...options.observability ? [options.observability.gauge("session_browser_memory_mb", options.memoryCapacityMb - availableMemoryMb)] : []
+					]).pipe(effect.Effect.asVoid);
+				})
+			};
+		}),
+		snapshot: effect.Effect.sync(() => ({
+			capacityMemoryMb: options.memoryCapacityMb,
+			availableMemoryMb,
+			activeSessions
+		}))
+	};
+});
+const sessionAdmissionLayer = (options) => effect.Layer.effect(SessionAdmission, makeSessionAdmission(options));
+//#endregion
+//#region src/session-scope.ts
+var SessionScope = class SessionScope {
+	scope;
+	observability;
+	metricAttributes;
+	finalizerNames = /* @__PURE__ */ new Set();
+	closed = false;
+	activeFibers = 0;
+	constructor(scope, observability, metricAttributes = {}) {
+		this.scope = scope;
+		this.observability = observability;
+		this.metricAttributes = metricAttributes;
+	}
+	static async make(options = {}) {
+		return new SessionScope(await effect.Effect.runPromise(effect.Scope.make()), options.observability, options.metricAttributes);
+	}
+	async addFinalizer(name, finalizer) {
+		if (this.closed) throw new Error("session scope is already closed");
+		this.finalizerNames.add(name);
+		let active = true;
+		await effect.Effect.runPromise(effect.Scope.addFinalizer(this.scope, effect.Effect.promise(async () => {
+			if (!active) return;
+			active = false;
+			this.finalizerNames.delete(name);
+			await finalizer();
+		})));
+		return () => {
+			active = false;
+			this.finalizerNames.delete(name);
+		};
+	}
+	snapshot() {
+		return {
+			closed: this.closed,
+			finalizers: [...this.finalizerNames]
+		};
+	}
+	async fork(effect$1) {
+		if (this.closed) throw new Error("session scope is already closed");
+		const fiber = await effect.Effect.runPromise(effect.Effect.forkIn(effect$1, this.scope));
+		this.activeFibers += 1;
+		this.publishActiveFibers();
+		effect.Effect.runPromise(effect.Fiber.await(fiber)).finally(() => {
+			this.activeFibers = Math.max(0, this.activeFibers - 1);
+			this.publishActiveFibers();
+		});
+	}
+	async close(reason = "normal-stop") {
+		if (this.closed) return;
+		this.closed = true;
+		await effect.Effect.runPromise(effect.Scope.close(this.scope, reason === "normal-stop" ? effect.Exit.void : effect.Exit.fail(/* @__PURE__ */ new Error(`session scope closed: ${reason}`))));
+	}
+	publishActiveFibers() {
+		if (!this.observability) return;
+		effect.Effect.runSync(this.observability.gauge("active_fibers", this.activeFibers, {
+			owner: "session-scope",
+			...this.metricAttributes
+		}));
+	}
+};
+//#endregion
+//#region src/startup-graph.ts
+const validateStartupGraph = (nodes) => effect.Effect.try({
+	try: () => {
+		const ids = new Set(nodes.map((node) => node.id));
+		if (ids.size !== nodes.length) throw new StartupGraphError({
+			detail: "startup graph contains duplicate node ids",
+			nodes: nodes.map((node) => node.id)
+		});
+		for (const node of nodes) for (const dependency of node.dependsOn ?? []) if (!ids.has(dependency)) throw new StartupGraphError({
+			detail: `${node.id} depends on missing node ${dependency}`,
+			nodes: [node.id, dependency]
+		});
+		const visiting = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		const byId = new Map(nodes.map((node) => [node.id, node]));
+		const visit = (id) => {
+			if (visited.has(id)) return;
+			if (visiting.has(id)) throw new StartupGraphError({
+				detail: `startup graph contains a cycle at ${id}`,
+				nodes: [...visiting, id]
+			});
+			visiting.add(id);
+			for (const dependency of byId.get(id)?.dependsOn ?? []) visit(dependency);
+			visiting.delete(id);
+			visited.add(id);
+		};
+		for (const node of nodes) visit(node.id);
+	},
+	catch: (error) => error instanceof StartupGraphError ? error : new StartupGraphError({
+		detail: String(error),
+		nodes: nodes.map((node) => node.id)
+	})
+});
+const runStartupGraph = (nodes, options = {}) => effect.Effect.gen(function* () {
+	yield* validateStartupGraph(nodes);
+	const startedAt = Date.now();
+	const pending = new Map(nodes.map((node) => [node.id, node]));
+	const values = /* @__PURE__ */ new Map();
+	const phases = [];
+	while (pending.size > 0) {
+		const ready = [...pending.values()].filter((node) => (node.dependsOn ?? []).every((dependency) => values.has(dependency)));
+		if (ready.length === 0) return yield* effect.Effect.fail(new StartupGraphError({
+			detail: "startup graph made no progress",
+			nodes: [...pending.keys()]
+		}));
+		const results = yield* effect.Effect.all(ready.map((node) => effect.Effect.gen(function* () {
+			return {
+				node,
+				nodeStartedAt: Date.now(),
+				exit: yield* effect.Effect.exit(node.run(values).pipe(effect.Effect.withSpan(`openwa.startup.${node.id}`, { attributes: {
+					"startup.node": node.id,
+					"startup.optional": node.optional ?? false
+				} })))
+			};
+		})), { concurrency: options.concurrency ?? 4 });
+		for (const { node, nodeStartedAt, exit } of results) {
+			pending.delete(node.id);
+			if (exit._tag === "Failure") {
+				if (!node.optional) return yield* effect.Effect.failCause(exit.cause);
+				values.set(node.id, exit);
+				phases.push({
+					id: node.id,
+					durationMs: Date.now() - nodeStartedAt,
+					optional: true,
+					result: exit
+				});
+				options.onPhase?.(phases.at(-1));
+				continue;
+			}
+			values.set(node.id, exit.value);
+			phases.push({
+				id: node.id,
+				durationMs: Date.now() - nodeStartedAt,
+				optional: node.optional ?? false,
+				result: exit.value
+			});
+			options.onPhase?.(phases.at(-1));
+		}
+	}
+	const result = {
+		values,
+		phases,
+		criticalPathMs: Date.now() - startedAt
+	};
+	options.onComplete?.(result);
+	return result;
+});
+//#endregion
+exports.BrowserDriver = BrowserDriver;
+exports.BrowserSession = BrowserSession;
+exports.ChatExecutor = ChatExecutor;
+exports.ExecutionSandbox = ExecutionSandbox;
+exports.InMemoryObservabilityLayer = InMemoryObservabilityLayer;
+exports.LicenseService = LicenseService;
+exports.OpenWaAskRpc = OpenWaAskRpc;
+exports.OpenWaHttpApi = OpenWaHttpApi;
+exports.PatchSource = PatchSource;
+exports.PluginRegistry = PluginRegistry;
+exports.QueueClosedError = QueueClosedError;
+exports.QueueOverloadedError = QueueOverloadedError;
+exports.RuntimeCapabilities = RuntimeCapabilities;
+exports.RuntimeCapabilityError = RuntimeCapabilityError;
+exports.RuntimeEventSchema = RuntimeEventSchema;
+exports.RuntimeHealthSchema = RuntimeHealthSchema;
+exports.RuntimeObservability = RuntimeObservability;
+exports.SandboxExecutionError = SandboxExecutionError;
+exports.SandboxPolicyError = SandboxPolicyError;
+exports.ScopedTaskQueue = ScopedTaskQueue;
+exports.SessionAdmission = SessionAdmission;
+exports.SessionAdmissionError = SessionAdmissionError;
+exports.SessionScope = SessionScope;
+exports.SessionStore = SessionStore;
+exports.StartupGraphError = StartupGraphError;
+exports.TaskExecutionError = TaskExecutionError;
+exports.TaskTimeoutError = TaskTimeoutError;
+exports.captureSandboxCause = captureSandboxCause;
+exports.decodeRuntimeEvent = decodeRuntimeEvent;
+exports.defaultChatSandboxPolicy = defaultChatSandboxPolicy;
+exports.makeBoundedEventPipeline = makeBoundedEventPipeline;
+exports.makeInMemoryObservability = makeInMemoryObservability;
+exports.makeRuntimeCapabilities = makeRuntimeCapabilities;
+exports.makeSessionAdmission = makeSessionAdmission;
+exports.queueMetricsObserver = queueMetricsObserver;
+exports.runStartupGraph = runStartupGraph;
+exports.runtimeCapabilitiesLayer = runtimeCapabilitiesLayer;
+exports.serviceLayer = serviceLayer;
+exports.sessionAdmissionLayer = sessionAdmissionLayer;
+exports.validateStartupGraph = validateStartupGraph;