@daneren2005/shared-memory-ecs 1.3.0 → 1.5.0

package/README.md

@@ -10,10 +10,14 @@ 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`), and the two halves that build it — `toBlock(config)` (maps the
+  config to the raw block values) and `attach(entity, memory, index)` (builds the accessor over that block).
+  Loading a component is `attach(entity, memory, memory.create(toBlock(config)))`; splitting it this way lets a
+  worker build the block off-thread (it calls only `toBlock`) and the main thread wrap it (`attach`) when it
+  adopts the entity. Plus an optional `save(component)` and `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`); `toBlock` 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
@@ -32,6 +36,7 @@ fog of war, sub-classed entities, required components, etc).
 ## Defining components
 
 ```ts
+import { Component } from '@daneren2005/shared-memory-ecs';
 import type { ComponentDefinition } from '@daneren2005/shared-memory-ecs';
 
 interface HealthComponent {
@@ -43,7 +48,16 @@ interface HealthComponent {
 const HEALTH_INDEX = 0;
 const HEALTH_MAX_INDEX = 1;
 
-// `maxHealth` is the defining Config prop; `health` is optional, runtime-derived Serialization.  `load`
+// The accessor is a subclass of `Component`, so its get/set live on one shared prototype: reading a component off
+// thousands of entities stays monomorphic and inline, and each instance is a single allocation rather than a
+// closure per accessor. Index `this.block` (the typed-array view, set for you) by the exported *_INDEX constants.
+class Health extends Component<Int32Array> implements HealthComponent {
+	get health() { return this.block[HEALTH_INDEX]; }
+	set health(value: number) { this.block[HEALTH_INDEX] = value; }
+	get maxHealth() { return this.block[HEALTH_MAX_INDEX]; }
+}
+
+// `maxHealth` is the defining Config prop; `health` is optional, runtime-derived Serialization.  `toBlock`
 // and `save` both see the combined `{ maxHealth: number, health?: number }`.
 const healthDefinition: ComponentDefinition<HealthComponent, Int32Array, { maxHealth: number }, { health?: number }> = {
 	type: Int32Array,
@@ -51,16 +65,15 @@ const healthDefinition: ComponentDefinition<HealthComponent, Int32Array, { maxHe
 	// Configs are flat and shared: this component loads whenever `maxHealth` is present, then reads what it
 	// needs off the same config object.  Only Config props may appear here.
 	loadProperties: ['maxHealth'],
-	load(entity, memoryComponent, config) {
-		const index = memoryComponent.create([config.health ?? config.maxHealth, config.maxHealth]);
-		const memory = memoryComponent.getBlock(index);
-
-		return {
-			index,
-			get health() { return memory[HEALTH_INDEX]; },
-			set health(value: number) { memory[HEALTH_INDEX] = value; },
-			get maxHealth() { return memory[HEALTH_MAX_INDEX]; }
-		};
+	// The block values, purely from config — so a worker can build the block off-thread. No entity/world access.
+	toBlock(config) {
+		return [config.health ?? config.maxHealth, config.maxHealth];
+	},
+	// The accessor over an already-allocated block. Runs on the main thread both when loading and when adopting a
+	// worker-built entity; a component's own extra allocations (a SharedList, a resource block) go here — a
+	// subclass that owns extra memory takes more constructor args (the entity, another pool) and stores them.
+	attach(entity, memoryComponent, index) {
+		return new Health(memoryComponent.getBlock(index), index);
 	},
 	save(component) {
 		// save returns only Serialization; maxHealth is Config and comes back from the template on reload.
@@ -73,7 +86,7 @@ const registry = {
 	health: healthDefinition
 	// ...other component definitions
 };
-type Components = { [K in keyof typeof registry]: ReturnType<(typeof registry)[K]['load']> };
+type Components = { [K in keyof typeof registry]: ReturnType<(typeof registry)[K]['attach']> };
 ```
 
 ## Using the world
@@ -110,6 +123,12 @@ console.log(goblin.save()); // { type: 'goblin', health: 10 } - no templated max
 world.loadEntity(goblin.save());
 ```
 
+An entity's `type` lives in shared memory (worker-visible), not as a plain field. Each distinct type string is
+interned once as an immutable `ConstantString` in the heap — 15 `"Space Ship"` entities share one allocation —
+and the `entity` block stores only a pointer to it at `TYPE_INDEX`. Reading `entity.components.entity.type`
+resolves that pointer back to the string through the world's cache; a worker can do the same (see
+[Reading an entity's type in a worker](#reading-an-entitys-type-in-a-worker)).
+
 ## Iterating entities
 
 `world.entities` is a `Map` keyed by `eid`, not an array, and so is `entities` on `EntitySystem` and
@@ -140,10 +159,10 @@ one: it is typed, it is readable, and one read costs nothing worth measuring.
 
 It is not free, though, and the cost shows up in exactly one situation — reading the same component off
 *thousands* of entities, *every frame*. The accessor walks several objects to get there and ends in a getter
-closure over the shared block, and because every entity has its own closure those call sites go megamorphic
-once enough entities are alive, so none of it inlines. Measured over ~10,000 entities, reading four values per
-entity cost **~950ns through the accessors against ~140ns straight off the block** — the difference between
-10ms a frame and 1.5ms.
+call over the shared block. `Component`-subclass accessors are prototype getters (all instances of a type share
+one hidden class, so those reads stay monomorphic and inline — unlike the old per-entity closures, which went
+megamorphic), but a getter call plus the property walk still loses to a raw indexed read in the very tightest
+per-frame loops.
 
 Where that matters, hold the block instead. It is the same memory the accessors read, so nothing changes about
 what you get, and it is what the update functions already work on:
@@ -151,15 +170,15 @@ what you get, and it is what the update functions already work on:
 ```ts
 import { TRANSFORM_X_INDEX } from '@daneren2005/shared-memory-physics';
 
-// Resolve once, when whatever is doing the reading is set up.
-const health = entity.components.health!;
-const block = world.registry.health.memoryComponent.getBlock(health.index) as Int32Array;
+// Resolve once, when whatever is doing the reading is set up. The component caches its view on `.block` when it
+// is attached, so read that rather than paying for another getBlock (each call allocates a fresh subarray).
+const block = entity.components.health!.block as Int32Array;
 
 // Then per frame, per entity:
 block[HEALTH_INDEX];
 ```
 
-Two things come with that. The block is only valid while the component is: resolve it again if the component
+Two things come with that. The block is only valid while the component is: re-read `.block` if the component
 can be removed and re-added, or hang it off something that dies with the entity. And it is indexed rather than
 named, so the offsets have to be exported alongside the definition — which is why every component in the
 physics library exports its `*_INDEX` constants.
@@ -258,8 +277,8 @@ barrel: importing `createComponentWorker` from `@daneren2005/shared-memory-ecs`
 `BaseWorld`, every system, their `@daneren2005/shared-memory-objects` dependencies - into the worker, even
 though a worker never runs any of it (easily ~20kb of dead code per worker). Import worker-side helpers from
 the `@daneren2005/shared-memory-ecs/worker` subpath instead. It exposes only what runs in a worker -
-`createComponentWorker`, `createEntityWorker`, `killEntityWorker`, `DEAD_INDEX` (plus the worker-relevant
-types) - so the bundle stays tiny:
+`createComponentWorker`, `createEntityWorker`, `killEntityWorker`, `DEAD_INDEX`, `TYPE_INDEX` (plus the
+worker-relevant types) - so the bundle stays tiny:
 
 ```ts
 // damage.worker.ts - the worker entry file
@@ -274,12 +293,46 @@ or `killEntityWorker` should import them from `/worker` too. Type-only imports (
 `ComponentSystemWorld`, ...) can come from either path since types are erased, and main-thread code
 (`ComponentSystem`, `BaseWorld`, `EntityFactory`, ...) keeps importing from the package root.
 
+A worker that creates entities (see [Creating entities from a worker](#creating-entities-from-a-worker)) passes
+your component registry as the third argument - `createComponentWorker(self, shipUpdate, registry)` - so it has
+each component's `toBlock`. Only do this in workers that actually create entities; it pulls the registry (and
+whatever it imports) into that worker's bundle.
+
+### Reading an entity's type in a worker
+
+The `entity` component carries the entity's `type` in shared memory as a pointer, so a worker can resolve it
+back to a string. Pull `entity` into the system's query (its block only reaches the worker if it is `required`
+or `optional`), read the pointer at `TYPE_INDEX`, and hand it to `world.getString` — the framework injects that
+resolver on `world` before every run:
+
+```ts
+import { TYPE_INDEX } from '@daneren2005/shared-memory-ecs/worker';
+import type { EntityUpdateFunction } from '@daneren2005/shared-memory-ecs/worker';
+
+const update: EntityUpdateFunction<Components, { entity: Uint32Array }> = (world, entityId, components) => {
+	const type = world.getString(components.entity[TYPE_INDEX]); // e.g. "Space Ship"
+	// ...branch on type, etc.
+};
+
+class TypedSystem extends ComponentSystem<Components, { entity: Uint32Array }> {
+	constructor(world: BaseWorld<Components>) {
+		super(world, { name: 'TypedSystem', required: ['entity'], updateFunction: update, getWorker: () => new Worker(/* ... */) });
+	}
+}
+```
+
+`world.getString(pointer)` is a Map lookup before it ever rebuilds the string from memory, and returns `''` for
+the empty type or a pointer whose buffer has not synced to the worker yet. This works identically on the
+main-thread fallback. It is not limited to type — any pointer to a `ConstantString` (via `world.constantStrings`
+on the main thread) resolves the same way.
+
 ### Reporting back to the main thread
 
 An update function runs on shared memory, so anything it writes is already visible on the main thread. What
 it cannot do from there is touch the world, so the things that have to happen back on it go through
 `callbacks`: `entityComponentChanged` (emitted on the entity as `component-property-updated`), `entityDied`
-(as `death`), and `createEntity`. All of them are collected during the run and applied once it completes.
+(as `death`), and `createEntity` (see [Creating entities from a worker](#creating-entities-from-a-worker)).
+All of them are collected during the run and applied once it completes.
 
 `emitEntityEvent` is the escape hatch for an event of your own: name it whatever you like and give it
 whatever args suit it, and it is emitted on the entity under that name. It exists so a system does not have
@@ -334,6 +387,112 @@ 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.
 
+### Creating entities from a worker
+
+An update function can spawn a whole entity, off-thread, from a factory config - the same
+`{ type, ...overrides }` you would pass to `world.loadEntity`. Because component pools live in shared memory,
+the worker merges the type's factory template, allocates each component's block and writes it, then reports
+what it made; the main thread only wraps the result:
+
+```ts
+// in the update function - spawn a ship, overriding two fields of its template
+createEntityWorker(world, { type: 'ship', x: 100, y: 150 }, callbacks);
+```
+
+`createEntityWorker` layers your overrides over the `ship` template, mints a unique id from a shared atomic
+counter (so it never collides with one the main thread or another worker hands out), and for each component
+the merged config triggers, pushes a block into its pool and writes the values - all off-thread. It reports
+back an id-plus-block-indexes descriptor; when the run completes the main thread *adopts* it, building the
+always-present `entity` component there (interning the `type` is a main-thread job) and wrapping each block the
+worker wrote - no block is copied or re-allocated. Like every other worker report-back, the new entity first
+exists on the following frame, so the system picks it up next run.
+
+Two things make this work, both opt-in so only the workers that create entities pay for them:
+
+- Register the system with `createsEntities: true`. That ships the factory templates to its worker on load.
+- In that system's worker entry, pass your component registry to `createComponentWorker`, so the worker has
+  each component's block builder:
+
+  ```ts
+  createComponentWorker(self, shipUpdate, registry);
+  ```
+
+Every component is already defined as two halves for exactly this — `toBlock(config)` (the block values) and
+`attach(entity, memory, index)` (the accessor), see [Defining components](#defining-components). The worker
+runs only `toBlock` (off-thread, no entity/world), and the main thread runs `attach` when it adopts the entity.
+So creating a component in a worker needs nothing extra as long as its `toBlock` is genuinely pure over config —
+no `entity`/`world` access:
+
+```ts
+const shipHealth: ComponentDefinition<HealthComponent, Int32Array, HealthConfig> = {
+	// ...
+	toBlock(config) {
+		return [config.health ?? config.maxHealth, config.maxHealth];
+	},
+	attach(entity, memory, index) {
+		const block = memory.getBlock(index);
+		// ...build the accessor over `block`
+	},
+};
+```
+
+This runs identically on the main-thread fallback. Two current limits: a `loadInFinishLoading` component (one
+that reads other entities) is skipped, since the worker has no world to read; and an adopted entity is always
+the base `BaseEntity` - a factory per-type subclass is not applied to it.
+
+### 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 `attach` —
+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'],
+  toBlock(config) {
+    /* the block's own values */
+  },
+  attach(entity, memory, index) {
+    /* 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/actions/build-worker-entity.d.ts

@@ -0,0 +1,13 @@
+import type { WorkerAllocator, WorkerCreateEntityConfig, WorkerCreatedEntity } from '../systems/component-system';
+export interface WorkerCreatableComponent {
+    loadProperties: Array<string>;
+    loadInFinishLoading?: boolean;
+    toBlock(config: Record<string, unknown>): Array<number>;
+}
+export type WorkerCreateRegistry = {
+    [name: string]: WorkerCreatableComponent;
+};
+export type FactoryConfigs = {
+    [type: string]: Record<string, unknown>;
+};
+export declare function buildWorkerEntity(config: WorkerCreateEntityConfig, factoryConfigs: FactoryConfigs, registry: WorkerCreateRegistry, allocator: WorkerAllocator): WorkerCreatedEntity;

package/dist/actions/create-entity-worker.d.ts

@@ -1,2 +1,2 @@
-import type { ComponentSystemCallbacks, CreateEntityConfig } from '../systems/component-system';
-export default function createEntityWorker(config: CreateEntityConfig, callbacks: ComponentSystemCallbacks): void;
+import type { ComponentSystemCallbacks, ComponentSystemWorld, WorkerCreateEntityConfig } from '../systems/component-system';
+export default function createEntityWorker(world: ComponentSystemWorld, config: WorkerCreateEntityConfig, callbacks: ComponentSystemCallbacks): void;

package/dist/component-definition.d.ts

@@ -5,6 +5,7 @@ import type BaseEntity from './entity';
 import type { EntityComponent, EntityComponentConfig, EntityComponentSerialization } from './entity-component';
 export interface BaseComponent {
     index: number;
+    block?: ComponentTypedArray;
 }
 export type ComponentMap = Record<string, BaseComponent>;
 export interface ComponentDefinition<Component extends BaseComponent, T extends ComponentTypedArray = ComponentTypedArray, Config = any, Serialization = object> {
@@ -12,8 +13,10 @@ export interface ComponentDefinition<Component extends BaseComponent, T extends
     size: number;
     loadProperties: Array<keyof Config & string>;
     loadInFinishLoading?: boolean;
-    load(entity: BaseEntity, memory: MemoryComponent<T>, config: Config & Serialization): Component;
+    toBlock(config: Config & Serialization, entity?: BaseEntity): Array<number>;
+    attach(entity: BaseEntity, memory: MemoryComponent<T>, index: number): 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>;
@@ -28,9 +31,9 @@ export type ComponentDefinitionMap = Record<string, ComponentDefinition<BaseComp
 type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 type DefinitionConfig<D> = D extends ComponentDefinition<BaseComponent, ComponentTypedArray, infer Config, infer Serialization> ? Config & Serialization : never;
 export type ComponentsOf<R extends ComponentDefinitionMap> = {
-    [K in keyof R]: ReturnType<R[K]['load']>;
+    [K in keyof R]: ReturnType<R[K]['attach']> & BaseComponent;
 } & {
-    entity: EntityComponent;
+    entity: EntityComponent & BaseComponent;
 };
 export type EntityConfigOf<R extends ComponentDefinitionMap> = Partial<UnionToIntersection<{
     [K in keyof R]: DefinitionConfig<R[K]>;

package/dist/component.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentTypedArray } from './memory-component';
+import type { BaseComponent } from './component-definition';
+export default abstract class Component<T extends ComponentTypedArray = ComponentTypedArray> implements BaseComponent {
+    readonly index: number;
+    readonly block: T;
+    constructor(block: T, index: number);
+}

package/dist/constant-string-cache.d.ts

@@ -0,0 +1,11 @@
+import ConstantString from '@daneren2005/shared-memory-objects/constant-string';
+import type MemoryHeap from '@daneren2005/shared-memory-objects/memory-heap';
+export default class ConstantStringCache {
+    private heap;
+    private byValue;
+    private byPointer;
+    constructor(heap: MemoryHeap);
+    getOrCreate(value: string): ConstantString;
+    getString(pointer: number): string | undefined;
+    clear(): void;
+}

package/dist/create-component-worker-CaB32Dgn.js

@@ -0,0 +1,263 @@
+import e from "@daneren2005/shared-memory-objects/memory-heap";
+import { getPointer as t } from "@daneren2005/shared-memory-objects/utils/pointer";
+import n from "@daneren2005/shared-memory-objects/shared-pool";
+import r from "@daneren2005/shared-memory-objects/constant-string";
+//#region src/memory-component.ts
+var i = class e {
+	heap;
+	pool;
+	constructor(e, t, r, i) {
+		this.heap = e, this.pool = i ? new n(e, i) : new n(e, {
+			type: t,
+			dataLength: r
+		});
+	}
+	static fromSharedMemory(t, n) {
+		return new e(t, Uint32Array, 1, n);
+	}
+	getSharedMemory() {
+		return this.pool.getSharedMemory();
+	}
+	get length() {
+		return this.pool.length;
+	}
+	get rawLength() {
+		return this.pool.bufferLength;
+	}
+	create(e) {
+		return this.pool.push(e);
+	}
+	getBlock(e) {
+		return this.pool.at(e);
+	}
+	get(e, t) {
+		return this.pool.get(e, t);
+	}
+	set(e, t, n) {
+		let r = this.pool.at(e);
+		r[t] = n;
+	}
+	delete(e) {
+		this.pool.deleteIndex(e);
+	}
+	clear() {
+		this.pool.clear();
+	}
+}, a = class {
+	heap;
+	byValue = /* @__PURE__ */ new Map();
+	byPointer = /* @__PURE__ */ new Map();
+	constructor(e) {
+		this.heap = e;
+	}
+	getOrCreate(e) {
+		let t = this.byValue.get(e);
+		if (t) return t;
+		let n = new r(this.heap, e);
+		return this.byValue.set(e, n), this.byPointer.set(n.pointer, e), n;
+	}
+	getString(e) {
+		if (e === 0) return "";
+		let n = this.byPointer.get(e);
+		if (n !== void 0) return n;
+		let i = t(e);
+		if (this.heap.buffers[i.bufferPosition] === void 0) return;
+		let a = new r(this.heap, i).value;
+		return this.byPointer.set(e, a), a;
+	}
+	clear() {
+		this.byValue.forEach((e) => e.free()), this.byValue.clear(), this.byPointer.clear();
+	}
+};
+//#endregion
+//#region src/systems/workers/apply-query-delta.ts
+function o(e, t) {
+	if (t.removed.length) {
+		let n = new Set(t.removed);
+		e = e.filter((e) => !n.has(e.entityId));
+	}
+	if (t.added.length) {
+		let n = /* @__PURE__ */ new Map();
+		e.forEach((e, t) => n.set(e.entityId, t));
+		for (let r of t.added) {
+			let t = n.get(r.entityId);
+			t === void 0 ? (n.set(r.entityId, e.length), e.push(r)) : e[t] = r;
+		}
+	}
+	return e;
+}
+//#endregion
+//#region src/actions/build-worker-entity.ts
+function s(e, t, n, r) {
+	let i = {
+		...t[e.type] ?? {},
+		...e
+	}, a = r.allocateEid(), o = {};
+	for (let e of Object.keys(n)) {
+		if (e === "entity") continue;
+		let t = n[e];
+		t.loadInFinishLoading || t.loadProperties.some((e) => e in i) && (o[e] = r.allocateComponentBlock(e, t.toBlock(i)));
+	}
+	return {
+		eid: a,
+		type: e.type,
+		isStatic: i.isStatic,
+		components: o
+	};
+}
+//#endregion
+//#region src/component.ts
+var c = class {
+	index;
+	block;
+	constructor(e, t) {
+		this.block = e, this.index = t;
+	}
+}, l = 0, u = 1, d = 2, f = class extends c {
+	cache;
+	constructor(e, t, n) {
+		super(e, t), this.cache = n;
+	}
+	get type() {
+		return this.cache.getString(this.block[2]) ?? "";
+	}
+	set type(e) {
+		this.block[2] = e ? this.cache.getOrCreate(e).pointer : 0;
+	}
+	get dead() {
+		return this.block[0] === 1;
+	}
+	set dead(e) {
+		this.block[0] = +!!e;
+	}
+	get isStatic() {
+		return this.block[1] === 1;
+	}
+	set isStatic(e) {
+		this.block[1] = +!!e;
+	}
+}, p = {
+	type: Uint32Array,
+	size: 3,
+	loadProperties: ["type", "isStatic"],
+	toBlock(e, t) {
+		let n = t.world.constantStrings, r = e.type ? n.getOrCreate(e.type).pointer : 0;
+		return [
+			+!!e.dead,
+			+!!e.isStatic,
+			r
+		];
+	},
+	attach(e, t, n) {
+		return new f(t.getBlock(n), n, e.world.constantStrings);
+	},
+	save(e) {
+		let t = {};
+		return e.type && (t.type = e.type), e.dead && (t.dead = !0), t;
+	}
+};
+//#endregion
+//#region src/actions/kill-entity-worker.ts
+function m(e, t, n) {
+	let r = t.entity;
+	r && (r[0] = 1), n.entityDied(e);
+}
+//#endregion
+//#region src/actions/create-entity-worker.ts
+function h(e, t, n) {
+	if (!e.buildEntityDescriptor) throw Error("createEntityWorker requires the system to be registered with createsEntities: true and the component registry passed to createComponentWorker");
+	n.createEntity(e.buildEntityDescriptor(t));
+}
+//#endregion
+//#region src/systems/workers/create-component-worker.ts
+function g(t, n, r) {
+	let c = [], l = {}, u, d, f, p = {}, m, h, g = (e) => f?.getString(e) ?? "";
+	t.onmessage = function(v) {
+		let y = v.data;
+		if (y.type === "init") _(t, { type: "init-complete" });
+		else if (y.type === "load") {
+			if (y.heap && (d = new e(y.heap), f = new a(d), d.addOnGrowBufferHandlers((e) => _(t, {
+				type: "grow-buffer-from-worker",
+				buffer: e
+			}))), d && y.sharedMemory) {
+				p = {};
+				for (let e of Object.keys(y.sharedMemory.components)) p[e] = i.fromSharedMemory(d, y.sharedMemory.components[e]);
+				m = d.getSharedAlloc(y.sharedMemory.eidCounter);
+			}
+			h = y.factoryConfigs, u = n.init?.(y.data) ?? void 0, _(t, { type: "loaded" });
+		} else if (y.type === "grow-buffer") d && d.buffers[y.buffer.bufferPosition] === void 0 && d.addSharedBuffer(y.buffer);
+		else if (y.type === "reset") {
+			c = [];
+			for (let e of Object.keys(l)) delete l[e];
+			u = void 0;
+		} else if (y.type === "run") {
+			u && Object.assign(y.world, u), y.world.getString = g;
+			let e = {
+				allocateEid: () => m ? Atomics.add(m.data, 0, 1) + 1 : 0,
+				allocateComponentBlock: (e, t) => p[e].create(t)
+			};
+			y.world.allocate = e, h && r && (y.world.buildEntityDescriptor = (t) => s(t, h, r, e));
+			let i = performance.now(), a = [], d = {}, f = [];
+			c = o(c, y.entities);
+			let v = {};
+			Object.entries(y.queries).forEach(([e, t]) => {
+				let n = o(l[e] ?? [], t);
+				l[e] = n, v[e] = n;
+			});
+			let b = {
+				entityComponentChanged(e, t, n, r) {
+					a.push({
+						entityId: e,
+						event: "component-property-updated",
+						args: [
+							t,
+							n,
+							r
+						]
+					});
+				},
+				emitEntityEvent(e, t, ...n) {
+					a.push({
+						entityId: e,
+						event: t,
+						args: n
+					});
+				},
+				emitSystemEvent(e, t) {
+					(d[e] ?? (d[e] = [])).push(t);
+				},
+				entityDied(e) {
+					a.push({
+						entityId: e,
+						event: "death",
+						args: []
+					});
+				},
+				createEntity(e) {
+					f.push(e);
+				}
+			};
+			n.preRun && n.preRun(y.world, c, v, b), c.forEach((e) => {
+				n(y.world, e.entityId, e.components, v, b);
+			}), n.entityRemoved && y.entities.removed.forEach((e) => {
+				n.entityRemoved(y.world, e, b);
+			});
+			let x = performance.now() - i;
+			_(t, {
+				type: "run-complete",
+				generation: y.generation,
+				runTime: x,
+				events: a,
+				systemEvents: d,
+				created: f
+			});
+		}
+	};
+}
+function _(e, t) {
+	e.postMessage(t);
+}
+//#endregion
+export { u as a, c, a as d, i as f, l as i, s as l, h as n, d as o, m as r, p as s, g as t, o as u };
+
+//# sourceMappingURL=create-component-worker-CaB32Dgn.js.map