@expressive/mvc 0.4.6 → 0.6.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);
@@ -50,11 +25,11 @@ function issues(register) {
     return Library;
 }
 
-const Oops$c = issues({
+const Oops$b = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
 });
 function suspend(source, key) {
-    const error = Oops$c.NotReady(source.subject, key);
+    const error = Oops$b.NotReady(source.subject, key);
     const promise = new Promise(resolve => {
         const release = source.addListener(forKey => {
             if (forKey == key)
@@ -94,174 +69,170 @@ function mayRetry(fn) {
     return compute();
 }
 
-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}].`
+    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`,
+    FactoryFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
+    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
+    ComputeFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`
 });
 const INFO = new WeakMap();
 const KEYS = new WeakMap();
 const ORDER = new WeakMap();
-function get(source, arg1, arg2) {
-    return apply(function from(key) {
-        const { subject, state } = this;
-        const required = arg2 === true || arg1 === true;
-        let getSource;
-        if (typeof arg1 == "boolean")
-            arg1 = undefined;
+function get(arg0, arg1, arg2) {
+    return apply(function get(key) {
+        const { subject } = this;
+        const computeRequired = arg1 === true || arg2 === true;
+        const factoryRequired = arg1 !== false && arg2 !== false;
+        let getter;
         // Easy mistake, using a peer, will always be unresolved.
-        if (typeof source == "symbol")
+        if (typeof arg0 == "symbol")
             throw Oops$a.PeerNotAllowed(subject, key);
-        // replace source controller in-case it is different
-        if (typeof source == "object")
-            getSource = () => ensure(source);
-        // specifically an arrow function (getter factory)
-        else if (!source.prototype) {
-            arg1 = source.call(subject, key);
-            getSource = () => this;
-        }
-        // Regular function is too ambiguous so not allowed.
-        else
-            throw Oops$a.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();
-                throw err;
-            }
-        };
-        const refreshValue = () => {
-            let value;
-            try {
-                value = compute(false);
-            }
-            catch (e) {
-                console.error(e);
-            }
-            finally {
-                if (state.get(key) !== value) {
-                    state.set(key, value);
-                    this.update(key);
-                    return value;
+        if (typeof arg0 == "function" && /^[A-Z]/.test(arg0.name))
+            throw Oops$a.BadSource(subject, key, arg0);
+        this.state.set(key, undefined);
+        const init = () => {
+            let source = this;
+            let setter;
+            if (typeof arg0 == "function") {
+                const result = mayRetry(() => arg0.call(subject, key, subject));
+                if (typeof result == "function")
+                    setter = result;
+                else {
+                    getter = factoryMode(this, result, key, factoryRequired);
+                    return;
                 }
             }
-        };
-        const dependancyDidUpdate = (_key, source) => {
-            if (source !== this) {
-                refreshValue();
+            else if (arg0 instanceof Promise) {
+                getter = factoryMode(this, arg0, key, factoryRequired);
                 return;
             }
-            let pending = KEYS.get(this);
-            if (!pending)
-                KEYS.set(this, pending = []);
-            pending.push(refreshValue);
+            else if (typeof arg1 == "function") {
+                // replace source controller in-case it is different
+                source = ensure(arg0);
+                setter = arg1;
+            }
+            else
+                throw new Error(`Factory argument cannot be ${arg1}`);
+            getter = computeMode(this, source, setter, key, computeRequired);
         };
-        const create = () => {
-            const control = getSource();
-            sub = control.subscribe(dependancyDidUpdate);
+        if (typeof arg0 == "function" && factoryRequired)
             try {
-                const value = compute(true);
-                state.set(key, value);
-                return value;
-            }
-            catch (e) {
-                throw e;
+                init();
             }
-            finally {
-                sub.commit();
-                order.push(refreshValue);
+            catch (err) {
+                Oops$a.ComputeFailed(subject, key).warn();
+                throw err;
             }
-        };
-        INFO.set(refreshValue, info);
         return () => {
-            const value = sub ? state.get(key) : create();
-            if (value === undefined && required)
-                throw suspend(this, key);
-            return value;
+            if (!getter)
+                init();
+            return getter();
         };
     });
 }
+function factoryMode(self, output, key, required) {
+    const { subject, state } = self;
+    let pending;
+    let error;
+    if (output instanceof Promise) {
+        state.set(key, undefined);
+        pending = output
+            .catch(err => error = err)
+            .then(val => {
+            state.set(key, val);
+            return val;
+        })
+            .finally(() => {
+            pending = undefined;
+            self.update(key);
+        });
+    }
+    state.set(key, output);
+    const suspend = () => {
+        if (required === false)
+            return undefined;
+        const issue = Oops$a.NotReady(subject, key);
+        Object.assign(pending, {
+            message: issue.message,
+            stack: issue.stack
+        });
+        throw pending;
+    };
+    return () => {
+        if (error)
+            throw error;
+        if (pending)
+            return suspend();
+        if (state.has(key))
+            return state.get(key);
+    };
+}
+function computeMode(self, source, setter, key, required) {
+    const { subject, state } = self;
+    let sub;
+    let order = ORDER.get(self);
+    if (!order)
+        ORDER.set(self, order = []);
+    const compute = (initial) => {
+        try {
+            return setter.call(sub.proxy, sub.proxy);
+        }
+        catch (err) {
+            Oops$a.Failed(subject, key, initial).warn();
+            throw err;
+        }
+    };
+    const refresh = () => {
+        let value;
+        try {
+            value = compute(false);
+        }
+        catch (e) {
+            console.error(e);
+        }
+        finally {
+            if (state.get(key) !== value) {
+                state.set(key, value);
+                self.update(key);
+                return value;
+            }
+        }
+    };
+    const update = (_key, source) => {
+        if (source !== self) {
+            refresh();
+            return;
+        }
+        let pending = KEYS.get(self);
+        if (!pending)
+            KEYS.set(self, pending = []);
+        pending.push(refresh);
+    };
+    const create = () => {
+        sub = source.subscribe(update);
+        try {
+            const value = compute(true);
+            state.set(key, value);
+            return value;
+        }
+        catch (e) {
+            throw e;
+        }
+        finally {
+            sub.commit();
+            order.push(refresh);
+        }
+    };
+    INFO.set(refresh, key);
+    return () => {
+        const value = sub ? state.get(key) : create();
+        if (value === undefined && required)
+            throw suspend(self, key);
+        return value;
+    };
+}
 function flush(control) {
     const pending = KEYS.get(control);
     if (!pending)
@@ -271,186 +242,77 @@ function flush(control) {
         const compute = pending
             .sort((a, b) => list.indexOf(b) - list.indexOf(a))
             .pop();
-        const { key } = INFO.get(compute);
+        const key = INFO.get(compute);
         if (!control.frame.has(key))
             compute();
     }
     KEYS.delete(control);
 }
 
-class Subscriber {
-    constructor(parent, onUpdate) {
-        this.onUpdate = onUpdate;
-        this.active = false;
-        this.dependant = new Set();
-        const proxy = create(parent.subject);
-        const using = new Map();
-        define(proxy, LOCAL, this);
-        defineProperty(this, "proxy", {
-            configurable: true,
-            get() {
-                if (UPDATE.has(proxy))
-                    setTimeout(() => UPDATE.delete(proxy), 0);
-                return proxy;
-            }
-        });
-        const release = parent.addListener(key => {
-            if (!this.active)
-                return;
-            const handler = using.get(key);
-            let notify;
-            if (typeof handler == "function") {
-                const callback = handler();
-                if (callback === true)
-                    notify = this.onUpdate(key, parent);
-            }
-            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) {
-                parent.waiting.add(getWhy);
-                parent.waiting.add(notify);
-            }
-        });
-        this.commit = () => {
-            this.active = true;
-            this.dependant.forEach(x => x.commit());
-            return this.release;
-        };
-        this.release = () => {
-            this.dependant.forEach(x => x.release());
-            release();
-        };
-        this.add = (key, value) => {
-            if (value !== undefined)
-                using.set(key, value);
-            else if (!using.has(key))
-                using.set(key, true);
-        };
-    }
-}
-
-const UPDATE = new WeakMap();
-function getUpdate(subject) {
-    return UPDATE.get(subject);
+const Oops$9 = 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$9.BadCallback();
+    };
 }
-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))
+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;
-        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));
-    }
+        if (typeof out == "function")
+            unSet = out;
+        else
+            throw Oops$9.BadCallback();
+    };
 }
 
-const Oops$9 = issues({
+const Oops$8 = 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]() {
@@ -503,7 +365,7 @@ class Model {
             const invoke = (key) => {
                 if (!key) {
                     clear();
-                    reject(Oops$9.Timeout(select, typeof argument == "number"
+                    reject(Oops$8.Timeout(select, typeof argument == "number"
                         ? `${argument}ms`
                         : `lifetime of ${this}`));
                 }
@@ -590,11 +452,11 @@ class Model {
             arg = undefined;
         }
         if (!frame.size && arg === true)
-            return Promise.reject(Oops$9.StrictUpdate());
+            return Promise.reject(Oops$8.StrictUpdate());
         return {
             then: (callback) => {
                 if (!callback)
-                    throw Oops$9.NoChaining();
+                    throw Oops$8.NoChaining();
                 if (frame.size || arg !== false)
                     waiting.add(() => {
                         callback(getUpdate(this));
@@ -613,27 +475,204 @@ class Model {
     toString() {
         return this.constructor.name;
     }
-    /**
-     * Creates a new instance of this controller.
-     *
-     * Beyond `new this(...)`, method will activate managed-state.
-     *
-     * @param args - arguments sent to constructor
-     */
-    static create(...args) {
-        const instance = new this(...args);
-        ensure(instance);
-        return instance;
+    /**
+     * Creates a new instance of this controller.
+     *
+     * Beyond `new this(...)`, method will activate managed-state.
+     *
+     * @param args - arguments sent to constructor
+     */
+    static create(...args) {
+        const instance = new this(...args);
+        ensure(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);
+    }
+}
+
+class Subscriber {
+    constructor(parent, onUpdate) {
+        this.onUpdate = onUpdate;
+        this.active = false;
+        this.dependant = new Set();
+        const proxy = create(parent.subject);
+        const using = new Map();
+        const listen = this.add = (key, value) => {
+            if (value !== undefined)
+                using.set(key, value);
+            else if (!using.has(key))
+                using.set(key, true);
+        };
+        LISTEN.set(proxy, listen);
+        defineProperty(proxy, LOCAL, { value: this });
+        defineProperty(this, "proxy", {
+            configurable: true,
+            get() {
+                if (UPDATE.has(proxy))
+                    setTimeout(() => UPDATE.delete(proxy), 0);
+                return proxy;
+            }
+        });
+        const release = parent.addListener(key => {
+            if (!this.active)
+                return;
+            const handler = using.get(key);
+            let notify;
+            if (typeof handler == "function") {
+                const callback = handler();
+                if (callback === true)
+                    notify = this.onUpdate(key, parent);
+            }
+            else if (handler === true)
+                notify = this.onUpdate(key, parent);
+            if (!notify)
+                return;
+            const notate = () => {
+                UPDATE.set(proxy, getUpdate(parent.subject).filter(k => using.has(k)));
+            };
+            parent.waiting.add(notate);
+            parent.waiting.add(notify);
+        });
+        this.commit = () => {
+            this.active = true;
+            this.dependant.forEach(x => x.commit());
+            return this.release;
+        };
+        this.release = () => {
+            this.dependant.forEach(x => x.release());
+            release();
+        };
+    }
+}
+
+const UPDATE = new WeakMap();
+const LISTEN = 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 listen = LISTEN.get(this);
+                if (listen)
+                    listen(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));
     }
-    /**
-     * 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);
+}
+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();
@@ -654,11 +693,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,58 +706,86 @@ 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 listen = LISTEN.get(this);
+                const local = this[LOCAL];
+                if (listen)
+                    listen(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);
     };
 }
 
-const Oops$8 = issues({
+/*! *****************************************************************************
+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$7 = issues({
     DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
 function act(task) {
@@ -726,7 +793,7 @@ function act(task) {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$8.DuplicatePending(key));
+                return Promise.reject(Oops$7.DuplicatePending(key));
             pending = true;
             this.update(key);
             try {
@@ -748,74 +815,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));
@@ -830,83 +829,6 @@ function ref(callback) {
     });
 }
 
-const Oops$7 = issues({
-    NonOptional: (Parent, key) => `Property ${Parent}.${key} is marked as required.`,
-    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
-    Failed: (model, key) => `Generating initial value for ${model}.${key} failed.`
-});
-function put(factory, argument) {
-    return apply(function set(key) {
-        const { subject, state } = this;
-        const required = argument === true || argument === undefined;
-        let set;
-        let get;
-        let pending;
-        let error;
-        const init = () => {
-            const output = typeof factory == "function" ?
-                mayRetry(() => factory.call(subject, key, subject)) :
-                factory;
-            if (output instanceof Promise) {
-                pending = output
-                    .catch(err => error = err)
-                    .then(val => {
-                    state.set(key, val);
-                    return val;
-                })
-                    .finally(() => {
-                    pending = undefined;
-                    this.update(key);
-                });
-                return;
-            }
-            state.set(key, output);
-            return output;
-        };
-        const suspend = () => {
-            if (required === false)
-                return undefined;
-            const issue = Oops$7.NotReady(subject, key);
-            Object.assign(pending, {
-                message: issue.message,
-                stack: issue.stack
-            });
-            throw pending;
-        };
-        if (required)
-            try {
-                init();
-            }
-            catch (err) {
-                Oops$7.Failed(subject, key).warn();
-                throw err;
-            }
-        get = () => {
-            if (pending)
-                return suspend();
-            if (error)
-                throw error;
-            if (state.has(key))
-                return state.get(key);
-            let output = init();
-            return pending
-                ? suspend()
-                : output;
-        };
-        if (typeof argument == "function")
-            set = createValueEffect(argument);
-        else
-            set = (value) => {
-                if (value === undefined && required)
-                    throw Oops$7.NonOptional(subject, key);
-            };
-        return {
-            set,
-            get
-        };
-    });
-}
-
 function set(value, argument) {
     if (!(1 in arguments)) {
         argument = value;
@@ -924,186 +846,246 @@ 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 = Symbol("any");
 function keyed(control, property, initial) {
-    const managed = new Stateful(initial, emit);
-    const context = new WeakMap();
-    const observers = new Set();
+    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) {
-        control.waiting.add(reset);
         control.update(property);
-        observers.forEach(notify => notify(key));
+        control.waiting.add(() => frozen.clear());
+        update.forEach(notify => notify(key));
     }
-    function init(local) {
+    function subscribe(local) {
         const proxy = create(managed);
-        const using = new Set();
-        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();
+        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.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);
-        };
-        local.add(property, false);
-        local.dependant.add({
-            commit() {
-                if (using.size === 0)
-                    using.add(ANY);
-                observers.add(onEvent);
-            },
-            release() {
-                observers.delete(onEvent);
-            }
-        });
         return proxy;
     }
     return {
         value: initial,
         get(local) {
             return local ?
-                context.get(local) || init(local) :
+                context.get(local) || subscribe(local) :
                 managed;
         },
         set(next) {
-            managed.source = next;
             control.state.set(property, next);
+            managed = init(next);
+            context.clear();
             emit(ANY);
         },
         destroy() {
-            observers.clear();
+            update.clear();
+            context.clear();
         }
     };
 }
-class Stateful {
-    constructor(source, emit) {
-        this.source = source;
-        this.emit = emit;
-        if (source instanceof Set)
-            assign(this, {
+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) {
-                    source.add(key);
+                    from.add(key);
                     emit(key);
                     return this;
                 }
-            });
-        else
-            assign(this, {
+            }
+            : {
                 get(key) {
-                    this.watch(key);
-                    return source.get(key);
+                    watch(this, ANY);
+                    return from.get(key);
                 },
                 set(key, value) {
-                    source.set(key, value);
+                    from.set(key, value);
                     emit(key);
                     return this;
                 }
             });
-    }
-    watch(_key) { }
-    has(key) {
-        this.watch(key);
-        return this.source.has(key);
-    }
-    ;
-    delete(key) {
-        this.emit(key);
-        return this.source.delete(key);
-    }
-    ;
-    clear() {
-        this.emit(ANY);
-        this.source.clear();
-    }
-    keys() {
-        this.watch(ANY);
-        return this.source.keys();
-    }
-    values() {
-        this.watch(ANY);
-        return this.source.values();
-    }
-    entries() {
-        this.watch(ANY);
-        return this.source.entries();
-    }
-    ;
-    get size() {
-        this.watch(ANY);
-        return this.source.size;
-    }
-    [Symbol.iterator]() {
-        this.watch(ANY);
-        return this.source[Symbol.iterator]();
-    }
-    ;
+        defineProperty(proxy, "size", {
+            get() {
+                watch(this, ANY);
+                return from.size;
+            }
+        });
+        return proxy;
+    };
 }
 
-const Oops$5 = issues({
+const Parent = new WeakMap();
+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.`
 });
 function use$1(input, argument) {
     return apply(function use(key) {
         const { state, subject } = this;
+        const required = argument !== false;
+        let pending;
+        let error;
+        let get = (_local) => state.get(key);
         if (typeof input === "function")
-            input = Model.isTypeof(input)
-                ? new input()
-                : input();
+            input = /^[A-Z]/.test(input.name)
+                ? new input() : input;
         else if (input && typeof input !== "object")
-            throw Oops$5.BadArgument(typeof input);
+            throw Oops$6.BadArgument(typeof input);
         if (input instanceof Map || input instanceof Set)
             return keyed(this, key, input);
-        function onUpdate(next) {
+        const onUpdate = (next) => {
             state.set(key, next);
             if (next) {
+                get = getRecursive(key, this);
                 Parent.set(next, subject);
                 ensure(next);
             }
             if (typeof argument == "function")
                 argument(next);
             return true;
-        }
-        if (input)
-            onUpdate(input);
+        };
+        const suspend = () => {
+            if (required === false)
+                return;
+            const issue = Oops$6.NotReady(subject, key);
+            Object.assign(pending, {
+                message: issue.message,
+                stack: issue.stack
+            });
+            throw pending;
+        };
+        const initialize = () => {
+            const output = typeof input == "function" ?
+                mayRetry(() => input.call(subject, subject)) :
+                input;
+            if (output instanceof Promise) {
+                pending = output
+                    .catch(err => error = err)
+                    .then(val => {
+                    onUpdate(val);
+                    return val;
+                })
+                    .finally(() => {
+                    pending = undefined;
+                    this.update(key);
+                });
+                return;
+            }
+            onUpdate(output);
+        };
+        if (input !== undefined && required)
+            initialize();
         return {
             set: onUpdate,
-            recursive: true
+            get(local) {
+                if (pending)
+                    return suspend();
+                if (error)
+                    throw error;
+                if (!state.has(key))
+                    initialize();
+                if (pending)
+                    return suspend();
+                return get(local);
+            }
         };
     });
 }
 
+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();
@@ -1388,12 +1370,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;
     }
     /**
@@ -1537,12 +1519,9 @@ exports.STATE = STATE;
 exports.WHY = WHY;
 exports.act = act;
 exports.apply = apply;
-exports.array = array;
 exports["default"] = MVC;
-exports.from = get;
 exports.get = get;
-exports.parent = parent;
-exports.put = put;
+exports.has = has;
 exports.ref = ref;
 exports.set = set;
 exports.tap = tap;