@expressive/mvc 0.70.0 → 0.72.0

package/dist/index.js

@@ -22,17 +22,16 @@ var index_exports = {};
 __export(index_exports, {
   Context: () => Context,
   METHOD: () => METHOD,
-  Model: () => Model,
   Observable: () => Observable,
+  State: () => State,
   addListener: () => addListener,
-  createEffect: () => createEffect,
-  default: () => Model,
+  default: () => State,
   event: () => event,
   get: () => get,
-  has: () => has,
   ref: () => ref,
   set: () => set,
-  use: () => use
+  use: () => use,
+  watch: () => watch
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -49,40 +48,38 @@ function addListener(subject, callback, select) {
     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)
+  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);
+function emit(state, key2) {
+  const listeners = LISTENERS.get(state);
   const notReady = listeners.has(onReady);
-  if (key2 === true && !notReady)
-    return;
-  let pending = PENDING.get(model);
+  if (key2 === true && !notReady) return;
+  let pending = PENDING.get(state);
   if (pending) {
     pending.add(key2);
     return;
   }
-  PENDING.set(model, pending = new Set(notReady ? [true, key2] : [key2]));
+  PENDING.set(state, 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)
+        const after = callback.call(state, key3, state);
+        if (after) {
           enqueue(after);
-        else if (after === null)
+        } else if (after === null) {
           listeners.delete(callback);
+        }
       }
-  if (key2 === null)
-    listeners.clear();
-  PENDING.delete(model);
+  if (key2 === null) listeners.clear();
+  PENDING.delete(state);
 }
 function event(subject, key2, silent) {
-  if (key2 === null)
-    return emit(subject, key2);
-  if (!key2)
-    return emit(subject, true);
+  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());
@@ -93,8 +90,7 @@ function event(subject, key2, silent) {
       });
   }
   pending.add(key2);
-  if (!silent)
-    emit(subject, key2);
+  if (!silent) emit(subject, key2);
 }
 function enqueue(eventHandler) {
   if (!DISPATCH.size)
@@ -110,14 +106,13 @@ function enqueue(eventHandler) {
     }, 0);
   DISPATCH.add(eventHandler);
 }
