@expressive/mvc 0.47.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,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 {
@@ -356,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>;

package/dist/index.js

@@ -150,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();
@@ -235,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") {
@@ -323,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() {
@@ -345,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, {
@@ -429,6 +426,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 +623,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 +656,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,172 +821,42 @@ 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:

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();
@@ -202,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") {
@@ -290,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() {
@@ -312,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, {
@@ -396,6 +393,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 +590,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 +623,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,172 +788,42 @@ 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 {

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.48.0",
+  "gitHead": "1f5ddf82e800cf53bf867ac5e546ad3186ce8bf5"
 }