mvc-kit 2.12.5 → 2.13.1

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/examples/primitive/channel.ts

@@ -0,0 +1,109 @@
+import { Channel, singleton, teardownAll } from 'mvc-kit';
+import type { ChannelStatus } from 'mvc-kit';
+
+// Channel: Persistent connection with auto-reconnect and typed messages
+//
+// Extend Channel<MessageMap> and implement two abstract methods:
+//   open(signal)  — establish the connection (WebSocket, SSE, etc.)
+//   close()       — tear down the transport
+//
+// The framework handles connection status, reconnect with exponential
+// backoff, message routing, and lifecycle management.
+
+// --- Message type map ---
+
+interface ChatMessages {
+  message: { userId: string; text: string };
+  typing: { userId: string };
+  presence: { online: string[] };
+}
+
+// --- Channel subclass ---
+
+class ChatChannel extends Channel<ChatMessages> {
+  // Tune reconnect behavior via static overrides
+  static override RECONNECT_BASE = 1000;   // initial backoff (ms)
+  static override RECONNECT_MAX = 30000;   // max backoff cap (ms)
+  static override MAX_ATTEMPTS = 5;        // give up after 5 attempts
+
+  private ws: { close(): void } | null = null;
+
+  // open() is called by the framework when connect() is invoked.
+  // The signal aborts on disconnect() or dispose().
+  protected open(signal: AbortSignal): void {
+    // In production, this would be:
+    //   this.ws = new WebSocket('wss://chat.example.com');
+    //   this.ws.onmessage = (e) => {
+    //     const { type, payload } = JSON.parse(e.data);
+    //     this.receive(type, payload);
+    //   };
+
+    // Simulated connection
+    console.log('Connecting...');
+    const connectTimer = setTimeout(() => {
+      if (!signal.aborted) {
+        console.log('Connected!');
+        // Simulate incoming messages
+        this.receive('presence', { online: ['alice', 'bob'] });
+        this.receive('message', { userId: 'alice', text: 'Hello!' });
+      }
+    }, 100);
+
+    this.ws = {
+      close: () => clearTimeout(connectTimer),
+    };
+
+    // Always clean up when the signal aborts (disconnect or dispose)
+    signal.addEventListener('abort', () => this.ws?.close());
+  }
+
+  // close() tears down the transport. Must not throw.
+  protected close(): void {
+    this.ws?.close();
+    this.ws = null;
+  }
+}
+
+// --- Usage ---
+
+const chat = singleton(ChatChannel);
+chat.init();
+
+// Subscribe to connection status changes
+chat.subscribe((next: ChannelStatus, prev: ChannelStatus) => {
+  console.log(`Status: connected=${next.connected}, reconnecting=${next.reconnecting}`);
+  if (next.error) console.log(`Error: ${next.error}`);
+});
+
+// Subscribe to typed messages
+const unsubMessage = chat.on('message', ({ userId, text }) => {
+  console.log(`${userId}: ${text}`);
+});
+
+// One-time subscription — auto-unsubscribes after first event
+chat.once('presence', ({ online }) => {
+  console.log('Initial presence:', online);
+});
+
+// Initiate connection
+chat.connect();
+
+// Read current status at any time
+console.log('Connected:', chat.state.connected);
+console.log('Reconnecting:', chat.state.reconnecting);
+console.log('Attempt:', chat.state.attempt);
+
+// Manually disconnect (cancels pending reconnect, resets status)
+// chat.disconnect();
+
+// Reconnect after disconnect
+// chat.connect();
+
+// Unsubscribe from a message type
+unsubMessage();
+
+// Cleanup — cancels timers, aborts signals, calls close()
+setTimeout(() => {
+  chat.dispose();
+  teardownAll();
+}, 500);

package/examples/primitive/collection.ts

