@expressive/mvc 1.0.0-beta.36 → 1.0.0-beta.37

package/lib/index.esm.js

@@ -1,31 +1,4 @@
-import React from '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;
-}
+import React, { useState, useMemo } from 'react';
 
 class Issue extends Error {
     constructor() {
@@ -44,10 +17,10 @@ function issues(register) {
     return Library;
 }
 
-const Oops$9 = issues({
+const Oops$d = issues({
     BadEffectCallback: () => `Callback for effect-callback may only return a function.`
 });
-const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertyDescriptors, getOwnPropertySymbols, keys, values } = Object;
+const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
 function define(target, key, value) {
     defineProperty(target, key, { value });
 }
@@ -73,7 +46,7 @@ function createEffect(callback) {
         if (unSet instanceof Promise)
             unSet = undefined;
         if (unSet && typeof unSet !== "function")
-            throw Oops$9.BadEffectCallback();
+            throw Oops$d.BadEffectCallback();
     };
 }
 function createValueEffect(callback) {
@@ -89,52 +62,92 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$9.BadEffectCallback();
+            throw Oops$d.BadEffectCallback();
     };
 }
 
-const Oops$8 = issues({
+const UPDATE = new WeakMap();
+function applyUpdate(subject, keys) {
+    UPDATE.set(subject, keys);
+    return () => {
+        setTimeout(() => {
+            UPDATE.delete(subject);
+        }, 0);
+    };
+}
+
+const Oops$c = 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 READY = new WeakSet();
 class Controller {
     constructor(subject) {
         this.subject = subject;
+        this.state = {};
         this.frame = new Set();
         this.waiting = new Set();
+        this.onDestroy = new Set();
         this.followers = new Set();
+        this.proxy = Object.create(subject);
     }
     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;
+        this.emit([]);
     }
-    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);
-            }
-            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)
-                });
-            }
+    stop() {
+        this.followers.clear();
+        this.onDestroy.forEach(x => x());
+    }
+    manage(key) {
+        const { proxy, state, subject } = this;
+        const { value: entry } = getOwnPropertyDescriptor(subject, key);
+        if (typeof entry == "function")
+            return;
+        let onGet;
+        let onSet;
+        let enumerable;
+        const instruction = Pending.get(entry);
+        if (instruction) {
+            Pending.delete(entry);
+            delete subject[key];
+            const desc = instruction.call(this, key, this);
+            if (!desc)
+                return;
+            if ("value" in desc)
+                state[key] = desc.value;
+            onSet = desc.set;
+            onGet = desc.get;
+            enumerable = desc.enumerable;
         }
+        else
+            state[key] = entry;
+        const set = onSet !== false
+            ? this.ref(key, onSet)
+            : undefined;
+        function get() {
+            const local = this[LOCAL];
+            const value = state[key];
+            if (local && !local.watch[key])
+                local.watch[key] = true;
+            return onGet ? onGet(value, local) : value;
+        }
+        setAlias(get, `tap ${key}`);
+        defineProperty(subject, key, {
+            enumerable,
+            set,
+            get: onGet
+                ? () => onGet(state[key])
+                : () => state[key]
+        });
+        defineProperty(proxy, key, {
+            enumerable,
+            set,
+            get
+        });
     }
