webspresso 0.0.111 → 0.0.113

package/core/client/api.js

@@ -84,9 +84,28 @@ class ClientRequestError extends Error {
       this.status === 408;
     this.isDropped = Boolean(details.isDropped);
     this.isSuperseded = Boolean(details.isSuperseded);
+    this.dispatched =
+      details.dispatched !== undefined
+        ? Boolean(details.dispatched)
+        : !this.isDropped && (this.kind !== 'canceled' || Boolean(details.cause));
+    this.outcomeUnknown =
+      details.outcomeUnknown !== undefined
+        ? Boolean(details.outcomeUnknown)
+        : MUTATION_METHODS.has(this.method) &&
+          this.dispatched &&
+          !this.isDropped &&
+          (this.kind === 'timeout' || this.kind === 'network' || this.kind === 'canceled');
+    this.outcome = this.outcomeUnknown
+      ? 'unknown'
+      : !this.dispatched || this.isDropped
+        ? 'not_sent'
+        : 'failed';
     this.serverRollbackGuaranteed = false;
     if (this.isCanceled) {
       this.note = 'Client request cancellation/abort does not roll back server-side execution.';
+    } else if (this.outcomeUnknown) {
+      this.note =
+        'Mutation request was dispatched before response delivery failed; the server may have committed the operation.';
     }
     if (details.cause) {
       this.cause = details.cause;
@@ -599,6 +618,110 @@ function abortableSleep(ms, signals = []) {
   });
 }
 
