@daneren2005/shared-memory-ecs 1.2.2 → 1.4.0

package/README.md

@@ -10,10 +10,11 @@ fog of war, sub-classed entities, required components, etc).
 - **Component** – a plain object with an `index` (its block inside a shared-memory pool) plus getters/
   setters over that memory. Games decide what components exist.
 - **`ComponentDefinition`** – describes a component: its typed array `type`, block `size`, the config keys
-  that trigger loading (`loadProperties`), a `load(entity, memory, config)` and an optional `save(component)`.
-  A component's data splits into `Config` (defining props supplied up front, e.g. `maxHealth`) and
-  `Serialization` (runtime-derived state, e.g. current `health`); `load` sees `Config & Serialization` while
-  `save` returns only the `Serialization` slice.
+  that trigger loading (`loadProperties`), a `load(entity, memory, config)`, an optional `save(component)`,
+  and an optional `free(component)`. A component's data splits into `Config` (defining props supplied up
+  front, e.g. `maxHealth`) and `Serialization` (runtime-derived state, e.g. current `health`); `load` sees
+  `Config & Serialization` while `save` returns only the `Serialization` slice. `free` runs when the
+  component is torn down (see [Freeing extra resources](#freeing-extra-resources)).
 - **`ComponentRegistry<C>`** – the map of all component definitions for a game.
 - **`EntityFactory<C>`** – maps an entity `type` name to a base (template) config. Loading an entity layers
   the caller's config over its type's template, so shared static data lives in one place and a save only
@@ -190,6 +191,67 @@ class DamageSystem extends ComponentSystem<Components, { health: Int32Array }, D
 }
 ```
 
+### Update-function hooks: `init` and `preRun`
+
+`addDataToWorld` runs on the main thread and re-sends its data every run. When the data instead needs to
+*live in the worker* — computed once, or too big to ship each frame — attach hooks to the update function
+itself. Both are optional properties on the `EntityUpdateFunction`.
+
+**`init`** runs on `system.finishLoading()` — once at startup (`world.init()` calls it), and again on each
+`world.load()` so a reused world re-seeds its workers. It receives whatever the system's `getInitData()` returned
+(structured-cloned across the boundary) and returns a `Partial<W>` that is merged onto `world` on every
+subsequent run. Use it for state that must be seeded from the main thread but then persist inside the worker
+— a seeded RNG, a lookup table, a config object — without paying to re-send it each frame. Type the init
+data with the `D` type parameter (the fourth on `EntityUpdateFunction` / `ComponentSystem`) so `getInitData`
+and the `init` hook agree on its shape; it defaults to `unknown` when a system has no init data:
+
+```ts
+interface DamageWorld extends ComponentSystemWorld {
+	damage: number
+}
+interface DamageInitData {
+	baseDamage: number
+}
+
+const damageUpdate: EntityUpdateFunction<Components, { health: Int32Array }, DamageWorld, DamageInitData> =
+	(world, entityId, components) => { components.health[0] -= world.damage; };
+
+// Runs once in the worker; its return is merged onto `world` before every run. `data` is typed as
+// `DamageInitData | undefined` (undefined when the system supplies no getInitData).
+damageUpdate.init = (data) => ({ damage: data?.baseDamage ?? 1 });
+
+class DamageSystem extends ComponentSystem<Components, { health: Int32Array }, DamageWorld, DamageInitData> {
+	constructor(world: BaseWorld<Components>) {
+		super(world, {
+			name: 'DamageSystem',
+			required: ['health'],
+			updateFunction: damageUpdate,
+			getWorker: () => new Worker(/* your worker entry */),
+			// Runs on the main thread; its result is structured-cloned to the worker's `init`.
+			getInitData: () => ({ baseDamage: 5 }),
+		});
+	}
+}
+```
+
+Unlike `addDataToWorld` (an overridable method on the system), `getInitData` is a config option — it lives in
+the options passed to the `ComponentSystem` constructor, so a system used without a subclass can supply it
+there directly.
+
+**`preRun`** runs once per run, before any entity is updated, with the run's `world`, the full entity list,
+the query results, and the same `callbacks`. Use it for setup that spans the whole batch — seeding a
+spatial index, resetting an accumulator, or emitting a run-level event — that would be wasteful or wrong to
+repeat inside the per-entity loop:
+
+```ts
+damageUpdate.preRun = (world, entities, queries, callbacks) => {
+	// Runs before the per-entity pass; `entities` is everything this run will touch.
+};
+```
+
+(An `entityRemoved(world, entityId, callbacks)` hook completes the set — it fires once per entity that left
+the system this run, so a worker can release any per-entity state it was holding.)
+
 ### Importing in workers
 
 Each worker entry file is bundled on its own, and a single-entry bundle cannot tree-shake this package's
@@ -273,6 +335,56 @@ thread already holds the values - sending them along would only pay to copy what
 System events are dispatched before the per-entity events of the same run, so an entity a run both moved and
 killed is still in the world when its move is reported.
 
+### Freeing component memory safely
+
+Component blocks live in a shared pool, so a freed block gets handed straight back out to the next entity that
+needs one. That is a problem across workers: if one system kills an entity, a second reuses its freed block for
+a brand-new entity, and a third is still mid-run over what it thinks is the old entity, the third system writes
+into the new entity's memory.
+
+So the library never frees a block the instant it is orphaned. When an entity dies or you call
+`removeComponent`, the block is *deferred* — the component is gone from the entity immediately, but the memory is
+held until every system that could be mid-run over it has finished a run. Only then is the block returned to the
+pool for reuse. This is automatic; there is nothing to call. The one visible effect is that
+`memoryComponent.length` can briefly sit one higher than the number of live components, until the next update
+lets the holding systems finish. If a system stays stuck (never completes a run) for more than ten seconds of
+unscaled time, the world logs a warning naming that system and frees the blocks anyway rather than leak them —
+a stuck system there is a bug worth chasing down.
+
+### Freeing extra resources
+
+Everything above frees a component's own block. A component that allocates something *else* in `load` —
+another heap structure (a `SharedList`, a `SharedString`) or child entities it owns — needs to release that
+too, and the block-level deferred free won't do it. Give the definition an optional `free(component)`:
+
+```ts
+const cargoDefinition: ComponentDefinition<Cargo, Uint32Array, CargoConfig> = {
+  type: Uint32Array,
+  size: 3,
+  loadProperties: ['cargoSpace'],
+  load(entity, memory, config) {
+    /* allocate a SharedList in the heap, stash its pointer in the block, return accessors */
+  },
+  free(component) {
+    component.items.free(); // release the SharedList + the item entities it holds
+  },
+};
+```
+
+`free` runs exactly once per component teardown: on `removeComponent`, and on every path that removes an
+entity — `removeEntity`, a `death` (from `killEntity`), a `load` that drops the old batch, and `clear`.
+It is deferred to the same safe point as the component's own block (see above), not fired the instant the
+entity dies — so a system still mid-run over that memory can't see your resource released early. Reload calls
+it without any `death` event, so it is the reliable place to avoid leaks when a world is reused.
+
+### Reusing a world: `load` and `clear`
+
+A world is meant to be reused rather than rebuilt. `world.load(config)` swaps in a fresh scenario — it removes
+the old entities, clears every system, and loads the new batch (deferred frees from the old contents drain over
+the following updates, as above). `await world.clear()` instead tears the world all the way back down to an
+empty, reusable state: it waits for every system's in-flight worker run to finish so nothing is still reading
+the memory, frees the held blocks immediately, and resolves once the world is ready to load into again.
+
 ## Measuring performance
 
 `PerformanceTiming` watches a world and reports what running it costs. Hand it the world and it hooks itself

package/dist/component-definition.d.ts

@@ -14,6 +14,7 @@ export interface ComponentDefinition<Component extends BaseComponent, T extends
     loadInFinishLoading?: boolean;
     load(entity: BaseEntity, memory: MemoryComponent<T>, config: Config & Serialization): Component;
     save?(component: Component): Serialization;
+    free?(component: Component): void;
 }
 export type RegisteredComponentDefinition<Component extends BaseComponent, T extends ComponentTypedArray = ComponentTypedArray, Config = any, Serialization = object> = ComponentDefinition<Component, T, Config, Serialization> & {
     memoryComponent: MemoryComponent<T>;

package/dist/{create-component-worker-Bd1BTUkq.js → create-component-worker-vbX3vEia.js}

@@ -58,21 +58,27 @@ function a(e, t) {
 //#endregion
 //#region src/systems/workers/create-component-worker.ts
 function o(t, n) {
-	let r = [], i = {};
-	t.onmessage = function(a) {
-		let o = a.data;
-		if (o.type === "init") s(t, { type: "loaded" });
-		else if (o.type === "run") {
-			let a = performance.now(), c = [], l = {}, u = [];
-			r = e(r, o.entities);
-			let d = {};
-			Object.entries(o.queries).forEach(([t, n]) => {
+	let r = [], i = {}, a;
+	t.onmessage = function(o) {
+		let c = o.data;
+		if (c.type === "init") s(t, { type: "init-complete" });
+		else if (c.type === "load") a = n.init?.(c.data) ?? void 0, s(t, { type: "loaded" });
+		else if (c.type === "reset") {
+			r = [];
+			for (let e of Object.keys(i)) delete i[e];
+			a = void 0;
+		} else if (c.type === "run") {
+			a && Object.assign(c.world, a);
+			let o = performance.now(), l = [], u = {}, d = [];
+			r = e(r, c.entities);
+			let f = {};
+			Object.entries(c.queries).forEach(([t, n]) => {
 				let r = e(i[t] ?? [], n);
-				i[t] = r, d[t] = r;
+				i[t] = r, f[t] = r;
 			});
-			let f = {
+			let p = {
 				entityComponentChanged(e, t, n, r) {
-					c.push({
+					l.push({
 						entityId: e,
 						event: "component-property-updated",
 						args: [
@@ -83,36 +89,39 @@ function o(t, n) {
 					});
 				},
 				emitEntityEvent(e, t, ...n) {
-					c.push({
+					l.push({
 						entityId: e,
 						event: t,
 						args: n
 					});
 				},
 				emitSystemEvent(e, t) {
-					(l[e] ?? (l[e] = [])).push(t);
+					(u[e] ?? (u[e] = [])).push(t);
 				},
 				entityDied(e) {
-					c.push({
+					l.push({
 						entityId: e,
 						event: "death",
 						args: []
 					});
 				},
 				createEntity(e) {
-					u.push(e);
+					d.push(e);
 				}
 			};
-			n.preRun && n.preRun(o.world, r, d, f), r.forEach((e) => {
-				n(o.world, e.entityId, e.components, d, f);
-			}), n.entityRemoved && o.entities.removed.forEach((e) => {
-				n.entityRemoved(o.world, e, f);
-			}), s(t, {
+			n.preRun && n.preRun(c.world, r, f, p), r.forEach((e) => {
+				n(c.world, e.entityId, e.components, f, p);
+			}), n.entityRemoved && c.entities.removed.forEach((e) => {
+				n.entityRemoved(c.world, e, p);
+			});
+			let m = performance.now() - o;
+			s(t, {
 				type: "run-complete",
-				runTime: performance.now() - a,
-				events: c,
-				systemEvents: l,
-				created: u
+				generation: c.generation,
+				runTime: m,
+				events: l,
+				systemEvents: u,
+				created: d
 			});
 		}
 	};
@@ -123,4 +132,4 @@ function s(e, t) {
 //#endregion
 export { n as a, t as i, a as n, r as o, i as r, e as s, o as t };
 
-//# sourceMappingURL=create-component-worker-Bd1BTUkq.js.map
+//# sourceMappingURL=create-component-worker-vbX3vEia.js.map

package/dist/create-component-worker-vbX3vEia.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-component-worker-vbX3vEia.js","names":[],"sources":["../src/systems/workers/apply-query-delta.ts","../src/entity-component.ts","../src/actions/kill-entity-worker.ts","../src/actions/create-entity-worker.ts","../src/systems/workers/create-component-worker.ts"],"sourcesContent":["import type { EntityUpdateComponents, QueryDelta, UpdateEntityConfigObject } from '../component-system';\n\n// Applies a run's delta to a query's persistent list: drop the entities that left, upsert those that joined or\n// changed. A steady-state run carries empty arrays and returns the list untouched. Returns the list (removals\n// rebuild it via filter), so callers must store the returned reference back.\nexport function applyQueryDelta<T extends EntityUpdateComponents>(\n\tlist: Array<UpdateEntityConfigObject<T>>,\n\tdelta: QueryDelta<T>,\n): Array<UpdateEntityConfigObject<T>> {\n\tif(delta.removed.length) {\n\t\tconst removedSet = new Set(delta.removed);\n\t\tlist = list.filter(entry => !removedSet.has(entry.entityId));\n\t}\n\n\tif(delta.added.length) {\n\t\t// Index existing members so a re-added entity replaces its entry in place instead of duplicating.\n\t\tconst indexByEid = new Map<number, number>();\n\t\tlist.forEach((entry, index) => indexByEid.set(entry.entityId, index));\n\n\t\tfor(let entity of delta.added) {\n\t\t\tconst existing = indexByEid.get(entity.entityId);\n\t\t\tif(existing !== undefined) {\n\t\t\t\tlist[existing] = entity;\n\t\t\t} else {\n\t\t\t\tindexByEid.set(entity.entityId, list.length);\n\t\t\t\tlist.push(entity);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn list;\n}\n","import type { ComponentDefinition } from './component-definition';\n\n// dead/isStatic live in the shared block (worker-visible); type is main-thread only.\nexport interface EntityComponent {\n\tindex: number\n\ttype: string\n\tdead: boolean\n\tisStatic: boolean\n}\n\nexport interface EntityComponentConfig {\n\ttype: string\n\tisStatic?: boolean\n}\n\nexport interface EntityComponentSerialization {\n\ttype?: string\n\tdead?: boolean\n}\n\nexport const DEAD_INDEX = 0;\nexport const STATIC_INDEX = 1;\n\nexport const entityDefinition: ComponentDefinition<EntityComponent, Uint32Array, EntityComponentConfig, EntityComponentSerialization> = {\n\ttype: Uint32Array,\n\tsize: 2,\n\tloadProperties: ['type', 'isStatic'],\n\tload(entity, memory, config) {\n\t\tconst index = memory.create([config.dead ? 1 : 0, config.isStatic ? 1 : 0]);\n\t\tconst block = memory.getBlock(index);\n\n\t\treturn {\n\t\t\tindex,\n\t\t\ttype: config.type,\n\t\t\tget dead() {\n\t\t\t\treturn block[DEAD_INDEX] === 1;\n\t\t\t},\n\t\t\tset dead(value: boolean) {\n\t\t\t\tblock[DEAD_INDEX] = value ? 1 : 0;\n\t\t\t},\n\t\t\tget isStatic() {\n\t\t\t\treturn block[STATIC_INDEX] === 1;\n\t\t\t},\n\t\t\tset isStatic(value: boolean) {\n\t\t\t\tblock[STATIC_INDEX] = value ? 1 : 0;\n\t\t\t},\n\t\t};\n\t},\n\tsave(component) {\n\t\tconst config: EntityComponentSerialization = {};\n\t\tif(component.type) {\n\t\t\tconfig.type = component.type;\n\t\t}\n\t\tif(component.dead) {\n\t\t\tconfig.dead = true;\n\t\t}\n\n\t\treturn config;\n\t},\n};\n","import type { ComponentTypedArray } from '../memory-component';\nimport type { ComponentSystemCallbacks, EntityUpdateComponents } from '../systems/component-system';\nimport { DEAD_INDEX } from '../entity-component';\n\n// Worker-side killEntity: flags the entity dead in its block and reports the death back via callbacks. The\n// entity component must be in the system's query for its block to be available here.\nexport default function killEntityWorker(entityId: number, components: EntityUpdateComponents, callbacks: ComponentSystemCallbacks): void {\n\tconst block = (components as { entity?: ComponentTypedArray }).entity;\n\tif(block) {\n\t\tblock[DEAD_INDEX] = 1;\n\t}\n\n\tcallbacks.entityDied(entityId);\n}\n","import type { ComponentSystemCallbacks, CreateEntityConfig } from '../systems/component-system';\n\n// Worker-side loadEntity: buffers the config through callbacks. The main thread builds it via world.loadEntity\n// once the run completes, so it first exists on the following frame.\nexport default function createEntityWorker(config: CreateEntityConfig, callbacks: ComponentSystemCallbacks): void {\n\tcallbacks.createEntity(config);\n}\n","import type ComponentWorkerMessage from './component-worker-message';\nimport type { EntityEvent, SystemEvents } from './component-worker-message';\nimport type { ComponentMap } from '../../component-definition';\nimport type { ComponentSystemCallbacks, ComponentSystemWorld, EntityQueryComponents, EntityUpdateComponents, EntityUpdateFunction, QueryDelta, UpdateEntityConfigObject } from '../component-system';\nimport { applyQueryDelta } from './apply-query-delta';\n\n// The slice of the worker global scope createComponentWorker touches. Passing `self` explicitly (rather than\n// using the global) lets runners like @vitest/web-worker, which inject `self` as a module local, drive it.\nexport interface ComponentWorkerScope {\n\tonmessage: ((e: MessageEvent) => void) | null\n\tpostMessage(message: ComponentWorkerMessage): void\n}\n\nexport default function createComponentWorker<\n\tC extends ComponentMap,\n\tT extends EntityUpdateComponents<C>,\n\tW extends ComponentSystemWorld = ComponentSystemWorld,\n\tD = unknown,\n>(scope: ComponentWorkerScope, updateFunction: EntityUpdateFunction<C, T, W, D>) {\n\t// Persistent lists, carried across runs and mutated by each run's delta (see applyQueryDelta).\n\tlet entities: Array<UpdateEntityConfigObject<T>> = [];\n\tconst queryEntities: { [key: string]: Array<UpdateEntityConfigObject<T>> } = {};\n\t// What updateFunction.init returned: persistent state (e.g. a seeded RNG) merged onto `world` each run.\n\tlet worldExtension: Partial<W> | undefined;\n\n\tscope.onmessage = function(e) {\n\t\tconst message = e.data as ComponentWorkerMessage<W, D>;\n\n\t\tif(message.type === 'init') {\n\t\t\tpostMessageTyped(scope, {\n\t\t\t\ttype: 'init-complete',\n\t\t\t});\n\t\t} else if(message.type === 'load') {\n\t\t\tworldExtension = updateFunction.init?.(message.data) ?? undefined;\n\t\t\tpostMessageTyped(scope, {\n\t\t\t\ttype: 'loaded',\n\t\t\t});\n\t\t} else if(message.type === 'reset') {\n\t\t\t// Drop the persistent lists so a reused world starts empty; worldExtension is refreshed by the next load.\n\t\t\tentities = [];\n\t\t\tfor(const key of Object.keys(queryEntities)) {\n\t\t\t\tdelete queryEntities[key];\n\t\t\t}\n\t\t\tworldExtension = undefined;\n\t\t} else if(message.type === 'run') {\n\t\t\tif(worldExtension) {\n\t\t\t\tObject.assign(message.world, worldExtension);\n\t\t\t}\n\t\t\tconst start = performance.now();\n\t\t\tlet entityEvents: Array<EntityEvent> = [];\n\t\t\tlet systemEvents: SystemEvents = {};\n\t\t\tlet createdEntities: Array<Record<string, unknown>> = [];\n\n\t\t\tentities = applyQueryDelta(entities, message.entities as QueryDelta<T>);\n\n\t\t\tlet queries: EntityQueryComponents<C> = {};\n\t\t\tObject.entries(message.queries).forEach(([queryKey, delta]) => {\n\t\t\t\tconst list = applyQueryDelta(queryEntities[queryKey] ?? [], delta as QueryDelta<T>);\n\t\t\t\tqueryEntities[queryKey] = list;\n\t\t\t\tqueries[queryKey] = list;\n\t\t\t});\n\n\t\t\tlet callbacks: ComponentSystemCallbacks<C> = {\n\t\t\t\tentityComponentChanged<K extends keyof C, P extends keyof C[K]>(entityId: number, componentName: K, prop: P, value: C[K][P]) {\n\t\t\t\t\tentityEvents.push({\n\t\t\t\t\t\tentityId,\n\t\t\t\t\t\tevent: 'component-property-updated',\n\t\t\t\t\t\targs: [componentName, prop, value],\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t\temitEntityEvent(entityId: number, event: string, ...args: Array<unknown>) {\n\t\t\t\t\tentityEvents.push({\n\t\t\t\t\t\tentityId,\n\t\t\t\t\t\tevent,\n\t\t\t\t\t\targs,\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t\temitSystemEvent(event: string, entityId: number) {\n\t\t\t\t\t(systemEvents[event] ?? (systemEvents[event] = [])).push(entityId);\n\t\t\t\t},\n\t\t\t\tentityDied(entityId: number) {\n\t\t\t\t\tentityEvents.push({\n\t\t\t\t\t\tentityId,\n\t\t\t\t\t\tevent: 'death',\n\t\t\t\t\t\targs: [],\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t\tcreateEntity(config: Record<string, unknown>) {\n\t\t\t\t\tcreatedEntities.push(config);\n\t\t\t\t},\n\t\t\t};\n\t\t\tif(updateFunction.preRun) {\n\t\t\t\tupdateFunction.preRun(message.world, entities, queries, callbacks);\n\t\t\t}\n\n\t\t\tentities.forEach(entity => {\n\t\t\t\tupdateFunction(message.world, entity.entityId, entity.components, queries, callbacks);\n\t\t\t});\n\n\t\t\tif(updateFunction.entityRemoved) {\n\t\t\t\tmessage.entities.removed.forEach(entityId => {\n\t\t\t\t\tupdateFunction.entityRemoved!(message.world, entityId, callbacks);\n\t\t\t\t});\n\t\t\t}\n\t\t\tconst runTime = performance.now() - start;\n\n\t\t\tpostMessageTyped(scope, {\n\t\t\t\ttype: 'run-complete',\n\t\t\t\tgeneration: message.generation,\n\t\t\t\trunTime,\n\t\t\t\tevents: entityEvents,\n\t\t\t\tsystemEvents,\n\t\t\t\tcreated: createdEntities,\n\t\t\t});\n\t\t}\n\t};\n}\n\nfunction postMessageTyped(scope: ComponentWorkerScope, message: ComponentWorkerMessage) {\n\tscope.postMessage(message);\n}\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -19,7 +19,7 @@ export type { IterableSystemConfig } from './systems/iterable-system';
 export { default as EntitySystem } from './systems/entity-system';
 export type { EntitySystemConfig } from './systems/entity-system';
 export { default as ComponentSystem } from './systems/component-system';
-export type { ComponentSystemConfig, ComponentSystemQuery, ComponentSystemWorld, ComponentSystemCallbacks, CreateEntityConfig, EntityUpdateComponents, EntityQueryComponents, EntityUpdateFunction, EntityUpdatePreRunFunction, EntityRemovedFunction, UpdateEntityConfig, UpdateEntityConfigObject, } from './systems/component-system';
+export type { ComponentSystemConfig, ComponentSystemQuery, ComponentSystemWorld, ComponentSystemCallbacks, CreateEntityConfig, EntityUpdateComponents, EntityQueryComponents, EntityUpdateFunction, EntityUpdateInitFunction, EntityUpdatePreRunFunction, EntityRemovedFunction, UpdateEntityConfig, UpdateEntityConfigObject, } from './systems/component-system';
 export { default as WebWorker } from './systems/workers/web-worker';
 export { default as ComponentWebWorker } from './systems/workers/component-web-worker';
 export { default as createComponentWorker } from './systems/workers/create-component-worker';