@expressive/mvc 0.48.0 → 0.50.0

package/dist/index.mjs

@@ -7,79 +7,66 @@ function addListener(subject, callback, select) {
   let subs = LISTENER.get(subject);
   if (!subs)
     LISTENER.set(subject, subs = /* @__PURE__ */ new Map([[onReady, false]]));
-  const filter = 2 in arguments && /* @__PURE__ */ new Set([select]);
+  const filter = select !== void 0 && /* @__PURE__ */ new Set([select]);
   if (!filter && !subs.has(onReady))
     callback(true, subject);
   subs.set(callback, filter);
   return () => subs.delete(callback);
 }
-function watch(from, key, value) {
-  const observer = OBSERVER.get(from);
-  if (observer) {
-    const listeners = LISTENER.get(from);
-    listeners.set(
-      observer,
-      (listeners.get(observer) || /* @__PURE__ */ new Set()).add(key)
-    );
-    const nested = LISTENER.get(value);
-    if (nested) {
-      LISTENER.set(value = Object.create(value), nested);
-      OBSERVER.set(value, observer);
-    }
-  }
-  return value;
+function watch(from, key2, value) {
+  const access = OBSERVER.get(from);
+  return access ? access(from, key2, value) : value;
 }
 var PENDING = /* @__PURE__ */ new WeakMap();
-function event(source, key) {
+function emit(source, key2) {
   const subs = LISTENER.get(source);
   const ready = !subs.has(onReady);
-  if (key === true && ready)
+  if (key2 === true && ready)
     return;
   let pending = PENDING.get(source);
   if (pending) {
-    pending.add(key);
+    pending.add(key2);
     return;
   }
   PENDING.set(source, pending = new Set(
-    key !== true && ready ? [key] : [true, key]
+    key2 !== true && ready ? [key2] : [true, key2]
   ));
-  pending.forEach((key2) => {
-    pending.delete(key2);
+  pending.forEach((key3) => {
+    pending.delete(key3);
     subs.forEach((select, callback) => {
       let after;
-      if (!select || select.has(key2)) {
-        if (after = callback.call(source, key2, source))
+      if (!select || select.has(key3)) {
+        if (after = callback.call(source, key3, source))
           queue(after);
       }
-      if (after === null || key2 === null)
+      if (after === null || key3 === null)
         subs.delete(callback);
     });
   });
   PENDING.delete(source);
 }
-function queue(event2) {
+function queue(event) {
   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(event);
 }
-function effect(target, callback) {
+function effect(target, callback, requireValues) {
   const listeners = LISTENER.get(target);
   let unset;
   let reset;
   function invoke() {
     let stale;
     const subscriber = Object.create(target);
-    LISTENER.set(subscriber, listeners);
-    OBSERVER.set(subscriber, () => {
+    function onUpdate() {
       if (stale)
         return null;
       stale = true;
@@ -88,7 +75,24 @@ function effect(target, callback) {
         unset = void 0;
       }
       return reset;
-    });
+    }
+    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);
+      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);
+      }
+      return value;
+    }
+    LISTENER.set(subscriber, listeners);
+    OBSERVER.set(subscriber, access);
     try {
       const out = callback.call(subscriber, subscriber);
       unset = typeof out == "function" ? out : void 0;
@@ -101,12 +105,12 @@ function effect(target, callback) {
         throw err;
     }
   }
-  addListener(target, (key) => {
-    if (key === true)
+  addListener(target, (key2) => {
+    if (key2 === true)
       invoke();
     else if (!reset)
       return reset;
-    if (key === null && unset)
+    if (key2 === null && unset)
       unset(null);
   });
   return () => {
@@ -160,15 +164,15 @@ var Model = class _Model {
         }
         done = cleanup;
       })();
-      for (const key in this) {
-        const desc = Object.getOwnPropertyDescriptor(this, key);
+      for (const key2 in this) {
+        const desc = Object.getOwnPropertyDescriptor(this, key2);
         if ("value" in desc) {
-          update(this, key, desc.value, true);
-          define(this, key, {
+          update(this, key2, desc.value, true);
+          define(this, key2, {
             configurable: false,
-            set: (x) => update(this, key, x),
+            set: (x) => update(this, key2, x),
             get() {
-              return watch(this, key, state[key]);
+              return watch(this, key2, state[key2]);
             }
           });
         }
@@ -203,12 +207,12 @@ var Model = class _Model {
     if (arg1 === void 0) {
       const values = {};
       const current = !EXPORT && (EXPORT = /* @__PURE__ */ new Map([[self, values]]));
-      for (let [key, value] of self) {
+      for (let [key2, value] of self) {
         if (EXPORT.has(value))
           value = EXPORT.get(value);
         else if (value && typeof value.get === "function")
           EXPORT.set(value, value = value.get());
-        values[key] = value;
+        values[key2] = value;
       }
       if (current)
         EXPORT = void 0;
@@ -229,16 +233,16 @@ var Model = class _Model {
   set(arg1, arg2, arg3) {
     const self = this.is;
     if (typeof arg1 == "function")
-      return addListener(self, (key) => {
-        if (typeof key == "string")
-          return arg1.call(self, key, self);
+      return addListener(self, (key2) => {
+        if (typeof key2 == "string")
+          return arg1.call(self, key2, self);
       });
     if (arg1 === null)
-      return event(this, null);
+      return emit(this, null);
     if (typeof arg1 == "object")
       assign(self, arg1);
     else if (arg1 == void 0)
-      event(this, true);
+      emit(this, true);
     else if (1 in arguments)
       update(self, arg1, arg2, arg3);
     else
@@ -246,8 +250,8 @@ var Model = class _Model {
     if (PENDING2.has(self))
       return {
         then: (res) => new Promise((res2) => {
-          const remove = addListener(self, (key) => {
-            if (key !== true) {
+          const remove = addListener(self, (key2) => {
+            if (key2 !== true) {
               remove();
               return res2.bind(null, Array.from(PENDING2.get(self)));
             }
@@ -268,7 +272,7 @@ var Model = class _Model {
    */
   static new(...args) {
     const instance = new this(...args);
-    event(instance, true);
+    emit(instance, true);
     return instance;
   }
   /**
@@ -310,12 +314,12 @@ function fetch(subject, property, required) {
   }
   const error = new Error(`${subject}.${property} is not yet available.`);
   const promise = new Promise((resolve, reject) => {
-    addListener(subject, (key) => {
-      if (key === property) {
-        resolve(state[key]);
+    addListener(subject, (key2) => {
+      if (key2 === property) {
+        resolve(state[key2]);
         return null;
       }
-      if (key === null)
+      if (key2 === null)
         reject(new Error(`${subject} is destroyed.`));
     });
   });
@@ -326,63 +330,70 @@ function fetch(subject, property, required) {
     stack: error.stack
   });
 }
-function update(subject, key, value, silent) {
+function update(subject, key2, value, arg) {
   const state = STATE.get(subject);
   if (Object.isFrozen(state))
-    throw new Error(`Tried to update ${String(key)} but ${subject} is destroyed.`);
-  const previous = state[key];
+    throw new Error(`Tried to update ${String(key2)} but ${subject} 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)
     return true;
   if (value instanceof Model && !PARENT.has(value)) {
     PARENT.set(value, subject);
-    event(value, true);
+    emit(value, true);
   }
-  state[key] = value;
-  if (silent !== true)
-    push(subject, key);
+  state[key2] = value;
+  if (arg !== true)
+    push(subject, key2);
 }
-function push(subject, key, silent) {
+function push(subject, key2, silent) {
   let pending = PENDING2.get(subject);
   if (!pending) {
     PENDING2.set(subject, pending = /* @__PURE__ */ new Set());
     if (!silent)
       queue(() => {
-        event(subject, false);
+        emit(subject, false);
         PENDING2.delete(subject);
       });
   }
-  pending.add(key);
+  pending.add(key2);
   if (!silent)
-    event(subject, key);
+    emit(subject, key2);
 }
 var METHODS = new WeakMap([[Model, []]]);
 function assign(to, values) {
   const methods = METHODS.get(to.constructor);
   const applicable = new Set(Object.keys(to).concat(methods));
-  for (const key in values)
-    if (applicable.has(key))
-      to[key] = values[key];
+  for (const key2 in values)
+    if (applicable.has(key2))
+      to[key2] = values[key2];
 }
 function bindMethods(type) {
   let keys = METHODS.get(type);
   if (!keys) {
     METHODS.set(type, keys = bindMethods(Object.getPrototypeOf(type)).slice());
     const desc = Object.getOwnPropertyDescriptors(type.prototype);
-    for (const key in desc)
-      if (key != "constructor" && "value" in desc[key]) {
+    for (const key2 in desc)
+      if (key2 != "constructor" && "value" in desc[key2]) {
         let bind2 = function(method) {
           const value2 = method.bind(this.is);
           METHOD.set(value2, method);
-          define(this.is, key, { value: value2, writable: true });
+          define(this.is, key2, { value: value2, writable: true });
           return value2;
         };
         var bind = bind2;
-        let { value } = desc[key];
-        keys.push(key);
-        Object.defineProperty(type.prototype, key, {
+        let { value } = desc[key2];
+        keys.push(key2);
+        Object.defineProperty(type.prototype, key2, {
           set: bind2,
           get() {
-            return this.hasOwnProperty(key) ? value : bind2.call(this, value);
+            return this.hasOwnProperty(key2) ? value : bind2.call(this, value);
           }
         });
       }
@@ -395,11 +406,21 @@ function uid() {
 
 // src/context.ts
 var Register = /* @__PURE__ */ new WeakMap();
+var Upstream = /* @__PURE__ */ new WeakMap();
+var Downstream = /* @__PURE__ */ new WeakMap();
+function key(T, upstream) {
+  const table = upstream ? Upstream : Downstream;
+  let key2 = table.get(T);
+  if (!key2) {
+    key2 = Symbol(T.name + (upstream ? " request" : ""));
+    table.set(T, key2);
+  }
+  return key2;
+}
 var Context = class _Context {
   constructor(inputs) {
-    this.downstream = /* @__PURE__ */ new WeakMap();
-    this.upstream = /* @__PURE__ */ new WeakMap();
     this.layer = /* @__PURE__ */ new Map();
+    this.cleanup = /* @__PURE__ */ new Set();
     if (inputs)
       this.include(inputs);
   }
@@ -414,43 +435,40 @@ var Context = class _Context {
     else
       Register.set(from, [callback]);
   }
-  key(T, upstream) {
-    const table = upstream ? this.upstream : this.downstream;
-    let key = table.get(T);
-    if (!key) {
-      key = Symbol(T.name + (upstream ? " request" : ""));
-      table.set(T, key);
-    }
-    return key;
-  }
-  has(model) {
-    const key = this.key(model.constructor, true);
-    const result = this[key];
-    const waiting = Register.get(model);
-    if (waiting instanceof Array)
-      waiting.forEach((cb) => cb(this));
-    Register.set(model, this);
-    if (typeof result == "function")
-      return result(model);
-  }
-  get(Type) {
-    const result = this[this.key(Type)];
+  get(Type, callback) {
+    if (callback)
+      return this.put(Type, callback);
+    const result = this[key(Type)];
     if (result === null)
       throw new Error(`Did find ${Type} in context, but multiple were defined.`);
     return result;
   }
+  push(inputs) {
+    const next = Object.create(this);
+    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.layer.clear();
+  }
   include(inputs, forEach) {
     const init = /* @__PURE__ */ new Map();
     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}.`);
     });
-    for (const key in inputs) {
-      const input = inputs[key];
-      const exists = this.layer.get(key);
+    for (const key2 in inputs) {
+      const input = inputs[key2];
+      const exists = this.layer.get(key2);
       if (!exists) {
         const instance = this.add(input);
-        this.layer.set(key, input);
+        this.layer.set(key2, input);
         init.set(instance, true);
       } else if (exists !== input) {
         this.pop();
@@ -469,118 +487,101 @@ var Context = class _Context {
         }
     }
   }
-  put(T, I, implicit, writable) {
-    do {
-      const key = this.key(T, typeof I == "function");
-      const value = this.hasOwnProperty(key) ? null : I;
-      if (value || this[key] !== I && !implicit)
-        Object.defineProperty(this, key, {
-          configurable: true,
-          writable,
-          value
-        });
-      T = Object.getPrototypeOf(T);
-    } while (T !== Model);
-  }
   add(input, implicit) {
-    let writable = true;
     let T;
     let I;
     if (typeof input == "function") {
       T = input;
       I = new input();
+      this.cleanup.add(() => I.set(null));
     } else {
       I = input;
       T = I.constructor;
-      writable = false;
     }
-    this.has(I);
-    this.put(T, I, implicit, writable);
+    this.has(T, I);
+    this.put(T, I, implicit);
     return I;
   }
-  push(inputs) {
-    const next = Object.create(this);
-    next.layer = /* @__PURE__ */ new Map();
-    if (inputs)
-      next.include(inputs);
-    return next;
+  has(type, model) {
+    do {
+      const K = key(type, true);
+      const result = this[K];
+      if (!result)
+        continue;
+      const callback = result(model);
+      if (callback)
+        this.cleanup.add(callback);
+    } while ((type = Object.getPrototypeOf(type)) !== Model);
+    const waiting = Register.get(model);
+    if (waiting instanceof Array)
+      waiting.forEach((cb) => cb(this));
+    Register.set(model, this);
   }
-  pop() {
-    const items = /* @__PURE__ */ new Set();
-    for (const key of Object.getOwnPropertySymbols(this)) {
-      const entry = Object.getOwnPropertyDescriptor(this, key);
-      if (entry.writable && entry.value)
-        items.add(entry.value);
-      delete this[key];
-    }
-    for (const model of items)
-      model.set(null);
-    this.layer.clear();
+  put(T, I, implicit) {
+    do {
+      const K = key(T, typeof I == "function");
+      const value = this.hasOwnProperty(K) ? null : I;
+      if (value || this[K] !== I && !implicit)
+        Object.defineProperty(this, K, { configurable: true, value });
+    } while ((T = Object.getPrototypeOf(T)) !== Model);
   }
 };
 
 // src/instruction/use.ts
 var INSTRUCT = /* @__PURE__ */ new Map();
-function use(model, argument) {
+function use(arg1, arg2) {
   const token = Symbol("instruction");
-  if (Model.is(model)) {
-    const type = model;
-    const value = new model();
-    model = (key, subject) => {
+  if (Model.is(arg1)) {
+    const type = arg1;
+    const value = new type();
+    arg1 = (key2, subject) => {
       function set2(next) {
-        if (next ? !(next instanceof type) : argument !== false)
-          throw new Error(`${subject}.${key} expected Model of type ${type} but got ${next && next.constructor}.`);
-        update(subject, key, next);
-        if (next && typeof argument == "function")
-          argument(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;
       }
       set2(value);
       return { set: set2, value };
     };
   }
-  INSTRUCT.set(token, model);
+  INSTRUCT.set(token, arg1);
   return token;
 }
 Model.on((_, subject) => {
   const state = STATE.get(subject);
   const props = Object.getOwnPropertyDescriptors(subject);
-  for (const key in props) {
-    const { value } = props[key];
+  for (const key2 in props) {
+    const { value } = props[key2];
     const instruction = INSTRUCT.get(value);
-    if (!instruction)
+    if (!instruction) {
+      if (value instanceof Model && key2 !== "is")
+        update(subject, key2, value);
       continue;
+    }
     INSTRUCT.delete(value);
-    delete subject[key];
-    const output = instruction.call(subject, key, subject, state);
+    delete subject[key2];
+    const output = instruction.call(subject, key2, subject, state);
     if (!output)
       continue;
     const desc = typeof output == "object" ? output : { get: output };
-    const { enumerable = true } = desc;
     if ("value" in desc)
-      state[key] = desc.value;
-    Object.defineProperty(subject, key, {
-      enumerable,
-      set(next) {
-        let { set: set2 } = desc;
-        if (set2 === false)
-          throw new Error(`${subject}.${key} is read-only.`);
-        if (typeof set2 == "function") {
-          const result = set2.call(subject, next, state[key]);
-          if (result === false)
-            return;
-          if (typeof result == "function")
-            next = result();
-          set2 = false;
-        }
-        update(subject, key, next, !!set2);
-      },
+      state[key2] = desc.value;
+    Object.defineProperty(subject, key2, {
+      enumerable: desc.enumerable !== false,
       get() {
         return watch(
           this,
-          key,
-          typeof desc.get == "function" ? desc.get(this) : fetch(subject, key, desc.get)
+          key2,
+          typeof desc.get == "function" ? desc.get(this) : fetch(subject, key2, desc.get)
         );
+      },
+      set(next) {
+        if (desc.set === false)
+          throw new Error(`${subject}.${key2} is read-only.`);
+        update(subject, key2, next, desc.set);
       }
     });
   }
@@ -590,10 +591,10 @@ Model.on((_, subject) => {
 // src/instruction/get.ts
 var STALE = /* @__PURE__ */ new WeakSet();
 function get(arg0, arg1) {
-  return use((key, subject, state) => {
+  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}.${key}. This is not allowed.`);
+      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;
@@ -623,26 +624,26 @@ function get(arg0, arg1) {
       let connect2 = function(model) {
         reset = effect(model, (current) => {
           proxy = current;
-          if (!(key in state) || STALE.delete(compute2))
+          if (!(key2 in state) || STALE.delete(compute2))
             compute2(!reset);
           return (didUpdate) => {
             if (didUpdate) {
               STALE.add(compute2);
-              push(subject, key, true);
+              push(subject, key2, true);
             }
           };
         });
       }, compute2 = function(initial) {
         let next;
         try {
-          next = getter.call(proxy, proxy, key);
+          next = getter.call(proxy, proxy, key2);
         } catch (err) {
-          console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
+          console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key2}.`);
           if (initial)
             throw err;
           console.error(err);
         }
-        update(subject, key, next, !isAsync);
+        update(subject, key2, next, !isAsync);
       };
       var connect = connect2, compute = compute2;
       const getter = arg1;
@@ -656,10 +657,10 @@ function get(arg0, arg1) {
         }
         if (STALE.delete(compute2))
           compute2();
-        return fetch(subject, key, !proxy);
+        return fetch(subject, key2, !proxy);
       };
     } else
-      source((got) => subject.set(key, got));
+      source((got) => subject.set(key2, got));
     return { get: arg1 };
   });
 }
@@ -667,35 +668,35 @@ function get(arg0, arg1) {
 // src/instruction/ref.ts
 var define2 = Object.defineProperty;
 function ref(arg, arg2) {
-  return use((key, subject, state) => {
+  return use((key2, subject, state) => {
     let value = {};
     if (arg === subject)
       subject.get(() => {
-        for (const key2 in state)
+        for (const key3 in state)
           if (typeof arg2 == "function")
-            define2(value, key2, {
+            define2(value, key3, {
               configurable: true,
               get() {
-                const out = arg2(key2);
-                define2(value, key2, { value: out });
+                const out = arg2(key3);
+                define2(value, key3, { value: out });
                 return out;
               }
             });
           else {
-            const get2 = () => state[key2];
-            const set2 = (value2) => subject.set(key2, value2);
+            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, key2, { value: set2 });
+            define2(value, key3, { value: set2 });
           }
       });
     else if (typeof arg == "object")
       throw new Error("ref instruction does not support object which is not 'this'");
     else {
       let unSet;
-      const get2 = () => state[key];
+      const get2 = () => state[key2];
       const set2 = (value2) => {
-        if (!subject.set(key, value2) || !arg)
+        if (!subject.set(key2, value2) || !arg)
           return;
         if (unSet)
           unSet = void unSet(value2);
@@ -705,44 +706,44 @@ function ref(arg, arg2) {
             unSet = out;
         }
       };
-      state[key] = null;
+      state[key2] = null;
       value = Object.defineProperties(set2, {
         current: { get: get2, set: set2 },
         get: { value: get2 }
       });
     }
-    define2(subject, key, { value });
+    define2(subject, key2, { value });
   });
 }
 
 // src/instruction/set.ts
 function set(value, argument) {
-  return use((key, subject) => {
+  return use((key2, subject) => {
     const output = {};
     if (typeof value == "function" || value instanceof Promise) {
       let init2 = function() {
         if (typeof value == "function")
           try {
-            value = attempt(value.bind(subject, key, subject));
+            value = attempt(value.bind(subject, key2));
           } catch (err) {
-            console.warn(`Generating initial value for ${subject}.${key} failed.`);
+            console.warn(`Generating initial value for ${subject}.${key2} failed.`);
             throw err;
           }
-        output.get = typeof argument == "boolean" ? argument : void 0;
+        output.get = argument === true;
         if (value instanceof Promise) {
           value.then((value2) => {
-            subject.set(key, value2);
+            subject.set(key2, value2);
             return value2;
           }).catch((err) => {
-            subject.set(key);
+            subject.set(key2);
             output.get = () => {
               throw err;
             };
           });
         } else
-          subject.set(key, value);
+          subject.set(key2, value);
         if (0 in arguments)
-          return subject[key];
+          return subject[key2];
       };
       var init = init2;
       if (argument)
@@ -765,7 +766,7 @@ function set(value, argument) {
     } else
       output.set = (value2) => {
         output.get = void 0;
-        subject.set(key, value2);
+        subject.set(key2, value2);
       };
     return output;
   });
@@ -789,47 +790,77 @@ function attempt(fn) {
 }
 
 // src/instruction/has.ts
-function has(type, argument) {
-  return use((key, subject, state) => {
-    const expect = (callback) => Context.get(subject, (context) => context.put(type, callback));
-    if (typeof argument == "boolean") {
-      expect((model) => {
-        subject.set(key, model);
-        const remove = () => {
-          if (state[key] === model)
-            delete state[key];
+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)));
+    };
+    if (!Model.is(arg1)) {
+      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);
+        update2();
+        return () => {
+          applied.delete(recipient);
+          update2();
+          if (typeof remove == "function")
+            remove();
         };
-        model.get(null, remove);
-        return remove;
       });
-      return { get: argument };
-    }
-    const value = /* @__PURE__ */ new Set();
-    expect((model) => {
-      if (value.has(model))
-        return;
-      const remove = typeof argument == "function" ? argument(model) : void 0;
-      if (remove === false)
-        return;
-      value.add(model);
-      subject.set(key);
-      const done = () => {
-        drop();
-        if (typeof remove == "function")
-          remove();
-        value.delete(model);
-        subject.set(key);
-      };
-      const drop = model.get(null, done);
-      return done;
-    });
-    return { value };
+    } else
+      Context.get(subject, (ctx) => ctx.get(arg1, (got) => {
+        let remove;
+        let disconnect;
+        if (applied.has(got))
+          return;
+        const callback = APPLY.get(got);
+        if (callback) {
+          const after = callback(subject);
+          if (after === false)
+            return;
+          if (typeof after == "function")
+            disconnect = after;
+        }
+        if (typeof arg2 == "function") {
+          const done2 = arg2(got, subject);
+          if (done2 === false)
+            return false;
+          remove = () => {
+            if (typeof done2 == "function")
+              done2();
+          };
+        }
+        applied.add(got);
+        update2();
+        const done = () => {
+          reset();
+          applied.delete(got);
+          update2();
+          if (disconnect)
+            disconnect();
+          if (typeof remove == "function")
+            remove();
+        };
+        const reset = got.get(null, done);
+        return done;
+      }));
+    return { value: [] };
   });
 }
 export {
   Context,
   Model,
   Model as default,
+  effect,
   get,
   has,
   ref,