@umpledger/sdk 2.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1520 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentManager: () => AgentManager,
+  AgentNotFoundError: () => AgentNotFoundError,
+  AgentRevokedError: () => AgentRevokedError,
+  AuditTrail: () => AuditTrail,
+  AuthorityExceededError: () => AuthorityExceededError,
+  ContractManager: () => ContractManager,
+  ContractNotFoundError: () => ContractNotFoundError,
+  DisputeError: () => DisputeError,
+  InsufficientFundsError: () => InsufficientFundsError,
+  MeteringEngine: () => MeteringEngine,
+  PolicyViolationError: () => PolicyViolationError,
+  PricingEngine: () => PricingEngine,
+  PricingTemplates: () => PricingTemplates,
+  SettlementBus: () => SettlementBus,
+  UMP: () => UMP,
+  UMPError: () => UMPError,
+  WalletFrozenError: () => WalletFrozenError,
+  WalletManager: () => WalletManager
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/id.ts
+var import_uuid = require("uuid");
+function generateId(prefix) {
+  return `${prefix}_${(0, import_uuid.v4)()}`;
+}
+function parseMoney(value) {
+  if (typeof value === "number") return value;
+  const cleaned = value.replace(/[^0-9.-]/g, "");
+  const parsed = parseFloat(cleaned);
+  if (isNaN(parsed)) throw new Error(`Invalid monetary value: ${value}`);
+  return parsed;
+}
+function round(value, decimals = 2) {
+  const factor = Math.pow(10, decimals);
+  return Math.round(value * factor) / factor;
+}
+function hrTimestamp() {
+  return /* @__PURE__ */ new Date();
+}
+
+// src/utils/errors.ts
+var UMPError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "UMPError";
+    this.code = code;
+  }
+};
+var AuthorityExceededError = class extends UMPError {
+  limit;
+  attempted;
+  constructor(limitType, limit, attempted) {
+    super(
+      `Authority exceeded: ${limitType} limit is ${limit}, attempted ${attempted}`,
+      "AUTHORITY_EXCEEDED"
+    );
+    this.name = "AuthorityExceededError";
+    this.limit = limit;
+    this.attempted = attempted;
+  }
+};
+var InsufficientFundsError = class extends UMPError {
+  available;
+  required;
+  constructor(available, required) {
+    super(
+      `Insufficient funds: available ${available}, required ${required}`,
+      "INSUFFICIENT_FUNDS"
+    );
+    this.name = "InsufficientFundsError";
+    this.available = available;
+    this.required = required;
+  }
+};
+var WalletFrozenError = class extends UMPError {
+  constructor(walletId) {
+    super(`Wallet ${walletId} is frozen \u2014 all transactions blocked`, "WALLET_FROZEN");
+    this.name = "WalletFrozenError";
+  }
+};
+var AgentNotFoundError = class extends UMPError {
+  constructor(agentId) {
+    super(`Agent not found: ${agentId}`, "AGENT_NOT_FOUND");
+    this.name = "AgentNotFoundError";
+  }
+};
+var AgentRevokedError = class extends UMPError {
+  constructor(agentId) {
+    super(`Agent ${agentId} has been revoked`, "AGENT_REVOKED");
+    this.name = "AgentRevokedError";
+  }
+};
+var ContractNotFoundError = class extends UMPError {
+  constructor(contractId) {
+    super(`Contract not found: ${contractId}`, "CONTRACT_NOT_FOUND");
+    this.name = "ContractNotFoundError";
+  }
+};
+var PolicyViolationError = class extends UMPError {
+  policyType;
+  action;
+  constructor(policyType, action, details) {
+    super(`Policy violation [${policyType}]: ${details}`, "POLICY_VIOLATION");
+    this.name = "PolicyViolationError";
+    this.policyType = policyType;
+    this.action = action;
+  }
+};
+var DisputeError = class extends UMPError {
+  constructor(message) {
+    super(message, "DISPUTE_ERROR");
+    this.name = "DisputeError";
+  }
+};
+
+// src/core/agent-manager.ts
+var import_crypto = __toESM(require("crypto"));
+var AgentManager = class {
+  agents = /* @__PURE__ */ new Map();
+  /**
+   * Register a new Agent Identity with authority scope.
+   */
+  create(options) {
+    const agentId = generateId("agt");
+    const now = hrTimestamp();
+    const { publicKey, privateKey } = import_crypto.default.generateKeyPairSync("ed25519");
+    const pubKeyHex = publicKey.export({ type: "spki", format: "der" }).toString("hex");
+    const authority = {
+      maxPerTransaction: parseMoney(options.authority.maxPerTransaction),
+      maxPerDay: parseMoney(options.authority.maxPerDay),
+      maxPerMonth: options.authority.maxPerMonth ? parseMoney(options.authority.maxPerMonth) : parseMoney(options.authority.maxPerDay) * 30,
+      allowedServices: options.authority.allowedServices,
+      allowedCounterparties: options.authority.allowedCounterparties,
+      requiresApprovalAbove: options.authority.requiresApprovalAbove,
+      autoRevokeAfter: options.authority.autoRevokeAfter
+    };
+    if (options.parentId) {
+      const parent = this.get(options.parentId);
+      authority.maxPerTransaction = Math.min(authority.maxPerTransaction, parent.authorityScope.maxPerTransaction);
+      authority.maxPerDay = Math.min(authority.maxPerDay, parent.authorityScope.maxPerDay);
+      authority.maxPerMonth = Math.min(authority.maxPerMonth, parent.authorityScope.maxPerMonth);
+    }
+    const verification = {
+      publicKey: pubKeyHex,
+      issuingAuthority: "ump-sdk-local",
+      expiresAt: new Date(now.getTime() + (options.authority.autoRevokeAfter || 365 * 24 * 60 * 60 * 1e3))
+    };
+    const agent = {
+      agentId,
+      agentType: options.type,
+      parentId: options.parentId || null,
+      displayName: options.name,
+      capabilities: options.capabilities || [],
+      authorityScope: authority,
+      verification,
+      metadata: {
+        ...options.metadata,
+        _privateKey: privateKey.export({ type: "pkcs8", format: "der" }).toString("hex")
+      },
+      status: "ACTIVE",
+      createdAt: now,
+      updatedAt: now
+    };
+    this.agents.set(agentId, agent);
+    if (options.authority.autoRevokeAfter) {
+      setTimeout(() => this.revoke(agentId), options.authority.autoRevokeAfter);
+    }
+    return agent;
+  }
+  /**
+   * Retrieve an agent by ID.
+   */
+  get(agentId) {
+    const agent = this.agents.get(agentId);
+    if (!agent) throw new AgentNotFoundError(agentId);
+    return agent;
+  }
+  /**
+   * Update authority scope (tightening is always allowed; loosening requires parent).
+   */
+  updateAuthority(agentId, newScope) {
+    const agent = this.get(agentId);
+    if (agent.status !== "ACTIVE") throw new AgentRevokedError(agentId);
+    const updated = {
+      ...agent,
+      authorityScope: { ...agent.authorityScope, ...newScope },
+      updatedAt: hrTimestamp()
+    };
+    this.agents.set(agentId, updated);
+    return updated;
+  }
+  /**
+   * Revoke an agent and cascade to all children.
+   */
+  revoke(agentId) {
+    const revoked = [];
+    const agent = this.agents.get(agentId);
+    if (!agent) return revoked;
+    agent.status = "REVOKED";
+    agent.updatedAt = hrTimestamp();
+    revoked.push(agentId);
+    for (const [id, a] of this.agents) {
+      if (a.parentId === agentId && a.status === "ACTIVE") {
+        revoked.push(...this.revoke(id));
+      }
+    }
+    return revoked;
+  }
+  /**
+   * Verify that an agent's identity is valid and active.
+   */
+  verify(agentId) {
+    const agent = this.agents.get(agentId);
+    if (!agent) return { valid: false, reason: "Agent not found" };
+    if (agent.status !== "ACTIVE") return { valid: false, reason: `Agent status: ${agent.status}` };
+    if (agent.verification.expiresAt < /* @__PURE__ */ new Date()) {
+      agent.status = "EXPIRED";
+      return { valid: false, reason: "Verification expired" };
+    }
+    return { valid: true };
+  }
+  /**
+   * Check if a transaction amount is within the agent's authority scope.
+   */
+  checkAuthority(agentId, amount, counterpartyId, serviceId) {
+    const agent = this.get(agentId);
+    const scope = agent.authorityScope;
+    if (agent.status !== "ACTIVE") {
+      return { allowed: false, reason: `Agent status: ${agent.status}` };
+    }
+    if (amount > scope.maxPerTransaction) {
+      return { allowed: false, reason: `Exceeds per-transaction limit of ${scope.maxPerTransaction}` };
+    }
+    if (scope.allowedCounterparties && counterpartyId) {
+      const allowed = scope.allowedCounterparties.some((pattern) => {
+        if (pattern.endsWith("*")) {
+          return counterpartyId.startsWith(pattern.slice(0, -1));
+        }
+        return counterpartyId === pattern;
+      });
+      if (!allowed) {
+        return { allowed: false, reason: `Counterparty ${counterpartyId} not in allowlist` };
+      }
+    }
+    if (scope.allowedServices && serviceId) {
+      if (!scope.allowedServices.includes(serviceId)) {
+        return { allowed: false, reason: `Service ${serviceId} not in allowlist` };
+      }
+    }
+    if (scope.requiresApprovalAbove && amount > scope.requiresApprovalAbove) {
+      return { allowed: true, requiresApproval: true };
+    }
+    return { allowed: true };
+  }
+  /**
+   * List all agents, optionally filtered.
+   */
+  list(filter) {
+    let results = Array.from(this.agents.values());
+    if (filter?.parentId) results = results.filter((a) => a.parentId === filter.parentId);
+    if (filter?.type) results = results.filter((a) => a.agentType === filter.type);
+    if (filter?.status) results = results.filter((a) => a.status === filter.status);
+    return results;
+  }
+};
+
+// src/core/wallet-manager.ts
+var WalletManager = class {
+  wallets = /* @__PURE__ */ new Map();
+  ledgers = /* @__PURE__ */ new Map();
+  // walletId -> entries
+  /**
+   * Create a wallet for an agent.
+   */
+  create(ownerAgentId) {
+    const walletId = generateId("wal");
+    const wallet = {
+      walletId,
+      ownerAgentId,
+      balances: [{
+        valueUnitType: "FIAT",
+        currency: "USD",
+        amount: 0,
+        reserved: 0,
+        available: 0
+      }],
+      frozen: false,
+      createdAt: hrTimestamp()
+    };
+    this.wallets.set(walletId, wallet);
+    this.ledgers.set(walletId, []);
+    return wallet;
+  }
+  /**
+   * Get wallet by ID.
+   */
+  get(walletId) {
+    const wallet = this.wallets.get(walletId);
+    if (!wallet) throw new UMPError(`Wallet not found: ${walletId}`, "WALLET_NOT_FOUND");
+    return wallet;
+  }
+  /**
+   * Get wallet by owner agent ID.
+   */
+  getByAgent(agentId) {
+    for (const w of this.wallets.values()) {
+      if (w.ownerAgentId === agentId) return w;
+    }
+    throw new UMPError(`No wallet found for agent: ${agentId}`, "WALLET_NOT_FOUND");
+  }
+  /**
+   * Fund a wallet (add money).
+   */
+  fund(walletId, options) {
+    const wallet = this.get(walletId);
+    if (wallet.frozen) throw new WalletFrozenError(walletId);
+    const amount = parseMoney(options.amount);
+    const vut = options.valueUnitType || "FIAT";
+    const currency = options.currency || "USD";
+    const balance = this.getOrCreateBalance(wallet, vut, currency);
+    balance.amount = round(balance.amount + amount);
+    balance.available = round(balance.available + amount);
+    const entry = this.appendLedger(walletId, {
+      type: "TOPUP",
+      amount,
+      valueUnitType: vut,
+      currency,
+      description: `Funded ${amount} ${currency}`,
+      balanceAfter: balance.available
+    });
+    return entry;
+  }
+  /**
+   * Reserve funds for a pending transaction (escrow pattern).
+   */
+  reserve(walletId, amount, counterpartyAgentId, transactionId) {
+    const wallet = this.get(walletId);
+    if (wallet.frozen) throw new WalletFrozenError(walletId);
+    const balance = this.getPrimaryBalance(wallet);
+    if (balance.available < amount) {
+      throw new InsufficientFundsError(balance.available, amount);
+    }
+    balance.reserved = round(balance.reserved + amount);
+    balance.available = round(balance.available - amount);
+    return this.appendLedger(walletId, {
+      type: "RESERVE",
+      amount,
+      valueUnitType: balance.valueUnitType,
+      currency: balance.currency,
+      counterpartyAgentId,
+      transactionId,
+      description: `Reserved ${amount} for transaction ${transactionId}`,
+      balanceAfter: balance.available
+    });
+  }
+  /**
+   * Debit wallet (immediate drawdown).
+   */
+  debit(walletId, amount, counterpartyAgentId, transactionId) {
+    const wallet = this.get(walletId);
+    if (wallet.frozen) throw new WalletFrozenError(walletId);
+    const balance = this.getPrimaryBalance(wallet);
+    if (balance.available < amount) {
+      throw new InsufficientFundsError(balance.available, amount);
+    }
+    balance.amount = round(balance.amount - amount);
+    balance.available = round(balance.available - amount);
+    return this.appendLedger(walletId, {
+      type: "DEBIT",
+      amount,
+      valueUnitType: balance.valueUnitType,
+      currency: balance.currency,
+      counterpartyAgentId,
+      transactionId,
+      description: `Debited ${amount} to ${counterpartyAgentId}`,
+      balanceAfter: balance.available
+    });
+  }
+  /**
+   * Credit wallet (receive payment).
+   */
+  credit(walletId, amount, counterpartyAgentId, transactionId) {
+    const wallet = this.get(walletId);
+    const balance = this.getPrimaryBalance(wallet);
+    balance.amount = round(balance.amount + amount);
+    balance.available = round(balance.available + amount);
+    return this.appendLedger(walletId, {
+      type: "CREDIT",
+      amount,
+      valueUnitType: balance.valueUnitType,
+      currency: balance.currency,
+      counterpartyAgentId,
+      transactionId,
+      description: `Credited ${amount} from ${counterpartyAgentId}`,
+      balanceAfter: balance.available
+    });
+  }
+  /**
+   * Release reserved funds (escrow release after outcome).
+   */
+  releaseReservation(walletId, amount, transactionId) {
+    const wallet = this.get(walletId);
+    const balance = this.getPrimaryBalance(wallet);
+    const releaseAmount = Math.min(amount, balance.reserved);
+    balance.reserved = round(balance.reserved - releaseAmount);
+    balance.amount = round(balance.amount - releaseAmount);
+    return this.appendLedger(walletId, {
+      type: "RELEASE",
+      amount: releaseAmount,
+      valueUnitType: balance.valueUnitType,
+      currency: balance.currency,
+      transactionId,
+      description: `Released ${releaseAmount} from escrow for ${transactionId}`,
+      balanceAfter: balance.available
+    });
+  }
+  /**
+   * Emergency freeze — blocks all transactions.
+   */
+  freeze(walletId) {
+    const wallet = this.get(walletId);
+    wallet.frozen = true;
+  }
+  /**
+   * Unfreeze wallet.
+   */
+  unfreeze(walletId) {
+    const wallet = this.get(walletId);
+    wallet.frozen = false;
+  }
+  /**
+   * Get immutable ledger entries for a wallet.
+   */
+  getLedger(walletId, limit = 100, offset = 0) {
+    const entries = this.ledgers.get(walletId) || [];
+    return entries.slice(offset, offset + limit);
+  }
+  /**
+   * Get real-time balance summary.
+   */
+  getBalance(walletId) {
+    const wallet = this.get(walletId);
+    return wallet.balances.map((b) => ({ ...b }));
+  }
+  // ── Private helpers ──
+  getPrimaryBalance(wallet) {
+    if (wallet.balances.length === 0) {
+      const balance = {
+        valueUnitType: "FIAT",
+        currency: "USD",
+        amount: 0,
+        reserved: 0,
+        available: 0
+      };
+      wallet.balances.push(balance);
+      return balance;
+    }
+    return wallet.balances[0];
+  }
+  getOrCreateBalance(wallet, vut, currency) {
+    let balance = wallet.balances.find(
+      (b) => b.valueUnitType === vut && b.currency === currency
+    );
+    if (!balance) {
+      balance = { valueUnitType: vut, currency, amount: 0, reserved: 0, available: 0 };
+      wallet.balances.push(balance);
+    }
+    return balance;
+  }
+  appendLedger(walletId, data) {
+    const entry = {
+      entryId: generateId("led"),
+      timestamp: hrTimestamp(),
+      ...data
+    };
+    const ledger = this.ledgers.get(walletId);
+    if (ledger) ledger.push(entry);
+    return entry;
+  }
+};
+
+// src/core/audit-trail.ts
+var AuditTrail = class {
+  records = [];
+  onAudit;
+  constructor(onAudit) {
+    this.onAudit = onAudit;
+  }
+  /**
+   * Record an audit entry. Returns the audit ID.
+   */
+  record(data) {
+    const auditId = generateId("aud");
+    const record = {
+      auditId,
+      when: hrTimestamp(),
+      ...data
+    };
+    this.records.push(record);
+    if (this.onAudit) {
+      this.onAudit(record);
+    }
+    return auditId;
+  }
+  /**
+   * Query audit records with filters.
+   */
+  query(filters, limit = 100, offset = 0) {
+    let results = this.records;
+    if (filters) {
+      if (filters.agentId) {
+        results = results.filter(
+          (r) => r.who.sourceAgentId === filters.agentId || r.who.targetAgentId === filters.agentId
+        );
+      }
+      if (filters.operation) {
+        results = results.filter((r) => r.what.operation === filters.operation);
+      }
+      if (filters.fromDate) {
+        results = results.filter((r) => r.when >= filters.fromDate);
+      }
+      if (filters.toDate) {
+        results = results.filter((r) => r.when <= filters.toDate);
+      }
+      if (filters.minAmount !== void 0) {
+        results = results.filter((r) => (r.what.amount || 0) >= filters.minAmount);
+      }
+      if (filters.contractId) {
+        results = results.filter((r) => r.why.contractId === filters.contractId);
+      }
+    }
+    return results.slice(offset, offset + limit);
+  }
+  /**
+   * Get a specific audit record by ID.
+   */
+  get(auditId) {
+    return this.records.find((r) => r.auditId === auditId);
+  }
+  /**
+   * Get total count of records.
+   */
+  count() {
+    return this.records.length;
+  }
+};
+
+// src/pricing/engine.ts
+var PricingEngine = class {
+  /**
+   * Rate a single usage event against a pricing rule.
+   * Returns the calculated amount.
+   */
+  rate(rule, context) {
+    const amount = this.evaluate(rule, context);
+    return {
+      ratedRecordId: generateId("rat"),
+      usageEventId: context.event.eventId,
+      contractId: context.event.contractId,
+      pricingRuleId: rule.ruleId,
+      quantity: context.event.quantity,
+      rate: context.event.quantity > 0 ? round(amount / context.event.quantity, 6) : 0,
+      amount: round(amount),
+      currency: "USD",
+      // default, override via contract
+      ratedAt: hrTimestamp()
+    };
+  }
+  /**
+   * Rate multiple usage events against a pricing rule.
+   */
+  rateBatch(rule, events) {
+    let cumulative = 0;
+    return events.map((event) => {
+      cumulative += event.quantity;
+      const context = {
+        event,
+        cumulativeQuantity: cumulative
+      };
+      return this.rate(rule, context);
+    });
+  }
+  /**
+   * Simulate: calculate projected cost without creating rated records.
+   */
+  simulate(rule, quantity, dimensions) {
+    const mockEvent = {
+      eventId: "sim",
+      sourceAgentId: "sim",
+      targetAgentId: "sim",
+      contractId: "sim",
+      serviceId: "sim",
+      timestamp: /* @__PURE__ */ new Date(),
+      quantity,
+      unit: "UNIT",
+      dimensions: dimensions || {}
+    };
+    return round(this.evaluate(rule, { event: mockEvent }));
+  }
+  /**
+   * Human-readable breakdown of how a price was calculated.
+   */
+  explain(rule, context) {
+    return this.buildExplanation(rule, context, 0);
+  }
+  // ═══════════════════════════════════════════════════════════
+  // PRIMITIVE EVALUATORS
+  // ═══════════════════════════════════════════════════════════
+  evaluate(rule, ctx) {
+    switch (rule.primitive) {
+      case "FIXED":
+        return this.evalFixed(rule, ctx);
+      case "UNIT_RATE":
+        return this.evalUnitRate(rule, ctx);
+      case "TIERED":
+        return this.evalTiered(rule, ctx);
+      case "PERCENTAGE":
+        return this.evalPercentage(rule, ctx);
+      case "THRESHOLD":
+        return this.evalThreshold(rule, ctx);
+      case "TIME_WINDOW":
+        return this.evalTimeWindow(rule, ctx);
+      case "CONDITIONAL":
+        return this.evalConditional(rule, ctx);
+      case "COMPOSITE":
+        return this.evalComposite(rule, ctx);
+      default:
+        throw new UMPError(`Unknown pricing primitive: ${rule.primitive}`, "INVALID_RULE");
+    }
+  }
+  /**
+   * FIXED: flat amount per event or period.
+   */
+  evalFixed(rule, _ctx) {
+    return rule.amount;
+  }
+  /**
+   * UNIT_RATE: rate × quantity.
+   */
+  evalUnitRate(rule, ctx) {
+    return rule.rate * ctx.event.quantity;
+  }
+  /**
+   * TIERED: different rates at different consumption levels.
+   * Supports GRADUATED (each unit at its tier's rate) and VOLUME (all units at qualifying tier).
+   */
+  evalTiered(rule, ctx) {
+    const quantity = ctx.cumulativeQuantity ?? ctx.event.quantity;
+    if (rule.mode === "VOLUME") {
+      const tier = rule.tiers.find(
+        (t) => quantity >= t.from && (t.to === null || quantity <= t.to)
+      );
+      return (tier?.rate ?? rule.tiers[rule.tiers.length - 1].rate) * ctx.event.quantity;
+    }
+    let total = 0;
+    let remaining = ctx.event.quantity;
+    let position = (ctx.cumulativeQuantity ?? ctx.event.quantity) - ctx.event.quantity;
+    for (const tier of rule.tiers) {
+      if (remaining <= 0) break;
+      const tierEnd = tier.to ?? Infinity;
+      const tierStart = tier.from;
+      if (position >= tierEnd) continue;
+      const effectiveStart = Math.max(position, tierStart);
+      const effectiveEnd = Math.min(position + remaining, tierEnd);
+      const unitsInTier = Math.max(0, effectiveEnd - effectiveStart);
+      total += unitsInTier * tier.rate;
+      remaining -= unitsInTier;
+      position += unitsInTier;
+    }
+    return total;
+  }
+  /**
+   * PERCENTAGE: fraction of a reference amount.
+   */
+  evalPercentage(rule, ctx) {
+    const reference = ctx.referenceAmount ?? ctx.event.dimensions[rule.referenceField] ?? 0;
+    let amount = reference * rule.percentage;
+    if (rule.min !== void 0) amount = Math.max(amount, rule.min);
+    if (rule.max !== void 0) amount = Math.min(amount, rule.max);
+    return amount;
+  }
+  /**
+   * THRESHOLD: binary trigger — different rates above/below threshold.
+   */
+  evalThreshold(rule, ctx) {
+    const quantity = ctx.cumulativeQuantity ?? ctx.event.quantity;
+    if (quantity <= rule.threshold) {
+      return ctx.event.quantity * rule.belowRate;
+    }
+    return ctx.event.quantity * rule.aboveRate;
+  }
+  /**
+   * TIME_WINDOW: rate varies by when consumption occurs.
+   */
+  evalTimeWindow(rule, ctx) {
+    const time = ctx.currentTime ?? ctx.event.timestamp;
+    const hour = time.getHours();
+    const day = time.getDay();
+    for (const window of rule.windows) {
+      const dayMatch = !window.dayOfWeek || window.dayOfWeek.includes(day);
+      const hourMatch = hour >= window.startHour && hour < window.endHour;
+      if (dayMatch && hourMatch) {
+        return ctx.event.quantity * window.rate;
+      }
+    }
+    return ctx.event.quantity * rule.defaultRate;
+  }
+  /**
+   * CONDITIONAL: price depends on an attribute or outcome.
+   */
+  evalConditional(rule, ctx) {
+    const fieldValue = ctx.event.dimensions[rule.field] ?? ctx.attributes?.[rule.field];
+    for (const branch of rule.branches) {
+      if (this.evaluateCondition(branch.condition, fieldValue)) {
+        return this.evaluate(branch.rule, ctx);
+      }
+    }
+    if (rule.fallback) {
+      return this.evaluate(rule.fallback, ctx);
+    }
+    return 0;
+  }
+  /**
+   * COMPOSITE: combines multiple rules with an operator.
+   */
+  evalComposite(rule, ctx) {
+    const amounts = rule.rules.map((r) => this.evaluate(r, ctx));
+    switch (rule.operator) {
+      case "ADD":
+        return amounts.reduce((sum, a) => sum + a, 0);
+      case "MAX":
+        return Math.max(...amounts);
+      case "MIN":
+        return Math.min(...amounts);
+      case "FIRST_MATCH":
+        return amounts.find((a) => a > 0) ?? 0;
+      default:
+        throw new UMPError(`Unknown composite operator: ${rule.operator}`, "INVALID_RULE");
+    }
+  }
+  // ── Condition evaluator (simplified expression engine) ──
+  evaluateCondition(condition, value) {
+    const eqMatch = condition.match(/^(\w+)\s*==\s*'([^']+)'$/);
+    if (eqMatch) return String(value) === eqMatch[2];
+    const neqMatch = condition.match(/^(\w+)\s*!=\s*'([^']+)'$/);
+    if (neqMatch) return String(value) !== neqMatch[2];
+    const gtMatch = condition.match(/^(\w+)\s*>\s*(\d+(?:\.\d+)?)$/);
+    if (gtMatch) return Number(value) > Number(gtMatch[2]);
+    const ltMatch = condition.match(/^(\w+)\s*<\s*(\d+(?:\.\d+)?)$/);
+    if (ltMatch) return Number(value) < Number(ltMatch[2]);
+    const gteMatch = condition.match(/^(\w+)\s*>=\s*(\d+(?:\.\d+)?)$/);
+    if (gteMatch) return Number(value) >= Number(gteMatch[2]);
+    if (condition === String(value)) return true;
+    return false;
+  }
+  // ── Explanation builder ──
+  buildExplanation(rule, ctx, depth) {
+    const indent = "  ".repeat(depth);
+    const amount = round(this.evaluate(rule, ctx));
+    switch (rule.primitive) {
+      case "FIXED":
+        return `${indent}FIXED: $${rule.amount} flat = $${amount}`;
+      case "UNIT_RATE":
+        return `${indent}UNIT_RATE: ${ctx.event.quantity} \xD7 $${rule.rate}/${rule.unit} = $${amount}`;
+      case "TIERED":
+        return `${indent}TIERED (${rule.mode}): ${ctx.event.quantity} units across ${rule.tiers.length} tiers = $${amount}`;
+      case "PERCENTAGE":
+        return `${indent}PERCENTAGE: ${(rule.percentage * 100).toFixed(1)}% of reference = $${amount}`;
+      case "THRESHOLD":
+        return `${indent}THRESHOLD: ${ctx.event.quantity > rule.threshold ? "above" : "below"} ${rule.threshold} \u2192 $${amount}`;
+      case "TIME_WINDOW":
+        return `${indent}TIME_WINDOW: rate at ${ctx.event.timestamp.toISOString()} = $${amount}`;
+      case "CONDITIONAL": {
+        const lines = [`${indent}CONDITIONAL on "${rule.field}":`];
+        lines.push(`${indent}  \u2192 result = $${amount}`);
+        return lines.join("\n");
+      }
+      case "COMPOSITE": {
+        const comp = rule;
+        const lines = [`${indent}COMPOSITE (${comp.operator}):`];
+        for (const sub of comp.rules) {
+          lines.push(this.buildExplanation(sub, ctx, depth + 1));
+        }
+        lines.push(`${indent}  = $${amount}`);
+        return lines.join("\n");
+      }
+      default:
+        return `${indent}UNKNOWN: $${amount}`;
+    }
+  }
+};
+
+// src/terms/contract-manager.ts
+var ContractManager = class {
+  contracts = /* @__PURE__ */ new Map();
+  /**
+   * Create a new contract between two agents.
+   */
+  create(sourceAgentId, options) {
+    const contractId = generateId("ctr");
+    const now = hrTimestamp();
+    const rules = options.pricingRules.map((r) => ({
+      ...r,
+      ruleId: r.ruleId || generateId("rul")
+    }));
+    const contract = {
+      contractId,
+      mode: options.mode || "TEMPLATE",
+      status: "ACTIVE",
+      parties: {
+        sourceAgentId,
+        targetAgentId: options.targetAgentId
+      },
+      pricingRules: rules,
+      effectiveFrom: options.effectiveFrom || now,
+      effectiveUntil: options.effectiveUntil,
+      metadata: options.metadata || {},
+      createdAt: now
+    };
+    this.contracts.set(contractId, contract);
+    return contract;
+  }
+  /**
+   * Get contract by ID.
+   */
+  get(contractId) {
+    const contract = this.contracts.get(contractId);
+    if (!contract) throw new ContractNotFoundError(contractId);
+    return contract;
+  }
+  /**
+   * Find active contract between two agents.
+   */
+  findActive(sourceAgentId, targetAgentId) {
+    const now = /* @__PURE__ */ new Date();
+    for (const c of this.contracts.values()) {
+      if (c.status === "ACTIVE" && c.parties.sourceAgentId === sourceAgentId && c.parties.targetAgentId === targetAgentId && c.effectiveFrom <= now && (!c.effectiveUntil || c.effectiveUntil > now)) {
+        return c;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Dynamic negotiation: propose terms.
+   * Returns a DRAFT contract that the counterparty can accept or counter.
+   */
+  propose(sourceAgentId, options) {
+    const contract = this.create(sourceAgentId, { ...options, mode: "DYNAMIC" });
+    contract.status = "PROPOSED";
+    return contract;
+  }
+  /**
+   * Accept a proposed contract — transitions to ACTIVE.
+   */
+  accept(contractId) {
+    const contract = this.get(contractId);
+    if (contract.status !== "PROPOSED") {
+      throw new UMPError(`Cannot accept contract in status: ${contract.status}`, "INVALID_STATE");
+    }
+    contract.status = "ACTIVE";
+    return contract;
+  }
+  /**
+   * Counter-propose: create a new proposal based on an existing one with modified terms.
+   */
+  counter(contractId, counterAgentId, modifiedRules) {
+    const original = this.get(contractId);
+    original.status = "EXPIRED";
+    return this.propose(counterAgentId, {
+      targetAgentId: original.parties.sourceAgentId,
+      // reverse direction
+      pricingRules: modifiedRules,
+      metadata: {
+        ...original.metadata,
+        counterTo: contractId
+      }
+    });
+  }
+  /**
+   * Terminate a contract.
+   */
+  terminate(contractId) {
+    const contract = this.get(contractId);
+    contract.status = "TERMINATED";
+    return contract;
+  }
+  /**
+   * List contracts for an agent.
+   */
+  listByAgent(agentId, status) {
+    return Array.from(this.contracts.values()).filter((c) => {
+      const partyMatch = c.parties.sourceAgentId === agentId || c.parties.targetAgentId === agentId;
+      if (!partyMatch) return false;
+      if (status && c.status !== status) return false;
+      return true;
+    });
+  }
+};
+
+// src/terms/metering.ts
+var MeteringEngine = class {
+  events = /* @__PURE__ */ new Map();
+  seenIds = /* @__PURE__ */ new Set();
+  // idempotency guard
+  /**
+   * Record a usage event.
+   * Idempotent: resubmitting the same eventId is a no-op.
+   */
+  record(event) {
+    const eventId = event.eventId || generateId("evt");
+    if (this.seenIds.has(eventId)) {
+      return this.events.get(eventId);
+    }
+    const fullEvent = {
+      ...event,
+      eventId,
+      timestamp: hrTimestamp()
+    };
+    this.events.set(eventId, fullEvent);
+    this.seenIds.add(eventId);
+    return fullEvent;
+  }
+  /**
+   * Record a batch of usage events.
+   */
+  recordBatch(events) {
+    return events.map((e) => this.record(e));
+  }
+  /**
+   * Create an outcome attestation for result-based billing.
+   */
+  attestOutcome(data) {
+    return {
+      outcomeId: generateId("out"),
+      outcomeType: data.outcomeType,
+      claimedBy: data.claimedBy,
+      evidence: data.evidence,
+      verificationMethod: data.verificationMethod,
+      verifiedBy: void 0,
+      confidenceScore: data.confidenceScore,
+      attestationStatus: "CLAIMED",
+      disputeWindow: data.disputeWindow || 24 * 60 * 60 * 1e3
+      // 24h default
+    };
+  }
+  /**
+   * Get events for a contract within a time range.
+   */
+  getByContract(contractId, from, to) {
+    let results = Array.from(this.events.values()).filter((e) => e.contractId === contractId);
+    if (from) results = results.filter((e) => e.timestamp >= from);
+    if (to) results = results.filter((e) => e.timestamp <= to);
+    return results.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+  }
+  /**
+   * Get events for a specific agent (as source or target).
+   */
+  getByAgent(agentId, limit = 100) {
+    return Array.from(this.events.values()).filter((e) => e.sourceAgentId === agentId || e.targetAgentId === agentId).slice(-limit);
+  }
+  /**
+   * Get a specific event by ID.
+   */
+  get(eventId) {
+    return this.events.get(eventId);
+  }
+  /**
+   * Get total metered quantity for a contract.
+   */
+  totalQuantity(contractId) {
+    return Array.from(this.events.values()).filter((e) => e.contractId === contractId).reduce((sum, e) => sum + e.quantity, 0);
+  }
+};
+
+// src/settlement/bus.ts
+var SettlementBus = class {
+  constructor(wallets, audit, pricingEngine) {
+    this.wallets = wallets;
+    this.audit = audit;
+    this.pricingEngine = pricingEngine;
+  }
+  settlements = /* @__PURE__ */ new Map();
+  escrows = /* @__PURE__ */ new Map();
+  /**
+   * Execute a full transaction: meter → rate → settle in one call.
+   * This is the high-level "transact" method from the Quick Start.
+   */
+  async transact(sourceAgentId, targetAgentId, event, rule) {
+    const startTime = Date.now();
+    const ratedRecord = this.pricingEngine.rate(rule, { event });
+    return this.settleInstant(
+      sourceAgentId,
+      targetAgentId,
+      [ratedRecord],
+      startTime
+    );
+  }
+  /**
+   * INSTANT_DRAWDOWN: Debit source, credit target atomically.
+   * Used for per-token, per-inference micro-transactions.
+   */
+  settleInstant(sourceAgentId, targetAgentId, ratedRecords, _startTime) {
+    const totalAmount = round(ratedRecords.reduce((sum, r) => sum + r.amount, 0));
+    const sourceWallet = this.wallets.getByAgent(sourceAgentId);
+    const targetWallet = this.wallets.getByAgent(targetAgentId);
+    const settlementId = generateId("stl");
+    const txnId = generateId("txn");
+    const balanceBefore = this.wallets.getBalance(sourceWallet.walletId)[0]?.available ?? 0;
+    this.wallets.debit(sourceWallet.walletId, totalAmount, targetAgentId, txnId);
+    this.wallets.credit(targetWallet.walletId, totalAmount, sourceAgentId, txnId);
+    const balanceAfter = this.wallets.getBalance(sourceWallet.walletId)[0]?.available ?? 0;
+    const settlement = {
+      settlementId,
+      pattern: "INSTANT_DRAWDOWN",
+      status: "SETTLED",
+      sourceAgentId,
+      targetAgentId,
+      ratedRecords,
+      totalAmount,
+      currency: ratedRecords[0]?.currency ?? "USD",
+      settledAt: hrTimestamp(),
+      auditId: ""
+    };
+    const auditId = this.audit.record({
+      what: { operation: "SETTLEMENT", entityType: "transaction", entityId: txnId, amount: totalAmount },
+      who: { sourceAgentId, targetAgentId },
+      why: { contractId: ratedRecords[0]?.contractId, pricingRuleId: ratedRecords[0]?.pricingRuleId },
+      how: { policiesEvaluated: ["SPENDING_LIMIT", "COUNTERPARTY_ALLOWLIST"], policiesPassed: ["SPENDING_LIMIT", "COUNTERPARTY_ALLOWLIST"] },
+      result: { balanceBefore, balanceAfter, settlementAmount: totalAmount, status: "SETTLED" }
+    });
+    settlement.auditId = auditId;
+    this.settlements.set(settlementId, settlement);
+    return { settlement, auditId };
+  }
+  /**
+   * ESCROW_RELEASE: Reserve funds, release upon outcome attestation.
+   * Used for outcome-based pricing and milestone payments.
+   */
+  createEscrow(sourceAgentId, targetAgentId, amount, transactionId) {
+    const sourceWallet = this.wallets.getByAgent(sourceAgentId);
+    const targetWallet = this.wallets.getByAgent(targetAgentId);
+    const escrowId = generateId("esc");
+    this.wallets.reserve(sourceWallet.walletId, amount, targetAgentId, transactionId);
+    this.escrows.set(escrowId, {
+      amount,
+      sourceWalletId: sourceWallet.walletId,
+      targetWalletId: targetWallet.walletId
+    });
+    this.audit.record({
+      what: { operation: "ESCROW_CREATED", entityType: "escrow", entityId: escrowId, amount },
+      who: { sourceAgentId, targetAgentId },
+      why: { justification: `Escrow for transaction ${transactionId}` },
+      how: { policiesEvaluated: ["SPENDING_LIMIT"], policiesPassed: ["SPENDING_LIMIT"] },
+      result: { status: "ESCROWED" }
+    });
+    return escrowId;
+  }
+  /**
+   * Release escrowed funds to the target (full or partial).
+   */
+  releaseEscrow(escrowId, releaseAmount) {
+    const escrow = this.escrows.get(escrowId);
+    if (!escrow) throw new UMPError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
+    const amount = releaseAmount ?? escrow.amount;
+    const txnId = generateId("txn");
+    this.wallets.releaseReservation(escrow.sourceWalletId, amount, txnId);
+    this.wallets.credit(escrow.targetWalletId, amount, "escrow", txnId);
+    if (amount < escrow.amount) {
+      escrow.amount -= amount;
+    } else {
+      this.escrows.delete(escrowId);
+    }
+    const settlement = {
+      settlementId: generateId("stl"),
+      pattern: "ESCROW_RELEASE",
+      status: "SETTLED",
+      sourceAgentId: "escrow",
+      targetAgentId: "escrow",
+      ratedRecords: [],
+      totalAmount: amount,
+      currency: "USD",
+      settledAt: hrTimestamp(),
+      auditId: ""
+    };
+    const auditId = this.audit.record({
+      what: { operation: "ESCROW_RELEASED", entityType: "escrow", entityId: escrowId, amount },
+      who: { sourceAgentId: "escrow", targetAgentId: "escrow" },
+      why: { justification: `Escrow ${escrowId} released` },
+      how: { policiesEvaluated: ["OUTCOME_VERIFICATION"], policiesPassed: ["OUTCOME_VERIFICATION"] },
+      result: { settlementAmount: amount, status: "SETTLED" }
+    });
+    settlement.auditId = auditId;
+    this.settlements.set(settlement.settlementId, settlement);
+    return { settlement, auditId };
+  }
+  /**
+   * WATERFALL_SPLIT: Distribute payment across multiple parties.
+   * Used for marketplace commissions and multi-party revenue share.
+   */
+  settleWaterfall(sourceAgentId, splits, ratedRecords) {
+    const sourceWallet = this.wallets.getByAgent(sourceAgentId);
+    const totalAmount = round(splits.reduce((sum, s) => sum + s.amount, 0));
+    const txnId = generateId("txn");
+    this.wallets.debit(sourceWallet.walletId, totalAmount, "waterfall", txnId);
+    const results = splits.map((split) => {
+      const targetWallet = this.wallets.getByAgent(split.agentId);
+      this.wallets.credit(targetWallet.walletId, split.amount, sourceAgentId, txnId);
+      const settlement = {
+        settlementId: generateId("stl"),
+        pattern: "WATERFALL_SPLIT",
+        status: "SETTLED",
+        sourceAgentId,
+        targetAgentId: split.agentId,
+        ratedRecords,
+        totalAmount: split.amount,
+        currency: "USD",
+        settledAt: hrTimestamp(),
+        auditId: ""
+      };
+      const auditId = this.audit.record({
+        what: { operation: "WATERFALL_SPLIT", entityType: "settlement", entityId: settlement.settlementId, amount: split.amount },
+        who: { sourceAgentId, targetAgentId: split.agentId },
+        why: { justification: `Waterfall split: ${split.amount} to ${split.agentId}` },
+        how: { policiesEvaluated: ["SPENDING_LIMIT"], policiesPassed: ["SPENDING_LIMIT"] },
+        result: { settlementAmount: split.amount, status: "SETTLED" }
+      });
+      settlement.auditId = auditId;
+      this.settlements.set(settlement.settlementId, settlement);
+      return { settlement, auditId };
+    });
+    return results;
+  }
+  /**
+   * Get settlement by ID.
+   */
+  get(settlementId) {
+    return this.settlements.get(settlementId);
+  }
+  /**
+   * List settlements for an agent.
+   */
+  listByAgent(agentId, limit = 50) {
+    return Array.from(this.settlements.values()).filter((s) => s.sourceAgentId === agentId || s.targetAgentId === agentId).slice(-limit);
+  }
+};
+
+// src/pricing/templates.ts
+var PricingTemplates = {
+  /**
+   * Per-Token LLM pricing (separate input/output rates).
+   * Example: GPT-4 at $30/M input, $60/M output tokens.
+   */
+  perToken(inputRatePerMillion, outputRatePerMillion) {
+    return {
+      ruleId: generateId("rul"),
+      name: "Per-Token LLM",
+      description: `$${inputRatePerMillion}/M input, $${outputRatePerMillion}/M output tokens`,
+      primitive: "CONDITIONAL",
+      field: "direction",
+      branches: [
+        {
+          condition: "direction == 'input'",
+          rule: {
+            ruleId: generateId("rul"),
+            name: "Input Token Rate",
+            primitive: "UNIT_RATE",
+            rate: inputRatePerMillion / 1e6,
+            unit: "TOKEN"
+          }
+        },
+        {
+          condition: "direction == 'output'",
+          rule: {
+            ruleId: generateId("rul"),
+            name: "Output Token Rate",
+            primitive: "UNIT_RATE",
+            rate: outputRatePerMillion / 1e6,
+            unit: "TOKEN"
+          }
+        }
+      ]
+    };
+  },
+  /**
+   * Per-Inference pricing with volume tiers.
+   * Example: $0.01/call for first 10K, $0.005/call after.
+   */
+  perInference(tiers) {
+    return {
+      ruleId: generateId("rul"),
+      name: "Per-Inference Tiered",
+      primitive: "TIERED",
+      mode: "GRADUATED",
+      tiers: tiers.map((t, i) => ({
+        from: i === 0 ? 0 : tiers[i - 1].upTo ?? 0,
+        to: t.upTo,
+        rate: t.rate
+      }))
+    };
+  },
+  /**
+   * Per-Resolution / outcome-based pricing.
+   * Charges only on successful outcome + percentage of value.
+   */
+  perResolution(successFee, valuePct) {
+    return {
+      ruleId: generateId("rul"),
+      name: "Per-Resolution Outcome",
+      primitive: "CONDITIONAL",
+      field: "outcome",
+      branches: [
+        {
+          condition: "outcome == 'SUCCESS'",
+          rule: {
+            ruleId: generateId("rul"),
+            name: "Success Composite",
+            primitive: "COMPOSITE",
+            operator: "ADD",
+            rules: [
+              {
+                ruleId: generateId("rul"),
+                name: "Success Fee",
+                primitive: "FIXED",
+                amount: successFee,
+                period: "PER_EVENT"
+              },
+              {
+                ruleId: generateId("rul"),
+                name: "Value Share",
+                primitive: "PERCENTAGE",
+                percentage: valuePct,
+                referenceField: "value_generated"
+              }
+            ]
+          }
+        }
+      ],
+      fallback: {
+        ruleId: generateId("rul"),
+        name: "No charge on failure",
+        primitive: "FIXED",
+        amount: 0,
+        period: "PER_EVENT"
+      }
+    };
+  },
+  /**
+   * Subscription + Usage hybrid.
+   * Base monthly fee + per-unit overage above included units.
+   */
+  subscriptionPlusUsage(monthlyBase, includedUnits, overageRate) {
+    return {
+      ruleId: generateId("rul"),
+      name: "Subscription + Usage",
+      primitive: "COMPOSITE",
+      operator: "ADD",
+      rules: [
+        {
+          ruleId: generateId("rul"),
+          name: "Monthly Base",
+          primitive: "FIXED",
+          amount: monthlyBase,
+          period: "MONTHLY"
+        },
+        {
+          ruleId: generateId("rul"),
+          name: "Overage",
+          primitive: "THRESHOLD",
+          threshold: includedUnits,
+          belowRate: 0,
+          aboveRate: overageRate
+        }
+      ]
+    };
+  },
+  /**
+   * Credit pool with per-unit drawdown.
+   */
+  creditPool(creditCost) {
+    return {
+      ruleId: generateId("rul"),
+      name: "Credit Pool",
+      primitive: "UNIT_RATE",
+      rate: creditCost,
+      unit: "CREDIT"
+    };
+  },
+  /**
+   * Spot compute pricing with peak/off-peak rates.
+   */
+  computeSpot(peakRate, offPeakRate, peakHours = [9, 17]) {
+    return {
+      ruleId: generateId("rul"),
+      name: "Compute Spot",
+      primitive: "TIME_WINDOW",
+      windows: [
+        {
+          startHour: peakHours[0],
+          endHour: peakHours[1],
+          rate: peakRate,
+          label: "peak",
+          dayOfWeek: [1, 2, 3, 4, 5]
+          // weekdays
+        }
+      ],
+      defaultRate: offPeakRate,
+      timezone: "UTC"
+    };
+  },
+  /**
+   * Marketplace commission (percentage take rate with floor and cap).
+   */
+  marketplaceCommission(takeRate, minFee, maxFee) {
+    return {
+      ruleId: generateId("rul"),
+      name: "Marketplace Commission",
+      primitive: "PERCENTAGE",
+      percentage: takeRate,
+      referenceField: "transaction_amount",
+      min: minFee,
+      max: maxFee
+    };
+  },
+  /**
+   * Agent-to-agent task pricing (fixed per-task + outcome bonus).
+   */
+  agentTask(basePerTask, bonusOnSuccess) {
+    return {
+      ruleId: generateId("rul"),
+      name: "Agent Task",
+      primitive: "COMPOSITE",
+      operator: "ADD",
+      rules: [
+        {
+          ruleId: generateId("rul"),
+          name: "Base Task Fee",
+          primitive: "FIXED",
+          amount: basePerTask,
+          period: "PER_EVENT"
+        },
+        {
+          ruleId: generateId("rul"),
+          name: "Success Bonus",
+          primitive: "CONDITIONAL",
+          field: "outcome",
+          branches: [
+            {
+              condition: "outcome == 'SUCCESS'",
+              rule: {
+                ruleId: generateId("rul"),
+                name: "Bonus",
+                primitive: "FIXED",
+                amount: bonusOnSuccess,
+                period: "PER_EVENT"
+              }
+            }
+          ]
+        }
+      ]
+    };
+  }
+};
+
+// src/index.ts
+var UMP = class {
+  // ── Layer 1: Identity & Value ──
+  agents;
+  wallets;
+  // ── Layer 2: Terms & Metering ──
+  contracts;
+  metering;
+  pricing;
+  // ── Layer 3: Settlement & Governance ──
+  settlement;
+  audit;
+  constructor(config) {
+    this.agents = new AgentManager();
+    this.wallets = new WalletManager();
+    this.audit = new AuditTrail(config.onAudit);
+    this.pricing = new PricingEngine();
+    this.contracts = new ContractManager();
+    this.metering = new MeteringEngine();
+    this.settlement = new SettlementBus(this.wallets, this.audit, this.pricing);
+  }
+  /**
+   * High-level: Register an agent and create its wallet.
+   * Returns an AgentHandle with convenience methods.
+   */
+  registerAgent(options) {
+    const agent = this.agents.create(options);
+    const wallet = this.wallets.create(agent.agentId);
+    return {
+      id: agent.agentId,
+      agent,
+      wallet: {
+        fund: (opts) => {
+          this.wallets.fund(wallet.walletId, opts);
+        },
+        balance: () => {
+          const balances = this.wallets.getBalance(wallet.walletId);
+          return balances[0]?.available ?? 0;
+        },
+        freeze: () => this.wallets.freeze(wallet.walletId),
+        unfreeze: () => this.wallets.unfreeze(wallet.walletId)
+      }
+    };
+  }
+  /**
+   * High-level: Execute a priced transaction between two agents.
+   *
+   * This is the "10 lines of code" Quick Start method.
+   * It finds or creates a contract, meters the event, rates it,
+   * settles payment, and returns the result — all in one call.
+   */
+  async transact(options) {
+    const startTime = Date.now();
+    const txnId = generateId("txn");
+    const sourceCheck = this.agents.verify(options.from);
+    if (!sourceCheck.valid) {
+      throw new AgentRevokedError(options.from);
+    }
+    let contract = this.contracts.findActive(options.from, options.to);
+    if (!contract) {
+      contract = this.contracts.create(options.from, {
+        targetAgentId: options.to,
+        pricingRules: [{
+          name: "Default per-unit",
+          primitive: "UNIT_RATE"
+        }]
+      });
+    }
+    const maxCost = options.maxCost ? parseMoney(options.maxCost) : void 0;
+    if (maxCost) {
+      const authCheck = this.agents.checkAuthority(options.from, maxCost, options.to, options.service);
+      if (!authCheck.allowed) {
+        throw new UMPError(`Authority check failed: ${authCheck.reason}`, "AUTHORITY_EXCEEDED");
+      }
+    }
+    const event = this.metering.record({
+      sourceAgentId: options.from,
+      targetAgentId: options.to,
+      contractId: contract.contractId,
+      serviceId: options.service,
+      quantity: 1,
+      unit: "API_CALL",
+      dimensions: options.payload || {}
+    });
+    const rule = contract.pricingRules[0];
+    const { settlement, auditId } = await this.settlement.transact(
+      options.from,
+      options.to,
+      event,
+      rule
+    );
+    return {
+      transactionId: txnId,
+      cost: settlement.totalAmount,
+      currency: settlement.currency,
+      outcome: event.outcome,
+      auditId,
+      settledAt: settlement.settledAt || /* @__PURE__ */ new Date(),
+      duration: Date.now() - startTime
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentManager,
+  AgentNotFoundError,
+  AgentRevokedError,
+  AuditTrail,
+  AuthorityExceededError,
+  ContractManager,
+  ContractNotFoundError,
+  DisputeError,
+  InsufficientFundsError,
+  MeteringEngine,
+  PolicyViolationError,
+  PricingEngine,
+  PricingTemplates,
+  SettlementBus,
+  UMP,
+  UMPError,
+  WalletFrozenError,
+  WalletManager
+});