wevu 7.0.4 → 7.1.1

package/dist/dev/runtime/app/setData/patchScheduler.mjs

@@ -1,22 +1,24 @@
 import { toPlain } from "../../diff.mjs";
-import { checkPayloadSize, collapsePayload, mergeSiblingPayload } from "./payload.mjs";
 import { applySnapshotUpdate, cloneSnapshotValue, isDeepEqualValue, isShallowEqualValue, normalizeSetDataValue } from "./snapshot.mjs";
+import { checkPayloadSize, collapsePayload, mergeSiblingPayload } from "./payload.mjs";
 
 //#region src/runtime/app/setData/patchScheduler.ts
-function runPatchUpdate(options) {
-	const { state, computedRefs, dirtyComputedKeys, includeComputed, computedCompare, computedCompareMaxDepth, computedCompareMaxKeys, currentAdapter, shouldIncludeKey, maxPatchKeys, maxPayloadBytes, mergeSiblingThreshold, mergeSiblingMaxInflationRatio, mergeSiblingMaxParentBytes, mergeSiblingSkipArray, elevateTopKeyThreshold, toPlainMaxDepth, toPlainMaxKeys, includeFunctions = false, functionPaths, plainCache, plainCacheEligibility, pendingPatches, fallbackTopKeys, latestSnapshot, latestComputedSnapshot, needsFullSnapshot, emitDebug, runDiffUpdate } = options;
+function preparePatchUpdate(options) {
+	const { state, computedRefs, dirtyComputedKeys, includeComputed, computedCompare, computedCompareMaxDepth, computedCompareMaxKeys, shouldIncludeKey, maxPatchKeys, maxPayloadBytes, mergeSiblingThreshold, mergeSiblingMaxInflationRatio, mergeSiblingMaxParentBytes, mergeSiblingSkipArray, elevateTopKeyThreshold, toPlainMaxDepth, toPlainMaxKeys, includeFunctions = false, functionPaths, plainCache, plainCacheEligibility, pendingPatches, fallbackTopKeys, dispatchedSnapshot, dispatchedComputedSnapshot } = options;
 	if (pendingPatches.size > maxPatchKeys) {
-		needsFullSnapshot.value = true;
 		const pendingCount = pendingPatches.size;
 		pendingPatches.clear();
 		dirtyComputedKeys.clear();
-		emitDebug({
-			mode: "diff",
+		return {
+			type: "fallback",
 			reason: "maxPatchKeys",
-			pendingPatchKeys: pendingCount,
-			payloadKeys: 0
-		});
-		return runDiffUpdate("maxPatchKeys");
+			debug: {
+				mode: "diff",
+				reason: "maxPatchKeys",
+				pendingPatchKeys: pendingCount,
+				payloadKeys: 0
+			}
+		};
 	}
 	const seen = /* @__PURE__ */ new WeakMap();
 	const plainByPath = /* @__PURE__ */ new Map();
@@ -40,9 +42,9 @@ function runPatchUpdate(options) {
 	const getStateValueByPath = (path) => {
 		const segments = path.split(".").filter(Boolean);
 		let current = state;
-		for (const seg of segments) {
-			if (current == null) return current;
-			current = current[seg];
+		for (const segment of segments) {
+			if (current == null || typeof current !== "object") return current;
+			current = Reflect.get(current, segment);
 		}
 		return current;
 	};
@@ -71,16 +73,10 @@ function runPatchUpdate(options) {
 		}
 		fallbackTopKeys.clear();
 	}
-	for (const [path, entry] of patchEntries) {
-		if ((entry.kind === "array" ? "set" : entry.op) === "delete") {
-			payload[path] = null;
-			continue;
-		}
-		payload[path] = getPlainByPath(path);
-	}
+	for (const [path, entry] of patchEntries) payload[path] = (entry.kind === "array" ? "set" : entry.op) === "delete" ? null : getPlainByPath(path);
 	let computedDirtyProcessed = 0;
+	const computedUpdates = Object.create(null);
 	if (includeComputed && dirtyComputedKeys.size) {
-		const computedPatch = Object.create(null);
 		const keys = [...dirtyComputedKeys];
 		dirtyComputedKeys.clear();
 		computedDirtyProcessed = keys.length;
@@ -95,12 +91,11 @@ function runPatchUpdate(options) {
 				functionPaths,
 				_path: key
 			});
-			const prevValue = latestComputedSnapshot[key];
+			const prevValue = dispatchedComputedSnapshot[key];
 			if (computedCompare === "deep" ? isDeepEqualValue(prevValue, nextValue, computedCompareMaxDepth, { keys: computedCompareMaxKeys }) : computedCompare === "shallow" ? isShallowEqualValue(prevValue, nextValue) : Object.is(prevValue, nextValue)) continue;
-			computedPatch[key] = normalizeSetDataValue(nextValue);
-			latestComputedSnapshot[key] = cloneSnapshotValue(nextValue);
+			payload[key] = normalizeSetDataValue(nextValue);
+			computedUpdates[key] = cloneSnapshotValue(nextValue);
 		}
-		Object.assign(payload, computedPatch);
 	}
 	let collapsedPayload = collapsePayload(payload);
 	let mergedSiblingParents = 0;
@@ -118,41 +113,42 @@ function runPatchUpdate(options) {
 		collapsedPayload = collapsePayload(mergedResult.out);
 	}
 	const sizeCheck = checkPayloadSize(collapsedPayload, maxPayloadBytes);
-	const shouldFallback = sizeCheck.fallback;
-	emitDebug({
-		mode: shouldFallback ? "diff" : "patch",
-		reason: shouldFallback ? "maxPayloadBytes" : "patch",
+	const payloadKeys = Object.keys(collapsedPayload).length;
+	const debug = {
+		mode: sizeCheck.fallback ? "diff" : "patch",
+		reason: sizeCheck.fallback ? "maxPayloadBytes" : "patch",
 		pendingPatchKeys: patchEntries.length,
-		payloadKeys: Object.keys(collapsedPayload).length,
+		payloadKeys,
 		mergedSiblingParents: mergedSiblingParents || void 0,
 		computedDirtyKeys: computedDirtyProcessed || void 0,
 		estimatedBytes: sizeCheck.estimatedBytes,
 		bytes: sizeCheck.bytes
-	});
-	if (shouldFallback) {
-		needsFullSnapshot.value = true;
-		pendingPatches.clear();
-		dirtyComputedKeys.clear();
-		return runDiffUpdate("maxPayloadBytes");
-	}
-	if (!Object.keys(collapsedPayload).length) return;
+	};
+	if (sizeCheck.fallback) return {
+		type: "fallback",
+		reason: "maxPayloadBytes",
+		debug
+	};
+	if (!payloadKeys) return;
+	const snapshot = { ...dispatchedSnapshot };
+	const clonedParents = /* @__PURE__ */ new WeakSet();
 	for (const [path, value] of Object.entries(collapsedPayload)) {
+		var _entry$op;
 		const entry = entryMap.get(path);
-		if (entry) applySnapshotUpdate(latestSnapshot, path, value, entry.kind === "array" ? "set" : entry.op, { cloneValue: false });
-		else applySnapshotUpdate(latestSnapshot, path, value, "set", { cloneValue: false });
-	}
-	if (typeof currentAdapter.setData === "function") {
-		const result = currentAdapter.setData(collapsedPayload);
-		if (result && typeof result.then === "function") return result.catch(() => {});
+		applySnapshotUpdate(snapshot, path, value, (entry === null || entry === void 0 ? void 0 : entry.kind) === "array" ? "set" : (_entry$op = entry === null || entry === void 0 ? void 0 : entry.op) !== null && _entry$op !== void 0 ? _entry$op : "set", {
+			cloneValue: false,
+			clonedParents
+		});
 	}
-	emitDebug({
-		mode: "patch",
-		reason: "patch",
-		pendingPatchKeys: patchEntries.length,
-		payloadKeys: Object.keys(collapsedPayload).length
-	});
+	return {
+		type: "patch",
+		payload: collapsedPayload,
+		snapshot,
+		computedUpdates: Object.keys(computedUpdates).length ? computedUpdates : void 0,
+		debug
+	};
 }
 
 //#endregion
