@oasys/oecs 0.3.1 → 0.5.0

package/dist/reactive/interop.d.cts

@@ -0,0 +1,19 @@
+import { Accessor } from './kernel.cjs';
+/**
+ * Vanilla subscription: invoke `onChange(value)` once per coalesced change to
+ * whatever `accessor` reads. Does NOT fire on subscribe (the consumer reads the
+ * initial value itself); returns a disposer. This is the universal adapter base.
+ */
+export declare function subscribe<T>(accessor: Accessor<T>, onChange: (value: T) => void): () => void;
+/**
+ * The framework-agnostic external-store contract (React's useSyncExternalStore
+ * shape, but useful everywhere). `subscribe` takes a zero-arg "something changed"
+ * callback; `getSnapshot` reads the current, referentially-stable value.
+ */
+export interface ExternalStore<T> {
+    subscribe(onStoreChange: () => void): () => void;
+    getSnapshot(): T;
+}
+/** Wrap an accessor as an ExternalStore. Snapshot stability comes from the kernel. */
+export declare function toExternalStore<T>(accessor: Accessor<T>): ExternalStore<T>;
+//# sourceMappingURL=interop.d.ts.map

package/dist/reactive/interop.d.ts

@@ -0,0 +1,19 @@
+import { Accessor } from './kernel.js';
+/**
+ * Vanilla subscription: invoke `onChange(value)` once per coalesced change to
+ * whatever `accessor` reads. Does NOT fire on subscribe (the consumer reads the
+ * initial value itself); returns a disposer. This is the universal adapter base.
+ */
+export declare function subscribe<T>(accessor: Accessor<T>, onChange: (value: T) => void): () => void;
+/**
+ * The framework-agnostic external-store contract (React's useSyncExternalStore
+ * shape, but useful everywhere). `subscribe` takes a zero-arg "something changed"
+ * callback; `getSnapshot` reads the current, referentially-stable value.
+ */
+export interface ExternalStore<T> {
+    subscribe(onStoreChange: () => void): () => void;
+    getSnapshot(): T;
+}
+/** Wrap an accessor as an ExternalStore. Snapshot stability comes from the kernel. */
+export declare function toExternalStore<T>(accessor: Accessor<T>): ExternalStore<T>;
+//# sourceMappingURL=interop.d.ts.map

package/dist/reactive/interop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interop.d.ts","sourceRoot":"","sources":["../../src/reactive/interop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAE1D;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAW5F;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC;IAC/B,SAAS,CAAC,aAAa,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IACjD,WAAW,IAAI,CAAC,CAAC;CACjB;AAED,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAK1E"}

package/dist/reactive/kernel.d.cts

@@ -0,0 +1,73 @@
+/**
+ * In-house fine-grained reactive kernel — signal / computed / effect / batch,
+ * plus ownership scopes (`root` / `onCleanup`). Zero dependencies (ADR-0021).
+ *
+ * This is the engine UI seam's propagation core. It is the same class of machine
+ * as the ECS observer system (ADR-0013) — fine-grained, glitch-free, cascades to
+ * a fixed point — at a different granularity, which is exactly why #646 chose to
+ * own it rather than adopt solid-js / @preact/signals-core / alien-signals.
+ *
+ * The dependency graph is an intrusive doubly-linked structure. One pooled `Link`
+ * per edge is threaded into BOTH the source's subscriber list and the target's
+ * dependency list at once, so link/unlink is O(1) pointer surgery with no hashing,
+ * and a stable-dependency re-run reuses its edges via a tail cursor (zero graph
+ * mutation). That is the entire performance story: it ties the throughput leaders
+ * on the hot paths and avoids the Set-based prototype's fan-in collapse.
+ *
+ * Computed is lazy and glitch-free via a version-cutoff pull (the model
+ * alien-signals / preact use):
+ *
+ *   - Every source carries a `version` that bumps only when its value actually
+ *     changes. Each edge (`Link`) remembers the source version it last saw.
+ *   - A write does NOT eagerly recompute anything. It propagates a "maybe-dirty"
+ *     mark (`OUTDATED`) down through computeds to effects, and queues the effects.
+ *     Computeds stay lazy.
+ *   - Work happens on the pull: when an effect flushes (or a computed is read),
+ *     `needsRecompute` walks its deps, refreshes each, and recomputes only if a
+ *     dep's version actually advanced. A recompute that produces an equal value
+ *     does NOT bump the node's own version, so its subscribers are skipped.
+ *
+ * That gives glitch-freedom (a diamond resolves with one consistent recompute of
+ * the join) and minimal work (unchanged values cut propagation) at once.
+ *
+ * Known, deliberate scope (refinements, not correctness gaps): computeds ALWAYS
+ * track their sources (no auto-unsubscribe of unobserved computeds — the TRACKING
+ * optimization) and there is no global-version fast path. The two help only a
+ * workload heavy in *unobserved* computeds and are low-value without each other;
+ * see ADR-0021. Cycle reads return the stale value rather than throwing.
+ */
+export type Eq<T> = (a: T, b: T) => boolean;
+/** A read accessor; calling it inside an effect/computed subscribes to the source. */
+export type Accessor<T> = () => T;
+/** A write setter; a same-value write (per `eq`) is a no-op and wakes nobody. */
+export type Setter<T> = (v: T) => void;
+/** Create a writable signal. Returns `[read, write]`; `eq` defaults to `Object.is`.
+ * The zero-arg form (Solid parity) starts at `undefined` for late-initialized
+ * values: `const [user, setUser] = signal<User>();` reads `User | undefined`. */
+export declare function signal<T>(): readonly [Accessor<T | undefined>, Setter<T | undefined>];
+export declare function signal<T>(initial: T, eq?: Eq<T>): readonly [Accessor<T>, Setter<T>];
+/** Create a lazy, glitch-free derived value. Recomputes on pull only when a dep changed. */
+export declare function computed<T>(fn: () => T, eq?: Eq<T>): Accessor<T>;
+/** Run `fn` now and re-run it whenever a tracked dep changes. Returns a disposer. */
+export declare function effect(fn: () => void): () => void;
+/** Coalesce all writes inside `fn` into a single flush at the outermost boundary. */
+export declare function batch(fn: () => void): void;
+/**
+ * Read inside `fn` without subscribing the enclosing effect/computed to anything it
+ * touches (Solid's `untrack`). Use it when a callback that runs during a tracked run
+ * must NOT become a dependency — e.g. an interop subscriber whose `onChange` reads
+ * other accessors. Returns `fn`'s result.
+ */
+export declare function untrack<T>(fn: () => T): T;
+/**
+ * Create an ownership scope. `fn` receives a disposer that tears down every
+ * effect/computed (and their onCleanups) created under the scope. Detached from
+ * any enclosing owner — you hold the disposer (Solid's `createRoot` contract).
+ */
+export declare function root<T>(fn: (dispose: () => void) => T): T;
+/**
+ * Register a cleanup with the owner in scope. Inside an effect/computed it runs
+ * before each re-run and on dispose; inside a `root` it runs on root disposal.
+ */
+export declare function onCleanup(fn: () => void): void;
+//# sourceMappingURL=kernel.d.ts.map