-    setter(key, handler) {
+    ref(key, handler) {
         const { state, subject } = this;
         return (value) => {
             if (state[key] == value)
@@ -155,6 +168,18 @@ class Controller {
             this.followers.delete(listener);
         };
     }
+    emit(keys) {
+        const waiting = [...this.waiting];
+        this.waiting.clear();
+        applyUpdate(this.subject, keys)();
+        for (const callback of waiting)
+            try {
+                callback(keys);
+            }
+            catch (err) {
+                console.error(err);
+            }
+    }
     update(key, value) {
         if (1 in arguments)
             this.state[key] = value;
@@ -164,19 +189,8 @@ class Controller {
             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);
-                setTimeout(() => {
-                    UPDATE.delete(this.subject);
-                }, 0);
-                handle.forEach(callback => {
-                    try {
-                        callback(keys);
-                    }
-                    catch (e) { }
-                });
+                this.emit(keys);
             }, 0);
         this.frame.add(key);
         for (const callback of this.followers) {
@@ -191,7 +205,7 @@ class Controller {
             return;
         }
         if (typeof arg == "boolean" && arg !== this.frame.size > 0)
-            return Promise.reject(Oops$8.StrictUpdate(arg));
+            return Promise.reject(Oops$c.StrictUpdate(arg));
         return {
             then: (callback) => {
                 if (callback)
@@ -200,76 +214,83 @@ class Controller {
                     else
                         callback(false);
                 else
-                    throw Oops$8.NoChaining();
+                    throw Oops$c.NoChaining();
             }
         };
     }
+}
+function control(subject, cb) {
+    let control = subject[CONTROL];
+    const ready = READY.has(control);
+    if (!control) {
+        control = new Controller(subject);
+        define(subject, CONTROL, control);
+    }
+    if (!cb) {
+        if (!ready) {
+            READY.add(control);
+            control.start();
+        }
+        return control;
+    }
+    if (!ready) {
+        let done;
+        control.requestUpdate(() => {
+            done = cb(control);
+        });
+        return () => done && done();
+    }
+    return cb(control);
 }
 
 class Subscriber {
     constructor(parent, onUpdate) {
         this.onUpdate = onUpdate;
         this.active = false;
-        this.watch = {};
         this.dependant = new Set();
+        this.watch = {};
         if (!(parent instanceof Controller))
-            parent = getController(parent);
-        this.parent = parent;
-        this.source = parent.subject;
-        const proxy = this.proxy = create(parent.subject);
-        const DEBUG = (keys) => {
-            UPDATE.set(proxy, keys.filter(k => k in this.watch));
-        };
+            parent = control(parent);
+        let reset;
+        const proxy = create(parent.proxy);
+        const controller = parent;
         define(proxy, LOCAL, this);
         defineProperty(this, "proxy", {
-            get: () => {
-                if (UPDATE.has(proxy))
-                    setTimeout(() => {
-                        UPDATE.delete(proxy);
-                    }, 0);
+            configurable: true,
+            get() {
+                if (reset)
+                    setTimeout(reset, 0);
                 return proxy;
             }
         });
-        for (const key in parent.state) {
-            const existing = getOwnPropertyDescriptor(parent.subject, key);
-            const isUsing = () => {
-                this.watch[key] = true;
-                delete proxy[key];
-                return proxy[key];
+        const onEvent = (key) => {
+            const handler = this.watch[key];
+            if (!handler)
+                return;
+            if (typeof handler == "function")
+                handler();
+            const notify = this.onUpdate(key, controller);
+            const getWhy = (keys) => {
+                reset = applyUpdate(proxy, keys.filter(k => k in this.watch));
             };
-            setAlias(isUsing, `tap ${key}`);
-            defineProperty(proxy, key, {
-                set: existing.set,
-                get: isUsing,
-                configurable: true,
-                enumerable: true
-            });
-        }
+            if (notify) {
+                controller.requestUpdate(getWhy);
+                controller.requestUpdate(notify);
+            }
+        };
         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);
-                }
-            });
+            const release = controller.addListener(onEvent);
             this.active = true;
             this.dependant.forEach(x => x.commit());
             return this.release = () => {
                 this.dependant.forEach(x => x.release());
-                onDone();
+                release();
             };
         };
     }
 }
 
