@rotorsoft/act 1.23.33 → 1.23.35

package/dist/index.cjs

@@ -395,10 +395,17 @@ var import_zod = require("zod");
 var REDACTED = "[REDACTED]";
 var SHREDDED = "[SHREDDED]";
 var _registry = import_zod.z.registry();
+var _SENSITIVE = /* @__PURE__ */ Symbol.for("act.sensitive");
+function _mark_sensitive(schema) {
+  const def = schema._zod?.def;
+  if (def) def[_SENSITIVE] = true;
+}
 function is_pii(schema) {
   let cur = schema;
   while (true) {
     if (_registry.has(cur)) return true;
+    const def = cur._zod?.def;
+    if (def?.[_SENSITIVE] === true) return true;
     const inner = cur._def?.innerType;
     if (!inner || inner === cur) return false;
     cur = inner;
@@ -406,12 +413,21 @@ function is_pii(schema) {
 }
 function pii_fields(schema) {
   const shape = schema.shape;
-  if (!shape || typeof shape !== "object") return [];
-  const fields = [];
-  for (const key of Object.keys(shape)) {
-    if (is_pii(shape[key])) fields.push(key);
+  if (shape && typeof shape === "object") {
+    const fields = [];
+    for (const key of Object.keys(shape)) {
+      if (is_pii(shape[key])) fields.push(key);
+    }
+    return fields;
   }
-  return fields;
+  const options = schema.options;
+  if (Array.isArray(options)) {
+    const fields = /* @__PURE__ */ new Set();
+    for (const option of options)
+      for (const key of pii_fields(option)) fields.add(key);
+    return [...fields];
+  }
+  return [];
 }
 function pii_split(emitted, fields) {
   const data = { ...emitted.data };
@@ -464,6 +480,7 @@ function pii_strip(event, fields) {
 var ZodEmpty = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.never());
 function sensitive(schema) {
   _registry.add(schema, { sensitive: true });
+  _mark_sensitive(schema);
   return schema;
 }
 var ActorSchema = import_zod2.z.object({
@@ -1418,8 +1435,11 @@ var InMemoryStore = class {
       }
     }
     this._events = this._events.filter((e) => !stream_set.has(e.stream));
+    const restarted = new Set(
+      full.filter((t) => t.snapshot !== void 0).map((t) => t.stream)
+    );
     for (const stream of stream_set) {
-      this._streams.delete(stream);
+      if (!restarted.has(stream)) this._streams.delete(stream);
       this._stream_versions.delete(stream);
       this._max_event_id_by_stream.delete(stream);
       this._pii.delete(stream);
@@ -3095,6 +3115,8 @@ var DEFAULT_COLD_START_BACK_SCAN = 1e4;
 var CorrelateCycle = class {
   _checkpoint = -1;
   _initialized = false;
+  /** In-flight init, memoized for single-flight and cleared on failure. */
+  _init_promise;
   _timer = void 0;
   // target → the priority it was last subscribed at. A dynamic target is
   // re-subscribed (so the store's `GREATEST` upsert runs) only when a later
@@ -3177,7 +3199,16 @@ var CorrelateCycle = class {
    */
   async init() {
     if (this._initialized) return;
+    if (!this._init_promise) {
+      this._init_promise = this._run_init().catch((error) => {
+        this._init_promise = void 0;
+        throw error;
+      });
+    }
+    await this._init_promise;
     this._initialized = true;
+  }
+  async _run_init() {
     const { watermark } = await store2().subscribe([...this._static_targets]);
     this._checkpoint = this._has_dynamic_resolvers ? Math.max(-1, watermark - this._cold_start_back_scan) : watermark;
     this._on_init?.();
@@ -3186,6 +3217,26 @@ var CorrelateCycle = class {
     }
     await this._on_init_async?.();
   }
+  /**
+   * Forget targets whose subscription rows no longer exist, so a later
+   * scan can re-subscribe them.
+   *
+   * A full close deletes the closed stream's subscription row. The
+   * in-process dedup would otherwise still believe the target is
+   * subscribed and never re-issue `subscribe()`, silently stopping
+   * delivery for any reaction whose target is named after the stream —
+   * the documented per-aggregate shape `.to(e => ({target: e.stream}))`
+   * makes those two namespaces collide by construction (#1398).
+   *
+   * Static targets are left alone: they are subscribed once at init and
+   * recorded at +Infinity so the dynamic path never re-opens them.
+   */
+  forget_subscribed(streams) {
+    const statics = new Set(this._static_targets.map((t) => t.stream));
+    for (const stream of streams) {
+      if (!statics.has(stream)) this._subscribed.delete(stream);
+    }
+  }
   /**
    * Discover dynamic-resolver targets in the events past the checkpoint
    * and register any new streams via `cd.subscribe`. Static targets are
@@ -4808,6 +4859,7 @@ var Act = class {
             correlation: close_correlation(this._correlator, close_actor),
             with_stream_lock: (stream, work) => this._with_close_lock(stream, work)
           });
+          this._forget_closed_subscriptions(result);
           try {
             this.emit("closed", result);
           } catch (err) {
@@ -5802,6 +5854,15 @@ var Act = class {
    * ]);
    * ```
    */
+  /**
+   * After a close, forget any target whose subscription row the truncate
+   * removed, so a later correlate can re-subscribe it (#1398). Restart
+   * targets keep their row, so only fully-retired streams are forgotten.
+   */
+  _forget_closed_subscriptions(result) {
+    const retired = [...result.truncated.entries()].filter(([, r]) => r.committed.name === TOMBSTONE_EVENT).map(([stream]) => stream);
+    if (retired.length) this._correlate.forget_subscribed(retired);
+  }
   async close(targets) {
     if (!targets.length) return { truncated: /* @__PURE__ */ new Map(), skipped: [] };
     return this._scoped(async () => {
@@ -5816,6 +5877,7 @@ var Act = class {
         correlation: close_correlation(this._correlator, close_actor),
         with_stream_lock: (stream, work) => this._with_close_lock(stream, work)
       });
+      this._forget_closed_subscriptions(result);
       this.emit("closed", result);
       return result;
     });