@expressive/mvc 0.33.0 → 0.34.0

package/lib/index.esm.js

@@ -23,619 +23,378 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-class Issue extends Error {
-    constructor() {
-        super(...arguments);
-        // drop first line (error factory) in stack trace.
-        this.stack = this.stack.replace(/\n.+/, "");
-    }
-    warn() {
-        console.warn(this.message);
-    }
-}
-function issues(register) {
-    const Library = {};
-    for (const name in register)
-        Library[name] = (...args) => new Issue(register[name].apply(null, args));
-    return Library;
-}
-
-const { assign, create, defineProperties, defineProperty, entries, keys, getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
-
-const Oops$8 = issues({
-    NotFound: (name) => `Could not find ${name} in context.`
-});
-function get$1(argument) {
-    return Control.get((dispatch, context) => {
-        const refresh = () => dispatch(x => x + 1);
-        let onUpdate;
-        let value;
-        if (typeof argument !== "function") {
-            const got = context.get(this);
-            if (got)
-                value = argument === undefined
-                    ? Control.watch(got, k => k ? onUpdate : undefined)
-                    : got;
-            else if (argument !== false)
-                throw Oops$8.NotFound(this);
-            return {
-                mount() {
-                    onUpdate = refresh;
-                    return () => onUpdate = null;
-                },
-                render: () => value
-            };
-        }
-        let compute = argument;
-        let suspense;
-        let getValue;
-        let factory;
-        let proxy;
-        const found = context.get(this);
-        if (!found)
-            throw Oops$8.NotFound(this);
-        function forceUpdate(action) {
-            if (typeof action == "function")
-                action = action();
-            if (getValue)
-                didUpdate(getValue());
-            else
-                refresh();
-            if (action)
-                return action.finally(refresh);
-        }
-        function didUpdate(got) {
-            value = got;
-            if (suspense) {
-                suspense();
-                suspense = undefined;
-            }
-            else
-                refresh();
-        }
-        proxy = Control.watch(found, () => factory ? null : onUpdate);
-        getValue = () => compute.call(proxy, proxy, forceUpdate);
-        value = getValue();
-        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();
-        }
-        if (value instanceof Promise) {
-            onUpdate = null;
-            value.then(didUpdate);
-            value = undefined;
-        }
-        else
-            onUpdate = () => {
-                const next = getValue();
-                if (value !== next)
-                    didUpdate(next);
-            };
-        return {
-            mount: () => () => {
-                onUpdate = null;
-            },
-            render: () => {
-                if (value !== undefined)
-                    return value;
-                if (onUpdate)
-                    return null;
-                throw new Promise(res => {
-                    suspense = res;
-                });
-            }
-        };
-    });
-}
-
-function use$1(apply, repeat) {
-    const render = Control.use(dispatch => {
-        const instance = this.new();
-        const local = Control.watch(instance, () => onUpdate);
-        const refresh = () => dispatch(x => x + 1);
-        let onUpdate;
-        let shouldApply = !!apply;
-        return {
-            instance,
-            mount() {
-                onUpdate = refresh;
-                return () => {
-                    onUpdate = null;
-                    instance.null();
-                };
-            },
-            render(props) {
-                if (shouldApply) {
-                    onUpdate = undefined;
-                    if (typeof props == "function")
-                        props(instance);
-                    else if (props)
-                        for (const key in instance)
-                            if (props.hasOwnProperty(key))
-                                instance[key] = props[key];
-                    if (!repeat)
-                        shouldApply = false;
-                    instance.set(0).then(() => onUpdate = refresh);
-                }
-                return local;
-            }
-        };
-    });
-    return render(apply);
-}
-
-const Oops$7 = issues({
-    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
-    Destoryed: () => "Model is destroyed."
-});
-function suspense(source, key) {
-    const error = Oops$7.NotReady(source.subject, key);
-    const watch = source.observers.get(key);
-    const promise = new Promise((resolve, reject) => {
-        function onUpdate(key) {
-            if (key)
-                return () => {
-                    if (source.state[key] !== undefined) {
-                        watch.delete(onUpdate);
-                        resolve();
-                    }
-                };
-            if (key === null)
-                reject(Oops$7.Destoryed());
-        }
-        watch.add(onUpdate);
-    });
-    return assign(promise, {
-        toString: () => String(error),
-        name: "Suspense",
-        message: error.message,
-        stack: error.stack
-    });
-}
-function mayRetry(fn) {
-    const retry = (err) => {
-        if (err instanceof Promise)
-            return err.then(compute);
-        else
-            throw err;
-    };
-    const compute = () => {
-        try {
-            const output = fn();
-            return output instanceof Promise
-                ? output.catch(retry)
-                : output;
-        }
-        catch (err) {
-            return retry(err);
-        }
-    };
-    return compute();
-}
-
-const Oops$6 = issues({
-    BadCallback: () => `Callback for effect-callback may only return a function.`
-});
-function createEffect(source, callback) {
-    return control(source, self => {
-        let { subject } = self;
-        let unSet;
-        let busy = false;
-        function invoke() {
-            if (busy)
-                return;
-            const output = mayRetry(() => {
-                if (typeof unSet == "function")
-                    unSet();
-                unSet = callback.call(subject, subject);
-                if (unSet instanceof Promise)
-                    unSet = undefined;
-                if (unSet && typeof unSet !== "function")
-                    throw Oops$6.BadCallback();
-            });
-            if (output instanceof Promise) {
-                output.finally(() => busy = false);
-                busy = true;
-            }
-        }
-        let refresh;
-        subject = watch(subject, () => refresh);
-        self.followers.add(key => (key === null || refresh === null ? refresh : undefined));
-        invoke();
-        refresh = invoke;
-        return () => refresh = null;
-    });
-}
-function createValueEffect(callback, ignoreNull) {
-    let unSet;
-    return function (value) {
-        if (typeof unSet == "function")
-            unSet = void unSet(value);
-        if (value === null && ignoreNull)
-            return;
-        const out = callback.call(this, value);
-        if (typeof out == "boolean")
-            return out;
-        if (!out || out instanceof Promise)
-            return;
-        if (typeof out == "function")
-            unSet = out;
-        else
-            throw Oops$6.BadCallback();
-    };
-}
-
-function getMethod(argument, callback, once) {
-    if (typeof argument == "function")
-        return createEffect(this, argument);
-    const self = control(this, true);
-    function get(key) {
-        const value = self.state[key];
-        return value instanceof Model ? value.get() : value;
-    }
-    const extract = typeof argument == "string"
-        ? () => get(argument)
-        : () => {
-            const output = {};
-            for (const key of argument || keys(self.state))
-                output[key] = get(key);
-            return output;
-        };
-    if (typeof callback != "function")
-        return extract();
-    const select = typeof argument == "string" ? [argument] : argument;
-    const invoke = () => callback(extract(), self.latest || []);
-    if (select)
-        for (const key of select)
-            try {
-                const value = self.subject[key];
-                if (!(key in self.state))
-                    self.watch(key, { value });
-            }
-            catch (e) {
-                // TODO: should this be caught?
-            }
-    if (once === undefined)
-        invoke();
-    const remove = self.addListener(key => {
-        if (!select || select.includes(key)) {
-            if (once)
-                remove();
-            return invoke;
-        }
-    });
-    return remove;
-}
-function setMethod(arg1, arg2) {
-    const self = control(this, true);
-    const { state } = self;
-    let timeout = 0;
-    switch (typeof arg1) {
-        case "string":
-            if (1 in arguments)
-                if (arg1 in state)
-                    state[arg1] = arg2;
-                else
-                    self.watch(arg1, { value: arg2 });
-            self.update(arg1);
-            break;
-        case "object":
-            for (const key in state)
-                if (key in arg1 && (!arg2 || arg2.includes(key))) {
-                    state[key] = arg1[key];
-                    self.update(key);
-                }
-            break;
-        default:
-            timeout = arg1;
-    }
-    return new Promise((resolve) => {
-        if (!self.frame.size && timeout === 0)
-            resolve(false);
-        const remove = self.addListener(() => {
-            remove();
-            return () => resolve(self.latest);
-        });
-        if (timeout > 0)
-            setTimeout(() => {
-                remove();
-                resolve(false);
-            }, timeout);
-    });
-}
-
-class Model {
-    constructor(id) {
-        new Control(this, id === undefined ? uid() : id);
-    }
-    /** Mark this instance for garbage collection. */
-    null() {
-        control(this, true).clear();
-    }
-    /**
-     * Creates a new instance of this controller.
-     *
-     * Beyond `new this(...)`, method will activate managed-state.
-     *
-     * @param args - arguments sent to constructor
-     */
-    static new(...args) {
-        const instance = new this(...args);
-        control(instance, true);
-        return instance;
-    }
-    /**
-     * Static equivalent of `x instanceof this`.
-     *
-     * Will determine if provided class is a subtype of this one.
-     */
-    static is(maybe) {
-        return (typeof maybe == "function" &&
-            maybe.prototype instanceof this);
-    }
-}
-Model.get = get$1;
-Model.use = use$1;
-defineProperty(Model, "toString", {
-    value() {
-        return this.name;
-    }
-});
-defineProperties(Model.prototype, {
-    get: { value: getMethod },
-    set: { value: setMethod },
-    toString: {
-        configurable: true,
-        value() {
-            return `${this.constructor.name}-${control(this).id}`;
-        }
-    }
-});
-/* TODO: Remove below on 1.0.0 release. */
-defineProperty(Model, "isTypeof", {
-    get() {
-        throw new Error("Model.isTypeof method was renamed. Use Model.is instead.");
-    }
-});
-defineProperties(Model.prototype, {
-    is: {
-        configurable: true,
-        get() {
-            throw new Error("Model.is property is now is only available from a hook.");
-        }
-    },
-    on: {
-        configurable: true,
-        writable: true,
-        value() {
-            throw new Error("Model.on() is deprecated. Use Model.get or Model.set instead.");
-        }
-    }
-});
-/** Random alphanumberic of length 6. Will always start with a letter. */
-function uid() {
-    return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
-}
+const { assign, create, defineProperty, entries, freeze, isFrozen, getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
 
-const Oops$5 = issues({
-    BadAssignment: (parent, expected, got) => `${parent} expected Model of type ${expected} but got ${got}.`,
-});
 const REGISTER = new WeakMap();
 const OBSERVER = new WeakMap();
 const INSTRUCT = new Map();
 const PENDING$1 = new WeakMap();
 const PARENTS = new WeakMap();
+const LIFECYCLE = {
+    ready: new Set(),
+    dispatch: new Set(),
+    update: new Set(),
+    didUpdate: new Set(),
+};
 class Control {
+    static on(event, callback) {
+        LIFECYCLE[event].add(callback);
+        return () => LIFECYCLE[event].delete(callback);
+    }
     constructor(subject, id) {
         this.state = {};
-        this.frame = new Set();
-        this.followers = new Set();
-        this.observers = new Map([["", this.followers]]);
-        this.id = id;
+        this.frame = freeze({});
+        this.listeners = new Map();
+        this.id = `${subject.constructor}-${id ? String(id) : uid()}`;
         this.subject = subject;
         REGISTER.set(subject, this);
         if (id !== false)
-            PENDING$1.set(this, new Set(Control.ready));
-    }
-    add(key) {
-        const { value } = getOwnPropertyDescriptor(this.subject, key);
-        const instruction = INSTRUCT.get(value);
-        if (typeof instruction == "function") {
-            INSTRUCT.delete(value);
-            instruction(this, key);
-        }
-        else if (value instanceof Model)
-            setRecursive(this, key, value);
-        else
-            this.watch(key, { value });
+            PENDING$1.set(this, new Set(LIFECYCLE.ready));
     }
     watch(key, output) {
-        const { state } = this;
+        const { state, subject, listeners } = this;
         const { set, enumerable = true } = output;
-        const subs = new Set();
-        this.observers.set(key, subs);
         if ("value" in output)
             state[key] = output.value;
-        defineProperty(this.subject, key, {
+        defineProperty(subject, key, {
             enumerable,
             set: set === false
                 ? undefined
-                : this.ref(key, set),
+                : (next) => {
+                    const previous = state[key];
+                    if (next !== previous) {
+                        state[key] = next;
+                        if (set && set.call(subject, next, previous) === false)
+                            state[key] = previous;
+                        else
+                            this.update(key);
+                    }
+                },
             get() {
-                const event = OBSERVER.get(this);
-                if (event)
-                    subs.add(event);
                 const value = output.get
-                    ? output.get(this) : state[key];
-                return event && REGISTER.has(value)
-                    ? watch(value, event)
-                    : value;
+                    ? output.get(this)
+                    : state[key];
+                const observer = OBSERVER.get(this);
+                if (observer) {
+                    const keys = listeners.get(observer);
+                    listeners.set(observer, new Set(keys).add(key));
+                    return watch(value, observer);
+                }
+                return 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))
+    update(key, value) {
+        const { state, subject, listeners } = this;
+        if (!listeners || 1 in arguments && value === state[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);
+        if (isFrozen(this.frame)) {
+            this.frame = {};
+            enqueue(() => {
+                freeze(this.frame);
+                listeners.forEach((subs, cb) => {
+                    if (!subs) {
+                        const notify = cb(undefined, subject);
+                        if (notify)
+                            enqueue(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 (1 in arguments)
+            state[key] = value;
+        if (key in this.frame)
+            return;
+        this.frame[key] = state[key];
+        for (const [cb, keys] of listeners)
+            if (!keys || keys.has(key)) {
+                const notify = cb(key, subject);
                 if (notify === null)
-                    subs.delete(cb);
+                    listeners.delete(cb);
                 else if (notify)
-                    requestUpdateFrame(notify);
+                    enqueue(notify);
+            }
+    }
+    fetch(key, required) {
+        const { state, subject } = this;
+        return () => {
+            if (key in state || required === false) {
+                const value = state[key];
+                if (value !== undefined || !required)
+                    return value;
+            }
+            const error = new Error(`${subject}.${key} is not yet available.`);
+            const promise = new Promise((resolve, reject) => {
+                function check() {
+                    if (state[key] !== undefined) {
+                        remove();
+                        resolve();
+                    }
+                }
+                const remove = this.addListener((k) => {
+                    if (k === key)
+                        return check;
+                    if (k === null)
+                        reject(new Error(`${subject} is destroyed.`));
+                });
             });
-        }
+            throw assign(promise, {
+                toString: () => String(error),
+                name: "Suspense",
+                message: error.message,
+                stack: error.stack
+            });
+        };
     }
     addListener(fn) {
-        this.followers.add(fn);
-        return () => this.followers.delete(fn);
+        this.listeners.set(fn, undefined);
+        return () => this.listeners.delete(fn);
     }
     clear() {
-        this.observers.forEach(subs => {
-            subs.forEach(fn => {
-                const cb = fn(null, this);
-                cb && cb();
-            });
-        });
-        this.observers.clear();
+        this.listeners.forEach((_, fn) => fn(null, this));
+        this.listeners.clear();
+        freeze(this.state);
     }
 }
-Control.ready = new Set();
-Control.after = new Set();
-Control.before = new Set();
-Control.pending = new Set();
-Control.for = control;
-Control.apply = apply;
 Control.watch = watch;
+Control.for = control;
+Control.add = add;
 function control(subject, ready) {
-    const control = REGISTER.get(subject);
-    const pending = PENDING$1.get(control);
+    const self = REGISTER.get(subject.is);
+    const pending = PENDING$1.get(self);
     if (typeof ready == "function") {
-        if (!pending)
-            return ready(control);
-        let done;
-        pending.add(() => done = ready(control));
-        return () => done && done();
+        if (pending) {
+            let done;
+            pending.add(() => done = ready(self));
+            return () => done && done();
+        }
+        return ready(self);
     }
     if (pending && ready) {
-        for (const key in control.subject)
-            control.add(key);
-        PENDING$1.delete(control);
-        pending.forEach(cb => cb(control));
+        for (const key in subject) {
+            const { value } = getOwnPropertyDescriptor(subject, key);
+            const instruction = INSTRUCT.get(value);
+            let desc = { value };
+            if (instruction) {
+                INSTRUCT.delete(value);
+                delete subject[key];
+                const out = instruction.call(self, key, self);
+                desc = typeof out == "function" ? { get: out } : out;
+            }
+            if (desc)
+                self.watch(key, desc);
+        }
+        PENDING$1.delete(self);
+        pending.forEach(cb => cb(self));
     }
-    return control;
+    return self;
 }
-function requestUpdateFrame(event) {
-    const { after, before, pending } = Control;
-    if (!pending.size)
+function enqueue(event) {
+    const { update, didUpdate, dispatch } = LIFECYCLE;
+    if (!dispatch.size)
         setTimeout(() => {
-            before.forEach(x => x());
-            pending.forEach(notify => {
+            update.forEach(x => x());
+            dispatch.forEach(event => {
                 try {
-                    notify();
+                    event();
                 }
                 catch (err) {
                     console.error(err);
                 }
             });
-            pending.clear();
-            after.forEach(x => x());
+            dispatch.clear();
+            didUpdate.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);
+    dispatch.add(event);
 }
-function parent(child, assign) {
+function parent(from, assign) {
     if (!assign)
-        return PARENTS.get(child);
-    PARENTS.set(child, assign);
+        return PARENTS.get(from);
+    PARENTS.set(from, assign);
 }
-function watch(value, cb) {
-    if (!OBSERVER.has(value)) {
-        const control = REGISTER.get(value);
-        value = defineProperty(create(value), "is", { value });
-        REGISTER.set(value, control);
+function watch(value, argument) {
+    const control = REGISTER.get(value);
+    if (control) {
+        if (!OBSERVER.has(value))
+            REGISTER.set(value = create(value), control);
+        OBSERVER.set(value, argument);
     }
-    OBSERVER.set(value, cb);
     return value;
 }
-function apply(instruction) {
+function add(instruction) {
     const placeholder = Symbol("instruction");
-    INSTRUCT.set(placeholder, (onto, key) => {
-        delete onto.subject[key];
-        const output = instruction.call(onto, key, onto);
-        if (output)
-            onto.watch(key, typeof output == "function" ? { get: output } : output);
-    });
+    INSTRUCT.set(placeholder, instruction);
     return placeholder;
+}
+/** Random alphanumberic of length 6. Will always start with a letter. */
+function uid() {
+    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.`
+class Model {
+    constructor(id) {
+        defineProperty(this, "is", { value: this });
+        new Control(this, id);
+    }
+    get(arg1) {
+        return typeof arg1 == "function"
+            ? effect(this, arg1)
+            : extract(this);
+    }
+    set(arg1, arg2) {
+        return typeof arg1 == "function"
+            ? control(this, c => c.addListener(k => k && arg1(k)))
+            : nextUpdate(this, arg1, arg2);
+    }
+    /** Mark this instance for garbage collection. */
+    null() {
+        control(this).clear();
+    }
+    /**
+     * Creates a new instance of this controller.
+     *
+     * Beyond `new this(...)`, method will activate managed-state.
+     *
+     * @param args - arguments sent to constructor
+     */
+    static new(...args) {
+        const instance = new this(...args);
+        control(instance, true);
+        return instance;
+    }
+    /**
+     * Static equivalent of `x instanceof this`.
+     * Determines if provided class is a subtype of this one.
+     * If so, language server will make available all static
+     * methods and properties of this class.
+     */
+    static is(maybe) {
+        return typeof maybe == "function" && maybe.prototype instanceof this;
+    }
+}
+defineProperty(Model.prototype, "toString", {
+    value() {
+        return control(this).id;
+    }
 });
+defineProperty(Model, "toString", {
+    value() {
+        return this.name;
+    }
+});
+
+function extract(target) {
+    const cache = new Map();
+    function get(value) {
+        if (value instanceof Model) {
+            let flat = cache.get(value);
+            if (!flat) {
+                cache.set(value, flat = {});
+                const { state } = control(value);
+                entries(state).forEach(([key, value]) => {
+                    flat[key] = get(value);
+                });
+            }
+            return flat;
+        }
+        return value;
+    }
+    return get(target);
+}
+function nextUpdate(target, arg1, arg2) {
+    return new Promise((resolve, reject) => {
+        control(target, self => {
+            if (isFrozen(self.frame) && typeof arg1 != "number") {
+                resolve(false);
+                return;
+            }
+            const callback = () => resolve(self.frame);
+            const remove = self.addListener((key) => {
+                if (!arg2 || key && arg2(key) === true) {
+                    remove();
+                    if (timeout)
+                        clearTimeout(timeout);
+                    return callback;
+                }
+            });
+            const timeout = typeof arg1 == "number" && setTimeout(() => {
+                remove();
+                reject(arg1);
+            }, arg1);
+        });
+    });
+}
+function effect(target, callback) {
+    return control(target, self => {
+        let refresh;
+        let unSet;
+        function invoke() {
+            if (unSet)
+                unSet();
+            try {
+                const out = callback.call(target, target);
+                unSet = typeof out == "function" ? out : undefined;
+            }
+            catch (err) {
+                if (err instanceof Promise) {
+                    err.then(() => (refresh = invoke)());
+                    refresh = undefined;
+                }
+                else
+                    console.error(err);
+            }
+        }
+        target = watch(target, () => refresh);
+        self.addListener(key => {
+            if (!refresh)
+                return refresh;
+            if (key === null && unSet)
+                unSet();
+        });
+        invoke();
+        refresh = invoke;
+        return () => {
+            refresh = null;
+        };
+    });
+}
+function attempt(fn) {
+    function retry(err) {
+        if (err instanceof Promise)
+            return err.then(compute);
+        else
+            throw err;
+    }
+    function compute() {
+        try {
+            const output = fn();
+            return output instanceof Promise
+                ? output.catch(retry)
+                : output;
+        }
+        catch (err) {
+            return retry(err);
+        }
+    }
+    return compute();
+}
+
 function run(task) {
-    return apply((key, control) => {
+    return add((key, control) => {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$4.DuplicatePending(key));
+                return Promise.reject(new Error(`Invoked action ${key} but one is already active.`));
             pending = true;
             control.update(key);
             try {
-                return yield mayRetry(() => (task.apply(control.subject, args)));
+                return yield attempt(() => task.apply(control.subject, args));
             }
             finally {
                 pending = false;
                 control.update(key);
             }
         });
-        control.state[key] = undefined;
         defineProperty(invoke, "active", {
             get: () => pending
         });
@@ -646,107 +405,93 @@ function run(task) {
     });
 }
 
-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}.`,
-    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) {
-    return apply((key, control) => {
+    return add((key, control) => {
         let { subject } = control;
         if (typeof arg0 == "symbol")
-            throw Oops$3.PeerNotAllowed(subject, key);
-        let source = cb => cb(subject);
+            throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key}. This is not allowed.`);
+        let source = resolve => resolve(subject);
         if (arg0 instanceof Model)
             subject = arg0;
         else if (Model.is(arg0)) {
             const hasParent = parent(subject);
             if (!hasParent) {
                 if (arg1 === true)
-                    throw Oops$3.Required(arg0, subject);
-                const fetch = Control.has(subject);
-                source = got => {
+                    throw new Error(`New ${subject} created standalone but requires parent of type ${arg0}.`);
+                if (!get.from)
+                    throw new Error(`Using context requires an adapter. If you are only testing, define \`get.context\` to simulate one.`);
+                const fetch = get.from(subject);
+                source = (resolve) => {
                     fetch(context => {
                         const model = context.get(arg0);
                         if (model)
-                            got(model);
+                            resolve(model);
                         else if (arg1 !== false)
-                            throw Oops$3.AmbientRequired(arg0, subject);
+                            throw new Error(`Attempted to find an instance of ${arg0} in context. It is required by ${subject}, but one could not be found.`);
                     });
                 };
             }
             else if (!arg0 || hasParent instanceof arg0)
                 subject = hasParent;
             else
-                throw Oops$3.Unexpected(arg0, subject, hasParent);
+                throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
         }
         else if (typeof arg0 == "function")
             arg1 = arg0.call(subject, key, subject);
-        return typeof arg1 == "function"
-            ? computed(control, key, source, arg1)
-            : recursive(control, key, source, arg1);
+        if (typeof arg1 == "function")
+            return compute(control, key, source, arg1);
+        source(got => control.update(key, got));
+        return control.fetch(key, arg1 !== false);
     });
 }
-function recursive(parent, key, source, required) {
-    let waiting;
-    if (source)
-        source((got) => {
-            parent.state[key] = got;
-            if (waiting)
-                parent.update(key);
-        });
-    waiting = true;
-    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;
+function compute(parent, key, source, setter) {
+    const { state, subject } = parent;
     let proxy;
-    let active;
     let isAsync;
     let reset;
     function compute(initial) {
-        if (parent.frame.has(key))
+        if (key in parent.frame)
             return;
         let next;
         try {
             next = setter.call(proxy, proxy);
         }
         catch (err) {
-            Oops$3.Failed(parent.subject, key, initial).warn();
+            // TODO: address possibility of loop
+            if (err instanceof Promise)
+                throw err.finally(compute);
+            console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
             if (initial)
                 throw err;
             console.error(err);
         }
         if (next !== state[key]) {
-            state[key] = next;
-            if (!initial || isAsync)
+            if (key in state || isAsync)
                 parent.update(key);
+            state[key] = next;
         }
     }
     function connect(model) {
+        let done;
         if (reset)
             reset();
-        let done;
         reset = () => done = true;
-        proxy = watch(model, (_, control) => {
+        proxy = watch(model, (_, updated) => {
             if (done)
                 return null;
-            if (control !== parent)
-                compute();
-            else
+            if (updated == subject)
                 PENDING.add(compute);
+            else
+                compute();
         });
+        output.get = () => {
+            if (PENDING.delete(compute))
+                compute();
+            return state[key];
+        };
         try {
             compute(true);
         }
@@ -754,20 +499,17 @@ function computed(parent, key, source, setter) {
             ORDER.set(compute, OFFSET++);
         }
     }
-    return () => {
-        if (!active) {
-            active = true;
+    const output = {
+        get() {
+            output.get = parent.fetch(key);
             source(connect);
             isAsync = true;
+            return output.get();
         }
-        if (!proxy)
-            throw suspense(parent, key);
-        if (PENDING.delete(compute))
-            compute();
-        return state[key];
     };
+    return output;
 }
-function flushComputed() {
+Control.on("update", () => {
     while (PENDING.size) {
         let compute;
         for (const item of PENDING)
@@ -776,21 +518,14 @@ function flushComputed() {
         PENDING.delete(compute);
         compute();
     }
-}
-Control.before.add(flushComputed);
+});
 
-const Oops$2 = issues({
-    BadRefObject: () => `ref instruction does not support object which is not 'this'`
-});
 function ref(arg, arg2) {
-    return apply((key, source) => {
+    return add((key, source) => {
+        const { subject, state } = source;
         let value = {};
-        if (typeof arg != "object")
-            value = createRef(source, key, arg && createValueEffect(arg, arg2 !== false));
-        else if (arg !== source.subject)
-            throw Oops$2.BadRefObject();
-        else
-            for (const key in source.state)
+        if (arg === subject)
+            for (const key in state)
                 defineProperty(value, key, typeof arg2 == "function" ? {
                     configurable: true,
                     get() {
@@ -801,13 +536,32 @@ function ref(arg, arg2) {
                 } : {
                     value: createRef(source, key)
                 });
-        source.state[key] = undefined;
-        source.observers.set(key, new Set());
-        defineProperty(source.subject, key, { value });
+        else if (typeof arg == "object")
+            throw new Error("ref instruction does not support object which is not 'this'");
+        else {
+            let unSet;
+            const set = (value) => {
+                source.update(key, value);
+                if (!arg)
+                    return;
+                if (unSet)
+                    unSet = void unSet(value);
+                if (value !== null || arg2 === false) {
+                    const out = arg.call(subject, value);
+                    if (typeof out == "function")
+                        unSet = out;
+                }
+            };
+            value = defineProperty(set, "current", {
+                get: () => state[key],
+                set
+            });
+        }
+        defineProperty(subject, key, { value });
     });
 }
-function createRef(src, key, cb) {
-    const refObjectFunction = src.ref(key, cb);
+function createRef(src, key) {
+    const refObjectFunction = src.update.bind(src, key);
     defineProperty(refObjectFunction, "current", {
         set: refObjectFunction,
         get: () => src.state[key]
@@ -815,115 +569,101 @@ function createRef(src, key, cb) {
     return refObjectFunction;
 }
 
-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.`
-});
 function set(value, argument) {
-    return apply((key, control) => {
+    return add((key, control) => {
         const { state, subject } = control;
+        const output = {};
         if (typeof value == "function" || value instanceof Promise) {
-            const output = {};
-            const init = () => {
+            function init() {
                 try {
                     if (typeof value == "function")
-                        value = mayRetry(value.bind(subject, key, subject));
+                        value = attempt(value.bind(subject, key, subject));
                     if (value instanceof Promise) {
                         const pending = value
                             .then(value => {
                             output.get = undefined;
-                            state[key] = value;
+                            control.update(key, value);
                             return value;
                         })
                             .catch(err => {
                             output.get = () => { throw err; };
-                        })
-                            .finally(() => {
                             control.update(key);
                         });
+                        assign(pending, {
+                            message: `${subject}.${key} is not yet available.`,
+                            stack: new Error().stack
+                        });
                         if (argument !== false)
-                            return () => {
-                                const { message, stack } = Oops$1.NotReady(subject, key);
-                                throw assign(pending, { message, stack });
+                            return output.get = () => {
+                                throw pending;
                             };
                     }
                     else
-                        state[key] = value;
+                        control.update(key, value);
                 }
                 catch (err) {
-                    Oops$1.ComputeFailed(subject, key).warn();
+                    console.warn(`Generating initial value for ${subject}.${key} failed.`);
                     throw err;
                 }
-            };
+            }
             if (argument)
                 init();
             else
                 output.get = () => {
-                    const get = output.get =
-                        key in state ? undefined : init();
+                    const get = key in state ? null : init();
                     return get ? get() : state[key];
                 };
-            return output;
-        }
-        const set = typeof argument == "function"
-            ? createValueEffect(argument)
-            : undefined;
-        if (value !== undefined) {
-            state[key] = value;
-            return { set };
         }
-        const output = {
-            get() {
-                if (key in state)
-                    return state[key];
-                throw suspense(control, key);
+        else {
+            if (value !== undefined)
+                output.value = value;
+            else
+                output.get = control.fetch(key);
+            if (typeof argument == "function") {
+                let unSet;
+                output.set = function (value, previous) {
+                    const out = argument.call(this, value, previous);
+                    if (out === false)
+                        return out;
+                    if (typeof unSet == "function")
+                        unSet = void unSet(value);
+                    if (typeof out == "function")
+                        unSet = out;
+                };
             }
-        };
-        if (set)
-            output.set = function (value) {
-                output.set = set;
-                state[key] = state[key];
-                return set.call(this, value);
-            };
+        }
         return output;
     });
 }
 
 function use(input, argument) {
-    return apply((key, source) => {
-        const { state, subject } = source;
+    return add((key, source) => {
+        const { subject, state } = source;
         if (typeof input === "function")
             input = new input();
         function set(next) {
+            if (input instanceof Model && !(next instanceof input.constructor))
+                throw new Error(`${subject}.${key} expected Model of type ${input.constructor} but got ${next}.`);
             if (next instanceof Model) {
                 parent(next, subject);
                 control(next, true);
             }
-            else if (next)
-                next = manage(next);
+            else if (next) {
+                const subject = create(next);
+                const control = new Control(subject, false);
+                for (const key in control.state = next)
+                    control.watch(key, {});
+                next = subject;
+            }
             state[key] = next;
             if (typeof argument == "function")
                 argument(next);
-            return true;
         }
         set(input);
         return { set };
     });
-}
-function manage(next) {
-    const subject = assign(create(next), {
-        get: getMethod,
-        set: setMethod
-    });
-    const control = new Control(subject, false);
-    for (const key in control.state = next)
-        control.watch(key, {});
-    return subject;
 }
 
-const Oops = issues({
-    MultipleExist: (name) => `Did find ${name} in context, but multiple were defined.`
-});
 class Context {
     constructor() {
         this.table = new WeakMap();
@@ -940,7 +680,7 @@ class Context {
     get(Type) {
         const result = this[this.has(Type)];
         if (result === null)
-            throw Oops.MultipleExist(Type);
+            throw new Error(`Did find ${Type} in context, but multiple were defined.`);
         return result;
     }
     include(inputs) {
@@ -960,15 +700,13 @@ class Context {
                 return this.include(inputs);
             }
         }
-        for (const [model] of init) {
-            const { state } = control(model, true);
-            Object.values(state).forEach(value => {
+        for (const [model] of init)
+            values(control(model, true).state).forEach(value => {
                 if (parent(value) === model) {
                     this.add(value, true);
                     init.set(value, false);
                 }
             });
-        }
         return init;
     }
     add(input, implicit) {
@@ -980,7 +718,7 @@ class Context {
             I = new input();
         }
         else {
-            I = control(input).subject;
+            I = input;
             T = I.constructor;
             writable = false;
         }
@@ -1020,7 +758,7 @@ const STATE = "__state";
 const UPDATE = "__update";
 const CONTROL = "__control";
 const PARENT = "__parent";
-defineProperties(Model.prototype, {
+Object.defineProperties(Model.prototype, {
     [CONTROL]: {
         get() {
             return control(this);
@@ -1033,7 +771,7 @@ defineProperties(Model.prototype, {
     },
     [UPDATE]: {
         get() {
-            return control(this).latest;
+            return control(this).frame;
         }
     },
     [PARENT]: {