@expressive/mvc 0.71.0 → 0.73.0

package/dist/index.js

@@ -1,1012 +1,872 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key2 of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key2) && key2 !== except)
-        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Context: () => Context,
-  METHOD: () => METHOD,
-  Model: () => Model,
-  Observable: () => Observable,
-  addListener: () => addListener,
-  createEffect: () => createEffect,
-  default: () => Model,
-  event: () => event,
-  get: () => get,
-  has: () => has,
-  ref: () => ref,
-  set: () => set,
-  use: () => use
-});
-module.exports = __toCommonJS(index_exports);
+Object.defineProperty(exports, '__esModule', { value: true });
 
-// src/control.ts
-var Observable = Symbol("observe");
-var onReady = () => null;
-var LISTENERS = /* @__PURE__ */ new WeakMap();
-var PENDING = /* @__PURE__ */ new WeakMap();
-var PENDING_KEYS = /* @__PURE__ */ new WeakMap();
-var DISPATCH = /* @__PURE__ */ new Set();
+//#region src/observable.ts
+const Observable = Symbol("observe");
+/** Placeholder event determines if state is initialized or not. */
+const onReady = () => null;
+const LISTENERS = /* @__PURE__ */ new WeakMap();
+/** Events pending for a given object. */
+const PENDING = /* @__PURE__ */ new WeakMap();
+/** Update register. */
+const PENDING_KEYS = /* @__PURE__ */ new WeakMap();
+/** Central event dispatch. Bunches all updates to occur at same time. */
+const DISPATCH = /* @__PURE__ */ new Set();
 function addListener(subject, callback, select) {
-  let listeners = LISTENERS.get(subject);
-  if (!listeners)
-    LISTENERS.set(subject, listeners = /* @__PURE__ */ new Map([[onReady, void 0]]));
-  if (select !== void 0 && !(select instanceof Set))
-    select = /* @__PURE__ */ new Set([select]);
-  if (!listeners.has(onReady) && !select)
-    callback.call(subject, true, subject);
-  listeners.set(callback, select);
-  return () => listeners.delete(callback);
+	let listeners = LISTENERS.get(subject);
+	if (!listeners) LISTENERS.set(subject, listeners = new Map([[onReady, void 0]]));
+	if (select !== void 0 && !(select instanceof Set)) select = new Set([select]);
+	if (!listeners.has(onReady) && !select) callback.call(subject, true, subject);
+	listeners.set(callback, select);
+	return () => listeners.delete(callback);
 }