-export { runPatchUpdate };
+export { preparePatchUpdate };
 //# sourceMappingURL=patchScheduler.mjs.map

package/dist/dev/runtime/app/setData/patchScheduler.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"patchScheduler.mjs","names":[],"sources":["../../../../../src/runtime/app/setData/patchScheduler.ts"],"sourcesContent":["import type { SetDataDebugInfo } from '../../types'\nimport { toPlain } from '../../diff'\nimport { checkPayloadSize, collapsePayload, mergeSiblingPayload } from './payload'\nimport { applySnapshotUpdate, cloneSnapshotValue, isDeepEqualValue, isShallowEqualValue, normalizeSetDataValue } from './snapshot'\n\ninterface PatchEntry {\n  kind: 'property' | 'array'\n  op: 'set' | 'delete'\n}\n\nexport function runPatchUpdate(options: {\n  state: Record<string, any>\n  computedRefs: Record<string, { value: any }>\n  dirtyComputedKeys: Set<string>\n  includeComputed: boolean\n  computedCompare: 'reference' | 'shallow' | 'deep'\n  computedCompareMaxDepth: number\n  computedCompareMaxKeys: number\n  currentAdapter: { setData?: (payload: Record<string, any>) => void | Promise<void> }\n  shouldIncludeKey: (key: string) => boolean\n  maxPatchKeys: number\n  maxPayloadBytes: number\n  mergeSiblingThreshold: number\n  mergeSiblingMaxInflationRatio: number\n  mergeSiblingMaxParentBytes: number\n  mergeSiblingSkipArray: boolean\n  elevateTopKeyThreshold: number\n  toPlainMaxDepth: number\n  toPlainMaxKeys: number\n  includeFunctions?: boolean\n  functionPaths: string[]\n  plainCache: WeakMap<object, { version: number, value: any }>\n  plainCacheEligibility?: WeakMap<object, boolean>\n  pendingPatches: Map<string, PatchEntry>\n  fallbackTopKeys: Set<string>\n  latestSnapshot: Record<string, any>\n  latestComputedSnapshot: Record<string, any>\n  needsFullSnapshot: { value: boolean }\n  emitDebug: (info: SetDataDebugInfo) => void\n  runDiffUpdate: (reason?: SetDataDebugInfo['reason']) => void | Promise<void>\n}) {\n  const {\n    state,\n    computedRefs,\n    dirtyComputedKeys,\n    includeComputed,\n    computedCompare,\n    computedCompareMaxDepth,\n    computedCompareMaxKeys,\n    currentAdapter,\n    shouldIncludeKey,\n    maxPatchKeys,\n    maxPayloadBytes,\n    mergeSiblingThreshold,\n    mergeSiblingMaxInflationRatio,\n    mergeSiblingMaxParentBytes,\n    mergeSiblingSkipArray,\n    elevateTopKeyThreshold,\n    toPlainMaxDepth,\n    toPlainMaxKeys,\n    includeFunctions = false,\n    functionPaths,\n    plainCache,\n    plainCacheEligibility,\n    pendingPatches,\n    fallbackTopKeys,\n    latestSnapshot,\n    latestComputedSnapshot,\n    needsFullSnapshot,\n    emitDebug,\n    runDiffUpdate,\n  } = options\n\n  if (pendingPatches.size > maxPatchKeys) {\n    needsFullSnapshot.value = true\n    const pendingCount = pendingPatches.size\n    pendingPatches.clear()\n    dirtyComputedKeys.clear()\n    emitDebug({\n      mode: 'diff',\n      reason: 'maxPatchKeys',\n      pendingPatchKeys: pendingCount,\n      payloadKeys: 0,\n    })\n    return runDiffUpdate('maxPatchKeys')\n  }\n\n  const seen = new WeakMap<object, any>()\n  const plainByPath = new Map<string, any>()\n  const payload: Record<string, any> = Object.create(null)\n  const patchEntriesRaw = [...pendingPatches.entries()]\n\n  if (Number.isFinite(elevateTopKeyThreshold) && elevateTopKeyThreshold > 0) {\n    const counts = new Map<string, number>()\n    for (const [path] of patchEntriesRaw) {\n      const top = path.split('.', 1)[0]\n      counts.set(top, (counts.get(top) ?? 0) + 1)\n    }\n    for (const [top, count] of counts) {\n      if (count >= elevateTopKeyThreshold) {\n        fallbackTopKeys.add(top)\n      }\n    }\n  }\n\n  const patchEntries = patchEntriesRaw.filter(([path]) => {\n    for (const topKey of fallbackTopKeys) {\n      if (path === topKey || path.startsWith(`${topKey}.`)) {\n        return false\n      }\n    }\n    return true\n  })\n  const entryMap = new Map(patchEntries)\n  pendingPatches.clear()\n\n  const getStateValueByPath = (path: string) => {\n    const segments = path.split('.').filter(Boolean)\n    let current: any = state as any\n    for (const seg of segments) {\n      if (current == null) {\n        return current\n      }\n      current = current[seg]\n    }\n    return current\n  }\n\n  const getPlainByPath = (path: string) => {\n    if (plainByPath.has(path)) {\n      return plainByPath.get(path)\n    }\n    const value = normalizeSetDataValue(\n      toPlain(getStateValueByPath(path), seen, { cache: plainCache, cacheEligibility: plainCacheEligibility, maxDepth: toPlainMaxDepth, maxKeys: toPlainMaxKeys, includeFunctions, functionPaths, _path: path }),\n    )\n    plainByPath.set(path, value)\n    return value\n  }\n\n  if (fallbackTopKeys.size) {\n    for (const topKey of fallbackTopKeys) {\n      if (!shouldIncludeKey(topKey)) {\n        continue\n      }\n      payload[topKey] = getPlainByPath(topKey)\n      entryMap.set(topKey, { kind: 'property', op: 'set' })\n    }\n    fallbackTopKeys.clear()\n  }\n\n  for (const [path, entry] of patchEntries) {\n    const effectiveOp = entry.kind === 'array' ? 'set' : entry.op\n    if (effectiveOp === 'delete') {\n      payload[path] = null\n      continue\n    }\n    payload[path] = getPlainByPath(path)\n  }\n\n  let computedDirtyProcessed = 0\n  if (includeComputed && dirtyComputedKeys.size) {\n    const computedPatch: Record<string, any> = Object.create(null)\n    const keys = [...dirtyComputedKeys]\n    dirtyComputedKeys.clear()\n    computedDirtyProcessed = keys.length\n    for (const key of keys) {\n      if (!shouldIncludeKey(key)) {\n        continue\n      }\n      const nextValue = toPlain(computedRefs[key].value, seen, { cache: plainCache, cacheEligibility: plainCacheEligibility, maxDepth: toPlainMaxDepth, maxKeys: toPlainMaxKeys, includeFunctions, functionPaths, _path: key })\n      const prevValue = latestComputedSnapshot[key]\n      const equal = computedCompare === 'deep'\n        ? isDeepEqualValue(prevValue, nextValue, computedCompareMaxDepth, { keys: computedCompareMaxKeys })\n        : computedCompare === 'shallow'\n          ? isShallowEqualValue(prevValue, nextValue)\n          : Object.is(prevValue, nextValue)\n      if (equal) {\n        continue\n      }\n      computedPatch[key] = normalizeSetDataValue(nextValue)\n      latestComputedSnapshot[key] = cloneSnapshotValue(nextValue)\n    }\n    Object.assign(payload, computedPatch)\n  }\n\n  let collapsedPayload = collapsePayload(payload)\n  let mergedSiblingParents = 0\n  if (mergeSiblingThreshold) {\n    const mergedResult = mergeSiblingPayload({\n      input: collapsedPayload,\n      entryMap,\n      getPlainByPath,\n      mergeSiblingThreshold,\n      mergeSiblingSkipArray,\n      mergeSiblingMaxParentBytes,\n      mergeSiblingMaxInflationRatio,\n    })\n    mergedSiblingParents = mergedResult.merged\n    collapsedPayload = collapsePayload(mergedResult.out)\n  }\n  const sizeCheck = checkPayloadSize(collapsedPayload, maxPayloadBytes)\n  const shouldFallback = sizeCheck.fallback\n  emitDebug({\n    mode: shouldFallback ? 'diff' : 'patch',\n    reason: shouldFallback ? 'maxPayloadBytes' : 'patch',\n    pendingPatchKeys: patchEntries.length,\n    payloadKeys: Object.keys(collapsedPayload).length,\n    mergedSiblingParents: mergedSiblingParents || undefined,\n    computedDirtyKeys: computedDirtyProcessed || undefined,\n    estimatedBytes: sizeCheck.estimatedBytes,\n    bytes: sizeCheck.bytes,\n  })\n  if (shouldFallback) {\n    needsFullSnapshot.value = true\n    pendingPatches.clear()\n    dirtyComputedKeys.clear()\n    return runDiffUpdate('maxPayloadBytes')\n  }\n  if (!Object.keys(collapsedPayload).length) {\n    return\n  }\n\n  // 保持快照同步，确保 patch 模式可安全回退到 diff。\n  for (const [path, value] of Object.entries(collapsedPayload)) {\n    const entry = entryMap.get(path)\n    if (entry) {\n      applySnapshotUpdate(latestSnapshot, path, value, entry.kind === 'array' ? 'set' : entry.op, { cloneValue: false })\n    }\n    else {\n      // 计算属性或 diffSnapshots 生成的顶层键。\n      applySnapshotUpdate(latestSnapshot, path, value, 'set', { cloneValue: false })\n    }\n  }\n\n  if (typeof currentAdapter.setData === 'function') {\n    const result = currentAdapter.setData(collapsedPayload)\n    if (result && typeof (result as Promise<any>).then === 'function') {\n      return (result as Promise<void>).catch(() => {})\n    }\n  }\n  emitDebug({\n    mode: 'patch',\n    reason: 'patch',\n    pendingPatchKeys: patchEntries.length,\n    payloadKeys: Object.keys(collapsedPayload).length,\n  })\n}\n"],"mappings":"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"}
+{"version":3,"file":"patchScheduler.mjs","names":[],"sources":["../../../../../src/runtime/app/setData/patchScheduler.ts"],"sourcesContent":["import type { SetDataDebugInfo } from '../../types'\nimport type { SetDataPayload, SetDataSnapshot } from './commitTracker'\nimport { toPlain } from '../../diff'\nimport { checkPayloadSize, collapsePayload, mergeSiblingPayload } from './payload'\nimport { applySnapshotUpdate, cloneSnapshotValue, isDeepEqualValue, isShallowEqualValue, normalizeSetDataValue } from './snapshot'\n\ninterface PatchEntry {\n  kind: 'property' | 'array'\n  op: 'set' | 'delete'\n}\n\nexport type PatchPreparation\n  = | undefined\n    | {\n      type: 'fallback'\n      reason: 'maxPatchKeys' | 'maxPayloadBytes'\n      debug: SetDataDebugInfo\n    }\n    | {\n      type: 'patch'\n      payload: SetDataPayload\n      snapshot: SetDataSnapshot\n      computedUpdates?: SetDataSnapshot\n      debug: SetDataDebugInfo\n    }\n\nexport interface PatchPrepareOptions {\n  state: Record<string, unknown>\n  computedRefs: Record<string, { value: unknown }>\n  dirtyComputedKeys: Set<string>\n  includeComputed: boolean\n  computedCompare: 'reference' | 'shallow' | 'deep'\n  computedCompareMaxDepth: number\n  computedCompareMaxKeys: number\n  shouldIncludeKey: (key: string) => boolean\n  maxPatchKeys: number\n  maxPayloadBytes: number\n  mergeSiblingThreshold: number\n  mergeSiblingMaxInflationRatio: number\n  mergeSiblingMaxParentBytes: number\n  mergeSiblingSkipArray: boolean\n  elevateTopKeyThreshold: number\n  toPlainMaxDepth: number\n  toPlainMaxKeys: number\n  includeFunctions?: boolean\n  functionPaths: string[]\n  plainCache: WeakMap<object, { version: number, value: unknown }>\n  plainCacheEligibility?: WeakMap<object, boolean>\n  pendingPatches: Map<string, PatchEntry>\n  fallbackTopKeys: Set<string>\n  dispatchedSnapshot: SetDataSnapshot\n  dispatchedComputedSnapshot: SetDataSnapshot\n}\n\nexport function preparePatchUpdate(options: PatchPrepareOptions): PatchPreparation {\n  const {\n    state,\n    computedRefs,\n    dirtyComputedKeys,\n    includeComputed,\n    computedCompare,\n    computedCompareMaxDepth,\n    computedCompareMaxKeys,\n    shouldIncludeKey,\n    maxPatchKeys,\n    maxPayloadBytes,\n    mergeSiblingThreshold,\n    mergeSiblingMaxInflationRatio,\n    mergeSiblingMaxParentBytes,\n    mergeSiblingSkipArray,\n    elevateTopKeyThreshold,\n    toPlainMaxDepth,\n    toPlainMaxKeys,\n    includeFunctions = false,\n    functionPaths,\n    plainCache,\n    plainCacheEligibility,\n    pendingPatches,\n    fallbackTopKeys,\n    dispatchedSnapshot,\n    dispatchedComputedSnapshot,\n  } = options\n\n  if (pendingPatches.size > maxPatchKeys) {\n    const pendingCount = pendingPatches.size\n    pendingPatches.clear()\n    dirtyComputedKeys.clear()\n    return {\n      type: 'fallback',\n      reason: 'maxPatchKeys',\n      debug: {\n        mode: 'diff',\n        reason: 'maxPatchKeys',\n        pendingPatchKeys: pendingCount,\n        payloadKeys: 0,\n      },\n    }\n  }\n\n  const seen = new WeakMap<object, unknown>()\n  const plainByPath = new Map<string, unknown>()\n  const payload: SetDataPayload = Object.create(null) as SetDataPayload\n  const patchEntriesRaw = [...pendingPatches.entries()]\n\n  if (Number.isFinite(elevateTopKeyThreshold) && elevateTopKeyThreshold > 0) {\n    const counts = new Map<string, number>()\n    for (const [path] of patchEntriesRaw) {\n      const top = path.split('.', 1)[0]!\n      counts.set(top, (counts.get(top) ?? 0) + 1)\n    }\n    for (const [top, count] of counts) {\n      if (count >= elevateTopKeyThreshold) {\n        fallbackTopKeys.add(top)\n      }\n    }\n  }\n\n  const patchEntries = patchEntriesRaw.filter(([path]) => {\n    for (const topKey of fallbackTopKeys) {\n      if (path === topKey || path.startsWith(`${topKey}.`)) {\n        return false\n      }\n    }\n    return true\n  })\n  const entryMap = new Map<string, PatchEntry>(patchEntries)\n  pendingPatches.clear()\n\n  const getStateValueByPath = (path: string) => {\n    const segments = path.split('.').filter(Boolean)\n    let current: unknown = state\n    for (const segment of segments) {\n      if (current == null || typeof current !== 'object') {\n        return current\n      }\n      current = Reflect.get(current, segment)\n    }\n    return current\n  }\n\n  const getPlainByPath = (path: string) => {\n    if (plainByPath.has(path)) {\n      return plainByPath.get(path)\n    }\n    const value = normalizeSetDataValue(\n      toPlain(getStateValueByPath(path), seen, {\n        cache: plainCache,\n        cacheEligibility: plainCacheEligibility,\n        maxDepth: toPlainMaxDepth,\n        maxKeys: toPlainMaxKeys,\n        includeFunctions,\n        functionPaths,\n        _path: path,\n      }),\n    )\n    plainByPath.set(path, value)\n    return value\n  }\n\n  if (fallbackTopKeys.size) {\n    for (const topKey of fallbackTopKeys) {\n      if (!shouldIncludeKey(topKey)) {\n        continue\n      }\n      payload[topKey] = getPlainByPath(topKey)\n      entryMap.set(topKey, { kind: 'property', op: 'set' })\n    }\n    fallbackTopKeys.clear()\n  }\n\n  for (const [path, entry] of patchEntries) {\n    const effectiveOp = entry.kind === 'array' ? 'set' : entry.op\n    payload[path] = effectiveOp === 'delete'\n      ? null\n      : getPlainByPath(path)\n  }\n\n  let computedDirtyProcessed = 0\n  const computedUpdates: SetDataSnapshot = Object.create(null) as SetDataSnapshot\n  if (includeComputed && dirtyComputedKeys.size) {\n    const keys = [...dirtyComputedKeys]\n    dirtyComputedKeys.clear()\n    computedDirtyProcessed = keys.length\n    for (const key of keys) {\n      if (!shouldIncludeKey(key)) {\n        continue\n      }\n      const nextValue = toPlain(computedRefs[key]!.value, seen, {\n        cache: plainCache,\n        cacheEligibility: plainCacheEligibility,\n        maxDepth: toPlainMaxDepth,\n        maxKeys: toPlainMaxKeys,\n        includeFunctions,\n        functionPaths,\n        _path: key,\n      })\n      const prevValue = dispatchedComputedSnapshot[key]\n      const equal = computedCompare === 'deep'\n        ? isDeepEqualValue(prevValue, nextValue, computedCompareMaxDepth, { keys: computedCompareMaxKeys })\n        : computedCompare === 'shallow'\n          ? isShallowEqualValue(prevValue, nextValue)\n          : Object.is(prevValue, nextValue)\n      if (equal) {\n        continue\n      }\n      payload[key] = normalizeSetDataValue(nextValue)\n      computedUpdates[key] = cloneSnapshotValue(nextValue)\n    }\n  }\n\n  let collapsedPayload = collapsePayload(payload)\n  let mergedSiblingParents = 0\n  if (mergeSiblingThreshold) {\n    const mergedResult = mergeSiblingPayload({\n      input: collapsedPayload,\n      entryMap,\n      getPlainByPath,\n      mergeSiblingThreshold,\n      mergeSiblingSkipArray,\n      mergeSiblingMaxParentBytes,\n      mergeSiblingMaxInflationRatio,\n    })\n    mergedSiblingParents = mergedResult.merged\n    collapsedPayload = collapsePayload(mergedResult.out)\n  }\n  const sizeCheck = checkPayloadSize(collapsedPayload, maxPayloadBytes)\n  const payloadKeys = Object.keys(collapsedPayload).length\n  const debug: SetDataDebugInfo = {\n    mode: sizeCheck.fallback ? 'diff' : 'patch',\n    reason: sizeCheck.fallback ? 'maxPayloadBytes' : 'patch',\n    pendingPatchKeys: patchEntries.length,\n    payloadKeys,\n    mergedSiblingParents: mergedSiblingParents || undefined,\n    computedDirtyKeys: computedDirtyProcessed || undefined,\n    estimatedBytes: sizeCheck.estimatedBytes,\n    bytes: sizeCheck.bytes,\n  }\n  if (sizeCheck.fallback) {\n    return {\n      type: 'fallback',\n      reason: 'maxPayloadBytes',\n      debug,\n    }\n  }\n  if (!payloadKeys) {\n    return undefined\n  }\n\n  const snapshot: SetDataSnapshot = { ...dispatchedSnapshot }\n  const clonedParents = new WeakSet<object>()\n  for (const [path, value] of Object.entries(collapsedPayload)) {\n    const entry = entryMap.get(path)\n    applySnapshotUpdate(\n      snapshot,\n      path,\n      value,\n      entry?.kind === 'array' ? 'set' : (entry?.op ?? 'set'),\n      { cloneValue: false, clonedParents },\n    )\n  }\n\n  return {\n    type: 'patch',\n    payload: collapsedPayload,\n    snapshot,\n    computedUpdates: Object.keys(computedUpdates).length ? computedUpdates : undefined,\n    debug,\n  }\n}\n"],"mappings":"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"}

