aeon-ui-engine 1.9.0 → 1.10.1

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [1.10.1] - 2026-10-22
+
+### Changed
+
+- Patch release so consumers can install a fresh `aeon-ui-engine` after 1.10.0.
+
+## [1.10.0] - 2026-10-21
+
+### Added
+
+- **App store (`@aeon-ui/primitives`).** `createAeonStore({ id, slices, persist?, sync? })` keeps an app's data in one place: each entity once, by id, in its slice (`defineSlice({ idOf, load?, ttl?, tags? })`). Every change is an event: `ENTITY.UPSERT`, `ENTITY.PATCH` and `ENTITY.REMOVE`, plus optimistic `WRITE.BEGIN`, which marks entities pending until `WRITE.CONFIRM` or `WRITE.ROLLBACK` (restores the old value and marks it failed). Queries run on the chart cache (`QUERY.FETCH`, `QUERY.REFRESH`, `QUERY.INVALIDATE`, `STORE.INVALIDATE`). `select`, `query` and `entity` return the same object until their data changes. `queryAttrs` and `entityAttrs` project state onto `data-aeon-state`. Persistence saves only confirmed values through an adapter (`memoryAdapter`, `webStorageAdapter`), with `version` and `migrate`. `sync` feeds server pushes in as events, and `STORE.CLEAR` wipes memory, running loads and the saved copy. Charts read it by invoking `store.actor`. Store ids, slice names and entity fields that name secrets, keys or spend decisions are refused.
+- **`useAeonSelector` and `useAeonQuery` (`@aeon-ui/react`).** Read the store; a component re-renders only when the value it selects changes.
+
 ## [1.9.0] - 2026-10-21
 
 ### Added

package/README.md