-function emit(model, key2) {
-  const listeners = LISTENERS.get(model);
-  const notReady = listeners.has(onReady);
-  if (key2 === true && !notReady)
-    return;
-  let pending = PENDING.get(model);
-  if (pending) {
-    pending.add(key2);
-    return;
-  }
-  PENDING.set(model, pending = new Set(notReady ? [true, key2] : [key2]));
-  for (const key3 of pending)
-    for (const [callback, filter] of listeners)
-      if (!filter || filter.has(key3)) {
-        const after = callback.call(model, key3, model);
-        if (after)
-          enqueue(after);
-        else if (after === null)
-          listeners.delete(callback);
-      }
-  if (key2 === null)
-    listeners.clear();
-  PENDING.delete(model);
+function emit(state, key) {
+	const listeners = LISTENERS.get(state);
+	const notReady = listeners.has(onReady);
+	if (key === true && !notReady) return;
+	let pending = PENDING.get(state);
+	if (pending) {
+		pending.add(key);
+		return;
+	}
+	PENDING.set(state, pending = new Set(notReady ? [true, key] : [key]));
+	for (const key of pending) for (const [callback, filter] of listeners) if (!filter || filter.has(key)) {
+		const after = callback.call(state, key, state);
+		if (after) enqueue(after);
+		else if (after === null) listeners.delete(callback);
+	}
+	if (key === null) listeners.clear();
+	PENDING.delete(state);
 }
-function event(subject, key2, silent) {
-  if (key2 === null)
-    return emit(subject, key2);
-  if (!key2)
-    return emit(subject, true);
-  let pending = PENDING_KEYS.get(subject);
-  if (!pending) {
-    PENDING_KEYS.set(subject, pending = /* @__PURE__ */ new Set());
-    if (!silent)
-      enqueue(() => {
-        emit(subject, false);
-        PENDING_KEYS.delete(subject);
-      });
-  }
-  pending.add(key2);
-  if (!silent)
-    emit(subject, key2);
+function event(subject, key, silent) {
+	if (key === null) return emit(subject, key);
+	if (!key) return emit(subject, true);
+	let pending = PENDING_KEYS.get(subject);
+	if (!pending) {
+		PENDING_KEYS.set(subject, pending = /* @__PURE__ */ new Set());
+		if (!silent) enqueue(() => {
+			emit(subject, false);
+			PENDING_KEYS.delete(subject);
+		});
+	}
+	pending.add(key);
+	if (!silent) emit(subject, key);
 }
 function enqueue(eventHandler) {
-  if (!DISPATCH.size)
-    setTimeout(() => {
-      DISPATCH.forEach((event2) => {
-        try {
-          event2();
-        } catch (err) {
-          console.error(err);
-        }
-      });
-      DISPATCH.clear();
-    }, 0);
-  DISPATCH.add(eventHandler);
+	if (!DISPATCH.size) setTimeout(() => {
+		DISPATCH.forEach((event) => {
+			try {
+				event();
+			} catch (err) {
+				console.error(err);
+			}
+		});
+		DISPATCH.clear();
+	}, 0);
+	DISPATCH.add(eventHandler);
 }
-function createEffect(target, callback, argument) {
-  let unset;
-  let reset;
-  function invoke() {
-    let ignore = true;
-    function onUpdate() {
-      if (ignore || reset === null)
-        return;
-      ignore = true;
-      if (reset && unset) {
-        unset(true);
-        unset = void 0;
-      }
-      enqueue(invoke);
-      return { then: enqueue };
-    }
-    try {
-      const exit = enter(argument === false);
-      const output = callback(target[Observable](onUpdate, argument === true));
-      const flush = exit();
-      ignore = false;
-      reset = output === null ? null : invoke;
-      unset = (key2) => {
-        if (typeof output == "function")
-          output(key2);
-        flush();
-      };
-    } catch (err) {
-      if (err instanceof Promise) {
-        reset = void 0;
-        err.then(invoke);
-      } else
-        throw err;
-    }
-  }
-  function cleanup() {
-    if (unset)
-      unset(false);
-    reset = null;
-  }
-  ;
-  if (EffectContext && argument !== false)
-    EffectContext.add(cleanup);
-  addListener(target, (key2) => {
-    if (key2 === true)
-      invoke();
-    else if (!reset)
-      return reset;
-    if (key2 === null && unset)
-      unset(null);
-  });
-  return cleanup;
+function watch(target, callback, argument) {
+	let unset;
+	let reset;
+	function invoke() {
+		let ignore = true;
+		function onUpdate() {
+			if (ignore || reset === null) return;
+			ignore = true;
+			if (reset && unset) {
+				unset(true);
+				unset = void 0;
+			}
+			enqueue(invoke);
+			return { then: enqueue };
+		}
+		try {
+			const exit = argument === false ? void 0 : scope();
+			const output = callback(target[Observable](onUpdate, argument === true));
+			const flush = exit ? exit() : () => {};
+			ignore = false;
+			reset = output === null ? null : invoke;
+			unset = (key) => {
+				if (typeof output == "function") output(key);
+				flush();
+			};
+		} catch (err) {
+			if (err instanceof Promise) {
+				reset = void 0;
+				err.then(invoke);
+			} else throw err;
+		}
+	}
+	function cleanup() {
+		if (unset) unset(false);
+		reset = null;
+	}
+	if (EffectContext && argument !== false) EffectContext.add(cleanup);
+	addListener(target, (key) => {
+		if (key === true) invoke();
+		else if (!reset) return reset;
+		if (key === null && unset) unset(null);
+	});
+	return cleanup;
 }
-var EffectContext;
-function enter(ignore) {
-  if (ignore)
-    return () => () => {
-    };
-  const last = EffectContext;
-  const context = EffectContext = /* @__PURE__ */ new Set();
-  return () => {
-    EffectContext = last;
-    return () => context.forEach((fn) => fn());
-  };
+let EffectContext;
+function scope() {
+	const last = EffectContext;
+	const context = EffectContext = /* @__PURE__ */ new Set();
+	return () => {
+		EffectContext = last;
+		return () => context.forEach((fn) => fn());
+	};
 }
 
-// src/model.ts
-var define = Object.defineProperty;
-var ID = /* @__PURE__ */ new WeakMap();
-var STATE = /* @__PURE__ */ new WeakMap();
-var NOTIFY = /* @__PURE__ */ new WeakMap();
-var PARENT = /* @__PURE__ */ new WeakMap();
-var METHODS = /* @__PURE__ */ new WeakMap();
-var METHOD = /* @__PURE__ */ new WeakMap();
-var Model = class {
-  constructor(...args) {
-    prepare(this);
-    define(this, "is", { value: this });
-    init(this, args);
-  }
-  [Observable](callback, required) {
-    const watch2 = /* @__PURE__ */ new Set();
-    const proxy = Object.create(this);
-    addListener(this, (key2) => {
-      if (watch2.has(key2))
-        callback();
-    });
-    OBSERVER.set(proxy, (key2, value) => {
-      if (value === void 0 && required)
-        throw new Error(`${this}.${key2} is required in this context.`);
-      watch2.add(key2);
-      if (value instanceof Object && Observable in value)
-        return value[Observable](callback, required) || value;
-      return value;
-    });
-    return proxy;
-  }
-  get(arg1, arg2) {
-    const self = this.is;
-    if (typeof arg1 == "function") {
-      const effect = METHOD.get(arg1) || arg1;
-      let pending = /* @__PURE__ */ new Set();
-      return createEffect(self, (proxy) => {
-        const cb = effect.call(proxy, proxy, pending);
-        return cb === null ? null : (update2) => {
-          pending = PENDING_KEYS.get(self);
-          if (typeof cb == "function")
-            cb(update2);
-        };
-      });
-    }
-    return arg1 === void 0 ? snapshot(self) : typeof arg2 == "function" ? addListener(self, arg2, arg1) : arg1 === null ? Object.isFrozen(STATE.get(self)) : fetch(self, arg1, arg2);
-  }
-  set(arg1, arg2, arg3) {
-    const self = this.is;
-    if (typeof arg1 == "function")
-      return addListener(self, (key2) => {
-        if (arg2 === key2 || arg2 === void 0 && typeof key2 == "string")
-          return arg1.call(self, key2, self);
-      });
-    if (arg1 && typeof arg1 == "object")
-      assign(self, arg1, arg2 === true);
-    else if (!arg2)
-      event(self, arg1);
-    else if (arg3)
-      manage(self, arg1, arg2);
-    else
-      update(self, arg1, arg2);
-    const pending = PENDING_KEYS.get(this);
-    if (pending)
-      return {
-        then: (res) => new Promise((res2) => {
-          const remove = addListener(this, (key2) => {
-            if (key2 !== true) {
-              remove();
-              return res2.bind(null, Array.from(pending));
-            }
-          });
-        }).then(res)
-      };
-  }
-  /**
-   * Iterate over managed properties in this instance of Model.
-   * Yeilds the key and current value for each property.
-   */
-  [Symbol.iterator]() {
-    return Object.entries(STATE.get(this.is))[Symbol.iterator]();
-  }
-  /**
-   * Create and activate a new instance of this model.
-   * 
-   * **Important** - Unlike `new this(...)` - this method also activates state.
-   * 
-   * @param args - arguments sent to constructor
-   */
-  static new(...args) {
-    const instance = new this(...args);
-    event(instance);
-    return instance;
-  }
-  /**
-   * Static equivalent of `x instanceof this`.
-   * Determines if provided class is a subtype of this one.
-   * If so, language server will make available all static
-   * methods and properties of this class.
-   */
-  static is(maybe) {
-    return maybe === this || typeof maybe == "function" && maybe.prototype instanceof this;
-  }
-  /**
-   * Register a callback to run when any instance of this Model is updated. 
-   */
-  static on(listener) {
-    let notify = NOTIFY.get(this);
-    if (!notify)
-      NOTIFY.set(this, notify = /* @__PURE__ */ new Set());
-    notify.add(listener);
-    return () => notify.delete(listener);
-  }
+//#endregion
+//#region src/state.ts
+const define = Object.defineProperty;
+/** Register for all active states via string identifiers (usually unique). */
+const ID = /* @__PURE__ */ new WeakMap();
+/** Internal state assigned to states. */
+const STATE = /* @__PURE__ */ new WeakMap();
+/** External listeners for any given State. */
+const NOTIFY = /* @__PURE__ */ new WeakMap();
+/** Parent-child relationships. */
+const PARENT = /* @__PURE__ */ new WeakMap();
+/** List of methods defined by a given type. */
+const METHODS = /* @__PURE__ */ new WeakMap();
+/** Reference bound instance methods to real ones. */
+const METHOD = /* @__PURE__ */ new WeakMap();
+/** Currently accumulating export. Stores real values of placeholder properties such as ref() or child states. */
+let EXPORT;
+var State = class {
+	constructor(...args) {
+		prepare(this);
+		define(this, "is", { value: this });
+		init$1(this, ...args, (x) => x.new && x.new());
+	}
+	[Observable](callback, required) {
+		const watch = /* @__PURE__ */ new Set();
+		const proxy = Object.create(this);
+		addListener(this, (key) => {
+			if (watch.has(key)) callback();
+		});
+		OBSERVER.set(proxy, (key, value) => {
+			if (value === void 0 && required) throw new Error(`${this}.${key} is required in this context.`);
+			watch.add(key);
+			if (value instanceof Object && Observable in value) return value[Observable](callback, required) || value;
+			return value;
+		});
+		return proxy;
+	}
+	get(arg1, arg2) {
+		const self = this.is;
+		if (arg1 === void 0) return values(self);
+		if (typeof arg1 == "function") return effect(self, arg1);
+		if (typeof arg2 == "function") return addListener(self, arg2, arg1);
+		if (arg1 === null) return Object.isFrozen(STATE.get(self));
+		return access(self, arg1, arg2);
+	}
+	set(arg1, arg2, arg3) {
+		const self = this.is;
+		if (typeof arg1 == "function") return addListener(self, (key) => {
+			if (arg2 === key || arg2 === void 0 && typeof key == "string") return arg1.call(self, key, self);
+		});
+		if (arg1 && typeof arg1 == "object") assign(self, arg1, arg2 === true);
+		else if (!arg2) event(self, arg1);
+		else if (arg3) manage(self, arg1, arg2);
+		else update(self, arg1, arg2);
+		const pending = PENDING_KEYS.get(this);
+		if (pending) return { then: (resolve) => new Promise((res) => {
+			const remove = addListener(this, (key) => {
+				if (key !== true) {
+					remove();
+					return () => res(Array.from(pending));
+				}
+			});
+		}).then(resolve) };
+	}
+	/**
+	* Iterate over managed properties in this instance of State.
+	* Yeilds the key and current value for each property.
+	*/
+	[Symbol.iterator]() {
+		return Object.entries(STATE.get(this.is))[Symbol.iterator]();
+	}
+	/**
+	* Create and activate a new instance of this state.
+	*
+	* **Important** - Unlike `new this(...)` - this method also activates state.
+	*
+	* @param args - arguments sent to constructor
+	*/
+	static new(...args) {
+		const instance = new this(...args);
+		event(instance);
+		return instance;
+	}
+	/**
+	* Static equivalent of `x instanceof this`.
+	* Determines if provided class is a subtype of this one.
+	* If so, language server will make available all static
+	* methods and properties of this class.
+	*/
+	static is(maybe) {
+		return maybe === this || typeof maybe == "function" && maybe.prototype instanceof this;
+	}
+	/**
+	* Register a callback to run when any instance of this State is updated.
+	*/
+	static on(listener) {
+		let notify = NOTIFY.get(this);
+		if (!notify) NOTIFY.set(this, notify = /* @__PURE__ */ new Set());
+		notify.add(listener);
+		return () => notify.delete(listener);
+	}
 };
-define(Model.prototype, "toString", {
-  value() {
-    return ID.get(this.is);
-  }
-});
-define(Model, "toString", {
-  value() {
-    return this.name;
-  }
-});
+define(State.prototype, "toString", { value() {
+	return ID.get(this.is);
+} });
+define(State, "toString", { value() {
+	return this.name;
+} });
 function assign(subject, data, silent) {
-  const methods = METHODS.get(subject.constructor);
-  for (const key2 in data) {
-    const bind = methods.get(key2);
-    if (bind)
-      bind.call(subject, data[key2]);
-    else if (key2 in subject && key2 !== "is") {
-      const desc = Object.getOwnPropertyDescriptor(subject, key2);
-      const set2 = desc && desc.set;
-      if (set2)
-        set2.call(subject, data[key2], silent);
-      else
-        subject[key2] = data[key2];
-    }
-  }
+	const methods = METHODS.get(subject.constructor);
+	for (const key in data) {
+		const bind = methods.get(key);
+		if (bind) bind.call(subject, data[key]);
+		else if (key in subject && key !== "is") {
+			const desc = Object.getOwnPropertyDescriptor(subject, key);
+			const set = desc && desc.set;
+			if (set) set.call(subject, data[key], silent);
+			else subject[key] = data[key];
+		}
+	}
 }
-function prepare(model) {
-  let T = model.constructor;
-  if (T === Model)
-    throw new Error("Cannot create base Model.");
-  const chain = [];
-  let keys2 = /* @__PURE__ */ new Map();
-  ID.set(model, `${T}-${uid()}`);
-  while (T.name) {
-    for (const cb of NOTIFY.get(T) || [])
-      addListener(model, cb);
-    if (T === Model) break;
-    else chain.unshift(T);
-    T = Object.getPrototypeOf(T);
-  }
-  for (const type of chain) {
-    if (METHODS.has(type)) {
-      keys2 = METHODS.get(type);
-      continue;
-    }
-    METHODS.set(type, keys2 = new Map(keys2));
-    for (const [key2, { value }] of Object.entries(
-      Object.getOwnPropertyDescriptors(type.prototype)
-    )) {
-      let bind2 = function(original) {
-        const { is } = this;
-        if (is.hasOwnProperty(key2) && !original)
-          return value;
-        const fn = original || value;
-        const bound = fn.bind(is);
-        METHOD.set(bound, fn);
-        define(is, key2, { value: bound, writable: true });
-        return bound;
-      };
-      var bind = bind2;
-      if (!value || key2 == "constructor")
-        continue;
-      keys2.set(key2, bind2);
-      define(type.prototype, key2, { get: bind2, set: bind2 });
-    }
-  }
+/** Apply instructions and inherited event listeners. Ensure class metadata is ready. */
+function prepare(state) {
+	let T = state.constructor;
+	if (T === State) throw new Error("Cannot create base State.");
+	const chain = [];
+	let keys = /* @__PURE__ */ new Map();
+	ID.set(state, `${T}-${uid()}`);
+	while (T.name) {
+		for (const cb of NOTIFY.get(T) || []) addListener(state, cb);
+		if (T === State) break;
+		else chain.unshift(T);
+		T = Object.getPrototypeOf(T);
+	}
+	for (const type of chain) {
+		if (METHODS.has(type)) {
+			keys = METHODS.get(type);
+			continue;
+		}
+		METHODS.set(type, keys = new Map(keys));
+		for (const [key, { value }] of Object.entries(Object.getOwnPropertyDescriptors(type.prototype))) {
+			if (!value || key == "constructor") continue;
+			function bind(original) {
+				const { is } = this;
+				if (is.hasOwnProperty(key) && !original) return value;
+				const fn = original || value;
+				const bound = fn.bind(is);
+				METHOD.set(bound, fn);
+				define(is, key, {
+					value: bound,
+					writable: true
+				});
+				return bound;
+			}
+			keys.set(key, bind);
+			define(type.prototype, key, {
+				get: bind,
+				set: bind
+			});
+		}
+	}
 }
-function init(model, args) {
-  const state = {};
-  STATE.set(model, state);
-  args = args.flat().filter((arg) => {
-    if (typeof arg != "string")
-      return true;
-    ID.set(model, arg);
-  });
-  addListener(model, () => {
-    if (!PARENT.has(model))
-      PARENT.set(model, null);
-    for (const key2 in model) {
-      const desc = Object.getOwnPropertyDescriptor(model, key2);
-      if ("value" in desc)
-        manage(model, key2, desc.value, true);
-    }
-    for (const arg of args) {
-      const use2 = typeof arg == "function" ? arg.call(model, model) : arg;
-      if (use2 instanceof Promise)
-        use2.catch((err) => {
-          console.error(`Async error in constructor for ${model}:`);
-          console.error(err);
-        });
-      else if (typeof use2 == "function")
-        addListener(model, use2, null);
-      else if (typeof use2 == "object")
-        assign(model, use2, true);
-    }
-    addListener(model, () => {
-      for (const [_, value] of model)
-        if (value instanceof Model && PARENT.get(value) === model)
-          value.set(null);
-      Object.freeze(state);
-    }, null);
-    return null;
-  });
+/**
+* Apply state arguemnts, run callbacks and observe properties.
+* Accumulate and handle cleanup events.
+**/
+function init$1(self, ...args) {
+	const state = {};
+	STATE.set(self, state);
+	args = args.flat().filter((arg) => {
+		if (typeof arg == "string") ID.set(self, arg);
+		else return true;
+	});
+	addListener(self, () => {
+		if (!PARENT.has(self)) PARENT.set(self, null);
+		for (const key in self) {
+			const desc = Object.getOwnPropertyDescriptor(self, key);
+			if ("value" in desc) manage(self, key, desc.value, true);
+		}
+		for (const arg of args) {
+			const use = typeof arg == "function" ? arg.call(self, self) : arg;
+			if (use instanceof Promise) use.catch((err) => {
+				console.error(`Async error in constructor for ${self}:`);
+				console.error(err);
+			});
+			else if (Array.isArray(use)) args.push(...use);
+			else if (typeof use == "function") addListener(self, use, null);
+			else if (typeof use == "object") assign(self, use, true);
+		}
+		addListener(self, () => {
+			for (const [_, value] of self) if (value instanceof State && PARENT.get(value) === self) value.set(null);
+			Object.freeze(state);
+		}, null);
+		return null;
+	});
 }
-function manage(target, key2, value, silent) {
-  const state = STATE.get(target);
-  function get2() {
-    return watch(this, key2, state[key2]);
-  }
-  function set2(value2, silent2) {
-    update(target, key2, value2, silent2);
-    if (value2 instanceof Model && !PARENT.has(value2)) {
-      PARENT.set(value2, target);
-      event(value2);
-    }
-  }
-  define(target, key2, { set: set2, get: get2 });
-  set2(value, silent);
+function manage(target, key, value, silent) {
+	const state = STATE.get(target);
+	function get() {
+		return follow(this, key, state[key]);
+	}
+	function set(value, silent) {
+		update(target, key, value, silent);
+		if (value instanceof State && !PARENT.has(value)) {
+			PARENT.set(value, target);
+			event(value);
+		}
+	}
+	define(target, key, {
+		set,
+		get
+	});
+	set(value, silent);
 }
-var OBSERVER = /* @__PURE__ */ new WeakMap();
-function watch(from, key2, value) {
-  const access = OBSERVER.get(from);
-  return access ? access(key2, value) : value;
+function effect(target, fn) {
+	const effect = METHOD.get(fn) || fn;
+	let pending = /* @__PURE__ */ new Set();
+	return watch(target, (proxy) => {
+		const cb = effect.call(proxy, proxy, pending);
+		if (cb === null) return cb;
+		return (update) => {
+			pending = PENDING_KEYS.get(target);
+			if (typeof cb == "function") cb(update);
+		};
+	});
 }
-function fetch(subject, property, required) {
-  const state = STATE.get(subject);
-  if (property in state || required === false) {
-    const value = state[property];
-    if (value !== void 0 || !required)
-      return value;
-  }
-  if (METHODS.get(subject.constructor).has(property))
-    return METHOD.get(subject[property]);
-  const error = new Error(`${subject}.${property} is not yet available.`);
-  const promise = new Promise((resolve, reject) => {
-    addListener(subject, (key2) => {
-      if (key2 === property) {
-        resolve(state[key2]);
-        return null;
-      }
-      if (key2 === null)
-        reject(new Error(`${subject} is destroyed.`));
-    });
-  });
-  throw Object.assign(promise, {
-    toString: () => String(error),
-    name: "Suspense",
-    message: error.message,
-    stack: error.stack
-  });
+function values(target) {
+	const values = {};
+	let isNotRecursive;
+	if (!EXPORT) {
+		isNotRecursive = true;
+		EXPORT = new Map([[target, values]]);
+	}
+	for (let [key, value] of target) {
+		if (EXPORT.has(value)) value = EXPORT.get(value);
+		else if (value && typeof value == "object" && "get" in value && typeof value.get === "function") EXPORT.set(value, value = value.get());
+		values[key] = value;
+	}
+	if (isNotRecursive) EXPORT = void 0;
+	return Object.freeze(values);
 }
-var EXPORT;
-function snapshot(model) {
-  const values = {};
-  let isNotRecursive;
-  if (!EXPORT) {
-    isNotRecursive = true;
-    EXPORT = /* @__PURE__ */ new Map([[model, values]]);
-  }
-  for (let [key2, value] of model) {
-    if (EXPORT.has(value))
-      value = EXPORT.get(value);
-    else if (value && typeof value == "object" && "get" in value && typeof value.get === "function")
-      EXPORT.set(value, value = value.get());
-    values[key2] = value;
-  }
-  if (isNotRecursive)
-    EXPORT = void 0;
-  return Object.freeze(values);
+const OBSERVER = /* @__PURE__ */ new WeakMap();
+function follow(from, key, value) {
+	const observe = OBSERVER.get(from);
+	return observe ? observe(key, value) : value;
 }
-function update(subject, key2, value, arg) {
-  const state = STATE.get(subject);
-  if (Object.isFrozen(state))
-    throw new Error(`Tried to update ${subject}.${String(key2)} but model is destroyed.`);
-  const previous = state[key2];
-  if (typeof arg == "function") {
-    const out = arg.call(subject, value, previous);
-    if (out === false)
-      return false;
-    if (typeof out == "function")
-      value = out();
-  }
-  if (value === previous && key2 in state)
-    return;
-  state[key2] = value;
-  if (arg !== true)
-    event(subject, key2);
-  return true;
+function access(subject, property, required) {
+	const state = STATE.get(subject);
+	if (property in state || required === false) {
+		const value = state[property];
+		if (value !== void 0 || !required) return value;
+	}
+	if (METHODS.get(subject.constructor).has(property)) return METHOD.get(subject[property]);
+	const error = /* @__PURE__ */ new Error(`${subject}.${property} is not yet available.`);
+	const promise = new Promise((resolve, reject) => {
+		addListener(subject, (key) => {
+			if (key === property) {
+				resolve(state[key]);
+				return null;
+			}
+			if (key === null) reject(/* @__PURE__ */ new Error(`${subject} is destroyed.`));
+		});
+	});
+	throw Object.assign(promise, {
+		toString: () => String(error),
+		name: "Suspense",
+		message: error.message,
+		stack: error.stack
+	});
 }
-function uid() {
-  return (0.278 + Math.random() * 0.722).toString(36).substring(2, 8).toUpperCase();
+function update(subject, key, value, arg) {
+	const state = STATE.get(subject);
+	if (Object.isFrozen(state)) throw new Error(`Tried to update ${subject}.${String(key)} but state is destroyed.`);
+	const previous = state[key];
+	if (typeof arg == "function") {
+		const out = arg.call(subject, value, previous);
+		if (out === false) return false;
+		if (typeof out == "function") value = out();
+	}
+	if (value === previous && key in state) return;
+	state[key] = value;
+	if (arg !== true) event(subject, key);
+	return true;
 }
-
-// src/context.ts
-var LOOKUP = /* @__PURE__ */ new WeakMap();
-var KEYS = /* @__PURE__ */ new Map();
-function key(T, upstream) {
-  let K = KEYS.get(T);
-  if (!K)
-    KEYS.set(T, K = Symbol(
-      typeof T == "symbol" ? "get " + T.description : String(T)
-    ));
-  return upstream ? key(K) : K;
-}
-function keys(from, upstream) {
-  const keys2 = /* @__PURE__ */ new Set();
-  do {
-    keys2.add(key(from, upstream));
-  } while ((from = Object.getPrototypeOf(from)) !== Model);
-  return keys2;
+/** Random alphanumberic of length 6; always starts with a letter. */
+function uid() {
+	return (.278 + Math.random() * .722).toString(36).substring(2, 8).toUpperCase();
 }
-var Context = class _Context {
-  constructor(inputs) {
-    this.layer = /* @__PURE__ */ new Map();
-    this.cleanup = /* @__PURE__ */ new Set();
-    if (inputs)
-      this.include(inputs);
-  }
-  static get({ is }, callback) {
-    const waiting = LOOKUP.get(is);
-    if (waiting instanceof _Context) {
-      if (callback)
-        callback(waiting);
-      return waiting;
-    }
-    if (callback)
-      if (waiting)
-        waiting.push(callback);
-      else
-        LOOKUP.set(is, [callback]);
-  }
-  /** Run callback when a specified type is registered to a **child** context. */
-  has(Type, callback) {
-    Object.defineProperty(this, key(Type, true), { value: callback, configurable: true });
-  }
-  get(Type, require2) {
-    const result = this[key(Type)];
-    if (result === null)
-      throw new Error(`Did find ${Type} in context, but multiple were defined.`);
-    if (result)
-      return result;
-    if (require2)
-      throw new Error(`Could not find ${Type} in context.`);
-  }
-  push(inputs) {
-    const next = Object.create(this);
-    this.cleanup = /* @__PURE__ */ new Set([() => next.pop(), ...this.cleanup]);
-    next.layer = /* @__PURE__ */ new Map();
-    next.cleanup = /* @__PURE__ */ new Set();
-    if (inputs)
-      next.include(inputs);
-    return next;
-  }
-  pop() {
-    for (const key2 of Object.getOwnPropertySymbols(this))
-      delete this[key2];
-    this.cleanup.forEach((cb) => cb());
-    this.cleanup.clear();
-    this.layer.clear();
-  }
-  include(inputs, forEach) {
-    const init3 = /* @__PURE__ */ new Map();
-    if (typeof inputs == "function" || inputs instanceof Model)
-      inputs = { [forEach ? 0 : this.layer.size]: inputs };
-    for (const [K, V] of Object.entries(inputs)) {
-      if (Model.is(V) || V instanceof Model) {
-        const exists = this.layer.get(K);
-        if (!exists) {
-          const instance = this.add(V);
-          this.layer.set(K, V);
-          init3.set(instance, true);
-        } else if (exists !== V) {
-          this.pop();
-          this.id = uid();
-          this.include(inputs);
-        }
-        continue;
-      }
-      throw new Error(
-        `Context may only include instance or class \`extends Model\` but got ${K == "0" || K == String(V) ? V : `${V} (as '${K}')`}.`
-      );
-    }
-    for (const [model, explicit] of init3) {
-      model.set();
-      if (explicit && forEach)
-        forEach(model);
-      for (const [_key, value] of model)
-        if (PARENT.get(value) === model) {
-          this.add(value, true);
-          init3.set(value, false);
-        }
-    }
-  }
-  add(input, implicit) {
-    const cleanup = /* @__PURE__ */ new Set();
-    let T;
-    let I;
-    if (typeof input == "function") {
-      T = input;
-      I = new input();
-    } else {
-      T = input.constructor;
-      I = input;
-    }
-    keys(T, true).forEach((K) => {
-      const expects = this[K];
-      if (!expects)
-        return;
-      addListener(I, (event2) => {
-        if (event2 === true) {
-          const callback = expects(I);
-          if (callback)
-            cleanup.add(callback);
-        }
-        return null;
-      });
-    });
-    keys(T).forEach((K) => {
-      const value = this.hasOwnProperty(K) ? null : I;
-      if (value || this[K] !== I && !implicit)
-        Object.defineProperty(this, K, {
-          configurable: true,
-          value
-        });
-    });
-    this.cleanup.add(() => {
-      cleanup.forEach((cb) => cb());
-      if (I !== input)
-        event(I, null);
-    });
-    const waiting = LOOKUP.get(I);
-    if (waiting instanceof Array)
-      waiting.forEach((cb) => cb(this));
-    LOOKUP.set(I, this);
-    return I;
-  }
-};
 
-// src/instruction/use.ts
-var INSTRUCTION = /* @__PURE__ */ new Map();
+//#endregion
+//#region src/instruction/use.ts
+const INSTRUCTION = /* @__PURE__ */ new Map();
 function use(arg1, arg2) {
-  if (Model.is(arg1))
-    arg1 = childInstruction(arg1, arg2);
-  const token = Symbol("instruction-" + uid());
-  INSTRUCTION.set(token, arg1);
-  return token;
+	if (State.is(arg1)) arg1 = childInstruction(arg1, arg2);
+	const token = Symbol("instruction-" + uid());
+	INSTRUCTION.set(token, arg1);
+	return token;
 }
 function childInstruction(type, arg2) {
-  return (key2, subject) => {
-    function set2(next) {
-      if (next ? !(next instanceof type) : arg2 !== false)
-        throw new Error(`${subject}.${key2} expected Model of type ${type} but got ${next && next.constructor}.`);
-      update(subject, key2, next);
-      if (next && typeof arg2 == "function")
-        arg2(next);
-      return false;
-    }
-    const value = new type();
-    set2(value);
-    PARENT.set(value, subject);
-    value.set();
-    return { set: set2 };
-  };
+	return (key, subject) => {
+		function set(next) {
+			if (next ? !(next instanceof type) : arg2 !== false) throw new Error(`${subject}.${key} expected State of type ${type} but got ${next && next.constructor}.`);
+			update(subject, key, next);
+			if (next && typeof arg2 == "function") arg2(next);
+			return false;
+		}
+		const value = new type();
+		set(value);
+		PARENT.set(value, subject);
+		value.set();
+		return { set };
+	};
 }
-function init2() {
-  const state = STATE.get(this);
-  for (const key2 in this) {
-    const { value } = Object.getOwnPropertyDescriptor(this, key2);
-    const instruction = INSTRUCTION.get(value);
-    if (!instruction)
-      continue;
-    INSTRUCTION.delete(value);
-    delete this[key2];
-    const output = instruction.call(this, key2, this, state);
-    if (!output)
-      continue;
-    const desc = typeof output == "object" ? output : { get: output };
-    if ("value" in desc)
-      state[key2] = desc.value;
-    const model = this;
-    Object.defineProperty(model, key2, {
-      enumerable: desc.enumerable !== false,
-      get() {
-        return watch(
-          this,
-          key2,
-          typeof desc.get == "function" ? desc.get(this) : fetch(model, key2, desc.get)
-        );
-      },
-      set(next) {
-        if (desc.set === false)
-          throw new Error(`${model}.${key2} is read-only.`);
-        update(model, key2, next, desc.set);
-      }
-    });
-  }
-  return null;
+function init() {
+	const state = STATE.get(this);
+	for (const key in this) {
+		const { value } = Object.getOwnPropertyDescriptor(this, key);
+		const instruction = INSTRUCTION.get(value);
+		if (!instruction) continue;
+		INSTRUCTION.delete(value);
+		delete this[key];
+		const output = instruction.call(this, key, this, state);
+		if (!output) continue;
+		const desc = typeof output == "object" ? output : { get: output };
+		if ("value" in desc) state[key] = desc.value;
+		const self = this;
+		Object.defineProperty(self, key, {
+			enumerable: desc.enumerable !== false,
+			get() {
+				return follow(this, key, typeof desc.get == "function" ? desc.get(this) : access(self, key, desc.get));
+			},
+			set(next) {
+				if (desc.set === false) throw new Error(`${self}.${key} is read-only.`);
+				update(self, key, next, desc.set);
+			}
+		});
+	}
+	return null;
 }
-Model.on(init2);
+State.on(init);
 
-// src/instruction/get.ts
-var STALE = /* @__PURE__ */ new WeakSet();
-function get(arg0, arg1) {
-  return use((key2, subject, state) => {
-    if (typeof arg0 == "symbol")
-      throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key2}. This is not allowed.`);
-    if (Model.is(arg0)) {
-      let assign3 = function(value) {
-        if (typeof arg1 == "function")
-          value.get((x) => arg1(x, key2));
-        update(subject, key2, value);
-      };
-      var assign2 = assign3;
-      const hasParent = PARENT.get(subject);
-      if (!hasParent && arg1 === true)
-        throw new Error(`${subject} may only exist as a child of type ${arg0}.`);
-      else if (hasParent) {
-        if (hasParent instanceof arg0) {
-          assign3(hasParent);
-          return {};
-        } else if (arg1 === true)
-          throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
-      }
-      Context.get(subject, (context) => {
-        const model = context.get(arg0);
-        if (model)
-          assign3(model);
-        else if (arg1 !== false)
-          throw new Error(`Required ${arg0} not found in context for ${subject}.`);
-      });
-      return {
-        get: arg1 !== false,
-        enumerable: false
-      };
-    }
-    let from = subject;
-    if (arg0 instanceof Model) {
-      from = arg0;
-    } else {
-      const fn = METHOD.get(arg0) || arg0;
-      arg1 = (p, k) => fn.call(p, k, p);
-    }
-    const source = (resolve) => resolve(from);
-    const getter = arg1;
-    let reset;
-    let isAsync;
-    let proxy;
-    function connect(model) {
-      reset = createEffect(model, (current) => {
-        proxy = current;
-        if (!(key2 in state) || STALE.delete(compute))
-          compute(!reset);
-        return (didUpdate) => {
-          if (didUpdate) {
-            STALE.add(compute);
-            event(subject, key2, true);
-          }
-        };
-      }, false);
-    }
-    function compute(initial) {
-      let next;
-      try {
-        next = getter.call(proxy, proxy, key2);
-      } catch (err) {
-        console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key2}.`);
-        if (initial)
-          throw err;
-        console.error(err);
-      }
-      update(subject, key2, next, !isAsync);
-    }
-    return () => {
-      if (!proxy) {
-        source(connect);
-        isAsync = true;
-      }
-      if (STALE.delete(compute))
-        compute();
-      return fetch(subject, key2, !proxy);
-    };
-  });
+//#endregion
+//#region src/context.ts
+const LOOKUP = /* @__PURE__ */ new WeakMap();
+const KEYS = /* @__PURE__ */ new Map();
+function key(T, upstream) {
+	let K = KEYS.get(T);
+	if (!K) {
+		K = Symbol(typeof T == "symbol" ? "get " + T.description : String(T));
+		KEYS.set(T, K);
+	}
+	return upstream ? key(K) : K;
 }
+function keys(from, upstream) {
+	const keys = /* @__PURE__ */ new Set();
+	do {
+		keys.add(key(from, upstream));
+		from = Object.getPrototypeOf(from);
+	} while (from !== State);
+	return keys;
+}
+var Context = class Context {
+	static get({ is }, callback) {
+		const context = LOOKUP.get(is);
+		if (context instanceof Context) {
+			if (callback) callback(context);
+			return context;
+		}
+		if (callback) if (context) context.push(callback);
+		else LOOKUP.set(is, [callback]);
+	}
+	constructor(inputs) {
+		this.id = uid();
+		this.inputs = {};
+		this.cleanup = /* @__PURE__ */ new Set();
+		if (inputs) this.use(inputs);
+	}
+	get(Type, arg2) {
+		if (typeof arg2 == "function") {
+			const k = key(Type, true);
+			Object.defineProperty(this, k, {
+				value: arg2,
+				configurable: true
+			});
+			return () => {
+				delete this[k];
+			};
+		}
+		const result = this[key(Type)];
+		if (result === null) throw new Error(`Did find ${Type} in context, but multiple were defined.`);
+		if (result) return result;
+		if (arg2) throw new Error(`Could not find ${Type} in context.`);
+	}
+	/**
+	* Adds a State to this context.
+	*/
+	add(input, implicit) {
+		const cleanup = /* @__PURE__ */ new Set();
+		let T;
+		let I;
+		if (typeof input == "function") {
+			T = input;
+			I = new input();
+		} else {
+			T = input.constructor;
+			I = input;
+		}
+		keys(T, true).forEach((K) => {
+			const expects = this[K];
+			if (expects) addListener(I, (event) => {
+				if (event === true) {
+					const cb = expects(I);
+					if (cb) cleanup.add(cb);
+				}
+				return null;
+			});
+		});
+		keys(T).forEach((K) => {
+			const value = this.hasOwnProperty(K) ? null : I;
+			if (value || this[K] !== I && !implicit) Object.defineProperty(this, K, {
+				configurable: true,
+				value
+			});
+		});
+		this.cleanup.add(() => {
+			cleanup.forEach((cb) => cb());
+			if (I !== input) event(I, null);
+		});
+		const waiting = LOOKUP.get(I);
+		if (waiting instanceof Array) waiting.forEach((cb) => cb(this));
+		LOOKUP.set(I, this);
+		return I;
+	}
+	/**
+	* Register one or more States to this context.
+	*
+	* Context will add or remove States as needed to keep with provided input.
+	*
+	* @param inputs State, State class, or map of States / State classes to register.
+	* @param forEach Optional callback to run for each State registered.
+	*/
+	use(inputs, forEach) {
+		const init = /* @__PURE__ */ new Map();
+		if (typeof inputs == "function" || inputs instanceof State) inputs = { [0]: inputs };
+		for (const [K, V] of Object.entries(inputs)) {
+			if (!(State.is(V) || V instanceof State)) throw new Error(`Context may only include instance or class \`extends State\` but got ${K == "0" || K == String(V) ? V : `${V} (as '${K}')`}.`);
+			const exists = this.inputs[K];
+			if (!exists) init.set(this.add(V), true);
+			else if (exists !== V) {
+				this.pop();
+				this.use(inputs);
+				this.id = uid();
+				return;
+			}
+		}
+		for (const [state, explicit] of init) {
+			state.set();
+			if (explicit && forEach) forEach(state);
+			for (const [_key, value] of state) if (PARENT.get(value) === state) {
+				this.add(value, true);
+				init.set(value, false);
+			}
+		}
+		this.inputs = inputs;
+	}
+	/**
+	* Create a child context, optionally registering one or more States to it.
+	*
+	* @param inputs State, State class, or map of States / State classes to register.
+	*/
+	push(inputs) {
+		const next = Object.create(this);
+		this.cleanup = new Set([() => next.pop(), ...this.cleanup]);
+		next.inputs = {};
+		next.cleanup = /* @__PURE__ */ new Set();
+		if (inputs) next.use(inputs);
+		return next;
+	}
+	/**
+	* Remove all States from this context.
+	*
+	* Will also run any cleanup callbacks registered when States were added.
+	*/
+	pop() {
+		for (const key of Object.getOwnPropertySymbols(this)) delete this[key];
+		this.cleanup.forEach((cb) => cb());
+		this.cleanup.clear();
+		this.inputs = {};
+	}
+};
+Object.defineProperty(Context.prototype, "toString", { value() {
+	return `Context-${this.id}`;
+} });
 
-// src/instruction/ref.ts
-var { defineProperty, defineProperties } = Object;
-function ref(arg, arg2) {
-  return use((key2, subject, state) => {
-    let value = {};
-    const method = (key3, from) => (callback) => callback ? addListener(subject, () => callback(from[key3]), key3) : from[key3];
-    if (arg === subject)
-      addListener(subject, () => {
-        for (const key3 in subject)
-          if (typeof arg2 == "function")
-            defineProperty(value, key3, {
-              configurable: true,
-              get() {
-                const out = arg2(key3);
-                defineProperty(value, key3, { value: out });
-                return out;
-              }
-            });
-          else {
-            const get2 = method(key3, subject);
-            const set2 = (x) => subject[key3] = x;
-            defineProperties(set2, {
-              current: { get: get2, set: set2 },
-              get: { value: get2 },
-              is: { value: subject },
-              key: { value: key3 }
-            });
-            defineProperty(value, key3, { value: set2 });
-          }
-        return null;
-      }, true);
-    else if (typeof arg == "object")
-      throw new Error("ref instruction does not support object which is not 'this'");
-    else {
-      let unset;
-      const get2 = method(key2, state);
-      const set2 = (value2) => {
-        if (!update(subject, key2, value2) || !arg)
-          return;
-        if (unset)
-          unset = void unset(value2);
-        if (value2 === null && arg2 !== false)
-          return;
-        const exit = enter();
-        const out = arg.call(subject, value2);
-        const flush = exit();
-        unset = (key3) => {
-          if (typeof out == "function")
-            out(key3);
-          flush();
-        };
-      };
-      state[key2] = null;
-      value = defineProperties({ get: get2, key: key2, is: subject }, {
-        current: { get: get2, set: set2 }
-      });
-    }
-    defineProperty(subject, key2, { value });
-  });
+//#endregion
+//#region src/instruction/get.ts
+function get(Type, arg1, arg2) {
+	const isDownstream = arg1 === true;
+	const isOptional = arg1 === false;
+	return use((key, subject) => {
+		if (isDownstream) {
+			const callback = typeof arg2 === "function" ? arg2 : void 0;
+			const applied = /* @__PURE__ */ new Set();
+			const reset = () => {
+				update(subject, key, Object.freeze(Array.from(applied)));
+			};
+			Context.get(subject, (context) => {
+				context.get(Type, (state) => {
+					let remove;
+					let flush;
+					if (applied.has(state)) return;
+					if (callback) {
+						const exit = scope();
+						try {
+							const done = callback(state, subject);
+							if (done === false) return false;
+							if (typeof done == "function") remove = done;
+						} finally {
+							flush = exit();
+						}
+					}
+					applied.add(state);
+					reset();
+					const done = () => {
+						if (flush) flush();
+						ignore();
+						applied.delete(state);
+						reset();
+						if (typeof remove == "function") remove();
+						remove = void 0;
+					};
+					const ignore = state.set(done, null);
+					return done;
+				});
+			});
+			return {
+				value: [],
+				enumerable: false
+			};
+		}
+		const hasParent = PARENT.get(subject);
+		function assign(value) {
+			if (typeof arg1 === "function") {
+				const result = arg1(value, subject);
+				if (typeof result === "function") subject.set(result, null);
+			}
+			update(subject, key, value);
+		}
+		if (hasParent && hasParent instanceof Type) {
+			assign(hasParent);
+			return {};
+		}
+		Context.get(subject, (context) => {
+			const self = context.get(Type);
+			if (self) assign(self);
+			else if (!isOptional) throw new Error(`Required ${Type} not found in context for ${subject}.`);
+		});
+		return {
+			get: !isOptional,
+			enumerable: false
+		};
+	});
 }
 
-// src/instruction/set.ts
+//#endregion
+//#region src/instruction/set.ts
+const STALE = /* @__PURE__ */ new WeakSet();
 function set(value, argument) {
-  return use((key2, subject) => {
-    const property = {};
-    if (typeof value == "function" || isThenable(value)) {
-      let init4 = function() {
-        if (typeof value == "function")
-          try {
-            value = attempt(value.bind(subject, key2));
-          } catch (err) {
-            console.warn(`Generating initial value for ${subject}.${key2} failed.`);
-            throw err;
-          }
-        property.get = argument !== false;
-        const set2 = (value2) => subject[key2] = value2;
-        if (isThenable(value))
-          value.then(set2, (error) => {
-            event(subject, key2);
-            property.get = () => {
-              throw error;
-            };
-          });
-        else
-          set2(value);
-        if (argument)
-          return null;
-        return subject[key2];
-      };
-      var init3 = init4;
-      if (argument)
-        addListener(subject, init4, true);
-      else
-        property.get = init4;
-    } else if (value !== void 0)
-      property.value = value;
-    if (typeof argument == "function") {
-      let unset;
-      property.set = function(value2, previous) {
-        const exit = enter();
-        const returns = argument.call(this, value2, previous);
-        const flush = exit();
-        if (returns === false)
-          return false;
-        if (typeof unset == "function")
-          unset(value2);
-        unset = (next) => {
-          if (typeof returns == "function")
-            returns(next);
-          flush();
-        };
-      };
-    } else
-      property.set = (value2) => {
-        property.get = void 0;
-        update(subject, key2, value2);
-      };
-    return property;
-  });
+	return use((key, subject, state) => {
+		if (typeof value == "symbol") throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key}. This is not allowed.`);
+		const property = {};
+		if (value instanceof State || value === true) {
+			let from = subject;
+			let getter;
+			if (value instanceof State) {
+				from = value;
+				getter = argument;
+			} else {
+				const fn = METHOD.get(argument) || argument;
+				getter = ((p, k) => fn.call(p, k, p));
+			}
+			const source = (resolve) => resolve(from);
+			let reset;
+			let isAsync;
+			let proxy;
+			function connect(self) {
+				reset = watch(self, (current) => {
+					proxy = current;
+					if (!(key in state) || STALE.delete(compute)) compute(!reset);
+					return (didUpdate) => {
+						if (didUpdate) {
+							STALE.add(compute);
+							event(subject, key, true);
+						}
+					};
+				}, false);
+			}
+			function compute(initial) {
+				let next;
+				try {
+					next = getter.call(proxy, proxy, key);
+				} catch (err) {
+					console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
+					if (initial) throw err;
+					console.error(err);
+				}
+				update(subject, key, next, !isAsync);
+			}
+			return () => {
+				if (!proxy) {
+					source(connect);
+					isAsync = true;
+				}
+				if (STALE.delete(compute)) compute();
+				return access(subject, key, !proxy);
+			};
+		}
+		if (typeof value == "function" || value instanceof Promise) {
+			function init() {
+				if (typeof value == "function") try {
+					value = attempt(value.bind(subject, key));
+				} catch (err) {
+					console.warn(`Generating initial value for ${subject}.${key} failed.`);
+					throw err;
+				}
+				property.get = argument !== false;
+				const set = (value) => subject[key] = value;
+				if (value instanceof Promise) value.then(set, (error) => {
+					event(subject, key);
+					property.get = () => {
+						throw error;
+					};
+				});
+				else set(value);
+				if (argument) return null;
+				return subject[key];
+			}
+			if (argument) addListener(subject, init, true);
+			else property.get = init;
+		} else if (value !== void 0) property.value = value;
+		if (typeof argument == "function") {
+			let unset;
+			property.set = function(value, previous) {
+				const exit = scope();
+				const returns = argument.call(this, value, previous);
+				const flush = exit();
+				if (returns === false) return false;
+				if (typeof unset == "function") unset(value);
+				unset = (next) => {
+					if (typeof returns == "function") returns(next);
+					flush();
+				};
+			};
+		} else property.set = (value) => {
+			property.get = void 0;
+			update(subject, key, value);
+		};
+		return property;
+	});
 }
 function attempt(fn) {
-  function retry(err) {
-    if (err instanceof Promise)
-      return err.then(compute);
-    else
-      throw err;
-  }
-  function compute() {
-    try {
-      const output = fn();
-      return output instanceof Promise ? output.catch(retry) : output;
-    } catch (err) {
-      return retry(err);
-    }
-  }
-  return compute();
-}
-function isThenable(value) {
-  return value && typeof value == "object" && typeof value.then == "function";
+	function retry(err) {
+		if (err instanceof Promise) return err.then(compute);
+		else throw err;
+	}
+	function compute() {
+		try {
+			const output = fn();
+			return output instanceof Promise ? output.catch(retry) : output;
+		} catch (err) {
+			return retry(err);
+		}
+	}
+	return compute();
 }
 
-// src/instruction/has.ts
-var APPLY = /* @__PURE__ */ new WeakMap();
-function has(arg1, arg2) {
-  return use((key2, subject) => {
-    const applied = /* @__PURE__ */ new Set();
-    const reset = () => {
-      update(subject, key2, Object.freeze(Array.from(applied)));
-    };
-    if (Model.is(arg1))
-      Context.get(subject, (ctx) => {
-        ctx.has(arg1, (model) => {
-          let remove;
-          let disconnect;
-          let flush;
-          if (applied.has(model))
-            return;
-          const exit = enter();
-          try {
-            const notify = APPLY.get(model);
-            if (notify) {
-              const after = notify(subject);
-              if (after === false)
-                return;
-              if (typeof after == "function")
-                disconnect = after;
-            }
-            if (typeof arg2 == "function") {
-              const done2 = arg2(model, subject);
-              if (done2 === false)
-                return false;
-              if (typeof done2 == "function")
-                remove = done2;
-            }
-          } finally {
-            flush = exit();
-          }
-          applied.add(model);
-          reset();
-          const done = () => {
-            flush();
-            ignore();
-            applied.delete(model);
-            reset();
-            if (disconnect)
-              disconnect();
-            if (typeof remove == "function")
-              remove();
-            remove = void 0;
-          };
-          const ignore = model.set(done, null);
-          return done;
-        });
-      });
-    else {
-      if (APPLY.has(subject))
-        throw new Error(`'has' callback can only be used once per model.`);
-      APPLY.set(subject, (recipient) => {
-        let remove;
-        if (arg1) {
-          remove = arg1(recipient, subject);
-          if (remove === false)
-            return false;
-        }
-        applied.add(recipient);
-        reset();
-        return () => {
-          applied.delete(recipient);
-          reset();
-          if (typeof remove == "function")
-            remove();
-        };
-      });
-    }
-    return {
-      value: [],
-      enumerable: false
-    };
-  });
+//#endregion
+//#region src/instruction/ref.ts
+const { defineProperty, defineProperties } = Object;
+function ref(arg, arg2) {
+	return use((key, subject, state) => {
+		let value = {};
+		const method = (key, from) => (callback) => callback ? addListener(subject, () => callback(from[key]), key) : from[key];
+		if (arg === subject) addListener(subject, () => {
+			for (const key in subject) if (typeof arg2 == "function") defineProperty(value, key, {
+				configurable: true,
+				get() {
+					const out = arg2(key);
+					defineProperty(value, key, { value: out });
+					return out;
+				}
+			});
+			else {
+				const get = method(key, subject);
+				const set = (x) => subject[key] = x;
+				defineProperties(set, {
+					current: {
+						get,
+						set
+					},
+					get: { value: get },
+					is: { value: subject },
+					key: { value: key }
+				});
+				defineProperty(value, key, { value: set });
+			}
+			return null;
+		}, true);
+		else if (typeof arg == "object") throw new Error("ref instruction does not support object which is not 'this'");
+		else {
+			let unset;
+			const get = method(key, state);
+			const set = (value) => {
+				if (!update(subject, key, value) || !arg) return;
+				if (unset) unset = void unset(value);
+				if (value === null && arg2 !== false) return;
+				const exit = scope();
+				const out = arg.call(subject, value);
+				const flush = exit();
+				unset = (key) => {
+					if (typeof out == "function") out(key);
+					flush();
+				};
+			};
+			state[key] = null;
+			value = defineProperty({
+				get,
+				key,
+				is: subject
+			}, "current", {
+				get,
+				set
+			});
+		}
+		defineProperty(subject, key, { value });
+	});
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Context,
-  METHOD,
-  Model,
-  Observable,
-  addListener,
-  createEffect,
-  event,
-  get,
-  has,
-  ref,
-  set,
-  use
-});
+
+//#endregion
+exports.Context = Context;
+exports.METHOD = METHOD;
+exports.Observable = Observable;
+exports.State = State;
+exports.addListener = addListener;
+exports.default = State;
+exports.event = event;
+exports.get = get;
+exports.ref = ref;
+exports.set = set;
+exports.use = use;
+exports.watch = watch;
 //# sourceMappingURL=index.js.map