mvc-kit 2.12.5 → 2.13.0

package/dist/wrapAsyncMethods.js

@@ -1,171 +1,144 @@
-import { isAbortError, classifyError } from "./errors.js";
 import { walkPrototypeChain } from "./walkPrototypeChain.js";
-const __DEV__ = typeof __MVC_KIT_DEV__ !== "undefined" && __MVC_KIT_DEV__;
-const LOADING_TASK_STATE = Object.freeze({ loading: true, error: null, errorCode: null });
+import { classifyError, isAbortError } from "./errors.js";
+//#region src/wrapAsyncMethods.ts
+var __DEV__ = typeof __MVC_KIT_DEV__ !== "undefined" && __MVC_KIT_DEV__;
+var LOADING_TASK_STATE = Object.freeze({
+	loading: true,
+	error: null,
+	errorCode: null
+});
+/**
+* Shared async method wrapping logic used by both ViewModel and Resource.
+* Walks the prototype chain, wraps methods with async tracking, and registers cleanup.
+* Returns the list of wrapped method keys.
+*/
 function wrapAsyncMethods(ctx) {
-  const {
-    instance,
-    stopPrototype,
-    reservedKeys,
-    lifecycleHooks,
-    isDisposed,
-    isInitialized,
-    asyncStates,
-    asyncSnapshots,
-    asyncListeners,
-    notifyAsync,
-    addCleanup,
-    ghostTimeout,
-    className,
-    activeOps
-  } = ctx;
-  if (__DEV__) {
-    for (const key of reservedKeys) {
-      if (Object.getOwnPropertyDescriptor(instance, key)?.value !== void 0) {
-        let fromPrototype = false;
-        let proto = Object.getPrototypeOf(instance);
-        while (proto && proto !== Object.prototype) {
-          const desc = Object.getOwnPropertyDescriptor(proto, key);
-          if (desc && typeof desc.value === "function") {
-            fromPrototype = true;
-            break;
-          }
-          proto = Object.getPrototypeOf(proto);
-        }
-        if (!fromPrototype) {
-          throw new Error(
-            `[mvc-kit] "${key}" is a reserved property on ${className} and cannot be overridden.`
-          );
-        }
-      }
-    }
-  }
-  const methodEntries = ctx.methods ?? (() => {
-    const result = [];
-    const processed = /* @__PURE__ */ new Set();
-    walkPrototypeChain(instance, stopPrototype, (key, desc) => {
-      if (desc.get || desc.set) return;
-      if (typeof desc.value !== "function") return;
-      if (key.startsWith("_")) return;
-      if (lifecycleHooks.has(key)) return;
-      if (processed.has(key)) return;
-      processed.add(key);
-      result.push({ key, fn: desc.value });
-    });
-    return result;
-  })();
-  const wrappedKeys = [];
-  for (const { key, fn: original } of methodEntries) {
-    let pruned = false;
-    const wrapper = function(...args) {
-      if (isDisposed()) {
-        if (__DEV__) {
-          console.warn(`[mvc-kit] "${key}" called after dispose — ignored.`);
-        }
-        return void 0;
-      }
-      if (__DEV__ && !isInitialized()) {
-        console.warn(
-          `[mvc-kit] "${key}" called before init(). Async tracking is active only after init().`
-        );
-      }
-      let result;
-      try {
-        result = original.apply(instance, args);
-      } catch (e) {
-        throw e;
-      }
-      if (!result || typeof result.then !== "function") {
-        if (!pruned) {
-          pruned = true;
-          asyncStates.delete(key);
-          asyncSnapshots.delete(key);
-          instance[key] = original.bind(instance);
-        }
-        return result;
-      }
-      let internal = asyncStates.get(key);
-      if (!internal) {
-        internal = { loading: false, error: null, errorCode: null, count: 0 };
-        asyncStates.set(key, internal);
-      }
-      internal.count++;
-      internal.loading = true;
-      internal.error = null;
-      internal.errorCode = null;
-      asyncSnapshots.set(key, LOADING_TASK_STATE);
-      notifyAsync();
-      if (__DEV__ && activeOps) {
-        activeOps.set(key, (activeOps.get(key) ?? 0) + 1);
-      }
-      const finalizeOp = (errorMsg, errorCode) => {
-        internal.count--;
-        internal.loading = internal.count > 0;
-        if (errorMsg !== void 0) {
-          internal.error = errorMsg;
-          internal.errorCode = errorCode ?? null;
-        }
-        asyncSnapshots.set(
-          key,
-          Object.freeze({ loading: internal.loading, error: internal.error, errorCode: internal.errorCode })
-        );
-        notifyAsync();
-        if (__DEV__ && activeOps) {
-          const c = (activeOps.get(key) ?? 1) - 1;
-          if (c <= 0) activeOps.delete(key);
-          else activeOps.set(key, c);
-        }
-      };
-      return result.then(
-        (value) => {
-          if (!isDisposed()) finalizeOp();
-          return value;
-        },
-        (error) => {
-          if (isAbortError(error)) {
-            if (!isDisposed()) finalizeOp();
-            return void 0;
-          }
-          if (isDisposed()) return void 0;
-          const classified = classifyError(error);
-          finalizeOp(classified.message, classified.code);
-          throw error;
-        }
-      );
-    };
-    wrappedKeys.push(key);
-    instance[key] = wrapper;
-  }
-  if (wrappedKeys.length > 0) {
-    addCleanup(() => {
-      const opsSnapshot = __DEV__ && activeOps ? new Map(activeOps) : null;
-      for (const k of wrappedKeys) {
-        if (__DEV__) {
-          instance[k] = () => {
-            console.warn(`[mvc-kit] "${k}" called after dispose — ignored.`);
-            return void 0;
-          };
-        } else {
-          instance[k] = () => void 0;
-        }
-      }
-      asyncListeners.clear();
-      asyncStates.clear();
-      asyncSnapshots.clear();
-      if (__DEV__ && opsSnapshot && opsSnapshot.size > 0) {
-        setTimeout(() => {
-          for (const [key, count] of opsSnapshot) {
-            console.warn(
-              `[mvc-kit] Ghost async operation detected: "${key}" had ${count} pending call(s) when the ${className} was disposed. Consider using disposeSignal to cancel in-flight work.`
-            );
-          }
-        }, ghostTimeout);
-      }
-    });
-  }
-  return wrappedKeys;
+	const { instance, stopPrototype, reservedKeys, lifecycleHooks, isDisposed, isInitialized, asyncStates, asyncSnapshots, asyncListeners, notifyAsync, addCleanup, ghostTimeout, className, activeOps } = ctx;
+	if (__DEV__) {
+		for (const key of reservedKeys) if (Object.getOwnPropertyDescriptor(instance, key)?.value !== void 0) {
+			let fromPrototype = false;
+			let proto = Object.getPrototypeOf(instance);
+			while (proto && proto !== Object.prototype) {
+				const desc = Object.getOwnPropertyDescriptor(proto, key);
+				if (desc && typeof desc.value === "function") {
+					fromPrototype = true;
+					break;
+				}
+				proto = Object.getPrototypeOf(proto);
+			}
+			if (!fromPrototype) throw new Error(`[mvc-kit] "${key}" is a reserved property on ${className} and cannot be overridden.`);
+		}
+	}
+	const methodEntries = ctx.methods ?? (() => {
+		const result = [];
+		const processed = /* @__PURE__ */ new Set();
+		walkPrototypeChain(instance, stopPrototype, (key, desc) => {
+			if (desc.get || desc.set) return;
+			if (typeof desc.value !== "function") return;
+			if (key.startsWith("_")) return;
+			if (lifecycleHooks.has(key)) return;
+			if (processed.has(key)) return;
+			processed.add(key);
+			result.push({
+				key,
+				fn: desc.value
+			});
+		});
+		return result;
+	})();
+	const wrappedKeys = [];
+	for (const { key, fn: original } of methodEntries) {
+		let pruned = false;
+		const wrapper = function(...args) {
+			if (isDisposed()) {
+				if (__DEV__) console.warn(`[mvc-kit] "${key}" called after dispose — ignored.`);
+				return;
+			}
+			if (__DEV__ && !isInitialized()) console.warn(`[mvc-kit] "${key}" called before init(). Async tracking is active only after init().`);
+			let result;
+			try {
+				result = original.apply(instance, args);
+			} catch (e) {
+				throw e;
+			}
+			if (!result || typeof result.then !== "function") {
+				if (!pruned) {
+					pruned = true;
+					asyncStates.delete(key);
+					asyncSnapshots.delete(key);
+					instance[key] = original.bind(instance);
+				}
+				return result;
+			}
+			let internal = asyncStates.get(key);
+			if (!internal) {
+				internal = {
+					loading: false,
+					error: null,
+					errorCode: null,
+					count: 0
+				};
+				asyncStates.set(key, internal);
+			}
+			internal.count++;
+			internal.loading = true;
+			internal.error = null;
+			internal.errorCode = null;
+			asyncSnapshots.set(key, LOADING_TASK_STATE);
+			notifyAsync();
+			if (__DEV__ && activeOps) activeOps.set(key, (activeOps.get(key) ?? 0) + 1);
+			const finalizeOp = (errorMsg, errorCode) => {
+				internal.count--;
+				internal.loading = internal.count > 0;
+				if (errorMsg !== void 0) {
+					internal.error = errorMsg;
+					internal.errorCode = errorCode ?? null;
+				}
+				asyncSnapshots.set(key, Object.freeze({
+					loading: internal.loading,
+					error: internal.error,
+					errorCode: internal.errorCode
+				}));
+				notifyAsync();
+				if (__DEV__ && activeOps) {
+					const c = (activeOps.get(key) ?? 1) - 1;
+					if (c <= 0) activeOps.delete(key);
+					else activeOps.set(key, c);
+				}
+			};
+			return result.then((value) => {
+				if (!isDisposed()) finalizeOp();
+				return value;
+			}, (error) => {
+				if (isAbortError(error)) {
+					if (!isDisposed()) finalizeOp();
+					return;
+				}
+				if (isDisposed()) return void 0;
+				const classified = classifyError(error);
+				finalizeOp(classified.message, classified.code);
+				throw error;
+			});
+		};
+		wrappedKeys.push(key);
+		instance[key] = wrapper;
+	}
+	if (wrappedKeys.length > 0) addCleanup(() => {
+		const opsSnapshot = __DEV__ && activeOps ? new Map(activeOps) : null;
+		for (const k of wrappedKeys) if (__DEV__) instance[k] = () => {
+			console.warn(`[mvc-kit] "${k}" called after dispose — ignored.`);
+		};
+		else instance[k] = () => void 0;
+		asyncListeners.clear();
+		asyncStates.clear();
+		asyncSnapshots.clear();
+		if (__DEV__ && opsSnapshot && opsSnapshot.size > 0) setTimeout(() => {
+			for (const [key, count] of opsSnapshot) console.warn(`[mvc-kit] Ghost async operation detected: "${key}" had ${count} pending call(s) when the ${className} was disposed. Consider using disposeSignal to cancel in-flight work.`);
+		}, ghostTimeout);
+	});
+	return wrappedKeys;
 }
