@rotorsoft/act 0.32.3 → 0.32.4

package/dist/@types/ports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/ports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAI5D,OAAO,KAAK,EACV,KAAK,EACL,UAAU,EACV,QAAQ,EACR,MAAM,EACN,KAAK,EACN,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;;;;;;GAaG;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS,4BAA6B,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAMlD;;;GAGG;AACH,KAAK,QAAQ,CAAC,IAAI,SAAS,UAAU,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,KAAK,IAAI,CAAC;AAKlE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,IAAI,SAAS,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,IACnD,UAAU,IAAI,KAAG,IAAI,CAQvC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,GAAG,0EASd,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,KAAK,wCAEhB,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,KAAK,wCAEhB,CAAC;AASH;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,cAAc,CAAC,IAAI,GAAE,QAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAe3E;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,OAAO,CACrB,QAAQ,CAAC,EAAE,QAAQ,GAClB,CAAC,IAAI,CAAC,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAGpC;AAMD;;;;GAIG;AACH,eAAO,MAAM,UAAU,iBAAiB,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,kBAAkB,CAAC"}
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/ports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAI5D,OAAO,KAAK,EACV,KAAK,EACL,UAAU,EACV,QAAQ,EACR,MAAM,EACN,KAAK,EACN,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;;;;;;GAaG;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS,4BAA6B,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAMlD;;;GAGG;AACH,KAAK,QAAQ,CAAC,IAAI,SAAS,UAAU,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,KAAK,IAAI,CAAC;AAKlE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,IAAI,SAAS,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,IACnD,UAAU,IAAI,KAAG,IAAI,CAWvC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,GAAG,0EASd,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,KAAK,wCAEhB,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,KAAK,wCAEhB,CAAC;AASH;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,cAAc,CAAC,IAAI,GAAE,QAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAe3E;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,OAAO,CACrB,QAAQ,CAAC,EAAE,QAAQ,GAClB,CAAC,IAAI,CAAC,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAGpC;AAMD;;;;GAIG;AACH,eAAO,MAAM,UAAU,iBAAiB,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,kBAAkB,CAAC"}

package/dist/index.cjs

@@ -345,12 +345,19 @@ var BaseSchema = PackageSchema.extend({
 });
 var { NODE_ENV, LOG_LEVEL, LOG_SINGLE_LINE, SLEEP_MS } = process.env;
 var env = NODE_ENV || "development";
-var logLevel = LOG_LEVEL || (NODE_ENV === "test" ? "error" : NODE_ENV === "production" ? "info" : "trace");
+var logLevel = LOG_LEVEL || (NODE_ENV === "test" ? "fatal" : NODE_ENV === "production" ? "info" : "trace");
 var logSingleLine = (LOG_SINGLE_LINE || "true") === "true";
 var sleepMs = parseInt(NODE_ENV === "test" ? "0" : SLEEP_MS ?? "100", 10);
 var pkg = getPackage();
+var _validated;
 var config = () => {
-  return extend({ ...pkg, env, logLevel, logSingleLine, sleepMs }, BaseSchema);
+  if (!_validated) {
+    _validated = extend(
+      { ...pkg, env, logLevel, logSingleLine, sleepMs },
+      BaseSchema
+    );
+  }
+  return _validated;
 };
 
 // src/utils.ts
@@ -773,7 +780,7 @@ function port(injector) {
     if (!adapters.has(injector.name)) {
       const injected = injector(adapter);
       adapters.set(injector.name, injected);
-      console.log(`[act] + ${injector.name}:${injected.constructor.name}`);
+      log().info(`[act] + ${injector.name}:${injected.constructor.name}`);
     }
     return adapters.get(injector.name);
   };
@@ -799,7 +806,7 @@ async function disposeAndExit(code = "EXIT") {
   }
   for (const adapter of [...adapters.values()].reverse()) {
     await adapter.dispose();
-    console.log(`[act] - ${adapter.constructor.name}`);
+    log().info(`[act] - ${adapter.constructor.name}`);
   }
   adapters.clear();
   config().env !== "test" && process.exit(code === "ERROR" ? 1 : 0);
