@expressive/mvc 1.0.0-beta.32 → 1.0.0-beta.35

package/lib/index.js

@@ -2,7 +2,38 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var react = require('react');
+var React = require('react');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+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 __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
 
 class Issue extends Error {
     constructor() {
@@ -13,9 +44,6 @@ class Issue extends Error {
     warn() {
         console.warn(this.message);
     }
-    throw() {
-        throw this;
-    }
 }
 function issues(register) {
     const Library = {};
@@ -24,10 +52,10 @@ function issues(register) {
     return Library;
 }
 
-const Oops$8 = issues({
+const Oops$9 = issues({
     BadEffectCallback: () => `Callback for effect-callback may only return a function.`
 });
-const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertyDescriptors, getOwnPropertySymbols, keys: keys$1, values } = Object;
+const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertyDescriptors, getOwnPropertySymbols, keys, values } = Object;
 function define(target, key, value) {
     defineProperty(target, key, { value });
 }
@@ -53,7 +81,7 @@ function createEffect(callback) {
         if (unSet instanceof Promise)
             unSet = undefined;
         if (unSet && typeof unSet !== "function")
-            throw Oops$8.BadEffectCallback();
+            throw Oops$9.BadEffectCallback();
     };
 }
 function createValueEffect(callback) {
@@ -61,7 +89,7 @@ function createValueEffect(callback) {
     return function (value) {
         if (typeof unSet == "function")
             unSet(value);
-        const out = callback.call(this, value);
+        const out = callback.call(this, value, this);
         if (typeof out == "boolean")
             return out;
         if (!out || out instanceof Promise)
@@ -69,95 +97,182 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$8.BadEffectCallback();
+            throw Oops$9.BadEffectCallback();
     };
-}
-function select(source, select) {
-    const proxy = {};
-    for (const k in source)
-        proxy[k] = k;
-    return select(proxy);
-}
-function selectRecursive(using, keys) {
-    const found = new Set();
-    const spy = {};
-    for (const key of new Set(keys))
-        defineProperty(spy, key, {
-            get() {
-                found.add(key);
-                return spy;
+}
+
+const Oops$8 = issues({
+    StrictUpdate: (expected) => `Strict update() did ${expected ? "not " : ""}find pending updates.`,
+    NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
+});
+class Controller {
+    constructor(subject) {
+        this.subject = subject;
+        this.frame = new Set();
+        this.waiting = new Set();
+        this.followers = new Set();
+    }
+    start() {
+        this.state = {};
+        for (const key in this.subject)
+            this.manage(key);
+        const handle = new Set(this.waiting);
+        this.waiting.clear();
+        handle.forEach(cb => cb([]));
+        return this;
+    }
+    manage(key, handler) {
+        const { state, subject } = this;
+        const desc = getOwnPropertyDescriptor(subject, key);
+        if (desc && "value" in desc) {
+            const { value } = desc;
+            const instruction = Pending.get(value);
+            if (instruction) {
+                Pending.delete(value);
+                delete subject[key];
+                instruction.call(this, key, this);
             }
-        });
-    using(spy);
-    return Array.from(found);
+            else if (typeof value !== "function" || /^[A-Z]/.test(key)) {
+                state[key] = value;
+                defineProperty(subject, key, {
+                    enumerable: true,
+                    get: () => state[key],
+                    set: this.setter(key, handler)
+                });
+            }
+        }
+    }
+    setter(key, handler) {
+        const { state, subject } = this;
+        return (value) => {
+            if (state[key] == value)
+                return;
+            if (handler)
+                switch (handler.call(subject, value, state)) {
+                    case true:
+                        this.update(key);
+                    case false:
+                        return;
+                }
+            this.update(key, value);
+        };
+    }
+    addListener(listener) {
+        this.followers.add(listener);
+        return () => {
+            this.followers.delete(listener);
+        };
+    }
+    update(key, value) {
+        if (1 in arguments)
+            this.state[key] = value;
+        if (this.frame.has(key))
+            return;
+        if (!this.frame.size)
+            setTimeout(() => {
+                flush(this);
+                const keys = Object.freeze([...this.frame]);
+                const handle = new Set(this.waiting);
+                this.waiting.clear();
+                this.frame.clear();
+                UPDATE.set(this.subject, keys);
+                setImmediate(() => {
+                    UPDATE.delete(this.subject);
+                });
+                handle.forEach(callback => {
+                    try {
+                        callback(keys);
+                    }
+                    catch (e) { }
+                });
+            }, 0);
+        this.frame.add(key);
+        for (const callback of this.followers) {
+            const event = callback(key, this);
+            if (typeof event == "function")
+                this.waiting.add(event);
+        }
+    }
+    requestUpdate(arg) {
+        if (typeof arg == "function") {
+            this.waiting.add(arg);
+            return;
+        }
+        if (typeof arg == "boolean" && arg !== this.frame.size > 0)
+            return Promise.reject(Oops$8.StrictUpdate(arg));
+        return {
+            then: (callback) => {
+                if (callback)
+                    if (this.frame.size)
+                        this.waiting.add(callback);
+                    else
+                        callback(false);
+                else
+                    throw Oops$8.NoChaining();
+            }
+        };
+    }
 }
 
 class Subscriber {
     constructor(parent, onUpdate) {
         this.onUpdate = onUpdate;
         this.active = false;
-        this.handle = {};
+        this.watch = {};
         this.dependant = new Set();
-        this.listen = (key, from) => {
-            const handler = this.handle[key];
-            if (!handler)
-                return;
-            if (typeof handler == "function")
-                handler();
-            const notify = this.onUpdate(key, from);
-            if (notify)
-                from.waiting.add(notify);
-        };
         if (!(parent instanceof Controller))
-            parent = manage(parent);
-        const subject = this.source =
-            parent.subject;
-        const proxy = this.proxy =
-            create(subject);
+            parent = getController(parent);
         this.parent = parent;
-        define(this.proxy, LOCAL, this);
-        defineProperty(this.proxy, UPDATE, {
-            get: () => (this.parent.handled.filter(key => key in this.handle))
+        this.source = parent.subject;
+        const proxy = this.proxy = create(parent.subject);
+        const DEBUG = (keys) => {
+            UPDATE.set(proxy, keys.filter(k => k in this.watch));
+        };
+        define(proxy, LOCAL, this);
+        defineProperty(this, "proxy", {
+            get: () => {
+                if (UPDATE.has(proxy))
+                    setImmediate(() => {
+                        UPDATE.delete(proxy);
+                    });
+                return proxy;
+            }
         });
-        if ("update" in subject) {
-            define(proxy, "update", (...args) => {
-                if (!args.length) {
-                    const refresh = this.onUpdate("", parent);
-                    if (refresh)
-                        refresh([]);
-                }
-                return subject.update(...args);
+        for (const key in parent.state) {
+            const existing = getOwnPropertyDescriptor(parent.subject, key);
+            const isUsing = () => {
+                this.watch[key] = true;
+                delete proxy[key];
+                return proxy[key];
+            };
+            setAlias(isUsing, `tap ${key}`);
+            defineProperty(proxy, key, {
+                set: existing.set,
+                get: isUsing,
+                configurable: true,
+                enumerable: true
             });
         }
-        for (const key in parent.state)
-            this.spy(key);
-    }
-    spy(key) {
-        const { proxy, source } = this;
-        const { set } = getOwnPropertyDescriptor(source, key);
-        const intercept = () => {
-            this.follow(key);
-            delete proxy[key];
-            return proxy[key];
-        };
-        setAlias(intercept, `tap ${key}`);
-        defineProperty(proxy, key, {
-            get: intercept,
-            set,
-            configurable: true,
-            enumerable: true
-        });
-    }
-    follow(key, callback) {
-        this.handle[key] = callback || true;
-    }
-    commit() {
-        const onDone = this.parent.addListener(this.listen);
-        this.active = true;
-        this.dependant.forEach(x => x.commit());
-        return this.release = () => {
-            this.dependant.forEach(x => x.release());
-            onDone();
+        this.commit = () => {
+            const { parent } = this;
+            const onDone = parent.addListener(key => {
+                const handler = this.watch[key];
+                if (!handler)
+                    return;
+                if (typeof handler == "function")
+                    handler();
+                const notify = this.onUpdate(key, parent);
+                if (notify) {
+                    parent.requestUpdate(DEBUG);
+                    parent.requestUpdate(notify);
+                }
+            });
+            this.active = true;
+            this.dependant.forEach(x => x.commit());
+            return this.release = () => {
+                this.dependant.forEach(x => x.release());
+                onDone();
+            };
         };
     }
 }
@@ -181,7 +296,7 @@ function prepare(parent, key, source, setter, getter) {
     }
     register.set(key, info);
     const current = getter
-        ? () => getter.call(subject, state[key], key)
+        ? () => getter(parent, key)
         : () => state[key];
     function compute(initial) {
         try {
@@ -239,7 +354,7 @@ function prepare(parent, key, source, setter, getter) {
         }
         finally {
             sub.commit();
-            for (const key in sub.handle) {
+            for (const key in sub.watch) {
                 const peer = register.get(key);
                 if (peer && peer.priority >= info.priority)
                     info.priority = peer.priority + 1;
@@ -259,7 +374,7 @@ function prepare(parent, key, source, setter, getter) {
             enumerable: true
         });
 }
-function ensure(on, keys) {
+function ensure$1(on, keys) {
     for (const key of keys) {
         const desc = getOwnPropertyDescriptor(on.subject, key);
         const getter = desc && desc.get;
@@ -282,6 +397,287 @@ function flush(on) {
     KEYS.delete(on);
 }
 
+const CONTROL = Symbol("CONTROL");
+const WHY = Symbol("UPDATE");
+const LOCAL = Symbol("LOCAL");
+const STATE = Symbol("STATE");
+const UPDATE = new WeakMap();
+function ensure(subject, callback) {
+    const control = subject[CONTROL];
+    if (!control.state) {
+        let done;
+        control.requestUpdate(() => {
+            done = callback(control);
+        });
+        return () => done();
+    }
+    return callback(control);
+}
+function getController(subject) {
+    const control = subject[CONTROL];
+    if (!control.state)
+        control.start();
+    if (subject.didCreate)
+        subject.didCreate();
+    return control;
+}
+class Model {
+    constructor() {
+        define(this, CONTROL, new Controller(this));
+        define(this, "get", this);
+        define(this, "set", this);
+    }
+    get [STATE]() {
+        return this[CONTROL].state;
+    }
+    get [WHY]() {
+        return UPDATE.get(this);
+    }
+    on(select, handler, squash, once) {
+        return ensure(this, control => {
+            const keys = typeof select == "string" ? [select] :
+                !select.length ? getOwnPropertyNames(control.state) :
+                    select;
+            ensure$1(control, keys);
+            const callback = squash
+                ? handler.bind(this)
+                : frame => frame
+                    .filter(k => keys.includes(k))
+                    .forEach(k => handler.call(this, control.state[k], k));
+            const trigger = once
+                ? frame => { remove(); callback(frame); }
+                : callback;
+            const remove = control.addListener(key => {
+                if (keys.includes(key))
+                    return trigger;
+            });
+            return remove;
+        });
+    }
+    once(select, callback, squash) {
+        if (callback)
+            return this.on(select, callback, squash, true);
+        return new Promise(resolve => {
+            this.on(select, resolve, true, true);
+        });
+    }
+    effect(callback, select) {
+        const effect = createEffect(callback);
+        return ensure(this, control => {
+            if (!select) {
+                const sub = new Subscriber(control, () => invoke);
+                const invoke = () => {
+                    const x = sub.proxy;
+                    effect.call(x, x);
+                };
+                invoke();
+                return sub.commit();
+            }
+            const invoke = () => {
+                effect.call(this.get, this.get);
+            };
+            invoke();
+            if (!select.length)
+                select.push("willDestroy");
+            return control.addListener(key => {
+                if (select.includes(key))
+                    return invoke;
+            });
+        });
+    }
+    import(from, subset) {
+        for (const key of subset || getOwnPropertyNames(this))
+            if (key in from)
+                this[key] = from[key];
+    }
+    export(subset) {
+        const { state } = getController(this);
+        const output = {};
+        for (const key of subset || getOwnPropertyNames(state))
+            output[key] = state[key];
+        return output;
+    }
+    update(arg, tag) {
+        const control = getController(this);
+        if (typeof arg == "string") {
+            control.update(arg);
+            if (1 in arguments && arg in this) {
+                const method = this[arg];
+                if (typeof method == "function")
+                    if (typeof tag != "boolean")
+                        method.call(this, tag);
+                    else if (tag)
+                        method.call(this);
+            }
+            arg = undefined;
+        }
+        return control.requestUpdate(arg);
+    }
+    destroy() {
+        this.update("willDestroy", true);
+    }
+    toString() {
+        return this.constructor.name;
+    }
+    static create(...args) {
+        const instance = new this(...args);
+        getController(instance);
+        return instance;
+    }
+    static isTypeof(maybe) {
+        return (typeof maybe == "function" &&
+            maybe.prototype instanceof this);
+    }
+}
+Model.CONTROL = CONTROL;
+Model.STATE = STATE;
+Model.LOCAL = LOCAL;
+Model.WHY = WHY;
+defineLazy(Model, CONTROL, function () {
+    return new Controller(this);
+});
+
+const Pending = new Map();
+function apply(fn, label) {
+    const name = label || fn.name || "pending";
+    const placeholder = Symbol(`${name} instruction`);
+    function setup(key) {
+        const { subject, state } = this;
+        let output = fn.call(this, key, this);
+        let desc = {};
+        let get;
+        let set;
+        if (!output)
+            return;
+        if (typeof output == "function")
+            get = output;
+        else {
+            (({ get, set } = output), desc = __rest(output, ["get", "set"]));
+            if ("value" in desc) {
+                state[key] = desc.value;
+                if (get || set)
+                    delete desc.value;
+                else {
+                    defineProperty(subject, key, desc);
+                    return;
+                }
+            }
+        }
+        defineProperty(subject, key, Object.assign(Object.assign({}, desc), { set: this.setter(key, set), get: get
+                ? function () {
+                    return get(state[key], this[LOCAL]);
+                }
+                : () => state[key] }));
+    }
+    Pending.set(placeholder, setup);
+    return placeholder;
+}
+
+//TODO: sync instruction
+function child(source, name) {
+    return apply(function child(key) {
+        const context = new WeakMap();
+        const peer = source.call(this, key);
+        function subscribe(sub) {
+            let child;
+            function init() {
+                if (child) {
+                    child.release();
+                    sub.dependant.delete(child);
+                    context.set(sub, undefined);
+                    child = undefined;
+                }
+                const instance = peer.get();
+                if (instance) {
+                    child = new Subscriber(instance, sub.onUpdate);
+                    if (sub.active)
+                        child.commit();
+                    sub.dependant.add(child);
+                    context.set(sub, child.proxy);
+                }
+            }
+            init();
+            sub.watch[key] = init;
+        }
+        return {
+            value: peer.get(),
+            set: peer.set,
+            get(_value, local) {
+                if (!local)
+                    return peer.get();
+                if (!context.has(local))
+                    subscribe(local);
+                return context.get(local);
+            }
+        };
+    }, name || source.name);
+}
+
+const Parent = new WeakMap();
+const Oops$6 = issues({
+    ParentRequired: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
+    UnexpectedParent: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
+    BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
+});
+function bootstrap(object) {
+    const breakdown = getOwnPropertyDescriptors(object);
+    const control = new Model();
+    for (const key in breakdown)
+        defineProperty(control, key, breakdown[key]);
+    return control;
+}
+function use$1(input, argument) {
+    return child(function use(key) {
+        const { subject } = this;
+        let current;
+        const onUpdate = (next) => {
+            if (next) {
+                current = next instanceof Model
+                    ? next : bootstrap(next);
+                Parent.set(current, subject);
+                getController(current);
+            }
+            else
+                current = undefined;
+            if (typeof argument == "function")
+                return argument(current);
+        };
+        if (input) {
+            const initial = Model.isTypeof(input)
+                ? new input() :
+                input instanceof Model
+                    ? input :
+                    typeof input === "function"
+                        ? input() :
+                        typeof input === "object"
+                            ? bootstrap(input)
+                            : null;
+            if (initial)
+                onUpdate(initial);
+            else if (initial === null)
+                throw Oops$6.BadArgument(typeof input);
+        }
+        return {
+            get: () => current,
+            set: onUpdate
+        };
+    });
+}
+function parent(Expects, required) {
+    return apply(function parent() {
+        const child = this.subject;
+        const expected = Expects.name;
+        const value = Parent.get(this.subject);
+        if (!value) {
+            if (required)
+                throw Oops$6.ParentRequired(expected, child);
+        }
+        else if (!(value instanceof Expects))
+            throw Oops$6.UnexpectedParent(expected, child, value);
+        return { value };
+    });
+}
+
 const Lifecycle = {
     WILL_RENDER: "willRender",
     WILL_UPDATE: "willUpdate",
@@ -289,7 +685,7 @@ const Lifecycle = {
     WILL_UNMOUNT: "willUnmount",
     DID_MOUNT: "didMount"
 };
-const lifecycleEvents = [
+[
     "didCreate",
     "willDestroy",
     ...values(Lifecycle)
@@ -297,7 +693,7 @@ const lifecycleEvents = [
 function lifecycle(prefix) {
     const type = eventsFor(prefix);
     return function useLifecycle(sub, tag) {
-        const emit = react.useMemo(() => {
+        const emit = React__default["default"].useMemo(() => {
             const subject = sub.source;
             const id = typeof tag == "function" ? tag(subject) : tag;
             return (name) => {
@@ -309,7 +705,7 @@ function lifecycle(prefix) {
         emit(sub.active
             ? Lifecycle.WILL_UPDATE
             : Lifecycle.WILL_MOUNT);
-        react.useLayoutEffect(() => {
+        React__default["default"].useLayoutEffect(() => {
             sub.commit();
             emit(Lifecycle.DID_MOUNT);
             return () => {
@@ -323,210 +719,264 @@ function eventsFor(prefix) {
     const map = new Map();
     for (const name of values(Lifecycle)) {
         const alias = prefix + name[0].toUpperCase() + name.slice(1);
-        lifecycleEvents.push(alias);
         map.set(name, alias);
     }
     return (e) => map.get(e);
 }
 
-const CONTROL = Symbol("control");
-const UPDATE = Symbol("update");
-const LOCAL = Symbol("local");
-const STATE = Symbol("state");
-function manage(src) {
-    return src[CONTROL];
+const useElementLifecycle = lifecycle("element");
+const useComponentLifecycle = lifecycle("component");
+function use(init) {
+    const [state, update] = React__default["default"].useState(() => [
+        init(() => update(state.concat()))
+    ]);
+    return state[0];
 }
-const Pending = new Map();
-function apply(fn, label) {
-    const name = label || fn.name || "pending";
-    const placeholder = Symbol(`${name} instruction`);
-    function setup(key) {
-        let output = fn.call(this, key, this);
-        if (typeof output == "function") {
-            const getter = output;
-            output = Object.assign(Object.assign({}, getOwnPropertyDescriptor(this.subject, key)), { get() {
-                    return getter(this[LOCAL]);
-                } });
+function useTap(model, path, expect) {
+    if (typeof path == "function")
+        return useComputed(model, path, expect);
+    const proxy = useActive(model, path, expect);
+    model.update("willRender", true);
+    return proxy;
+}
+function useTag(model, id) {
+    const hook = use(refresh => (new Subscriber(model, () => refresh)));
+    useElementLifecycle(hook, id || 0);
+    return hook.proxy;
+}
+function useNew(model, callback) {
+    const hook = use(refresh => {
+        if (callback)
+            callback(model);
+        return new Subscriber(model, () => refresh);
+    });
+    useComponentLifecycle(hook);
+    return hook.proxy;
+}
+function usePassive(Type, callback) {
+    const instance = React__default["default"].useMemo(() => {
+        const instance = Type.create();
+        if (callback)
+            callback(instance);
+        return instance;
+    }, []);
+    React__default["default"].useLayoutEffect(() => () => instance.destroy(), []);
+    instance.update("willRender", true);
+    return instance;
+}
+function useActive(target, focus, expected) {
+    const hook = use(refresh => {
+        const sub = new Subscriber(target, () => refresh);
+        if (focus) {
+            const source = sub.proxy;
+            defineProperty(sub, "proxy", {
+                get() {
+                    const value = source[focus];
+                    if (value === undefined && expected)
+                        throw suspend(sub.parent, focus);
+                    return value;
+                }
+            });
         }
-        if (output)
-            defineProperty(this.subject, key, output);
-    }
-    Pending.set(placeholder, setup);
-    return placeholder;
+        return sub;
+    });
+    React__default["default"].useLayoutEffect(() => hook.commit(), []);
+    return hook.proxy;
 }
-class Controller {
-    constructor(subject) {
-        this.subject = subject;
-        this.state = {};
-        this.frame = new Set();
-        this.waiting = new Set();
-        this.handled = [];
-        this.followers = new Set();
-    }
-    static setup(onto) {
-        const control = new this(onto);
-        defineProperty(onto, CONTROL, {
-            configurable: true,
-            get() {
-                defineProperty(onto, CONTROL, {
-                    value: control
-                });
-                defineProperty(onto, STATE, {
-                    get: () => (Object.assign({}, control.state)),
-                    configurable: true
-                });
-                defineProperty(onto, UPDATE, {
-                    get: () => [...control.handled],
-                    configurable: true
-                });
-                control.start();
-                if (onto.didCreate)
-                    onto.didCreate();
-                return control;
+function useComputed(target, compute, expected) {
+    const hook = use(refresh => {
+        const sub = new Subscriber(target, () => update);
+        const spy = sub.proxy;
+        let value = compute.call(spy, spy);
+        let update;
+        let retry;
+        const set = (next) => {
+            value = next;
+            if (retry) {
+                retry();
+                retry = undefined;
+            }
+            else
+                refresh();
+        };
+        if (value instanceof Promise) {
+            value.then(set);
+            value = undefined;
+        }
+        else {
+            sub.commit();
+            update = () => {
+                const next = compute.call(spy, spy);
+                if (value != next)
+                    set(next);
+            };
+        }
+        const get = expected
+            ? () => {
+                if (value === undefined)
+                    throw new Promise(res => retry = res);
+                return value;
             }
+            : () => value;
+        defineProperty(sub, "proxy", { get });
+        return sub;
+    });
+    React__default["default"].useLayoutEffect(() => hook.release, []);
+    return hook.proxy;
+}
+function useModel(Type, callback) {
+    const hook = use(refresh => {
+        const instance = new Type();
+        const sub = new Subscriber(instance, () => refresh);
+        const release = sub.parent.addListener((key) => {
+            if (key == Lifecycle.WILL_UNMOUNT)
+                return () => {
+                    instance.destroy();
+                    release();
+                };
         });
-        return control;
+        if (callback)
+            callback(instance);
+        return sub;
+    });
+    useComponentLifecycle(hook);
+    usePeerContext(hook.source);
+    return hook.proxy;
+}
+
+class Lookup {
+    constructor() {
+        this.table = new Map();
     }
-    get pending() {
-        return this.frame.size > 0;
+    get local() {
+        return [
+            ...new Set(getOwnPropertySymbols(this).map(symbol => this[symbol]))
+        ];
     }
-    start() {
-        const { subject } = this;
-        for (const key in subject) {
-            const desc = getOwnPropertyDescriptor(subject, key);
-            if (desc && "value" in desc) {
-                const { value } = desc;
-                const instruction = Pending.get(value);
-                if (instruction) {
-                    Pending.delete(value);
-                    delete subject[key];
-                    instruction.call(this, key, this);
-                }
-                else if (typeof value !== "function" || /^[A-Z]/.test(key))
-                    this.manage(key, value);
-            }
+    key(T) {
+        let key = this.table.get(T);
+        if (!key) {
+            key = Symbol(T.name);
+            this.table.set(T, key);
         }
-        this.emit();
-        return this;
-    }
-    select(using) {
-        const keys = getOwnPropertyNames(this.state);
-        return using
-            ? selectRecursive(using, keys.concat(lifecycleEvents))
-            : keys;
-    }
-    manage(key, initial, effect) {
-        const { state, subject } = this;
-        state[key] = initial;
-        defineProperty(subject, key, {
-            enumerable: true,
-            configurable: true,
-            get: () => state[key],
-            set: this.setter(key, effect)
-        });
+        return key;
     }
-    setter(key, handler) {
-        const { state, subject } = this;
-        return (value) => {
-            if (state[key] == value)
-                return;
-            if (handler)
-                switch (handler.call(subject, value)) {
-                    case true:
-                        this.update(key);
-                    case false:
-                        return;
-                }
-            this.update(key, value);
-        };
+    get(T) {
+        return this[this.key(T)];
     }
-    addListener(listener) {
-        this.followers.add(listener);
-        return () => {
-            this.followers.delete(listener);
-        };
+    push(I) {
+        const next = create(this);
+        if (I instanceof Model || typeof I == "function")
+            next.register(I);
+        else
+            for (const i of values(I))
+                next.register(i);
+        return next;
     }
-    update(key, value) {
-        if (1 in arguments)
-            this.state[key] = value;
-        if (this.frame.has(key))
-            return;
-        if (!this.frame.size)
-            setTimeout(() => this.emit(), 0);
-        this.frame.add(key);
-        for (const subscription of this.followers) {
-            const notify = subscription(key, this);
-            if (notify)
-                this.waiting.add(notify);
+    register(I) {
+        let writable = true;
+        let T;
+        if (I instanceof Model) {
+            T = I.constructor;
+            writable = false;
         }
+        else {
+            T = I;
+            I = I.create();
+        }
+        do {
+            const key = this.key(T);
+            const conflict = this.hasOwnProperty(key);
+            defineProperty(this, key, {
+                value: conflict ? null : I,
+                configurable: true,
+                writable
+            });
+            T = getPrototypeOf(T);
+        } while (T !== Model);
+        return I;
     }
-    emit() {
-        flush(this);
-        const handle = new Set(this.waiting);
-        const handled = this.handled =
-            Object.freeze([...this.frame]);
-        this.waiting.clear();
-        this.frame.clear();
-        handle.forEach(callback => {
-            try {
-                callback(handled);
-            }
-            catch (e) { }
-        });
-    }
-}
-function keys(from, using) {
-    if (typeof using == "string")
-        return [using];
-    if (typeof using == "object") {
-        using = Array.from(using);
-        if (using.length === 0)
-            using = undefined;
-        else
-            return using;
+    pop() {
+        for (const key of getOwnPropertySymbols(this)) {
+            const entry = getOwnPropertyDescriptor(this, key);
+            if (entry.writable)
+                entry.value.destroy();
+        }
     }
-    return from.select(using);
 }
 
-function child(source, name) {
-    return apply(function child(key) {
-        const context = new WeakMap();
-        const current = source.call(this, key);
-        function subscribe(sub) {
-            let child;
-            function start() {
-                const instance = current();
-                if (instance) {
-                    child = new Subscriber(instance, sub.onUpdate);
-                    if (sub.active)
-                        child.commit();
-                    sub.dependant.add(child);
-                    context.set(sub, child.proxy);
-                }
-            }
-            function restart() {
-                if (child) {
-                    child.release();
-                    sub.dependant.delete(child);
-                    context.set(sub, undefined);
-                    child = undefined;
-                }
-                start();
-            }
-            start();
-            sub.follow(key, restart);
-        }
-        return (local) => {
-            if (!local)
-                return current();
-            if (!context.has(local))
-                subscribe(local);
-            return context.get(local);
+const Oops$5 = issues({
+    NoProviderType: () => `Provider 'of' prop must be Model, typeof Model or a collection of them.`,
+    NothingInContext: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`,
+    BadConsumerProps: () => `Provider expects either a render function, 'get' or 'has' props.`
+});
+const LookupContext = React__default["default"].createContext(new Lookup());
+const useLookup = () => React__default["default"].useContext(LookupContext);
+function useContext(Type, strict) {
+    const instance = useLookup().get(Type);
+    if (!instance && strict)
+        throw Oops$5.NothingInContext(Type.name);
+    return instance;
+}
+function Consumer(props) {
+    const { get, has, children, of: Control } = props;
+    if (typeof children == "function")
+        return children(useTap(useContext(Control)));
+    const callback = has || get;
+    if (typeof callback == "function")
+        callback(useContext(Control, !!has));
+    else
+        throw Oops$5.BadConsumerProps();
+    return null;
+}
+function useNewContext(inject) {
+    const from = useLookup();
+    return React__default["default"].useMemo(() => {
+        if (!inject)
+            throw Oops$5.NoProviderType();
+        const context = from.push(inject);
+        for (const instance of context.local)
+            if (instance)
+                for (const apply of getPending(instance))
+                    apply(context);
+        return context;
+    }, []);
+}
+function useAppliedProps(within, props) {
+    const update = React__default["default"].useMemo(() => {
+        const targets = within.local;
+        return function integrate(props) {
+            for (const [key, value] of entries(props))
+                if (key != "of" && key != "children")
+                    for (const into of targets)
+                        if (into && key in into)
+                            into[key] = value;
         };
-    }, name || source.name);
+    }, []);
+    update(props);
+}
+function RenderFunction(props) {
+    const hook = use(refresh => {
+        const targets = props.context.local;
+        if (targets.length == 1)
+            return new Subscriber(targets[0], () => refresh);
+        return {};
+    });
+    if (hook.commit)
+        React__default["default"].useLayoutEffect(() => hook.commit(), []);
+    return props.render(hook.proxy);
+}
+function Provider(props) {
+    const context = useNewContext(props.of);
+    const render = props.children;
+    useAppliedProps(context, props);
+    React__default["default"].useLayoutEffect(() => () => context.pop(), []);
+    return React__default["default"].createElement(LookupContext.Provider, { value: context }, typeof render == "function"
+        ? React__default["default"].createElement(RenderFunction, { context, render })
+        : render);
 }
 
-const Oops$6 = issues({
+const Oops$4 = issues({
     CantAttachGlobal: (parent, child) => `Singleton '${parent}' attempted to attach '${child}' but it is not also a singleton.`,
     AmbientRequired: (requested, requester, key) => `Attempted to find an instance of ${requested} in context. It is required for [${requester}.${key}], but one could not be found.`
 });
@@ -534,14 +984,16 @@ const PendingContext = new WeakMap();
 const ContextWasUsed = new WeakMap();
 function tap(type, argument) {
     return child(function tap(key) {
-        return pendingAccess(this.subject, type, key, argument);
+        return {
+            get: pendingAccess(this.subject, type, key, argument)
+        };
     });
 }
 function pendingAccess(from, type, key, argument) {
-    if ("current" in type)
-        return () => type.current;
-    if ("current" in from.constructor)
-        throw Oops$6.CantAttachGlobal(from, type.name);
+    if ("set" in type)
+        return () => type.get();
+    if ("set" in from.constructor)
+        throw Oops$4.CantAttachGlobal(from, type.name);
     let instance;
     getPending(from).push(context => {
         instance = context.get(type);
@@ -550,7 +1002,7 @@ function pendingAccess(from, type, key, argument) {
                 instance = undefined;
         }
         else if (!instance && argument)
-            throw Oops$6.AmbientRequired(type.name, from, key);
+            throw Oops$4.AmbientRequired(type.name, from, key);
     });
     return () => instance;
 }
@@ -576,7 +1028,7 @@ function getPending(subject) {
     return pending;
 }
 
-const Oops$5 = issues({
+const Oops$3 = issues({
     DuplicateAction: (key) => `Invoked action ${key} but one is already active.`,
     BadComputedSource: (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.`
@@ -593,7 +1045,7 @@ function ref(arg) {
     return apply(function ref(key) {
         let value = {};
         if (typeof arg == "object") {
-            const source = manage(arg);
+            const source = getController(arg);
             for (const key in source.state)
                 defineLazy(value, key, createRef.bind(source, key));
         }
@@ -607,7 +1059,7 @@ function act(task) {
         let pending = false;
         const invoke = (...args) => {
             if (pending)
-                return Promise.reject(Oops$5.DuplicateAction(key));
+                return Promise.reject(Oops$3.DuplicateAction(key));
             pending = true;
             this.update(key);
             return new Promise(res => {
@@ -628,16 +1080,19 @@ function act(task) {
         };
     });
 }
-function from(source, setter, getter) {
+function from(source, setter, argument) {
     return apply(function from(key) {
-        const { subject } = this;
         let getSource;
+        const { subject } = this;
+        const getter = argument === true
+            ? pendingValue
+            : argument || undefined;
         // Easy mistake, using a peer, will always be unresolved.
         if (typeof source == "symbol")
-            throw Oops$5.PeerNotAllowed(subject, key);
+            throw Oops$3.PeerNotAllowed(subject, key);
         // replace source controller in-case different
         if (typeof source == "object")
-            getSource = () => manage(source);
+            getSource = () => getController(source);
         // specifically an arrow function (getter factory)
         else if (!source.prototype) {
             setter = source.call(subject, key);
@@ -646,22 +1101,24 @@ function from(source, setter, getter) {
         // is a peer Model (constructor)
         else if (Model.isTypeof(source))
             getSource = pendingAccess(subject, source, key, true);
-        // Regular function is to ambiguous so not allowed.
+        // Regular function is too ambiguous so not allowed.
         else
-            throw Oops$5.BadComputedSource(subject, key, source);
+            throw Oops$3.BadComputedSource(subject, key, source);
         prepare(this, key, getSource, setter, getter);
     });
 }
 
-const Oops$4 = issues({
+const Oops$2 = issues({
     ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
+/* deprecated - ignore coverage */
+/* istanbul ignore next */
 function pending(source, compute) {
-    return (source === undefined ?
-        suspendForValue() :
-        typeof source == "function" && !source.prototype ?
-            suspendForAsync(source) :
-            suspendForComputed(source, compute));
+    if (source === undefined)
+        return set();
+    if (typeof source == "function" && !source.prototype)
+        return set(source);
+    return from(source, compute, true);
 }
 /**
  * Get value, suspend instead if undefined.
@@ -675,442 +1132,140 @@ function pendingValue(via, key) {
         throw suspend(via, key);
     return value;
 }
-function suspend(source, key) {
-    const error = Oops$4.ValueNotReady(source.subject, key);
-    const promise = new Promise(resolve => {
-        const release = source.addListener(forKey => {
-            if (forKey == key)
-                return () => {
-                    if (source.state[key] !== undefined) {
-                        release();
-                        resolve();
-                    }
-                };
-        });
-    });
-    return Object.assign(promise, {
-        toString: () => String(error),
-        name: "Suspense",
-        message: error.message,
-        stack: error.stack
-    });
-}
-function suspendForComputed(source, compute) {
-    function getter(_value, key) {
-        return pendingValue(manage(this), key);
-    }
-    return from(source, compute, getter);
-}
-function suspendForValue() {
-    return apply(function pending(key) {
-        this.state[key] = undefined;
-        return {
-            set: this.setter(key),
-            get: () => pendingValue(this, key)
-        };
-    });
-}
-function suspendForAsync(source) {
-    return apply(function suspense(key) {
-        const subject = this.subject;
-        let waiting = true;
-        let value;
-        let error;
-        return () => {
-            if (error)
-                throw error;
-            if (!waiting)
-                return value;
-            const issue = Oops$4.ValueNotReady(subject, key);
-            let suspend = source
-                .call(subject, key)
+function pendingFactory(via, key, fn) {
+    const { subject, state } = via;
+    let waiting;
+    let error;
+    return () => {
+        if (waiting)
+            throw waiting;
+        if (error)
+            throw error;
+        if (key in state)
+            return state[key];
+        let output;
+        try {
+            output = fn.call(subject, key, subject);
+        }
+        catch (err) {
+            throw error = err;
+        }
+        if (output instanceof Promise) {
+            const issue = Oops$2.ValueNotReady(subject, key);
+            output
                 .catch(err => error = err)
-                .then(out => value = out)
-                .finally(() => waiting = false);
-            throw Object.assign(suspend, {
+                .then(out => state[key] = out)
+                .finally(() => waiting = undefined);
+            throw waiting = Object.assign(output, {
                 message: issue.message,
                 stack: issue.stack
             });
-        };
-    });
-}
-
-function use$1(init) {
-    const [state, update] = react.useState(() => [
-        init(() => update(state.concat()))
-    ]);
-    return state[0];
-}
-function useLazy(Type, callback) {
-    const instance = react.useMemo(() => {
-        const instance = Type.create();
-        if (callback)
-            callback(instance);
-        return instance;
-    }, []);
-    react.useLayoutEffect(() => () => instance.destroy(), []);
-    return instance;
-}
-function useWatcher(target, focus, expected) {
-    const hook = use$1(refresh => {
-        const sub = new Subscriber(target, () => refresh);
-        if (focus) {
-            const source = sub.proxy;
-            defineProperty(sub, "proxy", {
-                get() {
-                    const value = source[focus];
-                    if (value === undefined && expected)
-                        throw suspend(sub.parent, focus);
-                    return value;
-                }
-            });
         }
-        return sub;
-    });
-    react.useLayoutEffect(() => hook.commit(), []);
-    return hook.proxy;
-}
-function useComputed(target, compute, expected) {
-    const hook = use$1(refresh => {
-        const sub = new Subscriber(target, () => update);
-        const { proxy } = sub;
-        let value;
-        let retry;
-        const update = () => {
-            const next = compute.call(proxy, proxy);
-            if (value == next)
-                return;
-            value = next;
-            if (retry) {
-                retry();
-                retry = undefined;
-            }
-            else
-                refresh();
-        };
-        const access = () => {
-            if (value === undefined && expected)
-                throw new Promise(res => {
-                    retry = res;
-                });
-            return value;
-        };
-        value = compute.call(proxy, proxy);
-        sub.commit();
-        defineProperty(sub, "proxy", { get: access });
-        return sub;
-    });
-    react.useLayoutEffect(() => hook.release, []);
-    return hook.proxy;
+        else {
+            return state[key] = output;
+        }
+    };
 }
-function useModel(Type, callback) {
-    const hook = use$1(refresh => {
-        const instance = new Type();
-        const control = manage(instance);
-        const sub = new Subscriber(control, () => refresh);
-        const release = control.addListener((key) => {
-            if (key == Lifecycle.WILL_UNMOUNT)
+function suspend(source, key) {
+    const error = Oops$2.ValueNotReady(source.subject, key);
+    const promise = new Promise(resolve => {
+        const release = source.addListener(forKey => {
+            if (forKey == key)
                 return () => {
-                    instance.destroy();
-                    release();
+                    if (source.state[key] !== undefined) {
+                        release();
+                        resolve();
+                    }
                 };
         });
-        if (callback)
-            callback(instance);
-        return sub;
     });
-    return hook.proxy;
-}
-
-class Lookup {
-    constructor() {
-        this.table = new Map();
-    }
-    get local() {
-        return getOwnPropertySymbols(this).map((symbol) => this[symbol]);
-    }
-    key(T) {
-        let key = this.table.get(T);
-        if (!key) {
-            key = Symbol(T.name);
-            this.table.set(T, key);
-        }
-        return key;
-    }
-    get(T) {
-        return this[this.key(T)];
-    }
-    push(I) {
-        const next = create(this);
-        if (I instanceof Model || typeof I == "function")
-            next.register(I);
-        else
-            for (const i of values(I))
-                next.register(i);
-        return next;
-    }
-    register(I) {
-        let writable = true;
-        let T;
-        if (I instanceof Model) {
-            T = I.constructor;
-            writable = false;
-        }
-        else {
-            T = I;
-            I = I.create();
-        }
-        do {
-            defineProperty(this, this.key(T), {
-                value: I, writable
-            });
-            T = getPrototypeOf(T);
-        } while (T !== Model);
-        return I;
-    }
-    pop() {
-        for (const key of getOwnPropertySymbols(this)) {
-            const entry = getOwnPropertyDescriptor(this, key);
-            if (entry.writable)
-                entry.value.destroy();
-        }
-    }
+    return Object.assign(promise, {
+        toString: () => String(error),
+        name: "Suspense",
+        message: error.message,
+        stack: error.stack
+    });
 }
 
-const Oops$3 = issues({
-    NoProviderType: () => `Provider 'of' prop must be Model, typeof Model or a collection of them.`,
-    NothingInContext: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`,
-    BadConsumerProps: () => `Provider expects either a render function, 'get' or 'has' props.`
+const Oops$1 = issues({
+    NonOptional: (Parent, key) => `Property ${Parent}.${key} is marked as required.`,
+    BadFactory: () => `Set instruction can only accept a factory or undefined.`,
+    FactoryFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`
 });
-const LookupContext = react.createContext(new Lookup());
-const useLookup = () => react.useContext(LookupContext);
-function useFromContext(Type, strict) {
-    const instance = useLookup().get(Type);
-    if (!instance && strict)
-        throw Oops$3.NothingInContext(Type.name);
-    return instance;
-}
-function Consumer(props) {
-    const { get, has, children, of: Control } = props;
-    if (typeof children == "function")
-        return children(Control.tap());
-    const callback = has || get;
-    if (typeof callback == "function")
-        callback(Control.get(!!has));
-    else
-        throw Oops$3.BadConsumerProps();
-    return null;
-}
-function useNewContext(from, inject) {
-    return react.useMemo(() => {
-        if (!inject)
-            throw Oops$3.NoProviderType();
-        const context = from.push(inject);
-        for (const instance of context.local)
-            for (const apply of getPending(instance))
-                apply(context);
-        return context;
-    }, []);
-}
-function useAppliedProps(within, props) {
-    const update = react.useMemo(() => {
-        const targets = within.local;
-        return function integrate(props) {
-            for (const [key, value] of entries(props))
-                if (key != "of" && key != "children")
-                    for (const into of targets)
-                        if (key in into)
-                            into[key] = value;
-        };
-    }, []);
-    update(props);
+function lazy(value) {
+    return apply(function lazy(key) {
+        const source = this.subject;
+        source[key] = value;
+        defineProperty(this.state, key, {
+            get: () => source[key]
+        });
+    });
 }
-function RenderFunction(props) {
-    const hook = use$1(refresh => {
-        const targets = props.context.local;
-        if (targets.length == 1)
-            return new Subscriber(targets[0], () => refresh);
-        return {};
+function set(factory, argument) {
+    return apply(function set(key) {
+        let set;
+        let get;
+        const required = argument === true || argument === undefined;
+        if (factory === undefined)
+            get = () => pendingValue(this, key);
+        else if (typeof factory !== "function")
+            throw Oops$1.BadFactory();
+        else {
+            get = pendingFactory(this, key, factory);
+            if (required)
+                try {
+                    get();
+                }
+                catch (err) {
+                    if (err instanceof Promise)
+                        ;
+                    else {
+                        Oops$1.FactoryFailed(this.subject, key).warn();
+                        throw err;
+                    }
+                }
+        }
+        if (typeof argument == "function")
+            set = createValueEffect(argument);
+        else
+            set = (value) => {
+                if (value === undefined && required)
+                    throw Oops$1.NonOptional(this.subject, key);
+            };
+        return { set, get };
     });
-    if (hook.commit)
-        react.useLayoutEffect(() => hook.commit(), []);
-    return props.render(hook.proxy);
 }
-function Provider(props) {
-    const render = props.children;
-    const current = useLookup();
-    const context = useNewContext(current, props.of);
-    useAppliedProps(context, props);
-    react.useLayoutEffect(() => () => context.pop(), []);
-    return react.createElement(LookupContext.Provider, { value: context }, typeof render == "function"
-        ? react.createElement(RenderFunction, { context, render })
-        : render);
+function on(initial, onUpdate) {
+    return set(initial && (() => initial), onUpdate);
 }
 
-const Oops$2 = issues({
-    StrictUpdate: (expected) => `Strict update() did ${expected ? "not " : ""}find pending updates.`,
-    NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
-});
-const useElementLifecycle = lifecycle("element");
-const useComponentLifecycle = lifecycle("component");
-class Model {
-    constructor() {
-        const control = Controller.setup(this);
-        define(this, "get", this);
-        define(this, "set", this);
-        defer(control, "on");
-        defer(control, "effect");
-        control.waiting.add(() => {
-            delete this.on;
-            delete this.effect;
-        });
-    }
+class MVC extends Model {
     tap(path, expect) {
-        if (typeof path == "function")
-            return useComputed(this, path, expect);
-        const proxy = useWatcher(this, path, expect);
-        this.update("willRender", true);
-        return proxy;
+        return useTap(this, path, expect);
     }
     tag(id) {
-        const hook = use$1(refresh => {
-            return new Subscriber(this, () => refresh);
-        });
-        useElementLifecycle(hook, id || 0);
-        return hook.proxy;
+        return useTag(this, id);
     }
     use(callback) {
-        const hook = use$1(refresh => {
-            if (callback)
-                callback(this);
-            return new Subscriber(this, () => refresh);
-        });
-        useComponentLifecycle(hook);
-        return hook.proxy;
-    }
-    on(subset, handler, squash, once) {
-        const control = manage(this);
-        const request = keys(control, subset);
-        const callback = squash
-            ? handler.bind(this)
-            : frame => frame
-                .filter(k => request.includes(k))
-                .forEach(k => handler.call(this, control.state[k], k));
-        const trigger = once
-            ? frame => { remove(); callback(frame); }
-            : callback;
-        ensure(control, request);
-        const remove = control.addListener(key => {
-            if (request.includes(key))
-                return trigger;
-        });
-        return remove;
-    }
-    once(select, callback, squash) {
-        if (callback)
-            return this.on(select, callback, squash, true);
-        else
-            return new Promise(resolve => {
-                this.on(select, resolve, true, true);
-            });
-    }
-    effect(callback, select) {
-        const control = manage(this);
-        let target = this;
-        const effect = createEffect(callback);
-        const invoke = () => effect.call(target, target);
-        if (select) {
-            invoke();
-            return this.on(select, invoke, true);
-        }
-        else {
-            const sub = new Subscriber(control, () => invoke);
-            target = sub.proxy;
-            invoke();
-            return sub.commit();
-        }
-    }
-    import(from, subset) {
-        for (const key of keys(manage(this), subset))
-            if (key in from)
-                this[key] = from[key];
-    }
-    export(subset) {
-        const control = manage(this);
-        const output = {};
-        for (const key of keys(control, subset))
-            output[key] = control.state[key];
-        return output;
-    }
-    update(arg, tag) {
-        const control = manage(this);
-        if (typeof arg == "function")
-            arg = select(this, arg);
-        if (typeof arg == "boolean") {
-            if (!control.pending === arg)
-                return Promise.reject(Oops$2.StrictUpdate(arg));
-        }
-        else if (arg) {
-            control.update(arg);
-            if (1 in arguments && arg in this) {
-                const method = this[arg];
-                if (typeof method == "function")
-                    if (typeof tag != "boolean")
-                        method.call(this, tag);
-                    else if (tag)
-                        method.call(this);
-            }
-        }
-        return {
-            then(callback) {
-                if (callback)
-                    if (control.pending)
-                        control.waiting.add(callback);
-                    else
-                        callback(false);
-                else
-                    throw Oops$2.NoChaining();
-            }
-        };
-    }
-    destroy() {
-        this.update("willDestroy", true);
-    }
-    toString() {
-        return this.constructor.name;
-    }
-    static create(...args) {
-        const instance = new this(...args);
-        manage(instance);
-        return instance;
+        return useNew(this, callback);
     }
     static new(callback) {
-        const instance = useLazy(this, callback);
-        instance.update("willRender", true);
-        return instance;
-    }
-    static find(strict) {
-        return useFromContext(this, strict);
+        return usePassive(this, callback);
     }
     static get(key) {
-        const instance = this.find(!!key);
-        return (typeof key == "function" ?
-            key(instance) :
-            typeof key == "string" ?
-                instance[key] :
-                instance);
+        const instance = useContext(this, key !== false);
+        return (typeof key == "string" ?
+            instance[key] :
+            instance);
     }
     static tap(key, expect) {
-        return this.find(true).tap(key, expect);
+        return this.get().tap(key, expect);
     }
     static tag(id) {
-        return this.find(true).tag(id);
+        return this.get().tag(id);
     }
     static use(callback) {
-        const instance = useModel(this, callback);
-        useComponentLifecycle(instance[LOCAL]);
-        usePeerContext(instance.get);
-        return instance;
+        return useModel(this, callback);
     }
     static uses(props, only) {
         return this.use(instance => {
@@ -1122,131 +1277,11 @@ class Model {
         instance.import(props, only);
         return instance;
     }
-    static meta(path) {
+    static meta(path, expect) {
         return typeof path == "function"
-            ? useComputed(this, path)
-            : useWatcher(this, path);
+            ? useComputed(this, path, expect)
+            : useActive(this, path, expect);
     }
-    static isTypeof(maybe) {
-        return (typeof maybe == "function" &&
-            maybe.prototype instanceof this);
-    }
-}
-Model.CONTROL = CONTROL;
-Model.STATE = STATE;
-Model.LOCAL = LOCAL;
-Model.WHY = UPDATE;
-defineLazy(Model, CONTROL, function () {
-    return new Controller(this).start();
-});
-function defer(on, method) {
-    const { subject, waiting } = on;
-    const real = subject[method];
-    subject[method] = (...args) => {
-        let done;
-        waiting.add(() => {
-            done = real.apply(subject, args);
-        });
-        return () => done();
-    };
-}
-
-const Parent = new WeakMap();
-const Oops$1 = issues({
-    ParentRequired: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
-    UnexpectedParent: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
-    UndefinedNotAllowed: (key) => `Child property ${key} may not be undefined.`,
-    BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
-    IsReadOnly: (owner, key) => `${owner}.${key} is set to read-only, but tried to reassign assign.`,
-    MustBeDefined: (owner, key) => `${owner}.${key} must have initial value, as a read-only property.`
-});
-function bootstrap(object) {
-    const breakdown = getOwnPropertyDescriptors(object);
-    const control = new Model();
-    for (const key in breakdown)
-        defineProperty(control, key, breakdown[key]);
-    return control;
-}
-function use(input, argument) {
-    return child(function use(key) {
-        const { subject } = this;
-        // `true` => readonly
-        // `false` => writable, may be undefined
-        // `undefined` => writable (default)
-        let mode = argument;
-        let current;
-        const onUpdate = (next, initial) => {
-            if (mode === true && !initial)
-                throw Oops$1.IsReadOnly(subject, key);
-            if (next) {
-                current = next instanceof Model
-                    ? next : bootstrap(next);
-                Parent.set(current, subject);
-                manage(current);
-            }
-            else if (mode === undefined)
-                throw Oops$1.UndefinedNotAllowed(key);
-            else
-                current = undefined;
-            if (typeof argument == "function")
-                return argument(current);
-        };
-        if (input) {
-            current =
-                Model.isTypeof(input) ? new input() :
-                    input instanceof Model ? input :
-                        typeof input === "function" ? input() :
-                            typeof input === "object" ? bootstrap(input) :
-                                Oops$1.BadArgument(typeof input).throw();
-            if (current)
-                mode = onUpdate(current, true) || mode;
-            else if (mode == true)
-                throw Oops$1.MustBeDefined(subject, key);
-        }
-        else
-            mode = false;
-        this.manage(key, current, onUpdate);
-        return () => current;
-    });
-}
-function parent(Expects, required) {
-    return apply(function parent() {
-        const child = this.subject;
-        const expected = Expects.name;
-        const value = Parent.get(this.subject);
-        if (!value) {
-            if (required)
-                throw Oops$1.ParentRequired(expected, child);
-        }
-        else if (!(value instanceof Expects))
-            throw Oops$1.UnexpectedParent(expected, child, value);
-        return { value };
-    });
-}
-
-function on(initial, cb) {
-    return apply(function on(key) {
-        this.manage(key, initial, cb && createValueEffect(cb));
-    });
-}
-function memo(factory, defer) {
-    return apply(function memo(key) {
-        const source = this.subject;
-        const get = () => factory.call(source);
-        if (defer)
-            defineLazy(source, key, get);
-        else
-            define(source, key, get());
-    });
-}
-function lazy(value) {
-    return apply(function lazy(key) {
-        const source = this.subject;
-        source[key] = value;
-        defineProperty(this.state, key, {
-            get: () => source[key]
-        });
-    });
 }
 
 const Oops = issues({
@@ -1254,35 +1289,32 @@ const Oops = issues({
     GlobalExists: (name) => `Shared instance of ${name} already exists! Consider unmounting existing, or use ${name}.reset() to force-delete it.`
 });
 const Active = new WeakMap();
-class Singleton extends Model {
-    static get current() {
-        return Active.get(this);
-    }
+class Singleton extends MVC {
     static create(...args) {
         const Type = this;
         if (Active.has(Type))
             throw Oops.GlobalExists(this.name);
-        let instance = super.create(...args);
+        const instance = super.create(...args);
         Active.set(Type, instance);
         return instance;
     }
-    static update(updates) {
-        const instance = this.current || this.create();
+    static set(updates) {
+        const instance = Active.get(this) || this.create();
         instance.import(updates);
         return instance.update();
     }
-    static is() {
-        return this.find(true);
-    }
-    static find(strict) {
-        const instance = this.current;
-        if (!instance && strict)
+    static get(arg) {
+        const instance = Active.get(this);
+        if (!instance && arg !== false)
             throw Oops.GlobalDoesNotExist(this.name);
-        return instance;
+        return (typeof arg == "string" ?
+            instance[arg] :
+            instance);
     }
     static reset() {
-        if (this.current)
-            this.current.destroy();
+        const current = Active.get(this);
+        if (current)
+            current.destroy();
     }
     destroy() {
         super.destroy();
@@ -1291,20 +1323,21 @@ class Singleton extends Model {
 }
 
 exports.Consumer = Consumer;
-exports.Model = Model;
+exports.Model = MVC;
 exports.Provider = Provider;
 exports.Singleton = Singleton;
 exports.act = act;
 exports.apply = apply;
 exports.child = child;
-exports["default"] = Model;
+exports["default"] = MVC;
 exports.from = from;
 exports.lazy = lazy;
-exports.memo = memo;
+exports.memo = set;
 exports.on = on;
 exports.parent = parent;
 exports.pending = pending;
 exports.ref = ref;
+exports.set = set;
 exports.tap = tap;
-exports.use = use;
+exports.use = use$1;
 //# sourceMappingURL=index.js.map