@expressive/mvc 0.71.0 → 0.73.0

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+//#region src/observable.d.ts
 /**
  * Update callback function.
  *
@@ -6,284 +7,287 @@
  *   - `false` - a normal update has completed.
  *   - `true` - initial event; instance is ready.
  *   - `null` - terminal event; instance is expired.
- * @param source - Instance of Model for which update has occured.
+ * @param source - Instance of State for which update has occured.
  */
-type OnUpdate<T extends Observable = any> = (this: T, key: Event, source: T) => (() => void) | null | void;
+type Notify<T extends Observable = any> = (this: T, key: Event, source: T) => (() => void) | null | void;
 type Effect<T extends Observable> = (proxy: T) => ((update: boolean | null) => void) | Promise<void> | null | void;
 type Event = number | string | null | boolean | symbol;
 type PromiseLite<T = void> = {
-    then: (callback: () => T) => T;
+  then: (callback: () => T) => T;
 };
 declare namespace Observable {
-    type Callback = () => void | PromiseLite;
+  type Callback = () => void | PromiseLite;
 }
 interface Observable {
-    [Observable](callback: Observable.Callback, required?: boolean): this | void;
+  [Observable](callback: Observable.Callback, required?: boolean): this | void;
 }
 declare const Observable: unique symbol;
-declare function addListener<T extends Observable>(subject: T, callback: OnUpdate<T>, select?: Event | Set<Event>): () => boolean;
+/** Update register. */
+declare function addListener<T extends Observable>(subject: T, callback: Notify<T>, select?: Event | Set<Event>): () => boolean;
 declare function event(subject: Observable, key?: string | number | symbol | null, silent?: boolean): void;
 /**
  * Create a side-effect which will update whenever values accessed change.
  * Callback is called immediately and whenever values are stale.
  *
- * @param target - Instance of Model to observe.
+ * @param target - Instance of State to observe.
  * @param callback - Function to invoke when values change.
  * @param requireValues - If `true` will throw if accessing a value which is `undefined`.
  */
-declare function createEffect<T extends Model>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;
-declare function createEffect<T extends Model>(target: T, callback: Effect<T>, recursive?: boolean): () => void;
-
+declare function watch<T extends Observable>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;
+declare function watch<T extends Observable>(target: T, callback: Effect<T>, recursive?: boolean): () => void;
+//#endregion
+//#region src/state.d.ts
 /** Reference bound instance methods to real ones. */
 declare const METHOD: WeakMap<any, any>;
