@expressive/mvc 0.7.2 → 0.8.1

package/lib/index.esm.js

@@ -1,4 +1,4 @@
-import React, { useLayoutEffect, useState, useMemo } from 'react';
+import React, { useState, useMemo } from 'react';
 
 class Issue extends Error {
     constructor() {
@@ -18,10 +18,43 @@ function issues(register) {
 }
 
 const Oops$c = issues({
+    BadCallback: () => `Callback for effect-callback may only return a function.`
+});
+const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
+function createEffect(callback) {
+    let unSet;
+    return function (value) {
+        if (typeof unSet == "function")
+            unSet();
+        unSet = callback.call(this, value);
+        if (unSet instanceof Promise)
+            unSet = undefined;
+        if (unSet && typeof unSet !== "function")
+            throw Oops$c.BadCallback();
+    };
+}
+function createValueEffect(callback) {
+    let unSet;
+    return function (value) {
+        if (typeof unSet == "function")
+            unSet(value);
+        const out = callback.call(this, value, this);
+        if (typeof out == "boolean")
+            return out;
+        if (!out || out instanceof Promise)
+            return;
+        if (typeof out == "function")
+            unSet = out;
+        else
+            throw Oops$c.BadCallback();
+    };
+}
+
+const Oops$b = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
 });
 function suspend(source, key) {
-    const error = Oops$c.NotReady(source.subject, key);
+    const error = Oops$b.NotReady(source.subject, key);
     const promise = new Promise(resolve => {
         const release = source.addListener(forKey => {
             if (forKey == key)
@@ -33,7 +66,7 @@ function suspend(source, key) {
                 };
         });
     });
-    return Object.assign(promise, {
+    return assign(promise, {
         toString: () => String(error),
         name: "Suspense",
         message: error.message,
@@ -61,7 +94,7 @@ function mayRetry(fn) {
     return compute();
 }
 
-const Oops$b = issues({
+const Oops$a = issues({
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
 });
 const INFO = new WeakMap();
@@ -78,7 +111,7 @@ function computeMode(self, source, setter, key, required) {
             return setter.call(sub.proxy, sub.proxy);
         }
         catch (err) {
-            Oops$b.Failed(subject, key, initial).warn();
+            Oops$a.Failed(subject, key, initial).warn();
             throw err;
         }
     };
@@ -147,266 +180,28 @@ function flush(control) {
     KEYS.delete(control);
 }
 
-const Oops$a = issues({
-    BadCallback: () => `Callback for effect-callback may only return a function.`
-});
-const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
-function createEffect(callback) {
-    let unSet;
-    return function (value) {
-        if (typeof unSet == "function")
-            unSet();
-        unSet = callback.call(this, value);
-        if (unSet instanceof Promise)
-            unSet = undefined;
-        if (unSet && typeof unSet !== "function")
-            throw Oops$a.BadCallback();
-    };
-}
-function createValueEffect(callback) {
-    let unSet;
-    return function (value) {
-        if (typeof unSet == "function")
-            unSet(value);
-        const out = callback.call(this, value, this);
-        if (typeof out == "boolean")
-            return out;
-        if (!out || out instanceof Promise)
-            return;
-        if (typeof out == "function")
-            unSet = out;
-        else
-            throw Oops$a.BadCallback();
-    };
-}
-
-const Oops$9 = issues({
-    Timeout: (keys, timeout) => `No update for [${keys}] within ${timeout}.`,
-    StrictUpdate: () => `Strict update() did not find pending updates.`,
-    NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
-});
-const WHY = Symbol("UPDATE");
-const LOCAL = Symbol("LOCAL");
-const STATE = Symbol("STATE");
-class Model {
-    constructor() {
-        defineProperty(this, CONTROL, {
-            value: new Controller(this)
-        });
-        defineProperty(this, "is", {
-            value: this
-        });
-    }
-    get [STATE]() {
-        return this.export();
-    }
-    get [WHY]() {
-        return UPDATE.get(this);
-    }
-    on(select, handler, squash, once) {
-        return ensure(this, control => {
-            if (typeof select == "function")
-                return control.addListener(select);
-            const keys = typeof select == "string" ? [select] :
-                select.length ? select : [...control.state.keys()];
-            for (const key of keys)
-                try {
-                    void this[key];
-                }
-                catch (e) { }
-            const callback = squash
-                ? () => {
-                    handler.call(this, getUpdate(this));
-                }
-                : () => {
-                    getUpdate(this)
-                        .filter(k => keys.includes(k))
-                        .forEach(k => {
-                        handler.call(this, control.state.get(k), k);
-                    });
-                };
-            const onEvent = once
-                ? () => {
-                    remove();
-                    callback();
-                }
-                : callback;
-            const remove = control.addListener(key => {
-                if (keys.includes(key))
-                    return onEvent;
-            });
-            return remove;
-        });
-    }
-    once(select, argument, squash) {
-        if (typeof argument == "function")
-            return this.on(select, argument, squash, true);
-        if (typeof select == "string")
-            select = [select];
-        return new Promise((resolve, reject) => {
-            const invoke = (key) => {
-                if (!key) {
-                    clear();
-                    reject(Oops$9.Timeout(select, typeof argument == "number"
-                        ? `${argument}ms`
-                        : `lifetime of ${this}`));
-                }
-                else if (select.includes(key)) {
-                    clear();
-                    return resolve;
-                }
-            };
-            const clear = ensure(this, x => {
-                for (const key of select)
-                    try {
-                        void this[key];
-                    }
-                    catch (e) { }
-                return x.addListener(invoke);
-            });
-            if (typeof argument == "number")
-                setTimeout(invoke, argument);
-        });
-    }
-    effect(callback, select) {
-        const effect = createEffect(callback);
-        return ensure(this, control => {
-            let busy = false;
-            let inject = this.is;
-            const invoke = () => {
-                if (busy)
-                    return;
-                const output = mayRetry(() => {
-                    effect.call(inject, inject);
-                });
-                if (output instanceof Promise) {
-                    output.finally(() => busy = false);
-                    busy = true;
-                }
-            };
-            if (!select) {
-                const sub = control.subscribe(() => invoke);
-                inject = sub.proxy;
-                invoke();
-                return sub.commit();
-            }
-            invoke();
-            return control.addListener(key => {
-                if (key === null) {
-                    if (!select.length)
-                        invoke();
-                }
-                else if (select.includes(key))
-                    return invoke;
-            });
-        });
-    }
-    // TODO: account for exotic properties
-    import(source, select) {
-        const { subject } = ensure(this);
-        if (!select)
-            select = getOwnPropertyNames(subject);
-        for (const key of select)
-            if (key in source)
-                this[key] = source[key];
-    }
-    export(subset) {
-        const { state } = ensure(this);
-        const output = {};
-        const keys = subset || state.keys();
-        for (const key of keys)
-            output[key] = state.get(key);
-        return output;
-    }
-    update(arg, tag) {
-        const target = ensure(this);
-        const { frame, waiting } = target;
-        if (typeof arg == "string") {
-            target.update(arg);
-            if (1 in arguments && arg in this) {
-                const method = this[arg];
-                if (typeof method == "function")
-                    if (typeof tag != "boolean")
-                        method.call(this, tag);
-                    else if (tag)
-                        method.call(this);
-            }
-            arg = undefined;
-        }
-        if (!frame.size && arg === true)
-            return Promise.reject(Oops$9.StrictUpdate());
-        return {
-            then: (callback) => {
-                if (!callback)
-                    throw Oops$9.NoChaining();
-                if (frame.size || arg !== false)
-                    waiting.add(() => {
-                        callback(getUpdate(this));
-                    });
-                else
-                    callback(false);
-            }
-        };
-    }
-    /**
-     * Mark this instance for garbage-collection and send `willDestroy` event to all listeners.
-     */
-    destroy() {
-        ensure(this).clear();
-    }
-    toString() {
-        return this.constructor.name;
-    }
-    /**
-     * Creates a new instance of this controller.
-     *
-     * Beyond `new this(...)`, method will activate managed-state.
-     *
-     * @param args - arguments sent to constructor
-     */
-    static create(...args) {
-        const instance = new this(...args);
-        ensure(instance);
-        return instance;
-    }
-    /**
-     * 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);
-    }
-}
-
+const REGISTER$1 = new WeakMap();
 class Subscriber {
     constructor(parent, onUpdate) {
+        this.parent = parent;
         this.onUpdate = onUpdate;
         this.active = false;
         this.dependant = new Set();
-        const proxy = create(parent.subject);
-        const using = new Map();
-        const listen = this.add = (key, value) => {
-            if (value !== undefined)
-                using.set(key, value);
-            else if (!using.has(key))
-                using.set(key, true);
+        this.watch = new Map();
+        this.commit = () => {
+            const release = this.parent.addListener(this.event);
+            this.active = true;
+            this.dependant.forEach(x => x.commit());
+            return this.release = () => {
+                this.dependant.forEach(x => x.release());
+                release();
+            };
         };
-        LISTEN.set(proxy, listen);
-        defineProperty(proxy, LOCAL, { value: this });
-        defineProperty(this, "proxy", {
-            configurable: true,
-            get() {
-                if (UPDATE.has(proxy))
-                    setTimeout(() => UPDATE.delete(proxy), 0);
-                return proxy;
-            }
-        });
-        const release = parent.addListener(key => {
+        this.event = (key) => {
             if (!this.active)
                 return;
-            const handler = using.get(key);
+            const { parent, watch } = this;
+            const handler = watch.get(key);
             let notify;
             if (typeof handler == "function") {
                 const callback = handler();
@@ -417,41 +212,59 @@ class Subscriber {
                 notify = this.onUpdate(key, parent);
             if (!notify)
                 return;
-            const notate = () => {
-                UPDATE.set(proxy, getUpdate(parent.subject).filter(k => using.has(k)));
-            };
-            parent.waiting.add(notate);
+            parent.waiting.add(() => {
+                this.latest = parent.latest.filter(k => watch.has(k));
+            });
             parent.waiting.add(notify);
-        });
-        this.commit = () => {
-            this.active = true;
-            this.dependant.forEach(x => x.commit());
-            return this.release;
-        };
-        this.release = () => {
-            this.dependant.forEach(x => x.release());
-            release();
         };
+        const proxy = create(parent.subject);
+        const reset = () => this.latest = undefined;
+        REGISTER$1.set(proxy, this);
+        defineProperty(this, "proxy", {
+            configurable: true,
+            get() {
+                setTimeout(reset, 0);
+                return proxy;
+            }
+        });
+    }
+    static get(from) {
+        return REGISTER$1.get(from);
+    }
+    get using() {
+        return Array.from(this.watch.keys());
+    }
+    assign(apply, keys) {
+        const { waiting, subject } = this.parent;
+        this.active = false;
+        if (typeof keys !== "object")
+            keys = getOwnPropertyNames(subject);
+        for (const key of keys)
+            if (key in apply)
+                subject[key] = apply[key];
+        waiting.add(() => this.active = true);
+    }
+    add(key, value) {
+        if (value !== undefined)
+            this.watch.set(key, value);
+        else if (!this.watch.has(key))
+            this.watch.set(key, true);
     }
 }
 
-const UPDATE = new WeakMap();
-const LISTEN = new WeakMap();
-const CONTROL = Symbol("CONTROL");
-function getUpdate(subject) {
-    return UPDATE.get(subject);
-}
-class Controller {
+const REGISTER = new WeakMap();
+class Control {
     constructor(subject) {
         this.subject = subject;
         this.frame = new Set();
         this.waiting = new Set();
         this.followers = new Set();
+        REGISTER.set(subject, this);
     }
     subscribe(callback) {
         return new Subscriber(this, callback);
     }
-    add(key) {
+    watch(key) {
         const { subject, state } = this;
         const { value } = getOwnPropertyDescriptor(subject, key);
         if (typeof value == "function")
@@ -470,9 +283,9 @@ class Controller {
             enumerable: false,
             set: this.ref(key),
             get() {
-                const listen = LISTEN.get(this);
-                if (listen)
-                    listen(key);
+                const sub = Subscriber.get(this);
+                if (sub)
+                    sub.add(key);
                 return state.get(key);
             }
         });
@@ -500,16 +313,14 @@ class Controller {
         };
     }
     update(key) {
-        const { followers, frame, subject, waiting } = this;
+        const { followers, frame, waiting } = this;
         if (frame.has(key))
             return;
         else if (!frame.size)
             setTimeout(() => {
                 flush(this);
-                UPDATE.set(subject, Array.from(frame));
-                setTimeout(() => {
-                    UPDATE.delete(subject);
-                }, 0);
+                this.latest = Array.from(frame);
+                setTimeout(() => this.latest = undefined, 0);
                 frame.clear();
                 for (const notify of waiting)
                     try {
@@ -532,41 +343,44 @@ class Controller {
         this.followers.clear();
         listeners.forEach(x => x(null, this));
     }
-}
-function ensure(subject, cb) {
-    let control = subject[CONTROL];
-    if (!control)
-        defineProperty(subject, CONTROL, {
-            value: control =
-                new Controller(subject)
-        });
-    if (!control.state) {
-        const { waiting } = control;
-        if (cb) {
-            let done;
-            waiting.add(() => {
-                done = cb(control);
-            });
-            return () => done && done();
+    static get(from) {
+        if (from && "is" in from)
+            from = from.is;
+        return REGISTER.get(from);
+    }
+    static for(subject, cb) {
+        const control = this.get(subject) || new this(subject);
+        if (!control.state) {
+            const { waiting } = control;
+            if (cb) {
+                let done;
+                waiting.add(() => {
+                    done = cb(control);
+                });
+                return () => done && done();
+            }
+            control.state = new Map();
+            for (const key in subject)
+                control.watch(key);
+            control.waiting = new Set();
+            for (const cb of waiting)
+                cb();
         }
-        control.state = new Map();
-        for (const key in subject)
-            control.add(key);
-        const callback = Array.from(waiting);
-        waiting.clear();
-        for (const cb of callback)
-            cb();
+        return cb ? cb(control) : control;
     }
-    return cb ? cb(control) : control;
 }
 
 const PENDING = new Map();
-function apply(fn, label) {
-    const name = label || fn.name || "pending";
+/**
+ * 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 = fn.call(this, key, this);
+        let output = instruction.call(this, key, this);
         if (typeof output == "function")
             output = { get: output };
         if (typeof output != "object")
@@ -575,7 +389,7 @@ function apply(fn, label) {
             defineProperty(subject, key, output);
             return false;
         }
-        let { get: onGet, set: onSet, suspense } = output;
+        let { get: onGet, set: onSet, suspend: shouldSuspend } = output;
         if ("value" in output)
             state.set(key, output.value);
         if ("recursive" in output && output.recursive)
@@ -595,12 +409,11 @@ function apply(fn, label) {
                 ? this.ref(key, onSet)
                 : undefined,
             get() {
-                if (!state.has(key) && suspense)
+                if (!state.has(key) && shouldSuspend)
                     throw suspend(control, key);
-                const listen = LISTEN.get(this);
-                const local = this[LOCAL];
-                if (listen)
-                    listen(key);
+                const local = Subscriber.get(this);
+                if (local)
+                    local.add(key);
                 return onGet
                     ? onGet(local)
                     : state.get(key);
@@ -621,8 +434,8 @@ function getRecursive(key, from) {
                 if (reset)
                     reset();
                 const value = from.state.get(key);
-                if (value && CONTROL in value) {
-                    const child = ensure(value).subscribe(local.onUpdate);
+                if (Control.get(value)) {
+                    const child = Control.for(value).subscribe(local.onUpdate);
                     if (local.active)
                         child.commit();
                     local.dependant.add(child);
@@ -668,15 +481,15 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-const Oops$8 = issues({
+const Oops$9 = issues({
     DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
 function act(task) {
-    return apply(function act(key) {
+    return add(function act(key) {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$8.DuplicatePending(key));
+                return Promise.reject(Oops$9.DuplicatePending(key));
             pending = true;
             this.update(key);
             try {
@@ -719,8 +532,8 @@ function factoryMode(self, output, key, required) {
     const suspend = () => {
         if (required === false)
             return undefined;
-        const issue = Oops$7.NotReady(subject, key);
-        Object.assign(pending, {
+        const issue = Oops$8.NotReady(subject, key);
+        assign(pending, {
             message: issue.message,
             stack: issue.stack
         });
@@ -736,7 +549,7 @@ function factoryMode(self, output, key, required) {
     };
 }
 
-const Oops$7 = issues({
+const Oops$8 = issues({
     // BadSource: (model, property, got) =>
     //   `Bad from-instruction provided to ${model}.${property}. Expects an arrow-function or a Model as source. Got ${got}.`,
     PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or tap) as computed source for ${model}.${property}. This is not possible.`,
@@ -746,14 +559,14 @@ const Oops$7 = issues({
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
 });
 function get(arg0, arg1, arg2) {
-    return apply(function get(key) {
+    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);
+            throw Oops$8.PeerNotAllowed(subject, key);
         // if(typeof arg0 == "function" && /^[A-Z]/.test(arg0.name))
         //   throw Oops.BadSource(subject, key, arg0);
         this.state.set(key, undefined);
@@ -775,7 +588,7 @@ function get(arg0, arg1, arg2) {
             }
             else if (typeof arg1 == "function") {
                 // replace source controller in-case it is different
-                source = ensure(arg0);
+                source = Control.for(arg0);
                 setter = arg1;
             }
             else
@@ -787,7 +600,7 @@ function get(arg0, arg1, arg2) {
                 init();
             }
             catch (err) {
-                Oops$7.ComputeFailed(subject, key).warn();
+                Oops$8.ComputeFailed(subject, key).warn();
                 throw err;
             }
         return () => {
@@ -799,12 +612,12 @@ function get(arg0, arg1, arg2) {
 }
 
 function ref(arg, mapper) {
-    return apply(function ref(key) {
+    return add(function ref(key) {
         let value = {};
         if (typeof arg != "object")
             value = createRef(this, key, arg);
         else
-            ensure(arg).state.forEach((_val, key) => {
+            Control.for(arg).state.forEach((_val, key) => {
                 defineProperty(value, key, mapper ? {
                     configurable: true,
                     get() {
@@ -833,11 +646,11 @@ function set(value, argument) {
         argument = value;
         value = undefined;
     }
-    return apply(function set(key) {
+    return add(function set(key) {
         if (value !== undefined)
             this.state.set(key, value);
         return {
-            suspense: true,
+            suspend: true,
             set: typeof argument == "function"
                 ? createValueEffect(argument)
                 : undefined
@@ -992,12 +805,12 @@ function createProxy(emit, watch) {
 }
 
 const Parent = new WeakMap();
-const Oops$6 = issues({
+const Oops$7 = issues({
     BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
 function use$1(input, argument) {
-    return apply(function use(key) {
+    return add(function use(key) {
         const { state, subject } = this;
         const required = argument !== false;
         let pending;
@@ -1009,7 +822,7 @@ function use$1(input, argument) {
                 input = new input();
         }
         else if (input && typeof input !== "object")
-            throw Oops$6.BadArgument(typeof input);
+            throw Oops$7.BadArgument(typeof input);
         if (input instanceof Map || input instanceof Set)
             return keyed(this, key, input);
         const onUpdate = (next) => {
@@ -1017,7 +830,7 @@ function use$1(input, argument) {
             if (next) {
                 get = getRecursive(key, this);
                 Parent.set(next, subject);
-                ensure(next);
+                Control.for(next);
             }
             if (typeof argument == "function")
                 argument(next);
@@ -1026,8 +839,8 @@ function use$1(input, argument) {
         const suspend = () => {
             if (required === false)
                 return;
-            const issue = Oops$6.NotReady(subject, key);
-            Object.assign(pending, {
+            const issue = Oops$7.NotReady(subject, key);
+            assign(pending, {
                 message: issue.message,
                 stack: issue.stack
             });
@@ -1071,25 +884,204 @@ function use$1(input, argument) {
     });
 }
 
-const Oops$5 = issues({
+const Oops$6 = issues({
     Required: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
     Unexpected: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
 });
-function has(Expects, required) {
-    return apply(function parent() {
+function has(Type, required) {
+    return add(function parent() {
         const child = this.subject;
         const value = Parent.get(child);
-        const expected = Expects.name;
+        const expected = Type.name;
         if (!value) {
             if (required !== false)
-                throw Oops$5.Required(expected, child);
+                throw Oops$6.Required(expected, child);
         }
-        else if (!(value instanceof Expects))
-            throw Oops$5.Unexpected(expected, child, value);
+        else if (!(value instanceof Type))
+            throw Oops$6.Unexpected(expected, child, value);
         return { value };
     });
 }
 
+const Oops$5 = issues({
+    Timeout: (keys, timeout) => `No update for [${keys}] within ${timeout}.`,
+    StrictUpdate: () => `Strict update() did not find pending updates.`,
+    NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
+});
+class Model {
+    constructor() {
+        new Control(this);
+        defineProperty(this, "is", { value: this });
+    }
+    on(select, argument, once) {
+        if (typeof select == "function")
+            return Control.for(this, x => x.addListener(select));
+        const single = typeof select == "string";
+        let keys = single ? [select] : select;
+        if (typeof argument !== "function")
+            return new Promise((resolve, reject) => {
+                const removeListener = Control.for(this, control => {
+                    for (const key of keys)
+                        try {
+                            void this[key];
+                        }
+                        catch (e) { }
+                    return control.addListener(key => {
+                        if (!key) {
+                            removeListener();
+                            reject(Oops$5.Timeout(select, `lifetime of ${this}`));
+                        }
+                        else if (keys.includes(key)) {
+                            removeListener();
+                            return () => resolve(single ? control.state.get(key) : control.latest);
+                        }
+                    });
+                });
+                if (typeof argument == "number")
+                    setTimeout(() => {
+                        removeListener();
+                        reject(Oops$5.Timeout(select, `${argument}ms`));
+                    }, argument);
+            });
+        return Control.for(this, control => {
+            if (!keys.length)
+                keys = [...control.state.keys()];
+            for (const key of keys)
+                try {
+                    void this[key];
+                }
+                catch (e) { }
+            const callback = single
+                ? () => { argument.call(this, control.state.get(select), select); }
+                : () => { argument.call(this, control.latest); };
+            const onEvent = once
+                ? () => {
+                    removeListener();
+                    callback();
+                }
+                : callback;
+            const removeListener = control.addListener(key => {
+                if (keys.includes(key))
+                    return onEvent;
+            });
+            return removeListener;
+        });
+    }
+    effect(callback, select) {
+        const effect = createEffect(callback);
+        return Control.for(this, control => {
+            let busy = false;
+            let inject = this.is;
+            const invoke = () => {
+                if (busy)
+                    return;
+                const output = mayRetry(() => {
+                    effect.call(inject, inject);
+                });
+                if (output instanceof Promise) {
+                    output.finally(() => busy = false);
+                    busy = true;
+                }
+            };
+            if (!select) {
+                const sub = control.subscribe(() => invoke);
+                inject = sub.proxy;
+                invoke();
+                return sub.commit();
+            }
+            invoke();
+            return control.addListener(key => {
+                if (key === null) {
+                    if (!select.length)
+                        invoke();
+                }
+                else if (select.includes(key))
+                    return invoke;
+            });
+        });
+    }
+    export(subset) {
+        const { state } = Control.for(this);
+        const output = {};
+        const keys = subset || state.keys();
+        for (const key of keys)
+            output[key] = state.get(key);
+        return output;
+    }
+    update(arg1, arg2) {
+        const control = Control.for(this);
+        const { frame, state, waiting } = control;
+        if (arg1 === true && !frame.size)
+            return Promise.reject(Oops$5.StrictUpdate());
+        if (typeof arg1 == "object") {
+            for (const key in arg1)
+                if (arg2 === true || (arg2 ? arg2.includes(key) : state.has(key))) {
+                    state.set(key, arg1[key]);
+                    control.update(key);
+                }
+        }
+        else if (typeof arg1 == "string") {
+            control.update(arg1);
+            if (1 in arguments && arg1 in this) {
+                const method = this[arg1];
+                if (typeof method == "function")
+                    if (typeof arg2 != "boolean")
+                        method.call(this, arg2);
+                    else if (arg2)
+                        method.call(this);
+            }
+            arg1 = undefined;
+        }
+        return {
+            then: (callback) => {
+                if (!callback)
+                    throw Oops$5.NoChaining();
+                if (frame.size || arg1 !== false)
+                    waiting.add(() => {
+                        callback(control.latest);
+                    });
+                else
+                    callback(false);
+            }
+        };
+    }
+    /**
+     * Mark this instance for garbage-collection and send `willDestroy` event to all listeners.
+     */
+    kill() {
+        Control.for(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.for(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);
+    }
+}
+defineProperty(Model.prototype, "toString", {
+    value() {
+        return this.constructor.name;
+    }
+});
+
+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();
@@ -1126,20 +1118,19 @@ class Lookup {
         } while (T !== Model);
     }
     pop() {
+        const items = new Set();
         for (const key of getOwnPropertySymbols(this)) {
             const entry = getOwnPropertyDescriptor(this, key);
             if (entry.writable && entry.value)
-                entry.value.destroy();
+                items.add(entry.value);
         }
+        for (const model of items)
+            model.kill();
     }
-}
-
+}
 const LookupContext = React.createContext(new Lookup());
 const useLookup = () => React.useContext(LookupContext);
-const Oops$4 = issues({
-    NotFound: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`
-});
-function useLocal(Type, arg) {
+function useContext(Type, arg) {
     const instance = useLookup().get(Type);
     if (!instance && arg !== false)
         throw Oops$4.NotFound(Type.name);
@@ -1147,7 +1138,7 @@ function useLocal(Type, arg) {
         case "string":
             return instance[arg];
         case "function":
-            useLayoutEffect(() => arg(instance), []);
+            React.useLayoutEffect(() => arg(instance), []);
         default:
             return instance;
     }
@@ -1160,7 +1151,7 @@ const Oops$3 = issues({
 const PendingContext = new WeakMap();
 const ContextWasUsed = new WeakMap();
 function tap(type, argument) {
-    return apply(function tap(key) {
+    return add(function tap(key) {
         if ("set" in type)
             return {
                 recursive: true,
@@ -1182,7 +1173,7 @@ function tap(type, argument) {
         });
         return {
             recursive: true,
-            suspense: true
+            suspend: true
         };
     });
 }
@@ -1217,57 +1208,45 @@ function use(init) {
 
 function useModel(source, arg, arg2) {
     const instance = React.useMemo(() => {
-        const cb = arg2 || arg;
-        const instance = typeof source == "function" ?
-            source.prototype instanceof Model ?
-                new source() :
-                source() :
-            source;
-        ensure(instance);
-        if (typeof cb == "function")
-            cb(instance);
+        const callback = arg2 || arg;
+        const instance = Model.isTypeof(source) ?
+            source.new() :
+            source();
+        Control.for(instance);
+        if (typeof callback == "function")
+            callback(instance);
         return instance;
     }, []);
+    usePeerContext(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);
+                instance.on(arg, () => update(x => x + 1));
             return () => {
                 if (Model.isTypeof(source))
-                    instance.destroy();
+                    instance.kill();
             };
         }, []);
         return instance;
     }
-    else {
-        const local = use(refresh => (ensure(instance).subscribe(() => refresh)));
-        if (typeof arg == "object") {
-            local.active = false;
-            if (typeof arg2 !== "object")
-                arg2 = getOwnPropertyNames(instance);
-            for (const key of arg2)
-                if (key in arg)
-                    instance[key] = arg[key];
-            React.useLayoutEffect(() => {
-                local.active = true;
-            });
-        }
-        React.useLayoutEffect(() => {
-            local.commit();
-            return () => {
-                local.release();
-                if (Model.isTypeof(source))
-                    instance.destroy();
-            };
-        }, []);
-        return local.proxy;
-    }
+    const local = use(refresh => (Control.for(instance).subscribe(() => refresh)));
+    if (typeof arg == "object")
+        local.assign(arg, arg2);
+    React.useLayoutEffect(() => {
+        local.commit();
+        return () => {
+            local.release();
+            if (Model.isTypeof(source))
+                instance.kill();
+        };
+    }, []);
+    return local.proxy;
 }
 
 function useFrom(target, compute, suspend) {
     const local = use(refresh => {
-        const sub = ensure(target).subscribe(() => update);
+        const sub = Control.for(target).subscribe(() => update);
         const spy = sub.proxy;
         let value = compute.call(spy, spy);
         let update;
@@ -1306,84 +1285,80 @@ function useFrom(target, compute, suspend) {
     return local.proxy;
 }
 
-function useTap(source, path, expect) {
+function useTap(source, arg1, arg2) {
     const instance = useMemo(() => {
         if (typeof source == "object")
             return () => source;
-        if ("get" in source)
-            return () => source.get();
-        if ("prototype" in source)
-            return () => useLocal(source);
-        else
-            return source;
+        if (MVC.isTypeof(source))
+            return () => source.get(true);
+        if (Model.isTypeof(source))
+            return () => useContext(source);
+        return source;
     }, [])();
-    if (typeof path == "function")
-        return useFrom(instance, path, expect);
-    const local = use(refresh => (ensure(instance).subscribe(() => refresh)));
+    if (typeof arg1 == "function")
+        return useFrom(instance, arg1, arg2);
+    const local = use(refresh => (Control.for(instance).subscribe(() => refresh)));
     React.useLayoutEffect(local.commit, []);
-    if (typeof path !== "undefined") {
-        const value = local.proxy[path];
-        if (value === undefined && expect)
-            throw suspend(ensure(instance), path);
-        return value;
-    }
-    return local.proxy;
+    if (arg1 === undefined)
+        return local.proxy;
+    const value = local.proxy[arg1];
+    if (value === undefined && arg2)
+        throw suspend(local.parent, arg1);
+    return value;
 }
 
-/* istanbul ignore file */
 class MVC extends Model {
-    tap(path, expect) {
-        return useTap(this, path, expect);
-    }
-    use(arg, callback) {
-        return useModel(this, arg, callback);
-    }
     static get(arg) {
-        return useLocal(this, arg);
+        return useContext(this, arg);
     }
     static tap(key, expect) {
         return useTap(this, key, expect);
     }
-    static new(arg) {
-        const instance = React.useMemo(() => {
-            const instance = new this();
-            ensure(instance);
-            if (typeof arg == "function")
-                arg(instance);
-            else if (arg)
-                getOwnPropertyNames(instance).forEach(key => {
-                    if (key in arg)
-                        instance[key] = arg[key];
-                });
-            return instance;
-        }, []);
-        usePeerContext(instance.is);
-        return instance;
-    }
     static use(a, b) {
-        const instance = useModel(this, a, b);
-        usePeerContext(instance.is);
-        return instance;
-    }
-    /**
-     * @deprecated consider doing this manually - not worth minor efficiency gain over using.
-    */
-    static uses(apply, keys) {
-        return this.use(instance => {
-            instance.import(apply, keys);
-        });
-    }
-    /**
-     * @deprecated is now replaced by overload of `use` method.
-    */
-    static using(apply, keys) {
-        return this.use(apply, keys);
+        return useModel(this, a, b);
     }
     static meta(path, expect) {
         return useTap(() => this, path, expect);
     }
 }
 
+const LOCAL = "$debug local";
+const STATE = "$debug state";
+const UPDATE = "$debug update";
+const CONTROL = "$debug controller";
+Object.defineProperties(Model.prototype, {
+    [CONTROL]: {
+        get() {
+            return Control.get(this);
+        }
+    },
+    [LOCAL]: {
+        get() {
+            return Subscriber.get(this);
+        }
+    },
+    [STATE]: {
+        get() {
+            const { state } = Control.get(this);
+            const output = {};
+            state.forEach((value, key) => output[key] = value);
+            return output;
+        }
+    },
+    [UPDATE]: {
+        get() {
+            const source = Subscriber.get(this) || Control.get(this);
+            return source && source.latest;
+        }
+    }
+});
+const Debug = {
+    CONTROL,
+    LOCAL,
+    STATE,
+    UPDATE
+};
+
 const Oops$2 = issues({
     BadProps: () => `Provider expects either a render function, 'get' or 'has' props.`
 });
@@ -1393,66 +1368,66 @@ function Consumer(props) {
         return children(useTap(type));
     const callback = has || get;
     if (typeof callback == "function")
-        callback(useLocal(type, !!has));
+        callback(useContext(type, !!has));
     else
         throw Oops$2.BadProps();
     return null;
 }
 
 const Oops$1 = issues({
-    NoType: () => "Provider 'of' prop must be Model, typeof Model or a collection of them.",
-    PropDeprecated: () => "Provider `of` prop is deprecated, use `for` instead."
+    NoType: () => "Provider 'for' prop must be Model, typeof Model or a collection of them."
 });
 function Provider(props) {
-    if ("of" in props)
-        throw Oops$1.PropDeprecated();
-    const from = useLookup();
-    const context = React.useMemo(() => {
-        const I = props.for;
-        if (!I)
+    const context = useNewContext(props.for);
+    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(include) {
+    const ambient = useLookup();
+    return React.useMemo(() => {
+        if (!include)
             throw Oops$1.NoType();
-        const layer = from.push();
+        const layer = ambient.push();
         function register(I) {
             if (I instanceof Model)
                 layer.inject(I.constructor, I, false);
             else
-                layer.inject(I, I.create(), true);
+                layer.inject(I, I.new(), true);
         }
-        if (I instanceof Model || typeof I == "function")
-            register(I);
+        if (include instanceof Model || typeof include == "function")
+            register(include);
         else
-            values(I).forEach(register);
+            values(include).forEach(register);
         for (const instance of layer.local)
             if (instance)
                 for (const apply of getPending(instance))
                     apply(layer);
         return layer;
     }, []);
-    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 useAppliedProps(within, props) {
-    const update = React.useMemo(() => {
-        const targets = within.local;
-        return function integrate(props) {
-            for (const [key, value] of entries(props))
-                if (!["of", "for", "children"].includes(key))
-                    for (const into of targets)
-                        if (into && key in into)
-                            into[key] = value;
+function useAppliedProps(context, props) {
+    const apply = React.useMemo(() => {
+        return (props) => {
+            entries(props).forEach(([key, value]) => {
+                if (key == "for" || key == "children")
+                    return;
+                for (const into of context.local)
+                    if (into && key in into)
+                        into[key] = value;
+            });
         };
     }, []);
-    update(props);
+    apply(props);
 }
 function RenderFunction(props) {
     const hook = use(refresh => {
         const targets = props.context.local;
         if (targets.length == 1)
-            return ensure(targets[0]).subscribe(() => refresh);
+            return Control.for(targets[0]).subscribe(() => refresh);
         return {};
     });
     if (hook.commit)
@@ -1461,17 +1436,31 @@ function RenderFunction(props) {
 }
 
 const Oops = issues({
-    DoesNotExist: (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.`,
+    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 Active = new WeakMap();
 class Global extends MVC {
-    static create(...args) {
+    constructor() {
+        super();
+        Active.set(this.constructor, this);
+    }
+    kill(force) {
+        const type = this.constructor;
+        if (type.keepAlive && !force)
+            return false;
+        super.kill();
+        Active.delete(type);
+        return true;
+    }
+    static new(...args) {
         if (Active.has(this))
-            throw Oops.AlreadyExists(this.name);
+            if (this.keepAlive)
+                return Active.get(this);
+            else
+                throw Oops.AlreadyExists(this.name);
         const instance = new this(...args);
-        ensure(instance);
-        Active.set(this, instance);
+        Control.for(instance);
         return instance;
     }
     /**
@@ -1479,10 +1468,8 @@ class Global extends MVC {
      * 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);
-        return instance.update(false);
+    static set(values) {
+        return this.get(true).update(values);
     }
     static get(arg) {
         const instance = Active.get(this);
@@ -1496,13 +1483,10 @@ class Global extends MVC {
     static reset() {
         const current = Active.get(this);
         if (current)
-            current.destroy();
+            current.kill(true);
     }
-    destroy() {
-        super.destroy();
-        Active.delete(this.constructor);
-    }
-}
+}
+Global.keepAlive = true;
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, MVC as default, get, has, ref, set, tap, use$1 as use, useFrom, useLocal, useModel, useTap };
+export { Consumer, Debug, Global, MVC, MVC as Model, Provider, act, add, MVC as default, get, has, ref, set, tap, use$1 as use, useContext, useFrom, useModel, useTap };
 //# sourceMappingURL=index.esm.js.map