@expressive/mvc 1.0.0-beta.8 → 1.0.0

package/lib/index.js

@@ -2,7 +2,25 @@
 
 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);
+
+const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
+const UID_CACHE = new WeakMap();
+function assignWeak(into, from) {
+    for (const K in from)
+        if (K in into)
+            into[K] = from[K];
+}
+function uid(object) {
+    let uid = UID_CACHE.get(object);
+    if (!uid)
+        UID_CACHE.set(object, uid = Math.random());
+    return uid;
+}
 
 class Issue extends Error {
     constructor() {
@@ -21,993 +39,1593 @@ function issues(register) {
     return Library;
 }
 
-const Oops$8 = issues({
-    BadEffectCallback: () => `Callback for effect-callback may only return a function.`
+const Oops$f = issues({
+    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
 });
-const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertyDescriptors, getOwnPropertySymbols, keys: keys$1, 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 suspend(source, key) {
+    const error = Oops$f.NotReady(source.subject, key);
+    const promise = new Promise(resolve => {
+        const release = source.addListener(forKey => {
+            if (forKey == key)
+                return () => {
+                    if (source.state.get(key) !== undefined) {
+                        release();
+                        resolve();
+                    }
+                };
+        });
+    });
+    return assign(promise, {
+        toString: () => String(error),
+        name: "Suspense",
+        message: error.message,
+        stack: error.stack
     });
 }
-function setAlias(func, displayName) {
-    assign(func, { displayName });
-}
-function entriesIn(object) {
-    return entries(getOwnPropertyDescriptors(object));
-}
-function createEffect(callback) {
-    let unSet;
-    return function (value) {
-        typeof unSet == "function" && unSet();
-        unSet = callback.call(this, value);
-        if (unSet instanceof Promise)
-            unSet = undefined;
-        if (unSet && typeof unSet !== "function")
-            throw Oops$8.BadEffectCallback();
+function mayRetry(fn) {
+    const retry = (err) => {
+        if (err instanceof Promise)
+            return err.then(compute);
+        else
+            throw err;
     };
-}
-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;
-            }
-        });
-    using(spy);
-    return Array.from(found);
+    const compute = () => {
+        try {
+            const output = fn();
+            return output instanceof Promise
+                ? output.catch(retry)
+                : output;
+        }
+        catch (err) {
+            return retry(err);
+        }
+    };
+    return compute();
 }
 
-const Lifecycle = {
-    WILL_RENDER: "willRender",
-    WILL_UPDATE: "willUpdate",
-    WILL_MOUNT: "willMount",
-    WILL_UNMOUNT: "willUnmount",
-    DID_MOUNT: "didMount"
-};
-const lifecycleEvents = [
-    "didCreate",
-    "willDestroy",
-    ...values(Lifecycle)
-];
-function lifecycle(prefix) {
-    const type = eventsFor(prefix);
-    return function useLifecycle(sub, tag) {
-        const emit = react.useMemo(() => {
-            const { parent } = sub;
-            const { subject } = parent;
-            const id = typeof tag == "function" ? tag(subject) : tag;
-            return (name) => {
-                for (const key of [name, type(name)]) {
-                    const handler = subject[key];
-                    if (handler)
-                        handler.call(subject, id);
-                    parent.update(key);
-                }
-            };
-        }, [sub, tag]);
-        emit(Lifecycle.WILL_RENDER);
-        emit(sub.active
-            ? Lifecycle.WILL_UPDATE
-            : Lifecycle.WILL_MOUNT);
-        react.useLayoutEffect(() => {
+const Oops$e = issues({
+    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
+});
+const INFO = new WeakMap();
+const KEYS = new WeakMap();
+const ORDER = new WeakMap();
+function computeMode(self, source, setter, key, required) {
+    const { subject, state } = self;
+    let sub;
+    let order = ORDER.get(self);
+    let pending = KEYS.get(self);
+    if (!order)
+        ORDER.set(self, order = new Map());
+    if (!pending)
+        KEYS.set(self, pending = new Set());
+    const compute = (initial) => {
+        try {
+            return setter.call(sub.proxy, sub.proxy);
+        }
+        catch (err) {
+            Oops$e.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 create = () => {
+        sub = source.subscribe((_, source) => {
+            if (source !== self)
+                refresh();
+            else
+                pending.add(refresh);
+        });
+        sub.watch.set(key, false);
+        try {
+            const value = compute(true);
+            state.set(key, value);
+            return value;
+        }
+        catch (e) {
+            throw e;
+        }
+        finally {
             sub.commit();
-            emit(Lifecycle.DID_MOUNT);
-            return () => {
-                emit(Lifecycle.WILL_UNMOUNT);
-                sub.release();
-            };
-        }, [sub]);
+            order.set(refresh, order.size);
+        }
+    };
+    INFO.set(refresh, key);
+    return () => {
+        if (pending.has(refresh)) {
+            pending.delete(refresh);
+            refresh();
+        }
+        const value = sub ? state.get(key) : create();
+        if (value === undefined && required)
+            throw suspend(self, key);
+        return value;
     };
 }
-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);
+function flush(control) {
+    const pending = KEYS.get(control);
+    if (!pending || !pending.size)
+        return;
+    const priority = ORDER.get(control);
+    while (pending.size) {
+        let compute;
+        for (const item of pending)
+            if (!compute || priority.get(item) < priority.get(compute))
+                compute = item;
+        pending.delete(compute);
+        const key = INFO.get(compute);
+        if (!control.frame.has(key))
+            compute();
+    }
+    pending.clear();
 }
 
-class Controller {
-    constructor(subject) {
-        this.subject = subject;
-        this.state = {};
-        this.frame = new Set();
-        this.handles = new Set();
-        this.waiting = [];
-        bootstrap(this);
-    }
-    get pending() {
-        return this.frame.size > 0;
-    }
-    start() {
-        getOwnPropertyNames(this.subject)
-            .forEach(k => this.add(k));
-        this.emit();
-        return this;
-    }
-    select(using) {
-        const keys = getOwnPropertyNames(this.state);
-        return using
-            ? selectRecursive(using, keys.concat(lifecycleEvents))
-            : keys;
-    }
-    add(key) {
-        const desc = getOwnPropertyDescriptor(this.subject, key);
-        if (desc && "value" in desc) {
-            const { value } = desc;
-            if (apply(this, key, value))
-                return;
-            if (desc.enumerable && typeof value !== "function" || /^[A-Z]/.test(key))
-                this.manage(key, value);
+const Oops$d = issues({
+    BadCallback: () => `Callback for effect-callback may only return a function.`
+});
+function createEffect(model, callback, keys) {
+    return control(model, controller => {
+        let unSet;
+        let busy = false;
+        function effect(value) {
+            if (typeof unSet == "function")
+                unSet();
+            unSet = callback.call(this, value);
+            if (unSet instanceof Promise)
+                unSet = undefined;
+            if (unSet && typeof unSet !== "function")
+                throw Oops$d.BadCallback();
         }
-    }
-    manage(key, initial, effect) {
-        const { state, subject } = this;
-        state[key] = initial;
-        defineProperty(subject, key, {
-            enumerable: true,
-            configurable: true,
-            get: () => state[key],
-            set: this.sets(key, effect)
-        });
-    }
-    sets(key, handler) {
-        const { state, subject } = this;
-        return (value) => {
-            if (state[key] == value)
+        function invoke() {
+            if (busy)
                 return;
-            if (handler)
-                if (handler.call(subject, value) === false)
-                    return;
-            this.update(key, value);
-        };
-    }
-    watch(subset, handler, squash, once) {
-        const set = keys(this, subset);
-        const batch = {};
-        const remove = this.addListener(batch);
-        const callback = squash
-            ? handler.bind(this.subject)
-            : (frame) => {
-                for (const key of frame)
-                    if (set.includes(key))
-                        handler.call(this.subject, this.state[key], key);
-            };
-        const handle = once
-            ? (k) => { remove(); callback(k); }
-            : callback;
-        for (const key of set)
-            batch[key] = handle;
-        ensure(this, set);
-        return remove;
-    }
-    addListener(batch) {
-        this.handles.add(batch);
-        return () => {
-            this.handles.delete(batch);
-        };
-    }
-    include(to) {
-        if (capture(this, to))
+            const output = mayRetry(() => {
+                effect.call(model, model);
+            });
+            if (output instanceof Promise) {
+                output.finally(() => busy = false);
+                busy = true;
+            }
+        }
+        if (Array.isArray(keys)) {
+            invoke();
+            return controller.addListener(key => {
+                if (key === null) {
+                    if (!keys.length)
+                        invoke();
+                }
+                else if (keys.includes(key))
+                    return invoke;
+            });
+        }
+        const sub = controller.subscribe(() => invoke);
+        model = sub.proxy;
+        invoke();
+        return sub.commit();
+    });
+}
+function createValueEffect(callback) {
+    let unSet;
+    return function (value) {
+        if (typeof unSet == "function")
+            unSet(value);
+        const out = callback.call(this, value, this);
+        if (typeof out == "boolean")
+            return out;
+        if (!out || out instanceof Promise)
             return;
+        if (typeof out == "function")
+            unSet = out;
         else
-            this.waiting.push(to);
-    }
-    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.handles)
-            if (key in subscription)
-                this.include(subscription[key]);
-    }
-    emit() {
-        flush(this);
-        const keys = Array.from(this.frame);
-        const handle = new Set(this.waiting.splice(0));
-        this.frame.clear();
-        handle.forEach(cb => {
+            throw Oops$d.BadCallback();
+    };
+}
+
+const Oops$c = issues({
+    Timeout: (keys, timeout) => `No update seen for [${keys}] within ${timeout}.`,
+    KeysExpected: (key) => `Key "${key}" was expected in current update.`,
+    StrictUpdate: () => `Expected update but none in progress.`,
+    StrictNoUpdate: () => `Update is not expected but one is in progress!`
+});
+function addEventListener(source, arg1, arg2, arg3) {
+    if (typeof arg1 == "string")
+        arg1 = [arg1];
+    return control(source, controller => {
+        for (const key of arg1)
             try {
-                cb(keys);
+                void source[key];
             }
             catch (e) { }
+        const removeListener = controller.addListener(key => {
+            if (!key && !arg1.length)
+                arg2.call(source, []);
+            if (arg1.includes(key)) {
+                if (arg3)
+                    removeListener();
+                return arg2.bind(source);
+            }
         });
-    }
+        return removeListener;
+    });
 }
-function keys(from, using) {
-    if (typeof using == "string")
-        return [using];
-    if (typeof using == "object")
-        return Array.from(using);
-    return from.select(using);
-}
-
-const Oops$7 = 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.`
-});
-const PendingContext = new WeakMap();
-const ContextWasUsed = new WeakMap();
-const tap = (type, required) => set(function tap(key) {
-    const { subject } = this;
-    if ("current" in type)
-        defineLazy(subject, key, () => type.current);
-    else if ("current" in subject.constructor)
-        throw Oops$7.CantAttachGlobal(subject, type.name);
-    else
-        getPending(subject).push((context) => {
-            const remote = context.get(type);
-            if (!remote && required)
-                throw Oops$7.AmbientRequired(type.name, subject, key);
-            define(subject, key, remote);
+function awaitUpdate(source, arg1, arg2) {
+    const single = typeof arg1 == "string";
+    const keys = typeof arg1 == "string" ? [arg1] :
+        typeof arg1 == "object" ? arg1 :
+            undefined;
+    return new Promise((resolve, reject) => {
+        const timeout = (message) => {
+            const k = keys ? keys.join(", ") : "any";
+            removeListener();
+            reject(Oops$c.Timeout(k, message));
+        };
+        const removeListener = control(source, controller => {
+            const pending = controller.frame;
+            if (keys === null) {
+                if (pending.size)
+                    reject(Oops$c.StrictNoUpdate());
+                else
+                    resolve(null);
+                return;
+            }
+            if (keys) {
+                if (keys.length) {
+                    if (arg2 === 0 && single && !pending.has(keys[0])) {
+                        reject(Oops$c.KeysExpected(keys[0]));
+                        return;
+                    }
+                    else
+                        for (const key of keys)
+                            try {
+                                void source[key];
+                            }
+                            catch (e) { }
+                }
+            }
+            else if (!pending.size && arg1 === true || arg2 === 0) {
+                reject(Oops$c.StrictUpdate());
+                return;
+            }
+            else
+                controller.waiting.add(resolve);
+            return controller.addListener(key => {
+                if (!key) {
+                    if (keys && !keys.length)
+                        resolve([]);
+                    else
+                        timeout(`lifetime of ${source}`);
+                }
+                else if (!keys || keys.includes(key)) {
+                    removeListener();
+                    return keys => resolve(single ? controller.state.get(key) : keys);
+                }
+            });
         });
-});
-function usePeerContext(subject) {
-    if (ContextWasUsed.has(subject)) {
-        if (ContextWasUsed.get(subject))
-            useLookup();
-        return;
-    }
-    const pending = PendingContext.get(subject);
-    if (pending) {
-        const local = useLookup();
-        for (const init of pending)
-            init(local);
-        PendingContext.delete(subject);
-    }
-    ContextWasUsed.set(subject, !!pending);
-}
-function getPending(subject) {
-    let pending = PendingContext.get(subject);
-    if (!pending)
-        PendingContext.set(subject, pending = []);
-    return pending;
+        if (arg2 && typeof arg2 == "number")
+            setTimeout(() => timeout(`${arg2}ms`), arg2);
+    });
 }
 
+const REGISTER$1 = new WeakMap();
 class Subscriber {
     constructor(parent, onUpdate) {
+        this.parent = parent;
         this.onUpdate = onUpdate;
         this.active = false;
-        this.follows = {};
         this.dependant = new Set();
-        if (!(parent instanceof Controller))
-            parent = manage(parent);
-        this.parent = parent;
-        this.proxy = create(parent.subject);
-        define(this.proxy, LOCAL, this);
-        for (const key in parent.state)
-            this.spy(key);
-    }
-    spy(key) {
-        const { proxy, parent } = this;
-        const intercept = () => {
-            this.follow(key);
-            delete proxy[key];
-            return proxy[key];
-        };
-        setAlias(intercept, `tap ${key}`);
-        defineProperty(proxy, key, {
-            get: intercept,
-            set: parent.sets(key),
+        this.watch = new Map();
+        const proxy = create(parent.subject);
+        const reset = () => this.latest = undefined;
+        REGISTER$1.set(proxy, this);
+        defineProperty(this, "proxy", {
             configurable: true,
-            enumerable: true
+            get() {
+                setTimeout(reset, 0);
+                return proxy;
+            }
         });
     }
-    follow(key, cb) {
-        this.follows[key] = cb || this.onUpdate;
+    get using() {
+        return Array.from(this.watch.keys());
+    }
+    add(key, value) {
+        if (value !== undefined)
+            this.watch.set(key, value);
+        else if (!this.watch.has(key))
+            this.watch.set(key, true);
     }
     commit() {
-        const { dependant, follows, parent } = this;
-        const onDone = parent.addListener(follows);
+        const release = this.parent.addListener(key => {
+            if (this.active)
+                this.onEvent(key);
+        });
         this.active = true;
-        dependant.forEach(x => x.commit());
+        this.dependant.forEach(x => x.commit());
         return this.release = () => {
-            dependant.forEach(x => x.release());
-            onDone();
+            this.dependant.forEach(x => x.release());
+            release();
         };
     }
+    onEvent(key) {
+        const { parent, watch } = this;
+        let handler = watch.get(key);
+        if (typeof handler == "function")
+            handler = handler();
+        if (handler) {
+            const notify = this.onUpdate(key, parent);
+            if (notify) {
+                parent.waiting.add(update => {
+                    this.latest = update.filter(k => watch.has(k));
+                });
+                parent.waiting.add(notify);
+            }
+        }
+    }
+}
+function subscriber(from) {
+    return REGISTER$1.get(from);
 }
 
-const Oops$6 = issues({
-    HasPropertyUndefined: (control, property) => `${control}.${property} is marked as required for this render.`
+const Oops$b = issues({
+    NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
 });
-const useElementLifecycle = lifecycle("element");
-const useComponentLifecycle = lifecycle("component");
-function use$1(init) {
-    const [state, update] = react.useState(() => [
-        init(() => update(state.concat()))
-    ]);
-    return state[0];
-}
-function useLazy(Type, args) {
-    const instance = react.useMemo(() => Type.create(...args), []);
-    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 src = sub.proxy;
-            const key = keys(sub.parent, focus)[0];
-            defineProperty(sub, "proxy", {
-                get() {
-                    if (src[key] === undefined && expected)
-                        throw Oops$6.HasPropertyUndefined(target, key);
-                    return src[key];
+class Model {
+    constructor() {
+        new Control(this);
+        defineProperty(this, "is", { value: this });
+    }
+    on(arg1, arg2, arg3) {
+        if (typeof arg1 == "function")
+            return createEffect(this.is, arg1, arg2);
+        if (typeof arg2 != "function")
+            return awaitUpdate(this.is, arg1, arg2);
+        if (arg1)
+            return addEventListener(this.is, arg1, arg2, arg3);
+    }
+    get(arg1, arg2) {
+        const { state } = control(this);
+        const extract = typeof arg1 == "string"
+            ? () => state.get(arg1)
+            : () => {
+                const output = {};
+                for (const key of arg1 || state.keys())
+                    output[key] = state.get(key);
+                return output;
+            };
+        if (!arg1 || arg2 === undefined)
+            return extract();
+        if (typeof arg2 == "function")
+            return this.on(arg1, () => arg2(extract()));
+        const timeout = typeof arg2 == "number" ? arg2 : undefined;
+        return this.on(arg1, timeout).then(extract);
+    }
+    set(arg1, arg2) {
+        const controller = control(this);
+        const { state } = controller;
+        if (typeof arg1 == "object")
+            for (const key in arg1) {
+                if (arg2 === true || (arg2 ? arg2.includes(key) : state.has(key))) {
+                    state.set(key, arg1[key]);
+                    controller.update(key);
                 }
-            });
+            }
+        else if (typeof arg1 == "string") {
+            controller.update(arg1);
+            if (1 in arguments) {
+                if (state.has(arg1))
+                    state.set(arg1, arg2);
+                else if (arg1 in this) {
+                    const method = this[arg1];
+                    if (typeof method == "function")
+                        method.call(this, arg2);
+                }
+            }
         }
-        return sub;
-    });
-    react.useLayoutEffect(() => hook.commit(), []);
-    return hook.proxy;
-}
-function useSubscriber(target, tag) {
-    const hook = use$1(refresh => new Subscriber(target, refresh));
-    useElementLifecycle(hook, tag || 0);
-    return hook.proxy;
+        return {
+            then: (callback) => {
+                if (!callback)
+                    throw Oops$b.NoChaining();
+                controller.waiting.add(callback);
+            }
+        };
+    }
+    /**
+     * Clean up side effects and mark this instance for garbage-collection.
+     */
+    end() {
+        control(this).clear();
+    }
+    /**
+     * Creates a new instance of this controller.
+     *
+     * Beyond `new this(...)`, method will activate managed-state.
+     *
+     * @param args - arguments sent to constructor
+     */
+    static new(...args) {
+        const instance = new this(...args);
+        control(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);
+    }
 }
-function useModel(Type, args, callback) {
-    const hook = use$1(refresh => {
-        const instance = new Type(...args);
-        const sub = new Subscriber(instance, refresh);
-        instance.on(Lifecycle.WILL_UNMOUNT, () => {
-            instance.destroy();
-        });
-        if (callback)
-            callback(instance);
-        return sub;
-    });
-    usePeerContext(hook.parent.subject);
-    useComponentLifecycle(hook);
-    return hook.proxy;
-}
+defineProperty(Model.prototype, "toString", {
+    value() {
+        return this.constructor.name;
+    }
+});
 
-class Lookup {
-    constructor() {
-        this.table = new Map();
+const REGISTER = new WeakMap();
+const PENDING = new Map();
+class Control {
+    constructor(subject) {
+        this.subject = subject;
+        this.frame = new Set();
+        this.waiting = new Set();
+        this.followers = new Set();
+        REGISTER.set(subject, this);
     }
-    get local() {
-        return getOwnPropertySymbols(this).map((symbol) => this[symbol]);
+    subscribe(callback) {
+        return new Subscriber(this, callback);
     }
-    key(T) {
-        let key = this.table.get(T);
-        if (!key) {
-            key = Symbol(T.name);
-            this.table.set(T, key);
+    watch(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) {
+                delete subject[key];
+                PENDING.delete(value);
+                instruction.call(this, key, this);
+            }
+            return;
         }
-        return key;
+        state.set(key, value);
+        if (value instanceof Model) {
+            setRecursive(this, key, value);
+            return;
+        }
+        defineProperty(subject, key, {
+            enumerable: false,
+            set: this.ref(key),
+            get() {
+                const sub = subscriber(this);
+                if (sub)
+                    sub.add(key);
+                return state.get(key);
+            }
+        });
     }
-    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;
+    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);
+        };
     }
-    register(I) {
-        let writable = true;
-        let T;
-        if (I instanceof Model) {
-            T = I.constructor;
-            writable = false;
-        }
-        else {
-            T = I;
-            I = I.create();
+    update(key) {
+        const { followers, frame, waiting } = this;
+        if (frame.has(key))
+            return;
+        else if (!frame.size)
+            setTimeout(() => {
+                flush(this);
+                const keys = this.latest = Array.from(frame);
+                setTimeout(() => this.latest = undefined, 0);
+                frame.clear();
+                for (const notify of waiting)
+                    try {
+                        waiting.delete(notify);
+                        notify(keys);
+                    }
+                    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);
         }
-        do {
-            defineProperty(this, this.key(T), {
-                value: I,
-                writable
-            });
-        } while (T = T.inherits);
-        return I;
     }
-    pop() {
-        for (const key of getOwnPropertySymbols(this)) {
-            const entry = getOwnPropertyDescriptor(this, key);
-            if (entry.writable)
-                entry.value.destroy();
-        }
+    clear() {
+        const listeners = [...this.followers];
+        this.followers.clear();
+        listeners.forEach(x => x(null, this));
     }
-}
-
-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.createContext(new Lookup());
-const useLookup = () => react.useContext(LookupContext);
-function useFromContext(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(Control.tap());
-    const callback = has || get;
-    if (typeof callback == "function")
-        callback(Control.get(!!has));
-    else
-        throw Oops$5.BadConsumerProps();
-    return null;
-}
-function useNewContext(from, inject) {
-    return react.useMemo(() => {
-        if (!inject)
-            throw Oops$5.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 RenderFunction(props) {
-    const hook = use$1(refresh => {
-        const targets = props.context.local;
-        if (targets.length == 1)
-            return new Subscriber(targets[0], refresh);
-        return {};
-    });
-    if (hook.commit)
-        react.useLayoutEffect(() => hook.commit(), []);
-    return props.render(hook.proxy);
+function controller(from) {
+    if ("is" in from)
+        from = from.is;
+    return REGISTER.get(from);
 }
-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 control(subject, cb) {
+    const control = controller(subject) || new Control(subject);
+    if (!control.state) {
+        const { waiting } = control;
+        if (cb) {
+            let callback;
+            waiting.add(() => {
+                callback = cb(control);
+            });
+            return () => {
+                if (callback)
+                    callback();
+            };
+        }
+        control.state = new Map();
+        for (const key in subject)
+            control.watch(key);
+        control.waiting = new Set();
+        for (const cb of waiting)
+            cb([]);
+    }
+    return cb ? cb(control) : control;
 }
 
-const Oops$4 = issues({
-    StrictUpdate: (expected) => `Strict update() did ${expected ? "not " : ""}find pending updates.`
+const Parent = new WeakMap();
+const Oops$a = issues({
+    BadAssignment: (parent, expected, got) => `Property ${parent} expected Model of type ${expected} but got ${got}.`
 });
-const CONTROL = Symbol("control");
-const LOCAL = Symbol("local");
-const STATE = Symbol("state");
-function manage(src) {
-    return src[CONTROL];
-}
-class Model {
-    constructor() {
-        const control = new Controller(this);
-        define(this, "get", this);
-        define(this, "set", this);
-        defer(control, "on");
-        defer(control, "effect");
-        defineLazy(this, CONTROL, () => {
-            delete this.on;
-            delete this.effect;
-            this[STATE] = control.state;
-            control.start();
-            if (this.didCreate)
-                this.didCreate();
-            return control;
+function getRecursive(key, from) {
+    const context = new WeakMap();
+    const { state } = from;
+    return (local) => {
+        if (!local)
+            return state.get(key);
+        if (!context.has(local)) {
+            let reset;
+            const init = () => {
+                if (reset)
+                    reset();
+                const value = state.get(key);
+                if (value && controller(value)) {
+                    const child = control(value).subscribe(local.onUpdate);
+                    if (local.active)
+                        child.commit();
+                    local.dependant.add(child);
+                    context.set(local, child.proxy);
+                    reset = () => {
+                        child.release();
+                        local.dependant.delete(child);
+                        context.set(local, undefined);
+                        reset = undefined;
+                    };
+                }
+                return true;
+            };
+            local.add(key, init);
+            init();
+        }
+        return context.get(local);
+    };
+}
+function setRecursive(controller, key, initial) {
+    const { state, subject } = controller;
+    const Type = initial.constructor;
+    let get;
+    const onUpdate = (next) => {
+        state.set(key, next);
+        if (!(next instanceof Type))
+            throw Oops$a.BadAssignment(`${subject}.${key}`, Type.name, String(next));
+        get = getRecursive(key, controller);
+        Parent.set(next, subject);
+        control(next);
+        return true;
+    };
+    onUpdate(initial);
+    defineProperty(subject, key, {
+        set: controller.ref(key, onUpdate),
+        get() {
+            const local = subscriber(this);
+            if (local)
+                local.add(key);
+            return get(local);
+        }
+    });
+}
+
+/**
+ * Run instruction as controller sets itself up.
+ * This will specialize the behavior of a given property.
+ */
+function add(instruction, label) {
+    const name = label || instruction.name || "pending";
+    const placeholder = Symbol(`${name} instruction`);
+    function setup(key) {
+        const { subject, state } = this;
+        let output = instruction.call(this, key, this);
+        if (typeof output == "function")
+            output = { get: output };
+        if (typeof output != "object")
+            return;
+        if ("explicit" in output && output.explicit) {
+            defineProperty(subject, key, output);
+            return false;
+        }
+        let { get: onGet, set: onSet, suspend: shouldSuspend } = output;
+        if ("value" in output)
+            state.set(key, output.value);
+        if ("recursive" in output && output.recursive)
+            onGet = getRecursive(key, this);
+        if ("destroy" in output) {
+            const { destroy } = output;
+            if (destroy)
+                this.addListener((key) => {
+                    if (key == null)
+                        destroy();
+                });
+        }
+        const control = this;
+        defineProperty(subject, key, {
+            enumerable: output.enumerable,
+            set: onSet === false
+                ? undefined
+                : this.ref(key, onSet),
+            get() {
+                if (!state.has(key) && shouldSuspend)
+                    throw suspend(control, key);
+                const local = subscriber(this);
+                if (local)
+                    local.add(key);
+                return onGet
+                    ? onGet(local)
+                    : state.get(key);
+            }
         });
     }
-    tap(path, expect) {
-        return useWatcher(this, path, expect);
-    }
-    tag(id) {
-        return useSubscriber(this, id);
-    }
-    on(select, does, squash, once) {
-        return manage(this).watch(select, does, squash, once);
+    PENDING.set(placeholder, setup);
+    return placeholder;
+}
+
+/*! *****************************************************************************
+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$9 = issues({
+    DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
+});
+function run(task) {
+    return add(function run(key) {
+        let pending = false;
+        const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
+            if (pending)
+                return Promise.reject(Oops$9.DuplicatePending(key));
+            pending = true;
+            this.update(key);
+            try {
+                return yield mayRetry(() => (task.apply(this.subject, args)));
+            }
+            finally {
+                pending = false;
+                this.update(key);
+            }
+        });
+        this.state.set(key, undefined);
+        defineProperty(invoke, "active", {
+            get: () => pending
+        });
+        return {
+            value: invoke,
+            set: false
+        };
+    });
+}
+
+const Oops$8 = issues({
+    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
+});
+function factoryMode(self, value, key, required) {
+    const { subject, state } = self;
+    let pending;
+    let error;
+    if (value instanceof Promise) {
+        state.set(key, undefined);
+        pending = value
+            .catch(err => error = err)
+            .then(val => {
+            state.set(key, val);
+            return val;
+        })
+            .finally(() => {
+            pending = undefined;
+            self.update(key);
+        });
     }
-    once(select, does, squash) {
-        if (does)
-            return this.on(select, does, squash, true);
+    else
+        state.set(key, value);
+    const suspend = () => {
+        if (required === false)
+            return undefined;
+        const issue = Oops$8.NotReady(subject, key);
+        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);
+    };
+}
+
+const Oops$7 = issues({
+    PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or tap) as computed source for ${model}.${property}. This is not possible.`,
+    ComputeFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
+    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
+});
+function get(arg0, arg1, arg2) {
+    return add(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 arg0 == "symbol")
+            throw Oops$7.PeerNotAllowed(subject, key);
+        // if(typeof arg0 == "function" && /^[A-Z]/.test(arg0.name))
+        //   throw Oops.BadSource(subject, key, arg0);
+        this.state.set(key, undefined);
+        const init = () => {
+            let source = this;
+            let setter;
+            if (typeof arg0 == "function") {
+                let result = mayRetry(arg0.bind(subject, key, subject));
+                if (typeof result == "function")
+                    setter = result;
+                else {
+                    getter = factoryMode(this, result, key, factoryRequired);
+                    return;
+                }
+            }
+            else if (arg0 instanceof Promise) {
+                getter = factoryMode(this, arg0, key, factoryRequired);
+                return;
+            }
+            else if (typeof arg1 == "function") {
+                // replace source controller in-case it is different
+                source = control(arg0);
+                setter = arg1;
+            }
+            else
+                throw new Error(`Factory argument cannot be ${arg1}`);
+            getter = computeMode(this, source, setter, key, computeRequired);
+        };
+        if (typeof arg0 == "function" && computeRequired)
+            try {
+                init();
+            }
+            catch (err) {
+                Oops$7.ComputeFailed(subject, key).warn();
+                throw err;
+            }
+        return () => {
+            if (!getter)
+                init();
+            return getter();
+        };
+    });
+}
+
+function ref(arg, mapper) {
+    return add(function ref(key) {
+        let value = {};
+        this.state.set(key, undefined);
+        if (typeof arg != "object")
+            value = createRef(this, key, arg);
         else
-            return new Promise(resolve => {
-                this.on(select, resolve, true, true);
+            control(arg).state.forEach((_val, key) => {
+                defineProperty(value, key, mapper ? {
+                    configurable: true,
+                    get() {
+                        const out = mapper(key);
+                        defineProperty(value, key, { value: out });
+                        return out;
+                    }
+                } : {
+                    value: createRef(this, key)
+                });
+            });
+        return { value, explicit: true };
+    });
+}
+function createRef(src, key, cb) {
+    const refObjectFunction = src.ref(key, cb && createValueEffect(cb));
+    defineProperty(refObjectFunction, "current", {
+        set: refObjectFunction,
+        get: () => src.state.get(key)
+    });
+    return refObjectFunction;
+}
+
+function set(value, argument) {
+    if (!(1 in arguments)) {
+        argument = value;
+        value = undefined;
+    }
+    return add(function set(key) {
+        if (value !== undefined)
+            this.state.set(key, value);
+        return {
+            suspend: true,
+            set: typeof argument == "function"
+                ? createValueEffect(argument)
+                : undefined
+        };
+    });
+}
+
+const ANY = Symbol("any");
+function keyed(control, property, initial) {
+    const init = createProxy(emit, watch);
+    const frozen = new Set();
+    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.update(property);
+        control.waiting.add(() => frozen.clear());
+        update.forEach(notify => notify(key));
+    }
+    function subscribe(local) {
+        const proxy = create(managed);
+        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);
+                }
             });
-    }
-    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) {
-        const control = manage(this);
-        if (typeof arg == "boolean") {
-            if (!control.pending === arg)
-                return Promise.reject(Oops$4.StrictUpdate(arg));
-        }
-        else if (arg)
-            for (const key of keys(control, arg))
-                control.update(key);
-        if (control.pending)
-            return new Promise(cb => control.include(cb));
-        return Promise.resolve(false);
-    }
-    destroy() {
-        if (this.willDestroy)
-            this.willDestroy();
-    }
-    toString() {
-        return this.constructor.name;
+        watched.set(proxy, watch);
+        context.set(local, proxy);
+        return proxy;
     }
