@rotorsoft/act 1.8.0 → 1.10.0

package/dist/test/index.cjs

@@ -232,7 +232,7 @@ function C({ force: e } = {}) {
 var d = C();
 var y = d;
 
-// ../../node_modules/.pnpm/@vitest+pretty-format@4.1.7/node_modules/@vitest/pretty-format/dist/index.js
+// ../../node_modules/.pnpm/@vitest+pretty-format@4.1.8/node_modules/@vitest/pretty-format/dist/index.js
 function _mergeNamespaces(n, m) {
   m.forEach(function(e) {
     e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
@@ -1228,7 +1228,7 @@ var plugins = {
   Error: ErrorPlugin
 };
 
-// ../../node_modules/.pnpm/@vitest+utils@4.1.7/node_modules/@vitest/utils/dist/display.js
+// ../../node_modules/.pnpm/@vitest+utils@4.1.8/node_modules/@vitest/utils/dist/display.js
 var ansiColors = {
   bold: ["1", "22"],
   dim: ["2", "22"],
@@ -1942,7 +1942,7 @@ function objDisplay(obj, options = {}) {
   return str;
 }
 
-// ../../node_modules/.pnpm/@vitest+utils@4.1.7/node_modules/@vitest/utils/dist/helpers.js
+// ../../node_modules/.pnpm/@vitest+utils@4.1.8/node_modules/@vitest/utils/dist/helpers.js
 function assertTypes(value, name, types) {
   const receivedType = typeof value;
   const pass = types.includes(receivedType);
@@ -2037,7 +2037,7 @@ function unique(array) {
   return Array.from(new Set(array));
 }
 
-// ../../node_modules/.pnpm/@vitest+utils@4.1.7/node_modules/@vitest/utils/dist/timers.js
+// ../../node_modules/.pnpm/@vitest+utils@4.1.8/node_modules/@vitest/utils/dist/timers.js
 var SAFE_TIMERS_SYMBOL = /* @__PURE__ */ Symbol("vitest:SAFE_TIMERS");
 function getSafeTimers() {
   const { setTimeout: safeSetTimeout, setInterval: safeSetInterval, clearInterval: safeClearInterval, clearTimeout: safeClearTimeout, setImmediate: safeSetImmediate, clearImmediate: safeClearImmediate, queueMicrotask: safeQueueMicrotask } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis;
@@ -2054,7 +2054,7 @@ function getSafeTimers() {
   };
 }
 
-// ../../node_modules/.pnpm/@vitest+utils@4.1.7/node_modules/@vitest/utils/dist/chunk-pathe.M-eThtNZ.js
+// ../../node_modules/.pnpm/@vitest+utils@4.1.8/node_modules/@vitest/utils/dist/chunk-pathe.M-eThtNZ.js
 var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
   if (!input) {
@@ -2151,7 +2151,7 @@ var isAbsolute = function(p) {
   return _IS_ABSOLUTE_RE.test(p);
 };
 
-// ../../node_modules/.pnpm/@vitest+utils@4.1.7/node_modules/@vitest/utils/dist/source-map.js
+// ../../node_modules/.pnpm/@vitest+utils@4.1.8/node_modules/@vitest/utils/dist/source-map.js
 var comma = ",".charCodeAt(0);
 var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var intToChar = new Uint8Array(64);
@@ -2278,7 +2278,7 @@ function parseSingleV8Stack(raw) {
   };
 }
 
-// ../../node_modules/.pnpm/@vitest+runner@4.1.7/node_modules/@vitest/runner/dist/chunk-artifact.js
+// ../../node_modules/.pnpm/@vitest+runner@4.1.8/node_modules/@vitest/runner/dist/chunk-artifact.js
 var PendingError = class extends Error {
   code = "VITEST_PENDING";
   taskId;
@@ -3831,7 +3831,7 @@ function manageArtifactAttachment(attachment) {
   }
 }
 
-// ../../node_modules/.pnpm/vite@8.0.14_@types+node@25.9.1_esbuild@0.27.2_jiti@2.6.1_terser@5.46.1_tsx@4.22.3_yaml@2.9.0/node_modules/vite/dist/node/module-runner.js
+// ../../node_modules/.pnpm/vite@8.0.16_@types+node@25.9.1_esbuild@0.27.2_jiti@2.6.1_terser@5.46.1_tsx@4.22.4_yaml@2.9.0/node_modules/vite/dist/node/module-runner.js
 var SOURCEMAPPING_URL = "sourceMa";
 SOURCEMAPPING_URL += "ppingURL";
 var isWindows = typeof process < "u" && process.platform === "win32";
@@ -3877,7 +3877,7 @@ var envProxy = new Proxy({}, { get(_, p) {
   throw Error(`[module runner] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`);
 } });
 
-// ../../node_modules/.pnpm/vitest@4.1.7_@types+node@25.9.1_@vitest+coverage-v8@4.1.7_vite@8.0.14_@types+node@25.9._80d5839fc632fdcd9de039dffc6761e7/node_modules/vitest/dist/index.js
+// ../../node_modules/.pnpm/vitest@4.1.8_@types+node@25.9.1_@vitest+coverage-v8@4.1.8_vite@8.0.16_@types+node@25.9._87965f5280639f5a2754f2fd84ad1804/node_modules/vitest/dist/index.js
 var import_expect_type = __toESM(require_dist(), 1);
 
 // src/internal/lru-map.ts
@@ -4080,7 +4080,7 @@ var ConsoleLogger = class _ConsoleLogger {
 
 // src/config.ts
 var fs = __toESM(require("fs"), 1);
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // src/types/errors.ts
 var Errors = {
@@ -4129,48 +4129,54 @@ var ConcurrencyError = class extends Error {
 };
 
 // src/types/schemas.ts
+var import_zod2 = require("zod");
+
+// src/internal/sensitive.ts
 var import_zod = require("zod");
-var ZodEmpty = import_zod.z.record(import_zod.z.string(), import_zod.z.never());
-var ActorSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  name: import_zod.z.string()
+var _registry = import_zod.z.registry();
+
+// src/types/schemas.ts
+var ZodEmpty = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.never());
+var ActorSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  name: import_zod2.z.string()
 }).loose().readonly();
-var TargetSchema = import_zod.z.object({
-  stream: import_zod.z.string(),
+var TargetSchema = import_zod2.z.object({
+  stream: import_zod2.z.string(),
   actor: ActorSchema,
-  expectedVersion: import_zod.z.number().optional()
+  expectedVersion: import_zod2.z.number().optional()
 }).loose().readonly();
-var CausationEventSchema = import_zod.z.object({
-  id: import_zod.z.number(),
-  name: import_zod.z.string(),
-  stream: import_zod.z.string()
+var CausationEventSchema = import_zod2.z.object({
+  id: import_zod2.z.number(),
+  name: import_zod2.z.string(),
+  stream: import_zod2.z.string()
 });
-var EventMetaSchema = import_zod.z.object({
-  correlation: import_zod.z.string(),
-  causation: import_zod.z.object({
-    action: TargetSchema.and(import_zod.z.object({ name: import_zod.z.string() })).optional(),
+var EventMetaSchema = import_zod2.z.object({
+  correlation: import_zod2.z.string(),
+  causation: import_zod2.z.object({
+    action: TargetSchema.and(import_zod2.z.object({ name: import_zod2.z.string() })).optional(),
     event: CausationEventSchema.optional()
   })
 }).readonly();
-var CommittedMetaSchema = import_zod.z.object({
-  id: import_zod.z.number(),
-  stream: import_zod.z.string(),
-  version: import_zod.z.number(),
-  created: import_zod.z.date(),
+var CommittedMetaSchema = import_zod2.z.object({
+  id: import_zod2.z.number(),
+  stream: import_zod2.z.string(),
+  version: import_zod2.z.number(),
+  created: import_zod2.z.date(),
   meta: EventMetaSchema
 }).readonly();
-var QuerySchema = import_zod.z.object({
-  stream: import_zod.z.string().optional(),
-  names: import_zod.z.string().array().optional(),
-  before: import_zod.z.number().optional(),
-  after: import_zod.z.number().optional(),
-  limit: import_zod.z.number().optional(),
-  created_before: import_zod.z.date().optional(),
-  created_after: import_zod.z.date().optional(),
-  backward: import_zod.z.boolean().optional(),
-  correlation: import_zod.z.string().optional(),
-  with_snaps: import_zod.z.boolean().optional(),
-  stream_exact: import_zod.z.boolean().optional()
+var QuerySchema = import_zod2.z.object({
+  stream: import_zod2.z.string().optional(),
+  names: import_zod2.z.string().array().optional(),
+  before: import_zod2.z.number().optional(),
+  after: import_zod2.z.number().optional(),
+  limit: import_zod2.z.number().optional(),
+  created_before: import_zod2.z.date().optional(),
+  created_after: import_zod2.z.date().optional(),
+  backward: import_zod2.z.boolean().optional(),
+  correlation: import_zod2.z.string().optional(),
+  with_snaps: import_zod2.z.boolean().optional(),
+  stream_exact: import_zod2.z.boolean().optional()
 }).readonly();
 
 // src/types/index.ts
@@ -4190,13 +4196,13 @@ var LogLevels = [
 ];
 
 // src/utils.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var validate = (target, payload, schema) => {
   try {
     return schema ? schema.parse(payload) : payload;
   } catch (error) {
-    if (error instanceof import_zod2.ZodError) {
-      throw new ValidationError(target, payload, (0, import_zod2.prettifyError)(error));
+    if (error instanceof import_zod3.ZodError) {
+      throw new ValidationError(target, payload, (0, import_zod3.prettifyError)(error));
     }
     throw new ValidationError(target, payload, error);
   }
@@ -4210,13 +4216,13 @@ async function sleep(ms) {
 }
 
 // src/config.ts
-var PackageSchema = import_zod3.z.object({
-  name: import_zod3.z.string().min(1),
-  version: import_zod3.z.string().min(1),
-  description: import_zod3.z.string().min(1).optional(),
-  author: import_zod3.z.object({ name: import_zod3.z.string().min(1), email: import_zod3.z.string().optional() }).optional().or(import_zod3.z.string().min(1)).optional(),
-  license: import_zod3.z.string().min(1).optional(),
-  dependencies: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional()
+var PackageSchema = import_zod4.z.object({
+  name: import_zod4.z.string().min(1),
+  version: import_zod4.z.string().min(1),
+  description: import_zod4.z.string().min(1).optional(),
+  author: import_zod4.z.object({ name: import_zod4.z.string().min(1), email: import_zod4.z.string().optional() }).optional().or(import_zod4.z.string().min(1)).optional(),
+  license: import_zod4.z.string().min(1).optional(),
+  dependencies: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string()).optional()
 });
 var FALLBACK_PACKAGE = {
   name: "act-fallback",
@@ -4234,10 +4240,10 @@ var getPackage = () => {
 };
 var pkgLoadError;
 var BaseSchema = PackageSchema.extend({
-  env: import_zod3.z.enum(Environments),
-  logLevel: import_zod3.z.enum(LogLevels),
-  logSingleLine: import_zod3.z.boolean(),
-  sleepMs: import_zod3.z.number().int().min(0).max(5e3)
+  env: import_zod4.z.enum(Environments),
+  logLevel: import_zod4.z.enum(LogLevels),
+  logSingleLine: import_zod4.z.boolean(),
+  sleepMs: import_zod4.z.number().int().min(0).max(5e3)
 });
 var { NODE_ENV, LOG_LEVEL, LOG_SINGLE_LINE, SLEEP_MS } = process.env;
 var env = NODE_ENV || "development";
@@ -4460,11 +4466,24 @@ var InMemoryStore = class {
   _maxEventIdByStream = /* @__PURE__ */ new Map();
   // global max non-snapshot event id — fast pre-check for source-less streams in claim()
   _maxNonSnapEventId = -1;
+  // 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).
+  _pii = /* @__PURE__ */ new Map();
   _resetIndexes() {
     this._events.length = 0;
     this._streamVersions.clear();
     this._maxEventIdByStream.clear();
     this._maxNonSnapEventId = -1;
+    this._pii.clear();
+  }
+  // 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.
+  _withPii(e) {
+    const pii = this._pii.get(e.stream)?.get(e.id);
+    return pii ? { ...e, pii } : e;
   }
   /**
    * Dispose of the store and clear all events.
@@ -4520,7 +4539,9 @@ var InMemoryStore = class {
           continue;
         if (query.after && e.id <= query.after) break;
         if (query.created_after && e.created <= query.created_after) break;
-        await Promise.resolve(callback(e));
+        await Promise.resolve(
+          callback(this._withPii(e))
+        );
         count++;
         if (query?.limit && count >= query.limit) break;
       }
@@ -4532,7 +4553,9 @@ var InMemoryStore = class {
         if (query?.created_after && e.created <= query.created_after) continue;
         if (query?.before && e.id >= query.before) break;
         if (query?.created_before && e.created >= query.created_before) break;
-        await Promise.resolve(callback(e));
+        await Promise.resolve(
+          callback(this._withPii(e))
+        );
         count++;
         if (query?.limit && count >= query.limit) break;
       }
@@ -4561,7 +4584,7 @@ var InMemoryStore = class {
     }
     let version = currentVersion + 1;
     let lastNonSnapId = -1;
-    const committed = msgs.map(({ name, data }) => {
+    const committed = msgs.map(({ name, data, pii }) => {
       const c = {
         id: this._events.length,
         stream,
@@ -4572,9 +4595,17 @@ var InMemoryStore = class {
         meta
       };
       this._events.push(c);
+      if (pii != null) {
+        let perStream = this._pii.get(stream);
+        if (!perStream) {
+          perStream = /* @__PURE__ */ new Map();
+          this._pii.set(stream, perStream);
+        }
+        perStream.set(c.id, structuredClone(pii));
+      }
       if (name !== SNAP_EVENT) lastNonSnapId = c.id;
       version++;
-      return c;
+      return this._withPii(c);
     });
     this._streamVersions.set(stream, version - 1);
     if (lastNonSnapId >= 0) {
@@ -4755,6 +4786,21 @@ var InMemoryStore = class {
    * @param input - Stream names or a filter selecting the streams to unblock.
    * @returns Count of streams that were actually flipped (were blocked).
    */
+  /**
+   * 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;
+  }
   async unblock(input) {
     await sleep();
     let count = 0;