@daneren2005/shared-memory-ecs 1.8.2 → 1.10.0

package/dist/index.js

@@ -1,17 +1,17 @@
-import { _ as e, a as t, c as n, d as r, f as i, g as a, h as o, i as s, l as c, m as l, n as u, o as d, p as f, r as p, s as m, t as h, u as g, v as _ } from "./create-system-worker-C4aS3-3R.js";
-import v from "@daneren2005/shared-memory-objects/memory-heap";
-import { MAX_BYTE_OFFSET_LENGTH as y } from "@daneren2005/shared-memory-objects/utils/pointer";
+import { _ as e, a as t, c as n, d as r, f as i, g as a, h as o, i as s, l as c, m as l, n as u, o as d, p as f, r as p, s as m, t as ee, u as te, v as h, y as g } from "./create-system-worker-CNpRs2FO.js";
+import ne from "@daneren2005/shared-memory-objects/memory-heap";
+import { MAX_BYTE_OFFSET_LENGTH as _ } from "@daneren2005/shared-memory-objects/utils/pointer";
 //#region \0rolldown/runtime.js
-var b = Object.create, x = Object.defineProperty, S = Object.getOwnPropertyDescriptor, C = Object.getOwnPropertyNames, w = Object.getPrototypeOf, T = Object.prototype.hasOwnProperty, E = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t.exports), D = (e, t, n, r) => {
-	if (t && typeof t == "object" || typeof t == "function") for (var i = C(t), a = 0, o = i.length, s; a < o; a++) s = i[a], !T.call(e, s) && s !== n && x(e, s, {
+var v = Object.create, y = Object.defineProperty, re = Object.getOwnPropertyDescriptor, b = Object.getOwnPropertyNames, x = Object.getPrototypeOf, S = Object.prototype.hasOwnProperty, ie = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t.exports), ae = (e, t, n, r) => {
+	if (t && typeof t == "object" || typeof t == "function") for (var i = b(t), a = 0, o = i.length, s; a < o; a++) s = i[a], !S.call(e, s) && s !== n && y(e, s, {
 		get: ((e) => t[e]).bind(null, s),
-		enumerable: !(r = S(t, s)) || r.enumerable
+		enumerable: !(r = re(t, s)) || r.enumerable
 	});
 	return e;
-}, O = /* @__PURE__ */ ((e, t, n) => (n = e == null ? {} : b(w(e)), D(t || !e || !e.__esModule || !T.call(e, "default") ? x(n, "default", {
+}, C = /* @__PURE__ */ ((e, t, n) => (n = e == null ? {} : v(x(e)), ae(t || !e || !e.__esModule || !S.call(e, "default") ? y(n, "default", {
 	value: e,
 	enumerable: !0
-}) : n, e)))((/* @__PURE__ */ E(((e, t) => {
+}) : n, e)))((/* @__PURE__ */ ie(((e, t) => {
 	var n = Object.prototype.hasOwnProperty, r = "~";
 	function i() {}
 	Object.create && (i.prototype = Object.create(null), new i().__proto__ || (r = !1));
@@ -98,14 +98,18 @@ var b = Object.create, x = Object.defineProperty, S = Object.getOwnPropertyDescr
 		var t;
 		return e ? (t = r ? r + e : e, this._events[t] && s(this, t)) : (this._events = new i(), this._eventsCount = 0), this;
 	}, c.prototype.off = c.prototype.removeListener, c.prototype.addListener = c.prototype.on, c.prefixed = r, c.EventEmitter = c, t !== void 0 && (t.exports = c);
-})))(), 1), k = class extends O.default {
+})))(), 1), w = class extends C.default {
 	world;
 	name;
 	currentDelta = 0;
 	deltaBetweenRuns;
 	firstRun;
+	reads;
+	writes;
+	exclusive;
+	scheduledGameTime;
 	constructor(e, t = { name: "System" }) {
-		super(), this.name = t.name, this.world = e, this.deltaBetweenRuns = t.deltaBetweenRuns ?? 0, this.firstRun = t.firstRun !== void 0 && t.firstRun;
+		super(), this.name = t.name, this.world = e, this.reads = t.reads, this.writes = t.writes, this.exclusive = t.exclusive ?? !1, this.deltaBetweenRuns = t.deltaBetweenRuns ?? 0, this.firstRun = t.firstRun !== void 0 && t.firstRun;
 	}
 	init() {}
 	clear() {
@@ -113,6 +117,18 @@ var b = Object.create, x = Object.defineProperty, S = Object.getOwnPropertyDescr
 	}
 	finishLoading() {}
 	addEntities(e) {}
+	get gameTime() {
+		return this.scheduledGameTime ?? this.world.gameTime;
+	}
+	withGameTime(e, t) {
+		let n = this.scheduledGameTime;
+		this.scheduledGameTime = e;
+		try {
+			return t();
+		} finally {
+			this.scheduledGameTime = n;
+		}
+	}
 	update(e) {
 		if (this.currentDelta += e, this.currentDelta >= this.deltaBetweenRuns || this.firstRun) {
 			let e = 0;
@@ -141,17 +157,30 @@ var b = Object.create, x = Object.defineProperty, S = Object.getOwnPropertyDescr
 	shouldRun() {
 		return !0;
 	}
+	get readComponents() {
+		return this.reads;
+	}
+	get requiresExclusiveScheduling() {
+		return this.exclusive;
+	}
+	get createdComponents() {
+		return [];
+	}
+	get creationReadComponents() {
+		return this.readComponents;
+	}
+	get creationReadQueries() {}
 	destroy() {
 		this.removeAllListeners();
 	}
 };
-function A(e, t, n) {
+function T(e, t, n) {
 	let r = e.groups.map(t);
 	for (let t = 0; t < e.entities.length; t++) r[e.groupIndexes[t]] && n(e.entities[t]);
 }
 //#endregion
 //#region src/systems/iterable-system.ts
-var j = class extends k {
+var E = class extends w {
 	remainingInstancesToRun = [];
 	remainingInstancesStartTime = null;
 	iterationsPerCheck;
@@ -201,7 +230,7 @@ var j = class extends k {
 	}
 	beforeRunIterables() {}
 	getIterableEntityId(e) {}
-}, M = class e extends j {
+}, D = class e extends E {
 	entities = /* @__PURE__ */ new Map();
 	options;
 	constructor(e, t = { name: "EntitySystem" }) {
@@ -239,7 +268,7 @@ var j = class extends k {
 			t.entities.forEach((e) => this.onEntityAdded(e));
 			return;
 		}
-		A(t, (e) => this.hasComponents(e), (e) => {
+		T(t, (e) => this.hasComponents(e), (e) => {
 			this.filterEntity(e) && (this.entities.set(e.eid, e), this.options.updateEntityOnAdd && this.updateEntity(e, 0));
 		});
 	}
@@ -255,11 +284,28 @@ var j = class extends k {
 	shouldRun() {
 		return this.isCurrentlyRunning() || this.entities.size > 0;
 	}
-}, N = class {
+	get creationReadComponents() {
+		if (!this.options.components) return this.reads ? ["entity", ...this.reads] : void 0;
+		let e = this.options.components.filter((e) => e !== "entity");
+		return [...this.reads ?? [], ...e.length ? e : ["entity"]];
+	}
+	get creationReadQueries() {
+		if (this.checkAddEntity === e.prototype.checkAddEntity) return [this.options.components ?? []];
+	}
+	get readComponents() {
+		let e = this.options.components ?? this.reads;
+		return e ? [
+			"entity",
+			...e,
+			...this.reads ?? []
+		] : void 0;
+	}
+}, O = class {
 	onmessage(e, t = []) {}
-}, P = class extends N {
+}, k = class extends O {
 	updateFunction;
 	entities = [];
+	workState = new a();
 	queryEntities = {};
 	worldExtension;
 	world;
@@ -274,57 +320,67 @@ var j = class extends k {
 			allocateComponentBlock: (e, t) => i[e].memoryComponent.create(t)
 		};
 	}
-	postMessage(e) {
-		if (e.type === "init") this.onMessageTyped({ type: "init-complete" });
-		else if (e.type === "load") this.worldExtension = this.updateFunction.init?.(e.data) ?? void 0, this.onMessageTyped({ type: "loaded" });
-		else if (e.type === "reset") this.entities = [], this.queryEntities = {};
-		else if (e.type === "run") {
-			if (this.worldExtension && Object.assign(e.world, this.worldExtension), e.world.getString = (e) => this.world.constantStrings.getString(e) ?? "", e.world.heap = this.world.heap, e.world.allocate = this.allocator, this.createsEntities) {
-				let t = this.world.registry;
-				e.world.buildEntityDescriptor = (e) => o(e, this.world.factory.configs, t, this.allocator, this.world.factory.getWorkerClasses());
+	getString = (e) => this.world.constantStrings.getString(e) ?? "";
+	postMessage(t) {
+		if (t.type === "init") this.onMessageTyped({ type: "init-complete" });
+		else if (t.type === "load") {
+			this.entities = e(this.entities, t.entities), Object.entries(t.queries).forEach(([t, n]) => {
+				this.queryEntities[t] = e(this.queryEntities[t] ?? [], n);
+			});
+			let n = {
+				gameTime: t.gameTime,
+				getString: this.getString,
+				heap: this.world.heap
+			};
+			this.worldExtension = this.updateFunction.init?.(n, t.data, this.entities, this.queryEntities) ?? void 0, this.onMessageTyped({ type: "loaded" });
+		} else if (t.type === "reset") this.workState.clear(), this.entities = [], this.queryEntities = {};
+		else if (t.type === "run") {
+			if (t.world = this.workState.getWorld(t.world, t.workBatch), this.worldExtension && Object.assign(t.world, this.worldExtension), t.world.getString = this.getString, t.world.heap = this.world.heap, t.world.allocate = this.allocator, this.createsEntities) {
+				let e = this.world.registry;
+				t.world.buildEntityDescriptor = (t) => o(t, this.world.factory.configs, e, this.allocator, this.world.factory.getWorkerClasses());
 			}
 			if (this.addsComponents) {
-				let t = this.world.registry;
-				e.world.buildComponentDescriptor = (e, n) => l(e, n, t, this.allocator);
+				let e = this.world.registry;
+				t.world.buildComponentDescriptor = (t, n) => l(t, n, e, this.allocator);
 			}
-			let t = performance.now(), n = [], r = {}, i = [], s = [], c = [];
-			this.entities = a(this.entities, e.entities);
-			let u = {};
-			Object.entries(e.queries).forEach(([e, t]) => {
-				let n = a(this.queryEntities[e] ?? [], t);
-				this.queryEntities[e] = n, u[e] = n;
+			let n = performance.now(), r = [], i = {}, a = [], s = [], c = [];
+			this.entities = e(this.entities, t.entities);
+			let u = this.workState.getEntities(this.entities, t.entities, t.workBatch), d = {};
+			Object.entries(t.queries).forEach(([t, n]) => {
+				let r = e(this.queryEntities[t] ?? [], n);
+				this.queryEntities[t] = r, d[t] = r;
 			});
-			let d = {
-				entityComponentChanged(e, t, r, i) {
-					n.push({
+			let f = {
+				entityComponentChanged(e, t, n, i) {
+					r.push({
 						entityId: e,
 						event: "component-property-updated",
 						args: [
 							t,
-							r,
+							n,
 							i
 						]
 					});
 				},
-				emitEntityEvent(e, t, ...r) {
-					n.push({
+				emitEntityEvent(e, t, ...n) {
+					r.push({
 						entityId: e,
 						event: t,
-						args: r
+						args: n
 					});
 				},
 				emitSystemEvent(e, t) {
-					(r[e] ?? (r[e] = [])).push(t);
+					(i[e] ?? (i[e] = [])).push(t);
 				},
 				entityDied(e) {
-					n.push({
+					r.push({
 						entityId: e,
 						event: "death",
 						args: []
 					});
 				},
 				createEntity(e) {
-					i.push(e);
+					a.push(e);
 				},
 				addComponent(e, t) {
 					s.push({
@@ -342,8 +398,8 @@ var j = class extends k {
 				}
 			};
 			if (this.updateFunction.queryChanged) {
-				for (let [t, n] of Object.entries(e.queries)) if (n.added.length || n.removed.length) try {
-					this.updateFunction.queryChanged(e.world, t, n, d);
+				for (let [e, n] of Object.entries(t.queries)) if (n.added.length || n.removed.length) try {
+					this.updateFunction.queryChanged(t.world, e, n, f);
 				} catch (e) {
 					c.push({
 						error: e,
@@ -351,65 +407,80 @@ var j = class extends k {
 					});
 				}
 			}
-			let f = !1;
-			if (this.updateFunction.preRun) try {
-				this.updateFunction.preRun(e.world, this.entities, u, d);
+			let p = !1;
+			if (this.updateFunction.preRun && (!t.workBatch || t.workBatch.first)) try {
+				this.updateFunction.preRun(t.world, this.entities, d, f);
 			} catch (e) {
-				f = !0, c.push({
+				p = !0, c.push({
 					error: e,
 					phase: "preRun"
 				});
 			}
-			if (f || this.entities.forEach((t) => {
+			if (!p && this.updateFunction.preBatch) try {
+				this.updateFunction.preBatch(t.world, u, d, f);
+			} catch (e) {
+				p = !0, c.push({
+					error: e,
+					phase: "preBatch"
+				});
+			}
+			if (p || u.forEach((e) => {
 				try {
-					this.updateFunction(e.world, t.entityId, t.components, u, d);
-				} catch (e) {
+					this.updateFunction(t.world, e.entityId, e.components, d, f);
+				} catch (t) {
 					c.push({
-						error: e,
+						error: t,
 						phase: "update",
-						entityId: t.entityId
+						entityId: e.entityId
 					});
 				}
-			}), this.updateFunction.entityRemoved) for (let t of e.entities.removed) try {
-				this.updateFunction.entityRemoved(e.world, t, d);
-			} catch (e) {
+			}), this.updateFunction.entityRemoved) for (let e of t.entities.removed) try {
+				this.updateFunction.entityRemoved(t.world, e, f);
+			} catch (t) {
 				c.push({
-					error: e,
+					error: t,
 					phase: "entityRemoved",
-					entityId: t
+					entityId: e
 				});
 			}
-			let p = performance.now() - t;
-			this.onMessageTyped({
+			let m = performance.now() - n;
+			this.workState.finish(t.workBatch, p), this.onMessageTyped({
 				type: "run-complete",
-				generation: e.generation,
-				runTime: p,
-				events: n,
-				systemEvents: r,
-				created: i,
+				generation: t.generation,
+				runTime: m,
+				events: r,
+				systemEvents: i,
+				created: a,
 				componentChanges: s,
-				errors: c
+				errors: c,
+				workFailed: p
 			});
 		}
 	}
 	onMessageTyped(e) {
 		this.onmessage({ data: e });
 	}
-}, F = "___main", I = class e extends k {
+}, A = "___main", j = class e extends w {
 	entities = /* @__PURE__ */ new Map();
 	options;
 	worker;
 	isWorkerThread;
 	initialized = !1;
 	initPromise = null;
+	initError = null;
 	loadingPromise = null;
 	runCompletePromise = null;
 	isRunning = !1;
+	workPass;
+	timingBatch;
+	pendingEffects;
+	completeEffects;
 	generation = 0;
 	queryEntities = {};
 	queryDeltas = {};
 	constructor(e, t) {
-		super(e, t), this.options = t, Object.keys(this.options.queries ?? {}).forEach((e) => {
+		if (super(e, t), t.workBatchSize !== void 0 && (!Number.isSafeInteger(t.workBatchSize) || t.workBatchSize <= 0)) throw Error("workBatchSize must be a positive safe integer");
+		this.options = t, Object.keys(this.options.queries ?? {}).forEach((e) => {
 			this.queryEntities[e] = /* @__PURE__ */ new Map();
 		}), e.on("entity-added", (t) => {
 			e.isBulkLoading || this.checkAddEntity(t);
@@ -422,55 +493,102 @@ var j = class extends k {
 				type: "grow-buffer",
 				buffer: e
 			});
-		})) : (this.worker = new P(t.updateFunction, e, !!t.createsEntities, !!t.addsComponents), this.isWorkerThread = !1), this.initWorker();
+		})) : (this.worker = new k(t.updateFunction, e, !!t.createsEntities, !!t.addsComponents), this.isWorkerThread = !1), this.initWorker();
 	}
 	initWorker() {
-		this.worker.onmessage = (e) => {
-			let t = e.data;
-			if (t.type === "init-complete") this.initialized = !0, this.initPromise &&= (this.initPromise.resolve(), null);
-			else if (t.type === "loaded") this.loadingPromise &&= (this.loadingPromise.resolve(), null);
-			else if (t.type === "grow-buffer-from-worker") this.world.addGrownBuffer(t.buffer);
-			else if (t.type === "run-complete") {
-				if (t.generation !== this.generation) return;
-				this.isRunning = !1, this.world.emit(`system-${this.name}-worker-finished`, t.runTime), t.errors.forEach(({ error: e, entityId: t, phase: n }) => {
-					this.onError(e, {
-						entityId: t,
-						phase: n
-					});
-				}), (t.componentChanges ?? []).forEach((e) => {
-					let t = this.world.getEntityByEid(e.entityId);
-					if (e.type === "add") {
-						let n = this.world.registry[e.component.name];
-						if (!t || !n || e.component.name === "entity") {
-							n?.memoryComponent.delete(e.component.index);
-							return;
+		let e = (e) => {
+			console.error(e, e.cause), this.initialized || (this.initError = e, this.initPromise?.reject(e));
+		};
+		if (!(this.worker instanceof k)) {
+			let t = (t) => {
+				e(Error(`Worker ${this.name} failed to load`, { cause: t }));
+			};
+			this.worker.onerror = t, this.worker.onmessageerror = t;
+		}
+		this.worker.onmessage = (t) => {
+			let n = t.data;
+			if (n.type === "unhandled-rejection") e(Error(`Worker ${this.name} had an unhandled promise rejection`, { cause: n.error }));
+			else if (n.type === "init-complete") this.initialized = !0, this.initPromise &&= (this.initPromise.resolve(), null);
+			else if (n.type === "loaded") this.loadingPromise &&= (this.loadingPromise.resolve(), null);
+			else if (n.type === "grow-buffer-from-worker") this.world.addGrownBuffer(n.buffer);
+			else if (n.type === "run-complete") {
+				if (n.generation !== this.generation) {
+					this.world.scheduler.prepareEffects && this.discardWorkerAllocations(n);
+					return;
+				}
+				let e = this.timingBatch && {
+					...this.timingBatch,
+					last: this.timingBatch.last || !!n.workFailed
+				};
+				if (n.workFailed && (this.workPass = void 0), !this.completeEffects) {
+					this.applyWorkerEffects(n, !0, e);
+					return;
+				}
+				this.world.emit(`system-${this.name}-worker-finished`, n.runTime, e);
+				let t = this.generation, r = !1, i = () => {
+					this.pendingEffects = void 0, this.isRunning = !1, this.runCompletePromise?.resolve(), this.runCompletePromise = null;
+				}, a = {
+					apply: () => {
+						if (!r) {
+							if (t !== this.generation) {
+								a.discard();
+								return;
+							}
+							r = !0, this.pendingEffects = void 0;
+							try {
+								this.applyWorkerEffects(n, !1, e);
+							} catch (e) {
+								this.onError(e, { phase: "run" }), this.world.notifySystemRunCompleted(this);
+							} finally {
+								i();
+							}
 						}
-						let r = e.component.name;
-						t.removeComponent(r), t.attachComponent(r, e.component.index, !0);
-					} else t && e.componentName !== "entity" && t.removeComponent(e.componentName);
-				});
-				for (let e of Object.keys(t.systemEvents)) this.emit(e, t.systemEvents[e]);
-				t.events.forEach((e) => {
-					let t = this.world.getEntityByEid(e.entityId);
-					if (!t) {
-						console.warn(`${this.name}-event ${e.event}: Could not find entity with id ${e.entityId}`);
-						return;
+					},
+					discard: () => {
+						r || (r = !0, this.discardWorkerAllocations(n), i());
 					}
-					t.emit(e.event, ...e.args);
-				}), t.created.forEach((e) => {
-					this.world.adoptEntity(e);
-				}), this.world.emit(`system-${this.name}-worker-events-finished`, t.runTime), this.world.notifySystemRunCompleted(this), this.runCompletePromise &&= (this.runCompletePromise.resolve(), null);
+				};
+				this.pendingEffects = a, this.completeEffects(a);
 			}
 		}, this.worker.postMessage({ type: "init" });
 	}
+	applyWorkerEffects(e, t, n) {
+		this.isRunning = !1, t && this.world.emit(`system-${this.name}-worker-finished`, e.runTime, n), e.errors.forEach(({ error: e, entityId: t, phase: n }) => {
+			this.onError(e, {
+				entityId: t,
+				phase: n
+			});
+		}), (e.componentChanges ?? []).forEach((e) => {
+			let t = this.world.getEntityByEid(e.entityId);
+			if (e.type === "add") {
+				let n = this.world.registry[e.component.name];
+				if (!t || !n || e.component.name === "entity") {
+					n?.memoryComponent.delete(e.component.index);
+					return;
+				}
+				let r = e.component.name;
+				t.removeComponent(r), t.attachComponent(r, e.component.index, !0);
+			} else t && e.componentName !== "entity" && t.removeComponent(e.componentName);
+		});
+		for (let t of Object.keys(e.systemEvents)) this.emit(t, e.systemEvents[t]);
+		e.events.forEach((e) => {
+			let t = this.world.getEntityByEid(e.entityId);
+			if (!t) {
+				console.warn(`${this.name}-event ${e.event}: Could not find entity with id ${e.entityId}`);
+				return;
+			}
+			t.emit(e.event, ...e.args);
+		}), e.created.forEach((e) => {
+			this.world.adoptEntity(e);
+		}), this.world.emit(`system-${this.name}-worker-events-finished`, e.runTime, n), this.world.notifySystemRunCompleted(this), this.runCompletePromise &&= (this.runCompletePromise.resolve(), null);
+	}
+	discardWorkerAllocations(e) {
+		for (let t of e.created) for (let [e, n] of Object.entries(t.components)) this.world.registry[e]?.memoryComponent.delete(n);
+		for (let t of e.componentChanges ?? []) t.type === "add" && this.world.registry[t.component.name]?.memoryComponent.delete(t.component.index);
+	}
 	init() {
-		if (this.initialized) return;
-		if (this.initPromise) return this.initPromise.promise;
-		let { promise: e, resolve: t } = Promise.withResolvers();
-		return this.initPromise = {
-			promise: e,
-			resolve: t
-		}, e;
+		if (this.initError) return Promise.reject(this.initError);
+		if (!this.initialized) return this.initPromise ||= Promise.withResolvers(), this.initPromise.promise;
 	}
 	finishLoading() {
 		let { promise: e, resolve: t } = Promise.withResolvers();
@@ -478,34 +596,72 @@ var j = class extends k {
 			promise: e,
 			resolve: t
 		};
-		let n = {
+		let n = {};
+		Object.entries(this.options.queries ?? {}).forEach(([e, t]) => {
+			n[e] = this.buildQueryDelta(e, t);
+		});
+		let r = {
 			type: "load",
 			data: this.options.getInitData?.(),
+			gameTime: this.gameTime,
+			entities: this.buildQueryDelta(A, this.options),
+			queries: n,
 			heap: this.isWorkerThread ? this.world.heap.getSharedMemory() : void 0,
 			sharedMemory: this.isWorkerThread ? this.world.getSharedComponentMemory() : void 0,
 			factoryConfigs: this.isWorkerThread && this.options.createsEntities ? this.world.factory.configs : void 0,
 			factoryClasses: this.isWorkerThread && this.options.createsEntities ? this.world.factory.getWorkerClasses() : void 0,
 			addsComponents: !!this.options.addsComponents
 		};
-		return this.worker.postMessage(n), e;
+		return this.worker.postMessage(r), e;
 	}
 	clear() {
-		if (super.clear(), this.isRunning && !this.runCompletePromise) {
+		if (super.clear(), this.pendingEffects?.discard(), this.isRunning && !this.runCompletePromise) {
 			let { promise: e, resolve: t } = Promise.withResolvers();
 			this.runCompletePromise = {
 				promise: e,
 				resolve: t
 			};
 		}
-		this.isRunning = !1, this.generation++, this.entities.clear(), Object.values(this.queryEntities).forEach((e) => e.clear()), this.queryDeltas = {}, this.worker.postMessage({ type: "reset" });
+		this.isRunning = !1, this.generation++, this.entities.clear(), Object.values(this.queryEntities).forEach((e) => e.clear()), this.queryDeltas = {}, this.workPass = void 0, this.timingBatch = void 0, this.worker.postMessage({ type: "reset" });
 	}
 	update(e) {
-		return this.isRunning ? (this.currentDelta += e, !1) : super.update(e);
+		return this.isRunning ? (this.currentDelta += e, !1) : this.workPass ? (this.currentDelta += e, this.run(this.workPass.elapsedTime), !0) : super.update(e);
 	}
 	onRunFinished() {}
 	isCurrentlyRunning() {
 		return this.isRunning;
 	}
+	get readComponents() {
+		let e = [this.options, ...Object.values(this.options.queries ?? {})];
+		return [
+			"entity",
+			...this.reads ?? [],
+			...e.flatMap((e) => [...e.required, ...e.optional ?? []])
+		];
+	}
+	get requiresExclusiveScheduling() {
+		return super.requiresExclusiveScheduling || this.options.createsEntities === !0 || !!this.options.addsComponents;
+	}
+	get createdComponents() {
+		let e = this.options.createsEntities;
+		return e && typeof e != "boolean" ? ["entity", ...e] : [];
+	}
+	get creationReadComponents() {
+		let e = Object.values(this.options.queries ?? {});
+		return this.tracksMainQuery && e.push(this.options), [...this.reads ?? [], ...e.flatMap((e) => {
+			let t = e.required.filter((e) => e !== "entity"), n = e.optional?.filter((e) => e !== "entity") ?? [];
+			return [
+				...t.length ? t : ["entity"],
+				...n,
+				...e.not ?? []
+			];
+		})];
+	}
+	get creationReadQueries() {
+		if (this.checkAddEntity !== e.prototype.checkAddEntity || this.matchesQuery !== e.prototype.matchesQuery) return;
+		let t = Object.values(this.options.queries ?? {});
+		return this.tracksMainQuery && t.push(this.options), t.map((e) => e.required);
+	}
 	waitForRunToComplete() {
 		if (this.isRunning) {
 			if (!this.runCompletePromise) {
@@ -519,23 +675,48 @@ var j = class extends k {
 		}
 	}
 	run(e) {
-		let t = {
-			gameTime: this.world.gameTime,
+		let t, n = this.gameTime;
+		if (this.options.workBatchSize !== void 0 && this.tracksMainQuery) {
+			let r = !this.workPass, i = this.workPass ??= {
+				entities: Array.from(this.entities.values()),
+				cursor: 0,
+				elapsedTime: e,
+				gameTime: n
+			};
+			n = i.gameTime, e = i.elapsedTime;
+			let a = Math.min(i.cursor + this.options.workBatchSize, i.entities.length), o = [];
+			for (; i.cursor < a; i.cursor++) {
+				let e = i.entities[i.cursor];
+				this.entities.get(e.eid) === e && o.push(e.eid);
+			}
+			let s = i.cursor === i.entities.length;
+			t = {
+				entityIds: o,
+				first: r,
+				last: s
+			}, s && (this.workPass = void 0);
+		}
+		let r = {
+			gameTime: n,
 			elapsedTime: e
 		};
-		this.addDataToWorld?.(t), this.isRunning = !0;
-		let n = this.buildQueryDelta(F, this.options), r = {};
+		(!t || t.first) && this.addDataToWorld?.(r), this.timingBatch = t && {
+			first: t.first,
+			last: t.last
+		}, this.isRunning = !0, this.completeEffects = this.world.scheduler.prepareEffects?.(this.world, this);
+		let i = this.buildQueryDelta(A, this.options), a = {};
 		Object.entries(this.options.queries ?? {}).forEach(([e, t]) => {
-			r[e] = this.buildQueryDelta(e, t);
+			a[e] = this.buildQueryDelta(e, t);
 		});
-		let i = {
+		let o = {
 			type: "run",
 			generation: this.generation,
-			world: t,
-			entities: n,
-			queries: r
+			world: r,
+			entities: i,
+			queries: a,
+			workBatch: t
 		};
-		this.worker.postMessage(i);
+		this.worker.postMessage(o);
 	}
 	buildQueryDelta(e, t) {
 		let n = this.getQueryDelta(e), r = [];
@@ -592,7 +773,7 @@ var j = class extends k {
 	}
 	checkAddEntity(e) {
 		let t = this.tracksMainQuery && this.matchesQuery(e, this.options);
-		return this.updateEntityList(F, this.entities, e, t), Object.entries(this.options.queries ?? {}).forEach(([t, n]) => {
+		return this.updateEntityList(A, this.entities, e, t), Object.entries(this.options.queries ?? {}).forEach(([t, n]) => {
 			let r = this.queryEntities[t] ?? (this.queryEntities[t] = /* @__PURE__ */ new Map());
 			this.updateEntityList(t, r, e, this.matchesQuery(e, n));
 		}), t;
@@ -602,19 +783,19 @@ var j = class extends k {
 			t.entities.forEach((e) => this.checkAddEntity(e));
 			return;
 		}
-		this.tracksMainQuery && this.addBatchToQuery(F, this.entities, this.options, t), Object.entries(this.options.queries ?? {}).forEach(([e, n]) => {
+		this.tracksMainQuery && this.addBatchToQuery(A, this.entities, this.options, t), Object.entries(this.options.queries ?? {}).forEach(([e, n]) => {
 			let r = this.queryEntities[e] ?? (this.queryEntities[e] = /* @__PURE__ */ new Map());
 			this.addBatchToQuery(e, r, n, t);
 		});
 	}
 	addBatchToQuery(e, t, n, r) {
 		let i = this.getQueryDelta(e);
-		A(r, (e) => this.matchesComponents(e, n), (e) => {
+		T(r, (e) => this.matchesComponents(e, n), (e) => {
 			e.components.entity.dead || n.filter && !n.filter(e) || (t.set(e.eid, e), this.markAdded(i, e));
 		});
 	}
 	removeEntity(e) {
-		this.updateEntityList(F, this.entities, e, !1), Object.entries(this.queryEntities).forEach(([t, n]) => {
+		this.updateEntityList(A, this.entities, e, !1), Object.entries(this.queryEntities).forEach(([t, n]) => {
 			this.updateEntityList(t, n, e, !1);
 		});
 	}
@@ -624,12 +805,12 @@ var j = class extends k {
 		});
 	}
 	shouldRun() {
-		return this.entities.size > 0;
+		return this.workPass !== void 0 || this.entities.size > 0;
 	}
 	destroy() {
-		super.destroy(), "terminate" in this.worker && this.worker.terminate();
+		super.destroy(), this.pendingEffects?.discard(), "terminate" in this.worker && this.worker.terminate();
 	}
-}, L = class extends O.default {
+}, M = class extends C.default {
 	eid;
 	config;
 	world;
@@ -730,7 +911,7 @@ var j = class extends k {
 	assertComponentPropertyMutable(e, t) {
 		if (e === "entity" && (t === "type" || t === "class")) throw Error(`Entity ${t} is immutable`);
 	}
-}, R = class e {
+}, N = class e {
 	world;
 	configs;
 	classes;
@@ -747,7 +928,7 @@ var j = class extends k {
 		this.world = e, this.forbiddenProperties.clear();
 		for (let t of Object.keys(this.classes)) {
 			let n = this.classes[t].entity;
-			if (n !== L && !(n.prototype instanceof L)) throw Error(`Entity class ${t} must extend BaseEntity`);
+			if (n !== M && !(n.prototype instanceof M)) throw Error(`Entity class ${t} must extend BaseEntity`);
 			for (let n of this.classes[t].components) if (n === "entity" || !(n in e.registry)) throw Error(`Entity class ${t} contains unknown or reserved component ${n}`);
 		}
 		for (let e of Object.keys(this.configs)) this.validateTemplate(e, this.configs[e]);
@@ -773,7 +954,7 @@ var j = class extends k {
 	createAdoptedEntity(e, t, n) {
 		if (!t) {
 			if (this.hasClasses) throw Error(`Entity type ${e} has no class`);
-			return new L(this.world, void 0, n);
+			return new M(this.world, void 0, n);
 		}
 		let r = this.classes[t];
 		if (!r) throw Error(`Unknown entity class: ${t}`);
@@ -799,7 +980,7 @@ var j = class extends k {
 		return e ? this.getAllowedComponents(e) : void 0;
 	}
 	createEntity(e) {
-		return new L(this.world, e);
+		return new M(this.world, e);
 	}
 	get hasClasses() {
 		return this.allowedComponents.size > 0;
@@ -864,7 +1045,183 @@ var j = class extends k {
 		}
 		throw Error(`Entity type ${e} class ${t} loads a component outside its class`);
 	}
-}, z = y, B = 1e4, V = class extends O.default {
+}, P = 45, F = "!", I = "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO", L = "PQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}", R = (/* @__PURE__ */ new Int8Array(128)).fill(-1);
+for (let e = 0; e < P; e++) R[I.charCodeAt(e)] = e, R[L.charCodeAt(e)] = e + P;
+function z(e) {
+	let t = "";
+	for (; e >= P;) t += L[e % P], e = Math.floor(e / P);
+	return t + I[e];
+}
+var B = /* @__PURE__ */ new Float32Array(1), V = new Uint32Array(B.buffer);
+function oe(e, t) {
+	switch (e.type) {
+		case "boolean": return typeof t == "boolean" ? I[Number(t)] : void 0;
+		case "string": return t === null ? I[0] : typeof t == "string" && t.length ? z(t.length) + t : void 0;
+		case "float32": return typeof t != "number" || !Number.isFinite(t) || Math.fround(t) !== t ? void 0 : (B[0] = t, z(V[0]));
+		default: {
+			let n = se(e, t);
+			return n === void 0 ? void 0 : z(n);
+		}
+	}
+}
+function se(e, t) {
+	if (typeof t != "number") return;
+	let n = Math.round((t - (e.offset ?? 0)) * 10 ** (e.decimals ?? 0) / (e.step ?? 1));
+	if (!Number.isSafeInteger(n) || H(e, n) !== t) return;
+	if (e.type === "uint") return n >= 0 ? n : void 0;
+	let r = n >= 0 ? n * 2 : -n * 2 - 1;
+	return Number.isSafeInteger(r) ? r : void 0;
+}
+function H(e, t) {
+	return t * (e.step ?? 1) / 10 ** (e.decimals ?? 0) + (e.offset ?? 0);
+}
+function U(e, t) {
+	switch (e.type) {
+		case "boolean": return t !== 0;
+		case "float32": return V[0] = t, B[0];
+		case "uint": return H(e, t);
+		default: return H(e, t % 2 == 0 ? t / 2 : -(t + 1) / 2);
+	}
+}
+function W(e) {
+	return e.types === void 0 ? [e.type] : e.types;
+}
+var G = class {
+	encoders = /* @__PURE__ */ new Map();
+	used = /* @__PURE__ */ new Set();
+	constructor(e) {
+		let t = 0;
+		for (let n of e) {
+			let e = {
+				key: t,
+				definition: n,
+				indices: new Map(n.properties.map((e, t) => [e.name, t]))
+			};
+			for (let r of W(n)) {
+				if (this.encoders.has(r)) throw Error(`Duplicate compressed entity definition for ${r}`);
+				this.encoders.set(r, {
+					prefix: z(t++),
+					group: e
+				});
+			}
+		}
+	}
+	get entityDefinitions() {
+		let e = {};
+		for (let t of this.used) e[t.key] = t.definition;
+		return e;
+	}
+	compress(e) {
+		let t = e.type === void 0 ? void 0 : this.encoders.get(e.type), n = t && this.encode(t, e);
+		return !t || n === void 0 ? e : (this.used.add(t.group), n);
+	}
+	compressAll(e) {
+		let t = e.map((e) => this.compress(e));
+		return {
+			entityDefinitions: this.entityDefinitions,
+			entities: t
+		};
+	}
+	encode(e, t) {
+		let n = [];
+		for (let [r, i] of Object.entries(t)) {
+			if (r === "type" || i === void 0) continue;
+			let t = e.group.indices.get(r);
+			if (t === void 0) return;
+			let a = oe(e.group.definition.properties[t], i);
+			if (a === void 0) return;
+			n[t] = a;
+		}
+		let r = e.prefix;
+		for (let e = 0; e < n.length; e++) r += n[e] ?? F;
+		return r;
+	}
+};
+function ce(e, t) {
+	return new G(t).compressAll(e);
+}
+var K = /* @__PURE__ */ new WeakMap();
+function le(e) {
+	let t = K.get(e);
+	if (t) return t;
+	t = /* @__PURE__ */ new Map();
+	for (let [n, r] of Object.entries(e)) {
+		let e = W(r);
+		for (let i = 0; i < e.length; i++) {
+			if (t.has(Number(n) + i)) throw Error(`Compressed entity definitions overlap at key ${Number(n) + i}`);
+			t.set(Number(n) + i, {
+				type: e[i],
+				properties: r.properties
+			});
+		}
+	}
+	return K.set(e, t), t;
+}
+function q(e, t) {
+	let n = 0, r = () => {
+		if (e[n] === F) {
+			n++;
+			return;
+		}
+		let t = 0, r = 1;
+		for (; n < e.length;) {
+			let i = e.charCodeAt(n++), a = i < 128 ? R[i] : -1;
+			if (a < 0) throw Error(`Invalid compressed entity ${e}`);
+			if (a < P) return t + a * r;
+			t += (a - P) * r, r *= P;
+		}
+		throw Error(`Truncated compressed entity ${e}`);
+	}, i = r(), a = i === void 0 ? void 0 : le(t).get(i);
+	if (!a) throw Error(`No compressed entity definition for ${e}`);
+	let o = { type: a.type };
+	for (let t = 0; n < e.length; t++) {
+		let i = a.properties[t];
+		if (!i) throw Error(`Compressed entity ${e} has more values than ${a.type} defines`);
+		let s = r();
+		if (s !== void 0) {
+			if (i.type !== "string") o[i.name] = U(i, s);
+			else if (s === 0) o[i.name] = null;
+			else {
+				if (n + s > e.length) throw Error(`Truncated compressed entity ${e}`);
+				o[i.name] = e.slice(n, n += s);
+			}
+		}
+	}
+	return o;
+}
+function J(e, t) {
+	return e.map((e) => {
+		if (typeof e != "string") return e;
+		if (!t) throw Error("Compressed entities need entityDefinitions to load");
+		return q(e, t);
+	});
+}
+//#endregion
+//#region src/scheduling/default-scheduler.ts
+var Y = class {
+	update(e, t) {
+		let n = null;
+		return e.systems.forEach((r) => {
+			let i = !0, a = !1, o = !1;
+			e.emit(`system-${r.name}-started`);
+			try {
+				i = r.shouldRun(), i && (a = r.update(t));
+			} catch (t) {
+				let i = t;
+				console.error(i.message, i), o = !0, n = i, e.emit("system-error", {
+					system: r.name,
+					error: i,
+					phase: "run"
+				});
+			}
+			e.emit(`system-${r.name}-finished`, {
+				ran: a,
+				shouldRun: i,
+				failed: o
+			});
+		}), { lastSystemError: n };
+	}
+}, ue = _, X = 1e4, de = class extends C.default {
 	heap;
 	constantStrings;
 	eidCounter;
@@ -872,10 +1229,11 @@ var j = class extends k {
 	factory;
 	entities = /* @__PURE__ */ new Map();
 	systems = [];
+	scheduler;
 	gameTime = 0;
 	playerTime = 0;
 	timeScale = 1;
-	paused = !1;
+	isPaused = !1;
 	destroyed = !1;
 	pristine = !0;
 	isBulkLoading = !1;
@@ -889,20 +1247,21 @@ var j = class extends k {
 		waitingSystems: /* @__PURE__ */ new Set(),
 		waitElapsed: 0
 	};
-	constructor(t, n = {}) {
-		super(), this.heap = new v({ bufferSize: n.heapSize ?? z }), this.constantStrings = new e(this.heap), this.eidCounter = this.heap.allocUI32(1), this.heap.addOnGrowBufferHandlers((e) => this.emit("grow-buffer", e));
-		let r = {
-			...t,
+	clearing = !1;
+	constructor(e, t = {}) {
+		super(), this.scheduler = t.scheduler ?? new Y(), this.heap = new ne({ bufferSize: t.heapSize ?? ue }), this.constantStrings = new h(this.heap), this.eidCounter = this.heap.allocUI32(1), this.heap.addOnGrowBufferHandlers((e) => this.emit("grow-buffer", e));
+		let n = {
+			...e,
 			entity: i
-		}, a = {};
-		for (let e of Object.keys(r)) {
-			let t = r[e];
-			a[e] = {
+		}, r = {};
+		for (let e of Object.keys(n)) {
+			let t = n[e];
+			r[e] = {
 				...t,
-				memoryComponent: new _(this.heap, t.type, t.size)
+				memoryComponent: new g(this.heap, t.type, t.size)
 			};
 		}
-		this.registry = a, this.factory = n.factory ?? new R(), this.factory.setWorld(this);
+		this.registry = r, this.factory = t.factory ?? new N(), this.factory.setWorld(this);
 	}
 	allocateEid() {
 		return Atomics.add(this.eidCounter.data, 0, 1) + 1;
@@ -919,13 +1278,13 @@ var j = class extends k {
 		this.heap.buffers[e.bufferPosition] === void 0 && this.heap.addSharedBuffer(e), this.emit("grow-buffer", e);
 	}
 	get needsSpareBuffer() {
-		return this.systems.some((e) => e instanceof I && e.isWorkerThread && (!!e.options.createsEntities || !!e.options.addsComponents));
+		return this.systems.some((e) => e instanceof j && e.isWorkerThread && (!!e.options.createsEntities || !!e.options.addsComponents));
 	}
 	async init() {
 		await Promise.all(this.systems.map((e) => e.init()).filter((e) => e instanceof Promise));
 	}
-	finishLoadingSystems() {
-		return Promise.all(this.systems.map((e) => e.finishLoading()).filter((e) => e instanceof Promise));
+	async finishLoadingSystems() {
+		await Promise.all(this.systems.map((e) => e.finishLoading()).filter((e) => e instanceof Promise));
 	}
 	addEntity(e, t = !0) {
 		return this.entities.set(e.eid, e), e.world = this, this.pristine = !1, e.on("component-added", (t) => {
@@ -960,29 +1319,34 @@ var j = class extends k {
 		}
 	}
 	load(e) {
-		if (!this.pristine) {
+		if (!this.pristine || this.scheduler.prepareEffects && this.systems.some((e) => e.isCurrentlyRunning())) {
 			for (let e of Array.from(this.entities.values())) this.removeEntity(e);
-			this.systems.forEach((e) => e.clear()), this.consolidateFreeBuffersForReload();
+			this.systems.forEach((e) => e.clear()), this.scheduler.reset?.(this), this.consolidateFreeBuffersForReload();
 		}
 		for (let e of Object.keys(this.factory.configs)) this.constantStrings.getOrCreate(e);
 		for (let e of Object.keys(this.factory.classes)) this.constantStrings.getOrCreate(e);
 		this.isBulkLoading = !0;
 		try {
-			let t = e.entities.map((e) => this.loadEntity(e, !1));
+			let t = ("entityDefinitions" in e ? J(e.entities, e.entityDefinitions) : e.entities).map((e) => this.loadEntity(e, !1));
 			for (let e of t) e.finishLoading(), this.emit("entity-added", e), e.on("death", () => {
 				this.onEntityDied(e);
 			});
 		} finally {
 			this.isBulkLoading = !1;
 		}
-		let t = H(this.entities.values());
-		this.systems.forEach((e) => e.addEntities(t)), this.gameTime = e.gameTime ?? 0, this.playerTime = e.playerTime ?? 0, this.timeScale = e.timeScale ?? 1, this.finishLoadingSystems();
+		let t = fe(this.entities.values());
+		return this.systems.forEach((e) => e.addEntities(t)), this.gameTime = e.gameTime ?? 0, this.playerTime = e.playerTime ?? 0, this.timeScale = e.timeScale ?? 1, this.finishLoadingSystems();
 	}
 	async clear() {
-		if (!this.pristine) {
-			await Promise.all(this.systems.map((e) => e.waitForRunToComplete()).filter((e) => e instanceof Promise));
-			for (let e of Array.from(this.entities.values())) this.removeEntity(e);
-			this.systems.forEach((e) => e.clear()), this.freeAllPendingBuffers(), this.pristine = !0;
+		if (!this.pristine || this.scheduler.beforeClear) {
+			this.clearing = !0;
+			try {
+				this.scheduler.beforeClear?.(this), await Promise.all(this.systems.map((e) => e.waitForRunToComplete()).filter((e) => e instanceof Promise));
+				for (let e of Array.from(this.entities.values())) this.removeEntity(e);
+				this.systems.forEach((e) => e.clear()), this.scheduler.reset?.(this), this.freeAllPendingBuffers(), this.pristine = !0;
+			} finally {
+				this.clearing = !1;
+			}
 		}
 	}
 	removeEntity(e) {
@@ -1018,7 +1382,7 @@ var j = class extends k {
 		});
 	}
 	notifySystemRunCompleted(e) {
-		this.activeFreeBuffer.waitingSystems.delete(e) && this.activeFreeBuffer.waitingSystems.size === 0 && this.processFreeBuffers();
+		this.activeFreeBuffer.waitingSystems.delete(e) && this.activeFreeBuffer.waitingSystems.size === 0 && this.processFreeBuffers(), this.scheduler.runCompleted?.(this, e);
 	}
 	processFreeBuffers() {
 		for (; this.activeFreeBuffer.waitingSystems.size === 0 && (this.activeFreeBuffer.frees.length > 0 && this.performFrees(this.activeFreeBuffer), this.nextFreeBuffer.frees.length !== 0);) this.promoteNextFreeBuffer();
@@ -1042,22 +1406,22 @@ var j = class extends k {
 	}
 	checkFreeBufferTimeout(e) {
 		let t = this.activeFreeBuffer;
-		if (t.waitingSystems.size !== 0 && (t.waitElapsed += e, t.waitElapsed >= B)) {
+		if (t.waitingSystems.size !== 0 && (t.waitElapsed += e, t.waitElapsed >= X)) {
 			let e = Array.from(t.waitingSystems).map((e) => e.name).join(", ");
-			console.warn(`shared-memory-ecs: deferred component free waited over ${B}ms on system(s): ${e}; freeing anyway`), t.waitingSystems.clear(), this.processFreeBuffers();
+			console.warn(`shared-memory-ecs: deferred component free waited over ${X}ms on system(s): ${e}; freeing anyway`), t.waitingSystems.clear(), this.processFreeBuffers();
 		}
 	}
 	addSystem(e) {
-		return this.systems.push(e), this.emit("system-added", e), e;
+		return this.systems.push(e), this.scheduler.systemAdded?.(this, e), this.emit("system-added", e), e;
 	}
 	addSystemIfNotExists(e) {
-		this.systems.findIndex((t) => e.name === t.name) === -1 && (this.systems.push(e), this.emit("system-added", e));
+		this.systems.findIndex((t) => e.name === t.name) === -1 && (this.systems.push(e), this.scheduler.systemAdded?.(this, e), this.emit("system-added", e));
 	}
 	removeSystem(e) {
 		let t = this.systems.findIndex((t) => t.name === e);
 		if (t !== -1) {
 			let [e] = this.systems.splice(t, 1);
-			this.emit("system-removed", e);
+			this.scheduler.systemRemoved?.(this, e), this.emit("system-removed", e);
 		}
 	}
 	update(e) {
@@ -1069,41 +1433,35 @@ var j = class extends k {
 		if (this.playerTime += e, this.paused) return {};
 		let t = e;
 		e = this.timeScale * e, this.gameTime += e, this.processFreeBuffers(), this.needsSpareBuffer && this.heap.ensureSpareBuffer();
-		let n = null;
-		return this.systems.forEach((t) => {
-			let r = !0, i = !1, a = !1;
-			this.emit(`system-${t.name}-started`);
-			try {
-				r = t.shouldRun(), r && (i = t.update(e));
-			} catch (e) {
-				let r = e;
-				console.error(r.message, r), a = !0, n = r, this.emit("system-error", {
-					system: t.name,
-					error: r,
-					phase: "run"
-				});
-			}
-			this.emit(`system-${t.name}-finished`, {
-				ran: i,
-				shouldRun: r,
-				failed: a
-			});
-		}), this.checkFreeBufferTimeout(t), { lastSystemError: n };
+		let n = this.scheduler.update(this, e);
+		return this.checkFreeBufferTimeout(t), n;
 	}
 	pause() {
 		this.paused = !0;
 	}
+	get paused() {
+		return this.isPaused;
+	}
+	set paused(e) {
+		this.isPaused !== e && (this.isPaused = e, e && this.scheduler.pause?.(this));
+	}
+	prepareForSystemDispatch() {
+		return this.dispatchAllowed ? (this.needsSpareBuffer && this.heap.ensureSpareBuffer(), !0) : !1;
+	}
+	get dispatchAllowed() {
+		return !this.clearing && !this.destroyed;
+	}
 	resume() {
 		this.paused = !1;
 	}
 	addEntityToEntityWorkerSystem(e, t) {
 		this.isBulkLoading || this.systems.forEach((n) => {
-			(n instanceof M && n.options.components?.includes(t) || n instanceof I && this.componentAffectsEntityWorkerSystem(n, t)) && n.checkAddEntity(e);
+			(n instanceof D && n.options.components?.includes(t) || n instanceof j && this.componentAffectsEntityWorkerSystem(n, t)) && n.checkAddEntity(e);
 		});
 	}
 	removeEntityFromEntityWorkerSystem(e, t) {
 		this.isBulkLoading || this.systems.forEach((n) => {
-			n instanceof M && n.options.components?.includes(t) ? n.removeEntity(e) : n instanceof I && this.componentAffectsEntityWorkerSystem(n, t) && n.checkAddEntity(e);
+			n instanceof D && n.options.components?.includes(t) ? n.removeEntity(e) : n instanceof j && this.componentAffectsEntityWorkerSystem(n, t) && n.checkAddEntity(e);
 		});
 	}
 	componentAffectsEntityWorkerSystem(e, t) {
@@ -1113,10 +1471,10 @@ var j = class extends k {
 	destroy() {
 		this.destroyed ||= (this.systems.forEach((e) => {
 			e.destroy();
-		}), !0);
+		}), this.scheduler.destroy?.(this), !0);
 	}
 };
-function H(e) {
+function fe(e) {
 	let t = {
 		entities: [],
 		groupIndexes: [],
@@ -1129,28 +1487,279 @@ function H(e) {
 	return t;
 }
 //#endregion
+//#region src/scheduling/conflict-scheduler.ts
+var pe = class {
+	compiled = Object.freeze({
+		order: Object.freeze([]),
+		batches: Object.freeze([])
+	});
+	registeredSystems = [];
+	access = /* @__PURE__ */ new Map();
+	nodes = /* @__PURE__ */ new Set();
+	tails = /* @__PURE__ */ new Map();
+	frontiers = /* @__PURE__ */ new Map();
+	creators = /* @__PURE__ */ new Map();
+	creationReaders = /* @__PURE__ */ new Map();
+	exclusiveTail;
+	running = /* @__PURE__ */ new Map();
+	ready = [];
+	readyIndex = 0;
+	gameTime = 0;
+	pumping = !1;
+	resumeQueued = !1;
+	continuationTimer;
+	generation = 0;
+	publications = /* @__PURE__ */ new Set();
+	publicationReady = [];
+	publishing = !1;
+	get schedule() {
+		return this.compiled;
+	}
+	rebuild(e) {
+		let t = Array.from(new Set(e.systems)), n = t.map((e) => {
+			let t = e.readComponents, n = e.creationReadQueries;
+			return {
+				reads: new Set(t),
+				creationReads: new Set(n === void 0 ? e.creationReadComponents : e.reads),
+				creationQueries: n?.map((e) => Array.from(e)),
+				writes: new Set(e.writes),
+				creates: new Set(e.createdComponents),
+				exclusive: e.requiresExclusiveScheduling || t === void 0 || e.writes === void 0
+			};
+		});
+		this.access = new Map(t.map((e, t) => [e, n[t]]));
+		let r = [], i = [];
+		for (let e = 0; e < t.length; e++) {
+			let a = 0;
+			for (let t = 0; t < e; t++) this.conflicts(n[t], n[e]) && (a = Math.max(a, i[t] + 1));
+			i.push(a), (r[a] ??= []).push(t[e]);
+		}
+		return this.registeredSystems = e.systems.slice(), this.compiled = Object.freeze({
+			order: Object.freeze(r.flat()),
+			batches: Object.freeze(r.map((e) => Object.freeze(e)))
+		}), this.compiled;
+	}
+	systemAdded(e) {
+		this.rebuild(e);
+	}
+	systemRemoved(e) {
+		this.rebuild(e);
+	}
+	update(e, t) {
+		if (this.pumping) throw Error("ConflictScheduler does not support reentrant updates");
+		this.refreshMembership(e), this.gameTime = e.gameTime ?? this.gameTime + t;
+		for (let n of new Set(e.systems)) this.enqueue(n, this.access.get(n), t, this.gameTime);
+		return this.pump(e, !0);
+	}
+	runCompleted(e, t) {
+		let n = this.running.get(t);
+		if (!n || (this.complete(n), this.pumping || this.resumeQueued)) return;
+		this.resumeQueued = !0;
+		let r = this.generation;
+		queueMicrotask(() => {
+			r === this.generation && (this.resumeQueued = !1, this.pump(e, !1));
+		});
+	}
+	pause(e) {
+		this.scheduleContinuation(e);
+	}
+	scheduleContinuation(e) {
+		if (this.continuationTimer !== void 0 || !e.paused || !this.dispatchAllowed(e) || !Array.from(this.running.values()).some((e) => this.isSliced(e))) return;
+		let t = this.generation;
+		this.continuationTimer = setTimeout(() => {
+			t === this.generation && (this.continuationTimer = void 0, e.paused && this.pump(e, "sliced"));
+		}, 0);
+	}
+	isSliced(e) {
+		return e.system instanceof E && e.system.remainingInstancesToRun.length > 0;
+	}
+	reset() {
+		this.continuationTimer !== void 0 && (clearTimeout(this.continuationTimer), this.continuationTimer = void 0);
+		let e = Array.from(this.publications, (e) => e.effects);
+		this.publications.clear(), this.publicationReady = [], this.nodes.clear(), this.tails.clear(), this.frontiers.clear(), this.creators.clear(), this.creationReaders.clear(), this.exclusiveTail = void 0, this.running.clear(), this.ready = [], this.readyIndex = 0, this.gameTime = 0, this.resumeQueued = !1, this.generation++, e.forEach((e) => e.discard());
+	}
+	beforeClear() {
+		this.reset();
+	}
+	prepareEffects(e, t) {
+		let n = this.running.get(t), r = this.generation;
+		return (e) => {
+			if (!n || r !== this.generation || !this.nodes.has(n)) {
+				e.discard();
+				return;
+			}
+			n.effects = e, this.publications.add(n), n.publicationDependencies === 0 && this.publicationReady.push(n), this.publish();
+		};
+	}
+	publish() {
+		if (this.publishing) return;
+		this.publishing = !0;
+		let e = this.generation;
+		try {
+			for (; this.publicationReady.length && e === this.generation;) {
+				let e = this.publicationReady.pop();
+				this.publications.delete(e);
+				let t = e.effects;
+				e.effects = void 0, t.apply();
+			}
+		} finally {
+			this.publishing = !1;
+		}
+	}
+	destroy() {
+		this.reset();
+	}
+	refreshMembership(e) {
+		(e.systems.length !== this.registeredSystems.length || e.systems.some((e, t) => e !== this.registeredSystems[t])) && this.rebuild(e);
+	}
+	pump(e, t) {
+		this.pumping = !0;
+		let n = null, r = this.generation;
+		try {
+			if (t) for (let i of Array.from(this.running.values())) {
+				if (!i.system.isCurrentlyRunning() || t === "sliced" && !this.isSliced(i)) continue;
+				if (!this.prepare(e)) return { lastSystemError: n };
+				let a = this.dispatch(e, i, !0);
+				if (n = a?.lastSystemError ?? n, !a || r !== this.generation) return { lastSystemError: n };
+			}
+			for (; this.readyIndex < this.ready.length && r === this.generation && this.prepare(e);) {
+				let t = this.ready[this.readyIndex++], r = this.dispatch(e, t, !1);
+				if (n = r?.lastSystemError ?? n, !r) {
+					this.nodes.has(t) && t.state === "pending" && this.ready.push(t);
+					break;
+				}
+			}
+		} finally {
+			this.ready = this.ready.slice(this.readyIndex), this.readyIndex = 0, this.pumping = !1, this.scheduleContinuation(e);
+		}
+		return { lastSystemError: n };
+	}
+	enqueue(e, t, n, r) {
+		let i = {
+			system: e,
+			access: t,
+			elapsedTime: n,
+			gameTime: r,
+			state: "pending",
+			dependencies: 0,
+			dependents: [],
+			publicationDependencies: 0,
+			publicationDependents: []
+		}, a = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set(), s = (e) => {
+			e && e.state !== "complete" && a.add(e);
+		};
+		if (s(this.tails.get(e)), s(this.exclusiveTail), t.exclusive) this.tails.forEach(s), this.exclusiveTail = i;
+		else {
+			let n = (e) => {
+				e && e.state !== "complete" && o.add(e);
+			};
+			for (let e of t.creates) {
+				let t = this.frontier(e);
+				n(t.writer), n(t.creator);
+			}
+			if (t.creates.size) for (let e of this.creationReaders.values()) this.observesCreation(t, e.access) && n(e);
+			for (let n of t.reads) if (!t.writes.has(n)) {
+				let t = this.frontier(n);
+				s(t.writer), t.readers.set(e, i);
+			}
+			for (let e of this.creators.values()) this.observesCreation(e.access, t) && s(e);
+			(t.creationReads.size || t.creationQueries?.length) && this.creationReaders.set(t, i);
+			for (let e of t.writes) {
+				let t = this.frontier(e);
+				s(t.writer), s(t.creator), t.readers.forEach(s), t.readers.clear(), t.writer = i;
+			}
+			for (let e of t.creates) this.frontier(e).creator = i;
+			t.creates.size && this.creators.set(t, i);
+		}
+		for (let e of a) e.dependents.push(i);
+		i.dependencies = a.size;
+		for (let e of o) e.publicationDependents.push(i);
+		i.publicationDependencies = o.size, this.nodes.add(i), this.tails.set(e, i), i.dependencies || this.ready.push(i);
+	}
+	frontier(e) {
+		let t = this.frontiers.get(e);
+		return t || (t = { readers: /* @__PURE__ */ new Map() }, this.frontiers.set(e, t)), t;
+	}
+	complete(e) {
+		if (e.state !== "complete") {
+			e.state = "complete", this.nodes.delete(e), this.running.delete(e.system), this.tails.get(e.system) === e && this.tails.delete(e.system), this.exclusiveTail === e && (this.exclusiveTail = void 0), this.creators.get(e.access) === e && this.creators.delete(e.access), this.creationReaders.get(e.access) === e && this.creationReaders.delete(e.access);
+			for (let t of /* @__PURE__ */ new Set([
+				...e.access.reads,
+				...e.access.writes,
+				...e.access.creates
+			])) {
+				let n = this.frontiers.get(t);
+				n?.writer === e && (n.writer = void 0), n?.creator === e && (n.creator = void 0), n?.readers.get(e.system) === e && n.readers.delete(e.system), n && !n.writer && !n.creator && !n.readers.size && this.frontiers.delete(t);
+			}
+			for (let t of e.dependents) --t.dependencies === 0 && this.ready.push(t);
+			e.dependents.length = 0;
+			for (let t of e.publicationDependents) t.publicationDependencies--, t.publicationDependencies === 0 && t.effects && this.publicationReady.push(t);
+			e.publicationDependents.length = 0, this.publish();
+		}
+	}
+	dispatch(e, t, n) {
+		let r = t.system;
+		if (!n && !e.systems.includes(r)) return this.complete(t), {};
+		let i = this.generation, a = !0, o = !1, s = !1, c = null;
+		if (e.emit(`system-${r.name}-started`), this.nodes.has(t) && this.dispatchAllowed(e)) {
+			try {
+				if (!r.withGameTime(t.gameTime, () => (a = n || r.shouldRun(), !this.nodes.has(t) || !this.dispatchAllowed(e) ? !1 : (a ? (t.state = "running", this.running.set(r, t), o = r.update(n ? 0 : t.elapsedTime), i === this.generation && !r.isCurrentlyRunning() && this.complete(t)) : this.complete(t), !0)))) return;
+			} catch (n) {
+				let a = n;
+				console.error(a.message, a), s = !0, c = a, i === this.generation && (r.isCurrentlyRunning() ? (t.state = "running", this.running.set(r, t)) : this.complete(t)), e.emit("system-error", {
+					system: r.name,
+					error: a,
+					phase: "run"
+				});
+			}
+			return e.emit(`system-${r.name}-finished`, {
+				ran: o,
+				shouldRun: a,
+				failed: s
+			}), { lastSystemError: c };
+		}
+	}
+	prepare(e) {
+		return this.dispatchAllowed(e) && e.prepareForSystemDispatch?.() !== !1;
+	}
+	dispatchAllowed(e) {
+		return e.dispatchAllowed !== !1;
+	}
+	observesCreation(e, t) {
+		for (let n of t.creationReads) if (e.creates.has(n)) return !0;
+		return t.creationQueries?.some((t) => t.every((t) => e.creates.has(t))) ?? !1;
+	}
+	conflicts(e, t) {
+		if (e.exclusive || t.exclusive) return !0;
+		for (let n of e.writes) if (t.reads.has(n) || t.writes.has(n)) return !0;
+		for (let n of t.writes) if (e.reads.has(n)) return !0;
+		for (let n of e.creates) if (t.writes.has(n)) return !0;
+		return e.creates.size > 0 && this.observesCreation(e, t);
+	}
+};
+//#endregion
 //#region src/entity-class.ts
-function U(e, t) {
+function me(e, t) {
 	return t;
 }
-function W(e, t) {
+function Z(e, t) {
 	return t;
 }
 //#endregion
 //#region src/actions/kill-entity.ts
-function G(e) {
+function he(e) {
 	e.components.entity.dead = !0, e.emit("death");
 }
 //#endregion
 //#region src/performance-timing.ts
-var K = 1e3, q = {
+var ge = 1e3, Q = {
 	avg: 0,
 	min: 0,
 	max: 0,
 	samples: 0
 };
-function J(e) {
-	if (!e.length) return { ...q };
+function $(e) {
+	if (!e.length) return { ...Q };
 	let t = 0, n = Infinity, r = 0;
 	for (let i of e) t += i, i < n && (n = i), i > r && (r = i);
 	return {
@@ -1160,13 +1769,13 @@ function J(e) {
 		samples: e.length
 	};
 }
-var Y = class extends O.default {
+var _e = class extends C.default {
 	world;
 	ticksBetweenUpdates;
 	stats = {
-		update: { ...q },
+		update: { ...Q },
 		systems: [],
-		events: { ...q }
+		events: { ...Q }
 	};
 	autoUpdate;
 	ticks = 0;
@@ -1182,11 +1791,11 @@ var Y = class extends O.default {
 	}
 	reset() {
 		this.ticks = 0, this.updateTimes = [], this.systemTimings.forEach((e) => {
-			e.run = [], e.events = [], e.eventStart = -1;
+			e.run = [], e.events = [], e.eventStart = -1, e.pendingRun = 0, e.pendingEvents = 0;
 		}), this.stats = {
-			update: { ...q },
+			update: { ...Q },
 			systems: [],
-			events: { ...q }
+			events: { ...Q }
 		};
 	}
 	destroy() {
@@ -1210,11 +1819,13 @@ var Y = class extends O.default {
 			run: [],
 			events: [],
 			eventStart: -1,
-			onRunFinished: (e) => {
-				t.run.push(e), t.eventStart = performance.now();
+			pendingRun: 0,
+			pendingEvents: 0,
+			onRunFinished: (e, n) => {
+				(!n || n.first) && (t.pendingRun = 0, t.pendingEvents = 0), t.pendingRun += e, (!n || n.last) && (t.run.push(t.pendingRun), t.pendingRun = 0), t.eventStart = performance.now();
 			},
-			onEventsFinished: () => {
-				t.eventStart < 0 || (t.events.push(performance.now() - t.eventStart), t.eventStart = -1);
+			onEventsFinished: (e, n) => {
+				t.eventStart < 0 || (t.pendingEvents += performance.now() - t.eventStart, (!n || n.last) && (t.events.push(t.pendingEvents), t.pendingEvents = 0), t.eventStart = -1);
 			}
 		};
 		this.world.on(`system-${e.name}-worker-finished`, t.onRunFinished), this.world.on(`system-${e.name}-worker-events-finished`, t.onEventsFinished), this.systemTimings.set(e.name, t);
@@ -1229,21 +1840,21 @@ var Y = class extends O.default {
 			let t = this.systemTimings.get(e.name);
 			return {
 				name: e.name,
-				run: J(t?.run ?? []),
-				events: J(t?.events ?? [])
+				run: $(t?.run ?? []),
+				events: $(t?.events ?? [])
 			};
-		}), t = { ...q };
+		}), t = { ...Q };
 		return e.forEach((e) => {
 			t.avg += e.events.avg, t.min += e.events.min, t.max += e.events.max, t.samples += e.events.samples;
 		}), this.stats = {
-			update: J(this.updateTimes),
+			update: $(this.updateTimes),
 			systems: e,
 			events: t
 		}, this.ticks = 0, this.updateTimes = [], this.systemTimings.forEach((e) => {
 			e.run = [], e.events = [];
 		}), this.emit("stats-updated", this.stats), this.stats;
 	}
-}, X = class extends I {
+}, ve = class extends j {
 	constructor(e, t) {
 		super(e, {
 			...t,
@@ -1259,6 +1870,6 @@ var Y = class extends O.default {
 	}
 };
 //#endregion
-export { L as BaseEntity, V as BaseWorld, n as CLASS_INDEX, f as Component, e as ConstantStringCache, c as DEAD_INDEX, K as DEFAULT_TICKS_BETWEEN_UPDATES, R as EntityFactory, M as EntitySystem, P as EntitySystemWebWorker, I as EntityWorkerSystem, j as IterableSystem, _ as MemoryComponent, Y as PerformanceTiming, g as STATIC_INDEX, k as System, r as TYPE_INDEX, N as WebWorker, X as WorkerSystem, t as addComponentWorker, p as createEntitySystemWorker, d as createEntityWorker, h as createSystemWorker, U as defineEntityClasses, W as defineEntityConfigs, i as entityDefinition, G as killEntity, m as killEntityWorker, s as removeComponentWorker };
+export { M as BaseEntity, de as BaseWorld, n as CLASS_INDEX, f as Component, pe as ConflictScheduler, h as ConstantStringCache, c as DEAD_INDEX, ge as DEFAULT_TICKS_BETWEEN_UPDATES, Y as DefaultScheduler, G as EntityCompressor, N as EntityFactory, D as EntitySystem, k as EntitySystemWebWorker, j as EntityWorkerSystem, E as IterableSystem, g as MemoryComponent, _e as PerformanceTiming, te as STATIC_INDEX, w as System, r as TYPE_INDEX, O as WebWorker, ve as WorkerSystem, t as addComponentWorker, ce as compressEntities, p as createEntitySystemWorker, d as createEntityWorker, ee as createSystemWorker, J as decompressEntities, q as decompressEntity, me as defineEntityClasses, Z as defineEntityConfigs, i as entityDefinition, he as killEntity, m as killEntityWorker, s as removeComponentWorker };
 
 //# sourceMappingURL=index.js.map