package/dist/reactive/kernel.d.ts

@@ -0,0 +1,73 @@
+/**
+ * In-house fine-grained reactive kernel — signal / computed / effect / batch,
+ * plus ownership scopes (`root` / `onCleanup`). Zero dependencies (ADR-0021).
+ *
+ * This is the engine UI seam's propagation core. It is the same class of machine
+ * as the ECS observer system (ADR-0013) — fine-grained, glitch-free, cascades to
+ * a fixed point — at a different granularity, which is exactly why #646 chose to
+ * own it rather than adopt solid-js / @preact/signals-core / alien-signals.
+ *
+ * The dependency graph is an intrusive doubly-linked structure. One pooled `Link`
+ * per edge is threaded into BOTH the source's subscriber list and the target's
+ * dependency list at once, so link/unlink is O(1) pointer surgery with no hashing,
+ * and a stable-dependency re-run reuses its edges via a tail cursor (zero graph
+ * mutation). That is the entire performance story: it ties the throughput leaders
+ * on the hot paths and avoids the Set-based prototype's fan-in collapse.
+ *
+ * Computed is lazy and glitch-free via a version-cutoff pull (the model
+ * alien-signals / preact use):
+ *
+ *   - Every source carries a `version` that bumps only when its value actually
+ *     changes. Each edge (`Link`) remembers the source version it last saw.
+ *   - A write does NOT eagerly recompute anything. It propagates a "maybe-dirty"
+ *     mark (`OUTDATED`) down through computeds to effects, and queues the effects.
+ *     Computeds stay lazy.
+ *   - Work happens on the pull: when an effect flushes (or a computed is read),
+ *     `needsRecompute` walks its deps, refreshes each, and recomputes only if a
+ *     dep's version actually advanced. A recompute that produces an equal value
+ *     does NOT bump the node's own version, so its subscribers are skipped.
+ *
+ * That gives glitch-freedom (a diamond resolves with one consistent recompute of
+ * the join) and minimal work (unchanged values cut propagation) at once.
+ *
+ * Known, deliberate scope (refinements, not correctness gaps): computeds ALWAYS
+ * track their sources (no auto-unsubscribe of unobserved computeds — the TRACKING
+ * optimization) and there is no global-version fast path. The two help only a
+ * workload heavy in *unobserved* computeds and are low-value without each other;
+ * see ADR-0021. Cycle reads return the stale value rather than throwing.
+ */
+export type Eq<T> = (a: T, b: T) => boolean;
+/** A read accessor; calling it inside an effect/computed subscribes to the source. */
+export type Accessor<T> = () => T;
+/** A write setter; a same-value write (per `eq`) is a no-op and wakes nobody. */
+export type Setter<T> = (v: T) => void;
+/** Create a writable signal. Returns `[read, write]`; `eq` defaults to `Object.is`.
+ * The zero-arg form (Solid parity) starts at `undefined` for late-initialized
+ * values: `const [user, setUser] = signal<User>();` reads `User | undefined`. */
+export declare function signal<T>(): readonly [Accessor<T | undefined>, Setter<T | undefined>];
+export declare function signal<T>(initial: T, eq?: Eq<T>): readonly [Accessor<T>, Setter<T>];
+/** Create a lazy, glitch-free derived value. Recomputes on pull only when a dep changed. */
+export declare function computed<T>(fn: () => T, eq?: Eq<T>): Accessor<T>;
+/** Run `fn` now and re-run it whenever a tracked dep changes. Returns a disposer. */
+export declare function effect(fn: () => void): () => void;
+/** Coalesce all writes inside `fn` into a single flush at the outermost boundary. */
+export declare function batch(fn: () => void): void;
+/**
+ * Read inside `fn` without subscribing the enclosing effect/computed to anything it
+ * touches (Solid's `untrack`). Use it when a callback that runs during a tracked run
+ * must NOT become a dependency — e.g. an interop subscriber whose `onChange` reads
+ * other accessors. Returns `fn`'s result.
+ */
+export declare function untrack<T>(fn: () => T): T;
+/**
+ * Create an ownership scope. `fn` receives a disposer that tears down every
+ * effect/computed (and their onCleanups) created under the scope. Detached from
+ * any enclosing owner — you hold the disposer (Solid's `createRoot` contract).
+ */
+export declare function root<T>(fn: (dispose: () => void) => T): T;
+/**
+ * Register a cleanup with the owner in scope. Inside an effect/computed it runs
+ * before each re-run and on dispose; inside a `root` it runs on root disposal.
+ */
+export declare function onCleanup(fn: () => void): void;
+//# sourceMappingURL=kernel.d.ts.map

