@expressive/mvc 0.38.0 → 0.40.0

package/dist/index.d.ts

@@ -64,6 +64,13 @@ declare namespace Model {
      * Optional returned callback will run when once upon first access.
      */
     type Instruction<T = any, M extends Model = any> = (this: M, key: Model.Field<M> & string, thisArg: M, state: Model.State<M>) => Instruction.Descriptor<T> | Instruction.Getter<T> | void;
+    /**
+     * Model constructor callback - is called when Model finishes intializing.
+     * Returned function will call when model is destroyed.
+     */
+    type Callback = (() => void | (() => void));
+    /** Model constructor argument */
+    type Argument = string | Callback;
 }
 interface Model {
     /**
@@ -73,7 +80,7 @@ interface Model {
     is: this;
 }
 declare class Model {
-    constructor(arg?: string | (() => void | (() => void)));
+    constructor(arg?: Model.Argument);
     /** Pull current values from state. Flattens all models and exotic values recursively. */
     get(): Model.State<this>;
     /**
@@ -181,13 +188,14 @@ 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> = (this: S, on: S) => T;
-    type Factory<R, T> = (this: T, property: string, on: T) => Function<R, T>;
+    type Function<T, S = any> = (on: S, key: string) => T;
+    type Factory<T, S = any> = (this: S, key: string, thisArg: S) => T;
     type Source<T extends Model = Model> = (resolve: (x: T) => void) => void;
 }
 /**
@@ -196,9 +204,9 @@ declare namespace get {
  * will be made available to child upon this request.
  *
  * @param Type - Type of controller compatible with this class.
- * @param required - If true, will throw if Model is created without a parent.
+ * @param expectParent - If true, will throw if Model is created without a parent.
  */
-declare function get<T extends Model>(Type: Model.Type<T>, required?: true): T;
+declare function get<T extends Model>(Type: Model.Type<T>, asParent?: true): T;
 /**
  * Fetches and assigns the controller which spawned this host.
  * When parent assigns an instance via `use()` directive, it
@@ -207,7 +215,7 @@ declare function get<T extends Model>(Type: Model.Type<T>, required?: true): T;
  * @param Type - Type of controller compatible with this class.
  * @param required - If false, property may be undefined. Otherwise will throw suspense.
  */
-declare function get<T extends Model>(Type: Model.Type<T>, required: boolean): T | undefined;
+declare function get<T extends Model>(Type: Model.Type<T>, required?: false): T | undefined;
 /**
  * Implement a computed value from a foreign model. Output will be generated by provided function,
  * where the foreign model will be passed to that function.
@@ -215,20 +223,22 @@ declare function get<T extends Model>(Type: Model.Type<T>, required: boolean): T
  * @param source - Type of Model to fetch for computation.
  * @param compute - Compute function. Will update automatically as input values change.
  */
-declare function get<R, T extends Model>(Type: Model.Type<T>, compute: (this: T, on: T) => R): R;
+declare function get<R, T extends Model>(Type: Model.Type<T>, compute: get.Function<R, T>): R;
 /**
  * Implement a computed value; output will be generated by provided function.
  *
  * @param source - Source model from which computed value will be a subscriber.
  * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value. Will update automatically as input values change.
  */
-declare function get<R, T extends Model>(source: T, compute: (this: T, on: T) => R): R;
+declare function get<R, T extends Model>(source: T, compute: get.Function<R, T>): R;
 /**
  * Implement a computed value; output is returned by function from provided factory.
  *
+ * Factory is bound to owner of property.
+ *
  * @param compute - Factory function to generate a getter to subscribe dependancies.
  */
-declare function get<R, T>(compute: (property: string, on: T) => (this: T, state: T) => R): R;
+declare function get<R, T>(compute: get.Factory<R, T>): R;
 
 declare namespace ref {
     type Callback<T> = (argument: T) => ((next: T | null) => void) | Promise<void> | void | boolean;
@@ -345,19 +355,29 @@ declare function use<T extends Model>(model: T, ready?: (i: T) => void): T;
 /** Create a managed object with observable entries. */
 declare function use<T extends {}, O = use.Object<T>>(data: T, ready?: (object: O) => void): O;
 
+declare namespace has {
+    type Callback<T = any> = (model: T) => void | boolean | (() => void);
+}
+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>;
+
 declare namespace Context {
     type Input = Model | Model.New<Model> | Record<string | number, Model | Model.New<Model>>;
 }
 declare class Context {
-    static get(from: Model, callback: (context: Context) => void): void;
-    key: string;
-    protected table: WeakMap<Model.Type<Model>, symbol>;
+    static request<T extends Model>(type: Model.Type<T>, from: Model, callback: (got: T) => void): void;
+    id: string;
+    protected downstream: WeakMap<Model.Type<Model>, symbol>;
+    protected upstream: WeakMap<Model.Type<Model>, symbol>;
     protected layer: Map<string | number, Model | Model.Type<Model>>;
     constructor(inputs?: Context.Input);
-    protected has(T: Model.Type): keyof this;
+    key(T: Model.Type, upstream?: boolean): keyof this;
+    has(model: Model): (() => void) | undefined;
     get<T extends Model>(Type: Model.Type<T>): T | undefined;
     include(inputs: Context.Input): Map<Model, boolean>;
-    protected add<T extends Model>(input: T | Model.New<T>, implicit?: boolean): T;
+    put<T extends Model>(T: Model.New<T>, I: T | ((model: T) => void), implicit?: boolean, writable?: boolean): void;
+    add<T extends Model>(input: T | Model.New<T>, implicit?: boolean): T;
     push(inputs?: Context.Input): this;
     pop(): void;
 }
@@ -379,4 +399,4 @@ declare global {
     }
 }
 
-export { Context, Model, add, Model as default, get, ref, set, use };
+export { Context, Model, add, Model as default, get, has, ref, set, use };

package/dist/index.js

@@ -25,6 +25,7 @@ __export(src_exports, {
   add: () => add,
   default: () => Model,
   get: () => get,
+  has: () => has,
   ref: () => ref,
   set: () => set,
   use: () => use
@@ -153,6 +154,7 @@ var STATE = /* @__PURE__ */ new WeakMap();
 var NOTIFY = /* @__PURE__ */ new WeakMap();
 var PENDING2 = /* @__PURE__ */ new WeakMap();
 var PARENT = /* @__PURE__ */ new WeakMap();
+var METHOD = /* @__PURE__ */ new WeakMap();
 var define = Object.defineProperty;
 var Model = class _Model {
   constructor(arg) {
@@ -165,6 +167,22 @@ var Model = class _Model {
       new Set(NOTIFY.get(Type)).forEach((x) => addListener(this, x));
       if (Type === _Model)
         break;
+      const desc = Object.getOwnPropertyDescriptors(Type.prototype);
+      for (const key in desc) {
+        let { value } = desc[key];
+        if (typeof value == "function" && key !== "constructor")
+          Object.defineProperty(Type.prototype, key, {
+            get() {
+              const method = value.bind(this.is);
+              METHOD.set(method, value);
+              define(this.is, key, {
+                value: method,
+                configurable: false
+              });
+              return method;
+            }
+          });
+      }
       Type = Object.getPrototypeOf(Type);
     }
     addListener(this, () => {
@@ -295,6 +313,9 @@ 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() {
@@ -412,111 +433,6 @@ Model.on((_, subject) => {
   return null;
 });
 
-// src/context.ts
-var Context = class {
-  constructor(inputs) {
-    this.table = /* @__PURE__ */ new WeakMap();
-    this.layer = /* @__PURE__ */ new Map();
-    if (inputs)
-      this.include(inputs);
-  }
-  static get() {
-    throw new Error(`Using context requires an adapter. If you are only testing, define \`get.context\` to simulate one.`);
-  }
-  has(T) {
-    let key = this.table.get(T);
-    if (!key) {
-      key = Symbol(T.name);
-      this.table.set(T, key);
-    }
-    return key;
-  }
-  get(Type) {
-    const result = this[this.has(Type)];
-    if (result === null)
-      throw new Error(`Did find ${Type} in context, but multiple were defined.`);
-    return result;
-  }
-  include(inputs) {
-    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.key = uid();
-        return this.include(inputs);
-      }
-    }
-    for (const [model] of init)
-      for (const [_key, value] of model)
-        if (PARENT.get(value) === model) {
-          this.add(value, true);
-          init.set(value, false);
-        }
-    return init;
-  }
-  add(input, implicit) {
-    let writable = true;
-    let T;
-    let I;
-    if (typeof input == "function") {
-      T = input;
-      I = input.new();
-    } else {
-      I = input;
-      T = I.constructor;
-      writable = false;
-    }
-    do {
-      const key = this.has(T);
-      const value = this.hasOwnProperty(key) ? null : I;
-      if (value || I !== this[key] && !implicit)
-        Object.defineProperty(this, key, {
-          configurable: true,
-          writable,
-          value
-        });
-      T = Object.getPrototypeOf(T);
-    } while (T !== Model);
-    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/get.ts
 function get(arg0, arg1) {
   return add((key, subject) => {
@@ -532,10 +448,9 @@ function get(arg0, arg1) {
         if (arg1 === true)
           throw new Error(`${from} may only exist as a child of type ${arg0}.`);
         source = (resolve) => {
-          Context.get(from, (context) => {
-            const model = context.get(arg0);
-            if (model)
-              resolve(model);
+          arg0.at(from, (got) => {
+            if (got)
+              resolve(got);
             else if (arg1 !== false)
               throw new Error(`Required ${arg0} not found in context for ${from}.`);
           });
@@ -544,8 +459,10 @@ 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")
-      arg1 = arg0.call(from, key, from);
+    } else if (typeof arg0 == "function") {
+      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));
@@ -575,7 +492,7 @@ function compute(subject, key, source, setter) {
   function compute2(initial) {
     let next;
     try {
-      next = setter.call(proxy, proxy);
+      next = setter.call(proxy, proxy, key);
     } catch (err) {
       console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
       if (initial)
@@ -753,12 +670,180 @@ function use(value, argument) {
     return output;
   });
 }
+
+// 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) {
+    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();
+        return this.include(inputs);
+      }
+    }
+    for (const [model] of init) {
+      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);
+        }
+    }
+    return init;
+  }
+  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 = input.new();
+    } 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 add((key, subject, state) => {
+    if (typeof argument == "boolean") {
+      Context.request(type, subject, (model) => {
+        const remove = () => {
+          drop();
+          if (state[key] === model)
+            delete state[key];
+        };
+        subject.set(key, model);
+        const drop = model.get(null, remove);
+        return remove;
+      });
+      return { get: argument };
+    }
+    const children = /* @__PURE__ */ new Set();
+    Context.request(type, subject, (model) => {
+      if (children.has(model))
+        return;
+      const remove = typeof argument == "function" ? argument(model) : void 0;
+      if (remove === false)
+        return;
+      children.add(model);
+      subject.set(key);
+      const done = () => {
+        drop();
+        if (typeof remove == "function")
+          remove();
+        children.delete(model);
+        subject.set(key);
+      };
+      const drop = model.get(null, done);
+      return done;
+    });
+    return {
+      value: children
+    };
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Context,
   Model,
   add,
   get,
+  has,
   ref,
   set,
   use

package/dist/index.mjs

@@ -120,6 +120,7 @@ var STATE = /* @__PURE__ */ new WeakMap();
 var NOTIFY = /* @__PURE__ */ new WeakMap();
 var PENDING2 = /* @__PURE__ */ new WeakMap();
 var PARENT = /* @__PURE__ */ new WeakMap();
+var METHOD = /* @__PURE__ */ new WeakMap();
 var define = Object.defineProperty;
 var Model = class _Model {
   constructor(arg) {
@@ -132,6 +133,22 @@ var Model = class _Model {
       new Set(NOTIFY.get(Type)).forEach((x) => addListener(this, x));
       if (Type === _Model)
         break;
+      const desc = Object.getOwnPropertyDescriptors(Type.prototype);
+      for (const key in desc) {
+        let { value } = desc[key];
+        if (typeof value == "function" && key !== "constructor")
+          Object.defineProperty(Type.prototype, key, {
+            get() {
+              const method = value.bind(this.is);
+              METHOD.set(method, value);
+              define(this.is, key, {
+                value: method,
+                configurable: false
+              });
+              return method;
+            }
+          });
+      }
       Type = Object.getPrototypeOf(Type);
     }
     addListener(this, () => {
@@ -262,6 +279,9 @@ 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() {
@@ -379,111 +399,6 @@ Model.on((_, subject) => {
   return null;
 });
 
-// src/context.ts
-var Context = class {
-  constructor(inputs) {
-    this.table = /* @__PURE__ */ new WeakMap();
-    this.layer = /* @__PURE__ */ new Map();
-    if (inputs)
-      this.include(inputs);
-  }
-  static get() {
-    throw new Error(`Using context requires an adapter. If you are only testing, define \`get.context\` to simulate one.`);
-  }
-  has(T) {
-    let key = this.table.get(T);
-    if (!key) {
-      key = Symbol(T.name);
-      this.table.set(T, key);
-    }
-    return key;
-  }
-  get(Type) {
-    const result = this[this.has(Type)];
-    if (result === null)
-      throw new Error(`Did find ${Type} in context, but multiple were defined.`);
-    return result;
-  }
-  include(inputs) {
-    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.key = uid();
-        return this.include(inputs);
-      }
-    }
-    for (const [model] of init)
-      for (const [_key, value] of model)
-        if (PARENT.get(value) === model) {
-          this.add(value, true);
-          init.set(value, false);
-        }
-    return init;
-  }
-  add(input, implicit) {
-    let writable = true;
-    let T;
-    let I;
-    if (typeof input == "function") {
-      T = input;
-      I = input.new();
-    } else {
-      I = input;
-      T = I.constructor;
-      writable = false;
-    }
-    do {
-      const key = this.has(T);
-      const value = this.hasOwnProperty(key) ? null : I;
-      if (value || I !== this[key] && !implicit)
-        Object.defineProperty(this, key, {
-          configurable: true,
-          writable,
-          value
-        });
-      T = Object.getPrototypeOf(T);
-    } while (T !== Model);
-    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/get.ts
 function get(arg0, arg1) {
   return add((key, subject) => {
@@ -499,10 +414,9 @@ function get(arg0, arg1) {
         if (arg1 === true)
           throw new Error(`${from} may only exist as a child of type ${arg0}.`);
         source = (resolve) => {
-          Context.get(from, (context) => {
-            const model = context.get(arg0);
-            if (model)
-              resolve(model);
+          arg0.at(from, (got) => {
+            if (got)
+              resolve(got);
             else if (arg1 !== false)
               throw new Error(`Required ${arg0} not found in context for ${from}.`);
           });
@@ -511,8 +425,10 @@ 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")
-      arg1 = arg0.call(from, key, from);
+    } else if (typeof arg0 == "function") {
+      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));
@@ -542,7 +458,7 @@ function compute(subject, key, source, setter) {
   function compute2(initial) {
     let next;
     try {
-      next = setter.call(proxy, proxy);
+      next = setter.call(proxy, proxy, key);
     } catch (err) {
       console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
       if (initial)
@@ -720,12 +636,180 @@ function use(value, argument) {
     return output;
   });
 }
+
+// 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) {
+    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();
+        return this.include(inputs);
+      }
+    }
+    for (const [model] of init) {
+      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);
+        }
+    }
+    return init;
+  }
+  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 = input.new();
+    } 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 add((key, subject, state) => {
+    if (typeof argument == "boolean") {
+      Context.request(type, subject, (model) => {
+        const remove = () => {
+          drop();
+          if (state[key] === model)
+            delete state[key];
+        };
+        subject.set(key, model);
+        const drop = model.get(null, remove);
+        return remove;
+      });
+      return { get: argument };
+    }
+    const children = /* @__PURE__ */ new Set();
+    Context.request(type, subject, (model) => {
+      if (children.has(model))
+        return;
+      const remove = typeof argument == "function" ? argument(model) : void 0;
+      if (remove === false)
+        return;
+      children.add(model);
+      subject.set(key);
+      const done = () => {
+        drop();
+        if (typeof remove == "function")
+          remove();
+        children.delete(model);
+        subject.set(key);
+      };
+      const drop = model.get(null, done);
+      return done;
+    });
+    return {
+      value: children
+    };
+  });
+}
 export {
   Context,
   Model,
   add,
   Model as default,
   get,
+  has,
   ref,
   set,
   use

package/package.json

@@ -28,6 +28,6 @@
     "prebuild": "rm -rf dist",
     "preversion": "npm run test && npm run build"
   },
-  "version": "0.38.0",
-  "gitHead": "8f3d4c7939e483043de4391ee0edb877bb7da63c"
+  "version": "0.40.0",
+  "gitHead": "1eb515499dc2d6571d0cc97406192ce8eb0714d2"
 }