+function parseXhrHeaders(rawHeaders) {
+  const map = new Map();
+  if (typeof rawHeaders === 'string' && rawHeaders) {
+    const lines = rawHeaders.trim().split(/[\r\n]+/);
+    for (let i = 0; i < lines.length; i++) {
+      const idx = lines[i].indexOf(':');
+      if (idx > 0) {
+        const k = lines[i].slice(0, idx).trim().toLowerCase();
+        const v = lines[i].slice(idx + 1).trim();
+        map.set(k, v);
+      }
+    }
+  }
+  return {
+    get(name) {
+      return map.get(String(name || '').toLowerCase()) ?? null;
+    },
+    has(name) {
+      return map.has(String(name || '').toLowerCase());
+    },
+  };
+}
+
+function executeXhrUpload({ url, method, headers, body, credentials, signal, onUploadProgress }) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, url, true);
+    if (credentials === 'include' || credentials === 'same-origin') {
+      xhr.withCredentials = credentials === 'include';
+    }
+    if (headers && typeof headers === 'object') {
+      for (const [k, v] of Object.entries(headers)) {
+        if (v !== undefined && v !== null) {
+          xhr.setRequestHeader(k, String(v));
+        }
+      }
+    }
+
+    if (xhr.upload && typeof onUploadProgress === 'function') {
+      xhr.upload.onprogress = (evt) => {
+        const lengthComputable = Boolean(evt && evt.lengthComputable);
+        const loaded = evt && typeof evt.loaded === 'number' ? evt.loaded : 0;
+        const total = lengthComputable && evt && typeof evt.total === 'number' ? evt.total : 0;
+        const percent = lengthComputable && total > 0 ? Math.min(100, Math.round((loaded / total) * 100)) : null;
+        try {
+          onUploadProgress({ loaded, total, percent, lengthComputable });
+        } catch (_e) {}
+      };
+    }
+
+    const onAbort = () => {
+      try {
+        xhr.abort();
+      } catch (_e) {}
+    };
+    if (signal) {
+      if (signal.aborted) {
+        const abortErr = new Error('The operation was aborted.');
+        abortErr.name = 'AbortError';
+        reject(abortErr);
+        return;
+      }
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+
+    const cleanup = () => {
+      if (signal) {
+        try {
+          signal.removeEventListener('abort', onAbort);
+        } catch (_e) {}
+      }
+    };
+
+    xhr.onload = () => {
+      cleanup();
+      const status = xhr.status === 1223 ? 204 : xhr.status;
+      const rawText = typeof xhr.responseText === 'string' ? xhr.responseText : '';
+      const headerObj = parseXhrHeaders(xhr.getAllResponseHeaders ? xhr.getAllResponseHeaders() : '');
+      resolve({
+        ok: status >= 200 && status < 300,
+        status,
+        statusText: xhr.statusText || '',
+        headers: headerObj,
+        text: async () => rawText,
+        json: async () => (rawText ? JSON.parse(rawText) : null),
+      });
+    };
+
+    xhr.onerror = () => {
+      cleanup();
+      reject(new TypeError('Network request failed'));
+    };
+
+    xhr.onabort = () => {
+      cleanup();
+      const abortErr = new Error('The operation was aborted.');
+      abortErr.name = 'AbortError';
+      reject(abortErr);
+    };
+
+    xhr.send(body === undefined ? null : body);
+  });
+}
+
 /**
  * Create a Typed API Client instance.
  *
@@ -675,6 +798,8 @@ function createApiClient(config = {}) {
         method: upperMethod,
         url: requestUrl,
         key: requestKey,
+        dispatched: false,
+        outcomeUnknown: false,
       });
     }
 
@@ -883,13 +1008,25 @@ function createApiClient(config = {}) {
     try {
       let response;
       try {
-        response = await fetchImpl(requestUrl, {
-          method: upperMethod,
-          headers,
-          body: serializedBody,
-          credentials: options.credentials || 'same-origin',
-          signal: abortController.signal,
-        });
+        if (typeof options.onUploadProgress === 'function' && typeof XMLHttpRequest !== 'undefined') {
+          response = await executeXhrUpload({
+            url: requestUrl,
+            method: upperMethod,
+            headers,
+            body: serializedBody,
+            credentials: options.credentials || 'same-origin',
+            signal: abortController.signal,
+            onUploadProgress: options.onUploadProgress,
+          });
+        } else {
+          response = await fetchImpl(requestUrl, {
+            method: upperMethod,
+            headers,
+            body: serializedBody,
+            credentials: options.credentials || 'same-origin',
+            signal: abortController.signal,
+          });
+        }
       } catch (fetchErr) {
         if (timeoutTimer) {
           clearTimeout(timeoutTimer);
@@ -914,6 +1051,7 @@ function createApiClient(config = {}) {
               url: requestUrl,
               key: requestKey,
               isTimedOut: true,
+              dispatched: true,
               cause: fetchErr,
             }
           );
@@ -947,6 +1085,7 @@ function createApiClient(config = {}) {
               url: requestUrl,
               key: requestKey,
               isSuperseded: superseded,
+              dispatched: true,
               cause: fetchErr,
             }
           );
@@ -962,6 +1101,7 @@ function createApiClient(config = {}) {
             method: upperMethod,
             url: requestUrl,
             key: requestKey,
+            dispatched: true,
             cause: fetchErr,
           }
         );

package/core/client/controller.js

@@ -367,6 +367,8 @@ function defineController(definition = {}) {
     tasks: definition.tasks && typeof definition.tasks === 'object' ? definition.tasks : {},
     connect: typeof definition.connect === 'function' ? definition.connect : null,
     disconnect: typeof definition.disconnect === 'function' ? definition.disconnect : null,
+    beforePatch: typeof definition.beforePatch === 'function' ? definition.beforePatch : null,
+    afterPatch: typeof definition.afterPatch === 'function' ? definition.afterPatch : null,
     onError: typeof definition.onError === 'function' ? definition.onError : null,
     persist: definition.persist || null,
     watch: definition.watch && typeof definition.watch === 'object' ? definition.watch : null,
@@ -495,6 +497,7 @@ function createControllerRuntime(options = {}) {
   const activeInstances = new Map();
   // Standalone forms (forms without a controller wrapper)
   const standaloneForms = new WeakMap();
+  const activeStandaloneForms = new Set();
 
   /**
    * Register a controller definition with collision checking.
@@ -737,19 +740,26 @@ function createControllerRuntime(options = {}) {
       const signalPrefix = `__w_inst_${instanceId}.task_${taskKey}`;
 
       // React Query-style automatic revalidation options for tasks
+      const isMutationTask = taskOpts.mutation === true || taskOpts.kind === 'mutation';
       const staleTimeMs = parseDurationMs(taskOpts.staleTime, 0);
-      const refetchOnMountMode = parseRefetchMode(
-        taskOpts.refetchOnMount !== undefined ? taskOpts.refetchOnMount : taskOpts.refetchOnVisit,
-        false
-      );
-      const refetchOnFocusMode = parseRefetchMode(
-        taskOpts.refetchOnWindowFocus !== undefined ? taskOpts.refetchOnWindowFocus : taskOpts.refetchOnFocus,
-        false
-      );
-      const refetchOnReconnectMode = parseRefetchMode(taskOpts.refetchOnReconnect, false);
-      const refetchIntervalMs = parseDurationMs(taskOpts.refetchInterval, 0);
+      const refetchOnMountMode = isMutationTask
+        ? false
+        : parseRefetchMode(
+            taskOpts.refetchOnMount !== undefined ? taskOpts.refetchOnMount : taskOpts.refetchOnVisit,
+            false
+          );
+      const refetchOnFocusMode = isMutationTask
+        ? false
+        : parseRefetchMode(
+            taskOpts.refetchOnWindowFocus !== undefined ? taskOpts.refetchOnWindowFocus : taskOpts.refetchOnFocus,
+            false
+          );
+      const refetchOnReconnectMode = isMutationTask
+        ? false
+        : parseRefetchMode(taskOpts.refetchOnReconnect, false);
+      const refetchIntervalMs = isMutationTask ? 0 : parseDurationMs(taskOpts.refetchInterval, 0);
       const refetchIntervalInBg =
-        parseRefetchMode(taskOpts.refetchIntervalInBackground, false) === true;
+        !isMutationTask && parseRefetchMode(taskOpts.refetchIntervalInBackground, false) === true;
 
       let currentRunVersion = 0;
       let activeRuns = 0;
@@ -769,6 +779,7 @@ function createControllerRuntime(options = {}) {
       let _data = null;
       let _error = null;
       let _stale = false;
+      let _lastArgs = [];
 
       function isTaskStale(mode = true) {
         if (!mode) return false;
@@ -787,6 +798,10 @@ function createControllerRuntime(options = {}) {
 
       async function run(...args) {
         if (!isConnected()) return undefined;
+        if (args.length > 0) {
+          _lastArgs = [...args];
+        }
+        const effectiveArgs = args.length > 0 ? args : _lastArgs;
 
         if (policy === 'drop' && activeRuns > 0) {
           if (debug && typeof debug.trackDiscardedResponse === 'function') {
@@ -802,12 +817,12 @@ function createControllerRuntime(options = {}) {
 
         if (policy === 'queue') {
           const wait = queuedPromise;
-          const nextRun = wait.then(() => executeRun(...args)).catch(() => {});
+          const nextRun = wait.then(() => executeRun(...effectiveArgs)).catch(() => {});
           queuedPromise = nextRun;
           return nextRun;
         }
 
-        return executeRun(...args);
+        return executeRun(...effectiveArgs);
       }
 
       async function executeRun(...args) {
@@ -834,7 +849,7 @@ function createControllerRuntime(options = {}) {
         try {
           const result = await runFn(...args);
 
-          if (!isConnected() || runVersion !== currentRunVersion) {
+          if (!isConnected() || (policy !== 'parallel' && runVersion !== currentRunVersion)) {
             return undefined;
           }
 
@@ -847,7 +862,7 @@ function createControllerRuntime(options = {}) {
           updateSignal('stale', false);
           return result;
         } catch (err) {
-          if (!isConnected() || runVersion !== currentRunVersion) {
+          if (!isConnected() || (policy !== 'parallel' && runVersion !== currentRunVersion)) {
             return undefined;
           }
           if (err && (err.isCanceled || err.name === 'AbortError')) {
@@ -865,7 +880,11 @@ function createControllerRuntime(options = {}) {
             inFlightAbort = null;
           }
           activeRuns = Math.max(0, activeRuns - 1);
-          if (runVersion === currentRunVersion || activeRuns === 0) {
+          const shouldClearPending =
+            policy === 'parallel'
+              ? activeRuns === 0
+              : runVersion === currentRunVersion || activeRuns === 0;
+          if (shouldClearPending) {
             _pending = false;
             _stale = false;
             if (isConnected()) {
@@ -912,6 +931,9 @@ function createControllerRuntime(options = {}) {
         get lastUpdatedAt() {
           return _lastUpdatedAt;
         },
+        get lastArgs() {
+          return [..._lastArgs];
+        },
         isStale: () => isTaskStale(true),
         run,
         cancel,
@@ -1359,6 +1381,9 @@ function createControllerRuntime(options = {}) {
       root: defaultStorage,
     });
     const persistConfig = normalizePersistConfig(reg.definition.persist, controllerName);
+    let persistTimer = null;
+    let lastSavedJson = '';
+    const persistenceConflicts = [];
     function resolvePersistDriver(pConfig) {
       if (!pConfig) return storageCtx.local;
       if (pConfig.isGlobal) {
@@ -1367,6 +1392,30 @@ function createControllerRuntime(options = {}) {
       return storageCtx[pConfig.storageType] || storageCtx.local;
     }
 
+    function checkFragmentPersistenceConflict(idOrName, input) {
+      if (!persistConfig || !fragments || typeof fragments.getInstance !== 'function' || !input || typeof input !== 'object') {
+        return;
+      }
+      const inst =
+        fragments.getInstance(idOrName) ||
+        (typeof fragments.getInstances === 'function'
+          ? fragments.getInstances().find((i) => i.name === idOrName)
+          : null);
+      if (inst && inst.persistInput && inst.persistInput.key !== persistConfig.storageKey) {
+        const conflict = {
+          controller: controllerName,
+          controllerStorageKey: persistConfig.storageKey,
+          fragment: inst.instanceId,
+          fragmentStorageKey: inst.persistInput.key,
+          keys: Object.keys(input),
+        };
+        persistenceConflicts.push(conflict);
+        if (debug && typeof debug.recordEvent === 'function') {
+          debug.recordEvent('persist:conflict', conflict);
+        }
+      }
+    }
+
     // 6. Context object passed to `connect(ctx)` and `actions[name](ctx, event, actionEl)`
     ctx = Object.freeze({
       instanceId,
@@ -1383,10 +1432,27 @@ function createControllerRuntime(options = {}) {
       tasks: tasksProxy,
       task: createTaskInstance,
       storage: storageCtx,
+      get persistenceConflicts() {
+        return [...persistenceConflicts];
+      },
       clearPersistedState: () => {
+        if (persistTimer) {
+          clearTimeout(persistTimer);
+          persistTimer = null;
+        }
         if (persistConfig) {
           const driver = resolvePersistDriver(persistConfig);
           driver.remove(persistConfig.storageKey);
+          if (state && initialRawState) {
+            const keysToTrack = persistConfig.keys || Object.keys(initialRawState);
+            const currentPayload = {};
+            for (const k of keysToTrack) {
+              currentPayload[k] = state[k];
+            }
+            lastSavedJson = JSON.stringify(currentPayload);
+          } else {
+            lastSavedJson = '';
+          }
         }
       },
       param: (name, maybeEl) => {
@@ -1430,7 +1496,12 @@ function createControllerRuntime(options = {}) {
         return unregister;
       },
       invalidate: (tags) => (fragments ? fragments.invalidate(tags) : Promise.resolve({ ok: true, refreshed: [] })),
+      retryFailedFragments: () =>
+        fragments && typeof fragments.retryFailed === 'function'
+          ? fragments.retryFailed()
+          : Promise.resolve({ refreshed: [], skipped: true }),
       refresh: async (idOrName, input, opts) => {
+        checkFragmentPersistenceConflict(idOrName, input);
         if (!fragments) {
           const empty = { ok: true, refreshed: [], skipped: true };
           if (opts && typeof opts.onSuccess === 'function') await opts.onSuccess(empty);
@@ -1445,7 +1516,17 @@ function createControllerRuntime(options = {}) {
           const inst = fragments && fragments.getInstance ? fragments.getInstance(idOrName) : null;
           return inst && inst.input ? { ...inst.input } : {};
         },
+        get inputs() {
+          if (!fragments || typeof fragments.getInstances !== 'function') return {};
+          const list = fragments.getInstances(idOrName);
+          const map = {};
+          for (const inst of list) {
+            map[inst.instanceId] = inst.input ? { ...inst.input } : {};
+          }
+          return map;
+        },
         refresh: (input, opts) => {
+          checkFragmentPersistenceConflict(idOrName, input);
           if (!fragments) {
             const empty = { ok: true, refreshed: [], skipped: true };
             if (opts && typeof opts.onSuccess === 'function') {
@@ -1478,14 +1559,34 @@ function createControllerRuntime(options = {}) {
     );
     state = stateManager.state;
 
-    // Hydrate persisted state if defined
+    // Hydrate persisted state if defined (with schema-compatible type validation against corrupted storage)
     if (persistConfig) {
       const driver = resolvePersistDriver(persistConfig);
       const savedData = driver.get(persistConfig.storageKey, null);
       if (savedData && typeof savedData === 'object' && !isArray(savedData)) {
         for (const [k, v] of Object.entries(savedData)) {
           if (persistConfig.keys && !persistConfig.keys.includes(k)) continue;
-          if (Object.prototype.hasOwnProperty.call(initialRawState, k)) {
+          if (!Object.prototype.hasOwnProperty.call(initialRawState, k)) continue;
+          const initVal = initialRawState[k];
+          if (initVal !== null && typeof initVal === 'object' && !isArray(initVal)) {
+            if (v !== null && typeof v === 'object' && !isArray(v)) {
+              const merged = { ...initVal };
+              for (const [subKey, subVal] of Object.entries(v)) {
+                if (Object.prototype.hasOwnProperty.call(initVal, subKey)) {
+                  if (initVal[subKey] === null || typeof subVal === typeof initVal[subKey]) {
+                    merged[subKey] = subVal;
+                  }
+                } else {
+                  merged[subKey] = subVal;
+                }
+              }
+              state[k] = merged;
+            }
+          } else if (isArray(initVal)) {
+            if (isArray(v)) {
+              state[k] = v;
+            }
+          } else if (initVal === null || initVal === undefined || typeof v === typeof initVal) {
             state[k] = v;
           }
         }
@@ -1609,7 +1710,17 @@ function createControllerRuntime(options = {}) {
         isConnected,
         isLoadingTargetActive,
       });
-      domDisposers.push(unbind);
+      if (domDisposers.length === 0) {
+        domDisposers.push(unbind);
+      }
+
+      // Prune disconnected forms from scopedForms
+      for (const [fName, fh] of Array.from(scopedForms.entries())) {
+        if (!fh.el || fh.el.isConnected === false || !rootEl.contains(fh.el)) {
+          fh.destroy();
+          scopedForms.delete(fName);
+        }
+      }
 
       // Also auto-initialize any `<form data-w-form>` inside this controller's scope
       if (rootEl.tagName === 'FORM' && rootEl.hasAttribute('data-w-form')) {
@@ -1619,7 +1730,10 @@ function createControllerRuntime(options = {}) {
         const formsInScope = rootEl.querySelectorAll('form[data-w-form]');
         for (let i = 0; i < formsInScope.length; i++) {
           if (isTargetInControllerScope(rootEl, formsInScope[i])) {
-            createFormHandle(formsInScope[i], { api: scopedApi, datastar, debug, services });
+            const fh = createFormHandle(formsInScope[i], { api: scopedApi, datastar, debug, services });
+            if (fh && fh.name) {
+              scopedForms.set(fh.name, fh);
+            }
           }
         }
       }
@@ -1630,8 +1744,6 @@ function createControllerRuntime(options = {}) {
     // Auto-sync persisted state changes back to storage
     if (persistConfig) {
       const driver = resolvePersistDriver(persistConfig);
-      let persistTimer = null;
-      let lastSavedJson = '';
 
       const stopPersistEffect = registerEffect(() => {
         if (!isConnected()) return;
@@ -1703,6 +1815,33 @@ function createControllerRuntime(options = {}) {
       get isConnected() {
         return isConnected();
       },
+      invokeBeforePatch(meta = {}) {
+        if (!isConnected() || !reg.definition.beforePatch) return;
+        try {
+          const result = reg.definition.beforePatch(ctx, meta);
+          if (result && typeof result.then === 'function') {
+            // beforePatch must be synchronous; warn in dev and do not block morph
+            if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {
+              console.warn(`[webspresso] Controller "${controllerName}" beforePatch() returned a Promise; beforePatch hooks are synchronous and are not awaited.`);
+            }
+          }
+        } catch (err) {
+          handleControllerError(err, { phase: 'beforePatch' });
+        }
+      },
+      invokeAfterPatch(meta = {}) {
+        if (!isConnected() || !reg.definition.afterPatch) return;
+        try {
+          const res = reg.definition.afterPatch(ctx, meta);
+          if (res && typeof res.then === 'function') {
+            res.catch((err) => {
+              handleControllerError(err, { phase: 'afterPatch' });
+            });
+          }
+        } catch (err) {
+          handleControllerError(err, { phase: 'afterPatch' });
+        }
+      },
       destroy() {
         if (!connected) return;
         connected = false;
@@ -1816,6 +1955,11 @@ function createControllerRuntime(options = {}) {
       if (standaloneForm) {
         standaloneForm.destroy();
         standaloneForms.delete(node);
+        activeStandaloneForms.delete(standaloneForm);
+      } else if (node && node.__wFormHandle) {
+        try {
+          node.__wFormHandle.destroy();
+        } catch (_e) {}
       }
     }
   }
@@ -1901,6 +2045,7 @@ function createControllerRuntime(options = {}) {
           services,
         });
         standaloneForms.set(formEl, handle);
+        activeStandaloneForms.add(handle);
       }
     }
 
@@ -1921,6 +2066,82 @@ function createControllerRuntime(options = {}) {
     return mounted;
   }
 
+  const patchCycleTracker = typeof WeakMap !== 'undefined' ? new WeakMap() : null;
+
+  function collectAffectedInstances(fragmentEl) {
+    if (!fragmentEl) return [];
+    const affected = [];
+    for (const inst of activeInstances.values()) {
+      if (!inst || !inst.el || !inst.isConnected) continue;
+      if (
+        inst.el === fragmentEl ||
+        (typeof fragmentEl.contains === 'function' && fragmentEl.contains(inst.el)) ||
+        (typeof inst.el.contains === 'function' && inst.el.contains(fragmentEl))
+      ) {
+        affected.push(inst);
+      }
+    }
+    // Sort deterministically: outer ancestors first, inner descendants second
+    affected.sort((a, b) => {
+      if (a.el === b.el) return 0;
+      if (typeof a.el.contains === 'function' && a.el.contains(b.el)) return -1;
+      if (typeof b.el.contains === 'function' && b.el.contains(a.el)) return 1;
+      if (typeof a.el.compareDocumentPosition === 'function') {
+        const pos = a.el.compareDocumentPosition(b.el);
+        if (pos & 4) return -1; // DOCUMENT_POSITION_FOLLOWING
+        if (pos & 2) return 1;  // DOCUMENT_POSITION_PRECEDING
+      }
+      return 0;
+    });
+    return affected;
+  }
+
+  function notifyBeforePatch(fragmentEl, meta = {}) {
+    const affected = collectAffectedInstances(fragmentEl);
+    for (let i = 0; i < affected.length; i++) {
+      const inst = affected[i];
+      inst.invokeBeforePatch({
+        ...meta,
+        isFragmentRoot: inst.el === fragmentEl,
+        isDescendant: inst.el !== fragmentEl && typeof fragmentEl.contains === 'function' && fragmentEl.contains(inst.el),
+      });
+    }
+  }
+
+  function notifyAfterPatch(fragmentEl, meta = {}) {
+    if (patchCycleTracker && fragmentEl) {
+      const now = Date.now();
+      const prev = patchCycleTracker.get(fragmentEl) || { count: 0, lastAt: 0 };
+      const count = now - prev.lastAt < 100 ? prev.count + 1 : 1;
+      patchCycleTracker.set(fragmentEl, { count, lastAt: now });
+      if (count > 5) {
+        const msg = `Possible patch hook refresh loop detected on fragment "${meta.fragmentName || meta.fragmentId || 'unknown'}" (${count} rapid patch cycles).`;
+        if (debug && typeof debug.recordEvent === 'function') {
+          debug.recordEvent('patch:loop-warning', {
+            code: 'PATCH_HOOK_LOOP_DETECTED',
+            fragmentId: meta.fragmentId || null,
+            fragmentName: meta.fragmentName || null,
+            count,
+            message: msg,
+          });
+        } else if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {
+          console.warn(`[webspresso] ${msg}`);
+        }
+      }
+    }
+
+    const affected = collectAffectedInstances(fragmentEl);
+    // Reverse order for afterPatch: inner descendants first, outer ancestors second
+    for (let i = affected.length - 1; i >= 0; i--) {
+      const inst = affected[i];
+      inst.invokeAfterPatch({
+        ...meta,
+        isFragmentRoot: inst.el === fragmentEl,
+        isDescendant: inst.el !== fragmentEl && typeof fragmentEl.contains === 'function' && fragmentEl.contains(inst.el),
+      });
+    }
+  }
+
   return {
     register,
     services,
@@ -1934,6 +2155,8 @@ function createControllerRuntime(options = {}) {
     mountSubtree,
     syncTree: mountSubtree,
     unmountSubtree,
+    notifyBeforePatch,
+    notifyAfterPatch,
     mountControllerOnElement,
     getInstanceForElement(el, name) {
       const map = elementInstances.get(el);
@@ -1944,10 +2167,19 @@ function createControllerRuntime(options = {}) {
     getActiveInstances() {
       return Array.from(activeInstances.values());
     },
+    getStandaloneFormCount() {
+      return activeStandaloneForms.size;
+    },
     destroyAll() {
       for (const inst of Array.from(activeInstances.values())) {
         inst.destroy();
       }
+      for (const fh of Array.from(activeStandaloneForms.values())) {
+        try {
+          fh.destroy();
+        } catch (_e) {}
+      }
+      activeStandaloneForms.clear();
     },
   };
 }