package/dist/reactive/kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../../src/reactive/kernel.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,MAAM,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;AA0W5C,sFAAsF;AACtF,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC;AAClC,iFAAiF;AACjF,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;AAEvC;;iFAEiF;AACjF,wBAAgB,MAAM,CAAC,CAAC,KAAK,SAAS,CAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;AACvF,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AASrF,4FAA4F;AAC5F,wBAAgB,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,GAAE,EAAE,CAAC,CAAC,CAAa,GAAG,QAAQ,CAAC,CAAC,CAAC,CAS3E;AAED,qFAAqF;AACrF,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAKjD;AAED,qFAAqF;AACrF,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAO1C;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQzC;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,KAAK,CAAC,GAAG,CAAC,CASzD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAW9C"}

package/dist/reactive/map.d.cts

@@ -0,0 +1,16 @@
+export interface ReactiveMap<K, V> {
+    /** Read a key's value, subscribing the caller to that key (or to structure if absent). */
+    get(key: K): V | undefined;
+    /** Insert or update a key. Updating an existing key wakes only that key's readers. */
+    set(key: K, value: V): void;
+    /** Remove a key. Wakes that key's readers (now absent) and structure readers. */
+    delete(key: K): boolean;
+    /** Membership test, tracking the key set. */
+    has(key: K): boolean;
+    /** Entry count, tracking the key set. */
+    size(): number;
+    /** Snapshot of keys, tracking the key set. */
+    keys(): K[];
+}
+export declare function reactiveMap<K, V>(eq?: (a: V, b: V) => boolean): ReactiveMap<K, V>;
+//# sourceMappingURL=map.d.ts.map

package/dist/reactive/map.d.ts

@@ -0,0 +1,16 @@
+export interface ReactiveMap<K, V> {
+    /** Read a key's value, subscribing the caller to that key (or to structure if absent). */
+    get(key: K): V | undefined;
+    /** Insert or update a key. Updating an existing key wakes only that key's readers. */
+    set(key: K, value: V): void;
+    /** Remove a key. Wakes that key's readers (now absent) and structure readers. */
+    delete(key: K): boolean;
+    /** Membership test, tracking the key set. */
+    has(key: K): boolean;
+    /** Entry count, tracking the key set. */
+    size(): number;
+    /** Snapshot of keys, tracking the key set. */
+    keys(): K[];
+}
+export declare function reactiveMap<K, V>(eq?: (a: V, b: V) => boolean): ReactiveMap<K, V>;
+//# sourceMappingURL=map.d.ts.map

package/dist/reactive/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/reactive/map.ts"],"names":[],"mappings":"AA2BA,MAAM,WAAW,WAAW,CAAC,CAAC,EAAE,CAAC;IAChC,0FAA0F;IAC1F,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAC3B,sFAAsF;IACtF,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAC5B,iFAAiF;IACjF,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IACxB,6CAA6C;IAC7C,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IACrB,yCAAyC;IACzC,IAAI,IAAI,MAAM,CAAC;IACf,8CAA8C;IAC9C,IAAI,IAAI,CAAC,EAAE,CAAC;CACZ;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAmB,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAiE5F"}

package/dist/reactive/shallow.d.cts

@@ -0,0 +1,11 @@
+/**
+ * Shallow (one-level) value equality — the recommended `eq` for object-valued
+ * projections. Mirrors zustand `useShallow` / MobX `comparer.shallow`: two objects
+ * are equal iff they have the same own keys with `Object.is`-equal values. Restores
+ * "equal write wakes nobody" for projections that build a fresh object each tick.
+ *
+ * Lives in the kernel entry (`/reactive`) — it has zero ECS dependency
+ * (POLISH_AUDIT M12); `/reactive-sync` re-exports it for compatibility.
+ */
+export declare function shallow(a: object, b: object): boolean;
+//# sourceMappingURL=shallow.d.ts.map