-function createEffect(target, callback, argument) {
+function watch(target, callback, argument) {
   let unset;
   let reset;
   function invoke() {
     let ignore = true;
     function onUpdate() {
-      if (ignore || reset === null)
-        return;
+      if (ignore || reset === null) return;
       ignore = true;
       if (reset && unset) {
         unset(true);
@@ -133,41 +128,34 @@ function createEffect(target, callback, argument) {
       ignore = false;
       reset = output === null ? null : invoke;
       unset = (key2) => {
-        if (typeof output == "function")
-          output(key2);
+        if (typeof output == "function") output(key2);
         flush();
       };
     } catch (err) {
       if (err instanceof Promise) {
         reset = void 0;
         err.then(invoke);
-      } else
+      } else {
         throw err;
+      }
     }
   }
   function cleanup() {
-    if (unset)
-      unset(false);
+    if (unset) unset(false);
     reset = null;
   }
-  ;
-  if (EffectContext && argument !== false)
-    EffectContext.add(cleanup);
+  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);
+    if (key2 === true) invoke();
+    else if (!reset) return reset;
+    if (key2 === null && unset) unset(null);
   });
   return cleanup;
 }
 var EffectContext;
 function enter(ignore) {
-  if (ignore)
-    return () => () => {
-    };
+  if (ignore) return () => () => {
+  };
   const last = EffectContext;
   const context = EffectContext = /* @__PURE__ */ new Set();
   return () => {
@@ -176,7 +164,7 @@ function enter(ignore) {
   };
 }
 
-// src/model.ts
+// src/state.ts
 var define = Object.defineProperty;
 var ID = /* @__PURE__ */ new WeakMap();
 var STATE = /* @__PURE__ */ new WeakMap();
@@ -184,7 +172,8 @@ var NOTIFY = /* @__PURE__ */ new WeakMap();
 var PARENT = /* @__PURE__ */ new WeakMap();
 var METHODS = /* @__PURE__ */ new WeakMap();
 var METHOD = /* @__PURE__ */ new WeakMap();
-var Model = class {
+var EXPORT;
+var State = class {
   constructor(...args) {
     prepare(this);
     define(this, "is", { value: this });
@@ -194,8 +183,7 @@ var Model = class {
     const watch2 = /* @__PURE__ */ new Set();
     const proxy = Object.create(this);
     addListener(this, (key2) => {
-      if (watch2.has(key2))
-        callback();
+      if (watch2.has(key2)) callback();
     });
     OBSERVER.set(proxy, (key2, value) => {
       if (value === void 0 && required)
@@ -209,19 +197,11 @@ var Model = class {
   }
   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);
+    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;
@@ -230,14 +210,15 @@ var Model = class {
         if (arg2 === key2 || arg2 === void 0 && typeof key2 == "string")
           return arg1.call(self, key2, self);
       });
-    if (arg1 && typeof arg1 == "object")
+    if (arg1 && typeof arg1 == "object") {
       assign(self, arg1, arg2 === true);
-    else if (!arg2)
+    } else if (!arg2) {
       event(self, arg1);
-    else if (arg3)
+    } else if (arg3) {
       manage(self, arg1, arg2);
-    else
+    } else {
       update(self, arg1, arg2);
+    }
     const pending = PENDING_KEYS.get(this);
     if (pending)
       return {
@@ -252,21 +233,24 @@ var Model = class {
       };
   }
   /**
-   * Iterate over managed properties in this instance of Model.
+   * 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 model.
-   * 
+   * 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);
+    const instance = new this(...args, (x) => {
+      const cb = x.new && x.new();
+      if (cb) x.set(cb, null);
+    });
     event(instance);
     return instance;
   }
@@ -280,22 +264,21 @@ var Model = class {
     return maybe === this || typeof maybe == "function" && maybe.prototype instanceof this;
   }
   /**
-   * Register a callback to run when any instance of this Model is updated. 
+   * 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());
+    if (!notify) NOTIFY.set(this, notify = /* @__PURE__ */ new Set());
     notify.add(listener);
     return () => notify.delete(listener);
   }
 };
-define(Model.prototype, "toString", {
+define(State.prototype, "toString", {
   value() {
     return ID.get(this.is);
   }
 });
-define(Model, "toString", {
+define(State, "toString", {
   value() {
     return this.name;
   }
@@ -304,29 +287,29 @@ 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]);
+    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)
+      if (set2) {
         set2.call(subject, data[key2], silent);
-      else
+      } else {
         subject[key2] = data[key2];
+      }
     }
   }
 }
-function prepare(model) {
-  let T = model.constructor;
-  if (T === Model)
-    throw new Error("Cannot create base Model.");
+function prepare(state) {
+  let T = state.constructor;
+  if (T === State) throw new Error("Cannot create base State.");
   const chain = [];
   let keys2 = /* @__PURE__ */ new Map();
-  ID.set(model, `${T}-${uid()}`);
+  ID.set(state, `${T}-${uid()}`);
   while (T.name) {
-    for (const cb of NOTIFY.get(T) || [])
-      addListener(model, cb);
-    if (T === Model) break;
+    for (const cb of NOTIFY.get(T) || []) {
+      addListener(state, cb);
+    }
+    if (T === State) break;
     else chain.unshift(T);
     T = Object.getPrototypeOf(T);
   }
@@ -341,8 +324,7 @@ function prepare(model) {
     )) {
       let bind2 = function(original) {
         const { is } = this;
-        if (is.hasOwnProperty(key2) && !original)
-          return value;
+        if (is.hasOwnProperty(key2) && !original) return value;
         const fn = original || value;
         const bound = fn.bind(is);
         METHOD.set(bound, fn);
@@ -350,58 +332,85 @@ function prepare(model) {
         return bound;
       };
       var bind = bind2;
-      if (!value || key2 == "constructor")
-        continue;
+      if (!value || key2 == "constructor") continue;
       keys2.set(key2, bind2);
       define(type.prototype, key2, { get: bind2, set: bind2 });
     }
   }
 }
-function init(model, args) {
+function init(self, args) {
   const state = {};
-  STATE.set(model, state);
+  STATE.set(self, state);
   args = args.flat().filter((arg) => {
-    if (typeof arg != "string")
-      return true;
-    ID.set(model, arg);
+    if (typeof arg == "string") ID.set(self, arg);
+    else return true;
   });
-  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);
+  addListener(self, () => {
+    if (!PARENT.has(self)) PARENT.set(self, null);
+    for (const key2 in self) {
+      const desc = Object.getOwnPropertyDescriptor(self, key2);
+      if ("value" in desc) manage(self, key2, desc.value, true);
     }
     for (const arg of args) {
-      const use2 = typeof arg == "function" ? arg.call(model, model) : arg;
+      const use2 = typeof arg == "function" ? arg.call(self, self) : arg;
       if (use2 instanceof Promise)
         use2.catch((err) => {
-          console.error(`Async error in constructor for ${model}:`);
+          console.error(`Async error in constructor for ${self}:`);
           console.error(err);
         });
-      else if (typeof use2 == "function")
-        addListener(model, use2, null);
-      else if (typeof use2 == "object")
-        assign(model, use2, true);
+      else if (Array.isArray(use2)) args.push(...use2);
+      else if (typeof use2 == "function") addListener(self, use2, null);
+      else if (typeof use2 == "object") assign(self, use2, true);
     }
-    addListener(model, () => {
-      for (const [_, value] of model)
-        if (value instanceof Model && PARENT.get(value) === model)
-          value.set(null);
-      Object.freeze(state);
-    }, null);
+    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 effect(target, fn) {
+  const effect2 = METHOD.get(fn) || fn;
+  let pending = /* @__PURE__ */ new Set();
+  return watch(target, (proxy) => {
+    const cb = effect2.call(proxy, proxy, pending);
+    if (cb === null) return cb;
+    return (update2) => {
+      pending = PENDING_KEYS.get(target);
+      if (typeof cb == "function") cb(update2);
+    };
+  });
+}
+function values(target) {
+  const values2 = {};
+  let isNotRecursive;
+  if (!EXPORT) {
+    isNotRecursive = true;
+    EXPORT = /* @__PURE__ */ new Map([[target, values2]]);
+  }
+  for (let [key2, 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());
+    values2[key2] = value;
+  }
+  if (isNotRecursive) EXPORT = void 0;
+  return Object.freeze(values2);
+}
 function manage(target, key2, value, silent) {
   const state = STATE.get(target);
   function get2() {
-    return watch(this, key2, state[key2]);
+    return follow(this, key2, state[key2]);
   }
   function set2(value2, silent2) {
     update(target, key2, value2, silent2);
-    if (value2 instanceof Model && !PARENT.has(value2)) {
+    if (value2 instanceof State && !PARENT.has(value2)) {
       PARENT.set(value2, target);
       event(value2);
     }
@@ -410,16 +419,15 @@ function manage(target, key2, value, silent) {
   set2(value, silent);
 }
 var OBSERVER = /* @__PURE__ */ new WeakMap();
-function watch(from, key2, value) {
-  const access = OBSERVER.get(from);
-  return access ? access(key2, value) : value;
+function follow(from, key2, value) {
+  const observe = OBSERVER.get(from);
+  return observe ? observe(key2, value) : value;
 }
-function fetch(subject, property, required) {
+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 (value !== void 0 || !required) return value;
   }
   if (METHODS.get(subject.constructor).has(property))
     return METHOD.get(subject[property]);
@@ -430,8 +438,9 @@ function fetch(subject, property, required) {
         resolve(state[key2]);
         return null;
       }
-      if (key2 === null)
+      if (key2 === null) {
         reject(new Error(`${subject} is destroyed.`));
+      }
     });
   });
   throw Object.assign(promise, {
@@ -441,148 +450,145 @@ function fetch(subject, property, required) {
     stack: error.stack
   });
 }
-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);
-}
 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.`);
+    throw new Error(
+      `Tried to update ${subject}.${String(key2)} but state 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 (out === false) return false;
+    if (typeof out == "function") value = out();
   }
-  if (value === previous && key2 in state)
-    return;
+  if (value === previous && key2 in state) return;
   state[key2] = value;
-  if (arg !== true)
-    event(subject, key2);
+  if (arg !== true) event(subject, key2);
   return true;
 }
 function uid() {
   return (0.278 + Math.random() * 0.722).toString(36).substring(2, 8).toUpperCase();
 }
 
+// src/instruction/use.ts
+var INSTRUCTION = /* @__PURE__ */ new Map();
+function use(arg1, arg2) {
+  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 State 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 };
+  };
+}
+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 self = this;
+    Object.defineProperty(self, key2, {
+      enumerable: desc.enumerable !== false,
+      get() {
+        return follow(
+          this,
+          key2,
+          typeof desc.get == "function" ? desc.get(this) : access(self, key2, desc.get)
+        );
+      },
+      set(next) {
+        if (desc.set === false) {
+          throw new Error(`${self}.${key2} is read-only.`);
+        }
+        update(self, key2, next, desc.set);
+      }
+    });
+  }
+  return null;
+}
+State.on(init2);
+
 // 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)