package/dist/dev/runtime/app/setData/scheduler.d.mts

@@ -0,0 +1,51 @@
+import { SetDataDebugInfo } from "../../types/setData.mjs";
+import "../../types.mjs";
+import { CommitAwareSetDataAdapter } from "./commitTracker.mjs";
+import "../../capabilities.mjs";
+import { WevuRuntimeBindingManifestV1 } from "@weapp-core/constants";
+//#region src/runtime/app/setData/scheduler.d.ts
+export interface SetDataSchedulerOptions {
+  state: Record<string, any>;
+  setupState?: Record<string, any>;
+  snapshotOmitKeys?: Set<string>;
+  computedRefs: Record<string, {
+    value: any;
+  }>;
+  dirtyComputedKeys: Set<string>;
+  includeComputed: boolean;
+  setDataStrategy: 'diff' | 'patch';
+  computedCompare: 'reference' | 'shallow' | 'deep';
+  computedCompareMaxDepth: number;
+  computedCompareMaxKeys: number;
+  currentAdapter: CommitAwareSetDataAdapter;
+  shouldIncludeKey: (key: string) => boolean;
+  maxPatchKeys: number;
+  maxPayloadBytes: number;
+  mergeSiblingThreshold: number;
+  mergeSiblingMaxInflationRatio: number;
+  mergeSiblingMaxParentBytes: number;
+  mergeSiblingSkipArray: boolean;
+  elevateTopKeyThreshold: number;
+  prelinkMaxDepth?: number;
+  prelinkMaxKeys?: number;
+  toPlainMaxDepth: number;
+  toPlainMaxKeys: number;
+  includeFunctions?: boolean;
+  functionPaths: string[];
+  debug: ((info: SetDataDebugInfo) => void) | undefined;
+  debugWhen: 'fallback' | 'always';
+  debugSampleRate: number;
+  bindingManifest?: WevuRuntimeBindingManifestV1;
+  loopWarning: false | {
+    sampleWindowMs: number;
+    maxFlushes: number;
+    coolDownMs: number;
+  };
+  targetLabel?: string;
+  runTracker: () => void;
+  isMounted: () => boolean;
+  initialSnapshot?: Record<string, any>;
+  initialState?: Record<string, any>;
+}
+//#endregion
+//# sourceMappingURL=scheduler.d.mts.map

