@expressive/mvc 0.47.0 → 0.49.0

package/dist/index.d.ts

@@ -8,7 +8,7 @@ declare namespace Model {
      */
     type Callback<T extends Model = Model> = (this: T, thisArg: T) => MaybeAsync<(() => void) | Assign<T> | void>;
     /** Model constructor argument */
-    type Argument<T extends Model = Model> = string | Assign<T> | Callback<T> | Promise<Assign<T> | (() => void) | void> | void;
+    type Argument<T extends Model = Model> = Assign<T> | Callback<T> | string | void;
     /** Model constructor arguments */
     type Args<T extends Model = any> = Argument<T>[];
     /** Subset of `keyof T` which are not methods or defined by base Model U. **/
@@ -198,7 +198,6 @@ declare class Model {
      * Register a callback to run when any instance of this Model is updated.
      */
     static on<T extends Model>(this: Model.Type<T>, listener: Model.OnEvent<T>): () => boolean;
-    static at<T extends Model>(this: Model.Type<T>, from: Model, cb: (got: T | undefined) => void): void;
 }
 
 declare namespace get {
@@ -355,11 +354,24 @@ declare function has<T extends Model>(type: Model.Type<T>, one: true): T;
 declare function has<T extends Model>(type: Model.Type<T>, required: boolean): T | undefined;
 declare function has<T extends Model>(type: Model.Type<T>, arg?: has.Callback<T>): Set<T>;
 
+type Effect<T extends {}> = (this: T, argument: T) => ((update: boolean | null) => void) | Promise<void> | null | void;
+/**
+ * Create a side-effect which will update whenever values accessed change.
+ * Callback is called immediately and if ever values are stale.
+ *
+ * @param target - Instance of Model to observe.
+ * @param callback - Function to invoke when values change.
+ * @param requireValues - If `true` will throw if accessing a value which is `undefined`.
+ */
+declare function effect<T extends {}>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;
+declare function effect<T extends {}>(target: T, callback: Effect<T>, requireValues?: boolean): () => void;
+
 declare namespace Context {
-    type Input = Model | Model.Type<Model> | Record<string | number, Model | Model.Type<Model>>;
+    type Input = Record<string | number, Model | Model.Type<Model>>;
 }
 declare class Context {
-    static request<T extends Model>(type: Model.Type<T>, from: Model, callback: (got: T) => void): void;
+    static get<T extends Model>(on: Model, callback: ((got: Context) => void)): void;
+    static get<T extends Model>(on: Model): Context | undefined;
     id: string;
     protected downstream: WeakMap<Model.Type<Model>, symbol>;
     protected upstream: WeakMap<Model.Type<Model>, symbol>;
@@ -392,4 +404,4 @@ declare global {
     }
 }
 
-export { Context, Model, Model as default, get, has, ref, set, use };
+export { Context, Model, Model as default, effect, get, has, ref, set, use };

package/dist/index.js

@@ -23,6 +23,7 @@ __export(src_exports, {
   Context: () => Context,
   Model: () => Model,
   default: () => Model,
+  effect: () => effect,
   get: () => get,
   has: () => has,
   ref: () => ref,
@@ -35,6 +36,7 @@ module.exports = __toCommonJS(src_exports);
 var DISPATCH = /* @__PURE__ */ new Set();
 var OBSERVER = /* @__PURE__ */ new WeakMap();
 var LISTENER = /* @__PURE__ */ new WeakMap();
+var REQUIRED = /* @__PURE__ */ new WeakSet();
 var onReady = () => null;
 function addListener(subject, callback, select) {
   let subs = LISTENER.get(subject);
@@ -59,11 +61,13 @@ function watch(from, key, value) {
       LISTENER.set(value = Object.create(value), nested);
       OBSERVER.set(value, observer);
     }
+    if (value === void 0 && REQUIRED.has(from))
+      throw new Error(`${from}.${key} is required in this context.`);
   }
   return value;
 }
 var PENDING = /* @__PURE__ */ new WeakMap();
-function event(source, key) {
+function emit(source, key) {
   const subs = LISTENER.get(source);
   const ready = !subs.has(onReady);
   if (key === true && ready)
@@ -90,21 +94,21 @@ function event(source, key) {
   });
   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;
@@ -122,6 +126,8 @@ function effect(target, callback) {
       }
       return reset;
     });
+    if (requireValues)
+      REQUIRED.add(subscriber);
     try {
       const out = callback.call(subscriber, subscriber);
       unset = typeof out == "function" ? out : void 0;
@@ -150,7 +156,7 @@ function effect(target, callback) {
 }
 
 // src/model.ts
-var FLATTEN;
+var EXPORT;
 var NAMES = /* @__PURE__ */ new WeakMap();
 var STATE = /* @__PURE__ */ new WeakMap();
 var NOTIFY = /* @__PURE__ */ new WeakMap();
@@ -235,16 +241,16 @@ var Model = class _Model {
     }
     if (arg1 === void 0) {
       const values = {};
-      const current = !FLATTEN && (FLATTEN = /* @__PURE__ */ new Map([[self, values]]));
+      const current = !EXPORT && (EXPORT = /* @__PURE__ */ new Map([[self, values]]));
       for (let [key, value] of self) {
-        if (FLATTEN.has(value))
-          value = FLATTEN.get(value);
+        if (EXPORT.has(value))
+          value = EXPORT.get(value);
         else if (value && typeof value.get === "function")
-          FLATTEN.set(value, value = value.get());
+          EXPORT.set(value, value = value.get());
         values[key] = value;
       }
       if (current)
-        FLATTEN = void 0;
+        EXPORT = void 0;
       return Object.freeze(values);
     }
     if (typeof arg2 == "function") {
@@ -267,11 +273,11 @@ var Model = class _Model {
           return arg1.call(self, key, 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
@@ -301,7 +307,7 @@ var Model = class _Model {
    */
   static new(...args) {
     const instance = new this(...args);
-    event(instance, true);
+    emit(instance, true);
     return instance;
   }
   /**
@@ -323,9 +329,6 @@ var Model = class _Model {
     notify.add(listener);
     return () => notify.delete(listener);
   }
-  static at(from, cb) {
-    throw new Error(`Using context requires an adapter. If you are only testing, define \`get.context\` to simulate one.`);
-  }
 };
 define(Model.prototype, "toString", {
   value() {
@@ -345,14 +348,14 @@ function fetch(subject, property, required) {
       return value;
   }
   const error = new Error(`${subject}.${property} is not yet available.`);
-  const promise = new Promise((resolve, reject2) => {
+  const promise = new Promise((resolve, reject) => {
     addListener(subject, (key) => {
       if (key === property) {
         resolve(state[key]);
         return null;
       }
       if (key === null)
-        reject2(new Error(`${subject} is destroyed.`));
+        reject(new Error(`${subject} is destroyed.`));
     });
   });
   throw Object.assign(promise, {
@@ -371,7 +374,7 @@ function update(subject, key, value, silent) {
     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)
@@ -383,13 +386,13 @@ function push(subject, key, silent) {
     PENDING2.set(subject, pending = /* @__PURE__ */ new Set());
     if (!silent)
       queue(() => {
-        event(subject, false);
+        emit(subject, false);
         PENDING2.delete(subject);
       });
   }
   pending.add(key);
   if (!silent)
-    event(subject, key);
+    emit(subject, key);
 }
 var METHODS = new WeakMap([[Model, []]]);
 function assign(to, values) {
@@ -429,6 +432,132 @@ function uid() {
   return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
 }
 
+// src/context.ts
+var Register = /* @__PURE__ */ new WeakMap();
+var Context = class _Context {
+  constructor(inputs) {
+    this.downstream = /* @__PURE__ */ new WeakMap();
+    this.upstream = /* @__PURE__ */ new WeakMap();
+    this.layer = /* @__PURE__ */ new Map();
+    if (inputs)
+      this.include(inputs);
+  }
+  static get(from, callback) {
+    const waiting = Register.get(from);
+    if (!callback)
+      return waiting instanceof _Context ? waiting : void 0;
+    if (waiting instanceof _Context)
+      callback(waiting);
+    else if (waiting)
+      waiting.push(callback);
+    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)];
+    if (result === null)
+      throw new Error(`Did find ${Type} in context, but multiple were defined.`);
+    return result;
+  }
+  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);
+      if (!exists) {
+        const instance = this.add(input);
+        this.layer.set(key, input);
+        init.set(instance, true);
+      } else if (exists !== input) {
+        this.pop();
+        this.id = uid();
+        this.include(inputs);
+      }
+    }
+    for (const [model, explicit] of init) {
+      model.set();
+      if (forEach)
+        forEach(model, explicit);
+      for (const [_key, value] of model)
+        if (PARENT.get(value) === model) {
+          this.add(value, true);
+          init.set(value, false);
+        }
+    }
+  }
+  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();
+    } else {
+      I = input;
+      T = I.constructor;
+      writable = false;
+    }
+    this.has(I);
+    this.put(T, I, implicit, writable);
+    return I;
+  }
+  push(inputs) {
+    const next = Object.create(this);
+    next.layer = /* @__PURE__ */ new Map();
+    if (inputs)
+      next.include(inputs);
+    return next;
+  }
+  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();
+  }
+};
+
 // src/instruction/use.ts
 var INSTRUCT = /* @__PURE__ */ new Map();
 function use(model, argument) {
@@ -500,20 +629,21 @@ Model.on((_, subject) => {
 // src/instruction/get.ts
 var STALE = /* @__PURE__ */ new WeakSet();
 function get(arg0, arg1) {
-  return use((key, subject) => {
+  return use((key, 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.`);
     let source = (resolve) => resolve(from);
     if (arg0 instanceof Model) {
       from = arg0;
-    } else if (arg0.prototype instanceof Model) {
+    } else if (Model.is(arg0)) {
       const hasParent = PARENT.get(from);
       if (!hasParent) {
         if (arg1 === true)
           throw new Error(`${from} may only exist as a child of type ${arg0}.`);
         source = (resolve) => {
-          arg0.at(from, (got) => {
+          Context.get(from, (context) => {
+            const got = context.get(arg0);
             if (got)
               resolve(got);
             else if (arg1 !== false)
@@ -532,10 +662,8 @@ function get(arg0, arg1) {
       let connect2 = function(model) {
         reset = effect(model, (current) => {
           proxy = current;
-          if (!reset)
-            compute2(true);
-          else if (STALE.delete(compute2))
-            compute2();
+          if (!(key in state) || STALE.delete(compute2))
+            compute2(!reset);
           return (didUpdate) => {
             if (didUpdate) {
               STALE.add(compute2);
@@ -699,178 +827,49 @@ function attempt(fn) {
   return compute();
 }
 
-// src/context.ts
-var Expects = /* @__PURE__ */ new WeakMap();
-var Context = class {
-  constructor(inputs) {
-    this.downstream = /* @__PURE__ */ new WeakMap();
-    this.upstream = /* @__PURE__ */ new WeakMap();
-    this.layer = /* @__PURE__ */ new Map();
-    if (inputs)
-      this.include(inputs);
-  }
-  static request(type, from, callback) {
-    let map = Expects.get(from);
-    if (!map)
-      Expects.set(from, map = /* @__PURE__ */ new Map());
-    map.set(type, 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];
-    if (typeof result == "function")
-      return result(model);
-  }
-  get(Type) {
-    const result = this[this.key(Type)];
-    if (result === null)
-      throw new Error(`Did find ${Type} in context, but multiple were defined.`);
-    return result;
-  }
-  include(inputs, forEach) {
-    const init = /* @__PURE__ */ new Map();
-    if (typeof inputs == "function" || inputs instanceof Model)
-      inputs = { [0]: inputs };
-    else if (!inputs)
-      reject(inputs);
-    Object.entries(inputs).forEach(([K, V]) => {
-      if (!(Model.is(V) || V instanceof Model))
-        reject(`${V} as ${K}`);
-    });
-    for (const key in inputs) {
-      const input = inputs[key];
-      const exists = this.layer.get(key);
-      if (!exists) {
-        const instance = this.add(input);
-        this.layer.set(key, input);
-        init.set(instance, true);
-      } else if (exists !== input) {
-        this.pop();
-        this.id = uid();
-        this.include(inputs);
-      }
-    }
-    for (const [model, explicit] of init) {
-      if (forEach)
-        forEach(model, explicit);
-      model.set();
-      this.has(model);
-      const expects = Expects.get(model);
-      if (expects)
-        for (let [T, callback] of expects)
-          this.put(T, callback);
-      for (const [_key, value] of model)
-        if (PARENT.get(value) === model) {
-          this.add(value, true);
-          init.set(value, false);
-        }
-    }
-  }
-  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();
-    } else {
-      I = input;
-      T = I.constructor;
-      writable = false;
-    }
-    this.put(T, I, implicit, writable);
-    return I;
-  }
-  push(inputs) {
-    const next = Object.create(this);
-    next.layer = /* @__PURE__ */ new Map();
-    if (inputs)
-      next.include(inputs);
-    return next;
-  }
-  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();
-  }
-};
-function reject(argument) {
-  throw new Error(`Context can only include Model or instance but got ${argument}.`);
-}
-
 // 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") {
-      Context.request(type, subject, (model) => {
+      expect((model) => {
         subject.set(key, model);
         const remove = () => {
-          drop();
           if (state[key] === model)
             delete state[key];
         };
-        const drop = model.get(null, remove);
+        model.get(null, remove);
         return remove;
       });
       return { get: argument };
     }
-    const children = /* @__PURE__ */ new Set();
-    Context.request(type, subject, (model) => {
-      if (children.has(model))
+    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;
-      children.add(model);
+      value.add(model);
       subject.set(key);
       const done = () => {
         drop();
         if (typeof remove == "function")
           remove();
-        children.delete(model);
+        value.delete(model);
         subject.set(key);
       };
       const drop = model.get(null, done);
       return done;
     });
-    return {
-      value: children
-    };
+    return { value };
   });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Context,
   Model,
+  effect,
   get,
   has,
   ref,

package/dist/index.mjs

@@ -2,6 +2,7 @@
 var DISPATCH = /* @__PURE__ */ new Set();
 var OBSERVER = /* @__PURE__ */ new WeakMap();
 var LISTENER = /* @__PURE__ */ new WeakMap();
+var REQUIRED = /* @__PURE__ */ new WeakSet();
 var onReady = () => null;
 function addListener(subject, callback, select) {
   let subs = LISTENER.get(subject);
@@ -26,11 +27,13 @@ function watch(from, key, value) {
       LISTENER.set(value = Object.create(value), nested);
       OBSERVER.set(value, observer);
     }
+    if (value === void 0 && REQUIRED.has(from))
+      throw new Error(`${from}.${key} is required in this context.`);
   }
   return value;
 }
 var PENDING = /* @__PURE__ */ new WeakMap();
-function event(source, key) {
+function emit(source, key) {
   const subs = LISTENER.get(source);
   const ready = !subs.has(onReady);
   if (key === true && ready)
@@ -57,21 +60,21 @@ function event(source, key) {
   });
   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;
@@ -89,6 +92,8 @@ function effect(target, callback) {
       }
       return reset;
     });
+    if (requireValues)
+      REQUIRED.add(subscriber);
     try {
       const out = callback.call(subscriber, subscriber);
       unset = typeof out == "function" ? out : void 0;
@@ -117,7 +122,7 @@ function effect(target, callback) {
 }
 
 // src/model.ts
-var FLATTEN;
+var EXPORT;
 var NAMES = /* @__PURE__ */ new WeakMap();
 var STATE = /* @__PURE__ */ new WeakMap();
 var NOTIFY = /* @__PURE__ */ new WeakMap();
@@ -202,16 +207,16 @@ var Model = class _Model {
     }
     if (arg1 === void 0) {
       const values = {};
-      const current = !FLATTEN && (FLATTEN = /* @__PURE__ */ new Map([[self, values]]));
+      const current = !EXPORT && (EXPORT = /* @__PURE__ */ new Map([[self, values]]));
       for (let [key, value] of self) {
-        if (FLATTEN.has(value))
-          value = FLATTEN.get(value);
+        if (EXPORT.has(value))
+          value = EXPORT.get(value);
         else if (value && typeof value.get === "function")
-          FLATTEN.set(value, value = value.get());
+          EXPORT.set(value, value = value.get());
         values[key] = value;
       }
       if (current)
-        FLATTEN = void 0;
+        EXPORT = void 0;
       return Object.freeze(values);
     }
     if (typeof arg2 == "function") {
@@ -234,11 +239,11 @@ var Model = class _Model {
           return arg1.call(self, key, 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
@@ -268,7 +273,7 @@ var Model = class _Model {
    */
   static new(...args) {
     const instance = new this(...args);
-    event(instance, true);
+    emit(instance, true);
     return instance;
   }
   /**
@@ -290,9 +295,6 @@ var Model = class _Model {
     notify.add(listener);
     return () => notify.delete(listener);
   }
-  static at(from, cb) {
-    throw new Error(`Using context requires an adapter. If you are only testing, define \`get.context\` to simulate one.`);
-  }
 };
 define(Model.prototype, "toString", {
   value() {
@@ -312,14 +314,14 @@ function fetch(subject, property, required) {
       return value;
   }
   const error = new Error(`${subject}.${property} is not yet available.`);
-  const promise = new Promise((resolve, reject2) => {
+  const promise = new Promise((resolve, reject) => {
     addListener(subject, (key) => {
       if (key === property) {
         resolve(state[key]);
         return null;
       }
       if (key === null)
-        reject2(new Error(`${subject} is destroyed.`));
+        reject(new Error(`${subject} is destroyed.`));
     });
   });
   throw Object.assign(promise, {
@@ -338,7 +340,7 @@ function update(subject, key, value, silent) {
     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)
@@ -350,13 +352,13 @@ function push(subject, key, silent) {
     PENDING2.set(subject, pending = /* @__PURE__ */ new Set());
     if (!silent)
       queue(() => {
-        event(subject, false);
+        emit(subject, false);
         PENDING2.delete(subject);
       });
   }
   pending.add(key);
   if (!silent)
-    event(subject, key);
+    emit(subject, key);
 }
 var METHODS = new WeakMap([[Model, []]]);
 function assign(to, values) {
@@ -396,6 +398,132 @@ function uid() {
   return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
 }
 
+// src/context.ts
+var Register = /* @__PURE__ */ new WeakMap();
+var Context = class _Context {
+  constructor(inputs) {
+    this.downstream = /* @__PURE__ */ new WeakMap();
+    this.upstream = /* @__PURE__ */ new WeakMap();
+    this.layer = /* @__PURE__ */ new Map();
+    if (inputs)
+      this.include(inputs);
+  }
+  static get(from, callback) {
+    const waiting = Register.get(from);
+    if (!callback)
+      return waiting instanceof _Context ? waiting : void 0;
+    if (waiting instanceof _Context)
+      callback(waiting);
+    else if (waiting)
+      waiting.push(callback);
+    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)];
+    if (result === null)
+      throw new Error(`Did find ${Type} in context, but multiple were defined.`);
+    return result;
+  }
+  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);
+      if (!exists) {
+        const instance = this.add(input);
+        this.layer.set(key, input);
+        init.set(instance, true);
+      } else if (exists !== input) {
+        this.pop();
+        this.id = uid();
+        this.include(inputs);
+      }
+    }
+    for (const [model, explicit] of init) {
+      model.set();
+      if (forEach)
+        forEach(model, explicit);
+      for (const [_key, value] of model)
+        if (PARENT.get(value) === model) {
+          this.add(value, true);
+          init.set(value, false);
+        }
+    }
+  }
+  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();
+    } else {
+      I = input;
+      T = I.constructor;
+      writable = false;
+    }
+    this.has(I);
+    this.put(T, I, implicit, writable);
+    return I;
+  }
+  push(inputs) {
+    const next = Object.create(this);
+    next.layer = /* @__PURE__ */ new Map();
+    if (inputs)
+      next.include(inputs);
+    return next;
+  }
+  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();
+  }
+};
+
 // src/instruction/use.ts
 var INSTRUCT = /* @__PURE__ */ new Map();
 function use(model, argument) {
@@ -467,20 +595,21 @@ Model.on((_, subject) => {
 // src/instruction/get.ts
 var STALE = /* @__PURE__ */ new WeakSet();
 function get(arg0, arg1) {
-  return use((key, subject) => {
+  return use((key, 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.`);
     let source = (resolve) => resolve(from);
     if (arg0 instanceof Model) {
       from = arg0;
-    } else if (arg0.prototype instanceof Model) {
+    } else if (Model.is(arg0)) {
       const hasParent = PARENT.get(from);
       if (!hasParent) {
         if (arg1 === true)
           throw new Error(`${from} may only exist as a child of type ${arg0}.`);
         source = (resolve) => {
-          arg0.at(from, (got) => {
+          Context.get(from, (context) => {
+            const got = context.get(arg0);
             if (got)
               resolve(got);
             else if (arg1 !== false)
@@ -499,10 +628,8 @@ function get(arg0, arg1) {
       let connect2 = function(model) {
         reset = effect(model, (current) => {
           proxy = current;
-          if (!reset)
-            compute2(true);
-          else if (STALE.delete(compute2))
-            compute2();
+          if (!(key in state) || STALE.delete(compute2))
+            compute2(!reset);
           return (didUpdate) => {
             if (didUpdate) {
               STALE.add(compute2);
@@ -666,178 +793,49 @@ function attempt(fn) {
   return compute();
 }
 
-// src/context.ts
-var Expects = /* @__PURE__ */ new WeakMap();
-var Context = class {
-  constructor(inputs) {
-    this.downstream = /* @__PURE__ */ new WeakMap();
-    this.upstream = /* @__PURE__ */ new WeakMap();
-    this.layer = /* @__PURE__ */ new Map();
-    if (inputs)
-      this.include(inputs);
-  }
-  static request(type, from, callback) {
-    let map = Expects.get(from);
-    if (!map)
-      Expects.set(from, map = /* @__PURE__ */ new Map());
-    map.set(type, 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];
-    if (typeof result == "function")
-      return result(model);
-  }
-  get(Type) {
-    const result = this[this.key(Type)];
-    if (result === null)
-      throw new Error(`Did find ${Type} in context, but multiple were defined.`);
-    return result;
-  }
-  include(inputs, forEach) {
-    const init = /* @__PURE__ */ new Map();
-    if (typeof inputs == "function" || inputs instanceof Model)
-      inputs = { [0]: inputs };
-    else if (!inputs)
-      reject(inputs);
-    Object.entries(inputs).forEach(([K, V]) => {
-      if (!(Model.is(V) || V instanceof Model))
-        reject(`${V} as ${K}`);
-    });
-    for (const key in inputs) {
-      const input = inputs[key];
-      const exists = this.layer.get(key);
-      if (!exists) {
-        const instance = this.add(input);
-        this.layer.set(key, input);
-        init.set(instance, true);
-      } else if (exists !== input) {
-        this.pop();
-        this.id = uid();
-        this.include(inputs);
-      }
-    }
-    for (const [model, explicit] of init) {
-      if (forEach)
-        forEach(model, explicit);
-      model.set();
-      this.has(model);
-      const expects = Expects.get(model);
-      if (expects)
-        for (let [T, callback] of expects)
-          this.put(T, callback);
-      for (const [_key, value] of model)
-        if (PARENT.get(value) === model) {
-          this.add(value, true);
-          init.set(value, false);
-        }
-    }
-  }
-  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();
-    } else {
-      I = input;
-      T = I.constructor;
-      writable = false;
-    }
-    this.put(T, I, implicit, writable);
-    return I;
-  }
-  push(inputs) {
-    const next = Object.create(this);
-    next.layer = /* @__PURE__ */ new Map();
-    if (inputs)
-      next.include(inputs);
-    return next;
-  }
-  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();
-  }
-};
-function reject(argument) {
-  throw new Error(`Context can only include Model or instance but got ${argument}.`);
-}
-
 // 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") {
-      Context.request(type, subject, (model) => {
+      expect((model) => {
         subject.set(key, model);
         const remove = () => {
-          drop();
           if (state[key] === model)
             delete state[key];
         };
-        const drop = model.get(null, remove);
+        model.get(null, remove);
         return remove;
       });
       return { get: argument };
     }
-    const children = /* @__PURE__ */ new Set();
-    Context.request(type, subject, (model) => {
-      if (children.has(model))
+    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;
-      children.add(model);
+      value.add(model);
       subject.set(key);
       const done = () => {
         drop();
         if (typeof remove == "function")
           remove();
-        children.delete(model);
+        value.delete(model);
         subject.set(key);
       };
       const drop = model.get(null, done);
       return done;
     });
-    return {
-      value: children
-    };
+    return { value };
   });
 }
 export {
   Context,
   Model,
   Model as default,
+  effect,
   get,
   has,
   ref,

package/package.json

@@ -28,6 +28,6 @@
     "prebuild": "rm -rf dist",
     "preversion": "npm run test && npm run build"
   },
-  "version": "0.47.0",
-  "gitHead": "7c0ddd5ea9b7e08bd5aa21aa8e1ab65ceef17fcf"
+  "version": "0.49.0",
+  "gitHead": "3a1423ef6d335d0e876904459d360a2e0ebdff7b"
 }