-    ));
+  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 keys2 = /* @__PURE__ */ new Set();
   do {
     keys2.add(key(from, upstream));
-  } while ((from = Object.getPrototypeOf(from)) !== Model);
+    from = Object.getPrototypeOf(from);
+  } while (from !== State);
   return keys2;
 }
 var Context = class _Context {
   constructor(inputs) {
-    this.layer = /* @__PURE__ */ new Map();
+    this.id = uid();
+    this.inputs = {};
     this.cleanup = /* @__PURE__ */ new Set();
-    if (inputs)
-      this.include(inputs);
+    if (inputs) this.use(inputs);
   }
   static get({ is }, callback) {
-    const waiting = LOOKUP.get(is);
-    if (waiting instanceof _Context) {
-      if (callback)
-        callback(waiting);
-      return waiting;
+    const context = LOOKUP.get(is);
+    if (context instanceof _Context) {
+      if (callback) callback(context);
+      return context;
     }
     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) {
+      if (context) context.push(callback);
+      else LOOKUP.set(is, [callback]);
+  }
+  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 (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 };
-    Object.entries(inputs).forEach(([K, V]) => {
-      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);
-        }
-        return;
-      }
       throw new Error(
-        `Context may only include instance or class \`extends Model\` but got ${K == "0" || K == V ? V : `${V} (as '${K}')`}.`
+        `Did find ${Type} in context, but multiple were defined.`
       );
-    });
-    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);
-        }
-    }
+    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;
@@ -596,16 +602,14 @@ var Context = class _Context {
     }
     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;
