@expressive/mvc 0.7.2 → 0.8.0

package/lib/index.d.ts

@@ -8,48 +8,33 @@ declare type Listener = {
     commit(): void;
     release(): void;
 };
-declare class Subscriber<T extends Stateful = any> {
-    onUpdate: Controller.OnEvent;
+declare class Subscriber<T extends {} = any> {
+    parent: Control<T>;
+    onUpdate: Control.OnEvent;
     proxy: T;
     commit: () => Callback;
     release: Callback;
     active: boolean;
     dependant: Set<Listener>;
     add: (key: any, value?: boolean | Callback) => void;
-    constructor(parent: Controller<T>, onUpdate: Controller.OnEvent);
+    static get<T extends {}>(from: T): Subscriber<T> | undefined;
+    constructor(parent: Control<T>, onUpdate: Control.OnEvent);
 }
 
-declare const WHY: unique symbol;
-declare const LOCAL: unique symbol;
-declare const STATE: unique symbol;
-interface Stateful {
-    /** Controller for this instance. */
-    [CONTROL]?: Controller;
-    /** Current subscriber (if present) while used in a live context (e.g. hook or effect). */
-    [LOCAL]?: Subscriber;
-    /** Current state of this instance. */
-    [STATE]?: Model.Values<this>;
-    /**
-     * Last update causing a refresh to subscribers.
-     *
-     * If accessed directly, will contain all keys from last push.
-     * If within a subscribed function, will contain only keys which explicitly caused a refresh.
-     */
-    [WHY]?: readonly Model.Event<this>[];
-}
 declare namespace Model {
+    export { Control };
+    export { Subscriber };
     /** Including but not limited to T. */
     type Extends<T> = T | (string & Record<never, never>);
-    export { Controller };
-    export { Subscriber };
+    export type Type<T extends Model = Model> = typeof Model & (new () => T);
     export type OnUpdate<T, P> = (this: T, value: ValueOf<keyof T, P>, changed: P) => void;
     export type Effect<T> = (this: T, argument: T) => Callback | Promise<any> | void;
     /** Exotic value, actual value is contained. */
-    export interface Ref<T = any> {
+    export type Ref<T = any> = {
         (next: T): void;
         current: T | null;
-    }
-    /** Properties of T, of which are methods. */
+    };
+    /** Properties of T which are methods. */
     export type Methods<T> = {
         [K in keyof T]: T[K] extends Ref ? never : T[K] extends Function ? K : never;
     }[keyof T];
@@ -57,6 +42,8 @@ declare namespace Model {
      * Subset of `keyof T` which are not methods or defined by base Model U.
      *
      * **Note**: This excludes all keys which are not of type `string` (only those are managed).
+     *
+     * TODO: Should exclude methods
      **/
     export type Field<T, U extends Model = Model> = Exclude<keyof T & string, keyof U>;
     /**
@@ -64,9 +51,13 @@ declare namespace Model {
      **/
     export type Event<T, U extends Model = Model> = Extends<Field<T, U>>;
     /** Object containing managed entries found in T. */
-    export type Entries<T, U extends Model = Model> = Pick<T, Field<T, U>>;
+    export type Entries<T, U extends Model = Model> = {
+        [K in Field<T, U>]: T[K];
+    };
     /** Object comperable to data found in T. */
-    export type Compat<T, U extends Model = Model> = Partial<Entries<T, U>>;
+    export type Compat<T, U extends Model = Model> = {
+        [K in Field<T, U>]?: T[K];
+    };
     /** Actual value stored in state. */
     export type Value<R> = R extends Ref<infer T> ? T : R;
     /** Actual value belonging to a managed property. */
@@ -76,56 +67,45 @@ declare namespace Model {
      *
      * Differs from `Entries` as values here will drill into "real" values held by exotics like ref.
      */
-    export type Values<T, K extends Field<T, Model> = Field<T, Model>> = {
+    export type Values<T, K extends Field<T> = Field<T>> = {
         [P in K]: Value<T[P]>;
     };
 }
-interface Model extends Stateful {
+declare class Model {
     /**
      * Circular reference to `this` controller.
      *
      * Useful to obtain full reference where one has already destructured.
      */
     is: this;
-}
-declare class Model {
-    static [WHY]: readonly string[];
     constructor();
-    get [STATE](): Model.Values<this, Exclude<keyof this & string, keyof Model>>;
-    get [WHY](): readonly string[] | undefined;
     on<P = Model.Event<this>>(event: (key: P) => Callback | void): Callback;
-    on<P = Model.Event<this>>(keys: [], listener: Model.OnUpdate<this, P>, squash?: boolean, once?: boolean): Callback;
-    on<P = Model.Event<this>>(keys: [], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
-    on(keys: [], listener: unknown, squash: boolean, once?: boolean): Callback;
-    on<P extends Model.Event<this>>(key: P | P[], listener: Model.OnUpdate<this, P>, squash?: boolean, once?: boolean): Callback;
-    on<P extends Model.Event<this>>(key: P | P[], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
-    on<P extends Model.Event<this>>(key: P | P[], listener: unknown, squash: boolean, once?: boolean): Callback;
-    once<P = Model.Event<this>>(keys: [], listener: Model.OnUpdate<this, P>, squash?: false, once?: boolean): Callback;
-    once<P = Model.Event<this>>(keys: [], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
-    once<P = Model.Event<this>>(keys: [], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
-    once(keys: [], listener: unknown, squash: boolean, once?: boolean): Callback;
-    once<P extends Model.Event<this>>(key: P | P[], listener: Model.OnUpdate<this, P>, squash?: false): Callback;
-    once<P extends Model.Event<this>>(key: P | P[], listener: (keys: P[]) => void, squash: true): Callback;
-    once<P extends Model.Event<this>>(key: P | P[], listener: unknown, squash: boolean): Callback;
-    once<P extends Model.Event<this>>(key: P | P[], timeout?: number): Promise<void>;
+    on<P extends Model.Event<this>>(key: P): Promise<Model.ValueOf<this, P>>;
+    on<P extends Model.Event<this>>(key: P, timeout: number): Promise<Model.ValueOf<this, P>>;
+    on<P extends Model.Event<this>>(key: P, listener: Model.OnUpdate<this, P>, once?: boolean): Callback;
+    on<P extends Model.Event<this>>(key: P[]): Promise<P[]>;
+    on<P extends Model.Event<this>>(key: P[], timeout: number): Promise<P[]>;
+    on<P extends Model.Event<this>>(key: P[], listener: (keys: P[]) => void, once?: boolean): Callback;
+    on<P = Model.Event<this>>(keys: [], listener: Model.OnUpdate<this, P>, once?: boolean): Callback;
+    on<P = Model.Event<this>>(keys: [], listener: (keys: P[]) => void, once?: boolean): Callback;
     effect(callback: Model.Effect<this>): Callback;
     effect(callback: Model.Effect<this>, select: []): Callback;
     effect(callback: Model.Effect<this>, select: Model.Event<this>[]): Callback;
-    import<O extends Model.Compat<this>>(source: O, select?: (keyof O)[]): void;
     export(): Model.Values<this>;
     export<P extends Model.Field<this>>(select: P[]): Model.Values<this, P>;
     update(): PromiseLike<readonly Model.Event<this>[] | false>;
     update(strict: true): Promise<readonly Model.Event<this>[]>;
     update(strict: false): Promise<false>;
     update(strict: boolean): Promise<readonly Model.Event<this>[] | false>;
-    update(keys: Model.Event<this>): PromiseLike<readonly Model.Event<this>[]>;
-    update(keys: Model.Event<this>, callMethod: boolean): PromiseLike<readonly Model.Event<this>[]>;
-    update<T>(keys: Model.Event<this>, argument: T): PromiseLike<readonly Model.Event<this>[]>;
+    update(key: Model.Event<this>): PromiseLike<readonly Model.Event<this>[]>;
+    update(key: Model.Event<this>, callMethod: boolean): PromiseLike<readonly Model.Event<this>[]>;
+    update<T>(key: Model.Event<this>, argument: T): PromiseLike<readonly Model.Event<this>[]>;
+    update<T extends Model.Compat<this>>(source: T, select: (keyof T)[]): PromiseLike<(keyof T)[]>;
+    update<T extends Model.Compat<this>>(source: T, force?: boolean): PromiseLike<(keyof T)[]>;
     /**
      * Mark this instance for garbage-collection and send `willDestroy` event to all listeners.
      */
-    destroy(): void;
-    toString(): string;
+    kill(): void;
     /**
      * Creates a new instance of this controller.
      *
@@ -133,44 +113,47 @@ declare class Model {
      *
      * @param args - arguments sent to constructor
      */
-    static create<T extends Class>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
+    static new<T extends Class>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
     /**
      * Static equivalent of `x instanceof this`.
      *
      * Will determine if provided class is a subtype of this one.
      */
-    static isTypeof<T extends new () => Model>(this: T, maybe: any): maybe is T;
+    static isTypeof<T extends Model.Type>(this: T, maybe: any): maybe is T;
 }
 
-declare const CONTROL: unique symbol;
-declare namespace Controller {
+declare namespace Control {
     type OnValue<T = any> = (this: T, value: any) => boolean | void;
-    type OnEvent<T = any> = (key: Model.Event<T> | null, source: Controller) => Callback | void;
+    type OnEvent<T = any> = (key: Model.Event<T> | null, source: Control) => Callback | void;
+    type OnReady<T extends {}> = (control: Control<T>) => Callback | void;
 }
-declare class Controller<T extends Stateful = any> {
+declare class Control<T extends {} = any> {
     subject: T;
     state: Map<any, any>;
     frame: Set<string>;
     waiting: Set<Callback>;
-    followers: Set<Model.Controller.OnEvent<any>>;
+    followers: Set<Model.Control.OnEvent<any>>;
     constructor(subject: T);
-    subscribe(callback: Controller.OnEvent<T>): Model.Subscriber<T>;
-    add(key: keyof T & string): void;
-    addListener(listener: Controller.OnEvent<T>): () => void;
-    ref(key: Model.Field<T>, handler?: Controller.OnValue<T>): (value: any) => void;
+    subscribe(callback: Control.OnEvent<T>): Model.Subscriber<T>;
+    watch(key: keyof T & string): void;
+    addListener(listener: Control.OnEvent<T>): () => void;
+    ref(key: Model.Field<T>, handler?: Control.OnValue<T>): (value: any) => void;
     update(key: Model.Field<T>): void;
     clear(): void;
+    static get<T extends {}>(from: T): Control<T> | undefined;
+    static for<T extends {}>(subject: T): Control<T>;
+    static for<T extends {}>(subject: T, cb: Control.OnReady<T>): Callback;
 }
 
 /**
  * Property initializer, will run upon instance creation.
  * Optional returned callback will run when once upon first access.
  */
-declare type Instruction<T> = (this: Controller, key: string, thisArg: Controller) => Instruction.Getter<T> | Instruction.ExplicitDescriptor | Instruction.Descriptor<T> | Instruction.RecursiveDescriptor<T> | boolean | void;
+declare type Instruction<T> = (this: Control, key: string, thisArg: Control) => Instruction.Getter<T> | Instruction.ExplicitDescriptor | Instruction.Descriptor<T> | Instruction.RecursiveDescriptor<T> | boolean | void;
 declare namespace Instruction {
     type Getter<T> = (within?: Subscriber) => T;
     type Setter<T> = (value: T) => boolean | void;
-    type Runner<T> = (this: Controller, key: string, on: Controller) => Instruction.Descriptor<T> | boolean | undefined;
+    type Runner<T> = (this: Control, key: string, on: Control) => Instruction.Descriptor<T> | boolean | undefined;
     interface Descriptor<T> {
         configurable?: boolean;
         enumerable?: boolean;
@@ -178,7 +161,7 @@ declare namespace Instruction {
         writable?: boolean;
         get?: Getter<T>;
         set?: Setter<T> | false;
-        suspense?: boolean;
+        suspend?: boolean;
         destroy?: () => void;
     }
     interface ExplicitDescriptor extends PropertyDescriptor {
@@ -189,14 +172,14 @@ declare namespace Instruction {
         enumerable?: boolean;
         value?: T;
         set?: Setter<T> | false;
-        suspense?: boolean;
+        suspend?: boolean;
     }
 }
 /**
  * Run instruction as controller sets itself up.
  * This will specialize the behavior of a given property.
  */
-declare function apply<T = any>(instruction: Instruction<T>, name?: string): T;
+declare function add<T = any>(instruction: Instruction<T>, name?: string): T;
 
 declare type Async<T = any> = (...args: any[]) => Promise<T>;
 /**
@@ -361,7 +344,7 @@ declare function use<T extends Model>(from: () => T, required: boolean): T;
 /**
  * Create a new child instance of model.
  */
-declare function use<T extends Class>(Type: T, callback?: (i: InstanceOf<T>) => void): InstanceOf<T>;
+declare function use<T extends Model>(Type: Model.Type<T>, callback?: (i: T) => void): T;
 /**
  * Create a managed child from factory function.
  */
@@ -384,82 +367,49 @@ declare function use<T extends {}>(peer: T, callback?: (i: T) => void): T;
  * When parent assigns an instance via `use()` directive, it
  * will be made available to child upon this request.
  *
- * @param Expects - Type of controller compatible with this class.
+ * @param Type - Type of controller compatible with this class.
  * @param required - Throw if controller is created independantly.
  */
-declare function has<T extends typeof Model>(Expects: T, required: false): InstanceOf<T> | undefined;
-declare function has<T extends typeof Model>(Expects: T, required?: true): InstanceOf<T>;
+declare function has<T extends Model>(Type: Model.Type<T>, required: false): T | undefined;
+declare function has<T extends Model>(Type: Model.Type<T>, required?: true): T;
 
 declare class MVC extends Model {
-    static [CONTROL]: Controller;
-    /** Attaches this controller to a component. */
-    tap(): this;
-    tap<K extends Model.Field<this>>(key: K, expect: true): Exclude<this[K], undefined>;
-    tap<K extends Model.Field<this>>(key: K, expect?: boolean): this[K];
-    tap<T>(from: (this: this, state: this) => Promise<T>, expect: true): Exclude<T, undefined>;
-    tap<T>(from: (this: this, state: this) => Promise<T>, expect?: boolean): T | undefined;
-    tap<T>(from: (this: this, state: this) => T, expect: true): Exclude<T, undefined>;
-    tap<T>(from: (this: this, state: this) => T, expect?: boolean): T;
-    /**
-     * **React Hook** - Subscribe to instance of controller within a component.
-     *
-     * @param callback - Run once before subscription begins.
-     */
-    use(watch: Model.Field<this>[], callback?: (instance: this) => void): this;
-    use(callback?: (instance: this) => void): this;
     /**
      * **React Hook** - Fetch most instance of this controller from context, if it exists.
      *
      * @param required - Unless false, will throw where instance cannot be found.
      */
-    static get<T extends Class>(this: T, required?: boolean): InstanceOf<T>;
+    static get<T extends MVC>(this: Model.Type<T>, required?: boolean): T;
     /**
      * **React Hook** - Fetch most instance of this controller from context.
      *
      * @param required - If false, may return undefined.
      */
-    static get<T extends Class>(this: T, required: false): InstanceOf<T> | undefined;
+    static get<T extends MVC>(this: Model.Type<T>, required: false): T | undefined;
     /**
      * **React Hook** - Fetch specific value from instance of this controller in context.
      */
-    static get<T extends Class, I extends InstanceOf<T>, K extends Model.Field<I>>(this: T, key: K): I[K];
+    static get<I extends MVC, K extends Model.Field<I>>(this: Model.Type<I>, key: K): I[K];
     /**
      * **React Hook** - Fetch instance.
      *
      * Effect callback will run once if found, throw if not found.
      * Returned function is called on unmount.
      */
-    static get<T extends Class, I extends InstanceOf<T>>(this: T, effect: (found: I) => Callback | void): I;
+    static get<I extends MVC>(this: Model.Type<I>, effect: (found: I) => Callback | void): I;
     /**
      * **React Hook** - Fetch and subscribe to instance of this controller within ambient component.
      */
-    static tap<T extends Class>(this: T): InstanceOf<T>;
-    static tap<T extends Class, I extends InstanceOf<T>, K extends Model.Field<I>>(this: T, key: K, expect: true): Exclude<I[K], undefined>;
-    static tap<T extends Class, I extends InstanceOf<T>, K extends Model.Field<I>>(this: T, key: K, expect?: boolean): I[K];
-    static tap<T, M extends Class, I extends InstanceOf<M>>(this: M, from: (this: I, state: I) => Promise<T>, expect: true): Exclude<T, undefined>;
-    static tap<T, M extends Class, I extends InstanceOf<M>>(this: M, from: (this: I, state: I) => Promise<T>, expect?: boolean): T;
-    static tap<T, M extends Class, I extends InstanceOf<M>>(this: M, from: (this: I, state: I) => T, expect: true): Exclude<T, undefined>;
-    static tap<T, M extends Class, I extends InstanceOf<M>>(this: M, from: (this: I, state: I) => T, expect?: boolean): T;
-    /**
-     * **React Hook** - Spawn and maintain a controller from within a component.
-     *
-     * More efficient than `use()` if you don't need hook-based features.
-     *
-     * @param callback - Run after creation of instance.
-     */
-    static new<T extends Class, I extends InstanceOf<T>>(this: T, callback?: (instance: I) => void): I;
-    static new<T extends Class, I extends InstanceOf<T>>(this: T, apply: Model.Compat<I>): I;
-    static use<T extends Class, I extends InstanceOf<T>>(this: T, watch: Model.Field<I>[], callback?: (instance: I) => void): I;
-    static use<T extends Class, I extends InstanceOf<T>>(this: T, callback?: (instance: I) => void): I;
-    static use<T extends Class, I extends InstanceOf<T>>(this: T, apply: Model.Compat<I>, keys?: Model.Event<I>[]): I;
-    /**
-     * @deprecated consider doing this manually - not worth minor efficiency gain over using.
-    */
-    static uses<T extends typeof MVC, I extends InstanceOf<T>, D extends Model.Compat<I>>(this: T, apply: D, keys?: (keyof D)[]): InstanceOf<T>;
-    /**
-     * @deprecated is now replaced by overload of `use` method.
-    */
-    static using<T extends typeof MVC, I extends InstanceOf<T>>(this: T, apply: Model.Compat<I>, keys?: Model.Event<I>[]): I;
+    static tap<T extends MVC>(this: Model.Type<T>): T;
+    static tap<I extends MVC, K extends Model.Field<I>>(this: Model.Type<I>, key: K, expect: true): Exclude<I[K], undefined>;
+    static tap<I extends MVC, K extends Model.Field<I>>(this: Model.Type<I>, key: K, expect?: boolean): I[K];
+    static tap<T, I extends MVC>(this: Model.Type<I>, from: (this: I, state: I) => Promise<T>, expect: true): Exclude<T, undefined>;
+    static tap<T, I extends MVC>(this: Model.Type<I>, from: (this: I, state: I) => Promise<T>, expect?: boolean): T;
+    static tap<T, I extends MVC>(this: Model.Type<I>, from: (this: I, state: I) => T, expect: true): Exclude<T, undefined>;
+    static tap<T, I extends MVC>(this: Model.Type<I>, from: (this: I, state: I) => T, expect?: boolean): T;
+    static use<I extends MVC>(this: Model.Type<I>, watch: Model.Field<I>[], callback?: (instance: I) => void): I;
+    static use<I extends MVC>(this: Model.Type<I>, callback?: (instance: I) => void): I;
+    static use<I extends MVC>(this: Model.Type<I>, apply: Model.Compat<I>, keys?: Model.Event<I>[]): I;
     static meta<T extends Class>(this: T): T;
     static meta<T extends Class, K extends keyof T>(this: T, key: K, expect: true): Exclude<T[K], undefined>;
     static meta<T extends Class, K extends keyof T>(this: T, key: K, expect?: boolean): T[K];
@@ -469,6 +419,32 @@ declare class MVC extends Model {
     static meta<T, M extends Class>(this: M, from: (this: M, state: M) => T, expect?: boolean): T;
 }
 
+declare const LOCAL: unique symbol;
+declare const STATE: unique symbol;
+declare const UPDATE: unique symbol;
+declare const CONTROL: unique symbol;
+declare const Debug: {
+    readonly CONTROL: typeof CONTROL;
+    readonly LOCAL: typeof LOCAL;
+    readonly STATE: typeof STATE;
+    readonly UPDATE: typeof UPDATE;
+};
+declare type Debug<T extends {}> = T & {
+    /** Controller for this instance. */
+    [CONTROL]?: Control<T>;
+    /** Current subscriber (if present) while used in a live context (e.g. hook or effect). */
+    [LOCAL]?: Subscriber<T>;
+    /** Current state of this instance. */
+    [STATE]?: Model.Values<T>;
+    /**
+     * Last update causing a refresh to subscribers.
+     *
+     * If accessed directly, will contain all keys from last push.
+     * If within a subscribed function, will contain only keys which explicitly caused a refresh.
+     */
+    [UPDATE]?: readonly Model.Event<T>[];
+};
+
 declare namespace Consumer {
     type HasProps<E extends Class> = {
         /** @deprecated - use for instead */
@@ -510,28 +486,28 @@ declare class Lookup {
     private table;
     get local(): Model[];
     private key;
-    get(T: typeof Model): any;
+    get(T: Model.Type): any;
     push(): this;
-    inject(T: typeof Model, I: Model, writable?: boolean): void;
+    inject(T: Model.Type, I: Model, writable?: boolean): void;
     pop(): void;
 }
+declare function useContext<T extends Model>(Type: Model.Type<T>, required: false): T | undefined;
+declare function useContext<T extends Model>(Type: Model.Type<T>, arg?: boolean): T;
+declare function useContext<T extends Model>(Type: Model.Type<T>, effect: (found: T) => Callback | void): T;
+declare function useContext<T extends Model, K extends Model.Field<T>>(Type: Model.Type<T>, key: K): T[K];
 
 declare namespace Provider {
-    type Item = Model | typeof Model;
-    type Collection<T extends Item> = T[] | {
+    type Item = Model | Model.Type;
+    type Multiple<T extends Item = Item> = T[] | {
         [key: string]: T;
     };
     type Existent<E> = E extends Class ? InstanceType<E> : E extends Model ? E : never;
     type NormalProps<E, I = Existent<E>> = {
-        /** @deprecated use for instead. */
-        of?: never;
         for: E;
-        children: React.ReactNode | ((instance: I) => React.ReactNode);
+        children?: React.ReactNode | ((instance: I) => React.ReactNode);
     } & Model.Compat<I>;
     type MultipleProps<T extends Item> = {
-        /** @deprecated use for instead. */
-        of?: never;
-        for: Collection<T>;
+        for: Multiple<T>;
         children?: React.ReactNode | (() => React.ReactNode);
     } & Model.Compat<Existent<T>>;
     type Props<T extends Item> = MultipleProps<T> | NormalProps<T>;
@@ -539,32 +515,34 @@ declare namespace Provider {
 declare function Provider<T extends Provider.Item>(props: Provider.Props<T>): React.FunctionComponentElement<React.ProviderProps<Lookup>>;
 
 declare class Global extends MVC {
-    static create<T extends Class>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
+    constructor();
+    kill(force?: boolean): boolean;
+    static keepAlive: boolean;
+    static new<T extends Class>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
     /**
      * Update the active instance of this class.
      * Returns a thenable; resolves after successful update.
      * If instance does not already exist, one will be created.
      */
-    static set<T extends typeof Global>(this: T, updates: Partial<InstanceOf<T>>): any;
+    static set<T extends typeof Global>(this: T, values: Model.Compat<InstanceOf<T>, Global>): PromiseLike<Exclude<keyof InstanceOf<T> & string, keyof Global>[]>;
     /**
      * **React Hook** - Fetch most instance of this controller from context, if it exists.
      *
      * @param required - If false, may return undefined.
      */
-    static get<T extends Class>(this: T, required: false): InstanceOf<T> | undefined;
+    static get<T extends Global>(this: Model.Type<T>, required: false): T | undefined;
     /**
      * **React Hook** - Fetch most instance of this controller from context.
      *
      * @param required - Unless false, will throw where instance cannot be found.
      */
-    static get<T extends Class>(this: T, required?: boolean): InstanceOf<T>;
+    static get<T extends Global>(this: Model.Type<T>, required?: boolean): T;
     /**
      * **React Hook** - Fetch specific value from instance of this controller in context.
      */
-    static get<T extends Class, K extends Model.Field<InstanceOf<T>>>(this: T, key: K): InstanceOf<T>[K];
+    static get<T extends Global, K extends Model.Field<T, Global>>(this: Model.Type<T>, key: K): T[K];
     /** Destroy current instance of Global, if it exists. */
     static reset(): void;
-    destroy(): void;
 }
 
 /**
@@ -578,8 +556,8 @@ declare class Global extends MVC {
  *  - If argument is inadequate, but required, your implemention should simply throw.
  *  - If inadequate and not required, conditionally return false.
  */
-declare function tap<T extends Class>(Type: T, callback?: (instance?: InstanceOf<T>) => void | true): InstanceOf<T>;
-declare function tap<T extends Class>(Type: T, callback?: (instance?: InstanceOf<T>) => void | boolean): InstanceOf<T> | undefined;
+declare function tap<T extends Model>(Type: Model.Type<T>, callback?: (instance?: T) => void | true): T;
+declare function tap<T extends Model>(Type: Model.Type<T>, callback?: (instance?: T) => void | boolean): T | undefined;
 /**
  * Find and attach most applicable instance of Model via context.
  *
@@ -589,35 +567,26 @@ declare function tap<T extends Class>(Type: T, callback?: (instance?: InstanceOf
  * @param Type - Type of controller to attach to property.
  * @param required - Throw if instance of Type cannot be found.
  */
-declare function tap<T extends Class>(Type: T, required: true): InstanceOf<T>;
-declare function tap<T extends Class>(Type: T, required?: boolean): InstanceOf<T> | undefined;
-
-declare function useFrom<T extends Stateful, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
-declare function useFrom<T extends Stateful, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect?: boolean): R;
+declare function tap<T extends Model>(Type: Model.Type<T>, required: true): T;
+declare function tap<T extends Model>(Type: Model.Type<T>, required?: boolean): T | undefined;
 
-declare function useLocal<T extends typeof Model>(Type: T, required: false): InstanceOf<T> | undefined;
-declare function useLocal<T extends typeof Model>(Type: T, arg?: boolean): InstanceOf<T>;
-declare function useLocal<T extends typeof Model, I extends InstanceOf<T>>(Type: T, effect: (found: I) => Callback | void): I;
-declare function useLocal<T extends typeof Model, I extends InstanceOf<T>, K extends Model.Field<I>>(Type: T, key: K): I[K];
+declare function useFrom<T extends {}, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
+declare function useFrom<T extends {}, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect?: boolean): R;
 
-declare function useModel<T extends Class, I extends InstanceOf<T>>(source: T, watch: Model.Field<I>[], callback?: (instance: I) => void): I;
-declare function useModel<T extends Class, I extends InstanceOf<T>>(source: T, callback?: (instance: I) => void): I;
-declare function useModel<T extends Class, I extends InstanceOf<T>>(source: T, apply: Model.Compat<I>, keys?: Model.Event<I>[]): I;
-declare function useModel<T extends Stateful>(source: (() => T) | T, watch?: Model.Field<T>[], callback?: (instance: T) => void): T;
-declare function useModel<T extends Stateful>(source: (() => T) | T, callback?: (instance: T) => void): T;
-declare function useModel<T extends Stateful>(source: (() => T) | T, apply: Model.Compat<T>, keys?: Model.Event<T>[]): T;
+declare function useModel<T extends Model>(source: Model.Type<T>, watch: Model.Field<T>[], callback?: (instance: T) => void): T;
+declare function useModel<T extends Model>(source: Model.Type<T>, callback?: (instance: T) => void): T;
+declare function useModel<T extends Model>(source: Model.Type<T>, apply: Model.Compat<T>, keys?: Model.Event<T>[]): T;
+declare function useModel<T extends Model>(source: () => T, watch?: Model.Field<T>[], callback?: (instance: T) => void): T;
+declare function useModel<T extends Model>(source: () => T, callback?: (instance: T) => void): T;
+declare function useModel<T extends Model>(source: () => T, apply: Model.Compat<T>, keys?: Model.Event<T>[]): T;
 
 declare namespace useTap {
-    interface Tappable {
-        new (): Stateful;
-        new (...args: any[]): Stateful;
-        get?: () => Stateful;
-    }
+    type Source<T extends Model> = T | Model.Type<T> | (() => T | Model.Type<T>);
 }
-declare function useTap<T extends Stateful>(source: T | (() => T)): T;
-declare function useTap<T extends Stateful, K extends Model.Field<T>>(source: T | (() => T) | useTap.Tappable, path: K, expect: true): Exclude<T[K], undefined>;
-declare function useTap<T extends Stateful, K extends Model.Field<T>>(source: T | (() => T) | useTap.Tappable, path: K, expect?: boolean): T[K];
-declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
-declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect?: boolean): R;
+declare function useTap<T extends Model>(source: useTap.Source<T>): T;
+declare function useTap<T extends Model, K extends Model.Field<T>>(source: useTap.Source<T>, path: K, expect: true): Exclude<T[K], undefined>;
+declare function useTap<T extends Model, K extends Model.Field<T>>(source: useTap.Source<T>, path: K, expect?: boolean): T[K];
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, from: T) => R, expect?: boolean): R;
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, MVC as default, get, has, ref, set, tap, use, useFrom, useLocal, useModel, useTap };
+export { Consumer, Debug, Global, MVC, MVC as Model, Provider, act, add, MVC as default, get, has, ref, set, tap, use, useContext, useFrom, useModel, useTap };