@expressive/mvc 0.15.2 → 0.17.0

package/lib/index.esm.js

@@ -1,4 +1,21 @@
-import React, { useState, Suspense } from 'react';
+import React, { Suspense } from 'react';
+
+class Issue extends Error {
+    constructor() {
+        super(...arguments);
+        // drop first line (error factory) in stack trace.
+        this.stack = this.stack.replace(/\n.+/, "");
+    }
+    warn() {
+        console.warn(this.message);
+    }
+}
+function issues(register) {
+    const Library = {};
+    for (const name in register)
+        Library[name] = (...args) => new Issue(register[name].apply(null, args));
+    return Library;
+}
 
 const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
 const UID_CACHE = new WeakMap();
@@ -14,28 +31,82 @@ function uid(object) {
     return uid;
 }
 
-class Issue extends Error {
-    constructor() {
-        super(...arguments);
-        // drop first line (error factory) in stack trace.
-        this.stack = this.stack.replace(/\n.+/, "");
+const REGISTER$1 = new WeakMap();
+class Subscriber {
+    constructor(parent, onUpdate, strict) {
+        this.parent = parent;
+        this.onUpdate = onUpdate;
+        this.strict = strict;
+        this.active = false;
+        this.dependant = new Set();
+        this.watch = new Map();
+        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;
+            }
+        });
+        this.clear = parent.addListener(key => {
+            if (this.active)
+                this.notify(key);
+        });
     }
-    warn() {
-        console.warn(this.message);
+    get using() {
+        return Array.from(this.watch.keys());
+    }
+    apply(values, keys) {
+        const { waiting, subject } = this.parent;
+        this.active = false;
+        if (!keys)
+            keys = getOwnPropertyNames(subject);
+        for (const key of keys)
+            if (key in values)
+                subject[key] = values[key];
+        waiting.add(() => this.active = true);
+    }
+    follow(key, value) {
+        if (value !== undefined)
+            this.watch.set(key, value);
+        else if (!this.watch.has(key))
+            this.watch.set(key, true);
+    }
+    commit() {
+        this.active = true;
+        this.dependant.forEach(x => x.commit());
+    }
+    release() {
+        this.clear();
+        this.dependant.forEach(x => x.release());
+    }
+    notify(key) {
+        const { parent, watch } = this;
+        const handler = watch.get(key);
+        if (!handler)
+            return;
+        if (typeof handler == "function")
+            handler();
+        const notify = this.onUpdate(key, parent);
+        if (notify) {
+            parent.waiting.add(update => {
+                this.latest = update.filter(k => watch.has(k));
+            });
+            parent.waiting.add(notify);
+        }
     }
 }
