@cosystem/core 0.0.0

package/dist/index.mjs

@@ -0,0 +1,1056 @@
+import { create, createReactiveTracker } from "coaction";
+//#region src/errors.ts
+var CosystemError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CosystemError";
+	}
+};
+var FrozenContainerError = class extends CosystemError {
+	constructor() {
+		super("Container provider graph is frozen and can no longer be mutated.");
+		this.name = "FrozenContainerError";
+	}
+};
+var MissingProviderError = class extends CosystemError {
+	constructor(token, path) {
+		super([
+			`Missing provider for ${token}.`,
+			path.length > 0 ? "Resolution path:" : "",
+			...path.map((entry) => `  ${entry}`)
+		].filter(Boolean).join("\n"));
+		this.name = "MissingProviderError";
+	}
+};
+var DuplicateProviderError = class extends CosystemError {
+	constructor(token) {
+		super(`Duplicate non-multi provider for ${token}. Use override() or mark providers as multi.`);
+		this.name = "DuplicateProviderError";
+	}
+};
+var AmbiguousProviderError = class extends CosystemError {
+	constructor(token) {
+		super(`Multiple providers registered for ${token}. Use getAll() instead of get().`);
+		this.name = "AmbiguousProviderError";
+	}
+};
+var CircularDependencyError = class extends CosystemError {
+	constructor(path) {
+		super(["Circular dependency detected:", ...path.map((entry) => `  ${entry}`)].join("\n"));
+		this.name = "CircularDependencyError";
+	}
+};
+var AsyncProviderInSyncResolutionError = class extends CosystemError {
+	constructor(token) {
+		super(`Provider for ${token} resolved asynchronously. Use getAsync() instead of get().`);
+		this.name = "AsyncProviderInSyncResolutionError";
+	}
+};
+var LifetimeLeakError = class extends CosystemError {
+	constructor(parent, parentScope, child, childScope) {
+		super(`${parent} (${parentScope}) cannot depend on ${child} (${childScope}) without leakSafe.`);
+		this.name = "LifetimeLeakError";
+	}
+};
+var InjectContextError = class extends CosystemError {
+	constructor(token) {
+		super(`${token} can only be injected while resolving a provider or running an app hook.`);
+		this.name = "InjectContextError";
+	}
+};
+//#endregion
+//#region src/token.ts
+function token(description) {
+	const id = Symbol(description);
+	if (description === void 0) return { id };
+	return {
+		id,
+		description
+	};
+}
+function tokenName(tokenValue) {
+	if (typeof tokenValue === "string") return tokenValue;
+	if (typeof tokenValue === "symbol") return tokenValue.description ?? tokenValue.toString();
+	if (typeof tokenValue === "function") return tokenValue.name || "<anonymous class>";
+	return tokenValue.description ?? tokenValue.id.description ?? tokenValue.id.toString();
+}
+//#endregion
+//#region src/inject.ts
+let activeResolutionContext;
+function inject(token) {
+	if (activeResolutionContext === void 0) throw new InjectContextError(tokenName(token));
+	return activeResolutionContext.requestContainer.get(token);
+}
+function runWithInjectContext(context, callback) {
+	const previousContext = activeResolutionContext;
+	activeResolutionContext = context;
+	try {
+		return callback();
+	} finally {
+		activeResolutionContext = previousContext;
+	}
+}
+//#endregion
+//#region src/provider.ts
+function provide(providerToken, options) {
+	return {
+		provide: providerToken,
+		...options
+	};
+}
+function normalizeProvider(input) {
+	if (typeof input === "function") return normalizeProvider({
+		provide: input,
+		useClass: input
+	});
+	const token = input.provide;
+	const base = {
+		token,
+		tokenName: tokenName(token),
+		multi: input.multi ?? false,
+		leakSafe: input.leakSafe ?? false
+	};
+	if ("useClass" in input) return {
+		...base,
+		provider: {
+			kind: "class",
+			useClass: input.useClass
+		},
+		scope: input.scope ?? "singleton",
+		deps: input.deps ?? input.useClass.inject ?? [],
+		eager: input.eager ?? false,
+		...eraseDispose(input.dispose)
+	};
+	if ("useValue" in input) return {
+		...base,
+		provider: {
+			kind: "value",
+			useValue: input.useValue
+		},
+		scope: "singleton",
+		deps: [],
+		eager: true,
+		...eraseDispose(input.dispose)
+	};
+	if ("useFactory" in input) return {
+		...base,
+		provider: {
+			kind: "factory",
+			useFactory: input.useFactory
+		},
+		scope: input.scope ?? "singleton",
+		deps: input.deps ?? [],
+		eager: input.eager ?? false,
+		...eraseDispose(input.dispose)
+	};
+	return {
+		...base,
+		provider: {
+			kind: "existing",
+			useExisting: input.useExisting
+		},
+		scope: "singleton",
+		deps: [input.useExisting],
+		eager: false
+	};
+}
+function eraseDispose(dispose) {
+	if (dispose === void 0) return {};
+	return { dispose };
+}
+//#endregion
+//#region src/container.ts
+const asyncDisposeSymbol = Symbol.asyncDispose;
+const disposeSymbol = Symbol.dispose;
+function createContainer(options = {}) {
+	return new RuntimeContainer(options);
+}
+var RuntimeContainer = class RuntimeContainer {
+	parent;
+	strictScopes;
+	records = /* @__PURE__ */ new Map();
+	scopedCache = /* @__PURE__ */ new Map();
+	created = [];
+	root;
+	singletonCache = /* @__PURE__ */ new Map();
+	frozen = false;
+	constructor(options = {}) {
+		this.parent = options.parent;
+		this.strictScopes = options.strictScopes ?? this.parent?.strictScopes ?? true;
+		this.root = this.parent?.root ?? this;
+	}
+	get(token, options) {
+		const record = options?.optional === true ? this.getSingleRecord(token, true) : this.getSingleRecord(token, false);
+		if (record === void 0) return;
+		const context = this.createResolutionContext("sync");
+		const value = this.resolveRecord(record, context);
+		if (isPromiseLike(value)) throw new AsyncProviderInSyncResolutionError(record.tokenName);
+		return value;
+	}
+	getAll(token) {
+		const records = this.getAllRecords(token);
+		const context = this.createResolutionContext("sync");
+		return records.map((record) => {
+			const value = this.resolveRecord(record, context);
+			if (isPromiseLike(value)) throw new AsyncProviderInSyncResolutionError(record.tokenName);
+			return value;
+		});
+	}
+	async getAsync(token) {
+		const record = this.getSingleRecord(token, false);
+		const context = this.createResolutionContext("async");
+		return await this.resolveRecord(record, context);
+	}
+	has(token) {
+		return this.findRecords(token).length > 0;
+	}
+	provide(provider) {
+		this.assertMutable();
+		const record = normalizeProvider(provider);
+		const existing = this.records.get(record.token) ?? [];
+		if (!record.multi && existing.some((candidate) => !candidate.multi)) throw new DuplicateProviderError(record.tokenName);
+		this.records.set(record.token, [...existing, record]);
+	}
+	override(provider) {
+		this.assertMutable();
+		const record = normalizeProvider(provider);
+		const kept = (this.records.get(record.token) ?? []).filter((candidate) => candidate.multi && !record.multi);
+		this.records.set(record.token, [...kept, record]);
+	}
+	createScope(options = {}) {
+		return new RuntimeContainer({
+			parent: this,
+			strictScopes: options.strictScopes ?? this.strictScopes
+		});
+	}
+	build(target, options = {}) {
+		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);
+		return Reflect.construct(target, values);
+	}
+	freeze() {
+		this.frozen = true;
+	}
+	async dispose() {
+		const errors = [];
+		for (const entry of [...this.created].toReversed()) {
+			if (entry.disposed) continue;
+			entry.disposed = true;
+			try {
+				await disposeValue(entry.value, entry.record);
+			} catch (error) {
+				errors.push(error);
+			}
+		}
+		this.created.length = 0;
+		this.scopedCache.clear();
+		if (this.root === this) this.singletonCache.clear();
+		if (errors.length > 0) throw new AggregateError(errors, "One or more providers failed to dispose.");
+	}
+	assertMutable() {
+		if (this.frozen) throw new FrozenContainerError();
+	}
+	createResolutionContext(mode) {
+		return {
+			stack: [],
+			resolutionCache: /* @__PURE__ */ new Map(),
+			mode,
+			requestContainer: this
+		};
+	}
+	getSingleRecord(token, optional) {
+		const records = this.findRecords(token);
+		if (records.length === 0) {
+			if (optional) return;
+			throw new MissingProviderError(tokenName(token), []);
+		}
+		const nonMultiRecords = records.filter((record) => !record.multi);
+		if (nonMultiRecords.length === 1) return nonMultiRecords[0];
+		if (records.length === 1) return records[0];
+		throw new AmbiguousProviderError(tokenName(token));
+	}
+	getAllRecords(token) {
+		return this.getAllRecordsFromHierarchy(token);
+	}
+	findRecords(token) {
+		const localRecords = this.records.get(token);
+		if (localRecords !== void 0 && localRecords.length > 0) return localRecords;
+		return this.parent?.findRecords(token) ?? [];
+	}
+	getAllRecordsFromHierarchy(token) {
+		const parentRecords = this.parent?.getAllRecordsFromHierarchy(token) ?? [];
+		const localRecords = this.records.get(token) ?? [];
+		return [...parentRecords, ...localRecords];
+	}
+	resolveRecord(record, context) {
+		const cached = this.getCached(record, context);
+		if (cached.found) return cached.value;
+		this.assertNoCycle(record, context);
+		this.assertLifetimeSafe(record, context);
+		context.stack.push(record);
+		const finalize = (value) => {
+			context.stack.pop();
+			this.setCached(record, value, context);
+			return value;
+		};
+		const fail = (error) => {
+			context.stack.pop();
+			throw error;
+		};
+		try {
+			const value = this.createValue(record, context);
+			if (isPromiseLike(value)) {
+				if (context.mode === "sync") throw new AsyncProviderInSyncResolutionError(record.tokenName);
+				return Promise.resolve(value).then(finalize, fail);
+			}
+			return finalize(value);
+		} catch (error) {
+			return fail(error);
+		}
+	}
+	createValue(record, context) {
+		switch (record.provider.kind) {
+			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));
+				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)));
+				return runWithInjectContext(context, () => provider.useFactory(...deps));
+			}
+			case "existing": return this.resolveDependency(record.provider.useExisting, context);
+		}
+	}
+	resolveDependencies(deps, context) {
+		const values = Array.from({ length: deps.length });
+		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) => {
+				values[index] = resolved;
+				return resolved;
+			}));
+			else values[index] = value;
+		}
+		if (asyncValues.length === 0) return values;
+		return Promise.all(asyncValues).then(() => values);
+	}
+	resolveDependency(dep, context) {
+		if (isDependencyObject(dep)) {
+			if (dep.many === true) {
+				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);
+			if (record === void 0) return;
+			return this.resolveRecord(record, context);
+		}
+		const record = this.getSingleRecord(dep, false);
+		return this.resolveRecord(record, context);
+	}
+	resolveAllRecords(records, context) {
+		const values = records.map((record) => this.resolveRecord(record, context));
+		if (values.some(isPromiseLike)) return Promise.all(values);
+		return values;
+	}
+	getCached(record, context) {
+		const cache = this.cacheFor(record, context);
+		if (cache === void 0 || !cache.has(record)) return { found: false };
+		return {
+			found: true,
+			value: cache.get(record)
+		};
+	}
+	setCached(record, value, context) {
+		const cache = this.cacheFor(record, context);
+		if (cache === void 0) {
+			this.trackCreated(record, value, context);
+			return;
+		}
+		if (!cache.has(record)) {
+			cache.set(record, value);
+			this.trackCreated(record, value, context);
+		}
+	}
+	cacheFor(record, context) {
+		switch (record.scope) {
+			case "singleton": return this.root.singletonCache;
+			case "scoped": return context.requestContainer.scopedCache;
+			case "resolution": return context.resolutionCache;
+			case "transient": return;
+		}
+	}
+	trackCreated(record, value, context) {
+		if (value === null || typeof value !== "object" && typeof value !== "function") return;
+		(record.scope === "singleton" ? this.root : context.requestContainer).created.push({
+			record,
+			value,
+			disposed: false
+		});
+	}
+	assertNoCycle(record, context) {
+		const existingIndex = context.stack.indexOf(record);
+		if (existingIndex === -1) return;
+		throw new CircularDependencyError([...context.stack.slice(existingIndex), record].map((entry) => entry.tokenName));
+	}
+	assertLifetimeSafe(record, context) {
+		if (!this.strictScopes || record.leakSafe || context.stack.length === 0) return;
+		const parent = context.stack.at(-1);
+		if (parent === void 0) return;
+		if (isLifetimeLeak(parent.scope, record.scope)) throw new LifetimeLeakError(parent.tokenName, parent.scope, record.tokenName, record.scope);
+	}
+};
+function isDependencyObject(dep) {
+	return typeof dep === "object" && dep !== null && "token" in dep;
+}
+function isPromiseLike(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+}
+function isLifetimeLeak(parentScope, childScope) {
+	if (parentScope === "singleton") return childScope === "scoped" || childScope === "resolution" || childScope === "transient";
+	if (parentScope === "scoped") return childScope === "resolution" || childScope === "transient";
+	return false;
+}
+async function disposeValue(value, record) {
+	if (record.dispose !== void 0) await record.dispose(value);
+	if (value === null || typeof value !== "object" && typeof value !== "function") return;
+	const maybeDisposable = value;
+	if (asyncDisposeSymbol !== void 0 && typeof maybeDisposable[asyncDisposeSymbol] === "function") {
+		await maybeDisposable[asyncDisposeSymbol]();
+		return;
+	}
+	if (disposeSymbol !== void 0 && typeof maybeDisposable[disposeSymbol] === "function") {
+		maybeDisposable[disposeSymbol]();
+		return;
+	}
+	if (typeof maybeDisposable.dispose === "function") {
+		await maybeDisposable.dispose();
+		return;
+	}
+	if (typeof maybeDisposable.destroy === "function") await maybeDisposable.destroy();
+}
+//#endregion
+//#region src/metadata.ts
+const moduleMetadata = /* @__PURE__ */ new WeakMap();
+function defineModule(target, options = {}) {
+	const metadata = ensureModuleMetadata(target);
+	applyModuleOptions(metadata, options);
+	addProperties(metadata.state, options.state);
+	addProperties(metadata.actions, options.actions);
+	addProperties(metadata.computed, options.computed);
+	return target;
+}
+function getModuleMetadata(target) {
+	return moduleMetadata.get(target);
+}
+function addModuleState(target, property) {
+	ensureModuleMetadata(target).state.add(property);
+}
+function addModuleAction(target, property) {
+	ensureModuleMetadata(target).actions.add(property);
+}
+function addModuleComputed(target, property) {
+	ensureModuleMetadata(target).computed.add(property);
+}
+function applyModuleOptions(metadata, options) {
+	if (options.name !== void 0) metadata.name = options.name;
+	if (options.deps !== void 0) metadata.deps = options.deps;
+	if (options.scope !== void 0) metadata.scope = options.scope;
+}
+function ensureModuleMetadata(target) {
+	let metadata = moduleMetadata.get(target);
+	if (metadata !== void 0) return metadata;
+	metadata = {
+		kind: "module",
+		state: /* @__PURE__ */ new Set(),
+		actions: /* @__PURE__ */ new Set(),
+		computed: /* @__PURE__ */ new Set()
+	};
+	moduleMetadata.set(target, metadata);
+	return metadata;
+}
+function addProperties(target, properties) {
+	for (const property of properties ?? []) target.add(property);
+}
+//#endregion
+//#region src/app.ts
+function createApp(options = {}) {
+	return createAppInternal(options);
+}
+function createAppInternal(options = {}) {
+	const parent = isApp(options.parent) ? options.parent.container : options.parent;
+	const container = parent === void 0 ? createContainer() : createContainer({ parent });
+	const moduleTokens = [];
+	for (const provider of options.providers ?? []) {
+		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);
+	container.freeze();
+	const modules = instantiateModules(container, moduleTokens);
+	const store = create(createRootState(modules), {
+		name: "cosystem",
+		sliceMode: "single"
+	});
+	const app = new RuntimeApp({
+		container,
+		devOptions: options.devOptions ?? {},
+		modules,
+		plugins: options.plugins ?? [],
+		state: { version: 0 },
+		store,
+		...options.testInspector === void 0 ? {} : { testInspector: options.testInspector }
+	});
+	app.bindModules();
+	app.runModuleCreatedHooks();
+	app.init();
+	return app;
+}
+var RuntimeApp = class {
+	container;
+	state;
+	store;
+	devOptions;
+	modules;
+	moduleByToken = /* @__PURE__ */ new Map();
+	moduleByName = /* @__PURE__ */ new Map();
+	plugins;
+	testInspector;
+	initPromise = Promise.resolve();
+	isStarted = false;
+	isDisposed = false;
+	constructor(options) {
+		this.container = options.container;
+		this.devOptions = options.devOptions;
+		this.modules = options.modules;
+		this.plugins = options.plugins;
+		this.state = options.state;
+		this.store = options.store;
+		this.testInspector = options.testInspector;
+		for (const moduleBinding of options.modules) {
+			this.moduleByToken.set(moduleBinding.token, moduleBinding);
+			this.moduleByName.set(moduleBinding.name, moduleBinding);
+		}
+		this.store.subscribe(() => {
+			this.state.version += 1;
+			const state = this.store.getPureState();
+			this.testInspector?.recordPatch(state);
+			this.emitStateChange({ state });
+		});
+	}
+	get started() {
+		return this.isStarted;
+	}
+	get(token) {
+		return this.container.get(token);
+	}
+	getAsync(token) {
+		return this.container.getAsync(token);
+	}
+	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;
+	}
+	getModuleByName(name) {
+		const moduleBinding = this.moduleByName.get(name);
+		if (moduleBinding === void 0) throw new CosystemError(`${name} is not a CoSystem module.`);
+		return moduleBinding.instance;
+	}
+	watch(read, listener, options = {}) {
+		const equals = options.equals ?? Object.is;
+		const tracker = createReactiveTracker();
+		let previous = tracker.track(read);
+		if (options.immediate === true) listener(previous, previous);
+		const publish = () => {
+			const next = tracker.track(read);
+			if (equals(next, previous)) return;
+			const last = previous;
+			previous = next;
+			listener(next, last);
+		};
+		const unsubscribeStore = this.store.subscribe(publish);
+		const unsubscribeTracker = tracker.subscribe(publish);
+		return () => {
+			unsubscribeStore();
+			unsubscribeTracker();
+			tracker.dispose();
+		};
+	}
+	async start() {
+		if (this.isStarted) return;
+		await this.initPromise;
+		await this.runLifecycle("onStart");
+		this.isStarted = true;
+	}
+	async stop() {
+		if (!this.isStarted) return;
+		await this.runLifecycle("onStop", true);
+		this.isStarted = false;
+	}
+	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;
+	}
+	createScope(options) {
+		return { container: this.container.createScope(options) };
+	}
+	bindModules() {
+		for (const moduleBinding of this.modules) {
+			this.bindState(moduleBinding);
+			this.bindComputed(moduleBinding);
+			this.bindActions(moduleBinding);
+		}
+	}
+	runModuleCreatedHooks() {
+		for (const moduleBinding of this.modules) {
+			const event = {
+				name: moduleBinding.name,
+				token: moduleBinding.token,
+				instance: moduleBinding.instance
+			};
+			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");
+		})();
+	}
+	bindState(moduleBinding) {
+		for (const property of moduleBinding.metadata.state) Object.defineProperty(moduleBinding.instance, property, {
+			configurable: true,
+			enumerable: true,
+			get: () => this.readModuleState(moduleBinding, property),
+			set: (value) => this.writeModuleState(moduleBinding, property, value)
+		});
+	}
+	bindActions(moduleBinding) {
+		for (const property of moduleBinding.metadata.actions) {
+			const action = getMethod(moduleBinding.instance, property);
+			moduleBinding.originalActions.set(property, action);
+			Object.defineProperty(moduleBinding.instance, property, {
+				configurable: true,
+				value: (...args) => this.runAction(moduleBinding, property, args)
+			});
+		}
+	}
+	bindComputed(moduleBinding) {
+		for (const property of moduleBinding.metadata.computed) {
+			const getter = getGetter(moduleBinding.instance, property);
+			moduleBinding.originalComputed.set(property, getter);
+			Object.defineProperty(moduleBinding.instance, property, {
+				configurable: true,
+				enumerable: true,
+				get: () => getter.call(moduleBinding.instance)
+			});
+		}
+	}
+	readModuleState(moduleBinding, property) {
+		return this.store.getState()[moduleBinding.name]?.[property];
+	}
+	writeModuleState(moduleBinding, property, value) {
+		if (moduleBinding.activeDraft !== void 0) {
+			moduleBinding.activeDraft[property] = value;
+			return;
+		}
+		if (this.devOptions.strictActions === true && moduleBinding.actionDepth === 0) throw new CosystemError(`Cannot write ${moduleBinding.name}.${String(property)} outside an action.`);
+		this.store.setState((draft) => {
+			draft[moduleBinding.name] ??= {};
+			draft[moduleBinding.name][property] = value;
+		});
+	}
+	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.`);
+		const event = {
+			args,
+			method: String(property),
+			module: moduleBinding.name,
+			startedAt: Date.now()
+		};
+		this.emitActionStart(event);
+		let result;
+		let error;
+		try {
+			moduleBinding.actionDepth += 1;
+			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]);
+				} finally {
+					moduleBinding.activeDraft = previousDraft;
+				}
+			});
+		} catch (caught) {
+			error = caught;
+		} finally {
+			moduleBinding.actionDepth -= 1;
+		}
+		const endedEvent = {
+			...event,
+			endedAt: Date.now(),
+			...error === void 0 ? {} : { error }
+		};
+		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]?.();
+	}
+	emitActionStart(event) {
+		for (const plugin of this.plugins) plugin.onActionStart?.(event);
+	}
+	emitActionEnd(event) {
+		for (const plugin of this.plugins) plugin.onActionEnd?.(event);
+	}
+	emitStateChange(event) {
+		for (const plugin of this.plugins) plugin.onStateChange?.(event);
+	}
+};
+function normalizeAppProvider(provider) {
+	if (typeof provider === "function") {
+		const metadata = getModuleMetadata(provider);
+		if (metadata !== void 0) return {
+			provider: provide(provider, createModuleClassProviderOptions(provider, metadata)),
+			moduleToken: provider
+		};
+		return { provider };
+	}
+	if ("useClass" in provider) {
+		const metadata = getModuleMetadata(provider.useClass);
+		if (metadata !== void 0) return {
+			provider: {
+				...provider,
+				...mergeModuleClassProviderOptions(provider, metadata)
+			},
+			moduleToken: provider.provide
+		};
+	}
+	return { provider };
+}
+function createModuleClassProviderOptions(useClass, metadata) {
+	return {
+		useClass,
+		...metadata.deps === void 0 ? {} : { deps: metadata.deps },
+		...metadata.scope === void 0 ? {} : { scope: metadata.scope }
+	};
+}
+function mergeModuleClassProviderOptions(provider, metadata) {
+	return {
+		..."deps" in provider || metadata.deps === void 0 ? {} : { deps: metadata.deps },
+		..."scope" in provider || metadata.scope === void 0 ? {} : { scope: metadata.scope }
+	};
+}
+function instantiateModules(container, moduleTokens) {
+	const modules = [];
+	for (const moduleToken of moduleTokens) {
+		const instance = container.get(moduleToken);
+		const metadata = getModuleMetadata(instance.constructor);
+		if (metadata === void 0) continue;
+		const name = metadata.name ?? stableModuleName(moduleToken);
+		if (modules.some((moduleBinding) => moduleBinding.name === name)) throw new DuplicateProviderError(name);
+		modules.push({
+			actionDepth: 0,
+			activeDraft: void 0,
+			instance,
+			metadata,
+			name,
+			originalActions: /* @__PURE__ */ new Map(),
+			originalComputed: /* @__PURE__ */ new Map(),
+			token: moduleToken
+		});
+	}
+	return modules;
+}
+function createRootState(modules) {
+	const rootState = {};
+	for (const moduleBinding of modules) {
+		const state = {};
+		for (const property of moduleBinding.metadata.state) state[property] = moduleBinding.instance[property];
+		rootState[moduleBinding.name] = state;
+	}
+	return rootState;
+}
+function stableModuleName(token) {
+	const name = tokenName(token);
+	return `${name.slice(0, 1).toLowerCase()}${name.slice(1)}`;
+}
+function getMethod(instance, property) {
+	const descriptor = getDescriptor(instance, property);
+	if (descriptor?.value === void 0 || typeof descriptor.value !== "function") throw new CosystemError(`${String(property)} is not a method.`);
+	return descriptor.value;
+}
+function getGetter(instance, property) {
+	const descriptor = getDescriptor(instance, property);
+	if (descriptor?.get === void 0) throw new CosystemError(`${String(property)} is not a getter.`);
+	return descriptor.get;
+}
+function getDescriptor(instance, property) {
+	let current = instance;
+	while (current !== null) {
+		const descriptor = Object.getOwnPropertyDescriptor(current, property);
+		if (descriptor !== void 0) return descriptor;
+		current = Object.getPrototypeOf(current);
+	}
+}
+function isApp(value) {
+	return typeof value === "object" && value !== null && "get" in value && "start" in value && "dispose" in value;
+}
+//#endregion
+//#region src/decorators.ts
+function module(options = {}) {
+	return function moduleDecorator(target, _context) {
+		defineModule(target, options);
+		return target;
+	};
+}
+function state(_value, context) {
+	if (context.kind !== "accessor") throw new TypeError("@state only supports standard accessor decorators.");
+	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.");
+	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.");
+	context.addInitializer(function initializeComputed() {
+		addModuleComputed(this.constructor, context.name);
+	});
+}
+//#endregion
+//#region src/testApp.ts
+function testApp(options = {}) {
+	const inspector = createTestInspector();
+	const { autoStart, overrides, strictActions, ...createOptions } = options;
+	const app = createAppInternal({
+		...createOptions,
+		devOptions: {
+			...createOptions.devOptions,
+			...strictActions === void 0 ? {} : { strictActions }
+		},
+		...overrides === void 0 ? {} : { overrides },
+		testInspector: inspector
+	});
+	Object.defineProperty(app, "test", {
+		configurable: false,
+		enumerable: false,
+		value: inspector
+	});
+	if (autoStart === true) return app.start().then(() => app);
+	return app;
+}
+function createTestInspector() {
+	const actions = [];
+	const patches = [];
+	let lastState;
+	return {
+		clearActions() {
+			actions.length = 0;
+		},
+		clearPatches() {
+			patches.length = 0;
+		},
+		flushEffects() {
+			return Promise.resolve();
+		},
+		getActions() {
+			return actions;
+		},
+		getPatches() {
+			return patches;
+		},
+		getState() {
+			return lastState;
+		},
+		recordAction(event) {
+			actions.push(event);
+		},
+		recordPatch(patch) {
+			lastState = patch;
+			patches.push(patch);
+		}
+	};
+}
+//#endregion
+//#region src/worker.ts
+function createWorkerApp(options) {
+	const { transport, ...appOptions } = options;
+	const app = createApp(appOptions);
+	const unsubscribeTransport = transport.subscribe((message) => {
+		if (message.type !== "call") return;
+		handleCall(app, transport, message);
+	});
+	const unsubscribeStore = app.store.subscribe(() => {
+		publishState(app, transport);
+	});
+	transport.post({ type: "ready" });
+	publishState(app, transport);
+	return {
+		app,
+		async dispose() {
+			unsubscribeTransport();
+			unsubscribeStore();
+			await app.dispose();
+		}
+	};
+}
+function createWorkerClient(options) {
+	const { transport } = options;
+	const listeners = /* @__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);
+	});
+	const client = {
+		state,
+		call(module, method, ...args) {
+			const id = nextId;
+			nextId += 1;
+			return new Promise((resolve, reject) => {
+				pending.set(id, {
+					reject,
+					resolve
+				});
+				transport.post({
+					args,
+					id,
+					method,
+					module,
+					type: "call"
+				});
+			});
+		},
+		dispose() {
+			unsubscribe();
+			for (const entry of pending.values()) entry.reject(new CosystemError("Worker client disposed before response."));
+			pending.clear();
+			listeners.clear();
+		},
+		getState() {
+			return snapshot;
+		},
+		module(name) {
+			return new Proxy({}, { get(_target, property) {
+				if (typeof property !== "string") return;
+				return (...args) => client.call(name, property, ...args);
+			} });
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+	return client;
+}
+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) {
+	try {
+		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.`);
+		const value = await method.apply(module, message.args);
+		transport.post({
+			id: message.id,
+			type: "result",
+			value
+		});
+	} catch (error) {
+		transport.post({
+			error: serializeError(error),
+			id: message.id,
+			type: "result"
+		});
+	}
+}
+function publishState(app, transport) {
+	transport.post({
+		state: app.store.getPureState(),
+		type: "state",
+		version: app.state.version
+	});
+}
+function createMemoryWorkerTransport(inbox, outbox) {
+	return {
+		post(message) {
+			for (const listener of outbox) listener(message);
+		},
+		subscribe(listener) {
+			inbox.add(listener);
+			return () => {
+				inbox.delete(listener);
+			};
+		}
+	};
+}
+function serializeError(error) {
+	if (error instanceof Error) return {
+		message: error.message,
+		name: error.name,
+		...error.stack === void 0 ? {} : { stack: error.stack }
+	};
+	return {
+		message: String(error),
+		name: "Error"
+	};
+}
+function createRemoteError(error) {
+	const remoteError = new CosystemError(`Remote worker error: ${error.message}`);
+	remoteError.name = error.name;
+	if (error.stack !== void 0) remoteError.stack = error.stack;
+	return remoteError;
+}
+//#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 };
+
+//# sourceMappingURL=index.mjs.map