@expressive/mvc 0.46.0 → 0.48.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,11 +198,8 @@ 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 function add<T = any>(instruction: Model.Instruction): T;
-
 declare namespace get {
     type Function<T, S = any> = (on: S, key: string) => T;
     type Factory<T, S = any> = (this: S, key: string, thisArg: S) => T;
@@ -346,19 +343,9 @@ declare function set<T>(factory: set.Factory<T> | Promise<T>, required?: boolean
  */
 declare function set<T>(value: T | undefined, onUpdate: set.Callback<T>): T;
 
-/** Create a placeholder for specified Model type. */
-declare function use<T extends Model>(): T | undefined;
-/** Create a new child instance of model. */
+declare function use<T = any>(instruction: Model.Instruction): T;
+declare function use<T extends Model>(Type: Model.Type<T>, required: false): T | undefined;
 declare function use<T extends Model>(Type: Model.Type<T>, ready?: (i: T) => void): T;
-/**
- * Use existing model as a child of model assigned to.
- *
- * Note: If `peer` is not already initialized before parent is
- * (created with `new` as opposed to create method), that model will
- * attach this via `parent()` instruction. It will not, however, if
- * already active.
- **/
-declare function use<T extends Model>(model: T, ready?: (i: T) => void): T;
 
 declare namespace has {
     type Callback<T = any> = (model: T) => void | boolean | (() => void);
@@ -368,10 +355,11 @@ declare function has<T extends Model>(type: Model.Type<T>, required: boolean): T
 declare function has<T extends Model>(type: Model.Type<T>, arg?: has.Callback<T>): Set<T>;
 
 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>;
@@ -404,4 +392,4 @@ declare global {
     }
 }
 
-export { Context, Model, add, Model as default, get, has, ref, set, use };
+export { Context, Model, Model as default, get, has, ref, set, use };

package/dist/index.js

@@ -22,7 +22,6 @@ var src_exports = {};
 __export(src_exports, {
   Context: () => Context,
   Model: () => Model,
-  add: () => add,
   default: () => Model,
   get: () => get,
   has: () => has,
@@ -151,7 +150,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();
@@ -197,7 +196,7 @@ var Model = class _Model {
       for (const key in this) {
         const desc = Object.getOwnPropertyDescriptor(this, key);
         if ("value" in desc) {
-          state[key] = desc.value;
+          update(this, key, desc.value, true);
           define(this, key, {
             configurable: false,
             set: (x) => update(this, key, x),
@@ -207,6 +206,8 @@ var Model = class _Model {
           });
         }
       }
+      if (!PARENT.has(this))
+        PARENT.set(this, null);
       addListener(this, () => {
         if (!done)
           throw new Error(`Tried to destroy ${this} but not fully initialized.`);
@@ -234,16 +235,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") {
@@ -322,9 +323,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() {
@@ -344,14 +342,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, {
@@ -368,6 +366,10 @@ function update(subject, key, value, silent) {
   const previous = state[key];
   if (value === previous)
     return true;
+  if (value instanceof Model && !PARENT.has(value)) {
+    PARENT.set(value, subject);
+    event(value, true);
+  }
   state[key] = value;
   if (silent !== true)
     push(subject, key);
@@ -424,26 +426,168 @@ function uid() {
   return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
 }
 
-// src/instruction/add.ts
+// 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 add(instruction) {
+function use(model, argument) {
   const token = Symbol("instruction");
-  INSTRUCT.set(token, instruction);
+  if (Model.is(model)) {
+    const type = model;
+    const value = new model();
+    model = (key, 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);
+        return false;
+      }
+      set2(value);
+      return { set: set2, value };
+    };
+  }
+  INSTRUCT.set(token, model);
   return token;
 }
 Model.on((_, subject) => {
   const state = STATE.get(subject);
-  Object.entries(
-    Object.getOwnPropertyDescriptors(subject)
-  ).forEach(([key, { value }]) => {
+  const props = Object.getOwnPropertyDescriptors(subject);
+  for (const key in props) {
+    const { value } = props[key];
     const instruction = INSTRUCT.get(value);
     if (!instruction)
-      return;
+      continue;
     INSTRUCT.delete(value);
     delete subject[key];
     const output = instruction.call(subject, key, subject, state);
     if (!output)
-      return;
+      continue;
     const desc = typeof output == "object" ? output : { get: output };
     const { enumerable = true } = desc;
     if ("value" in desc)
@@ -472,26 +616,28 @@ Model.on((_, subject) => {
         );
       }
     });
-  });
+  }
   return null;
 });
 
 // src/instruction/get.ts
+var STALE = /* @__PURE__ */ new WeakSet();
 function get(arg0, arg1) {
-  return add((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)
+    if (arg0 instanceof Model) {
       from = arg0;
-    else if (Model.is(arg0)) {
+    } 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)
@@ -502,63 +648,59 @@ function get(arg0, arg1) {
         from = hasParent;
       else
         throw new Error(`New ${from} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
-    } else if (typeof arg0 == "function") {
+    } else {
       const fn = METHOD.get(arg0) || arg0;
       arg1 = (p, k) => fn.call(p, k, p);
     }
-    if (typeof arg1 == "function")
-      return compute(subject, key, source, arg1);
-    source((got) => subject.set(key, got));
-    return { get: arg1 };
-  });
-}
-var STALE = /* @__PURE__ */ new WeakSet();
-function compute(subject, key, source, setter) {
-  let reset;
-  let isAsync;
-  let proxy;
-  function connect(model) {
-    reset = effect(model, (current) => {
-      proxy = current;
-      if (!reset)
-        compute2(true);
-      else if (STALE.delete(compute2))
-        compute2();
-      return (didUpdate) => {
-        if (didUpdate) {
-          STALE.add(compute2);
-          push(subject, key, true);
+    if (typeof arg1 == "function") {
+      let connect2 = function(model) {
+        reset = effect(model, (current) => {
+          proxy = current;
+          if (!(key in state) || STALE.delete(compute2))
+            compute2(!reset);
+          return (didUpdate) => {
+            if (didUpdate) {
+              STALE.add(compute2);
+              push(subject, key, true);
+            }
+          };
+        });
+      }, compute2 = function(initial) {
+        let next;
+        try {
+          next = getter.call(proxy, proxy, key);
+        } catch (err) {
+          console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
+          if (initial)
+            throw err;
+          console.error(err);
         }
+        update(subject, key, next, !isAsync);
       };
-    });
-  }
-  function compute2(initial) {
-    let next;
-    try {
-      next = setter.call(proxy, proxy, key);
-    } catch (err) {
-      console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
-      if (initial)
-        throw err;
-      console.error(err);
-    }
-    update(subject, key, next, !isAsync);
-  }
-  return () => {
-    if (!proxy) {
-      source(connect);
-      isAsync = true;
-    }
-    if (STALE.delete(compute2))
-      compute2();
-    return fetch(subject, key, !proxy);
-  };
+      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, key, !proxy);
+      };
+    } else
+      source((got) => subject.set(key, got));
+    return { get: arg1 };
+  });
 }
 
 // src/instruction/ref.ts
 var define2 = Object.defineProperty;
 function ref(arg, arg2) {
-  return add((key, subject, state) => {
+  return use((key, subject, state) => {
     let value = {};
     if (arg === subject)
       subject.get(() => {
@@ -608,7 +750,7 @@ function ref(arg, arg2) {
 
 // src/instruction/set.ts
 function set(value, argument) {
-  return add((key, subject) => {
+  return use((key, subject) => {
     const output = {};
     if (typeof value == "function" || value instanceof Promise) {
       let init2 = function() {
@@ -664,11 +806,11 @@ function set(value, argument) {
 function attempt(fn) {
   function retry(err) {
     if (err instanceof Promise)
-      return err.then(compute2);
+      return err.then(compute);
     else
       throw err;
   }
-  function compute2() {
+  function compute() {
     try {
       const output = fn();
       return output instanceof Promise ? output.catch(retry) : output;
@@ -676,202 +818,51 @@ function attempt(fn) {
       return retry(err);
     }
   }
-  return compute2();
-}
-
-// src/instruction/use.ts
-function use(value, argument) {
-  return add((property, subject) => {
-    if (typeof value === "function")
-      value = new value();
-    function set2(next) {
-      if (value instanceof Model && !(next instanceof value.constructor))
-        throw new Error(`${subject}.${property} expected Model of type ${value.constructor} but got ${next}.`);
-      if (next instanceof Model) {
-        PARENT.set(next, subject);
-        event(next, true);
-      }
-      if (typeof argument == "function")
-        argument(next);
-    }
-    set2(value);
-    return { set: set2, value };
-  });
-}
-
-// 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}.`);
+  return compute();
 }
 
 // src/instruction/has.ts
 function has(type, argument) {
-  return add((key, subject, state) => {
+  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,
-  add,
   get,
   has,
   ref,

package/dist/index.mjs

@@ -117,7 +117,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();
@@ -163,7 +163,7 @@ var Model = class _Model {
       for (const key in this) {
         const desc = Object.getOwnPropertyDescriptor(this, key);
         if ("value" in desc) {
-          state[key] = desc.value;
+          update(this, key, desc.value, true);
           define(this, key, {
             configurable: false,
             set: (x) => update(this, key, x),
@@ -173,6 +173,8 @@ var Model = class _Model {
           });
         }
       }
+      if (!PARENT.has(this))
+        PARENT.set(this, null);
       addListener(this, () => {
         if (!done)
           throw new Error(`Tried to destroy ${this} but not fully initialized.`);
@@ -200,16 +202,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") {
@@ -288,9 +290,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() {
@@ -310,14 +309,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, {
@@ -334,6 +333,10 @@ function update(subject, key, value, silent) {
   const previous = state[key];
   if (value === previous)
     return true;
+  if (value instanceof Model && !PARENT.has(value)) {
+    PARENT.set(value, subject);
+    event(value, true);
+  }
   state[key] = value;
   if (silent !== true)
     push(subject, key);
@@ -390,26 +393,168 @@ function uid() {
   return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
 }
 
-// src/instruction/add.ts
+// 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 add(instruction) {
+function use(model, argument) {
   const token = Symbol("instruction");
-  INSTRUCT.set(token, instruction);
+  if (Model.is(model)) {
+    const type = model;
+    const value = new model();
+    model = (key, 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);
+        return false;
+      }
+      set2(value);
+      return { set: set2, value };
+    };
+  }
+  INSTRUCT.set(token, model);
   return token;
 }
 Model.on((_, subject) => {
   const state = STATE.get(subject);
-  Object.entries(
-    Object.getOwnPropertyDescriptors(subject)
-  ).forEach(([key, { value }]) => {
+  const props = Object.getOwnPropertyDescriptors(subject);
+  for (const key in props) {
+    const { value } = props[key];
     const instruction = INSTRUCT.get(value);
     if (!instruction)
-      return;
+      continue;
     INSTRUCT.delete(value);
     delete subject[key];
     const output = instruction.call(subject, key, subject, state);
     if (!output)
-      return;
+      continue;
     const desc = typeof output == "object" ? output : { get: output };
     const { enumerable = true } = desc;
     if ("value" in desc)
@@ -438,26 +583,28 @@ Model.on((_, subject) => {
         );
       }
     });
-  });
+  }
   return null;
 });
 
 // src/instruction/get.ts
+var STALE = /* @__PURE__ */ new WeakSet();
 function get(arg0, arg1) {
-  return add((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)
+    if (arg0 instanceof Model) {
       from = arg0;
-    else if (Model.is(arg0)) {
+    } 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)
@@ -468,63 +615,59 @@ function get(arg0, arg1) {
         from = hasParent;
       else
         throw new Error(`New ${from} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
-    } else if (typeof arg0 == "function") {
+    } else {
       const fn = METHOD.get(arg0) || arg0;
       arg1 = (p, k) => fn.call(p, k, p);
     }
-    if (typeof arg1 == "function")
-      return compute(subject, key, source, arg1);
-    source((got) => subject.set(key, got));
-    return { get: arg1 };
-  });
-}
-var STALE = /* @__PURE__ */ new WeakSet();
-function compute(subject, key, source, setter) {
-  let reset;
-  let isAsync;
-  let proxy;
-  function connect(model) {
-    reset = effect(model, (current) => {
-      proxy = current;
-      if (!reset)
-        compute2(true);
-      else if (STALE.delete(compute2))
-        compute2();
-      return (didUpdate) => {
-        if (didUpdate) {
-          STALE.add(compute2);
-          push(subject, key, true);
+    if (typeof arg1 == "function") {
+      let connect2 = function(model) {
+        reset = effect(model, (current) => {
+          proxy = current;
+          if (!(key in state) || STALE.delete(compute2))
+            compute2(!reset);
+          return (didUpdate) => {
+            if (didUpdate) {
+              STALE.add(compute2);
+              push(subject, key, true);
+            }
+          };
+        });
+      }, compute2 = function(initial) {
+        let next;
+        try {
+          next = getter.call(proxy, proxy, key);
+        } catch (err) {
+          console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
+          if (initial)
+            throw err;
+          console.error(err);
         }
+        update(subject, key, next, !isAsync);
       };
-    });
-  }
-  function compute2(initial) {
-    let next;
-    try {
-      next = setter.call(proxy, proxy, key);
-    } catch (err) {
-      console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
-      if (initial)
-        throw err;
-      console.error(err);
-    }
-    update(subject, key, next, !isAsync);
-  }
-  return () => {
-    if (!proxy) {
-      source(connect);
-      isAsync = true;
-    }
-    if (STALE.delete(compute2))
-      compute2();
-    return fetch(subject, key, !proxy);
-  };
+      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, key, !proxy);
+      };
+    } else
+      source((got) => subject.set(key, got));
+    return { get: arg1 };
+  });
 }
 
 // src/instruction/ref.ts
 var define2 = Object.defineProperty;
 function ref(arg, arg2) {
-  return add((key, subject, state) => {
+  return use((key, subject, state) => {
     let value = {};
     if (arg === subject)
       subject.get(() => {
@@ -574,7 +717,7 @@ function ref(arg, arg2) {
 
 // src/instruction/set.ts
 function set(value, argument) {
-  return add((key, subject) => {
+  return use((key, subject) => {
     const output = {};
     if (typeof value == "function" || value instanceof Promise) {
       let init2 = function() {
@@ -630,11 +773,11 @@ function set(value, argument) {
 function attempt(fn) {
   function retry(err) {
     if (err instanceof Promise)
-      return err.then(compute2);
+      return err.then(compute);
     else
       throw err;
   }
-  function compute2() {
+  function compute() {
     try {
       const output = fn();
       return output instanceof Promise ? output.catch(retry) : output;
@@ -642,201 +785,50 @@ function attempt(fn) {
       return retry(err);
     }
   }
-  return compute2();
-}
-
-// src/instruction/use.ts
-function use(value, argument) {
-  return add((property, subject) => {
-    if (typeof value === "function")
-      value = new value();
-    function set2(next) {
-      if (value instanceof Model && !(next instanceof value.constructor))
-        throw new Error(`${subject}.${property} expected Model of type ${value.constructor} but got ${next}.`);
-      if (next instanceof Model) {
-        PARENT.set(next, subject);
-        event(next, true);
-      }
-      if (typeof argument == "function")
-        argument(next);
-    }
-    set2(value);
-    return { set: set2, value };
-  });
-}
-
-// 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}.`);
+  return compute();
 }
 
 // src/instruction/has.ts
 function has(type, argument) {
-  return add((key, subject, state) => {
+  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,
-  add,
   Model as default,
   get,
   has,

package/package.json

@@ -28,6 +28,6 @@
     "prebuild": "rm -rf dist",
     "preversion": "npm run test && npm run build"
   },
-  "version": "0.46.0",
-  "gitHead": "22ffbbadad0ab45f73c71e178183941e78ed2a56"
+  "version": "0.48.0",
+  "gitHead": "1f5ddf82e800cf53bf867ac5e546ad3186ce8bf5"
 }