@@ -0,0 +1,118 @@
+import { Collection } from 'mvc-kit';
+
+// Collection: Reactive typed array with CRUD and query methods
+
+interface Todo {
+  id: string;
+  text: string;
+  done: boolean;
+  priority: 'low' | 'medium' | 'high';
+}
+
+// --- Basic usage ---
+
+const todos = new Collection<Todo>();
+
+// Subscribe to changes
+todos.subscribe((items, prev) => {
+  console.log(`Collection changed: ${prev.length} → ${items.length} items`);
+});
+
+// CRUD operations (trigger notifications)
+
+// Add items
+todos.add(
+  { id: '1', text: 'Learn mvc-kit', done: false, priority: 'high' },
+  { id: '2', text: 'Build an app', done: false, priority: 'medium' },
+  { id: '3', text: 'Write tests', done: true, priority: 'low' }
+);
+
+console.log('Length:', todos.length); // 3
+console.log('Items:', todos.items);
+
+// Update an item
+todos.update('1', { done: true });
+console.log('After update:', todos.get('1')?.done); // true
+
+// Remove an item
+todos.remove('3');
+console.log('After remove length:', todos.length); // 2
+
+// Query operations (pure, no notifications)
+
+// Get by id (O(1) lookup)
+const todo = todos.get('1');
+console.log('Get by id:', todo?.text);
+
+// Check existence
+console.log('Has id 1:', todos.has('1')); // true
+console.log('Has id 99:', todos.has('99')); // false
+
+// Find first match
+const firstIncomplete = todos.find(t => !t.done);
+console.log('First incomplete:', firstIncomplete?.text);
+
+// Filter
+const highPriority = todos.filter(t => t.priority === 'high');
+console.log('High priority count:', highPriority.length);
+
+// Sort (returns new array, doesn't mutate)
+const sorted = todos.sorted((a, b) => a.text.localeCompare(b.text));
+console.log('Sorted:', sorted.map(t => t.text));
+
+// Map
+const texts = todos.map(t => t.text);
+console.log('Texts:', texts);
+
+// Reset - replace all items
+todos.reset([
+  { id: 'a', text: 'New todo', done: false, priority: 'medium' }
+]);
+console.log('After reset length:', todos.length); // 1
+
+// Clear all items
+todos.clear();
+console.log('After clear length:', todos.length); // 0
+
+// --- Upsert: add-or-replace by ID ---
+
+todos.reset([
+  { id: '1', text: 'Learn mvc-kit', done: false, priority: 'high' },
+  { id: '2', text: 'Build an app', done: false, priority: 'medium' },
+]);
+
+// Upsert replaces existing items in-place and appends new ones
+todos.upsert(
+  { id: '2', text: 'Build an app', done: true, priority: 'medium' },  // replaces in position
+  { id: '3', text: 'Ship it', done: false, priority: 'high' },         // appended
+);
+console.log('After upsert length:', todos.length); // 3
+console.log('Item 2 done:', todos.get('2')?.done); // true (replaced)
+console.log('Item 3 text:', todos.get('3')?.text); // 'Ship it' (new)
+
+// --- Optimistic updates ---
+
+// Reset with some data for the optimistic demo
+todos.reset([
+  { id: '1', text: 'Learn mvc-kit', done: false, priority: 'high' },
+  { id: '2', text: 'Build an app', done: false, priority: 'medium' },
+]);
+
+// Snapshot current state, apply mutations, get a rollback function
+const rollback = todos.optimistic(() => {
+  todos.update('1', { done: true });
+  todos.remove('2');
+});
+
+console.log('After optimistic:', todos.length); // 1
+console.log('Item 1 done:', todos.get('1')?.done); // true
+
+// If the server call fails, rollback restores pre-optimistic state
+rollback();
+
+console.log('After rollback:', todos.length); // 2
+console.log('Item 1 done:', todos.get('1')?.done); // false
+console.log('Item 2 exists:', todos.has('2')); // true
+
+// Cleanup
+todos.dispose();