@fluixi/reactive 1.0.0-alpha.82 → 1.0.0-alpha.84

package/dist/lib/store/api.cjs

@@ -1 +1,612 @@
-"use strict";var m=Object.defineProperty;var _=Object.getOwnPropertyDescriptor;var H=Object.getOwnPropertyNames;var W=Object.prototype.hasOwnProperty;var z=(e,t)=>{for(var n in t)m(e,n,{get:t[n],enumerable:!0})},C=(e,t,n,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of H(t))!W.call(e,o)&&o!==n&&m(e,o,{get:()=>t[o],enumerable:!(r=_(t,o))||r.enumerable});return e};var F=e=>C(m({},"__esModule",{value:!0}),e);var J={};z(J,{store:()=>G});module.exports=F(J);var i=require("@fluixi/reactive/signal"),h=Symbol("store-raw"),j=Symbol("store-node"),w=Symbol("store-has"),P=Symbol("store-self"),N=Symbol("store-track");var I=new WeakMap,U=new WeakMap;function M(e){let[t,n]=(0,i.createSignal)(e),r=t;return r.$=n,r}function p(e){let t=I.get(e);return t||I.set(e,t={keys:new Map}),t}function v(e,t,n){let r=e.keys.get(t);return r||e.keys.set(t,r=M(n)),r}function $(e){let t=p(e);(t.all||(t.all=M()))()}function D(e,t){e.$(typeof t=="function"?()=>t:t)}function E(e){if(e==null||typeof e!="object")return!1;if(Array.isArray(e))return!0;let t=Object.getPrototypeOf(e);return t===Object.prototype||t===null}function l(e){if(!E(e))return e;let t=U.get(e);if(t)return t;let n=new Proxy(e,X);return U.set(e,n),n}var X={get(e,t,n){if(t===h||t===j)return e;if(t===i.$PROXY)return n;if(t===w)return a=>a in e;if(t==="__proxy")return!0;if(t===N||t===P)return $(e),n;let r=e[t];if(typeof r=="function"&&!Object.prototype.hasOwnProperty.call(e,t))return r;let o=Object.getOwnPropertyDescriptor(e,t);if(o&&o.get)return o.get.call(n);let s=v(p(e),t,r)();return E(s)?l(s):s},set(){return!0},deleteProperty(e,t){return t in e&&u(e,t,void 0),!0},has(e,t){return t===h||t===i.$PROXY||t===j||t===w||t===P||t===N?!0:(v(p(e),t,e[t])(),t in e)},ownKeys(e){return $(e),Reflect.ownKeys(e)},getOwnPropertyDescriptor(e,t){return Reflect.getOwnPropertyDescriptor(e,t)}};function u(e,t,n){if(e[t]===n&&(n!==void 0||t in e))return;let o=Array.isArray(e),s=o?e.length:0;n===void 0?delete e[t]:e[t]=n;let a=p(e),c=a.keys.get(t);if(c&&D(c,n),o&&e.length!==s){let f=a.keys.get("length");f&&D(f,e.length)}a.all&&a.all.$(void 0)}function R(e,t){return typeof e=="function"?e(t):e}function A(e,t){for(let n of Object.keys(t)){let r=t[n],o=e[n];r&&typeof r=="object"&&!Array.isArray(r)&&o&&typeof o=="object"&&!Array.isArray(o)?A(o,r):u(e,n,r)}}function g(e){let t=[],n=e.replace(/\[([^\]]*)\]/g,".$1");for(let r of n.split("."))r.length&&t.push(r);return t}function K(e,t,n){let r=t.length-1;for(let s=0;s<r;s++){let a=t[s];if(a==="*"){let f=t.slice(s+1);if(Array.isArray(e))for(let T=0;T<e.length;T++)K(e[T],f,n);return}let c=e[a];(c==null||typeof c!="object")&&(c=/^\d+$/.test(t[s+1])?[]:{},u(e,a,c)),e=c}let o=t[r];if(o==="*"){if(Array.isArray(e))for(let s=0;s<e.length;s++)u(e,s,R(n,e[s]));return}u(e,o,R(n,e[o]))}function S(e,t,n){K(e,g(t),n)}function q(e,t){let n=t[0];if(typeof n=="function"&&t.length===1){let r=n(e);r&&r!==e&&A(e,r);return}if(Array.isArray(n)&&t.length===1){for(let r of n)Array.isArray(r)&&S(e,r[0],r[1]);return}if(n&&typeof n=="object"&&!Array.isArray(n)&&t.length===1){A(e,n);return}if(Array.isArray(t[1])&&t.length>=3){S(e,`${n}.${t[1].join(".")}`,t[2]);return}S(e,String(n),t[1])}function O(e){if(e==null||typeof e!="object")return e;if(Array.isArray(e))return e.map(O);let t={};for(let n of Object.keys(e))t[n]=O(e[n]);return t}function y(e,t){let n=e;for(let r of g(t)){if(n==null)return;n=n[r]}return n}var d=class{constructor(t,n={immutable:!0}){this.options=n;this.root=t,this.set=((...r)=>(0,i.batch)(()=>q(this.root,r)))}get state(){return l(this.root)}get proxy(){return l(this.root)}get accessor(){return(()=>l(this.root))}unwrap(){return this.root}getNode(t){return this.root&&this.root[t]}get(t){if(t==null||t==="")return b(this.state);let n=this.state;for(let r of g(t)){if(n==null)return;n=n[r]}return b(n)}select(t){return(0,i.createMemo)(()=>t(this.state))}subscribe(t){return(0,i.createEffect)(()=>t(this.state))}watch(t,n){let r;return(0,i.createEffect)(()=>{let o=t(this.state);Object.is(o,r)||(n(o,r),r=o)})}reactive(t){return(0,i.createMemo)(()=>this.state[t])}produce(t){this.set((n=>{let r=O(n);return t(r),r}))}reconcile(t,n={}){this.set(t)}push(t,...n){let r=y(this.root,t);this.set(t,r.concat(n))}pop(t){let n=y(this.root,t).slice(),r=n.pop();return this.set(t,n),r}shift(t){let n=y(this.root,t).slice(),r=n.shift();return this.set(t,n),r}splice(t,n,r,...o){let s=y(this.root,t).slice(),a=s.splice(n,r,...o);return this.set(t,s),a}insert(t,n,r){let o=y(this.root,t).slice();o.splice(n,0,r),this.set(t,o)}removeAt(t,n){let r=y(this.root,t).slice(),o=r.splice(n,1);return this.set(t,r),o}toObservable(){let[t]=(0,i.createSignal)(this.state);return t.toObservable()}dispose(){}},L=["get","select","watch","subscribe","produce","reconcile","push","pop","shift","splice","insert","removeAt","unwrap","toObservable"];function V(e,t){for(let n of L)e[n]=t[n].bind(t);e.$=t.reactive.bind(t)}function x(e,t={immutable:!0}){let n=new d(e,t);return V(n.set,n),[n.proxy,n.set]}function Y(e,t={}){return new d(e,{...t,immutable:!1})}function b(e){if(e==null||typeof e!="object")return e;let t=e[h];return t!==void 0?t:e}function B(e){return(0,i.untrack)(()=>b(e))}var Z=Object.freeze({createStore:x,createMutableStore:Y,batch:i.batch,unwrap:b,untrackStore:B});function G(e,t){let[n,r]=x(e,t);return new Proxy(n,{get:(o,s)=>s==="set"?r:o[s],has:(o,s)=>s==="set"||Reflect.has(o,s)})}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/store/api.ts
+var api_exports = {};
+__export(api_exports, {
+  store: () => store
+});
+module.exports = __toCommonJS(api_exports);
+
+// src/lib/store/store.ts
+var import_signal = require("@fluixi/reactive/signal");
+
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.84";
+
+// src/lib/signal/graph/state.ts
+var MAJOR = VERSION.split(".")[0];
+var KEY = `__fluixi_signal_state_v${MAJOR}__`;
+var VERSIONS_KEY = `__fluixi_signal_builds_v${MAJOR}__`;
+var defaultSchedule = (run) => {
+  if (typeof queueMicrotask === "function") queueMicrotask(run);
+  else void Promise.resolve().then(run);
+};
+function defaults() {
+  return {
+    consumer: null,
+    untracked: false,
+    owner: null,
+    queue: [],
+    scheduled: false,
+    flushing: false,
+    batchDepth: 0,
+    hostSchedule: defaultSchedule,
+    onSuspend: null,
+    onError: null,
+    observer: null
+  };
+}
+var realm = globalThis;
+function backfillState(existing) {
+  const fresh = defaults();
+  const target = existing;
+  for (const field of Object.keys(fresh)) {
+    if (!(field in existing)) target[field] = fresh[field];
+  }
+  return existing;
+}
+function claim() {
+  const existing = realm[KEY];
+  return existing ? backfillState(existing) : realm[KEY] = defaults();
+}
+var G = claim();
+(realm[VERSIONS_KEY] ??= []).push(VERSION);
+
+// src/lib/signal/graph/observe.ts
+function observeReactiveNodes(next) {
+  G.observer = next;
+  return () => {
+    if (G.observer === next) G.observer = null;
+  };
+}
+var running = [];
+var origin;
+function withReactiveOrigin(owner, fn) {
+  if (!G.observer) return fn();
+  const previous = origin;
+  origin = owner;
+  try {
+    return fn();
+  } finally {
+    origin = previous;
+  }
+}
+function reportReactiveNode(report) {
+  const observer = G.observer;
+  if (observer) {
+    observer.created(
+      report.parents === void 0 ? { ...report, parents: running, origin: report.origin ?? origin } : report
+    );
+  }
+}
+function reportReactiveMove(node, origin2, name) {
+  G.observer?.moved?.(node, origin2, name);
+}
+function reportReactiveDispose(node) {
+  G.observer?.disposed?.(node);
+}
+var HOOK = "__FLUIXI_DEVTOOLS_HOOK__";
+var hook = globalThis[HOOK];
+if (typeof hook?.inject === "function") {
+  try {
+    hook.inject({ observeReactiveNodes, version: VERSION });
+  } catch {
+  }
+}
+function isObserved() {
+  return G.observer != null;
+}
+
+// src/lib/store/store.ts
+var $RAW = /* @__PURE__ */ Symbol("store-raw");
+var $NODE = /* @__PURE__ */ Symbol("store-node");
+var $HAS = /* @__PURE__ */ Symbol("store-has");
+var $SELF = /* @__PURE__ */ Symbol("store-self");
+var $TRACK = /* @__PURE__ */ Symbol("store-track");
+var NODES = /* @__PURE__ */ new WeakMap();
+var PROXIES = /* @__PURE__ */ new WeakMap();
+var OWNERS = /* @__PURE__ */ new WeakMap();
+var ROOTS = /* @__PURE__ */ new WeakMap();
+function forgetReplaced(dead, state) {
+  if (!isTrackable(dead) || !isObserved()) return;
+  const alive = /* @__PURE__ */ new Set();
+  const keep = (value) => {
+    if (!isTrackable(value) || alive.has(value)) return;
+    alive.add(value);
+    for (const child of Object.values(value)) keep(child);
+  };
+  keep(ROOTS.get(state) ?? state);
+  const seen = /* @__PURE__ */ new Set();
+  const drop = (value) => {
+    if (!isTrackable(value)) return;
+    const target = value;
+    if (alive.has(target) || seen.has(target)) return;
+    seen.add(target);
+    const ns = NODES.get(target);
+    if (ns) {
+      for (const node of ns.keys.values()) reportReactiveDispose(node);
+      if (ns.all) reportReactiveDispose(ns.all);
+      NODES.delete(target);
+      OWNERS.delete(target);
+      PROXIES.delete(target);
+    }
+    for (const child of Object.values(target)) drop(child);
+  };
+  drop(dead);
+}
+var pathOf = (base, key, array) => array ? `${base}[${String(key)}]` : `${base}.${String(key)}`;
+function createDataNode(initial, ns, key) {
+  const owner = ns?.owner;
+  const label = owner && key !== void 0 ? pathOf(owner.name, key, ns?.array) : void 0;
+  const [get, set] = withReactiveOrigin(
+    owner?.store,
+    () => (0, import_signal.createSignal)(initial, label ? { name: label } : void 0)
+  );
+  const node = get;
+  node.$ = set;
+  return node;
+}
+function nodesOf(target) {
+  let ns = NODES.get(target);
+  if (!ns) NODES.set(target, ns = { keys: /* @__PURE__ */ new Map(), owner: OWNERS.get(target), array: Array.isArray(target) });
+  else if (!ns.owner) ns.owner = OWNERS.get(target);
+  return ns;
+}
+function keyNode(ns, key, seed) {
+  let node = ns.keys.get(key);
+  if (!node) ns.keys.set(key, node = createDataNode(seed, ns, key));
+  return node;
+}
+function claim2(target, holder, name, parent) {
+  const was = OWNERS.get(target);
+  if (was && was.store === holder && was.name === name) return;
+  const owner = { store: holder, name };
+  OWNERS.set(target, owner);
+  ROOTS.set(target, ROOTS.get(parent) ?? parent);
+  const ns = NODES.get(target);
+  if (!ns) return;
+  ns.owner = owner;
+  if (!isObserved()) return;
+  for (const [key, node] of ns.keys) reportReactiveMove(node, holder, pathOf(name, key, ns.array));
+  if (ns.all) reportReactiveMove(ns.all, holder, pathOf(name, "*", ns.array));
+}
+function trackKeys(target) {
+  const ns = nodesOf(target);
+  (ns.all || (ns.all = createDataNode(void 0, ns, "*")))();
+}
+function pokeNode(node, value) {
+  node.$(typeof value === "function" ? () => value : value);
+}
+function isTrackable(value) {
+  if (value == null || typeof value !== "object") return false;
+  if (Array.isArray(value)) return true;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function box(value) {
+  if (!isTrackable(value)) return value;
+  const existing = PROXIES.get(value);
+  if (existing) return existing;
+  const proxy = new Proxy(value, handler);
+  PROXIES.set(value, proxy);
+  return proxy;
+}
+var handler = {
+  get(target, key, receiver) {
+    if (key === $RAW) return target;
+    if (key === $NODE) return target;
+    if (key === import_signal.$PROXY) return receiver;
+    if (key === $HAS) return (k) => k in target;
+    if (key === "__proxy") return true;
+    if (key === $TRACK || key === $SELF) {
+      trackKeys(target);
+      return receiver;
+    }
+    const value = target[key];
+    if (typeof value === "function" && !Object.prototype.hasOwnProperty.call(target, key)) {
+      return value;
+    }
+    const desc = Object.getOwnPropertyDescriptor(target, key);
+    if (desc && desc.get) return desc.get.call(receiver);
+    const ns = nodesOf(target);
+    const holder = keyNode(ns, key, value);
+    const current = holder();
+    if (!isTrackable(current)) return current;
+    if (ns.owner) claim2(current, holder, pathOf(ns.owner.name, key, ns.array), target);
+    return box(current);
+  },
+  set() {
+    return true;
+  },
+  deleteProperty(target, key) {
+    if (key in target) writeKey(target, key, void 0);
+    return true;
+  },
+  has(target, key) {
+    if (key === $RAW || key === import_signal.$PROXY || key === $NODE || key === $HAS || key === $SELF || key === $TRACK)
+      return true;
+    keyNode(nodesOf(target), key, target[key])();
+    return key in target;
+  },
+  ownKeys(target) {
+    trackKeys(target);
+    return Reflect.ownKeys(target);
+  },
+  getOwnPropertyDescriptor(target, key) {
+    return Reflect.getOwnPropertyDescriptor(target, key);
+  }
+};
+function rawValue(value, seen = /* @__PURE__ */ new Set()) {
+  if (value == null || typeof value !== "object") return value;
+  const raw = value[$RAW] ?? value;
+  if (seen.has(raw) || !isTrackable(raw)) return raw;
+  seen.add(raw);
+  let changed = false;
+  const swap = (v) => {
+    const next = rawValue(v, seen);
+    if (next !== v) changed = true;
+    return next;
+  };
+  if (Array.isArray(raw)) {
+    const out2 = raw.map(swap);
+    return changed ? out2 : raw;
+  }
+  const out = {};
+  for (const k of Object.keys(raw)) out[k] = swap(raw[k]);
+  return changed ? out : raw;
+}
+function writeKey(state, key, rawInput) {
+  const value = rawValue(rawInput);
+  const prev = state[key];
+  if (prev === value && (value !== void 0 || key in state)) return;
+  const isArray = Array.isArray(state);
+  const len = isArray ? state.length : 0;
+  if (value === void 0) delete state[key];
+  else state[key] = value;
+  const ns = nodesOf(state);
+  const node = ns.keys.get(key);
+  if (node) pokeNode(node, value);
+  forgetReplaced(prev, state);
+  if (isArray && state.length !== len) {
+    const lengthNode = ns.keys.get("length");
+    if (lengthNode) pokeNode(lengthNode, state.length);
+  }
+  if (ns.all) ns.all.$(void 0);
+}
+function nextValue(value, prev) {
+  return typeof value === "function" ? value(prev) : value;
+}
+function mergeInto(state, value) {
+  for (const key of Object.keys(value)) {
+    const next = value[key];
+    const prev = state[key];
+    if (next && typeof next === "object" && !Array.isArray(next) && prev && typeof prev === "object" && !Array.isArray(prev)) {
+      mergeInto(prev, next);
+    } else {
+      writeKey(state, key, next);
+    }
+  }
+}
+function parsePath(path) {
+  const out = [];
+  const normalized = path.replace(/\[([^\]]*)\]/g, ".$1");
+  for (const part of normalized.split(".")) if (part.length) out.push(part);
+  return out;
+}
+function applyAt(current, segs, value) {
+  const last = segs.length - 1;
+  for (let i = 0; i < last; i++) {
+    const seg = segs[i];
+    if (seg === "*") {
+      const rest = segs.slice(i + 1);
+      if (Array.isArray(current))
+        for (let idx = 0; idx < current.length; idx++)
+          applyAt(current[idx], rest, value);
+      return;
+    }
+    let next = current[seg];
+    if (next == null || typeof next !== "object") {
+      next = /^\d+$/.test(segs[i + 1]) ? [] : {};
+      writeKey(current, seg, next);
+    }
+    current = next;
+  }
+  const term = segs[last];
+  if (term === "*") {
+    if (Array.isArray(current))
+      for (let idx = 0; idx < current.length; idx++)
+        writeKey(current, idx, nextValue(value, current[idx]));
+    return;
+  }
+  writeKey(current, term, nextValue(value, current[term]));
+}
+function applyPath(root, path, value) {
+  applyAt(root, parsePath(path), value);
+}
+function isPathBatch(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((e) => Array.isArray(e) && e.length >= 2 && typeof e[0] === "string");
+}
+function replaceArray(target, next) {
+  for (let i = target.length - 1; i >= next.length; i--) writeKey(target, String(i), void 0);
+  if (target.length !== next.length) writeKey(target, "length", next.length);
+  for (let i = 0; i < next.length; i++) writeKey(target, String(i), next[i]);
+}
+function applySet(root, args) {
+  const first = args[0];
+  if (typeof first === "function" && args.length === 1) {
+    const next = first(root);
+    if (next && next !== root) mergeInto(root, next);
+    return;
+  }
+  if (Array.isArray(first) && args.length === 1) {
+    if (isPathBatch(first)) {
+      for (const entry of first) applyPath(root, entry[0], entry[1]);
+      return;
+    }
+    if (Array.isArray(root)) {
+      replaceArray(root, first);
+      return;
+    }
+    if (first.length === 0) return;
+    throw new TypeError(
+      "[fluixi] set() was given an array that is neither a batch of [path, value] pairs nor a replacement for an array root. Name the path you meant, as in set('items', [...])."
+    );
+  }
+  if (first && typeof first === "object" && !Array.isArray(first) && args.length === 1) {
+    mergeInto(root, first);
+    return;
+  }
+  if (Array.isArray(args[1]) && args.length >= 3) {
+    applyPath(root, `${first}.${args[1].join(".")}`, args[2]);
+    return;
+  }
+  applyPath(root, String(first), args[1]);
+}
+function clone(value) {
+  if (value == null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(clone);
+  const out = {};
+  for (const key of Object.keys(value)) out[key] = clone(value[key]);
+  return out;
+}
+function rawAt(root, path) {
+  let cur = root;
+  for (const seg of parsePath(path)) {
+    if (cur == null) return void 0;
+    cur = cur[seg];
+  }
+  return cur;
+}
+var Store = class {
+  constructor(initialState, options = { immutable: true }) {
+    this.options = options;
+    this.root = initialState;
+    this.set = ((...args) => (0, import_signal.batch)(() => applySet(this.root, args)));
+    if (initialState && typeof initialState === "object") {
+      OWNERS.set(initialState, { store: this, name: options.name ?? "store" });
+      ROOTS.set(initialState, initialState);
+    }
+    reportReactiveNode({
+      kind: "store",
+      node: this,
+      handle: () => this.root,
+      name: options.name
+    });
+  }
+  get state() {
+    return box(this.root);
+  }
+  get proxy() {
+    return box(this.root);
+  }
+  get accessor() {
+    return (() => box(this.root));
+  }
+  unwrap() {
+    return this.root;
+  }
+  getNode(key) {
+    return this.root && this.root[key];
+  }
+  // Tracked read at a path. Empty path returns the whole (unwrapped) state.
+  get(path) {
+    if (path == null || path === "") return unwrap(this.state);
+    let cur = this.state;
+    for (const seg of parsePath(path)) {
+      if (cur == null) return void 0;
+      cur = cur[seg];
+    }
+    return unwrap(cur);
+  }
+  select(selector) {
+    return (0, import_signal.createMemo)(() => selector(this.state));
+  }
+  subscribe(listener) {
+    return (0, import_signal.createEffect)(() => listener(this.state));
+  }
+  watch(selector, effect) {
+    let prev;
+    return (0, import_signal.createEffect)(() => {
+      const cur = selector(this.state);
+      if (!Object.is(cur, prev)) {
+        effect(cur, prev);
+        prev = cur;
+      }
+    });
+  }
+  // Reactive accessor for a top-level key.
+  reactive(key) {
+    return (0, import_signal.createMemo)(() => this.state[key]);
+  }
+  produce(producer) {
+    this.set(((prev) => {
+      const draft = clone(prev);
+      producer(draft);
+      return draft;
+    }));
+  }
+  reconcile(value, _options = {}) {
+    this.set(value);
+  }
+  push(path, ...items) {
+    const arr = rawAt(this.root, path);
+    this.set(path, arr.concat(items));
+  }
+  pop(path) {
+    const arr = rawAt(this.root, path).slice();
+    const item = arr.pop();
+    this.set(path, arr);
+    return item;
+  }
+  shift(path) {
+    const arr = rawAt(this.root, path).slice();
+    const item = arr.shift();
+    this.set(path, arr);
+    return item;
+  }
+  splice(path, start, deleteCount, ...items) {
+    const arr = rawAt(this.root, path).slice();
+    const removed = arr.splice(start, deleteCount, ...items);
+    this.set(path, arr);
+    return removed;
+  }
+  insert(path, index, value) {
+    const arr = rawAt(this.root, path).slice();
+    arr.splice(index, 0, value);
+    this.set(path, arr);
+  }
+  removeAt(path, index) {
+    const arr = rawAt(this.root, path).slice();
+    const removed = arr.splice(index, 1);
+    this.set(path, arr);
+    return removed;
+  }
+  /**
+   * Swap a whole value, rather than merging into it.
+   *
+   * `set(partial)` merges per key, which is what you want for an object and never what
+   * you want for an array. This replaces: `replace(value)` at the root, or
+   * `replace(path, value)` further down.
+   *
+   * @example
+   * ```ts
+   * const [items, set] = createStore([1, 2, 3]);
+   * set.replace([]);            // now empty
+   * set.replace(['a', 'b']);    // now two entries
+   * ```
+   */
+  replace(pathOrValue, maybeValue) {
+    if (arguments.length >= 2) {
+      const target = rawAt(this.root, String(pathOrValue));
+      const next = maybeValue;
+      if (Array.isArray(target) && Array.isArray(next)) {
+        replaceArray(target, next);
+        return;
+      }
+      this.set(pathOrValue, next);
+      return;
+    }
+    const root = this.root;
+    if (Array.isArray(root) && Array.isArray(pathOrValue)) {
+      replaceArray(root, pathOrValue);
+      return;
+    }
+    this.set(pathOrValue);
+  }
+  /**
+   * Empty an array, at the root or at a path.
+   *
+   * @example
+   * ```ts
+   * set.clear();          // the root array
+   * set.clear('todos');   // a nested one
+   * ```
+   */
+  clear(path) {
+    const target = path === void 0 ? this.root : rawAt(this.root, path);
+    if (Array.isArray(target)) {
+      replaceArray(target, []);
+      return;
+    }
+    if (target && typeof target === "object") {
+      for (const key of Object.keys(target)) writeKey(target, key, void 0);
+    }
+  }
+  toObservable() {
+    const [get] = (0, import_signal.createSignal)(this.state);
+    return get.toObservable();
+  }
+  dispose() {
+  }
+};
+var SETTER_METHODS = [
+  "get",
+  "select",
+  "watch",
+  "subscribe",
+  "produce",
+  "reconcile",
+  "push",
+  "pop",
+  "shift",
+  "splice",
+  "insert",
+  "removeAt",
+  "replace",
+  "clear",
+  "unwrap",
+  "toObservable"
+];
+function attachStoreMethods(target, store2) {
+  for (const name of SETTER_METHODS) target[name] = store2[name].bind(store2);
+  target.$ = store2.reactive.bind(store2);
+}
+function createStore(initialState, options = { immutable: true }) {
+  const store2 = new Store(initialState, options);
+  attachStoreMethods(store2.set, store2);
+  return [store2.proxy, store2.set];
+}
+function createMutableStore(initialState, options = {}) {
+  return new Store(initialState, { ...options, immutable: false });
+}
+function unwrap(item) {
+  if (item == null || typeof item !== "object") return item;
+  const raw = item[$RAW];
+  return raw !== void 0 ? raw : item;
+}
+function untrackStore(store2) {
+  return (0, import_signal.untrack)(() => unwrap(store2));
+}
+var StoreAPI = Object.freeze({
+  createStore,
+  createMutableStore,
+  batch: import_signal.batch,
+  unwrap,
+  untrackStore
+});
+
+// src/lib/store/api.ts
+function store(initialState, options) {
+  const [state, set] = createStore(initialState, options);
+  return new Proxy(state, {
+    get: (target, key) => key === "set" ? set : target[key],
+    has: (target, key) => key === "set" || Reflect.has(target, key)
+  });
+}

package/dist/lib/store/api.d.ts

@@ -3,5 +3,38 @@ import type { Immutable, Store, StoreOptions } from './store.js';
 export type StoreHandle<T> = Immutable<T> & {
     set: Store<T>['set'];
 };
+/**
+ * A reactive store you read by property access and write with `.set()`.
+ *
+ * Tracking is per key and lazy: a signal is created for a key the first time something
+ * reads it, so an effect reading one field is untouched by a write to another. Nested
+ * objects and arrays are proxied on access, to whatever depth is reached.
+ *
+ * `options.equals` compares whole states, not individual keys, and `options.name` is
+ * what a devtools panel labels the store with.
+ *
+ * @example An object argument patches the keys it names and leaves the rest:
+ * ```ts
+ * const user = store({ name: 'Ada', role: 'admin' });
+ *
+ * effect(() => console.log(user.name));   // subscribes to `name` only
+ * user.set({ role: 'owner' });           // the effect does not re-run
+ * user.set({ name: 'Grace' });           // now it does
+ * ```
+ *
+ * @example A dot path writes deep without rebuilding the tree above it. Array indices
+ * are segments like any other:
+ * ```ts
+ * const state = store({ todos: [{ done: false }] });
+ * state.set('todos.0.done', true);
+ * state.set('todos.0.done', (done) => !done);   // or derive from the current value
+ * ```
+ *
+ * @example A `set` key of your own is unreachable through this form, because the setter
+ * occupies the name. `createStore` hands back a tuple and has no such collision:
+ * ```ts
+ * const [config, setConfig] = createStore({ set: 'a value' });
+ * ```
+ */
 export declare function store<T>(initialState: T, options?: StoreOptions<T>): StoreHandle<T>;
 //# sourceMappingURL=api.d.ts.map

package/dist/lib/store/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../src/lib/store/api.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEjE,0DAA0D;AAC1D,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG;IAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;CAAE,CAAC;AAErE,wBAAgB,KAAK,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAUnF"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../src/lib/store/api.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEjE,0DAA0D;AAC1D,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG;IAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;CAAE,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAUnF"}