@expressive/mvc 0.19.2 → 0.21.0

package/lib/index.js

@@ -2,10 +2,29 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
-/** Random alphanumberic of length 6; will always start with a letter. */
-function random() {
-    return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 }
 
 class Issue extends Error {
@@ -25,89 +44,27 @@ function issues(register) {
     return Library;
 }
 
-const REGISTER$1 = new WeakMap();
-class Subscriber {
-    constructor(parent, onUpdate) {
-        this.onUpdate = onUpdate;
-        this.active = false;
-        this.dependant = new Set();
-        this.watch = new Map();
-        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,
-            get() {
-                setTimeout(reset, 0);
-                return proxy;
-            }
-        });
-        this.parent = parent;
-        this.clear = parent.addListener(key => {
-            if (this.active)
-                this.notify(key);
-        });
-    }
-    get using() {
-        return Array.from(this.watch.keys());
-    }
-    get(key, using) {
-        this.follow(key);
-        return using
-            ? using(this)
-            : this.parent.state.get(key);
-    }
-    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 subscriber(from) {
-    return REGISTER$1.get(from);
-}
+const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
 
-const Oops$8 = issues({
+const Oops$9 = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
+    Destoryed: () => "Model is destroyed."
 });
-function suspend(source, key) {
-    const error = Oops$8.NotReady(source.subject, key);
-    const promise = new Promise(resolve => {
-        const release = source.addListener(forKey => {
-            if (forKey == key)
+function suspense(source, key) {
+    const error = Oops$9.NotReady(source.subject, key);
+    const promise = new Promise((resolve, reject) => {
+        const subs = source.observers.get(key);
+        const onUpdate = (key) => {
+            if (key)
                 return () => {
-                    if (source.state.get(key) !== undefined) {
-                        release();
+                    if (source.state[key] !== undefined) {
+                        subs.delete(onUpdate);
                         resolve();
                     }
                 };
-        });
+            reject(Oops$9.Destoryed());
+        };
+        subs.add(onUpdate);
     });
     return assign(promise, {
         toString: () => String(error),
@@ -137,11 +94,12 @@ function mayRetry(fn) {
     return compute();
 }
 
-const Oops$7 = issues({
+const Oops$8 = issues({
     BadCallback: () => `Callback for effect-callback may only return a function.`
 });
-function createEffect(model, callback, keys) {
-    return control(model, controller => {
+function createEffect(source, callback) {
+    return control(source, self => {
+        let { subject } = self;
         let unSet;
         let busy = false;
         function invoke() {
@@ -150,33 +108,23 @@ function createEffect(model, callback, keys) {
             const output = mayRetry(() => {
                 if (typeof unSet == "function")
                     unSet();
-                unSet = callback.call(model, model);
+                unSet = callback.call(subject, subject);
                 if (unSet instanceof Promise)
                     unSet = undefined;
                 if (unSet && typeof unSet !== "function")
-                    throw Oops$7.BadCallback();
+                    throw Oops$8.BadCallback();
             });
             if (output instanceof Promise) {
                 output.finally(() => busy = false);
                 busy = true;
             }
         }
-        if (Array.isArray(keys)) {
-            invoke();
-            return controller.addListener(key => {
-                if (key === null) {
-                    if (!keys.length)
-                        invoke();
-                }
-                else if (keys.includes(key))
-                    return invoke;
-            });
-        }
-        const sub = new Subscriber(controller, () => invoke);
-        model = sub.proxy;
+        let refresh;
+        subject = watch(subject, () => refresh);
+        self.followers.add(key => (key === null || refresh === null ? refresh : undefined));
         invoke();
-        sub.commit();
-        return () => sub.release();
+        refresh = invoke;
+        return () => refresh = null;
     });
 }
 function createValueEffect(callback) {
@@ -192,162 +140,254 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$7.BadCallback();
+            throw Oops$8.BadCallback();
     };
 }
 
-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.`,
-    StrictNoUpdate: () => `Update is not expected but one is in progress!`
+const Oops$7 = issues({
+    KeysExpected: (key) => `Key "${key}" was expected in current update.`
 });
-function addEventListener(source, arg1, arg2, arg3) {
-    if (typeof arg1 == "string")
-        arg1 = [arg1];
-    return control(source, controller => {
-        for (const key of arg1)
-            try {
-                void source[key];
-            }
-            catch (e) { }
-        const removeListener = controller.addListener(key => {
-            if (!key && !arg1.length)
-                arg2.call(source, []);
-            if (arg1.includes(key)) {
-                if (arg3)
+function addEventListener(source, select, callback, once) {
+    return control(source, self => {
+        const { subject } = self;
+        if (typeof select == "string")
+            select = [select];
+        if (select)
+            for (const key of select)
+                try {
+                    void subject[key];
+                }
+                catch (e) {
+                    // TODO: should this be caught?
+                }
+        const removeListener = self.addListener(key => {
+            if (key === null)
+                callback.call(subject, null);
+            else if (!select || select.includes(key)) {
+                if (once)
                     removeListener();
-                return arg2.bind(source);
+                return () => callback.call(subject, self.latest);
             }
         });
         return removeListener;
     });
 }
-function awaitUpdate(source, arg1, arg2) {
-    const single = typeof arg1 == "string";
-    const keys = typeof arg1 == "string" ? [arg1] :
-        typeof arg1 == "object" ? arg1 :
-            undefined;
+function awaitUpdate(source, select, timeout) {
     return new Promise((resolve, reject) => {
-        const timeout = (message) => {
-            const k = keys ? keys.join(", ") : "any";
-            removeListener();
-            reject(Oops$6.Timeout(k, message));
-        };
-        const removeListener = control(source, controller => {
-            const pending = controller.frame;
-            if (keys === null) {
-                if (pending.size)
-                    reject(Oops$6.StrictNoUpdate());
-                else
-                    resolve(null);
-                return;
+        if (timeout === 0) {
+            const self = control(source, true);
+            if (!self.frame.size)
+                resolve(false);
+            else if (typeof select == "string" && !self.frame.has(select))
+                reject(Oops$7.KeysExpected(select));
+            else {
+                const remove = self.addListener(() => {
+                    remove();
+                    return () => resolve(self.latest);
+                });
             }
-            if (keys) {
-                if (keys.length) {
-                    if (arg2 === 0 && single && !pending.has(keys[0])) {
-                        reject(Oops$6.KeysExpected(keys[0]));
-                        return;
-                    }
-                    else
-                        for (const key of keys)
-                            try {
-                                void source[key];
-                            }
-                            catch (e) { }
-                }
+        }
+        else {
+            const remove = addEventListener(source, select, resolve, true);
+            if (timeout > 0)
+                setTimeout(() => {
+                    remove();
+                    resolve(false);
+                }, timeout);
+        }
+    });
+}
+
+const Oops$6 = issues({
+    NotFound: (name) => `Could not find ${name} in context.`
+});
+function get$1(arg1, arg2) {
+    return Control.get(this, (refresh, context) => {
+        let onUpdate;
+        let value;
+        if (typeof arg1 !== "function") {
+            context(got => {
+                if (got)
+                    value = arg1 === undefined
+                        ? Control.watch(got, () => onUpdate)
+                        : got;
+                else if (arg1 !== false)
+                    throw Oops$6.NotFound(this);
+            });
+            return {
+                mount() {
+                    onUpdate = refresh;
+                    return () => onUpdate = null;
+                },
+                render: () => value
+            };
+        }
+        let compute = arg1;
+        let suspense;
+        let getValue;
+        let factory;
+        let proxy;
+        context(got => {
+            if (!got)
+                throw Oops$6.NotFound(this);
+            proxy = Control.watch(got, () => factory ? null : onUpdate);
+            getValue = () => compute.call(proxy, proxy, forceUpdate);
+            value = getValue();
+            function forceUpdate(action) {
+                if (typeof action == "function")
+                    action = action();
+                if (getValue)
+                    didUpdate(getValue());
+                else
+                    refresh();
+                if (action)
+                    return action.finally(refresh);
             }
-            else if (!pending.size && arg1 === true || arg2 === 0) {
-                reject(Oops$6.StrictUpdate());
-                return;
+        });
+        if (value === null) {
+            getValue = undefined;
+            onUpdate = null;
+            return;
+        }
+        if (typeof value == "function") {
+            const get = value;
+            Control.watch(proxy, () => onUpdate);
+            factory = true;
+            compute = () => get();
+            value = get();
+        }
+        const didUpdate = (got) => {
+            value = got;
+            if (suspense) {
+                suspense();
+                suspense = undefined;
             }
             else
-                controller.waiting.add(resolve);
-            return controller.addListener(key => {
-                if (!key) {
-                    if (keys && !keys.length)
-                        resolve([]);
-                    else
-                        timeout(`lifetime of ${source}`);
-                }
-                else if (!keys || keys.includes(key)) {
-                    removeListener();
-                    return keys => resolve(single ? controller.state.get(key) : keys);
+                refresh();
+        };
+        if (value instanceof Promise) {
+            onUpdate = null;
+            value.then(didUpdate);
+            value = undefined;
+        }
+        else
+            onUpdate = () => {
+                const next = getValue();
+                if (notEqual(value, next))
+                    didUpdate(next);
+            };
+        return {
+            mount: () => () => {
+                onUpdate = null;
+            },
+            render: () => {
+                if (value !== undefined)
+                    return value;
+                if (arg2)
+                    throw new Promise(res => {
+                        suspense = res;
+                    });
+                return null;
+            }
+        };
+    });
+}
+/** 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])));
+
+function use$1(arg1, arg2) {
+    const render = Control.use((refresh) => {
+        let onUpdate;
+        let applyProps = typeof arg1 === "object";
+        const instance = this.new();
+        const proxy = Control.watch(instance, () => onUpdate);
+        if (typeof arg1 == "function")
+            arg1(instance);
+        return {
+            instance,
+            mount() {
+                onUpdate = refresh;
+                return () => {
+                    onUpdate = null;
+                    instance.null();
+                };
+            },
+            render(props) {
+                if (applyProps) {
+                    onUpdate = undefined;
+                    applyProps = !!arg2;
+                    for (const key in props)
+                        if (instance.hasOwnProperty(key))
+                            instance[key] = props[key];
+                    instance.on(0).then(() => onUpdate = refresh);
                 }
-            });
-        });
-        if (arg2 && typeof arg2 == "number")
-            setTimeout(() => timeout(`${arg2}ms`), arg2);
+                return proxy;
+            }
+        };
     });
+    return render(arg1);
 }
 
-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(id) {
-        new Control(this);
-        defineProperty(this, "is", { value: this });
-        defineProperty(this, "id", { value: id || random() });
+        new Control(this, id);
+    }
+    /**
+     * Reference to `this` without a subscription.
+     * Use to obtain full reference from a destructure.
+     */
+    get is() {
+        return this;
     }
     on(arg1, arg2, arg3) {
         if (typeof arg1 == "function")
-            return createEffect(this.is, arg1, arg2);
-        if (typeof arg2 != "function")
-            return awaitUpdate(this.is, arg1, arg2);
-        if (arg1)
-            return addEventListener(this.is, arg1, arg2, arg3);
+            return createEffect(this, arg1);
+        if (typeof arg1 == "number") {
+            arg2 = arg1;
+            arg1 = undefined;
+        }
+        return typeof arg2 == "function"
+            ? addEventListener(this, arg1, arg2, arg3)
+            : awaitUpdate(this, arg1, arg2);
     }
     get(arg1, arg2) {
-        const { state } = control(this);
-        const extract = () => {
+        const { state } = control(this, true);
+        function values() {
             if (typeof arg1 == "string")
-                return state.get(arg1);
+                return state[arg1];
+            if (!arg1)
+                return Object.assign({}, state);
             const output = {};
-            for (const key of arg1 || state.keys())
-                output[key] = state.get(key);
+            for (const key of arg1)
+                output[key] = state[key];
             return output;
-        };
-        if (!arg1 || arg2 === undefined)
-            return extract();
-        if (typeof arg2 == "function")
-            return this.on(arg1, () => arg2(extract()));
-        const timeout = typeof arg2 == "number" ? arg2 : undefined;
-        return this.on(arg1, timeout).then(extract);
+        }
+        return typeof arg2 == "function"
+            ? this.on(arg1, () => arg2(values()))
+            : values();
     }
     set(arg1, arg2) {
-        const controller = control(this);
+        const controller = control(this, true);
         const { state } = controller;
         if (typeof arg1 == "string") {
             controller.update(arg1);
-            if (1 in arguments) {
-                if (state.has(arg1))
-                    state.set(arg1, arg2);
-                else if (arg1 in this) {
-                    const method = this[arg1];
-                    if (typeof method == "function")
-                        method.call(this, arg2);
-                }
-            }
+            if (1 in arguments && arg1 in state)
+                state[arg1] = arg2;
         }
         else if (typeof arg1 == "object")
-            for (const key in arg1)
-                if (arg2 === true || (arg2 ? arg2.includes(key) : state.has(key))) {
-                    state.set(key, arg1[key]);
+            for (const key in state)
+                if (key in arg1 && (!arg2 || arg2.includes(key))) {
+                    state[key] = arg1[key];
                     controller.update(key);
                 }
-        return {
-            then: (callback) => {
-                if (!callback)
-                    throw Oops$5.NoChaining();
-                controller.waiting.add(callback);
-            }
-        };
+        return this.on(0);
     }
     /** Mark this instance for garbage collection. */
-    gc() {
-        control(this).clear();
+    null() {
+        control(this, true).clear();
     }
     /**
      * Creates a new instance of this controller.
@@ -358,18 +398,9 @@ class Model {
      */
     static new(...args) {
         const instance = new this(...args);
-        control(instance);
+        control(instance, true);
         return instance;
     }
-    static find() {
-        throw Oops$5.NoAdapter("find");
-    }
-    static get() {
-        throw Oops$5.NoAdapter("get");
-    }
-    static use() {
-        throw Oops$5.NoAdapter("use");
-    }
     /**
      * Static equivalent of `x instanceof this`.
      *
@@ -380,10 +411,12 @@ class Model {
             maybe.prototype instanceof this);
     }
 }
+Model.get = get$1;
+Model.use = use$1;
 defineProperty(Model.prototype, "toString", {
     configurable: true,
     value() {
-        return `${this.constructor.name}-${this.id}`;
+        return `${this.constructor.name}-${control(this).id}`;
     }
 });
 defineProperty(Model, "toString", {
@@ -392,129 +425,326 @@ defineProperty(Model, "toString", {
     }
 });
 
-/**
- * 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 };
+const Oops$5 = issues({
+    BadAssignment: (parent, expected, got) => `${parent} expected Model of type ${expected} but got ${got}.`,
+});
+const INSTRUCTION = new Map();
+const REGISTER = new WeakMap();
+const OBSERVER = new WeakMap();
+const PARENTS = new WeakMap();
+class Control {
+    constructor(subject, id = random()) {
+        this.subject = subject;
+        this.id = id;
+        this.frame = new Set();
+        this.followers = new Set();
+        this.observers = new Map([["", this.followers]]);
+        REGISTER.set(subject, this);
+    }
+    add(key) {
+        const { value } = getOwnPropertyDescriptor(this.subject, key);
+        const instruction = INSTRUCTION.get(value);
+        if (typeof instruction == "function") {
+            INSTRUCTION.delete(value);
+            instruction(key, this);
+        }
+        else if (value instanceof Model)
+            setRecursive(this, key, value);
+        else if (typeof value != "function")
+            this.watch(key, { value });
+    }
+    watch(key, output) {
+        const { state } = this;
+        const { get, set, enumerable } = output;
+        const subs = new Set();
+        this.observers.set(key, subs);
         if ("value" in output)
-            control.state.set(key, output.value);
-        let { enumerable, get, set } = output;
-        defineProperty(control.subject, key, {
+            state[key] = output.value;
+        defineProperty(this.subject, key, {
             enumerable,
-            set: (set === false
+            set: set === false
                 ? undefined
-                : control.ref(key, set)),
+                : this.ref(key, set),
             get() {
-                const local = subscriber(this);
-                return (local ? local.get(key, get) :
-                    get ? get(local) :
-                        control.state.get(key));
+                const event = OBSERVER.get(this);
+                if (event)
+                    subs.add(event);
+                const value = get ? get(this) : state[key];
+                return event && value instanceof Model
+                    ? watch(value, event)
+                    : value;
             }
         });
+    }
+    ref(key, callback) {
+        const { state, subject } = this;
+        return (value) => {
+            if (value !== state[key])
+                switch (callback && callback.call(subject, value)) {
+                    case undefined:
+                        state[key] = value;
+                    case true:
+                        this.update(key);
+                }
+        };
+    }
+    update(key) {
+        const { frame } = this;
+        if (frame.has(key))
+            return;
+        if (!frame.size) {
+            this.latest = undefined;
+            requestUpdateFrame(() => {
+                this.latest = Array.from(frame);
+                this.followers.forEach(cb => {
+                    const notify = cb(undefined, this);
+                    if (notify)
+                        requestUpdateFrame(notify);
+                });
+                frame.clear();
+            });
+        }
+        frame.add(key);
+        for (const k of ["", key]) {
+            const subs = this.observers.get(k);
+            subs && subs.forEach(cb => {
+                const notify = cb(key, this);
+                if (notify === null)
+                    subs.delete(cb);
+                else if (notify)
+                    requestUpdateFrame(notify);
+            });
+        }
+    }
+    addListener(fn) {
+        this.followers.add(fn);
+        return () => this.followers.delete(fn);
+    }
+    clear() {
+        this.observers.forEach(subs => {
+            subs.forEach(fn => {
+                const cb = fn(null, this);
+                cb && cb();
+            });
+        });
+        this.observers.clear();
+    }
+}
+Control.after = new Set();
+Control.before = new Set();
+Control.pending = new Set();
+Control.for = control;
+Control.apply = apply;
+Control.watch = watch;
+const PENDING_INIT = new WeakMap();
+function control(subject, ready) {
+    const control = REGISTER.get(subject.is);
+    const onReady = typeof ready == "function" && ready;
+    if (!control.state && ready) {
+        let waiting = PENDING_INIT.get(control);
+        if (!waiting)
+            PENDING_INIT.set(control, waiting = new Set());
+        if (onReady) {
+            let callback;
+            waiting.add(() => callback = onReady(control));
+            return () => callback && callback();
+        }
+        control.state = {};
+        for (const key in control.subject)
+            control.add(key);
+        waiting.forEach(cb => cb());
+    }
+    return onReady ? onReady(control) : control;
+}
+function requestUpdateFrame(event) {
+    const { after, before, pending } = Control;
+    if (!pending.size)
+        setTimeout(() => {
+            before.forEach(x => x());
+            pending.forEach(notify => {
+                try {
+                    notify();
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+            pending.clear();
+            after.forEach(x => x());
+        }, 0);
+    pending.add(event);
+}
+function setRecursive(on, key, value) {
+    const set = (next) => {
+        if (next instanceof value.constructor) {
+            on.state[key] = next;
+            parent(next, on.subject);
+            control(next, true);
+            return true;
+        }
+        throw Oops$5.BadAssignment(`${on.subject}.${key}`, value.constructor, next);
+    };
+    on.watch(key, { set });
+    set(value);
+}
+function parent(child, register) {
+    if (!register)
+        return PARENTS.get(child);
+    PARENTS.set(child, register);
+}
+function watch(on, cb) {
+    if (!on.hasOwnProperty("is"))
+        on = defineProperty(create(on), "is", { value: on });
+    OBSERVER.set(on, cb);
+    return on;
+}
+function apply(instruction) {
+    const placeholder = Symbol("instruction");
+    INSTRUCTION.set(placeholder, (key, onto) => {
+        delete onto.subject[key];
+        const output = instruction.call(onto, key, onto);
+        if (output)
+            onto.watch(key, typeof output == "function" ? { get: output } : output);
     });
     return placeholder;
+}
+/** Random alphanumberic of length 6; will always start with a letter. */
+function random() {
+    return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
 }
 
 const Oops$4 = issues({
+    DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
+});
+function run(task) {
+    return apply((key, control) => {
+        let pending = false;
+        const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
+            if (pending)
+                return Promise.reject(Oops$4.DuplicatePending(key));
+            pending = true;
+            control.update(key);
+            try {
+                return yield mayRetry(() => (task.apply(control.subject, args)));
+            }
+            finally {
+                pending = false;
+                control.update(key);
+            }
+        });
+        control.state[key] = undefined;
+        defineProperty(invoke, "active", {
+            get: () => pending
+        });
+        return {
+            value: invoke,
+            set: false
+        };
+    });
+}
+
+const Oops$3 = 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}.`,
-    Required: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
+    Required: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}.`,
+    Unexpected: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
+    AmbientRequired: (requested, requester) => `Attempted to find an instance of ${requested} in context. It is required by ${requester}, but one could not be found.`
 });
 function get(arg0, arg1) {
-    const fetch = this || getParentForGetInstruction;
-    return add(function get(key) {
-        let { subject } = this;
+    return apply((key, control) => {
+        let { subject } = control;
         if (typeof arg0 == "symbol")
-            throw Oops$4.PeerNotAllowed(subject, key);
+            throw Oops$3.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 (Model.isTypeof(arg0)) {
+            const hasParent = parent(subject);
+            if (!hasParent) {
+                if (arg1 === true)
+                    throw Oops$3.Required(arg0, subject);
+                source = callback => Control.has(arg0, subject, got => {
+                    if (got)
+                        callback(got);
+                    else if (arg1 !== false)
+                        throw Oops$3.AmbientRequired(arg0, subject);
+                });
+            }
+            else if (!arg0 || hasParent instanceof arg0)
+                subject = hasParent;
+            else
+                throw Oops$3.Unexpected(arg0, subject, hasParent);
+        }
         else if (typeof arg0 == "function")
             arg1 = arg0.call(subject, key, subject);
         return typeof arg1 == "function"
-            ? computed(this, key, source, arg1)
-            : recursive(this, key, source, arg1);
+            ? computed(control, key, source, arg1)
+            : recursive(control, key, 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, relativeTo.constructor);
-    };
-}
 function recursive(parent, key, source, required) {
-    const getter = getRecursive(key, parent);
     let waiting;
-    source((got) => {
-        parent.state.set(key, got);
-        if (waiting)
-            parent.update(key);
-    });
+    if (source)
+        source((got) => {
+            parent.state[key] = got;
+            if (waiting)
+                parent.update(key);
+        });
     waiting = true;
-    return (local) => {
-        const value = parent.state.get(key);
-        if (!value && required !== false)
-            parent.waitFor(key);
-        return local ? getter(local) : value;
+    return () => {
+        const value = parent.state[key];
+        if (value)
+            return value;
+        if (required !== false)
+            throw suspense(parent, key);
     };
 }
+const ORDER = new WeakMap();
+const PENDING = new Set();
+let OFFSET = 0;
 function computed(parent, key, source, setter) {
     const { state } = parent;
-    let local;
+    let proxy;
     let active;
     let isAsync;
-    let order = ORDER.get(parent);
-    let pending = KEYS.get(parent);
-    if (!order)
-        ORDER.set(parent, order = new Map());
-    if (!pending)
-        KEYS.set(parent, pending = new Set());
-    INFO.set(compute, key);
+    let reset;
     function compute(initial) {
+        if (parent.frame.has(key))
+            return;
         let next;
         try {
-            next = setter.call(local.proxy, local.proxy);
+            next = setter.call(proxy, proxy);
         }
         catch (err) {
-            Oops$4.Failed(parent.subject, key, initial).warn();
+            Oops$3.Failed(parent.subject, key, initial).warn();
             if (initial)
                 throw err;
             console.error(err);
         }
-        if (next !== state.get(key)) {
-            state.set(key, next);
+        if (next !== state[key]) {
+            state[key] = next;
             if (!initial || isAsync)
                 parent.update(key);
         }
     }
     function connect(model) {
-        local = new Subscriber(model, (_, control) => {
+        if (reset)
+            reset();
+        let done;
+        reset = () => done = true;
+        proxy = watch(model, (_, control) => {
+            if (done)
+                return null;
             if (control !== parent)
                 compute();
             else
-                pending.add(compute);
+                PENDING.add(compute);
         });
-        local.watch.set(key, false);
         try {
             compute(true);
         }
         finally {
-            local.commit();
-            order.set(compute, order.size);
+            ORDER.set(compute, OFFSET++);
         }
     }
     return () => {
@@ -523,297 +753,32 @@ function computed(parent, key, source, setter) {
             source(connect);
             isAsync = true;
         }
-        if (!local)
-            parent.waitFor(key);
-        if (pending.delete(compute))
+        if (!proxy)
+            throw suspense(parent, key);
+        if (PENDING.delete(compute))
             compute();
-        return state.get(key);
+        return state[key];
     };
 }
-const INFO = new WeakMap();
-const KEYS = new WeakMap();
-const ORDER = new WeakMap();
-function flushComputed(control) {
-    const pending = KEYS.get(control);
-    if (!pending || !pending.size)
-        return;
-    const priority = ORDER.get(control);
-    while (pending.size) {
+function flushComputed() {
+    while (PENDING.size) {
         let compute;
-        for (const item of pending)
-            if (!compute || priority.get(item) < priority.get(compute))
+        for (const item of PENDING)
+            if (!compute || ORDER.get(item) < ORDER.get(compute))
                 compute = item;
-        pending.delete(compute);
-        const key = INFO.get(compute);
-        if (!control.frame.has(key))
-            compute();
+        PENDING.delete(compute);
+        compute();
     }
-    pending.clear();
-}
-function using(fn) {
-    return Object.assign(get.bind(fn), { using });
 }
-get.using = using;
-
-const REGISTER = new WeakMap();
-const PENDING = new Map();
-class Control {
-    constructor(subject) {
-        this.subject = subject;
-        this.frame = new Set();
-        this.waiting = new Set();
-        this.followers = new Set();
-        REGISTER.set(subject, this);
-    }
-    watch(key) {
-        const { subject, state } = this;
-        const { value } = getOwnPropertyDescriptor(subject, key);
-        if (typeof value == "function")
-            return;
-        if (typeof value == "symbol") {
-            const instruction = PENDING.get(value);
-            if (instruction) {
-                delete subject[key];
-                PENDING.delete(value);
-                instruction(this, key);
-            }
-            return;
-        }
-        state.set(key, value);
-        if (value instanceof Model) {
-            setRecursive(this, key, value);
-            return;
-        }
-        defineProperty(subject, key, {
-            enumerable: false,
-            set: this.ref(key),
-            get() {
-                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 () => {
-            this.followers.delete(listener);
-        };
-    }
-    ref(key, handler) {
-        const { subject, state } = this;
-        return (value) => {
-            if (state.get(key) == value)
-                return;
-            if (handler)
-                switch (handler.call(subject, value)) {
-                    case true:
-                        this.update(key);
-                    case false:
-                        return;
-                }
-            state.set(key, value);
-            this.update(key);
-        };
-    }
-    update(key) {
-        const { followers, frame, waiting } = this;
-        if (frame.has(key))
-            return;
-        else if (!frame.size)
-            setTimeout(() => {
-                flushComputed(this);
-                const keys = this.latest = Array.from(frame);
-                setTimeout(() => this.latest = undefined, 0);
-                frame.clear();
-                for (const notify of waiting)
-                    try {
-                        waiting.delete(notify);
-                        notify(keys);
-                    }
-                    catch (err) {
-                        console.error(err);
-                    }
-            }, 0);
-        frame.add(key);
-        for (const callback of followers) {
-            const event = callback(key, this);
-            if (typeof event == "function")
-                waiting.add(event);
-        }
-    }
-    clear() {
-        const listeners = [...this.followers];
-        this.followers.clear();
-        listeners.forEach(x => x(null, this));
-    }
-}
-Control.get = controller;
-Control.for = control;
-function controller(from) {
-    if ("is" in from)
-        from = from.is;
-    return REGISTER.get(from);
-}
-function control(subject, cb) {
-    const control = controller(subject) || new Control(subject);
-    if (!control.state) {
-        const { waiting } = control;
-        if (cb) {
-            let callback;
-            waiting.add(() => {
-                callback = cb(control);
-            });
-            return () => {
-                if (callback)
-                    callback();
-            };
-        }
-        control.state = new Map();
-        for (const key in subject)
-            control.watch(key);
-        control.waiting = new Set();
-        for (const cb of waiting)
-            cb([]);
-    }
-    return cb ? cb(control) : control;
-}
-
-const Parent = new WeakMap();
-const Oops$3 = issues({
-    BadAssignment: (parent, expected, got) => `${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, from, value);
-    return value;
-}
-function getRecursive(key, from) {
-    const context = new WeakMap();
-    const { state } = from;
-    return (local) => {
-        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, String(next));
-        const getter = getRecursive(key, controller);
-        get = (local) => local ? getter(local) : state.get(key);
-        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);
-        }
-    });
-}
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-const Oops$2 = issues({
-    DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
-});
-function run(task) {
-    return add(function run(key) {
-        let pending = false;
-        const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
-            if (pending)
-                return Promise.reject(Oops$2.DuplicatePending(key));
-            pending = true;
-            this.update(key);
-            try {
-                return yield mayRetry(() => (task.apply(this.subject, args)));
-            }
-            finally {
-                pending = false;
-                this.update(key);
-            }
-        });
-        this.state.set(key, undefined);
-        defineProperty(invoke, "active", {
-            get: () => pending
-        });
-        return {
-            value: invoke,
-            set: false
-        };
-    });
-}
+Control.before.add(flushComputed);
 
 function ref(arg, mapper) {
-    return add(function ref(key) {
+    return apply((key, source) => {
         let value = {};
-        this.state.set(key, undefined);
         if (typeof arg != "object")
-            value = createRef(this, key, arg);
+            value = createRef(source, key, arg);
         else
-            control(arg).state.forEach((_val, key) => {
+            for (const key in control(arg, true).state) {
                 defineProperty(value, key, mapper ? {
                     configurable: true,
                     get() {
@@ -822,28 +787,30 @@ function ref(arg, mapper) {
                         return out;
                     }
                 } : {
-                    value: createRef(this, key)
+                    value: createRef(source, key)
                 });
-            });
-        defineProperty(this.subject, key, { value });
+            }
+        source.state[key] = undefined;
+        source.observers.set(key, new Set());
+        defineProperty(source.subject, key, { value });
     });
 }
 function createRef(src, key, cb) {
     const refObjectFunction = src.ref(key, cb && createValueEffect(cb));
     defineProperty(refObjectFunction, "current", {
         set: refObjectFunction,
-        get: () => src.state.get(key)
+        get: () => src.state[key]
     });
     return refObjectFunction;
 }
 
-const Oops$1 = issues({
+const Oops$2 = 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) {
-    return add(function set(key) {
-        const { state, subject } = this;
+    return apply((key, control) => {
+        const { state, subject } = control;
         if (typeof value == "function" || value instanceof Promise) {
             const required = argument !== false;
             let getter;
@@ -854,24 +821,24 @@ function set(value, argument) {
                     let pending;
                     let error;
                     if (value instanceof Promise) {
-                        state.set(key, undefined);
+                        state[key] = undefined;
                         pending = value
                             .catch(err => error = err)
                             .then(val => {
-                            state.set(key, val);
+                            state[key] = val;
                             return val;
                         })
                             .finally(() => {
                             pending = undefined;
-                            this.update(key);
+                            control.update(key);
                         });
                     }
                     else
-                        state.set(key, value);
+                        state[key] = value;
                     const suspend = () => {
                         if (required === false)
                             return undefined;
-                        const issue = Oops$1.NotReady(subject, key);
+                        const issue = Oops$2.NotReady(subject, key);
                         assign(pending, {
                             message: issue.message,
                             stack: issue.stack
@@ -883,12 +850,11 @@ function set(value, argument) {
                             throw error;
                         if (pending)
                             return suspend();
-                        if (state.has(key))
-                            return state.get(key);
+                        return state[key];
                     };
                 }
                 catch (err) {
-                    Oops$1.ComputeFailed(subject, key).warn();
+                    Oops$2.ComputeFailed(subject, key).warn();
                     throw err;
                 }
             };
@@ -901,13 +867,13 @@ function set(value, argument) {
             };
         }
         if (value !== undefined)
-            state.set(key, value);
+            state[key] = value;
         return {
             get: () => {
-                if (state.has(key))
-                    return state.get(key);
+                if (key in state)
+                    return state[key];
                 else
-                    this.waitFor(key);
+                    throw suspense(control, key);
             },
             set: typeof argument == "function"
                 ? createValueEffect(argument)
@@ -916,180 +882,27 @@ function set(value, argument) {
     });
 }
 
-const ANY = Symbol("any");
-function keyed(control, property, initial) {
-    const init = createProxy(emit, watch);
-    const frozen = new Set();
-    const context = new Map();
-    const users = new Map();
-    const watched = new WeakMap();
-    const update = new Set();
-    let managed = init(initial);
-    function watch(on, key) {
-        const include = watched.get(on);
-        if (include)
-            include.add(key);
-    }
-    function emit(key) {
-        control.update(property);
-        control.waiting.add(() => frozen.clear());
-        update.forEach(notify => notify(key));
-    }
-    function subscribe(local) {
-        const proxy = create(managed);
-        let watch = users.get(local);
-        if (!watch) {
-            const using = watch = new Set();
-            users.set(local, using);
-            function onEvent(key) {
-                if (frozen.has(local))
-                    return;
-                if (key === ANY || using.has(key) || using.has(ANY)) {
-                    const refresh = local.onUpdate(property, control);
-                    if (refresh) {
-                        frozen.add(local);
-                        refresh();
-                    }
-                }
-            }
-            local.follow(property, false);
-            local.dependant.add({
-                commit() {
-                    if (using.size === 0)
-                        using.add(ANY);
-                    update.add(onEvent);
-                },
-                release() {
-                    update.delete(onEvent);
-                }
-            });
-        }
-        watched.set(proxy, watch);
-        context.set(local, proxy);
-        return proxy;
-    }
-    control.addListener(key => {
-        if (key === null) {
-            update.clear();
-            context.clear();
-        }
-    });
-    return {
-        value: initial,
-        get(local) {
-            return local ?
-                context.get(local) || subscribe(local) :
-                managed;
-        },
-        set(next) {
-            control.state.set(property, next);
-            managed = init(next);
-            context.clear();
-            emit(ANY);
-        }
-    };
-}
-function createProxy(emit, watch) {
-    return (from) => {
-        const proxy = create(from);
-        assign(proxy, {
-            from,
-            delete(key) {
-                // TODO: this commit's fix needs tests.
-                // Was not cause by coverage.
-                const out = from.delete(key);
-                emit(key);
-                return out;
-            },
-            clear() {
-                from.clear();
-                emit(ANY);
-            },
-            has(key) {
-                watch(this, key);
-                return from.has(key);
-            },
-            keys() {
-                watch(this, ANY);
-                return from.keys();
-            },
-            values() {
-                watch(this, ANY);
-                return from.values();
-            },
-            entries() {
-                watch(this, ANY);
-                return from.entries();
-            },
-            forEach(callbackfn, thisArg) {
-                const acc = [];
-                from.forEach((a, b, c) => {
-                    const result = callbackfn.call(thisArg, a, b, c);
-                    if (result !== undefined)
-                        acc.push(result);
-                });
-                watch(this, ANY);
-                return acc;
-            },
-            [Symbol.iterator]() {
-                watch(this, ANY);
-                return from[Symbol.iterator]();
-            },
-        }, from instanceof Set
-            ? {
-                add(key) {
-                    from.add(key);
-                    emit(key);
-                    return this;
-                }
-            }
-            : {
-                get(key) {
-                    watch(this, ANY);
-                    return from.get(key);
-                },
-                set(key, value) {
-                    from.set(key, value);
-                    emit(key);
-                    return this;
-                }
-            });
-        defineProperty(proxy, "size", {
-            get() {
-                watch(this, ANY);
-                return from.size;
-            }
-        });
-        return proxy;
-    };
-}
-
-const Oops = issues({
+const Oops$1 = issues({
     BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
 function use(input, argument) {
-    return add(function use(key) {
-        const { state, subject } = this;
+    return apply((key, source) => {
+        const { state, subject } = source;
         const required = argument !== false;
         let pending;
         let error;
-        let get = (_local) => state.get(key);
         if (typeof input === "function") {
             if ("prototype" in input && input === input.prototype.constructor)
                 input = new input();
         }
         else if (input && typeof input !== "object")
-            throw Oops.BadArgument(typeof input);
-        if (input instanceof Map || input instanceof Set)
-            return keyed(this, key, input);
+            throw Oops$1.BadArgument(typeof input);
         const onUpdate = (next) => {
-            state.set(key, next);
+            state[key] = next;
             if (next) {
-                const getter = getRecursive(key, this);
-                get = (local) => local ? getter(local) : state.get(key);
-                Parent.set(next, subject);
-                control(next);
+                parent(next, subject);
+                control(next, true);
             }
             if (typeof argument == "function")
                 argument(next);
@@ -1098,7 +911,7 @@ function use(input, argument) {
         const suspend = () => {
             if (required === false)
                 return;
-            const issue = Oops.NotReady(subject, key);
+            const issue = Oops$1.NotReady(subject, key);
             assign(pending, {
                 message: issue.message,
                 stack: issue.stack
@@ -1111,14 +924,14 @@ function use(input, argument) {
                 input;
             if (output instanceof Promise) {
                 pending = output
-                    .catch(err => error = err)
                     .then(val => {
                     onUpdate(val);
                     return val;
                 })
+                    .catch(err => error = err)
                     .finally(() => {
                     pending = undefined;
-                    this.update(key);
+                    source.update(key);
                 });
                 return;
             }
@@ -1128,60 +941,29 @@ function use(input, argument) {
             initialize();
         return {
             set: onUpdate,
-            get(local) {
+            get() {
                 if (pending)
                     return suspend();
                 if (error)
                     throw error;
-                if (!state.has(key))
+                if (!(key in state))
                     initialize();
                 if (pending)
                     return suspend();
-                return get(local);
+                return state[key];
             }
         };
     });
 }
 
-const LOCAL = "__local";
-const STATE = "__state";
-const UPDATE = "__update";
-const CONTROL = "__control";
-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 Oops = issues({
+    MultipleExist: (name) => `Did find ${name} in context, but multiple were defined.`,
+    NewValue: (name) => `Provider already has already defined '${name}' but got new value. This is not yet supported.`
 });
-const Debug = {
-    CONTROL,
-    LOCAL,
-    STATE,
-    UPDATE
-};
-
-class Register {
+class Context {
     constructor() {
-        this.table = new Map();
+        this.table = new WeakMap();
+        this.input = new Map();
     }
     has(T) {
         let key = this.table.get(T);
@@ -1192,9 +974,37 @@ class Register {
         return key;
     }
     get(Type) {
-        return this[this.has(Type)];
+        const result = this[this.has(Type)];
+        if (result === null)
+            throw Oops.MultipleExist(Type);
+        return result;
     }
-    add(input, key) {
+    include(inputs) {
+        const init = new Map();
+        for (const key in inputs) {
+            const input = inputs[key];
+            const exists = this.input.get(key);
+            if (exists)
+                if (exists !== input)
+                    throw Oops.NewValue(key);
+                else
+                    continue;
+            const instance = this.add(input);
+            this.input.set(key, input);
+            init.set(instance, true);
+        }
+        for (const [model] of init) {
+            const { state } = control(model, true);
+            Object.values(state).forEach(value => {
+                if (parent(value) === model) {
+                    this.add(value, true);
+                    init.set(value, false);
+                }
+            });
+        }
+        return init;
+    }
+    add(input, implicit) {
         let writable = true;
         let T;
         let I;
@@ -1209,20 +1019,20 @@ class Register {
         }
         do {
             const key = this.has(T);
-            defineProperty(this, key, {
-                configurable: true,
-                value: this.hasOwnProperty(key) && I !== this[key] ? null : I,
-                writable
-            });
+            const value = this.hasOwnProperty(key) ? null : I;
+            if (value || I !== this[key] && !implicit)
+                defineProperty(this, key, {
+                    configurable: true,
+                    value,
+                    writable
+                });
             T = getPrototypeOf(T);
         } while (T !== Model);
-        if (key !== undefined)
-            this.register.set(key, input);
         return I;
     }
     push() {
         const next = create(this);
-        next.register = new Map();
+        next.input = new Map();
         return next;
     }
     pop() {
@@ -1234,21 +1044,48 @@ class Register {
             delete this[key];
         }
         for (const model of items)
-            model.gc();
+            model.null();
+        this.input.clear();
     }
 }
 
-const Internal = {
-    getParent
+const STATE = "__state";
+const UPDATE = "__update";
+const CONTROL = "__control";
+const PARENT = "__parent";
+defineProperties(Model.prototype, {
+    [CONTROL]: {
+        get() {
+            return control(this);
+        }
+    },
+    [STATE]: {
+        get() {
+            return Object.assign({}, control(this).state);
+        }
+    },
+    [UPDATE]: {
+        get() {
+            return control(this).latest;
+        }
+    },
+    [PARENT]: {
+        get() {
+            return parent(this);
+        }
+    }
+});
+const Debug = {
+    CONTROL,
+    STATE,
+    UPDATE,
+    PARENT
 };
 
+exports.Context = Context;
 exports.Control = Control;
 exports.Debug = Debug;
-exports.Internal = Internal;
 exports.Model = Model;
-exports.Register = Register;
-exports.Subscriber = Subscriber;
-exports.add = add;
 exports["default"] = Model;
 exports.get = get;
 exports.issues = issues;