@expressive/mvc 0.4.5 → 0.5.0

package/lib/index.js

@@ -8,31 +8,6 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
 class Issue extends Error {
     constructor() {
         super(...arguments);
@@ -95,78 +70,6 @@ function mayRetry(fn) {
 }
 
 const Oops$b = issues({
-    BadCallback: () => `Callback for effect-callback may only return a function.`
-});
-const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
-function define(target, key, value) {
-    defineProperty(target, key, { value });
-}
-function defineLazy(object, property, init) {
-    defineProperty(object, property, {
-        configurable: true,
-        get() {
-            const value = init.call(this);
-            defineProperty(this, property, { value });
-            return value;
-        }
-    });
-}
-function createEffect(callback) {
-    let unSet;
-    return function (value) {
-        if (typeof unSet == "function")
-            unSet();
-        unSet = callback.call(this, value);
-        if (unSet instanceof Promise)
-            unSet = undefined;
-        if (unSet && typeof unSet !== "function")
-            throw Oops$b.BadCallback();
-    };
-}
-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$b.BadCallback();
-    };
-}
-
-function ensure(subject, cb) {
-    let control = subject[CONTROL];
-    if (!control) {
-        control = new Controller(subject);
-        define(subject, CONTROL, control);
-    }
-    if (!control.state) {
-        const { waiting } = control;
-        if (cb) {
-            let done;
-            waiting.add(() => {
-                done = cb(control);
-            });
-            return () => done && done();
-        }
-        control.state = new Map();
-        for (const key in subject)
-            control.add(key);
-        const callback = Array.from(waiting);
-        waiting.clear();
-        for (const cb of callback)
-            cb();
-    }
-    return cb ? cb(control) : control;
-}
-
-const Oops$a = issues({
     BadSource: (model, property, got) => `Bad from-instruction provided to ${model}.${property}. Expects an arrow-function or a Model as source. Got ${got}.`,
     PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or tap) as computed source for ${model}.${property}. This is not possible.`,
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
@@ -174,8 +77,8 @@ const Oops$a = issues({
 const INFO = new WeakMap();
 const KEYS = new WeakMap();
 const ORDER = new WeakMap();
-function from(source, arg1, arg2) {
-    return apply(function from(key) {
+function get(source, arg1, arg2) {
+    return apply(function get(key) {
         const { subject, state } = this;
         const required = arg2 === true || arg1 === true;
         let getSource;
@@ -183,7 +86,7 @@ function from(source, arg1, arg2) {
             arg1 = undefined;
         // Easy mistake, using a peer, will always be unresolved.
         if (typeof source == "symbol")
-            throw Oops$a.PeerNotAllowed(subject, key);
+            throw Oops$b.PeerNotAllowed(subject, key);
         // replace source controller in-case it is different
         if (typeof source == "object")
             getSource = () => ensure(source);
@@ -194,24 +97,23 @@ function from(source, arg1, arg2) {
         }
         // Regular function is too ambiguous so not allowed.
         else
-            throw Oops$a.BadSource(subject, key, source);
+            throw Oops$b.BadSource(subject, key, source);
         const setter = arg1;
         const info = { key, parent: this };
         let sub;
         let order = ORDER.get(this);
         if (!order)
             ORDER.set(this, order = []);
-        state.set(key, undefined);
         const compute = (initial) => {
             try {
                 return setter.call(sub.proxy, sub.proxy);
             }
             catch (err) {
-                Oops$a.Failed(subject, key, initial).warn();
+                Oops$b.Failed(subject, key, initial).warn();
                 throw err;
             }
         };
-        const refreshValue = () => {
+        const refresh = () => {
             let value;
             try {
                 value = compute(false);
@@ -227,19 +129,18 @@ function from(source, arg1, arg2) {
                 }
             }
         };
-        const dependancyDidUpdate = (_key, source) => {
+        const update = (_key, source) => {
             if (source !== this) {
-                refreshValue();
+                refresh();
                 return;
             }
             let pending = KEYS.get(this);
             if (!pending)
                 KEYS.set(this, pending = []);
-            pending.push(refreshValue);
+            pending.push(refresh);
         };
         const create = () => {
-            const control = getSource();
-            sub = control.subscribe(dependancyDidUpdate);
+            sub = getSource().subscribe(update);
             try {
                 const value = compute(true);
                 state.set(key, value);
@@ -250,10 +151,11 @@ function from(source, arg1, arg2) {
             }
             finally {
                 sub.commit();
-                order.push(refreshValue);
+                order.push(refresh);
             }
         };
-        INFO.set(refreshValue, info);
+        state.set(key, undefined);
+        INFO.set(refresh, info);
         return () => {
             const value = sub ? state.get(key) : create();
             if (value === undefined && required)
@@ -278,6 +180,39 @@ function flush(control) {
     KEYS.delete(control);
 }
 
+const Oops$a = issues({
+    BadCallback: () => `Callback for effect-callback may only return a function.`
+});
+const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
+function createEffect(callback) {
+    let unSet;
+    return function (value) {
+        if (typeof unSet == "function")
+            unSet();
+        unSet = callback.call(this, value);
+        if (unSet instanceof Promise)
+            unSet = undefined;
+        if (unSet && typeof unSet !== "function")
+            throw Oops$a.BadCallback();
+    };
+}
+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$a.BadCallback();
+    };
+}
+
 class Subscriber {
     constructor(parent, onUpdate) {
         this.onUpdate = onUpdate;
@@ -285,7 +220,7 @@ class Subscriber {
         this.dependant = new Set();
         const proxy = create(parent.subject);
         const using = new Map();
-        define(proxy, LOCAL, this);
+        defineProperty(proxy, LOCAL, { value: this });
         defineProperty(this, "proxy", {
             configurable: true,
             get() {
@@ -306,15 +241,13 @@ class Subscriber {
             }
             else if (handler === true)
                 notify = this.onUpdate(key, parent);
-            const getWhy = () => {
-                const update = getUpdate(parent.subject);
-                const applicable = update.filter(k => using.has(k));
-                UPDATE.set(proxy, applicable);
+            if (!notify)
+                return;
+            const notate = () => {
+                UPDATE.set(proxy, getUpdate(parent.subject).filter(k => using.has(k)));
             };
-            if (notify) {
-                parent.waiting.add(getWhy);
-                parent.waiting.add(notify);
-            }
+            parent.waiting.add(notate);
+            parent.waiting.add(notify);
         });
         this.commit = () => {
             this.active = true;
@@ -334,123 +267,37 @@ class Subscriber {
     }
 }
 
-const UPDATE = new WeakMap();
-function getUpdate(subject) {
-    return UPDATE.get(subject);
-}
-class Controller {
-    constructor(subject) {
-        this.subject = subject;
-        this.frame = new Set();
-        this.waiting = new Set();
-        this.followers = new Set();
-    }
-    subscribe(callback) {
-        return new Subscriber(this, callback);
-    }
-    add(key) {
-        const { subject, state } = this;
-        const { value } = getOwnPropertyDescriptor(subject, key);
-        if (typeof value == "function")
-            return;
-        if (typeof value == "symbol") {
-            const instruction = PENDING.get(value);
-            if (instruction)
-                instruction.call(this, key, this);
-            return;
-        }
-        state.set(key, value);
-        defineProperty(subject, key, {
-            enumerable: false,
-            set: this.ref(key),
-            get() {
-                const local = this[LOCAL];
-                if (local)
-                    local.add(key);
-                return state.get(key);
-            }
-        });
-    }
-    addListener(listener) {
-        this.followers.add(listener);
-        return () => {
-            this.followers.delete(listener);
-        };
-    }
-    ref(key, handler) {
-        const { subject, state } = this;
-        return (value) => {
-            if (state.get(key) == value)
-                return;
-            if (handler)
-                switch (handler.call(subject, value)) {
-                    case true:
-                        this.update(key);
-                    case false:
-                        return;
-                }
-            state.set(key, value);
-            this.update(key);
-        };
-    }
-    update(key) {
-        const { followers, frame, subject, waiting } = this;
-        if (frame.has(key))
-            return;
-        else if (!frame.size)
-            setTimeout(() => {
-                flush(this);
-                UPDATE.set(subject, Array.from(frame));
-                setTimeout(() => {
-                    UPDATE.delete(subject);
-                }, 0);
-                frame.clear();
-                for (const notify of waiting)
-                    try {
-                        waiting.delete(notify);
-                        notify();
-                    }
-                    catch (err) {
-                        console.error(err);
-                    }
-            }, 0);
-        frame.add(key);
-        for (const callback of followers) {
-            const event = callback(key, this);
-            if (typeof event == "function")
-                waiting.add(event);
-        }
-    }
-    clear() {
-        const listeners = [...this.followers];
-        this.followers.clear();
-        listeners.forEach(x => x(null, this));
-    }
-}
-
 const Oops$9 = issues({
     Timeout: (keys, timeout) => `No update for [${keys}] within ${timeout}.`,
     StrictUpdate: () => `Strict update() did not find pending updates.`,
     NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
 });
-const CONTROL = Symbol("CONTROL");
 const WHY = Symbol("UPDATE");
 const LOCAL = Symbol("LOCAL");
 const STATE = Symbol("STATE");
 class Model {
     constructor() {
-        define(this, CONTROL, new Controller(this));
-        define(this, "get", this);
-        define(this, "is", this);
-        defineLazy(this, "set", () => {
-            const controller = ensure(this);
-            const assign = (key, value) => {
-                controller.state.set(key, value);
-                controller.update(key);
-            };
-            for (const key of controller.state.keys())
-                define(assign, key, controller.ref(key));
-            return assign;
+        defineProperty(this, CONTROL, {
+            value: new Controller(this)
+        });
+        defineProperty(this, "is", {
+            value: this
+        });
+        defineProperty(this, "set", {
+            configurable: true,
+            get: () => {
+                const controller = ensure(this);
+                const value = (key, value) => {
+                    controller.state.set(key, value);
+                    controller.update(key);
+                };
+                for (const key of controller.state.keys())
+                    defineProperty(value, key, {
+                        value: controller.ref(key)
+                    });
+                defineProperty(this, "set", { value });
+                return value;
+            }
         });
     }
     get [STATE]() {
@@ -636,6 +483,127 @@ class Model {
     }
 }
 
+const UPDATE = new WeakMap();
+const CONTROL = Symbol("CONTROL");
+function getUpdate(subject) {
+    return UPDATE.get(subject);
+}
+class Controller {
+    constructor(subject) {
+        this.subject = subject;
+        this.frame = new Set();
+        this.waiting = new Set();
+        this.followers = new Set();
+    }
+    subscribe(callback) {
+        return new Subscriber(this, callback);
+    }
+    add(key) {
+        const { subject, state } = this;
+        const { value } = getOwnPropertyDescriptor(subject, key);
+        if (typeof value == "function")
+            return;
+        if (typeof value == "symbol") {
+            const instruction = PENDING.get(value);
+            if (instruction)
+                instruction.call(this, key, this);
+            return;
+        }
+        state.set(key, value);
+        defineProperty(subject, key, {
+            enumerable: false,
+            set: this.ref(key),
+            get() {
+                const local = this[LOCAL];
+                if (local)
+                    local.add(key);
+                return state.get(key);
+            }
+        });
+    }
+    addListener(listener) {
+        this.followers.add(listener);
+        return () => {
+            this.followers.delete(listener);
+        };
+    }
+    ref(key, handler) {
+        const { subject, state } = this;
+        return (value) => {
+            if (state.get(key) == value)
+                return;
+            if (handler)
+                switch (handler.call(subject, value)) {
+                    case true:
+                        this.update(key);
+                    case false:
+                        return;
+                }
+            state.set(key, value);
+            this.update(key);
+        };
+    }
+    update(key) {
+        const { followers, frame, subject, waiting } = this;
+        if (frame.has(key))
+            return;
+        else if (!frame.size)
+            setTimeout(() => {
+                flush(this);
+                UPDATE.set(subject, Array.from(frame));
+                setTimeout(() => {
+                    UPDATE.delete(subject);
+                }, 0);
+                frame.clear();
+                for (const notify of waiting)
+                    try {
+                        waiting.delete(notify);
+                        notify();
+                    }
+                    catch (err) {
+                        console.error(err);
+                    }
+            }, 0);
+        frame.add(key);
+        for (const callback of followers) {
+            const event = callback(key, this);
+            if (typeof event == "function")
+                waiting.add(event);
+        }
+    }
+    clear() {
+        const listeners = [...this.followers];
+        this.followers.clear();
+        listeners.forEach(x => x(null, this));
+    }
+}
+function ensure(subject, cb) {
+    let control = subject[CONTROL];
+    if (!control)
+        defineProperty(subject, CONTROL, {
+            value: control =
+                new Controller(subject)
+        });
+    if (!control.state) {
+        const { waiting } = control;
+        if (cb) {
+            let done;
+            waiting.add(() => {
+                done = cb(control);
+            });
+            return () => done && done();
+        }
+        control.state = new Map();
+        for (const key in subject)
+            control.add(key);
+        const callback = Array.from(waiting);
+        waiting.clear();
+        for (const cb of callback)
+            cb();
+    }
+    return cb ? cb(control) : control;
+}
+
 const PENDING = new Map();
 function apply(fn, label) {
     const name = label || fn.name || "pending";
@@ -654,11 +622,11 @@ function apply(fn, label) {
             defineProperty(subject, key, output);
             return false;
         }
+        let { get: onGet, set: onSet, suspense } = output;
+        if ("value" in output)
+            state.set(key, output.value);
         if ("recursive" in output && output.recursive)
-            output = Object.assign(Object.assign({}, output), { get: getRecursive(key, this) });
-        const desc = output;
-        if ("value" in desc)
-            state.set(key, desc.value);
+            onGet = getRecursive(key, this);
         if ("destroy" in output) {
             const { destroy } = output;
             if (destroy)
@@ -667,57 +635,84 @@ function apply(fn, label) {
                         destroy();
                 });
         }
-        const { get: onGet, set: onSet, enumerable, suspense } = desc;
-        const set = onSet !== false
-            ? this.ref(key, onSet)
-            : undefined;
-        function get() {
-            if (!state.has(key) && suspense)
-                throw suspend(control, key);
-            const local = this[LOCAL];
-            if (local)
-                local.add(key);
-            return onGet
-                ? onGet(local)
-                : state.get(key);
-        }
-        defineProperty(subject, key, { enumerable, get, set });
+        defineProperty(subject, key, {
+            enumerable: output.enumerable,
+            set: onSet !== false
+                ? this.ref(key, onSet)
+                : undefined,
+            get() {
+                if (!state.has(key) && suspense)
+                    throw suspend(control, key);
+                const local = this[LOCAL];
+                if (local)
+                    local.add(key);
+                return onGet
+                    ? onGet(local)
+                    : state.get(key);
+            }
+        });
     }
     PENDING.set(placeholder, setup);
     return placeholder;
 }
 function getRecursive(key, from) {
     const context = new WeakMap();
-    const { state } = from;
     return (local) => {
         if (!local)
-            return state.get(key);
+            return from.state.get(key);
         if (!context.has(local)) {
-            let child;
+            let reset;
             const init = () => {
-                if (child) {
-                    child.release();
-                    local.dependant.delete(child);
-                    context.set(local, undefined);
-                    child = undefined;
-                }
-                const value = state.get(key);
+                if (reset)
+                    reset();
+                const value = from.state.get(key);
                 if (value && CONTROL in value) {
-                    child = ensure(value).subscribe(local.onUpdate);
+                    const child = ensure(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;
             };
-            init();
             local.add(key, init);
+            init();
         }
         return context.get(local);
     };
 }
 
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
 const Oops$8 = issues({
     DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
@@ -748,74 +743,6 @@ function act(task) {
     });
 }
 
-class Managed extends Array {
-    constructor(onUpdate) {
-        super();
-        this.lastUpdate = [0, 0];
-        this.update = (from, to) => {
-            this.lastUpdate = [from, to];
-            onUpdate();
-        };
-    }
-    push(...items) {
-        const { length } = this;
-        const end = super.push(...items);
-        this.update(length, end);
-        return end;
-    }
-    unshift(...items) {
-        const end = super.push(...items);
-        this.update(0, end);
-        return end;
-    }
-    splice(start, deleteCount, ...rest) {
-        const end = deleteCount !== rest.length ? Infinity : deleteCount;
-        this.update(start, end);
-        return super.splice(start, deleteCount, ...rest);
-    }
-}
-function array() {
-    return apply(function array(key) {
-        const context = new WeakMap();
-        const array = new Managed(() => this.update(key));
-        const getLocal = (context) => {
-            const proxy = Object.create(array);
-            let rangeA = 0;
-            let rangeB = 0;
-            const onUpdate = () => {
-                const [lastA, lastB] = array.lastUpdate;
-                if (rangeA <= lastB && rangeB >= lastA)
-                    return true;
-            };
-            const listen = (eventA, eventB) => {
-                if (context.active)
-                    return;
-                context.add(key, onUpdate);
-                rangeA = Math.min(rangeA, eventA);
-                rangeB = Math.max(rangeB, eventB);
-            };
-            proxy[Symbol.iterator] = () => {
-                listen(0, Infinity);
-                return array[Symbol.iterator]();
-            };
-            return proxy;
-        };
-        return {
-            value: array,
-            set: false,
-            get: (local) => {
-                if (!local)
-                    return this.state.get(key);
-                if (context.has(local))
-                    return context.get(local);
-                const output = getLocal(local);
-                context.set(local, output);
-                return output;
-            }
-        };
-    });
-}
-
 function ref(callback) {
     return apply(function ref(key) {
         const value = this.ref(key, callback && createValueEffect(callback));
@@ -838,9 +765,8 @@ const Oops$7 = issues({
 function put(factory, argument) {
     return apply(function set(key) {
         const { subject, state } = this;
-        const required = argument === true || argument === undefined;
-        let set;
-        let get;
+        const required = argument === true ||
+            argument === undefined;
         let pending;
         let error;
         const init = () => {
@@ -863,6 +789,14 @@ function put(factory, argument) {
             state.set(key, output);
             return output;
         };
+        if (required)
+            try {
+                init();
+            }
+            catch (err) {
+                Oops$7.Failed(subject, key).warn();
+                throw err;
+            }
         const suspend = () => {
             if (required === false)
                 return undefined;
@@ -873,30 +807,21 @@ function put(factory, argument) {
             });
             throw pending;
         };
-        if (required)
-            try {
-                init();
-            }
-            catch (err) {
-                Oops$7.Failed(subject, key).warn();
-                throw err;
-            }
-        get = () => {
+        const get = () => {
             if (pending)
                 return suspend();
             if (error)
                 throw error;
             if (state.has(key))
                 return state.get(key);
-            let output = init();
+            const output = init();
             return pending
                 ? suspend()
                 : output;
         };
-        if (typeof argument == "function")
-            set = createValueEffect(argument);
-        else
-            set = (value) => {
+        const set = typeof argument == "function"
+            ? createValueEffect(argument)
+            : (value) => {
                 if (value === undefined && required)
                     throw Oops$7.NonOptional(subject, key);
             };
@@ -924,257 +849,162 @@ function set(value, argument) {
     });
 }
 
-const Parent = new WeakMap();
-const Oops$6 = 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}.`,
-});
-function parent(Expects, required) {
-    return apply(function parent() {
-        const child = this.subject;
-        const value = Parent.get(child);
-        const expected = Expects.name;
-        if (!value) {
-            if (required !== false)
-                throw Oops$6.Required(expected, child);
-        }
-        else if (!(value instanceof Expects))
-            throw Oops$6.Unexpected(expected, child, value);
-        return { value };
-    });
-}
-
-const ANY$1 = Symbol("any");
-function managedMap(control, property, initial) {
-    const managed = new ManagedMap(initial, emit);
-    const context = new WeakMap();
-    const observers = new Set();
+const ANY = Symbol("any");
+function keyed(control, property, initial) {
+    const init = createProxy(emit, watch);
     const frozen = new Set();
-    function reset() {
-        frozen.clear();
+    const context = new Map();
+    const users = new Map();
+    const watched = new WeakMap();
+    const update = new Set();
+    let managed = init(initial);
+    function watch(on, key) {
+        const include = watched.get(on);
+        if (include)
+            include.add(key);
     }
     function emit(key) {
-        observers.forEach(notify => notify(key));
         control.update(property);
-        control.waiting.add(reset);
+        control.waiting.add(() => frozen.clear());
+        update.forEach(notify => notify(key));
     }
-    function init(local) {
+    function subscribe(local) {
         const proxy = create(managed);
-        const using = new Set();
-        observers.add(key => {
-            if (frozen.has(local))
-                return;
-            if (using.has(key) || using.has(ANY$1) || key === ANY$1 && using.size) {
-                const refresh = local.onUpdate(property, control);
-                if (refresh) {
-                    frozen.add(local);
-                    refresh();
+        let watch = users.get(local);
+        if (!watch) {
+            const using = watch = new Set();
+            users.set(local, using);
+            function onEvent(key) {
+                if (frozen.has(local))
+                    return;
+                if (key === ANY || using.has(key) || using.has(ANY)) {
+                    const refresh = local.onUpdate(property, control);
+                    if (refresh) {
+                        frozen.add(local);
+                        refresh();
+                    }
                 }
             }
-        });
-        local.add(property, false);
+            local.add(property, false);
+            local.dependant.add({
+                commit() {
+                    if (using.size === 0)
+                        using.add(ANY);
+                    update.add(onEvent);
+                },
+                release() {
+                    update.delete(onEvent);
+                }
+            });
+        }
+        watched.set(proxy, watch);
         context.set(local, proxy);
-        proxy.watch = (key) => {
-            if (!local.active)
-                using.add(key);
-        };
         return proxy;
     }
     return {
         value: initial,
         get(local) {
-            if (!local)
-                return managed;
-            if (context.has(local))
-                return context.get(local);
-            return init(local);
+            return local ?
+                context.get(local) || subscribe(local) :
+                managed;
         },
         set(next) {
-            managed.source = next;
             control.state.set(property, next);
-            emit(ANY$1);
+            managed = init(next);
+            context.clear();
+            emit(ANY);
         },
         destroy() {
-            observers.clear();
+            update.clear();
+            context.clear();
         }
     };
 }
-class ManagedMap {
-    constructor(source, emit) {
-        this.source = source;
-        this.emit = emit;
-    }
-    watch(_key) { }
-    set(key, value) {
-        this.source.set(key, value);
-        this.emit(key);
-        return this;
-    }
-    ;
-    delete(key) {
-        this.emit(key);
-        return this.source.delete(key);
-    }
-    ;
-    clear() {
-        this.emit(ANY$1);
-        this.source.clear();
-    }
-    get(key) {
-        this.watch(key);
-        return this.source.get(key);
-    }
-    ;
-    has(key) {
-        this.watch(key);
-        return this.source.has(key);
-    }
-    ;
-    values() {
-        this.watch(ANY$1);
-        return this.source.values();
-    }
-    keys() {
-        this.watch(ANY$1);
-        return this.source.keys();
-    }
-    entries() {
-        this.watch(ANY$1);
-        return this.source.entries();
-    }
-    ;
-    [Symbol.iterator]() {
-        this.watch(ANY$1);
-        return this.source[Symbol.iterator]();
-    }
-    ;
-    get size() {
-        this.watch(ANY$1);
-        return this.source.size;
-    }
-}
-
-const ANY = Symbol("any");
-function managedSet(control, property, initial) {
-    const managed = new ManagedSet(initial, emit);
-    const context = new WeakMap();
-    const observers = new Set();
-    const frozen = new Set();
-    function reset() {
-        frozen.clear();
-    }
-    function emit(key) {
-        observers.forEach(notify => notify(key));
-        control.update(property);
-        control.waiting.add(reset);
-    }
-    function init(local) {
-        const proxy = create(managed);
-        const using = new Set();
-        observers.add(key => {
-            if (frozen.has(local))
-                return;
-            if (using.has(key) || using.has(ANY) || key === ANY && using.size) {
-                const refresh = local.onUpdate(property, control);
-                if (refresh) {
-                    frozen.add(local);
-                    refresh();
+function createProxy(emit, watch) {
+    return (from) => {
+        const proxy = create(from);
+        assign(proxy, {
+            from,
+            delete(key) {
+                emit(key);
+                return from.delete(key);
+            },
+            clear() {
+                emit(ANY);
+                from.clear();
+            },
+            has(key) {
+                watch(this, key);
+                return from.has(key);
+            },
+            keys() {
+                watch(this, ANY);
+                return from.keys();
+            },
+            values() {
+                watch(this, ANY);
+                return from.values();
+            },
+            entries() {
+                watch(this, ANY);
+                return from.entries();
+            },
+            forEach(callbackfn, thisArg) {
+                const acc = [];
+                from.forEach((a, b, c) => {
+                    const result = callbackfn.call(thisArg, a, b, c);
+                    if (result !== undefined)
+                        acc.push(result);
+                });
+                watch(this, ANY);
+                return acc;
+            },
+            [Symbol.iterator]() {
+                watch(this, ANY);
+                return from[Symbol.iterator]();
+            },
+        }, from instanceof Set
+            ? {
+                add(key) {
+                    from.add(key);
+                    emit(key);
+                    return this;
+                }
+            }
+            : {
+                get(key) {
+                    watch(this, ANY);
+                    return from.get(key);
+                },
+                set(key, value) {
+                    from.set(key, value);
+                    emit(key);
+                    return this;
                 }
+            });
+        defineProperty(proxy, "size", {
+            get() {
+                watch(this, ANY);
+                return from.size;
             }
         });
-        local.add(property, false);
-        context.set(local, proxy);
-        proxy.watch = (key) => {
-            if (!local.active)
-                using.add(key);
-        };
         return proxy;
-    }
-    return {
-        value: initial,
-        get(local) {
-            if (!local)
-                return managed;
-            if (context.has(local))
-                return context.get(local);
-            return init(local);
-        },
-        set(next) {
-            managed.source = next;
-            control.state.set(property, next);
-            emit(ANY);
-        },
-        destroy() {
-            observers.clear();
-        }
     };
-}
-class ManagedSet {
-    constructor(source, emit) {
-        this.source = source;
-        this.emit = emit;
-    }
-    watch(_key) { }
-    add(key) {
-        this.source.add(key);
-        this.emit(key);
-        return this;
-    }
-    ;
-    delete(key) {
-        this.emit(key);
-        return this.source.delete(key);
-    }
-    ;
-    clear() {
-        this.emit(ANY);
-        this.source.clear();
-    }
-    has(key) {
-        this.watch(key);
-        return this.source.has(key);
-    }
-    ;
-    values() {
-        this.watch(ANY);
-        return this.source.values();
-    }
-    keys() {
-        this.watch(ANY);
-        return this.source.keys();
-    }
-    entries() {
-        this.watch(ANY);
-        return this.source.entries();
-    }
-    ;
-    [Symbol.iterator]() {
-        this.watch(ANY);
-        return this.source[Symbol.iterator]();
-    }
-    ;
-    get size() {
-        this.watch(ANY);
-        return this.source.size;
-    }
 }
 
-const Oops$5 = issues({
+const Parent = new WeakMap();
+const Oops$6 = issues({
     BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
 });
 function use$1(input, argument) {
     return apply(function use(key) {
         const { state, subject } = this;
         if (typeof input === "function")
-            input = Model.isTypeof(input)
-                ? new input()
-                : input();
+            input = "prototype" in input ? new input() : input();
         else if (input && typeof input !== "object")
-            throw Oops$5.BadArgument(typeof input);
-        if (input instanceof Map)
-            return managedMap(this, key, input);
-        if (input instanceof Set)
-            return managedSet(this, key, input);
+            throw Oops$6.BadArgument(typeof input);
+        if (input instanceof Map || input instanceof Set)
+            return keyed(this, key, input);
         function onUpdate(next) {
             state.set(key, next);
             if (next) {
@@ -1194,6 +1024,25 @@ function use$1(input, argument) {
     });
 }
 
+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}.`,
+});
+function has(Expects, required) {
+    return apply(function parent() {
+        const child = this.subject;
+        const value = Parent.get(child);
+        const expected = Expects.name;
+        if (!value) {
+            if (required !== false)
+                throw Oops$5.Required(expected, child);
+        }
+        else if (!(value instanceof Expects))
+            throw Oops$5.Unexpected(expected, child, value);
+        return { value };
+    });
+}
+
 class Lookup {
     constructor() {
         this.table = new Map();
@@ -1478,12 +1327,12 @@ class MVC extends Model {
                 });
             return instance;
         }, []);
-        usePeerContext(instance.get);
+        usePeerContext(instance.is);
         return instance;
     }
     static use(a, b) {
         const instance = useModel(this, a, b);
-        usePeerContext(instance.get);
+        usePeerContext(instance.is);
         return instance;
     }
     /**
@@ -1627,10 +1476,9 @@ exports.STATE = STATE;
 exports.WHY = WHY;
 exports.act = act;
 exports.apply = apply;
-exports.array = array;
 exports["default"] = MVC;
-exports.from = from;
-exports.parent = parent;
+exports.get = get;
+exports.has = has;
 exports.put = put;
 exports.ref = ref;
 exports.set = set;