@expressive/mvc 0.17.1 → 0.18.1

package/lib/index.js

@@ -2,11 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var React = require('react');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
 
 class Issue extends Error {
     constructor() {
@@ -25,31 +21,17 @@ function issues(register) {
     return Library;
 }
 
-const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
-const UID_CACHE = new WeakMap();
-function assignWeak(into, from) {
-    for (const K in from)
-        if (K in into)
-            into[K] = from[K];
-}
-function uid(object) {
-    let uid = UID_CACHE.get(object);
-    if (!uid)
-        UID_CACHE.set(object, uid = Math.random());
-    return uid;
-}
-
 const REGISTER$1 = new WeakMap();
 class Subscriber {
-    constructor(parent, onUpdate, strict) {
-        this.parent = parent;
+    constructor(parent, onUpdate) {
         this.onUpdate = onUpdate;
-        this.strict = strict;
         this.active = false;
         this.dependant = new Set();
         this.watch = new Map();
-        const proxy = create(parent.subject);
+        if (!(parent instanceof Control))
+            parent = Control.for(parent);
         const reset = () => this.latest = undefined;
+        const proxy = create(parent.subject);
         REGISTER$1.set(proxy, this);
         defineProperty(this, "proxy", {
             configurable: true,
@@ -58,6 +40,7 @@ class Subscriber {
                 return proxy;
             }
         });
+        this.parent = parent;
         this.clear = parent.addListener(key => {
             if (this.active)
                 this.notify(key);
@@ -66,15 +49,11 @@ class Subscriber {
     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);
+    get(key, using) {
+        this.follow(key);
+        return using
+            ? using(this)
+            : this.parent.state.get(key);
     }
     follow(key, value) {
         if (value !== undefined)
@@ -110,11 +89,11 @@ function subscriber(from) {
     return REGISTER$1.get(from);
 }
 
-const Oops$c = issues({
+const Oops$8 = 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$8.NotReady(source.subject, key);
     const promise = new Promise(resolve => {
         const release = source.addListener(forKey => {
             if (forKey == key)
@@ -154,87 +133,7 @@ function mayRetry(fn) {
     return compute();
 }
 
-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}.`,
-});
-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);
-    };
-}
-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);
-    };
-}
-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;
-    };
-    onUpdate(initial);
-    defineProperty(subject, key, {
-        set: controller.ref(key, onUpdate),
-        get() {
-            const local = subscriber(this);
-            if (local)
-                local.follow(key);
-            return get(local);
-        }
-    });
-}
-
-const Oops$a = issues({
+const Oops$7 = issues({
     BadCallback: () => `Callback for effect-callback may only return a function.`
 });
 function createEffect(model, callback, keys) {
@@ -248,7 +147,7 @@ function createEffect(model, callback, keys) {
             if (unSet instanceof Promise)
                 unSet = undefined;
             if (unSet && typeof unSet !== "function")
-                throw Oops$a.BadCallback();
+                throw Oops$7.BadCallback();
         }
         function invoke() {
             if (busy)
@@ -292,11 +191,11 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$a.BadCallback();
+            throw Oops$7.BadCallback();
     };
 }
 
-const Oops$9 = issues({
+const Oops$6 = 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.`,
@@ -332,13 +231,13 @@ function awaitUpdate(source, arg1, arg2) {
         const timeout = (message) => {
             const k = keys ? keys.join(", ") : "any";
             removeListener();
-            reject(Oops$9.Timeout(k, message));
+            reject(Oops$6.Timeout(k, message));
         };
         const removeListener = control(source, controller => {
             const pending = controller.frame;
             if (keys === null) {
                 if (pending.size)
-                    reject(Oops$9.StrictNoUpdate());
+                    reject(Oops$6.StrictNoUpdate());
                 else
                     resolve(null);
                 return;
@@ -346,7 +245,7 @@ function awaitUpdate(source, arg1, arg2) {
             if (keys) {
                 if (keys.length) {
                     if (arg2 === 0 && single && !pending.has(keys[0])) {
-                        reject(Oops$9.KeysExpected(keys[0]));
+                        reject(Oops$6.KeysExpected(keys[0]));
                         return;
                     }
                     else
@@ -358,7 +257,7 @@ function awaitUpdate(source, arg1, arg2) {
                 }
             }
             else if (!pending.size && arg1 === true || arg2 === 0) {
-                reject(Oops$9.StrictUpdate());
+                reject(Oops$6.StrictUpdate());
                 return;
             }
             else
@@ -381,8 +280,9 @@ function awaitUpdate(source, arg1, arg2) {
     });
 }
 
-const Oops$8 = issues({
-    NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
+const Oops$5 = issues({
+    NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`,
+    NoAdapter: (method) => `Can't call Model.${method} without an adapter.`
 });
 class Model {
     constructor() {
@@ -399,14 +299,14 @@ class Model {
     }
     get(arg1, arg2) {
         const { state } = control(this);
-        const extract = typeof arg1 == "string"
-            ? () => state.get(arg1)
-            : () => {
-                const output = {};
-                for (const key of arg1 || state.keys())
-                    output[key] = state.get(key);
-                return output;
-            };
+        const extract = () => {
+            if (typeof arg1 == "string")
+                return state.get(arg1);
+            const output = {};
+            for (const key of arg1 || state.keys())
+                output[key] = state.get(key);
+            return output;
+        };
         if (!arg1 || arg2 === undefined)
             return extract();
         if (typeof arg2 == "function")
@@ -439,15 +339,13 @@ class Model {
         return {
             then: (callback) => {
                 if (!callback)
-                    throw Oops$8.NoChaining();
+                    throw Oops$5.NoChaining();
                 controller.waiting.add(callback);
             }
         };
     }
-    /**
-     * Clean up side effects and mark this instance for garbage-collection.
-     */
-    end() {
+    /** Mark this instance for garbage collection. */
+    gc() {
         control(this).clear();
     }
     /**
@@ -462,6 +360,18 @@ class Model {
         control(instance);
         return instance;
     }
+    static use() {
+        throw Oops$5.NoAdapter("use");
+    }
+    static get() {
+        throw Oops$5.NoAdapter("get");
+    }
+    static tap() {
+        throw Oops$5.NoAdapter("tap");
+    }
+    static meta() {
+        throw Oops$5.NoAdapter("meta");
+    }
     /**
      * Static equivalent of `x instanceof this`.
      *
@@ -476,114 +386,172 @@ defineProperty(Model.prototype, "toString", {
     value() {
         return this.constructor.name;
     }
-});
-const FindInstruction = new WeakMap([
-    [Model, getParentForGetInstruction]
-]);
+});
 
-const Oops$7 = issues({
+/**
+ * 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`);
+    PENDING.set(placeholder, (control, key) => {
+        let output = instruction.call(control, key, control);
+        if (!output)
+            return undefined;
+        if (typeof output == "function")
+            output = { get: output };
+        if ("value" in output)
+            control.state.set(key, output.value);
+        let { enumerable, get, set } = output;
+        defineProperty(control.subject, key, {
+            enumerable,
+            set: (set === false
+                ? undefined
+                : control.ref(key, set)),
+            get() {
+                const local = subscriber(this);
+                return (local ? local.get(key, get) :
+                    get ? get(local) :
+                        control.state.get(key));
+            }
+        });
+    });
+    return placeholder;
+}
+
+const Oops$4 = 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}].`
+    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`,
+    Required: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
 });
 function get(arg0, arg1) {
+    const fetch = this || getParentForGetInstruction;
     return add(function get(key) {
-        const { subject, state } = this;
-        // Easy mistake, using a peer, will always be unresolved.
+        let { subject } = this;
         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") {
+            throw Oops$4.PeerNotAllowed(subject, key);
+        let source = cb => cb(subject);
+        if (arg0 instanceof Model)
+            subject = arg0;
+        else if (Model.isTypeof(arg0))
+            source = fetch(arg0, subject, arg1 !== false);
+        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);
-        }
+        return typeof arg1 == "function"
+            ? getComputed(key, this, source, arg1)
+            : getRecursive$1(key, this, source, arg1);
+    });
+}
+function getParentForGetInstruction(type, relativeTo, required) {
+    const item = getParent(relativeTo, type);
+    return callback => {
+        if (item)
+            callback(item);
+        else if (required)
+            throw Oops$4.Required(type.name, relativeTo);
+    };
+}
+function getRecursive$1(key, parent, source, required) {
+    const context = new WeakMap();
+    const { state } = parent;
+    let waiting;
+    source((got) => {
+        state.set(key, got);
+        if (waiting)
+            parent.update(key);
     });
+    waiting = true;
+    function create(local) {
+        let reset;
+        local.follow(key, init);
+        init();
+        function init() {
+            if (reset)
+                reset();
+            const value = state.get(key);
+            if (value && controller(value)) {
+                const child = new Subscriber(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;
+                };
+            }
+        }
+    }
+    return (local) => {
+        const value = state.get(key);
+        if (!value && required !== false)
+            parent.waitFor(key);
+        if (!local)
+            return value;
+        if (!context.has(local))
+            create(local);
+        return context.get(local);
+    };
 }
 function getComputed(key, parent, source, setter) {
     const { state } = parent;
-    let sub;
+    let local;
+    let active;
+    let isAsync;
     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) => {
+    INFO.set(compute, key);
+    function compute(initial) {
+        let next;
         try {
-            return setter.call(sub.proxy, sub.proxy);
+            next = setter.call(local.proxy, local.proxy);
         }
         catch (err) {
-            Oops$7.Failed(instance, key, initial).warn();
-            throw err;
+            Oops$4.Failed(parent.subject, key, initial).warn();
+            if (initial)
+                throw err;
+            console.error(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 (next !== state.get(key)) {
+            state.set(key, next);
+            if (!initial || isAsync)
+                parent.update(key);
+        }
+    }
+    function connect(model) {
+        local = new Subscriber(model, (_, control) => {
             if (control !== parent)
-                refresh();
+                compute();
             else
-                pending.add(refresh);
+                pending.add(compute);
         });
-        sub.watch.set(key, false);
+        local.watch.set(key, false);
         try {
-            const value = compute(true);
-            state.set(key, value);
-            return value;
+            compute(true);
         }
         finally {
-            sub.commit();
-            order.set(refresh, order.size);
-        }
-    };
-    const refresh = () => {
-        let value;
-        try {
-            value = compute(false);
-        }
-        catch (e) {
-            console.error(e);
+            local.commit();
+            order.set(compute, order.size);
         }
-        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();
+        if (!active) {
+            active = true;
+            source(connect);
+            isAsync = true;
         }
-        return sub ? state.get(key) : create();
+        if (!local)
+            parent.waitFor(key);
+        if (pending.delete(compute))
+            compute();
+        return state.get(key);
     };
 }
 const INFO = new WeakMap();
@@ -606,16 +574,10 @@ function flush(control) {
     }
     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);
-}
+function using(fn) {
+    return Object.assign(get.bind(fn), { using });
+}
+get.using = using;
 
 const REGISTER = new WeakMap();
 const PENDING = new Map();
@@ -650,17 +612,17 @@ class Control {
             enumerable: false,
             set: this.ref(key),
             get() {
-                const sub = subscriber(this);
-                const value = state.get(key);
-                if (sub) {
-                    sub.follow(key);
-                    if (value === undefined && sub.strict)
-                        throw suspend(this, key);
-                }
-                return value;
+                const local = subscriber(this);
+                return local
+                    ? local.get(key)
+                    : state.get(key);
             }
         });
     }
+    /** Throw suspense which resolves when key is set. */
+    waitFor(key) {
+        throw suspend(this, key);
+    }
     addListener(listener) {
         this.followers.add(listener);
         return () => {
@@ -746,46 +708,72 @@ function control(subject, cb) {
     return cb ? cb(control) : control;
 }
 
-/**
- * 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`);
-    PENDING.set(placeholder, (control, key) => {
-        let output = instruction.call(control, key, control);
-        if (!output)
-            return undefined;
-        if (typeof output == "function")
-            output = { get: output };
-        if ("value" in output)
-            control.state.set(key, output.value);
-        let { enumerable, get, set } = output;
-        defineProperty(control.subject, key, {
-            enumerable,
-            set: set === false
-                ? undefined
-                : control.ref(key, set),
-            get() {
-                const local = subscriber(this);
-                if (local)
-                    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;
+const Parent = new WeakMap();
+const Oops$3 = issues({
+    BadAssignment: (parent, expected, got) => `Property ${parent} expected Model of type ${expected} but got ${got}.`,
+    Unexpected: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
+});
+function getParent(from, type) {
+    const value = Parent.get(from);
+    if (value && type && !(value instanceof type))
+        throw Oops$3.Unexpected(type.name, from, value);
+    return value;
+}
+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 = new Subscriber(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);
+    };
+}
+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$3.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.follow(key);
+            return get(local);
+        }
     });
-    return placeholder;
 }
 
 /******************************************************************************
@@ -813,7 +801,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-const Oops$6 = issues({
+const Oops$2 = issues({
     DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
 function run(task) {
@@ -821,7 +809,7 @@ function run(task) {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$6.DuplicatePending(key));
+                return Promise.reject(Oops$2.DuplicatePending(key));
             pending = true;
             this.update(key);
             try {
@@ -874,7 +862,7 @@ function createRef(src, key, cb) {
     return refObjectFunction;
 }
 
-const Oops$5 = issues({
+const Oops$1 = issues({
     ComputeFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
@@ -908,7 +896,7 @@ function set(value, argument) {
                     const suspend = () => {
                         if (required === false)
                             return undefined;
-                        const issue = Oops$5.NotReady(subject, key);
+                        const issue = Oops$1.NotReady(subject, key);
                         assign(pending, {
                             message: issue.message,
                             stack: issue.stack
@@ -925,7 +913,7 @@ function set(value, argument) {
                     };
                 }
                 catch (err) {
-                    Oops$5.ComputeFailed(subject, key).warn();
+                    Oops$1.ComputeFailed(subject, key).warn();
                     throw err;
                 }
             };
@@ -944,7 +932,7 @@ function set(value, argument) {
                 if (state.has(key))
                     return state.get(key);
                 else
-                    throw suspend(this, key);
+                    this.waitFor(key);
             },
             set: typeof argument == "function"
                 ? createValueEffect(argument)
@@ -1101,7 +1089,7 @@ function createProxy(emit, watch) {
     };
 }
 
-const Oops$4 = issues({
+const Oops = issues({
     BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
@@ -1117,7 +1105,7 @@ function use(input, argument) {
                 input = new input();
         }
         else if (input && typeof input !== "object")
-            throw Oops$4.BadArgument(typeof input);
+            throw Oops.BadArgument(typeof input);
         if (input instanceof Map || input instanceof Set)
             return keyed(this, key, input);
         const onUpdate = (next) => {
@@ -1134,7 +1122,7 @@ function use(input, argument) {
         const suspend = () => {
             if (required === false)
                 return;
-            const issue = Oops$4.NotReady(subject, key);
+            const issue = Oops.NotReady(subject, key);
             assign(pending, {
                 message: issue.message,
                 stack: issue.stack
@@ -1179,6 +1167,42 @@ function use(input, argument) {
     });
 }
 
+const LOCAL = "$debug local";
+const STATE = "$debug state";
+const UPDATE = "$debug update";
+const CONTROL = "$debug controller";
+defineProperties(Model.prototype, {
+    [CONTROL]: {
+        get() {
+            return controller(this);
+        }
+    },
+    [LOCAL]: {
+        get() {
+            return subscriber(this);
+        }
+    },
+    [STATE]: {
+        get() {
+            const { state } = controller(this);
+            const output = {};
+            state.forEach((value, key) => output[key] = value);
+            return output;
+        }
+    },
+    [UPDATE]: {
+        get() {
+            return (subscriber(this) || controller(this)).latest;
+        }
+    }
+});
+const Debug = {
+    CONTROL,
+    LOCAL,
+    STATE,
+    UPDATE
+};
+
 class Register {
     constructor() {
         this.table = new Map();
@@ -1234,394 +1258,22 @@ class Register {
             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?`,
-    MultipleExist: (name) => `Did find ${name} in context, but multiple were defined by same Provider.`
-});
-const LookupContext = React__default["default"].createContext(Global$1);
-function useLookup() {
-    try {
-        return React__default["default"].useContext(LookupContext);
-    }
-    catch (err) {
-        return Global$1;
+            model.gc();
     }
-}
-function useContext(Type, required) {
-    const instance = useLookup().get(Type);
-    if (instance === null)
-        throw Oops$3.MultipleExist(Type.name);
-    if (!instance && required !== false)
-        throw MVC.isTypeof(Type) && Type.global
-            ? Oops$3.DoesNotExist(Type.name)
-            : Oops$3.NotFound(Type.name);
-    return instance;
 }
 
-const Oops$2 = issues({
-    NotAllowed: (parent, child) => `Global '${parent}' attempted to attach '${child}' but it is not also a singleton.`,
-    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 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 (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));
-        });
-}
-function usePeerContext(subject) {
-    if (Applied.has(subject)) {
-        if (Applied.get(subject))
-            useLookup();
-        return;
-    }
-    const pending = Pending.get(subject);
-    if (pending) {
-        const local = useLookup();
-        for (const init of pending)
-            init(local);
-        Pending.delete(subject);
-    }
-    Applied.set(subject, !!pending);
-}
-function getPending(subject) {
-    let pending = Pending.get(subject);
-    if (!pending)
-        Pending.set(subject, pending = []);
-    return pending;
-}
-
-function useModel(source, arg1, arg2) {
-    const instance = React__default["default"].useMemo(() => {
-        const callback = arg2 || arg1;
-        const instance = Model.isTypeof(source)
-            ? new source()
-            : source();
-        control(instance);
-        if (typeof callback == "function")
-            callback(instance);
-        return instance;
-    }, []);
-    usePeerContext(instance);
-    if (Array.isArray(arg1)) {
-        const update = React__default["default"].useState(0)[1];
-        React__default["default"].useLayoutEffect(() => {
-            if (arg1.length && instance instanceof Model)
-                instance.on(arg1, () => update(x => x + 1));
-            return () => {
-                if (Model.isTypeof(source))
-                    instance.end();
-            };
-        }, []);
-        return instance;
-    }
-    const state = React__default["default"].useState(0);
-    const local = React__default["default"].useMemo(() => {
-        const refresh = state[1].bind(null, x => x + 1);
-        return new Subscriber(control(instance), () => refresh);
-    }, []);
-    if (typeof arg1 == "object")
-        local.apply(arg1, arg2);
-    React__default["default"].useLayoutEffect(() => {
-        local.commit();
-        return () => {
-            local.release();
-            if (Model.isTypeof(source))
-                instance.end();
-        };
-    }, []);
-    return local.proxy;
-}
-
-function useTap(source, arg1, arg2) {
-    const instance = typeof source == "object"
-        ? source
-        : "get" in source
-            ? source.get()
-            : source();
-    const deps = [uid(instance)];
-    const state = React__default["default"].useState(0);
-    const local = React__default["default"].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 = () => arg1.call(spy, spy, forceUpdate);
-        function forceUpdate(passthru) {
-            if (typeof passthru == "function")
-                passthru = passthru();
-            if (make)
-                reassign(make());
-            else
-                refresh();
-            if (passthru)
-                return passthru.finally(refresh);
-        }
-        function reassign(next) {
-            value = next;
-            if (retry) {
-                retry();
-                retry = undefined;
-            }
-            else
-                refresh();
-        }
-        let retry;
-        let update;
-        let value = make();
-        if (value === null) {
-            sub.watch.clear();
-            make = undefined;
-            return;
-        }
-        if (typeof value == "function") {
-            const get = value;
-            sub.watch.clear();
-            arg1 = () => get();
-            value = get();
-        }
-        if (value instanceof Promise) {
-            value.then(reassign);
-            value = undefined;
-        }
-        else {
-            sub.commit();
-            update = () => {
-                const next = make();
-                if (notEqual(value, next))
-                    reassign(next);
-            };
-        }
-        defineProperty(sub, "proxy", {
-            get() {
-                if (value !== undefined)
-                    return value;
-                if (arg2)
-                    throw new Promise(res => retry = res);
-                return null;
-            }
-        });
-        return sub;
-    }, deps);
-    if (!local)
-        return null;
-    React__default["default"].useLayoutEffect(() => {
-        local.commit();
-        return () => local.release();
-    }, deps);
-    return local.proxy;
-}
-/** 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])));
-
-class MVC extends Model {
-    end(force) {
-        const type = this.constructor;
-        if (type.keepAlive && !force)
-            return false;
-        super.end();
-        Global$1.delete(this);
-        return true;
-    }
-    static new(...args) {
-        const exists = Global$1.get(this);
-        if (exists)
-            if (this.keepAlive)
-                return exists;
-            else
-                throw Oops$3.AlreadyExists(this.name);
-        const instance = super.new(...args);
-        if (this.global)
-            Global$1.add(instance);
-        return instance;
-    }
-    static get(arg1, arg2) {
-        const required = arg1 === undefined || arg1 === true;
-        const instance = useContext(this, required);
-        if (typeof arg1 === "function" && instance)
-            callback(arg1);
-        else if (arg2)
-            callback(arg2);
-        return instance;
-        function callback(effect) {
-            try {
-                React__default["default"].useLayoutEffect(() => effect(instance), []);
-            }
-            catch (err) {
-                if (instance)
-                    instance.on(effect, []);
-                else
-                    effect(undefined);
-            }
-        }
-    }
-    static tap(arg1, arg2) {
-        return useTap(this, arg1, arg2);
-    }
-    static use(a, b) {
-        return useModel(this, a, b);
-    }
-    static meta(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.`
-});
-function Consumer(props) {
-    const { get, has, children, for: type } = props;
-    if (typeof children == "function")
-        return children(useTap(type));
-    const callback = has || get;
-    if (typeof callback == "function")
-        callback(useContext(type, !!has));
-    else
-        throw Oops$1.BadProps();
-    return null;
-}
-
-const Oops = issues({
-    NoType: () => "Provider 'for' prop must be Model, typeof Model or a collection of them."
-});
-function Provider(props) {
-    const context = useNewContext(props.for, props.use);
-    return (React__default["default"].createElement(LookupContext.Provider, { value: context }, props.fallback === false
-        ? props.children
-        : (React__default["default"].createElement(React.Suspense, { fallback: props.fallback || null }, props.children))));
-}
-function useNewContext(include, assign) {
-    const init = new Set();
-    const ambient = useLookup();
-    const context = React__default["default"].useMemo(() => {
-        if (!include)
-            throw Oops.NoType();
-        return ambient.push();
-    }, []);
-    function register(key, 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);
-    }
-    if (typeof include == "function" || include instanceof Model)
-        register(0, include);
-    else
-        entries(include).forEach(e => register(...e));
-    for (const instance of init) {
-        control(instance).state.forEach(value => {
-            // TODO: should this run repeatedly?
-            if (Parent.get(value) === instance) {
-                context.add(value);
-                init.add(value);
-            }
-        });
-        for (const apply of getPending(instance))
-            apply(context);
-        // TODO: add test to validate this.
-        init.delete(instance);
-    }
-    React__default["default"].useLayoutEffect(() => () => context.pop(), []);
-    return context;
-}
-
-class Global extends MVC {
-}
-Global.global = true;
-Global.keepAlive = true;
-
-const LOCAL = "$debug local";
-const STATE = "$debug state";
-const UPDATE = "$debug update";
-const CONTROL = "$debug controller";
-defineProperties(Model.prototype, {
-    [CONTROL]: {
-        get() {
-            return controller(this);
-        }
-    },
-    [LOCAL]: {
-        get() {
-            return subscriber(this);
-        }
-    },
-    [STATE]: {
-        get() {
-            const { state } = controller(this);
-            const output = {};
-            state.forEach((value, key) => output[key] = value);
-            return output;
-        }
-    },
-    [UPDATE]: {
-        get() {
-            return (subscriber(this) || controller(this)).latest;
-        }
-    }
-});
-const Debug = {
-    CONTROL,
-    LOCAL,
-    STATE,
-    UPDATE
+const Internal = {
+    getParent
 };
 
-exports.Consumer = Consumer;
+exports.Control = Control;
 exports.Debug = Debug;
-exports.Global = Global;
-exports.MVC = MVC;
-exports.Model = MVC;
-exports.Provider = Provider;
+exports.Internal = Internal;
+exports.Model = Model;
+exports.Register = Register;
+exports.Subscriber = Subscriber;
 exports.add = add;
-exports["default"] = MVC;
+exports["default"] = Model;
 exports.get = get;
 exports.ref = ref;
 exports.run = run;