@rotorsoft/act 0.41.0 → 0.42.0

package/dist/index.js

@@ -95,7 +95,6 @@ function classifyRegistry(registry, states) {
 }
 
 // src/internal/close-cycle.ts
-import { randomUUID } from "crypto";
 async function runCloseCycle(targets, deps) {
   const targetMap = new Map(targets.map((t) => [t.stream, t]));
   const streams = [...targetMap.keys()];
@@ -107,11 +106,10 @@ async function runCloseCycle(targets, deps) {
     skipped
   );
   if (!safe.length) return { truncated: /* @__PURE__ */ new Map(), skipped };
-  const correlation = randomUUID();
   const { guarded, guardEvents } = await guardWithTombstones(
     safe,
     streamInfo,
-    correlation,
+    deps.correlation,
     deps.tombstone,
     skipped
   );
@@ -129,7 +127,7 @@ async function runCloseCycle(targets, deps) {
     guarded,
     seedStates,
     guardEvents,
-    correlation
+    deps.correlation
   );
   return { truncated, skipped };
 }
@@ -370,8 +368,32 @@ var CorrelateCycle = class {
   }
 };
 
+// src/internal/correlator.ts
+import { randomInt } from "crypto";
+var BASE = 36;
+var SEG_WIDTH = 4;
+var SEG_SPACE = BASE ** SEG_WIDTH;
+function seg(n) {
+  return n.toString(BASE).padStart(SEG_WIDTH, "0");
+}
+var defaultCorrelator = ({ state: state2, action: action2 }) => {
+  const s = state2.slice(0, SEG_WIDTH).toLowerCase();
+  const a = action2.slice(0, SEG_WIDTH).toLowerCase();
+  const ts = seg(Date.now() % SEG_SPACE);
+  const rnd = seg(randomInt(SEG_SPACE));
+  return `${s}-${a}-${ts}${rnd}`;
+};
+function closeCorrelation(correlator, actor) {
+  return correlator({
+    state: "$close",
+    action: "close",
+    stream: "$close",
+    actor
+  });
+}
+
 // src/internal/drain-cycle.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID } from "crypto";
 
 // src/internal/drain-ratio.ts
 var RATIO_MIN = 0.2;
@@ -393,7 +415,7 @@ function computeLagLeadRatio(handled, lagging, leading) {
 
 // src/internal/drain-cycle.ts
 async function runDrainCycle(ops, registry, batchHandlers, handle, handleBatch, lagging, leading, eventLimit, leaseMillis, isDeferred) {
-  const leased = await ops.claim(lagging, leading, randomUUID2(), leaseMillis);
+  const leased = await ops.claim(lagging, leading, randomUUID(), leaseMillis);
   if (!leased.length) return void 0;
   const active = isDeferred ? leased.filter((l) => !isDeferred(l.stream)) : leased;
   if (!active.length) {
@@ -912,7 +934,6 @@ var block = (leases) => store().block(leases);
 var subscribe = (streams) => store().subscribe(streams);
 
 // src/internal/event-sourcing.ts
-import { randomUUID as randomUUID3 } from "crypto";
 import { patch } from "@rotorsoft/act-patch";
 async function snap(snapshot) {
   try {
@@ -1000,7 +1021,7 @@ async function load(me, stream, callback, asOf) {
   }
   return { event, state: state2, version, patches, snaps, cache_hit, replayed };
 }
-async function action(me, action2, target, payload, reactingTo, skipValidation = false) {
+async function action(me, action2, target, payload, reactingTo, skipValidation = false, correlator = defaultCorrelator) {
   const { stream, expectedVersion, actor } = target;
   if (!stream) throw new Error("Missing target stream");
   const validated = skipValidation ? payload : validate(action2, payload, me.actions[action2]);
@@ -1046,7 +1067,12 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
     data: skipValidation ? data : validate(name, data, me.events[name])
   }));
   const meta = {
-    correlation: reactingTo?.meta.correlation || randomUUID3(),
+    correlation: reactingTo?.meta.correlation || correlator({
+      action: action2,
+      state: me.name,
+      stream,
+      actor: target.actor
+    }),
     causation: {
       action: {
         name: action2,
@@ -1150,12 +1176,21 @@ var traced = (inner, exit, entry) => (async (...args) => {
   exit?.(result, ...args);
   return result;
 });
-function buildEs(logger) {
+function buildEs(logger, correlator = defaultCorrelator) {
+  const boundAction = (me, actionName, target, payload, reactingTo, skipValidation = false) => action(
+    me,
+    actionName,
+    target,
+    payload,
+    reactingTo,
+    skipValidation,
+    correlator
+  );
   if (logger.level !== "trace") {
     return {
       snap,
       load,
-      action,
+      action: boundAction,
       tombstone
     };
   }
@@ -1185,7 +1220,7 @@ function buildEs(logger) {
       );
     }),
     action: traced(
-      action,
+      boundAction,
       (snapshots, _me, _action, target) => {
         const committed = snapshots.filter((s) => s.event);
         if (committed.length) {
@@ -1293,7 +1328,8 @@ var Act = class {
     this._states = _states;
     this._batch_handlers = batchHandlers;
     this._scoped = options.scoped ? (fn) => scoped.run(options.scoped, fn) : (fn) => fn();
-    this._es = buildEs(this._logger);
+    this._correlator = options.correlator ?? defaultCorrelator;
+    this._es = buildEs(this._logger, this._correlator);
     this._cd = buildDrain(this._logger);
     this._handle = buildHandle({
       logger: this._logger,
@@ -1406,6 +1442,13 @@ var Act = class {
    * path keeps reading fresh `store()`/`cache()` per call, which matters for
    * tests that dispose and re-seed mid-suite. */
   _scoped;
+  /**
+   * Correlation-id generator for originating actions. Bound at
+   * construction from `options.correlator ?? defaultCorrelator`. The
+   * `do()` path passes this into the `_es.action` closure; close-cycle
+   * uses it via {@link closeCorrelation}.
+   */
+  _correlator;
   /** Pre-bound IAct methods reused across drain cycles. Only `do` varies per
    * payload (it captures the triggering event for reactingTo auto-inject). */
   _bound_do = this.do.bind(this);
@@ -1966,12 +2009,14 @@ var Act = class {
     if (!targets.length) return { truncated: /* @__PURE__ */ new Map(), skipped: [] };
     return this._scoped(async () => {
       await this.correlate({ limit: 1e3 });
+      const closeActor = { id: "$close", name: "close" };
       const result = await runCloseCycle(targets, {
         reactiveEventsSize: this._reactive_events.size,
         eventToState: this._event_to_state,
         load: this._es.load,
         tombstone: this._es.tombstone,
-        logger: this._logger
+        logger: this._logger,
+        correlation: closeCorrelation(this._correlator, closeActor)
       });
       this.emit("closed", result);
       return result;