@rotorsoft/act 1.32.24 → 1.32.25

package/dist/test/index.cjs

@@ -472,13 +472,9 @@ var InMemoryStream = class {
   _leased_until = void 0;
   _priority = 0;
   _lane = DEFAULT_LANE;
-  // Persisted next-visit time. When set and still in the future, the
-  // stream is held out of `claim` entirely — so a deferred reaction is not
-  // re-claimed (and `retry` is never bumped) until its due-time passes. Unlike
-  // in-process backoff, this is durable store state shared across workers.
+  // While in the future, the stream is held out of `claim`.
   _deferred_at = void 0;
-  // Work mark: highest event id observed to resolve to this target.
-  // `undefined` means the row was never correlated, so `claim` skips it.
+  // Work mark; `undefined` = never correlated, so `claim` skips it.
   _correlated_at = void 0;
   constructor(stream, source, priority = 0, lane = DEFAULT_LANE) {
     this.stream = stream;
@@ -492,44 +488,28 @@ var InMemoryStream = class {
   get lane() {
     return this._lane;
   }
-  /** Replace on every subscribe — current builder config wins on restart. */
+  /** Replaced on every subscribe, so the current config wins on restart. */
   set lane(value) {
     this._lane = value;
   }
-  /**
-   * Bump the priority via {@link subscribe}: keeps the maximum across
-   * reactions so the highest-priority registrant wins.
-   */
   bump_priority(priority) {
     if (priority > this._priority) this._priority = priority;
   }
   get correlated_at() {
     return this._correlated_at;
   }
-  /**
-   * Raise the work mark via {@link subscribe}: keeps the maximum, for every
-   * value including zero and negatives, so a mark never regresses.
-   */
+  /** A mark never regresses, including at zero and negatives. */
   mark(correlated_at) {
     if (this._correlated_at === void 0 || correlated_at > this._correlated_at)
       this._correlated_at = correlated_at;
   }
-  /**
-   * Set the priority outright via {@link prioritize}: operator
-   * runtime override that ignores the build-time `max()` invariant.
-   */
+  /** Operator override; ignores the subscribe-time `max()`. */
   set_priority(priority) {
     this._priority = priority;
   }
   get is_available() {
-    return !this._blocked && (!this._leased_until || this._leased_until <= /* @__PURE__ */ new Date()) && // A stream deferred to a future time is not claimable until due.
-    (!this._deferred_at || this._deferred_at <= Date.now());
-  }
-  /**
-   * Hold this stream out of `claim` until `deferred_at` (ms since epoch).
-   * Set by a deliberate `defer` outcome — not a failure, so retry/blocked
-   * state is untouched. Cleared by ack/block/reset/unblock.
-   */
+    return !this._blocked && (!this._leased_until || this._leased_until <= /* @__PURE__ */ new Date()) && (!this._deferred_at || this._deferred_at <= Date.now());
+  }
   defer(deferred_at) {
     this._deferred_at = deferred_at;
     this._retry = -1;
@@ -552,16 +532,9 @@ var InMemoryStream = class {
   get leased_until() {
     return this._leased_until;
   }
-  /** Persisted next-visit time, or undefined when no active defer. */
   get deferred_at() {
     return this._deferred_at;
   }
-  /**
-   * Attempt to lease this stream for processing.
-   * @param lease - The lease request.
-   * @param millis - Lease duration in milliseconds.
-   * @returns The granted lease or undefined if blocked.
-   */
   lease(lease, millis) {
     this._leased_by = lease.by;
     this._leased_until = new Date(Date.now() + millis);
@@ -576,12 +549,7 @@ var InMemoryStream = class {
       lane: this._lane
     };
   }
-  /**
-   * Finalize this stream's lease: ack (advance the watermark) or, when the
-   * lease carries a `due` marker, defer (persist the schedule, hold the
-   * watermark) — see {@link Store.ack}.
-   * @param lease - The lease request.
-   */
+  /** Ack, or with `due`, also persist the schedule. See {@link Store.ack}. */
   ack(lease) {
     if (this._leased_by === lease.by) {
       this._leased_by = void 0;
@@ -606,11 +574,6 @@ var InMemoryStream = class {
       };
     }
   }
-  /**
-   * Block a stream for processing after failing to process and reaching max retries with blocking enabled.
-   * @param lease - The lease request.
-   * @param error Blocked error message.
-   */
   block(lease, error) {
     if (this._leased_by === lease.by && !this._blocked) {
       this._blocked = true;
@@ -628,11 +591,7 @@ var InMemoryStream = class {
       };
     }
   }
-  /**
-   * Reset this stream's watermark and state for replay. The retry counter
-   * resets to -1 to match the constructor + ack() invariant ("released
-   * stream"); the next claim() bumps it to 0 (first attempt).
-   */
+  /** Retry resets to -1 (released); the next claim makes it 0. */
   reset() {
     this._at = -1;
     this._retry = -1;
@@ -642,11 +601,7 @@ var InMemoryStream = class {
     this._leased_until = void 0;
     this._deferred_at = void 0;
   }
-  /**
-   * Clear the blocked flag and lease bookkeeping without touching the
-   * watermark. Returns true if the stream was actually blocked (and is
-   * now flipped); false otherwise.
-   */
+  /** True only when the stream was blocked. */
   unblock() {
     if (!this._blocked) return false;
     this._blocked = false;
@@ -659,33 +614,17 @@ var InMemoryStream = class {
   }
 };
 var InMemoryStore = class {
-  // stored events
   _events = [];
-  // next event id — monotonic, never reused. Deletions (truncate, windowed
-  // prune) punch holes in the id sequence, so ids are NOT array indexes and
-  // NOT `_events.length`; they only stay sorted ascending in `_events`.
+  // Never reused. Deletions punch holes, so ids are not array indexes.
   _next_id = 0;
-  // stored stream positions and other metadata
   _streams = /* @__PURE__ */ new Map();
   /** Correlate checkpoint: how far the log has been READ. */
   _correlated_at = -1;
-  /**
-   * Per-correlator checkpoint and lease, keyed by correlator.
-   *
-   * Keyed rather than singular because correlators that look for different
-   * things read the log for different reasons: sharing one position lets a
-   * partial-behaviour worker inherit another's, and sharing one lease lets
-   * one starve the other. Callers that supply no correlator use
-   * `_correlated_at` instead, the shared checkpoint.
-   */
+  /** Per-correlator checkpoint and lease; keyless callers use `_correlated_at`. */
   _correlators = /* @__PURE__ */ new Map();
-  // last committed version per stream — O(1) replacement for filter-on-commit
   _stream_versions = /* @__PURE__ */ new Map();
-  // stream → (event_id → cloned sensitive payload). Two-level so `forget_pii`
-  // is O(1) — drop the inner Map for the stream and the wipe is done — mirroring
-  // the `DELETE WHERE stream = ?` scope that durable adapters get from their
-  // stream index. Entries exist only for events committed with a non-null
-  // `pii` field; absence means "no PII" (returned as `null` on load).
+  // stream → (event_id → cloned pii). Two levels so `forget_pii` drops one
+  // inner Map. Absence means no PII.
   _pii = /* @__PURE__ */ new Map();
   _reset_indexes() {
     this._events.length = 0;
@@ -703,10 +642,7 @@ var InMemoryStore = class {
     }
     per_stream.set(id, structuredClone(pii));
   }
-  // First index whose event id is greater than `after`. `_events` stays
-  // sorted ascending by id (append-only commits; deletions preserve
-  // order), so id-bounded scans binary-search their start instead of
-  // assuming id === index — an invariant that truncation breaks.
+  // First index whose id is greater than `after` (ids are sorted, not dense).
   _first_index_after(after) {
     let lo = 0;
     let hi = this._events.length;
@@ -717,32 +653,19 @@ var InMemoryStore = class {
     }
     return lo;
   }
-  // Attach the isolated PII payload (or null) to an event before handing it to
-  // a caller. Allocation-free for events without PII — by far the common case.
+  // Allocation-free for events without PII, the common case.
   _with_pii(e, wanted = true) {
     if (!wanted) return e;
     const pii = this._pii.get(e.stream)?.get(e.id);
     return pii ? { ...e, pii } : e;
   }
-  /**
-   * Dispose of the store and clear all events.
-   * @returns Promise that resolves when disposal is complete.
-   */
   async dispose() {
     await sleep();
     this._reset_indexes();
   }
-  /**
-   * Seed the store with initial data (no-op for in-memory).
-   * @returns Promise that resolves when seeding is complete.
-   */
   async seed() {
     await sleep();
   }
-  /**
-   * Drop all data from the store.
-   * @returns Promise that resolves when the store is cleared.
-   */
   async drop() {
     await sleep();
     this._reset_indexes();
@@ -762,12 +685,7 @@ var InMemoryStore = class {
   _stream_matches(pattern, query, stream) {
     return query.stream_exact ? stream === pattern : RegExp(pattern).test(stream);
   }
-  /**
-   * Index of the latest snapshot of the queried stream, or -1. `with_snaps`
-   * on an exact single stream resumes there, so earlier events aren't read.
-   * The orchestrator asks only for unbounded current-state loads, so the
-   * floor applies whenever asked; an explicit `after` wins over it.
-   */
+  /** Index of the stream's latest snapshot, or -1; an explicit `after` wins. */
   _snap_floor(query) {
     if (!query?.with_snaps || !query.stream_exact || query.stream === void 0 || query.after !== void 0)
       return -1;
@@ -777,12 +695,6 @@ var InMemoryStore = class {
     }
     return -1;
   }
-  /**
-   * Query events in the store, optionally filtered by query options.
-   * @param callback - Function to call for each event.
-   * @param query - Optional query options.
-   * @returns The number of events processed.
-   */
   async query(callback, query) {
     await sleep();
     const floor = this._snap_floor(query);
@@ -801,15 +713,6 @@ var InMemoryStore = class {
     }
     return count;
   }
-  /**
-   * Commit one or more events to a stream.
-   * @param stream - The stream name.
-   * @param msgs - The events/messages to commit.
-   * @param meta - Event metadata.
-   * @param expectedVersion - Optional optimistic concurrency check.
-   * @returns The committed events with metadata.
-   * @throws ConcurrencyError if expectedVersion does not match.
-   */
   async commit(stream, msgs, meta, expectedVersion) {
     await sleep();
     const current_version = this._stream_versions.get(stream) ?? -1;
@@ -840,15 +743,6 @@ var InMemoryStore = class {
     this._stream_versions.set(stream, version - 1);
     return committed;
   }
-  /**
-   * Atomically discovers and leases streams for processing.
-   * Fuses poll + lease into a single operation.
-   * @param lagging - Max streams from lagging frontier.
-   * @param leading - Max streams from leading frontier.
-   * @param by - Lease holder identifier.
-   * @param millis - Lease duration in milliseconds.
-   * @returns Granted leases.
-   */
   async claim(lagging, leading, by, millis, lane) {
     await sleep();
     const has_work = (s) => s.correlated_at !== void 0 && s.at < s.correlated_at;
@@ -884,15 +778,6 @@ var InMemoryStore = class {
       (p) => this._streams.get(p.stream)?.lease({ ...p, by, retry: 0 }, millis)
     ).filter((l) => !!l);
   }
-  /**
-   * Registers streams for event processing. When the same stream is
-   * resubscribed with a different priority, the **maximum** wins — so
-   * the highest-priority registered reaction sets the scheduling lane.
-   * Use {@link prioritize} for operator runtime overrides.
-   *
-   * @param streams - Streams to register with optional source + priority.
-   * @returns subscribed count and current max watermark.
-   */
   async subscribe(streams, correlated_at, correlator) {
     await sleep();
     let correlating;
@@ -907,9 +792,7 @@ var InMemoryStore = class {
         this._correlators.set(correlator.key, {
           at,
           by: correlator.by,
-          // A non-positive `millis` releases outright rather than setting an
-          // expiry a hair in the future: a successor asking inside the same
-          // millisecond would otherwise still be refused.
+          // Release outright, or a successor in the same ms is still refused.
           until: correlator.millis > 0 ? now + correlator.millis : 0
         });
       } else {
@@ -951,53 +834,26 @@ var InMemoryStore = class {
       ...correlating === void 0 ? {} : { correlating }
     };
   }
-  /**
-   * Acknowledge completion of processing for leased streams.
-   * @param leases - Leases to acknowledge, including last processed watermark and lease holder.
-   */
   async ack(leases) {
     await sleep();
     return leases.map((l) => this._streams.get(l.stream)?.ack(l)).filter((l) => !!l);
   }
-  /**
-   * Block a stream for processing after failing to process and reaching max retries with blocking enabled.
-   * @param leases - Leases to block, including lease holder and last error message.
-   * @returns Blocked leases.
-   */
   async block(leases) {
     await sleep();
     return leases.map((l) => this._streams.get(l.stream)?.block(l, l.error)).filter((l) => !!l);
   }
-  /**
-   * Hold the matched streams out of {@link claim} until `deferred_at`
-   * (ms since epoch) — see {@link Store.defer}. Accepts an explicit list
-   * of names or a {@link StreamFilter}, mirroring {@link reset}/{@link unblock}.
-   * Persisted store state (unlike in-process backoff), so the skip is honored
-   * by every competing worker. Unknown names are silently skipped.
-   *
-   * @returns Count of streams whose `deferred_at` was set.
-   */
   async defer(input, deferred_at) {
     await sleep();
     const selected = this._select(input);
     for (const s of selected) s.defer(deferred_at);
     return selected.length;
   }
-  /**
-   * The streams named by `input`: an explicit list (de-duplicated, so a
-   * repeated name counts once, matching the SQL adapters' set-based
-   * `stream = ANY(...)`; unknown names are skipped) or a {@link StreamFilter}.
-   */
+  /** De-duplicated like the SQL `stream = ANY(...)`; unknown names skipped. */
   _select(input) {
     if (Array.isArray(input))
       return [...new Set(input)].map((name) => this._streams.get(name)).filter((s) => s !== void 0);
     return [...this._streams.values()].filter(this._filter_predicate(input));
   }
-  /**
-   * Build a predicate from a {@link StreamFilter}. Compiled regexes are
-   * cached in the closure so callers can apply it across the streams
-   * map without re-compiling per iteration.
-   */
   _filter_predicate(filter) {
     const stream_re = filter.stream !== void 0 && !filter.stream_exact ? new RegExp(filter.stream) : void 0;
     const source_re = filter.source !== void 0 && !filter.source_exact ? new RegExp(filter.source) : void 0;
@@ -1017,46 +873,18 @@ var InMemoryStore = class {
       return true;
     };
   }
-  /**
-   * Reset watermarks to -1, clearing retry, blocked, error, and lease
-   * state so the matched streams can be replayed from the beginning.
-   * Accepts either an explicit list of names or a {@link StreamFilter}.
-   *
-   * @param input - Stream names or a filter selecting the streams to reset.
-   * @returns Count of streams that were actually reset.
-   */
   async reset(input) {
     await sleep();
     const selected = this._select(input);
     for (const s of selected) s.reset();
     return selected.length;
   }
-  /**
-   * Wipe the sensitive-data payload for every event on the stream — see
-   * {@link Store.forget_pii}. O(1) drop of the stream's inner Map; the size of
-   * that Map is the count of events that had PII. Idempotent: a second call
-   * finds no inner Map and returns `0`.
-   *
-   * @param stream - Target stream.
-   * @returns Count of events whose isolated PII payload was deleted.
-   */
   async forget_pii(stream) {
     await sleep();
     const count = this._pii.get(stream)?.size ?? 0;
     this._pii.delete(stream);
     return count;
   }
-  /**
-   * Clear the blocked flag (and retry / error / lease) on the matched
-   * streams without touching the watermark. Streams that aren't blocked
-   * at call time are silently skipped. Accepts either an explicit list
-   * of names or a {@link StreamFilter}. The filter form always restricts
-   * to blocked streams — passing `blocked: false` matches nothing.
-   * See {@link Store.unblock}.
-   *
-   * @param input - Stream names or a filter selecting the streams to unblock.
-   * @returns Count of streams that were actually flipped (were blocked).
-   */
   async unblock(input) {
     await sleep();
     const selected = this._select(
@@ -1064,26 +892,12 @@ var InMemoryStore = class {
     );
     return selected.filter((s) => s.unblock()).length;
   }
-  /**
-   * Bulk-update priority of streams matching `filter`. Mirrors
-   * {@link query_streams}'s filter semantics — see {@link Store.prioritize}.
-   * Unlike {@link subscribe} (which keeps `max()` of registered
-   * priorities), this sets the priority outright — operator override
-   * for the build-time scheduling policy.
-   *
-   * @returns Count of streams whose priority changed.
-   */
   async prioritize(filter, priority) {
     await sleep();
     const changed = this._select(filter).filter((s) => s.priority !== priority);
     for (const s of changed) s.set_priority(priority);
     return changed.length;
   }
-  /**
-   * Streams registered subscription positions to the callback, ordered by
-   * stream name. Returns the highest event id in the store and the count
-   * of positions emitted.
-   */
   async query_streams(callback, query) {
     await sleep();
     const limit = query?.limit ?? 100;
@@ -1126,19 +940,6 @@ var InMemoryStore = class {
     }
     return { maxEventId: this._events.at(-1)?.id ?? -1, count };
   }
-  /**
-   * Per-stream aggregated stats — see {@link Store.query_stats}.
-   *
-   * Single forward scan over the in-memory event list, accumulating per
-   * stream. The "cheap heads" cost tier from durable adapters doesn't
-   * apply here (InMemory has no indexes); correctness is the goal, perf
-   * is a non-issue.
-   *
-   * Scope rules:
-   * - Array `input` — explicit stream names, regardless of subscription.
-   * - Filter `input` — `stream`/`stream_exact` match against event-bearing
-   *   stream names. Empty filter `{}` matches every event-bearing stream.
-   */
   async query_stats(input, options) {
     await sleep();
     const exclude = new Set(options?.exclude ?? []);
@@ -1200,15 +1001,6 @@ var InMemoryStore = class {
     }
     return out;
   }
-  /**
-   * Atomically truncates streams and seeds each with a snapshot or tombstone.
-   * Windowed targets (`before` set) prune the prefix below the closest safe
-   * `__snapshot__` instead — no seed, subscriptions untouched, no-op when no
-   * snapshot qualifies.
-   * @param targets - Streams to truncate with optional snapshot state and meta,
-   *   or a `before`/`max_id` boundary for a windowed prefix delete.
-   * @returns Map keyed by stream name, each entry with `deleted` count and `committed` event.
-   */
   async truncate(targets) {
     await sleep();
     const result = /* @__PURE__ */ new Map();
@@ -1259,18 +1051,7 @@ var InMemoryStore = class {
     }
     return result;
   }
-  /**
-   * Atomically wipe-and-rebuild the store under an in-process snapshot.
-   *
-   * Captures every index state up front, clears it, then hands the
-   * orchestrator a per-event insert `callback` via the driver. Any
-   * throw inside the driver restores the snapshot, leaving the store
-   * byte-for-byte unchanged from the operator's perspective.
-   *
-   * `id`s are reassigned `0..N-1` as events arrive (dense — the
-   * monotonic id counter restarts at 0 for the rebuild). `created` is
-   * preserved verbatim from the source.
-   */
+  /** A throw inside the driver restores the captured state. Ids restart at 0. */
   async restore(driver) {
     await sleep();
     const prev_events = this._events;