@expressive/mvc 0.52.1 → 0.53.0

package/dist/index.js

@@ -22,8 +22,10 @@ var src_exports = {};
 __export(src_exports, {
   Context: () => Context,
   Model: () => Model,
+  addListener: () => addListener,
+  createEffect: () => createEffect,
+  createProxy: () => createProxy,
   default: () => Model,
-  effect: () => effect,
   get: () => get,
   has: () => has,
   ref: () => ref,
@@ -33,73 +35,108 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/control.ts
+var onReady = () => null;
+var LISTENERS = /* @__PURE__ */ new WeakMap();
+var PENDING = /* @__PURE__ */ new WeakMap();
+var PENDING_KEYS = /* @__PURE__ */ new WeakMap();
 var DISPATCH = /* @__PURE__ */ new Set();
 var OBSERVER = /* @__PURE__ */ new WeakMap();
-var LISTENER = /* @__PURE__ */ new WeakMap();
-var onReady = () => null;
 function addListener(subject, callback, select) {
-  let subs = LISTENER.get(subject);
-  if (!subs)
-    LISTENER.set(subject, subs = /* @__PURE__ */ new Map([[onReady, false]]));
-  const filter = select !== void 0 && /* @__PURE__ */ new Set([select]);
-  if (!subs.has(onReady) && !filter)
-    callback(true, subject);
-  subs.set(callback, filter);
-  return () => subs.delete(callback);
-}
-function watch(from, key2, value) {
-  const access = OBSERVER.get(from);
-  return access ? access(from, key2, value) : value;
+  let listeners = LISTENERS.get(subject);
+  if (!listeners)
+    LISTENERS.set(subject, listeners = /* @__PURE__ */ new Map([[onReady, void 0]]));
+  const filter = select === void 0 ? void 0 : /* @__PURE__ */ new Set([select]);
+  if (!listeners.has(onReady) && !filter)
+    callback.call(subject, true, subject);
+  listeners.set(callback, filter);
+  return () => listeners.delete(callback);
 }
-var PENDING = /* @__PURE__ */ new WeakMap();
-function emit(source, key2) {
-  const subs = LISTENER.get(source);
-  const ready = !subs.has(onReady);
-  if (key2 === true && ready)
+function emit(model, key2) {
+  const listeners = LISTENERS.get(model);
+  const notReady = listeners.has(onReady);
+  if (key2 === true && !notReady)
     return;
-  let pending = PENDING.get(source);
-  if (pending) {
-    pending.add(key2);
+  let pending2 = PENDING.get(model);
+  if (pending2) {
+    pending2.add(key2);
     return;
   }
-  PENDING.set(source, pending = new Set(
-    key2 !== true && ready ? [key2] : [true, key2]
-  ));
-  pending.forEach((key3) => {
-    pending.delete(key3);
-    subs.forEach((select, callback) => {
-      let after;
-      if (!select || select.has(key3)) {
-        if (after = callback.call(source, key3, source))
-          queue(after);
+  PENDING.set(model, pending2 = new Set(notReady ? [true, key2] : [key2]));
+  for (const key3 of pending2)
+    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 (after === null || key3 === null)
-        subs.delete(callback);
-    });
-  });
-  PENDING.delete(source);
+  if (key2 === null)
+    listeners.clear();
+  PENDING.delete(model);
+}
+function event(subject, key2, silent) {
+  if (key2 === null)
+    return emit(subject, key2);
+  if (!key2)
+    return emit(subject, true);
+  let pending2 = PENDING_KEYS.get(subject);
+  if (!pending2) {
+    PENDING_KEYS.set(subject, pending2 = /* @__PURE__ */ new Set());
+    if (!silent)
+      enqueue(() => {
+        emit(subject, false);
+        PENDING_KEYS.delete(subject);
+      });
+  }
+  pending2.add(key2);
+  if (!silent)
+    emit(subject, key2);
 }
-function queue(event2) {
+function pending(subject) {
+  if (PENDING_KEYS.has(subject))
+    return {
+      then: (res) => new Promise((res2) => {
+        const remove = addListener(subject, (key2) => {
+          if (key2 !== true) {
+            remove();
+            return res2.bind(null, Array.from(PENDING_KEYS.get(subject)));
+          }
+        });
+      }).then(res)
+    };
+}
+function enqueue(eventHandler) {
   if (!DISPATCH.size)
     setTimeout(() => {
-      DISPATCH.forEach((event3) => {
+      DISPATCH.forEach((event2) => {
         try {
-          event3();
+          event2();
         } catch (err) {
           console.error(err);
         }
       });
       DISPATCH.clear();
     }, 0);
-  DISPATCH.add(event2);
+  DISPATCH.add(eventHandler);
+}
+function createProxy(from, observer) {
+  const proxy = Object.create(from);
+  OBSERVER.set(proxy, observer);
+  return proxy;
+}
+function watch(from, key2, value) {
+  const access = OBSERVER.get(from);
+  return access ? access(from, key2, value) : value;
 }
-function effect(target, callback, requireValues) {
-  const listeners = LISTENER.get(target);
+function createEffect(target, callback, requireValues) {
+  const listeners = LISTENERS.get(target);
   let unset;
   let reset;
   function invoke() {
     let stale;
-    const subscriber = Object.create(target);
+    const subscriber = createProxy(target, access);
+    LISTENERS.set(subscriber, listeners);
     function onUpdate() {
       if (stale)
         return null;
@@ -113,20 +150,19 @@ function effect(target, callback, requireValues) {
     function access(from, key2, value) {
       if (value === void 0 && requireValues)
         throw new Error(`${from}.${key2} is required in this context.`);
-      const listeners2 = LISTENER.get(from);
+      const listeners2 = LISTENERS.get(from);
       let listener = listeners2.get(onUpdate);
       if (!listener)
         listeners2.set(onUpdate, listener = /* @__PURE__ */ new Set());
       listener.add(key2);
-      const nested = LISTENER.get(value);
-      if (nested) {
-        LISTENER.set(value = Object.create(value), nested);
-        OBSERVER.set(value, access);
-      }
+      const nested = LISTENERS.get(value);
+      if (nested)
+        LISTENERS.set(
+          value = createProxy(value, access),
+          nested
+        );
       return value;
     }
-    LISTENER.set(subscriber, listeners);
-    OBSERVER.set(subscriber, access);
     try {
       const out = callback.call(subscriber, subscriber);
       unset = typeof out == "function" ? out : void 0;
@@ -159,80 +195,55 @@ var define = Object.defineProperty;
 var ID = /* @__PURE__ */ new WeakMap();
 var STATE = /* @__PURE__ */ new WeakMap();
 var NOTIFY = /* @__PURE__ */ new WeakMap();
-var PENDING2 = /* @__PURE__ */ new WeakMap();
 var PARENT = /* @__PURE__ */ new WeakMap();
 var METHODS = /* @__PURE__ */ new WeakMap();
 var METHOD = /* @__PURE__ */ new WeakMap();
-var EXPORT;
-var Model = class _Model {
+var Model = class {
   constructor(...args) {
-    define(this, "is", { value: this });
-    ID.set(this, `${this.constructor}-${uid()}`);
-    STATE.set(this, {});
     prepare(this);
+    define(this, "is", { value: this });
     init(this, args);
   }
   get(arg1, arg2) {
     const self = this.is;
-    if (arg1 === void 0)
-      return values(self);
     if (typeof arg1 == "function") {
-      let pending = /* @__PURE__ */ new Set();
-      return effect(self, (state) => {
-        const cb = arg1.call(state, state, pending);
+      let pending2 = /* @__PURE__ */ new Set();
+      return createEffect(self, (proxy) => {
+        const cb = arg1.call(proxy, proxy, pending2);
         return cb === null ? cb : (update2) => {
-          pending = PENDING2.get(self);
+          pending2 = PENDING_KEYS.get(self);
           if (typeof cb == "function")
-            return cb(update2);
+            cb(update2);
         };
       });
     }
-    if (typeof arg2 == "function") {
-      if (arg1 === null)
-        return addListener(self, arg2.bind(this, this), null);
-      const state = STATE.get(self);
-      if (arg1 in state)
-        arg2.call(this, state[arg1], arg1, this);
-      return addListener(self, () => {
-        arg2.call(this, arg1 in state ? state[arg1] : arg1, arg1, this);
-      }, arg1);
-    }
+    if (arg1 === void 0)
+      return snapshot(self);
+    if (typeof arg2 == "function")
+      return addListener(self, arg2, arg1);
     return arg1 === null ? Object.isFrozen(STATE.get(self)) : fetch(self, arg1, arg2);
   }
-  set(arg1, arg2, arg3) {
+  set(arg1, arg2) {
     const self = this.is;
     if (typeof arg1 == "function")
       return addListener(self, (key2) => {
         if (typeof key2 == "string")
           return arg1.call(self, key2, self);
       });
-    if (arg1 === null) {
-      emit(this, null);
-      return;
-    }
-    if (typeof arg1 == "object")
-      assign(self, arg1);
-    else if (arg1 == void 0)
-      emit(this, true);
-    else if (1 in arguments)
-      update(self, arg1, arg2, arg3);
-    else
+    if (arg1 && typeof arg1 == "object") {
+      const methods = METHODS.get(self.constructor);
+      for (const key2 in arg1)
+        if (methods.has(key2))
+          self[key2] = arg1[key2];
+        else if (key2 in self)
+          update(self, key2, arg1[key2], arg2 === true);
+    } else
       event(self, arg1);
-    if (PENDING2.has(self))
-      return {
-        then: (res) => new Promise((res2) => {
-          const remove = addListener(self, (key2) => {
-            if (key2 !== true) {
-              remove();
-              return res2.bind(null, Array.from(PENDING2.get(self)));
-            }
-          });
-        }).then(res)
-      };
+    return pending(self);
   }
   /**
    * Iterate over managed properties in this instance of Model.
-   * Yeilds the key and underlying value for each property.
+   * Yeilds the key and current value for each property.
    */
   [Symbol.iterator]() {
     return Object.entries(STATE.get(this.is))[Symbol.iterator]();
@@ -245,9 +256,8 @@ var Model = class _Model {
    * @param args - arguments sent to constructor
    */
   static new(...args) {
-    _Model.is(this);
     const instance = new this(...args);
-    emit(instance, true);
+    event(instance);
     return instance;
   }
   /**
@@ -257,9 +267,7 @@ var Model = class _Model {
    * methods and properties of this class.
    */
   static is(maybe) {
-    if (maybe === _Model)
-      throw new Error("Model is abstract and not a valid type.");
-    return typeof maybe == "function" && maybe.prototype instanceof this;
+    return maybe === this || typeof maybe == "function" && maybe.prototype instanceof this;
   }
   /**
    * Register a callback to run when any instance of this Model is updated. 
@@ -283,48 +291,48 @@ define(Model, "toString", {
   }
 });
 function prepare(model) {
+  let T = model.constructor;
+  if (T === Model)
+    throw new Error("Cannot create base Model.");
   const chain = [];
-  let type = model.constructor;
   let keys2 = /* @__PURE__ */ new Set();
-  while (type.name) {
-    chain.unshift(type);
-    type = Object.getPrototypeOf(type);
-  }
-  for (const type2 of chain) {
-    for (const cb of NOTIFY.get(type2) || [])
+  ID.set(model, `${T}-${uid()}`);
+  while (T.name) {
+    for (const cb of NOTIFY.get(T) || [])
       addListener(model, cb);
-    if (type2 == Model)
-      continue;
-    if (METHODS.has(type2)) {
-      keys2 = METHODS.get(type2);
+    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(type2, keys2 = new Set(keys2));
+    METHODS.set(type, keys2 = new Set(keys2));
     for (const [key2, { value }] of Object.entries(
-      Object.getOwnPropertyDescriptors(type2.prototype)
+      Object.getOwnPropertyDescriptors(type.prototype)
     )) {
-      let set3 = function(method) {
-        const value2 = method.bind(this.is);
+      let bind2 = function(method = value) {
+        const value2 = method.bind(model);
         METHOD.set(value2, method);
-        define(this.is, key2, { value: value2, writable: true });
+        define(model, key2, { value: value2, writable: true });
         return value2;
       };
-      var set2 = set3;
+      var bind = bind2;
       if (!value || key2 == "constructor")
         continue;
       keys2.add(key2);
-      Object.defineProperty(type2.prototype, key2, {
-        set: set3,
-        get() {
-          return this.hasOwnProperty(key2) ? value : set3.call(this, value);
-        }
-      });
+      define(type.prototype, key2, { get: bind2, set: bind2 });
     }
   }
 }
 function init(model, args) {
-  const done = /* @__PURE__ */ new Set();
-  const state = STATE.get(model);
+  const methods = METHODS.get(model.constructor);
+  const state = {};
+  STATE.set(model, state);
   args = args.flat().filter((arg) => {
     if (typeof arg != "string")
       return true;
@@ -341,9 +349,12 @@ function init(model, args) {
           console.error(err);
         });
       else if (typeof use2 == "function")
-        done.add(use2);
-      else if (typeof use2 == "object")
-        assign(model, use2);
+        addListener(model, use2, null);
+      else if (typeof use2 == "object") {
+        for (const key2 in use2)
+          if (key2 in model || methods.has(key2))
+            model[key2] = use2[key2];
+      }
     });
     for (const key2 in model) {
       const desc = Object.getOwnPropertyDescriptor(model, key2);
@@ -351,22 +362,30 @@ function init(model, args) {
         update(model, key2, desc.value, true);
         define(model, key2, {
           configurable: false,
-          set: (x) => update(model, key2, x),
           get() {
             return watch(this, key2, state[key2]);
+          },
+          set(value) {
+            update(model, key2, value);
+            mayAdopt(model, value);
           }
         });
       }
     }
+    addListener(model, () => {
+      for (const [_, value] of model)
+        if (value instanceof Model && PARENT.get(value) === model)
+          value.set(null);
+      Object.freeze(state);
+    }, null);
     return null;
   });
-  addListener(model, () => {
-    done.forEach((x) => x());
-    for (const [_, value] of model)
-      if (value instanceof Model && PARENT.get(value) === model)
-        value.set(null);
-    Object.freeze(state);
-  }, null);
+}
+function mayAdopt(parent, child) {
+  if (child instanceof Model && !PARENT.has(child)) {
+    PARENT.set(child, parent);
+    event(child);
+  }
 }
 function fetch(subject, property, required) {
   const state = STATE.get(subject);
@@ -393,19 +412,24 @@ function fetch(subject, property, required) {
     stack: error.stack
   });
 }
-function values(model) {
-  const values2 = {};
-  const current = !EXPORT && (EXPORT = /* @__PURE__ */ new Map([[model, values2]]));
+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.get === "function")
+    else if (value && typeof value == "object" && "get" in value && typeof value.get === "function")
       EXPORT.set(value, value = value.get());
-    values2[key2] = value;
+    values[key2] = value;
   }
-  if (current)
+  if (isNotRecursive)
     EXPORT = void 0;
-  return Object.freeze(values2);
+  return Object.freeze(values);
 }
 function update(subject, key2, value, arg) {
   const state = STATE.get(subject);
@@ -420,46 +444,23 @@ function update(subject, key2, value, arg) {
       value = out();
   }
   if (value === previous)
-    return true;
-  if (value instanceof Model && !PARENT.has(value)) {
-    PARENT.set(value, subject);
-    emit(value, true);
-  }
+    return;
   state[key2] = value;
   if (arg !== true)
     event(subject, key2);
-}
-function event(subject, key2, silent) {
-  let pending = PENDING2.get(subject);
-  if (!pending) {
-    PENDING2.set(subject, pending = /* @__PURE__ */ new Set());
-    if (!silent)
-      queue(() => {
-        emit(subject, false);
-        PENDING2.delete(subject);
-      });
-  }
-  pending.add(key2);
-  if (!silent)
-    emit(subject, key2);
-}
-function assign(to, values2) {
-  const methods = METHODS.get(to.constructor);
-  for (const key2 in values2)
-    if (key2 in to || methods.has(key2))
-      to[key2] = values2[key2];
+  return true;
 }
 function uid() {
-  return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
+  return (0.278 + Math.random() * 0.722).toString(36).substring(2, 8).toUpperCase();
 }
 
 // src/context.ts
-var Register = /* @__PURE__ */ new WeakMap();
-var Table = /* @__PURE__ */ new Map();
+var LOOKUP = /* @__PURE__ */ new WeakMap();
+var KEYS = /* @__PURE__ */ new Map();
 function key(T, upstream) {
-  let K = Table.get(T);
+  let K = KEYS.get(T);
   if (!K)
-    Table.set(T, K = Symbol(
+    KEYS.set(T, K = Symbol(
       typeof T == "symbol" ? "get " + T.description : String(T)
     ));
   return upstream ? key(K) : K;
@@ -479,7 +480,7 @@ var Context = class _Context {
       this.include(inputs);
   }
   static get(from, callback) {
-    const waiting = Register.get(from);
+    const waiting = LOOKUP.get(from);
     if (waiting instanceof _Context) {
       if (callback)
         callback(waiting);
@@ -489,11 +490,14 @@ var Context = class _Context {
       if (waiting)
         waiting.push(callback);
       else
-        Register.set(from, [callback]);
+        LOOKUP.set(from, [callback]);
   }
-  get(Type, callback) {
-    if (callback)
-      Object.defineProperty(this, key(Type, true), { value: callback });
+  /** Run callback when a specified type is registered to a **child** context. */
+  has(Type, callback) {
+    define(this, key(Type, true), { value: callback });
+  }
+  /** Find specified type registered to a parent context. Returns undefined if none are found. */
+  get(Type) {
     const result = this[key(Type)];
     if (result === null)
       throw new Error(`Did find ${Type} in context, but multiple were defined.`);
@@ -515,9 +519,16 @@ var Context = class _Context {
   }
   include(inputs, forEach) {
     const init2 = /* @__PURE__ */ new Map();
+    if (typeof inputs == "function" || inputs instanceof Model)
+      inputs = { 0: inputs };
     Object.entries(inputs).forEach(([K, V]) => {
-      if (!(Model.is(V) || V instanceof Model))
-        throw new Error(`Context can only include Model or instance but got ${V}${K && " as " + K}.`);
+      if (Model.is(V) || V instanceof Model)
+        return;
+      if (K && K != V)
+        V = `${V} (as '${K}')`;
+      throw new Error(
+        `Context may only include instance or class \`extends Model\` but got ${V}.`
+      );
     });
     for (const key2 in inputs) {
       const input = inputs[key2];
@@ -534,8 +545,10 @@ var Context = class _Context {
     }
     for (const [model, explicit] of init2) {
       model.set();
-      if (forEach)
+      if (typeof forEach == "function")
         forEach(model, explicit);
+      else if (forEach && explicit)
+        model.set(forEach);
       for (const [_key, value] of model)
         if (PARENT.get(value) === model) {
           this.add(value, true);
@@ -552,8 +565,8 @@ var Context = class _Context {
       I = new input();
       this.cleanup.add(() => I.set(null));
     } else {
+      T = input.constructor;
       I = input;
-      T = I.constructor;
     }
     keys(T, true).forEach((K) => {
       const result = this[K];
@@ -566,15 +579,15 @@ var Context = class _Context {
     keys(T).forEach((K) => {
       const value = this.hasOwnProperty(K) ? null : I;
       if (value || this[K] !== I && !implicit)
-        Object.defineProperty(this, K, {
+        define(this, K, {
           configurable: true,
           value
         });
     });
-    const waiting = Register.get(I);
+    const waiting = LOOKUP.get(I);
     if (waiting instanceof Array)
       waiting.forEach((cb) => cb(this));
-    Register.set(I, this);
+    LOOKUP.set(I, this);
     return I;
   }
 };
@@ -610,8 +623,7 @@ Model.on((_, model) => {
     const { value } = Object.getOwnPropertyDescriptor(model, key2);
     const instruction = INSTRUCT.get(value);
     if (!instruction) {
-      if (value instanceof Model && key2 !== "is")
-        update(model, key2, value);
+      mayAdopt(model, value);
       continue;
     }
     INSTRUCT.delete(value);
@@ -622,7 +634,7 @@ Model.on((_, model) => {
     const desc = typeof output == "object" ? output : { get: output };
     if ("value" in desc)
       state[key2] = desc.value;
-    Object.defineProperty(model, key2, {
+    define(model, key2, {
       enumerable: desc.enumerable !== false,
       get() {
         return watch(
@@ -645,81 +657,84 @@ Model.on((_, model) => {
 var STALE = /* @__PURE__ */ new WeakSet();
 function get(arg0, arg1) {
   return use((key2, subject, state) => {
-    let from = subject;
     if (typeof arg0 == "symbol")
-      throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${from}.${key2}. This is not allowed.`);
-    let source = (resolve) => resolve(from);
-    if (arg0 instanceof Model) {
-      from = arg0;
-    } else if (Model.is(arg0)) {
-      const hasParent = PARENT.get(from);
+      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 assign2 = function(value) {
+        if (typeof arg1 == "function")
+          value.get((x) => arg1(x, key2));
+        update(subject, key2, value);
+      };
+      var assign = assign2;
+      const hasParent = PARENT.get(subject);
       if (!hasParent) {
         if (arg1 === true)
-          throw new Error(`${from} may only exist as a child of type ${arg0}.`);
-        source = (resolve) => {
-          Context.get(from, (context) => {
-            const got = context.get(arg0);
-            if (got)
-              resolve(got);
-            else if (arg1 !== false)
-              throw new Error(`Required ${arg0} not found in context for ${from}.`);
-          });
-        };
+          throw new Error(`${subject} may only exist as a child of type ${arg0}.`);
+        Context.get(subject, (context) => {
+          const model = context.get(arg0);
+          if (model)
+            assign2(model);
+          else if (arg1 !== false)
+            throw new Error(`Required ${arg0} not found in context for ${subject}.`);
+        });
       } else if (!arg0 || hasParent instanceof arg0)
-        from = hasParent;
+        assign2(hasParent);
       else
-        throw new Error(`New ${from} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
+        throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
+      return {
+        get: arg1 !== 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);
     }
-    if (typeof arg1 == "function") {
-      let connect2 = function(model) {
-        reset = effect(model, (current) => {
-          proxy = current;
-          if (!(key2 in state) || STALE.delete(compute2))
-            compute2(!reset);
-          return (didUpdate) => {
-            if (didUpdate) {
-              STALE.add(compute2);
-              event(subject, key2, true);
-            }
-          };
-        });
-      }, 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;
-      const getter = arg1;
-      let reset;
-      let isAsync;
-      let proxy;
-      return () => {
-        if (!proxy) {
-          source(connect2);
-          isAsync = true;
-        }
-        if (STALE.delete(compute2))
-          compute2();
-        return fetch(subject, key2, !proxy);
-      };
-    } else
-      source((got) => subject.set(key2, got));
-    return { get: arg1 };
+    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);
+          }
+        };
+      });
+    }
+    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);
+    };
   });
 }
 
 // src/instruction/ref.ts
-var define2 = Object.defineProperty;
 function ref(arg, arg2) {
   return use((key2, subject, state) => {
     let value = {};
@@ -727,20 +742,22 @@ function ref(arg, arg2) {
       subject.get(() => {
         for (const key3 in state)
           if (typeof arg2 == "function")
-            define2(value, key3, {
+            define(value, key3, {
               configurable: true,
               get() {
                 const out = arg2(key3);
-                define2(value, key3, { value: out });
+                define(value, key3, { value: out });
                 return out;
               }
             });
           else {
             const get2 = () => state[key3];
-            const set2 = (value2) => subject.set(key3, value2);
-            define2(set2, "current", { get: get2, set: set2 });
-            define2(set2, "get", { value: get2 });
-            define2(value, key3, { value: set2 });
+            const set2 = (value2) => {
+              update(subject, key3, value2);
+            };
+            define(set2, "current", { get: get2, set: set2 });
+            define(set2, "get", { value: get2 });
+            define(value, key3, { value: set2 });
           }
       });
     else if (typeof arg == "object")
@@ -749,7 +766,7 @@ function ref(arg, arg2) {
       let unSet;
       const get2 = () => state[key2];
       const set2 = (value2) => {
-        if (!subject.set(key2, value2) || !arg)
+        if (!update(subject, key2, value2) || !arg)
           return;
         if (unSet)
           unSet = void unSet(value2);
@@ -765,7 +782,7 @@ function ref(arg, arg2) {
         get: { value: get2 }
       });
     }
-    define2(subject, key2, { value });
+    define(subject, key2, { value });
   });
 }
 
@@ -785,16 +802,16 @@ function set(value, argument) {
         output.get = argument === true;
         if (value instanceof Promise) {
           value.then((value2) => {
-            subject.set(key2, value2);
+            update(subject, key2, value2);
             return value2;
           }).catch((err) => {
-            subject.set(key2);
+            event(subject, key2);
             output.get = () => {
               throw err;
             };
           });
         } else
-          subject.set(key2, value);
+          update(subject, key2, value);
         if (0 in arguments)
           return subject[key2];
       };
@@ -819,7 +836,7 @@ function set(value, argument) {
     } else
       output.set = (value2) => {
         output.get = void 0;
-        subject.set(key2, value2);
+        update(subject, key2, value2);
       };
     return output;
   });
@@ -847,17 +864,17 @@ var APPLY = /* @__PURE__ */ new WeakMap();
 function has(arg1, arg2) {
   return use((key2, subject) => {
     const applied = /* @__PURE__ */ new Set();
-    const update2 = () => {
-      subject.set(key2, Object.freeze(Array.from(applied)));
+    const apply = () => {
+      update(subject, key2, Object.freeze(Array.from(applied)));
     };
     if (Model.is(arg1))
       Context.get(subject, (context) => {
-        context.get(arg1, (got) => {
+        context.has(arg1, (model) => {
           let remove;
           let disconnect;
-          if (applied.has(got))
+          if (applied.has(model))
             return;
-          const callback = APPLY.get(got);
+          const callback = APPLY.get(model);
           if (callback) {
             const after = callback(subject);
             if (after === false)
@@ -866,7 +883,7 @@ function has(arg1, arg2) {
               disconnect = after;
           }
           if (typeof arg2 == "function") {
-            const done2 = arg2(got, subject);
+            const done2 = arg2(model, subject);
             if (done2 === false)
               return false;
             remove = () => {
@@ -874,18 +891,18 @@ function has(arg1, arg2) {
                 done2();
             };
           }
-          applied.add(got);
-          update2();
+          applied.add(model);
+          apply();
           const done = () => {
-            reset();
-            applied.delete(got);
-            update2();
+            ignore();
+            applied.delete(model);
+            apply();
             if (disconnect)
               disconnect();
             if (typeof remove == "function")
               remove();
           };
-          const reset = got.get(null, done);
+          const ignore = model.get(null, done);
           return done;
         });
       });
@@ -900,10 +917,10 @@ function has(arg1, arg2) {
             return false;
         }
         applied.add(recipient);
-        update2();
+        apply();
         return () => {
           applied.delete(recipient);
-          update2();
+          apply();
           if (typeof remove == "function")
             remove();
         };
@@ -916,7 +933,9 @@ function has(arg1, arg2) {
 0 && (module.exports = {
   Context,
   Model,
-  effect,
+  addListener,
+  createEffect,
+  createProxy,
   get,
   has,
   ref,