-export {
-  wrapAsyncMethods
-};
-//# sourceMappingURL=wrapAsyncMethods.js.map
+//#endregion
+export { wrapAsyncMethods };
+
+//# sourceMappingURL=wrapAsyncMethods.js.map

package/dist/wrapAsyncMethods.js.map

@@ -1 +1 @@
-{"version":3,"file":"wrapAsyncMethods.js","sources":["../src/wrapAsyncMethods.ts"],"sourcesContent":["import { isAbortError, classifyError } from './errors';\nimport { walkPrototypeChain } from './walkPrototypeChain';\nimport type { TaskState } from './types';\n\nconst __DEV__ = typeof __MVC_KIT_DEV__ !== 'undefined' && __MVC_KIT_DEV__;\n\nconst LOADING_TASK_STATE: TaskState = Object.freeze({ loading: true, error: null, errorCode: null });\n\n/** @internal Mutable internal async tracking state per method. */\nexport interface InternalTaskState {\n  loading: boolean;\n  error: string | null;\n  errorCode: TaskState['errorCode'];\n  count: number;\n}\n\n/** @internal Configuration for the shared async method wrapping logic. */\nexport interface AsyncTrackingContext {\n  instance: object;\n  stopPrototype: object;\n  reservedKeys: readonly string[];\n  lifecycleHooks: Set<string>;\n  isDisposed: () => boolean;\n  isInitialized: () => boolean;\n  asyncStates: Map<string, InternalTaskState>;\n  asyncSnapshots: Map<string, TaskState>;\n  asyncListeners: Set<() => void>;\n  notifyAsync: () => void;\n  addCleanup: (fn: () => void) => void;\n  ghostTimeout: number;\n  className: string;\n  activeOps: Map<string, number> | null;\n  /** Pre-scanned methods from class metadata cache. When provided, skips prototype walk. */\n  methods?: Array<{ key: string; fn: Function }>;\n}\n\n/**\n * Shared async method wrapping logic used by both ViewModel and Resource.\n * Walks the prototype chain, wraps methods with async tracking, and registers cleanup.\n * Returns the list of wrapped method keys.\n */\nexport function wrapAsyncMethods(ctx: AsyncTrackingContext): string[] {\n  const {\n    instance,\n    stopPrototype,\n    reservedKeys,\n    lifecycleHooks,\n    isDisposed,\n    isInitialized,\n    asyncStates,\n    asyncSnapshots,\n    asyncListeners,\n    notifyAsync,\n    addCleanup,\n    ghostTimeout,\n    className,\n    activeOps,\n  } = ctx;\n\n  // Instance property reserved key check (DEV-only — prototype check in constructor catches most cases)\n  // Skip own properties that are bound methods from bindPublicMethods (the key\n  // also exists as a method on the prototype chain). Only reject class-field overrides.\n  if (__DEV__) {\n    for (const key of reservedKeys) {\n      if (Object.getOwnPropertyDescriptor(instance, key)?.value !== undefined) {\n        // Check if the prototype chain has a method with this name —\n        // if so, the own property is from bindPublicMethods, not a user override\n        let fromPrototype = false;\n        let proto = Object.getPrototypeOf(instance);\n        while (proto && proto !== Object.prototype) {\n          const desc = Object.getOwnPropertyDescriptor(proto, key);\n          if (desc && typeof desc.value === 'function') { fromPrototype = true; break; }\n          proto = Object.getPrototypeOf(proto);\n        }\n        if (!fromPrototype) {\n          throw new Error(\n            `[mvc-kit] \"${key}\" is a reserved property on ${className} and cannot be overridden.`\n          );\n        }\n      }\n    }\n  }\n\n  // Use pre-scanned methods from class metadata cache, or walk prototype chain\n  const methodEntries: Array<{ key: string; fn: Function }> = ctx.methods ?? (() => {\n    const result: Array<{ key: string; fn: Function }> = [];\n    const processed = new Set<string>();\n    walkPrototypeChain(instance, stopPrototype, (key, desc) => {\n      if (desc.get || desc.set) return;\n      if (typeof desc.value !== 'function') return;\n      if (key.startsWith('_')) return;\n      if (lifecycleHooks.has(key)) return;\n      if (processed.has(key)) return;\n      processed.add(key);\n      result.push({ key, fn: desc.value });\n    });\n    return result;\n  })();\n\n  const wrappedKeys: string[] = [];\n\n  for (const { key, fn: original } of methodEntries) {\n    let pruned = false;\n\n    const wrapper = function (this: any, ...args: unknown[]) {\n      // Disposed guard\n      if (isDisposed()) {\n        if (__DEV__) {\n          console.warn(`[mvc-kit] \"${key}\" called after dispose — ignored.`);\n        }\n        return undefined;\n      }\n\n      // Pre-init guard (DEV only — method still executes)\n      if (__DEV__ && !isInitialized()) {\n        console.warn(\n          `[mvc-kit] \"${key}\" called before init(). ` +\n          `Async tracking is active only after init().`\n        );\n      }\n\n      let result: unknown;\n      try {\n        result = original.apply(instance, args);\n      } catch (e) {\n        // Sync throw — not tracked as async\n        throw e;\n      }\n\n      // Sync detection: if not thenable, prune from async tracking\n      if (!result || typeof (result as any).then !== 'function') {\n        if (!pruned) {\n          pruned = true;\n          // Remove from async maps\n          asyncStates.delete(key);\n          asyncSnapshots.delete(key);\n          // Replace wrapper with bound original for zero overhead\n          (instance as any)[key] = original.bind(instance);\n        }\n        return result;\n      }\n\n      // ── Async tracking ──────────────────────────────────────\n      let internal = asyncStates.get(key);\n      if (!internal) {\n        internal = { loading: false, error: null, errorCode: null, count: 0 };\n        asyncStates.set(key, internal);\n      }\n\n      internal.count++;\n      internal.loading = true;\n      internal.error = null;\n      internal.errorCode = null;\n      asyncSnapshots.set(key, LOADING_TASK_STATE);\n      notifyAsync();\n\n      if (__DEV__ && activeOps) {\n        activeOps.set(key, (activeOps.get(key) ?? 0) + 1);\n      }\n\n      // Shared bookkeeping: decrement count, snapshot state, update DEV active ops\n      const finalizeOp = (errorMsg?: string | null, errorCode?: TaskState['errorCode']) => {\n        internal!.count--;\n        internal!.loading = internal!.count > 0;\n        if (errorMsg !== undefined) {\n          internal!.error = errorMsg;\n          internal!.errorCode = errorCode ?? null;\n        }\n        asyncSnapshots.set(\n          key,\n          Object.freeze({ loading: internal!.loading, error: internal!.error, errorCode: internal!.errorCode }),\n        );\n        notifyAsync();\n\n        if (__DEV__ && activeOps) {\n          const c = (activeOps.get(key) ?? 1) - 1;\n          if (c <= 0) activeOps.delete(key);\n          else activeOps.set(key, c);\n        }\n      };\n\n      return (result as Promise<unknown>).then(\n        (value) => {\n          if (!isDisposed()) finalizeOp();\n          return value;\n        },\n        (error) => {\n          // AbortError — silently swallow\n          if (isAbortError(error)) {\n            if (!isDisposed()) finalizeOp();\n            return undefined;\n          }\n\n          // Disposed — fizzle silently\n          if (isDisposed()) return undefined;\n\n          const classified = classifyError(error);\n          finalizeOp(classified.message, classified.code);\n\n          // Re-throw to preserve standard Promise rejection\n          throw error;\n        },\n      );\n    };\n\n    wrappedKeys.push(key);\n    (instance as any)[key] = wrapper;\n  }\n\n  // Register cleanup for disposal\n  if (wrappedKeys.length > 0) {\n    addCleanup(() => {\n      // Snapshot active ops for ghost check before clearing\n      const opsSnapshot = __DEV__ && activeOps ? new Map(activeOps) : null;\n\n      // Swap all wrapped methods to no-ops (with DEV warning)\n      for (const k of wrappedKeys) {\n        if (__DEV__) {\n          (instance as any)[k] = () => {\n            console.warn(`[mvc-kit] \"${k}\" called after dispose — ignored.`);\n            return undefined;\n          };\n        } else {\n          (instance as any)[k] = () => undefined;\n        }\n      }\n\n      // Clear async state\n      asyncListeners.clear();\n      asyncStates.clear();\n      asyncSnapshots.clear();\n\n      // DEV: schedule ghost check\n      if (__DEV__ && opsSnapshot && opsSnapshot.size > 0) {\n        setTimeout(() => {\n          for (const [key, count] of opsSnapshot) {\n            console.warn(\n              `[mvc-kit] Ghost async operation detected: \"${key}\" had ${count} ` +\n              `pending call(s) when the ${className} was disposed. ` +\n              `Consider using disposeSignal to cancel in-flight work.`\n            );\n          }\n        }, ghostTimeout);\n      }\n    });\n  }\n\n  return wrappedKeys;\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"wrapAsyncMethods.js","names":[],"sources":["../src/wrapAsyncMethods.ts"],"sourcesContent":["import { isAbortError, classifyError } from './errors';\nimport { walkPrototypeChain } from './walkPrototypeChain';\nimport type { TaskState } from './types';\n\nconst __DEV__ = typeof __MVC_KIT_DEV__ !== 'undefined' && __MVC_KIT_DEV__;\n\nconst LOADING_TASK_STATE: TaskState = Object.freeze({ loading: true, error: null, errorCode: null });\n\n/** @internal Mutable internal async tracking state per method. */\nexport interface InternalTaskState {\n  loading: boolean;\n  error: string | null;\n  errorCode: TaskState['errorCode'];\n  count: number;\n}\n\n/** @internal Configuration for the shared async method wrapping logic. */\nexport interface AsyncTrackingContext {\n  instance: object;\n  stopPrototype: object;\n  reservedKeys: readonly string[];\n  lifecycleHooks: Set<string>;\n  isDisposed: () => boolean;\n  isInitialized: () => boolean;\n  asyncStates: Map<string, InternalTaskState>;\n  asyncSnapshots: Map<string, TaskState>;\n  asyncListeners: Set<() => void>;\n  notifyAsync: () => void;\n  addCleanup: (fn: () => void) => void;\n  ghostTimeout: number;\n  className: string;\n  activeOps: Map<string, number> | null;\n  /** Pre-scanned methods from class metadata cache. When provided, skips prototype walk. */\n  methods?: Array<{ key: string; fn: Function }>;\n}\n\n/**\n * Shared async method wrapping logic used by both ViewModel and Resource.\n * Walks the prototype chain, wraps methods with async tracking, and registers cleanup.\n * Returns the list of wrapped method keys.\n */\nexport function wrapAsyncMethods(ctx: AsyncTrackingContext): string[] {\n  const {\n    instance,\n    stopPrototype,\n    reservedKeys,\n    lifecycleHooks,\n    isDisposed,\n    isInitialized,\n    asyncStates,\n    asyncSnapshots,\n    asyncListeners,\n    notifyAsync,\n    addCleanup,\n    ghostTimeout,\n    className,\n    activeOps,\n  } = ctx;\n\n  // Instance property reserved key check (DEV-only — prototype check in constructor catches most cases)\n  // Skip own properties that are bound methods from bindPublicMethods (the key\n  // also exists as a method on the prototype chain). Only reject class-field overrides.\n  if (__DEV__) {\n    for (const key of reservedKeys) {\n      if (Object.getOwnPropertyDescriptor(instance, key)?.value !== undefined) {\n        // Check if the prototype chain has a method with this name —\n        // if so, the own property is from bindPublicMethods, not a user override\n        let fromPrototype = false;\n        let proto = Object.getPrototypeOf(instance);\n        while (proto && proto !== Object.prototype) {\n          const desc = Object.getOwnPropertyDescriptor(proto, key);\n          if (desc && typeof desc.value === 'function') { fromPrototype = true; break; }\n          proto = Object.getPrototypeOf(proto);\n        }\n        if (!fromPrototype) {\n          throw new Error(\n            `[mvc-kit] \"${key}\" is a reserved property on ${className} and cannot be overridden.`\n          );\n        }\n      }\n    }\n  }\n\n  // Use pre-scanned methods from class metadata cache, or walk prototype chain\n  const methodEntries: Array<{ key: string; fn: Function }> = ctx.methods ?? (() => {\n    const result: Array<{ key: string; fn: Function }> = [];\n    const processed = new Set<string>();\n    walkPrototypeChain(instance, stopPrototype, (key, desc) => {\n      if (desc.get || desc.set) return;\n      if (typeof desc.value !== 'function') return;\n      if (key.startsWith('_')) return;\n      if (lifecycleHooks.has(key)) return;\n      if (processed.has(key)) return;\n      processed.add(key);\n      result.push({ key, fn: desc.value });\n    });\n    return result;\n  })();\n\n  const wrappedKeys: string[] = [];\n\n  for (const { key, fn: original } of methodEntries) {\n    let pruned = false;\n\n    const wrapper = function (this: any, ...args: unknown[]) {\n      // Disposed guard\n      if (isDisposed()) {\n        if (__DEV__) {\n          console.warn(`[mvc-kit] \"${key}\" called after dispose — ignored.`);\n        }\n        return undefined;\n      }\n\n      // Pre-init guard (DEV only — method still executes)\n      if (__DEV__ && !isInitialized()) {\n        console.warn(\n          `[mvc-kit] \"${key}\" called before init(). ` +\n          `Async tracking is active only after init().`\n        );\n      }\n\n      let result: unknown;\n      try {\n        result = original.apply(instance, args);\n      } catch (e) {\n        // Sync throw — not tracked as async\n        throw e;\n      }\n\n      // Sync detection: if not thenable, prune from async tracking\n      if (!result || typeof (result as any).then !== 'function') {\n        if (!pruned) {\n          pruned = true;\n          // Remove from async maps\n          asyncStates.delete(key);\n          asyncSnapshots.delete(key);\n          // Replace wrapper with bound original for zero overhead\n          (instance as any)[key] = original.bind(instance);\n        }\n        return result;\n      }\n\n      // ── Async tracking ──────────────────────────────────────\n      let internal = asyncStates.get(key);\n      if (!internal) {\n        internal = { loading: false, error: null, errorCode: null, count: 0 };\n        asyncStates.set(key, internal);\n      }\n\n      internal.count++;\n      internal.loading = true;\n      internal.error = null;\n      internal.errorCode = null;\n      asyncSnapshots.set(key, LOADING_TASK_STATE);\n      notifyAsync();\n\n      if (__DEV__ && activeOps) {\n        activeOps.set(key, (activeOps.get(key) ?? 0) + 1);\n      }\n\n      // Shared bookkeeping: decrement count, snapshot state, update DEV active ops\n      const finalizeOp = (errorMsg?: string | null, errorCode?: TaskState['errorCode']) => {\n        internal!.count--;\n        internal!.loading = internal!.count > 0;\n        if (errorMsg !== undefined) {\n          internal!.error = errorMsg;\n          internal!.errorCode = errorCode ?? null;\n        }\n        asyncSnapshots.set(\n          key,\n          Object.freeze({ loading: internal!.loading, error: internal!.error, errorCode: internal!.errorCode }),\n        );\n        notifyAsync();\n\n        if (__DEV__ && activeOps) {\n          const c = (activeOps.get(key) ?? 1) - 1;\n          if (c <= 0) activeOps.delete(key);\n          else activeOps.set(key, c);\n        }\n      };\n\n      return (result as Promise<unknown>).then(\n        (value) => {\n          if (!isDisposed()) finalizeOp();\n          return value;\n        },\n        (error) => {\n          // AbortError — silently swallow\n          if (isAbortError(error)) {\n            if (!isDisposed()) finalizeOp();\n            return undefined;\n          }\n\n          // Disposed — fizzle silently\n          if (isDisposed()) return undefined;\n\n          const classified = classifyError(error);\n          finalizeOp(classified.message, classified.code);\n\n          // Re-throw to preserve standard Promise rejection\n          throw error;\n        },\n      );\n    };\n\n    wrappedKeys.push(key);\n    (instance as any)[key] = wrapper;\n  }\n\n  // Register cleanup for disposal\n  if (wrappedKeys.length > 0) {\n    addCleanup(() => {\n      // Snapshot active ops for ghost check before clearing\n      const opsSnapshot = __DEV__ && activeOps ? new Map(activeOps) : null;\n\n      // Swap all wrapped methods to no-ops (with DEV warning)\n      for (const k of wrappedKeys) {\n        if (__DEV__) {\n          (instance as any)[k] = () => {\n            console.warn(`[mvc-kit] \"${k}\" called after dispose — ignored.`);\n            return undefined;\n          };\n        } else {\n          (instance as any)[k] = () => undefined;\n        }\n      }\n\n      // Clear async state\n      asyncListeners.clear();\n      asyncStates.clear();\n      asyncSnapshots.clear();\n\n      // DEV: schedule ghost check\n      if (__DEV__ && opsSnapshot && opsSnapshot.size > 0) {\n        setTimeout(() => {\n          for (const [key, count] of opsSnapshot) {\n            console.warn(\n              `[mvc-kit] Ghost async operation detected: \"${key}\" had ${count} ` +\n              `pending call(s) when the ${className} was disposed. ` +\n              `Consider using disposeSignal to cancel in-flight work.`\n            );\n          }\n        }, ghostTimeout);\n      }\n    });\n  }\n\n  return wrappedKeys;\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mvc-kit",
-  "version": "2.12.5",
+  "version": "2.13.0",
   "description": "Zero-magic, class-based reactive ViewModel library",
   "type": "module",
   "main": "./dist/mvc-kit.cjs",
@@ -81,16 +81,16 @@
   },
   "devDependencies": {
     "@testing-library/react": "^16.0.0",
-    "@types/react": "^18.3.0",
-    "esbuild": "^0.25.12",
+    "@types/react": "^19.2.14",
+    "esbuild": "^0.28.0",
     "fake-indexeddb": "^6.2.5",
-    "jsdom": "^26.0.0",
+    "jsdom": "^29.0.2",
     "msw": "^2.12.10",
-    "react": "^18.3.0",
-    "react-dom": "^18.3.0",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
     "react-router-dom": "^7.0.0",
-    "typescript": "~5.9.3",
-    "vite": "^7.3.1",
+    "typescript": "~6.0.2",
+    "vite": "^8.0.8",
     "vitest": "^4.0.18"
   }
 }

package/src/Pending.test.ts

@@ -1510,8 +1510,7 @@ describe('Pending', () => {
 
     it('supersede replaces meta', async () => {
       const p = new Pending<string, TestMeta>();
-      let resolve1!: () => void;
-      const promise1 = new Promise<void>(r => { resolve1 = r; });
+      const promise1 = new Promise<void>(() => {});
 
       p.enqueue('a', 'send', () => promise1, { label: 'first', priority: 1 });
       await vi.advanceTimersByTimeAsync(0);

package/src/Sorting.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { Sorting } from './Sorting';
 import type { SortDescriptor } from './Sorting';
 import { ViewModel } from './ViewModel';

package/src/produceDraft.test.ts

@@ -143,7 +143,7 @@ describe('produceDraft', () => {
   // ── Original immutability ───────────────────────────────────────
 
   it('never mutates original state', () => {
-    const state = Object.freeze({ count: 0, name: 'test' });
+    const state = Object.freeze<{ count: number; name: string }>({ count: 0, name: 'test' });
     const result = produceDraft(state, (d) => {
       d.count = 5;
       d.name = 'updated';
@@ -154,8 +154,8 @@ describe('produceDraft', () => {
   });
 
   it('never mutates original nested objects', () => {
-    const config = Object.freeze({ theme: 'dark', size: 14 });
-    const state = Object.freeze({ config });
+    const config = { theme: 'dark', size: 14 };
+    const state = Object.freeze<{ config: { theme: string; size: number } }>({ config });
     const result = produceDraft(state, (d) => {
       d.config.theme = 'light';
     });

package/src/react/components/CardList.test.tsx

@@ -59,7 +59,7 @@ describe('CardList', () => {
   });
 
   it('uses custom keyOf', () => {
-    const { container } = render(
+    render(
       <CardList
         items={[{ uid: 'x', label: 'X' }]}
         keyOf={(item: any) => item.uid}

package/src/react/components/DataTable.test.tsx

@@ -411,7 +411,7 @@ describe('DataTable', () => {
         <DataTable
           items={users.slice(0, 1)}
           columns={columns}
-          renderRow={(item, index, cells) => (
+          renderRow={(_item, _index, cells) => (
             <>{cells}<td data-testid="extra">Extra</td></>
           )}
         />,

package/src/react/components/InfiniteScroll.test.tsx

@@ -14,7 +14,7 @@ beforeEach(() => {
   mockObserve = vi.fn();
   mockDisconnect = vi.fn();
 
-  global.IntersectionObserver = class MockIntersectionObserver {
+  globalThis.IntersectionObserver = class MockIntersectionObserver {
     constructor(callback: IntersectionObserverCallback) {
       observerCallback = callback;
     }
@@ -157,18 +157,18 @@ describe('InfiniteScroll', () => {
   });
 
   it('handles missing IntersectionObserver (SSR guard)', () => {
-    const saved = global.IntersectionObserver;
-    delete (global as any).IntersectionObserver;
+    const saved = globalThis.IntersectionObserver;
+    delete (globalThis as any).IntersectionObserver;
 
     // Should not throw
-    const { container } = render(
+    render(
       <InfiniteScroll hasMore={true} onLoadMore={() => {}}>
         <p>Content</p>
       </InfiniteScroll>,
     );
     expect(screen.getByText('Content')).toBeDefined();
 
-    global.IntersectionObserver = saved;
+    globalThis.IntersectionObserver = saved;
   });
 
   describe('direction prop', () => {

package/dist/mvc-kit.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"mvc-kit.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/mvc-kit.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mvc-kit.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}

package/dist/react-native.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-native.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/react-native.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-native.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/react.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"react.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/react.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"react.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}

package/dist/web.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"web.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

package/dist/web.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"web.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}