package/dist/reactive/shallow.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shallow (one-level) value equality — the recommended `eq` for object-valued
+ * projections. Mirrors zustand `useShallow` / MobX `comparer.shallow`: two objects
+ * are equal iff they have the same own keys with `Object.is`-equal values. Restores
+ * "equal write wakes nobody" for projections that build a fresh object each tick.
+ *
+ * Lives in the kernel entry (`/reactive`) — it has zero ECS dependency
+ * (POLISH_AUDIT M12); `/reactive-sync` re-exports it for compatibility.
+ */
+export declare function shallow(a: object, b: object): boolean;
+//# sourceMappingURL=shallow.d.ts.map

package/dist/reactive/shallow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shallow.d.ts","sourceRoot":"","sources":["../../src/reactive/shallow.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAWrD"}

package/dist/reactive/struct.d.cts

@@ -0,0 +1,10 @@
+/** Per-field setters: `set.field(value)`. */
+export type StructSetters<T> = {
+    readonly [K in keyof T]: (v: T[K]) => void;
+};
+/** Optional per-field equality overrides. */
+export type StructEq<T> = {
+    readonly [K in keyof T]?: (a: T[K], b: T[K]) => boolean;
+};
+export declare function reactiveStruct<T extends object>(initial: T, eq?: StructEq<T>): readonly [proxy: Readonly<T>, set: StructSetters<T>];
+//# sourceMappingURL=struct.d.ts.map

package/dist/reactive/struct.d.ts

@@ -0,0 +1,10 @@
+/** Per-field setters: `set.field(value)`. */
+export type StructSetters<T> = {
+    readonly [K in keyof T]: (v: T[K]) => void;
+};
+/** Optional per-field equality overrides. */
+export type StructEq<T> = {
+    readonly [K in keyof T]?: (a: T[K], b: T[K]) => boolean;
+};
+export declare function reactiveStruct<T extends object>(initial: T, eq?: StructEq<T>): readonly [proxy: Readonly<T>, set: StructSetters<T>];
+//# sourceMappingURL=struct.d.ts.map

package/dist/reactive/struct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"struct.d.ts","sourceRoot":"","sources":["../../src/reactive/struct.ts"],"names":[],"mappings":"AA6BA,6CAA6C;AAC7C,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;CAAE,CAAC;AAC9E,6CAA6C;AAC7C,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO;CAAE,CAAC;AAEtF,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC9C,OAAO,EAAE,CAAC,EACV,EAAE,GAAE,QAAQ,CAAC,CAAC,CAAM,GAClB,SAAS,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAyDtD"}

package/dist/shallow-DQ8aG51_.cjs

@@ -0,0 +1 @@
+"use strict";const p=require("./kernel-yWV3XnAb.cjs");function O(g=Object.is){const l=new Map,[t,h]=p.signal(0);let i=0;const a=(s,r)=>s!==void 0&&r!==void 0?g(s,r):s===r;return{get(s){const r=l.get(s);if(r!==void 0)return r[0]();t()},set(s,r){const o=l.get(s);o!==void 0?o[1](r):(l.set(s,p.signal(r,a)),h(++i))},delete(s){const r=l.get(s);return r===void 0?!1:(l.delete(s),p.batch(()=>{r[1](void 0),h(++i)}),!0)},has(s){return t(),l.has(s)},size(){return t(),l.size},keys(){return t(),[...l.keys()]}}}function k(g,l={}){const t={},h={},i=Object.keys(g),a=new Set(i);for(const r of i){const[o,b]=p.signal(g[r],l[r]);t[r]=o,h[r]=b}return[new Proxy({},{get:(r,o)=>a.has(o)?t[o]():Reflect.get(r,o),has:(r,o)=>a.has(o),ownKeys:()=>i,getOwnPropertyDescriptor:(r,o)=>a.has(o)?{get:()=>t[o](),enumerable:!0,configurable:!0}:void 0,set:(r,o)=>!1}),h]}const y=Symbol("reactiveArray.absent");function j(g=[],l=Object.is){const t=[],[h,i]=p.signal(0);let a=0;const s=(e,n)=>e!==y&&n!==y?l(e,n):e===n,r=e=>p.signal(e,s),o=e=>p.untrack(t[e][0]);for(const e of g)t.push(r(e));function b(e){p.batch(()=>{const n=t.length,f=e.length,v=f<n?f:n;for(let c=0;c<v;c++)t[c][1](e[c]);if(f>n){for(let c=n;c<f;c++)t.push(r(e[c]));i(++a)}else if(f<n){const c=t.splice(f);for(let d=0;d<c.length;d++)c[d][1](y);i(++a)}})}return{get(e){if(e>=0&&e<t.length){const n=t[e][0]();if(n!==y)return n}h()},length(){return h(),t.length},snapshot(){h();const e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=t[n][0]();return e},set(e,n){e>=0&&e<t.length&&t[e][1](n)},push(e){t.push(r(e)),i(++a)},pop(){const e=t.length;if(e===0)return;const n=o(e-1),[f]=t.splice(e-1);return p.batch(()=>{f[1](y),i(++a)}),n},splice(e,n,...f){const v=t.length,c=e<0?Math.max(v+e,0):Math.min(e,v),d=n===void 0?v-c:Math.max(0,Math.min(n,v-c)),w=[];for(let u=0;u<d;u++)w.push(o(c+u));const m=[];for(let u=0;u<c;u++)m.push(o(u));for(let u=0;u<f.length;u++)m.push(f[u]);for(let u=c+d;u<v;u++)m.push(o(u));return b(m),w},reconcile(e){b(e)}}}function S(g,l){if(Object.is(g,l))return!0;const t=g,h=l,i=Object.keys(t);if(i.length!==Object.keys(h).length)return!1;for(let a=0;a<i.length;a++){const s=i[a];if(!Object.prototype.hasOwnProperty.call(h,s)||!Object.is(t[s],h[s]))return!1}return!0}exports.reactiveArray=j;exports.reactiveMap=O;exports.reactiveStruct=k;exports.shallow=S;

