@expressive/mvc 0.18.1 → 0.19.2

package/lib/index.d.ts

@@ -1,13 +1,43 @@
-declare const LOCAL = "$debug local";
-declare const STATE = "$debug state";
-declare const UPDATE = "$debug update";
-declare const CONTROL = "$debug controller";
+declare namespace Issue {
+    type Variable = {} | string | number | boolean | null | undefined;
+    type Variables<T> = T extends (...args: infer T) => any ? T : never;
+    type Messages = {
+        [named: string]: (...args: Variable[]) => string;
+    };
+    type Output<M extends Messages> = {
+        readonly [P in keyof M]: (...args: Variables<M[P]>) => Issue;
+    };
+}
+declare class Issue extends Error {
+    stack: string;
+    warn(): void;
+}
+declare function issues<M extends Issue.Messages>(register: M): Issue.Output<M>;
+
+declare const LOCAL = "__local";
+declare const STATE = "__state";
+declare const UPDATE = "__update";
+declare const CONTROL = "__control";
 declare const Debug: {
-    readonly CONTROL: "$debug controller";
-    readonly LOCAL: "$debug local";
-    readonly STATE: "$debug state";
-    readonly UPDATE: "$debug update";
+    /** Use to access Model's local Subscriber (if exists). */
+    LOCAL: "__local";
+    /** Use to access snapshot of Model's current state. */
+    STATE: "__state";
+    /**
+     * Use to access snapshot of Model's latest update.
+     *
+     * Note: If used within a Subscriber, update will be narrowed to the specific keys
+     * which triggered a refresh (if one did).
+     */
+    UPDATE: "__update";
+    /** Use to access a Model's controller. */
+    CONTROL: "__control";
 };
