@daneren2005/shared-memory-ecs 1.10.2 → 1.10.4

package/README.md

@@ -926,6 +926,27 @@ through `system.addEntities(batch)`. Entities with the same component keys are g
 test runs once per group instead of once per entity; system membership keeps load order. A system that overrides
 `checkAddEntity` (or an `EntityWorkerSystem` that overrides `matchesQuery`) still has it called for each entity.
 
+#### Loading in slices with progress
+
+A big save can block the main thread for seconds. Pass `sliceMs` and `load()` yields to the event loop whenever a
+slice runs over, reporting progress as it goes:
+
+```ts
+await world.load(save, {
+	sliceMs: 25,
+	onProgress: ({ phase, done, total, fraction }) => setBar(fraction),
+	// Systems hold every entity and their load messages are posted; only worker replies are left.
+	onEntitiesReady: () => buildIndexes(world),
+});
+```
+
+Phases run `entities` → `linking` (`finishLoading`, `entity-added`) → `systems` (`addEntities`, then
+`finishLoading`) → `workers` (replies). `fraction` weights them 0.6 / 0.1 / 0.1 / 0.2. `yieldTo` overrides the yield
+(default `scheduler.yield()`, else `setTimeout(0)`). While `world.isLoading` is set, `update()` does nothing; don't touch
+the world until `load()` resolves. A `load()`, `clear()` or `destroy()` during a sliced load, or aborting its `signal`, rejects it
+with an `AbortError`, and the next load or clear tears down the partly loaded world. Without `sliceMs`, `load()` runs
+synchronously up to awaiting the workers, and `onProgress`/`onEntitiesReady` still fire.
+
 ### Compressing saves
 
 Big maps are mostly entities whose save is a `type` plus a few integers. `compressEntities(entities, definitions)`
@@ -1019,3 +1040,5 @@ npm install
 npm run build      # emits dist/ (js + d.ts)
 npm run type-check
 ```
+
+Workers invoked directly outside scheduler dispatch publish their effects immediately. Replies from before a scheduler reset are discarded.

package/dist/entity-compression.d.ts

@@ -37,4 +37,5 @@ export declare class EntityCompressor {
 export declare function compressEntities<Cfg extends CompressibleConfig>(entities: ReadonlyArray<Cfg>, definitions: ReadonlyArray<CompressedEntityDefinition>): CompressedEntities<Cfg>;
 export declare function decompressEntity(encoded: string, definitions: CompressedEntityDefinitions): Record<string, DecompressedValue | string>;
 export declare function decompressEntities<Cfg>(entities: ReadonlyArray<Cfg | string>, definitions: CompressedEntityDefinitions | undefined): Array<Cfg>;
+export declare function decompressEntityConfig<Cfg>(entity: Cfg | string, definitions: CompressedEntityDefinitions | undefined): Cfg;
 export {};

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { default as BaseWorld } from './world';
-export type { WorldOptions, WorldConfig, CompressedWorldConfig } from './world';
+export type { WorldOptions, WorldConfig, CompressedWorldConfig, WorldLoadOptions, WorldLoadPhase, WorldLoadProgress } from './world';
 export { EntityCompressor, compressEntities, decompressEntity, decompressEntities } from './entity-compression';
 export type { CompressedEntities, CompressedEntityDefinition, CompressedEntityDefinitions, CompressedEntityProperty, CompressedPropertyType, } from './entity-compression';
 export { default as DefaultScheduler } from './scheduling/default-scheduler';