@rotorsoft/act 1.23.35 → 1.23.37

package/dist/index.js

@@ -209,7 +209,19 @@ var make_schema_pass = (deps) => {
         return;
       }
       const schema = state2.events[name];
-      const parsed = schema.safeParse(event.data);
+      const sensitive2 = pii_fields(schema);
+      let parse_schema = schema;
+      if (sensitive2.length > 0) {
+        const omitter = schema.omit;
+        if (typeof omitter !== "function") {
+          return;
+        }
+        parse_schema = omitter.call(
+          schema,
+          Object.fromEntries(sensitive2.map((f) => [f, true]))
+        );
+      }
+      const parsed = parse_schema.safeParse(event.data);
       if (!parsed.success) {
         findings.push({
           category: "schema",
@@ -2531,6 +2543,13 @@ function trace_cycle(logger, leased, fetched, handled, acked, blocked) {
 }
 
 // src/internal/drain-cycle.ts
+function budget_exhausted(lease, options) {
+  if (!options?.blockOnError || lease.retry <= options.maxRetries)
+    return void 0;
+  const error = `Blocking ${lease.stream} after ${lease.retry} claims with no acknowledged progress \u2014 the lease was lost on every attempt, so the retry budget (${options.maxRetries}) was spent without the handler ever reporting an error. Raise leaseMillis for this handler, then unblock the stream.`;
+  log().error(error);
+  return { lease, handled: 0, acked_at: lease.at, error, block: true };
+}
 async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_batch, lagging, leading, eventLimit, leaseMillis, on_blocked, lane) {
   const leased = await ops.claim(
     lagging,
@@ -2563,6 +2582,8 @@ async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_bat
       const entry = fetch_map.get(lease.stream);
       const at = entry.fetch.events.at(-1)?.id || fetch_window_at;
       const { payloads } = entry;
+      const exhausted = budget_exhausted(lease, payloads[0]?.options);
+      if (exhausted) return Promise.resolve(exhausted);
       const batchHandler = batch_handlers.get(lease.stream);
       if (batchHandler && payloads.length > 0) {
         return handle_batch({ ...lease, at }, payloads, batchHandler);
@@ -2574,12 +2595,18 @@ async function run_drain_cycle(ops, registry, batch_handlers, handle, handle_bat
     handled.filter(({ block: block2 }) => block2).map(({ lease, error }) => ({ ...lease, error }))
   );
   if (blocked.length) on_blocked(blocked);
-  const acked = await ops.ack(
-    handled.flatMap((h, i) => {
-      const advance = h.handled > 0 ? h.acked_at : leased[i].at;
-      return h.defer !== void 0 ? { ...h.lease, at: advance, due: h.defer, retry: -1 } : h.next_attempt_at !== void 0 ? { ...h.lease, at: advance, due: h.next_attempt_at } : h.handled > 0 || !h.error ? { ...h.lease, at: h.acked_at } : [];
-    })
-  );
+  const submitted = handled.flatMap((h, i) => {
+    const advance = h.handled > 0 ? h.acked_at : leased[i].at;
+    return h.defer !== void 0 ? { ...h.lease, at: advance, due: h.defer, retry: -1 } : h.next_attempt_at !== void 0 ? { ...h.lease, at: advance, due: h.next_attempt_at } : h.handled > 0 || !h.error ? { ...h.lease, at: h.acked_at } : [];
+  });
+  const acked = await ops.ack(submitted);
+  const expected = submitted.filter((l) => l.due === void 0).length;
+  if (acked.length < expected)
+    log().error(
+      new Error(
+        `drain: ${expected - acked.length} of ${expected} acks were dropped \u2014 the lease was taken by another worker mid-handler. That work will be redelivered (at-least-once), but persistent drops mean leaseMillis is too short for this handler.`
+      )
+    );
   const closeable = handled.filter((h) => h.close !== void 0).map((h) => h.close);
   return { leased, fetched, handled, acked, blocked, closeable };
 }