@rotorsoft/act 1.32.30 → 1.33.1

package/dist/chunk-YKL44PYX.cjs

@@ -0,0 +1,1233 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;
+
+
+
+
+
+
+
+var _chunkNNWP65YMcjs = require('./chunk-NNWP65YM.cjs');
+
+// src/adapters/console-logger.ts
+var LEVEL_VALUES = {
+  fatal: 60,
+  error: 50,
+  warn: 40,
+  info: 30,
+  debug: 20,
+  trace: 10
+};
+var LEVEL_COLORS = {
+  fatal: "\x1B[41m\x1B[37m",
+  // white on red bg
+  error: "\x1B[31m",
+  // red
+  warn: "\x1B[33m",
+  // yellow
+  info: "\x1B[32m",
+  // green
+  debug: "\x1B[36m",
+  // cyan
+  trace: "\x1B[90m"
+  // gray
+};
+var RESET = "\x1B[0m";
+var noop = () => {
+};
+var ConsoleLogger = class _ConsoleLogger {
+  
+  
+  
+  
+  
+  
+  
+  
+  constructor(options = {}) {
+    const {
+      level = "info",
+      pretty = process.env.NODE_ENV !== "production",
+      bindings
+    } = options;
+    this._pretty = pretty;
+    this.level = level;
+    const threshold = _nullishCoalesce(LEVEL_VALUES[level], () => ( 30));
+    const write = pretty ? this._pretty_write.bind(this, bindings) : this._json_write.bind(this, bindings);
+    this.fatal = write.bind(this, "fatal", 60);
+    this.error = threshold <= 50 ? write.bind(this, "error", 50) : noop;
+    this.warn = threshold <= 40 ? write.bind(this, "warn", 40) : noop;
+    this.info = threshold <= 30 ? write.bind(this, "info", 30) : noop;
+    this.debug = threshold <= 20 ? write.bind(this, "debug", 20) : noop;
+    this.trace = threshold <= 10 ? write.bind(this, "trace", 10) : noop;
+  }
+  /** No-op — `console.log` has no resources to release. */
+  async dispose() {
+  }
+  /** @inheritDoc */
+  child(bindings) {
+    return new _ConsoleLogger({
+      level: this.level,
+      pretty: this._pretty,
+      bindings
+    });
+  }
+  _json_write(bindings, level, _num, obj_or_msg, msg) {
+    let obj;
+    let message;
+    if (typeof obj_or_msg === "string") {
+      message = obj_or_msg;
+      obj = {};
+    } else if (obj_or_msg instanceof Error) {
+      message = _nullishCoalesce(msg, () => ( obj_or_msg.message));
+      obj = {
+        error: { message: obj_or_msg.message, name: obj_or_msg.name },
+        stack: obj_or_msg.stack
+      };
+    } else if (obj_or_msg !== null && typeof obj_or_msg === "object") {
+      message = msg;
+      obj = { ...obj_or_msg };
+    } else {
+      message = msg;
+      obj = { value: obj_or_msg };
+    }
+    const entry = Object.assign({ level, time: Date.now() }, bindings, obj);
+    if (message) entry.msg = message;
+    let line;
+    try {
+      line = JSON.stringify(entry);
+    } catch (e2) {
+      line = JSON.stringify({
+        level,
+        time: entry.time,
+        msg: _nullishCoalesce(message, () => ( "[unserializable]")),
+        unserializable: true
+      });
+    }
+    process.stdout.write(line + "\n");
+  }
+  _pretty_write(bindings, level, _num, obj_or_msg, msg) {
+    const color = LEVEL_COLORS[level];
+    const tag = `${color}${level.toUpperCase().padEnd(5)}${RESET}`;
+    const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+    let message;
+    let data;
+    if (typeof obj_or_msg === "string") {
+      message = obj_or_msg;
+    } else if (obj_or_msg instanceof Error) {
+      message = _nullishCoalesce(msg, () => ( obj_or_msg.message));
+      data = obj_or_msg.stack;
+    } else {
+      message = _nullishCoalesce(msg, () => ( ""));
+      if (obj_or_msg !== void 0 && obj_or_msg !== null) {
+        try {
+          data = JSON.stringify(obj_or_msg);
+        } catch (e3) {
+          data = "[unserializable]";
+        }
+      }
+    }
+    const bind_str = bindings && Object.keys(bindings).length ? ` ${JSON.stringify(bindings)}` : "";
+    const parts = [ts, tag, message, data, bind_str].filter(Boolean);
+    process.stdout.write(parts.join(" ") + "\n");
+  }
+};
+
+// src/internal/lru-map.ts
+var LruMap = (_class = class {
+  __init() {this._entries = /* @__PURE__ */ new Map()}
+  
+  constructor(maxSize) {;_class.prototype.__init.call(this);
+    this._max_size = maxSize;
+  }
+  get(key) {
+    const v = this._entries.get(key);
+    if (v === void 0) return void 0;
+    this._entries.delete(key);
+    this._entries.set(key, v);
+    return v;
+  }
+  has(key) {
+    return this._entries.has(key);
+  }
+  set(key, value) {
+    this._entries.delete(key);
+    if (this._entries.size >= this._max_size) {
+      const oldest = this._entries.keys().next().value;
+      this._entries.delete(oldest);
+    }
+    this._entries.set(key, value);
+  }
+  delete(key) {
+    return this._entries.delete(key);
+  }
+  clear() {
+    this._entries.clear();
+  }
+  get size() {
+    return this._entries.size;
+  }
+}, _class);
+
+// src/adapters/in-memory-cache.ts
+var InMemoryCache = class {
+  // CacheEntry<any> lets `get<TState>` and `set<TState>` flow without casts:
+  // any is bidirectionally compatible with the per-call TState binding, while
+  // the public Cache interface still presents a typed surface to callers.
+  
+  constructor(options) {
+    this._entries = new LruMap(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.maxSize]), () => ( 1e3)));
+  }
+  /** @inheritDoc */
+  async get(stream) {
+    return this._entries.get(stream);
+  }
+  /** @inheritDoc */
+  async set(stream, entry) {
+    this._entries.set(stream, entry);
+  }
+  /** @inheritDoc */
+  async invalidate(stream) {
+    this._entries.delete(stream);
+  }
+  /** @inheritDoc */
+  async clear() {
+    this._entries.clear();
+  }
+  /** @inheritDoc */
+  async dispose() {
+    this._entries.clear();
+  }
+  /** Current number of entries held by the LRU. */
+  get size() {
+    return this._entries.size;
+  }
+};
+
+// src/config.ts
+var _fs = require('fs'); var fs = _interopRequireWildcard(_fs);
+var _zod = require('zod');
+
+// src/internal/config.ts
+
+var BackoffOptionsSchema = _zod.z.object({
+  strategy: _zod.z.enum(["fixed", "linear", "exponential"]),
+  baseMs: _zod.z.number().min(0),
+  maxMs: _zod.z.number().gt(0).optional(),
+  jitter: _zod.z.boolean().optional()
+});
+var DEFAULT_BACKOFF = {
+  strategy: "fixed",
+  baseMs: 1e4
+};
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_BLOCK_ON_ERROR = true;
+var ReactionOptionsSchema = _zod.z.object({
+  blockOnError: _zod.z.boolean(),
+  maxRetries: _zod.z.number().int().min(0),
+  backoff: BackoffOptionsSchema.optional()
+});
+function resolveReactionConfig(options) {
+  return ReactionOptionsSchema.parse(options);
+}
+var ActionOptionsSchema = _zod.z.object({
+  maxRetries: _zod.z.number().int().min(0).optional(),
+  backoff: BackoffOptionsSchema.optional()
+});
+function resolveActionConfig(options) {
+  return ActionOptionsSchema.parse(options);
+}
+var LaneConfigSchema = _zod.z.object({
+  name: _zod.z.string().min(1),
+  leaseMillis: _zod.z.number().min(0).optional(),
+  streamLimit: _zod.z.number().int().min(0).optional(),
+  cycleMs: _zod.z.number().min(0).optional()
+});
+function resolveLaneConfig(options) {
+  LaneConfigSchema.parse(options);
+  return options;
+}
+var DEFAULT_STREAM_LIMIT = 10;
+var DEFAULT_EVENT_LIMIT = 10;
+var DEFAULT_LEASE_MILLIS = 1e4;
+var DrainOptionsSchema = _zod.z.object({
+  streamLimit: _zod.z.number().int().min(0).optional(),
+  eventLimit: _zod.z.number().int().min(0).optional(),
+  leaseMillis: _zod.z.number().min(0).optional()
+});
+function resolveDrainConfig(options) {
+  if (options === void 0) return void 0;
+  DrainOptionsSchema.parse(options);
+  return options;
+}
+var SettleOptionsSchema = DrainOptionsSchema.extend({
+  debounceMs: _zod.z.number().min(0).optional(),
+  // `maxPasses` defaults to Infinity (no cap) when omitted; a present value is
+  // a non-negative integer — `0` is legal and means "run no passes".
+  //
+  // `Infinity` is accepted explicitly. It is the documented default
+  // (`Act.settle`'s doc-comment and `SettleOptions.maxPasses` both name it),
+  // and `settle.ts` destructures `maxPasses = Infinity`, so the one value the
+  // docs advertise was the one value `z.number().int()` refused — Zod 4
+  // rejects `±Infinity`, and an integer check cannot pass it either. Wrapper
+  // code normalizing an optional cap (`maxPasses: opts.maxPasses ?? Infinity`)
+  // is the natural way to hit it. Accepting it also honors this module's own
+  // rule that a value which works today is never newly rejected.
+  maxPasses: _zod.z.union([_zod.z.number().int().min(0), _zod.z.literal(Number.POSITIVE_INFINITY)]).optional()
+}).loose();
+function resolveSettleConfig(options) {
+  if (options === void 0) return void 0;
+  SettleOptionsSchema.parse(options);
+  return options;
+}
+var MAX_SHUTDOWN_GRACE_MS = 3e4;
+var ShutdownOptionsSchema = _zod.z.object({
+  // `0` is legal and is exactly today's behavior: stop scheduling and
+  // return without waiting.
+  graceMs: _zod.z.number().min(0).optional()
+}).loose();
+function resolveShutdownConfig(options) {
+  if (options === void 0) return void 0;
+  ShutdownOptionsSchema.parse(options);
+  return options;
+}
+var ActOptionsSchema = _zod.z.object({
+  maxSubscribedStreams: _zod.z.number().int().min(1).optional(),
+  settleDebounceMs: _zod.z.number().int().min(0).optional(),
+  autoSettle: _zod.z.boolean().optional()
+}).loose();
+function resolveActConfig(options) {
+  if (options === void 0) return void 0;
+  ActOptionsSchema.parse(options);
+  return options;
+}
+var DEFAULT_AUTOCLOSE_WINDOW_TZ = "UTC";
+function is_valid_time_zone(tz) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return true;
+  } catch (e4) {
+    return false;
+  }
+}
+var AutocloseWindowSchema = _zod.z.object({
+  start: _zod.z.number().int().min(0).max(23, { message: "autocloseWindow.start must be an hour in [0, 23]" }),
+  end: _zod.z.number().int().min(0).max(23, { message: "autocloseWindow.end must be an hour in [0, 23]" }),
+  timeZone: _zod.z.string().refine(is_valid_time_zone, {
+    message: "autocloseWindow.timeZone must be a valid IANA time zone"
+  }).default(DEFAULT_AUTOCLOSE_WINDOW_TZ)
+}).refine((w) => w.start !== w.end, {
+  message: "autocloseWindow.start and end must differ \u2014 an empty window disables autoclose"
+});
+var AutocloseOptionsSchema = _zod.z.object({
+  autocloseWindow: AutocloseWindowSchema.optional()
+});
+function resolveAutocloseConfig(options) {
+  return AutocloseOptionsSchema.parse({
+    autocloseWindow: _optionalChain([options, 'optionalAccess', _2 => _2.autocloseWindow])
+  });
+}
+var DEFAULT_CIRCUIT_FAILURE_THRESHOLD = 5;
+var DEFAULT_CIRCUIT_COOLDOWN_MS = 3e4;
+var CircuitBreakerOptionsSchema = _zod.z.object({
+  failureThreshold: _zod.z.number().int().min(1).default(DEFAULT_CIRCUIT_FAILURE_THRESHOLD),
+  cooldownMs: _zod.z.number().int().min(100).max(36e5).default(DEFAULT_CIRCUIT_COOLDOWN_MS)
+});
+var resolveCircuitBreakerConfig = (options) => CircuitBreakerOptionsSchema.parse(_nullishCoalesce(options, () => ( {})));
+var DEFAULT_FOLD_FLUSH_EVERY = 1e3;
+var DEFAULT_MAX_CACHED_STATES = 1e4;
+var FoldOptionsSchema = _zod.z.object({
+  flushEvery: _zod.z.number().int().min(1).default(DEFAULT_FOLD_FLUSH_EVERY),
+  maxCachedStates: _zod.z.number().int().min(1).default(DEFAULT_MAX_CACHED_STATES)
+});
+function resolveFoldConfig(options) {
+  return FoldOptionsSchema.parse(options);
+}
+
+// src/utils.ts
+
+var validate = (target, payload, schema) => {
+  try {
+    return schema ? schema.parse(payload) : payload;
+  } catch (error) {
+    if (error instanceof _zod.ZodError) {
+      throw new (0, _chunkNNWP65YMcjs.ValidationError)(target, payload, _zod.prettifyError.call(void 0, error));
+    }
+    throw new (0, _chunkNNWP65YMcjs.ValidationError)(target, payload, error);
+  }
+};
+var extend = (source, schema, target) => {
+  const value = validate("config", source, schema);
+  return { ...target, ...value };
+};
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, _nullishCoalesce(ms, () => ( config().sleepMs))));
+}
+var SOURCE_METACHARACTERS = /[\^$.*+?()[\]{}|\\]/;
+function is_literal_source(source) {
+  return !SOURCE_METACHARACTERS.test(source);
+}
+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;
+
+// src/adapters/in-memory-store.ts
+var InMemoryStream = (_class2 = class {
+  
+  
+  __init2() {this._at = -1}
+  __init3() {this._retry = -1}
+  __init4() {this._blocked = false}
+  __init5() {this._error = ""}
+  __init6() {this._leased_by = void 0}
+  __init7() {this._leased_until = void 0}
+  __init8() {this._priority = 0}
+  __init9() {this._lane = _chunkNNWP65YMcjs.DEFAULT_LANE}
+  // While in the future, the stream is held out of `claim`.
+  __init10() {this._deferred_at = void 0}
+  // Work mark; `undefined` = never correlated, so `claim` skips it.
+  __init11() {this._correlated_at = void 0}
+  constructor(stream, source, priority = 0, lane = _chunkNNWP65YMcjs.DEFAULT_LANE) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);_class2.prototype.__init11.call(this);
+    this.stream = stream;
+    this.source = source;
+    this._priority = priority;
+    this._lane = lane;
+  }
+  get priority() {
+    return this._priority;
+  }
+  get lane() {
+    return this._lane;
+  }
+  /** Replaced on every subscribe, so the current config wins on restart. */
+  set lane(value) {
+    this._lane = value;
+  }
+  bump_priority(priority) {
+    if (priority > this._priority) this._priority = priority;
+  }
+  get correlated_at() {
+    return this._correlated_at;
+  }
+  /** 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;
+  }
+  /** 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()) && (!this._deferred_at || this._deferred_at <= Date.now());
+  }
+  defer(deferred_at) {
+    this._deferred_at = deferred_at;
+    this._retry = -1;
+  }
+  get at() {
+    return this._at;
+  }
+  get retry() {
+    return this._retry;
+  }
+  get blocked() {
+    return this._blocked;
+  }
+  get error() {
+    return this._error;
+  }
+  get leased_by() {
+    return this._leased_by;
+  }
+  get leased_until() {
+    return this._leased_until;
+  }
+  get deferred_at() {
+    return this._deferred_at;
+  }
+  lease(lease, millis) {
+    this._leased_by = lease.by;
+    this._leased_until = new Date(Date.now() + millis);
+    this._retry = this._retry + 1;
+    return {
+      stream: this.stream,
+      source: this.source,
+      at: lease.at,
+      by: lease.by,
+      retry: this._retry,
+      lagging: lease.lagging,
+      lane: this._lane
+    };
+  }
+  /** 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;
+      this._leased_until = void 0;
+      if (lease.due !== void 0) {
+        this._at = lease.at;
+        this._retry = lease.retry;
+        this._deferred_at = lease.due;
+        return void 0;
+      }
+      this._retry = -1;
+      this._at = lease.at;
+      this._deferred_at = void 0;
+      return {
+        stream: this.stream,
+        source: this.source,
+        at: this._at,
+        by: lease.by,
+        retry: this._retry,
+        lagging: lease.lagging,
+        lane: this._lane
+      };
+    }
+  }
+  block(lease, error) {
+    if (this._leased_by === lease.by && !this._blocked) {
+      this._blocked = true;
+      this._error = error;
+      this._deferred_at = void 0;
+      return {
+        stream: this.stream,
+        source: this.source,
+        at: this._at,
+        by: this._leased_by,
+        retry: this._retry,
+        error: this._error,
+        lagging: lease.lagging,
+        lane: this._lane
+      };
+    }
+  }
+  /** Retry resets to -1 (released); the next claim makes it 0. */
+  reset() {
+    this._at = -1;
+    this._retry = -1;
+    this._blocked = false;
+    this._error = "";
+    this._leased_by = void 0;
+    this._leased_until = void 0;
+    this._deferred_at = void 0;
+  }
+  /** True only when the stream was blocked. */
+  unblock() {
+    if (!this._blocked) return false;
+    this._blocked = false;
+    this._retry = -1;
+    this._error = "";
+    this._leased_by = void 0;
+    this._leased_until = void 0;
+    this._deferred_at = void 0;
+    return true;
+  }
+}, _class2);
+var InMemoryStore = (_class3 = class {constructor() { _class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this); }
+  __init12() {this._events = []}
+  // Never reused. Deletions punch holes, so ids are not array indexes.
+  __init13() {this._next_id = 0}
+  __init14() {this._streams = /* @__PURE__ */ new Map()}
+  /** Correlate checkpoint: how far the log has been READ. */
+  __init15() {this._correlated_at = -1}
+  /** Per-correlator checkpoint and lease; keyless callers use `_correlated_at`. */
+  __init16() {this._correlators = /* @__PURE__ */ new Map()}
+  __init17() {this._stream_versions = /* @__PURE__ */ new Map()}
+  // stream → (event_id → cloned pii). Two levels so `forget_pii` drops one
+  // inner Map. Absence means no PII.
+  __init18() {this._pii = /* @__PURE__ */ new Map()}
+  _reset_indexes() {
+    this._events.length = 0;
+    this._next_id = 0;
+    this._correlated_at = -1;
+    this._stream_versions.clear();
+    this._pii.clear();
+  }
+  // Stores a cloned copy, so caller-side mutation can't reach it.
+  _put_pii(stream, id, pii) {
+    let per_stream = this._pii.get(stream);
+    if (!per_stream) {
+      per_stream = /* @__PURE__ */ new Map();
+      this._pii.set(stream, per_stream);
+    }
+    per_stream.set(id, structuredClone(pii));
+  }
+  // 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;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (this._events[mid].id > after) hi = mid;
+      else lo = mid + 1;
+    }
+    return lo;
+  }
+  // Allocation-free for events without PII, the common case.
+  _with_pii(e, wanted = true) {
+    if (!wanted) return e;
+    const pii = _optionalChain([this, 'access', _3 => _3._pii, 'access', _4 => _4.get, 'call', _5 => _5(e.stream), 'optionalAccess', _6 => _6.get, 'call', _7 => _7(e.id)]);
+    return pii ? { ...e, pii } : e;
+  }
+  async dispose() {
+    await sleep();
+    this._reset_indexes();
+  }
+  async seed() {
+    await sleep();
+  }
+  async drop() {
+    await sleep();
+    this._reset_indexes();
+    this._streams = /* @__PURE__ */ new Map();
+  }
+  in_query(query, e) {
+    if (query.stream && !this._stream_matches(query.stream, query, e.stream))
+      return false;
+    if (query.names && !query.names.includes(e.name)) return false;
+    if (query.correlation && _optionalChain([e, 'access', _8 => _8.meta, 'optionalAccess', _9 => _9.correlation]) !== query.correlation)
+      return false;
+    if (e.name === _chunkNNWP65YMcjs.SNAP_EVENT && !query.with_snaps) return false;
+    if (query.created_after && e.created <= query.created_after) return false;
+    if (query.created_before && e.created >= query.created_before) return false;
+    return true;
+  }
+  _stream_matches(pattern, query, stream) {
+    return query.stream_exact ? stream === pattern : RegExp(pattern).test(stream);
+  }
+  /** Index of the stream's latest snapshot, or -1; an explicit `after` wins. */
+  _snap_floor(query) {
+    if (!_optionalChain([query, 'optionalAccess', _10 => _10.with_snaps]) || !query.stream_exact || query.stream === void 0 || query.after !== void 0)
+      return -1;
+    for (let j = this._events.length - 1; j >= 0; j--) {
+      const e = this._events[j];
+      if (e.stream === query.stream && e.name === _chunkNNWP65YMcjs.SNAP_EVENT) return j;
+    }
+    return -1;
+  }
+  async query(callback, query) {
+    await sleep();
+    const floor = this._snap_floor(query);
+    const lo = floor >= 0 ? floor : this._first_index_after(_nullishCoalesce(_optionalChain([query, 'optionalAccess', _11 => _11.after]), () => ( -1)));
+    const hi = _optionalChain([query, 'optionalAccess', _12 => _12.before]) !== void 0 ? this._first_index_after(query.before - 1) : this._events.length;
+    const with_pii = _optionalChain([query, 'optionalAccess', _13 => _13.with_pii]) !== false;
+    let count = 0;
+    for (let k = 0; k < hi - lo; k++) {
+      const e = this._events[_optionalChain([query, 'optionalAccess', _14 => _14.backward]) ? hi - 1 - k : lo + k];
+      if (query && !this.in_query(query, e)) continue;
+      await Promise.resolve(
+        callback(this._with_pii(e, with_pii))
+      );
+      count++;
+      if (_optionalChain([query, 'optionalAccess', _15 => _15.limit]) && count >= query.limit) break;
+    }
+    return count;
+  }
+  async commit(stream, msgs, meta, expectedVersion) {
+    await sleep();
+    const current_version = _nullishCoalesce(this._stream_versions.get(stream), () => ( -1));
+    if (typeof expectedVersion === "number" && current_version !== expectedVersion) {
+      throw new (0, _chunkNNWP65YMcjs.ConcurrencyError)(
+        stream,
+        current_version,
+        msgs,
+        expectedVersion
+      );
+    }
+    let version = current_version + 1;
+    const committed = msgs.map(({ name, data, pii }) => {
+      const c = {
+        id: this._next_id++,
+        stream,
+        version,
+        created: /* @__PURE__ */ new Date(),
+        name,
+        data,
+        meta
+      };
+      this._events.push(c);
+      if (pii != null) this._put_pii(stream, c.id, pii);
+      version++;
+      return this._with_pii(c);
+    });
+    this._stream_versions.set(stream, version - 1);
+    return committed;
+  }
+  async claim(lagging, leading, by, millis, lane) {
+    await sleep();
+    const has_work = (s) => s.correlated_at !== void 0 && s.at < s.correlated_at;
+    const available = [...this._streams.values()].filter(
+      (s) => s.is_available && has_work(s) && (lane === void 0 || s.lane === lane)
+    );
+    const fair = lagging >= 2 ? Math.max(1, Math.floor(lagging / 4)) : 0;
+    const by_priority = [...available].sort(
+      (a, b) => b.priority - a.priority || a.at - b.at
+    );
+    const priority_slice = by_priority.slice(0, lagging - fair);
+    const picked = new Set(priority_slice.map((s) => s.stream));
+    const fair_slice = [...available].sort((a, b) => a.at - b.at).filter((s) => !picked.has(s.stream)).slice(0, fair);
+    const lag = [...priority_slice, ...fair_slice].map((s) => ({
+      stream: s.stream,
+      source: s.source,
+      at: s.at,
+      lagging: true
+    }));
+    const lead = available.sort((a, b) => b.at - a.at).slice(0, leading).map((s) => ({
+      stream: s.stream,
+      source: s.source,
+      at: s.at,
+      lagging: false
+    }));
+    const seen = /* @__PURE__ */ new Set();
+    const combined = [...lag, ...lead].filter((p) => {
+      if (seen.has(p.stream)) return false;
+      seen.add(p.stream);
+      return true;
+    });
+    return combined.map(
+      (p) => _optionalChain([this, 'access', _16 => _16._streams, 'access', _17 => _17.get, 'call', _18 => _18(p.stream), 'optionalAccess', _19 => _19.lease, 'call', _20 => _20({ ...p, by, retry: 0 }, millis)])
+    ).filter((l) => !!l);
+  }
+  async subscribe(streams, correlated_at, correlator) {
+    await sleep();
+    let correlating;
+    let keyed_at;
+    if (correlator) {
+      const now = Date.now();
+      const held = this._correlators.get(correlator.key);
+      const at = Math.max(_nullishCoalesce(_optionalChain([held, 'optionalAccess', _21 => _21.at]), () => ( this._correlated_at)), _nullishCoalesce(correlated_at, () => ( -1)));
+      keyed_at = at;
+      if (!held || held.until < now || held.by === correlator.by) {
+        correlating = true;
+        this._correlators.set(correlator.key, {
+          at,
+          by: correlator.by,
+          // Release outright, or a successor in the same ms is still refused.
+          until: correlator.millis > 0 ? now + correlator.millis : 0
+        });
+      } else {
+        correlating = false;
+        held.at = at;
+      }
+      if (correlated_at !== void 0 && correlated_at > this._correlated_at)
+        this._correlated_at = correlated_at;
+    } else if (correlated_at !== void 0 && correlated_at > this._correlated_at)
+      this._correlated_at = correlated_at;
+    let subscribed = 0;
+    for (const {
+      stream,
+      source,
+      priority = 0,
+      lane = _chunkNNWP65YMcjs.DEFAULT_LANE,
+      correlated_at: correlated_at2
+    } of streams) {
+      const existing = this._streams.get(stream);
+      if (existing) {
+        if (priority >= existing.priority) existing.lane = lane;
+        existing.bump_priority(priority);
+        if (correlated_at2 !== void 0) existing.mark(correlated_at2);
+      } else {
+        const created = new InMemoryStream(stream, source, priority, lane);
+        if (correlated_at2 !== void 0) created.mark(correlated_at2);
+        this._streams.set(stream, created);
+        subscribed++;
+      }
+    }
+    let watermark = -1;
+    for (const s of this._streams.values()) {
+      if (s.at > watermark) watermark = s.at;
+    }
+    return {
+      subscribed,
+      watermark,
+      correlated_at: _nullishCoalesce(keyed_at, () => ( this._correlated_at)),
+      ...correlating === void 0 ? {} : { correlating }
+    };
+  }
+  async ack(leases) {
+    await sleep();
+    return leases.map((l) => _optionalChain([this, 'access', _22 => _22._streams, 'access', _23 => _23.get, 'call', _24 => _24(l.stream), 'optionalAccess', _25 => _25.ack, 'call', _26 => _26(l)])).filter((l) => !!l);
+  }
+  async block(leases) {
+    await sleep();
+    return leases.map((l) => _optionalChain([this, 'access', _27 => _27._streams, 'access', _28 => _28.get, 'call', _29 => _29(l.stream), 'optionalAccess', _30 => _30.block, 'call', _31 => _31(l, l.error)])).filter((l) => !!l);
+  }
+  async defer(input, deferred_at) {
+    await sleep();
+    const selected = this._select(input);
+    for (const s of selected) s.defer(deferred_at);
+    return selected.length;
+  }
+  /** 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));
+  }
+  _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;
+    return (s) => {
+      if (filter.stream !== void 0) {
+        if (filter.stream_exact ? s.stream !== filter.stream : !stream_re.test(s.stream))
+          return false;
+      }
+      if (filter.source !== void 0) {
+        if (s.source === void 0) return false;
+        if (filter.source_exact ? s.source !== filter.source : !source_re.test(s.source))
+          return false;
+      }
+      if (filter.blocked !== void 0 && s.blocked !== filter.blocked)
+        return false;
+      if (filter.lane !== void 0 && s.lane !== filter.lane) return false;
+      return true;
+    };
+  }
+  async reset(input) {
+    await sleep();
+    const selected = this._select(input);
+    for (const s of selected) s.reset();
+    return selected.length;
+  }
+  async forget_pii(stream) {
+    await sleep();
+    const count = _nullishCoalesce(_optionalChain([this, 'access', _32 => _32._pii, 'access', _33 => _33.get, 'call', _34 => _34(stream), 'optionalAccess', _35 => _35.size]), () => ( 0));
+    this._pii.delete(stream);
+    return count;
+  }
+  async unblock(input) {
+    await sleep();
+    const selected = this._select(
+      Array.isArray(input) ? input : { ...input, blocked: true }
+    );
+    return selected.filter((s) => s.unblock()).length;
+  }
+  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;
+  }
+  async query_streams(callback, query) {
+    await sleep();
+    const limit = _nullishCoalesce(_optionalChain([query, 'optionalAccess', _36 => _36.limit]), () => ( 100));
+    const after = _optionalChain([query, 'optionalAccess', _37 => _37.after]);
+    const source_matches = _optionalChain([query, 'optionalAccess', _38 => _38.source_matches]);
+    const matches = this._filter_predicate(_nullishCoalesce(query, () => ( {})));
+    const reverse_cache = /* @__PURE__ */ new Map();
+    const reverse_match = (source) => {
+      let re = reverse_cache.get(source);
+      if (!re) {
+        re = new RegExp(source);
+        reverse_cache.set(source, re);
+      }
+      return source_matches.some((name) => re.test(name));
+    };
+    const sorted = [...this._streams.keys()].sort().map((stream) => this._streams.get(stream));
+    let count = 0;
+    for (const s of sorted) {
+      if (after !== void 0 && s.stream <= after) continue;
+      if (!matches(s)) continue;
+      if (source_matches !== void 0) {
+        if (s.source && !reverse_match(s.source)) continue;
+      }
+      if (count >= limit) break;
+      callback({
+        stream: s.stream,
+        source: s.source,
+        at: s.at,
+        retry: s.retry,
+        blocked: s.blocked,
+        error: s.error,
+        priority: s.priority,
+        leased_by: s.leased_by,
+        leased_until: s.leased_until,
+        lane: s.lane,
+        deferred_at: s.deferred_at,
+        correlated_at: s.correlated_at
+      });
+      count++;
+    }
+    return { maxEventId: _nullishCoalesce(_optionalChain([this, 'access', _39 => _39._events, 'access', _40 => _40.at, 'call', _41 => _41(-1), 'optionalAccess', _42 => _42.id]), () => ( -1)), count };
+  }
+  async query_stats(input, options) {
+    await sleep();
+    const exclude = new Set(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _43 => _43.exclude]), () => ( [])));
+    const want_tail = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _44 => _44.tail]), () => ( false));
+    const want_count = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _45 => _45.count]), () => ( false));
+    const want_names = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _46 => _46.names]), () => ( false));
+    const before = _optionalChain([options, 'optionalAccess', _47 => _47.before]);
+    const after = _optionalChain([options, 'optionalAccess', _48 => _48.after]);
+    const limit = _optionalChain([options, 'optionalAccess', _49 => _49.limit]);
+    const array_targets = Array.isArray(input) ? new Set(input) : null;
+    const filter = Array.isArray(input) ? null : input;
+    const stream_re = _optionalChain([filter, 'optionalAccess', _50 => _50.stream]) !== void 0 && !filter.stream_exact ? new RegExp(filter.stream) : void 0;
+    const scope_cache = /* @__PURE__ */ new Map();
+    const in_scope = (stream) => {
+      const cached = scope_cache.get(stream);
+      if (cached !== void 0) return cached;
+      let ok = true;
+      if (array_targets) {
+        ok = array_targets.has(stream);
+      } else if (_optionalChain([filter, 'optionalAccess', _51 => _51.stream]) !== void 0) {
+        ok = filter.stream_exact ? stream === filter.stream : (
+          // stream_re set when stream is regex
+          stream_re.test(stream)
+        );
+      }
+      scope_cache.set(stream, ok);
+      return ok;
+    };
+    const acc = /* @__PURE__ */ new Map();
+    for (const e of this._events) {
+      if (before !== void 0 && e.id >= before) continue;
+      if (!in_scope(e.stream)) continue;
+      if (exclude.has(e.name)) continue;
+      let a = acc.get(e.stream);
+      if (!a) {
+        a = { head: e, count: 0 };
+        if (want_tail) a.tail = e;
+        if (want_names) a.names = {};
+        acc.set(e.stream, a);
+      }
+      a.head = e;
+      a.count++;
+      if (want_names) {
+        const n = String(e.name);
+        a.names[n] = (_nullishCoalesce(a.names[n], () => ( 0))) + 1;
+      }
+    }
+    const ordered = [...acc.keys()].sort();
+    const out = /* @__PURE__ */ new Map();
+    for (const stream of ordered) {
+      if (limit !== void 0 && out.size >= limit) break;
+      if (after !== void 0 && stream <= after) continue;
+      const a = acc.get(stream);
+      const stats = { head: a.head };
+      if (want_tail) stats.tail = a.tail;
+      if (want_count) stats.count = a.count;
+      if (want_names) stats.names = a.names;
+      out.set(stream, stats);
+    }
+    return out;
+  }
+  async truncate(targets) {
+    await sleep();
+    const result = /* @__PURE__ */ new Map();
+    const windowed = targets.filter((t) => t.before !== void 0);
+    if (windowed.length) {
+      const drop = /* @__PURE__ */ new Set();
+      for (const { stream, before, max_id } of windowed) {
+        let boundary;
+        for (const e of this._events) {
+          if (e.stream === stream && e.name === _chunkNNWP65YMcjs.SNAP_EVENT && e.created < before && (max_id === void 0 || e.id <= max_id) && (!boundary || e.id > boundary.id))
+            boundary = e;
+        }
+        if (!boundary) continue;
+        let deleted = 0;
+        for (const e of this._events) {
+          if (e.stream === stream && e.id < boundary.id) {
+            drop.add(e.id);
+            _optionalChain([this, 'access', _52 => _52._pii, 'access', _53 => _53.get, 'call', _54 => _54(stream), 'optionalAccess', _55 => _55.delete, 'call', _56 => _56(e.id)]);
+            deleted++;
+          }
+        }
+        result.set(stream, { deleted, committed: boundary, before });
+      }
+      if (drop.size) this._events = this._events.filter((e) => !drop.has(e.id));
+    }
+    const full = targets.filter((t) => t.before === void 0);
+    for (const { stream, snapshot, meta } of full) {
+      let deleted = 0;
+      this._events = this._events.filter((e) => {
+        if (e.stream !== stream) return true;
+        deleted++;
+        return false;
+      });
+      this._stream_versions.delete(stream);
+      this._pii.delete(stream);
+      const event = {
+        id: this._next_id++,
+        stream,
+        version: 0,
+        created: /* @__PURE__ */ new Date(),
+        name: snapshot !== void 0 ? _chunkNNWP65YMcjs.SNAP_EVENT : _chunkNNWP65YMcjs.TOMBSTONE_EVENT,
+        data: _nullishCoalesce(snapshot, () => ( {})),
+        meta: _nullishCoalesce(meta, () => ( { correlation: "", causation: {} }))
+      };
+      this._events.push(event);
+      this._stream_versions.set(stream, 0);
+      result.set(stream, { deleted, committed: event });
+    }
+    return result;
+  }
+  /** A throw inside the driver restores the captured state. Ids restart at 0. */
+  async restore(driver) {
+    await sleep();
+    const prev_events = this._events;
+    const prev_next_id = this._next_id;
+    const prev_streams = this._streams;
+    const prev_stream_versions = this._stream_versions;
+    const prev_pii = this._pii;
+    const prev_correlated_at = this._correlated_at;
+    const prev_correlators = new Map(
+      [...this._correlators].map(([k, v]) => [k, { ...v }])
+    );
+    this._correlated_at = -1;
+    for (const c of this._correlators.values()) c.at = -1;
+    this._events = [];
+    this._next_id = 0;
+    this._streams = /* @__PURE__ */ new Map();
+    this._stream_versions = /* @__PURE__ */ new Map();
+    this._pii = /* @__PURE__ */ new Map();
+    try {
+      await driver(async (event) => {
+        const id = this._next_id++;
+        const { pii, ...rest } = event;
+        const committed = { ...rest, id };
+        this._events.push(committed);
+        if (pii != null) this._put_pii(event.stream, id, pii);
+        this._stream_versions.set(event.stream, event.version);
+        return id;
+      });
+    } catch (err) {
+      this._events = prev_events;
+      this._next_id = prev_next_id;
+      this._streams = prev_streams;
+      this._stream_versions = prev_stream_versions;
+      this._pii = prev_pii;
+      this._correlated_at = prev_correlated_at;
+      this._correlators = prev_correlators;
+      throw err;
+    }
+  }
+}, _class3);
+
+// src/disposers.ts
+var entries = [];
+var prune = () => {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const { ref } = entries[i];
+    if (ref && !ref.deref()) entries.splice(i, 1);
+  }
+};
+var register_disposer = (run) => {
+  prune();
+  entries.push({ run });
+};
+var register_weak_disposer = (ref, run) => {
+  prune();
+  entries.push({
+    run,
+    ref
+  });
+};
+var run_disposers = async () => {
+  for (const { run, ref } of [...entries].reverse()) {
+    if (!ref) {
+      await run();
+      continue;
+    }
+    const target = ref.deref();
+    if (target) await run(target);
+  }
+};
+
+// src/scoped.ts
+var _async_hooks = require('async_hooks');
+var scoped = new (0, _async_hooks.AsyncLocalStorage)();
+var reacting = new (0, _async_hooks.AsyncLocalStorage)();
+function make_run_scoped(bag) {
+  return (fn) => scoped.run(bag, fn);
+}
+function current_autoclose_window() {
+  return _optionalChain([scoped, 'access', _57 => _57.getStore, 'call', _58 => _58(), 'optionalAccess', _59 => _59.autoclose_window]);
+}
+function current_ports() {
+  return scoped.getStore();
+}
+function run_reacting(event, fn) {
+  const box = { event };
+  return reacting.run(box, async () => {
+    try {
+      return await fn();
+    } finally {
+      box.event = void 0;
+    }
+  });
+}
+function current_reacting() {
+  return _optionalChain([reacting, 'access', _60 => _60.getStore, 'call', _61 => _61(), 'optionalAccess', _62 => _62.event]);
+}
+function make_reaction_scope(app) {
+  return { app, run: run_reacting };
+}
+
+// src/ports.ts
+var adapters = /* @__PURE__ */ new Map();
+function port(injector) {
+  return (adapter) => {
+    if (!adapters.has(injector.name)) {
+      const injected = injector(adapter);
+      adapters.set(injector.name, injected);
+      log().info(`[act] + ${injector.name}:${injected.constructor.name}`);
+    }
+    return adapters.get(injector.name);
+  };
+}
+var log = port(function log2(adapter) {
+  const cfg = config();
+  return adapter || new ConsoleLogger({
+    level: cfg.logLevel,
+    pretty: cfg.env !== "production"
+  });
+});
+var _store = port(function store(adapter) {
+  return _nullishCoalesce(adapter, () => ( new InMemoryStore()));
+});
+var store2 = ((adapter) => {
+  return _nullishCoalesce(_optionalChain([current_ports, 'call', _63 => _63(), 'optionalAccess', _64 => _64.store]), () => ( _store(adapter)));
+});
+var _cache = port(function cache(adapter) {
+  return _nullishCoalesce(adapter, () => ( new InMemoryCache()));
+});
+var cache2 = ((adapter) => {
+  return _nullishCoalesce(_optionalChain([current_ports, 'call', _65 => _65(), 'optionalAccess', _66 => _66.cache]), () => ( _cache(adapter)));
+});
+var default_scope = () => DEFAULT_SCOPE;
+var DEFAULT_SCOPE = {
+  get store() {
+    return _store();
+  },
+  get cache() {
+    return _cache();
+  }
+};
+async function disposeAndExit(code = "EXIT") {
+  if (code === "ERROR" && config().env === "production") {
+    log().warn(
+      "disposeAndExit('ERROR') ignored in production \u2014 process kept alive"
+    );
+    return;
+  }
+  await run_disposers();
+  for (const adapter of [...adapters.values()].reverse()) {
+    await adapter.dispose();
+    log().info(`[act] - ${adapter.constructor.name}`);
+  }
+  adapters.clear();
+  config().env !== "test" && process.exit(code === "ERROR" ? 1 : 0);
+}
+function dispose(disposer) {
+  disposer && register_disposer(disposer);
+  return disposeAndExit;
+}
+
+// src/config.ts
+var PackageSchema = _zod.z.object({
+  name: _zod.z.string().min(1),
+  version: _zod.z.string().min(1),
+  description: _zod.z.string().min(1).optional(),
+  author: _zod.z.object({ name: _zod.z.string().min(1), email: _zod.z.string().optional() }).optional().or(_zod.z.string().min(1)).optional(),
+  license: _zod.z.string().min(1).optional(),
+  dependencies: _zod.z.record(_zod.z.string(), _zod.z.string()).optional()
+});
+var FALLBACK_PACKAGE = {
+  name: "act-fallback",
+  version: "0.0.0-fallback",
+  description: "Synthetic fallback \u2014 package.json could not be loaded"
+};
+var get_package = () => {
+  try {
+    const raw = JSON.parse(fs.readFileSync("package.json").toString());
+    const pkg2 = {
+      name: FALLBACK_PACKAGE.name,
+      version: FALLBACK_PACKAGE.version
+    };
+    for (const [key, schema] of Object.entries(PackageSchema.shape)) {
+      const field = schema.safeParse(_optionalChain([raw, 'optionalAccess', _67 => _67[key]]));
+      if (field.success && field.data !== void 0) pkg2[key] = field.data;
+    }
+    return pkg2;
+  } catch (err) {
+    pkg_load_error = err;
+    return FALLBACK_PACKAGE;
+  }
+};
+var pkg_load_error;
+var BaseSchema = PackageSchema.extend({
+  env: _zod.z.enum(_chunkNNWP65YMcjs.Environments),
+  logLevel: _zod.z.enum(_chunkNNWP65YMcjs.LogLevels),
+  logSingleLine: _zod.z.boolean(),
+  sleepMs: _zod.z.number().int().min(0).max(5e3)
+});
+var { NODE_ENV, LOG_LEVEL, LOG_SINGLE_LINE, SLEEP_MS } = process.env;
+var env = NODE_ENV || "development";
+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" : _nullishCoalesce(SLEEP_MS, () => ( "100")), 10);
+var pkg = get_package();
+var _validated;
+var config = () => {
+  if (!_validated) {
+    _validated = extend(
+      { ...pkg, env, logLevel, logSingleLine, sleepMs },
+      BaseSchema
+    );
+    if (pkg_load_error) {
+      const msg = pkg_load_error instanceof Error ? pkg_load_error.message : typeof pkg_load_error === "string" ? pkg_load_error : "unknown error";
+      log().warn(
+        `[act] Could not read package.json (${msg}); using synthetic name="${FALLBACK_PACKAGE.name}" version="${FALLBACK_PACKAGE.version}".`
+      );
+      pkg_load_error = void 0;
+    }
+  }
+  return _validated;
+};
+function resolveAutocloseConfig2(options) {
+  return resolveAutocloseConfig(options);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ConsoleLogger = ConsoleLogger; exports.LruMap = LruMap; exports.InMemoryCache = InMemoryCache; exports.DEFAULT_BACKOFF = DEFAULT_BACKOFF; exports.DEFAULT_MAX_RETRIES = DEFAULT_MAX_RETRIES; exports.DEFAULT_BLOCK_ON_ERROR = DEFAULT_BLOCK_ON_ERROR; exports.resolveReactionConfig = resolveReactionConfig; exports.resolveActionConfig = resolveActionConfig; exports.resolveLaneConfig = resolveLaneConfig; exports.DEFAULT_STREAM_LIMIT = DEFAULT_STREAM_LIMIT; exports.DEFAULT_EVENT_LIMIT = DEFAULT_EVENT_LIMIT; exports.DEFAULT_LEASE_MILLIS = DEFAULT_LEASE_MILLIS; exports.resolveDrainConfig = resolveDrainConfig; exports.resolveSettleConfig = resolveSettleConfig; exports.MAX_SHUTDOWN_GRACE_MS = MAX_SHUTDOWN_GRACE_MS; exports.resolveShutdownConfig = resolveShutdownConfig; exports.resolveActConfig = resolveActConfig; exports.resolveAutocloseConfig = resolveAutocloseConfig; exports.resolveCircuitBreakerConfig = resolveCircuitBreakerConfig; exports.resolveFoldConfig = resolveFoldConfig; exports.PackageSchema = PackageSchema; exports.config = config; exports.resolveAutocloseConfig2 = resolveAutocloseConfig2; exports.validate = validate; exports.extend = extend; exports.sleep = sleep; exports.is_literal_source = is_literal_source; exports.dateReviver = dateReviver; exports.InMemoryStore = InMemoryStore; exports.register_weak_disposer = register_weak_disposer; exports.make_run_scoped = make_run_scoped; exports.current_autoclose_window = current_autoclose_window; exports.current_reacting = current_reacting; exports.make_reaction_scope = make_reaction_scope; exports.port = port; exports.log = log; exports.store = store2; exports.cache = cache2; exports.default_scope = default_scope; exports.disposeAndExit = disposeAndExit; exports.dispose = dispose;
+//# sourceMappingURL=chunk-YKL44PYX.cjs.map