-const Oops$7 = issues({
+const Oops$b = 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.`
 });
@@ -287,15 +308,12 @@ function prepare(parent, key, source, setter, getter) {
         USED.set(parent, register);
     }
     register.set(key, info);
-    const current = getter
-        ? () => getter(parent, key)
-        : () => state[key];
     function compute(initial) {
         try {
             return setter.call(sub.proxy, sub.proxy);
         }
         catch (err) {
-            Oops$7.ComputeFailed(subject, key, !!initial).warn();
+            Oops$b.ComputeFailed(subject, key, !!initial).warn();
             throw err;
         }
     }
@@ -331,17 +349,12 @@ function prepare(parent, key, source, setter, getter) {
             value: undefined,
             writable: true
         });
-        defineProperty(subject, key, {
-            enumerable: true,
-            configurable: true,
-            get: current
-        });
         try {
-            state[key] = compute(true);
+            return state[key] = compute(true);
         }
         catch (e) {
             if (early)
-                Oops$7.ComputedEarly(key).warn();
+                Oops$b.ComputedEarly(key).warn();
             throw e;
         }
         finally {
@@ -352,23 +365,24 @@ function prepare(parent, key, source, setter, getter) {
                     info.priority = peer.priority + 1;
             }
         }
-        return current();
     }
     setAlias(update, `try ${key}`);
     setAlias(create, `new ${key}`);
     setAlias(setter, `run ${key}`);
     INIT.add(create);
     INFO.set(update, info);
-    for (const on of [state, subject])
-        defineProperty(on, key, {
-            get: create,
-            configurable: true,
-            enumerable: true
-        });
+    defineProperty(state, key, {
+        get: create,
+        configurable: true,
+        enumerable: true
+    });
+    return getter
+        ? () => getter(parent, key)
+        : {};
 }
-function ensure$1(on, keys) {
+function ensure(on, keys) {
     for (const key of keys) {
-        const desc = getOwnPropertyDescriptor(on.subject, key);
+        const desc = getOwnPropertyDescriptor(on.state, key);
         const getter = desc && desc.get;
         if (INIT.has(getter))
             getter(true);
@@ -393,26 +407,6 @@ 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));
@@ -426,11 +420,13 @@ class Model {
         return UPDATE.get(this);
     }
     on(select, handler, squash, once) {
-        return ensure(this, control => {
+        return control(this, control => {
+            if (typeof select == "function")
+                return control.addListener(select);
             const keys = typeof select == "string" ? [select] :
                 !select.length ? getOwnPropertyNames(control.state) :
                     select;
-            ensure$1(control, keys);
+            ensure(control, keys);
             const callback = squash
                 ? handler.bind(this)
                 : frame => frame
@@ -455,7 +451,7 @@ class Model {
     }
     effect(callback, select) {
         const effect = createEffect(callback);
-        return ensure(this, control => {
+        return control(this, control => {
             if (!select) {
                 const sub = new Subscriber(control, () => invoke);
                 const invoke = () => {
@@ -469,30 +465,40 @@ class Model {
                 effect.call(this.get, this.get);
             };
             invoke();
-            if (!select.length)
-                select.push("willDestroy");
+            if (!select.length) {
+                control.onDestroy.add(invoke);
+                return () => {
+                    control.onDestroy.delete(invoke);
+                };
+            }
             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];
+    // TODO: account for exotic properties
+    import(source, select) {
+        const { subject } = control(this);
+        if (!select)
+            select = getOwnPropertyNames(subject);
+        for (const key of select)
+            if (key in source)
+                this[key] = source[key];
     }
     export(subset) {
-        const { state } = getController(this);
+        const { state } = control(this);
         const output = {};
-        for (const key of subset || getOwnPropertyNames(state))
+        if (!subset)
+            subset = getOwnPropertyNames(state);
+        for (const key of subset)
             output[key] = state[key];
         return output;
     }
     update(arg, tag) {
-        const control = getController(this);
+        const target = control(this);
         if (typeof arg == "string") {
-            control.update(arg);
+            target.update(arg);
             if (1 in arguments && arg in this) {
                 const method = this[arg];
                 if (typeof method == "function")
@@ -503,28 +509,39 @@ class Model {
             }
             arg = undefined;
         }
-        return control.requestUpdate(arg);
+        return target.requestUpdate(arg);
     }
+    /**
+     * Mark this instance for garbage-collection and send `willDestroy` event to all listeners.
+     */
     destroy() {
-        this.update("willDestroy", true);
+        control(this).stop();
     }
     toString() {
         return this.constructor.name;
     }
+    /**
+     * Creates a new instance of this controller.
+     *
+     * Beyond `new this(...)`, method will activate managed-state.
+     *
+     * @param args - arguments sent to constructor
+     */
     static create(...args) {
         const instance = new this(...args);
-        getController(instance);
+        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);
     }
 }
-Model.CONTROL = CONTROL;
-Model.STATE = STATE;
-Model.LOCAL = LOCAL;
-Model.WHY = WHY;
 defineLazy(Model, CONTROL, function () {
     return new Controller(this);
 });
@@ -534,306 +551,302 @@ 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;
-                }
-            }
+        if ("explicit" in output) {
+            defineProperty(this.subject, key, output);
+            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] }));
+        if ("recursive" in output)
+            output = Object.assign(Object.assign({}, output), { get: recursive(this, key) });
+        if (typeof output == "function")
+            return { get: output };
+        else
+            return output;
     }
     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);
-                }
+}
+function recursive(source, key) {
+    const context = new WeakMap();
+    const subscribe = (parent) => {
+        let child;
+        const init = () => {
+            if (child) {
+                child.release();
+                parent.dependant.delete(child);
+                context.set(parent, undefined);
+                child = undefined;
             }
-            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);
+            const value = source.state[key];
+            if (value && CONTROL in value) {
+                child = new Subscriber(value, parent.onUpdate);
+                if (parent.active)
+                    child.commit();
+                parent.dependant.add(child);
+                context.set(parent, child.proxy);
             }
         };
-    }, name || source.name);
+        init();
+        parent.watch[key] = init;
+    };
+    return (value, local) => {
+        if (!local)
+            return value;
+        if (!context.has(local))
+            subscribe(local);
+        return context.get(local);
+    };
 }
 
-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}.`,
+const Oops$a = issues({
+    DuplicateAction: (key) => `Invoked action ${key} but one is already active.`
 });
-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);
+function act(task) {
+    return apply(function act(key) {
+        let pending = false;
+        const invoke = (...args) => {
+            if (pending)
+                return Promise.reject(Oops$a.DuplicateAction(key));
+            pending = true;
+            this.update(key);
+            return new Promise(res => {
+                res(task.apply(this.subject, args));
+            }).finally(() => {
+                pending = false;
+                this.update(key);
+            });
         };
-        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);
-        }
+        this.state[key] = undefined;
+        setAlias(invoke, `run ${key}`);
+        defineProperty(invoke, "active", {
+            get: () => pending
+        });
         return {
-            get: () => current,
-            set: onUpdate
+            value: invoke,
+            set: false
         };
     });
