@expressive/mvc 0.87.0 → 0.88.0

package/dist/state.d.ts

@@ -1,6 +1,5 @@
 import { Context } from "./context.js";
 import { event } from "./observable.js";
-import { Caught } from "./caught.js";
 
 //#region src/state.d.ts
 /** Internal state assigned to states. */
@@ -9,7 +8,16 @@ declare const STORE: WeakMap<State, Record<string | number | symbol, unknown>>;
  *  Also carries work to run at the deadline, which `def` uses to bound its registry. */
 declare const PENDING: Set<State | (() => void)>;
 /** External lifecycle listeners for any given State class. */
-type Handler = State.Init<any> | State.On<any>;
+type Handler = State.On<any>;
+declare const SETUP: WeakMap<State.Extends<State>, Set<Handler>>;
+/** Reference bound instance methods, or their getter, to real one. */
+declare const UNBIND: WeakMap<any, any>;
+/** List of methods defined by a given type. */
+declare const METHODS: WeakMap<Function, Map<string, (value: any) => void>>;
+/** List of reactive getters defined by a given type. */
+declare const GETTERS: WeakMap<Function, Map<string, () => unknown>>;
+/** Replacement for a getter captured by live computed properties, for hot patching. */
+declare const LATEST: WeakMap<Function, Function>;
 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;
@@ -32,10 +40,7 @@ declare namespace State {
    * will observe). 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;
-  /**
-   * Lifecycle handlers for `State.on`, keyed by when they run. A bare `Init`
-   * function passed to `on` is sugar for `{ before }`.
-   */
+  /** Lifecycle handlers for `State.on`, keyed by when they run. */
   interface On<T extends State = State> {
     /**
      * Per-class setup, run once when the class is first bootstrapped - before
@@ -45,24 +50,32 @@ declare namespace State {
      */
     type?(type: State.Extends<T>): void;
     /**
-     * Per-instance setup, run in the `prepare` phase before `observe` and the
-     * `new()` hook. Equivalent to passing a bare function to `on`. May return a
-     * cleanup, constructor args, or an assign overlay.
+     * Per-instance, once constructed - before own values are observed and
+     * before constructor args and `new()`. May return a cleanup, constructor
+     * args, or an assign overlay.
      */
-    before?(this: T, thisArg: T): void | (() => void) | Promise<void> | Args<T> | Assign<T>;
+    setup?(this: T, self: T): void | (() => void) | Promise<void> | Args<T> | Assign<T>;
     /**
-     * Per-instance setup, run at the `new()` slot - after own values are
-     * observed and constructor args applied. May return a cleanup function.
+     * Per-instance, once ready - after own values are observed, constructor
+     * args applied and `new()` has run. May return a cleanup function.
      */
-    after?(this: T, self: T): void | (() => void);
+    ready?(this: T, self: T): void | (() => void);
     /**
-     * Receives a `Caught` mvc reports for this State or a subclass - most-derived
-     * class first, last registered first. Return it (or a replacement) to pass it
-     * on; return nothing to handle it; throw to let it escape uncaught. Passed off
-     * the end, a warning logs and anything else is thrown - to the writer for a
-     * destroyed write, else uncaught.
+     * Runs each time a method is bound to an instance - first access,
+     * reassignment, and the rebind after a hot patch - with the key, the bound
+     * function and the instance. Tooling and development use.
      */
-    catch?(this: T, error: Caught): Caught | void;
+    method?(this: T, key: string, fn: Function, self: T): void;
+    /**
+     * Receives what an effect, refreshing getter or async initializer of this State
+     * or a subclass threw, a destroyed write, or an instance never activated - with
+     * its `kind` (`effect`, `getter`, `setup`, `dead`, `unused`) and `key` where
+     * one applies. Most-derived class first, last registered first, each once. Return the error
+     * (or another) to pass it on; return nothing to handle it; throw to let it escape.
+     * Passed off the end, a destroyed write outputs nothing, `unused` warns,
+     * anything else escapes uncaught.
+     */
+    catch?(this: T, error: unknown, kind: 'effect' | 'getter' | 'setup' | 'dead' | 'unused', key?: string): unknown;
   }
   /** Object overlay to override values and methods on a state. */
   type Assign<T> = Record<string, unknown> & { [K in Property<T>]?: T[K] extends ((...args: infer A) => infer R) ? (this: T, ...args: A) => R : T[K] };
