@oasys/oecs 0.4.0 → 0.5.0

package/dist/internal.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./host_commands-BF8QMi3c.cjs"),d="/packages/engine/src/core/ecs/";class h{activeCache=null;repoRootCache=null;buf=new Map;callsiteCache=new Map;isActive(){if(this.activeCache!==null)return this.activeCache;const t=globalThis.process?.env?.VISUAL_INTEL_TRACE;return this.activeCache=t==="1"||t==="true"}repoRoot(){if(this.repoRootCache!==null)return this.repoRootCache;const e=globalThis.process;return this.repoRootCache=e?.cwd?.()??""}resolveCallsite(){return T(new Error().stack??null,this.repoRoot(),this.callsiteCache)}record(e,t,l){const s=this.resolveCallsite();if(!s)return;const o=`${e}	${t}	${l}	${s}`;this.buf.set(o,(this.buf.get(o)??0)+1)}recordEmit(e){this.record("ecs-events","emit",e)}recordRead(e){this.record("ecs-events","read",e)}recordResourceRead(e){this.record("resources","read",e)}recordResourceWrite(e){this.record("resources","write",e)}recordResourceRegister(e){this.record("resources","register",e)}recordResourceRemove(e){this.record("resources","remove",e)}recordSendAction(e){this.record("actions","send_action",e)}recordHandleAction(e){this.record("actions","handle_action",e)}snapshot(){const e={"ecs-events":{emit:[],read:[]},actions:{send_action:[],handle_action:[]},resources:{read:[],write:[],register:[],remove:[]}};for(const[t,l]of this.buf.entries()){const[s,o,n,c]=t.split("	");if(!s||!o||c===void 0)continue;const u={key:s==="actions"?Number(n):n,file:c,count:l},E=e[s][o];E&&E.push(u)}for(const t of Object.values(e))for(const l of Object.values(t))l.sort((s,o)=>{if(s.file!==o.file)return s.file<o.file?-1:1;const n=String(s.key),c=String(o.key);return n<c?-1:n>c?1:0});return{schemaVersion:1,capturedAt:new Date().toISOString(),channels:e}}reset(){this.buf.clear(),this.callsiteCache.clear(),this.activeCache=null,this.repoRootCache=null}}function _(i){const e=/\(([^)]+):\d+:\d+\)\s*$/.exec(i);if(e)return e[1]??null;const t=/at\s+([^\s][^()]*?):\d+:\d+\s*$/.exec(i);return t&&(t[1]??"").trim()||null}function T(i,e,t){if(!i)return null;const l=i.split(`
+`);for(let s=0;s<l.length;s++){const o=l[s],n=t?.get(o);if(n!==void 0){if(n===null)continue;return n}const c=_(o);if(!c){t?.set(o,null);continue}if(c.includes(d)){t?.set(o,null);continue}const a=C(c,e);return t?.set(o,a),a}return null}function C(i,e){let t=i;return t.startsWith("file://")&&(t=t.slice(7)),e&&t.startsWith(e+"/")&&(t=t.slice(e.length+1)),t.replace(/\\/g,"/")}const R=new h;exports.BUDGET_DEFAULT_ARCHETYPES=r.BUDGET_DEFAULT_ARCHETYPES;exports.BUDGET_DEFAULT_BYTES_PER_ENTITY=r.BUDGET_DEFAULT_BYTES_PER_ENTITY;exports.BUDGET_GROWTH_HEADROOM=r.BUDGET_GROWTH_HEADROOM;exports.DEFAULT_ECS_CAP_BYTES=r.DEFAULT_ECS_CAP_BYTES;exports.HOST_COMMAND_PAYLOAD_BYTES=r.HOST_COMMAND_PAYLOAD_BYTES;exports.HostCommandDispatcher=r.HostCommandDispatcher;exports.MAX_ENTITY_ID=r.MAX_ENTITY_ID;exports.MAX_GENERATION=r.MAX_GENERATION;exports.MAX_INDEX=r.MAX_INDEX;exports.MAX_LIVE_GENERATION=r.MAX_LIVE_GENERATION;exports.RETIRED_GENERATION=r.RETIRED_GENERATION;exports.accessCheck=r.accessCheck;exports.createEntityId=r.createEntityId;exports.getEntityGeneration=r.getEntityGeneration;exports.resolveECSMemory=r.resolveECSMemory;exports.ringDespawnCodec=r.ringDespawnCodec;exports.ringDisableCodec=r.ringDisableCodec;exports.ringEnableCodec=r.ringEnableCodec;exports.ringRemoveComponentCodec=r.ringRemoveComponentCodec;exports.ringSetFieldCodec=r.ringSetFieldCodec;exports.dispatchTrace=R;

package/dist/internal.d.cts

@@ -0,0 +1,20 @@
+/**
+ * # oecs/internal — unstable tooling surface
+ *
+ * Codecs, ABI constants, memory inspectors, and dev-mode singletons, exported
+ * for tests, tooling, and advanced integrations (replication decode,
+ * cross-thread transports, adversarial harnesses).
+ *
+ * **No semver guarantees.** Anything here may change or disappear in any
+ * release. The supported application surface is the package root.
+ *
+ * @module oecs/internal
+ */
+export { resolveECSMemory, DEFAULT_ECS_CAP_BYTES, BUDGET_GROWTH_HEADROOM, BUDGET_DEFAULT_BYTES_PER_ENTITY, BUDGET_DEFAULT_ARCHETYPES } from './core/ecs/index.cjs';
+export type { ResolvedECSMemory, ECSMemoryCapContext } from './core/ecs/index.cjs';
+export { accessCheck } from './core/ecs/index.cjs';
+export { dispatchTrace, type DispatchTraceSnapshot, type DispatchTraceEntry } from './core/ecs/index.cjs';
+export { HostCommandDispatcher, ringSetFieldCodec, ringDespawnCodec, ringDisableCodec, ringEnableCodec, ringRemoveComponentCodec, HOST_COMMAND_PAYLOAD_BYTES } from './core/ecs/index.cjs';
+export type { RingCommandApplier } from './core/ecs/index.cjs';
+export { createEntityId, getEntityGeneration, MAX_INDEX, MAX_GENERATION, MAX_LIVE_GENERATION, RETIRED_GENERATION, MAX_ENTITY_ID } from './core/ecs/index.cjs';
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts

@@ -0,0 +1,20 @@
+/**
+ * # oecs/internal — unstable tooling surface
+ *
+ * Codecs, ABI constants, memory inspectors, and dev-mode singletons, exported
+ * for tests, tooling, and advanced integrations (replication decode,
+ * cross-thread transports, adversarial harnesses).
+ *
+ * **No semver guarantees.** Anything here may change or disappear in any
+ * release. The supported application surface is the package root.
+ *
+ * @module oecs/internal
+ */
+export { resolveECSMemory, DEFAULT_ECS_CAP_BYTES, BUDGET_GROWTH_HEADROOM, BUDGET_DEFAULT_BYTES_PER_ENTITY, BUDGET_DEFAULT_ARCHETYPES } from './core/ecs/index.js';
+export type { ResolvedECSMemory, ECSMemoryCapContext } from './core/ecs/index.js';
+export { accessCheck } from './core/ecs/index.js';
+export { dispatchTrace, type DispatchTraceSnapshot, type DispatchTraceEntry } from './core/ecs/index.js';
+export { HostCommandDispatcher, ringSetFieldCodec, ringDespawnCodec, ringDisableCodec, ringEnableCodec, ringRemoveComponentCodec, HOST_COMMAND_PAYLOAD_BYTES } from './core/ecs/index.js';
+export type { RingCommandApplier } from './core/ecs/index.js';
+export { createEntityId, getEntityGeneration, MAX_INDEX, MAX_GENERATION, MAX_LIVE_GENERATION, RETIRED_GENERATION, MAX_ENTITY_ID } from './core/ecs/index.js';
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,EACN,gBAAgB,EAChB,qBAAqB,EACrB,sBAAsB,EACtB,+BAA+B,EAC/B,yBAAyB,EACzB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAGzE,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAIzC,OAAO,EAAE,aAAa,EAAE,KAAK,qBAAqB,EAAE,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAMhG,OAAO,EACN,qBAAqB,EACrB,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,wBAAwB,EACxB,0BAA0B,EAC1B,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAQrD,OAAO,EACN,cAAc,EACd,mBAAmB,EACnB,SAAS,EACT,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACb,MAAM,YAAY,CAAC"}

package/dist/internal.js

@@ -0,0 +1,141 @@
+import { b as v, a as A, B as g, D as m, i as D, H as S, n as b, l as I, M, m as N, R as O, c as k, j as w, k as y, r as G, e as F, f as B, g as H, h as L, d as U } from "./host_commands-i4cAeyL5.js";
+const h = "/packages/engine/src/core/ecs/";
+class d {
+  activeCache = null;
+  repoRootCache = null;
+  buf = /* @__PURE__ */ new Map();
+  callsiteCache = /* @__PURE__ */ new Map();
+  isActive() {
+    if (this.activeCache !== null) return this.activeCache;
+    const t = globalThis.process?.env?.VISUAL_INTEL_TRACE;
+    return this.activeCache = t === "1" || t === "true";
+  }
+  repoRoot() {
+    if (this.repoRootCache !== null) return this.repoRootCache;
+    const e = globalThis.process;
+    return this.repoRootCache = e?.cwd?.() ?? "";
+  }
+  resolveCallsite() {
+    return E(
+      new Error().stack ?? null,
+      this.repoRoot(),
+      this.callsiteCache
+    );
+  }
+  record(e, t, i) {
+    const r = this.resolveCallsite();
+    if (!r) return;
+    const s = `${e}	${t}	${i}	${r}`;
+    this.buf.set(s, (this.buf.get(s) ?? 0) + 1);
+  }
+  recordEmit(e) {
+    this.record("ecs-events", "emit", e);
+  }
+  recordRead(e) {
+    this.record("ecs-events", "read", e);
+  }
+  recordResourceRead(e) {
+    this.record("resources", "read", e);
+  }
+  recordResourceWrite(e) {
+    this.record("resources", "write", e);
+  }
+  recordResourceRegister(e) {
+    this.record("resources", "register", e);
+  }
+  recordResourceRemove(e) {
+    this.record("resources", "remove", e);
+  }
+  recordSendAction(e) {
+    this.record("actions", "send_action", e);
+  }
+  recordHandleAction(e) {
+    this.record("actions", "handle_action", e);
+  }
+  snapshot() {
+    const e = {
+      "ecs-events": { emit: [], read: [] },
+      actions: { send_action: [], handle_action: [] },
+      resources: { read: [], write: [], register: [], remove: [] }
+    };
+    for (const [t, i] of this.buf.entries()) {
+      const [r, s, o, c] = t.split("	");
+      if (!r || !s || c === void 0) continue;
+      const u = { key: r === "actions" ? Number(o) : o, file: c, count: i }, l = e[r][s];
+      l && l.push(u);
+    }
+    for (const t of Object.values(e))
+      for (const i of Object.values(t))
+        i.sort((r, s) => {
+          if (r.file !== s.file) return r.file < s.file ? -1 : 1;
+          const o = String(r.key), c = String(s.key);
+          return o < c ? -1 : o > c ? 1 : 0;
+        });
+    return {
+      schemaVersion: 1,
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      channels: e
+    };
+  }
+  reset() {
+    this.buf.clear(), this.callsiteCache.clear(), this.activeCache = null, this.repoRootCache = null;
+  }
+}
+function f(n) {
+  const e = /\(([^)]+):\d+:\d+\)\s*$/.exec(n);
+  if (e) return e[1] ?? null;
+  const t = /at\s+([^\s][^()]*?):\d+:\d+\s*$/.exec(n);
+  return t && (t[1] ?? "").trim() || null;
+}
+function E(n, e, t) {
+  if (!n) return null;
+  const i = n.split(`
+`);
+  for (let r = 0; r < i.length; r++) {
+    const s = i[r], o = t?.get(s);
+    if (o !== void 0) {
+      if (o === null) continue;
+      return o;
+    }
+    const c = f(s);
+    if (!c) {
+      t?.set(s, null);
+      continue;
+    }
+    if (c.includes(h)) {
+      t?.set(s, null);
+      continue;
+    }
+    const a = p(c, e);
+    return t?.set(s, a), a;
+  }
+  return null;
+}
+function p(n, e) {
+  let t = n;
+  return t.startsWith("file://") && (t = t.slice(7)), e && t.startsWith(e + "/") && (t = t.slice(e.length + 1)), t.replace(/\\/g, "/");
+}
+const C = new d();
+export {
+  v as BUDGET_DEFAULT_ARCHETYPES,
+  A as BUDGET_DEFAULT_BYTES_PER_ENTITY,
+  g as BUDGET_GROWTH_HEADROOM,
+  m as DEFAULT_ECS_CAP_BYTES,
+  D as HOST_COMMAND_PAYLOAD_BYTES,
+  S as HostCommandDispatcher,
+  b as MAX_ENTITY_ID,
+  I as MAX_GENERATION,
+  M as MAX_INDEX,
+  N as MAX_LIVE_GENERATION,
+  O as RETIRED_GENERATION,
+  k as accessCheck,
+  w as createEntityId,
+  C as dispatchTrace,
+  y as getEntityGeneration,
+  G as resolveECSMemory,
+  F as ringDespawnCodec,
+  B as ringDisableCodec,
+  H as ringEnableCodec,
+  L as ringRemoveComponentCodec,
+  U as ringSetFieldCodec
+};

package/dist/primitives.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./topological_sort-WAT-VHb-.cjs");class s{_dense=[];_sparse=[];get size(){return this._dense.length}get values(){return this._dense}has(e){return this._dense[this._sparse[e]]===e}add(e){this.has(e)||(this._sparse[e]=this._dense.length,this._dense.push(e))}delete(e){if(!this.has(e))return!1;const t=this._sparse[e],a=this._dense[this._dense.length-1];return this._dense[t]=a,this._sparse[a]=t,this._dense.pop(),!0}clear(){this._dense.length=0,this._sparse.length=0}[Symbol.iterator](){return this._dense[Symbol.iterator]()}}exports.BinaryHeap=r.BinaryHeap;exports.BitSet=r.BitSet;exports.GrowableFloat32Array=r.GrowableFloat32Array;exports.GrowableFloat64Array=r.GrowableFloat64Array;exports.GrowableInt16Array=r.GrowableInt16Array;exports.GrowableInt32Array=r.GrowableInt32Array;exports.GrowableInt8Array=r.GrowableInt8Array;exports.GrowableTypedArray=r.GrowableTypedArray;exports.GrowableUint16Array=r.GrowableUint16Array;exports.GrowableUint32Array=r.GrowableUint32Array;exports.GrowableUint8Array=r.GrowableUint8Array;exports.SparseMap=r.SparseMap;exports.topologicalSort=r.topologicalSort;exports.SparseSet=s;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./typed_arrays-D3NmwtCG.cjs"),t=require("./topological_sort-BDvEyb9W.cjs");class o{_dense=[];_sparse=[];get size(){return this._dense.length}get values(){return this._dense}has(e){return this._dense[this._sparse[e]]===e}add(e){this.has(e)||(this._sparse[e]=this._dense.length,this._dense.push(e))}delete(e){if(!this.has(e))return!1;const a=this._sparse[e],s=this._dense[this._dense.length-1];return this._dense[a]=s,this._sparse[s]=a,this._dense.pop(),!0}clear(){this._dense.length=0,this._sparse.length=0}[Symbol.iterator](){return this._dense[Symbol.iterator]()}}exports.BitSet=r.BitSet;exports.GrowableFloat32Array=r.GrowableFloat32Array;exports.GrowableFloat64Array=r.GrowableFloat64Array;exports.GrowableInt16Array=r.GrowableInt16Array;exports.GrowableInt32Array=r.GrowableInt32Array;exports.GrowableInt8Array=r.GrowableInt8Array;exports.GrowableTypedArray=r.GrowableTypedArray;exports.GrowableUint16Array=r.GrowableUint16Array;exports.GrowableUint32Array=r.GrowableUint32Array;exports.GrowableUint8Array=r.GrowableUint8Array;exports.BinaryHeap=t.BinaryHeap;exports.SparseMap=t.SparseMap;exports.topologicalSort=t.topologicalSort;exports.SparseSet=o;

package/dist/primitives.d.cts

@@ -0,0 +1,18 @@
+/**
+ * `@oasys/oecs/primitives` — the general-purpose data-structure primitives the
+ * ECS is built on, surfaced for direct consumer use: a bit set, sparse set/map,
+ * growable typed arrays, a binary heap, and a topological sort.
+ *
+ * These are the low-level building blocks only; the ECS itself is the default
+ * `@oasys/oecs` entry. The internal assertion, brand, and error helpers under
+ * `src/type_primitives/` are intentionally NOT re-exported here.
+ *
+ * @module
+ */
+export { BitSet } from './type_primitives/bitset/bitset.cjs';
+export { SparseSet } from './type_primitives/sparse_set/sparse_set.cjs';
+export { SparseMap } from './type_primitives/sparse_map/sparse_map.cjs';
+export { GrowableTypedArray, GrowableFloat32Array, GrowableFloat64Array, GrowableInt8Array, GrowableInt16Array, GrowableInt32Array, GrowableUint8Array, GrowableUint16Array, GrowableUint32Array, type TypedArrayTag, type AnyTypedArray } from './type_primitives/typed_arrays/typed_arrays.cjs';
+export { BinaryHeap, type CompareFn } from './type_primitives/binary_heap/binary_heap.cjs';
+export { topologicalSort } from './type_primitives/topological_sort/topological_sort.cjs';
+//# sourceMappingURL=primitives.d.ts.map

package/dist/primitives.d.ts

@@ -9,10 +9,10 @@
  *
  * @module
  */
-export { BitSet } from './type_primitives/bitset/bitset';
-export { SparseSet } from './type_primitives/sparse_set/sparse_set';
-export { SparseMap } from './type_primitives/sparse_map/sparse_map';
-export { GrowableTypedArray, GrowableFloat32Array, GrowableFloat64Array, GrowableInt8Array, GrowableInt16Array, GrowableInt32Array, GrowableUint8Array, GrowableUint16Array, GrowableUint32Array, type TypedArrayTag, type AnyTypedArray } from './type_primitives/typed_arrays/typed_arrays';
-export { BinaryHeap, type CompareFn } from './type_primitives/binary_heap/binary_heap';
-export { topologicalSort } from './type_primitives/topological_sort/topological_sort';
+export { BitSet } from './type_primitives/bitset/bitset.js';
+export { SparseSet } from './type_primitives/sparse_set/sparse_set.js';
+export { SparseMap } from './type_primitives/sparse_map/sparse_map.js';
+export { GrowableTypedArray, GrowableFloat32Array, GrowableFloat64Array, GrowableInt8Array, GrowableInt16Array, GrowableInt32Array, GrowableUint8Array, GrowableUint16Array, GrowableUint32Array, type TypedArrayTag, type AnyTypedArray } from './type_primitives/typed_arrays/typed_arrays.js';
+export { BinaryHeap, type CompareFn } from './type_primitives/binary_heap/binary_heap.js';
+export { topologicalSort } from './type_primitives/topological_sort/topological_sort.js';
 //# sourceMappingURL=primitives.d.ts.map

package/dist/primitives.js

@@ -1,5 +1,6 @@
-import { i as h, B as l, a as o, b as _, d, e as p, c as b, G as u, g as w, h as G, f as g, S as y, t as A } from "./topological_sort-DlRpSrxu.js";
-class t {
+import { B as h, a as o, b as l, d as p, e as _, c as d, G as b, g as u, h as w, f as G } from "./typed_arrays-BcXcnzB4.js";
+import { B as y, S as A, t as S } from "./topological_sort-DK6EjpWa.js";
+class a {
   _dense = [];
   _sparse = [];
   get size() {
@@ -8,16 +9,16 @@ class t {
   get values() {
     return this._dense;
   }
-  has(s) {
-    return this._dense[this._sparse[s]] === s;
+  has(e) {
+    return this._dense[this._sparse[e]] === e;
   }
-  add(s) {
-    this.has(s) || (this._sparse[s] = this._dense.length, this._dense.push(s));
+  add(e) {
+    this.has(e) || (this._sparse[e] = this._dense.length, this._dense.push(e));
   }
-  delete(s) {
-    if (!this.has(s)) return !1;
-    const e = this._sparse[s], r = this._dense[this._dense.length - 1];
-    return this._dense[e] = r, this._sparse[r] = e, this._dense.pop(), !0;
+  delete(e) {
+    if (!this.has(e)) return !1;
+    const s = this._sparse[e], r = this._dense[this._dense.length - 1];
+    return this._dense[s] = r, this._sparse[r] = s, this._dense.pop(), !0;
   }
   clear() {
     this._dense.length = 0, this._sparse.length = 0;
@@ -27,18 +28,18 @@ class t {
   }
 }
 export {
-  h as BinaryHeap,
-  l as BitSet,
+  y as BinaryHeap,
+  h as BitSet,
   o as GrowableFloat32Array,
-  _ as GrowableFloat64Array,
-  d as GrowableInt16Array,
-  p as GrowableInt32Array,
-  b as GrowableInt8Array,
-  u as GrowableTypedArray,
-  w as GrowableUint16Array,
-  G as GrowableUint32Array,
-  g as GrowableUint8Array,
-  y as SparseMap,
-  t as SparseSet,
-  A as topologicalSort
+  l as GrowableFloat64Array,
+  p as GrowableInt16Array,
+  _ as GrowableInt32Array,
+  d as GrowableInt8Array,
+  b as GrowableTypedArray,
+  u as GrowableUint16Array,
+  w as GrowableUint32Array,
+  G as GrowableUint8Array,
+  A as SparseMap,
+  a as SparseSet,
+  S as topologicalSort
 };

package/dist/reactive/array.d.ts

@@ -0,0 +1,24 @@
+export interface ReactiveArray<T> {
+    /** Read slot `i`, subscribing to that slot (or to structure if out of range). */
+    get(i: number): T | undefined;
+    /** Element count, tracking structure (length changes only, not value updates). */
+    length(): number;
+    /**
+     * Whole-array snapshot. Tracks structure AND every slot value — the COARSE read
+     * (any slot change wakes it). Use `length()` + `get(i)` for the fine-grained path;
+     * `snapshot()` is for feeding a positional array to a Solid `<Index each>`.
+     */
+    snapshot(): readonly T[];
+    /** Fine-grained slot write. Updating an in-range slot wakes only that slot's readers. */
+    set(i: number, value: T): void;
+    /** Append one element; bumps structure. */
+    push(value: T): void;
+    /** Remove + return the last element; bumps structure. */
+    pop(): T | undefined;
+    /** Array-semantics splice; positionally reconciles so only shifted slots wake. */
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+    /** Structural-sharing bulk replace: diff vs current, write only changed slots. */
+    reconcile(next: readonly T[]): void;
+}
+export declare function reactiveArray<T>(initial?: readonly T[], eq?: (a: T, b: T) => boolean): ReactiveArray<T>;
+//# sourceMappingURL=array.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/reactive/array.ts"],"names":[],"mappings":"AA2CA,MAAM,WAAW,aAAa,CAAC,CAAC;IAC/B,iFAAiF;IACjF,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC;IAC9B,kFAAkF;IAClF,MAAM,IAAI,MAAM,CAAC;IACjB;;;;OAIG;IACH,QAAQ,IAAI,SAAS,CAAC,EAAE,CAAC;IACzB,yFAAyF;IACzF,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAC/B,2CAA2C;IAC3C,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACrB,yDAAyD;IACzD,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;IACrB,kFAAkF;IAClF,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;IAChE,kFAAkF;IAClF,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,GAAG,IAAI,CAAC;CACpC;AAED,wBAAgB,aAAa,CAAC,CAAC,EAC9B,OAAO,GAAE,SAAS,CAAC,EAAO,EAC1B,EAAE,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAmB,GACrC,aAAa,CAAC,CAAC,CAAC,CAmGlB"}

package/dist/reactive/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../kernel-yWV3XnAb.cjs"),t=require("../shallow-DQ8aG51_.cjs"),r=require("../interop-CT-REx0W.cjs");exports.batch=e.batch;exports.computed=e.computed;exports.effect=e.effect;exports.onCleanup=e.onCleanup;exports.root=e.root;exports.signal=e.signal;exports.untrack=e.untrack;exports.reactiveArray=t.reactiveArray;exports.reactiveMap=t.reactiveMap;exports.reactiveStruct=t.reactiveStruct;exports.shallow=t.shallow;exports.subscribe=r.subscribe;exports.toExternalStore=r.toExternalStore;

package/dist/reactive/index.d.cts

@@ -0,0 +1,11 @@
+/**
+ * Reactive kernel — the engine UI seam's fine-grained, glitch-free reactive core
+ * (ADR-0021). Zero dependencies; consumer owns rendering. See docs/api/reactive.md.
+ */
+export { signal, computed, effect, batch, untrack, root, onCleanup, type Accessor, type Setter, type Eq } from './kernel.cjs';
+export { reactiveMap, type ReactiveMap } from './map.cjs';
+export { reactiveStruct, type StructSetters, type StructEq } from './struct.cjs';
+export { reactiveArray, type ReactiveArray } from './array.cjs';
+export { subscribe, toExternalStore, type ExternalStore } from './interop.cjs';
+export { shallow } from './shallow.cjs';
+//# sourceMappingURL=index.d.ts.map

package/dist/reactive/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Reactive kernel — the engine UI seam's fine-grained, glitch-free reactive core
+ * (ADR-0021). Zero dependencies; consumer owns rendering. See docs/api/reactive.md.
+ */
+export { signal, computed, effect, batch, untrack, root, onCleanup, type Accessor, type Setter, type Eq } from './kernel.js';
+export { reactiveMap, type ReactiveMap } from './map.js';
+export { reactiveStruct, type StructSetters, type StructEq } from './struct.js';
+export { reactiveArray, type ReactiveArray } from './array.js';
+export { subscribe, toExternalStore, type ExternalStore } from './interop.js';
+export { shallow } from './shallow.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/reactive/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACN,MAAM,EACN,QAAQ,EACR,MAAM,EACN,KAAK,EACL,OAAO,EACP,IAAI,EACJ,SAAS,EACT,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,EAAE,EACP,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,OAAO,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,SAAS,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAC3E,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC"}

package/dist/reactive/index.js

@@ -0,0 +1,18 @@
+import { b as r, c as e, e as t, o, r as c, s as p, u } from "../kernel-DgyrLFjW.js";
+import { b as f, r as i, a as l, s as n } from "../shallow-DfnAm9vG.js";
+import { s as x, t as v } from "../interop-CcY6ASQc.js";
+export {
+  r as batch,
+  e as computed,
+  t as effect,
+  o as onCleanup,
+  f as reactiveArray,
+  i as reactiveMap,
+  l as reactiveStruct,
+  c as root,
+  n as shallow,
+  p as signal,
+  x as subscribe,
+  v as toExternalStore,
+  u as untrack
+};

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/{core/reactive → reactive}/interop.d.ts

@@ -1,4 +1,4 @@
-import { Accessor } from './kernel';
+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

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/{core/reactive → reactive}/kernel.d.ts

@@ -36,12 +36,15 @@
  * workload heavy in *unobserved* computeds and are low-value without each other;
  * see ADR-0021. Cycle reads return the stale value rather than throwing.
  */
-type Eq<T> = (a: T, b: T) => boolean;
+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`. */
+/** 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>;
@@ -67,5 +70,4 @@ export declare function root<T>(fn: (dispose: () => void) => T): T;
  * before each re-run and on dispose; inside a `root` it runs on root disposal.
  */
 export declare function onCleanup(fn: () => void): void;
-export {};
 //# 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.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/{core/reactive → reactive}/struct.d.ts

@@ -6,5 +6,5 @@ export type StructSetters<T> = {
 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: T, set: StructSetters<T>];
+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;