package/dist/shallow-DfnAm9vG.js

@@ -0,0 +1,150 @@
+import { s as y, b as O, u as j } from "./kernel-DgyrLFjW.js";
+function S(p = Object.is) {
+  const l = /* @__PURE__ */ new Map(), [e, f] = y(0);
+  let i = 0;
+  const a = (s, r) => s !== void 0 && r !== void 0 ? p(s, r) : s === r;
+  return {
+    get(s) {
+      const r = l.get(s);
+      if (r !== void 0) return r[0]();
+      e();
+    },
+    set(s, r) {
+      const o = l.get(s);
+      o !== void 0 ? o[1](r) : (l.set(s, y(r, a)), f(++i));
+    },
+    delete(s) {
+      const r = l.get(s);
+      return r === void 0 ? !1 : (l.delete(s), O(() => {
+        r[1](void 0), f(++i);
+      }), !0);
+    },
+    has(s) {
+      return e(), l.has(s);
+    },
+    size() {
+      return e(), l.size;
+    },
+    keys() {
+      return e(), [...l.keys()];
+    }
+  };
+}
+function M(p, l = {}) {
+  const e = {}, f = {}, i = Object.keys(p), a = new Set(i);
+  for (const r of i) {
+    const [o, m] = y(
+      p[r],
+      l[r]
+    );
+    e[r] = o, f[r] = m;
+  }
+  return [new Proxy({}, {
+    // A field read subscribes; a NON-field key must not throw. `JSON.stringify`
+    // (`toJSON`), `await proxy` (`then`), `String(proxy)` (`Symbol.toPrimitive`)
+    // and `for..of` (`Symbol.iterator`) all probe keys that aren't fields — fall
+    // through to the (empty) target so they see the ordinary undefined/inherited
+    // value instead of calling `undefined()`. `fieldSet` (not `k in reads`) so
+    // inherited `toString`/`constructor` aren't mistaken for fields.
+    get: (r, o) => a.has(o) ? e[o]() : Reflect.get(r, o),
+    has: (r, o) => a.has(o),
+    // Enumerable without subscribing: enumeration calls `ownKeys` +
+    // `getOwnPropertyDescriptor`, never `get`, so `Object.keys(proxy)` returns
+    // the field set and tracks nothing. The descriptor is an ACCESSOR whose `get`
+    // reads the live signal, so `{...proxy}` / `Object.values(proxy)` /
+    // `Object.getOwnPropertyDescriptor(proxy, f).value` see the current value
+    // (a value-less descriptor would normalize to `value: undefined`). Non-field
+    // keys report no own descriptor. The target is the empty (extensible) object,
+    // so these configurable own keys satisfy the Proxy invariants.
+    ownKeys: () => i,
+    getOwnPropertyDescriptor: (r, o) => a.has(o) ? { get: () => e[o](), enumerable: !0, configurable: !0 } : void 0,
+    // Writes go through `set.field(v)` — the proxy is a READ surface, and its
+    // public type says so (`Readonly<T>`, POLISH_AUDIT #8). The trap backs the
+    // type for JS callers / policed casts: without it, a field assignment threw
+    // an opaque "Cannot redefine property" (the accessor descriptor above has no
+    // setter) and a TYPO'D field silently stuck on the hidden target as a
+    // non-reactive value.
+    set: (r, o) => !1
+  }), f];
+}
+const v = Symbol("reactiveArray.absent");
+function x(p = [], l = Object.is) {
+  const e = [], [f, i] = y(0);
+  let a = 0;
+  const s = (t, n) => t !== v && n !== v ? l(t, n) : t === n, r = (t) => y(t, s), o = (t) => j(e[t][0]);
+  for (const t of p) e.push(r(t));
+  function m(t) {
+    O(() => {
+      const n = e.length, h = t.length, g = h < n ? h : n;
+      for (let c = 0; c < g; c++) e[c][1](t[c]);
+      if (h > n) {
+        for (let c = n; c < h; c++) e.push(r(t[c]));
+        i(++a);
+      } else if (h < n) {
+        const c = e.splice(h);
+        for (let d = 0; d < c.length; d++) c[d][1](v);
+        i(++a);
+      }
+    });
+  }
+  return {
+    get(t) {
+      if (t >= 0 && t < e.length) {
+        const n = e[t][0]();
+        if (n !== v) return n;
+      }
+      f();
+    },
+    length() {
+      return f(), e.length;
+    },
+    snapshot() {
+      f();
+      const t = new Array(e.length);
+      for (let n = 0; n < e.length; n++) t[n] = e[n][0]();
+      return t;
+    },
+    set(t, n) {
+      t >= 0 && t < e.length && e[t][1](n);
+    },
+    push(t) {
+      e.push(r(t)), i(++a);
+    },
+    pop() {
+      const t = e.length;
+      if (t === 0) return;
+      const n = o(t - 1), [h] = e.splice(t - 1);
+      return O(() => {
+        h[1](v), i(++a);
+      }), n;
+    },
+    splice(t, n, ...h) {
+      const g = e.length, c = t < 0 ? Math.max(g + t, 0) : Math.min(t, g), d = n === void 0 ? g - c : Math.max(0, Math.min(n, g - c)), w = [];
+      for (let u = 0; u < d; u++) w.push(o(c + u));
+      const b = [];
+      for (let u = 0; u < c; u++) b.push(o(u));
+      for (let u = 0; u < h.length; u++) b.push(h[u]);
+      for (let u = c + d; u < g; u++) b.push(o(u));
+      return m(b), w;
+    },
+    reconcile(t) {
+      m(t);
+    }
+  };
+}
+function A(p, l) {
+  if (Object.is(p, l)) return !0;
+  const e = p, f = l, i = Object.keys(e);
+  if (i.length !== Object.keys(f).length) return !1;
+  for (let a = 0; a < i.length; a++) {
+    const s = i[a];
+    if (!Object.prototype.hasOwnProperty.call(f, s) || !Object.is(e[s], f[s])) return !1;
+  }
+  return !0;
+}
+export {
+  M as a,
+  x as b,
+  S as r,
+  A as s
+};

