@rotorsoft/act 1.32.4 → 1.32.6

package/dist/index.js

@@ -1070,6 +1070,23 @@ async function run_close_cycle(targets, deps) {
   const skipped = [];
   const windowed_result = windowed.length ? await run_windowed_closes(windowed, deps, skipped) : /* @__PURE__ */ new Map();
   if (!full.length) return { truncated: windowed_result, skipped };
+  const truncated = await with_stream_locks(
+    full.map((t) => t.stream),
+    deps,
+    () => run_full_closes(full, target_map, deps, skipped)
+  );
+  for (const [stream, entry] of windowed_result) truncated.set(stream, entry);
+  return { truncated, skipped };
+}
+function with_stream_locks(streams, deps, work) {
+  const with_lock = deps.with_stream_lock ?? ((_stream, w) => w());
+  return [...streams].sort().reduceRight(
+    (inner, stream) => () => with_lock(stream, inner),
+    work
+  )();
+}
+async function run_full_closes(full, target_map, deps, skipped) {
+  const none = /* @__PURE__ */ new Map();
   const streams = full.map((t) => t.stream);
   const stream_info = await scan_stream_heads(streams);
   for (const target of full) {
@@ -1092,7 +1109,7 @@ async function run_close_cycle(targets, deps) {
     deps.probe_page_size ?? SAFETY_PROBE_PAGE_SIZE,
     deps.catch_up_correlation
   );
-  if (!safe.length) return { truncated: windowed_result, skipped };
+  if (!safe.length) return none;
   const { guarded, guard_events } = await guard_with_tombstones(
     safe,
     stream_info,
@@ -1100,7 +1117,7 @@ async function run_close_cycle(targets, deps) {
     deps.tombstone,
     skipped
   );
-  if (!guarded.length) return { truncated: windowed_result, skipped };
+  if (!guarded.length) return none;
   const seed_states = await load_restart_seeds(
     guarded,
     target_map,
@@ -1110,14 +1127,18 @@ async function run_close_cycle(targets, deps) {
     deps.logger
   );
   await run_archive_callbacks(guarded, target_map);
-  const truncated = await truncate_and_warm_cache(
+  const still_guarded = await heads_still_guarded(
     guarded,
+    guard_events,
+    skipped
+  );
+  if (!still_guarded.length) return none;
+  return truncate_and_warm_cache(
+    still_guarded,
     seed_states,
     guard_events,
     deps.correlation
   );
-  for (const [stream, entry] of windowed_result) truncated.set(stream, entry);
-  return { truncated, skipped };
 }
 async function run_windowed_closes(windowed, deps, skipped) {
   const checkpoint = deps.reactive_events_size > 0 ? await deps.catch_up_correlation(Number.MAX_SAFE_INTEGER) : -1;
@@ -1307,6 +1328,15 @@ async function run_archive_callbacks(guarded, target_map) {
     if (archive_fn) await archive_fn();
   }
 }
+async function heads_still_guarded(guarded, guard_events, skipped) {
+  const heads = await store().query_stats(guarded, {});
+  return guarded.filter((stream) => {
+    if (heads.get(stream)?.head.id === guard_events.get(stream).id)
+      return true;
+    skipped.push(stream);
+    return false;
+  });
+}
 async function truncate_and_warm_cache(guarded, seed_states, guard_events, correlation) {
   const trunc_targets = guarded.map((stream) => {
     const snapshot = seed_states.get(stream);
@@ -3050,6 +3080,7 @@ var DrainController = class {
       if (!cycle) {
         this._deps.breaker.passed();
         this._armed = false;
+        if (this._defer.size > 0) this._defer.schedule();
         return EMPTY_DRAIN;
       }
       const { leased, fetched, handled, acked, blocked, closeable } = cycle;
@@ -3580,9 +3611,9 @@ var Act = class {
    */
   _close_locks = /* @__PURE__ */ new Map();
   /**
-   * Run `work` under the per-stream close lock (#1222). Serializes
-   * windowed-close critical sections for the same stream while letting
-   * different streams proceed in parallel.
+   * Run `work` under the per-stream close lock (#1222). Serializes close
+   * critical sections for the same stream (windowed prunes, and full closes
+   * since #1738) while letting different streams proceed in parallel.
    */
   _with_close_lock(stream, work) {
     const prev = this._close_locks.get(stream) ?? Promise.resolve();
@@ -4950,23 +4981,29 @@ function base_type_name(zodType) {
   return t.constructor.name;
 }
 function merge_schemas(existing, incoming, state_name) {
-  if (existing instanceof ZodObject && incoming instanceof ZodObject) {
-    const existing_shape = existing.shape;
-    const incoming_shape = incoming.shape;
-    for (const key of Object.keys(incoming_shape)) {
-      if (key in existing_shape) {
-        const existing_base = base_type_name(existing_shape[key]);
-        const incoming_base = base_type_name(incoming_shape[key]);
-        if (existing_base !== incoming_base) {
-          throw new Error(
-            `Schema conflict in "${state_name}": key "${key}" has type "${existing_base}" but incoming partial declares "${incoming_base}"`
-          );
-        }
+  if (existing === incoming) return existing;
+  const existing_object = as_object(existing, "existing", state_name);
+  const incoming_object = as_object(incoming, "incoming", state_name);
+  const existing_shape = existing_object.shape;
+  const incoming_shape = incoming_object.shape;
+  for (const key of Object.keys(incoming_shape)) {
+    if (key in existing_shape) {
+      const existing_base = base_type_name(existing_shape[key]);
+      const incoming_base = base_type_name(incoming_shape[key]);
+      if (existing_base !== incoming_base) {
+        throw new Error(
+          `Schema conflict in "${state_name}": key "${key}" has type "${existing_base}" but incoming partial declares "${incoming_base}"`
+        );
       }
     }
-    return existing.extend(incoming_shape);
   }
-  return existing;
+  return existing_object.extend(incoming_shape);
+}
+function as_object(schema, side, state_name) {
+  if (schema instanceof ZodObject) return schema;
+  throw new Error(
+    `Cannot merge state schemas for "${state_name}": the ${side} partial's schema is a ${schema.constructor.name}, not a z.object. Partials of the same state are merged by extending their shapes, so declare every partial's state as a plain z.object({ ... }).`
+  );
 }
 function merge_inits(existing, incoming) {
   return () => ({ ...existing(), ...incoming() });