-      });
+      if (expects)
+        addListener(I, (event2) => {
+          if (event2 === true) {
+            const cb = expects(I);
+            if (cb) cleanup.add(cb);
+          }
+          return null;
+        });
     });
     keys(T).forEach((K) => {
       const value = this.hasOwnProperty(K) ? null : I;
@@ -617,272 +621,261 @@ var Context = class _Context {
     });
     this.cleanup.add(() => {
       cleanup.forEach((cb) => cb());
-      if (I !== input)
-        event(I, null);
+      if (I !== input) event(I, null);
     });
     const waiting = LOOKUP.get(I);
-    if (waiting instanceof Array)
-      waiting.forEach((cb) => cb(this));
+    if (waiting instanceof Array) waiting.forEach((cb) => cb(this));
     LOOKUP.set(I, this);
     return I;
   }
-};
-
-// src/instruction/use.ts
-var 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;
-}
-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 };
-  };
-}
-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)
+  /**
+   * 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 init3 = /* @__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}')`}.`
         );
-      },
-      set(next) {
-        if (desc.set === false)
-          throw new Error(`${model}.${key2} is read-only.`);
-        update(model, key2, next, desc.set);
+      const exists = this.inputs[K];
+      if (!exists) {
+        init3.set(this.add(V), true);
+      } else if (exists !== V) {
+        this.pop();
+        this.use(inputs);
+        this.id = uid();
+        return;
       }
-    });
+    }
+    for (const [state, explicit] of init3) {
+      state.set();
+      if (explicit && forEach) forEach(state);
+      for (const [_key, value] of state)
+        if (PARENT.get(value) === state) {
+          this.add(value, true);
+          init3.set(value, false);
+        }
+    }
+    this.inputs = inputs;
   }
-  return null;
-}
-Model.on(init2);
+  /**
+   * 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 = /* @__PURE__ */ 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 key2 of Object.getOwnPropertySymbols(this)) delete this[key2];
+    this.cleanup.forEach((cb) => cb());
+    this.cleanup.clear();
+    this.inputs = {};
+  }
+};
+Object.defineProperty(Context.prototype, "toString", {
+  value() {
+    return `Context-${this.id}`;
+  }
+});
 
 // 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);
