@rotorsoft/act 0.3.0 → 0.4.1

package/dist/index.js

@@ -1,28 +1,863 @@
-import { config } from "./config";
-import { disposeAndExit, logger } from "./ports";
-/** @module act */
-export * from "./act";
-export * from "./act-builder";
-export * from "./ports";
-export * from "./state-builder";
-export * from "./types";
-export * from "./utils";
-export { config };
-// exit on signals
+// src/config.ts
+import * as dotenv from "dotenv";
+import * as fs from "fs";
+import { z as z2 } from "zod/v4";
+
+// src/types/errors.ts
+var Errors = {
+  ValidationError: "ERR_VALIDATION",
+  InvariantError: "ERR_INVARIANT",
+  ConcurrencyError: "ERR_CONCURRENCY"
+};
+var ValidationError = class extends Error {
+  constructor(target, payload, details) {
+    super(`Invalid ${target} payload`);
+    this.target = target;
+    this.payload = payload;
+    this.details = details;
+    this.name = Errors.ValidationError;
+  }
+};
+var InvariantError = class extends Error {
+  details;
+  constructor(name, payload, target, description) {
+    super(`${name} failed invariant: ${description}`);
+    this.name = Errors.InvariantError;
+    this.details = { name, payload, target, description };
+  }
+};
+var ConcurrencyError = class extends Error {
+  constructor(lastVersion, events, expectedVersion) {
+    super(
+      `Concurrency error committing event "${events.at(0)?.name}". Expected version ${expectedVersion} but found version ${lastVersion}.`
+    );
+    this.lastVersion = lastVersion;
+    this.events = events;
+    this.expectedVersion = expectedVersion;
+    this.name = Errors.ConcurrencyError;
+  }
+};
+
+// src/types/schemas.ts
+import { z } from "zod/v4";
+var ZodEmpty = z.record(z.string(), z.never());
+var ActorSchema = z.object({
+  id: z.string(),
+  name: z.string()
+}).readonly();
+var TargetSchema = z.object({
+  stream: z.string(),
+  actor: ActorSchema,
+  expectedVersion: z.number().optional()
+}).readonly();
+var CausationEventSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  stream: z.string()
+});
+var EventMetaSchema = z.object({
+  correlation: z.string(),
+  causation: z.object({
+    action: TargetSchema.and(z.object({ name: z.string() })).optional(),
+    event: CausationEventSchema.optional()
+  })
+}).readonly();
+var CommittedMetaSchema = z.object({
+  id: z.number(),
+  stream: z.string(),
+  version: z.number(),
+  created: z.date(),
+  meta: EventMetaSchema
+}).readonly();
+function buildSnapshotSchema(s) {
+  const events = Object.entries(s.events).map(
+    ([name, zod]) => z.object({
+      name: z.literal(name),
+      data: zod,
+      id: z.number(),
+      stream: z.string(),
+      version: z.number(),
+      created: z.date(),
+      meta: EventMetaSchema
+    })
+  );
+  return z.object({
+    state: s.state.readonly(),
+    event: z.union([events[0], events[1], ...events.slice(2)]).optional(),
+    patches: z.number(),
+    snaps: z.number()
+  });
+}
+var QuerySchema = z.object({
+  stream: z.string().optional(),
+  names: z.string().array().optional(),
+  before: z.number().optional(),
+  after: z.number().optional(),
+  limit: z.number().optional(),
+  created_before: z.date().optional(),
+  created_after: z.date().optional(),
+  backward: z.boolean().optional(),
+  correlation: z.string().optional()
+});
+
+// src/types/index.ts
+var Environments = [
+  "development",
+  "test",
+  "staging",
+  "production"
+];
+var LogLevels = [
+  "fatal",
+  "error",
+  "warn",
+  "info",
+  "debug",
+  "trace"
+];
+
+// src/utils.ts
+import { prettifyError } from "zod/v4";
+var UNMERGEABLES = [
+  RegExp,
+  Date,
+  Array,
+  Map,
+  Set,
+  WeakMap,
+  WeakSet,
+  ArrayBuffer,
+  SharedArrayBuffer,
+  DataView,
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array
+];
+var is_mergeable = (value) => !!value && typeof value === "object" && !UNMERGEABLES.some((t) => value instanceof t);
+var patch = (original, patches) => {
+  const copy = {};
+  Object.keys({ ...original, ...patches }).forEach((key) => {
+    const patched_value = patches[key];
+    const original_value = original[key];
+    const patched = patches && key in patches;
+    const deleted = patched && (typeof patched_value === "undefined" || patched_value === null);
+    const value = patched && !deleted ? patched_value : original_value;
+    !deleted && (copy[key] = is_mergeable(value) ? patch(original_value || {}, patched_value || {}) : value);
+  });
+  return copy;
+};
+var validate = (target, payload, schema) => {
+  try {
+    return schema ? schema.parse(payload) : payload;
+  } catch (error) {
+    if (error instanceof Error && error.name === "ZodError") {
+      throw new ValidationError(
+        target,
+        payload,
+        prettifyError(error)
+      );
+    }
+    throw new ValidationError(target, payload, error);
+  }
+};
+var extend = (source, schema, target) => {
+  const value = validate("config", source, schema);
+  return Object.assign(target || {}, value);
+};
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms ?? config().sleepMs));
+}
+
+// src/config.ts
+dotenv.config();
+var PackageSchema = z2.object({
+  name: z2.string().min(1),
+  version: z2.string().min(1),
+  description: z2.string().min(1),
+  author: z2.object({ name: z2.string().min(1), email: z2.string().optional() }).or(z2.string().min(1)),
+  license: z2.string().min(1),
+  dependencies: z2.record(z2.string(), z2.string())
+});
+var getPackage = () => {
+  const pkg2 = fs.readFileSync("package.json");
+  return JSON.parse(pkg2.toString());
+};
+var BaseSchema = PackageSchema.extend({
+  env: z2.enum(Environments),
+  logLevel: z2.enum(LogLevels),
+  logSingleLine: z2.boolean(),
+  sleepMs: z2.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" ? "error" : LOG_LEVEL === "production" ? "info" : "trace");
+var logSingleLine = (LOG_SINGLE_LINE || "true") === "true";
+var sleepMs = parseInt(NODE_ENV === "test" ? "0" : SLEEP_MS ?? "100");
+var pkg = getPackage();
+var config = () => {
+  return extend({ ...pkg, env, logLevel, logSingleLine, sleepMs }, BaseSchema);
+};
+
+// src/ports.ts
+import { pino } from "pino";
+
+// src/adapters/InMemoryStore.ts
+var InMemoryStream = class {
+  constructor(stream) {
+    this.stream = stream;
+  }
+  _at = -1;
+  _retry = -1;
+  _lease;
+  _blocked = false;
+  lease(lease) {
+    if (!this._blocked && lease.at > this._at) {
+      this._lease = { ...lease, retry: this._retry + 1 };
+      return this._lease;
+    }
+  }
+  ack(lease) {
+    if (this._lease && lease.at >= this._at) {
+      this._retry = lease.retry;
+      this._blocked = lease.block;
+      if (!this._blocked && !lease.error) {
+        this._at = lease.at;
+        this._retry = 0;
+      }
+      this._lease = void 0;
+    }
+  }
+};
+var InMemoryStore = class {
+  // stored events
+  _events = [];
+  // stored stream positions and other metadata
+  _streams = /* @__PURE__ */ new Map();
+  async dispose() {
+    await sleep();
+    this._events.length = 0;
+  }
+  async seed() {
+    await sleep();
+  }
+  async drop() {
+    await sleep();
+    this._events.length = 0;
+  }
+  async query(callback, query) {
+    await sleep();
+    const {
+      stream,
+      names,
+      before,
+      after = -1,
+      limit,
+      created_before,
+      created_after,
+      correlation
+    } = query || {};
+    let i = after + 1, count = 0;
+    while (i < this._events.length) {
+      const e = this._events[i++];
+      if (stream && e.stream !== stream) continue;
+      if (names && !names.includes(e.name)) continue;
+      if (correlation && e.meta?.correlation !== correlation) continue;
+      if (created_after && e.created <= created_after) continue;
+      if (before && e.id >= before) break;
+      if (created_before && e.created >= created_before) break;
+      callback(e);
+      count++;
+      if (limit && count >= limit) break;
+    }
+    return count;
+  }
+  async commit(stream, msgs, meta, expectedVersion) {
+    await sleep();
+    const instance = this._events.filter((e) => e.stream === stream);
+    if (expectedVersion && instance.length - 1 !== expectedVersion)
+      throw new ConcurrencyError(
+        instance.length - 1,
+        msgs,
+        expectedVersion
+      );
+    let version = instance.length;
+    return msgs.map(({ name, data }) => {
+      const committed = {
+        id: this._events.length,
+        stream,
+        version,
+        created: /* @__PURE__ */ new Date(),
+        name,
+        data,
+        meta
+      };
+      this._events.push(committed);
+      version++;
+      return committed;
+    });
+  }
+  /**
+   * Fetches new events from stream watermarks
+   */
+  async fetch(limit) {
+    const streams = [...this._streams.values()].filter((s) => !s._blocked).sort((a, b) => a._at - b._at).slice(0, limit);
+    const after = streams.length ? streams.reduce(
+      (min, s) => Math.min(min, s._at),
+      Number.MAX_SAFE_INTEGER
+    ) : -1;
+    const events = [];
+    await this.query((e) => events.push(e), { after, limit });
+    return { streams: streams.map(({ stream }) => stream), events };
+  }
+  async lease(leases) {
+    await sleep();
+    return leases.map((lease) => {
+      const stream = this._streams.get(lease.stream) || // store new correlations
+      this._streams.set(lease.stream, new InMemoryStream(lease.stream)).get(lease.stream);
+      return stream.lease(lease);
+    }).filter((l) => !!l);
+  }
+  async ack(leases) {
+    await sleep();
+    leases.forEach((lease) => this._streams.get(lease.stream)?.ack(lease));
+  }
+};
+
+// src/ports.ts
+var ExitCodes = ["ERROR", "EXIT"];
+var logger = pino({
+  transport: config().env !== "production" ? {
+    target: "pino-pretty",
+    options: {
+      ignore: "pid,hostname",
+      singleLine: config().logSingleLine,
+      colorize: true
+    }
+  } : void 0,
+  level: config().logLevel
+});
+var adapters = /* @__PURE__ */ new Map();
+function port(injector) {
+  return function(adapter) {
+    if (!adapters.has(injector.name)) {
+      const injected = injector(adapter);
+      adapters.set(injector.name, injected);
+      logger.info(`\u{1F50C} injected ${injector.name}:${injected.constructor.name}`);
+    }
+    return adapters.get(injector.name);
+  };
+}
+var disposers = [];
+async function disposeAndExit(code = "EXIT") {
+  if (code === "ERROR" && config().env === "production") return;
+  await Promise.all(disposers.map((disposer) => disposer()));
+  await Promise.all(
+    [...adapters.values()].reverse().map(async (adapter) => {
+      await adapter.dispose();
+      logger.info(`\u{1F50C} disposed ${adapter.constructor.name}`);
+    })
+  );
+  adapters.clear();
+  config().env !== "test" && process.exit(code === "ERROR" ? 1 : 0);
+}
+function dispose(disposer) {
+  disposer && disposers.push(disposer);
+  return disposeAndExit;
+}
+var SNAP_EVENT = "__snapshot__";
+var store = port(function store2(adapter) {
+  return adapter || new InMemoryStore();
+});
+
+// src/act.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import EventEmitter from "events";
+
+// src/event-sourcing.ts
+import { randomUUID } from "crypto";
+async function snap(snapshot) {
+  try {
+    const { id, stream, name, meta, version } = snapshot.event;
+    const snapped = await store().commit(
+      stream,
+      [{ name: SNAP_EVENT, data: snapshot.state }],
+      {
+        correlation: meta.correlation,
+        causation: { event: { id, name, stream } }
+      },
+      version
+      // IMPORTANT! - state events are committed right after the snapshot event
+    );
+    logger.trace(snapped, "\u{1F7E0} snap");
+  } catch (error) {
+    logger.error(error);
+  }
+}
+async function load(me, stream, callback) {
+  let state2 = me.init ? me.init() : {};
+  let patches = 0;
+  let snaps = 0;
+  let event;
+  await store().query(
+    (e) => {
+      event = e;
+      if (e.name === SNAP_EVENT) {
+        state2 = e.data;
+        snaps++;
+        patches = 0;
+      } else if (me.patch[e.name]) {
+        state2 = patch(state2, me.patch[e.name](event, state2));
+        patches++;
+      }
+      callback && callback({ event, state: state2, patches, snaps });
+    },
+    { stream },
+    true
+  );
+  logger.trace({ stream, patches, snaps, state: state2 }, "\u{1F7E2} load");
+  return { event, state: state2, patches, snaps };
+}
+async function action(me, action2, target, payload, reactingTo, skipValidation = false) {
+  const { stream, expectedVersion, actor } = target;
+  if (!stream) throw new Error("Missing target stream");
+  payload = skipValidation ? payload : validate(action2, payload, me.actions[action2]);
+  logger.trace(
+    payload,
+    `\u{1F535} ${action2} "${stream}${expectedVersion ? `@${expectedVersion}` : ""}"`
+  );
+  let snapshot = await load(me, stream);
+  if (me.given) {
+    const invariants = me.given[action2] || [];
+    invariants.forEach(({ valid, description }) => {
+      if (!valid(snapshot.state, actor))
+        throw new InvariantError(
+          action2,
+          payload,
+          target,
+          description
+        );
+    });
+  }
+  let { state: state2, patches } = snapshot;
+  const result = me.on[action2](payload, state2, target);
+  if (!result) return snapshot;
+  if (Array.isArray(result) && result.length === 0) {
+    return snapshot;
+  }
+  const tuples = Array.isArray(result[0]) ? result : [result];
+  const emitted = tuples.map(([name, data]) => ({
+    name,
+    data: skipValidation ? data : validate(name, data, me.events[name])
+  }));
+  const meta = {
+    correlation: reactingTo?.meta.correlation || randomUUID(),
+    causation: {
+      action: {
+        name: action2,
+        ...target
+        // payload: TODO: flag to include action payload in metadata
+        // not included by default to avoid large payloads
+      },
+      event: reactingTo ? {
+        id: reactingTo.id,
+        name: reactingTo.name,
+        stream: reactingTo.stream
+      } : void 0
+    }
+  };
+  const committed = await store().commit(
+    stream,
+    emitted,
+    meta,
+    // TODO: review reactions not enforcing expected version
+    reactingTo ? void 0 : expectedVersion || snapshot.event?.version
+  );
+  snapshot = committed.map((event) => {
+    state2 = patch(state2, me.patch[event.name](event, state2));
+    patches++;
+    logger.trace({ event, state: state2 }, "\u{1F534} commit");
+    return { event, state: state2, patches, snaps: snapshot.snaps };
+  }).at(-1);
+  me.snap && me.snap(snapshot) && void snap(snapshot);
+  return snapshot;
+}
+
+// src/act.ts
+var Act = class {
+  constructor(registry, drainLimit) {
+    this.registry = registry;
+    this.drainLimit = drainLimit;
+  }
+  _emitter = new EventEmitter();
+  emit(event, args) {
+    return this._emitter.emit(event, args);
+  }
+  on(event, listener) {
+    this._emitter.on(event, listener);
+    return this;
+  }
+  /**
+   * Executes an action and emits an event to be committed by the store.
+   *
+   * @template K The type of action to execute
+   * @template T The type of target
+   * @template P The type of payloads
+   * @param action The action to execute
+   * @param target The target of the action
+   * @param payload The payload of the action
+   * @param reactingTo The event that the action is reacting to
+   * @param skipValidation Whether to skip validation
+   * @returns The snapshot of the committed Event
+   */
+  async do(action2, target, payload, reactingTo, skipValidation = false) {
+    const snapshot = await action(
+      this.registry.actions[action2],
+      action2,
+      target,
+      payload,
+      reactingTo,
+      skipValidation
+    );
+    this.emit("committed", snapshot);
+    return snapshot;
+  }
+  /**
+   * Loads a snapshot of the state from the store.
+   *
+   * @template SX The type of state
+   * @template EX The type of events
+   * @template AX The type of actions
+   * @param state The state to load
+   * @param stream The stream to load
+   * @param callback The callback to call with the snapshot
+   * @returns The snapshot of the loaded state
+   */
+  async load(state2, stream, callback) {
+    return await load(state2, stream, callback);
+  }
+  /**
+   * Queries the store for events.
+   *
+   * @param query The query to execute
+   * @param callback The callback to call with the events
+   * @returns The query result
+   */
+  async query(query, callback) {
+    let first = void 0, last = void 0;
+    const count = await store().query((e) => {
+      !first && (first = e);
+      last = e;
+      callback && callback(e);
+    }, query);
+    return { first, last, count };
+  }
+  /**
+   * Handles leased reactions.
+   *
+   * @param lease The lease to handle
+   * @param reactions The reactions to handle
+   * @returns The lease
+   */
+  async handle(lease, reactions) {
+    const stream = lease.stream;
+    lease.retry > 0 && logger.warn(`Retrying ${stream}@${lease.at} (${lease.retry}).`);
+    for (const reaction of reactions) {
+      const { event, handler, options } = reaction;
+      try {
+        await handler(event, stream);
+        lease.at = event.id;
+      } catch (error) {
+        lease.error = error;
+        if (error instanceof ValidationError)
+          logger.error({ stream, error }, error.message);
+        else logger.error(error);
+        if (lease.retry < options.maxRetries) lease.retry++;
+        else if (options.blockOnError) {
+          lease.block = true;
+          logger.error(`Blocked ${stream} after ${lease.retry} retries.`);
+        }
+        break;
+      }
+    }
+    return lease;
+  }
+  drainLocked = false;
+  /**
+   * Drains events from the store.
+   *
+   * @returns The number of drained events
+   */
+  async drain() {
+    if (this.drainLocked) return 0;
+    this.drainLocked = true;
+    const drained = [];
+    const { streams, events } = await store().fetch(this.drainLimit);
+    if (events.length) {
+      logger.trace(
+        events.map(({ id, stream, name }) => ({ id, stream, name })).reduce(
+          (a, { id, stream, name }) => ({ ...a, [id]: { [stream]: name } }),
+          {}
+        ),
+        "\u26A1\uFE0F fetch"
+      );
+      const resolved = new Set(streams);
+      const correlated = /* @__PURE__ */ new Map();
+      for (const event of events)
+        for (const reaction of this.registry.events[event.name].reactions.values()) {
+          const stream = typeof reaction.resolver === "string" ? reaction.resolver : reaction.resolver(event);
+          if (stream) {
+            resolved.add(stream);
+            (correlated.get(stream) || correlated.set(stream, []).get(stream)).push({ ...reaction, event });
+          }
+        }
+      const last = events.at(-1).id;
+      const leases = [...resolved.values()].map((stream) => ({
+        by: randomUUID2(),
+        stream,
+        at: last,
+        retry: 0,
+        block: false
+      }));
+      const leased = await store().lease(leases);
+      logger.trace(
+        leased.map(({ stream, at, retry }) => ({ stream, at, retry })).reduce(
+          (a, { stream, at, retry }) => ({ ...a, [stream]: { at, retry } }),
+          {}
+        ),
+        "\u26A1\uFE0F lease"
+      );
+      const handling = leased.map((lease) => ({
+        lease,
+        reactions: correlated.get(lease.stream) || []
+      })).filter(({ reactions }) => reactions.length);
+      if (handling.length) {
+        await Promise.allSettled(
+          handling.map(({ lease, reactions }) => this.handle(lease, reactions))
+        ).then(
+          (promise) => {
+            promise.forEach((result) => {
+              if (result.status === "rejected") logger.error(result.reason);
+              else if (!result.value.error) drained.push(result.value);
+            });
+          },
+          (error) => logger.error(error)
+        );
+        drained.length && this.emit("drained", drained);
+      }
+      await store().ack(leased);
+      logger.trace(
+        leased.map(({ stream, at, retry, block, error }) => ({
+          stream,
+          at,
+          retry,
+          block,
+          error
+        })).reduce(
+          (a, { stream, at, retry, block, error }) => ({
+            ...a,
+            [stream]: { at, retry, block, error }
+          }),
+          {}
+        ),
+        "\u26A1\uFE0F ack"
+      );
+    }
+    this.drainLocked = false;
+    return drained.length;
+  }
+};
+
+// src/act-builder.ts
+var _this_ = ({ stream }) => stream;
+var _void_ = () => void 0;
+function act(states = /* @__PURE__ */ new Set(), registry = {
+  actions: {},
+  events: {}
+}) {
+  const builder = {
+    /**
+     * Adds a state to the builder.
+     *
+     * @template SX The type of state
+     * @template EX The type of events
+     * @template AX The type of actions
+     * @param state The state to add
+     * @returns The builder
+     */
+    with: (state2) => {
+      if (!states.has(state2.name)) {
+        states.add(state2.name);
+        for (const name of Object.keys(state2.actions)) {
+          if (registry.actions[name])
+            throw new Error(`Duplicate action "${name}"`);
+          registry.actions[name] = state2;
+        }
+        for (const name of Object.keys(state2.events)) {
+          if (registry.events[name])
+            throw new Error(`Duplicate event "${name}"`);
+          registry.events[name] = {
+            schema: state2.events[name],
+            reactions: /* @__PURE__ */ new Map()
+          };
+        }
+      }
+      return act(
+        states,
+        registry
+      );
+    },
+    /**
+     * Adds a reaction to an event.
+     *
+     * @template K The type of event
+     * @param event The event to add a reaction to
+     * @returns The builder
+     */
+    on: (event) => ({
+      do: (handler, options) => {
+        const reaction = {
+          handler,
+          resolver: _this_,
+          options: {
+            blockOnError: options?.blockOnError ?? true,
+            maxRetries: options?.maxRetries ?? 3,
+            retryDelayMs: options?.retryDelayMs ?? 1e3
+          }
+        };
+        registry.events[event].reactions.set(handler.name, reaction);
+        return {
+          ...builder,
+          to(resolver) {
+            registry.events[event].reactions.set(handler.name, {
+              ...reaction,
+              resolver
+            });
+            return builder;
+          },
+          void() {
+            registry.events[event].reactions.set(handler.name, {
+              ...reaction,
+              resolver: _void_
+            });
+            return builder;
+          }
+        };
+      }
+    }),
+    build: (drainLimit = 10) => new Act(registry, drainLimit),
+    events: registry.events
+  };
+  return builder;
+}
+
+// src/state-builder.ts
+function state(name, state2) {
+  return {
+    init(init) {
+      return {
+        emits(events) {
+          return {
+            patch(patch2) {
+              return action_builder({
+                events,
+                actions: {},
+                state: state2,
+                name,
+                init,
+                patch: patch2,
+                on: {}
+              });
+            }
+          };
+        }
+      };
+    }
+  };
+}
+function action_builder(state2) {
+  return {
+    on(action2, schema) {
+      if (action2 in state2.actions)
+        throw new Error(`Duplicate action "${action2}"`);
+      const actions = { ...state2.actions, [action2]: schema };
+      const on = { ...state2.on };
+      const _given = { ...state2.given };
+      function given(rules) {
+        _given[action2] = rules;
+        return { emit };
+      }
+      function emit(handler) {
+        on[action2] = handler;
+        return action_builder({
+          ...state2,
+          actions,
+          on,
+          given: _given
+        });
+      }
+      return { given, emit };
+    },
+    snap(snap2) {
+      return action_builder({ ...state2, snap: snap2 });
+    },
+    build() {
+      return state2;
+    }
+  };
+}
+
+// src/index.ts
 process.once("SIGINT", async (arg) => {
-    logger.info(arg, "SIGINT");
-    await disposeAndExit("EXIT");
+  logger.info(arg, "SIGINT");
+  await disposeAndExit("EXIT");
 });
 process.once("SIGTERM", async (arg) => {
-    logger.info(arg, "SIGTERM");
-    await disposeAndExit("EXIT");
+  logger.info(arg, "SIGTERM");
+  await disposeAndExit("EXIT");
 });
 process.once("uncaughtException", async (arg) => {
-    logger.error(arg, "Uncaught Exception");
-    await disposeAndExit("ERROR");
+  logger.error(arg, "Uncaught Exception");
+  await disposeAndExit("ERROR");
 });
 process.once("unhandledRejection", async (arg) => {
-    logger.error(arg, "Unhandled Rejection");
-    await disposeAndExit("ERROR");
+  logger.error(arg, "Unhandled Rejection");
+  await disposeAndExit("ERROR");
 });
+export {
+  Act,
+  ActorSchema,
+  CausationEventSchema,
+  CommittedMetaSchema,
+  ConcurrencyError,
+  Environments,
+  Errors,
+  EventMetaSchema,
+  ExitCodes,
+  InvariantError,
+  LogLevels,
+  QuerySchema,
+  SNAP_EVENT,
+  TargetSchema,
+  ValidationError,
+  ZodEmpty,
+  act,
+  buildSnapshotSchema,
+  config,
+  dispose,
+  disposeAndExit,
+  extend,
+  logger,
+  patch,
+  port,
+  sleep,
+  state,
+  store,
+  validate
+};
 //# sourceMappingURL=index.js.map