@rotorsoft/act 2.0.5 → 2.1.1

package/dist/index.js

@@ -5,37 +5,28 @@ import {
   DEFAULT_EVENT_LIMIT,
   DEFAULT_LEASE_MILLIS,
   DEFAULT_MAX_RETRIES,
-  DEFAULT_QUERY_STREAMS_LIMIT,
   DEFAULT_STREAM_LIMIT,
   InMemoryCache,
   InMemoryStore,
   LruMap,
   MAX_SHUTDOWN_GRACE_MS,
-  PackageSchema,
   cache,
-  check_appends,
   check_store,
-  concurrency_error,
   config,
   current_autoclose_window,
   current_reacting,
-  dateReviver,
-  default_scope,
   dispose,
   disposeAndExit,
-  extend,
-  fair_slots,
-  is_literal_source,
+  is_valid_target,
   log,
   make_reaction_scope,
   make_run_scoped,
-  notification_of,
+  package_schema,
   port,
   register_weak_disposer,
   resolveActConfig,
   resolveActionConfig,
   resolveAutocloseConfig,
-  resolveAutocloseConfig2,
   resolveCircuitBreakerConfig,
   resolveDrainConfig,
   resolveFoldConfig,
@@ -43,12 +34,21 @@ import {
   resolveReactionConfig,
   resolveSettleConfig,
   resolveShutdownConfig,
-  seed_event,
+  resolveTargetConfig,
   sleep,
   store,
-  throw_if_stale,
+  unscoped_ports,
   validate
-} from "./chunk-3JULRYQO.js";
+} from "./chunk-QPVUARKL.js";
+import {
+  checkAppends,
+  checkVersion,
+  concurrencyError,
+  fairSlots,
+  isStreamName,
+  parseNotification,
+  seedEvent
+} from "./chunk-UXDNSZAD.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -56,6 +56,7 @@ import {
   ConcurrencyError,
   DEFAULT_LANE,
   DEFAULT_MAX_SUBSCRIBED_STREAMS,
+  DEFAULT_QUERY_STREAMS_LIMIT,
   DEFAULT_SETTLE_DEBOUNCE_MS,
   DeferSignal,
   Environments,