-}
-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",
-    WILL_MOUNT: "willMount",
-    WILL_UNMOUNT: "willUnmount",
-    DID_MOUNT: "didMount"
-};
-[
-    "didCreate",
-    "willDestroy",
-    ...values(Lifecycle)
-];
-function lifecycle(prefix) {
-    const type = eventsFor(prefix);
-    return function useLifecycle(sub, tag) {
-        const emit = React.useMemo(() => {
-            const subject = sub.source;
-            const id = typeof tag == "function" ? tag(subject) : tag;
-            return (name) => {
-                for (const key of [name, type(name)])
-                    subject.update(key, id);
-            };
-        }, [sub, tag]);
-        emit(Lifecycle.WILL_RENDER);
-        emit(sub.active
-            ? Lifecycle.WILL_UPDATE
-            : Lifecycle.WILL_MOUNT);
-        React.useLayoutEffect(() => {
-            sub.commit();
-            emit(Lifecycle.DID_MOUNT);
-            return () => {
-                emit(Lifecycle.WILL_UNMOUNT);
-                sub.release();
-            };
-        }, [sub]);
-    };
-}
-function eventsFor(prefix) {
-    const map = new Map();
-    for (const name of values(Lifecycle)) {
-        const alias = prefix + name[0].toUpperCase() + name.slice(1);
-        map.set(name, alias);
-    }
-    return (e) => map.get(e);
 }
 
-const useElementLifecycle = lifecycle("element");
-const useComponentLifecycle = lifecycle("component");
-function use(init) {
-    const [state, update] = React.useState(() => [
-        init(() => update(state.concat()))
-    ]);
-    return state[0];
-}
-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.useMemo(() => {
-        const instance = Type.create();
-        if (callback)
-            callback(instance);
-        return instance;
-    }, []);
-    React.useLayoutEffect(() => () => instance.destroy(), []);
-    instance.update("willRender", true);
-    return instance;
+const Oops$9 = issues({
+    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
+});
+/**
+ * Get value, suspend instead if undefined.
+ *
+ * Throws suspense promise also interpretable as an error.
+ * React could handle it but other contexts probably not.
+ */
+function pendingValue(via, key) {
+    const value = via.state[key];
+    if (value === undefined)
+        throw suspend(via, key);
+    return value;
 }
-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;
-                }
-            });
+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);
         }
