@stream-mdx/react 0.4.0 → 1.0.0

package/dist/renderer/patch-commit-scheduler.cjs

@@ -6,17 +6,14 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
     for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 
 // src/renderer/patch-commit-scheduler.ts
 var patch_commit_scheduler_exports = {};
@@ -24,232 +21,172 @@ __export(patch_commit_scheduler_exports, {
   PatchCommitScheduler: () => PatchCommitScheduler
 });
 module.exports = __toCommonJS(patch_commit_scheduler_exports);
+var import_patch_batching = require("@stream-mdx/core/perf/patch-batching");
 
 // src/renderer/patch-coalescing.ts
 var import_core = require("@stream-mdx/core");
 
 // src/renderer/patch-commit-scheduler.ts
-var DEFAULT_TIMEOUT_MS = 16;
-var COALESCING_DURATION_SAMPLE_LIMIT = 60;
-var COALESCING_DURATION_ACTIVATE_MS = 6;
-var COALESCING_DURATION_DEACTIVATE_MS = 4;
-var RETAIN_TOUCHED_IN_HISTORY = typeof process !== "undefined" && process.env ? process.env.NODE_ENV !== "production" : true;
-var EMPTY_TOUCHED_SET = /* @__PURE__ */ new Set();
+var DEFAULT_TIMEOUT_MS = 16, COALESCING_DURATION_SAMPLE_LIMIT = 60, COALESCING_DURATION_ACTIVATE_MS = 6, COALESCING_DURATION_DEACTIVATE_MS = 4, RETAIN_TOUCHED_IN_HISTORY = typeof process < "u" && process.env ? process.env.NODE_ENV !== "production" : !0, EMPTY_TOUCHED_SET = /* @__PURE__ */ new Set();
+function semanticEnvelopeKeyForPatch(patch) {
+  if ((0, import_patch_batching.getPatchKind)(patch) !== "semantic") return;
+  let meta = patch.op === "setHTML" ? patch.patchMeta : patch.meta, streamSeq = meta?.streamSeq, parseEpoch = meta?.parseEpoch, tx = meta?.tx;
+  if (!(typeof streamSeq != "number" || !Number.isFinite(streamSeq) || streamSeq < 0 || typeof parseEpoch != "number" || !Number.isFinite(parseEpoch) || parseEpoch < 0 || typeof tx != "number" || !Number.isFinite(tx) || tx < 0))
+    return `${streamSeq}/${parseEpoch}/${tx}`;
+}
+function shouldSkipCoalescing(patches) {
+  if (patches.length <= 1) return !0;
+  let firstEnvelopeKey, hasEnvelopeKey = !1, hasMultipleEnvelopes = !1, hasUnsequencedSemantic = !1, hasEnrichment = !1, observePatch = (patch) => {
+    if ((0, import_patch_batching.getPatchKind)(patch) === "enrichment") {
+      hasEnrichment = !0;
+      return;
+    }
+    let key = semanticEnvelopeKeyForPatch(patch);
+    if (key === void 0) {
+      hasUnsequencedSemantic = !0;
+      return;
+    }
+    hasEnvelopeKey && firstEnvelopeKey !== key && (hasMultipleEnvelopes = !0), hasEnvelopeKey || (firstEnvelopeKey = key, hasEnvelopeKey = !0);
+  };
+  for (let patch of patches)
+    if (patch.op === "setPropsBatch")
+      for (let entry of patch.entries ?? [])
+        !entry || !entry.at || observePatch({
+          op: "setProps",
+          at: entry.at,
+          props: entry.props,
+          meta: { ...patch.meta ?? {}, ...entry.meta ?? {} }
+        });
+    else
+      observePatch(patch);
+  return hasEnvelopeKey && (hasMultipleEnvelopes || hasUnsequencedSemantic || hasEnrichment);
+}
 function getDefaultNow() {
-  if (typeof performance !== "undefined" && typeof performance.now === "function") {
-    return () => performance.now();
-  }
-  return () => Date.now();
+  return typeof performance < "u" && typeof performance.now == "function" ? () => performance.now() : () => Date.now();
 }
 function getDefaultRaf() {
-  if (typeof globalThis !== "undefined") {
-    const candidate = globalThis.requestAnimationFrame;
-    if (typeof candidate === "function") {
+  if (typeof globalThis < "u") {
+    let candidate = globalThis.requestAnimationFrame;
+    if (typeof candidate == "function")
       return candidate.bind(globalThis);
-    }
   }
   return null;
 }
 function getDefaultCancelRaf() {
-  if (typeof globalThis !== "undefined") {
-    const candidate = globalThis.cancelAnimationFrame;
-    if (typeof candidate === "function") {
+  if (typeof globalThis < "u") {
+    let candidate = globalThis.cancelAnimationFrame;
+    if (typeof candidate == "function")
       return candidate.bind(globalThis);
-    }
   }
   return null;
 }
 var PatchCommitScheduler = class {
   constructor(params) {
-    this.highQueue = [];
-    this.lowQueue = [];
-    this.scheduled = false;
-    this.flushing = false;
+    this.semanticQueue = [];
+    this.enrichmentHighQueue = [];
+    this.enrichmentLowQueue = [];
+    this.scheduled = !1;
+    this.flushing = !1;
     this.scheduledHandle = null;
-    this.scheduledViaRaf = false;
+    this.scheduledViaRaf = !1;
     this.sequence = 0;
     this.idleResolvers = [];
-    this.paused = false;
+    this.paused = !1;
     this.history = [];
     this.scheduleToken = 0;
     this.coalescingDurationSamples = [];
-    this.adaptiveBudgetActive = false;
-    this.store = params.store;
-    this.onFlush = params.onFlush;
-    this.frameBudgetMs = Math.max(1, params.options?.frameBudgetMs ?? 10);
-    this.maxBatchesPerFlush = params.options?.maxBatchesPerFlush ?? 12;
-    this.now = params.options?.now ?? getDefaultNow();
-    this.raf = params.options?.raf ?? getDefaultRaf();
-    this.cancelRaf = params.options?.cancelRaf ?? getDefaultCancelRaf();
-    this.timeoutMs = Math.max(1, params.options?.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-    this.lowPriorityFrameBudgetMs = Math.max(
+    this.adaptiveBudgetActive = !1;
+    this.flushCount = 0;
+    this.store = params.store, this.onFlush = params.onFlush, this.isGenerationCurrent = params.isGenerationCurrent, this.frameBudgetMs = Math.max(1, params.options?.frameBudgetMs ?? 4), this.maxBatchesPerFlush = params.options?.maxBatchesPerFlush ?? 12, this.now = params.options?.now ?? getDefaultNow(), this.raf = params.options?.raf ?? getDefaultRaf(), this.cancelRaf = params.options?.cancelRaf ?? getDefaultCancelRaf(), this.timeoutMs = Math.max(1, params.options?.timeoutMs ?? DEFAULT_TIMEOUT_MS), this.lowPriorityFrameBudgetMs = Math.max(
       1,
       params.options?.lowPriorityFrameBudgetMs ?? Math.max(2, Math.floor(this.frameBudgetMs * 0.6))
-    );
-    this.maxLowPriorityBatchesPerFlush = params.options?.maxLowPriorityBatchesPerFlush ?? 2;
-    this.urgentQueueThreshold = Math.max(1, params.options?.urgentQueueThreshold ?? 4);
-    this.historyLimit = Math.max(1, params.options?.historyLimit ?? 200);
-    const requestedBatch = params.options?.batch;
-    if (requestedBatch === "microtask") {
-      this.batchStrategy = "microtask";
-    } else if (requestedBatch === "timeout") {
-      this.batchStrategy = "timeout";
-    } else if (requestedBatch === "rAF") {
-      this.batchStrategy = this.raf ? "rAF" : "timeout";
-    } else {
-      this.batchStrategy = "microtask";
-    }
-    if (this.batchStrategy === "microtask" && typeof queueMicrotask !== "function") {
-      this.batchStrategy = this.raf ? "rAF" : "timeout";
-    }
+    ), this.maxLowPriorityBatchesPerFlush = params.options?.maxLowPriorityBatchesPerFlush ?? 2, this.urgentQueueThreshold = Math.max(1, params.options?.urgentQueueThreshold ?? 4), this.historyLimit = Math.max(1, params.options?.historyLimit ?? 200), this.startupMicrotaskFlushes = Math.max(0, Math.floor(params.options?.startupMicrotaskFlushes ?? 0)), this.adaptiveBudgeting = params.options?.adaptiveBudgeting ?? !0;
+    let requestedBatch = params.options?.batch;
+    requestedBatch === "microtask" ? this.batchStrategy = "microtask" : requestedBatch === "timeout" ? this.batchStrategy = "timeout" : requestedBatch === "rAF" ? this.batchStrategy = this.raf ? "rAF" : "timeout" : this.batchStrategy = this.raf ? "rAF" : "timeout", this.batchStrategy === "microtask" && typeof queueMicrotask != "function" && (this.batchStrategy = this.raf ? "rAF" : "timeout");
   }
   enqueue(input) {
-    if (!input || !input.patches || input.patches.length === 0) {
+    if (!input || !input.patches || input.patches.length === 0)
       return;
-    }
-    if (!this.paused && !this.flushing && this.getPendingCount() >= this.urgentQueueThreshold) {
-      this.runFlush(this.frameBudgetMs, false);
-    }
-    const batch = {
+    this.batchStrategy !== "rAF" && !this.paused && !this.flushing && this.getPendingCount() >= this.urgentQueueThreshold && this.runFlush(this.frameBudgetMs, !1);
+    let explicitKind = input.meta?.kind, hasExplicitKind = explicitKind === "semantic" || explicitKind === "enrichment", hasSemanticPatch = !1, hasNonInputSourcePatch = !1;
+    for (let patch of input.patches)
+      patch.op !== "appendInputSource" && (hasNonInputSourcePatch = !0), !hasExplicitKind && !hasSemanticPatch && (0, import_patch_batching.getPatchKind)(patch) === "semantic" && (hasSemanticPatch = !0);
+    let batch = {
       seq: ++this.sequence,
       patches: input.patches,
       meta: input.meta ?? {},
       receivedAt: input.meta?.receivedAt ?? this.now(),
+      kind: explicitKind === "semantic" || explicitKind === "enrichment" ? explicitKind : hasSemanticPatch ? "semantic" : "enrichment",
+      hasNonInputSourcePatch,
       priority: input.meta?.priority === "low" ? "low" : "high"
     };
-    if (batch.priority === "low") {
-      this.lowQueue.push(batch);
-    } else {
-      this.highQueue.push(batch);
-    }
-    if (!this.paused) {
-      this.schedule();
-    }
+    batch.kind === "semantic" ? (batch.priority = "high", this.semanticQueue.push(batch)) : batch.priority === "low" ? this.enrichmentLowQueue.push(batch) : this.enrichmentHighQueue.push(batch), this.paused || this.schedule();
   }
   flushAll() {
-    if (this.highQueue.length === 0 && this.lowQueue.length === 0 && !this.flushing) {
+    if (this.semanticQueue.length === 0 && this.enrichmentHighQueue.length === 0 && this.enrichmentLowQueue.length === 0 && !this.flushing)
       return null;
-    }
     this.cancelScheduled();
-    const result = this.runFlush(Number.POSITIVE_INFINITY, true);
-    this.maybeResolveIdle();
-    return result;
+    let result = this.runFlush(Number.POSITIVE_INFINITY, !0);
+    return this.maybeResolveIdle(), result;
   }
   clear() {
-    this.cancelScheduled();
-    this.highQueue = [];
-    this.lowQueue = [];
-    this.flushing = false;
-    this.coalescingDurationSamples = [];
-    this.adaptiveBudgetActive = false;
-    this.adaptiveHighBatchCap = void 0;
-    this.adaptiveLowBatchCap = void 0;
-    this.maybeResolveIdle();
+    this.cancelScheduled(), this.semanticQueue = [], this.enrichmentHighQueue = [], this.enrichmentLowQueue = [], this.flushing = !1, this.flushCount = 0, this.coalescingDurationSamples = [], this.adaptiveBudgetActive = !1, this.adaptiveHighBatchCap = void 0, this.adaptiveLowBatchCap = void 0, this.maybeResolveIdle();
   }
   getPendingCount() {
-    return this.highQueue.length + this.lowQueue.length;
+    return this.semanticQueue.length + this.enrichmentHighQueue.length + this.enrichmentLowQueue.length;
   }
   isIdle() {
-    return !this.flushing && !this.scheduled && this.highQueue.length === 0 && this.lowQueue.length === 0;
+    return !this.flushing && !this.scheduled && this.semanticQueue.length === 0 && this.enrichmentHighQueue.length === 0 && this.enrichmentLowQueue.length === 0;
   }
   awaitIdle() {
-    if (this.isIdle()) {
-      return Promise.resolve();
-    }
-    return new Promise((resolve) => {
+    return this.isIdle() ? Promise.resolve() : new Promise((resolve) => {
       this.idleResolvers.push(resolve);
     });
   }
   schedule() {
-    if (this.paused) {
-      return;
-    }
-    if (this.scheduled || this.flushing) {
+    if (this.paused || this.scheduled || this.flushing)
       return;
-    }
-    const token = ++this.scheduleToken;
-    this.scheduled = true;
-    const execute = () => {
+    let token = ++this.scheduleToken;
+    this.scheduled = !0;
+    let execute = () => {
       if (token !== this.scheduleToken) {
-        this.scheduled = false;
-        this.scheduledHandle = null;
-        this.scheduledViaRaf = false;
-        this.maybeResolveIdle();
+        this.scheduled = !1, this.scheduledHandle = null, this.scheduledViaRaf = !1, this.maybeResolveIdle();
         return;
       }
       if (this.paused) {
-        this.scheduled = false;
-        this.scheduledHandle = null;
-        this.scheduledViaRaf = false;
-        this.maybeResolveIdle();
+        this.scheduled = !1, this.scheduledHandle = null, this.scheduledViaRaf = !1, this.maybeResolveIdle();
         return;
       }
-      this.scheduled = false;
-      this.scheduledHandle = null;
-      this.scheduledViaRaf = false;
-      this.runFlush(this.frameBudgetMs, false);
-      this.maybeResolveIdle();
-    };
-    if (this.batchStrategy === "microtask" && typeof queueMicrotask === "function") {
-      this.scheduledViaRaf = false;
-      this.scheduledHandle = token;
-      queueMicrotask(execute);
-    } else if (this.batchStrategy === "rAF" && this.raf) {
-      this.scheduledViaRaf = true;
-      this.scheduledHandle = this.raf(() => execute());
-    } else {
-      this.scheduledViaRaf = false;
-      this.scheduledHandle = setTimeout(() => execute(), this.timeoutMs);
-    }
+      this.scheduled = !1, this.scheduledHandle = null, this.scheduledViaRaf = !1, this.runFlush(this.frameBudgetMs, !1), this.maybeResolveIdle();
+    }, useStartupMicrotask = this.batchStrategy !== "microtask" && this.startupMicrotaskFlushes > 0 && this.flushCount < this.startupMicrotaskFlushes && typeof queueMicrotask == "function";
+    (this.batchStrategy === "microtask" || useStartupMicrotask) && typeof queueMicrotask == "function" ? (this.scheduledViaRaf = !1, this.scheduledHandle = token, queueMicrotask(execute)) : this.batchStrategy === "rAF" && this.raf ? (this.scheduledViaRaf = !0, this.scheduledHandle = this.raf(() => execute())) : (this.scheduledViaRaf = !1, this.scheduledHandle = setTimeout(() => execute(), this.timeoutMs));
   }
   cancelScheduled() {
-    if (!this.scheduled) return;
-    this.scheduleToken++;
-    if (this.scheduledHandle !== null) {
-      if (this.scheduledViaRaf && this.cancelRaf) {
-        this.cancelRaf(this.scheduledHandle);
-      } else {
-        clearTimeout(this.scheduledHandle);
-      }
-    }
-    this.scheduled = false;
-    this.scheduledHandle = null;
-    this.scheduledViaRaf = false;
+    this.scheduled && (this.scheduleToken++, this.scheduledHandle !== null && (this.scheduledViaRaf && this.cancelRaf ? this.cancelRaf(this.scheduledHandle) : clearTimeout(this.scheduledHandle)), this.scheduled = !1, this.scheduledHandle = null, this.scheduledViaRaf = !1);
   }
   runFlush(budgetMs, manual) {
-    if (this.paused && !manual) {
-      return null;
-    }
-    if (this.highQueue.length === 0 && this.lowQueue.length === 0) {
+    if (this.paused && !manual || this.semanticQueue.length === 0 && this.enrichmentHighQueue.length === 0 && this.enrichmentLowQueue.length === 0)
       return null;
-    }
-    this.flushing = true;
-    const startedAt = this.now();
-    const initialQueueSize = this.highQueue.length + this.lowQueue.length;
-    const batches = [];
-    let totalInputPatches = 0;
-    let totalAppliedPatches = 0;
-    let elapsed = 0;
-    const processQueue = (queue, maxBatches, budgetLimit) => {
-      const effectiveBudget = manual ? Number.POSITIVE_INFINITY : Math.max(0, budgetLimit ?? budgetMs);
-      const startingBatchCount = batches.length;
-      let consumed = 0;
-      while (consumed < queue.length) {
-        const next = queue[consumed];
+    this.flushing = !0;
+    let startedAt = this.now(), elapsed = 0, initialSemanticQueueSize = this.semanticQueue.length, initialEnrichmentQueueSize = this.enrichmentHighQueue.length + this.enrichmentLowQueue.length, initialQueueSize = initialSemanticQueueSize + initialEnrichmentQueueSize, batches = [], totalInputPatches = 0, totalAppliedPatches = 0, hasNonInputSourcePatch = !1, processQueue = (queue, maxBatches, budgetLimit) => {
+      let effectiveBudget = manual ? Number.POSITIVE_INFINITY : Math.max(0, budgetLimit ?? budgetMs), startingBatchCount = batches.length, consumed = 0;
+      for (; consumed < queue.length; ) {
+        let next = queue[consumed];
         if (!next) break;
-        consumed += 1;
-        const applyStart = this.now();
-        const queueDelayMs = Math.max(0, applyStart - next.receivedAt);
-        const { patches: coalesced, metrics: coalescingMetrics } = (0, import_core.coalescePatchesWithMetrics)(next.patches, import_core.DEFAULT_COALESCE_CONFIG);
-        const touched = this.store.applyPatches(coalesced, {
-          coalesced: true,
+        if (consumed += 1, next.meta.generation !== void 0 && this.isGenerationCurrent && !this.isGenerationCurrent(next.meta.generation)) continue;
+        hasNonInputSourcePatch || (hasNonInputSourcePatch = next.hasNonInputSourcePatch);
+        let applyStart = this.now(), queueDelayMs = Math.max(0, applyStart - next.receivedAt), coalesced, coalescingMetrics;
+        if (shouldSkipCoalescing(next.patches))
+          coalesced = next.patches;
+        else {
+          let result = (0, import_core.coalescePatchesWithMetrics)(next.patches, import_core.DEFAULT_COALESCE_CONFIG);
+          coalesced = result.patches, coalescingMetrics = result.metrics;
+        }
+        let touched = this.store.applyPatches(coalesced, {
+          coalesced: !0,
           metrics: coalescingMetrics
-        });
-        const durationMs = this.now() - applyStart;
-        this.recordCoalescingDuration(coalescingMetrics?.durationMs);
-        totalInputPatches += next.patches.length;
-        totalAppliedPatches += coalesced.length;
-        batches.push({
+        }), durationMs = this.now() - applyStart;
+        if (this.recordCoalescingDuration(coalescingMetrics?.durationMs), totalInputPatches += next.patches.length, totalAppliedPatches += coalesced.length, batches.push({
           tx: next.meta.tx,
           metrics: next.meta.metrics,
           patchCount: next.patches.length,
@@ -260,43 +197,30 @@ var PatchCommitScheduler = class {
           receivedAt: next.receivedAt,
           appliedAt: applyStart,
           priority: next.priority,
+          kind: next.kind,
           coalescing: coalescingMetrics
-        });
-        if (maxBatches && batches.length - startingBatchCount >= maxBatches) {
+        }), maxBatches && batches.length - startingBatchCount >= maxBatches || !manual && (elapsed = this.now() - startedAt, elapsed >= effectiveBudget))
           break;
-        }
-        if (!manual) {
-          elapsed = this.now() - startedAt;
-          if (elapsed >= effectiveBudget) {
-            break;
-          }
-        }
-      }
-      if (consumed > 0) {
-        queue.splice(0, consumed);
       }
+      consumed > 0 && queue.splice(0, consumed);
     };
-    const initialHighQueueSize = this.highQueue.length;
-    const configuredHighLimit = manual || !this.maxBatchesPerFlush ? void 0 : initialHighQueueSize > this.maxBatchesPerFlush ? void 0 : this.maxBatchesPerFlush;
-    const highBatchLimit = this.adaptiveHighBatchCap ?? configuredHighLimit;
-    processQueue(this.highQueue, highBatchLimit, budgetMs);
-    if (manual) {
-      processQueue(this.lowQueue, void 0, Number.POSITIVE_INFINITY);
-    } else if (this.lowQueue.length > 0) {
-      elapsed = this.now() - startedAt;
-      const budgetForLow = Math.max(0, this.lowPriorityFrameBudgetMs - elapsed);
-      if (budgetForLow > 0) {
-        const initialLowQueueSize = this.lowQueue.length;
-        const configuredLowLimit = manual || !this.maxLowPriorityBatchesPerFlush ? void 0 : initialLowQueueSize > this.maxLowPriorityBatchesPerFlush ? void 0 : this.maxLowPriorityBatchesPerFlush;
-        const lowBatchLimit = this.adaptiveLowBatchCap ?? configuredLowLimit;
-        processQueue(this.lowQueue, lowBatchLimit, budgetForLow);
+    if (processQueue(this.semanticQueue, void 0, budgetMs), this.semanticQueue.length === 0) {
+      let initialHighQueueSize = this.enrichmentHighQueue.length, configuredHighLimit = manual || !this.maxBatchesPerFlush || initialHighQueueSize > this.maxBatchesPerFlush ? void 0 : this.maxBatchesPerFlush, highBatchLimit = this.adaptiveBudgeting ? this.adaptiveHighBatchCap ?? configuredHighLimit : configuredHighLimit;
+      if (processQueue(this.enrichmentHighQueue, highBatchLimit, budgetMs), manual)
+        processQueue(this.enrichmentLowQueue, void 0, Number.POSITIVE_INFINITY);
+      else if (this.enrichmentLowQueue.length > 0) {
+        elapsed = this.now() - startedAt;
+        let budgetForLow = Math.max(0, this.lowPriorityFrameBudgetMs - elapsed), processedHigherPriorityWork = batches.length > 0;
+        if (budgetForLow > 0 || !processedHigherPriorityWork) {
+          let initialLowQueueSize = this.enrichmentLowQueue.length, configuredLowLimit = this.maxLowPriorityBatchesPerFlush ? initialLowQueueSize > this.maxLowPriorityBatchesPerFlush ? void 0 : this.maxLowPriorityBatchesPerFlush : void 0, lowBatchLimit = this.adaptiveBudgeting ? this.adaptiveLowBatchCap ?? configuredLowLimit : configuredLowLimit;
+          processQueue(this.enrichmentLowQueue, lowBatchLimit, budgetForLow);
+        }
       }
     }
-    this.flushing = false;
-    const completedAt = this.now();
-    const totalDurationMs = completedAt - startedAt;
-    const remaining = this.highQueue.length + this.lowQueue.length;
+    this.flushing = !1;
+    let completedAt = this.now(), totalDurationMs = completedAt - startedAt, remainingSemantic = this.semanticQueue.length, remainingEnrichment = this.enrichmentHighQueue.length + this.enrichmentLowQueue.length, remaining = remainingSemantic + remainingEnrichment;
     if (batches.length > 0) {
+      this.flushCount += 1;
       try {
         this.onFlush({
           batches,
@@ -304,54 +228,48 @@ var PatchCommitScheduler = class {
           totalAppliedPatches,
           totalDurationMs,
           remainingQueueSize: remaining,
+          remainingSemanticQueueSize: remainingSemantic,
+          remainingEnrichmentQueueSize: remainingEnrichment,
           queueDepthBefore: initialQueueSize,
+          semanticQueueDepthBefore: initialSemanticQueueSize,
+          enrichmentQueueDepthBefore: initialEnrichmentQueueSize,
           flushStartedAt: startedAt,
           flushCompletedAt: completedAt
-        });
+        }, hasNonInputSourcePatch);
       } catch (error) {
         console.error("[patch-scheduler] onFlush callback failed", error);
       }
     }
-    if (remaining > 0 && !this.paused) {
-      this.schedule();
-    }
-    const coalescingStats = this.computeCoalescingDurationStats();
-    this.updateAdaptiveBudget(coalescingStats.p95);
-    const adaptiveState = this.snapshotAdaptiveBudget(coalescingStats.p95 ?? null);
-    const flushResult = batches.length > 0 ? {
+    remaining > 0 && !this.paused && this.schedule();
+    let coalescingStats = this.adaptiveBudgeting ? this.computeCoalescingDurationStats() : { sampleCount: this.coalescingDurationSamples.length, p95: null };
+    this.adaptiveBudgeting && this.updateAdaptiveBudget(coalescingStats.p95);
+    let adaptiveState = this.adaptiveBudgeting ? this.snapshotAdaptiveBudget(coalescingStats.p95 ?? null) : void 0, flushResult = batches.length > 0 ? {
       batches,
       totalPatches: totalInputPatches,
       totalAppliedPatches,
       totalDurationMs,
       remainingQueueSize: remaining,
+      remainingSemanticQueueSize: remainingSemantic,
+      remainingEnrichmentQueueSize: remainingEnrichment,
       queueDepthBefore: initialQueueSize,
+      semanticQueueDepthBefore: initialSemanticQueueSize,
+      enrichmentQueueDepthBefore: initialEnrichmentQueueSize,
       flushStartedAt: startedAt,
       flushCompletedAt: completedAt,
       coalescingDurationP95: coalescingStats.p95 ?? void 0,
       coalescingDurationSampleCount: coalescingStats.sampleCount,
-      adaptiveBudgetActive: adaptiveState.active,
+      adaptiveBudgetActive: adaptiveState?.active,
       adaptiveBudgetState: adaptiveState
     } : null;
-    if (flushResult) {
-      this.recordHistory(flushResult);
-    }
-    return flushResult;
+    return flushResult && this.recordHistory(flushResult), flushResult;
   }
   recordCoalescingDuration(value) {
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-      return;
-    }
-    this.coalescingDurationSamples.push(value);
-    if (this.coalescingDurationSamples.length > COALESCING_DURATION_SAMPLE_LIMIT) {
-      this.coalescingDurationSamples.splice(0, this.coalescingDurationSamples.length - COALESCING_DURATION_SAMPLE_LIMIT);
-    }
+    typeof value != "number" || !Number.isFinite(value) || (this.coalescingDurationSamples.push(value), this.coalescingDurationSamples.length > COALESCING_DURATION_SAMPLE_LIMIT && this.coalescingDurationSamples.splice(0, this.coalescingDurationSamples.length - COALESCING_DURATION_SAMPLE_LIMIT));
   }
   computeCoalescingDurationStats() {
-    if (this.coalescingDurationSamples.length === 0) {
+    if (this.coalescingDurationSamples.length === 0)
       return { sampleCount: 0, p95: null };
-    }
-    const sorted = [...this.coalescingDurationSamples].sort((a, b) => a - b);
-    const index = Math.min(sorted.length - 1, Math.max(0, Math.floor(0.95 * (sorted.length - 1))));
+    let sorted = [...this.coalescingDurationSamples].sort((a, b) => a - b), index = Math.min(sorted.length - 1, Math.max(0, Math.floor(0.95 * (sorted.length - 1))));
     return { sampleCount: this.coalescingDurationSamples.length, p95: sorted[index] ?? null };
   }
   snapshotAdaptiveBudget(latestP95) {
@@ -361,50 +279,32 @@ var PatchCommitScheduler = class {
       lowBatchCap: this.adaptiveLowBatchCap,
       activateThresholdMs: COALESCING_DURATION_ACTIVATE_MS,
       deactivateThresholdMs: COALESCING_DURATION_DEACTIVATE_MS,
-      lastObservedP95: typeof latestP95 === "number" ? latestP95 : null
+      lastObservedP95: typeof latestP95 == "number" ? latestP95 : null
     };
   }
   updateAdaptiveBudget(p95) {
-    if (p95 !== null && p95 > COALESCING_DURATION_ACTIVATE_MS) {
-      if (!this.adaptiveBudgetActive) {
-        this.adaptiveBudgetActive = true;
-        this.adaptiveHighBatchCap = this.computeAdaptiveCap(this.maxBatchesPerFlush, 2);
-        this.adaptiveLowBatchCap = this.computeAdaptiveCap(this.maxLowPriorityBatchesPerFlush, 1);
-      }
-    } else if (this.adaptiveBudgetActive && (p95 === null || p95 < COALESCING_DURATION_DEACTIVATE_MS)) {
-      this.adaptiveBudgetActive = false;
-      this.adaptiveHighBatchCap = void 0;
-      this.adaptiveLowBatchCap = void 0;
-    }
+    this.adaptiveBudgeting && (p95 !== null && p95 > COALESCING_DURATION_ACTIVATE_MS ? this.adaptiveBudgetActive || (this.adaptiveBudgetActive = !0, this.adaptiveHighBatchCap = this.computeAdaptiveCap(this.maxBatchesPerFlush, 2), this.adaptiveLowBatchCap = this.computeAdaptiveCap(this.maxLowPriorityBatchesPerFlush, 1)) : this.adaptiveBudgetActive && (p95 === null || p95 < COALESCING_DURATION_DEACTIVATE_MS) && (this.adaptiveBudgetActive = !1, this.adaptiveHighBatchCap = void 0, this.adaptiveLowBatchCap = void 0));
   }
   computeAdaptiveCap(configured, fallback = 1) {
-    if (configured === void 0 || configured <= 0) {
-      return Math.max(1, fallback);
-    }
-    return Math.max(1, Math.floor(configured / 2));
+    return configured === void 0 || configured <= 0 ? Math.max(1, fallback) : Math.max(1, Math.floor(configured / 2));
   }
   maybeResolveIdle() {
-    if (!this.isIdle()) {
+    if (!this.isIdle() || this.idleResolvers.length === 0)
       return;
-    }
-    if (this.idleResolvers.length === 0) {
-      return;
-    }
-    const pending = this.idleResolvers.slice();
+    let pending = this.idleResolvers.slice();
     this.idleResolvers = [];
-    for (const resolve of pending) {
+    for (let resolve of pending)
       try {
         resolve();
       } catch (error) {
         console.error("[patch-scheduler] idle resolver failed", error);
       }
-    }
   }
   recordHistory(result) {
-    if (RETAIN_TOUCHED_IN_HISTORY) {
+    if (RETAIN_TOUCHED_IN_HISTORY)
       this.history.push(result);
-    } else {
-      const trimmed = {
+    else {
+      let trimmed = {
         ...result,
         batches: result.batches.map((batch) => ({
           ...batch,
@@ -413,100 +313,34 @@ var PatchCommitScheduler = class {
       };
       this.history.push(trimmed);
     }
-    if (this.history.length > this.historyLimit) {
-      this.history.splice(0, this.history.length - this.historyLimit);
-    }
+    this.history.length > this.historyLimit && this.history.splice(0, this.history.length - this.historyLimit);
   }
   pause() {
-    if (this.paused) {
-      return;
-    }
-    this.paused = true;
-    this.cancelScheduled();
+    this.paused || (this.paused = !0, this.cancelScheduled());
   }
   resume() {
-    if (!this.paused) {
-      return;
-    }
-    this.paused = false;
-    if (this.getPendingCount() > 0) {
-      this.schedule();
-    }
+    this.paused && (this.paused = !1, this.getPendingCount() > 0 && this.schedule());
   }
   isPaused() {
     return this.paused;
   }
   restart() {
-    this.cancelScheduled();
-    this.highQueue = [];
-    this.lowQueue = [];
-    this.flushing = false;
-    this.sequence = 0;
-    this.history = [];
-    this.scheduleToken++;
-    this.paused = false;
-    this.coalescingDurationSamples = [];
-    this.adaptiveBudgetActive = false;
-    this.adaptiveHighBatchCap = void 0;
-    this.adaptiveLowBatchCap = void 0;
-    this.maybeResolveIdle();
+    this.cancelScheduled(), this.semanticQueue = [], this.enrichmentHighQueue = [], this.enrichmentLowQueue = [], this.flushing = !1, this.sequence = 0, this.history = [], this.flushCount = 0, this.scheduleToken++, this.paused = !1, this.coalescingDurationSamples = [], this.adaptiveBudgetActive = !1, this.adaptiveHighBatchCap = void 0, this.adaptiveLowBatchCap = void 0, this.maybeResolveIdle();
   }
   getHistory(limit) {
-    if (limit === void 0 || limit >= this.history.length) {
-      return [...this.history];
-    }
-    return this.history.slice(this.history.length - limit);
+    return limit === void 0 || limit >= this.history.length ? [...this.history] : this.history.slice(this.history.length - limit);
   }
   setHistoryLimit(limit) {
-    this.historyLimit = Math.max(1, limit);
-    if (this.history.length > this.historyLimit) {
-      this.history.splice(0, this.history.length - this.historyLimit);
-    }
+    this.historyLimit = Math.max(1, limit), this.history.length > this.historyLimit && this.history.splice(0, this.history.length - this.historyLimit);
   }
   updateOptions(options) {
     if (!options) return;
-    let shouldReschedule = false;
-    if (typeof options.frameBudgetMs !== "undefined") {
-      this.frameBudgetMs = Math.max(1, options.frameBudgetMs);
-      shouldReschedule = true;
-    }
-    if (typeof options.maxBatchesPerFlush !== "undefined") {
-      this.maxBatchesPerFlush = options.maxBatchesPerFlush;
-      shouldReschedule = true;
-    }
-    if (typeof options.lowPriorityFrameBudgetMs !== "undefined") {
-      this.lowPriorityFrameBudgetMs = Math.max(1, options.lowPriorityFrameBudgetMs);
-      shouldReschedule = true;
-    }
-    if (typeof options.maxLowPriorityBatchesPerFlush !== "undefined") {
-      this.maxLowPriorityBatchesPerFlush = options.maxLowPriorityBatchesPerFlush;
-      shouldReschedule = true;
-    }
-    if (typeof options.urgentQueueThreshold !== "undefined") {
-      this.urgentQueueThreshold = Math.max(1, options.urgentQueueThreshold);
-      shouldReschedule = true;
-    }
-    if (typeof options.historyLimit !== "undefined") {
-      this.setHistoryLimit(options.historyLimit);
-    }
-    if (typeof options.batch !== "undefined") {
-      const requestedBatch = options.batch;
-      if (requestedBatch === "microtask") {
-        this.batchStrategy = "microtask";
-      } else if (requestedBatch === "timeout") {
-        this.batchStrategy = "timeout";
-      } else if (requestedBatch === "rAF") {
-        this.batchStrategy = this.raf ? "rAF" : "timeout";
-      }
-      if (this.batchStrategy === "microtask" && typeof queueMicrotask !== "function") {
-        this.batchStrategy = this.raf ? "rAF" : "timeout";
-      }
-      shouldReschedule = true;
-    }
-    if (shouldReschedule && !this.paused && !this.flushing && this.getPendingCount() > 0) {
-      this.cancelScheduled();
-      this.schedule();
+    let shouldReschedule = !1;
+    if (typeof options.frameBudgetMs < "u" && (this.frameBudgetMs = Math.max(1, options.frameBudgetMs), shouldReschedule = !0), typeof options.maxBatchesPerFlush < "u" && (this.maxBatchesPerFlush = options.maxBatchesPerFlush, shouldReschedule = !0), typeof options.lowPriorityFrameBudgetMs < "u" && (this.lowPriorityFrameBudgetMs = Math.max(1, options.lowPriorityFrameBudgetMs), shouldReschedule = !0), typeof options.maxLowPriorityBatchesPerFlush < "u" && (this.maxLowPriorityBatchesPerFlush = options.maxLowPriorityBatchesPerFlush, shouldReschedule = !0), typeof options.urgentQueueThreshold < "u" && (this.urgentQueueThreshold = Math.max(1, options.urgentQueueThreshold), shouldReschedule = !0), typeof options.historyLimit < "u" && this.setHistoryLimit(options.historyLimit), typeof options.startupMicrotaskFlushes < "u" && (this.startupMicrotaskFlushes = Math.max(0, Math.floor(options.startupMicrotaskFlushes))), typeof options.adaptiveBudgeting < "u" && (this.adaptiveBudgeting = options.adaptiveBudgeting), typeof options.batch < "u") {
+      let requestedBatch = options.batch;
+      requestedBatch === "microtask" ? this.batchStrategy = "microtask" : requestedBatch === "timeout" ? this.batchStrategy = "timeout" : requestedBatch === "rAF" && (this.batchStrategy = this.raf ? "rAF" : "timeout"), this.batchStrategy === "microtask" && typeof queueMicrotask != "function" && (this.batchStrategy = this.raf ? "rAF" : "timeout"), shouldReschedule = !0;
     }
+    shouldReschedule && !this.paused && !this.flushing && this.getPendingCount() > 0 && (this.cancelScheduled(), this.schedule());
   }
   clearHistory() {
     this.history = [];