-declare namespace Model {
-    /** Any type of Model, using own class constructor as its identifier. */
-    type Type<T extends Model = Model> = (abstract new (...args: any[]) => T) & typeof Model;
-    /** A Model constructor, but which is not abstract. */
-    type Init<T extends Model = Model> = (new (...args: Model.Args<T>) => T) & Omit<typeof Model, never>;
-    /**
-     * Model constructor callback - is called when Model finishes intializing.
-     * Returned function will run when model is destroyed.
-     */
-    type Callback<T extends Model = Model> = (this: T, thisArg: T) => Promise<void> | (() => void) | Assign<T> | void;
-    /** Model constructor argument */
-    type Argument<T extends Model = Model> = Assign<T> | Callback<T> | string | void;
-    /** Model constructor arguments */
-    type Args<T extends Model = any> = (Argument<T> | Args<T>)[];
-    /** Subset of `keyof T` which are not methods or defined by base Model U. **/
-    type Field<T> = Exclude<keyof T, keyof Model>;
-    /** Any valid key for model, including but not limited to Field<T>. */
-    type Event<T> = Field<T> | (string & {}) | number | symbol;
-    /** Object overlay to override values and methods on a model. */
-    type Assign<T> = {
-        [K in Field<T>]?: T[K] extends (...args: infer A) => infer R ? (this: T, ...args: A) => R : T[K];
-    } & Record<string, unknown>;
-    /** Export/Import compatible value for a given property in a Model. */
-    type Export<R> = R extends {
-        get(): infer T;
-    } ? T : R;
-    /** Value for a property managed by a model. */
-    type Value<T extends Model, K extends Event<T>> = K extends keyof T ? Export<T[K]> : unknown;
-    type OnEvent<T extends Model> = (this: T, key: unknown, source: T) => (() => void) | void | null;
-    type OnUpdate<T extends Model, K extends Event<T>> = (this: T, key: K, thisArg: K) => void;
-    /**
-     * Values from current state of given model.
-     * Differs from `Values` as values here will drill
-     * into "real" values held by exotics like ref.Object.
-     */
-    type State<T> = {
-        [P in Field<T>]: Export<T[P]>;
-    };
-    /** Object comperable to data found in T. */
-    type Values<T> = {
-        [P in Field<T>]?: Export<T[P]>;
-    };
-    /** Exotic value, where actual value is contained within. */
-    type Ref<T = any> = {
-        (next: T): void;
-        current: T | null;
-    };
-    /**
-     * A callback function which is subscribed to parent and updates when accessed properties change.
-     *
-     * @param current - Current state of this model. This is a proxy which detects properties which
-     * where accessed, and thus depended upon to stay current.
-     *
-     * @param update - Set of properties which have changed, and events fired, since last update.
-     *
-     * @returns A callback function which will be called when this effect is stale.
-     */
-    type Effect<T> = (this: T, current: T, update: Set<Event<T>>) => EffectCallback | Promise<void> | null | void;
-    /**
-     * A callback function returned by effect. Will be called when effect is stale.
-     *
-     * @param update - `true` if update is pending, `false` effect has been cancelled, `null` if model is destroyed.
-     */
-    type EffectCallback = ((update: boolean | null) => void);
-    /**
-     * Property initializer, will run upon instance creation.
-     * Optional returned callback will run when once upon first access.
-     */
-    type Instruction<T = any, M extends Model = any> = (this: M, key: Extract<Field<M>, string>, thisArg: M, state: State<M>) => Descriptor<T> | ((source: M) => T) | void;
-    type Getter<T> = (source: Model) => T;
-    type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);
-    type Descriptor<T = any> = {
-        get?: Getter<T> | boolean;
-        set?: Setter<T> | boolean;
-        enumerable?: boolean;
-        value?: T;
-    };
+declare namespace State {
+  /** Any type of State, using own class constructor as its identifier. */
+  type Extends<T extends State = State> = (abstract new (...args: any[]) => T) & typeof State;
+  /** A State constructor which may be instanciated. */
+  type Type<T extends State = State> = (new (...args: State.Args<T>) => T) & Omit<typeof State, never>;
+  /** State constructor arguments */
+  type Args<T extends State = any> = (Args<T> | Init<T> | Assign<T> | string | void)[];
+  /**
+   * State constructor callback - is called when State finishes intializing.
+   * Returned function will run when state is destroyed.
+   */
+  type Init<T extends State = State> = (this: T, thisArg: T) => Promise<void> | (() => void) | Args<T> | Assign<T> | void;
+  /** Object overlay to override values and methods on a state. */
+  type Assign<T> = Record<string, unknown> & { [K in Field<T>]?: T[K] extends ((...args: infer A) => infer R) ? (this: T, ...args: A) => R : T[K] };
+  /** Subset of `keyof T` which are not methods or defined by base State U. **/
+  type Field<T> = Exclude<keyof T, keyof State>;
+  /** Any valid key for state, including but not limited to Field<T>. */
+  type Event<T> = Field<T> | number | symbol | (string & {});
+  /** Export/Import compatible value for a given property in a State. */
+  type Export<R> = R extends {
+    get(): infer T;
+  } ? T : R;
+  /** Value for a property managed by a state. */
+  type Value<T extends State, K extends State.Event<T>> = K extends keyof T ? Export<T[K]> : unknown;
+  type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);
+  type OnEvent<T extends State> = (this: T, key: unknown, source: T) => void | (() => void) | null;
+  type OnUpdate<T extends State, K extends State.Event<T>> = (this: T, key: K, thisArg: K) => void;
+  /**
+   * Values from current state of given state.
+   * Differs from `Values` as values here will drill
+   * into "real" values held by exotics like ref.Object.
+   */
+  type Values<T> = { [P in Field<T>]: Export<T[P]> };
+  /** Object comperable to data found in T. */
+  type Partial<T> = { [P in Field<T>]?: Export<T[P]> };
+  /** Exotic value, where actual value is contained within. */
+  type Ref<T = any> = {
+    (next: T): void;
+    current: T | null;
+  };
+  /**
+   * A callback function which is subscribed to parent and updates when accessed properties change.
+   *
+   * @param current - Current state of this state. This is a proxy which detects properties which
+   * where accessed, and thus depended upon to stay current.
+   *
+   * @param update - Set of properties which have changed, and events fired, since last update.
+   *
+   * @returns A callback function which will be called when this effect is stale.
+   */
+  type Effect<T> = (this: T, current: T, update: Set<State.Event<T>>) => EffectCallback | Promise<void> | null | void;
+  /**
+   * A callback function returned by effect. Will be called when effect is stale.
+   *
+   * @param update - `true` if update is pending, `false` effect has been cancelled, `null` if state is destroyed.
+   */
+  type EffectCallback = (update: boolean | null) => void;
 }