-        return sub;
-    });
-    React.useLayoutEffect(() => hook.commit(), []);
-    return hook.proxy;
-}
-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;
+        catch (err) {
+            throw error = err;
+        }
+        if (output instanceof Promise) {
+            const issue = Oops$9.ValueNotReady(subject, key);
+            output
+                .catch(err => error = err)
+                .then(out => state[key] = out)
+                .finally(() => waiting = undefined);
+            throw waiting = Object.assign(output, {
+                message: issue.message,
+                stack: issue.stack
+            });
         }
         else {
-            sub.commit();
-            update = () => {
-                const next = compute.call(spy, spy);
-                if (value != next)
-                    set(next);
-            };
+            return state[key] = output;
         }
-        const get = expected
-            ? () => {
-                if (value === undefined)
-                    throw new Promise(res => retry = res);
-                return value;
-            }
-            : () => value;
-        defineProperty(sub, "proxy", { get });
-        return sub;
-    });
-    React.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)
+function suspend(source, key) {
+    const error = Oops$9.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;
     });
-    useComponentLifecycle(hook);
-    usePeerContext(hook.source);
-    return hook.proxy;
+    return Object.assign(promise, {
+        toString: () => String(error),
+        name: "Suspense",
+        message: error.message,
+        stack: error.stack
+    });
+}
+
+const Oops$8 = issues({
+    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.`
+});
+function from(source, setter, arg) {
+    return apply(function from(key) {
+        const { subject } = this;
+        let getSource;
+        let getter;
+        if (arg === true || setter === true)
+            getter = pendingValue;
+        if (typeof setter == "boolean")
+            setter = undefined;
+        // Easy mistake, using a peer, will always be unresolved.
+        if (typeof source == "symbol")
+            throw Oops$8.PeerNotAllowed(subject, key);
+        // replace source controller in-case it is different
+        if (typeof source == "object")
+            getSource = () => control(source);
+        // specifically an arrow function (getter factory)
+        else if (!source.prototype) {
+            setter = source.call(subject, key);
+            getSource = () => this;
+        }
+        // Regular function is too ambiguous so not allowed.
+        else
+            throw Oops$8.BadComputedSource(subject, key, source);
+        return prepare(this, key, getSource, setter, getter);
+    });
+}
+
+function ref(arg) {
+    return apply(function ref(key) {
+        let value = {};
+        if (typeof arg == "object") {
+            const source = control(arg);
+            for (const key in source.state)
+                defineLazy(value, key, createRef.bind(source, key));
+        }
+        else
+            value = createRef.call(this, key, arg);
+        return { value, explicit: true };
+    });
+}
+function createRef(key, cb) {
+    const refObjectFunction = this.ref(key, cb && createValueEffect(cb));
+    defineProperty(refObjectFunction, "current", {
+        set: refObjectFunction,
+        get: () => this.state[key]
+    });
+    return refObjectFunction;
+}
+
+const Oops$7 = 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.`
+});
+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$7.BadFactory();
+        else {
+            get = pendingFactory(this, key, factory);
+            if (required)
+                try {
+                    get();
+                }
+                catch (err) {
+                    if (err instanceof Promise)
+                        ;
+                    else {
+                        Oops$7.FactoryFailed(this.subject, key).warn();
+                        throw err;
+                    }
+                }
+        }
+        if (typeof argument == "function")
+            set = createValueEffect(argument);
+        else
+            set = (value) => {
+                if (value === undefined && required)
+                    throw Oops$7.NonOptional(this.subject, key);
+            };
+        return { set, get };
+    });
+}
+
+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}.`,
+});
+function parent(Expects, required) {
+    return apply(function parent() {
+        const child = this.subject;
+        const value = Parent.get(child);
+        const expected = Expects.name;
+        if (!value) {
+            if (required !== false)
+                throw Oops$6.ParentRequired(expected, child);
+        }
+        else if (!(value instanceof Expects))
+            throw Oops$6.UnexpectedParent(expected, child, value);
+        return { value };
+    });
+}
+
+const Oops$5 = issues({
+    BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
+});
+function use$1(input, argument) {
+    return apply(function use(key) {
+        const { subject } = this;
+        const onUpdate = (next) => {
+            this.state[key] = next;
+            if (next) {
+                Parent.set(next, subject);
+                control(next);
+            }
+            if (typeof argument == "function")
+                argument(next);
+            return true;
+        };
+        if (input) {
+            const value = Model.isTypeof(input)
+                ? new input() :
+                typeof input === "object"
+                    ? input :
+                    typeof input === "function"
+                        ? input()
+                        : null;
+            if (value === null)
+                throw Oops$5.BadArgument(typeof input);
+            if (value)
+                onUpdate(value);
+        }
+        return {
+            set: onUpdate,
+            recursive: true
+        };
+    });
 }
 
 class Lookup {
@@ -891,113 +904,56 @@ class Lookup {
     pop() {
         for (const key of getOwnPropertySymbols(this)) {
             const entry = getOwnPropertyDescriptor(this, key);
-            if (entry.writable)
+            if (entry.writable && entry.value)
                 entry.value.destroy();
         }
     }
 }
 
-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 useContext(Type, strict) {
+const Oops$4 = issues({
+    NothingInContext: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`
+});
+function useInContext(Type, arg) {
     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.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.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;
-        };
-    }, []);
-    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.useLayoutEffect(() => hook.commit(), []);
-    return props.render(hook.proxy);
-}
-function Provider(props) {
-    const context = useNewContext(props.of);
-    const render = props.children;
-    useAppliedProps(context, props);
-    React.useLayoutEffect(() => () => context.pop(), []);
-    return React.createElement(LookupContext.Provider, { value: context }, typeof render == "function"
-        ? React.createElement(RenderFunction, { context, render })
-        : render);
+    if (!instance && arg !== false)
+        throw Oops$4.NothingInContext(Type.name);
+    return typeof arg == "string" ?
+        instance[arg] :
+        instance;
 }
 