package/dist/shared-BU1Cd40h.js

@@ -0,0 +1,103 @@
+class u extends Error {
+  constructor(t, e, r, n) {
+    super(t, n), this.requestedBytes = e, this.capBytes = r, this.name = "StoreCapExceededError";
+  }
+}
+class c extends Error {
+  constructor() {
+    super(
+      "SharedArrayBuffer is not available in this runtime. The chosen world backing is SAB-based and cannot start without it. In browsers this requires cross-origin isolation: serve the page with `Cross-Origin-Opener-Policy: same-origin` and `Cross-Origin-Embedder-Policy: require-corp` (or `credentialless`). Alternatively choose the pure-TS heap profile (`memory: { heap: {} }`), which is backed by a plain ArrayBuffer and needs no SAB / no COOP+COEP. In Bun/Node SAB is available unconditionally — if you see this there, the runtime is older than expected or the global was shadowed."
+    ), this.name = "SabUnavailableError";
+  }
+}
+const d = (a) => {
+  if (typeof SharedArrayBuffer > "u") throw new c();
+  return new SharedArrayBuffer(a);
+}, h = 64 * 1024;
+function f(a, t, e) {
+  if (e <= 0 || !Number.isInteger(e))
+    throw new Error(`${a}: maxBytes must be a positive integer (got ${e})`);
+  let r = null;
+  const n = (o) => {
+    if (o > e)
+      throw new u(
+        `${a}: requested ${o} bytes exceeds the by-design maxBytes cap of ${e}. This is a hard ceiling with no grow-beyond-cap fallback (#380); a real workload stays ~16 MiB. Reaching it signals runaway entity/column growth upstream — diagnose that rather than raising the cap blindly.`,
+        o,
+        e
+      );
+    return r === null ? (r = t.create(o, e), r) : (o > r.byteLength && t.growTo(r, o), r);
+  };
+  return Object.defineProperty(n, "isInPlace", { value: !0, enumerable: !0 }), n;
+}
+function w(a = 256 * 1024 * 1024) {
+  if (typeof SharedArrayBuffer > "u") throw new c();
+  return f(
+    "growable_sab_allocator",
+    {
+      create: (t, e) => {
+        const r = SharedArrayBuffer;
+        return new r(t, { maxByteLength: e });
+      },
+      // boundary: SharedArrayBuffer.grow is in the spec but not in all
+      // lib types; widen here so the rest of the layer doesn't need to.
+      growTo: (t, e) => t.grow(e)
+    },
+    a
+  );
+}
+function b(a = 256 * 1024 * 1024) {
+  return f(
+    "heap_arraybuffer_allocator",
+    {
+      create: (t, e) => {
+        const r = ArrayBuffer;
+        return new r(t, { maxByteLength: e });
+      },
+      // boundary: `ArrayBuffer.prototype.resize` is ES2024, not in the ES2022
+      // lib types; widen here. Resize keeps the same buffer object and
+      // preserves existing views (the in-place contract).
+      growTo: (t, e) => t.resize(e)
+    },
+    a
+  );
+}
+function g(a) {
+  if (!(a.buffer instanceof SharedArrayBuffer))
+    throw new Error(
+      "wasm_memory_allocator: WebAssembly.Memory must be constructed with `shared: true` so its buffer is a SharedArrayBuffer"
+    );
+  const t = () => a.buffer, e = (r) => {
+    const n = a.buffer.byteLength;
+    if (r <= n)
+      return t();
+    const o = Math.ceil((r - n) / h), s = (i) => (
+      // The JS API doesn't expose the Memory's `maximum`, so the cap is
+      // reported as unknowable (`null`) — the caller declared it at
+      // `new WebAssembly.Memory({ maximum })` time.
+      new u(
+        `wasm_memory_allocator: memory.grow(${o}) failed (current=${n} bytes, requested=${r} bytes, maximum may be reached)`,
+        r,
+        null,
+        { cause: i }
+      )
+    );
+    let l;
+    try {
+      l = a.grow(o);
+    } catch (i) {
+      throw s(i);
+    }
+    if (l === -1)
+      throw s();
+    return t();
+  };
+  return Object.defineProperty(e, "isInPlace", { value: !0, enumerable: !0 }), e;
+}
+export {
+  d as D,
+  u as S,
+  c as a,
+  w as g,
+  b as h,
+  g as w
+};