-    static create(...args) {
-        const instance = new this(...args);
-        manage(instance);
-        return instance;
-    }
-    static use(...args) {
-        return useModel(this, args);
-    }
-    static uses(props, only) {
-        return useModel(this, [], instance => {
-            instance.import(props, only);
+    return {
+        value: initial,
+        get(local) {
+            return local ?
+                context.get(local) || subscribe(local) :
+                managed;
+        },
+        set(next) {
+            control.state.set(property, next);
+            managed = init(next);
+            context.clear();
+            emit(ANY);
+        },
+        destroy() {
+            update.clear();
+            context.clear();
+        }
+    };
+}
+function createProxy(emit, watch) {
+    return (from) => {
+        const proxy = create(from);
+        assign(proxy, {
+            from,
+            delete(key) {
+                // TODO: this commit's fix needs tests.
+                // Was not cause by coverage.
+                const out = from.delete(key);
+                emit(key);
+                return out;
+            },
+            clear() {
+                from.clear();
+                emit(ANY);
+            },
+            has(key) {
+                watch(this, key);
+                return from.has(key);
+            },
+            keys() {
+                watch(this, ANY);
+                return from.keys();
+            },
+            values() {
+                watch(this, ANY);
+                return from.values();
+            },
+            entries() {
+                watch(this, ANY);
+                return from.entries();
+            },
+            forEach(callbackfn, thisArg) {
+                const acc = [];
+                from.forEach((a, b, c) => {
+                    const result = callbackfn.call(thisArg, a, b, c);
+                    if (result !== undefined)
+                        acc.push(result);
+                });
+                watch(this, ANY);
+                return acc;
+            },
+            [Symbol.iterator]() {
+                watch(this, ANY);
+                return from[Symbol.iterator]();
+            },
+        }, from instanceof Set
+            ? {
+                add(key) {
+                    from.add(key);
+                    emit(key);
+                    return this;
+                }
+            }
+            : {
+                get(key) {
+                    watch(this, ANY);
+                    return from.get(key);
+                },
+                set(key, value) {
+                    from.set(key, value);
+                    emit(key);
+                    return this;
+                }
+            });
+        defineProperty(proxy, "size", {
+            get() {
+                watch(this, ANY);
+                return from.size;
+            }
         });
+        return proxy;
+    };
+}
+
+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 add(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") {
+            if ("prototype" in input && input === input.prototype.constructor)
+                input = new input();
+        }
+        else if (input && typeof input !== "object")
+            throw Oops$6.BadArgument(typeof input);
+        if (input instanceof Map || input instanceof Set)
+            return keyed(this, key, input);
+        const onUpdate = (next) => {
+            state.set(key, next);
+            if (next) {
+                get = getRecursive(key, this);
+                Parent.set(next, subject);
+                control(next);
+            }
+            if (typeof argument == "function")
+                argument(next);
+            return true;
+        };
+        const suspend = () => {
+            if (required === false)
+                return;
+            const issue = Oops$6.NotReady(subject, key);
+            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,
+            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(Type, required) {
+    return add(function parent() {
+        const child = this.subject;
+        const value = Parent.get(child);
+        const expected = Type.name;
+        if (!value) {
+            if (required !== false)
+                throw Oops$5.Required(expected, child);
+        }
+        else if (!(value instanceof Type))
+            throw Oops$5.Unexpected(expected, child, value);
+        return { value };
+    });
+}
+
+const Oops$4 = issues({
+    NotFound: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`
+});
+class Lookup {
+    constructor() {
+        this.table = new Map();
     }
-    static using(props, only) {
-        const instance = useModel(this, []);
-        instance.import(props, only);
-        return instance;
-    }
-    static new(...args) {
-        return useLazy(this, args);
-    }
-    static get(key) {
-        const instance = this.find(!!key);
-        return (typeof key == "function" ?
-            key(instance) :
-            typeof key == "string" ?
-                instance[key] :
-                instance);
-    }
-    static tap(key, expect) {
-        return useWatcher(this.find(true), key, expect);
-    }
-    static tag(id) {
-        return useSubscriber(this.find(true), id);
+    key(T) {
+        let key = this.table.get(T);
+        if (!key) {
+            key = Symbol(T.name);
+            this.table.set(T, key);
+        }
+        return key;
     }
-    static meta(path) {
-        return useWatcher(this, path);
+    get(Type) {
+        return this[this.key(Type)];
+    }
+    has(key, input, callback) {
+        if (MVC.isTypeof(input) && input.global)
+            return input.new();
+        if (this.register.get(key) === input)
+            return typeof input == "object"
+                ? input
+                : this.get(input);
+        const instance = this.add(input);
+        this.register.set(key, input);
+        if (callback)
+            callback(instance);
+        return instance;
     }
-    static find(strict) {
-        return useFromContext(this, strict);
+    add(input) {
+        let writable = true;
+        let T;
+        let I;
+        if (typeof input == "function") {
+            T = input;
+            I = new input();
+        }
+        else {
+            I = input;
+            T = I.constructor;
+            writable = false;
+        }
+        do {
+            const key = this.key(T);
+            defineProperty(this, key, {
+                configurable: true,
+                value: this.hasOwnProperty(key) ? null : I,
+                writable
+            });
+            T = getPrototypeOf(T);
+        } while (T !== Model);
+        return I;
     }
-    static isTypeof(maybe) {
-        return (typeof maybe == "function" &&
-            maybe.prototype instanceof this);
+    push() {
+        const next = create(this);
+        next.register = new Map();
+        return next;
     }
-    static get inherits() {
-        const I = getPrototypeOf(this);
-        if (I !== Model)
-            return I;
+    pop() {
+        const items = new Set();
+        for (const key of getOwnPropertySymbols(this)) {
+            const entry = getOwnPropertyDescriptor(this, key);
+            if (entry.writable && entry.value)
+                items.add(entry.value);
+        }
+        for (const model of items)
+            model.end();
     }
 }
-Model.STATE = STATE;
-Model.CONTROL = CONTROL;
-Model.LOCAL = LOCAL;
-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.push(() => {
-            done = real.apply(subject, args);
-        });
-        return () => done();
-    };
+const LookupContext = React__default["default"].createContext(new Lookup());
+const useLookup = () => React__default["default"].useContext(LookupContext);
+function useContext(Type, required) {
+    const instance = useLookup().get(Type);
+    if (!instance && required !== false)
+        throw Oops$4.NotFound(Type.name);
+    return instance;
 }
 
 const Oops$3 = issues({
-    ComputeFailed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`,
-    ComputedEarly: (property) => `Note: Computed values don't run until accessed, except when subscribed to. '${property}' getter may have run earlier than intended.`
+    NotAllowed: (parent, child) => `Global '${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.`
 });
-const ComputedInit = new WeakSet();
-const ComputedInfo = new WeakMap();
-const ComputedFor = new WeakMap();
-const ComputedKeys = new WeakMap();
-function bootstrap(on) {
-    const defined = new Map();
-    let scan = on.subject;
-    ComputedFor.set(on, defined);
-    while (scan !== Model && scan.constructor !== Model) {
-        for (let [key, { get, set }] of entriesIn(scan))
-            if (get && !defined.has(key))
-                defined.set(key, prepare(on, key, get, set));
-        scan = getPrototypeOf(scan);
+const Pending = new WeakMap();
+const Applied = new WeakMap();
+function tap(type, argument) {
+    return add(function tap(key) {
+        if (MVC.isTypeof(type) && type.global)
+            return {
+                recursive: true,
+                value: type.get()
+            };
+        const { subject } = this;
+        if (subject.constructor.global)
+            throw Oops$3.NotAllowed(subject, type.name);
+        getPending(subject).push(context => {
+            let instance = context.get(type);
+            if (typeof argument == "function") {
+                if (argument(instance) === false)
+                    instance = undefined;
+            }
+            else if (!instance && argument)
+                throw Oops$3.AmbientRequired(type.name, subject, key);
+            this.state.set(key, instance);
+            this.update(key);
+        });
+        return {
+            recursive: true,
+            suspend: true
+        };
+    });
+}
+function usePeerContext(subject) {
+    if (Applied.has(subject)) {
+        if (Applied.get(subject))
+            useLookup();
+        return;
+    }
+    const pending = Pending.get(subject);
+    if (pending) {
+        const local = useLookup();
+        for (const init of pending)
+            init(local);
+        Pending.delete(subject);
     }
+    Applied.set(subject, !!pending);
 }
-function prepare(on, key, getter, setter) {
-    const { state, subject } = on;
-    const info = {
-        key, parent: on, priority: 1
-    };
-    let sub;
-    function compute(initial) {
-        try {
-            return getter.call(sub.proxy, sub.proxy);
-        }
-        catch (err) {
-            Oops$3.ComputeFailed(subject, key, !!initial).warn();
-            throw err;
-        }
+function getPending(subject) {
+    let pending = Pending.get(subject);
+    if (!pending)
+        Pending.set(subject, pending = []);
+    return pending;
+}
+
+function useNew(source, arg1, arg2) {
+    const instance = React__default["default"].useMemo(() => {
+        const callback = arg2 || arg1;
+        const instance = Model.isTypeof(source)
+            ? new source()
+            : source();
+        control(instance);
+        if (typeof callback == "function")
+            callback(instance);
+        return instance;
+    }, []);
+    usePeerContext(instance);
+    if (Array.isArray(arg1)) {
+        const update = React.useState(0)[1];
+        React__default["default"].useLayoutEffect(() => {
+            if (arg1.length && instance instanceof Model)
+                instance.on(arg1, () => update(x => x + 1));
+            return () => {
+                if (Model.isTypeof(source))
+                    instance.end();
+            };
+        }, []);
+        return instance;
     }
-    function update() {
-        let value;
-        try {
-            value = compute(false);
-        }
-        catch (e) {
-            console.error(e);
+    const state = React__default["default"].useState(0);
+    const local = React__default["default"].useMemo(() => {
+        const refresh = state[1].bind(null, x => x + 1);
+        return control(instance).subscribe(() => refresh);
+    }, []);
+    if (typeof arg1 == "object") {
+        const { waiting, subject } = local.parent;
+        let keys = arg2;
+        local.active = false;
+        if (!keys)
+            keys = getOwnPropertyNames(subject);
+        for (const key of keys)
+            if (key in arg1)
+                subject[key] = arg1[key];
+        waiting.add(() => local.active = true);
+    }
+    React__default["default"].useLayoutEffect(() => {
+        local.commit();
+        return () => {
+            local.release();
+            if (Model.isTypeof(source))
+                instance.end();
+        };
+    }, []);
+    return local.proxy;
+}
+
+function use(init, deps) {
+    const state = React__default["default"].useState(0);
+    return React__default["default"].useMemo(() => {
+        return init(state[1].bind(null, x => x + 1));
+    }, deps);
+}
+
+function useCompute(source, compute, suspend) {
+    const deps = [uid(source)];
+    const local = use(refresh => {
+        const sub = control(source).subscribe(() => update);
+        const spy = sub.proxy;
+        let make = () => compute.call(spy, spy, forceUpdate);
+        function forceUpdate(passthru) {
+            if (make)
+                reassign(make());
+            else
+                refresh();
+            if (passthru)
+                return passthru.finally(refresh);
         }
-        finally {
-            if (state[key] !== value) {
-                on.update(key, value);
-                return value;
+        function reassign(next) {
+            value = next;
+            if (retry) {
+                retry();
+                retry = undefined;
             }
+            else
+                refresh();
         }
-    }
-    function create(early) {
-        sub = new Subscriber(on, update);
-        ComputedInfo.set(update, info);
-        defineProperty(state, key, {
-            value: undefined,
-            writable: true
-        });
-        defineProperty(subject, key, {
-            enumerable: true,
-            configurable: true,
-            get: () => state[key],
-            set: setter
-        });
-        try {
-            return state[key] = compute(true);
+        let retry;
+        let update;
+        let value = make();
+        if (value === null) {
+            sub.watch.clear();
+            make = undefined;
+            return;
         }
-        catch (e) {
-            if (early)
-                Oops$3.ComputedEarly(key).warn();
-            throw e;
+        if (typeof value == "function") {
+            const get = value;
+            sub.watch.clear();
+            compute = () => get();
+            value = get();
         }
-        finally {
-            let defined = ComputedFor.get(on);
+        if (value instanceof Promise) {
+            value.then(reassign);
+            value = undefined;
+        }
+        else {
             sub.commit();
-            for (const key in sub.follows) {
-                const compute = defined.get(key);
-                if (compute && compute.priority >= info.priority)
-                    info.priority = compute.priority + 1;
-            }
+            update = () => {
+                const next = make();
+                if (value != next)
+                    reassign(next);
+            };
         }
-    }
-    function revert(value) {
-        delete state[key];
-        defineProperty(subject, key, {
-            enumerable: true,
-            configurable: true,
-            value
-        });
-    }
-    setAlias(update, `try ${key}`);
-    setAlias(create, `new ${key}`);
-    setAlias(getter, `run ${key}`);
-    ComputedInit.add(create);
-    for (const on of [state, subject])
-        defineProperty(on, key, {
-            get: create,
-            set: setter || revert,
-            configurable: true,
-            enumerable: true
+        defineProperty(sub, "proxy", {
+            get() {
+                if (value !== undefined)
+                    return value;
+                if (suspend)
+                    throw new Promise(res => retry = res);
+                return null;
+            }
         });
-    return info;
-}
-function ensure(on, keys) {
-    for (const key of keys) {
-        const desc = getOwnPropertyDescriptor(on.subject, key);
-        const getter = desc && desc.get;
-        if (ComputedInit.has(getter))
-            getter(true);
-    }
-}
-function capture(on, request) {
-    const compute = ComputedInfo.get(request);
-    if (!compute)
-        return;
-    let pending = ComputedKeys.get(on);
-    if (!pending)
-        ComputedKeys.set(on, pending = []);
-    if (compute.parent !== on)
-        request();
-    else {
-        const byPriorty = (sib) => compute.priority > ComputedInfo.get(sib).priority;
-        pending.splice(pending.findIndex(byPriorty) + 1, 0, request);
-    }
-    return true;
+        return sub;
+    }, deps);
+    if (!local)
+        return null;
+    React__default["default"].useLayoutEffect(() => local.release, deps);
+    return local.proxy;
+}
+
+function useTap(source, arg1, arg2) {
+    const instance = typeof source == "object"
+        ? source
+        : "get" in source
+            ? source.get()
+            : useContext(source);
+    return typeof arg1 == "function"
+        ? useCompute(instance, arg1, arg2)
+        : useSubscribe(instance, arg1, arg2);
 }
-function flush(on) {
-    const handled = on.frame;
-    let pending = ComputedKeys.get(on);
-    if (pending) {
-        while (pending.length) {
-            const compute = pending.shift();
-            const { key } = ComputedInfo.get(compute);
-            if (!handled.has(key))
-                compute();
-        }
-        ComputedKeys.delete(on);
-    }
+function useSubscribe(source, path, expect) {
+    const deps = [uid(source)];
+    const local = use(refresh => (control(source).subscribe(() => refresh)), deps);
+    React__default["default"].useLayoutEffect(() => local.commit(), deps);
+    if (path === undefined)
+        return local.proxy;
+    const value = local.proxy[path];
+    if (value === undefined && expect)
+        throw suspend(local.parent, path);
+    return value;
 }
 
+const Global$1 = new WeakMap();
 const Oops$2 = issues({
-    DuplicateAction: (key) => `Invoked action ${key} but one is already active.`
+    DoesNotExist: (name) => `Tried to access singleton ${name}, but none exist! Did you forget to initialize?\nCall ${name}.new() before attempting to access, or consider using ${name}.use() instead.`,
+    AlreadyExists: (name) => `Shared instance of ${name} already exists! Consider unmounting existing, or use ${name}.reset() to force-delete it.`
 });
-const Pending = new Map();
-function set(instruction, name = instruction.name || "pending") {
-    const placeholder = Symbol(`${name} instruction`);
-    function apply(key) {
-        let output = instruction.call(this, key);
-        if (typeof output == "function") {
-            const getter = output;
-            output = Object.assign(Object.assign({}, getOwnPropertyDescriptor(this.subject, key)), { get() {
-                    return getter(this[LOCAL]);
-                } });
-        }
-        if (output)
-            defineProperty(this.subject, key, output);
-    }
-    Pending.set(placeholder, apply);
-    return placeholder;
-}
-function apply(on, key, value) {
-    const instruction = Pending.get(value);
-    if (instruction) {
-        Pending.delete(value);
-        delete on.subject[key];
-        instruction.call(on, key);
+class MVC extends Model {
+    end(force) {
+        const type = this.constructor;
+        if (type.keepAlive && !force)
+            return false;
+        super.end();
+        Global$1.delete(type);
         return true;
     }
-}
-const ref = (cb) => set(function ref(key) {
-    const refObjectFunction = this.sets(key, cb && createEffect(cb));
-    defineProperty(refObjectFunction, "current", {
-        set: refObjectFunction,
-        get: () => this.state[key]
-    });
-    return {
-        value: refObjectFunction
-    };
-});
-const on = (value, cb) => set(function on(key) {
-    this.manage(key, value, cb && createEffect(cb));
-});
-const memo = (factory, defer) => set(function memo(key) {
-    const source = this.subject;
-    const get = () => factory.call(source);
-    if (defer)
-        defineLazy(source, key, get);
-    else
-        define(source, key, get());
-});
-const lazy = (value) => set(function lazy(key) {
-    const source = this.subject;
-    source[key] = value;
-    defineProperty(this.state, key, {
-        get: () => source[key]
-    });
-});
-const act = (task) => set(function act(key) {
-    let pending = false;
-    const invoke = (...args) => {
-        if (pending)
-            return Promise.reject(Oops$2.DuplicateAction(key));
-        pending = true;
-        this.update(key);
-        return new Promise(res => {
-            res(task.apply(this.subject, args));
-        }).finally(() => {
-            pending = false;
-            this.update(key);
-        });
-    };
-    setAlias(invoke, `run ${key}`);
-    defineProperty(invoke, "active", {
-        get: () => pending
-    });
-    return {
-        value: invoke,
-        writable: false
-    };
-});
-const from = (getter) => set(function from(key) {
-    prepare(this, key, getter);
-});
+    static new(...args) {
+        if (Global$1.has(this))
+            if (this.keepAlive)
+                return Global$1.get(this);
+            else
+                throw Oops$2.AlreadyExists(this.name);
+        const instance = super.new(...args);
+        if (this.global)
+            Global$1.set(this, instance);
+        return instance;
+    }
+    static get(arg1, arg2) {
+        let instance;
+        const required = arg1 === undefined || arg1 === true;
+        if (this.global) {
+            instance = Global$1.get(this);
+            if (!instance && required)
+                throw Oops$2.DoesNotExist(this.name);
+        }
+        else
+            instance = useContext(this, required);
+        function callback(effect) {
+            try {
+                React__default["default"].useLayoutEffect(() => effect(instance), []);
+            }
+            catch (err) {
+                if (instance)
+                    instance.on(effect, []);
+                else
+                    effect(undefined);
+            }
+        }
+        if (typeof arg1 === "string")
+            return instance[arg1];
+        if (typeof arg1 === "function" && instance)
+            callback(arg1);
+        else if (arg2)
+            callback(arg2);
+        return instance;
+    }
+    static tap(arg1, arg2) {
+        const instance = this.get();
+        return typeof arg1 == "function"
+            ? useCompute(instance, arg1, arg2)
+            : useSubscribe(instance, arg1, arg2);
+    }
+    static use(a, b) {
+        return useNew(this, a, b);
+    }
+    static meta(arg1, arg2) {
+        return typeof arg1 == "function"
+            ? useCompute(this, arg1, arg2)
+            : useSubscribe(this, arg1, arg2);
+    }
+}
 
-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.`
+    BadProps: () => `Provider expects either a render function, 'get' or 'has' props.`
 });
-const use = (Peer, argument) => set(function use(key) {
-    const Proxies = new WeakMap();
-    let instance;
-    const update = (next) => {
-        instance = next;
-        if (next) {
-            Parent.set(instance, this.subject);
-            manage(instance);
-        }
-        if (typeof argument == "function")
-            argument(instance);
-        else if (!instance && argument !== false)
-            throw Oops$1.UndefinedNotAllowed(key);
-    };
-    const attach = (sub) => {
-        let child;
-        function create() {
-            if (!instance)
-                return;
-            child = new Subscriber(instance, sub.onUpdate);
-            if (sub.active)
-                child.commit();
-            sub.dependant.add(child);
-            Proxies.set(sub, child.proxy);
-        }
-        function refresh() {
-            if (child) {
-                child.release();
-                sub.dependant.delete(child);
-                Proxies.set(sub, undefined);
-                child = undefined;
-            }
-            create();
-            sub.onUpdate();
-        }
-        create();
-        sub.follow(key, refresh);
-    };
-    if (Peer) {
-        instance = Model.isTypeof(Peer)
-            ? new Peer()
-            : Peer();
-        if (instance)
-            update(instance);
-    }
+function Consumer(props) {
+    const { get, has, children, for: type } = props;
+    if (typeof children == "function")
+        return children(useTap(type));
+    const callback = has || get;
+    if (typeof callback == "function")
+        callback(useContext(type, !!has));
     else
-        argument = false;
-    this.manage(key, instance, update);
-    return (local) => {
-        if (!local)
-            return instance;
-        if (!Proxies.has(local))
-            attach(local);
-        return Proxies.get(local);
-    };
-});
-const parent = (Expects, required) => set(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 };
-});
+        throw Oops$1.BadProps();
+    return null;
+}
 
 const Oops = issues({
-    GlobalDoesNotExist: (name) => `Tried to access singleton ${name}, but none exist! Did you forget to initialize?\nCall ${name}.create() before attempting to access, or consider using ${name}.use() instead.`,
-    GlobalExists: (name) => `Shared instance of ${name} already exists! Consider unmounting existing, or use ${name}.reset() to force-delete it.`
+    NoType: () => "Provider 'for' prop must be Model, typeof Model or a collection of them."
 });
-const Active = new WeakMap();
-class Singleton extends Model {
-    static get current() {
-        return Active.get(this);
-    }
-    static create(...args) {
-        const Type = this;
-        if (Active.has(Type))
-            throw Oops.GlobalExists(this.name);
-        let instance = super.create(...args);
-        Active.set(Type, instance);
-        return instance;
-    }
-    static find() {
-        if (this.current)
-            return this.current;
-        throw Oops.GlobalDoesNotExist(this.name);
-    }
-    static reset() {
-        if (this.current)
-            this.current.destroy();
+function Provider(props) {
+    const context = useNewContext(props.for, props.and);
+    return (React__default["default"].createElement(LookupContext.Provider, { value: context }, props.fallback === false
+        ? props.children
+        : (React__default["default"].createElement(React.Suspense, { fallback: props.fallback || null }, props.children))));
+}
+function useNewContext(include, assign) {
+    const init = new Set();
+    const ambient = useLookup();
+    const context = React__default["default"].useMemo(() => {
+        if (!include)
+            throw Oops.NoType();
+        return ambient.push();
+    }, []);
+    function register(key, T) {
+        const instance = context.has(key, T, i => init.add(i));
+        if (assign)
+            assignWeak(instance, assign);
     }
-    destroy() {
-        super.destroy();
-        Active.delete(this.constructor);
+    if (typeof include == "function" || include instanceof Model)
+        register(0, include);
+    else
+        entries(include).forEach(e => register(...e));
+    for (const instance of init) {
+        control(instance).state.forEach(value => {
+            if (Parent.get(value) === instance) {
+                context.add(value);
+                init.add(value);
+            }
+        });
+        for (const apply of getPending(instance))
+            apply(context);
     }
+    React__default["default"].useLayoutEffect(() => () => context.pop(), []);
+    return context;
 }
 
+class Global extends MVC {
+}
+Global.global = true;
+Global.keepAlive = true;
+
+const LOCAL = "$debug local";
+const STATE = "$debug state";
+const UPDATE = "$debug update";
+const CONTROL = "$debug controller";
+defineProperties(Model.prototype, {
+    [CONTROL]: {
+        get() {
+            return controller(this);
+        }
+    },
+    [LOCAL]: {
+        get() {
+            return subscriber(this);
+        }
+    },
+    [STATE]: {
+        get() {
+            const { state } = controller(this);
+            const output = {};
+            state.forEach((value, key) => output[key] = value);
+            return output;
+        }
+    },
+    [UPDATE]: {
+        get() {
+            return (subscriber(this) || controller(this)).latest;
+        }
+    }
+});
+const Debug = {
+    CONTROL,
+    LOCAL,
+    STATE,
+    UPDATE
+};
+
 exports.Consumer = Consumer;
-exports.Model = Model;
+exports.Debug = Debug;
+exports.Global = Global;
+exports.MVC = MVC;
+exports.Model = MVC;
 exports.Provider = Provider;
-exports.Singleton = Singleton;
-exports.act = act;
-exports.default = Model;
-exports.from = from;
-exports.lazy = lazy;
-exports.memo = memo;
-exports.on = on;
-exports.parent = parent;
+exports.add = add;
+exports["default"] = MVC;
+exports.get = get;
+exports.has = has;
 exports.ref = ref;
+exports.run = run;
 exports.set = set;
 exports.tap = tap;
-exports.use = use;
+exports.use = use$1;
+exports.useContext = useContext;
+exports.useNew = useNew;
+exports.useTap = useTap;