+/**
+ * Generic will declare debug properties on a given Model.
+ *
+ * These properties always exist at runtime, however are hidden unless you cast your Model as `Debug<T>`.
+ */
 type Debug<T extends Model> = T & {
     /** Controller for this instance. */
     [CONTROL]?: Control<T>;
@@ -28,24 +58,19 @@ type Callback = () => void;
 type Class = new (...args: any[]) => any;
 type InstanceOf<T> = T extends { prototype: infer U } ? U : never;
 
+type MaybePromise<T> = T | Promise<T>;
+
 /** Type may not be undefined - instead will be null.  */
 type NoVoid<T> = T extends undefined ? null : T;
 
-type OptionalValues<T extends {}> = {
-  [P in Model.Key<T>]: T[P] | undefined;
-}
-
-type NonOptionalValues<T extends {}> = {
-  [P in Model.Key<T>]: Exclude<T[P], undefined>;
-};
-
 declare namespace Model {
     export { Control };
     export { Subscriber };
     /** Including but not limited to T. */
     type Extends<T> = T | (string & Record<never, never>);
     /** Any typeof Model, using class constructor as the reference. */
-    export type Type<T extends Model = Model> = (abstract new (...args: any[]) => T);
+    export type Type<T extends Model = Model> = abstract new () => T;
+    export type Class<T extends Model> = (abstract new () => T) & typeof Model;
     /** A typeof Model, specifically one which may be created without arguments. */
     export type New<T extends Model = Model> = (new () => T) & typeof Model;
     export type Effect<T> = (this: T, argument: T) => Callback | Promise<any> | void;
@@ -95,7 +120,7 @@ declare namespace Model {
         [P in Key<T>]: Value<T[P]>;
     };
     export type FindFunction = <T extends Model>(type: Model.Type<T>, relativeTo: Model, required: boolean) => (_refresh: (x: T) => void) => T | undefined;
-    export type TapCallback<T extends Model, R> = (this: T, model: T, update: ForceUpdate) => R;
+    export type GetCallback<T extends Model, R> = (this: T, model: T, update: ForceUpdate) => R;
     type ForceUpdate = {
         /** Force an update in current component. */
         (): void;
@@ -119,7 +144,9 @@ declare class Model {
      * Use to obtain full reference from a destructure.
      */
     is: this;
-    constructor();
+    /** Unique identifier for Model instance. */
+    id: string;
+    constructor(id?: string);
     on<P extends Model.Event<this>>(keys?: P | Iterable<P>, timeout?: number): Promise<P[]>;
     on<P extends Model.Event<this>>(keys: P | Iterable<P>, listener: (this: this, keys: Model.Event<this>[]) => void, once?: boolean): Callback;
     on(effect: Model.Effect<this>): Callback;
@@ -130,15 +157,15 @@ declare class Model {
     on(current: true): Promise<Model.Event<this>[]>;
     on(current: null): Promise<null>;
     get(): Model.Export<this>;
-    get<P extends Model.Key<this>>(property: P): this[P];
-    get<P extends Model.Key<this>>(property: P, timeout: number): Promise<this[P]>;
-    get<P extends Model.Key<this>>(property: P, onChange: true): Promise<this[P]>;
-    get<P extends Model.Key<this>>(property: P, onChange: boolean): this[P] | Promise<this[P]>;
-    get<P extends Model.Key<this>>(property: P, listener: (this: this, value: this[P], key: P[]) => void): Callback;
+    get<P extends Model.Key<this>>(select: P): this[P];
     get<P extends Model.Key<this>>(select: Iterable<P>): Model.Get<this, P>;
+    get<P extends Model.Key<this>>(select: P, timeout: number): Promise<this[P]>;
     get<P extends Model.Key<this>>(select: Iterable<P>, timeout: number): Promise<Model.Get<this, P>>;
+    get<P extends Model.Key<this>>(select: P, onChange: true): Promise<this[P]>;
     get<P extends Model.Key<this>>(select: Iterable<P>, onChange: true): Promise<Model.Get<this, P>>;
-    get<P extends Model.Key<this>>(select: Iterable<P>, onChange: boolean): Model.Get<this, P> | Promise<Model.Get<this, P>>;
+    get<P extends Model.Key<this>>(select: P, onChange: boolean): MaybePromise<this[P]>;
+    get<P extends Model.Key<this>>(select: Iterable<P>, onChange: boolean): MaybePromise<Model.Get<this, P>>;
+    get<P extends Model.Key<this>>(select: P, listener: (this: this, value: this[P], key: P[]) => void): Callback;
     get<P extends Model.Key<this>>(select: Iterable<P>, listener: (this: this, value: Model.Get<this, P>, key: P[]) => void): Callback;
     set(key: Model.Event<this>): PromiseLike<readonly Model.Event<this>[]>;
     set<K extends Model.Event<this>>(key: Model.Event<this>, value: Model.ValueOf<this, K>): PromiseLike<readonly Model.Event<this>[]>;
@@ -154,29 +181,22 @@ declare class Model {
      * @param args - arguments sent to constructor
      */
     static new<T extends Class>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
+    static find<T extends Model>(this: Model.Type<T>, required?: boolean): T;
+    static find<T extends Model>(this: Model.Type<T>, required: false): T | undefined;
+    static get<T extends Model>(this: Model.Type<T>): T;
+    static get<T extends Model>(this: Model.Type<T>, passive: true): T;
+    static get<T extends Model>(this: Model.Type<T>, required: false): T | undefined;
+    static get<T extends Model, R extends []>(this: Model.Type<T>, compute: Model.GetCallback<T, R | (() => R)>, expect?: boolean): R;
+    static get<T extends Model, R extends []>(this: Model.Type<T>, compute: Model.GetCallback<T, Promise<R> | (() => R) | null>, expect?: boolean): R | null;
+    static get<T extends Model, R extends []>(this: Model.Type<T>, compute: Model.GetCallback<T, Promise<R> | R>, expect: true): Exclude<R, undefined>;
+    static get<T extends Model, R>(this: Model.Type<T>, init: Model.GetCallback<T, () => R>): NoVoid<R>;
+    static get<T extends Model, R>(this: Model.Type<T>, init: Model.GetCallback<T, (() => R) | null>): NoVoid<R> | null;
+    static get<T extends Model, R>(this: Model.Type<T>, compute: Model.GetCallback<T, Promise<R> | R>, expect: true): Exclude<R, undefined>;
+    static get<T extends Model, R>(this: Model.Type<T>, compute: Model.GetCallback<T, Promise<R>>, expect?: boolean): NoVoid<R> | null;
+    static get<T extends Model, R>(this: Model.Type<T>, compute: Model.GetCallback<T, R>, expect?: boolean): NoVoid<R>;
     static use<I extends Model>(this: Model.Type<I>, watch: Model.Key<I>[], callback?: (instance: I) => void): I;
     static use<I extends Model>(this: Model.Type<I>, callback?: (instance: I) => void): I;
     static use<I extends Model>(this: Model.Type<I>, apply: Model.Compat<I>, keys?: Model.Event<I>[]): I;
-    static get<T extends Model>(this: Model.Type<T>, required?: boolean): T;
-    static get<T extends Model>(this: Model.Type<T>, required: false): T | undefined;
-    static tap<T extends Model>(this: Model.Type<T>): T;
-    static tap<T extends Model, R extends readonly unknown[] | []>(this: Model.Type<T>, compute: Model.TapCallback<T, R | (() => R)>, expect?: boolean): R;
-    static tap<T extends Model, R extends readonly unknown[] | []>(this: Model.Type<T>, compute: Model.TapCallback<T, Promise<R> | (() => R) | null>, expect?: boolean): R | null;
-    static tap<T extends Model, R extends readonly unknown[] | []>(this: Model.Type<T>, compute: Model.TapCallback<T, Promise<R> | R>, expect: true): Exclude<R, undefined>;
-    static tap<T extends Model, R>(this: Model.Type<T>, init: Model.TapCallback<T, () => R>): NoVoid<R>;
-    static tap<T extends Model, R>(this: Model.Type<T>, init: Model.TapCallback<T, (() => R) | null>): NoVoid<R> | null;
-    static tap<T extends Model, R>(this: Model.Type<T>, compute: Model.TapCallback<T, Promise<R> | R>, expect: true): Exclude<R, undefined>;
-    static tap<T extends Model, R>(this: Model.Type<T>, compute: Model.TapCallback<T, Promise<R>>, expect?: boolean): NoVoid<R> | null;
-    static tap<T extends Model, R>(this: Model.Type<T>, compute: Model.TapCallback<T, R>, expect?: boolean): NoVoid<R>;
-    static tap<T extends Model>(this: Model.Type<T>, expect: true): NonOptionalValues<T>;
-    static tap<T extends Model>(this: Model.Type<T>, expect?: boolean): OptionalValues<T>;
-    protected static meta<T extends Class>(this: T): T;
-    protected static meta<T extends Class>(this: T, expect: true): NonOptionalValues<T>;
-    protected static meta<T extends Class>(this: T, expect?: boolean): OptionalValues<T>;
-    protected static meta<T, M extends Class>(this: M, from: (this: M, state: M) => Promise<T>, expect: true): Exclude<T, undefined>;
-    protected static meta<T, M extends Class>(this: M, from: (this: M, state: M) => Promise<T>, expect?: boolean): T;
-    protected static meta<T, M extends Class>(this: M, from: (this: M, state: M) => T, expect: true): Exclude<T, undefined>;
-    protected static meta<T, M extends Class>(this: M, from: (this: M, state: M) => T, expect?: boolean): T;
     /**
      * Static equivalent of `x instanceof this`.
      *
@@ -272,7 +292,7 @@ declare namespace control {
 declare function control<T extends Model>(subject: T): Control<T>;
 declare function control<T extends Model>(subject: T, cb: control.OnReady<T>): Callback;
 
-declare function getParent<T extends Model>(from: Model, type?: Model.Type<T>): T;
+declare function getParent<T extends Model>(from: Model, type?: Model.Class<T>): T;
 
 type Async<T = any> = (...args: any[]) => Promise<T>;
 /**
@@ -295,7 +315,7 @@ declare function run<S>(action: Async<S>): typeof action & {
 declare namespace get {
     type Function<T, S = any> = (this: S, on: S) => T;
     type Factory<R, T> = (this: T, property: string, on: T) => Function<R, T>;
-    type FindFunction<T extends Model = Model> = (type: typeof Model, relativeTo: Model, required: boolean) => Source<T>;
+    type FindFunction<T extends Model = Model> = (type: Model.Class<T>, relativeTo: Model, required: boolean) => Source<T>;
     type Source<T extends Model = Model> = (callback: (x: T) => void) => void;
     /** Assign fetch algorithm for get instruction. */
     let using: (fn: FindFunction) => typeof get;
@@ -479,4 +499,4 @@ declare const Internal: {
     getParent: typeof getParent;
 };
 
-export { Control, Debug, Internal, Model, Register, Subscriber, add, Model as default, get, ref, run, set, use };
+export { Control, Debug, Internal, Model, Register, Subscriber, add, Model as default, get, issues, ref, run, set, use };

package/lib/index.esm.js

@@ -1,4 +1,8 @@
-const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
+const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
+/** Random alphanumberic of length 6; will always start with a letter. */
+function random() {
+    return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
+}
 
 class Issue extends Error {
     constructor() {
@@ -136,20 +140,17 @@ function createEffect(model, callback, keys) {
     return control(model, controller => {
         let unSet;
         let busy = false;
-        function effect(value) {
-            if (typeof unSet == "function")
-                unSet();
-            unSet = callback.call(this, value);
-            if (unSet instanceof Promise)
-                unSet = undefined;
-            if (unSet && typeof unSet !== "function")
-                throw Oops$7.BadCallback();
-        }
         function invoke() {
             if (busy)
                 return;
             const output = mayRetry(() => {
-                effect.call(model, model);
+                if (typeof unSet == "function")
+                    unSet();
+                unSet = callback.call(model, model);
+                if (unSet instanceof Promise)
+                    unSet = undefined;
+                if (unSet && typeof unSet !== "function")
+                    throw Oops$7.BadCallback();
             });
             if (output instanceof Promise) {
                 output.finally(() => busy = false);
@@ -281,9 +282,10 @@ const Oops$5 = issues({
     NoAdapter: (method) => `Can't call Model.${method} without an adapter.`
 });
 class Model {
-    constructor() {
+    constructor(id) {
         new Control(this);
         defineProperty(this, "is", { value: this });
+        defineProperty(this, "id", { value: id || random() });
     }
     on(arg1, arg2, arg3) {
         if (typeof arg1 == "function")
@@ -313,14 +315,7 @@ class Model {
     set(arg1, arg2) {
         const controller = control(this);
         const { state } = controller;
-        if (typeof arg1 == "object")
-            for (const key in arg1) {
-                if (arg2 === true || (arg2 ? arg2.includes(key) : state.has(key))) {
-                    state.set(key, arg1[key]);
-                    controller.update(key);
-                }
-            }
-        else if (typeof arg1 == "string") {
+        if (typeof arg1 == "string") {
             controller.update(arg1);
             if (1 in arguments) {
                 if (state.has(arg1))
@@ -332,6 +327,12 @@ class Model {
                 }
             }
         }
+        else if (typeof arg1 == "object")
+            for (const key in arg1)
+                if (arg2 === true || (arg2 ? arg2.includes(key) : state.has(key))) {
+                    state.set(key, arg1[key]);
+                    controller.update(key);
+                }
         return {
             then: (callback) => {
                 if (!callback)
@@ -356,17 +357,14 @@ class Model {
         control(instance);
         return instance;
     }
-    static use() {
-        throw Oops$5.NoAdapter("use");
+    static find() {
+        throw Oops$5.NoAdapter("find");
     }
     static get() {
         throw Oops$5.NoAdapter("get");
     }
-    static tap() {
-        throw Oops$5.NoAdapter("tap");
-    }
-    static meta() {
-        throw Oops$5.NoAdapter("meta");
+    static use() {
+        throw Oops$5.NoAdapter("use");
     }
     /**
      * Static equivalent of `x instanceof this`.
@@ -379,8 +377,14 @@ class Model {
     }
 }
 defineProperty(Model.prototype, "toString", {
+    configurable: true,
     value() {
-        return this.constructor.name;
+        return `${this.constructor.name}-${this.id}`;
+    }
+});
+defineProperty(Model, "toString", {
+    value() {
+        return this.name;
     }
 });
 
@@ -418,7 +422,7 @@ function add(instruction, label) {
 
 const Oops$4 = issues({
     PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or get) as computed source for ${model}.${property}. This is not allowed.`,
-    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`,
+    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} ${parent}.${property}.`,
     Required: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
 });
 function get(arg0, arg1) {
@@ -435,8 +439,8 @@ function get(arg0, arg1) {
         else if (typeof arg0 == "function")
             arg1 = arg0.call(subject, key, subject);
         return typeof arg1 == "function"
-            ? getComputed(key, this, source, arg1)
-            : getRecursive$1(key, this, source, arg1);
+            ? computed(this, key, source, arg1)
+            : recursive(this, key, source, arg1);
     });
 }
 function getParentForGetInstruction(type, relativeTo, required) {
@@ -445,54 +449,26 @@ function getParentForGetInstruction(type, relativeTo, required) {
         if (item)
             callback(item);
         else if (required)
-            throw Oops$4.Required(type.name, relativeTo);
+            throw Oops$4.Required(type, relativeTo.constructor);
     };
 }
-function getRecursive$1(key, parent, source, required) {
-    const context = new WeakMap();
-    const { state } = parent;
+function recursive(parent, key, source, required) {
+    const getter = getRecursive(key, parent);
     let waiting;
     source((got) => {
-        state.set(key, got);
+        parent.state.set(key, got);
         if (waiting)
             parent.update(key);
     });
     waiting = true;
-    function create(local) {
-        let reset;
-        local.follow(key, init);
-        init();
-        function init() {
-            if (reset)
-                reset();
-            const value = state.get(key);
-            if (value && controller(value)) {
-                const child = new Subscriber(value, local.onUpdate);
-                if (local.active)
-                    child.commit();
-                local.dependant.add(child);
-                context.set(local, child.proxy);
-                reset = () => {
-                    child.release();
-                    local.dependant.delete(child);
-                    context.set(local, undefined);
-                    reset = undefined;
-                };
-            }
-        }
-    }
     return (local) => {
-        const value = state.get(key);
+        const value = parent.state.get(key);
         if (!value && required !== false)
             parent.waitFor(key);
-        if (!local)
-            return value;
-        if (!context.has(local))
-            create(local);
-        return context.get(local);
+        return local ? getter(local) : value;
     };
 }
-function getComputed(key, parent, source, setter) {
+function computed(parent, key, source, setter) {
     const { state } = parent;
     let local;
     let active;
@@ -553,7 +529,7 @@ function getComputed(key, parent, source, setter) {
 const INFO = new WeakMap();
 const KEYS = new WeakMap();
 const ORDER = new WeakMap();
-function flush(control) {
+function flushComputed(control) {
     const pending = KEYS.get(control);
     if (!pending || !pending.size)
         return;
@@ -647,7 +623,7 @@ class Control {
             return;
         else if (!frame.size)
             setTimeout(() => {
-                flush(this);
+                flushComputed(this);
                 const keys = this.latest = Array.from(frame);
                 setTimeout(() => this.latest = undefined, 0);
                 frame.clear();
@@ -706,21 +682,19 @@ function control(subject, cb) {
 
 const Parent = new WeakMap();
 const Oops$3 = issues({
-    BadAssignment: (parent, expected, got) => `Property ${parent} expected Model of type ${expected} but got ${got}.`,
+    BadAssignment: (parent, expected, got) => `${parent} expected Model of type ${expected} but got ${got}.`,
     Unexpected: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
 });
 function getParent(from, type) {
     const value = Parent.get(from);
     if (value && type && !(value instanceof type))
-        throw Oops$3.Unexpected(type.name, from, value);
+        throw Oops$3.Unexpected(type, from, value);
     return value;
 }
 function getRecursive(key, from) {
     const context = new WeakMap();
     const { state } = from;
     return (local) => {
-        if (!local)
-            return state.get(key);
         if (!context.has(local)) {
             let reset;
             const init = () => {
@@ -754,8 +728,9 @@ function setRecursive(controller, key, initial) {
     const onUpdate = (next) => {
         state.set(key, next);
         if (!(next instanceof Type))
-            throw Oops$3.BadAssignment(`${subject}.${key}`, Type.name, String(next));
-        get = getRecursive(key, controller);
+            throw Oops$3.BadAssignment(`${subject}.${key}`, Type, String(next));
+        const getter = getRecursive(key, controller);
+        get = (local) => local ? getter(local) : state.get(key);
         Parent.set(next, subject);
         control(next);
         return true;
@@ -1107,7 +1082,8 @@ function use(input, argument) {
         const onUpdate = (next) => {
             state.set(key, next);
             if (next) {
-                get = getRecursive(key, this);
+                const getter = getRecursive(key, this);
+                get = (local) => local ? getter(local) : state.get(key);
                 Parent.set(next, subject);
                 control(next);
             }
@@ -1163,10 +1139,10 @@ function use(input, argument) {
     });
 }
 
-const LOCAL = "$debug local";
-const STATE = "$debug state";
-const UPDATE = "$debug update";
-const CONTROL = "$debug controller";
+const LOCAL = "__local";
+const STATE = "__state";
+const UPDATE = "__update";
+const CONTROL = "__control";
 defineProperties(Model.prototype, {
     [CONTROL]: {
         get() {
@@ -1262,4 +1238,4 @@ const Internal = {
     getParent
 };
 
-export { Control, Debug, Internal, Model, Register, Subscriber, add, Model as default, get, ref, run, set, use };
+export { Control, Debug, Internal, Model, Register, Subscriber, add, Model as default, get, issues, ref, run, set, use };

package/lib/index.js

@@ -2,7 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
+const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
+/** Random alphanumberic of length 6; will always start with a letter. */
+function random() {
+    return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
+}
 
 class Issue extends Error {
     constructor() {
@@ -140,20 +144,17 @@ function createEffect(model, callback, keys) {
     return control(model, controller => {
         let unSet;
         let busy = false;
-        function effect(value) {
-            if (typeof unSet == "function")
-                unSet();
-            unSet = callback.call(this, value);
-            if (unSet instanceof Promise)
-                unSet = undefined;
-            if (unSet && typeof unSet !== "function")
-                throw Oops$7.BadCallback();
-        }
         function invoke() {
             if (busy)
                 return;
             const output = mayRetry(() => {
-                effect.call(model, model);
+                if (typeof unSet == "function")
+                    unSet();
+                unSet = callback.call(model, model);
+                if (unSet instanceof Promise)
+                    unSet = undefined;
+                if (unSet && typeof unSet !== "function")
+                    throw Oops$7.BadCallback();
             });
             if (output instanceof Promise) {
                 output.finally(() => busy = false);
@@ -285,9 +286,10 @@ const Oops$5 = issues({
     NoAdapter: (method) => `Can't call Model.${method} without an adapter.`
 });
 class Model {
-    constructor() {
+    constructor(id) {
         new Control(this);
         defineProperty(this, "is", { value: this });
+        defineProperty(this, "id", { value: id || random() });
     }
     on(arg1, arg2, arg3) {
         if (typeof arg1 == "function")
@@ -317,14 +319,7 @@ class Model {
     set(arg1, arg2) {
         const controller = control(this);
         const { state } = controller;
-        if (typeof arg1 == "object")
-            for (const key in arg1) {
-                if (arg2 === true || (arg2 ? arg2.includes(key) : state.has(key))) {
-                    state.set(key, arg1[key]);
-                    controller.update(key);
-                }
-            }
-        else if (typeof arg1 == "string") {
+        if (typeof arg1 == "string") {
             controller.update(arg1);
             if (1 in arguments) {
                 if (state.has(arg1))
@@ -336,6 +331,12 @@ class Model {
                 }
             }
         }
+        else if (typeof arg1 == "object")
+            for (const key in arg1)
+                if (arg2 === true || (arg2 ? arg2.includes(key) : state.has(key))) {
+                    state.set(key, arg1[key]);
+                    controller.update(key);
+                }
         return {
             then: (callback) => {
                 if (!callback)
@@ -360,17 +361,14 @@ class Model {
         control(instance);
         return instance;
     }
-    static use() {
-        throw Oops$5.NoAdapter("use");
+    static find() {
+        throw Oops$5.NoAdapter("find");
     }
     static get() {
         throw Oops$5.NoAdapter("get");
     }
-    static tap() {
-        throw Oops$5.NoAdapter("tap");
-    }
-    static meta() {
-        throw Oops$5.NoAdapter("meta");
+    static use() {
+        throw Oops$5.NoAdapter("use");
     }
     /**
      * Static equivalent of `x instanceof this`.
@@ -383,8 +381,14 @@ class Model {
     }
 }
 defineProperty(Model.prototype, "toString", {
+    configurable: true,
     value() {
-        return this.constructor.name;
+        return `${this.constructor.name}-${this.id}`;
+    }
+});
+defineProperty(Model, "toString", {
+    value() {
+        return this.name;
     }
 });
 
@@ -422,7 +426,7 @@ function add(instruction, label) {
 
 const Oops$4 = issues({
     PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or get) as computed source for ${model}.${property}. This is not allowed.`,
-    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`,
+    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} ${parent}.${property}.`,
     Required: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
 });
 function get(arg0, arg1) {
@@ -439,8 +443,8 @@ function get(arg0, arg1) {
         else if (typeof arg0 == "function")
             arg1 = arg0.call(subject, key, subject);
         return typeof arg1 == "function"
-            ? getComputed(key, this, source, arg1)
-            : getRecursive$1(key, this, source, arg1);
+            ? computed(this, key, source, arg1)
+            : recursive(this, key, source, arg1);
     });
 }
 function getParentForGetInstruction(type, relativeTo, required) {
@@ -449,54 +453,26 @@ function getParentForGetInstruction(type, relativeTo, required) {
         if (item)
             callback(item);
         else if (required)
-            throw Oops$4.Required(type.name, relativeTo);
+            throw Oops$4.Required(type, relativeTo.constructor);
     };
 }
-function getRecursive$1(key, parent, source, required) {
-    const context = new WeakMap();
-    const { state } = parent;
+function recursive(parent, key, source, required) {
+    const getter = getRecursive(key, parent);
     let waiting;
     source((got) => {
-        state.set(key, got);
+        parent.state.set(key, got);
         if (waiting)
             parent.update(key);
     });
     waiting = true;
-    function create(local) {
-        let reset;
-        local.follow(key, init);
-        init();
-        function init() {
-            if (reset)
-                reset();
-            const value = state.get(key);
-            if (value && controller(value)) {
-                const child = new Subscriber(value, local.onUpdate);
-                if (local.active)
-                    child.commit();
-                local.dependant.add(child);
-                context.set(local, child.proxy);
-                reset = () => {
-                    child.release();
-                    local.dependant.delete(child);
-                    context.set(local, undefined);
-                    reset = undefined;
-                };
-            }
-        }
-    }
     return (local) => {
-        const value = state.get(key);
+        const value = parent.state.get(key);
         if (!value && required !== false)
             parent.waitFor(key);
-        if (!local)
-            return value;
-        if (!context.has(local))
-            create(local);
-        return context.get(local);
+        return local ? getter(local) : value;
     };
 }
-function getComputed(key, parent, source, setter) {
+function computed(parent, key, source, setter) {
     const { state } = parent;
     let local;
     let active;
@@ -557,7 +533,7 @@ function getComputed(key, parent, source, setter) {
 const INFO = new WeakMap();
 const KEYS = new WeakMap();
 const ORDER = new WeakMap();
-function flush(control) {
+function flushComputed(control) {
     const pending = KEYS.get(control);
     if (!pending || !pending.size)
         return;
@@ -651,7 +627,7 @@ class Control {
             return;
         else if (!frame.size)
             setTimeout(() => {
-                flush(this);
+                flushComputed(this);
                 const keys = this.latest = Array.from(frame);
                 setTimeout(() => this.latest = undefined, 0);
                 frame.clear();
@@ -710,21 +686,19 @@ function control(subject, cb) {
 
 const Parent = new WeakMap();
 const Oops$3 = issues({
-    BadAssignment: (parent, expected, got) => `Property ${parent} expected Model of type ${expected} but got ${got}.`,
+    BadAssignment: (parent, expected, got) => `${parent} expected Model of type ${expected} but got ${got}.`,
     Unexpected: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
 });
 function getParent(from, type) {
     const value = Parent.get(from);
     if (value && type && !(value instanceof type))
-        throw Oops$3.Unexpected(type.name, from, value);
+        throw Oops$3.Unexpected(type, from, value);
     return value;
 }
 function getRecursive(key, from) {
     const context = new WeakMap();
     const { state } = from;
     return (local) => {
-        if (!local)
-            return state.get(key);
         if (!context.has(local)) {
             let reset;
             const init = () => {
@@ -758,8 +732,9 @@ function setRecursive(controller, key, initial) {
     const onUpdate = (next) => {
         state.set(key, next);
         if (!(next instanceof Type))
-            throw Oops$3.BadAssignment(`${subject}.${key}`, Type.name, String(next));
-        get = getRecursive(key, controller);
+            throw Oops$3.BadAssignment(`${subject}.${key}`, Type, String(next));
+        const getter = getRecursive(key, controller);
+        get = (local) => local ? getter(local) : state.get(key);
         Parent.set(next, subject);
         control(next);
         return true;
@@ -1111,7 +1086,8 @@ function use(input, argument) {
         const onUpdate = (next) => {
             state.set(key, next);
             if (next) {
-                get = getRecursive(key, this);
+                const getter = getRecursive(key, this);
+                get = (local) => local ? getter(local) : state.get(key);
                 Parent.set(next, subject);
                 control(next);
             }
@@ -1167,10 +1143,10 @@ function use(input, argument) {
     });
 }
 
-const LOCAL = "$debug local";
-const STATE = "$debug state";
-const UPDATE = "$debug update";
-const CONTROL = "$debug controller";
+const LOCAL = "__local";
+const STATE = "__state";
+const UPDATE = "__update";
+const CONTROL = "__control";
 defineProperties(Model.prototype, {
     [CONTROL]: {
         get() {
@@ -1275,6 +1251,7 @@ exports.Subscriber = Subscriber;
 exports.add = add;
 exports["default"] = Model;
 exports.get = get;
+exports.issues = issues;
 exports.ref = ref;
 exports.run = run;
 exports.set = set;

package/package.json

@@ -37,5 +37,5 @@
     "tslib": "^2.3.0",
     "typescript": "^4.9.5"
   },
-  "version": "0.18.1"
+  "version": "0.19.2"
 }