package/dist/shared-BymrGTyR.cjs

@@ -0,0 +1 @@
+"use strict";class s extends Error{constructor(o,r,e,n){super(o,n),this.requestedBytes=r,this.capBytes=e,this.name="StoreCapExceededError"}}class l extends Error{constructor(){super("SharedArrayBuffer is not available in this runtime. The chosen world backing is SAB-based and cannot start without it. In browsers this requires cross-origin isolation: serve the page with `Cross-Origin-Opener-Policy: same-origin` and `Cross-Origin-Embedder-Policy: require-corp` (or `credentialless`). Alternatively choose the pure-TS heap profile (`memory: { heap: {} }`), which is backed by a plain ArrayBuffer and needs no SAB / no COOP+COEP. In Bun/Node SAB is available unconditionally — if you see this there, the runtime is older than expected or the global was shadowed."),this.name="SabUnavailableError"}}const h=a=>{if(typeof SharedArrayBuffer>"u")throw new l;return new SharedArrayBuffer(a)},d=64*1024;function f(a,o,r){if(r<=0||!Number.isInteger(r))throw new Error(`${a}: maxBytes must be a positive integer (got ${r})`);let e=null;const n=t=>{if(t>r)throw new s(`${a}: requested ${t} bytes exceeds the by-design maxBytes cap of ${r}. This is a hard ceiling with no grow-beyond-cap fallback (#380); a real workload stays ~16 MiB. Reaching it signals runaway entity/column growth upstream — diagnose that rather than raising the cap blindly.`,t,r);return e===null?(e=o.create(t,r),e):(t>e.byteLength&&o.growTo(e,t),e)};return Object.defineProperty(n,"isInPlace",{value:!0,enumerable:!0}),n}function b(a=256*1024*1024){if(typeof SharedArrayBuffer>"u")throw new l;return f("growable_sab_allocator",{create:(o,r)=>{const e=SharedArrayBuffer;return new e(o,{maxByteLength:r})},growTo:(o,r)=>o.grow(r)},a)}function w(a=256*1024*1024){return f("heap_arraybuffer_allocator",{create:(o,r)=>{const e=ArrayBuffer;return new e(o,{maxByteLength:r})},growTo:(o,r)=>o.resize(r)},a)}function A(a){if(!(a.buffer instanceof SharedArrayBuffer))throw new Error("wasm_memory_allocator: WebAssembly.Memory must be constructed with `shared: true` so its buffer is a SharedArrayBuffer");const o=()=>a.buffer,r=e=>{const n=a.buffer.byteLength;if(e<=n)return o();const t=Math.ceil((e-n)/d),c=i=>new s(`wasm_memory_allocator: memory.grow(${t}) failed (current=${n} bytes, requested=${e} bytes, maximum may be reached)`,e,null,{cause:i});let u;try{u=a.grow(t)}catch(i){throw c(i)}if(u===-1)throw c();return o()};return Object.defineProperty(r,"isInPlace",{value:!0,enumerable:!0}),r}exports.DEFAULT_SAB_ALLOCATOR=h;exports.SabUnavailableError=l;exports.StoreCapExceededError=s;exports.growableSabAllocator=b;exports.heapArraybufferAllocator=w;exports.wasmMemoryAllocator=A;

package/dist/shared.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("./shared-BymrGTyR.cjs");exports.DEFAULT_SAB_ALLOCATOR=a.DEFAULT_SAB_ALLOCATOR;exports.SabUnavailableError=a.SabUnavailableError;exports.growableSabAllocator=a.growableSabAllocator;exports.wasmMemoryAllocator=a.wasmMemoryAllocator;

package/dist/shared.d.cts

@@ -0,0 +1,22 @@
+/**
+ * `@oasys/oecs/shared` — the opt-in SharedArrayBuffer / WASM profile.
+ *
+ * The default `@oasys/oecs` profile runs the column store over a plain
+ * resizable `ArrayBuffer` (no cross-origin isolation). This entry surfaces the
+ * `SharedArrayBuffer`-backed allocators for worlds that opt into worker offload
+ * or a WASM compute backend — construct with `new ECS({ memory: { shared: {} } })`,
+ * or pass one of these allocators through `memory: { allocator }`.
+ *
+ * **Requires cross-origin isolation (COOP/COEP) in browsers** — that's the
+ * whole reason it's a separate, opt-in profile.
+ *
+ * The WASM compute backend itself is NOT bundled here: oecs ships the
+ * `ComputeBackend` *seam* (`@oasys/oecs` → `attachBackend`) plus the
+ * cross-thread ring transport (`HostCommandDispatcher`). The worker entrypoint
+ * and the compiled WASM module are the consumer's to provide.
+ *
+ * @module
+ */
+export { growableSabAllocator, wasmMemoryAllocator, DEFAULT_SAB_ALLOCATOR, SabUnavailableError } from './core/store/index.cjs';
+export type { SharedMemoryArm } from './core/ecs/ecs_memory.cjs';
+//# sourceMappingURL=shared.d.ts.map

