@daneren2005/shared-memory-ecs 1.4.0 → 1.5.0

package/README.md

@@ -10,11 +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)`, 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)).
+  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
@@ -33,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 {
@@ -44,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,
@@ -52,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.
@@ -74,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
@@ -111,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
@@ -141,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:
@@ -152,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.
@@ -259,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
@@ -275,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
@@ -335,6 +387,59 @@ 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
@@ -353,7 +458,7 @@ 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` —
+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)`:
 
@@ -362,7 +467,10 @@ const cargoDefinition: ComponentDefinition<Cargo, Uint32Array, CargoConfig> = {
   type: Uint32Array,
   size: 3,
   loadProperties: ['cargoSpace'],
-  load(entity, memory, config) {
+  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) {

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,7 +13,8 @@ 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;
 }
@@ -29,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