@rotorsoft/act 1.11.0 → 1.12.1

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-5PWLGL5E.js";
+} from "./chunk-QCSXT5MB.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -271,7 +271,7 @@ var make_restart_candidate_pass = (deps, options) => {
         // names map is sparse — `__snapshot__` key absent when the
         // stream has never been snapshotted (a common case for the
         // restart-candidate signal).
-        snaps: names["__snapshot__"] ?? 0
+        snaps: names.__snapshot__ ?? 0
       });
     },
     drain: () => findings
@@ -333,7 +333,7 @@ var make_snapshot_drift_pass = (deps, options) => {
       candidates.push({
         stream,
         total: count,
-        snaps: names["__snapshot__"] ?? 0
+        snaps: names.__snapshot__ ?? 0
       });
     },
     async finalize(deps2) {
@@ -827,6 +827,76 @@ var AutocloseController = class {
   }
 };
 
+// src/internal/autoclose-policy.ts
+import { z as z2 } from "zod";
+var MIN_AFTER_MS = 6e4;
+var AfterSchema = z2.object({
+  days: z2.number({ message: "autocloses: after.days must be a number" }).positive("autocloses: after.days must be > 0")
+}).refine((o) => o.days * 864e5 >= MIN_AFTER_MS, {
+  message: `autocloses: after resolves to < ${MIN_AFTER_MS}ms (one minute), which is too short to be a meaningful retention window`
+});
+var IsSchema = z2.union([
+  z2.string().min(1, "autocloses: is must be a non-empty event name"),
+  z2.array(
+    z2.string().min(1, "autocloses: is entries must be non-empty event names")
+  ).min(1, "autocloses: is must include at least one event name").readonly()
+]);
+var ReachesSchema = z2.number({ message: "autocloses: reaches must be a number" }).int("autocloses: reaches must be an integer").min(1, "autocloses: reaches must be >= 1");
+var OrBlockSchema = z2.object({
+  after: AfterSchema.optional(),
+  is: IsSchema.optional(),
+  reaches: ReachesSchema.optional()
+}).strict().refine(
+  (o) => o.after !== void 0 || o.is !== void 0 || o.reaches !== void 0,
+  {
+    message: "autocloses: `or` block must include at least one of after / is / reaches"
+  }
+);
+var AutoclosePolicySchema = z2.object({
+  after: AfterSchema.optional(),
+  is: IsSchema.optional(),
+  reaches: ReachesSchema.optional(),
+  or: OrBlockSchema.optional()
+}).strict().refine(
+  (o) => o.after !== void 0 || o.is !== void 0 || o.reaches !== void 0 || o.or !== void 0,
+  {
+    message: "autocloses: at least one of after / is / reaches / or must be specified \u2014 empty `{}` is a misconfiguration"
+  }
+);
+function compile_after(after) {
+  const after_ms = after.days * 864e5;
+  return (_stream, head) => Date.now() - head.created.getTime() >= after_ms;
+}
+function compile_is(is) {
+  const set = new Set(typeof is === "string" ? [is] : is);
+  return (_stream, head) => set.has(head.name);
+}
+function compile_reaches(reaches) {
+  return (_stream, _head, count) => count >= reaches;
+}
+function compile_autoclose_policy(options) {
+  const parsed = AutoclosePolicySchema.parse(options);
+  const and_preds = [];
+  if (parsed.after) and_preds.push(compile_after(parsed.after));
+  if (parsed.is) and_preds.push(compile_is(parsed.is));
+  if (parsed.reaches) and_preds.push(compile_reaches(parsed.reaches));
+  const or_preds = [];
+  if (parsed.or) {
+    if (parsed.or.after) or_preds.push(compile_after(parsed.or.after));
+    if (parsed.or.is) or_preds.push(compile_is(parsed.or.is));
+    if (parsed.or.reaches) or_preds.push(compile_reaches(parsed.or.reaches));
+  }
+  return (stream, head, count) => {
+    if (and_preds.length > 0 && and_preds.every((p) => p(stream, head, count))) {
+      return true;
+    }
+    if (or_preds.some((p) => p(stream, head, count))) {
+      return true;
+    }
+    return false;
+  };
+}
+
 // src/internal/build-classify.ts
 var ALL_LANES = /* @__PURE__ */ Symbol("act-1103/all-lanes");
 function classify_registry(registry, states) {
@@ -1548,7 +1618,7 @@ function trace_cycle(logger, leased, fetched, handled, acked, blocked) {
   const detail = leased.map(({ stream, at, retry }) => {
     const f = fetch_by_stream.get(stream);
     const key = f?.source ? `${hue(C_STREAM, stream)}${dim(`<-${f.source}`)}` : hue(C_STREAM, stream);
-    const events = f && f.events.length ? ` ${dim(
+    const events = f?.events.length ? ` ${dim(
       `[${f.events.map(({ id, name }) => `#${id} ${String(name)}`).join(", ")}]`
     )}` : "";
     const acked_at = acked_by_stream.get(stream);
@@ -1898,6 +1968,11 @@ function merge_event_register(target, source) {
     const target_reg = target[event_name];
     if (!target_reg) continue;
     for (const [name, reaction] of source_reg.reactions) {
+      const existing = target_reg.reactions.get(name);
+      if (existing !== void 0 && existing !== reaction)
+        throw new Error(
+          `Duplicate reaction "${name}" for event "${event_name}". Reaction handlers are keyed by function name; rename one of them.`
+        );
       target_reg.reactions.set(name, reaction);
     }
   }
@@ -3348,6 +3423,10 @@ function act() {
           throw new Error(
             `Reaction handler for "${String(event)}" must be a named function`
           );
+        if (registry.events[event].reactions.has(handler.name))
+          throw new Error(
+            `Duplicate reaction "${handler.name}" for event "${String(event)}". Reaction handlers are keyed by function name; rename one of them.`
+          );
         registry.events[event].reactions.set(handler.name, reaction);
         return Object.assign(builder, {
           to(resolver) {
@@ -3464,6 +3543,10 @@ function _projection(target) {
             throw new Error(
               `Projection handler for "${event}" must be a named function`
             );
+          if (register.reactions.has(handler.name))
+            throw new Error(
+              `Duplicate projection handler "${handler.name}" for event "${event}". Projection handlers are keyed by function name; rename one of them.`
+            );
           register.reactions.set(handler.name, reaction);
           const widened = base;
           return Object.assign(widened, {
@@ -3539,6 +3622,10 @@ function slice() {
           throw new Error(
             `Reaction handler for "${String(event)}" must be a named function`
           );
+        if (events[event].reactions.has(handler.name))
+          throw new Error(
+            `Duplicate reaction "${handler.name}" for event "${String(event)}". Reaction handlers are keyed by function name; rename one of them.`
+          );
         events[event].reactions.set(handler.name, reaction);
         return Object.assign(builder, {
           to(resolver) {
@@ -3650,10 +3737,17 @@ function action_builder(state2) {
       internal.disclose = disclose;
       return builder;
     },
-    autocloses(predicate) {
-      if (typeof predicate !== "function") {
+    autocloses(predicate_or_policy) {
+      let predicate;
+      if (typeof predicate_or_policy === "function") {
+        predicate = predicate_or_policy;
+      } else if (predicate_or_policy !== null && typeof predicate_or_policy === "object") {
+        predicate = compile_autoclose_policy(
+          predicate_or_policy
+        );
+      } else {
         throw new Error(
-          ".autocloses(predicate) requires a function; got " + typeof predicate
+          ".autocloses(...) requires a function or a policy object; got " + typeof predicate_or_policy
         );
       }
       internal.autoclose = predicate;