-const Oops$4 = issues({
-    CantAttachGlobal: (parent, child) => `Singleton '${parent}' attempted to attach '${child}' but it is not also a singleton.`,
+const Oops$3 = issues({
+    CantAttachGlobal: (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 PendingContext = new WeakMap();
 const ContextWasUsed = new WeakMap();
 function tap(type, argument) {
-    return child(function tap(key) {
+    return apply(function tap(key) {
+        if ("set" in type)
+            this.state[key] = type.get();
+        else {
+            const { subject } = this;
+            if ("set" in subject.constructor)
+                throw Oops$3.CantAttachGlobal(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.update(key, instance);
+            });
+        }
         return {
-            get: pendingAccess(this.subject, type, key, argument)
+            recursive: true
         };
     });
 }
-function pendingAccess(from, type, key, argument) {
-    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);
-        if (typeof argument == "function") {
-            if (argument(instance) === false)
-                instance = undefined;
-        }
-        else if (!instance && argument)
-            throw Oops$4.AmbientRequired(type.name, from, key);
-    });
-    return () => instance;
-}
 function usePeerContext(subject) {
     if (ContextWasUsed.has(subject)) {
         if (ContextWasUsed.get(subject))
@@ -1020,268 +976,242 @@ function getPending(subject) {
     return pending;
 }
 
-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.`
-});
-function createRef(key, cb) {
-    const refObjectFunction = this.setter(key, cb && createValueEffect(cb));
-    defineProperty(refObjectFunction, "current", {
-        set: refObjectFunction,
-        get: () => this.state[key]
-    });
-    return refObjectFunction;
-}
-function ref(arg) {
-    return apply(function ref(key) {
-        let value = {};
-        if (typeof arg == "object") {
-            const source = getController(arg);
-            for (const key in source.state)
-                defineLazy(value, key, createRef.bind(source, key));
-        }
-        else
-            value = createRef.call(this, key, arg);
-        return { value };
-    });
-}
-function act(task) {
-    return apply(function act(key) {
-        let pending = false;
-        const invoke = (...args) => {
-            if (pending)
-                return Promise.reject(Oops$3.DuplicateAction(key));
-            pending = true;
-            this.update(key);
-            return new Promise(res => {
-                res(task.apply(this.subject, args));
-            }).finally(() => {
-                pending = false;
-                this.update(key);
-            });
-        };
-        this.state[key] = undefined;
-        setAlias(invoke, `run ${key}`);
-        defineProperty(invoke, "active", {
-            get: () => pending
+function use(init) {
+    const [state, update] = React.useState(() => [
+        init(() => update(state.concat()))
+    ]);
+    return state[0];
+}
+
+function useModel(source, arg, callback) {
+    const instance = React.useMemo(() => {
+        const cb = callback || arg;
+        const instance = typeof source == "function" ?
+            source.prototype instanceof Model ?
+                new source() :
+                source() :
+            source;
+        control(instance);
+        if (typeof cb == "function")
+            cb(instance);
+        return instance;
+    }, []);
+    if (Array.isArray(arg)) {
+        const update = useState(0)[1];
+        React.useLayoutEffect(() => {
+            if (arg.length && instance instanceof Model)
+                instance.on(arg, () => update(x => x + 1), true);
+            return () => {
+                if (Model.isTypeof(source))
+                    instance.destroy();
+            };
+        }, []);
+        return instance;
+    }
+    else {
+        const local = use(refresh => {
+            return new Subscriber(instance, () => refresh);
         });
-        return {
-            value: invoke,
-            writable: false
-        };
-    });
-}
-function from(source, setter, argument) {
-    return apply(function from(key) {
-        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$3.PeerNotAllowed(subject, key);
-        // replace source controller in-case different
-        if (typeof source == "object")
-            getSource = () => getController(source);
-        // specifically an arrow function (getter factory)
-        else if (!source.prototype) {
-            setter = source.call(subject, key);
-            getSource = () => this;
-        }
-        // is a peer Model (constructor)
-        else if (Model.isTypeof(source))
-            getSource = pendingAccess(subject, source, key, true);
-        // Regular function is too ambiguous so not allowed.
-        else
-            throw Oops$3.BadComputedSource(subject, key, source);
-        prepare(this, key, getSource, setter, getter);
-    });
+        React.useLayoutEffect(() => {
+            local.commit();
+            return () => {
+                local.release();
+                if (Model.isTypeof(source))
+                    instance.destroy();
+            };
+        }, []);
+        return local.proxy;
+    }
 }
 
-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) {
-    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.
- *
- * Throws suspense promise also interpretable as an error.
- * React could handle it but other contexts probably not.
- */
-function pendingValue(via, key) {
-    const value = via.state[key];
-    if (value === undefined)
-        throw suspend(via, key);
-    return value;
-}
-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 => state[key] = out)
-                .finally(() => waiting = undefined);
-            throw waiting = Object.assign(output, {
-                message: issue.message,
-                stack: issue.stack
-            });
+function useFrom(target, compute, suspend) {
+    const local = 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 {
-            return state[key] = output;
+            sub.commit();
+            update = () => {
+                const next = compute.call(spy, spy);
+                if (value != next)
+                    set(next);
+            };
         }
-    };
-}
-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 () => {
-                    if (source.state[key] !== undefined) {
-                        release();
-                        resolve();
-                    }
-                };
+        defineProperty(sub, "proxy", {
+            get() {
+                if (value === undefined && suspend)
+                    throw new Promise(res => retry = res);
+                return value;
+            }
         });
+        return sub;
     });
-    return Object.assign(promise, {
-        toString: () => String(error),
-        name: "Suspense",
-        message: error.message,
-        stack: error.stack
-    });
+    React.useLayoutEffect(() => local.release, []);
+    return local.proxy;
 }
 
-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.`
-});
-function lazy(value) {
-    return apply(function lazy(key) {
-        const source = this.subject;
-        source[key] = value;
-        defineProperty(this.state, key, {
-            get: () => source[key]
-        });
-    });
-}
-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;
-                    }
+function useTap(source, path, expect) {
+    const instance = useMemo(() => {
+        if (typeof source == "object")
+            return () => source;
+        if ("get" in source)
+            return () => source.get();
+        if ("prototype" in source)
+            return () => useInContext(source);
+        else
+            return source;
+    }, [])();
+    if (typeof path == "function")
+        return useFrom(instance, path, expect);
+    const local = use(refresh => {
+        const parent = control(instance);
+        const sub = new Subscriber(parent, () => refresh);
+        if (typeof path == "string") {
+            const source = sub.proxy;
+            defineProperty(sub, "proxy", {
+                get() {
+                    const value = source[path];
+                    if (value === undefined && expect)
+                        throw suspend(parent, path);
+                    return value;
                 }
+            });
         }
-        if (typeof argument == "function")
-            set = createValueEffect(argument);
-        else
-            set = (value) => {
-                if (value === undefined && required)
-                    throw Oops$1.NonOptional(this.subject, key);
-            };
-        return { set, get };
+        return sub;
     });
-}
-function on(initial, onUpdate) {
-    return set(initial && (() => initial), onUpdate);
+    React.useLayoutEffect(() => local.commit(), []);
+    return local.proxy;
 }
 
 class MVC extends Model {
     tap(path, expect) {
         return useTap(this, path, expect);
     }
-    tag(id) {
-        return useTag(this, id);
+    use(arg, callback) {
+        return useModel(this, arg, callback);
     }
-    use(callback) {
-        return useNew(this, callback);
-    }
-    static new(callback) {
-        return usePassive(this, callback);
-    }
-    static get(key) {
-        const instance = useContext(this, key !== false);
-        return (typeof key == "string" ?
-            instance[key] :
-            instance);
+    static get(required) {
+        return useInContext(this, required);
     }
     static tap(key, expect) {
-        return this.get().tap(key, expect);
+        return useTap(this, key, expect);
     }
-    static tag(id) {
-        return this.get().tag(id);
+    /**
+     * **React Hook** - Spawn and maintain a controller from within a component.
+     *
+     * More efficient than `use()` if you don't need hook-based features.
+     *
+     * @param callback - Run after creation of instance.
+     */
+    static new(callback) {
+        return useModel(this, [], callback);
     }
-    static use(callback) {
-        return useModel(this, callback);
+    static use(arg, callback) {
+        const instance = useModel(this, arg, callback);
+        usePeerContext(instance.get);
+        return instance;
     }
-    static uses(props, only) {
+    static uses(data, only) {
         return this.use(instance => {
-            instance.import(props, only);
+            instance.import(data, only);
         });
     }
-    static using(props, only) {
+    static using(data, only) {
         const instance = this.use();
-        instance.import(props, only);
+        instance.import(data, only);
         return instance;
     }
     static meta(path, expect) {
-        return typeof path == "function"
-            ? useComputed(this, path, expect)
-            : useActive(this, path, expect);
+        return useTap(() => this, path, expect);
     }
 }
 
+const Oops$2 = issues({
+    BadConsumerProps: () => `Provider expects either a render function, 'get' or 'has' props.`
+});
+function Consumer(props) {
+    const { get, has, children, of: Control } = props;
+    if (typeof children == "function")
+        return children(useTap(Control));
+    const callback = has || get;
+    if (typeof callback == "function")
+        callback(useInContext(Control, !!has));
+    else
+        throw Oops$2.BadConsumerProps();
+    return null;
+}
+
+const Oops$1 = issues({
+    NoProviderType: () => `Provider 'of' prop must be Model, typeof Model or a collection of them.`
+});
+function Provider(props) {
+    const context = useNewContext(props.of);
+    const render = props.children;
+    useAppliedProps(context, props);
+    React.useLayoutEffect(() => () => context.pop(), []);
+    return React.createElement(LookupContext.Provider, { value: context }, typeof render == "function"
+        ? React.createElement(RenderFunction, { context, render })
+        : render);
+}
+function useNewContext(inject) {
+    const from = useLookup();
+    return React.useMemo(() => {
+        if (!inject)
+            throw Oops$1.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.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;
+        };
+    }, []);
+    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.useLayoutEffect(() => hook.commit(), []);
+    return props.render(hook.proxy);
+}
+
 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.`
 });
 const Active = new WeakMap();
-class Singleton extends MVC {
+class Global extends MVC {
     static create(...args) {
         const Type = this;
         if (Active.has(Type))
@@ -1290,6 +1220,11 @@ class Singleton extends MVC {
         Active.set(Type, instance);
         return instance;
     }
+    /**
+     * Update the active instance of this class.
+     * Returns a thenable; resolves after successful update.
+     * If instance does not already exist, one will be created.
+     */
     static set(updates) {
         const instance = Active.get(this) || this.create();
         instance.import(updates);
@@ -1303,6 +1238,7 @@ class Singleton extends MVC {
             instance[arg] :
             instance);
     }
+    /** Destroy current instance of Global, if it exists. */
     static reset() {
         const current = Active.get(this);
         if (current)
@@ -1314,5 +1250,5 @@ class Singleton extends MVC {
     }
 }
 
-export { Consumer, MVC as Model, Provider, Singleton, act, apply, child, MVC as default, from, lazy, set as memo, on, parent, pending, ref, set, tap, use$1 as use };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, MVC as default, from, parent, ref, set, tap, use$1 as use, useFrom, useInContext, useModel, useTap };
 //# sourceMappingURL=index.esm.js.map