-function issues(register) {
-    const Library = {};
-    for (const name in register)
-        Library[name] = (...args) => new Issue(register[name].apply(null, args));
-    return Library;
+function subscriber(from) {
+    return REGISTER$1.get(from);
 }
 
-const Oops$f = issues({
+const Oops$c = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
 });
 function suspend(source, key) {
-    const error = Oops$f.NotReady(source.subject, key);
+    const error = Oops$c.NotReady(source.subject, key);
     const promise = new Promise(resolve => {
         const release = source.addListener(forKey => {
             if (forKey == key)
@@ -75,98 +146,87 @@ function mayRetry(fn) {
     return compute();
 }
 
-const Oops$e = issues({
-    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
+const Parent = new WeakMap();
+const Oops$b = issues({
+    BadAssignment: (parent, expected, got) => `Property ${parent} expected Model of type ${expected} but got ${got}.`,
+    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}.`,
 });
-const INFO = new WeakMap();
-const KEYS = new WeakMap();
-const ORDER = new WeakMap();
-function computeMode(self, source, setter, key, required) {
-    const { subject, state } = self;
-    let sub;
-    let order = ORDER.get(self);
-    let pending = KEYS.get(self);
-    if (!order)
-        ORDER.set(self, order = new Map());
-    if (!pending)
-        KEYS.set(self, pending = new Set());
-    const compute = (initial) => {
-        try {
-            return setter.call(sub.proxy, sub.proxy);
-        }
-        catch (err) {
-            Oops$e.Failed(subject, key, initial).warn();
-            throw err;
-        }
+function getParentForGetInstruction(type, relativeTo, required) {
+    const item = getParent(type, relativeTo);
+    return (_refresh) => {
+        if (item)
+            return item;
+        if (required)
+            throw Oops$b.Required(type.name, relativeTo);
     };
-    const refresh = () => {
-        let value;
-        try {
-            value = compute(false);
-        }
-        catch (e) {
-            console.error(e);
-        }
-        finally {
-            if (state.get(key) !== value) {
-                state.set(key, value);
-                self.update(key);
-                return value;
-            }
+}
+function getParent(type, from) {
+    const value = Parent.get(from);
+    if (value && !(value instanceof type))
+        throw Oops$b.Unexpected(type.name, from, value);
+    return value;
+}
+function getRecursive(key, from) {
+    const context = new WeakMap();
+    const { state } = from;
+    return (local) => {
+        if (!state.has(key))
+            throw suspend(from, key);
+        if (!local)
+            return state.get(key);
+        if (!context.has(local)) {
+            let reset;
+            const init = () => {
+                if (reset)
+                    reset();
+                const value = state.get(key);
+                if (value && controller(value)) {
+                    const child = new Subscriber(control(value), local.onUpdate);
+                    if (local.active)
+                        child.commit();
+                    local.dependant.add(child);
+                    context.set(local, child.proxy);
+                    reset = () => {
+                        child.release();
+                        local.dependant.delete(child);
+                        context.set(local, undefined);
+                        reset = undefined;
+                    };
+                }
+            };
+            local.follow(key, init);
+            init();
         }
+        return context.get(local);
     };
-    const create = () => {
-        sub = source.subscribe((_, source) => {
-            if (source !== self)
-                refresh();
-            else
-                pending.add(refresh);
-        });
-        sub.watch.set(key, false);
-        try {
-            const value = compute(true);
-            state.set(key, value);
-            return value;
-        }
-        catch (e) {
-            throw e;
-        }
-        finally {
-            sub.commit();
-            order.set(refresh, order.size);
-        }
+}
+function setRecursive(controller, key, initial) {
+    const { state, subject } = controller;
+    const Type = initial.constructor;
+    let get;
+    const onUpdate = (next) => {
+        state.set(key, next);
+        if (!(next instanceof Type))
+            throw Oops$b.BadAssignment(`${subject}.${key}`, Type.name, String(next));
+        get = getRecursive(key, controller);
+        Parent.set(next, subject);
+        control(next);
+        return true;
     };
-    INFO.set(refresh, key);
-    return () => {
-        if (pending.has(refresh)) {
-            pending.delete(refresh);
-            refresh();
+    onUpdate(initial);
+    defineProperty(subject, key, {
+        set: controller.ref(key, onUpdate),
+        get() {
+            const local = subscriber(this);
+            if (local)
+                local.follow(key);
+            return get(local);
         }
-        const value = sub ? state.get(key) : create();
-        if (value === undefined && required)
-            throw suspend(self, key);
-        return value;
-    };
-}
-function flush(control) {
-    const pending = KEYS.get(control);
-    if (!pending || !pending.size)
-        return;
-    const priority = ORDER.get(control);
-    while (pending.size) {
-        let compute;
-        for (const item of pending)
-            if (!compute || priority.get(item) < priority.get(compute))
-                compute = item;
-        pending.delete(compute);
-        const key = INFO.get(compute);
-        if (!control.frame.has(key))
-            compute();
-    }
-    pending.clear();
+    });
 }
 
-const Oops$d = issues({
+const Oops$a = issues({
     BadCallback: () => `Callback for effect-callback may only return a function.`
 });
 function createEffect(model, callback, keys) {
@@ -180,7 +240,7 @@ function createEffect(model, callback, keys) {
             if (unSet instanceof Promise)
                 unSet = undefined;
             if (unSet && typeof unSet !== "function")
-                throw Oops$d.BadCallback();
+                throw Oops$a.BadCallback();
         }
         function invoke() {
             if (busy)
@@ -204,10 +264,11 @@ function createEffect(model, callback, keys) {
                     return invoke;
             });
         }
-        const sub = controller.subscribe(() => invoke);
+        const sub = new Subscriber(controller, () => invoke);
         model = sub.proxy;
         invoke();
-        return sub.commit();
+        sub.commit();
+        return () => sub.release();
     });
 }
 function createValueEffect(callback) {
@@ -223,11 +284,11 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$d.BadCallback();
+            throw Oops$a.BadCallback();
     };
 }
 
-const Oops$c = issues({
+const Oops$9 = issues({
     Timeout: (keys, timeout) => `No update seen for [${keys}] within ${timeout}.`,
     KeysExpected: (key) => `Key "${key}" was expected in current update.`,
     StrictUpdate: () => `Expected update but none in progress.`,
@@ -263,13 +324,13 @@ function awaitUpdate(source, arg1, arg2) {
         const timeout = (message) => {
             const k = keys ? keys.join(", ") : "any";
             removeListener();
-            reject(Oops$c.Timeout(k, message));
+            reject(Oops$9.Timeout(k, message));
         };
         const removeListener = control(source, controller => {
             const pending = controller.frame;
             if (keys === null) {
                 if (pending.size)
-                    reject(Oops$c.StrictNoUpdate());
+                    reject(Oops$9.StrictNoUpdate());
                 else
                     resolve(null);
                 return;
@@ -277,7 +338,7 @@ function awaitUpdate(source, arg1, arg2) {
             if (keys) {
                 if (keys.length) {
                     if (arg2 === 0 && single && !pending.has(keys[0])) {
-                        reject(Oops$c.KeysExpected(keys[0]));
+                        reject(Oops$9.KeysExpected(keys[0]));
                         return;
                     }
                     else
@@ -289,7 +350,7 @@ function awaitUpdate(source, arg1, arg2) {
                 }
             }
             else if (!pending.size && arg1 === true || arg2 === 0) {
-                reject(Oops$c.StrictUpdate());
+                reject(Oops$9.StrictUpdate());
                 return;
             }
             else
@@ -312,67 +373,7 @@ function awaitUpdate(source, arg1, arg2) {
     });
 }
 
-const REGISTER$1 = new WeakMap();
-class Subscriber {
-    constructor(parent, onUpdate) {
-        this.parent = parent;
-        this.onUpdate = onUpdate;
-        this.active = false;
-        this.dependant = new Set();
-        this.watch = new Map();
-        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;
-            }
-        });
-    }
-    get using() {
-        return Array.from(this.watch.keys());
-    }
-    add(key, value) {
-        if (value !== undefined)
-            this.watch.set(key, value);
-        else if (!this.watch.has(key))
-            this.watch.set(key, true);
-    }
-    commit() {
-        const release = this.parent.addListener(key => {
-            if (this.active)
-                this.onEvent(key);
-        });
-        this.active = true;
-        this.dependant.forEach(x => x.commit());
-        return this.release = () => {
-            this.dependant.forEach(x => x.release());
-            release();
-        };
-    }
-    onEvent(key) {
-        const { parent, watch } = this;
-        let handler = watch.get(key);
-        if (typeof handler == "function")
-            handler = handler();
-        if (handler) {
-            const notify = this.onUpdate(key, parent);
-            if (notify) {
-                parent.waiting.add(update => {
-                    this.latest = update.filter(k => watch.has(k));
-                });
-                parent.waiting.add(notify);
-            }
-        }
-    }
-}
-function subscriber(from) {
-    return REGISTER$1.get(from);
-}
-
-const Oops$b = issues({
+const Oops$8 = issues({
     NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
 });
 class Model {
@@ -430,7 +431,7 @@ class Model {
         return {
             then: (callback) => {
                 if (!callback)
-                    throw Oops$b.NoChaining();
+                    throw Oops$8.NoChaining();
                 controller.waiting.add(callback);
             }
         };
@@ -463,11 +464,150 @@ class Model {
             maybe.prototype instanceof this);
     }
 }
-defineProperty(Model.prototype, "toString", {
-    value() {
-        return this.constructor.name;
-    }
-});
+defineProperty(Model.prototype, "toString", {
+    value() {
+        return this.constructor.name;
+    }
+});
+const FindInstruction = new WeakMap([
+    [Model, getParentForGetInstruction]
+]);
+
+const Oops$7 = issues({
+    PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or get) as computed source for ${model}.${property}. This is not allowed.`,
+    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
+});
+function get(arg0, arg1) {
+    return add(function get(key) {
+        const { subject, state } = this;
+        // Easy mistake, using a peer, will always be unresolved.
+        if (typeof arg0 == "symbol")
+            throw Oops$7.PeerNotAllowed(subject, key);
+        let source;
+        const sourceRequired = arg1 !== false;
+        if (arg0 instanceof Model) {
+            source = () => arg0;
+            if (typeof arg1 !== "function")
+                throw new Error(`Factory argument cannot be ${arg1}`);
+        }
+        else if (Model.isTypeof(arg0)) {
+            source = find(arg0, subject, sourceRequired);
+        }
+        else if (typeof arg0 == "function") {
+            arg1 = arg0.call(subject, key, subject);
+            source = () => subject;
+        }
+        if (typeof arg1 == "function")
+            return getComputed(key, this, source, arg1);
+        else {
+            const init = source((got) => {
+                state.set(key, got);
+                this.update(key);
+            });
+            // TODO: remove fixes suspense test
+            if (init || arg1 === false)
+                state.set(key, init);
+            return getRecursive(key, this);
+        }
+    });
+}
+function getComputed(key, parent, source, setter) {
+    const { state } = parent;
+    let sub;
+    let order = ORDER.get(parent);
+    let pending = KEYS.get(parent);
+    let instance;
+    if (!order)
+        ORDER.set(parent, order = new Map());
+    if (!pending)
+        KEYS.set(parent, pending = new Set());
+    const compute = (initial) => {
+        try {
+            return setter.call(sub.proxy, sub.proxy);
+        }
+        catch (err) {
+            Oops$7.Failed(instance, key, initial).warn();
+            throw err;
+        }
+    };
+    const create = () => {
+        // TODO: replace create with a cleanup function
+        const got = source(create);
+        if (!got)
+            throw suspend(parent, key);
+        instance = got;
+        sub = new Subscriber(control(instance), (_, control) => {
+            if (control !== parent)
+                refresh();
+            else
+                pending.add(refresh);
+        });
+        sub.watch.set(key, false);
+        try {
+            const value = compute(true);
+            state.set(key, value);
+            return value;
+        }
+        finally {
+            sub.commit();
+            order.set(refresh, order.size);
+        }
+    };
+    const refresh = () => {
+        let value;
+        try {
+            value = compute(false);
+        }
+        catch (e) {
+            console.error(e);
+        }
+        finally {
+            if (state.get(key) !== value) {
+                state.set(key, value);
+                parent.update(key);
+                return value;
+            }
+        }
+    };
+    INFO.set(refresh, key);
+    return () => {
+        if (pending.has(refresh)) {
+            pending.delete(refresh);
+            refresh();
+        }
+        return sub ? state.get(key) : create();
+    };
+}
+const INFO = new WeakMap();
+const KEYS = new WeakMap();
+const ORDER = new WeakMap();
+function flush(control) {
+    const pending = KEYS.get(control);
+    if (!pending || !pending.size)
+        return;
+    const priority = ORDER.get(control);
+    while (pending.size) {
+        let compute;
+        for (const item of pending)
+            if (!compute || priority.get(item) < priority.get(compute))
+                compute = item;
+        pending.delete(compute);
+        const key = INFO.get(compute);
+        if (!control.frame.has(key))
+            compute();
+    }
+    pending.clear();
+}
+// TODO: collapse this function when MVC is merged into Model.
+function find(type, relativeTo, required) {
+    let T = type;
+    do {
+        T = getPrototypeOf(T);
+        const getter = FindInstruction.get(T);
+        if (getter)
+            return getter(type, relativeTo, required);
+    } while (T.prototype instanceof Model);
+}
 
 const REGISTER = new WeakMap();
 const PENDING = new Map();
@@ -479,9 +619,6 @@ class Control {
         this.followers = new Set();
         REGISTER.set(subject, this);
     }
-    subscribe(callback) {
-        return new Subscriber(this, callback);
-    }
     watch(key) {
         const { subject, state } = this;
         const { value } = getOwnPropertyDescriptor(subject, key);
@@ -492,7 +629,7 @@ class Control {
             if (instruction) {
                 delete subject[key];
                 PENDING.delete(value);
-                instruction.call(this, key, this);
+                instruction(this, key);
             }
             return;
         }
@@ -506,9 +643,13 @@ class Control {
             set: this.ref(key),
             get() {
                 const sub = subscriber(this);
-                if (sub)
-                    sub.add(key);
-                return state.get(key);
+                const value = state.get(key);
+                if (sub) {
+                    sub.follow(key);
+                    if (value === undefined && sub.strict)
+                        throw suspend(this, key);
+                }
+                return value;
             }
         });
     }
@@ -566,6 +707,8 @@ class Control {
         listeners.forEach(x => x(null, this));
     }
 }
+Control.get = controller;
+Control.for = control;
 function controller(from) {
     if ("is" in from)
         from = from.is;
@@ -595,68 +738,6 @@ function control(subject, cb) {
     return cb ? cb(control) : control;
 }
 
-const Parent = new WeakMap();
-const Oops$a = issues({
-    BadAssignment: (parent, expected, got) => `Property ${parent} expected Model of type ${expected} but got ${got}.`
-});
-function getRecursive(key, from) {
-    const context = new WeakMap();
-    const { state } = from;
-    return (local) => {
-        if (!local)
-            return state.get(key);
-        if (!context.has(local)) {
-            let reset;
-            const init = () => {
-                if (reset)
-                    reset();
-                const value = state.get(key);
-                if (value && controller(value)) {
-                    const child = control(value).subscribe(local.onUpdate);
-                    if (local.active)
-                        child.commit();
-                    local.dependant.add(child);
-                    context.set(local, child.proxy);
-                    reset = () => {
-                        child.release();
-                        local.dependant.delete(child);
-                        context.set(local, undefined);
-                        reset = undefined;
-                    };
-                }
-                return true;
-            };
-            local.add(key, init);
-            init();
-        }
-        return context.get(local);
-    };
-}
-function setRecursive(controller, key, initial) {
-    const { state, subject } = controller;
-    const Type = initial.constructor;
-    let get;
-    const onUpdate = (next) => {
-        state.set(key, next);
-        if (!(next instanceof Type))
-            throw Oops$a.BadAssignment(`${subject}.${key}`, Type.name, String(next));
-        get = getRecursive(key, controller);
-        Parent.set(next, subject);
-        control(next);
-        return true;
-    };
-    onUpdate(initial);
-    defineProperty(subject, key, {
-        set: controller.ref(key, onUpdate),
-        get() {
-            const local = subscriber(this);
-            if (local)
-                local.add(key);
-            return get(local);
-        }
-    });
-}
-
 /**
  * Run instruction as controller sets itself up.
  * This will specialize the behavior of a given property.
@@ -664,53 +745,42 @@ function setRecursive(controller, key, initial) {
 function add(instruction, label) {
     const name = label || instruction.name || "pending";
     const placeholder = Symbol(`${name} instruction`);
-    function setup(key) {
-        const { subject, state } = this;
-        let output = instruction.call(this, key, this);
+    PENDING.set(placeholder, (control, key) => {
+        let output = instruction.call(control, key, control);
+        if (!output)
+            return undefined;
         if (typeof output == "function")
             output = { get: output };
-        if (typeof output != "object")
-            return;
-        if ("explicit" in output && output.explicit) {
-            defineProperty(subject, key, output);
-            return false;
-        }
-        let { get: onGet, set: onSet, suspend: shouldSuspend } = output;
         if ("value" in output)
-            state.set(key, output.value);
-        if ("recursive" in output && output.recursive)
-            onGet = getRecursive(key, this);
-        if ("destroy" in output) {
-            const { destroy } = output;
-            if (destroy)
-                this.addListener((key) => {
-                    if (key == null)
-                        destroy();
-                });
-        }
-        const control = this;
-        defineProperty(subject, key, {
-            enumerable: output.enumerable,
-            set: onSet === false
+            control.state.set(key, output.value);
+        let { enumerable, get, set } = output;
+        defineProperty(control.subject, key, {
+            enumerable,
+            set: set === false
                 ? undefined
-                : this.ref(key, onSet),
+                : control.ref(key, set),
             get() {
-                if (!state.has(key) && shouldSuspend)
-                    throw suspend(control, key);
                 const local = subscriber(this);
                 if (local)
-                    local.add(key);
-                return onGet
-                    ? onGet(local)
-                    : state.get(key);
+                    local.follow(key);
+                try {
+                    const value = get ? get(local) : control.state.get(key);
+                    if (value === undefined && local && local.strict === true)
+                        throw suspend(control, key);
+                    return value;
+                }
+                catch (err) {
+                    if (err instanceof Promise && local && local.strict === false)
+                        return;
+                    throw err;
+                }
             }
         });
-    }
-    PENDING.set(placeholder, setup);
+    });
     return placeholder;
 }
 
-/*! *****************************************************************************
+/******************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -735,7 +805,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-const Oops$9 = issues({
+const Oops$6 = issues({
     DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
 function run(task) {
@@ -743,7 +813,7 @@ function run(task) {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$9.DuplicatePending(key));
+                return Promise.reject(Oops$6.DuplicatePending(key));
             pending = true;
             this.update(key);
             try {
@@ -765,106 +835,6 @@ function run(task) {
     });
 }
 
-const Oops$8 = issues({
-    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
-});
-function factoryMode(self, value, key, required) {
-    const { subject, state } = self;
-    let pending;
-    let error;
-    if (value instanceof Promise) {
-        state.set(key, undefined);
-        pending = value
-            .catch(err => error = err)
-            .then(val => {
-            state.set(key, val);
-            return val;
-        })
-            .finally(() => {
-            pending = undefined;
-            self.update(key);
-        });
-    }
-    else
-        state.set(key, value);
-    const suspend = () => {
-        if (required === false)
-            return undefined;
-        const issue = Oops$8.NotReady(subject, key);
-        assign(pending, {
-            message: issue.message,
-            stack: issue.stack
-        });
-        throw pending;
-    };
-    return () => {
-        if (error)
-            throw error;
-        if (pending)
-            return suspend();
-        if (state.has(key))
-            return state.get(key);
-    };
-}
-
-const Oops$7 = issues({
-    PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or tap) as computed source for ${model}.${property}. This is not possible.`,
-    ComputeFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
-    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
-});
-function get(arg0, arg1, arg2) {
-    return add(function get(key) {
-        const { subject } = this;
-        const computeRequired = arg1 === true || arg2 === true;
-        const factoryRequired = arg1 !== false && arg2 !== false;
-        let getter;
-        // Easy mistake, using a peer, will always be unresolved.
-        if (typeof arg0 == "symbol")
-            throw Oops$7.PeerNotAllowed(subject, key);
-        // if(typeof arg0 == "function" && /^[A-Z]/.test(arg0.name))
-        //   throw Oops.BadSource(subject, key, arg0);
-        this.state.set(key, undefined);
-        const init = () => {
-            let source = this;
-            let setter;
-            if (typeof arg0 == "function") {
-                let result = mayRetry(arg0.bind(subject, key, subject));
-                if (typeof result == "function")
-                    setter = result;
-                else {
-                    getter = factoryMode(this, result, key, factoryRequired);
-                    return;
-                }
-            }
-            else if (arg0 instanceof Promise) {
-                getter = factoryMode(this, arg0, key, factoryRequired);
-                return;
-            }
-            else if (typeof arg1 == "function") {
-                // replace source controller in-case it is different
-                source = control(arg0);
-                setter = arg1;
-            }
-            else
-                throw new Error(`Factory argument cannot be ${arg1}`);
-            getter = computeMode(this, source, setter, key, computeRequired);
-        };
-        if (typeof arg0 == "function" && computeRequired)
-            try {
-                init();
-            }
-            catch (err) {
-                Oops$7.ComputeFailed(subject, key).warn();
-                throw err;
-            }
-        return () => {
-            if (!getter)
-                init();
-            return getter();
-        };
-    });
-}
-
 function ref(arg, mapper) {
     return add(function ref(key) {
         let value = {};
@@ -884,7 +854,7 @@ function ref(arg, mapper) {
                     value: createRef(this, key)
                 });
             });
-        return { value, explicit: true };
+        defineProperty(this.subject, key, { value });
     });
 }
 function createRef(src, key, cb) {
@@ -896,16 +866,78 @@ function createRef(src, key, cb) {
     return refObjectFunction;
 }
 
+const Oops$5 = issues({
+    ComputeFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
+    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
+});
 function set(value, argument) {
-    if (!(1 in arguments)) {
-        argument = value;
-        value = undefined;
-    }
     return add(function set(key) {
+        const { state, subject } = this;
+        if (typeof value == "function" || value instanceof Promise) {
+            const required = argument !== false;
+            let getter;
+            const init = () => {
+                try {
+                    if (typeof value == "function")
+                        value = mayRetry(value.bind(subject, key, subject));
+                    let pending;
+                    let error;
+                    if (value instanceof Promise) {
+                        state.set(key, undefined);
+                        pending = value
+                            .catch(err => error = err)
+                            .then(val => {
+                            state.set(key, val);
+                            return val;
+                        })
+                            .finally(() => {
+                            pending = undefined;
+                            this.update(key);
+                        });
+                    }
+                    else
+                        state.set(key, value);
+                    const suspend = () => {
+                        if (required === false)
+                            return undefined;
+                        const issue = Oops$5.NotReady(subject, key);
+                        assign(pending, {
+                            message: issue.message,
+                            stack: issue.stack
+                        });
+                        throw pending;
+                    };
+                    getter = () => {
+                        if (error)
+                            throw error;
+                        if (pending)
+                            return suspend();
+                        if (state.has(key))
+                            return state.get(key);
+                    };
+                }
+                catch (err) {
+                    Oops$5.ComputeFailed(subject, key).warn();
+                    throw err;
+                }
+            };
+            if (argument === true)
+                init();
+            return () => {
+                if (!getter)
+                    init();
+                return getter();
+            };
+        }
         if (value !== undefined)
-            this.state.set(key, value);
+            state.set(key, value);
         return {
-            suspend: true,
+            get: () => {
+                if (state.has(key))
+                    return state.get(key);
+                else
+                    throw suspend(this, key);
+            },
             set: typeof argument == "function"
                 ? createValueEffect(argument)
                 : undefined
@@ -949,7 +981,7 @@ function keyed(control, property, initial) {
                     }
                 }
             }
-            local.add(property, false);
+            local.follow(property, false);
             local.dependant.add({
                 commit() {
                     if (using.size === 0)
@@ -965,6 +997,12 @@ function keyed(control, property, initial) {
         context.set(local, proxy);
         return proxy;
     }
+    control.addListener(key => {
+        if (key === null) {
+            update.clear();
+            context.clear();
+        }
+    });
     return {
         value: initial,
         get(local) {
@@ -977,10 +1015,6 @@ function keyed(control, property, initial) {
             managed = init(next);
             context.clear();
             emit(ANY);
-        },
-        destroy() {
-            update.clear();
-            context.clear();
         }
     };
 }
@@ -1059,11 +1093,11 @@ function createProxy(emit, watch) {
     };
 }
 
-const Oops$6 = issues({
+const Oops$4 = 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) {
+function use(input, argument) {
     return add(function use(key) {
         const { state, subject } = this;
         const required = argument !== false;
@@ -1075,7 +1109,7 @@ function use$1(input, argument) {
                 input = new input();
         }
         else if (input && typeof input !== "object")
-            throw Oops$6.BadArgument(typeof input);
+            throw Oops$4.BadArgument(typeof input);
         if (input instanceof Map || input instanceof Set)
             return keyed(this, key, input);
         const onUpdate = (next) => {
@@ -1092,7 +1126,7 @@ function use$1(input, argument) {
         const suspend = () => {
             if (required === false)
                 return;
-            const issue = Oops$6.NotReady(subject, key);
+            const issue = Oops$4.NotReady(subject, key);
             assign(pending, {
                 message: issue.message,
                 stack: issue.stack
@@ -1137,33 +1171,11 @@ function use$1(input, argument) {
     });
 }
 
-const Oops$5 = issues({
-    Required: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
-    Unexpected: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
-});
-function has(Type, required) {
-    return add(function parent() {
-        const child = this.subject;
-        const value = Parent.get(child);
-        const expected = Type.name;
-        if (!value) {
-            if (required !== false)
-                throw Oops$5.Required(expected, child);
-        }
-        else if (!(value instanceof Type))
-            throw Oops$5.Unexpected(expected, child, value);
-        return { value };
-    });
-}
-
-const Oops$4 = issues({
-    NotFound: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`
-});
-class Lookup {
+class Register {
     constructor() {
         this.table = new Map();
     }
-    key(T) {
+    has(T) {
         let key = this.table.get(T);
         if (!key) {
             key = Symbol(T.name);
@@ -1172,22 +1184,9 @@ class Lookup {
         return key;
     }
     get(Type) {
-        return this[this.key(Type)];
-    }
-    has(key, input, callback) {
-        if (MVC.isTypeof(input) && input.global)
-            return input.new();
-        if (this.register.get(key) === input)
-            return typeof input == "object"
-                ? input
-                : this.get(input);
-        const instance = this.add(input);
-        this.register.set(key, input);
-        if (callback)
-            callback(instance);
-        return instance;
+        return this[this.has(Type)];
     }
-    add(input) {
+    add(input, key) {
         let writable = true;
         let T;
         let I;
@@ -1196,12 +1195,12 @@ class Lookup {
             I = new input();
         }
         else {
-            I = input;
+            I = input.is;
             T = I.constructor;
             writable = false;
         }
         do {
-            const key = this.key(T);
+            const key = this.has(T);
             defineProperty(this, key, {
                 configurable: true,
                 value: this.hasOwnProperty(key) ? null : I,
@@ -1209,6 +1208,8 @@ class Lookup {
             });
             T = getPrototypeOf(T);
         } while (T !== Model);
+        if (key !== undefined)
+            this.register.set(key, input);
         return I;
     }
     push() {
@@ -1222,52 +1223,74 @@ class Lookup {
             const entry = getOwnPropertyDescriptor(this, key);
             if (entry.writable && entry.value)
                 items.add(entry.value);
+            delete this[key];
         }
         for (const model of items)
             model.end();
     }
+    delete(instance) {
+        for (const key of getOwnPropertySymbols(this)) {
+            const entry = getOwnPropertyDescriptor(this, key);
+            if (entry.value === instance)
+                delete this[key];
+        }
+    }
+}
+const Global$1 = new Register();
+
+const Oops$3 = issues({
+    AlreadyExists: (name) => `Shared instance of ${name} already exists! Consider unmounting existing, or use ${name}.reset() to force-delete it.`,
+    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.`,
+    NotFound: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`
+});
+const LookupContext = React.createContext(Global$1);
+function useLookup() {
+    try {
+        return React.useContext(LookupContext);
+    }
+    catch (err) {
+        return Global$1;
+    }
 }
-const LookupContext = React.createContext(new Lookup());
-const useLookup = () => React.useContext(LookupContext);
 function useContext(Type, required) {
     const instance = useLookup().get(Type);
     if (!instance && required !== false)
-        throw Oops$4.NotFound(Type.name);
+        throw MVC.isTypeof(Type) && Type.global
+            ? Oops$3.DoesNotExist(Type.name)
+            : Oops$3.NotFound(Type.name);
     return instance;
 }
 
-const Oops$3 = issues({
+const Oops$2 = issues({
     NotAllowed: (parent, child) => `Global '${parent}' attempted to attach '${child}' but it is not also a singleton.`,
-    AmbientRequired: (requested, requester, key) => `Attempted to find an instance of ${requested} in context. It is required for [${requester}.${key}], but one could not be found.`
+    AmbientRequired: (requested, requester) => `Attempted to find an instance of ${requested} in context. It is required by ${requester}, but one could not be found.`
 });
 const Pending = new WeakMap();
 const Applied = new WeakMap();
-function tap(type, argument) {
-    return add(function tap(key) {
-        if (MVC.isTypeof(type) && type.global)
-            return {
-                recursive: true,
-                value: type.get()
-            };
-        const { subject } = this;
-        if (subject.constructor.global)
-            throw Oops$3.NotAllowed(subject, type.name);
-        getPending(subject).push(context => {
-            let instance = context.get(type);
-            if (typeof argument == "function") {
-                if (argument(instance) === false)
-                    instance = undefined;
+function getContextForGetInstruction(type, relativeTo, required) {
+    let item = getParent(type, relativeTo);
+    return (refresh) => {
+        if (item)
+            return item;
+        findRelative(relativeTo, type, got => {
+            if (got) {
+                item = got;
+                refresh(got);
             }
-            else if (!instance && argument)
-                throw Oops$3.AmbientRequired(type.name, subject, key);
-            this.state.set(key, instance);
-            this.update(key);
+            else if (required)
+                throw Oops$2.AmbientRequired(type.name, relativeTo);
+        });
+    };
+}
+function findRelative(from, type, callback) {
+    if (MVC.isTypeof(type) && type.global)
+        callback(Global$1.get(type));
+    else if (from.constructor.global)
+        throw Oops$2.NotAllowed(from, type.name);
+    else
+        getPending(from).push(context => {
+            callback(context.get(type));
         });
-        return {
-            recursive: true,
-            suspend: true
-        };
-    });
 }
 function usePeerContext(subject) {
     if (Applied.has(subject)) {
@@ -1291,7 +1314,7 @@ function getPending(subject) {
     return pending;
 }
 
-function useNew(source, arg1, arg2) {
+function useModel(source, arg1, arg2) {
     const instance = React.useMemo(() => {
         const callback = arg2 || arg1;
         const instance = Model.isTypeof(source)
@@ -1304,7 +1327,7 @@ function useNew(source, arg1, arg2) {
     }, []);
     usePeerContext(instance);
     if (Array.isArray(arg1)) {
-        const update = useState(0)[1];
+        const update = React.useState(0)[1];
         React.useLayoutEffect(() => {
             if (arg1.length && instance instanceof Model)
                 instance.on(arg1, () => update(x => x + 1));
@@ -1318,19 +1341,10 @@ function useNew(source, arg1, arg2) {
     const state = React.useState(0);
     const local = React.useMemo(() => {
         const refresh = state[1].bind(null, x => x + 1);
-        return control(instance).subscribe(() => refresh);
+        return new Subscriber(control(instance), () => refresh);
     }, []);
-    if (typeof arg1 == "object") {
-        const { waiting, subject } = local.parent;
-        let keys = arg2;
-        local.active = false;
-        if (!keys)
-            keys = getOwnPropertyNames(subject);
-        for (const key of keys)
-            if (key in arg1)
-                subject[key] = arg1[key];
-        waiting.add(() => local.active = true);
-    }
+    if (typeof arg1 == "object")
+        local.apply(arg1, arg2);
     React.useLayoutEffect(() => {
         local.commit();
         return () => {
@@ -1342,19 +1356,22 @@ function useNew(source, arg1, arg2) {
     return local.proxy;
 }
 
-function use(init, deps) {
+function useTap(source, arg1, arg2) {
+    const instance = typeof source == "object"
+        ? source
+        : "get" in source
+            ? source.get()
+            : source();
+    const deps = [uid(instance)];
     const state = React.useState(0);
-    return React.useMemo(() => {
-        return init(state[1].bind(null, x => x + 1));
-    }, deps);
-}
-
-function useCompute(source, compute, suspend) {
-    const deps = [uid(source)];
-    const local = use(refresh => {
-        const sub = control(source).subscribe(() => update);
+    const local = React.useMemo(() => {
+        const refresh = state[1].bind(null, x => x + 1);
+        const controller = control(instance);
+        if (typeof arg1 != "function")
+            return new Subscriber(controller, () => refresh, arg1);
+        const sub = new Subscriber(controller, () => update);
         const spy = sub.proxy;
-        let make = () => compute.call(spy, spy, forceUpdate);
+        let make = () => arg1.call(spy, spy, forceUpdate);
         function forceUpdate(passthru) {
             if (typeof passthru == "function")
                 passthru = passthru();
@@ -1385,7 +1402,7 @@ function useCompute(source, compute, suspend) {
         if (typeof value == "function") {
             const get = value;
             sub.watch.clear();
-            compute = () => get();
+            arg1 = () => get();
             value = get();
         }
         if (value instanceof Promise) {
@@ -1396,7 +1413,7 @@ function useCompute(source, compute, suspend) {
             sub.commit();
             update = () => {
                 const next = make();
-                if (value != next)
+                if (notEqual(value, next))
                     reassign(next);
             };
         }
@@ -1404,7 +1421,7 @@ function useCompute(source, compute, suspend) {
             get() {
                 if (value !== undefined)
                     return value;
-                if (suspend)
+                if (arg2)
                     throw new Promise(res => retry = res);
                 return null;
             }
@@ -1413,67 +1430,47 @@ function useCompute(source, compute, suspend) {
     }, deps);
     if (!local)
         return null;
-    React.useLayoutEffect(() => local.release, deps);
+    React.useLayoutEffect(() => {
+        local.commit();
+        return () => local.release();
+    }, deps);
     return local.proxy;
-}
-
-function useTap(source, arg1, arg2) {
-    const instance = typeof source == "object"
-        ? source
-        : "get" in source
-            ? source.get()
-            : useContext(source);
-    return typeof arg1 == "function"
-        ? useCompute(instance, arg1, arg2)
-        : useSubscribe(instance, arg1, arg2);
 }
-function useSubscribe(source, path, expect) {
-    const deps = [uid(source)];
-    const local = use(refresh => (control(source).subscribe(() => refresh)), deps);
-    React.useLayoutEffect(() => local.commit(), deps);
-    if (path === undefined)
-        return local.proxy;
-    const value = local.proxy[path];
-    if (value === undefined && expect)
-        throw suspend(local.parent, path);
-    return value;
-}
+/** Values are not equal for purposes of a refresh. */
+const notEqual = (a, b) => (b !== a && (!Array.isArray(a) ||
+    !Array.isArray(b) ||
+    a.length !== b.length ||
+    a.some((x, i) => x !== b[i])));
 
-const Global$1 = new WeakMap();
-const Oops$2 = issues({
-    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.`
-});
 class MVC extends Model {
     end(force) {
         const type = this.constructor;
         if (type.keepAlive && !force)
             return false;
         super.end();
-        Global$1.delete(type);
+        Global$1.delete(this);
         return true;
     }
     static new(...args) {
-        if (Global$1.has(this))
+        const exists = Global$1.get(this);
+        if (exists)
             if (this.keepAlive)
-                return Global$1.get(this);
+                return exists;
             else
-                throw Oops$2.AlreadyExists(this.name);
+                throw Oops$3.AlreadyExists(this.name);
         const instance = super.new(...args);
         if (this.global)
-            Global$1.set(this, instance);
+            Global$1.add(instance);
         return instance;
     }
     static get(arg1, arg2) {
-        let instance;
         const required = arg1 === undefined || arg1 === true;
-        if (this.global) {
-            instance = Global$1.get(this);
-            if (!instance && required)
-                throw Oops$2.DoesNotExist(this.name);
-        }
-        else
-            instance = useContext(this, required);
+        const instance = useContext(this, required);
+        if (typeof arg1 === "function" && instance)
+            callback(arg1);
+        else if (arg2)
+            callback(arg2);
+        return instance;
         function callback(effect) {
             try {
                 React.useLayoutEffect(() => effect(instance), []);
@@ -1485,29 +1482,18 @@ class MVC extends Model {
                     effect(undefined);
             }
         }
-        if (typeof arg1 === "string")
-            return instance[arg1];
-        if (typeof arg1 === "function" && instance)
-            callback(arg1);
-        else if (arg2)
-            callback(arg2);
-        return instance;
     }
     static tap(arg1, arg2) {
-        const instance = this.get();
-        return typeof arg1 == "function"
-            ? useCompute(instance, arg1, arg2)
-            : useSubscribe(instance, arg1, arg2);
+        return useTap(this, arg1, arg2);
     }
     static use(a, b) {
-        return useNew(this, a, b);
+        return useModel(this, a, b);
     }
     static meta(arg1, arg2) {
-        return typeof arg1 == "function"
-            ? useCompute(this, arg1, arg2)
-            : useSubscribe(this, arg1, arg2);
+        return useTap(() => this, arg1, arg2);
     }
-}
+}
+FindInstruction.set(MVC, getContextForGetInstruction);
 
 const Oops$1 = issues({
     BadProps: () => `Provider expects either a render function, 'get' or 'has' props.`
@@ -1541,8 +1527,17 @@ function useNewContext(include, assign) {
             throw Oops.NoType();
         return ambient.push();
     }, []);
-    function register(key, T) {
-        const instance = context.has(key, T, i => init.add(i));
+    function register(key, input) {
+        let instance;
+        if (MVC.isTypeof(input) && input.global)
+            instance = input.new();
+        else if (context.register.get(key) === input)
+            instance = typeof input == "object"
+                ? input
+                : context.get(input);
+        else
+            instance = context.add(input, key);
+        init.add(instance);
         if (assign)
             assignWeak(instance, assign);
     }
@@ -1605,4 +1600,4 @@ const Debug = {
     UPDATE
 };
 
-export { Consumer, Debug, Global, MVC, MVC as Model, Provider, add, MVC as default, get, has, ref, run, set, tap, use$1 as use, useContext, useNew, useTap };
+export { Consumer, Debug, Global, MVC, MVC as Model, Provider, add, MVC as default, get, ref, run, set, use };