-interface Model {
-    /**
-     * Loopback to instance of this model. This is useful when in a subscribed context,
-     * to keep write access to `this` after a destructure. You can use it to read variables silently as well.
-     **/
-    is: this;
+interface State {
+  /**
+   * Loopback to instance of this state. This is useful when in a subscribed context,
+   * to keep write access to `this` after a destructure. You can use it to read variables silently as well.
+   **/
+  is: this;
 }
-declare abstract class Model implements Observable {
-    constructor(...args: Model.Args);
-    [Observable](callback: Observable.Callback, required?: boolean): this;
-    /**
-     * Pull current values from state. Flattens all models and exotic values recursively.
-     *
-     * @returns Object with all values from this model.
-     **/
-    get(): Model.State<this>;
-    /**
-     * Run a function which will run automatically when accessed values change.
-     *
-     * @param effect Function to run, and again whenever accessed values change.
-     *               If effect returns a function, it will be called when a change occurs (syncronously),
-     *               effect is cancelled, or parent model is destroyed.
-     * @returns Function to cancel listener.
-     */
-    get(effect: Model.Effect<this>): () => void;
-    /**
-     * Get value of a property.
-     *
-     * @param key - Property to get value of.
-     * @param required - If true, will throw an error if property is not available.
-     * @returns Value of property.
-     */
-    get<T extends Model.Event<this>>(key: T, required?: boolean): Model.Value<this, T>;
-    /**
-     * Run a function when a property is updated.
-     *
-     * @param key - Property to watch for updates.
-     * @param callback - Function to call when property is updated.
-     * @returns Function to cancel listener.
-     */
-    get<T extends Model.Event<this>>(key: T, callback: Model.OnUpdate<this, T>): () => void;
-    /**
-     * Check if model is expired.
-     *
-     * @param status - `null` to check if model is expired.
-     * @returns `true` if model is expired, `false` otherwise.
-     */
-    get(status: null): boolean;
-    /**
-     * Callback when model is to be destroyed.
-     *
-     * @param callback - Function to call when model is destroyed.
-     * @returns Function to cancel listener.
-     */
-    get(status: null, callback: () => void): () => void;
-    /**
-     * Get update in progress.
-     *
-     * @returns Promise which resolves object with updated values, `undefined` if there no update is pending.
-     **/
-    set(): PromiseLike<Model.Event<this>[]> | undefined;
-    /**
-     * Update mulitple properties at once. Merges argument with current state.
-     * Properties which are not managed by this model will be ignored.
-     *
-     * @param assign - Object with properties to update.
-     * @param silent - If an update does occur, listeners will not be refreshed automatically.
-     * @returns Promise resolving an array of keys updated, `undefined` (immediately) if a noop.
-     */
-    set(assign?: Model.Assign<this>, silent?: boolean): PromiseLike<Model.Event<this>[]> | undefined;
-    /**
-     * Push an update. This will not change the value of associated property.
-     *
-     * Useful where a property value internally has changed, but the object is the same.
-     * For example: An array has pushed a new value, or a nested property is updated.
-     *
-     * You can also use this to dispatch arbitrary events.
-     * Symbols are recommended as non-property events, however you can use any string.
-     * If doing so, be sure to avoid collisions with property names! An easy way to do this is
-     * to prefix an event with "!" and/or use dash-case. e.g. `set("!event")` or `set("my-event")`.
-     *
-     * @param key - Property or event to dispatch.
-     * @returns Promise resolves an array of keys updated.
-     */
-    set(key: Model.Event<this>): PromiseLike<Model.Event<this>[]>;
-    /**
-     * Set a value for a property. This will update the value and notify listeners.
-     *
-     * **Use with caution!** Key nor value are checked for validity.
-     *
-     * This is meant for assigning values programmatically,
-     * where simple assignment is not practicable.
-     *
-     * For example: `(this as any)[myProperty] = value;`
-     *
-     * @param key - Property to set value for.
-     * @param value - Value to set for property.
-     * @param init - If true, model will begin to manage the property if it is not already.
-     * @returns Promise resolves an array of keys updated.
-     */
-    set(key: Model.Event<this>, value: unknown, init?: boolean): PromiseLike<Model.Event<this>[]>;
-    /**
-     * Call a function when update occurs.
-     *
-     * Given function is called for every assignment (which changes value) or explicit `set`.
-     *
-     * To run logic on final value only, callback may return a function. Using the same
-     * function for one or more events will ensure it is called only when events are settled.
-     *
-     * @param callback - Function to call when update occurs.
-     * @returns Function to remove listener. Will return `true` if removed, `false` if inactive already.
-     *
-    */
-    set(callback: Model.OnEvent<this>): () => boolean;
-    /**
-     * Call a function when a property is updated.
-     * Unlike `get`, this calsl synchronously and will fire as many times as the property is updated.
-     *
-     * @param callback - Function to call when property is updated.
-     * @param event - Property to watch for updates.
-     */
-    set(callback: Model.OnEvent<this>, event: Model.Event<this> | null): () => boolean;
-    /**
-     * Declare an end to updates. This event is final and will freeze state.
-     * This event can be watched for as well, to run cleanup logic and internally will remove all listeners.
-     *
-     * @param status - `null` to end updates.
-     */
-    set(status: null): void;
-    /**
-     * Iterate over managed properties in this instance of Model.
-     * Yeilds the key and current value for each property.
-     */
-    [Symbol.iterator](): Iterator<[string, unknown]>;
-    /**
-     * Create and activate a new instance of this model.
-     *
-     * **Important** - Unlike `new this(...)` - this method also activates state.
-     *
-     * @param args - arguments sent to constructor
-     */
-    static new<T extends Model>(this: Model.Init<T>, ...args: Model.Args<T>): T;
-    /**
-     * 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<T extends Model.Type>(this: T, maybe: unknown): maybe is T;
-    /**
-     * Register a callback to run when any instance of this Model is updated.
-     */
-    static on<T extends Model>(this: Model.Type<T>, listener: Model.OnEvent<T>): () => boolean;
+declare abstract class State implements Observable {
+  constructor(...args: State.Args);
+  [Observable](callback: Observable.Callback, required?: boolean): this;
+  /**
+   * Optional lifecycle hook called during State initialization.
+   * Can return a cleanup function to run when state is destroyed.
+   */
+  protected new?(): void | (() => void);
+  /**
+   * Pull current values from state. Flattens all states and exotic values recursively.
+   *
+   * @returns Object with all values from this state.
+   **/
+  get(): State.Values<this>;
+  /**
+   * Run a function which will run automatically when accessed values change.
+   *
+   * @param effect Function to run, and again whenever accessed values change.
+   *               If effect returns a function, it will be called when a change occurs (syncronously),
+   *               effect is cancelled, or parent state is destroyed.
+   * @returns Function to cancel listener.
+   */
+  get(effect: State.Effect<this>): () => void;
+  /**
+   * Get value of a property.
+   *
+   * @param key - Property to get value of.
+   * @param required - If true, will throw an error if property is not available.
+   * @returns Value of property.
+   */
+  get<T extends State.Event<this>>(key: T, required?: boolean): State.Value<this, T>;
+  /**
+   * Run a function when a property is updated.
+   *
+   * @param key - Property to watch for updates.
+   * @param callback - Function to call when property is updated.
+   * @returns Function to cancel listener.
+   */
+  get<T extends State.Event<this>>(key: T, callback: State.OnUpdate<this, T>): () => void;
+  /**
+   * Check if state is expired.
+   *
+   * @param status - `null` to check if state is expired.
+   * @returns `true` if state is expired, `false` otherwise.
+   */
+  get(status: null): boolean;
+  /**
+   * Callback when state is to be destroyed.
+   *
+   * @param callback - Function to call when state is destroyed.
+   * @returns Function to cancel listener.
+   */
+  get(status: null, callback: () => void): () => void;
+  /**
+   * Get update in progress.
+   *
+   * @returns Promise which resolves object with updated values, `undefined` if there no update is pending.
+   **/
+  set(): PromiseLike<State.Event<this>[]> | undefined;
+  /**
+   * Update mulitple properties at once. Merges argument with current state.
+   * Properties which are not managed by this state will be ignored.
+   *
+   * @param assign - Object with properties to update.
+   * @param silent - If an update does occur, listeners will not be refreshed automatically.
+   * @returns Promise resolving an array of keys updated, `undefined` (immediately) if a noop.
+   */
+  set(assign?: State.Assign<this>, silent?: boolean): PromiseLike<State.Event<this>[]> | undefined;
+  /**
+   * Push an update. This will not change the value of associated property.
+   *
+   * Useful where a property value internally has changed, but the object is the same.
+   * For example: An array has pushed a new value, or a nested property is updated.
+   *
+   * You can also use this to dispatch arbitrary events.
+   * Symbols are recommended as non-property events, however you can use any string.
+   * If doing so, be sure to avoid collisions with property names! An easy way to do this is
+   * to prefix an event with "!" and/or use dash-case. e.g. `set("!event")` or `set("my-event")`.
+   *
+   * @param key - Property or event to dispatch.
+   * @returns Promise resolves an array of keys updated.
+   */
+  set(key: State.Event<this>): PromiseLike<State.Event<this>[]>;
+  /**
+   * Set a value for a property. This will update the value and notify listeners.
+   *
+   * **Use with caution!** Key nor value are checked for validity.
+   *
+   * This is meant for assigning values programmatically,
+   * where simple assignment is not practicable.
+   *
+   * For example: `(this as any)[myProperty] = value;`
+   *
+   * @param key - Property to set value for.
+   * @param value - Value to set for property.
+   * @param init - If true, state will begin to manage the property if it is not already.
+   * @returns Promise resolves an array of keys updated.
+   */
+  set(key: State.Event<this>, value: unknown, init?: boolean): PromiseLike<State.Event<this>[]>;
+  /**
+   * Call a function when update occurs.
+   *
+   * Given function is called for every assignment (which changes value) or explicit `set`.
+   *
+   * To run logic on final value only, callback may return a function. Using the same
+   * function for one or more events will ensure it is called only when events are settled.
+   *
+   * @param callback - Function to call when update occurs.
+   * @returns Function to remove listener. Will return `true` if removed, `false` if inactive already.
+   *
+   */
+  set(callback: State.OnEvent<this>): () => boolean;
+  /**
+   * Call a function when a property is updated.
+   * Unlike `get`, this calls synchronously and will fire as many times as the property is updated.
+   *
+   * @param callback - Function to call when property is updated.
+   * @param event - Property to watch for updates.
+   */
+  set(callback: State.OnEvent<this>, event: State.Event<this> | null): () => boolean;
+  /**
+   * Declare an end to updates. This event is final and will freeze state.
+   * This event can be watched for as well, to run cleanup logic and internally will remove all listeners.
+   *
+   * @param status - `null` to end updates.
+   */
+  set(status: null): void;
+  /**
+   * Iterate over managed properties in this instance of State.
+   * Yeilds the key and current value for each property.
+   */
+  [Symbol.iterator](): Iterator<[string, unknown]>;
+  /**
+   * Create and activate a new instance of this state.
+   *
+   * **Important** - Unlike `new this(...)` - this method also activates state.
+   *
+   * @param args - arguments sent to constructor
+   */
+  static new<T extends State>(this: State.Type<T>, ...args: State.Args<T>): T;
+  /**
+   * 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<T extends State.Extends>(this: T, maybe: unknown): maybe is T;
+  /**
+   * Register a callback to run when any instance of this State is updated.
+   */
+  static on<T extends State>(this: State.Extends<T>, listener: State.OnEvent<T>): () => boolean;
+}
+//#endregion
+//#region src/instruction/use.d.ts
+/**
+ * Property initializer, will run upon instance creation.
+ * Optional returned callback will run when once upon first access.
+ */
+type Instruction<T = any, M extends State = any> = (this: M, key: Extract<State.Field<M>, string>, thisArg: M, state: State.Values<M>) => Instruction.Descriptor<T> | ((source: M) => T) | void;
+declare namespace Instruction {
+  type Getter<T> = (source: State) => T;
+  type Descriptor<T = any> = {
+    get?: Getter<T> | boolean;
+    set?: State.Setter<T> | boolean;
+    enumerable?: boolean;
+    value?: T;
+  };
 }
-
+declare function use<T>(instruction: Instruction<T>): T extends void ? unknown : T;
+declare function use<T extends State>(Type: State.Type<T>, required: false): T | undefined;
+declare function use<T extends State>(Type: State.Type<T>, ready?: (i: T) => void): T;
+//#endregion
+//#region src/instruction/get.d.ts
 declare namespace get {
-    type Compute<T, S = any> = (on: S, key: string) => T;
-    type Factory<T, S = any> = (this: S, key: string, thisArg: S) => T;
-    type Source<T extends Model = Model> = (resolve: (x: T) => void) => void;
-    type Effect<T> = (model: T, key: string) => (() => void) | void;
+  type Callback<T = any> = (state: T, subject: State) => void | boolean | (() => void);
 }
 /**
- * Fetches and assigns the controller which spawned this host.
- * When parent assigns an instance via `use()` directive, it
- * will be made available to child upon this request.
+ * Fetches upstream State from context with optional lifecycle callback.
+ * Callback runs on mount and can return cleanup function for unmount.
  *
- * @param Type - Type of controller compatible with this class.
- * @param expectParent - If true, will throw if Model is created without a parent.
+ * @param Type - Type of State to fetch.
+ * @param callback - Optional lifecycle callback, receives (state, subject). Can return cleanup function.
  */
-declare function get<T extends Model>(Type: Model.Type<T>, expectParent?: true): T;
+declare function get<T extends State>(Type: State.Extends<T>, callback?: get.Callback<T>): T;
 /**
  * Fetches and assigns the controller which spawned this host.
  * When parent assigns an instance via `use()` directive, it
@@ -292,62 +296,111 @@ declare function get<T extends Model>(Type: Model.Type<T>, expectParent?: true):
  * @param Type - Type of controller compatible with this class.
  * @param required - If false, property may be undefined. Otherwise will throw suspense.
  */
-declare function get<T extends Model>(Type: Model.Type<T>, required?: false): T | undefined;
+declare function get<T extends State>(Type: State.Extends<T>, required: false): T | undefined;
 /**
- * Implement a computed value from a foreign model. Output will be generated by provided function,
- * where the foreign model will be passed to that function.
+ * Collects downstream States, this will accumulate all instances of specified type for which this is an ancestor.
+ * Returns a frozen array that updates as States are added or removed.
+ * Callback runs on each State registration and can return cleanup or false to prevent registration.
  *
- * @param source - Type of Model to fetch for computation.
- * @param compute - Compute function. Will update automatically as input values change.
+ * @param Type - Type of State to collect.
+ * @param downstream - Must be true to enable downstream mode.
+ * @param callback - Optional lifecycle callback, receives (state, subject). May return false to prevent registration.
  */
-declare function get<T extends Model>(Type: Model.Type<T>, effect: get.Effect<T>): T;
+declare function get<T extends State>(Type: State.Extends<T>, downstream: true, callback?: get.Callback<T>): readonly T[];
+//#endregion
+//#region src/instruction/set.d.ts
+declare namespace set {
+  type Callback<T, S = any> = (this: S, next: T, previous: T) => ((next: T) => void) | Promise<any> | void | boolean;
+  type Compute<T, S = any> = (on: S, key: string) => T;
+  type Factory<T, S = any> = (this: S, key: string) => Promise<T> | T;
+}
 /**
- * Implement a computed value; output will be generated by provided function.
+ * Set property as `undefined` but required.
  *
- * @param source - Source model from which computed value will be a subscriber.
- * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value. Will update automatically as input values change.
+ * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid
+ * `Promise`/`Error` (aka: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
  */
-declare function get<R, T extends Model>(source: T, compute: get.Compute<R, T>): R;
+declare function set<T = any>(): T;
 /**
- * Implement a computed value; output is returned by function from provided factory.
+ * Set property with a factory function.
  *
- * Factory is bound to owner of property.
+ * **Note** Factory is lazy! It will only run if/when property is accessed.
+ * Value will be undefined until factory resolves, which will also dispatch an update for the property.
+ */
+declare function set<T>(factory: set.Factory<T>, required: false): T | undefined;
+/**
+ * Set property with a factory function.
+ *
+ * If async, property cannot be accessed until resolves, yeilding a result.
+ * If accessed while still processing, React Suspense will be thrown.
  *
- * @param compute - Factory function to generate a getter to subscribe dependancies.
+ * @param factory - Callback run to derrive property value.
+ * @param required - If true run factory immediately on creation, otherwise on access.
  */
-declare function get<R, T>(compute: get.Factory<R, T>): R;
-
+declare function set<T>(factory: set.Factory<T>, required?: boolean): T;
+/**
+ * Set property with a factory function.
+ *
+ * If async, property cannot be accessed until resolves, yeilding a result.
+ * If accessed while still processing, React Suspense will be thrown.
+ *
+ * @param factory - Callback run to derrive property value.
+ * @param onUpdate - Callback run when property is finished computing or is set.
+ */
+declare function set<T>(factory: set.Factory<T>, onUpdate?: set.Callback<T>): T;
+/**
+ * Set a property with empty placeholder and/or update callback.
+ *
+ * @param value - Starting value for property. If undefined, suspense will be thrown on access, until value is set and accepted by callback.
+ * @param onUpdate - Callback run when property is set. If returns false, update is not accepted and property will keep previous value.
+ */
+declare function set<T>(value: T | undefined, onUpdate?: set.Callback<T>): T;
+/**
+ * Implement a reactive computed value using a method reference.
+ *
+ * The method will automatically re-run when any accessed properties change.
+ * Use `true` to indicate reactive mode with implicit `this` as the source.
+ *
+ * @param reactiveToThis - Pass `true` to enable reactive mode with implicit this
+ * @param method - Method reference or compute function to use
+ */
+declare function set<R, T = any>(reactiveToThis: true, method: set.Compute<R, T> | Function): R;
+/**
+ * Implement a computed value; output will be generated by provided function.
+ *
+ * @param reactiveTo - Source state from which computed value will be a subscriber.
+ * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value. Will update automatically as input values change.
+ */
+declare function set<R, T extends State>(reactiveTo: T, compute: set.Compute<R, T>): R;
+//#endregion
+//#region src/instruction/ref.d.ts
 declare namespace ref {
-    type Callback<T> = (argument: T) => ((next: T | null) => void) | Promise<void> | void | boolean;
-    interface Object<T = any> {
-        /** Current value held by this reference. */
-        current: T;
-        /** Model instance this reference belongs to. */
-        is: Model;
-        /** Key of property on model this reference belongs to. */
-        key: string;
-        /**
-         * Subscribe to changes of this reference.
-         *
-         * @param callback - Callback to invoke with the current value when it changes.
-         * @returns Unsubscribe function to stop listening to changes.
-         */
-        get(callback: (value: T) => void): () => void;
-        /** Retrieve current value. */
-        get(): T | null;
-    }
-    /** Object with references to all managed values of `T`. */
-    /** Object with references to all managed values of `T`. */
-    type Proxy<T extends Model> = {
-        [P in Model.Field<T>]-?: Object<T[P]>;
-    } & {
-        get(): T;
-    };
-    type CustomProxy<T extends Model, R> = {
-        [P in Model.Field<T>]-?: R;
-    } & {
-        get(): T;
-    };
+  type Callback<T> = (argument: T) => ((next: T | null) => void) | Promise<void> | void | boolean;
+  interface Object<T = any> {
+    /** Current value held by this reference. */
+    current: T;
+    /** State instance this reference belongs to. */
+    is: State;
+    /** Key of property on state this reference belongs to. */
+    key: string;
+    /**
+     * Subscribe to changes of this reference.
+     *
+     * @param callback - Callback to invoke with the current value when it changes.
+     * @returns Unsubscribe function to stop listening to changes.
+     */
+    get(callback: (value: T) => void): () => void;
+    /** Retrieve current value. */
+    get(): T | null;
+  }
+  /** Object with references to all managed values of `T`. */
+  /** Object with references to all managed values of `T`. */
+  type Proxy<T extends State> = { [P in State.Field<T>]-?: Object<T[P]> } & {
+    get(): T;
+  };
+  type CustomProxy<T extends State, R> = { [P in State.Field<T>]-?: R } & {
+    get(): T;
+  };
 }
 /**
  * Creates an object with references to all managed values.
@@ -355,18 +408,18 @@ declare namespace ref {
  *
  * *Properties are simultaneously a ref-function and ref-object, use as needed.*
  *
- * @param target - Source model from which to reference values.
+ * @param target - Source state from which to reference values.
  */
-declare function ref<T extends Model>(target: T): ref.Proxy<T>;
+declare function ref<T extends State>(target: T): ref.Proxy<T>;
 /**
  * Creates an object with values based on managed values.
  * Each property will invoke mapper function on first access supply
  * the its return value going forward.
  *
- * @param target - Source model from which to reference values.
+ * @param target - Source state from which to reference values.
  * @param mapper - Function producing the placeholder value for any given property.
  */
-declare function ref<O extends Model, R>(target: O, mapper: (key: Model.Field<O>) => R): ref.CustomProxy<O, R>;
+declare function ref<O extends State, R>(target: O, mapper: (key: State.Field<O>) => R): ref.CustomProxy<O, R>;
 /**
  * Creates a ref-compatible property.
  * Will persist value, and updates to this are made part of controller event-stream.
@@ -386,92 +439,64 @@ declare function ref<T>(callback?: ref.Callback<T>): ref.Object<T>;
  * @param ignoreNull - Default `true`. If `false`, will still callback with `null`.
  */
 declare function ref<T>(callback: ref.Callback<T | null>, ignoreNull: boolean): ref.Object<T>;
-
-declare namespace set {
-    type Callback<T, S = any> = (this: S, next: T, previous: T) => ((next: T) => void) | Promise<any> | void | boolean;
-    type Factory<T, S = any> = (this: S, key: string) => Thenable<T> | T;
-    type Thenable<T> = {
-        then: (onFulfilled?: (value: T) => any, onRejected?: (reason: any) => any) => any;
-    };
-}
-/**
- * Set property as `undefined` but required.
- *
- * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid
- * `Promise`/`Error` (aka: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
- */
-declare function set<T = any>(): T;
-/**
- * Set property with a factory function.
- *
- * **Note** Factory is lazy! It will only run if/when property is accessed.
- * Value will be undefined until factory resolves, which will also dispatch an update for the property.
- */
-declare function set<T>(factory: set.Factory<T> | set.Thenable<T>, required: false): T | undefined;
-/**
- * Set property with a factory function.
- *
- * If async, property cannot be accessed until resolves, yeilding a result.
- * If accessed while still processing, React Suspense will be thrown.
- *
- * @param factory - Callback run to derrive property value.
- * @param required - If true run factory immediately on creation, otherwise on access.
- */
-declare function set<T>(factory: set.Factory<T> | set.Thenable<T>, required?: boolean): T;
-/**
- * Set property with a factory function.
- *
- * If async, property cannot be accessed until resolves, yeilding a result.
- * If accessed while still processing, React Suspense will be thrown.
- *
- * @param factory - Callback run to derrive property value.
- * @param onUpdate - Callback run when property is finished computing or is set.
- */
-declare function set<T>(factory: set.Factory<T> | set.Thenable<T>, onUpdate?: set.Callback<T>): T;
-/**
- * Set a property with empty placeholder and/or update callback.
- *
- * @param value - Starting value for property. If undefined, suspense will be thrown on access, until value is set and accepted by callback.
- * @param onUpdate - Callback run when property is set. If returns false, update is not accepted and property will keep previous value.
- */
-declare function set<T>(value: T | undefined, onUpdate?: set.Callback<T>): T;
-
-declare function use<T>(instruction: Model.Instruction<T>): T extends void ? unknown : T;
-declare function use<T extends Model>(Type: Model.Init<T>, required: false): T | undefined;
-declare function use<T extends Model>(Type: Model.Init<T>, ready?: (i: T) => void): T;
-
-declare namespace has {
-    type Callback<T = any> = (model: T, recipient: Model) => void | boolean | (() => void);
-}
-declare function has<T extends Model>(type: Model.Type<T>, callback?: has.Callback<T>): readonly T[];
-declare function has(callback?: has.Callback): readonly Model[];
-
+//#endregion
+//#region src/context.d.ts
 declare namespace Context {
-    type Multiple<T extends Model> = {
-        [key: string | number]: Model.Init<T> | T;
-    };
-    type Accept<T extends Model = Model> = T | Model.Init<T> | Multiple<T>;
-    type Expect<T extends Model = Model> = (model: T) => (() => void) | void;
+  type Multiple<T extends State> = {
+    [key: string | number]: State.Type<T> | T;
+  };
+  type Accept<T extends State = State> = T | State.Type<T> | Multiple<T>;
+  type Expect<T extends State = State> = (state: T) => (() => void) | void;
 }
 interface Context {
-    [key: symbol]: Model | Context.Expect | null | undefined;
+  [key: symbol]: State | Context.Expect | null | undefined;
 }
 declare class Context {
-    static get<T extends Model>(on: Model, callback: ((got: Context) => void)): void;
-    static get<T extends Model>(on: Model): Context | undefined;
-    id: string;
-    protected layer: Map<string | number, Model | Model.Type<Model>>;
-    protected cleanup: Set<() => void>;
-    constructor(inputs?: Context.Accept);
-    /** Run callback when a specified type is registered to a **child** context. */
-    has<T extends Model>(Type: Model.Type<T>, callback: (model: T) => void): void;
-    /** Find specified type registered to a parent context. Returns undefined if none are found. */
-    get<T extends Model>(Type: Model.Type<T>, require: true): T;
-    get<T extends Model>(Type: Model.Type<T>, require?: boolean): T | undefined;
-    push(inputs?: Context.Accept): this;
-    pop(): void;
-    include<T extends Model>(inputs: Context.Accept<T>, forEach?: Context.Expect<T>): void;
-    protected add<T extends Model>(input: T | Model.Init<T>, implicit?: boolean): T;
+  /**
+   * Get the context for a specified State. If a callback is provided, it will be run when
+   * the context becomes available.
+   */
+  static get<T extends State>(on: State, callback: (got: Context) => void): void;
+  /**
+   * Get the context for a specified State. Returns undefined if none are found.
+   */
+  static get<T extends State>(on: State): Context | undefined;
+  id: string;
+  protected inputs: Record<string | number, State | State.Extends>;
+  protected cleanup: Set<() => void>;
+  constructor(inputs?: Context.Accept);
+  /** Find specified type registered to a parent context. Throws if none are found. */
+  get<T extends State>(Type: State.Extends<T>, require: true): T;
+  /** Find specified type registered to a parent context. Returns undefined if none are found. */
+  get<T extends State>(Type: State.Extends<T>, require?: boolean): T | undefined;
+  /** Run callback when a specified type is registered in context downstream. */
+  get<T extends State>(Type: State.Extends<T>, callback: (state: T) => void): () => void;
+  /**
+   * Adds a State to this context.
+   */
+  protected add<T extends State>(input: T | State.Type<T>, implicit?: boolean): T;
+  /**
+   * Register one or more States to this context.
+   *
+   * Context will add or remove States as needed to keep with provided input.
+   *
+   * @param inputs State, State class, or map of States / State classes to register.
+   * @param forEach Optional callback to run for each State registered.
+   */
+  use<T extends State>(inputs: Context.Accept<T>, forEach?: Context.Expect<T>): void;
+  /**
+   * Create a child context, optionally registering one or more States to it.
+   *
+   * @param inputs State, State class, or map of States / State classes to register.
+   */
+  push(inputs?: Context.Accept): this;
+  /**
+   * Remove all States from this context.
+   *
+   * Will also run any cleanup callbacks registered when States were added.
+   */
+  pop(): void;
 }
-
-export { Context, METHOD, Model, Observable, addListener, createEffect, Model as default, event, get, has, ref, set, use };
+//#endregion
+export { Context, type Instruction, METHOD, Observable, State, State as default, addListener, event, get, ref, set, use, watch };
+//# sourceMappingURL=index.d.ts.map