@@ -1117,6 +1124,18 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
 }
 
 // src/internal/tracing.ts
+var PRETTY = config().env !== "production";
+var C_BLUE = "\x1B[38;5;39m";
+var C_ORANGE = "\x1B[38;5;208m";
+var C_GREEN = "\x1B[38;5;42m";
+var C_MAGENTA = "\x1B[38;5;165m";
+var C_DRAIN = "\x1B[38;5;244m";
+var C_RESET = "\x1B[0m";
+var es_caption = (caption, color, body) => PRETTY ? `${color}${body}${C_RESET}` : `${caption}: ${body}`;
+var drain_caption = (caption) => {
+  const tag = `>> ${caption}`;
+  return PRETTY ? `${C_DRAIN}${tag}${C_RESET}` : tag;
+};
 var traced = (inner, exit, entry) => (async (...args) => {
   entry?.(...args);
   const result = await inner(...args);
@@ -1130,11 +1149,17 @@ function buildEs(logger) {
   return {
     snap: traced(snap, void 0, (snapshot) => {
       logger.trace(
-        `\u{1F7E0} snap ${snapshot.event.stream}@${snapshot.event.version}`
+        es_caption(
+          "snap",
+          C_MAGENTA,
+          `${snapshot.event.stream}@${snapshot.event.version}`
+        )
       );
     }),
     load: traced(load, void 0, (_me, stream, _cb, asOf) => {
-      logger.trace(`\u{1F7E2} load ${stream}${asOf ? " (as-of)" : ""}`);
+      logger.trace(
+        es_caption("load", C_GREEN, `${stream}${asOf ? " (as-of)" : ""}`)
+      );
     }),
     action: traced(
       action,
@@ -1143,12 +1168,19 @@ function buildEs(logger) {
         if (committed.length) {
           logger.trace(
             committed.map((s) => s.event.data),
-            `\u{1F534} commit ${target.stream}.${committed.map((s) => s.event.name).join(", ")}`
+            es_caption(
+              "committed",
+              C_ORANGE,
+              `${target.stream}.${committed.map((s) => s.event.name).join(", ")}`
+            )
           );
         }
       },
       (_me, action2, target, payload) => {
-        logger.trace(payload, `\u{1F535} ${target.stream}.${action2}`);
+        logger.trace(
+          payload,
+          es_caption("action", C_BLUE, `${target.stream}.${action2}`)
+        );
       }
     )
   };
@@ -1169,7 +1201,7 @@ function buildDrain(logger) {
         const data = Object.fromEntries(
           leased.map(({ stream, at, retry }) => [stream, { at, retry }])
         );
-        logger.trace(data, ">> lease");
+        logger.trace(data, drain_caption("claimed"));
       }
     }),
     fetch: traced(fetch, (fetched) => {
@@ -1182,14 +1214,14 @@ function buildDrain(logger) {
           return [key, value];
         })
       );
-      logger.trace(data, ">> fetch");
+      logger.trace(data, drain_caption("fetched"));
     }),
     ack: traced(ack, (acked) => {
       if (acked.length) {
         const data = Object.fromEntries(
           acked.map(({ stream, at, retry }) => [stream, { at, retry }])
         );
-        logger.trace(data, ">> ack");
+        logger.trace(data, drain_caption("acked"));
       }
     }),
     block: traced(block, (blocked) => {
@@ -1200,13 +1232,13 @@ function buildDrain(logger) {
             { at, retry, error }
           ])
         );
-        logger.trace(data, ">> block");
+        logger.trace(data, drain_caption("blocked"));
       }
     }),
     subscribe: traced(subscribe, (result, streams) => {
       if (result.subscribed) {
         const data = streams.map(({ stream }) => stream).join(" ");
-        logger.trace(`>> correlate ${data}`);
+        logger.trace(`${drain_caption("correlated")} ${data}`);
       }
     })
   };