package/dist/dev/runtime/app/setData/scheduler.mjs

@@ -3,22 +3,19 @@ import { getReactiveVersion, isReactive } from "../../../reactivity/reactive.mjs
 import { isRef } from "../../../reactivity/ref.mjs";
 import { hasOwn } from "../../../utils.mjs";
 import { hasTrackableSetupBinding } from "../../setupTracking.mjs";
+import { resolveBindingDiagnostics } from "../../bindingManifest.mjs";
 import { diffSnapshots, toPlain } from "../../diff.mjs";
 import { collectSnapshot } from "./snapshot.mjs";
-import { runPatchUpdate } from "./patchScheduler.mjs";
+import { createSetDataCommitTracker } from "./commitTracker.mjs";
 
 //#region src/runtime/app/setData/scheduler.ts
 function createSetDataScheduler(options) {
-	const { state, setupState, snapshotOmitKeys, computedRefs, dirtyComputedKeys, includeComputed, setDataStrategy, computedCompare, computedCompareMaxDepth, computedCompareMaxKeys, currentAdapter, shouldIncludeKey, maxPatchKeys, maxPayloadBytes, mergeSiblingThreshold, mergeSiblingMaxInflationRatio, mergeSiblingMaxParentBytes, mergeSiblingSkipArray, elevateTopKeyThreshold, toPlainMaxDepth, toPlainMaxKeys, includeFunctions = false, functionPaths, debug, debugWhen, debugSampleRate, loopWarning, targetLabel, runTracker, isMounted, initialSnapshot, initialState } = options;
+	const { state, setupState, snapshotOmitKeys, computedRefs, dirtyComputedKeys, includeComputed, setDataStrategy, currentAdapter, shouldIncludeKey, toPlainMaxDepth, toPlainMaxKeys, includeFunctions = false, functionPaths, debug, debugWhen, debugSampleRate, bindingManifest, loopWarning, targetLabel, runTracker, isMounted, initialSnapshot, initialState } = options;
 	const plainCache = /* @__PURE__ */ new WeakMap();
 	const plainCacheEligibility = /* @__PURE__ */ new WeakMap();
-	let latestSnapshot = {};
-	let latestComputedSnapshot = Object.create(null);
-	const latestStateTokens = Object.create(null);
-	const latestComputedTokens = Object.create(null);
-	const needsFullSnapshot = { value: setDataStrategy === "patch" };
-	const pendingPatches = /* @__PURE__ */ new Map();
-	const fallbackTopKeys = /* @__PURE__ */ new Set();
+	const initialSnapshotBaseline = {};
+	const dispatchedStateTokens = Object.create(null);
+	const dispatchedComputedTokens = Object.create(null);
 	const flushTimes = [];
 	let lastLoopWarningAt = Number.NEGATIVE_INFINITY;
 	const initialStateKeys = new Set(initialState && typeof initialState === "object" ? Object.keys(initialState) : []);
@@ -67,7 +64,7 @@ function createSetDataScheduler(options) {
 	};
 	const shouldIncludeSnapshotKey = (key) => shouldIncludeKey(key) && !(snapshotOmitKeys === null || snapshotOmitKeys === void 0 ? void 0 : snapshotOmitKeys.has(key));
 	if (initialSnapshot) {
-		for (const [key, value] of Object.entries(initialSnapshot)) if (shouldIncludeSnapshotKey(key)) latestSnapshot[key] = value;
+		for (const [key, value] of Object.entries(initialSnapshot)) if (shouldIncludeSnapshotKey(key)) initialSnapshotBaseline[key] = value;
 	}
 	const syncInitialSnapshotTokens = () => {
 		if (!initialSnapshot) return;
@@ -76,13 +73,13 @@ function createSetDataScheduler(options) {
 		for (const key of Object.keys(initialSnapshot)) {
 			if (!shouldIncludeSnapshotKey(key)) continue;
 			if (rawSetupState && hasOwn(rawSetupState, key)) {
-				latestStateTokens[key] = createValueToken(rawSetupState[key]);
+				dispatchedStateTokens[key] = createValueToken(rawSetupState[key]);
 				continue;
 			}
 			if (hasOwn(rawState, key)) {
 				if (initialStateKeys.has(key)) continue;
 				rawState[key] = initialSnapshot[key];
-				latestStateTokens[key] = createValueToken(rawState[key]);
+				dispatchedStateTokens[key] = createValueToken(rawState[key]);
 			}
 		}
 	};
@@ -98,16 +95,45 @@ function createSetDataScheduler(options) {
 		}
 		return matches;
 	};
-	const emitDebug = (info) => {
+	const emitDebug = (info, pathSource) => {
 		if (!debug) return;
 		const isFallback = info.reason !== "patch" && info.reason !== "diff";
 		if (debugWhen === "fallback" && !isFallback) return;
-		if (debugSampleRate < 1 && Math.random() > debugSampleRate) return;
+		if (info.reason !== "commitFailure" && debugSampleRate < 1 && Math.random() > debugSampleRate) return;
+		let debugInfo = info;
+		if (bindingManifest) {
+			const paths = typeof pathSource === "function" ? pathSource() : pathSource !== null && pathSource !== void 0 ? pathSource : [];
+			const wholeSnapshotFallback = info.reason === "needsFullSnapshot" || info.reason === "maxPatchKeys" || info.reason === "maxPayloadBytes";
+			debugInfo = {
+				...info,
+				bindings: resolveBindingDiagnostics(bindingManifest, paths, wholeSnapshotFallback)
+			};
+		}
 		try {
-			debug(info);
+			debug(debugInfo);
 		} catch (_unused) {}
 	};
-	const recordFlushForLoopWarning = () => {
+	const commitTracker = createSetDataCommitTracker({
+		initialSnapshot: initialSnapshotBaseline,
+		adapter: currentAdapter,
+		onFailure: (failure) => {
+			emitDebug({
+				mode: failure.mode,
+				reason: "commitFailure",
+				pendingPatchKeys: failure.pendingPatchKeys,
+				payloadKeys: failure.payloadKeys,
+				revision: failure.revision,
+				committedRevision: failure.committedRevision,
+				targetLabel,
+				message: failure.error.message
+			});
+			try {
+				var _currentAdapter$__wev;
+				(_currentAdapter$__wev = currentAdapter.__wevu_reportSetDataError) === null || _currentAdapter$__wev === void 0 || _currentAdapter$__wev.call(currentAdapter, failure.error);
+			} catch (_unused2) {}
+		}
+	});
+	const recordFlushForLoopWarning = (pendingPatchKeys = 0, pathSource) => {
 		if (!loopWarning) return;
 		const current = Date.now();
 		flushTimes.push(current);
@@ -119,14 +145,14 @@ function createSetDataScheduler(options) {
 		emitDebug({
 			mode: setDataStrategy,
 			reason: "loopWarning",
-			pendingPatchKeys: pendingPatches.size + fallbackTopKeys.size,
+			pendingPatchKeys,
 			payloadKeys: 0,
 			computedDirtyKeys: includeComputed ? dirtyComputedKeys.size : 0,
 			flushCount: flushTimes.length,
 			windowMs: loopWarning.sampleWindowMs,
 			targetLabel,
 			message: `${targetLabel ? `${targetLabel} ` : ""}疑似运行时更新循环：${flushTimes.length} 次 setData flush/${loopWarning.sampleWindowMs}ms`
-		});
+		}, pathSource);
 	};
 	const collect = () => collectSnapshot({
 		state,
@@ -145,7 +171,8 @@ function createSetDataScheduler(options) {
 	const collectDiffSnapshot = () => {
 		const rawState = isReactive(state) ? toRaw(state) : state;
 		const rawSetupState = setupState && typeof setupState === "object" ? isReactive(setupState) ? toRaw(setupState) : setupState : void 0;
-		const nextSnapshot = { ...latestSnapshot };
+		const dispatchedSnapshot = commitTracker.state.dispatchedSnapshot;
+		const nextSnapshot = { ...dispatchedSnapshot };
 		const seen = /* @__PURE__ */ new WeakMap();
 		const includedStateKeys = /* @__PURE__ */ new Set();
 		const includedComputedKeys = /* @__PURE__ */ new Set();
@@ -155,9 +182,9 @@ function createSetDataScheduler(options) {
 			includedStateKeys.add(key);
 			const source = rawSetupState && hasOwn(rawSetupState, key) ? rawSetupState : rawState;
 			const token = createValueToken(source[key]);
-			const previousToken = latestStateTokens[key];
+			const previousToken = dispatchedStateTokens[key];
 			if (previousToken && token && typeof previousToken === "object" && typeof token === "object" && hasOwn(previousToken, "raw") && hasOwn(token, "raw") && Array.isArray(previousToken.raw) && Array.isArray(token.raw) && previousToken.raw !== token.raw) replacedTopLevelKeys.add(key);
-			if (!isSameToken(previousToken, token) || !hasOwn(latestSnapshot, key)) nextSnapshot[key] = toPlain(source[key], seen, {
+			if (!isSameToken(previousToken, token) || !hasOwn(dispatchedSnapshot, key)) nextSnapshot[key] = toPlain(source[key], seen, {
 				cache: plainCache,
 				cacheEligibility: plainCacheEligibility,
 				maxDepth: toPlainMaxDepth,
@@ -166,14 +193,14 @@ function createSetDataScheduler(options) {
 				functionPaths,
 				_path: key
 			});
-			latestStateTokens[key] = token;
+			dispatchedStateTokens[key] = token;
 		}
-		for (const key of Object.keys(latestStateTokens)) if (!includedStateKeys.has(key)) {
-			delete latestStateTokens[key];
+		for (const key of Object.keys(dispatchedStateTokens)) if (!includedStateKeys.has(key)) {
+			delete dispatchedStateTokens[key];
 			if (!includeComputed || !hasOwn(computedRefs, key)) delete nextSnapshot[key];
 		}
 		if (!includeComputed) {
-			for (const key of Object.keys(latestComputedTokens)) delete latestComputedTokens[key];
+			for (const key of Object.keys(dispatchedComputedTokens)) delete dispatchedComputedTokens[key];
 			return {
 				snapshot: nextSnapshot,
 				replacedTopLevelKeys
@@ -184,7 +211,7 @@ function createSetDataScheduler(options) {
 			includedComputedKeys.add(key);
 			const value = computedRefs[key].value;
 			const token = createValueToken(value);
-			if (!isSameToken(latestComputedTokens[key], token) || !hasOwn(latestSnapshot, key)) nextSnapshot[key] = toPlain(value, seen, {
+			if (!isSameToken(dispatchedComputedTokens[key], token) || !hasOwn(dispatchedSnapshot, key)) nextSnapshot[key] = toPlain(value, seen, {
 				cache: plainCache,
 				cacheEligibility: plainCacheEligibility,
 				maxDepth: toPlainMaxDepth,
@@ -193,10 +220,10 @@ function createSetDataScheduler(options) {
 				functionPaths,
 				_path: key
 			});
-			latestComputedTokens[key] = token;
+			dispatchedComputedTokens[key] = token;
 		}
-		for (const key of Object.keys(latestComputedTokens)) if (!includedComputedKeys.has(key)) {
-			delete latestComputedTokens[key];
+		for (const key of Object.keys(dispatchedComputedTokens)) if (!includedComputedKeys.has(key)) {
+			delete dispatchedComputedTokens[key];
 			if (!hasOwn(rawState, key) || !shouldIncludeSnapshotKey(key)) delete nextSnapshot[key];
 		}
 		return {
@@ -204,107 +231,67 @@ function createSetDataScheduler(options) {
 			replacedTopLevelKeys
 		};
 	};
-	const runDiffUpdate = (reason = "diff") => {
+	const runDiffUpdate = (reason = "diff", pendingPatchKeys = 0, onSnapshotPrepared) => {
 		var _diffCollection$snaps;
 		const diffCollection = setDataStrategy === "diff" ? collectDiffSnapshot() : void 0;
 		const snapshot = (_diffCollection$snaps = diffCollection === null || diffCollection === void 0 ? void 0 : diffCollection.snapshot) !== null && _diffCollection$snaps !== void 0 ? _diffCollection$snaps : collect();
-		const diff = diffCollection ? (() => {
+		const dispatchedSnapshot = commitTracker.state.dispatchedSnapshot;
+		const needsRecovery = commitTracker.state.needsFullSnapshot;
+		const payload = needsRecovery ? commitTracker.createFullPayload(snapshot) : diffCollection ? (() => {
 			const fastDiff = {};
 			for (const key of diffCollection.replacedTopLevelKeys) fastDiff[key] = snapshot[key];
 			return {
-				...diffSnapshots(latestSnapshot, snapshot, { skipKeys: diffCollection.replacedTopLevelKeys }),
+				...diffSnapshots(dispatchedSnapshot, snapshot, { skipKeys: diffCollection.replacedTopLevelKeys }),
 				...fastDiff
 			};
-		})() : diffSnapshots(latestSnapshot, snapshot);
-		latestSnapshot = snapshot;
-		needsFullSnapshot.value = false;
-		pendingPatches.clear();
-		if (setDataStrategy === "patch" && includeComputed) {
-			latestComputedSnapshot = Object.create(null);
-			for (const key of Object.keys(computedRefs)) {
-				if (!shouldIncludeSnapshotKey(key)) continue;
-				latestComputedSnapshot[key] = snapshot[key];
-			}
-			dirtyComputedKeys.clear();
-		}
-		if (!Object.keys(diff).length) return;
-		if (typeof currentAdapter.setData === "function") {
-			const result = currentAdapter.setData(diff);
-			if (result && typeof result.then === "function") return result.catch(() => {});
-		}
+		})() : diffSnapshots(dispatchedSnapshot, snapshot);
+		onSnapshotPrepared === null || onSnapshotPrepared === void 0 || onSnapshotPrepared(snapshot);
+		const payloadKeys = Object.keys(payload).length;
+		if (!payloadKeys && !needsRecovery) return;
+		const effectiveReason = needsRecovery ? "needsFullSnapshot" : reason;
 		emitDebug({
 			mode: "diff",
-			reason,
-			pendingPatchKeys: 0,
-			payloadKeys: Object.keys(diff).length
+			reason: effectiveReason,
+			pendingPatchKeys,
+			payloadKeys
+		}, Object.keys(payload));
+		commitTracker.dispatch({
+			mode: "diff",
+			kind: needsRecovery ? "full" : "delta",
+			reason: effectiveReason,
+			snapshot,
+			payload,
+			pendingPatchKeys
 		});
 	};
-	const mutationRecorder = (record, stateRootRaw) => {
-		if (!isMounted()) return;
-		if (record.root !== stateRootRaw) {
-			const topKeys = resolveTopKeysByRoot(record.root);
-			if (topKeys.length) for (const key of topKeys) fallbackTopKeys.add(key);
-			return;
-		}
-		if (!record.path) {
-			if (Array.isArray(record.fallbackTopKeys) && record.fallbackTopKeys.length) for (const key of record.fallbackTopKeys) fallbackTopKeys.add(key);
-			else needsFullSnapshot.value = true;
-			return;
-		}
-		const topKey = record.path.split(".", 1)[0];
-		if (!shouldIncludeSnapshotKey(topKey)) return;
-		pendingPatches.set(record.path, {
-			kind: record.kind,
-			op: record.op
-		});
+	const prepareJob = (pendingPatchKeys = 0, pathSource) => {
+		if (!isMounted()) return false;
+		recordFlushForLoopWarning(pendingPatchKeys, pathSource);
+		runTracker();
+		return true;
 	};
 	const job = (_stateRootRaw) => {
-		if (!isMounted()) return;
-		recordFlushForLoopWarning();
-		runTracker();
-		if (setDataStrategy === "patch" && !needsFullSnapshot.value) {
-			if (!(pendingPatches.size > 0 || fallbackTopKeys.size > 0 || includeComputed && dirtyComputedKeys.size > 0)) return runDiffUpdate("diff");
-			return runPatchUpdate({
-				state,
-				computedRefs,
-				dirtyComputedKeys,
-				includeComputed,
-				computedCompare,
-				computedCompareMaxDepth,
-				computedCompareMaxKeys,
-				currentAdapter,
-				shouldIncludeKey: shouldIncludeSnapshotKey,
-				maxPatchKeys,
-				maxPayloadBytes,
-				mergeSiblingThreshold,
-				mergeSiblingMaxInflationRatio,
-				mergeSiblingMaxParentBytes,
-				mergeSiblingSkipArray,
-				elevateTopKeyThreshold,
-				toPlainMaxDepth,
-				toPlainMaxKeys,
-				includeFunctions,
-				functionPaths,
-				plainCache,
-				plainCacheEligibility,
-				pendingPatches,
-				fallbackTopKeys,
-				latestSnapshot,
-				latestComputedSnapshot,
-				needsFullSnapshot,
-				emitDebug,
-				runDiffUpdate
-			});
-		} else return runDiffUpdate(needsFullSnapshot.value ? "needsFullSnapshot" : "diff");
+		if (!prepareJob()) return;
+		return runDiffUpdate("diff");
 	};
-	const snapshot = () => setDataStrategy === "patch" ? collect() : { ...latestSnapshot };
-	const cloneLatestSnapshot = () => ({ ...latestSnapshot });
+	const snapshot = () => setDataStrategy === "patch" ? collect() : { ...commitTracker.state.dispatchedSnapshot };
+	const cloneLatestSnapshot = () => ({ ...commitTracker.state.dispatchedSnapshot });
 	return {
+		collect,
+		emitDebug,
+		getLatestSnapshot: () => commitTracker.state.dispatchedSnapshot,
+		dispatchUpdate: commitTracker.dispatch,
+		needsFullSnapshot: () => commitTracker.state.needsFullSnapshot,
 		job,
-		mutationRecorder,
+		plainCache,
+		plainCacheEligibility,
+		prepareJob,
+		resolveTopKeysByRoot,
+		runDiffUpdate,
+		shouldIncludeSnapshotKey,
 		snapshot,
 		cloneLatestSnapshot,
-		getLatestSnapshot: () => latestSnapshot
+		dispose: commitTracker.dispose
 	};
 }