@cosystem/core 0.0.0 → 1.0.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { create, createReactiveTracker } from "coaction";
+import { computed as computed$1, create, createReactiveTracker } from "coaction";
 //#region src/errors.ts
 var CosystemError = class extends Error {
 	constructor(message) {
@@ -184,7 +184,7 @@ var RuntimeContainer = class RuntimeContainer {
 		if (record === void 0) return;
 		const context = this.createResolutionContext("sync");
 		const value = this.resolveRecord(record, context);
-		if (isPromiseLike(value)) throw new AsyncProviderInSyncResolutionError(record.tokenName);
+		if (isPromiseLike$1(value)) throw new AsyncProviderInSyncResolutionError(record.tokenName);
 		return value;
 	}
 	getAll(token) {
@@ -192,7 +192,7 @@ var RuntimeContainer = class RuntimeContainer {
 		const context = this.createResolutionContext("sync");
 		return records.map((record) => {
 			const value = this.resolveRecord(record, context);
-			if (isPromiseLike(value)) throw new AsyncProviderInSyncResolutionError(record.tokenName);
+			if (isPromiseLike$1(value)) throw new AsyncProviderInSyncResolutionError(record.tokenName);
 			return value;
 		});
 	}
@@ -227,7 +227,13 @@ var RuntimeContainer = class RuntimeContainer {
 		const deps = options.deps ?? target.inject ?? [];
 		const context = this.createResolutionContext("sync");
 		const values = this.resolveDependencies(deps, context);
-		if (isPromiseLike(values)) throw new AsyncProviderInSyncResolutionError(target.name);
+		if (isPromiseLike$1(values)) throw new AsyncProviderInSyncResolutionError(target.name);
+		return Reflect.construct(target, values);
+	}
+	async buildAsync(target, options = {}) {
+		const deps = options.deps ?? target.inject ?? [];
+		const context = this.createResolutionContext("async");
+		const values = await this.resolveDependencies(deps, context);
 		return Reflect.construct(target, values);
 	}
 	freeze() {
@@ -301,7 +307,7 @@ var RuntimeContainer = class RuntimeContainer {
 		};
 		try {
 			const value = this.createValue(record, context);
-			if (isPromiseLike(value)) {
+			if (isPromiseLike$1(value)) {
 				if (context.mode === "sync") throw new AsyncProviderInSyncResolutionError(record.tokenName);
 				return Promise.resolve(value).then(finalize, fail);
 			}
@@ -315,14 +321,14 @@ var RuntimeContainer = class RuntimeContainer {
 			case "class": {
 				const provider = record.provider;
 				const deps = this.resolveDependencies(record.deps, context);
-				if (isPromiseLike(deps)) return Promise.resolve(deps).then((values) => Reflect.construct(provider.useClass, values));
+				if (isPromiseLike$1(deps)) return Promise.resolve(deps).then((values) => Reflect.construct(provider.useClass, values));
 				return Reflect.construct(provider.useClass, deps);
 			}
 			case "value": return record.provider.useValue;
 			case "factory": {
 				const provider = record.provider;
 				const deps = this.resolveDependencies(record.deps, context);
-				if (isPromiseLike(deps)) return Promise.resolve(deps).then((values) => runWithInjectContext(context, () => provider.useFactory(...values)));
+				if (isPromiseLike$1(deps)) return Promise.resolve(deps).then((values) => runWithInjectContext(context, () => provider.useFactory(...values)));
 				return runWithInjectContext(context, () => provider.useFactory(...deps));
 			}
 			case "existing": return this.resolveDependency(record.provider.useExisting, context);
@@ -333,7 +339,7 @@ var RuntimeContainer = class RuntimeContainer {
 		const asyncValues = [];
 		for (const [index, dep] of deps.entries()) {
 			const value = this.resolveDependency(dep, context);
-			if (isPromiseLike(value)) asyncValues.push(Promise.resolve(value).then((resolved) => {
+			if (isPromiseLike$1(value)) asyncValues.push(Promise.resolve(value).then((resolved) => {
 				values[index] = resolved;
 				return resolved;
 			}));
@@ -348,16 +354,21 @@ var RuntimeContainer = class RuntimeContainer {
 				const records = this.getAllRecords(dep.token);
 				return this.resolveAllRecords(records, context);
 			}
-			const record = dep.optional === true ? this.getSingleRecord(dep.token, true) : this.getSingleRecord(dep.token, false);
+			const record = dep.optional === true ? this.getSingleRecord(dep.token, true) : this.getRequiredRecord(dep.token, context);
 			if (record === void 0) return;
 			return this.resolveRecord(record, context);
 		}
-		const record = this.getSingleRecord(dep, false);
+		const record = this.getRequiredRecord(dep, context);
 		return this.resolveRecord(record, context);
 	}
+	getRequiredRecord(token, context) {
+		const record = this.getSingleRecord(token, true);
+		if (record === void 0) throw new MissingProviderError(tokenName(token), context.stack.map((entry) => entry.tokenName));
+		return record;
+	}
 	resolveAllRecords(records, context) {
 		const values = records.map((record) => this.resolveRecord(record, context));
-		if (values.some(isPromiseLike)) return Promise.all(values);
+		if (values.some(isPromiseLike$1)) return Promise.all(values);
 		return values;
 	}
 	getCached(record, context) {
@@ -410,7 +421,7 @@ var RuntimeContainer = class RuntimeContainer {
 function isDependencyObject(dep) {
 	return typeof dep === "object" && dep !== null && "token" in dep;
 }
-function isPromiseLike(value) {
+function isPromiseLike$1(value) {
 	return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
 }
 function isLifetimeLeak(parentScope, childScope) {
@@ -437,18 +448,69 @@ async function disposeValue(value, record) {
 	if (typeof maybeDisposable.destroy === "function") await maybeDisposable.destroy();
 }
 //#endregion
+//#region src/lazyModule.ts
+function lazyModule(load) {
+	return {
+		kind: "lazyModule",
+		load
+	};
+}
+function isLazyModule(input) {
+	return typeof input === "object" && input !== null && "kind" in input && input.kind === "lazyModule" && "load" in input && typeof input.load === "function";
+}
+function normalizeLazyModuleProviders(input) {
+	if (isProviderInput(input)) return [input];
+	if (Array.isArray(input)) {
+		assertProviderArray(input);
+		return input;
+	}
+	if (typeof input === "object" && input !== null) {
+		const exports = input;
+		const providers = [];
+		if (exports.providers !== void 0) {
+			assertProviderArray(exports.providers);
+			providers.push(...exports.providers);
+		}
+		if (exports.default !== void 0) if (Array.isArray(exports.default)) {
+			assertProviderArray(exports.default);
+			providers.push(...exports.default);
+		} else if (isProviderInput(exports.default)) providers.push(exports.default);
+		else throw new CosystemError("Lazy module default export must be a provider or provider array.");
+		if (providers.length > 0) return providers;
+	}
+	throw new CosystemError("Lazy module loader must return a provider, provider array, or module exports with providers/default.");
+}
+function assertProviderArray(values) {
+	if (values.every(isProviderInput)) return;
+	throw new CosystemError("Lazy module provider arrays may only contain provider entries.");
+}
+function isProviderInput(value) {
+	if (typeof value === "function") return true;
+	return typeof value === "object" && value !== null && "provide" in value && ("useClass" in value || "useValue" in value || "useFactory" in value || "useExisting" in value);
+}
+//#endregion
 //#region src/metadata.ts
 const moduleMetadata = /* @__PURE__ */ new WeakMap();
-function defineModule(target, options = {}) {
+const moduleMetadataKey = Symbol.for("@cosystem/core/moduleMetadata");
+const symbolMetadataKey = Symbol.metadata;
+function defineModule(target, options = {}, context) {
 	const metadata = ensureModuleMetadata(target);
+	mergeModuleMetadata(metadata, readContextMetadata(context));
 	applyModuleOptions(metadata, options);
 	addProperties(metadata.state, options.state);
 	addProperties(metadata.actions, options.actions);
 	addProperties(metadata.computed, options.computed);
+	addProperties(metadata.effects, options.effects);
+	writeContextMetadata(context, metadata);
 	return target;
 }
 function getModuleMetadata(target) {
-	return moduleMetadata.get(target);
+	const existing = moduleMetadata.get(target);
+	if (existing !== void 0) return existing;
+	const metadata = readSymbolMetadata(target);
+	if (metadata === void 0) return;
+	moduleMetadata.set(target, metadata);
+	return metadata;
 }
 function addModuleState(target, property) {
 	ensureModuleMetadata(target).state.add(property);
@@ -459,6 +521,9 @@ function addModuleAction(target, property) {
 function addModuleComputed(target, property) {
 	ensureModuleMetadata(target).computed.add(property);
 }
+function addModuleEffect(target, property) {
+	ensureModuleMetadata(target).effects.add(property);
+}
 function applyModuleOptions(metadata, options) {
 	if (options.name !== void 0) metadata.name = options.name;
 	if (options.deps !== void 0) metadata.deps = options.deps;
@@ -471,38 +536,96 @@ function ensureModuleMetadata(target) {
 		kind: "module",
 		state: /* @__PURE__ */ new Set(),
 		actions: /* @__PURE__ */ new Set(),
-		computed: /* @__PURE__ */ new Set()
+		computed: /* @__PURE__ */ new Set(),
+		effects: /* @__PURE__ */ new Set()
 	};
 	moduleMetadata.set(target, metadata);
 	return metadata;
 }
+function ensureContextModuleMetadata(context) {
+	if (context?.metadata === void 0) return;
+	const existing = readContextMetadata(context);
+	if (existing !== void 0) return existing;
+	const metadata = createModuleMetadata();
+	writeContextMetadata(context, metadata);
+	return metadata;
+}
 function addProperties(target, properties) {
 	for (const property of properties ?? []) target.add(property);
 }
+function createModuleMetadata() {
+	return {
+		kind: "module",
+		state: /* @__PURE__ */ new Set(),
+		actions: /* @__PURE__ */ new Set(),
+		computed: /* @__PURE__ */ new Set(),
+		effects: /* @__PURE__ */ new Set()
+	};
+}
+function readContextMetadata(context) {
+	const value = context?.metadata?.[moduleMetadataKey];
+	return isModuleMetadata(value) ? value : void 0;
+}
+function writeContextMetadata(context, metadata) {
+	if (context?.metadata === void 0) return;
+	context.metadata[moduleMetadataKey] = metadata;
+}
+function readSymbolMetadata(target) {
+	if (symbolMetadataKey === void 0) return;
+	const metadata = target[symbolMetadataKey];
+	if (metadata === void 0 || metadata === null || typeof metadata !== "object") return;
+	const value = metadata[moduleMetadataKey];
+	return isModuleMetadata(value) ? value : void 0;
+}
+function mergeModuleMetadata(target, source) {
+	if (source === void 0 || source === target) return;
+	applyModuleOptions(target, source);
+	addProperties(target.state, [...source.state]);
+	addProperties(target.actions, [...source.actions]);
+	addProperties(target.computed, [...source.computed]);
+	addProperties(target.effects, [...source.effects]);
+}
+function isModuleMetadata(value) {
+	return typeof value === "object" && value !== null && value.kind === "module" && value instanceof Object && value.state instanceof Set && value.actions instanceof Set && value.computed instanceof Set && value.effects instanceof Set;
+}
 //#endregion
 //#region src/app.ts
+const runtimeModuleMetadataKey = Symbol.for("@cosystem/core/runtimeModule");
+const appContainerMap = /* @__PURE__ */ new WeakMap();
 function createApp(options = {}) {
 	return createAppInternal(options);
 }
+function runInAction(module, callback, options) {
+	const metadata = getRuntimeModuleMetadata(module);
+	if (metadata === void 0) throw new CosystemError("runInAction() target is not a CoSystem module instance.");
+	return metadata.app.runInAction(module, callback, options);
+}
 function createAppInternal(options = {}) {
-	const parent = isApp(options.parent) ? options.parent.container : options.parent;
+	const parent = isApp(options.parent) ? getAppContainer(options.parent) : options.parent;
 	const container = parent === void 0 ? createContainer() : createContainer({ parent });
 	const moduleTokens = [];
+	const lazyModules = [];
 	for (const provider of options.providers ?? []) {
+		if (isLazyModule(provider)) {
+			lazyModules.push(provider);
+			continue;
+		}
 		const normalized = normalizeAppProvider(provider);
 		container.provide(normalized.provider);
 		if (normalized.moduleToken !== void 0) moduleTokens.push(normalized.moduleToken);
 	}
-	for (const override of options.overrides ?? []) container.override(normalizeAppProvider(override).provider);
+	for (const override of options.overrides ?? []) {
+		const normalized = normalizeAppProvider(override);
+		if (normalized.moduleToken !== void 0 && !moduleTokens.some((moduleToken) => moduleToken === normalized.moduleToken)) throw new CosystemError(`Cannot add ${tokenName(normalized.moduleToken)} as a new CoSystem module through overrides.`);
+		container.override(normalized.provider);
+	}
 	container.freeze();
 	const modules = instantiateModules(container, moduleTokens);
-	const store = create(createRootState(modules), {
-		name: "cosystem",
-		sliceMode: "single"
-	});
+	const store = create(createRootState(modules), createStoreOptions(options.engine, shouldEnablePatches(options)));
 	const app = new RuntimeApp({
 		container,
 		devOptions: options.devOptions ?? {},
+		lazyModules,
 		modules,
 		plugins: options.plugins ?? [],
 		state: { version: 0 },
@@ -510,26 +633,35 @@ function createAppInternal(options = {}) {
 		...options.testInspector === void 0 ? {} : { testInspector: options.testInspector }
 	});
 	app.bindModules();
+	app.attachRuntimeMetadata();
+	instantiateEagerProviders(container);
 	app.runModuleCreatedHooks();
 	app.init();
+	appContainerMap.set(app, container);
 	return app;
 }
 var RuntimeApp = class {
-	container;
 	state;
 	store;
+	#container;
 	devOptions;
 	modules;
+	pendingLazyModules;
 	moduleByToken = /* @__PURE__ */ new Map();
 	moduleByName = /* @__PURE__ */ new Map();
 	plugins;
 	testInspector;
+	effectDisposers = [];
+	pendingEffects = /* @__PURE__ */ new Set();
+	loadedLazyModules = /* @__PURE__ */ new WeakMap();
+	dynamicScopes = [];
 	initPromise = Promise.resolve();
 	isStarted = false;
 	isDisposed = false;
 	constructor(options) {
-		this.container = options.container;
+		this.#container = options.container;
 		this.devOptions = options.devOptions;
+		this.pendingLazyModules = [...options.lazyModules];
 		this.modules = options.modules;
 		this.plugins = options.plugins;
 		this.state = options.state;
@@ -539,29 +671,35 @@ var RuntimeApp = class {
 			this.moduleByToken.set(moduleBinding.token, moduleBinding);
 			this.moduleByName.set(moduleBinding.name, moduleBinding);
 		}
+		this.wrapStoreSetState();
 		this.store.subscribe(() => {
 			this.state.version += 1;
 			const state = this.store.getPureState();
-			this.testInspector?.recordPatch(state);
+			this.testInspector?.recordState(state);
 			this.emitStateChange({ state });
 		});
+		this.testInspector?.setFlushEffects(() => this.flushEffects());
 	}
 	get started() {
 		return this.isStarted;
 	}
 	get(token) {
-		return this.container.get(token);
+		const moduleBinding = this.moduleByToken.get(token);
+		if (moduleBinding !== void 0) return moduleBinding.instance;
+		return this.#container.get(token);
 	}
 	getAsync(token) {
-		return this.container.getAsync(token);
+		const moduleBinding = this.moduleByToken.get(token);
+		if (moduleBinding !== void 0) return Promise.resolve(moduleBinding.instance);
+		return this.#container.getAsync(token);
 	}
 	getAll(token) {
-		return this.container.getAll(token);
+		return this.#container.getAll(token);
 	}
 	getModule(token) {
-		const value = this.get(token);
-		if (!this.moduleByToken.has(token)) throw new CosystemError(`${tokenName(token)} is not a CoSystem module.`);
-		return value;
+		const moduleBinding = this.moduleByToken.get(token);
+		if (moduleBinding === void 0) throw new CosystemError(`${tokenName(token)} is not a CoSystem module.`);
+		return moduleBinding.instance;
 	}
 	getModuleByName(name) {
 		const moduleBinding = this.moduleByName.get(name);
@@ -588,50 +726,129 @@ var RuntimeApp = class {
 			tracker.dispose();
 		};
 	}
+	runInAction(module, callback, options = {}) {
+		const moduleBinding = this.resolveModuleBinding(module);
+		return this.runActionCallback(moduleBinding, options.name ?? "runInAction", options.args ?? [], callback);
+	}
 	async start() {
 		if (this.isStarted) return;
 		await this.initPromise;
-		await this.runLifecycle("onStart");
-		this.isStarted = true;
+		try {
+			await this.runLifecycle("onStart");
+			this.isStarted = true;
+		} catch (error) {
+			this.emitError(error, { phase: "start" });
+			throw error;
+		}
 	}
 	async stop() {
 		if (!this.isStarted) return;
-		await this.runLifecycle("onStop", true);
-		this.isStarted = false;
+		try {
+			await this.runLifecycle("onStop", true);
+			this.isStarted = false;
+		} catch (error) {
+			this.emitError(error, { phase: "stop" });
+			throw error;
+		}
 	}
 	async dispose() {
 		if (this.isDisposed) return;
 		await this.stop();
-		await this.runLifecycle("onDispose", true);
-		await Promise.all(this.plugins.map((plugin) => plugin.dispose?.()));
-		await this.container.dispose();
-		this.store.destroy();
-		this.isDisposed = true;
+		try {
+			this.stopEffects();
+			await this.waitForPendingEffects();
+			await this.runLifecycle("onDispose", true);
+			for (const scope of this.dynamicScopes.toReversed()) await scope.dispose();
+			await Promise.all(this.plugins.map((plugin) => plugin.dispose?.()));
+			await this.#container.dispose();
+			this.store.destroy();
+			this.isDisposed = true;
+		} catch (error) {
+			this.emitError(error, { phase: "dispose" });
+			throw error;
+		}
 	}
 	createScope(options) {
-		return { container: this.container.createScope(options) };
+		return { container: this.#container.createScope(options) };
+	}
+	async load(module) {
+		if (module === void 0) {
+			const modules = this.pendingLazyModules.splice(0);
+			const results = [];
+			for (const pendingModule of modules) results.push(await this.load(pendingModule));
+			return results;
+		}
+		const existing = this.loadedLazyModules.get(module);
+		if (existing !== void 0) return existing;
+		if (this.isDisposed) throw new CosystemError("Cannot load a lazy module after app disposal.");
+		await this.initPromise;
+		try {
+			const providers = normalizeLazyModuleProviders(await module.load());
+			const scopeContainer = this.#container.createScope();
+			const moduleTokens = [];
+			for (const provider of providers) {
+				const normalized = normalizeAppProvider(provider);
+				scopeContainer.provide(normalized.provider);
+				if (normalized.moduleToken !== void 0) moduleTokens.push(normalized.moduleToken);
+			}
+			scopeContainer.freeze();
+			const loadedModules = instantiateModules(scopeContainer, moduleTokens, false);
+			this.assertNewModules(loadedModules);
+			this.installModuleState(loadedModules);
+			this.registerModules(loadedModules);
+			this.bindModules(loadedModules);
+			this.attachRuntimeMetadata(loadedModules);
+			instantiateEagerProviders(scopeContainer);
+			this.dynamicScopes.push(scopeContainer);
+			this.runModuleCreatedHooks(loadedModules);
+			await this.runLifecycle("onInit", false, loadedModules);
+			this.startEffects(loadedModules);
+			if (this.isStarted) await this.runLifecycle("onStart", false, loadedModules);
+			const result = {
+				modules: loadedModules.map(toModuleCreatedEvent),
+				scope: { container: scopeContainer }
+			};
+			this.loadedLazyModules.set(module, result);
+			return result;
+		} catch (error) {
+			this.emitError(error, { phase: "load" });
+			throw error;
+		}
 	}
-	bindModules() {
-		for (const moduleBinding of this.modules) {
+	bindModules(modules = this.modules) {
+		for (const moduleBinding of modules) {
 			this.bindState(moduleBinding);
 			this.bindComputed(moduleBinding);
 			this.bindActions(moduleBinding);
 		}
 	}
-	runModuleCreatedHooks() {
-		for (const moduleBinding of this.modules) {
-			const event = {
+	attachRuntimeMetadata(modules = this.modules) {
+		for (const moduleBinding of modules) Object.defineProperty(moduleBinding.instance, runtimeModuleMetadataKey, {
+			configurable: false,
+			enumerable: false,
+			value: {
+				app: this,
 				name: moduleBinding.name,
-				token: moduleBinding.token,
-				instance: moduleBinding.instance
-			};
+				token: moduleBinding.token
+			}
+		});
+	}
+	runModuleCreatedHooks(modules = this.modules) {
+		for (const moduleBinding of modules) {
+			const event = toModuleCreatedEvent(moduleBinding);
 			for (const plugin of this.plugins) plugin.onModuleCreated?.(event);
 		}
 	}
 	init() {
 		this.initPromise = (async () => {
-			await Promise.all(this.plugins.map((plugin) => plugin.setup?.(this)));
-			await this.runLifecycle("onInit");
+			try {
+				await Promise.all(this.plugins.map((plugin) => this.runWithAppInjectContext(() => plugin.setup?.(this))));
+				await this.runLifecycle("onInit");
+				this.startEffects();
+			} catch (error) {
+				this.emitError(error, { phase: "init" });
+				throw error;
+			}
 		})();
 	}
 	bindState(moduleBinding) {
@@ -655,15 +872,21 @@ var RuntimeApp = class {
 	bindComputed(moduleBinding) {
 		for (const property of moduleBinding.metadata.computed) {
 			const getter = getGetter(moduleBinding.instance, property);
+			const accessor = computed$1(() => getter.call(moduleBinding.instance));
 			moduleBinding.originalComputed.set(property, getter);
+			moduleBinding.computedAccessors.set(property, accessor);
 			Object.defineProperty(moduleBinding.instance, property, {
 				configurable: true,
 				enumerable: true,
-				get: () => getter.call(moduleBinding.instance)
+				get: () => {
+					if (moduleBinding.activeDraft !== void 0 || !moduleBinding.reactiveSlice) return getter.call(moduleBinding.instance);
+					return accessor();
+				}
 			});
 		}
 	}
 	readModuleState(moduleBinding, property) {
+		if (!moduleBinding.reactiveSlice) return this.store.getPureState()[moduleBinding.name]?.[property];
 		return this.store.getState()[moduleBinding.name]?.[property];
 	}
 	writeModuleState(moduleBinding, property, value) {
@@ -672,6 +895,18 @@ var RuntimeApp = class {
 			return;
 		}
 		if (this.devOptions.strictActions === true && moduleBinding.actionDepth === 0) throw new CosystemError(`Cannot write ${moduleBinding.name}.${String(property)} outside an action.`);
+		if (!moduleBinding.reactiveSlice) {
+			const state = this.store.getPureState();
+			const slice = state[moduleBinding.name] ?? {};
+			this.store.setState({
+				...state,
+				[moduleBinding.name]: {
+					...slice,
+					[property]: value
+				}
+			});
+			return;
+		}
 		this.store.setState((draft) => {
 			draft[moduleBinding.name] ??= {};
 			draft[moduleBinding.name][property] = value;
@@ -680,6 +915,9 @@ var RuntimeApp = class {
 	runAction(moduleBinding, property, args) {
 		const action = moduleBinding.originalActions.get(property);
 		if (action === void 0) throw new CosystemError(`${moduleBinding.name}.${String(property)} is not an action.`);
+		return this.runActionCallback(moduleBinding, property, args, () => action.apply(moduleBinding.instance, [...args]));
+	}
+	runActionCallback(moduleBinding, property, args, callback) {
 		const event = {
 			args,
 			method: String(property),
@@ -691,21 +929,76 @@ var RuntimeApp = class {
 		let error;
 		try {
 			moduleBinding.actionDepth += 1;
-			this.store.setState((draft) => {
+			if (moduleBinding.reactiveSlice) this.store.setState((draft) => {
 				const previousDraft = moduleBinding.activeDraft;
 				moduleBinding.activeDraft = draft[moduleBinding.name] ?? {};
 				draft[moduleBinding.name] = moduleBinding.activeDraft;
 				try {
-					result = action.apply(moduleBinding.instance, [...args]);
+					result = callback();
 				} finally {
 					moduleBinding.activeDraft = previousDraft;
 				}
 			});
+			else {
+				const state = this.store.getPureState();
+				const slice = state[moduleBinding.name];
+				const previousDraft = moduleBinding.activeDraft;
+				moduleBinding.activeDraft = slice === void 0 ? {} : { ...slice };
+				try {
+					result = callback();
+					this.store.setState({
+						...state,
+						[moduleBinding.name]: moduleBinding.activeDraft
+					});
+				} finally {
+					moduleBinding.activeDraft = previousDraft;
+				}
+			}
 		} catch (caught) {
 			error = caught;
+			this.emitError(caught, { phase: "action" });
 		} finally {
 			moduleBinding.actionDepth -= 1;
 		}
+		if (error !== void 0) {
+			this.finishAction(event, error);
+			throw error;
+		}
+		if (isPromiseLike(result)) return Promise.resolve(result).then((value) => {
+			this.finishAction(event);
+			return value;
+		}, (caught) => {
+			this.emitError(caught, { phase: "action" });
+			this.finishAction(event, caught);
+			throw caught;
+		});
+		this.finishAction(event);
+		return result;
+	}
+	resolveModuleBinding(target) {
+		if (typeof target === "object" && target !== null) {
+			const metadata = getRuntimeModuleMetadata(target);
+			if (metadata !== void 0) {
+				if (metadata.app !== this) throw new CosystemError("runInAction() target belongs to another CoSystem app.");
+				const moduleBinding = this.moduleByToken.get(metadata.token);
+				if (moduleBinding !== void 0) return moduleBinding;
+			}
+			if (isTokenObject(target)) {
+				const moduleBinding = this.moduleByToken.get(target);
+				if (moduleBinding !== void 0) return moduleBinding;
+			}
+			throw new CosystemError("runInAction() target is not a CoSystem module.");
+		}
+		if (typeof target === "string") {
+			const moduleBinding = this.moduleByName.get(target) ?? this.moduleByToken.get(target);
+			if (moduleBinding !== void 0) return moduleBinding;
+			throw new CosystemError(`${target} is not a CoSystem module.`);
+		}
+		const moduleBinding = this.moduleByToken.get(target);
+		if (moduleBinding !== void 0) return moduleBinding;
+		throw new CosystemError(`${tokenName(target)} is not a CoSystem module.`);
+	}
+	finishAction(event, error) {
 		const endedEvent = {
 			...event,
 			endedAt: Date.now(),
@@ -713,12 +1006,63 @@ var RuntimeApp = class {
 		};
 		this.testInspector?.recordAction(endedEvent);
 		this.emitActionEnd(endedEvent);
-		if (error !== void 0) throw error;
-		return result;
 	}
-	async runLifecycle(method, reverse = false) {
-		const modules = reverse ? this.modules.toReversed() : this.modules;
-		for (const moduleBinding of modules) await moduleBinding.instance[method]?.();
+	async runLifecycle(method, reverse = false, modules = this.modules) {
+		const orderedModules = reverse ? modules.toReversed() : modules;
+		for (const moduleBinding of orderedModules) {
+			const lifecycle = moduleBinding.instance;
+			await this.runWithAppInjectContext(() => lifecycle[method]?.());
+		}
+	}
+	startEffects(modules = this.modules) {
+		for (const moduleBinding of modules) for (const property of moduleBinding.metadata.effects) this.startEffect(moduleBinding, property);
+	}
+	startEffect(moduleBinding, property) {
+		const method = getMethod(moduleBinding.instance, property);
+		const tracker = createReactiveTracker();
+		let disposed = false;
+		const run = () => {
+			if (disposed) return;
+			try {
+				tracker.track(() => this.runEffect(moduleBinding, property, method));
+			} catch (error) {
+				this.emitError(error, { phase: "effect" });
+				throw error;
+			}
+		};
+		const unsubscribe = tracker.subscribe(() => {
+			try {
+				run();
+			} catch {}
+		});
+		run();
+		this.effectDisposers.push(() => {
+			disposed = true;
+			unsubscribe();
+			tracker.dispose();
+		});
+	}
+	runEffect(moduleBinding, property, method) {
+		const result = this.runWithAppInjectContext(() => method.call(moduleBinding.instance));
+		if (!isPromiseLike(result)) return;
+		const pending = Promise.resolve(result).then(() => void 0).catch((error) => {
+			this.emitError(error, { phase: `effect:${moduleBinding.name}.${String(property)}` });
+			throw error;
+		}).finally(() => {
+			this.pendingEffects.delete(pending);
+		});
+		this.pendingEffects.add(pending);
+		pending.catch(() => void 0);
+	}
+	stopEffects() {
+		for (const dispose of this.effectDisposers.splice(0).toReversed()) dispose();
+	}
+	async flushEffects() {
+		await this.initPromise;
+		await this.waitForPendingEffects();
+	}
+	async waitForPendingEffects() {
+		while (this.pendingEffects.size > 0) await Promise.all(this.pendingEffects);
 	}
 	emitActionStart(event) {
 		for (const plugin of this.plugins) plugin.onActionStart?.(event);
@@ -729,6 +1073,59 @@ var RuntimeApp = class {
 	emitStateChange(event) {
 		for (const plugin of this.plugins) plugin.onStateChange?.(event);
 	}
+	emitPatch(event) {
+		for (const plugin of this.plugins) plugin.onPatch?.(event);
+	}
+	emitError(error, context) {
+		for (const plugin of this.plugins) plugin.onError?.(error, context);
+	}
+	runWithAppInjectContext(callback) {
+		return runWithInjectContext({
+			mode: "sync",
+			requestContainer: this.#container,
+			resolutionCache: /* @__PURE__ */ new Map(),
+			stack: []
+		}, callback);
+	}
+	wrapStoreSetState() {
+		const originalSetState = this.store.setState.bind(this.store);
+		this.store.setState = ((...args) => {
+			const result = originalSetState(...args);
+			this.recordMutationResult(result);
+			return result;
+		});
+	}
+	recordMutationResult(result) {
+		if (!Array.isArray(result) || result.length < 3) return;
+		const patches = result[1];
+		if (patches.length === 0) return;
+		this.testInspector?.recordPatch(patches);
+		this.emitPatch({
+			inversePatches: result[2],
+			patches
+		});
+	}
+	assertNewModules(modules) {
+		for (const moduleBinding of modules) {
+			if (this.moduleByToken.has(moduleBinding.token)) throw new DuplicateProviderError(tokenName(moduleBinding.token));
+			if (this.moduleByName.has(moduleBinding.name)) throw new DuplicateProviderError(moduleBinding.name);
+		}
+	}
+	installModuleState(modules) {
+		if (modules.length === 0) return;
+		const rootState = createRootState(modules);
+		this.store.setState({
+			...this.store.getPureState(),
+			...rootState
+		});
+	}
+	registerModules(modules) {
+		for (const moduleBinding of modules) {
+			this.modules.push(moduleBinding);
+			this.moduleByToken.set(moduleBinding.token, moduleBinding);
+			this.moduleByName.set(moduleBinding.name, moduleBinding);
+		}
+	}
 };
 function normalizeAppProvider(provider) {
 	if (typeof provider === "function") {
@@ -751,6 +1148,18 @@ function normalizeAppProvider(provider) {
 	}
 	return { provider };
 }
+function createStoreOptions(engine, enablePatches) {
+	return {
+		name: "cosystem",
+		sliceMode: "single",
+		enablePatches,
+		...engine?.transport === void 0 ? {} : { transport: engine.transport }
+	};
+}
+function shouldEnablePatches(options) {
+	if (options.engine?.patches !== void 0) return options.engine.patches;
+	return options.testInspector !== void 0 || (options.plugins ?? []).some((plugin) => plugin.onPatch !== void 0);
+}
 function createModuleClassProviderOptions(useClass, metadata) {
 	return {
 		useClass,
@@ -764,7 +1173,7 @@ function mergeModuleClassProviderOptions(provider, metadata) {
 		..."scope" in provider || metadata.scope === void 0 ? {} : { scope: metadata.scope }
 	};
 }
-function instantiateModules(container, moduleTokens) {
+function instantiateModules(container, moduleTokens, reactiveSlice = true) {
 	const modules = [];
 	for (const moduleToken of moduleTokens) {
 		const instance = container.get(moduleToken);
@@ -775,16 +1184,36 @@ function instantiateModules(container, moduleTokens) {
 		modules.push({
 			actionDepth: 0,
 			activeDraft: void 0,
+			computedAccessors: /* @__PURE__ */ new Map(),
 			instance,
 			metadata,
 			name,
 			originalActions: /* @__PURE__ */ new Map(),
 			originalComputed: /* @__PURE__ */ new Map(),
+			reactiveSlice,
 			token: moduleToken
 		});
 	}
 	return modules;
 }
+function toModuleCreatedEvent(moduleBinding) {
+	return {
+		instance: moduleBinding.instance,
+		name: moduleBinding.name,
+		token: moduleBinding.token
+	};
+}
+function instantiateEagerProviders(container) {
+	const internalContainer = container;
+	for (const [token, records] of internalContainer.records) {
+		if (!records.some((record) => record.eager)) continue;
+		if (records.some((record) => record.multi)) {
+			container.getAll(token);
+			continue;
+		}
+		container.get(token);
+	}
+}
 function createRootState(modules) {
 	const rootState = {};
 	for (const moduleBinding of modules) {
@@ -808,6 +1237,12 @@ function getGetter(instance, property) {
 	if (descriptor?.get === void 0) throw new CosystemError(`${String(property)} is not a getter.`);
 	return descriptor.get;
 }
+function getRuntimeModuleMetadata(module) {
+	return module[runtimeModuleMetadataKey];
+}
+function isTokenObject(value) {
+	return "id" in value && typeof value.id === "symbol";
+}
 function getDescriptor(instance, property) {
 	let current = instance;
 	while (current !== null) {
@@ -819,32 +1254,71 @@ function getDescriptor(instance, property) {
 function isApp(value) {
 	return typeof value === "object" && value !== null && "get" in value && "start" in value && "dispose" in value;
 }
+function isPromiseLike(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+}
+function getAppContainer(app) {
+	const container = appContainerMap.get(app);
+	if (container === void 0) throw new CosystemError("Parent app was not created by CoSystem.");
+	return container;
+}
 //#endregion
 //#region src/decorators.ts
 function module(options = {}) {
-	return function moduleDecorator(target, _context) {
-		defineModule(target, options);
+	return function moduleDecorator(target, context) {
+		defineModule(target, options, context);
 		return target;
 	};
 }
 function state(_value, context) {
 	if (context.kind !== "accessor") throw new TypeError("@state only supports standard accessor decorators.");
+	ensureContextModuleMetadata(context)?.state.add(context.name);
 	context.addInitializer(function initializeState() {
 		addModuleState(this.constructor, context.name);
 	});
 }
 function action(_value, context) {
 	if (context.kind !== "method") throw new TypeError("@action only supports method decorators.");
+	ensureContextModuleMetadata(context)?.actions.add(context.name);
 	context.addInitializer(function initializeAction() {
 		addModuleAction(this.constructor, context.name);
 	});
 }
 function computed(_value, context) {
 	if (context.kind !== "getter") throw new TypeError("@computed only supports getter decorators.");
+	ensureContextModuleMetadata(context)?.computed.add(context.name);
 	context.addInitializer(function initializeComputed() {
 		addModuleComputed(this.constructor, context.name);
 	});
 }
+function effect(_value, context) {
+	if (context.kind !== "method") throw new TypeError("@effect only supports method decorators.");
+	ensureContextModuleMetadata(context)?.effects.add(context.name);
+	context.addInitializer(function initializeEffect() {
+		addModuleEffect(this.constructor, context.name);
+	});
+}
+//#endregion
+//#region src/loggerPlugin.ts
+function createLoggerPlugin(options = {}) {
+	const logger = options.logger ?? console;
+	return {
+		name: "cosystem:logger",
+		onActionEnd(event) {
+			if (event.error !== void 0) {
+				logger.error(`Action failed: ${event.module}.${event.method}`, event);
+				return;
+			}
+			logger.info(`Action completed: ${event.module}.${event.method}`, event);
+		},
+		onError(error, context) {
+			logger.error(`Runtime error during ${context.phase}`, error);
+		},
+		onModuleCreated(event) {
+			logger.info(`Module created: ${event.name}`, event);
+		}
+	};
+}
 //#endregion
 //#region src/testApp.ts
 function testApp(options = {}) {
@@ -867,9 +1341,13 @@ function testApp(options = {}) {
 	if (autoStart === true) return app.start().then(() => app);
 	return app;
 }
+function defaultFlushEffects() {
+	return Promise.resolve();
+}
 function createTestInspector() {
 	const actions = [];
 	const patches = [];
+	let flushEffects = defaultFlushEffects;
 	let lastState;
 	return {
 		clearActions() {
@@ -879,7 +1357,7 @@ function createTestInspector() {
 			patches.length = 0;
 		},
 		flushEffects() {
-			return Promise.resolve();
+			return flushEffects();
 		},
 		getActions() {
 			return actions;
@@ -894,59 +1372,78 @@ function createTestInspector() {
 			actions.push(event);
 		},
 		recordPatch(patch) {
-			lastState = patch;
 			patches.push(patch);
+		},
+		recordState(state) {
+			lastState = state;
+		},
+		setFlushEffects(callback) {
+			flushEffects = callback;
 		}
 	};
 }
 //#endregion
 //#region src/worker.ts
 function createWorkerApp(options) {
-	const { transport, ...appOptions } = options;
-	const app = createApp(appOptions);
+	const { stateSections, sync = "snapshot", transport, ...appOptions } = options;
+	let stateSyncVersion = 0;
+	let publishPatches = false;
+	const patchPlugin = {
+		name: "cosystem:worker-patches",
+		onPatch(event) {
+			if (publishPatches) {
+				const version = stateSections === void 0 ? app.state.version : stateSyncVersion + 1;
+				if (publishState(app, transport, event.patches, sync, stateSections, version)) stateSyncVersion = version;
+			}
+		}
+	};
+	const app = createApp({
+		...appOptions,
+		engine: {
+			...appOptions.engine,
+			patches: true
+		},
+		plugins: [...appOptions.plugins ?? [], patchPlugin]
+	});
+	const ready = app.start().then(() => {
+		publishPatches = true;
+		transport.post({ type: "ready" });
+		const version = stateSections === void 0 ? app.state.version : stateSyncVersion;
+		if (publishState(app, transport, [], "snapshot", stateSections, version)) stateSyncVersion = version;
+	});
 	const unsubscribeTransport = transport.subscribe((message) => {
 		if (message.type !== "call") return;
-		handleCall(app, transport, message);
-	});
-	const unsubscribeStore = app.store.subscribe(() => {
-		publishState(app, transport);
+		handleCall(app, transport, message, ready);
 	});
-	transport.post({ type: "ready" });
-	publishState(app, transport);
 	return {
 		app,
+		ready,
 		async dispose() {
 			unsubscribeTransport();
-			unsubscribeStore();
+			await ready.catch(() => void 0);
 			await app.dispose();
 		}
 	};
 }
 function createWorkerClient(options) {
-	const { transport } = options;
+	const { onConflict, transport } = options;
 	const listeners = /* @__PURE__ */ new Set();
+	const selectorWatchers = /* @__PURE__ */ new Set();
 	const pending = /* @__PURE__ */ new Map();
 	const state = { version: 0 };
 	let nextId = 1;
 	let snapshot;
-	const unsubscribe = transport.subscribe((message) => {
-		if (message.type === "state") {
-			state.version = message.version;
-			snapshot = message.state;
-			for (const listener of listeners) listener(message);
-			return;
-		}
-		if (message.type !== "result") return;
-		const entry = pending.get(message.id);
-		if (entry === void 0) return;
-		pending.delete(message.id);
-		if (message.error !== void 0) {
-			entry.reject(createRemoteError(message.error));
-			return;
-		}
-		entry.resolve(message.value);
+	let readySettled = false;
+	let resolveReady;
+	let rejectReady;
+	const ready = new Promise((resolve, reject) => {
+		resolveReady = resolve;
+		rejectReady = reject;
 	});
+	ready.catch(() => void 0);
+	let unsubscribe = noop;
 	const client = {
+		ready,
 		state,
 		call(module, method, ...args) {
 			const id = nextId;
@@ -967,9 +1464,14 @@ function createWorkerClient(options) {
 		},
 		dispose() {
 			unsubscribe();
+			if (!readySettled) {
+				readySettled = true;
+				rejectReady(new CosystemError("Worker client disposed before initial state."));
+			}
 			for (const entry of pending.values()) entry.reject(new CosystemError("Worker client disposed before response."));
 			pending.clear();
 			listeners.clear();
+			selectorWatchers.clear();
 		},
 		getState() {
 			return snapshot;
@@ -980,22 +1482,256 @@ function createWorkerClient(options) {
 				return (...args) => client.call(name, property, ...args);
 			} });
 		},
+		select(selector) {
+			if (snapshot === void 0) throw new CosystemError("Worker client state is not ready.");
+			return selector(snapshot, client);
+		},
 		subscribe(listener) {
 			listeners.add(listener);
 			return () => {
 				listeners.delete(listener);
 			};
+		},
+		watch(selector, listener, watchOptions = {}) {
+			const watcher = {
+				equals: watchOptions.equals ?? Object.is,
+				immediate: watchOptions.immediate ?? false,
+				initialized: false,
+				listener,
+				previous: void 0,
+				selector
+			};
+			if (snapshot !== void 0) {
+				const value = selector(snapshot, client);
+				watcher.initialized = true;
+				watcher.previous = value;
+				if (watcher.immediate) listener(value, value);
+			}
+			selectorWatchers.add(watcher);
+			return () => {
+				selectorWatchers.delete(watcher);
+			};
+		}
+	};
+	const publishSelectorWatchers = () => {
+		if (snapshot === void 0) return;
+		for (const watcher of selectorWatchers) {
+			const value = watcher.selector(snapshot, client);
+			if (!watcher.initialized) {
+				watcher.initialized = true;
+				watcher.previous = value;
+				if (watcher.immediate) watcher.listener(value, value);
+				continue;
+			}
+			const previous = watcher.previous;
+			if (watcher.equals(value, previous)) continue;
+			watcher.previous = value;
+			watcher.listener(value, previous);
 		}
 	};
+	unsubscribe = transport.subscribe((message) => {
+		if (message.type === "state") {
+			if (readySettled && message.version <= state.version) {
+				reportWorkerConflict(onConflict, {
+					currentVersion: state.version,
+					incomingVersion: message.version,
+					message,
+					reason: "stale-message"
+				});
+				return;
+			}
+			const isPatchOnly = message.state === void 0 && message.sync === "patch";
+			if (isPatchOnly && snapshot === void 0) {
+				reportWorkerConflict(onConflict, {
+					currentVersion: state.version,
+					incomingVersion: message.version,
+					message,
+					reason: "missing-snapshot"
+				});
+				return;
+			}
+			if (isPatchOnly && readySettled && message.version !== state.version + 1) {
+				reportWorkerConflict(onConflict, {
+					currentVersion: state.version,
+					incomingVersion: message.version,
+					message,
+					reason: "version-gap"
+				});
+				return;
+			}
+			try {
+				snapshot = isPatchOnly ? applyWorkerPatches(snapshot, message.patches ?? []) : message.state;
+			} catch (error) {
+				reportWorkerConflict(onConflict, {
+					currentVersion: state.version,
+					error,
+					incomingVersion: message.version,
+					message,
+					reason: "patch-apply-failed"
+				});
+				return;
+			}
+			state.version = message.version;
+			if (!readySettled) {
+				readySettled = true;
+				resolveReady();
+			}
+			for (const listener of listeners) listener(message);
+			publishSelectorWatchers();
+			return;
+		}
+		if (message.type !== "result") return;
+		const entry = pending.get(message.id);
+		if (entry === void 0) return;
+		pending.delete(message.id);
+		if (message.error !== void 0) {
+			entry.reject(createRemoteError(message.error));
+			return;
+		}
+		entry.resolve(message.value);
+	});
 	return client;
 }
+function reportWorkerConflict(onConflict, event) {
+	onConflict?.(event);
+}
 function createMemoryWorkerTransportPair() {
 	const leftListeners = /* @__PURE__ */ new Set();
 	const rightListeners = /* @__PURE__ */ new Set();
 	return [createMemoryWorkerTransport(leftListeners, rightListeners), createMemoryWorkerTransport(rightListeners, leftListeners)];
 }
-async function handleCall(app, transport, message) {
+function createPostMessageWorkerTransport(endpoint, options = {}) {
+	const source = options.source ?? endpoint;
+	const target = options.target ?? endpoint;
+	return {
+		post(message) {
+			try {
+				target.postMessage(message);
+			} catch (error) {
+				options.onError?.(error, message);
+			}
+		},
+		subscribe(listener) {
+			const handleMessage = (event) => {
+				if (!isWorkerMessage(event.data)) return;
+				listener(event.data);
+			};
+			source.addEventListener("message", handleMessage);
+			return () => {
+				source.removeEventListener("message", handleMessage);
+			};
+		}
+	};
+}
+function createBroadcastWorkerTransport(broadcast, options = {}) {
+	const channel = options.channel ?? defaultBroadcastWorkerChannel;
+	const peerId = options.peerId ?? createWorkerPeerId();
+	const callRoutes = /* @__PURE__ */ new Map();
+	let nextRoutedCallId = 1;
+	return {
+		post(message) {
+			try {
+				const routed = routeBroadcastWorkerMessage(message, callRoutes);
+				const target = routed.target ?? getBroadcastWorkerTarget(message, options);
+				const envelope = {
+					channel,
+					message: routed.message,
+					source: peerId,
+					type: "cosystem:worker",
+					...target === void 0 ? {} : { target }
+				};
+				broadcast.postMessage(envelope);
+			} catch (error) {
+				options.onError?.(error, message);
+			}
+		},
+		subscribe(listener) {
+			const handleMessage = (event) => {
+				const envelope = event.data;
+				if (!isBroadcastWorkerMessageEnvelope(envelope) || envelope.channel !== channel || envelope.source === peerId || envelope.target !== void 0 && envelope.target !== peerId) return;
+				if (envelope.message.type === "call") {
+					const routedCallId = nextRoutedCallId;
+					nextRoutedCallId += 1;
+					callRoutes.set(routedCallId, {
+						id: envelope.message.id,
+						source: envelope.source
+					});
+					listener({
+						...envelope.message,
+						id: routedCallId
+					});
+					return;
+				}
+				listener(envelope.message);
+			};
+			broadcast.addEventListener("message", handleMessage);
+			return () => {
+				broadcast.removeEventListener("message", handleMessage);
+			};
+		}
+	};
+}
+function createMemoryBroadcastChannel(name = defaultBroadcastWorkerChannel) {
+	return new MemoryBroadcastChannel(name);
+}
+function createDataTransportWorkerTransport(dataTransport, options = {}) {
+	const listeners = /* @__PURE__ */ new Set();
+	const disposers = [];
+	let listening = false;
+	const start = () => {
+		if (listening) return;
+		listening = true;
+		for (const type of workerMessageTypes) {
+			const dispose = dataTransport.listen(type, (message) => {
+				if (!isWorkerMessage(message)) return;
+				for (const listener of listeners) listener(message);
+			});
+			if (typeof dispose === "function") disposers.push(dispose);
+		}
+	};
+	const stop = () => {
+		if (!listening) return;
+		listening = false;
+		for (const dispose of disposers.splice(0)) dispose();
+	};
+	return {
+		post(message) {
+			dataTransport.emit({
+				name: message.type,
+				respond: false
+			}, message).catch((error) => {
+				options.onError?.(error, message);
+			});
+		},
+		subscribe(listener) {
+			start();
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+				if (listeners.size === 0) stop();
+			};
+		}
+	};
+}
+function getBroadcastWorkerTarget(message, options) {
+	return message.type === "call" ? options.targetPeerId : void 0;
+}
+function routeBroadcastWorkerMessage(message, callRoutes) {
+	if (message.type !== "result") return { message };
+	const route = callRoutes.get(message.id);
+	if (route === void 0) return { message };
+	callRoutes.delete(message.id);
+	return {
+		message: {
+			...message,
+			id: route.id
+		},
+		target: route.source
+	};
+}
+async function handleCall(app, transport, message, ready) {
 	try {
+		await ready;
 		const module = app.getModuleByName(message.module);
 		const method = module[message.method];
 		if (typeof method !== "function") throw new CosystemError(`${message.module}.${message.method} is not callable.`);
@@ -1013,13 +1749,112 @@ async function handleCall(app, transport, message) {
 		});
 	}
 }
-function publishState(app, transport) {
-	transport.post({
-		state: app.store.getPureState(),
+function publishState(app, transport, patches = [], mode = "snapshot", sections, version = app.state.version) {
+	const filteredPatches = filterWorkerPatches(patches, sections);
+	const isPatch = filteredPatches.length > 0;
+	if (patches.length > 0 && filteredPatches.length === 0) return false;
+	const state = filterWorkerState(app.store.getPureState(), sections);
+	const message = {
+		...isPatch && mode === "patch" ? {} : { state },
+		...sections === void 0 ? {} : { sections },
+		sync: isPatch ? "patch" : "snapshot",
 		type: "state",
-		version: app.state.version
+		version,
+		...isPatch ? { patches: filteredPatches } : {}
+	};
+	transport.post(message);
+	return true;
+}
+function filterWorkerState(state, sections) {
+	if (sections === void 0 || !isRecord(state)) return state;
+	const filtered = {};
+	for (const section of sections) if (section in state) filtered[section] = state[section];
+	return filtered;
+}
+function filterWorkerPatches(patches, sections) {
+	if (sections === void 0) return patches;
+	const sectionSet = new Set(sections);
+	return patches.filter((patch) => {
+		if (!isWorkerPatch(patch)) throw new CosystemError("Worker state patch is invalid.");
+		const section = getWorkerPatchSection(patch);
+		return section !== void 0 && sectionSet.has(String(section));
 	});
 }
+function getWorkerPatchSection(patch) {
+	return normalizePatchPath(patch.path)[0];
+}
+function applyWorkerPatches(state, patches) {
+	let next = state;
+	for (const patch of patches) next = applyWorkerPatch(next, patch);
+	return next;
+}
+function applyWorkerPatch(state, patch) {
+	if (!isWorkerPatch(patch)) throw new CosystemError("Worker state patch is invalid.");
+	const path = normalizePatchPath(patch.path);
+	if (path.length === 0) {
+		if (patch.op === "remove") return;
+		return patch.value;
+	}
+	return applyPatchAtPath(state, path, patch);
+}
+function applyPatchAtPath(state, path, patch) {
+	const [segment, ...rest] = path;
+	if (segment === void 0) throw new CosystemError("Worker state patch path is invalid.");
+	const container = clonePatchContainer(state, segment);
+	if (rest.length === 0) {
+		if (patch.op === "remove") {
+			removePatchValue(container, segment);
+			return container;
+		}
+		setPatchValue(container, segment, patch.value);
+		return container;
+	}
+	setPatchValue(container, segment, applyPatchAtPath(getPatchValue(container, segment), rest, patch));
+	return container;
+}
+function clonePatchContainer(state, nextSegment) {
+	if (Array.isArray(state)) return [...state];
+	if (isRecord(state)) return { ...state };
+	return typeof nextSegment === "number" ? [] : {};
+}
+function getPatchValue(container, segment) {
+	if (Array.isArray(container)) return container[toArrayIndex(segment)];
+	return container[String(segment)];
+}
+function setPatchValue(container, segment, value) {
+	if (Array.isArray(container)) {
+		container[toArrayIndex(segment)] = value;
+		return;
+	}
+	container[String(segment)] = value;
+}
+function removePatchValue(container, segment) {
+	if (Array.isArray(container)) {
+		container.splice(toArrayIndex(segment), 1);
+		return;
+	}
+	delete container[String(segment)];
+}
+function toArrayIndex(segment) {
+	if (typeof segment === "number") return segment;
+	return Number(segment);
+}
+function normalizePatchPath(path) {
+	if (Array.isArray(path)) return path.map((segment) => normalizePatchPathSegment(segment));
+	if (typeof path === "string") {
+		if (path === "" || path === "/") return [];
+		return path.split("/").slice(1).map((segment) => normalizePatchPathSegment(segment.replaceAll("~1", "/").replaceAll("~0", "~")));
+	}
+	throw new CosystemError("Worker state patch path is invalid.");
+}
+function normalizePatchPathSegment(segment) {
+	if (typeof segment === "number" || typeof segment === "string") return segment;
+	throw new CosystemError("Worker state patch path segment is invalid.");
+}
+function isWorkerPatch(value) {
+	if (!isRecord(value)) return false;
+	return (value.op === "add" || value.op === "replace" || value.op === "remove") && (Array.isArray(value.path) || typeof value.path === "string");
+}
 function createMemoryWorkerTransport(inbox, outbox) {
 	return {
 		post(message) {
@@ -1033,6 +1868,72 @@ function createMemoryWorkerTransport(inbox, outbox) {
 		}
 	};
 }
+const workerMessageTypes = [
+	"call",
+	"result",
+	"state",
+	"ready"
+];
+const defaultBroadcastWorkerChannel = "cosystem:worker";
+const memoryBroadcastChannels = /* @__PURE__ */ new Map();
+let nextWorkerPeerId = 1;
+var MemoryBroadcastChannel = class {
+	name;
+	#listeners = /* @__PURE__ */ new Set();
+	#closed = false;
+	constructor(name) {
+		this.name = name;
+		let channels = memoryBroadcastChannels.get(name);
+		if (channels === void 0) {
+			channels = /* @__PURE__ */ new Set();
+			memoryBroadcastChannels.set(name, channels);
+		}
+		channels.add(this);
+	}
+	postMessage(message) {
+		if (this.#closed) return;
+		const channels = memoryBroadcastChannels.get(this.name);
+		if (channels === void 0) return;
+		for (const channel of channels) {
+			if (channel === this || channel.#closed) continue;
+			channel.dispatch({ data: message });
+		}
+	}
+	addEventListener(_type, listener) {
+		if (!this.#closed) this.#listeners.add(listener);
+	}
+	removeEventListener(_type, listener) {
+		this.#listeners.delete(listener);
+	}
+	close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#listeners.clear();
+		const channels = memoryBroadcastChannels.get(this.name);
+		if (channels === void 0) return;
+		channels.delete(this);
+		if (channels.size === 0) memoryBroadcastChannels.delete(this.name);
+	}
+	dispatch(event) {
+		for (const listener of this.#listeners) listener(event);
+	}
+};
+function createWorkerPeerId() {
+	const id = nextWorkerPeerId;
+	nextWorkerPeerId += 1;
+	return `peer:${id}`;
+}
+function isWorkerMessage(message) {
+	if (typeof message !== "object" || message === null || !("type" in message)) return false;
+	return workerMessageTypes.includes(message.type);
+}
+function isBroadcastWorkerMessageEnvelope(message) {
+	if (!isRecord(message)) return false;
+	return message.type === "cosystem:worker" && typeof message.channel === "string" && typeof message.source === "string" && (message.target === void 0 || typeof message.target === "string") && isWorkerMessage(message.message);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function serializeError(error) {
 	if (error instanceof Error) return {
 		message: error.message,
@@ -1050,7 +1951,8 @@ function createRemoteError(error) {
 	if (error.stack !== void 0) remoteError.stack = error.stack;
 	return remoteError;
 }
+function noop() {}
 //#endregion
-export { AmbiguousProviderError, AsyncProviderInSyncResolutionError, CircularDependencyError, CosystemError, DuplicateProviderError, FrozenContainerError, InjectContextError, LifetimeLeakError, MissingProviderError, action, computed, createApp, createContainer, createMemoryWorkerTransportPair, createWorkerApp, createWorkerClient, defineModule, getModuleMetadata, inject, module, provide, state, testApp, token, tokenName };
+export { AmbiguousProviderError, AsyncProviderInSyncResolutionError, CircularDependencyError, CosystemError, DuplicateProviderError, FrozenContainerError, InjectContextError, LifetimeLeakError, MissingProviderError, action, computed, createApp, createBroadcastWorkerTransport, createContainer, createDataTransportWorkerTransport, createLoggerPlugin, createMemoryBroadcastChannel, createMemoryWorkerTransportPair, createPostMessageWorkerTransport, createWorkerApp, createWorkerClient, defineModule, effect, getModuleMetadata, inject, lazyModule, module, provide, runInAction, state, testApp, token, tokenName };
 
 //# sourceMappingURL=index.mjs.map