@@ -1220,7 +1252,7 @@ var Act = class {
     this._batch_handlers = batchHandlers;
     this._es = buildEs(this._logger);
     this._cd = buildDrain(this._logger);
-    const statics = [];
+    const statics = /* @__PURE__ */ new Map();
     for (const [name, register] of Object.entries(this.registry.events)) {
       if (register.reactions.size > 0) {
         this._reactive_events.add(name);
@@ -1229,14 +1261,13 @@ var Act = class {
         if (typeof reaction.resolver === "function") {
           this._has_dynamic_resolvers = true;
         } else {
-          statics.push({
-            stream: reaction.resolver.target,
-            source: reaction.resolver.source
-          });
+          const { target, source } = reaction.resolver;
+          const key = `${target}|${source ?? ""}`;
+          if (!statics.has(key)) statics.set(key, { stream: target, source });
         }
       }
     }
-    this._static_targets = statics;
+    this._static_targets = [...statics.values()];
     for (const merged of this._states.values()) {
       for (const eventName of Object.keys(merged.events)) {
         this._event_to_state.set(eventName, merged);
@@ -1297,6 +1328,12 @@ var Act = class {
   _event_to_state = /* @__PURE__ */ new Map();
   /** Logger resolved at construction time (after user port configuration) */
   _logger = log();
+  /** 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);
+  _bound_load = this.load.bind(this);
+  _bound_query = this.query.bind(this);
+  _bound_query_array = this.query_array.bind(this);
   /**
    * Executes an action on a state instance, committing resulting events.
    *
@@ -1519,12 +1556,12 @@ var Act = class {
     const stream = lease.stream;
     let at = payloads.at(0).event.id, handled = 0;
     lease.retry > 0 && this._logger.warn(`Retrying ${stream}@${at} (${lease.retry}).`);
-    const doAction = this.do.bind(this);
+    const doAction = this._bound_do;
     const scopedApp = {
       do: doAction,
-      load: this.load.bind(this),
-      query: this.query.bind(this),
-      query_array: this.query_array.bind(this)
+      load: this._bound_load,
+      query: this._bound_query,
+      query_array: this._bound_query_array
     };
     for (const payload of payloads) {
       const { event, handler, options } = payload;
@@ -1657,12 +1694,13 @@ var Act = class {
           return { fetched: [], leased: [], acked: [], blocked: [] };
         }
         const fetched = await this._cd.fetch(leased, eventLimit);
-        const payloadsMap = /* @__PURE__ */ new Map();
+        const fetchMap = /* @__PURE__ */ new Map();
         const fetch_window_at = fetched.reduce(
           (max, { at, events }) => Math.max(max, events.at(-1)?.id || at),
           0
         );
-        fetched.forEach(({ stream, events }) => {
+        for (const f of fetched) {
+          const { stream, events } = f;
           const payloads = events.flatMap((event) => {
             const register = this.registry.events[event.name];
             if (!register) return [];
@@ -1671,13 +1709,13 @@ var Act = class {
               return resolved && resolved.target === stream;
             }).map((reaction) => ({ ...reaction, event }));
           });
-          payloadsMap.set(stream, payloads);
-        });
+          fetchMap.set(stream, { fetch: f, payloads });
+        }
         const handled = await Promise.all(
           leased.map((lease) => {
-            const streamFetch = fetched.find((f) => f.stream === lease.stream);
-            const at = streamFetch?.events.at(-1)?.id || fetch_window_at;
-            const payloads = payloadsMap.get(lease.stream);
+            const entry = fetchMap.get(lease.stream);
+            const at = entry?.fetch.events.at(-1)?.id || fetch_window_at;
+            const payloads = entry?.payloads ?? [];
             const batchHandler = this._batch_handlers.get(lease.stream);
             if (batchHandler && payloads.length > 0) {
               return this.handleBatch({ ...lease, at }, payloads, batchHandler);