@@ -80,8 +81,9 @@ import {
   output_of,
   pii_fields,
   pii_schemas,
-  sensitive
-} from "./chunk-ESFICIG2.js";
+  sensitive,
+  sensitiveFields
+} from "./chunk-W3PHEA5Q.js";
 
 // src/signals.ts
 process.once("SIGINT", async (arg) => {
@@ -288,7 +290,7 @@ var make_schema_pass = (deps) => {
         return;
       }
       const schema = state2.events[name];
-      const sensitive2 = pii_fields(schema);
+      const sensitive2 = sensitiveFields(schema);
       let parse_schema = schema;
       if (sensitive2.length > 0) {
         const omitter = schema.omit;
@@ -1130,7 +1132,7 @@ async function fetch(leased, eventLimit) {
   return Promise.all(
     leased.map(async ({ stream, source, at, lagging }) => {
       const events = [];
-      const stream_exact = source !== void 0 && is_literal_source(source, stream) ? true : void 0;
+      const stream_exact = source !== void 0 && isStreamName(source, stream) ? true : void 0;
       try {
         await store().query((e) => events.push(e), {
           stream: source,
@@ -1320,24 +1322,29 @@ async function scan(source, opts = {}, callback) {
           return;
         }
         let remapped = migrated;
-        const caused_by = migrated.meta.causation.event?.id;
-        if (caused_by !== void 0) {
-          const new_caused_by = id_map.get(caused_by);
-          if (new_caused_by !== void 0 && new_caused_by !== caused_by) {
-            remapped = {
-              ...migrated,
-              meta: {
-                ...migrated.meta,
-                causation: {
-                  ...migrated.meta.causation,
+        const { action: action2, event: cause } = migrated.meta.causation;
+        if (cause || stream_rename && action2) {
+          remapped = {
+            ...migrated,
+            meta: {
+              ...migrated.meta,
+              causation: {
+                ...migrated.meta.causation,
+                ...action2 && stream_rename && {
+                  action: { ...action2, stream: stream_rename(action2.stream) }
+                },
+                ...cause && {
                   event: {
-                    ...migrated.meta.causation.event,
-                    id: new_caused_by
+                    ...cause,
+                    // A cause missing from the source has no id in the new
+                    // log; its old id would name another event there.
+                    id: id_map.get(cause.id) ?? -1,
+                    stream: stream_rename ? stream_rename(cause.stream) : cause.stream
                   }
                 }
               }
-            };
-          }
+            }
+          };
         }
         const new_id = await callback(remapped);
         id_map.set(event.id, new_id);
@@ -2307,7 +2314,7 @@ function synthesize_autoclose_reactions(registry, states, read_window) {
       // An anchored stream name would read as a pattern, and a store may refuse
       // it at subscribe, stopping every reaction. Such a stream has no
       // autoclose: `app.close` still closes it.
-      resolver: (e) => is_literal_source(e.stream) ? {
+      resolver: (e) => isStreamName(e.stream) ? {
         target: `${AUTOCLOSE_TARGET_PREFIX}${e.stream}`,
         source: e.stream
       } : void 0,
@@ -2546,7 +2553,7 @@ function source_matcher() {
   const compiled = /* @__PURE__ */ new Map();
   return (source, target, stream) => {
     if (!source) return true;
-    if (is_literal_source(source, target)) return source === stream;
+    if (isStreamName(source, target)) return source === stream;
     let re = compiled.get(source);
     if (!re) {
       re = new RegExp(source);
@@ -2717,6 +2724,13 @@ function report_undeclared_lane(seen, handler, target, lane, declared) {
     `Reaction "${handler}" resolved onto undeclared lane "${lane}" \u2014 for example target "${target}". Declared lanes: ${[...declared].map((l) => `"${l}"`).join(", ")}. No controller claims it, so the stream would never drain \u2014 running it on "default" instead. The equivalent static \`.to({ lane })\` is rejected at build; a dynamic resolver's lane is only knowable here.`
   );
 }
+function report_bad_priority(seen, handler, target, priority) {
+  report_once(
+    seen,
+    `priority|${handler}|${String(priority)}`,
+    `Reaction "${handler}" resolved priority ${String(priority)} for target "${target}", which isn't a 32-bit integer. Skipping that event for this reaction; other reactions keep running. The equivalent static \`.to({ priority })\` is rejected at build; a dynamic resolver's priority is only knowable here.`
+  );
+}
 function report_lane_conflict(seen, handler, target, kept, dropped) {
   report_once(
     seen,
@@ -2822,7 +2836,7 @@ var CorrelateCycle = class {
   // Would the target's own `fetch` (filtered by `source`) return this event?
   _in_fetch_window(source, stream) {
     if (source === void 0 || source === stream) return true;
-    if (is_literal_source(source)) return false;
+    if (isStreamName(source)) return false;
     let pattern = this._patterns.get(source);
     if (!pattern) {
       pattern = new RegExp(source);
@@ -2884,6 +2898,15 @@ var CorrelateCycle = class {
               return;
             }
             if (!resolved) continue;
+            if (!is_valid_target(resolved)) {
+              report_bad_priority(
+                this._reported,
+                reaction.handler.name,
+                resolved.target,
+                resolved.priority
+              );
+              continue;
+            }
             let lane = resolved.lane;
             if (lane !== void 0 && !this._declared_lanes.has(lane)) {
               report_undeclared_lane(
@@ -3385,7 +3408,7 @@ var Act = class {
     this._declared_lanes = ["default", ...lanes.map((l) => l.name)];
     validate_only_lanes(options.onlyLanes, this._declared_lanes);
     if (options.scoped) check_store(options.scoped.store);
-    this._ports = options.scoped ?? default_scope();
+    this._ports = options.scoped ?? unscoped_ports();
     const ports = this._ports;
     this._scoped = make_run_scoped({
       // Getters, not a spread: the singletons resolve lazily, so a later
@@ -4200,8 +4223,9 @@ var Act = class {
    * registered stream.**
    *
    * @param filter - Selection criteria (regex by default, like {@link query}).
-   * @param priority - New priority value. Set as-is — no clamp.
+   * @param priority - New priority value, a 32-bit integer. Set as-is — no clamp.
    * @returns Count of streams whose priority changed.
+   * @throws ZodError when `priority` isn't a 32-bit integer.
    *
    * @example Boost a specific projection mid-replay
    * ```typescript
@@ -4211,6 +4235,7 @@ var Act = class {
    * @see {@link Store.prioritize} for the underlying primitive
    */
   async prioritize(filter, priority) {
+    resolveTargetConfig({ priority });
     return this._scoped(() => store().prioritize(filter, priority));
   }
   // Shared by `close()` and reaction-requested closes.
@@ -4512,6 +4537,7 @@ function add_reaction(events, event, name, kind, make, builder) {
   events[event].reactions.set(name, reaction);
   return Object.assign(builder, {
     to(resolver) {
+      if (typeof resolver === "object") resolveTargetConfig(resolver);
       reaction.resolver = typeof resolver === "string" ? { target: resolver } : resolver;
       return builder;
     }
@@ -5486,37 +5512,65 @@ function write_line(writer, line) {
     });
   });
 }
+
+// src/deprecated.ts
+var check_appends = checkAppends;
+var throw_if_stale = checkVersion;
+var concurrency_error = concurrencyError;
+var seed_event = seedEvent;
+var fair_slots = fairSlots;
+var is_literal_source = isStreamName;
+var notification_of = parseNotification;
+var DEFAULT_QUERY_STREAMS_LIMIT2 = DEFAULT_QUERY_STREAMS_LIMIT;
+var ActorSchema2 = ActorSchema;
+var TargetSchema2 = TargetSchema;
+var EventMetaSchema2 = EventMetaSchema;
+var CausationEventSchema2 = CausationEventSchema;
+var CommittedMetaSchema2 = CommittedMetaSchema;
+var QuerySchema2 = QuerySchema;
+var Environments2 = Environments;
+var LogLevels2 = LogLevels;
+var ExitCodes2 = ExitCodes;
+var DEFAULT_LANE2 = DEFAULT_LANE;
+var DEFAULT_MAX_SUBSCRIBED_STREAMS2 = DEFAULT_MAX_SUBSCRIBED_STREAMS;
+var DEFAULT_SETTLE_DEBOUNCE_MS2 = DEFAULT_SETTLE_DEBOUNCE_MS;
+var PackageSchema = package_schema;
+var default_scope = unscoped_ports;
+var resolveAutocloseConfig2 = resolveAutocloseConfig;
+var extend = (source, schema, target) => ({ ...target, ...validate("config", source, schema) });
+var ISO_8601 = /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(\.\d+)?(Z|[+-][0-2][0-9]:[0-5][0-9])?$/;
+var dateReviver = (_key, value) => typeof value === "string" && ISO_8601.test(value) ? new Date(value) : value;
 export {
   Act,
-  ActorSchema,
-  CausationEventSchema,
-  CommittedMetaSchema,
+  ActorSchema2 as ActorSchema,
+  CausationEventSchema2 as CausationEventSchema,
+  CommittedMetaSchema2 as CommittedMetaSchema,
   ConcurrencyError,
   ConsoleLogger,
   CsvFile,
-  DEFAULT_LANE,
-  DEFAULT_MAX_SUBSCRIBED_STREAMS,
-  DEFAULT_QUERY_STREAMS_LIMIT,
-  DEFAULT_SETTLE_DEBOUNCE_MS,
+  DEFAULT_LANE2 as DEFAULT_LANE,
+  DEFAULT_MAX_SUBSCRIBED_STREAMS2 as DEFAULT_MAX_SUBSCRIBED_STREAMS,
+  DEFAULT_QUERY_STREAMS_LIMIT2 as DEFAULT_QUERY_STREAMS_LIMIT,
+  DEFAULT_SETTLE_DEBOUNCE_MS2 as DEFAULT_SETTLE_DEBOUNCE_MS,
   DeferSignal,
-  Environments,
+  Environments2 as Environments,
   Errors,
-  EventMetaSchema,
-  ExitCodes,
+  EventMetaSchema2 as EventMetaSchema,
+  ExitCodes2 as ExitCodes,
   InMemoryCache,
   InMemoryStore,
-  LogLevels,
+  LogLevels2 as LogLevels,
   NonRetryableError,
   PackageSchema,
   PreconditionError,
-  QuerySchema,
+  QuerySchema2 as QuerySchema,
   REDACTED,
   SHREDDED,
   SNAP_EVENT,
   StoreError,
   StreamClosedError,
   TOMBSTONE_EVENT,
-  TargetSchema,
+  TargetSchema2 as TargetSchema,
   ValidationError,
   ZodEmpty,
   act,
@@ -5539,6 +5593,7 @@ export {
   resolveAutocloseConfig2 as resolveAutocloseConfig,
   seed_event,
   sensitive,
+  sensitiveFields,
   sleep,
   slice,
   state,