+function get(Type, arg1, arg2) {
+  const isDownstream = arg1 === true;
+  const isOptional = arg1 === false;
+  return use((key2, subject) => {
+    if (isDownstream) {
+      const callback = typeof arg2 === "function" ? arg2 : void 0;
+      const applied = /* @__PURE__ */ new Set();
+      const reset = () => {
+        update(subject, key2, Object.freeze(Array.from(applied)));
       };
-      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}.`);
+        context.get(Type, (state) => {
+          let remove;
+          let flush;
+          if (applied.has(state)) return;
+          if (callback) {
+            const exit = enter();
+            try {
+              const done2 = callback(state, subject);
+              if (done2 === false) return false;
+              if (typeof done2 == "function") remove = done2;
+            } 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 {
-        get: arg1 !== false,
+        value: [],
         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);
+    const hasParent = PARENT.get(subject);
+    function assign2(value) {
+      if (typeof arg1 === "function") {
+        const callback = arg1;
+        const result = callback(value, subject);
+        if (typeof result === "function") {
+          subject.set(result, null);
+        }
       }
-      update(subject, key2, next, !isAsync);
+      update(subject, key2, value);
     }
-    return () => {
-      if (!proxy) {
-        source(connect);
-        isAsync = true;
-      }
-      if (STALE.delete(compute))
-        compute();
-      return fetch(subject, key2, !proxy);
+    if (hasParent && hasParent instanceof Type) {
+      assign2(hasParent);
+      return {};
+    }
+    Context.get(subject, (context) => {
+      const self = context.get(Type);
+      if (self) assign2(self);
+      else if (!isOptional)
+        throw new Error(
+          `Required ${Type} not found in context for ${subject}.`
+        );
+    });
+    return {
+      get: !isOptional,
+      enumerable: false
     };
   });
 }
 
-// src/instruction/ref.ts
-var { defineProperty, defineProperties } = Object;
-function ref(arg, arg2) {
+// src/instruction/set.ts
+var STALE = /* @__PURE__ */ new WeakSet();
+function set(value, argument) {
   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;
+    if (typeof value == "symbol")
+      throw new Error(
+        `Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key2}. This is not allowed.`
+      );
+    const property = {};
+    if (value instanceof State || value === true) {
+      let connect2 = function(self) {
+        reset = watch(
+          self,
+          (current) => {
+            proxy = current;
+            if (!(key2 in state) || STALE.delete(compute2)) compute2(!reset);
+            return (didUpdate) => {
+              if (didUpdate) {
+                STALE.add(compute2);
+                event(subject, key2, true);
               }
-            });
-          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();
-        };
+            };
+          },
+          false
+        );
+      }, compute2 = function(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);
+      };
+      var connect = connect2, compute = compute2;
+      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;
+      return () => {
+        if (!proxy) {
+          source(connect2);
+          isAsync = true;
+        }
+        if (STALE.delete(compute2)) compute2();
+        return access(subject, key2, !proxy);
       };
-      state[key2] = null;
-      value = defineProperties({ get: get2, key: key2, is: subject }, {
-        current: { get: get2, set: set2 }
-      });
     }
-    defineProperty(subject, key2, { value });
-  });
-}
-
-// src/instruction/set.ts
-function set(value, argument) {
-  return use((key2, subject) => {
-    const property = {};
-    if (typeof value == "function" || isThenable(value)) {
+    if (typeof value == "function" || value instanceof Promise) {
       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.`);
+            console.warn(
+              `Generating initial value for ${subject}.${key2} failed.`
+            );
             throw err;
           }
         property.get = argument !== false;
         const set2 = (value2) => subject[key2] = value2;
-        if (isThenable(value))
+        if (value instanceof Promise)
           value.then(set2, (error) => {
             event(subject, key2);
             property.get = () => {
               throw error;
             };
           });
-        else
-          set2(value);
-        if (argument)
-          return null;
+        else set2(value);
+        if (argument) return null;
         return subject[key2];
       };
       var init3 = init4;
-      if (argument)
+      if (argument) {
         addListener(subject, init4, true);
-      else
+      } else {
         property.get = init4;
-    } else if (value !== void 0)
+      }
+    } 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);
+        if (returns === false) return false;
+        if (typeof unset == "function") unset(value2);
         unset = (next) => {
-          if (typeof returns == "function")
-            returns(next);
+          if (typeof returns == "function") returns(next);
           flush();
         };
       };
@@ -896,10 +889,8 @@ function set(value, argument) {
 }
 function attempt(fn) {
   function retry(err) {
-    if (err instanceof Promise)
-      return err.then(compute);
-    else
-      throw err;
+    if (err instanceof Promise) return err.then(compute);
+    else throw err;
   }
   function compute() {
     try {
@@ -911,102 +902,82 @@ function attempt(fn) {
   }
   return compute();
 }
-function isThenable(value) {
-  return value && typeof value == "object" && typeof value.then == "function";
-}
 
-// 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;
+// 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 });
             }
-          } 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;
-        });
-      });
+          return null;
+        },
+        true
+      );
+    else if (typeof arg == "object")
+      throw new Error(
+        "ref instruction does not support object which is not 'this'"
+      );
     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();
+      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 = defineProperty({ get: get2, key: key2, is: subject }, "current", {
+        get: get2,
+        set: set2
       });
     }
-    return {
-      value: [],
-      enumerable: false
-    };
+    defineProperty(subject, key2, { value });
   });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Context,
   METHOD,
-  Model,
   Observable,
+  State,
   addListener,
-  createEffect,
   event,
   get,
-  has,
   ref,
   set,
-  use
+  use,
+  watch
 });
 //# sourceMappingURL=index.js.map