@adobe/ecs 0.2.0 → 0.2.3

package/src/perftest/suite.ts

@@ -196,7 +196,7 @@ export const idle = System.create({ components: { with: [unused] } }, () => {});
 /** A system that throws, so each run of it rejects. */
 export const failing = System.create({}, () => { throw new Error("suite: failing"); });
 /** An observer system no entity matches: a run of it alone has no tiers. */
-export const idleObserver = System.create({ observer: true, components: { with: [unused] } }, () => {});
+export const idleObserver = System.create({ readonly: true, components: { with: [unused] } }, () => {});
 
 /** Fifty systems no entity matches, in one tier. */
 export const idles = System.create({

package/src/world.test.ts

@@ -23,7 +23,7 @@ describe("World.create", () => {
         await world.run(spawn);
         await world.run(add);
         let seen = 0;
-        await world.run(System.create({ observer: true, components: { with: [count] } }, row => { seen = row[count]; }));
+        await world.run(System.create({ readonly: true, components: { with: [count] } }, row => { seen = row[count]; }));
         expect(seen).toBe(2);
     });
     it("rejects a key that isn't a resource, as worlds the implementation creates do", () => {
@@ -40,7 +40,7 @@ describe("World.join", () => {
         await shared;
         await joined.run(raise);
         let seen = 0;
-        await world.run(System.create({ observer: true }, ({ resources }) => { seen = resources[total]; }));
+        await world.run(System.create({ readonly: true }, ({ resources }) => { seen = resources[total]; }));
         expect(seen).toBe(7);
     });
 });

package/src/world.ts

@@ -0,0 +1,32 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { create as createWorld, join as joinWorld } from './implementation/index.js';
+import type { Create } from './interface/world/create.js';
+import type { Join } from './interface/world/join.js';
+
+export type { Table } from './interface/world/table/table.js';
+
+/**
+ * Creates a world on this thread, synchronously, with resources starting at the given values in place of their
+ * defaults. This thread is its `"world"` thread for the world's life: it runs the sync points, the ticks and the GPU
+ * device, and fills every logical thread no joined thread claims. Keys are the resources' symbols, built-in ones
+ * included (`{ [workers]: 0 }`); string keys are never a resource's, so they're ignored. Throws for a symbol that isn't
+ * a resource, or is one only the world writes. While a declaration's trait or default doesn't hold, each call fails to
+ * compile, once, naming each such key, its members and what's wrong with them.
+ * @function
+ */
+export const create: Create = createWorld;
+
+/**
+ * Joins, from another thread, a world that `share` let join through the other end of `port`, claiming the logical
+ * `threads` this thread fills: their objects live here, and the systems and finalizers reading them run here. Resolves,
+ * once the world accepted the claim, to the same world: its `run` runs systems there, and its `add` and `remove` take
+ * readonly systems, which run here after the world's sync points. Add them before awaiting anything else, so the
+ * world's `share` resolves with them in place. Its `dispose` disconnects this thread. Rejects with an `Error` saying
+ * why it didn't join: the world refused the claim, was disposed, or its thread ended first, as the platform reports it:
+ * the world's `Worker` failing to start or throwing first, a port closed, as in node, or, in a browser, the world's
+ * thread ending once it was shared through a port this thread listened on. A browser world's worker that the page ended
+ * before this thread heard from it isn't reported, so the join stays pending. Rejects too where memory can't be shared,
+ * as without cross-origin isolation.
+ * @function
+ */
+export const join: Join = joinWorld;