package/dist/shared.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `@oasys/oecs/shared` — the opt-in SharedArrayBuffer / WASM profile.
+ *
+ * The default `@oasys/oecs` profile runs the column store over a plain
+ * resizable `ArrayBuffer` (no cross-origin isolation). This entry surfaces the
+ * `SharedArrayBuffer`-backed allocators for worlds that opt into worker offload
+ * or a WASM compute backend — construct with `new ECS({ memory: { shared: {} } })`,
+ * or pass one of these allocators through `memory: { allocator }`.
+ *
+ * **Requires cross-origin isolation (COOP/COEP) in browsers** — that's the
+ * whole reason it's a separate, opt-in profile.
+ *
+ * The WASM compute backend itself is NOT bundled here: oecs ships the
+ * `ComputeBackend` *seam* (`@oasys/oecs` → `attachBackend`) plus the
+ * cross-thread ring transport (`HostCommandDispatcher`). The worker entrypoint
+ * and the compiled WASM module are the consumer's to provide.
+ *
+ * @module
+ */
+export { growableSabAllocator, wasmMemoryAllocator, DEFAULT_SAB_ALLOCATOR, SabUnavailableError } from './core/store/index.js';
+export type { SharedMemoryArm } from './core/ecs/ecs_memory.js';
+//# sourceMappingURL=shared.d.ts.map

package/dist/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EACN,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACnB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/shared.js

@@ -0,0 +1,7 @@
+import { D as r, a as l, g as A, w as s } from "./shared-BU1Cd40h.js";
+export {
+  r as DEFAULT_SAB_ALLOCATOR,
+  l as SabUnavailableError,
+  A as growableSabAllocator,
+  s as wasmMemoryAllocator
+};

package/dist/topological_sort-BDvEyb9W.cjs

@@ -0,0 +1 @@
+"use strict";class d{_denseKeys=[];_denseVals=[];_sparse=[];get size(){return this._denseKeys.length}get keys(){return this._denseKeys}has(s){return this._denseKeys[this._sparse[s]]===s}get(s){return this.has(s)?this._denseVals[this._sparse[s]]:void 0}set(s,t){if(this.has(s)){this._denseVals[this._sparse[s]]=t;return}this._sparse[s]=this._denseKeys.length,this._denseKeys.push(s),this._denseVals.push(t)}delete(s){if(!this.has(s))return!1;const t=this._sparse[s],i=this._denseKeys[this._denseKeys.length-1];return this._denseKeys[t]=i,this._denseVals[t]=this._denseVals[this._denseVals.length-1],this._sparse[i]=t,this._denseKeys.pop(),this._denseVals.pop(),!0}clear(){this._denseKeys.length=0,this._denseVals.length=0,this._sparse.length=0}forEach(s){for(let t=0;t<this._denseKeys.length;t++)s(this._denseKeys[t],this._denseVals[t])}[Symbol.iterator](){let s=0;const t=this._denseKeys,i=this._denseVals;return{next(){return s<t.length?{value:[t[s],i[s++]],done:!1}:{value:void 0,done:!0}}}}}class g{_compare;_data=[];constructor(s){this._compare=s}get size(){return this._data.length}peek(){return this._data[0]}push(s){this._data.push(s),this._siftUp(this._data.length-1)}pop(){const s=this._data;if(s.length===0)return;const i=s[0],h=s.pop();return s.length>0&&(s[0]=h,this._siftDown(0)),i}clear(){this._data.length=0}_siftUp(s){const t=this._data,i=this._compare,h=t[s];for(;s>0;){const n=s-1>>1;if(i(h,t[n])>=0)break;t[s]=t[n],s=n}t[s]=h}_siftDown(s){const t=this._data,i=this._compare,h=t.length,n=h>>1,c=t[s];for(;s<n;){let a=(s<<1)+1;const e=a+1;if(e<h&&i(t[e],t[a])<0&&(a=e),i(t[a],c)>=0)break;t[s]=t[a],s=a}t[s]=c}}function u(l,s,t,i){const h=i??(e=>String(e)),n=new Map;for(let e=0;e<l.length;e++)n.set(l[e],0);for(const[,e]of s)for(let r=0;r<e.length;r++){const o=e[r];n.has(o)&&n.set(o,n.get(o)+1)}const c=new g(t);for(let e=0;e<l.length;e++)n.get(l[e])===0&&c.push(l[e]);const a=[];for(;c.size>0;){const e=c.pop();a.push(e);const r=s.get(e);if(r!==void 0)for(let o=0;o<r.length;o++){const _=r[o];if(!n.has(_))continue;const p=n.get(_)-1;n.set(_,p),p===0&&c.push(_)}}if(a.length!==l.length){const e=[];for(const[r,o]of n)o>0&&e.push(h(r));throw new TypeError(`Cycle detected in topological sort. Nodes still pending: ${e.join(", ")}`)}return a}exports.BinaryHeap=g;exports.SparseMap=d;exports.topologicalSort=u;