@expressive/mvc 0.10.1 → 0.11.0

package/lib/index.esm.js

@@ -22,11 +22,11 @@ function issues(register) {
     return Library;
 }
 
-const Oops$e = issues({
+const Oops$f = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
 });
 function suspend(source, key) {
-    const error = Oops$e.NotReady(source.subject, key);
+    const error = Oops$f.NotReady(source.subject, key);
     const promise = new Promise(resolve => {
         const release = source.addListener(forKey => {
             if (forKey == key)
@@ -66,7 +66,7 @@ function mayRetry(fn) {
     return compute();
 }
 
-const Oops$d = issues({
+const Oops$e = issues({
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
 });
 const INFO = new WeakMap();
@@ -86,7 +86,7 @@ function computeMode(self, source, setter, key, required) {
             return setter.call(sub.proxy, sub.proxy);
         }
         catch (err) {
-            Oops$d.Failed(subject, key, initial).warn();
+            Oops$e.Failed(subject, key, initial).warn();
             throw err;
         }
     };
@@ -157,6 +157,152 @@ function flush(control) {
     pending.clear();
 }
 
+const Oops$d = issues({
+    BadCallback: () => `Callback for effect-callback may only return a function.`
+});
+function createEffect(model, callback, keys) {
+    return Control.for(model, control => {
+        let unSet;
+        let busy = false;
+        function effect(value) {
+            if (typeof unSet == "function")
+                unSet();
+            unSet = callback.call(this, value);
+            if (unSet instanceof Promise)
+                unSet = undefined;
+            if (unSet && typeof unSet !== "function")
+                throw Oops$d.BadCallback();
+        }
+        function invoke() {
+            if (busy)
+                return;
+            const output = mayRetry(() => {
+                effect.call(model, model);
+            });
+            if (output instanceof Promise) {
+                output.finally(() => busy = false);
+                busy = true;
+            }
+        }
+        if (Array.isArray(keys)) {
+            invoke();
+            return control.addListener(key => {
+                if (key === null) {
+                    if (!keys.length)
+                        invoke();
+                }
+                else if (keys.includes(key))
+                    return invoke;
+            });
+        }
+        const sub = control.subscribe(() => invoke);
+        model = sub.proxy;
+        invoke();
+        return sub.commit();
+    });
+}
+function createValueEffect(callback) {
+    let unSet;
+    return function (value) {
+        if (typeof unSet == "function")
+            unSet(value);
+        const out = callback.call(this, value, this);
+        if (typeof out == "boolean")
+            return out;
+        if (!out || out instanceof Promise)
+            return;
+        if (typeof out == "function")
+            unSet = out;
+        else
+            throw Oops$d.BadCallback();
+    };
+}
+
+const Oops$c = issues({
+    Timeout: (keys, timeout) => `No update seen for [${keys}] within ${timeout}.`,
+    KeysExpected: (key) => `Key "${key}" was expected in current update.`,
+    StrictUpdate: () => `Expected update but none in progress.`,
+    StrictNoUpdate: () => `Update is not expected but one is in progress!`
+});
+function addEventListener(source, arg1, arg2, arg3) {
+    if (typeof arg1 == "string")
+        arg1 = [arg1];
+    return Control.for(source, control => {
+        for (const key of arg1)
+            try {
+                void source[key];
+            }
+            catch (e) { }
+        const removeListener = control.addListener(key => {
+            if (!key && !arg1.length)
+                arg2.call(source, []);
+            if (arg1.includes(key)) {
+                if (arg3)
+                    removeListener();
+                return arg2.bind(source);
+            }
+        });
+        return removeListener;
+    });
+}
+function awaitUpdate(source, arg1, arg2) {
+    const single = typeof arg1 == "string";
+    const keys = typeof arg1 == "string" ? [arg1] :
+        typeof arg1 == "object" ? arg1 :
+            undefined;
+    return new Promise((resolve, reject) => {
+        const timeout = (message) => {
+            const k = keys ? keys.join(", ") : "any";
+            removeListener();
+            reject(Oops$c.Timeout(k, message));
+        };
+        const removeListener = Control.for(source, control => {
+            const pending = control.frame;
+            if (keys === null) {
+                if (pending.size)
+                    reject(Oops$c.StrictNoUpdate());
+                else
+                    resolve(null);
+                return;
+            }
+            if (keys) {
+                if (keys.length) {
+                    if (arg2 === 0 && single && !pending.has(keys[0])) {
+                        reject(Oops$c.KeysExpected(keys[0]));
+                        return;
+                    }
+                    else
+                        for (const key of keys)
+                            try {
+                                void source[key];
+                            }
+                            catch (e) { }
+                }
+            }
+            else if (!pending.size && arg1 === true || arg2 === 0) {
+                reject(Oops$c.StrictUpdate());
+                return;
+            }
+            else
+                control.waiting.add(resolve);
+            return control.addListener(key => {
+                if (!key) {
+                    if (keys && !keys.length)
+                        resolve([]);
+                    else
+                        timeout(`lifetime of ${source}`);
+                }
+                else if (!keys || keys.includes(key)) {
+                    removeListener();
+                    return keys => resolve(single ? control.state.get(key) : keys);
+                }
+            });
+        });
+        if (arg2 && typeof arg2 == "number")
+            setTimeout(() => timeout(`${arg2}ms`), arg2);
+    });
+}
+
 const REGISTER$1 = new WeakMap();
 class Subscriber {
     constructor(parent, onUpdate) {
@@ -229,6 +375,102 @@ class Subscriber {
     }
 }
 
+const Oops$b = issues({
+    NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
+});
+class Model {
+    constructor() {
+        new Control(this);
+        defineProperty(this, "is", { value: this });
+    }
+    on(arg1, arg2, arg3) {
+        if (typeof arg1 == "function")
+            return createEffect(this.is, arg1, arg2);
+        if (typeof arg2 != "function")
+            return awaitUpdate(this.is, arg1, arg2);
+        if (arg1)
+            return addEventListener(this.is, arg1, arg2, arg3);
+    }
+    get(arg1, arg2) {
+        const { state } = Control.for(this);
+        const extract = typeof arg1 == "string"
+            ? () => state.get(arg1)
+            : () => {
+                const output = {};
+                for (const key of arg1 || state.keys())
+                    output[key] = state.get(key);
+                return output;
+            };
+        if (!arg1 || arg2 === undefined)
+            return extract();
+        if (typeof arg2 == "function")
+            return this.on(arg1, () => arg2(extract()));
+        const timeout = typeof arg2 == "number" ? arg2 : undefined;
+        return this.on(arg1, timeout).then(extract);
+    }
+    set(arg1, arg2) {
+        const control = Control.for(this);
+        if (typeof arg1 == "object")
+            for (const key in arg1) {
+                if (arg2 === true || (arg2 ? arg2.includes(key) : control.state.has(key))) {
+                    control.state.set(key, arg1[key]);
+                    control.update(key);
+                }
+            }
+        else if (typeof arg1 == "string") {
+            control.update(arg1);
+            if (1 in arguments) {
+                if (control.state.has(arg1))
+                    control.state.set(arg1, arg2);
+                else if (arg1 in this) {
+                    const method = this[arg1];
+                    if (typeof method == "function")
+                        method.call(this, arg2);
+                }
+            }
+        }
+        return {
+            then: (callback) => {
+                if (!callback)
+                    throw Oops$b.NoChaining();
+                control.waiting.add(callback);
+            }
+        };
+    }
+    /**
+     * Clean up side effects and mark this instance for garbage-collection.
+     */
+    end() {
+        Control.for(this).clear();
+    }
+    /**
+     * Creates a new instance of this controller.
+     *
+     * Beyond `new this(...)`, method will activate managed-state.
+     *
+     * @param args - arguments sent to constructor
+     */
+    static new(...args) {
+        const instance = new this(...args);
+        Control.for(instance);
+        return instance;
+    }
+    /**
+     * Static equivalent of `x instanceof this`.
+     *
+     * Will determine if provided class is a subtype of this one.
+     */
+    static isTypeof(maybe) {
+        return (typeof maybe == "function" &&
+            maybe.prototype instanceof this);
+    }
+}
+defineProperty(Model.prototype, "toString", {
+    value() {
+        return this.constructor.name;
+    }
+});
+
 const REGISTER = new WeakMap();
 const PENDING = new Map();
 class Control {
@@ -257,6 +499,10 @@ class Control {
             return;
         }
         state.set(key, value);
+        if (value instanceof Model) {
+            setRecursive(this, key, value);
+            return;
+        }
         defineProperty(subject, key, {
             enumerable: false,
             set: this.ref(key),
@@ -351,6 +597,68 @@ class Control {
     }
 }
 
+const Parent = new WeakMap();
+const Oops$a = issues({
+    BadAssignment: (parent, expected, got) => `Property ${parent} expected Model of type ${expected} but got ${got}.`
+});
+function getRecursive(key, from) {
+    const context = new WeakMap();
+    const { state } = from;
+    return (local) => {
+        if (!local)
+            return state.get(key);
+        if (!context.has(local)) {
+            let reset;
+            const init = () => {
+                if (reset)
+                    reset();
+                const value = state.get(key);
+                if (Control.get(value)) {
+                    const child = Control.for(value).subscribe(local.onUpdate);
+                    if (local.active)
+                        child.commit();
+                    local.dependant.add(child);
+                    context.set(local, child.proxy);
+                    reset = () => {
+                        child.release();
+                        local.dependant.delete(child);
+                        context.set(local, undefined);
+                        reset = undefined;
+                    };
+                }
+                return true;
+            };
+            local.add(key, init);
+            init();
+        }
+        return context.get(local);
+    };
+}
+function setRecursive(control, key, initial) {
+    const { state, subject } = control;
+    const Type = initial.constructor;
+    let get;
+    const onUpdate = (next) => {
+        state.set(key, next);
+        if (!(next instanceof Type))
+            throw Oops$a.BadAssignment(`${subject}.${key}`, Type.name, String(next));
+        get = getRecursive(key, control);
+        Parent.set(next, subject);
+        Control.for(next);
+        return true;
+    };
+    onUpdate(initial);
+    defineProperty(subject, key, {
+        set: control.ref(key, onUpdate),
+        get() {
+            const local = Subscriber.get(this);
+            if (local)
+                local.add(key);
+            return get(local);
+        }
+    });
+}
+
 /**
  * Run instruction as controller sets itself up.
  * This will specialize the behavior of a given property.
@@ -385,9 +693,9 @@ function add(instruction, label) {
         const control = this;
         defineProperty(subject, key, {
             enumerable: output.enumerable,
-            set: onSet !== false
-                ? this.ref(key, onSet)
-                : undefined,
+            set: onSet === false
+                ? undefined
+                : this.ref(key, onSet),
             get() {
                 if (!state.has(key) && shouldSuspend)
                     throw suspend(control, key);
@@ -401,39 +709,7 @@ function add(instruction, label) {
         });
     }
     PENDING.set(placeholder, setup);
-    return placeholder;
-}
-function getRecursive(key, from) {
-    const context = new WeakMap();
-    return (local) => {
-        if (!local)
-            return from.state.get(key);
-        if (!context.has(local)) {
-            let reset;
-            const init = () => {
-                if (reset)
-                    reset();
-                const value = from.state.get(key);
-                if (Control.get(value)) {
-                    const child = Control.for(value).subscribe(local.onUpdate);
-                    if (local.active)
-                        child.commit();
-                    local.dependant.add(child);
-                    context.set(local, child.proxy);
-                    reset = () => {
-                        child.release();
-                        local.dependant.delete(child);
-                        context.set(local, undefined);
-                        reset = undefined;
-                    };
-                }
-                return true;
-            };
-            local.add(key, init);
-            init();
-        }
-        return context.get(local);
-    };
+    return placeholder;
 }
 
 /*! *****************************************************************************
@@ -461,7 +737,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-const Oops$c = issues({
+const Oops$9 = issues({
     DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
 function run(task) {
@@ -469,7 +745,7 @@ function run(task) {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$c.DuplicatePending(key));
+                return Promise.reject(Oops$9.DuplicatePending(key));
             pending = true;
             this.update(key);
             try {
@@ -491,7 +767,7 @@ function run(task) {
     });
 }
 
-const Oops$b = issues({
+const Oops$8 = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
 function factoryMode(self, output, key, required) {
@@ -515,7 +791,7 @@ function factoryMode(self, output, key, required) {
     const suspend = () => {
         if (required === false)
             return undefined;
-        const issue = Oops$b.NotReady(subject, key);
+        const issue = Oops$8.NotReady(subject, key);
         assign(pending, {
             message: issue.message,
             stack: issue.stack
@@ -532,7 +808,7 @@ function factoryMode(self, output, key, required) {
     };
 }
 
-const Oops$a = issues({
+const Oops$7 = issues({
     PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or tap) as computed source for ${model}.${property}. This is not possible.`,
     ComputeFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
@@ -545,7 +821,7 @@ function get(arg0, arg1, arg2) {
         let getter;
         // Easy mistake, using a peer, will always be unresolved.
         if (typeof arg0 == "symbol")
-            throw Oops$a.PeerNotAllowed(subject, key);
+            throw Oops$7.PeerNotAllowed(subject, key);
         // if(typeof arg0 == "function" && /^[A-Z]/.test(arg0.name))
         //   throw Oops.BadSource(subject, key, arg0);
         this.state.set(key, undefined);
@@ -579,7 +855,7 @@ function get(arg0, arg1, arg2) {
                 init();
             }
             catch (err) {
-                Oops$a.ComputeFailed(subject, key).warn();
+                Oops$7.ComputeFailed(subject, key).warn();
                 throw err;
             }
         return () => {
@@ -590,67 +866,6 @@ function get(arg0, arg1, arg2) {
     });
 }
 
-const Oops$9 = issues({
-    BadCallback: () => `Callback for effect-callback may only return a function.`
-});
-function createEffect(model, callback, keys) {
-    return Control.for(model, control => {
-        let unSet;
-        let busy = false;
-        function effect(value) {
-            if (typeof unSet == "function")
-                unSet();
-            unSet = callback.call(this, value);
-            if (unSet instanceof Promise)
-                unSet = undefined;
-            if (unSet && typeof unSet !== "function")
-                throw Oops$9.BadCallback();
-        }
-        function invoke() {
-            if (busy)
-                return;
-            const output = mayRetry(() => {
-                effect.call(model, model);
-            });
-            if (output instanceof Promise) {
-                output.finally(() => busy = false);
-                busy = true;
-            }
-        }
-        if (Array.isArray(keys)) {
-            invoke();
-            return control.addListener(key => {
-                if (key === null) {
-                    if (!keys.length)
-                        invoke();
-                }
-                else if (keys.includes(key))
-                    return invoke;
-            });
-        }
-        const sub = control.subscribe(() => invoke);
-        model = sub.proxy;
-        invoke();
-        return sub.commit();
-    });
-}
-function createValueEffect(callback) {
-    let unSet;
-    return function (value) {
-        if (typeof unSet == "function")
-            unSet(value);
-        const out = callback.call(this, value, this);
-        if (typeof out == "boolean")
-            return out;
-        if (!out || out instanceof Promise)
-            return;
-        if (typeof out == "function")
-            unSet = out;
-        else
-            throw Oops$9.BadCallback();
-    };
-}
-
 function ref(arg, mapper) {
     return add(function ref(key) {
         let value = {};
@@ -845,8 +1060,7 @@ function createProxy(emit, watch) {
     };
 }
 
-const Parent = new WeakMap();
-const Oops$8 = issues({
+const Oops$6 = issues({
     BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
@@ -858,12 +1072,11 @@ function use$1(input, argument) {
         let error;
         let get = (_local) => state.get(key);
         if (typeof input === "function") {
-            if ("prototype" in input &&
-                input === input.prototype.constructor)
+            if ("prototype" in input && input === input.prototype.constructor)
                 input = new input();
         }
         else if (input && typeof input !== "object")
-            throw Oops$8.BadArgument(typeof input);
+            throw Oops$6.BadArgument(typeof input);
         if (input instanceof Map || input instanceof Set)
             return keyed(this, key, input);
         const onUpdate = (next) => {
@@ -880,7 +1093,7 @@ function use$1(input, argument) {
         const suspend = () => {
             if (required === false)
                 return;
-            const issue = Oops$8.NotReady(subject, key);
+            const issue = Oops$6.NotReady(subject, key);
             assign(pending, {
                 message: issue.message,
                 stack: issue.stack
@@ -925,7 +1138,7 @@ function use$1(input, argument) {
     });
 }
 
-const Oops$7 = issues({
+const Oops$5 = issues({
     Required: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
     Unexpected: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
 });
@@ -936,195 +1149,14 @@ function has(Type, required) {
         const expected = Type.name;
         if (!value) {
             if (required !== false)
-                throw Oops$7.Required(expected, child);
+                throw Oops$5.Required(expected, child);
         }
         else if (!(value instanceof Type))
-            throw Oops$7.Unexpected(expected, child, value);
+            throw Oops$5.Unexpected(expected, child, value);
         return { value };
     });
 }
 
-const Oops$6 = issues({
-    Timeout: (keys, timeout) => `No update seen for [${keys}] within ${timeout}.`,
-    KeysExpected: (key) => `Key "${key}" was expected in current update.`,
-    StrictUpdate: () => `Expected update but none in progress.`,
-    StrictNoUpdate: () => `Update is not expected but one is in progress!`
-});
-function addEventListener(source, arg1, arg2, arg3) {
-    if (typeof arg1 == "string")
-        arg1 = [arg1];
-    return Control.for(source, control => {
-        for (const key of arg1)
-            try {
-                void source[key];
-            }
-            catch (e) { }
-        const removeListener = control.addListener(key => {
-            if (!key && !arg1.length)
-                arg2.call(source, []);
-            if (arg1.includes(key)) {
-                if (arg3)
-                    removeListener();
-                return arg2.bind(source);
-            }
-        });
-        return removeListener;
-    });
-}
-function awaitUpdate(source, arg1, arg2) {
-    const single = typeof arg1 == "string";
-    const keys = typeof arg1 == "string" ? [arg1] :
-        typeof arg1 == "object" ? arg1 :
-            undefined;
-    return new Promise((resolve, reject) => {
-        const timeout = (message) => {
-            const k = keys ? keys.join(", ") : "any";
-            removeListener();
-            reject(Oops$6.Timeout(k, message));
-        };
-        const removeListener = Control.for(source, control => {
-            const pending = control.frame;
-            if (keys === null) {
-                if (pending.size)
-                    reject(Oops$6.StrictNoUpdate());
-                else
-                    resolve(null);
-                return;
-            }
-            if (keys) {
-                if (keys.length) {
-                    if (arg2 === 0 && single && !pending.has(keys[0])) {
-                        reject(Oops$6.KeysExpected(keys[0]));
-                        return;
-                    }
-                    else
-                        for (const key of keys)
-                            try {
-                                void source[key];
-                            }
-                            catch (e) { }
-                }
-            }
-            else if (!pending.size && arg1 === true || arg2 === 0) {
-                reject(Oops$6.StrictUpdate());
-                return;
-            }
-            else
-                control.waiting.add(resolve);
-            return control.addListener(key => {
-                if (!key) {
-                    if (keys && !keys.length)
-                        resolve([]);
-                    else
-                        timeout(`lifetime of ${source}`);
-                }
-                else if (!keys || keys.includes(key)) {
-                    removeListener();
-                    return keys => resolve(single ? control.state.get(key) : keys);
-                }
-            });
-        });
-        if (arg2 && typeof arg2 == "number")
-            setTimeout(() => timeout(`${arg2}ms`), arg2);
-    });
-}
-
-const Oops$5 = issues({
-    NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
-});
-class Model {
-    constructor() {
-        new Control(this);
-        defineProperty(this, "is", { value: this });
-    }
-    on(arg1, arg2, arg3) {
-        if (typeof arg1 == "function")
-            return createEffect(this.is, arg1, arg2);
-        if (typeof arg2 != "function")
-            return awaitUpdate(this.is, arg1, arg2);
-        if (arg1)
-            return addEventListener(this.is, arg1, arg2, arg3);
-    }
-    get(arg1, arg2) {
-        const { state } = Control.for(this);
-        const extract = typeof arg1 == "string"
-            ? () => state.get(arg1)
-            : () => {
-                const output = {};
-                for (const key of arg1 || state.keys())
-                    output[key] = state.get(key);
-                return output;
-            };
-        if (!arg1 || arg2 === undefined)
-            return extract();
-        if (typeof arg2 == "function")
-            return this.on(arg1, () => arg2(extract()));
-        const timeout = typeof arg2 == "number" ? arg2 : undefined;
-        return this.on(arg1, timeout).then(extract);
-    }
-    set(arg1, arg2) {
-        const control = Control.for(this);
-        if (typeof arg1 == "object")
-            for (const key in arg1) {
-                if (arg2 === true || (arg2 ? arg2.includes(key) : control.state.has(key))) {
-                    control.state.set(key, arg1[key]);
-                    control.update(key);
-                }
-            }
-        else if (typeof arg1 == "string") {
-            control.update(arg1);
-            if (1 in arguments) {
-                if (control.state.has(arg1))
-                    control.state.set(arg1, arg2);
-                else if (arg1 in this) {
-                    const method = this[arg1];
-                    if (typeof method == "function")
-                        method.call(this, arg2);
-                }
-            }
-        }
-        return {
-            then: (callback) => {
-                if (!callback)
-                    throw Oops$5.NoChaining();
-                control.waiting.add(callback);
-            }
-        };
-    }
-    /**
-     * Clean up side effects and mark this instance for garbage-collection.
-     */
-    end() {
-        Control.for(this).clear();
-    }
-    /**
-     * Creates a new instance of this controller.
-     *
-     * Beyond `new this(...)`, method will activate managed-state.
-     *
-     * @param args - arguments sent to constructor
-     */
-    static new(...args) {
-        const instance = new this(...args);
-        Control.for(instance);
-        return instance;
-    }
-    /**
-     * Static equivalent of `x instanceof this`.
-     *
-     * Will determine if provided class is a subtype of this one.
-     */
-    static isTypeof(maybe) {
-        return (typeof maybe == "function" &&
-            maybe.prototype instanceof this);
-    }
-}
-defineProperty(Model.prototype, "toString", {
-    value() {
-        return this.constructor.name;
-    }
-});
-
 const Oops$4 = issues({
     NotFound: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`
 });
@@ -1146,7 +1178,19 @@ class Lookup {
     get(T) {
         return this[this.key(T)];
     }
-    add(T, I, writable) {
+    add(input) {
+        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.key(T);
             const conflict = this.hasOwnProperty(key);
@@ -1157,6 +1201,10 @@ class Lookup {
             });
             T = getPrototypeOf(T);
         } while (T !== Model);
+        Control.for(I).state.forEach(value => {
+            if (value instanceof Model)
+                this.add(value);
+        });
     }
     push() {
         return create(this);
@@ -1246,9 +1294,9 @@ function use(init) {
 function useNew(source, arg1, arg2) {
     const instance = React.useMemo(() => {
         const callback = arg2 || arg1;
-        const instance = Model.isTypeof(source) ?
-            source.new() :
-            source();
+        const instance = Model.isTypeof(source)
+            ? new source()
+            : source();
         Control.for(instance);
         if (typeof callback == "function")
             callback(instance);
@@ -1456,28 +1504,22 @@ function useNewContext(include, assign) {
         if (!include)
             throw Oops.NoType();
         const next = ambient.push();
-        function register(I) {
-            if (I instanceof Model)
-                next.add(I.constructor, I, false);
-            else
-                next.add(I, I.new(), true);
-        }
         if (include instanceof Model || typeof include == "function")
-            register(include);
+            next.add(include);
         else
-            values(include).forEach(register);
+            values(include).forEach(x => next.add(x));
         for (const instance of next.local)
-            if (instance)
+            if (instance) {
+                if (assign)
+                    assignWeak(instance, assign);
                 for (const apply of getPending(instance))
                     apply(next);
+            }
         return next;
     }, []);
-    if (assign) {
-        for (const key in assign)
-            for (const into of context.local)
-                if (into && key in into)
-                    into[key] = assign[key];
-    }
+    if (assign)
+        for (const into of context.local)
+            assignWeak(into, assign);
     return context;
 }
 function RenderFunction(props) {
@@ -1490,6 +1532,11 @@ function RenderFunction(props) {
     if (hook.commit)
         React.useLayoutEffect(hook.commit, []);
     return props.render(hook.proxy);
+}
+function assignWeak(into, from) {
+    for (const K in from)
+        if (K in into)
+            into[K] = from[K];
 }
 
 class Global extends MVC {