@@ -176,6 +176,39 @@ function AsyncSurface() {
 
 See [docs/PRIMITIVE_COVERAGE.md](./docs/PRIMITIVE_COVERAGE.md).
 
+## App data: one store
+
+Each app keeps its data in one `createAeonStore`: every entity once, by id, in its slice. Components never copy it. They read through selectors and show state through `data-aeon-*` attributes. Every change is an event sent to the store.
+
+```tsx
+import { createAeonStore, defineSlice, entityAttrs, queryAttrs, webStorageAdapter } from '@aeon-ui/primitives'
+import { useAeonQuery, useAeonSelector } from '@aeon-ui/react'
+
+export const store = createAeonStore({
+  id: 'wallet-app',
+  slices: { payments: defineSlice<Payment>({ idOf: (p) => p.id, load: (query) => api.payments(query), ttl: 30_000 }) },
+  persist: { adapter: webStorageAdapter(), version: 1 },
+  sync: (send) => api.onPayment((p) => send({ type: 'ENTITY.UPSERT', slice: 'payments', entities: [p] })),
+})
+
+function Payments() {
+  const result = useAeonQuery(store, 'payments', 'recent') // loads once per key, shared by every reader
+  return <ul {...queryAttrs(result)}>{result.entities.map((p) => <PaymentRow key={p.id} id={p.id} />)}</ul>
+}
+
+function PaymentRow({ id }: { id: string }) {
+  const payment = useAeonSelector(store, (s) => s.slices.payments.byId[id]) // re-renders only when this payment changes
+  const slice = useAeonSelector(store, (s) => s.slices.payments)
+  return <li {...entityAttrs(slice, 'payments', id)}>{payment?.amount}</li>
+}
+```
+
+- **Writes:** `ENTITY.UPSERT`, `ENTITY.PATCH` and `ENTITY.REMOVE` change entities directly. `WRITE.BEGIN` applies a change at once and marks it `pending` until `WRITE.CONFIRM`, or until `WRITE.ROLLBACK` puts the old value back and marks the entity `failed`.
+- **Queries:** `QUERY.FETCH`, `QUERY.REFRESH` and `QUERY.INVALIDATE { query | tag }` run on the chart cache's states (`idle`, `loading`, `ready`, `stale`, `refreshing`, `failed`). `STORE.INVALIDATE` reloads every watched query (for reconnect or window focus). `STORE.CLEAR` drops all data, running loads and the saved copy (for lock or account switch).
+- **Persistence:** only confirmed values are saved, after a short quiet delay. A `version` bump runs `migrate`; without one, older saved data is dropped. Data written during start-up wins over the saved copy. Slices with `persist: false` stay in memory.
+- **Charts:** invoke `store.actor` with `input: { select }` to get `STORE.UPDATE` whenever the selection changes. Store events sent to it are forwarded to the store.
+- **Never stored:** store ids, slice names and entity fields at any depth that name secrets, keys, seeds, passwords or spend are refused.
+
 ## Example
 
 ```tsx

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aeon-ui-engine",
-  "version": "1.9.0",
+  "version": "1.10.1",
   "private": false,
   "type": "module",
   "bin": {

package/packages/core/vitest.config.ts

@@ -3,6 +3,7 @@ import { defineConfig } from 'vitest/config'
 export default defineConfig({
   test: {
     environment: 'node',
+    maxWorkers: '50%',
     include: ['src/**/*.test.ts'],
   },
 })

package/packages/primitives/dist/chunk-H5XJGZHT.js

@@ -0,0 +1,493 @@
+import {
+  createChartCache,
+  isCacheableId
+} from "./chunk-5BNAV4S2.js";
+
+// src/machines/store.ts
+import { stateToAttr } from "@aeon-ui/core";
+import { assign, createActor, fromCallback, setup } from "xstate";
+function defineSlice(options) {
+  return options;
+}
+var DEFAULT_TTL = 3e4;
+var ALL_TAG = "*";
+var EMPTY_IDS = Object.freeze([]);
+var IDLE_QUERY = Object.freeze({ state: "idle", ids: EMPTY_IDS, error: null, loadedAt: null });
+var EMPTY_SLICE = Object.freeze({ byId: {}, ids: EMPTY_IDS, queries: {}, pending: {}, failed: {} });
+var defaultKeyOf = (key) => typeof key === "string" ? key : JSON.stringify(key);
+function shallowEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const keysA = Object.keys(a);
+  if (keysA.length !== Object.keys(b).length) return false;
+  return keysA.every((key) => Object.hasOwn(b, key) && Object.is(a[key], b[key]));
+}
+function isStorableName(name) {
+  return isCacheableId(name.replace(/([a-z0-9])([A-Z])/g, "$1 $2"));
+}
+function unstorableField(value, depth = 0) {
+  if (depth > 8 || typeof value !== "object" || value === null) return null;
+  for (const [key, inner] of Object.entries(value)) {
+    if (!Array.isArray(value) && !isStorableName(key)) return key;
+    const nested = unstorableField(inner, depth + 1);
+    if (nested !== null) return nested;
+  }
+  return null;
+}
+function queryAttrs(result) {
+  return { "data-aeon-state": stateToAttr(result.state), "data-aeon-count": String(result.ids.length) };
+}
+function entityAttrs(slice, sliceName, id) {
+  const state = slice.pending[id] !== void 0 ? "pending" : slice.failed[id] !== void 0 ? "failed" : "settled";
+  return { "data-aeon-entity": sliceName, "data-aeon-state": state };
+}
+function memoryAdapter(initial = {}) {
+  const data = new Map(Object.entries(initial));
+  return {
+    data,
+    load: (key) => data.get(key) ?? null,
+    save: (key, value) => void data.set(key, value),
+    remove: (key) => void data.delete(key)
+  };
+}
+function webStorageAdapter(storage = globalThis.localStorage) {
+  return {
+    load: (key) => storage.getItem(key),
+    save: (key, value) => storage.setItem(key, value),
+    remove: (key) => storage.removeItem(key)
+  };
+}
+function omit(record, keys) {
+  let next = null;
+  for (const key of keys) {
+    if (!Object.hasOwn(record, key)) continue;
+    next ??= { ...record };
+    delete next[key];
+  }
+  return next ?? record;
+}
+function withSlice(data, name, slice) {
+  return slice === data.slices[name] ? data : { ...data, slices: { ...data.slices, [name]: slice } };
+}
+function putEntities(r, name, slice, entities) {
+  const def = r.defs[name];
+  const equals = def.equals ?? shallowEqual;
+  let byId = null;
+  let added = null;
+  let failed = slice.failed;
+  for (const entity of entities) {
+    const id = def.idOf(entity);
+    const held = (byId ?? slice.byId)[id];
+    failed = omit(failed, [id]);
+    if (held !== void 0 && (held === entity || equals(held, entity))) continue;
+    byId ??= { ...slice.byId };
+    if (held === void 0 && !Object.hasOwn(byId, id)) (added ??= []).push(id);
+    byId[id] = entity;
+  }
+  if (!byId && failed === slice.failed) return slice;
+  return { ...slice, byId: byId ?? slice.byId, ids: added ? [...slice.ids, ...added] : slice.ids, failed };
+}
+function removeEntities(slice, ids) {
+  const byId = omit(slice.byId, ids);
+  if (byId === slice.byId) return slice;
+  const gone = new Set(ids);
+  return { ...slice, byId, ids: slice.ids.filter((id) => !gone.has(id)) };
+}
+function sameIds(a, b) {
+  return a.length === b.length && a.every((id, i) => id === b[i]);
+}
+function applyQueryUpdate(r, data, name, key, view) {
+  const def = r.defs[name];
+  let slice = data.slices[name] ?? EMPTY_SLICE;
+  let writes = data.writes;
+  const previous = slice.queries[key] ?? IDLE_QUERY;
+  let ids = previous.ids;
+  if (view.data !== void 0) {
+    const incoming = view.data;
+    const settled = [];
+    for (const entity of incoming) {
+      const id = def.idOf(entity);
+      const write = slice.pending[id];
+      if (write !== void 0 && writes[write]) {
+        writes = { ...writes, [write]: { ...writes[write], before: { ...writes[write].before, [id]: entity } } };
+      } else settled.push(entity);
+    }
+    slice = putEntities(r, name, slice, settled);
+    const nextIds = incoming.map(def.idOf);
+    if (!sameIds(nextIds, ids)) ids = nextIds;
+  } else if (view.state === "idle") ids = EMPTY_IDS;
+  const query = previous.state === view.state && previous.ids === ids && previous.error === view.error && previous.loadedAt === view.loadedAt ? previous : Object.freeze({ state: view.state, ids, error: view.error, loadedAt: view.loadedAt });
+  if (query !== previous) slice = { ...slice, queries: { ...slice.queries, [key]: query } };
+  const next = withSlice(data, name, slice);
+  return writes === data.writes ? next : { ...next, writes };
+}
+function beginWrite(r, data, event) {
+  if (data.writes[event.write]) return data;
+  const def = r.defs[event.slice];
+  let slice = data.slices[event.slice] ?? EMPTY_SLICE;
+  const before = {};
+  const after = {};
+  const ids = [];
+  for (const entity of event.upsert ?? []) {
+    const id = def.idOf(entity);
+    before[id] = slice.byId[id];
+    ids.push(id);
+  }
+  for (const id of event.remove ?? []) {
+    before[id] = slice.byId[id];
+    ids.push(id);
+  }
+  slice = putEntities(r, event.slice, slice, event.upsert ?? []);
+  slice = removeEntities(slice, event.remove ?? []);
+  for (const id of ids) after[id] = slice.byId[id];
+  const pending = { ...slice.pending };
+  for (const id of ids) pending[id] = event.write;
+  slice = { ...slice, pending, failed: omit(slice.failed, ids) };
+  return { ...withSlice(data, event.slice, slice), writes: { ...data.writes, [event.write]: { slice: event.slice, before, after } } };
+}
+function settleWrite(data, writeId, rollback) {
+  const write = data.writes[writeId];
+  if (!write) return data;
+  let slice = data.slices[write.slice] ?? EMPTY_SLICE;
+  const ids = Object.keys(write.after);
+  const mine = ids.filter((id) => slice.pending[id] === writeId);
+  slice = { ...slice, pending: omit(slice.pending, mine) };
+  if (rollback !== null) {
+    const failed = { ...slice.failed };
+    for (const id of ids) {
+      if (slice.byId[id] !== write.after[id]) continue;
+      const restore = write.before[id];
+      if (restore === void 0) slice = removeEntities(slice, [id]);
+      else {
+        const had = Object.hasOwn(slice.byId, id);
+        slice = { ...slice, byId: { ...slice.byId, [id]: restore }, ids: had ? slice.ids : [...slice.ids, id] };
+      }
+      failed[id] = rollback;
+    }
+    slice = { ...slice, failed };
+  }
+  const writes = { ...data.writes };
+  delete writes[writeId];
+  return { ...withSlice(data, write.slice, slice), writes };
+}
+function hydrate(r, data, saved) {
+  let next = { ...data, status: "ready" };
+  if (!saved) return next;
+  for (const [name, stored] of Object.entries(saved)) {
+    const def = r.defs[name];
+    if (!def || def.persist === false || !stored || typeof stored.byId !== "object") continue;
+    const slice = next.slices[name] ?? EMPTY_SLICE;
+    const order = Array.isArray(stored.ids) ? stored.ids : Object.keys(stored.byId);
+    const missing = order.map((id) => stored.byId[id]).filter((entity) => entity !== void 0 && unstorableField(entity) === null && !Object.hasOwn(slice.byId, def.idOf(entity)));
+    next = withSlice(next, name, putEntities(r, name, slice, missing));
+  }
+  return next;
+}
+function reduce(r, data, event) {
+  switch (event.type) {
+    case "ENTITY.UPSERT":
+      return withSlice(data, event.slice, putEntities(r, event.slice, data.slices[event.slice] ?? EMPTY_SLICE, event.entities));
+    case "ENTITY.PATCH": {
+      const slice = data.slices[event.slice] ?? EMPTY_SLICE;
+      const held = slice.byId[event.id];
+      if (held === void 0) return data;
+      return withSlice(data, event.slice, putEntities(r, event.slice, slice, [{ ...held, ...event.patch }]));
+    }
+    case "ENTITY.REMOVE": {
+      const slice = removeEntities(data.slices[event.slice] ?? EMPTY_SLICE, event.ids);
+      return withSlice(data, event.slice, { ...slice, failed: omit(slice.failed, event.ids) });
+    }
+    case "WRITE.BEGIN":
+      return beginWrite(r, data, event);
+    case "WRITE.CONFIRM":
+      return settleWrite(data, event.write, null);
+    case "WRITE.ROLLBACK":
+      return settleWrite(data, event.write, event.error ?? "write failed");
+    case "QUERY.UPDATE":
+      return applyQueryUpdate(r, data, event.slice, event.key, event.view);
+    case "STORE.HYDRATED":
+      return hydrate(r, data, event.slices);
+    case "STORE.CLEAR":
+      return { ...data, slices: Object.fromEntries(Object.keys(r.defs).map((name) => [name, EMPTY_SLICE])), writes: {} };
+    default:
+      return data;
+  }
+}
+function createStoreMachine(defs) {
+  const r = { defs };
+  return setup({
+    types: {
+      context: {},
+      events: {},
+      input: {}
+    }
+  }).createMachine({
+    id: "aeonStore",
+    context: ({ input }) => ({
+      data: {
+        status: input.hydrate ? "hydrating" : "ready",
+        slices: Object.fromEntries(Object.keys(defs).map((name) => [name, EMPTY_SLICE])),
+        writes: {}
+      }
+    }),
+    initial: "boot",
+    states: {
+      boot: { always: [{ guard: ({ context }) => context.data.status === "hydrating", target: "hydrating" }, { target: "ready" }] },
+      hydrating: { on: { "STORE.HYDRATED": { target: "ready", actions: assign(({ context, event }) => ({ data: reduce(r, context.data, event) })) } } },
+      ready: {}
+    },
+    on: {
+      "*": { actions: assign(({ context, event }) => event.type === "STORE.HYDRATED" ? {} : { data: reduce(r, context.data, event) }) }
+    }
+  });
+}
+function persistable(defs, data) {
+  const out = {};
+  for (const [name, def] of Object.entries(defs)) {
+    if (def.persist === false) continue;
+    const slice = data.slices[name] ?? EMPTY_SLICE;
+    const byId = { ...slice.byId };
+    const ids = [...slice.ids];
+    for (const [id, writeId] of Object.entries(slice.pending)) {
+      const before = data.writes[writeId]?.before[id];
+      if (before === void 0) {
+        delete byId[id];
+        const at = ids.indexOf(id);
+        if (at >= 0) ids.splice(at, 1);
+      } else {
+        if (!Object.hasOwn(byId, id)) ids.push(id);
+        byId[id] = before;
+      }
+    }
+    out[name] = { byId, ids };
+  }
+  return out;
+}
+function parseSaved(raw, options) {
+  if (!raw) return null;
+  try {
+    const saved = JSON.parse(raw);
+    if (typeof saved !== "object" || saved === null || typeof saved.slices !== "object" || saved.slices === null) return null;
+    const slices = saved.slices;
+    if (saved.version === options.version) return slices;
+    if (typeof saved.version !== "number" || !options.migrate) return null;
+    return options.migrate(slices, saved.version) ?? null;
+  } catch {
+    return null;
+  }
+}
+function createAeonStore(options) {
+  if (!isStorableName(options.id)) throw new Error(`refusing store "${options.id}": secrets, keys and spend decisions are never stored`);
+  for (const name of Object.keys(options.slices)) {
+    if (!isStorableName(name)) throw new Error(`refusing slice "${name}" in store "${options.id}": secrets, keys and spend decisions are never stored`);
+  }
+  const defs = options.slices;
+  const persist = options.persist;
+  const storageKey = `aeon-store:${options.id}`;
+  const actor = createActor(createStoreMachine(defs), { input: { hydrate: persist !== void 0 } });
+  const listeners = /* @__PURE__ */ new Set();
+  const caches = /* @__PURE__ */ new Map();
+  const watched = /* @__PURE__ */ new Map();
+  let data = actor.getSnapshot().context.data;
+  let stopped = false;
+  for (const [name, def] of Object.entries(defs)) {
+    if (!def.load) continue;
+    const load = def.load;
+    const userTags = def.tags;
+    caches.set(
+      name,
+      createChartCache({
+        id: `${options.id}.${name}`,
+        load: (query2, context) => load(query2, context),
+        ttl: def.ttl ?? DEFAULT_TTL,
+        tags: (query2) => [ALL_TAG, ...userTags?.(query2) ?? []],
+        keyOf: def.queryKey ?? defaultKeyOf,
+        // Watched queries are pinned; this bounds the unwatched ones.
+        maxEntries: 200,
+        now: options.now
+      })
+    );
+  }
+  let saveTimer = null;
+  const save = async () => {
+    if (saveTimer !== null) clearTimeout(saveTimer);
+    saveTimer = null;
+    if (!persist || stopped || data.status !== "ready") return;
+    await persist.adapter.save(storageKey, JSON.stringify({ version: persist.version, slices: persistable(defs, data) }));
+  };
+  const persisted = Object.keys(defs).filter((name) => defs[name].persist !== false);
+  const persistChanged = (previous, next) => persisted.some((name) => previous.slices[name]?.byId !== next.slices[name]?.byId || previous.slices[name]?.pending !== next.slices[name]?.pending);
+  const heldBeforeHydration = (previous) => persisted.some((name) => (previous.slices[name]?.ids.length ?? 0) > 0);
+  actor.subscribe((snapshot) => {
+    const next = snapshot.context.data;
+    if (next === data) return;
+    const previous = data;
+    data = next;
+    if (persist && next.status === "ready" && (previous.status === "ready" ? persistChanged(previous, next) : heldBeforeHydration(previous))) {
+      if (saveTimer !== null) clearTimeout(saveTimer);
+      saveTimer = setTimeout(() => void save().catch(() => {
+      }), persist.delayMs ?? 250);
+    }
+    for (const listener of [...listeners]) listener();
+  });
+  actor.start();
+  const keyOf = (name, query2) => (defs[name].queryKey ?? defaultKeyOf)(query2);
+  const watch = (name, query2) => {
+    const cache = caches.get(name);
+    if (!cache) throw new Error(`slice "${name}" in store "${options.id}" has no load, so it has no queries`);
+    const key = keyOf(name, query2);
+    let forSlice = watched.get(name);
+    if (!forSlice) watched.set(name, forSlice = /* @__PURE__ */ new Map());
+    if (!forSlice.has(key)) {
+      const forward = (view) => actor.send({ type: "QUERY.UPDATE", slice: name, key, view });
+      forSlice.set(key, cache.subscribe(query2, forward));
+      forward(cache.peek(query2));
+    }
+    return cache;
+  };
+  const unwatchAll = () => {
+    for (const forSlice of watched.values()) for (const stop of forSlice.values()) stop();
+    watched.clear();
+  };
+  const checkFields = (entities) => {
+    for (const entity of entities) {
+      const field = unstorableField(entity);
+      if (field !== null) throw new Error(`refusing field "${field}" in store "${options.id}": secrets, keys and spend decisions are never stored`);
+    }
+  };
+  const send = (event) => {
+    if (stopped) return;
+    const e = event;
+    if ("slice" in e && !Object.hasOwn(defs, e.slice)) throw new Error(`store "${options.id}" has no slice "${e.slice}"`);
+    switch (e.type) {
+      case "ENTITY.UPSERT":
+        checkFields(e.entities);
+        break;
+      case "ENTITY.PATCH":
+        checkFields([e.patch]);
+        break;
+      case "WRITE.BEGIN":
+        checkFields(e.upsert ?? []);
+        break;
+      case "QUERY.FETCH":
+        watch(e.slice, e.query).fetch(e.query);
+        return;
+      case "QUERY.REFRESH":
+        watch(e.slice, e.query).refresh(e.query);
+        return;
+      case "QUERY.INVALIDATE": {
+        const cache = caches.get(e.slice);
+        if (!cache) return;
+        if (e.tag !== void 0) cache.invalidate({ tag: e.tag });
+        else if (e.query !== void 0) cache.invalidate({ key: e.query });
+        else cache.invalidate({ tag: ALL_TAG });
+        return;
+      }
+      case "STORE.INVALIDATE":
+        for (const cache of caches.values()) cache.invalidate({ tag: ALL_TAG });
+        return;
+      case "STORE.CLEAR":
+        unwatchAll();
+        for (const cache of caches.values()) cache.clear();
+        actor.send(e);
+        if (saveTimer !== null) clearTimeout(saveTimer);
+        saveTimer = null;
+        if (persist) void Promise.resolve(persist.adapter.remove(storageKey)).catch(() => {
+        });
+        return;
+    }
+    actor.send(e);
+  };
+  const results = /* @__PURE__ */ new Map();
+  const query = (name, q) => {
+    const key = keyOf(name, q);
+    const slice = data.slices[name] ?? EMPTY_SLICE;
+    const view = slice.queries[key] ?? IDLE_QUERY;
+    const memoKey = `${name}\0${key}`;
+    const held = results.get(memoKey);
+    if (held && held.view === view && held.byId === slice.byId) return held.result;
+    const entities = view.ids.map((id) => slice.byId[id]).filter((entity) => entity !== void 0);
+    const result = held && held.view === view && sameEntities(held.result.entities, entities) ? held.result : Object.freeze({ ...view, entities: Object.freeze(entities) });
+    results.set(memoKey, { view, byId: slice.byId, result });
+    return result;
+  };
+  const select = (selector, equals = Object.is) => {
+    let from = data;
+    let value = selector(data);
+    const get = () => {
+      if (from !== data) {
+        const next = selector(data);
+        from = data;
+        if (!equals(value, next)) value = next;
+      }
+      return value;
+    };
+    return {
+      get,
+      subscribe: (listener) => {
+        let last = get();
+        return store.subscribe(() => {
+          const next = get();
+          if (next === last) return;
+          last = next;
+          listener(next);
+        });
+      }
+    };
+  };
+  let stopSync = void 0;
+  const ready = persist ? Promise.resolve().then(() => persist.adapter.load(storageKey)).then((raw) => parseSaved(raw, persist), () => null).then((slices) => {
+    if (!stopped) actor.send({ type: "STORE.HYDRATED", slices });
+  }) : Promise.resolve();
+  const store = {
+    id: options.id,
+    getSnapshot: () => data,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    },
+    send,
+    select,
+    entity: (name, id) => (data.slices[name] ?? EMPTY_SLICE).byId[id],
+    query: (name, q) => query(name, q),
+    ready,
+    flush: () => ready.then(save),
+    stop: () => {
+      if (stopped) return;
+      stopped = true;
+      if (saveTimer !== null) clearTimeout(saveTimer);
+      if (typeof stopSync === "function") stopSync();
+      unwatchAll();
+      actor.stop();
+      listeners.clear();
+    },
+    actor: fromCallback(
+      ({ input, sendBack, receive }) => {
+        const selection = select(input.select, input.equals);
+        const report = (value) => sendBack({ type: "STORE.UPDATE", store: options.id, value });
+        report(selection.get());
+        receive((event) => send(event));
+        return selection.subscribe(report);
+      }
+    )
+  };
+  stopSync = options.sync?.(send);
+  return store;
+}
+function sameEntities(a, b) {
+  return a.length === b.length && a.every((entity, i) => entity === b[i]);
+}
+
+export {
+  defineSlice,
+  shallowEqual,
+  isStorableName,
+  unstorableField,
+  queryAttrs,
+  entityAttrs,
+  memoryAdapter,
+  webStorageAdapter,
+  createStoreMachine,
+  createAeonStore
+};

package/packages/primitives/dist/index.d.ts

@@ -17,4 +17,5 @@ export { STICKY_BAR_STATES, StickyBarContext, StickyBarEvent, StickyBarState, st
 export { CONTENT_REGION_STATES, ContentRegionContext, ContentRegionEvent, ContentRegionState, contentRegionMachine } from './machines/content-region.js';
 export { CLIPBOARD_STATES, ClipboardContext, ClipboardEvent, ClipboardStatus, clipboardMachine } from './machines/clipboard.js';
 export { CACHE_STATES, CacheCommand, CacheEntryActor, CacheEntryContext, CacheEntryEvent, CacheEntryInput, CacheState, CacheUpdate, CacheView, ChartCache, ChartCacheOptions, cacheEntryMachine, createCacheEntryMachine, createChartCache, isCacheableId } from './machines/cache.js';
+export { AeonStore, AnySlices, EntityOf, PersistedSlices, QueryOf, QueryResult, QueryView, Selection, SliceDefinition, SliceOptions, SliceState, StoreAdapter, StoreEvent, StoreOptions, StorePersistOptions, StoreState, StoreStatus, StoreUpdate, createAeonStore, createStoreMachine, defineSlice, entityAttrs, isStorableName, memoryAdapter, queryAttrs, shallowEqual, unstorableField, webStorageAdapter } from './machines/store.js';
 import 'xstate';

package/packages/primitives/dist/index.js

@@ -2,6 +2,18 @@ import {
   STICKY_BAR_STATES,
   stickyBarMachine
 } from "./chunk-YBPNI2LI.js";
+import {
+  createAeonStore,
+  createStoreMachine,
+  defineSlice,
+  entityAttrs,
+  isStorableName,
+  memoryAdapter,
+  queryAttrs,
+  shallowEqual,
+  unstorableField,
+  webStorageAdapter
+} from "./chunk-H5XJGZHT.js";
 import {
   tabsMachine
 } from "./chunk-HONROWUG.js";
@@ -103,24 +115,34 @@ export {
   clamp as clampSliderValue,
   clipboardMachine,
   contentRegionMachine,
+  createAeonStore,
   createAsyncMachine,
   createCacheEntryMachine,
   createChartCache,
+  createStoreMachine,
+  defineSlice,
   dialogMachine,
+  entityAttrs,
   fieldMachine,
   fileUploadMachine,
   getFileUploadPhase,
   isCacheableId,
   isEmptyAsyncData,
+  isStorableName,
+  memoryAdapter,
   normalizePair as normalizeRangeSliderValues,
   panelMachine,
   popoverMachine,
+  queryAttrs,
   rangeSliderMachine,
+  shallowEqual,
   sliderMachine,
   snap2 as snapRangeSliderValue,
   snap as snapSliderValue,
   stickyBarMachine,
   tabsMachine,
   toastMachine,
-  toggleMachine
+  toggleMachine,
+  unstorableField,
+  webStorageAdapter
 };

package/packages/primitives/dist/machines/app-nav.d.ts

@@ -61,13 +61,13 @@ declare const appNavMachine: xstate.StateMachine<AppNavContext, {
     type: "RESET";
     section: string;
 }, {}, never, {
-    type: "pop";
+    type: "replace";
     params: xstate.NonReducibleUnknown;
 } | {
-    type: "push";
+    type: "pop";
     params: xstate.NonReducibleUnknown;
 } | {
-    type: "replace";
+    type: "push";
     params: xstate.NonReducibleUnknown;
 } | {
     type: "clear";