@@ -210,6 +223,18 @@ declare abstract class State {
    * @returns Function to cancel listener.
    */
   get<T extends State>(type: State.Type<T>, callback: Context.Expect<T>, downstream?: boolean): () => void;
+  /** Owner of this State. Throws if it has none. */
+  get<T extends typeof State>(type: T & (typeof State extends T ? unknown : never), required?: true): State;
+  /** Owner of this State. Undefined if it has none. */
+  get<T extends typeof State>(type: T & (typeof State extends T ? unknown : never), required: boolean): State | undefined;
+  /**
+   * Run a callback for each State this one owns - those owned now, then each
+   * one as it activates. Callback may return a function, called when that State
+   * is destroyed.
+   *
+   * @returns Function to stop watching.
+   */
+  get<T extends typeof State>(type: T & (typeof State extends T ? unknown : never), callback: (child: State) => void | (() => void), downstream: true): () => void;
   /**
    * Get update in progress.
    *
@@ -221,7 +246,7 @@ declare abstract class State {
    * Properties which are not managed by this state will be ignored.
    *
    * @param assign - Object with properties to update.
-   * @param silent - If true, listeners will not be notified. If state is destroyed, drops the update without reporting it.
+   * @param silent - If true, listeners will not be notified. If state is destroyed, stores the update without reporting it.
    * @returns Array of keys updated, syncronously contains keys updated immediately and may be resolved (to itself) when all updates are settled.
    */
   set(assign?: State.Assign<this>, silent?: boolean): State.Updated<this>;
@@ -255,7 +280,7 @@ declare abstract class State {
    */
   set(key: State.Event<this>): State.Updated<this>;
   /**
-   * Declare an end to updates. This event is final and will freeze state.
+   * Declare an end to updates. This event is final - later writes are stored but never dispatched.
    * This event can be watched for as well, to run cleanup logic and internally will remove all listeners.
    *
    * @param status - `null` to end updates.
@@ -304,16 +329,18 @@ declare abstract class State {
   /**
    * Register a lifecycle handler for this State and its subclasses.
    *
-   * A bare function is per-instance setup run in the `prepare` phase (sugar for
-   * `{ before }`); if it returns a function, that runs when the instance is
-   * destroyed. Pass a {@link State.On} object to hook by cadence - `type`
-   * (per-class, at bootstrap), `before` (per-instance, before `new()`), and
-   * `after` (per-instance, at the `new()` slot).
+   * Hooks by cadence - `type` (per-class, at bootstrap), `setup` (per-instance,
+   * before values are observed), `ready` (per-instance, after `new()`), and
+   * `method` (per method binding). A function alone is a `setup` handler. A
+   * function returned from `setup` or `ready` runs when the instance is destroyed.
    *
    * @returns Function to remove the handler.
    */
-  static on<T extends State>(this: State.Extends<T>, handler: State.Init<T> | State.On<T>): () => boolean;
+  static on<T extends State>(this: State.Extends<T>, setup: NonNullable<State.On<T>['setup']>): () => boolean;
+  static on<T extends State>(this: State.Extends<T>, handler: State.On<T>): () => boolean;
 }
+/** Bind own configurable methods of a type and collect its reactive getters. */
+declare function classify(type: State.Extends, keys: Map<string, (value: any) => void>, getters: Map<string, () => unknown>): void;
 /**
  * Install a reactive computed property on a state instance, derived from a prototype
  * getter or an arity-bearing `set` factory.
@@ -344,26 +371,27 @@ declare function trailing(state: State): State[];
  * claimed later. Returns a callback to stop watching.
  */
 declare function children(state: State, callback: (child: State) => void): () => boolean;
+/**
+ * Report States owned by this one - those active now, then each one as it
+ * activates. A function returned by `callback` runs when that State is destroyed.
+ */
+declare function owned(state: State, callback: (child: State) => void | (() => void)): () => undefined;
 declare function access(state: State, property: string, required?: boolean): any;
 /**
  * Update a property on a state instance and notify listeners.
  *
  * This is used internally to update properties, but can also be used to update properties which are not managed by state, or to update values without triggering setters.
  *
- * A destroyed state reports the write - thrown to the writer unless a `catch` handler takes it - and returns `false`; `silent` skips both, and dispatch.
+ * A destroyed state stores the write without dispatch, reports it unless `silent`, and returns `false`.
  */
 declare function update<T>(state: State, key: State.Event<T>, value: T, silent?: boolean, own?: boolean): boolean;
-/** Error thrown by a handler replaying in dispatch, attributed to the State which queued it. */
-declare function fault(err: unknown, owner?: object): void;
-/** Begin tracking live instances, so a hot patch can reach them. */
-declare function track(): void;
 /**
- * Move the members of `next` onto `prev`, which keeps its identity. Returns the
- * live instances of `prev`, each needing a refresh.
+ * Hand a value stored by an owning writer to that property's adopter,
+ * creating one the first time a State is stored there. A property which has
+ * held a State keeps its adopter, so a later non-State value releases the
+ * previous child.
  */
-declare function patch(prev: State.Extends, next: State.Extends, own: Handler[]): State[];
-/** Lifecycle handlers registered on a class itself. */
-declare function handlers(type: State.Extends): Handler[];
+declare function adopt(state: State, key: unknown, value: unknown): void;
 /** Random alphanumberic of length 6; always starts with a letter. */
 declare function uid(): string;
 declare function unbind<T extends Function>(fn: T): T;
@@ -377,5 +405,5 @@ declare function unbind<T extends Function>(fn?: T): T | undefined;
 declare function parent(child: object): State | null | undefined;
 declare function parent(child: object, value: State | null): boolean;
 //#endregion
-export { PENDING, STORE, State, access, apply, children, compute, event, fault, handlers, parent, patch, track, trailing, uid, unbind, update };
+export { GETTERS, type Handler, LATEST, METHODS, PENDING, SETUP, STORE, State, UNBIND, access, adopt, apply, children, classify, compute, event, owned, parent, trailing, uid, unbind, update };
 //# sourceMappingURL=state.d.ts.map

package/dist/state.js

@@ -1,6 +1,6 @@
-import { Caught } from "./caught.js";
+import { REPORT } from "./dispatch.js";
 import { capture, event, listener, observer, queued, touch, watch } from "./observable.js";
-import { Context, join } from "./context.js";
+import { Context, host, join } from "./context.js";
 
 //#region src/state.ts
 const define = Object.defineProperty;
@@ -22,12 +22,6 @@ const METHODS = /* @__PURE__ */ new WeakMap();
 const GETTERS = /* @__PURE__ */ new WeakMap();
 /** Replacement for a getter captured by live computed properties, for hot patching. */
 const LATEST = /* @__PURE__ */ new WeakMap();
-/** Method implementations replaced by a hot patch. */
-const PAST = /* @__PURE__ */ new WeakSet();
-/** Live instances, tracked once hot patching is enabled. */
-let LIVE;
-/** Bootstrapped subclasses of each class, tracked once hot patching is enabled. */
-const SUBCLASSES = /* @__PURE__ */ new WeakMap();
 /** Event every observer treats as watched, forcing a refresh after a hot patch. */
 const REFRESH = Symbol.for("@expressive/mvc.refresh");
 /** Stale flags for compute closures awaiting refresh on next access. */
@@ -40,6 +34,8 @@ let ANNOUNCED = false;
 /** Adopters for managed properties which have held a child State. */
 const ADOPT = /* @__PURE__ */ new WeakMap();
 const CHILDREN = /* @__PURE__ */ new WeakMap();
+const OWNS = /* @__PURE__ */ new WeakMap();
+const OWNED = /* @__PURE__ */ new WeakMap();
 var State = class State {
 	/**
 	* Whether an instance activated with no enclosing context registers itself
@@ -60,7 +56,8 @@ var State = class State {
 	get(arg1, arg2, arg3) {
 		const self = this.is;
 		if (arg1 === void 0) return values(self);
-		if (State.is(arg1)) return Context.get(self).get(arg1, arg2, arg3, self);
+		if (arg1 === State) return typeof arg2 == "function" ? owned(self, arg2) : observed(this, arg1, owner(self, arg2));
+		if (State.is(arg1)) return observed(this, arg1, Context.get(self).get(arg1, arg2, arg3, self));
 		if (typeof arg1 == "function") return watch(self, unbind(arg1));
 		if (typeof arg2 == "function") return callback(self, arg2, arg1);
 		if (arg1 === null) return observer(self) === null;
@@ -105,18 +102,8 @@ var State = class State {
 	static is(maybe) {
 		return maybe === this || typeof maybe == "function" && maybe.prototype instanceof this;
 	}
-	/**
-	* Register a lifecycle handler for this State and its subclasses.
-	*
-	* A bare function is per-instance setup run in the `prepare` phase (sugar for
-	* `{ before }`); if it returns a function, that runs when the instance is
-	* destroyed. Pass a {@link State.On} object to hook by cadence - `type`
-	* (per-class, at bootstrap), `before` (per-instance, before `new()`), and
-	* `after` (per-instance, at the `new()` slot).
-	*
-	* @returns Function to remove the handler.
-	*/
 	static on(handler) {
+		if (typeof handler == "function") handler = { setup: handler };
 		let setup = SETUP.get(this);
 		if (!setup) SETUP.set(this, setup = /* @__PURE__ */ new Set());
 		setup.add(handler);
@@ -129,6 +116,9 @@ define(State.prototype, "toString", { value() {
 define(State, "toString", { value() {
 	return this.name;
 } });
+function observed(from, key, value) {
+	return value instanceof State ? touch(from, key, value) : value;
+}
 /** Register a user OnEvent callback, preserving `this` and `source`. */
 function callback(self, cb, select) {
 	return listener(self, (key) => cb.call(self, key, self), select);
@@ -147,7 +137,6 @@ function init(state, ...args) {
 	const { before, after } = bootstrap(T);
 	ID.set(state, `${T}-${uid()}`);
 	STORE.set(state, {});
-	LIVE?.add(new WeakRef(state));
 	function observe() {
 		for (const key in state) {
 			const desc = Object.getOwnPropertyDescriptor(state, key) || {};
@@ -162,13 +151,20 @@ function init(state, ...args) {
 		const g = type.global;
 		if (!(typeof g == "function" ? g(state) : g)) return;
 		if (!Object.prototype.hasOwnProperty.call(type, "global")) throw new Error(`${state} would register as a global by inheritance alone - re-declare \`static global\` on ${type.name} (\`true\` to keep it, \`false\` to opt out).`);
+		for (let T = type; T !== State; T = Object.getPrototypeOf(T)) {
+			const found = Context.root.get(T, false);
+			if (found && (T === type || found.constructor === T)) throw new Error(`Cannot register ${state} as a global - ${found} already exists in root. Destroy the existing instance first, or provide additional ones via explicit context.`);
+		}
 		return Context.root.add(state);
 	}
 	listener(state, (key) => {
 		const rest = trailing(state);
 		PENDING.delete(state);
 		if (key === null) return null;
-		parent(state, null);
+		if (!PARENT.has(state)) parent(state, host(state) || null);
+		const above = PARENT.get(state);
+		const owns = above && (OWNS.get(above) || OWNS.set(above, /* @__PURE__ */ new Set()).get(above));
+		if (owns) listener(state, () => void owns.delete(state), null);
 		const queue = [
 			...before,
 			observe,
@@ -181,12 +177,16 @@ function init(state, ...args) {
 			for (let i = 0; i < queue.length; i++) {
 				const arg = queue[i];
 				const out = typeof arg == "function" ? arg.call(state, state) : arg;
-				if (out instanceof Promise) out.catch((err) => report(new Caught.Init(state, err)));
+				if (out instanceof Promise) out.catch((err) => report("setup", state, err));
 				else if (Array.isArray(out)) queue.splice(i + 1, 0, ...out);
 				else if (typeof out == "function") listener(state, out, null);
 				else if (typeof out == "object") assign(state, out, true);
 			}
 		});
+		if (owns) {
+			owns.add(state);
+			OWNED.get(above)?.forEach((cb) => cb(state));
+		}
 		let end = rest.length;
 		while (end-- > 0 && PENDING.has(rest[end]));
 		for (let i = 0; i < end; i++) PENDING.delete(rest[i]);
@@ -197,7 +197,7 @@ function init(state, ...args) {
 		queueMicrotask(() => {
 			QUEUED = false;
 			for (const item of PENDING) if (typeof item == "function") item();
-			else report(new Caught.Inactive(item));
+			else report("unused", item, /* @__PURE__ */ new Error(`${item} was constructed but never activated.`));
 			PENDING.clear();
 		});
 	}
@@ -232,10 +232,9 @@ function bootstrap(T) {
 		T = Object.getPrototypeOf(T);
 	}
 	for (const type of chain) {
-		for (const handler of SETUP.get(type) || []) if (typeof handler == "function") before.add(handler);
-		else {
-			if (handler.before) before.add(handler.before);
-			if (handler.after) after.add(handler.after);
+		for (const handler of SETUP.get(type) || []) {
+			if (handler.setup) before.add(handler.setup);
+			if (handler.ready) after.add(handler.ready);
 			if (handler.type) onType.add(handler.type);
 		}
 		if (type === State) continue;
@@ -245,12 +244,6 @@ function bootstrap(T) {
 			continue;
 		}
 		for (const setupType of onType) setupType(type);
-		if (LIVE) {
-			const parent = Object.getPrototypeOf(type);
-			let children = SUBCLASSES.get(parent);
-			if (!children) SUBCLASSES.set(parent, children = /* @__PURE__ */ new Set());
-			children.add(type);
-		}
 		METHODS.set(type, keys = new Map(keys));
 		GETTERS.set(type, getters = new Map(getters));
 		classify(type, keys, getters);
@@ -295,6 +288,7 @@ function classify(type, keys, getters) {
 				writable: true,
 				configurable: true
 			});
+			for (const handler of stages(is.constructor, "method")) handler.call(is, key, bound, is);
 			return bound;
 		}
 		UNBIND.set(bind, value);
@@ -305,6 +299,12 @@ function classify(type, keys, getters) {
 		});
 	}
 }
+/** Handlers of one stage along the class chain - ancestor first, in registration order, each once. */
+function stages(T, key) {
+	const found = T === State ? /* @__PURE__ */ new Set() : stages(Object.getPrototypeOf(T), key);
+	for (const handler of SETUP.get(T) || []) if (handler[key]) found.add(handler[key]);
+	return found;
+}
 /**
 * Install a reactive computed property on a state instance, derived from a prototype
 * getter or an arity-bearing `set` factory.
@@ -339,7 +339,7 @@ function compute(getter, key) {
 				console.warn(`An exception was thrown while initializing ${this}.${key}.`);
 				throw err;
 			}
-			if (!(err instanceof Promise)) report(new Caught.Getter(this, key, err));
+			if (!(err instanceof Promise)) report("getter", this, err, key);
 		}
 		update(this, key, next, !isAsync);
 	};
@@ -461,6 +461,26 @@ function children(state, callback) {
 	set.add(callback);
 	return () => set.delete(callback);
 }
+function owner(state, required) {
+	const found = PARENT.get(state);
+	if (found || required === false) return found || void 0;
+	throw new Error(`${state} has no owner.`);
+}
+/**
+* Report States owned by this one - those active now, then each one as it
+* activates. A function returned by `callback` runs when that State is destroyed.
+*/
+function owned(state, callback) {
+	function each(child) {
+		const done = callback(child);
+		if (typeof done == "function") listener(child, () => void done(), null);
+	}
+	OWNS.get(state)?.forEach(each);
+	let set = OWNED.get(state);
+	if (!set) OWNED.set(state, set = /* @__PURE__ */ new Set());
+	set.add(each);
+	return () => void set.delete(each);
+}
 /** Currently accumulating export. Stores real values of placeholder properties such as ref() or child states. */
 let EXPORT;
 function values(state) {
@@ -524,15 +544,16 @@ function assign(state, data, silent) {
 *
 * This is used internally to update properties, but can also be used to update properties which are not managed by state, or to update values without triggering setters.
 *
-* A destroyed state reports the write - thrown to the writer unless a `catch` handler takes it - and returns `false`; `silent` skips both, and dispatch.
+* A destroyed state stores the write without dispatch, reports it unless `silent`, and returns `false`.
 */
 function update(state, key, value, silent, own) {
+	const store = STORE.get(state);
+	if (value instanceof State) value = value.is;
 	if (observer(state) === null) {
-		if (!silent) report(new Caught.Destroyed(state, String(key)), true);
+		if (!silent) report("dead", state, /* @__PURE__ */ new Error(`Tried to update ${state}.${String(key)} but state is destroyed.`), String(key));
+		store[key] = value;
 		return false;
 	}
-	const store = STORE.get(state);
-	if (value instanceof State) value = value.is;
 	if (key in store && value === store[key]) return false;
 	store[key] = value;
 	if (!silent) event(state, key);
@@ -540,40 +561,23 @@ function update(state, key, value, silent, own) {
 	return true;
 }
 /**
-* Pass a caught error along `catch` handlers - most-derived class first, last registered
-* first - until one returns nothing. Passed off the end, a warning logs and anything
-* else is thrown - to the caller when `sync`, else uncaught. So is a handler's throw,
-* and one wrapping an error a handler already threw escapes that error unreported.
+* Pass an error along `catch` handlers - most-derived class first, last registered
+* first, one on several classes once at the outermost - until one returns nothing. Passed off
+* the end, a destroyed write outputs nothing, `unused` warns, anything else escapes uncaught;
+* so does a handler's throw.
 */
-function report(caught, sync) {
-	const handlers = /* @__PURE__ */ new Set();
-	let error = caught;
-	if (caught.cause instanceof Caught) return escape(caught.cause);
-	for (let T = caught.state.constructor;; T = Object.getPrototypeOf(T)) {
-		for (const handler of [...SETUP.get(T) || []].reverse()) if (typeof handler == "object" && handler.catch) handlers.add(handler.catch);
-		if (T === State) break;
-	}
+function report(kind, owner, error, key) {
+	const state = owner instanceof State ? owner : owner && PARENT.get(owner);
+	if (!state) return REPORT.error(error);
 	try {
-		for (const handler of handlers) if (!(error = handler.call(caught.state, error))) return;
+		for (const handler of [...stages(state.constructor, "catch")].reverse()) if ((error = handler.call(state, error, kind, key)) === void 0) return;
+		if (kind == "unused") console.warn(error);
+		else if (kind != "dead") REPORT.error(error);
 	} catch (err) {
-		if (sync) throw err;
-		return escape(err);
+		REPORT.error(err);
 	}
-	if (error.warning) console.warn(error);
-	else if (sync) throw error;
-	else escape(error);
-}
-function escape(err) {
-	queueMicrotask(() => {
-		throw err;
-	});
-}
-/** Error thrown by a handler replaying in dispatch, attributed to the State which queued it. */
-function fault(err, owner) {
-	const state = owner instanceof State ? owner : owner && PARENT.get(owner);
-	if (state) report(new Caught.Effect(state, err));
-	else escape(err);
 }
+REPORT.as = report;
 /**
 * Hand a value stored by an owning writer to that property's adopter,
 * creating one the first time a State is stored there. A property which has
@@ -598,101 +602,6 @@ function latest(getter) {
 	for (let next; next = LATEST.get(getter);) getter = next;
 	return getter;
 }
-/** Begin tracking live instances, so a hot patch can reach them. */
-function track() {
-	LIVE ||= /* @__PURE__ */ new Set();
-}
-/**
-* Move the members of `next` onto `prev`, which keeps its identity. Returns the
-* live instances of `prev`, each needing a refresh.
-*/
-function patch(prev, next, own) {
-	const proto = prev.prototype;
-	const incoming = Object.getOwnPropertyDescriptors(next.prototype);
-	const keys = METHODS.get(prev);
-	const getters = GETTERS.get(prev);
-	const methods = /* @__PURE__ */ new Map();
-	const knownKeys = new Set(keys?.keys());
-	const knownGetters = new Set(getters?.keys());
-	let setup = SETUP.get(prev);
-	for (const handler of own) setup.delete(handler);
-	for (const handler of handlers(next)) {
-		if (!setup) SETUP.set(prev, setup = /* @__PURE__ */ new Set());
-		setup.add(handler);
-	}
-	for (const key of Reflect.ownKeys(next)) {
-		if (key == "prototype" || key == "length" || key == "name") continue;
-		if (Object.getOwnPropertyDescriptor(prev, key)?.configurable !== false) define(prev, key, Object.getOwnPropertyDescriptor(next, key));
-	}
-	const removed = /* @__PURE__ */ new Set();
-	for (const key of Object.getOwnPropertyNames(proto)) if (key != "constructor" && !(key in incoming)) {
-		const bind = keys?.get(key);
-		if (bind && Object.getOwnPropertyDescriptor(proto, key).get === bind) {
-			PAST.add(UNBIND.get(bind));
-			keys.delete(key);
-		}
-		removed.add(key);
-		Reflect.deleteProperty(proto, key);
-		getters?.delete(key);
-	}
-	for (const [key, desc] of Object.entries(incoming)) {
-		if (key == "constructor") continue;
-		const current = Object.getOwnPropertyDescriptor(proto, key);
-		if (typeof desc.value == "function") methods.set(key, desc.value);
-		if (current?.configurable === false) {
-			if (current.writable) proto[key] = desc.value;
-			continue;
-		}
-		if (current?.get && keys?.get(key) === current.get) PAST.add(UNBIND.get(current.get));
-		const getter = getters?.get(key);
-		if (getter) LATEST.set(getter, desc.get);
-		define(proto, key, {
-			...desc,
-			configurable: true
-		});
-	}
-	if (keys) {
-		for (let T = prev;; T = Object.getPrototypeOf(T)) {
-			for (const handler of SETUP.get(T) || []) if (typeof handler == "object" && handler.type) handler.type(prev);
-			if (T === State) break;
-		}
-		classify(prev, keys, getters);
-	}
-	const live = [];
-	for (const ref of LIVE) {
-		const state = ref.deref();
-		if (!state) LIVE.delete(ref);
-		else if (state instanceof prev) live.push(state);
-	}
-	const descendants = new Set([prev, ...live.map((state) => state.constructor)]);
-	for (const type of descendants) for (const child of SUBCLASSES.get(type) || []) descendants.add(child);
-	descendants.delete(prev);
-	for (const type of descendants) {
-		const inherit = METHODS.get(type);
-		const computed = GETTERS.get(type);
-		for (const [key, bind] of keys) if (!knownKeys.has(key) && !inherit.has(key)) inherit.set(key, bind);
-		for (const [key, get] of getters) if (!knownGetters.has(key) && !computed.has(key)) computed.set(key, get);
-		for (const key of removed) if (!(key in type.prototype)) {
-			inherit.delete(key);
-			computed.delete(key);
-		}
-	}
-	for (const state of live) {
-		for (const [key, value] of methods) {
-			const desc = Object.getOwnPropertyDescriptor(state, key);
-			if (!desc) continue;
-			if (desc.set) desc.set.call(state, value);
-			else if (PAST.has(UNBIND.get(desc.value))) delete state[key];
-		}
-		for (const key of removed) if (PAST.has(UNBIND.get(Object.getOwnPropertyDescriptor(state, key)?.value))) delete state[key];
-		for (const [key, get] of GETTERS.get(state.constructor)) if (!knownGetters.has(key) && get === getters.get(key)) compute.call(state, get, key);
-	}
-	return live;
-}
-/** Lifecycle handlers registered on a class itself. */
-function handlers(type) {
-	return [...SETUP.get(type) || []];
-}
 /** Random alphanumberic of length 6; always starts with a letter. */
 function uid() {
 	return (.278 + Math.random() * .722).toString(36).substring(2, 8).toUpperCase();
@@ -708,5 +617,5 @@ function parent(child, value) {
 }
 
 //#endregion
-export { PENDING, STORE, State, access, apply, children, compute, event, fault, handlers, parent, patch, track, trailing, uid, unbind, update };
+export { GETTERS, LATEST, METHODS, PENDING, SETUP, STORE, State, UNBIND, access, adopt, apply, children, classify, compute, event, owned, parent, trailing, uid, unbind, update };
 //# sourceMappingURL=state.js.map