@chocbite/ts-lib-state 1.0.0

package/dist/index.js

@@ -0,0 +1,3698 @@
+// src/array/sync.ts
+import {
+  err as err2,
+  none as none2,
+  ok as ok2
+} from "@chocbite/ts-lib-result";
+
+// src/types.ts
+var STATE_KEY = /* @__PURE__ */ Symbol("is_state");
+
+// src/base.ts
+var StateBase = class {
+  get [STATE_KEY]() {
+    return true;
+  }
+  #subscribers = /* @__PURE__ */ new Set();
+  #read_promises;
+  sub(func, update) {
+    if (this.#subscribers.has(func)) {
+      console.error("Function already registered as subscriber", this, func);
+      return func;
+    }
+    if (this.#subscribers.size === 0) this.on_subscribe();
+    this.#subscribers.add(func);
+    if (update) this.then(func);
+    return func;
+  }
+  unsub(func) {
+    if (this.#subscribers.delete(func)) {
+      if (this.#subscribers.size == 0) this.on_unsubscribe();
+    } else console.error("Subscriber not found with state", this, func);
+    return func;
+  }
+  in_use() {
+    return this.#subscribers.size > 0 ? this : void 0;
+  }
+  has(subscriber) {
+    return this.#subscribers.has(subscriber) ? this : void 0;
+  }
+  amount() {
+    return this.#subscribers.size;
+  }
+  /**Called when subscriber is added*/
+  on_subscribe() {
+  }
+  /**Called when subscriber is removed*/
+  on_unsubscribe() {
+  }
+  /**Updates all subscribers with a value */
+  update_subs(value) {
+    for (const subscriber of this.#subscribers) {
+      try {
+        subscriber(value);
+      } catch (e) {
+        console.error("Failed while calling subscribers ", e, this, subscriber);
+      }
+    }
+  }
+  //Promises
+  /**Creates a promise which can be fulfilled later with fulRProm */
+  async append_r_prom(func) {
+    return func(
+      await new Promise((a) => {
+        (this.#read_promises ??= []).push(
+          a
+        );
+      })
+    );
+  }
+  /**Fulfills all read promises with given value */
+  ful_r_prom(value) {
+    if (this.#read_promises)
+      for (let i = 0; i < this.#read_promises.length; i++)
+        this.#read_promises[i](value);
+    this.#read_promises = [];
+    return value;
+  }
+};
+
+// src/sync/sync.ts
+import {
+  err,
+  none,
+  ok
+} from "@chocbite/ts-lib-result";
+var RXS = class extends StateBase {
+  constructor(init, helper, setter) {
+    super();
+    if (setter === true)
+      this.#setter = (value, state2, old) => {
+        if (old && !old.err && value === old.value)
+          return ok(void 0);
+        return this.#helper?.limit ? this.#helper?.limit(value).map((e) => state2.set_ok(e)) : ok(state2.set_ok(value));
+      };
+    else this.#setter = setter;
+    if (helper) this.#helper = helper;
+    this.#value = init;
+  }
+  #value;
+  #setter;
+  #helper;
+  //#Owner Context
+  set(value) {
+    this.update_subs(this.#value = value);
+  }
+  set_ok(value) {
+    this.set(ok(value));
+  }
+  set_err(error) {
+    this.set(err(error));
+  }
+  set setter(setter) {
+    this.#setter = setter;
+  }
+  get setter() {
+    return this.#setter;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  get read_write() {
+    return this.#setter ? this : void 0;
+  }
+  //#Reader Context
+  get rok() {
+    return this.#value.ok;
+  }
+  get rsync() {
+    return true;
+  }
+  async then(func) {
+    return func(this.#value);
+  }
+  get() {
+    return this.#value;
+  }
+  ok() {
+    return this.#value.value;
+  }
+  related() {
+    return this.#helper?.related ? this.#helper.related() : none();
+  }
+  //#Writer Context
+  get writable() {
+    return this.#setter !== void 0;
+  }
+  get wsync() {
+    return this.writable;
+  }
+  async write(value) {
+    return this.write_sync(value);
+  }
+  write_sync(value) {
+    if (this.#setter)
+      return this.#setter(
+        value,
+        this,
+        this.#value
+      );
+    return err("State not writable");
+  }
+  limit(value) {
+    return this.#helper?.limit ? this.#helper.limit(value) : ok(value);
+  }
+  check(value) {
+    return this.#helper?.check ? this.#helper.check(value) : ok(value);
+  }
+};
+var ros = {
+  /**Creates a sync ok state from an initial value.
+   * @param init initial value for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  ok(init, helper) {
+    return new RXS(ok(init), helper);
+  },
+  /**Creates a sync ok state from an initial result.
+   * @param init initial result for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  result(init, helper) {
+    return new RXS(init, helper);
+  }
+};
+var ros_ws = {
+  /**Creates a sync ok state from an initial value.
+   * @param init initial value for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  ok(init, setter = true, helper) {
+    return new RXS(
+      ok(init),
+      helper,
+      setter
+    );
+  },
+  /**Creates a sync ok state from an initial result.
+   * @param init initial result for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  result(init, setter = true, helper) {
+    return new RXS(
+      init,
+      helper,
+      setter
+    );
+  }
+};
+var res = {
+  /**Creates a sync state from an initial value.
+   * @param init initial value for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  ok(init, helper) {
+    return new RXS(
+      ok(init),
+      helper
+    );
+  },
+  /**Creates a sync state from an initial error.
+   * @param init initial error for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  err(init, helper) {
+    return new RXS(
+      err(init),
+      helper
+    );
+  },
+  /**Creates a sync state from an initial result.
+   * @param init initial result for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  result(init, helper) {
+    return new RXS(
+      init,
+      helper
+    );
+  }
+};
+var res_ws = {
+  /**Creates a writable sync state from an initial value.
+   * @param init initial value for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  ok(init, setter = true, helper) {
+    return new RXS(
+      ok(init),
+      helper,
+      setter
+    );
+  },
+  /**Creates a writable sync state from an initial error.
+   * @param init initial error for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  err(init, setter = true, helper) {
+    return new RXS(
+      err(init),
+      helper,
+      setter
+    );
+  },
+  /**Creates a writable sync state from an initial result.
+   * @param init initial result for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  result(init, setter = true, helper) {
+    return new RXS(
+      init,
+      helper,
+      setter
+    );
+  }
+};
+var STATE_SYNC = {
+  /**Sync read only states with guarenteed ok*/
+  ros,
+  /**Sync read and sync write with guarenteed ok*/
+  ros_ws,
+  /**Sync read only states with error */
+  res,
+  /**Sync read and sync write with error */
+  res_ws
+};
+
+// src/array/sync.ts
+var STATE_ARRAY_KEY = /* @__PURE__ */ Symbol("is_state_array");
+function apply_read(array, read, transform) {
+  const a = array;
+  const t = transform;
+  const { type: ty, index: ix, items: it } = read;
+  if (ty === "fresh") a.splice(ix, a.length, ...t ? it.map(t) : it);
+  else if (ty === "added") a.splice(ix, 0, ...t ? it.map(t) : it);
+  else if (ty === "removed") a.splice(ix, it.length);
+  else if (ty === "changed")
+    for (let i = 0; i < it.length; i++) a[ix + i] = t ? t(it[i], i, it) : it[i];
+  return a;
+}
+var RXS2 = class extends StateBase {
+  get [STATE_ARRAY_KEY]() {
+    return true;
+  }
+  constructor(init, helper, setter) {
+    super();
+    if (setter === true) this.#setter = (val) => ok2(this.apply_write(ok2(val)));
+    else this.#setter = setter;
+    if (helper) this.#helper = helper;
+    this.set(init);
+  }
+  #error;
+  #array = [];
+  #helper;
+  #setter;
+  #length;
+  #mr(type, index, items) {
+    return { array: this.#array, type, index, items };
+  }
+  set(value) {
+    this.#array = value.ok ? [...value.value] : [];
+    this.#error = value.ok ? void 0 : value.error;
+    this.update_subs(ok2(this.#mr("fresh", 0, this.#array)));
+  }
+  set_ok(value) {
+    this.set(ok2(value));
+  }
+  set_err(error) {
+    this.set(err2(error));
+  }
+  set setter(setter) {
+    this.#setter = setter;
+  }
+  get setter() {
+    return this.#setter;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  get read_write() {
+    return this.#setter ? this : void 0;
+  }
+  //#Reader Context
+  get rok() {
+    return true;
+  }
+  get rsync() {
+    return true;
+  }
+  async then(func) {
+    return func(this.get());
+  }
+  get() {
+    if (this.#error) return err2(this.#error);
+    return ok2(this.#mr("fresh", 0, this.#array));
+  }
+  ok() {
+    return this.#mr("fresh", 0, this.#array);
+  }
+  related() {
+    return this.#helper?.related ? this.#helper.related() : none2();
+  }
+  //#Writer Context
+  get writable() {
+    return this.#setter !== void 0;
+  }
+  get wsync() {
+    return this.writable;
+  }
+  async write(value) {
+    return this.write_sync(value);
+  }
+  write_sync(value) {
+    if (this.#setter)
+      return this.#setter(value, this, this.get());
+    return err2("State not writable");
+  }
+  limit(value) {
+    return this.#helper?.limit ? this.#helper.limit(value) : ok2(value);
+  }
+  check(value) {
+    return this.#helper?.check ? this.#helper.check(value) : ok2(value);
+  }
+  //Array/Owner Context
+  get array() {
+    return this.#array;
+  }
+  get length() {
+    return this.#array.length;
+  }
+  get length_state() {
+    return this.#length ??= STATE_SYNC.ros.ok(this.length);
+  }
+  at(index) {
+    return this.#array.at(index);
+  }
+  set_index(index, value) {
+    const l = this.#array.length;
+    this.#array[index] = value;
+    this.update_subs(ok2(this.#mr("changed", index, [value])));
+    if (this.#array.length !== l && this.#length)
+      this.#length.set_ok(this.#array.length);
+  }
+  push(...items) {
+    const index = this.#array.length;
+    const new_len = this.#array.push(...items);
+    this.update_subs(ok2(this.#mr("added", index, items)));
+    if (this.#length) this.#length.set_ok(new_len);
+    return new_len;
+  }
+  pop() {
+    const l = this.#array.length;
+    const p = this.#array.pop();
+    if (this.#array.length < l) {
+      this.update_subs(
+        ok2(this.#mr("removed", this.#array.length, [p]))
+      );
+      if (this.#length) this.#length.set_ok(this.#array.length);
+    }
+    return p;
+  }
+  shift() {
+    const l = this.#array.length;
+    const s = this.#array.shift();
+    if (this.#array.length < l) {
+      this.update_subs(ok2(this.#mr("removed", 0, [s])));
+      if (this.#length) this.#length.set_ok(this.#array.length);
+    }
+    return s;
+  }
+  unshift(...items) {
+    const new_len = this.#array.unshift(...items);
+    this.update_subs(ok2(this.#mr("added", 0, items)));
+    if (this.#length) this.#length.set_ok(new_len);
+    return new_len;
+  }
+  splice(start, delete_count, ...items) {
+    const r = this.#array.splice(start, delete_count, ...items);
+    if (r.length > 0)
+      this.update_subs(ok2(this.#mr("removed", start, r)));
+    if (items.length > 0)
+      this.update_subs(ok2(this.#mr("added", start, items)));
+    if (this.#length) this.#length.set_ok(this.#array.length);
+    return r;
+  }
+  delete(val) {
+    for (let i = 0; i < this.#array.length; i++)
+      if (this.#array[i] = val) {
+        this.update_subs(ok2(this.#mr("removed", i, [val])));
+        i--;
+      }
+    if (this.#length) this.#length.set_ok(this.#array.length);
+  }
+  ///Helps apply the changes from one state array to another
+  apply_read(result, transform) {
+    const { index, items: its, type } = result.value;
+    const items = transform(its, type);
+    if (type === "fresh") return this.set(ok2(items));
+    else if (type === "added") this.#array.splice(index, 0, ...items);
+    else if (type === "removed") this.#array.splice(index, items.length);
+    else if (type === "changed")
+      for (let i = 0; i < its.length; i++) this.#array[index + i] = items[i];
+    this.update_subs(ok2(this.#mr(type, index, items)));
+  }
+  apply_write(result) {
+    if (!result.ok) return;
+    const type = result.value.type;
+    if (type === "write") this.set_ok(result.value.items);
+    else if (type === "pop") this.pop();
+    else if (type === "shift") this.shift();
+    else if (type === "push") this.push(...result.value.items);
+    else if (type === "unshift") this.unshift(...result.value.items);
+    else if (type === "delete") this.delete(result.value.item);
+    else if (type === "splice")
+      this.splice(
+        result.value.index,
+        result.value.delete_count,
+        ...result.value.items ? result.value.items : []
+      );
+    else if (type === "change")
+      this.set_index(result.value.index, result.value.item);
+  }
+  apply_write_transform(result, transform) {
+    if (!result.ok) return;
+    const type = result.value.type;
+    if (type === "write")
+      this.set_ok(result.value.items.map((item) => transform(item)));
+    else if (type === "pop") this.pop();
+    else if (type === "shift") this.shift();
+    else if (type === "push")
+      this.push(...result.value.items.map((item) => transform(item)));
+    else if (type === "unshift")
+      this.unshift(...result.value.items.map((item) => transform(item)));
+    else if (type === "delete") this.delete(transform(result.value.item));
+    else if (type === "splice")
+      this.splice(
+        result.value.index,
+        result.value.delete_count,
+        ...result.value.items ? result.value.items.map((item) => transform(item)) : []
+      );
+    else if (type === "change")
+      this.set_index(result.value.index, transform(result.value.item));
+  }
+};
+var ROS = {
+  /**Creates a state representing an array
+   * @param init initial array, leave empty for empty array
+   * @param helper functions to make related*/
+  ok(init = [], helper) {
+    return new RXS2(
+      ok2(init),
+      helper
+    );
+  }
+};
+var ROS_WS = {
+  /**Creates a state representing an array
+   * @param init initial array, leave empty for empty array
+   * @param setter function called when state value is set via setter, set true let write set it's value
+   * @param helper functions to check and limit*/
+  ok(init = [], setter, helper) {
+    return new RXS2(
+      ok2(init),
+      helper,
+      setter
+    );
+  }
+};
+var RES = {
+  /**Creates a state representing an array
+   * @param init initial array, leave empty for empty array
+   * @param helper functions to make related*/
+  ok(init = [], helper) {
+    return new RXS2(
+      ok2(init),
+      helper
+    );
+  },
+  /**Creates a state representing an array
+   * @param init initial error
+   * @param helper functions to make related*/
+  err(error, helper) {
+    return new RXS2(
+      err2(error),
+      helper
+    );
+  }
+};
+var RES_WS = {
+  /**Creates a state representing an array
+   * @param init initial array, leave empty for empty array
+   * @param setter function called when state value is set via setter, set true let write set it's value
+   * @param helper functions to check and limit*/
+  ok(init = [], setter, helper) {
+    return new RXS2(
+      ok2(init),
+      helper,
+      setter
+    );
+  },
+  /**Creates a state representing an array
+   * @param err initial error
+   * @param setter function called when state value is set via setter, set true let write set it's value
+   * @param helper functions to check and limit*/
+  err(error, setter, helper) {
+    return new RXS2(
+      err2(error),
+      helper,
+      setter
+    );
+  }
+};
+var STATE_ARRAY = {
+  /**The state key is a symbol used to identify state array objects
+   * To implement a custom state, set this key to true on the object */
+  STATE_ARRAY_KEY,
+  /** Applies a read from a state array to another array
+   * @template AT - Types allowed in both arrays.
+   * @template TAT - Optional type if state array type is different from array
+   * @param array Array to modify in place
+   * @param read Read struct from state array
+   * @param transform optional tranform function for when state array is not same type of array*/
+  apply_read,
+  ros: ROS,
+  ros_ws: ROS_WS,
+  res: RES,
+  res_ws: RES_WS,
+  /**Returns true if the given object promises to be a state array */
+  is(s) {
+    return Boolean(s) && s[STATE_ARRAY_KEY] === true;
+  },
+  //# Array Write Helpers
+  write(items) {
+    return { type: "write", items };
+  },
+  index(index, value) {
+    return { type: "change", index, item: value };
+  },
+  push(...items) {
+    return { type: "push", items };
+  },
+  pop() {
+    return { type: "pop" };
+  },
+  shift() {
+    return { type: "shift" };
+  },
+  unshift(...items) {
+    return { type: "unshift", items };
+  },
+  splice(start, delete_count, ...items) {
+    return {
+      type: "splice",
+      index: start,
+      delete_count: delete_count ?? 0,
+      items
+    };
+  },
+  pluck(index) {
+    return { type: "splice", index, delete_count: 1 };
+  },
+  insert(index, ...items) {
+    return { type: "splice", index, delete_count: 0, items };
+  }
+};
+
+// src/collected/number.ts
+import { ok as ok3 } from "@chocbite/ts-lib-result";
+
+// src/collected/rea.ts
+import { err as err3, none as none3 } from "@chocbite/ts-lib-result";
+var REA = class extends StateBase {
+  constructor(transform, ...states) {
+    super();
+    if (transform) this.getter = transform;
+    this.#states = states;
+  }
+  #buffer;
+  #states;
+  #state_buffers = [];
+  #state_subscribers = [];
+  getter(values) {
+    return values[0];
+  }
+  /**Called when subscriber is added*/
+  on_subscribe() {
+    if (!this.#states.length) {
+      this.#buffer = err3("No states registered");
+      return;
+    }
+    this.#state_buffers.length = this.#states.length;
+    {
+      let count = 0;
+      const amount = this.#states.length - 1;
+      Promise.all(this.#states).then((vals) => {
+        for (let i = 0; i < this.#state_buffers.length; i++)
+          this.#state_buffers[i] = this.#state_buffers[i] ?? vals[i];
+        this.#buffer = this.getter(
+          this.#state_buffers
+        );
+        this.ful_r_prom(this.#buffer);
+        count = amount;
+      });
+      let calc = false;
+      for (let i = 0; i < this.#states.length; i++) {
+        this.#state_subscribers[i] = this.#states[i].sub((value) => {
+          if (count < amount) {
+            if (!this.#state_buffers[i]) count++;
+            this.#state_buffers[i] = value;
+            return;
+          }
+          this.#state_buffers[i] = value;
+          if (!calc) {
+            calc = true;
+            Promise.resolve().then(() => {
+              this.#buffer = this.getter(
+                this.#state_buffers
+              );
+              this.update_subs(this.#buffer);
+              calc = false;
+            });
+          }
+        });
+      }
+    }
+  }
+  /**Called when subscriber is removed*/
+  on_unsubscribe() {
+    for (let i = 0; i < this.#states.length; i++)
+      this.#states[i].unsub(this.#state_subscribers[i]);
+    this.#state_subscribers = [];
+    this.#state_buffers = [];
+    this.#buffer = void 0;
+  }
+  //#Owner Context
+  set_states(...states) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#states = [...states];
+      this.on_subscribe();
+    } else this.#states = [...states];
+  }
+  set_getter(getter) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.getter = getter;
+      this.on_subscribe();
+    } else this.getter = getter;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return false;
+  }
+  get rsync() {
+    return false;
+  }
+  async then(func) {
+    if (this.#buffer) return func(this.#buffer);
+    if (!this.#state_buffers.length)
+      return func(
+        this.getter(
+          await Promise.all(this.#states)
+        )
+      );
+    return this.append_r_prom(func);
+  }
+  related() {
+    return none3();
+  }
+  //#Writer Context
+  get writable() {
+    return false;
+  }
+  get wsync() {
+    return false;
+  }
+};
+var STATE_COLLECTED_REA = {
+  /**Creates a state that collects multiple states values and reduces it to one.
+   * @param transform - Function to translate value of collected states, false means first states values is used.
+   * @param states - The states to collect.*/
+  from(transform, ...states) {
+    return new REA(transform, ...states);
+  },
+  class: REA
+};
+
+// src/collected/res.ts
+import { err as err4, none as none4 } from "@chocbite/ts-lib-result";
+var RES2 = class extends StateBase {
+  /**Creates a state which is derived from other states. The derived state will update when any of the other states update.
+   * @param transform - Function to translate value of state or states to something else, false means first states values is used.
+   * @param states - The other states to be used in the derived state.*/
+  constructor(transform, ...states) {
+    super();
+    if (transform) this.getter = transform;
+    this.#states = states;
+  }
+  #buffer;
+  #states;
+  #state_buffers = [];
+  #state_subscribers = [];
+  getter(values) {
+    return values[0];
+  }
+  /**Called when subscriber is added*/
+  on_subscribe() {
+    if (!this.#states.length) {
+      this.#buffer = err4("No states registered");
+      return;
+    }
+    let calc = false;
+    for (let i = 0; i < this.#states.length; i++) {
+      this.#state_buffers[i] = this.#states[i].get();
+      this.#state_subscribers[i] = this.#states[i].sub((value) => {
+        this.#state_buffers[i] = value;
+        if (!calc) {
+          calc = true;
+          Promise.resolve().then(() => {
+            this.#buffer = this.getter(
+              this.#state_buffers
+            );
+            this.update_subs(this.#buffer);
+            calc = false;
+          });
+        }
+      });
+    }
+    this.#buffer = this.getter(
+      this.#state_buffers
+    );
+    this.update_subs(this.#buffer);
+  }
+  /**Called when subscriber is removed*/
+  on_unsubscribe() {
+    for (let i = 0; i < this.#states.length; i++)
+      this.#states[i].unsub(this.#state_subscribers[i]);
+    this.#state_subscribers = [];
+    this.#state_buffers = [];
+    this.#buffer = void 0;
+  }
+  //#Owner
+  set_states(...states) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#states = [...states];
+      this.on_subscribe();
+    } else this.#states = [...states];
+  }
+  set_getter(getter) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.getter = getter;
+      this.on_subscribe();
+    } else this.getter = getter;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return false;
+  }
+  get rsync() {
+    return true;
+  }
+  async then(func) {
+    return func(this.get());
+  }
+  get() {
+    if (this.#buffer) return this.#buffer;
+    return this.#states.length ? this.getter(
+      this.#states.map((s) => s.get())
+    ) : err4("No states registered");
+  }
+  related() {
+    return none4();
+  }
+  //#Writer Context
+  get writable() {
+    return false;
+  }
+  get wsync() {
+    return false;
+  }
+};
+var STATE_COLLECTED_RES = {
+  /**Creates a state that collects multiple states values and reduces it to one.
+   * @param transform - Function to translate value of collected states, false means first states values is used.
+   * @param states - The states to collect.*/
+  from(transform, ...states) {
+    return new RES2(transform, ...states);
+  },
+  class: RES2
+};
+
+// src/collected/roa.ts
+import { none as none5 } from "@chocbite/ts-lib-result";
+var ROA = class extends StateBase {
+  /**Creates a state which is derived from other states. The derived state will update when any of the other states update.
+   * @param transform - Function to translate value of state or states to something else, false means first states values is used.
+   * @param states - The other states to be used in the derived state.*/
+  constructor(transform, ...states) {
+    super();
+    if (transform) this.getter = transform;
+    this.#states = states;
+  }
+  #buffer;
+  #states;
+  #state_buffers = [];
+  #state_subscribers = [];
+  getter(values) {
+    return values[0];
+  }
+  /**Called when subscriber is added*/
+  on_subscribe() {
+    this.#state_buffers.length = this.#states.length;
+    {
+      let count = 0;
+      const amount = this.#states.length - 1;
+      Promise.all(this.#states).then((vals) => {
+        for (let i = 0; i < this.#state_buffers.length; i++)
+          this.#state_buffers[i] = this.#state_buffers[i] ?? vals[i];
+        this.#buffer = this.getter(
+          this.#state_buffers
+        );
+        this.ful_r_prom(this.#buffer);
+        count = amount;
+      });
+      let calc = false;
+      for (let i = 0; i < this.#states.length; i++) {
+        this.#state_subscribers[i] = this.#states[i].sub((value) => {
+          if (count < amount) {
+            if (!this.#state_buffers[i]) count++;
+            this.#state_buffers[i] = value;
+            return;
+          }
+          this.#state_buffers[i] = value;
+          if (!calc) {
+            calc = true;
+            Promise.resolve().then(() => {
+              this.#buffer = this.getter(
+                this.#state_buffers
+              );
+              this.update_subs(this.#buffer);
+              calc = false;
+            });
+          }
+        });
+      }
+    }
+  }
+  /**Called when subscriber is removed*/
+  on_unsubscribe() {
+    for (let i = 0; i < this.#states.length; i++)
+      this.#states[i].unsub(this.#state_subscribers[i]);
+    this.#state_subscribers = [];
+    this.#state_buffers = [];
+    this.#buffer = void 0;
+  }
+  //#Owner
+  set_states(...states) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#states = [...states];
+      this.on_subscribe();
+    } else this.#states = [...states];
+  }
+  set_getter(getter) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.getter = getter;
+      this.on_subscribe();
+    } else this.getter = getter;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return true;
+  }
+  get rsync() {
+    return false;
+  }
+  async then(func) {
+    if (this.#buffer) return func(this.#buffer);
+    if (!this.#state_buffers.length)
+      return func(
+        this.getter(
+          await Promise.all(this.#states)
+        )
+      );
+    return this.append_r_prom(func);
+  }
+  related() {
+    return none5();
+  }
+  //#Writer Context
+  get writable() {
+    return false;
+  }
+  get wsync() {
+    return false;
+  }
+};
+var STATE_COLLECTED_ROA = {
+  /**Creates a guarenteed ok state that collects multiple states values and reduces it to one.
+   * @param transform - Function to translate value of collected states, false means first states values is used.
+   * @param states - The states to collect.*/
+  from(transform, ...states) {
+    return new ROA(transform, ...states);
+  },
+  class: ROA
+};
+
+// src/collected/ros.ts
+import { none as none6 } from "@chocbite/ts-lib-result";
+var ROS2 = class extends StateBase {
+  constructor(transform, ...states) {
+    super();
+    if (transform) this.getter = transform;
+    this.#states = states;
+  }
+  #buffer;
+  #states;
+  #state_buffers = [];
+  #state_subscribers = [];
+  getter(values) {
+    return values[0];
+  }
+  /**Called when subscriber is added*/
+  on_subscribe() {
+    let calc = false;
+    for (let i = 0; i < this.#states.length; i++) {
+      this.#state_buffers[i] = this.#states[i].get();
+      this.#state_subscribers[i] = this.#states[i].sub((value) => {
+        this.#state_buffers[i] = value;
+        if (!calc) {
+          calc = true;
+          Promise.resolve().then(() => {
+            this.#buffer = this.getter(
+              this.#state_buffers
+            );
+            this.update_subs(this.#buffer);
+            calc = false;
+          });
+        }
+      });
+    }
+    this.#buffer = this.getter(
+      this.#state_buffers
+    );
+    this.update_subs(this.#buffer);
+  }
+  /**Called when subscriber is removed*/
+  on_unsubscribe() {
+    for (let i = 0; i < this.#states.length; i++)
+      this.#states[i].unsub(this.#state_subscribers[i]);
+    this.#state_subscribers = [];
+    this.#state_buffers = [];
+    this.#buffer = void 0;
+  }
+  //#Owner
+  set_states(...states) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#states = [...states];
+      this.on_subscribe();
+    } else this.#states = [...states];
+  }
+  set_getter(getter) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.getter = getter;
+      this.on_subscribe();
+    } else this.getter = getter;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return true;
+  }
+  get rsync() {
+    return true;
+  }
+  async then(func) {
+    return func(this.get());
+  }
+  get() {
+    if (this.#buffer) return this.#buffer;
+    return this.getter(
+      this.#states.map((s) => s.get())
+    );
+  }
+  ok() {
+    return this.get().value;
+  }
+  related() {
+    return none6();
+  }
+  //#Writer Context
+  get writable() {
+    return false;
+  }
+  get wsync() {
+    return false;
+  }
+};
+var STATE_COLLECTED_ROS = {
+  /**Creates a guarenteed ok state that collects multiple states values and reduces it to one.
+   * @param transform - Function to translate value of collected states, false means first states values is used.
+   * @param states - The states to collect.*/
+  from(transform, ...states) {
+    return new ROS2(transform, ...states);
+  },
+  class: ROS2
+};
+
+// src/collected/number.ts
+var NumberSumREA = class extends STATE_COLLECTED_REA.class {
+  constructor(...states) {
+    super(false, ...states);
+  }
+  getter(values) {
+    let sum = 0;
+    for (const val of values) {
+      if (val.err) return val;
+      sum += val.value;
+    }
+    return ok3(sum);
+  }
+};
+var NumberSumROA = class extends STATE_COLLECTED_ROA.class {
+  constructor(...states) {
+    super(false, ...states);
+  }
+  getter(values) {
+    return ok3(values.reduce((acc, val) => acc + val.value, 0));
+  }
+};
+var NumberSumRES = class extends STATE_COLLECTED_RES.class {
+  constructor(...states) {
+    super(false, ...states);
+  }
+  getter(values) {
+    let sum = 0;
+    for (const val of values) {
+      if (val.err) return val;
+      sum += val.value;
+    }
+    return ok3(sum);
+  }
+};
+var NumberSumROS = class extends STATE_COLLECTED_ROS.class {
+  constructor(...states) {
+    super(false, ...states);
+  }
+  getter(values) {
+    return ok3(values.reduce((acc, val) => acc + val.value, 0));
+  }
+};
+var NumberPercentageREA = class extends STATE_COLLECTED_REA.class {
+  constructor(st1, st2) {
+    super(false, st1, st2);
+  }
+  getter(values) {
+    if (values[0].err) return values[0];
+    if (values[1].err) return values[1];
+    return ok3(
+      values[1].value / (values[0].value === 0 ? 1 : values[0].value) * 100
+    );
+  }
+};
+var NumberPercentageROA = class extends STATE_COLLECTED_ROA.class {
+  constructor(st1, st2) {
+    super(false, st1, st2);
+  }
+  getter(values) {
+    return ok3(
+      values[1].value / (values[0].value === 0 ? 1 : values[0].value) * 100
+    );
+  }
+};
+var NumberPercentageRES = class extends STATE_COLLECTED_RES.class {
+  constructor(st1, st2) {
+    super(false, st1, st2);
+  }
+  getter(values) {
+    if (values[0].err) return values[0];
+    if (values[1].err) return values[1];
+    return ok3(
+      values[1].value / (values[0].value === 0 ? 1 : values[0].value) * 100
+    );
+  }
+};
+var NumberPercentageROS = class extends STATE_COLLECTED_ROS.class {
+  constructor(st1, st2) {
+    super(false, st1, st2);
+  }
+  getter(values) {
+    return ok3(
+      values[1].value / (values[0].value === 0 ? 1 : values[0].value) * 100
+    );
+  }
+};
+var STATE_COLLECTS_NUMBER = {
+  //Calculates the sum of all the states
+  sum: {
+    rea(...states) {
+      return new NumberSumREA(...states);
+    },
+    roa(...states) {
+      return new NumberSumROA(...states);
+    },
+    res(...states) {
+      return new NumberSumRES(...states);
+    },
+    ros(...states) {
+      return new NumberSumROS(...states);
+    }
+  },
+  //Calculates how many percent the second state is of the first state
+  percentage: {
+    rea(st1, st2) {
+      return new NumberPercentageREA(st1, st2);
+    },
+    roa(st1, st2) {
+      return new NumberPercentageROA(st1, st2);
+    },
+    res(st1, st2) {
+      return new NumberPercentageRES(st1, st2);
+    },
+    ros(st1, st2) {
+      return new NumberPercentageROS(st1, st2);
+    }
+  }
+};
+
+// src/delayed/delayed.ts
+import {
+  err as err5,
+  none as none7,
+  ok as ok4
+} from "@chocbite/ts-lib-result";
+var RXA = class extends StateBase {
+  constructor(init, helper, setter_sync, setter_async) {
+    super();
+    if (setter_sync === true)
+      this.#setter_sync = (value, state2, old) => {
+        if (old && !old.err && value === old.value)
+          return ok4(void 0);
+        return this.#helper?.limit ? this.#helper?.limit(value).map((e) => state2.set_ok(e)) : ok4(state2.set_ok(value));
+      };
+    else this.#setter_sync = setter_sync;
+    if (setter_async === true)
+      this.#setter_async = async (value, state2, old) => {
+        if (old && !old.err && value === old.value)
+          return ok4(void 0);
+        return this.#helper?.limit ? this.#helper?.limit(value).map((e) => state2.set_ok(e)) : ok4(state2.set_ok(value));
+      };
+    else this.#setter_async = setter_async;
+    if (helper) this.#helper = helper;
+    let initializing = false;
+    this.then = async (func) => {
+      if (init) {
+        if (!initializing) {
+          initializing = true;
+          (async () => {
+            try {
+              this.#value = await init();
+              this.ful_r_prom(this.#value);
+            } catch (e) {
+              console.error("Failed to initialize delayed RO state: ", e, this);
+            }
+            this.#clean();
+          })();
+        }
+      }
+      return this.append_r_prom(func);
+    };
+    this.set = (value) => {
+      this.#clean();
+      this.set(this.ful_r_prom(value));
+    };
+    const write_sync = this.write_sync.bind(this);
+    this.write_sync = (value) => write_sync(value).map((val) => this.#clean() ?? val);
+    const write = this.write.bind(this);
+    this.write = async (value) => (await write(value)).map((val) => this.#clean() ?? val);
+  }
+  #clean() {
+    ["then", "set", "write", "write_sync"].forEach(
+      (k) => delete this[k]
+    );
+  }
+  #value;
+  #setter_sync;
+  #setter_async;
+  #helper;
+  //#Owner Context
+  set(value) {
+    this.update_subs(this.#value = value);
+  }
+  set_ok(value) {
+    this.set(ok4(value));
+  }
+  set_err(error) {
+    this.set(err5(error));
+  }
+  set setter_sync(setter) {
+    this.#setter_sync = setter;
+  }
+  get setter_sync() {
+    return this.#setter_sync;
+  }
+  set setter_async(setter) {
+    this.#setter_async = setter;
+  }
+  get setter_async() {
+    return this.#setter_async;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  get read_write_sync() {
+    return this.#setter_sync ? this : void 0;
+  }
+  get read_write_async() {
+    return this.#setter_async ? this : void 0;
+  }
+  //#Reader Context
+  get rok() {
+    return true;
+  }
+  //Becomes sync compatible once evaluated
+  get rsync() {
+    return Boolean(this.#value);
+  }
+  get() {
+    return this.#value;
+  }
+  ok() {
+    return this.#value.value;
+  }
+  async then(func) {
+    return func(this.#value);
+  }
+  related() {
+    return this.#helper?.related ? this.#helper.related() : none7();
+  }
+  //#Writer Context
+  get writable() {
+    return Boolean(this.#setter_sync || this.#setter_async);
+  }
+  get wsync() {
+    return Boolean(this.#setter_sync);
+  }
+  async write(value) {
+    if (this.#setter_async)
+      return this.#setter_async(
+        value,
+        this,
+        this.#value
+      );
+    else if (this.#setter_sync)
+      return this.#setter_sync(
+        value,
+        this,
+        this.#value
+      );
+    return err5("State not writable");
+  }
+  write_sync(value) {
+    if (this.#setter_sync)
+      return this.#setter_sync(
+        value,
+        this,
+        this.#value
+      );
+    return err5("State not writable");
+  }
+  limit(value) {
+    return this.#helper?.limit ? this.#helper.limit(value) : ok4(value);
+  }
+  check(value) {
+    return this.#helper?.check ? this.#helper.check(value) : ok4(value);
+  }
+};
+var roa = {
+  /**Creates a delayed ok state from an initial value, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial value for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  ok(init, helper) {
+    return new RXA(
+      init ? async () => ok4(await init()) : void 0,
+      helper
+    );
+  },
+  /**Creates a delayed ok state from an initial result, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial result for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  result(init, helper) {
+    return new RXA(init, helper);
+  }
+};
+var roa_ws = {
+  /**Creates a delayed ok state from an initial value, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial value for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  ok(init, setter = true, helper) {
+    return new RXA(
+      init ? async () => ok4(await init()) : void 0,
+      helper,
+      setter
+    );
+  },
+  /**Creates a delayed ok state from an initial result, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial result for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  result(init, setter = true, helper) {
+    return new RXA(
+      init,
+      helper,
+      setter
+    );
+  }
+};
+var roa_wa = {
+  /**Creates a delayed ok state from an initial value, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial value for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  ok(init, setter = true, helper) {
+    return new RXA(
+      init ? async () => ok4(await init()) : void 0,
+      helper,
+      void 0,
+      setter
+    );
+  },
+  /**Creates a delayed ok state from an initial result, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial result for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  result(init, setter = true, helper) {
+    return new RXA(
+      init,
+      helper,
+      void 0,
+      setter
+    );
+  }
+};
+var rea = {
+  /**Creates a delayed ok state from an initial value, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial value for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  ok(init, helper) {
+    return new RXA(
+      init ? async () => ok4(await init()) : void 0,
+      helper
+    );
+  },
+  /**Creates a delayed state from an initial error, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial error for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  err(init, helper) {
+    return new RXA(
+      init ? async () => err5(await init()) : void 0,
+      helper
+    );
+  },
+  /**Creates a delayed ok state from an initial result, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial result for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  result(init, helper) {
+    return new RXA(
+      init,
+      helper
+    );
+  }
+};
+var rea_ws = {
+  /**Creates a delayed ok state from an initial value, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial value for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  ok(init, setter = true, helper) {
+    return new RXA(
+      init ? async () => ok4(await init()) : void 0,
+      helper,
+      setter
+    );
+  },
+  /**Creates a writable delayed state from an initial error, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial error for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  err(init, setter = true, helper) {
+    return new RXA(
+      init ? async () => err5(await init()) : void 0,
+      helper,
+      setter
+    );
+  },
+  /**Creates a delayed ok state from an initial result, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial result for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  result(init, setter = true, helper) {
+    return new RXA(
+      init,
+      helper,
+      setter
+    );
+  }
+};
+var rea_wa = {
+  /**Creates a delayed ok state from an initial value, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial value for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  ok(init, setter = true, helper) {
+    return new RXA(
+      init ? async () => ok4(await init()) : void 0,
+      helper,
+      void 0,
+      setter
+    );
+  },
+  /**Creates a writable delayed state from an initial error, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial error for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  err(init, setter = true, helper) {
+    return new RXA(
+      init ? async () => err5(await init()) : void 0,
+      helper,
+      void 0,
+      setter
+    );
+  },
+  /**Creates a delayed ok state from an initial result, delayed meaning the value is a promise evaluated on first access.
+   * @param init initial result for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  result(init, setter = true, helper) {
+    return new RXA(
+      init,
+      helper,
+      void 0,
+      setter
+    );
+  }
+};
+var STATE_DELAYED = {
+  /**Read only delayed states with guarenteed ok, delayed meaning the value is a promise evaluated on first access. */
+  roa,
+  /**Read write delayed states with guarenteed ok and sync write, delayed meaning the value is a promise evaluated on first access. */
+  roa_ws,
+  /**Read write delayed states with guarenteed ok and async write, delayed meaning the value is a promise evaluated on first access. */
+  roa_wa,
+  /**Read only delayed states with error, delayed meaning the value is a promise evaluated on first access. */
+  rea,
+  /**Read write delayed states with error and sync write, delayed meaning the value is a promise evaluated on first access. */
+  rea_ws,
+  /**Read write delayed state with error and async write, delayed meaning the value is a promise evaluated on first access. */
+  rea_wa
+};
+
+// src/helpers.ts
+import { number_step_start_decimal } from "@chocbite/ts-lib-math";
+import {
+  err as err6,
+  ok as ok5,
+  some
+} from "@chocbite/ts-lib-result";
+var StateNumberHelper = class {
+  min;
+  max;
+  unit;
+  decimals;
+  step;
+  start;
+  constructor(min, max, unit, decimals, step, start) {
+    if (min !== void 0) this.min = min;
+    if (max !== void 0) this.max = max;
+    if (unit !== void 0) this.unit = unit;
+    if (decimals !== void 0) {
+      this.decimals = decimals;
+      if (step !== void 0) this.step = step;
+      if (start !== void 0) this.start = start;
+    } else {
+      if (step !== void 0) {
+        this.step = step;
+        const match = String(step).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
+        this.decimals = match ? Math.max(
+          0,
+          (match[1] ? match[1].length : 0) - (match[2] ? +match[2] : 0)
+        ) : 0;
+        if (start !== void 0) {
+          this.start = start;
+          const match2 = String(start).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
+          this.decimals = Math.max(
+            this.decimals,
+            match2 ? Math.max(
+              0,
+              (match2[1] ? match2[1].length : 0) - (match2[2] ? +match2[2] : 0)
+            ) : 0
+          );
+        }
+      }
+    }
+  }
+  limit(value) {
+    return ok5(
+      Math.min(
+        this.max ?? Infinity,
+        Math.max(
+          this.min ?? -Infinity,
+          number_step_start_decimal(
+            value,
+            this.step,
+            this.start,
+            this.decimals
+          )
+        )
+      )
+    );
+  }
+  check(value) {
+    if (this.max !== void 0 && value > this.max)
+      return err6(value + " is bigger than the limit of " + this.max);
+    if (this.min !== void 0 && value < this.min)
+      return err6(value + " is smaller than the limit of " + this.min);
+    return ok5(value);
+  }
+  related() {
+    return some(this);
+  }
+};
+var nums = {
+  /**Number limiter struct
+   * @param min minimum allowed number
+   * @param max maximum allowed number
+   * @param unit unit for number
+   * @param decimals number of suggested decimals to show
+   * @param step allowed step size for number 0.1 allows 0,0.1,0.2,0.3...
+   * @param start start offset for step, 0.5 and step 2 allows 0.5,2.5,4.5,6.5*/
+  helper(min, max, unit, decimals, step, start) {
+    return new StateNumberHelper(min, max, unit, decimals, step, start);
+  }
+};
+var StateStringHelper = class {
+  max_length;
+  max_length_bytes;
+  constructor(max_length, max_length_bytes) {
+    if (max_length !== void 0) this.max_length = max_length;
+    if (max_length_bytes !== void 0)
+      this.max_length_bytes = max_length_bytes;
+  }
+  limit(value) {
+    if (this.max_length && value.length > this.max_length)
+      value = value.slice(0, this.max_length);
+    if (this.max_length_bytes) {
+      value = new TextDecoder().decode(
+        new TextEncoder().encode(value).slice(0, this.max_length_bytes)
+      );
+      if (value.at(-1)?.charCodeAt(0) === 65533) value = value.slice(0, -1);
+    }
+    return ok5(value);
+  }
+  check(value) {
+    if (this.max_length !== void 0 && value.length > this.max_length)
+      return err6(
+        "the text is longer than the limit of " + this.max_length + " characters"
+      );
+    if (this.max_length_bytes !== void 0 && new TextEncoder().encode(value).length > this.max_length_bytes)
+      return err6(
+        "the text is longer than the limit of " + this.max_length_bytes + " bytes"
+      );
+    return ok5(value);
+  }
+  related() {
+    return some(this);
+  }
+};
+var strings = {
+  /**String limiter struct
+   * @param max_length max length for string
+   * @param max_length_bytes max byte length for string*/
+  helper(max_length, max_length_bytes) {
+    return new StateStringHelper(max_length, max_length_bytes);
+  }
+};
+var StateEnumHelper = class {
+  list;
+  constructor(list) {
+    this.list = list;
+  }
+  map(func) {
+    return Object.keys(this.list).map(
+      (key) => func(key, this.list[key])
+    );
+  }
+  limit(value) {
+    return ok5(value);
+  }
+  check(value) {
+    if (value in this.list) return ok5(value);
+    return err6(String(value) + " is not in list");
+  }
+  related() {
+    return some(this);
+  }
+};
+var enums = {
+  /**Creates an enum helper struct, use list method to make a list with correct typing*/
+  helper(list) {
+    return new StateEnumHelper(list);
+  },
+  /**Creates an enum description list, passing the enum as a generic type to this function makes things look a bit nicer */
+  list(list) {
+    return list;
+  }
+};
+async function await_value(value, state2, timeout = 500) {
+  let func = () => {
+  };
+  const res3 = await Promise.race([
+    new Promise((a) => setTimeout(a, timeout, false)),
+    new Promise((a) => {
+      func = state2.sub((res4) => {
+        if (res4.ok && res4.value === value) a(true);
+      });
+    })
+  ]);
+  state2.unsub(func);
+  return res3;
+}
+async function compare(state1, state2) {
+  const res1 = await state1;
+  const res22 = await state2;
+  if (res1.err || res22.err) return false;
+  return res1.value === res22.value;
+}
+function compare_sync(state1, state2) {
+  const res1 = state1.get();
+  const res22 = state2.get();
+  if (res1.err || res22.err) return true;
+  return res1.value !== res22.value;
+}
+var is = {
+  rea(s) {
+    return s instanceof StateBase;
+  },
+  roa(s) {
+    return s instanceof StateBase && s.rok;
+  },
+  res(s) {
+    return s instanceof StateBase && s.rsync;
+  },
+  ros(s) {
+    return s instanceof StateBase && s.rsync && s.rok;
+  },
+  rea_wa(s) {
+    return s instanceof StateBase && s.writable;
+  },
+  rea_ws(s) {
+    return s instanceof StateBase && s.writable && s.wsync;
+  },
+  roa_wa(s) {
+    return s instanceof StateBase && s.writable && s.rok;
+  },
+  roa_ws(s) {
+    return s instanceof StateBase && s.writable && s.wsync && s.rok;
+  },
+  res_wa(s) {
+    return s instanceof StateBase && s.writable && s.rsync;
+  },
+  res_ws(s) {
+    return s instanceof StateBase && s.writable && s.wsync && s.rsync;
+  },
+  ros_wa(s) {
+    return s instanceof StateBase && s.writable && s.rsync && s.rok;
+  },
+  ros_ws(s) {
+    return s instanceof StateBase && s.writable && s.wsync && s.rsync && s.rok;
+  }
+};
+var STATE_HELPERS = {
+  is,
+  nums,
+  strings,
+  enums,
+  await_value,
+  compare,
+  compare_sync
+};
+
+// src/lazy/lazy.ts
+import {
+  err as err7,
+  none as none8,
+  ok as ok6
+} from "@chocbite/ts-lib-result";
+var RXS3 = class extends StateBase {
+  constructor(init, helper, setter) {
+    super();
+    if (setter === true)
+      this.#setter = (value, state2, old) => {
+        if (old && !old.err && value === old.value)
+          return ok6(void 0);
+        return this.#helper?.limit ? this.#helper?.limit(value).map((e) => state2.set_ok(e)) : ok6(state2.set_ok(value));
+      };
+    else this.#setter = setter;
+    if (helper) this.#helper = helper;
+    this.get = () => this.#clean() ?? (this.#value = init());
+    this.set = (value) => this.set(this.#clean() ?? value);
+    const write_sync = this.write_sync.bind(this);
+    this.write_sync = (value) => write_sync(value).map((val) => this.#clean() ?? val);
+  }
+  #clean() {
+    ["get", "set", "write_sync"].forEach((k) => delete this[k]);
+  }
+  #value;
+  #setter;
+  #helper;
+  //#Owner Context
+  set(value) {
+    this.update_subs(this.#value = value);
+  }
+  set_ok(value) {
+    this.set(ok6(value));
+  }
+  set_err(error) {
+    this.set(err7(error));
+  }
+  set setter(setter) {
+    this.#setter = setter;
+  }
+  get setter() {
+    return this.#setter;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  get read_write() {
+    return this.#setter ? this : void 0;
+  }
+  //#Reader Context
+  get rok() {
+    return true;
+  }
+  get rsync() {
+    return true;
+  }
+  async then(func) {
+    return func(this.get());
+  }
+  get() {
+    return this.#value;
+  }
+  ok() {
+    return this.get().value;
+  }
+  related() {
+    return this.#helper?.related ? this.#helper.related() : none8();
+  }
+  //#Writer Context
+  get writable() {
+    return this.#setter !== void 0;
+  }
+  get wsync() {
+    return this.writable;
+  }
+  async write(value) {
+    return this.write_sync(value);
+  }
+  write_sync(value) {
+    if (this.#setter)
+      return this.#setter(
+        value,
+        this,
+        this.#value
+      );
+    return err7("State not writable");
+  }
+  limit(value) {
+    return this.#helper?.limit ? this.#helper.limit(value) : ok6(value);
+  }
+  check(value) {
+    return this.#helper?.check ? this.#helper.check(value) : ok6(value);
+  }
+};
+var ros2 = {
+  /**Creates a lazy ok state from an initial value, lazy meaning the value is only evaluated on first access.
+   * @param init initial value for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  ok(init, helper) {
+    return new RXS3(
+      () => ok6(init()),
+      helper
+    );
+  },
+  /**Creates a lazy ok state from an initial result, lazy meaning the value is only evaluated on first access.
+   * @param init initial result for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  result(init, helper) {
+    return new RXS3(init, helper);
+  }
+};
+var ros_ws2 = {
+  /**Creates a lazy ok state from an initial value, lazy meaning the value is only evaluated on first access.
+   * @param init initial value for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  ok(init, setter = true, helper) {
+    return new RXS3(
+      () => ok6(init()),
+      helper,
+      setter
+    );
+  },
+  /**Creates a lazy ok state from an initial result, lazy meaning the value is only evaluated on first access.
+   * @param init initial result for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  result(init, setter = true, helper) {
+    return new RXS3(
+      init,
+      helper,
+      setter
+    );
+  }
+};
+var res2 = {
+  /**Creates a lazy state from an initial value, lazy meaning the value is only evaluated on first access.
+   * @param init initial value for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  ok(init, helper) {
+    return new RXS3(
+      () => ok6(init()),
+      helper
+    );
+  },
+  /**Creates a lazy state from an initial error, lazy meaning the value is only evaluated on first access.
+   * @param init initial error for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  err(init, helper) {
+    return new RXS3(
+      () => err7(init()),
+      helper
+    );
+  },
+  /**Creates a lazy state from an initial result, lazy meaning the value is only evaluated on first access.
+   * @param init initial result for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  result(init, helper) {
+    return new RXS3(
+      init,
+      helper
+    );
+  }
+};
+var res_ws2 = {
+  /**Creates a writable lazy state from an initial value, lazy meaning the value is only evaluated on first access.
+   * @param init initial value for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  ok(init, setter = true, helper) {
+    return new RXS3(
+      () => ok6(init()),
+      helper,
+      setter
+    );
+  },
+  /**Creates a writable lazy state from an initial error, lazy meaning the value is only evaluated on first access.
+   * @param init initial error for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  err(init, setter = true, helper) {
+    return new RXS3(
+      () => err7(init()),
+      helper,
+      setter
+    );
+  },
+  /**Creates a writable lazy state from an initial result, lazy meaning the value is only evaluated on first access.
+   * @param init initial result for state.
+   * @param helper functions to check and limit the value, and to return related states.*/
+  result(init, setter = true, helper) {
+    return new RXS3(
+      init,
+      helper,
+      setter
+    );
+  }
+};
+var STATE_LAZY = {
+  /**Sync Read lazy states with guarenteed ok, lazy meaning the value is only evaluated on first access. */
+  ros: ros2,
+  /**Sync Read And Sync Write lazy states with guarenteed ok, lazy meaning the value is only evaluated on first access. */
+  ros_ws: ros_ws2,
+  /**Sync Read lazy states with error, lazy meaning the value is only evaluated on first access. */
+  res: res2,
+  /**Sync Read And Sync Write lazy states with error, lazy meaning the value is only evaluated on first access. */
+  res_ws: res_ws2
+};
+
+// src/proxy/rea.ts
+import {
+  err as err8,
+  none as none9
+} from "@chocbite/ts-lib-result";
+var REA2 = class extends StateBase {
+  constructor(state2, transform_read) {
+    super();
+    this.#state = state2;
+    if (transform_read) this.transform_read = transform_read;
+  }
+  #state;
+  #subscriber = (value) => {
+    this.#buffer = this.transform_read(value);
+    this.update_subs(this.#buffer);
+  };
+  #buffer;
+  transform_read(value) {
+    return value;
+  }
+  transform_write;
+  on_subscribe(run = false) {
+    this.#state.sub(this.#subscriber, run);
+  }
+  on_unsubscribe() {
+    this.#state.unsub(this.#subscriber);
+    this.#buffer = void 0;
+  }
+  //#Owner Context
+  set_state(state2) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#state = state2;
+      this.on_subscribe(true);
+    } else this.#state = state2;
+  }
+  set_transform_read(transform) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.transform_read = transform;
+      this.on_subscribe(true);
+    } else this.transform_read = transform;
+  }
+  set_transform_write(transform) {
+    this.transform_write = transform;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return this.#state.rok;
+  }
+  get rsync() {
+    return this.#state.rsync;
+  }
+  async then(func) {
+    if (this.#buffer) return func(this.#buffer);
+    return func(this.transform_read(await this.#state));
+  }
+  related() {
+    return none9();
+  }
+  //#Writer Context
+  get writable() {
+    return this.#state.writable;
+  }
+  get wsync() {
+    return this.#state.wsync;
+  }
+  async write(value) {
+    if (!this.#state.write) return err8("State not writable");
+    if (!this.transform_write) return err8("State not writable");
+    return this.#state.write(this.transform_write(value));
+  }
+  write_sync(value) {
+    if (!this.#state.write_sync) return err8("State not writable");
+    if (!this.transform_write) return err8("State not writable");
+    return this.#state.write_sync(this.transform_write(value));
+  }
+  limit(_value) {
+    return err8("Limit not supported on proxy states");
+  }
+  check(_value) {
+    return err8("Check not supported on proxy states");
+  }
+};
+function rea_from(state2, transform) {
+  return new REA2(state2, transform);
+}
+var REAWS = class extends StateBase {
+  constructor(state2, transform_read, transform_write) {
+    super();
+    this.#state = state2;
+    if (transform_read) this.transform_read = transform_read;
+    if (transform_write) this.transform_write = transform_write;
+  }
+  #state;
+  #subscriber = (value) => {
+    this.#buffer = this.transform_read(value);
+    this.update_subs(this.#buffer);
+  };
+  #buffer;
+  transform_read(value) {
+    return value;
+  }
+  transform_write(value) {
+    return value;
+  }
+  on_subscribe(run = false) {
+    this.#state.sub(this.#subscriber, run);
+  }
+  on_unsubscribe() {
+    this.#state.unsub(this.#subscriber);
+    this.#buffer = void 0;
+  }
+  //#Owner Context
+  set_state(state2) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#state = state2;
+      this.on_subscribe(true);
+    } else this.#state = state2;
+  }
+  set_transform_read(transform) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.transform_read = transform;
+      this.on_subscribe(true);
+    } else this.transform_read = transform;
+  }
+  set_transform_write(transform) {
+    this.transform_write = transform;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  get read_write() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return this.#state.rok;
+  }
+  get rsync() {
+    return this.#state.rsync;
+  }
+  async then(func) {
+    if (this.#buffer) return func(this.#buffer);
+    return func(this.transform_read(await this.#state));
+  }
+  related() {
+    return none9();
+  }
+  //#Writer Context
+  get writable() {
+    return true;
+  }
+  get wsync() {
+    return true;
+  }
+  write(value) {
+    return this.#state.write(this.transform_write(value));
+  }
+  write_sync(value) {
+    return this.#state.write_sync(this.transform_write(value));
+  }
+  limit(_value) {
+    return err8("Limit not supported on proxy states");
+  }
+  check(_value) {
+    return err8("Check not supported on proxy states");
+  }
+};
+function rea_ws_from(state2, transform_read, transform_write) {
+  return new REAWS(
+    state2,
+    transform_read,
+    transform_write
+  );
+}
+var REAWA = class extends StateBase {
+  constructor(state2, transform_read, transform_write) {
+    super();
+    this.#state = state2;
+    if (transform_read) this.transform_read = transform_read;
+    if (transform_write) this.transform_write = transform_write;
+  }
+  #state;
+  #subscriber = (value) => {
+    this.#buffer = this.transform_read(value);
+    this.update_subs(this.#buffer);
+  };
+  #buffer;
+  transform_read(value) {
+    return value;
+  }
+  transform_write(value) {
+    return value;
+  }
+  on_subscribe(run = false) {
+    this.#state.sub(this.#subscriber, run);
+  }
+  on_unsubscribe() {
+    this.#state.unsub(this.#subscriber);
+    this.#buffer = void 0;
+  }
+  //#Owner Context
+  set_state(state2) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#state = state2;
+      this.on_subscribe(true);
+    } else this.#state = state2;
+  }
+  set_transform_read(transform) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.transform_read = transform;
+      this.on_subscribe(true);
+    } else this.transform_read = transform;
+  }
+  set_transform_write(transform) {
+    this.transform_write = transform;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  get read_write() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return this.#state.rok;
+  }
+  get rsync() {
+    return this.#state.rsync;
+  }
+  async then(func) {
+    if (this.#buffer) return func(this.#buffer);
+    return func(this.transform_read(await this.#state));
+  }
+  related() {
+    return none9();
+  }
+  //#Writer Context
+  get writable() {
+    return true;
+  }
+  get wsync() {
+    return this.#state.wsync;
+  }
+  write(value) {
+    return this.#state.write(this.transform_write(value));
+  }
+  limit(_value) {
+    return err8("Limit not supported on proxy states");
+  }
+  check(_value) {
+    return err8("Check not supported on proxy states");
+  }
+};
+function rea_wa_from(state2, transform_read, transform_write) {
+  return new REAWA(
+    state2,
+    transform_read,
+    transform_write
+  );
+}
+var STATE_PROXY_REA = {
+  rea: rea_from,
+  rea_ws: rea_ws_from,
+  rea_wa: rea_wa_from
+};
+
+// src/proxy/res.ts
+import {
+  err as err9,
+  none as none10
+} from "@chocbite/ts-lib-result";
+var RES3 = class extends StateBase {
+  constructor(state2, transform_read) {
+    super();
+    this.#state = state2;
+    if (transform_read) this.transform_read = transform_read;
+  }
+  #state;
+  #subscriber = (value) => {
+    this.#buffer = this.transform_read(value);
+    this.update_subs(this.#buffer);
+  };
+  #buffer;
+  transform_read(value) {
+    return value;
+  }
+  transform_write;
+  on_subscribe(run = false) {
+    this.#state.sub(this.#subscriber, run);
+  }
+  on_unsubscribe() {
+    this.#state.unsub(this.#subscriber);
+    this.#buffer = void 0;
+  }
+  //#Owner Context
+  set_state(state2) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#state = state2;
+      this.on_subscribe(true);
+    } else this.#state = state2;
+  }
+  set_transform_read(transform) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.transform_read = transform;
+      this.on_subscribe(true);
+    } else this.transform_read = transform;
+  }
+  set_transform_write(transform) {
+    this.transform_write = transform;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return this.#state.rok;
+  }
+  get rsync() {
+    return true;
+  }
+  async then(func) {
+    return func(this.get());
+  }
+  get() {
+    if (this.#buffer) return this.#buffer;
+    return this.transform_read(this.#state.get());
+  }
+  related() {
+    return none10();
+  }
+  //#Writer Context
+  get writable() {
+    return this.#state.writable;
+  }
+  get wsync() {
+    return this.#state.wsync;
+  }
+  async write(value) {
+    if (!this.#state.write) return err9("State not writable");
+    if (!this.transform_write) return err9("State not writable");
+    return this.#state.write(this.transform_write(value));
+  }
+  write_sync(value) {
+    if (!this.#state.write_sync) return err9("State not writable");
+    if (!this.transform_write) return err9("State not writable");
+    return this.#state.write_sync(this.transform_write(value));
+  }
+  limit() {
+    return err9("Limit not supported on proxy states");
+  }
+  check() {
+    return err9("Check not supported on proxy states");
+  }
+};
+function res_from(state2, transform) {
+  return new RES3(state2, transform);
+}
+var RESWS = class extends StateBase {
+  constructor(state2, transform_read, transform_write) {
+    super();
+    this.#state = state2;
+    if (transform_read) this.transform_read = transform_read;
+    if (transform_write) this.transform_write = transform_write;
+  }
+  #state;
+  #subscriber = (value) => {
+    this.#buffer = this.transform_read(value);
+    this.update_subs(this.#buffer);
+  };
+  #buffer;
+  transform_read(value) {
+    return value;
+  }
+  transform_write(value) {
+    return value;
+  }
+  on_subscribe(run = false) {
+    this.#state.sub(this.#subscriber, run);
+  }
+  on_unsubscribe() {
+    this.#state.unsub(this.#subscriber);
+    this.#buffer = void 0;
+  }
+  //#Owner Context
+  /**Sets the state that is being proxied, and updates subscribers with new value*/
+  set_state(state2) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#state = state2;
+      this.on_subscribe(true);
+    } else this.#state = state2;
+  }
+  /**Changes the transform function of the proxy, and updates subscribers with new value*/
+  set_transform_read(transform) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.transform_read = transform;
+      this.on_subscribe(true);
+    } else this.transform_read = transform;
+  }
+  /**Changes the transform function of the proxy, and updates subscribers with new value*/
+  set_transform_write(transform) {
+    this.transform_write = transform;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  get read_write() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return this.#state.rok;
+  }
+  get rsync() {
+    return true;
+  }
+  async then(func) {
+    if (this.#buffer) return func(this.#buffer);
+    return func(this.transform_read(await this.#state));
+  }
+  get() {
+    if (this.#buffer) return this.#buffer;
+    return this.transform_read(this.#state.get());
+  }
+  related() {
+    return none10();
+  }
+  //#Writer Context
+  get writable() {
+    return true;
+  }
+  get wsync() {
+    return true;
+  }
+  write(value) {
+    return this.#state.write(this.transform_write(value));
+  }
+  write_sync(value) {
+    return this.#state.write_sync(this.transform_write(value));
+  }
+  limit() {
+    return err9("Limit not supported on proxy states");
+  }
+  check() {
+    return err9("Check not supported on proxy states");
+  }
+};
+function res_ws_from(state2, transform_read, transform_write) {
+  return new RESWS(
+    state2,
+    transform_read,
+    transform_write
+  );
+}
+var RESWA = class extends StateBase {
+  constructor(state2, transform_read, transform_write) {
+    super();
+    this.#state = state2;
+    if (transform_read) this.transform_read = transform_read;
+    if (transform_write) this.transform_write = transform_write;
+  }
+  #state;
+  #subscriber = (value) => {
+    this.#buffer = this.transform_read(value);
+    this.update_subs(this.#buffer);
+  };
+  #buffer;
+  transform_read(value) {
+    return value;
+  }
+  transform_write(value) {
+    return value;
+  }
+  on_subscribe(run = false) {
+    this.#state.sub(this.#subscriber, run);
+  }
+  on_unsubscribe() {
+    this.#state.unsub(this.#subscriber);
+    this.#buffer = void 0;
+  }
+  //#Owner Context
+  /**Sets the state that is being proxied, and updates subscribers with new value*/
+  set_state(state2) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#state = state2;
+      this.on_subscribe(true);
+    } else this.#state = state2;
+  }
+  /**Changes the transform function of the proxy, and updates subscribers with new value*/
+  set_transform_read(transform) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.transform_read = transform;
+      this.on_subscribe(true);
+    } else this.transform_read = transform;
+  }
+  /**Changes the transform function of the proxy, and updates subscribers with new value*/
+  set_transform_write(transform) {
+    this.transform_write = transform;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  get read_write() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return this.#state.rok;
+  }
+  get rsync() {
+    return true;
+  }
+  async then(func) {
+    if (this.#buffer) return func(this.#buffer);
+    return func(this.transform_read(await this.#state));
+  }
+  get() {
+    if (this.#buffer) return this.#buffer;
+    return this.transform_read(this.#state.get());
+  }
+  related() {
+    return none10();
+  }
+  //#Writer Context
+  get writable() {
+    return true;
+  }
+  get wsync() {
+    return this.#state.wsync;
+  }
+  write(value) {
+    return this.#state.write(this.transform_write(value));
+  }
+  limit() {
+    return err9("Limit not supported on proxy states");
+  }
+  check() {
+    return err9("Check not supported on proxy states");
+  }
+};
+function res_wa_from(state2, transform_read, transform_write) {
+  return new RESWA(
+    state2,
+    transform_read,
+    transform_write
+  );
+}
+var STATE_PROXY_RES = {
+  res: res_from,
+  res_ws: res_ws_from,
+  res_wa: res_wa_from
+};
+
+// src/proxy/roa.ts
+import {
+  err as err10,
+  none as none11
+} from "@chocbite/ts-lib-result";
+var ROA2 = class extends StateBase {
+  constructor(state2, transform_read) {
+    super();
+    this.#state = state2;
+    if (transform_read) this.transform_read = transform_read;
+  }
+  #state;
+  #subscriber = (value) => {
+    this.#buffer = this.transform_read(value);
+    this.update_subs(this.#buffer);
+  };
+  #buffer;
+  transform_read(value) {
+    return value;
+  }
+  transform_write;
+  on_subscribe(run = false) {
+    this.#state.sub(this.#subscriber, run);
+  }
+  on_unsubscribe() {
+    this.#state.unsub(this.#subscriber);
+    this.#buffer = void 0;
+  }
+  //#Owner Context
+  set_state(state2) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#state = state2;
+      this.on_subscribe(true);
+    } else this.#state = state2;
+  }
+  set_transform_read(transform) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.transform_read = transform;
+      this.on_subscribe(true);
+    } else this.transform_read = transform;
+  }
+  set_transform_write(transform) {
+    this.transform_write = transform;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return true;
+  }
+  get rsync() {
+    return this.#state.rsync;
+  }
+  async then(func) {
+    if (this.#buffer) return func(this.#buffer);
+    return func(this.transform_read(await this.#state));
+  }
+  related() {
+    return none11();
+  }
+  //#Writer Context
+  get writable() {
+    return this.#state.writable;
+  }
+  get wsync() {
+    return this.#state.wsync;
+  }
+  async write(value) {
+    if (!this.#state.write) return err10("State not writable");
+    if (!this.transform_write) return err10("State not writable");
+    return this.#state.write(this.transform_write(value));
+  }
+  write_sync(value) {
+    if (!this.#state.write_sync) return err10("State not writable");
+    if (!this.transform_write) return err10("State not writable");
+    return this.#state.write_sync(this.transform_write(value));
+  }
+  limit(_value) {
+    return err10("Limit not supported on proxy states");
+  }
+  check(_value) {
+    return err10("Check not supported on proxy states");
+  }
+};
+function roa_from(state2, transform) {
+  return new ROA2(state2, transform);
+}
+var ROAWS = class extends StateBase {
+  constructor(state2, transform_read, transform_write) {
+    super();
+    this.#state = state2;
+    if (transform_read) this.transform_read = transform_read;
+    if (transform_write) this.transform_write = transform_write;
+  }
+  #state;
+  #subscriber = (value) => {
+    this.#buffer = this.transform_read(value);
+    this.update_subs(this.#buffer);
+  };
+  #buffer;
+  transform_read(value) {
+    return value;
+  }
+  transform_write(value) {
+    return value;
+  }
+  on_subscribe(run = false) {
+    this.#state.sub(this.#subscriber, run);
+  }
+  on_unsubscribe() {
+    this.#state.unsub(this.#subscriber);
+    this.#buffer = void 0;
+  }
+  //#Owner Context
+  set_state(state2) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#state = state2;
+      this.on_subscribe(true);
+    } else this.#state = state2;
+  }
+  set_transform_read(transform) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.transform_read = transform;
+      this.on_subscribe(true);
+    } else this.transform_read = transform;
+  }
+  set_transform_write(transform) {
+    this.transform_write = transform;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  get read_write() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return true;
+  }
+  get rsync() {
+    return this.#state.rsync;
+  }
+  async then(func) {
+    if (this.#buffer) return func(this.#buffer);
+    return func(this.transform_read(await this.#state));
+  }
+  related() {
+    return none11();
+  }
+  //#Writer Context
+  get writable() {
+    return true;
+  }
+  get wsync() {
+    return true;
+  }
+  write(value) {
+    return this.#state.write(this.transform_write(value));
+  }
+  write_sync(value) {
+    return this.#state.write_sync(this.transform_write(value));
+  }
+  limit(_value) {
+    return err10("Limit not supported on proxy states");
+  }
+  check(_value) {
+    return err10("Check not supported on proxy states");
+  }
+};
+function roa_ws_from(state2, transform_read, transform_write) {
+  return new ROAWS(
+    state2,
+    transform_read,
+    transform_write
+  );
+}
+var ROAWA = class extends StateBase {
+  constructor(state2, transform_read, transform_write) {
+    super();
+    this.#state = state2;
+    if (transform_read) this.transform_read = transform_read;
+    if (transform_write) this.transform_write = transform_write;
+  }
+  #state;
+  #subscriber = (value) => {
+    this.#buffer = this.transform_read(value);
+    this.update_subs(this.#buffer);
+  };
+  #buffer;
+  transform_read(value) {
+    return value;
+  }
+  transform_write(value) {
+    return value;
+  }
+  on_subscribe(run = false) {
+    this.#state.sub(this.#subscriber, run);
+  }
+  on_unsubscribe() {
+    this.#state.unsub(this.#subscriber);
+    this.#buffer = void 0;
+  }
+  //#Owner Context
+  set_state(state2) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#state = state2;
+      this.on_subscribe(true);
+    } else this.#state = state2;
+  }
+  set_transform_read(transform) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.transform_read = transform;
+      this.on_subscribe(true);
+    } else this.transform_read = transform;
+  }
+  set_transform_write(transform) {
+    this.transform_write = transform;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  get read_write() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return true;
+  }
+  get rsync() {
+    return this.#state.rsync;
+  }
+  async then(func) {
+    if (this.#buffer) return func(this.#buffer);
+    return func(this.transform_read(await this.#state));
+  }
+  related() {
+    return none11();
+  }
+  //#Writer Context
+  get writable() {
+    return true;
+  }
+  get wsync() {
+    return this.#state.wsync;
+  }
+  write(value) {
+    return this.#state.write(this.transform_write(value));
+  }
+  limit(_value) {
+    return err10("Limit not supported on proxy states");
+  }
+  check(_value) {
+    return err10("Check not supported on proxy states");
+  }
+};
+function roa_wa_from(state2, transform_read, transform_write) {
+  return new ROAWA(
+    state2,
+    transform_read,
+    transform_write
+  );
+}
+var STATE_PROXY_ROA = {
+  roa: roa_from,
+  roa_ws: roa_ws_from,
+  roa_wa: roa_wa_from
+};
+
+// src/proxy/ros.ts
+import {
+  err as err11,
+  none as none12
+} from "@chocbite/ts-lib-result";
+var ROS3 = class extends StateBase {
+  constructor(state2, transform_read) {
+    super();
+    this.#state = state2;
+    if (transform_read) this.transform_read = transform_read;
+  }
+  #state;
+  #subscriber = (value) => {
+    this.#buffer = this.transform_read(value);
+    this.update_subs(this.#buffer);
+  };
+  #buffer;
+  transform_read(value) {
+    return value;
+  }
+  transform_write;
+  on_subscribe(run = false) {
+    this.#state.sub(this.#subscriber, run);
+  }
+  on_unsubscribe() {
+    this.#state.unsub(this.#subscriber);
+    this.#buffer = void 0;
+  }
+  //#Owner Context
+  set_state(state2) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#state = state2;
+      this.on_subscribe(true);
+    } else this.#state = state2;
+  }
+  set_transform_read(transform) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.transform_read = transform;
+      this.on_subscribe(true);
+    } else this.transform_read = transform;
+  }
+  set_transform_write(transform) {
+    this.transform_write = transform;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return true;
+  }
+  get rsync() {
+    return true;
+  }
+  async then(func) {
+    return func(this.get());
+  }
+  get() {
+    if (this.#buffer) return this.#buffer;
+    return this.transform_read(this.#state.get());
+  }
+  ok() {
+    return this.get().value;
+  }
+  related() {
+    return none12();
+  }
+  //#Writer Context
+  get writable() {
+    return this.#state.writable;
+  }
+  get wsync() {
+    return this.#state.wsync;
+  }
+  async write(value) {
+    if (!this.#state.write) return err11("State not writable");
+    if (!this.transform_write) return err11("State not writable");
+    return this.#state.write(this.transform_write(value));
+  }
+  write_sync(value) {
+    if (!this.#state.write_sync) return err11("State not writable");
+    if (!this.transform_write) return err11("State not writable");
+    return this.#state.write_sync(this.transform_write(value));
+  }
+  limit(_value) {
+    return err11("Limit not supported on proxy states");
+  }
+  check(_value) {
+    return err11("Check not supported on proxy states");
+  }
+};
+function ros_from(state2, transform) {
+  return new ROS3(state2, transform);
+}
+var ROSWS = class extends StateBase {
+  constructor(state2, transform_read, transform_write) {
+    super();
+    this.#state = state2;
+    if (transform_read) this.transform_read = transform_read;
+    if (transform_write) this.transform_write = transform_write;
+  }
+  #state;
+  #subscriber = (value) => {
+    this.#buffer = this.transform_read(value);
+    this.update_subs(this.#buffer);
+  };
+  #buffer;
+  transform_read(value) {
+    return value;
+  }
+  transform_write(value) {
+    return value;
+  }
+  on_subscribe(run = false) {
+    this.#state.sub(this.#subscriber, run);
+  }
+  on_unsubscribe() {
+    this.#state.unsub(this.#subscriber);
+    this.#buffer = void 0;
+  }
+  //#Owner Context
+  set_state(state2) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#state = state2;
+      this.on_subscribe(true);
+    } else this.#state = state2;
+  }
+  set_transform_read(transform) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.transform_read = transform;
+      this.on_subscribe(true);
+    } else this.transform_read = transform;
+  }
+  set_transform_write(transform) {
+    this.transform_write = transform;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  get read_write() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return true;
+  }
+  get rsync() {
+    return true;
+  }
+  async then(func) {
+    if (this.#buffer) return func(this.#buffer);
+    return func(this.transform_read(await this.#state));
+  }
+  get() {
+    if (this.#buffer) return this.#buffer;
+    return this.transform_read(this.#state.get());
+  }
+  ok() {
+    return this.get().value;
+  }
+  related() {
+    return none12();
+  }
+  //#Writer Context
+  get writable() {
+    return true;
+  }
+  get wsync() {
+    return true;
+  }
+  write(value) {
+    return this.#state.write(this.transform_write(value));
+  }
+  write_sync(value) {
+    return this.#state.write_sync(this.transform_write(value));
+  }
+  limit(_value) {
+    return err11("Limit not supported on proxy states");
+  }
+  check(_value) {
+    return err11("Check not supported on proxy states");
+  }
+};
+function ros_ws_from(state2, transform_read, transform_write) {
+  return new ROSWS(
+    state2,
+    transform_read,
+    transform_write
+  );
+}
+var ROSWA = class extends StateBase {
+  constructor(state2, transform_read, transform_write) {
+    super();
+    this.#state = state2;
+    if (transform_read) this.transform_read = transform_read;
+    if (transform_write) this.transform_write = transform_write;
+  }
+  #state;
+  #subscriber = (value) => {
+    this.#buffer = this.transform_read(value);
+    this.update_subs(this.#buffer);
+  };
+  #buffer;
+  transform_read(value) {
+    return value;
+  }
+  transform_write(value) {
+    return value;
+  }
+  on_subscribe(run = false) {
+    this.#state.sub(this.#subscriber, run);
+  }
+  on_unsubscribe() {
+    this.#state.unsub(this.#subscriber);
+    this.#buffer = void 0;
+  }
+  //#Owner Context
+  set_state(state2) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.#state = state2;
+      this.on_subscribe(true);
+    } else this.#state = state2;
+  }
+  set_transform_read(transform) {
+    if (this.in_use()) {
+      this.on_unsubscribe();
+      this.transform_read = transform;
+      this.on_subscribe(true);
+    } else this.transform_read = transform;
+  }
+  set_transform_write(transform) {
+    this.transform_write = transform;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  get read_write() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return true;
+  }
+  get rsync() {
+    return true;
+  }
+  async then(func) {
+    if (this.#buffer) return func(this.#buffer);
+    return func(this.transform_read(await this.#state));
+  }
+  get() {
+    if (this.#buffer) return this.#buffer;
+    return this.transform_read(this.#state.get());
+  }
+  ok() {
+    return this.get().value;
+  }
+  related() {
+    return none12();
+  }
+  //#Writer Context
+  get writable() {
+    return true;
+  }
+  get wsync() {
+    return this.#state.wsync;
+  }
+  write(value) {
+    return this.#state.write(this.transform_write(value));
+  }
+  limit(_value) {
+    return err11("Limit not supported on proxy states");
+  }
+  check(_value) {
+    return err11("Check not supported on proxy states");
+  }
+};
+function ros_wa_from(state2, transform_read, transform_write) {
+  return new ROSWA(
+    state2,
+    transform_read,
+    transform_write
+  );
+}
+var STATE_PROXY_ROS = {
+  ros: ros_from,
+  ros_ws: ros_ws_from,
+  ros_wa: ros_wa_from
+};
+
+// src/resource/rea.ts
+import {
+  err as err12,
+  none as none13,
+  ok as ok7
+} from "@chocbite/ts-lib-result";
+var StateResourceREA = class extends StateBase {
+  #valid = 0;
+  #fetching = false;
+  #buffer;
+  #retention_timout = 0;
+  #debounce_timout = 0;
+  #timeout_timout = 0;
+  on_subscribe() {
+    if (this.#retention_timout) {
+      clearTimeout(this.#retention_timout);
+      this.#retention_timout = 0;
+    } else {
+      if (this.debounce > 0)
+        this.#debounce_timout = setTimeout(() => {
+          this.setup_connection(this);
+          this.#debounce_timout = 0;
+        }, this.debounce);
+      else this.setup_connection(this);
+    }
+  }
+  on_unsubscribe() {
+    if (this.#debounce_timout) {
+      clearTimeout(this.#debounce_timout);
+      this.#debounce_timout = 0;
+    } else {
+      if (this.retention > 0) {
+        this.#retention_timout = setTimeout(() => {
+          this.teardown_connection(this);
+          this.#retention_timout = 0;
+        }, this.retention);
+      } else {
+        this.teardown_connection(this);
+      }
+    }
+    if (this.validity === true) this.#valid = 0;
+  }
+  update_single(value, update = false) {
+    this.#fetching = false;
+    clearTimeout(this.#timeout_timout);
+    this.ful_r_prom(value);
+    if (update) {
+      if (!this.#buffer?.compare(value)) this.update_subs(value);
+      this.#buffer = value;
+      this.#valid = this.validity === true ? true : performance.now() + this.validity;
+    }
+  }
+  update_resource(value) {
+    if (!this.#buffer?.compare(value)) this.update_subs(value);
+    this.#buffer = value;
+    this.#valid = this.validity === true ? true : performance.now() + this.validity;
+  }
+  get buffer() {
+    return this.#buffer;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return false;
+  }
+  get rsync() {
+    return false;
+  }
+  async then(func) {
+    if (this.#valid === true || this.#valid >= performance.now())
+      return func(this.#buffer);
+    else {
+      const prom = this.append_r_prom(func);
+      if (!this.#fetching) {
+        this.#fetching = true;
+        this.#timeout_timout = setTimeout(
+          () => this.#fetching = false,
+          this.timeout
+        );
+        if (this.debounce > 0)
+          setTimeout(() => this.single_get(this), this.debounce);
+        else this.single_get(this);
+      }
+      return prom;
+    }
+  }
+  //#Writer Context
+  get writable() {
+    return false;
+  }
+  get wsync() {
+    return false;
+  }
+};
+var FuncREA = class extends StateResourceREA {
+  constructor(once, setup, teardown, timeout, debounce, validity, retention, helper) {
+    super();
+    this.single_get = once;
+    this.setup_connection = setup;
+    this.teardown_connection = teardown;
+    this.timeout = timeout;
+    this.debounce = debounce;
+    this.validity = validity;
+    this.retention = retention;
+    if (helper) this.#helper = helper;
+  }
+  timeout;
+  debounce;
+  validity;
+  retention;
+  #helper;
+  /**Called if the state is awaited, returns the value once*/
+  single_get(_state) {
+  }
+  /**Called when state is subscribed to to setup connection to remote resource*/
+  setup_connection(_state) {
+  }
+  /**Called when state is no longer subscribed to to cleanup connection to remote resource*/
+  teardown_connection(_state) {
+  }
+  related() {
+    return this.#helper?.related ? this.#helper.related() : none13();
+  }
+};
+var rea2 = {
+  /**Alternative state resource which can be initialized with functions
+   * @template READ - The type of the state’s value when read.
+   * @template REL - The type of related states, defaults to an empty object.
+   * @param once function called when state value is requested once
+   * @param setup function called when state has been subscribed to
+   * @param teardown function called when state has been unsubscribed from completely
+   * @param debounce delay added to once value retrival, which will collect multiple once requests into a single one
+   * @param validity how long the last retrived value is considered valid
+   * @param retention delay after last subscriber unsubscribes before teardown is called, to allow quick resubscribe without teardown
+   * */
+  from(once, setup, teardown, times, helper) {
+    return new FuncREA(
+      once,
+      setup,
+      teardown,
+      times?.timeout ?? 1e3,
+      times?.debounce ?? 0,
+      times?.validity ?? 0,
+      times?.retention ?? 0,
+      helper
+    );
+  },
+  class: StateResourceREA
+};
+var StateResourceREAWA = class extends StateBase {
+  #valid = 0;
+  #fetching = false;
+  #buffer;
+  #retention_timout = 0;
+  #debounce_timout = 0;
+  #timeout_timout = 0;
+  #write_buffer;
+  #write_debounce_timout = 0;
+  #write_promises = [];
+  on_subscribe() {
+    if (this.#retention_timout) {
+      clearTimeout(this.#retention_timout);
+      this.#retention_timout = 0;
+    } else {
+      if (this.debounce > 0)
+        this.#debounce_timout = setTimeout(() => {
+          this.setup_connection(this);
+          this.#debounce_timout = 0;
+        }, this.debounce);
+      else this.setup_connection(this);
+    }
+  }
+  on_unsubscribe() {
+    if (this.#debounce_timout) {
+      clearTimeout(this.#debounce_timout);
+      this.#debounce_timout = 0;
+    } else {
+      if (this.retention > 0) {
+        this.#retention_timout = setTimeout(() => {
+          this.teardown_connection(this);
+          this.#retention_timout = 0;
+        }, this.retention);
+      } else {
+        this.teardown_connection(this);
+      }
+    }
+    if (this.validity === true) this.#valid = 0;
+  }
+  update_single(value, update = false) {
+    this.#fetching = false;
+    clearTimeout(this.#timeout_timout);
+    this.ful_r_prom(value);
+    if (update) {
+      if (!this.#buffer?.compare(value)) this.update_subs(value);
+      this.#buffer = value;
+      this.#valid = this.validity === true ? true : performance.now() + this.validity;
+    }
+  }
+  update_resource(value) {
+    if (!this.#buffer?.compare(value)) this.update_subs(value);
+    this.#buffer = value;
+    this.#valid = this.validity === true ? true : performance.now() + this.validity;
+  }
+  get buffer() {
+    return this.#buffer;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  get read_write() {
+    return this;
+  }
+  //Reader Context
+  get rok() {
+    return false;
+  }
+  get rsync() {
+    return false;
+  }
+  async then(func) {
+    if (this.#valid === true || this.#valid >= performance.now())
+      return func(this.#buffer);
+    else {
+      const prom = this.append_r_prom(func);
+      if (!this.#fetching) {
+        this.#fetching = true;
+        this.#timeout_timout = setTimeout(
+          () => this.#fetching = false,
+          this.timeout
+        );
+        if (this.debounce > 0)
+          setTimeout(() => this.single_get(this), this.debounce);
+        else this.single_get(this);
+      }
+      return prom;
+    }
+  }
+  //Writer Context
+  get writable() {
+    return true;
+  }
+  get wsync() {
+    return false;
+  }
+  async write(value) {
+    this.#write_buffer = value;
+    if (this.write_debounce === 0) return this.write_action(value, this);
+    else if (this.#write_debounce_timout === 0)
+      this.#write_debounce_timout = window.setTimeout(async () => {
+        this.#write_debounce_timout = 0;
+        const write_buffer = this.#write_buffer;
+        this.#write_buffer = void 0;
+        const promises = this.#write_promises;
+        this.#write_promises = [];
+        const res3 = await this.write_action(write_buffer, this);
+        for (let i = 0; i < promises.length; i++) promises[i](res3);
+      }, this.write_debounce);
+    return new Promise((a) => {
+      this.#write_promises.push(a);
+    });
+  }
+};
+var FuncREAWA = class extends StateResourceREAWA {
+  constructor(once, setup, teardown, timeout, debounce, validity, retention, write_debounce, write_action, helper) {
+    super();
+    this.single_get = once;
+    this.setup_connection = setup;
+    this.teardown_connection = teardown;
+    if (write_action) this.write_action = write_action;
+    this.timeout = timeout;
+    this.debounce = debounce;
+    this.validity = validity;
+    this.retention = retention;
+    this.write_debounce = write_debounce || 0;
+    if (helper) this.#helper = helper;
+  }
+  timeout;
+  debounce;
+  validity;
+  retention;
+  write_debounce;
+  #helper;
+  /**Called if the state is awaited, returns the value once*/
+  single_get(_state) {
+  }
+  /**Called when state is subscribed to to setup connection to remote resource*/
+  setup_connection(_state) {
+  }
+  /**Called when state is no longer subscribed to to cleanup connection to remote resource*/
+  teardown_connection(_state) {
+  }
+  /**Called after write debounce finished with the last written value*/
+  async write_action(_value, _state) {
+    return err12("State not writable");
+  }
+  limit(value) {
+    return this.#helper?.limit ? this.#helper.limit(value) : ok7(value);
+  }
+  check(value) {
+    return this.#helper?.check ? this.#helper.check(value) : ok7(value);
+  }
+  related() {
+    return this.#helper?.related ? this.#helper.related() : none13();
+  }
+};
+var rea_wa2 = {
+  /**Alternative state resource which can be initialized with functions
+   * @template READ - The type of the state’s value when read.
+   * @template WT - The type which can be written to the state.
+   * @template REL - The type of related states, defaults to an empty object.
+   * @param once function called when state value is requested once, returns a Err(string) on failure
+   * @param setup function called when state has been subscribed to
+   * @param teardown function called when state has been unsubscribed from completely
+   * @param write_action function called after write debounce finished with the last written value
+   * @param debounce delay added to once value retrival, which will collect multiple once requests into a single one
+   * @param validity how long the last retrived value is considered valid
+   * @param retention delay after last subscriber unsubscribes before teardown is called, to allow quick resubscribe without teardown
+   * @param write_debounce debounce delay for write calls, only the last write within the delay is used
+   * */
+  from(once, setup, teardown, write_action, times, helper) {
+    return new FuncREAWA(
+      once,
+      setup,
+      teardown,
+      times?.timeout ?? 1e3,
+      times?.debounce ?? 0,
+      times?.validity ?? 0,
+      times?.retention ?? 0,
+      times?.write_debounce ?? 0,
+      write_action,
+      helper
+    );
+  },
+  class: StateResourceREAWA
+};
+var STATE_RESOURCE_REA = {
+  /**Remote resource */
+  rea: rea2,
+  /**Remote resource with write cabability */
+  rea_wa: rea_wa2
+};
+
+// src/resource/roa.ts
+import { none as none14 } from "@chocbite/ts-lib-result";
+var StateResourceROA = class extends StateBase {
+  #valid = 0;
+  #fetching = false;
+  #buffer;
+  #retention_timout = 0;
+  #debounce_timout = 0;
+  #timeout_timout = 0;
+  on_subscribe() {
+    if (this.#retention_timout) {
+      clearTimeout(this.#retention_timout);
+      this.#retention_timout = 0;
+    } else {
+      if (this.debounce > 0)
+        this.#debounce_timout = setTimeout(() => {
+          this.setup_connection(this);
+          this.#debounce_timout = 0;
+        }, this.debounce);
+      else this.setup_connection(this);
+    }
+  }
+  on_unsubscribe() {
+    if (this.#debounce_timout) {
+      clearTimeout(this.#debounce_timout);
+      this.#debounce_timout = 0;
+    } else {
+      if (this.retention > 0) {
+        this.#retention_timout = setTimeout(() => {
+          this.teardown_connection(this);
+          this.#retention_timout = 0;
+        }, this.retention);
+      } else {
+        this.teardown_connection(this);
+      }
+    }
+    if (this.validity === true) this.#valid = 0;
+  }
+  update_single(value, update = false) {
+    this.#fetching = false;
+    clearTimeout(this.#timeout_timout);
+    this.ful_r_prom(value);
+    if (update) {
+      if (!this.#buffer?.compare(value)) this.update_subs(value);
+      this.#buffer = value;
+      this.#valid = this.validity === true ? true : performance.now() + this.validity;
+    }
+  }
+  update_resource(value) {
+    if (!this.#buffer?.compare(value)) this.update_subs(value);
+    this.#buffer = value;
+    this.#valid = this.validity === true ? true : performance.now() + this.validity;
+  }
+  get buffer() {
+    return this.#buffer;
+  }
+  get state() {
+    return this;
+  }
+  get read_only() {
+    return this;
+  }
+  //#Reader Context
+  get rok() {
+    return true;
+  }
+  get rsync() {
+    return false;
+  }
+  async then(func) {
+    if (this.#valid === true || this.#valid >= performance.now())
+      return func(this.#buffer);
+    else {
+      const prom = this.append_r_prom(func);
+      if (!this.#fetching) {
+        this.#fetching = true;
+        this.#timeout_timout = setTimeout(
+          () => this.#fetching = false,
+          this.timeout
+        );
+        if (this.debounce > 0)
+          setTimeout(() => this.single_get(this), this.debounce);
+        else this.single_get(this);
+      }
+      return prom;
+    }
+  }
+  //#Writer Context
+  get writable() {
+    return false;
+  }
+  get wsync() {
+    return false;
+  }
+};
+var FuncROA = class extends StateResourceROA {
+  constructor(once, setup, teardown, timeout, debounce, validity, retention, helper) {
+    super();
+    this.single_get = once;
+    this.setup_connection = setup;
+    this.teardown_connection = teardown;
+    this.timeout = timeout;
+    this.debounce = debounce;
+    this.validity = validity;
+    this.retention = retention;
+    if (helper) this.#helper = helper;
+  }
+  timeout;
+  debounce;
+  validity;
+  retention;
+  #helper;
+  /**Called if the state is awaited, returns the value once*/
+  single_get(_state) {
+  }
+  /**Called when state is subscribed to to setup connection to remote resource*/
+  setup_connection(_state) {
+  }
+  /**Called when state is no longer subscribed to to cleanup connection to remote resource*/
+  teardown_connection(_state) {
+  }
+  related() {
+    return this.#helper?.related ? this.#helper.related() : none14();
+  }
+};
+var roa2 = {
+  /**Alternative state resource which can be initialized with functions
+   * @template READ - The type of the state’s value when read.
+   * @template REL - The type of related states, defaults to an empty object.
+   * @param once function called when state value is requested once
+   * @param setup function called when state has been subscribed to
+   * @param teardown function called when state has been unsubscribed from completely
+   * @param debounce delay added to once value retrival, which will collect multiple once requests into a single one
+   * @param validity how long the last retrived value is considered valid, if true, value is valid until all unsubscribes
+   * @param retention delay after last subscriber unsubscribes before teardown is called, to allow quick resubscribe without teardown
+   * */
+  from(once, setup, teardown, times, helper) {
+    return new FuncROA(
+      once,
+      setup,
+      teardown,
+      times?.timeout ?? 1e3,
+      times?.debounce ?? 0,
+      times?.validity ?? 0,
+      times?.retention ?? 0,
+      helper
+    );
+  },
+  class: StateResourceROA
+};
+var STATE_RESOURCE_ROA = {
+  /**Remote resource with guaranteed ok value */
+  roa: roa2
+};
+
+// src/index.ts
+var state = {
+  /**The state key is a symbol used to identify state objects
+   * To implement a custom state, set this key to true on the object */
+  STATE_KEY,
+  a: STATE_ARRAY,
+  /**Collected states, collects values from multiple states and reduces it to one */
+  c: {
+    rea: STATE_COLLECTED_REA,
+    res: STATE_COLLECTED_RES,
+    roa: STATE_COLLECTED_ROA,
+    ros: STATE_COLLECTED_ROS,
+    num: STATE_COLLECTS_NUMBER
+  },
+  d: STATE_DELAYED,
+  h: STATE_HELPERS,
+  l: STATE_LAZY,
+  p: {
+    ...STATE_PROXY_REA,
+    ...STATE_PROXY_RES,
+    ...STATE_PROXY_ROA,
+    ...STATE_PROXY_ROS
+  },
+  r: { ...STATE_RESOURCE_REA, ...STATE_RESOURCE_ROA },
+  s: STATE_SYNC,
+  /**Returns true if the given object promises to be a state */
+  is(s) {
+    return Boolean(s) && s[STATE_KEY] === true;
+  },
+  /**Utility base class for state, with basic state functionality */
+  class: StateBase,
+  ok: STATE_SYNC.ros.ok,
+  err: STATE_SYNC.res.err,
+  from: STATE_SYNC.res.ok,
+  ok_ws: STATE_SYNC.ros_ws.ok,
+  err_ws: STATE_SYNC.res_ws.err,
+  from_ws: STATE_SYNC.res_ws.ok
+};
+export {
+  StateEnumHelper,
+  StateNumberHelper,
+  StateStringHelper,
+  state
+};