hierarchical-approval 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1759 @@
+'use strict';
+
+var crypto = require('crypto');
+var zod = require('zod');
+var EventEmitter = require('eventemitter3');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+
+// src/engine/ApprovalEngine.ts
+var SubmitOptionsSchema = zod.z.object({
+  templateName: zod.z.string().min(1),
+  documentId: zod.z.string().min(1),
+  documentType: zod.z.string().min(1),
+  submittedBy: zod.z.string().min(1),
+  data: zod.z.record(zod.z.string(), zod.z.unknown()).default({}),
+  metadata: zod.z.record(zod.z.string(), zod.z.unknown()).default({}),
+  expiresAt: zod.z.coerce.date().optional(),
+  deadlineAction: zod.z.enum(["cancel", "reject"]).optional()
+});
+var ApproveOptionsSchema = zod.z.object({
+  approverId: zod.z.string().min(1),
+  comment: zod.z.string().optional()
+});
+var RejectOptionsSchema = zod.z.object({
+  approverId: zod.z.string().min(1),
+  reason: zod.z.string().min(1),
+  returnTo: zod.z.enum(["originator", "previous"]).optional()
+});
+var DelegateOptionsSchema = zod.z.object({
+  fromApprover: zod.z.string().min(1),
+  toApprover: zod.z.string().min(1),
+  reason: zod.z.string().min(1),
+  until: zod.z.coerce.date().optional()
+});
+var CancelOptionsSchema = zod.z.object({
+  cancelledBy: zod.z.string().min(1),
+  reason: zod.z.string().min(1)
+});
+var EscalateOptionsSchema = zod.z.object({
+  escalatedBy: zod.z.string().min(1)
+});
+var ResubmitOptionsSchema = zod.z.object({
+  resubmittedBy: zod.z.string().min(1),
+  reason: zod.z.string().optional(),
+  updatedData: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var AddCommentOptionsSchema = zod.z.object({
+  actorId: zod.z.string().min(1),
+  comment: zod.z.string().min(1)
+});
+var OverrideOptionsSchema = zod.z.object({
+  overriddenBy: zod.z.string().min(1),
+  justification: zod.z.string().min(1)
+});
+var EventBus = class {
+  constructor() {
+    this.emitter = new EventEmitter__default.default();
+  }
+  emit(event, payload) {
+    this.emitter.emit(event, payload);
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.emitter.once(event, listener);
+    return this;
+  }
+};
+
+// src/utils/Logger.ts
+var noopLogger = {
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  },
+  debug: () => {
+  }
+};
+
+// src/utils/Clock.ts
+var systemClock = { now: () => /* @__PURE__ */ new Date() };
+
+// src/utils/IdGenerator.ts
+var defaultIdGenerator = (prefix) => `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+
+// src/errors.ts
+var ApprovalError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "ApprovalError";
+  }
+  toJSON() {
+    return { code: this.code, message: this.message, name: this.name };
+  }
+  toHttpStatus() {
+    const map = {
+      NOT_FOUND: 404,
+      CONFLICT: 409,
+      FORBIDDEN: 403,
+      VALIDATION: 422,
+      TEMPLATE_NOT_FOUND: 404
+    };
+    return map[this.code] ?? 500;
+  }
+};
+var ApprovalNotFoundError = class extends ApprovalError {
+  constructor(resource, id) {
+    super(`${resource} "${id}" not found.`, "NOT_FOUND");
+    this.name = "ApprovalNotFoundError";
+  }
+};
+var ApprovalConflictError = class extends ApprovalError {
+  constructor(instanceId) {
+    super(
+      `Concurrent modification detected on instance "${instanceId}". The record was updated by another process. Please retry.`,
+      "CONFLICT"
+    );
+    this.name = "ApprovalConflictError";
+  }
+};
+var ApprovalForbiddenError = class extends ApprovalError {
+  constructor(message) {
+    super(message, "FORBIDDEN");
+    this.name = "ApprovalForbiddenError";
+  }
+};
+var ApprovalValidationError = class extends ApprovalError {
+  constructor(message, cause) {
+    super(message, "VALIDATION");
+    this.cause = cause;
+    this.name = "ApprovalValidationError";
+  }
+};
+var ApprovalTemplateNotFoundError = class extends ApprovalError {
+  constructor(name) {
+    super(`Template "${name}" not found.`, "TEMPLATE_NOT_FOUND");
+    this.name = "ApprovalTemplateNotFoundError";
+  }
+};
+
+// src/engine/TemplateRegistry.ts
+var TemplateRegistry = class {
+  constructor(adapter, tenantId, opts) {
+    this.adapter = adapter;
+    this.tenantId = tenantId;
+    this.clock = opts?.clock ?? systemClock;
+    this.generateId = opts?.generateId ?? defaultIdGenerator;
+  }
+  async define(config) {
+    const existing = await this.adapter.getTemplate(this.tenantId, config.name);
+    if (existing) {
+      throw new ApprovalValidationError(
+        `Template "${config.name}" already exists for this tenant. Delete it first or use engine.updateTemplate() to modify it.`
+      );
+    }
+    const id = this.generateId("tpl");
+    const template = {
+      ...config,
+      id,
+      tenantId: this.tenantId,
+      createdAt: this.clock.now(),
+      version: 1
+    };
+    await this.adapter.saveTemplate(template);
+    return id;
+  }
+  /** Update an existing template, incrementing its version. Throws if the template doesn't exist. */
+  async update(config) {
+    const existing = await this.adapter.getTemplate(this.tenantId, config.name);
+    if (!existing) {
+      throw new ApprovalTemplateNotFoundError(config.name);
+    }
+    const newId = this.generateId("tpl");
+    const updated = {
+      ...config,
+      id: newId,
+      tenantId: this.tenantId,
+      createdAt: existing.createdAt,
+      version: (existing.version ?? 1) + 1,
+      previousVersionId: existing.id
+    };
+    await this.adapter.saveTemplate(updated);
+    return newId;
+  }
+  async get(name) {
+    const template = await this.adapter.getTemplate(this.tenantId, name);
+    if (!template) throw new ApprovalTemplateNotFoundError(name);
+    return template;
+  }
+  async list() {
+    return this.adapter.listTemplates(this.tenantId);
+  }
+};
+
+// src/engine/LevelResolver.ts
+var LevelResolver = class {
+  constructor() {
+    this.resolvers = /* @__PURE__ */ new Map();
+    this.approverTypes = /* @__PURE__ */ new Map();
+  }
+  register(name, fn) {
+    this.resolvers.set(name, fn);
+  }
+  registerApproverType(typeName, fn) {
+    this.approverTypes.set(typeName, fn);
+  }
+  async resolveApprovers(approvers, submittedBy, data, orgProvider) {
+    const resolved = [];
+    for (const approver of approvers) {
+      switch (approver.type) {
+        case "user":
+          resolved.push(approver.userId);
+          break;
+        case "role": {
+          if (!orgProvider) {
+            throw new Error(
+              `Cannot resolve role "${approver.role}" without an orgProvider configured on ApprovalEngine.`
+            );
+          }
+          const users = await orgProvider.getUsersByRole(
+            approver.role
+          );
+          resolved.push(...users);
+          break;
+        }
+        case "dynamic": {
+          const fn = this.resolvers.get(approver.resolver);
+          if (!fn) {
+            throw new Error(
+              `No resolver registered for "${approver.resolver}". Call engine.registerResolver("${approver.resolver}", fn) first.`
+            );
+          }
+          const userId = await fn(submittedBy, data);
+          resolved.push(userId);
+          break;
+        }
+        default: {
+          const customFn = this.approverTypes.get(approver.type);
+          if (!customFn) {
+            throw new ApprovalValidationError(
+              `Unknown approver type "${approver.type}". Register it with engine.registerApproverType("${approver.type}", fn) first.`
+            );
+          }
+          const ids = await customFn(approver, { submittedBy, data, orgProvider });
+          resolved.push(...ids);
+          break;
+        }
+      }
+    }
+    const result = [...new Set(resolved)];
+    if (result.length === 0) {
+      throw new ApprovalValidationError(
+        "No approvers resolved for this level. Check your approver configuration \u2014 role may have no members or dynamic resolver returned empty."
+      );
+    }
+    return result;
+  }
+};
+
+// src/engine/EscalationScheduler.ts
+var EscalationScheduler = class {
+  constructor(opts) {
+    this.intervalId = null;
+    this.tickPromise = null;
+    this.lastTickAt = null;
+    this.adapter = opts.adapter;
+    this.tenantId = opts.tenantId;
+    this.onEscalate = opts.onEscalate;
+    this.onExpire = opts.onExpire;
+    this.onSlaBreach = opts.onSlaBreach;
+    this.onRevertDelegation = opts.onRevertDelegation;
+    this.pollIntervalMs = opts.pollIntervalMs ?? 6e4;
+    this.logger = opts.logger ?? noopLogger;
+    this.clock = opts.clock ?? systemClock;
+  }
+  get isRunning() {
+    return this.intervalId !== null;
+  }
+  start() {
+    if (this.intervalId !== null) return;
+    this.intervalId = setInterval(() => {
+      this.tickPromise = this.tick().catch((err) => {
+        this.logger.error("EscalationScheduler: unhandled error in tick", err, { tenantId: this.tenantId });
+      }).finally(() => {
+        this.tickPromise = null;
+      });
+    }, this.pollIntervalMs);
+  }
+  async stop() {
+    if (this.intervalId !== null) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    if (this.tickPromise) {
+      await this.tickPromise;
+    }
+  }
+  async tick() {
+    this.lastTickAt = this.clock.now();
+    const now = this.lastTickAt;
+    let instances;
+    try {
+      instances = await this.adapter.getOverdueInstances(this.tenantId, now);
+    } catch (err) {
+      this.logger.error("EscalationScheduler: failed to fetch overdue instances", err, {
+        tenantId: this.tenantId
+      });
+      return;
+    }
+    for (const instance of instances) {
+      try {
+        if (this.onRevertDelegation) {
+          for (const level of instance.levels) {
+            if (level.delegatedUntil && new Date(level.delegatedUntil) <= now && level.status === "pending" && level.delegatedFrom) {
+              try {
+                await this.onRevertDelegation(instance.id, level.level, level.delegatedFrom);
+              } catch (err) {
+                this.logger.error("EscalationScheduler: failed to revert delegation", err, {
+                  tenantId: this.tenantId,
+                  instanceId: instance.id,
+                  levelNumber: level.level
+                });
+              }
+            }
+          }
+        }
+        if (instance.expiresAt && new Date(instance.expiresAt) <= now) {
+          if (this.onExpire) {
+            await this.onExpire(instance.id, instance.deadlineAction ?? "cancel");
+            this.logger.debug("EscalationScheduler: expired instance", {
+              tenantId: this.tenantId,
+              instanceId: instance.id,
+              deadlineAction: instance.deadlineAction ?? "cancel"
+            });
+          }
+          continue;
+        }
+        if (instance.slaDeadlineAt && new Date(instance.slaDeadlineAt) <= now && !instance.slaBreachedAt) {
+          if (this.onSlaBreach) {
+            try {
+              await this.onSlaBreach(instance.id);
+              this.logger.warn("EscalationScheduler: SLA breached", {
+                tenantId: this.tenantId,
+                instanceId: instance.id,
+                slaDeadlineAt: instance.slaDeadlineAt
+              });
+            } catch (err) {
+              this.logger.error("EscalationScheduler: failed to record SLA breach", err, {
+                tenantId: this.tenantId,
+                instanceId: instance.id
+              });
+            }
+          }
+        }
+        const currentLevel = instance.levels.find((l) => l.level === instance.currentLevel);
+        if (currentLevel?.escalationDueAt && new Date(currentLevel.escalationDueAt) <= now) {
+          await this.onEscalate(instance.id);
+          this.logger.debug("EscalationScheduler: escalated instance", {
+            tenantId: this.tenantId,
+            instanceId: instance.id
+          });
+        }
+      } catch (err) {
+        this.logger.error("EscalationScheduler: failed to process instance", err, {
+          tenantId: this.tenantId,
+          instanceId: instance.id
+        });
+      }
+    }
+  }
+  static computeEscalationDue(escalationAfterDays, fromDate) {
+    if (escalationAfterDays <= 0) return void 0;
+    const due = new Date(fromDate);
+    due.setDate(due.getDate() + escalationAfterDays);
+    return due;
+  }
+};
+
+// src/engine/ConditionEvaluator.ts
+var operatorRegistry = /* @__PURE__ */ new Map([
+  [">", (a, e) => Number(a) > Number(e)],
+  ["<", (a, e) => Number(a) < Number(e)],
+  [">=", (a, e) => Number(a) >= Number(e)],
+  ["<=", (a, e) => Number(a) <= Number(e)],
+  ["==", (a, e) => a === e],
+  ["!=", (a, e) => a !== e],
+  ["in", (a, e) => Array.isArray(e) && e.includes(a)],
+  ["not_in", (a, e) => Array.isArray(e) && !e.includes(a)]
+]);
+function registerConditionOperator(name, fn) {
+  operatorRegistry.set(name, fn);
+}
+function getField(data, path) {
+  return path.split(".").reduce((obj, key) => {
+    if (obj !== null && typeof obj === "object" && key in obj) {
+      return obj[key];
+    }
+    return void 0;
+  }, data);
+}
+function evaluateCondition(condition, data) {
+  const fn = operatorRegistry.get(condition.operator);
+  if (!fn) {
+    throw new ApprovalValidationError(
+      `Unknown condition operator "${condition.operator}". Register it with engine.registerConditionOperator() or use a built-in: ${[...operatorRegistry.keys()].join(", ")}.`
+    );
+  }
+  const actual = getField(data, condition.field);
+  return fn(actual, condition.value);
+}
+function evaluateRule(rule, data) {
+  if (Array.isArray(rule)) {
+    return rule.every((c) => evaluateCondition(c, data));
+  }
+  return evaluateCondition(rule, data);
+}
+function evaluateConditions(conditions, data) {
+  const mutations = { addLevels: [], skipLevels: /* @__PURE__ */ new Set() };
+  for (const rule of conditions) {
+    if (evaluateRule(rule.when, data)) {
+      if (rule.addLevels) mutations.addLevels.push(...rule.addLevels);
+      if (rule.skipLevels) rule.skipLevels.forEach((l) => mutations.skipLevels.add(l));
+    }
+  }
+  return mutations;
+}
+
+// src/engine/StateMachine.ts
+function assertStatus(instance, expected) {
+  if (instance.status !== expected) {
+    throw new ApprovalError(
+      `Expected instance status "${expected}" but got "${instance.status}".`,
+      "INVALID_STATUS"
+    );
+  }
+}
+function assertApproverOnLevel(level, approverId) {
+  if (!level.approverIds.includes(approverId)) {
+    throw new ApprovalForbiddenError(
+      `User "${approverId}" is not an approver for level ${level.level}.`
+    );
+  }
+}
+function hasAlreadyActed(level, approverId) {
+  return level.approvedBy.includes(approverId) || level.rejectedBy.includes(approverId);
+}
+function isLevelApproved(level) {
+  const { mode, approverIds, approvedBy } = level;
+  const total = approverIds.length;
+  if (total === 0) {
+    throw new ApprovalValidationError(
+      `Level ${level.level} ("${level.name}") has no approvers. Ensure resolvers return at least one user.`
+    );
+  }
+  const count = approvedBy.length;
+  switch (mode) {
+    case "any":
+      return count >= 1;
+    case "all":
+      return count >= total;
+    case "majority":
+      return count > Math.floor(total / 2);
+  }
+}
+function isLevelRejected(level) {
+  const { mode, approverIds, rejectedBy } = level;
+  const total = approverIds.length;
+  if (total === 0) {
+    throw new ApprovalValidationError(
+      `Level ${level.level} ("${level.name}") has no approvers. Ensure resolvers return at least one user.`
+    );
+  }
+  const rejectCount = rejectedBy.length;
+  switch (mode) {
+    case "any":
+      return rejectCount >= total;
+    case "all":
+      return rejectCount >= 1;
+    case "majority":
+      return rejectCount > Math.floor(total / 2);
+  }
+}
+
+// src/engine/ApprovalEngine.ts
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_BASE_DELAY_MS = 50;
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["approved", "rejected", "cancelled", "expired"]);
+var ApprovalEngine = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.bus = new EventBus();
+    this.tenantId = opts.tenantId ?? "default";
+    this.logger = opts.logger ?? noopLogger;
+    this.clock = opts.clock ?? systemClock;
+    this.generateId = opts.generateId ?? defaultIdGenerator;
+    this.maxBulkItems = opts.maxBulkItems ?? 200;
+    this.retryPolicy = {
+      maxAttempts: opts.retryPolicy?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
+      baseDelayMs: opts.retryPolicy?.baseDelayMs ?? DEFAULT_BASE_DELAY_MS,
+      maxDelayMs: opts.retryPolicy?.maxDelayMs ?? Infinity,
+      jitter: opts.retryPolicy?.jitter ?? true
+    };
+    this.idempotencyKeyFn = opts.idempotencyKeyFn ?? defaultIdempotencyKeyFn;
+    this.registry = new TemplateRegistry(opts.adapter, this.tenantId, {
+      clock: this.clock,
+      generateId: this.generateId
+    });
+    this.resolver = new LevelResolver();
+    this.escalation = new EscalationScheduler({
+      adapter: opts.adapter,
+      tenantId: this.tenantId,
+      onEscalate: async (id) => {
+        await this.escalateInternal(id);
+      },
+      onExpire: async (id, action) => {
+        await this.expireInstance(id, action);
+      },
+      onSlaBreach: async (id) => {
+        await this.markSlaBreached(id);
+      },
+      onRevertDelegation: async (id, level, from) => {
+        await this.revertDelegation(id, level, from);
+      },
+      pollIntervalMs: opts.escalationPollIntervalMs ?? 6e4,
+      logger: this.logger,
+      clock: this.clock
+    });
+    this.escalation.start();
+  }
+  on(event, listener) {
+    this.bus.on(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.bus.off(event, listener);
+    return this;
+  }
+  registerResolver(name, fn) {
+    this.resolver.register(name, fn);
+  }
+  registerApproverType(typeName, fn) {
+    this.resolver.registerApproverType(typeName, fn);
+  }
+  registerConditionOperator(name, fn) {
+    registerConditionOperator(name, fn);
+  }
+  // ─── Template management ──────────────────────────────────────────────────
+  /** Validate a template config without persisting. Synchronous; never throws. */
+  validateTemplate(config) {
+    const errors = [];
+    if (!config.levels || config.levels.length === 0) {
+      errors.push({ field: "levels", message: "Template must have at least one level." });
+    } else {
+      const levelNums = /* @__PURE__ */ new Set();
+      config.levels.forEach((l, i) => {
+        if (levelNums.has(l.level)) {
+          errors.push({ field: `levels[${i}].level`, message: `Duplicate level number: ${l.level}.` });
+        }
+        levelNums.add(l.level);
+        if (!l.approvers || l.approvers.length === 0) {
+          errors.push({ field: `levels[${i}].approvers`, message: `Level ${l.level} must have at least one approver.` });
+        }
+        if (l.escalationAfterDays !== void 0 && l.escalationAfterDays <= 0) {
+          errors.push({ field: `levels[${i}].escalationAfterDays`, message: `Level ${l.level} escalationAfterDays must be a positive number.` });
+        }
+      });
+    }
+    if (config.conditions) {
+      config.conditions.forEach((rule, ruleIdx) => {
+        if (rule.addLevels) {
+          rule.addLevels.forEach((al, alIdx) => {
+            const conflictsWithStatic = config.levels.some((l) => l.level === al.level);
+            if (conflictsWithStatic) {
+              errors.push({
+                field: `conditions[${ruleIdx}].addLevels[${alIdx}].level`,
+                message: `Level ${al.level} in addLevels conflicts with an existing static level.`
+              });
+            }
+            if (rule.skipLevels?.includes(al.level)) {
+              errors.push({
+                field: `conditions[${ruleIdx}].addLevels[${alIdx}].level`,
+                message: `Level ${al.level} appears in both addLevels and skipLevels in the same condition.`
+              });
+            }
+          });
+        }
+      });
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  async defineTemplate(config) {
+    const validation = this.validateTemplate(config);
+    if (!validation.valid) {
+      const first = validation.errors[0];
+      throw new ApprovalValidationError(
+        `Invalid template configuration: ${first?.message ?? "unknown error"}`
+      );
+    }
+    return this.registry.define(config);
+  }
+  /** Update an existing template, incrementing its version. In-flight instances are protected by their templateSnapshot. */
+  async updateTemplate(config) {
+    const validation = this.validateTemplate(config);
+    if (!validation.valid) {
+      const first = validation.errors[0];
+      throw new ApprovalValidationError(
+        `Invalid template configuration: ${first?.message ?? "unknown error"}`
+      );
+    }
+    return this.registry.update(config);
+  }
+  async getTemplate(name) {
+    return this.registry.get(name);
+  }
+  async listTemplates() {
+    return this.registry.list();
+  }
+  // ─── Lifecycle ────────────────────────────────────────────────────────────
+  async submit(raw, auditCtx) {
+    const opts = parseOrThrow(() => SubmitOptionsSchema.parse(raw));
+    const startMs = this.clock.now().getTime();
+    const template = await this.registry.get(opts.templateName);
+    const idempotencyKey = this.idempotencyKeyFn(this.tenantId, opts.documentType, opts.documentId, opts.templateName, opts.data);
+    const existing = await this.opts.adapter.getIdempotentInstance(this.tenantId, idempotencyKey);
+    if (existing && !TERMINAL_STATUSES.has(existing.status)) {
+      this.logger.info("submit: returning idempotent existing instance", {
+        tenantId: this.tenantId,
+        instanceId: existing.id,
+        idempotencyKey
+      });
+      return existing;
+    }
+    const mutations = evaluateConditions(template.conditions ?? [], opts.data);
+    const allLevelCfgs = [...template.levels, ...mutations.addLevels].filter((l) => !mutations.skipLevels.has(l.level)).sort((a, b) => a.level - b.level);
+    if (allLevelCfgs.length === 0) {
+      throw new ApprovalValidationError(
+        "Template has no active levels after condition evaluation. Check that skipLevels conditions are not removing all levels."
+      );
+    }
+    const levelNumSet = new Set(allLevelCfgs.map((l) => l.level));
+    if (levelNumSet.size !== allLevelCfgs.length) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const l of allLevelCfgs) {
+        if (seen.has(l.level)) {
+          throw new ApprovalValidationError(
+            `Duplicate level number ${l.level} after condition evaluation. Check addLevels in conditions.`
+          );
+        }
+        seen.add(l.level);
+      }
+    }
+    const now = this.clock.now();
+    const instanceId = this.generateId("inst");
+    const levels = allLevelCfgs.map((cfg, idx) => ({
+      level: cfg.level,
+      name: cfg.name,
+      mode: cfg.mode,
+      approverConfigs: cfg.approvers,
+      approverIds: [],
+      approvedBy: [],
+      rejectedBy: [],
+      status: idx === 0 ? "pending" : "waiting",
+      escalationAfterDays: cfg.escalationAfterDays,
+      escalationDueAt: idx === 0 && cfg.escalationAfterDays ? new Date(now.getTime() + cfg.escalationAfterDays * 864e5) : void 0
+    }));
+    const firstCfg = allLevelCfgs[0];
+    const firstLevel = levels[0];
+    if (firstCfg && firstLevel) {
+      firstLevel.approverIds = await this.resolver.resolveApprovers(
+        firstCfg.approvers,
+        opts.submittedBy,
+        opts.data,
+        this.opts.orgProvider
+      );
+    }
+    const auditEntry = {
+      action: "submitted",
+      actorId: opts.submittedBy,
+      level: allLevelCfgs[0]?.level ?? 1,
+      timestamp: now,
+      ...auditCtx
+    };
+    const slaDeadlineAt = template.slaDeadlineDays ? new Date(now.getTime() + template.slaDeadlineDays * 864e5) : void 0;
+    const instance = {
+      id: instanceId,
+      tenantId: this.tenantId,
+      templateId: template.id,
+      templateName: template.name,
+      documentId: opts.documentId,
+      documentType: opts.documentType,
+      submittedBy: opts.submittedBy,
+      status: "pending",
+      currentLevel: allLevelCfgs[0]?.level ?? 1,
+      version: 1,
+      idempotencyKey,
+      levels,
+      auditLog: [auditEntry],
+      data: opts.data,
+      metadata: opts.metadata,
+      createdAt: now,
+      updatedAt: now,
+      expiresAt: opts.expiresAt,
+      deadlineAction: opts.deadlineAction,
+      slaDeadlineAt,
+      templateSnapshot: {
+        escalation: template.escalation,
+        slaDeadlineDays: template.slaDeadlineDays,
+        allowOverride: template.allowOverride
+      }
+    };
+    await this.runMiddlewareBefore({ operation: "submit", actorId: opts.submittedBy, tenantId: this.tenantId, input: opts });
+    await this.opts.adapter.saveInstance(instance);
+    this.logger.info("submit: instance created", {
+      tenantId: this.tenantId,
+      instanceId,
+      documentId: opts.documentId,
+      templateName: opts.templateName
+    });
+    this.opts.metricsAdapter?.increment("approval.submitted", { tenantId: this.tenantId, templateName: template.name });
+    this.opts.metricsAdapter?.timing("approval.operation_duration_ms", this.clock.now().getTime() - startMs, { operation: "submit" });
+    const eventPayload = {
+      instanceId: instance.id,
+      documentId: instance.documentId,
+      documentType: instance.documentType,
+      timestamp: now,
+      submittedBy: opts.submittedBy,
+      currentApprovers: firstLevel?.approverIds ?? []
+    };
+    this.bus.emit("approval:submitted", eventPayload);
+    await this.notifyAdapters("approval:submitted", instance, eventPayload);
+    await this.runExternalAudit(instance, auditEntry);
+    await this.runMiddlewareAfter({ operation: "submit", actorId: opts.submittedBy, tenantId: this.tenantId, input: opts }, instance);
+    return instance;
+  }
+  async approve(instanceId, raw, auditCtx) {
+    const opts = parseOrThrow(() => ApproveOptionsSchema.parse(raw));
+    const startMs = this.clock.now().getTime();
+    return this.withOptimisticRetry(instanceId, async (instance) => {
+      assertStatus(instance, "pending");
+      if (opts.approverId === instance.submittedBy) {
+        throw new ApprovalForbiddenError(
+          `Self-approval is not permitted. Approver "${opts.approverId}" submitted this request.`
+        );
+      }
+      const level = this.currentLevelInstance(instance);
+      await this.runAuthorizationPolicy({ operation: "approve", actorId: opts.approverId, instance, level, opts });
+      await this.runMiddlewareBefore({ operation: "approve", instanceId, actorId: opts.approverId, tenantId: this.tenantId, input: opts });
+      assertApproverOnLevel(level, opts.approverId);
+      if (hasAlreadyActed(level, opts.approverId)) {
+        throw new ApprovalError(
+          `Approver "${opts.approverId}" has already acted on level ${level.level}.`,
+          "ALREADY_ACTED"
+        );
+      }
+      const now = this.clock.now();
+      const oldValue = snapshotLevel(level);
+      level.approvedBy.push(opts.approverId);
+      const auditEntry = {
+        action: "approved",
+        actorId: opts.approverId,
+        level: level.level,
+        timestamp: now,
+        comment: opts.comment,
+        oldValue,
+        newValue: snapshotLevel(level),
+        ...auditCtx
+      };
+      instance.auditLog.push(auditEntry);
+      instance.updatedAt = now;
+      if (isLevelApproved(level)) {
+        level.status = "approved";
+        const nextLevel = this.findNextLevel(instance);
+        if (!nextLevel) {
+          instance.status = "approved";
+          await this.opts.adapter.updateInstance(instance, instance.version);
+          await this.opts.adapter.appendAuditEntry(this.tenantId, instanceId, auditEntry);
+          await this.runExternalAudit(instance, auditEntry);
+          this.logger.info("approve: instance fully approved", { tenantId: this.tenantId, instanceId });
+          this.opts.metricsAdapter?.increment("approval.approved", { tenantId: this.tenantId, isFinal: "true" });
+          this.opts.metricsAdapter?.timing("approval.operation_duration_ms", this.clock.now().getTime() - startMs, { operation: "approve" });
+          const p = { instanceId, documentId: instance.documentId, documentType: instance.documentType, timestamp: now, approverId: opts.approverId, level: level.level, comment: opts.comment, isFinal: true };
+          this.bus.emit("approval:approved", p);
+          this.bus.emit("approval:completed", instance);
+          await this.notifyAdapters("approval:approved", instance, p);
+          await this.runMiddlewareAfter({ operation: "approve", instanceId, actorId: opts.approverId, tenantId: this.tenantId, input: opts }, instance);
+          return instance;
+        }
+        nextLevel.approverIds = await this.resolver.resolveApprovers(
+          nextLevel.approverConfigs,
+          instance.submittedBy,
+          instance.data,
+          this.opts.orgProvider
+        );
+        if (nextLevel.escalationAfterDays) {
+          nextLevel.escalationDueAt = new Date(now.getTime() + nextLevel.escalationAfterDays * 864e5);
+        }
+        nextLevel.status = "pending";
+        instance.currentLevel = nextLevel.level;
+        await this.opts.adapter.updateInstance(instance, instance.version);
+        await this.opts.adapter.appendAuditEntry(this.tenantId, instanceId, auditEntry);
+        await this.runExternalAudit(instance, auditEntry);
+        this.opts.metricsAdapter?.increment("approval.approved", { tenantId: this.tenantId, isFinal: "false" });
+        this.opts.metricsAdapter?.timing("approval.operation_duration_ms", this.clock.now().getTime() - startMs, { operation: "approve" });
+        const pAdv = { instanceId, documentId: instance.documentId, documentType: instance.documentType, timestamp: now, approverId: opts.approverId, level: level.level, comment: opts.comment, isFinal: false };
+        this.bus.emit("approval:approved", pAdv);
+        const pLvl = { instanceId, documentId: instance.documentId, documentType: instance.documentType, timestamp: now, fromLevel: level.level, toLevel: nextLevel.level, newApprovers: nextLevel.approverIds };
+        this.bus.emit("approval:level_advanced", pLvl);
+        await this.notifyAdapters("approval:level_advanced", instance, pLvl);
+        await this.runMiddlewareAfter({ operation: "approve", instanceId, actorId: opts.approverId, tenantId: this.tenantId, input: opts }, instance);
+      } else {
+        await this.opts.adapter.updateInstance(instance, instance.version);
+        await this.opts.adapter.appendAuditEntry(this.tenantId, instanceId, auditEntry);
+        await this.runExternalAudit(instance, auditEntry);
+        this.opts.metricsAdapter?.increment("approval.approved", { tenantId: this.tenantId });
+        this.opts.metricsAdapter?.timing("approval.operation_duration_ms", this.clock.now().getTime() - startMs, { operation: "approve" });
+        const p = { instanceId, documentId: instance.documentId, documentType: instance.documentType, timestamp: now, approverId: opts.approverId, level: level.level, comment: opts.comment, isFinal: false };
+        this.bus.emit("approval:approved", p);
+        await this.notifyAdapters("approval:approved", instance, p);
+        await this.runMiddlewareAfter({ operation: "approve", instanceId, actorId: opts.approverId, tenantId: this.tenantId, input: opts }, instance);
+      }
+      return instance;
+    });
+  }
+  async reject(instanceId, raw, auditCtx) {
+    const opts = parseOrThrow(() => RejectOptionsSchema.parse(raw));
+    return this.withOptimisticRetry(instanceId, async (instance) => {
+      assertStatus(instance, "pending");
+      if (opts.approverId === instance.submittedBy) {
+        throw new ApprovalForbiddenError(
+          `Self-rejection is not permitted. Approver "${opts.approverId}" submitted this request.`
+        );
+      }
+      const level = this.currentLevelInstance(instance);
+      await this.runAuthorizationPolicy({ operation: "reject", actorId: opts.approverId, instance, level, opts });
+      await this.runMiddlewareBefore({ operation: "reject", instanceId, actorId: opts.approverId, tenantId: this.tenantId, input: opts });
+      assertApproverOnLevel(level, opts.approverId);
+      if (hasAlreadyActed(level, opts.approverId)) {
+        throw new ApprovalError(
+          `Approver "${opts.approverId}" has already acted on level ${level.level}.`,
+          "ALREADY_ACTED"
+        );
+      }
+      const now = this.clock.now();
+      const oldValue = snapshotLevel(level);
+      level.rejectedBy.push(opts.approverId);
+      const auditEntry = {
+        action: "rejected",
+        actorId: opts.approverId,
+        level: level.level,
+        timestamp: now,
+        reason: opts.reason,
+        oldValue,
+        newValue: snapshotLevel(level),
+        ...auditCtx
+      };
+      instance.auditLog.push(auditEntry);
+      instance.updatedAt = now;
+      if (isLevelRejected(level)) {
+        level.status = "rejected";
+        if (opts.returnTo === "previous") {
+          const prevLevel = this.findPreviousLevel(instance);
+          if (!prevLevel) {
+            throw new ApprovalValidationError(
+              `Cannot return to previous level: instance "${instanceId}" is already at the first level (${level.level}). Remove returnTo: 'previous' or use returnTo: 'originator' to fully reject.`
+            );
+          }
+          prevLevel.status = "pending";
+          prevLevel.approvedBy = [];
+          prevLevel.rejectedBy = [];
+          instance.currentLevel = prevLevel.level;
+          await this.opts.adapter.updateInstance(instance, instance.version);
+          await this.opts.adapter.appendAuditEntry(this.tenantId, instanceId, auditEntry);
+          await this.runExternalAudit(instance, auditEntry);
+          const p2 = { instanceId, documentId: instance.documentId, documentType: instance.documentType, timestamp: now, approverId: opts.approverId, level: level.level, reason: opts.reason, returnTo: "previous" };
+          this.bus.emit("approval:rejected", p2);
+          await this.notifyAdapters("approval:rejected", instance, p2);
+          await this.runMiddlewareAfter({ operation: "reject", instanceId, actorId: opts.approverId, tenantId: this.tenantId, input: opts }, instance);
+          return instance;
+        }
+        instance.status = "rejected";
+        await this.opts.adapter.updateInstance(instance, instance.version);
+        await this.opts.adapter.appendAuditEntry(this.tenantId, instanceId, auditEntry);
+        await this.runExternalAudit(instance, auditEntry);
+        this.opts.metricsAdapter?.increment("approval.rejected", { tenantId: this.tenantId });
+        this.logger.info("reject: instance rejected", { tenantId: this.tenantId, instanceId });
+        const p = { instanceId, documentId: instance.documentId, documentType: instance.documentType, timestamp: now, approverId: opts.approverId, level: level.level, reason: opts.reason, returnTo: opts.returnTo === "originator" ? "originator" : null };
+        this.bus.emit("approval:rejected", p);
+        await this.notifyAdapters("approval:rejected", instance, p);
+        await this.runMiddlewareAfter({ operation: "reject", instanceId, actorId: opts.approverId, tenantId: this.tenantId, input: opts }, instance);
+      } else {
+        await this.opts.adapter.updateInstance(instance, instance.version);
+        await this.opts.adapter.appendAuditEntry(this.tenantId, instanceId, auditEntry);
+        await this.runExternalAudit(instance, auditEntry);
+      }
+      return instance;
+    });
+  }
+  async delegate(instanceId, raw, auditCtx) {
+    const opts = parseOrThrow(() => DelegateOptionsSchema.parse(raw));
+    await this.withOptimisticRetry(instanceId, async (instance) => {
+      assertStatus(instance, "pending");
+      if (opts.fromApprover === opts.toApprover) {
+        throw new ApprovalForbiddenError("Cannot delegate to yourself.");
+      }
+      const level = this.currentLevelInstance(instance);
+      await this.runAuthorizationPolicy({ operation: "delegate", actorId: opts.fromApprover, instance, level, opts });
+      await this.runMiddlewareBefore({ operation: "delegate", instanceId, actorId: opts.fromApprover, tenantId: this.tenantId, input: opts });
+      assertApproverOnLevel(level, opts.fromApprover);
+      if (hasAlreadyActed(level, opts.fromApprover)) {
+        throw new ApprovalForbiddenError(
+          `Cannot delegate after acting: "${opts.fromApprover}" has already approved or rejected level ${level.level}.`
+        );
+      }
+      const now = this.clock.now();
+      const idx = level.approverIds.indexOf(opts.fromApprover);
+      level.approverIds[idx] = opts.toApprover;
+      if (opts.until) {
+        level.delegatedUntil = opts.until;
+        level.delegatedFrom = opts.fromApprover;
+        level.delegatedTo = opts.toApprover;
+      }
+      const auditEntry = {
+        action: "delegated",
+        actorId: opts.fromApprover,
+        level: level.level,
+        timestamp: now,
+        reason: opts.reason,
+        delegateTo: opts.toApprover,
+        ...auditCtx
+      };
+      instance.auditLog.push(auditEntry);
+      instance.updatedAt = now;
+      await this.opts.adapter.updateInstance(instance, instance.version);
+      await this.opts.adapter.appendAuditEntry(this.tenantId, instanceId, auditEntry);
+      await this.runExternalAudit(instance, auditEntry);
+      const p = { instanceId, documentId: instance.documentId, documentType: instance.documentType, timestamp: now, fromApprover: opts.fromApprover, toApprover: opts.toApprover, level: level.level, reason: opts.reason };
+      this.bus.emit("approval:delegated", p);
+      await this.notifyAdapters("approval:delegated", instance, p);
+      await this.runMiddlewareAfter({ operation: "delegate", instanceId, actorId: opts.fromApprover, tenantId: this.tenantId, input: opts }, instance);
+      return instance;
+    });
+  }
+  async cancel(instanceId, raw, auditCtx) {
+    const opts = parseOrThrow(() => CancelOptionsSchema.parse(raw));
+    return this.withOptimisticRetry(instanceId, async (instance) => {
+      if (instance.status === "approved" || instance.status === "rejected") {
+        throw new ApprovalError(`Cannot cancel a "${instance.status}" approval.`, "CANNOT_CANCEL");
+      }
+      await this.runAuthorizationPolicy({ operation: "cancel", actorId: opts.cancelledBy, instance, opts });
+      await this.runMiddlewareBefore({ operation: "cancel", instanceId, actorId: opts.cancelledBy, tenantId: this.tenantId, input: opts });
+      const now = this.clock.now();
+      instance.status = "cancelled";
+      instance.updatedAt = now;
+      const auditEntry = {
+        action: "cancelled",
+        actorId: opts.cancelledBy,
+        level: instance.currentLevel,
+        timestamp: now,
+        reason: opts.reason,
+        ...auditCtx
+      };
+      instance.auditLog.push(auditEntry);
+      await this.opts.adapter.updateInstance(instance, instance.version);
+      await this.opts.adapter.appendAuditEntry(this.tenantId, instanceId, auditEntry);
+      await this.runExternalAudit(instance, auditEntry);
+      this.opts.metricsAdapter?.increment("approval.cancelled", { tenantId: this.tenantId });
+      this.logger.info("cancel: instance cancelled", { tenantId: this.tenantId, instanceId });
+      const p = { instanceId, documentId: instance.documentId, documentType: instance.documentType, timestamp: now, cancelledBy: opts.cancelledBy, reason: opts.reason };
+      this.bus.emit("approval:cancelled", p);
+      await this.notifyAdapters("approval:cancelled", instance, p);
+      await this.runMiddlewareAfter({ operation: "cancel", instanceId, actorId: opts.cancelledBy, tenantId: this.tenantId, input: opts }, instance);
+      return instance;
+    });
+  }
+  async escalate(instanceId, raw, auditCtx) {
+    parseOrThrow(() => EscalateOptionsSchema.parse(raw));
+    return this.escalateInternal(instanceId, raw.escalatedBy, auditCtx);
+  }
+  /** Add a comment to an instance without approving or rejecting. */
+  async addComment(instanceId, raw, auditCtx) {
+    const opts = parseOrThrow(() => AddCommentOptionsSchema.parse(raw));
+    const instance = await this.requireInstance(instanceId);
+    await this.runAuthorizationPolicy({ operation: "addComment", actorId: opts.actorId, instance, opts });
+    await this.runMiddlewareBefore({ operation: "addComment", instanceId, actorId: opts.actorId, tenantId: this.tenantId, input: opts });
+    const now = this.clock.now();
+    const auditEntry = {
+      action: "commented",
+      actorId: opts.actorId,
+      level: instance.currentLevel,
+      timestamp: now,
+      comment: opts.comment,
+      ...auditCtx
+    };
+    instance.auditLog.push(auditEntry);
+    instance.updatedAt = now;
+    await this.opts.adapter.updateInstance(instance, instance.version);
+    await this.opts.adapter.appendAuditEntry(this.tenantId, instanceId, auditEntry);
+    await this.runExternalAudit(instance, auditEntry);
+    await this.runMiddlewareAfter({ operation: "addComment", instanceId, actorId: opts.actorId, tenantId: this.tenantId, input: opts });
+  }
+  /** Resubmit a rejected instance, creating a new linked instance from level 1. */
+  async resubmit(instanceId, raw, auditCtx) {
+    const opts = parseOrThrow(() => ResubmitOptionsSchema.parse(raw));
+    const original = await this.requireInstance(instanceId);
+    if (original.status !== "rejected") {
+      throw new ApprovalForbiddenError(
+        `Cannot resubmit an instance with status "${original.status}". Only rejected instances can be resubmitted.`
+      );
+    }
+    await this.runAuthorizationPolicy({ operation: "resubmit", actorId: opts.resubmittedBy, instance: original, opts });
+    await this.runMiddlewareBefore({ operation: "resubmit", instanceId, actorId: opts.resubmittedBy, tenantId: this.tenantId, input: opts });
+    const template = await this.registry.get(original.templateName);
+    const mergedData = { ...original.data, ...opts.updatedData ?? {} };
+    const mutations = evaluateConditions(template.conditions ?? [], mergedData);
+    const allLevelCfgs = [...template.levels, ...mutations.addLevels].filter((l) => !mutations.skipLevels.has(l.level)).sort((a, b) => a.level - b.level);
+    if (allLevelCfgs.length === 0) {
+      throw new ApprovalValidationError("Template has no active levels after condition evaluation.");
+    }
+    const levelNums = new Set(allLevelCfgs.map((l) => l.level));
+    if (levelNums.size !== allLevelCfgs.length) {
+      throw new ApprovalValidationError("Duplicate level numbers after condition evaluation.");
+    }
+    const now = this.clock.now();
+    const newInstanceId = this.generateId("inst");
+    const levels = allLevelCfgs.map((cfg, idx) => ({
+      level: cfg.level,
+      name: cfg.name,
+      mode: cfg.mode,
+      approverConfigs: cfg.approvers,
+      approverIds: [],
+      approvedBy: [],
+      rejectedBy: [],
+      status: idx === 0 ? "pending" : "waiting",
+      escalationAfterDays: cfg.escalationAfterDays,
+      escalationDueAt: idx === 0 && cfg.escalationAfterDays ? new Date(now.getTime() + cfg.escalationAfterDays * 864e5) : void 0
+    }));
+    const firstCfg = allLevelCfgs[0];
+    const firstLevel = levels[0];
+    if (firstCfg && firstLevel) {
+      firstLevel.approverIds = await this.resolver.resolveApprovers(
+        firstCfg.approvers,
+        opts.resubmittedBy,
+        mergedData,
+        this.opts.orgProvider
+      );
+    }
+    const auditEntry = {
+      action: "resubmitted",
+      actorId: opts.resubmittedBy,
+      level: allLevelCfgs[0]?.level ?? 1,
+      timestamp: now,
+      reason: opts.reason,
+      ...auditCtx
+    };
+    const slaDeadlineAt = template.slaDeadlineDays ? new Date(now.getTime() + template.slaDeadlineDays * 864e5) : void 0;
+    const newInstance = {
+      id: newInstanceId,
+      tenantId: this.tenantId,
+      templateId: template.id,
+      templateName: template.name,
+      documentId: original.documentId,
+      documentType: original.documentType,
+      submittedBy: opts.resubmittedBy,
+      status: "pending",
+      currentLevel: allLevelCfgs[0]?.level ?? 1,
+      version: 1,
+      parentInstanceId: instanceId,
+      levels,
+      auditLog: [auditEntry],
+      data: mergedData,
+      metadata: original.metadata,
+      createdAt: now,
+      updatedAt: now,
+      slaDeadlineAt,
+      templateSnapshot: {
+        escalation: template.escalation,
+        slaDeadlineDays: template.slaDeadlineDays,
+        allowOverride: template.allowOverride
+      }
+    };
+    await this.opts.adapter.saveInstance(newInstance);
+    await this.runExternalAudit(newInstance, auditEntry);
+    this.logger.info("resubmit: new instance created from rejected original", {
+      tenantId: this.tenantId,
+      originalInstanceId: instanceId,
+      newInstanceId
+    });
+    const p = {
+      instanceId: newInstanceId,
+      documentId: newInstance.documentId,
+      documentType: newInstance.documentType,
+      timestamp: now,
+      resubmittedBy: opts.resubmittedBy,
+      originalInstanceId: instanceId
+    };
+    this.bus.emit("approval:resubmitted", p);
+    await this.notifyAdapters("approval:resubmitted", newInstance, p);
+    await this.runMiddlewareAfter({ operation: "resubmit", instanceId, actorId: opts.resubmittedBy, tenantId: this.tenantId, input: opts }, newInstance);
+    return newInstance;
+  }
+  /** Preview the resolved approval chain for a template and document data, without creating an instance. */
+  async previewApprovalChain(templateName, data, submittedBy) {
+    const template = await this.registry.get(templateName);
+    const mutations = evaluateConditions(template.conditions ?? [], data);
+    const conditionsApplied = [];
+    (template.conditions ?? []).forEach((rule, idx) => {
+      const m = evaluateConditions([rule], data);
+      if (m.addLevels.length > 0 || m.skipLevels.size > 0) {
+        conditionsApplied.push(idx);
+      }
+    });
+    const allLevelCfgs = [...template.levels, ...mutations.addLevels].filter((l) => !mutations.skipLevels.has(l.level)).sort((a, b) => a.level - b.level);
+    const levels = [];
+    for (const cfg of allLevelCfgs) {
+      try {
+        const resolvedApprovers = await this.resolver.resolveApprovers(
+          cfg.approvers,
+          submittedBy,
+          data,
+          this.opts.orgProvider
+        );
+        levels.push({ level: cfg.level, name: cfg.name, resolvedApprovers, mode: cfg.mode });
+      } catch {
+        levels.push({ level: cfg.level, name: cfg.name, resolvedApprovers: [], mode: cfg.mode });
+      }
+    }
+    return { levels, conditionsApplied };
+  }
+  /** Check whether a user is eligible to approve a specific instance. Never throws. */
+  async canApprove(instanceId, userId) {
+    let instance;
+    try {
+      instance = await this.requireInstance(instanceId);
+    } catch {
+      return { eligible: false, reason: "wrong_status" };
+    }
+    if (instance.status !== "pending") {
+      return { eligible: false, reason: "wrong_status" };
+    }
+    if (userId === instance.submittedBy) {
+      return { eligible: false, reason: "self_approval" };
+    }
+    const level = this.currentLevelInstance(instance);
+    if (!level.approverIds.includes(userId)) {
+      const hasDelegated = instance.auditLog.some(
+        (e) => e.action === "delegated" && e.actorId === userId && e.level === level.level
+      );
+      return { eligible: false, reason: hasDelegated ? "delegated_away" : "not_an_approver" };
+    }
+    if (hasAlreadyActed(level, userId)) {
+      return { eligible: false, reason: "already_acted" };
+    }
+    return { eligible: true };
+  }
+  /** Emergency bypass — completes the instance as 'approved', skipping remaining levels. Requires template.allowOverride = true. */
+  async override(instanceId, raw, auditCtx) {
+    const opts = parseOrThrow(() => OverrideOptionsSchema.parse(raw));
+    return this.withOptimisticRetry(instanceId, async (instance) => {
+      assertStatus(instance, "pending");
+      const allowOverride = instance.templateSnapshot?.allowOverride ?? (await this.registry.get(instance.templateName)).allowOverride;
+      if (!allowOverride) {
+        throw new ApprovalForbiddenError(
+          `Override is not enabled for template "${instance.templateName}". Set allowOverride: true in the template config.`
+        );
+      }
+      if (opts.overriddenBy === instance.submittedBy) {
+        throw new ApprovalForbiddenError(
+          "Override cannot be performed by the original submitter."
+        );
+      }
+      await this.runAuthorizationPolicy({ operation: "override", actorId: opts.overriddenBy, instance, opts });
+      await this.runMiddlewareBefore({ operation: "override", instanceId, actorId: opts.overriddenBy, tenantId: this.tenantId, input: opts });
+      const now = this.clock.now();
+      instance.status = "approved";
+      instance.updatedAt = now;
+      const auditEntry = {
+        action: "overridden",
+        actorId: opts.overriddenBy,
+        level: instance.currentLevel,
+        timestamp: now,
+        reason: opts.justification,
+        ...auditCtx
+      };
+      instance.auditLog.push(auditEntry);
+      await this.opts.adapter.updateInstance(instance, instance.version);
+      await this.opts.adapter.appendAuditEntry(this.tenantId, instanceId, auditEntry);
+      await this.runExternalAudit(instance, auditEntry);
+      this.opts.metricsAdapter?.increment("approval.overridden", { tenantId: this.tenantId });
+      this.logger.info("override: instance force-approved", {
+        tenantId: this.tenantId,
+        instanceId,
+        overriddenBy: opts.overriddenBy
+      });
+      const p = {
+        instanceId,
+        documentId: instance.documentId,
+        documentType: instance.documentType,
+        timestamp: now,
+        overriddenBy: opts.overriddenBy,
+        justification: opts.justification
+      };
+      this.bus.emit("approval:overridden", p);
+      this.bus.emit("approval:completed", instance);
+      await this.notifyAdapters("approval:overridden", instance, p);
+      await this.runMiddlewareAfter({ operation: "override", instanceId, actorId: opts.overriddenBy, tenantId: this.tenantId, input: opts }, instance);
+      return instance;
+    });
+  }
+  /** Approve multiple instances in one call. Never throws — failures collected in result.failed. */
+  async bulkApprove(instanceIds, raw, auditCtx) {
+    const opts = parseOrThrow(() => ApproveOptionsSchema.parse(raw));
+    this.guardBulkSize(instanceIds);
+    const result = { succeeded: [], failed: [], total: instanceIds.length };
+    for (const id of instanceIds) {
+      try {
+        result.succeeded.push(await this.approve(id, opts, auditCtx));
+      } catch (err) {
+        result.failed.push({ instanceId: id, error: err instanceof ApprovalError ? err : new ApprovalError(String(err), "UNKNOWN") });
+      }
+    }
+    return result;
+  }
+  /** Reject multiple instances in one call. Never throws — failures collected in result.failed. */
+  async bulkReject(instanceIds, raw, auditCtx) {
+    const opts = parseOrThrow(() => RejectOptionsSchema.parse(raw));
+    this.guardBulkSize(instanceIds);
+    const result = { succeeded: [], failed: [], total: instanceIds.length };
+    for (const id of instanceIds) {
+      try {
+        result.succeeded.push(await this.reject(id, opts, auditCtx));
+      } catch (err) {
+        result.failed.push({ instanceId: id, error: err instanceof ApprovalError ? err : new ApprovalError(String(err), "UNKNOWN") });
+      }
+    }
+    return result;
+  }
+  // ─── Queries ──────────────────────────────────────────────────────────────
+  async getInstance(instanceId) {
+    return this.requireInstance(instanceId);
+  }
+  async getPendingFor(approverId, opts) {
+    return this.opts.adapter.getInstancesByApprover(this.tenantId, approverId, opts);
+  }
+  async queryInstances(filter, opts) {
+    return this.opts.adapter.getInstancesByFilter(this.tenantId, filter, opts);
+  }
+  async queryInstancesByCursor(filter, opts) {
+    if (!this.opts.adapter.getInstancesByCursor) {
+      throw new ApprovalError(
+        "The configured storage adapter does not support cursor pagination. Implement getInstancesByCursor() or use queryInstances() instead.",
+        "NOT_SUPPORTED"
+      );
+    }
+    return this.opts.adapter.getInstancesByCursor(this.tenantId, filter, opts);
+  }
+  async getHistory(instanceId) {
+    const instance = await this.requireInstance(instanceId);
+    return instance.auditLog;
+  }
+  async getCurrentApprovers(instanceId) {
+    const instance = await this.requireInstance(instanceId);
+    if (instance.status !== "pending") return [];
+    return this.currentLevelInstance(instance).approverIds;
+  }
+  /** Check adapter connectivity and escalation scheduler health. */
+  async healthCheck() {
+    let adapterStatus = "connected";
+    let pendingCount = 0;
+    let overdueCount = 0;
+    try {
+      const result = await this.opts.adapter.getInstancesByFilter(
+        this.tenantId,
+        { status: "pending" },
+        { limit: 1, offset: 0 }
+      );
+      pendingCount = result.total;
+    } catch {
+      adapterStatus = "error";
+    }
+    if (adapterStatus === "connected") {
+      try {
+        const overdue = await this.opts.adapter.getOverdueInstances(this.tenantId, this.clock.now());
+        overdueCount = overdue.length;
+      } catch {
+        adapterStatus = "error";
+      }
+    }
+    const status = adapterStatus === "error" ? "unhealthy" : overdueCount > 0 ? "degraded" : "healthy";
+    return {
+      status,
+      adapter: adapterStatus,
+      pendingCount,
+      overdueCount,
+      escalationRunning: this.escalation.isRunning,
+      lastTickAt: this.escalation.lastTickAt ?? void 0
+    };
+  }
+  async shutdown() {
+    await this.escalation.stop();
+    await this.opts.schedulerAdapter?.shutdown();
+  }
+  // ─── Internals ────────────────────────────────────────────────────────────
+  async escalateInternal(instanceId, escalatedBy = "system", auditCtx) {
+    return this.withOptimisticRetry(instanceId, async (instance) => {
+      if (instance.status !== "pending") return instance;
+      const escalationConfig = instance.templateSnapshot?.escalation ?? (await this.registry.get(instance.templateName)).escalation;
+      if (!escalationConfig) return instance;
+      const newApprovers = await this.resolver.resolveApprovers(
+        [escalationConfig.escalateTo],
+        instance.submittedBy,
+        instance.data,
+        this.opts.orgProvider
+      );
+      const filteredApprovers = newApprovers.filter((id) => id !== instance.submittedBy);
+      if (filteredApprovers.length === 0) {
+        this.logger.warn("escalateInternal: escalation resolved to submitter only \u2014 no approvers added", {
+          tenantId: this.tenantId,
+          instanceId
+        });
+        return instance;
+      }
+      const level = this.currentLevelInstance(instance);
+      level.approverIds = [.../* @__PURE__ */ new Set([...level.approverIds, ...filteredApprovers])];
+      level.escalationDueAt = void 0;
+      const now = this.clock.now();
+      const escalatedTo = filteredApprovers[0] ?? "unknown";
+      const auditEntry = {
+        action: "escalated",
+        actorId: escalatedBy,
+        level: level.level,
+        timestamp: now,
+        delegateTo: escalatedTo,
+        ...auditCtx
+      };
+      instance.auditLog.push(auditEntry);
+      instance.updatedAt = now;
+      await this.opts.adapter.updateInstance(instance, instance.version);
+      await this.opts.adapter.appendAuditEntry(this.tenantId, instanceId, auditEntry);
+      await this.runExternalAudit(instance, auditEntry);
+      this.opts.metricsAdapter?.increment("approval.escalated", { tenantId: this.tenantId });
+      this.logger.info("escalate: instance escalated", { tenantId: this.tenantId, instanceId, escalatedTo });
+      const p = { instanceId, documentId: instance.documentId, documentType: instance.documentType, timestamp: now, level: level.level, escalatedTo };
+      this.bus.emit("approval:escalated", p);
+      await this.notifyAdapters("approval:escalated", instance, p);
+      return instance;
+    });
+  }
+  async expireInstance(instanceId, deadlineAction) {
+    try {
+      await this.withOptimisticRetry(instanceId, async (instance) => {
+        if (instance.status !== "pending") return instance;
+        const now = this.clock.now();
+        instance.status = deadlineAction === "reject" ? "rejected" : "cancelled";
+        instance.updatedAt = now;
+        const auditEntry = {
+          action: "expired",
+          actorId: "system",
+          level: instance.currentLevel,
+          timestamp: now,
+          reason: `Approval deadline reached. Action: ${deadlineAction}.`
+        };
+        instance.auditLog.push(auditEntry);
+        await this.opts.adapter.updateInstance(instance, instance.version);
+        await this.opts.adapter.appendAuditEntry(this.tenantId, instanceId, auditEntry);
+        await this.runExternalAudit(instance, auditEntry);
+        this.opts.metricsAdapter?.increment("approval.expired", { tenantId: this.tenantId });
+        this.logger.warn("expireInstance: instance expired by deadline", {
+          tenantId: this.tenantId,
+          instanceId,
+          deadlineAction
+        });
+        const p = { instanceId, documentId: instance.documentId, documentType: instance.documentType, timestamp: now, deadlineAction };
+        this.bus.emit("approval:expired", p);
+        await this.notifyAdapters("approval:expired", instance, p);
+        return instance;
+      });
+    } catch (err) {
+      this.logger.error("expireInstance: failed", err, { tenantId: this.tenantId, instanceId });
+    }
+  }
+  async markSlaBreached(instanceId) {
+    try {
+      await this.withOptimisticRetry(instanceId, async (instance) => {
+        if (instance.status !== "pending" || instance.slaBreachedAt) return instance;
+        const now = this.clock.now();
+        instance.slaBreachedAt = now;
+        instance.updatedAt = now;
+        await this.opts.adapter.updateInstance(instance, instance.version);
+        this.opts.metricsAdapter?.increment("approval.sla_breached", { tenantId: this.tenantId });
+        this.logger.warn("markSlaBreached: SLA breached", { tenantId: this.tenantId, instanceId });
+        const p = { instanceId, documentId: instance.documentId, documentType: instance.documentType, timestamp: now, slaDeadlineAt: instance.slaDeadlineAt ?? now };
+        this.bus.emit("approval:sla_breached", p);
+        await this.notifyAdapters("approval:sla_breached", instance, p);
+        return instance;
+      });
+    } catch (err) {
+      this.logger.error("markSlaBreached: failed", err, { tenantId: this.tenantId, instanceId });
+    }
+  }
+  async revertDelegation(instanceId, levelNumber, fromApprover) {
+    try {
+      await this.withOptimisticRetry(instanceId, async (instance) => {
+        if (instance.status !== "pending") return instance;
+        const level = instance.levels.find((l) => l.level === levelNumber);
+        if (!level || level.status !== "pending") return instance;
+        const delegateTo = level.delegatedTo;
+        if (delegateTo) {
+          const delegateIdx = level.approverIds.indexOf(delegateTo);
+          if (delegateIdx >= 0) {
+            level.approverIds[delegateIdx] = fromApprover;
+          } else {
+            level.approverIds.push(fromApprover);
+          }
+        }
+        level.delegatedUntil = void 0;
+        level.delegatedFrom = void 0;
+        level.delegatedTo = void 0;
+        const now = this.clock.now();
+        instance.updatedAt = now;
+        await this.opts.adapter.updateInstance(instance, instance.version);
+        this.logger.info("revertDelegation: delegation expired and reverted", {
+          tenantId: this.tenantId,
+          instanceId,
+          levelNumber,
+          fromApprover
+        });
+        return instance;
+      });
+    } catch (err) {
+      this.logger.error("revertDelegation: failed", err, { tenantId: this.tenantId, instanceId });
+    }
+  }
+  /** Read-modify-write with optimistic locking retry. */
+  async withOptimisticRetry(instanceId, fn) {
+    const { maxAttempts, baseDelayMs, maxDelayMs = Infinity, jitter = true } = this.retryPolicy;
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      if (attempt > 0) {
+        let delay = Math.min(baseDelayMs * attempt, maxDelayMs);
+        if (jitter) delay += Math.random() * baseDelayMs;
+        await sleep(delay);
+        this.opts.metricsAdapter?.increment("approval.conflict_retry", { tenantId: this.tenantId, attempt: String(attempt) });
+        this.logger.warn("withOptimisticRetry: retrying after conflict", {
+          tenantId: this.tenantId,
+          instanceId,
+          attempt
+        });
+      }
+      const instance = await this.requireInstance(instanceId);
+      if (attempt > 0 && TERMINAL_STATUSES.has(instance.status)) {
+        throw new ApprovalForbiddenError(
+          `Instance "${instanceId}" is already in terminal status "${instance.status}" and cannot be modified.`
+        );
+      }
+      try {
+        return await fn(instance);
+      } catch (err) {
+        if (err instanceof ApprovalConflictError) {
+          lastError = err;
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw lastError ?? new ApprovalConflictError(instanceId);
+  }
+  async requireInstance(id) {
+    const instance = await this.opts.adapter.getInstance(this.tenantId, id);
+    if (!instance) throw new ApprovalNotFoundError("Instance", id);
+    return instance;
+  }
+  currentLevelInstance(instance) {
+    const level = instance.levels.find((l) => l.level === instance.currentLevel);
+    if (!level) {
+      const available = instance.levels.map((l) => l.level).join(", ");
+      throw new ApprovalError(
+        `Level ${instance.currentLevel} not found on instance (available: ${available}).`,
+        "INVALID_LEVEL"
+      );
+    }
+    return level;
+  }
+  findNextLevel(instance) {
+    return instance.levels.find((l) => l.level > instance.currentLevel && l.status === "waiting") ?? null;
+  }
+  findPreviousLevel(instance) {
+    return [...instance.levels].filter((l) => l.level < instance.currentLevel).sort((a, b) => b.level - a.level)[0] ?? null;
+  }
+  guardBulkSize(instanceIds) {
+    if (instanceIds.length > this.maxBulkItems) {
+      throw new ApprovalValidationError(
+        `Bulk operation exceeds maximum allowed items (${this.maxBulkItems}). Got ${instanceIds.length}.`
+      );
+    }
+  }
+  // ─── Extension point helpers ──────────────────────────────────────────────
+  async runAuthorizationPolicy(ctx) {
+    if (!this.opts.authorizationPolicy) return;
+    try {
+      const denial = await this.opts.authorizationPolicy.authorize(ctx);
+      if (denial) throw new ApprovalForbiddenError(denial);
+    } catch (err) {
+      if (err instanceof ApprovalForbiddenError) throw err;
+      this.logger.error("authorizationPolicy.authorize threw unexpectedly", err, { tenantId: this.tenantId });
+      throw err;
+    }
+  }
+  async runMiddlewareBefore(ctx) {
+    if (!this.opts.middleware?.length) return;
+    for (const mw of this.opts.middleware) {
+      try {
+        await mw.before?.(ctx);
+      } catch (err) {
+        this.logger.error("middleware.before threw", err, { operation: ctx.operation });
+      }
+    }
+  }
+  async runMiddlewareAfter(ctx, result) {
+    if (!this.opts.middleware?.length) return;
+    for (const mw of this.opts.middleware) {
+      try {
+        await mw.after?.(ctx, result);
+      } catch (err) {
+        this.logger.error("middleware.after threw", err, { operation: ctx.operation });
+      }
+    }
+  }
+  async notifyAdapters(eventType, instance, payload) {
+    if (!this.opts.notificationAdapter) return;
+    const level = instance.levels.find((l) => l.level === instance.currentLevel);
+    const notifEvent = {
+      type: eventType,
+      instanceId: instance.id,
+      documentId: instance.documentId,
+      documentType: instance.documentType,
+      timestamp: this.clock.now(),
+      recipients: level?.approverIds ?? [],
+      templateName: instance.templateName,
+      tenantId: instance.tenantId,
+      payload
+    };
+    try {
+      await this.opts.notificationAdapter.notify(notifEvent);
+    } catch (err) {
+      this.logger.error("notificationAdapter.notify threw", err, { tenantId: this.tenantId, instanceId: instance.id });
+    }
+  }
+  async runExternalAudit(instance, entry) {
+    if (!this.opts.auditAdapter) return;
+    try {
+      await this.opts.auditAdapter.append(this.tenantId, instance.id, entry, instance);
+    } catch (err) {
+      this.logger.error("auditAdapter.append threw", err, { tenantId: this.tenantId, instanceId: instance.id });
+    }
+  }
+};
+function defaultIdempotencyKeyFn(tenantId, documentType, documentId, templateName, _data) {
+  return crypto.createHash("sha256").update(`${tenantId}:${documentType}:${documentId}:${templateName}`).digest("hex");
+}
+function snapshotLevel(level) {
+  return {
+    approverIds: [...level.approverIds],
+    approvedBy: [...level.approvedBy],
+    rejectedBy: [...level.rejectedBy],
+    status: level.status
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseOrThrow(fn) {
+  try {
+    return fn();
+  } catch (err) {
+    throw new ApprovalValidationError(
+      err instanceof Error ? err.message : "Invalid input",
+      err
+    );
+  }
+}
+
+// src/adapters/MemoryAdapter.ts
+function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function reviveDates(instance) {
+  return {
+    ...instance,
+    createdAt: new Date(instance.createdAt),
+    updatedAt: new Date(instance.updatedAt),
+    expiresAt: instance.expiresAt ? new Date(instance.expiresAt) : void 0,
+    slaDeadlineAt: instance.slaDeadlineAt ? new Date(instance.slaDeadlineAt) : void 0,
+    slaBreachedAt: instance.slaBreachedAt ? new Date(instance.slaBreachedAt) : void 0,
+    auditLog: instance.auditLog.map((e) => ({ ...e, timestamp: new Date(e.timestamp) })),
+    levels: instance.levels.map((l) => {
+      const level = { ...l };
+      if (l.escalationDueAt) level.escalationDueAt = new Date(l.escalationDueAt);
+      if (l.delegatedUntil) level.delegatedUntil = new Date(l.delegatedUntil);
+      return level;
+    })
+  };
+}
+function applyFilter(instance, filter) {
+  if (filter.status && instance.status !== filter.status) return false;
+  if (filter.documentType && instance.documentType !== filter.documentType) return false;
+  if (filter.submittedBy && instance.submittedBy !== filter.submittedBy) return false;
+  if (filter.fromDate && instance.createdAt < filter.fromDate) return false;
+  if (filter.toDate && instance.createdAt > filter.toDate) return false;
+  return true;
+}
+var MemoryAdapter = class {
+  constructor() {
+    // keyed by `${tenantId}:${template.name}`
+    this.templates = /* @__PURE__ */ new Map();
+    // keyed by `${tenantId}:${instance.id}`
+    this.instances = /* @__PURE__ */ new Map();
+  }
+  async saveTemplate(template) {
+    this.templates.set(`${template.tenantId}:${template.name}`, deepClone(template));
+  }
+  async getTemplate(tenantId, name) {
+    return deepClone(this.templates.get(`${tenantId}:${name}`) ?? null);
+  }
+  async listTemplates(tenantId) {
+    const result = [];
+    for (const [key, template] of this.templates) {
+      if (key.startsWith(`${tenantId}:`)) {
+        result.push(deepClone(template));
+      }
+    }
+    return result;
+  }
+  async saveInstance(instance) {
+    this.instances.set(`${instance.tenantId}:${instance.id}`, deepClone(instance));
+  }
+  async updateInstance(instance, expectedVersion) {
+    const key = `${instance.tenantId}:${instance.id}`;
+    const stored = this.instances.get(key);
+    if (!stored) throw new ApprovalConflictError(instance.id);
+    if (stored.version !== expectedVersion) throw new ApprovalConflictError(instance.id);
+    const updated = deepClone(instance);
+    updated.version = expectedVersion + 1;
+    this.instances.set(key, updated);
+  }
+  async getInstance(tenantId, id) {
+    const raw = this.instances.get(`${tenantId}:${id}`);
+    if (!raw) return null;
+    return reviveDates(deepClone(raw));
+  }
+  async getInstancesByApprover(tenantId, approverId, opts) {
+    const all = [...this.instances.values()].filter((i) => {
+      if (i.tenantId !== tenantId || i.status !== "pending") return false;
+      const currentLevel = i.levels.find((l) => l.level === i.currentLevel);
+      return currentLevel?.approverIds.includes(approverId) ?? false;
+    });
+    return paginate(all.map((i) => reviveDates(deepClone(i))), opts);
+  }
+  async getInstancesByFilter(tenantId, filter, opts) {
+    const all = [...this.instances.values()].filter(
+      (i) => i.tenantId === tenantId && applyFilter(i, filter)
+    );
+    return paginate(all.map((i) => reviveDates(deepClone(i))), opts);
+  }
+  async getOverdueInstances(tenantId, asOf) {
+    return [...this.instances.values()].filter((i) => {
+      if (i.tenantId !== tenantId || i.status !== "pending") return false;
+      const currentLevel = i.levels.find((l) => l.level === i.currentLevel);
+      const hasOverdueEscalation = currentLevel?.escalationDueAt != null && new Date(currentLevel.escalationDueAt) <= asOf;
+      const isExpired = i.expiresAt != null && new Date(i.expiresAt) <= asOf;
+      const hasSLABreach = i.slaDeadlineAt != null && new Date(i.slaDeadlineAt) <= asOf && !i.slaBreachedAt;
+      const hasDelegationExpiry = i.levels.some(
+        (l) => l.status === "pending" && l.delegatedUntil != null && new Date(l.delegatedUntil) <= asOf && l.delegatedFrom != null
+      );
+      return hasOverdueEscalation || isExpired || hasSLABreach || hasDelegationExpiry;
+    }).map((i) => reviveDates(deepClone(i)));
+  }
+  async getInstancesByCursor(tenantId, filter, opts) {
+    const all = [...this.instances.values()].filter((i) => i.tenantId === tenantId && applyFilter(i, filter)).map((i) => reviveDates(deepClone(i))).sort((a, b) => {
+      const ta = a.updatedAt.getTime();
+      const tb = b.updatedAt.getTime();
+      return ta !== tb ? ta - tb : a.id.localeCompare(b.id);
+    });
+    const { cursor, limit, direction = "forward" } = opts;
+    let startIdx = 0;
+    if (cursor) {
+      const [ts, id] = decodeCursor(cursor);
+      const idx = all.findIndex(
+        (i) => i.updatedAt.getTime() > ts || i.updatedAt.getTime() === ts && i.id > id
+      );
+      startIdx = idx === -1 ? all.length : idx;
+    }
+    if (direction === "backward" && startIdx > 0) {
+      startIdx = Math.max(0, startIdx - limit - 1);
+    }
+    const slice = all.slice(startIdx, startIdx + limit);
+    const hasMore = startIdx + limit < all.length;
+    const nextCursor = hasMore ? encodeCursor(slice[slice.length - 1]) : void 0;
+    const prevCursor = startIdx > 0 ? encodeCursor(all[startIdx - 1]) : void 0;
+    return { items: slice, nextCursor, prevCursor, hasMore };
+  }
+  async getIdempotentInstance(tenantId, idempotencyKey) {
+    for (const instance of this.instances.values()) {
+      if (instance.tenantId === tenantId && instance.idempotencyKey === idempotencyKey) {
+        return reviveDates(deepClone(instance));
+      }
+    }
+    return null;
+  }
+  async appendAuditEntry(tenantId, instanceId, entry) {
+    const key = `${tenantId}:${instanceId}`;
+    const instance = this.instances.get(key);
+    if (!instance) return;
+    instance.auditLog.push(deepClone(entry));
+    instance.updatedAt = new Date(entry.timestamp);
+  }
+  /** Test helper — total stored instances across all tenants. */
+  get size() {
+    return this.instances.size;
+  }
+};
+function paginate(items, opts) {
+  const total = items.length;
+  if (!opts) return { items, total };
+  return { items: items.slice(opts.offset, opts.offset + opts.limit), total };
+}
+function encodeCursor(instance) {
+  return Buffer.from(`${instance.updatedAt.getTime()}|${instance.id}`).toString("base64");
+}
+function decodeCursor(cursor) {
+  const decoded = Buffer.from(cursor, "base64").toString("utf8");
+  const pipeIdx = decoded.indexOf("|");
+  return [Number(decoded.slice(0, pipeIdx)), decoded.slice(pipeIdx + 1)];
+}
+
+exports.ApprovalConflictError = ApprovalConflictError;
+exports.ApprovalEngine = ApprovalEngine;
+exports.ApprovalError = ApprovalError;
+exports.ApprovalForbiddenError = ApprovalForbiddenError;
+exports.ApprovalNotFoundError = ApprovalNotFoundError;
+exports.ApprovalTemplateNotFoundError = ApprovalTemplateNotFoundError;
+exports.ApprovalValidationError = ApprovalValidationError;
+exports.EscalationScheduler = EscalationScheduler;
+exports.MemoryAdapter = MemoryAdapter;
+exports.defaultIdGenerator = defaultIdGenerator;
+exports.noopLogger = noopLogger;
+exports.systemClock = systemClock;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map