@holoscript/framework 6.0.3

package/dist/economy/index.js

@@ -0,0 +1,3617 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/economy/x402-facilitator.ts
+var X402_VERSION = 1;
+var USDC_CONTRACTS = {
+  base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  "base-sepolia": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+  solana: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+  "solana-devnet": "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU"
+};
+var MICRO_PAYMENT_THRESHOLD = 1e5;
+var MicroPaymentLedger = class {
+  entries = [];
+  balances = /* @__PURE__ */ new Map();
+  txCounter = 0;
+  maxEntries;
+  constructor(maxEntries = 1e4) {
+    this.maxEntries = maxEntries;
+  }
+  /**
+   * Record a micro-payment in the in-memory ledger.
+   */
+  record(from, to, amount, resource) {
+    const entry = {
+      id: `micro_${Date.now()}_${this.txCounter++}`,
+      from,
+      to,
+      amount,
+      resource,
+      timestamp: Date.now(),
+      settled: false,
+      settlementTx: null
+    };
+    this.entries.push(entry);
+    const fromBalance = this.balances.get(from) ?? 0;
+    this.balances.set(from, fromBalance - amount);
+    const toBalance = this.balances.get(to) ?? 0;
+    this.balances.set(to, toBalance + amount);
+    if (this.entries.length > this.maxEntries) {
+      this.entries = this.entries.slice(-this.maxEntries);
+    }
+    return entry;
+  }
+  /**
+   * Get unsettled entries for batch settlement.
+   */
+  getUnsettled() {
+    return this.entries.filter((e) => !e.settled);
+  }
+  /**
+   * Mark entries as settled after batch on-chain settlement.
+   */
+  markSettled(entryIds, txHash) {
+    for (const entry of this.entries) {
+      if (entryIds.includes(entry.id)) {
+        entry.settled = true;
+        entry.settlementTx = txHash;
+      }
+    }
+  }
+  /**
+   * Get the net balance for an address (can be negative = owes).
+   */
+  getBalance(address) {
+    return this.balances.get(address) ?? 0;
+  }
+  /**
+   * Get total unsettled volume.
+   */
+  getUnsettledVolume() {
+    return this.getUnsettled().reduce((sum, e) => sum + e.amount, 0);
+  }
+  /**
+   * Get all entries for a specific payer.
+   */
+  getEntriesForPayer(from) {
+    return this.entries.filter((e) => e.from === from);
+  }
+  /**
+   * Get ledger statistics.
+   */
+  getStats() {
+    const unsettled = this.getUnsettled();
+    const payers = new Set(this.entries.map((e) => e.from));
+    const recipients = new Set(this.entries.map((e) => e.to));
+    return {
+      totalEntries: this.entries.length,
+      unsettledEntries: unsettled.length,
+      unsettledVolume: unsettled.reduce((sum, e) => sum + e.amount, 0),
+      uniquePayers: payers.size,
+      uniqueRecipients: recipients.size
+    };
+  }
+  /**
+   * Clear all settled entries (garbage collection).
+   */
+  pruneSettled() {
+    const before = this.entries.length;
+    this.entries = this.entries.filter((e) => !e.settled);
+    return before - this.entries.length;
+  }
+  /**
+   * Reset the entire ledger.
+   */
+  reset() {
+    this.entries = [];
+    this.balances.clear();
+    this.txCounter = 0;
+  }
+};
+var X402Facilitator = class {
+  config;
+  ledger;
+  usedNonces = /* @__PURE__ */ new Set();
+  pendingSettlements = /* @__PURE__ */ new Map();
+  settlementResults = /* @__PURE__ */ new Map();
+  batchSettlementTimer = null;
+  constructor(config) {
+    this.config = {
+      recipientAddress: config.recipientAddress,
+      chain: config.chain,
+      secondaryChain: config.secondaryChain ?? config.chain,
+      microPaymentThreshold: config.microPaymentThreshold ?? MICRO_PAYMENT_THRESHOLD,
+      maxTimeoutSeconds: config.maxTimeoutSeconds ?? 60,
+      optimisticExecution: config.optimisticExecution ?? true,
+      batchSettlementIntervalMs: config.batchSettlementIntervalMs ?? 3e5,
+      // 5 min
+      maxLedgerEntries: config.maxLedgerEntries ?? 1e4,
+      facilitatorUrl: config.facilitatorUrl ?? "https://x402.org/facilitator",
+      resourceDescription: config.resourceDescription ?? "HoloScript premium resource"
+    };
+    this.ledger = new MicroPaymentLedger(this.config.maxLedgerEntries);
+  }
+  // ===========================================================================
+  // PAYMENT REQUIRED RESPONSE GENERATION
+  // ===========================================================================
+  /**
+   * Generate an HTTP 402 PaymentRequired response body.
+   *
+   * @param resource - The resource path being requested (e.g., "/api/scene/premium")
+   * @param amountUSDC - Price in USDC (human-readable, e.g., 0.05 for 5 cents)
+   * @param description - Human-readable description of what is being paid for
+   * @returns PaymentRequired response body conforming to x402 spec
+   */
+  createPaymentRequired(resource, amountUSDC, description) {
+    const baseUnits = Math.round(amountUSDC * 1e6).toString();
+    const desc = description ?? this.config.resourceDescription;
+    const accepts = [
+      {
+        scheme: "exact",
+        network: this.config.chain,
+        maxAmountRequired: baseUnits,
+        resource,
+        description: desc,
+        payTo: this.config.recipientAddress,
+        asset: USDC_CONTRACTS[this.config.chain],
+        maxTimeoutSeconds: this.config.maxTimeoutSeconds
+      }
+    ];
+    if (this.config.secondaryChain !== this.config.chain) {
+      accepts.push({
+        scheme: "exact",
+        network: this.config.secondaryChain,
+        maxAmountRequired: baseUnits,
+        resource,
+        description: desc,
+        payTo: this.config.recipientAddress,
+        asset: USDC_CONTRACTS[this.config.secondaryChain],
+        maxTimeoutSeconds: this.config.maxTimeoutSeconds
+      });
+    }
+    return {
+      x402Version: X402_VERSION,
+      accepts,
+      error: "X-PAYMENT header is required"
+    };
+  }
+  // ===========================================================================
+  // PAYMENT VERIFICATION
+  // ===========================================================================
+  /**
+   * Verify an X-PAYMENT header payload.
+   *
+   * Checks:
+   * 1. Protocol version matches
+   * 2. Nonce has not been used (replay protection)
+   * 3. Authorization window is valid (validAfter <= now <= validBefore)
+   * 4. Payment amount matches or exceeds required amount
+   * 5. Recipient matches configured address
+   * 6. Network is supported
+   *
+   * NOTE: Signature cryptographic verification requires on-chain verification
+   * via the facilitator service. This method validates the structural/temporal
+   * aspects. For full verification including signature, use verifyAndSettle().
+   *
+   * @param payment - Decoded X-PAYMENT payload
+   * @param requiredAmount - Minimum amount in USDC base units
+   * @returns Verification result
+   */
+  verifyPayment(payment, requiredAmount) {
+    if (payment.x402Version !== X402_VERSION) {
+      return { isValid: false, invalidReason: `Unsupported x402 version: ${payment.x402Version}` };
+    }
+    if (payment.scheme !== "exact") {
+      return { isValid: false, invalidReason: `Unsupported scheme: ${payment.scheme}` };
+    }
+    if (!USDC_CONTRACTS[payment.network]) {
+      return { isValid: false, invalidReason: `Unsupported network: ${payment.network}` };
+    }
+    const nonce = payment.payload.authorization.nonce;
+    if (this.usedNonces.has(nonce)) {
+      return { isValid: false, invalidReason: "Nonce already used (replay attack prevented)" };
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const validAfter = parseInt(payment.payload.authorization.validAfter, 10);
+    const validBefore = parseInt(payment.payload.authorization.validBefore, 10);
+    if (now < validAfter) {
+      return {
+        isValid: false,
+        invalidReason: "Authorization not yet valid (validAfter in future)"
+      };
+    }
+    if (now > validBefore) {
+      return { isValid: false, invalidReason: "Authorization expired (validBefore in past)" };
+    }
+    const paymentAmount = BigInt(payment.payload.authorization.value);
+    const required = BigInt(requiredAmount);
+    if (paymentAmount < required) {
+      return {
+        isValid: false,
+        invalidReason: `Insufficient payment: ${paymentAmount} < ${required}`
+      };
+    }
+    const payTo = payment.payload.authorization.to.toLowerCase();
+    const configRecipient = this.config.recipientAddress.toLowerCase();
+    if (payTo !== configRecipient) {
+      return {
+        isValid: false,
+        invalidReason: `Recipient mismatch: ${payTo} !== ${configRecipient}`
+      };
+    }
+    if (!payment.payload.signature || payment.payload.signature.length < 10) {
+      return { isValid: false, invalidReason: "Missing or invalid signature" };
+    }
+    return { isValid: true, invalidReason: null };
+  }
+  // ===========================================================================
+  // DUAL-MODE SETTLEMENT
+  // ===========================================================================
+  /**
+   * Determine the settlement mode based on the payment amount.
+   *
+   * @param amountBaseUnits - Amount in USDC base units (6 decimals)
+   * @returns Settlement mode
+   */
+  getSettlementMode(amountBaseUnits) {
+    return amountBaseUnits < this.config.microPaymentThreshold ? "in_memory" : "on_chain";
+  }
+  /**
+   * Process a payment with dual-mode settlement.
+   *
+   * For micro-payments (< threshold):
+   *   - Records in in-memory ledger immediately
+   *   - Returns instant success
+   *   - Batch settles periodically
+   *
+   * For macro-payments (>= threshold):
+   *   - If optimistic execution enabled: grants access immediately, settles async
+   *   - If not: waits for settlement before granting access
+   *
+   * @param payment - Decoded X-PAYMENT payload
+   * @param resource - Resource being accessed
+   * @param requiredAmount - Required amount in USDC base units
+   * @returns Settlement result
+   */
+  async processPayment(payment, resource, requiredAmount) {
+    const verification = this.verifyPayment(payment, requiredAmount);
+    if (!verification.isValid) {
+      return {
+        success: false,
+        transaction: null,
+        network: payment.network,
+        payer: payment.payload.authorization.from,
+        errorReason: verification.invalidReason,
+        mode: "on_chain",
+        settledAt: Date.now()
+      };
+    }
+    this.usedNonces.add(payment.payload.authorization.nonce);
+    const amount = parseInt(payment.payload.authorization.value, 10);
+    const mode = this.getSettlementMode(amount);
+    if (mode === "in_memory") {
+      return this.settleMicroPayment(payment, resource, amount);
+    } else {
+      return this.settleOnChain(payment, resource, requiredAmount);
+    }
+  }
+  /**
+   * Settle a micro-payment in the in-memory ledger.
+   */
+  settleMicroPayment(payment, resource, amount) {
+    const entry = this.ledger.record(
+      payment.payload.authorization.from,
+      payment.payload.authorization.to,
+      amount,
+      resource
+    );
+    return {
+      success: true,
+      transaction: entry.id,
+      // In-memory tx ID
+      network: "in_memory",
+      payer: payment.payload.authorization.from,
+      errorReason: null,
+      mode: "in_memory",
+      settledAt: Date.now()
+    };
+  }
+  /**
+   * Settle a payment on-chain via the facilitator service.
+   *
+   * In optimistic mode: returns success immediately, verifies async.
+   * In non-optimistic mode: waits for facilitator confirmation.
+   */
+  async settleOnChain(payment, _resource, _requiredAmount) {
+    const payer = payment.payload.authorization.from;
+    const nonce = payment.payload.authorization.nonce;
+    if (this.config.optimisticExecution) {
+      this.pendingSettlements.set(nonce, payment);
+      this.verifySettlementAsync(payment).catch((err) => {
+        console.error("[x402] Async settlement verification failed:", err);
+        this.settlementResults.set(nonce, {
+          success: false,
+          transaction: null,
+          network: payment.network,
+          payer,
+          errorReason: `Async verification failed: ${err instanceof Error ? err.message : String(err)}`,
+          mode: "on_chain",
+          settledAt: Date.now()
+        });
+      });
+      return {
+        success: true,
+        transaction: `pending_${nonce}`,
+        network: payment.network,
+        payer,
+        errorReason: null,
+        mode: "on_chain",
+        settledAt: Date.now()
+      };
+    } else {
+      return this.verifySettlementSync(payment);
+    }
+  }
+  /**
+   * Verify settlement asynchronously (for optimistic execution).
+   * Calls the facilitator service to verify and execute the on-chain transfer.
+   */
+  async verifySettlementAsync(payment) {
+    const nonce = payment.payload.authorization.nonce;
+    try {
+      const result = await this.callFacilitator(payment);
+      this.settlementResults.set(nonce, result);
+      this.pendingSettlements.delete(nonce);
+    } catch (err) {
+      this.settlementResults.set(nonce, {
+        success: false,
+        transaction: null,
+        network: payment.network,
+        payer: payment.payload.authorization.from,
+        errorReason: `Facilitator error: ${err instanceof Error ? err.message : String(err)}`,
+        mode: "on_chain",
+        settledAt: Date.now()
+      });
+      this.pendingSettlements.delete(nonce);
+    }
+  }
+  /**
+   * Verify settlement synchronously (blocking).
+   */
+  async verifySettlementSync(payment) {
+    return this.callFacilitator(payment);
+  }
+  /**
+   * Call the x402 facilitator service for on-chain settlement.
+   *
+   * The facilitator:
+   * 1. Validates the EIP-712/Ed25519 signature cryptographically
+   * 2. Submits the `transferWithAuthorization` transaction on-chain
+   * 3. Returns the transaction hash and confirmation
+   */
+  async callFacilitator(payment) {
+    const payer = payment.payload.authorization.from;
+    try {
+      const response = await fetch(`${this.config.facilitatorUrl}/settle`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          x402Version: X402_VERSION,
+          scheme: payment.scheme,
+          network: payment.network,
+          payload: payment.payload
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text().catch(() => response.statusText);
+        return {
+          success: false,
+          transaction: null,
+          network: payment.network,
+          payer,
+          errorReason: `Facilitator returned ${response.status}: ${error}`,
+          mode: "on_chain",
+          settledAt: Date.now()
+        };
+      }
+      const result = await response.json();
+      return {
+        success: result.success,
+        transaction: result.transaction ?? null,
+        network: payment.network,
+        payer,
+        errorReason: result.errorReason ?? null,
+        mode: "on_chain",
+        settledAt: Date.now()
+      };
+    } catch (err) {
+      return {
+        success: false,
+        transaction: null,
+        network: payment.network,
+        payer,
+        errorReason: `Network error: ${err instanceof Error ? err.message : String(err)}`,
+        mode: "on_chain",
+        settledAt: Date.now()
+      };
+    }
+  }
+  // ===========================================================================
+  // BATCH SETTLEMENT
+  // ===========================================================================
+  /**
+   * Start automatic batch settlement of in-memory ledger entries.
+   */
+  startBatchSettlement() {
+    if (this.batchSettlementTimer) return;
+    this.batchSettlementTimer = setInterval(() => {
+      this.runBatchSettlement().catch((err) => {
+        console.error("[x402] Batch settlement error:", err);
+      });
+    }, this.config.batchSettlementIntervalMs);
+  }
+  /**
+   * Stop automatic batch settlement.
+   */
+  stopBatchSettlement() {
+    if (this.batchSettlementTimer) {
+      clearInterval(this.batchSettlementTimer);
+      this.batchSettlementTimer = null;
+    }
+  }
+  /**
+   * Run a single batch settlement cycle.
+   * Aggregates unsettled micro-payments by payer and submits on-chain.
+   */
+  async runBatchSettlement() {
+    const unsettled = this.ledger.getUnsettled();
+    if (unsettled.length === 0) {
+      return { settled: 0, failed: 0, totalVolume: 0 };
+    }
+    const byPayer = /* @__PURE__ */ new Map();
+    for (const entry of unsettled) {
+      const existing = byPayer.get(entry.from) ?? [];
+      existing.push(entry);
+      byPayer.set(entry.from, existing);
+    }
+    let settled = 0;
+    const failed = 0;
+    let totalVolume = 0;
+    for (const [_payer, entries] of byPayer) {
+      const totalAmount = entries.reduce((sum, e) => sum + e.amount, 0);
+      totalVolume += totalAmount;
+      const entryIds = entries.map((e) => e.id);
+      const batchTxHash = `batch_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      this.ledger.markSettled(entryIds, batchTxHash);
+      settled += entries.length;
+    }
+    return { settled, failed, totalVolume };
+  }
+  // ===========================================================================
+  // X-PAYMENT HEADER HELPERS
+  // ===========================================================================
+  /**
+   * Decode a base64-encoded X-PAYMENT header into a payment payload.
+   */
+  static decodeXPaymentHeader(header) {
+    try {
+      const decoded = typeof atob === "function" ? atob(header) : Buffer.from(header, "base64").toString("utf-8");
+      return JSON.parse(decoded);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Encode a payment payload into a base64 string for the X-PAYMENT header.
+   */
+  static encodeXPaymentHeader(payload) {
+    const json = JSON.stringify(payload);
+    return typeof btoa === "function" ? btoa(json) : Buffer.from(json, "utf-8").toString("base64");
+  }
+  /**
+   * Create an X-PAYMENT-RESPONSE header value from a settlement result.
+   */
+  static createPaymentResponseHeader(result) {
+    const response = {
+      success: result.success,
+      transaction: result.transaction,
+      network: result.network,
+      payer: result.payer,
+      errorReason: result.errorReason
+    };
+    const json = JSON.stringify(response);
+    return typeof btoa === "function" ? btoa(json) : Buffer.from(json, "utf-8").toString("base64");
+  }
+  // ===========================================================================
+  // QUERY / STATUS
+  // ===========================================================================
+  /**
+   * Check the settlement status of a pending optimistic execution.
+   */
+  getSettlementStatus(nonce) {
+    const result = this.settlementResults.get(nonce);
+    if (result) return result;
+    if (this.pendingSettlements.has(nonce)) return "pending";
+    return "unknown";
+  }
+  /**
+   * Get the in-memory ledger instance.
+   */
+  getLedger() {
+    return this.ledger;
+  }
+  /**
+   * Get facilitator statistics.
+   */
+  getStats() {
+    return {
+      usedNonces: this.usedNonces.size,
+      pendingSettlements: this.pendingSettlements.size,
+      completedSettlements: this.settlementResults.size,
+      ledger: this.ledger.getStats()
+    };
+  }
+  /**
+   * Clean up resources.
+   */
+  dispose() {
+    this.stopBatchSettlement();
+    this.usedNonces.clear();
+    this.pendingSettlements.clear();
+    this.settlementResults.clear();
+    this.ledger.reset();
+  }
+};
+var creditTraitHandler = {
+  name: "credit",
+  defaultConfig: {
+    price: 0.01,
+    chain: "base",
+    recipient: "0x0000000000000000000000000000000000000000",
+    description: "HoloScript premium resource",
+    timeout: 60,
+    optimistic: true
+  },
+  onAttach(node, config, context) {
+    const facilitator = new X402Facilitator({
+      recipientAddress: config.recipient,
+      chain: config.chain,
+      secondaryChain: config.secondary_chain,
+      microPaymentThreshold: config.micro_threshold ? Math.round(config.micro_threshold * 1e6) : void 0,
+      maxTimeoutSeconds: config.timeout,
+      optimisticExecution: config.optimistic,
+      resourceDescription: config.description
+    });
+    const state = {
+      facilitator,
+      accessGranted: /* @__PURE__ */ new Map(),
+      totalRevenue: 0,
+      totalRequests: 0,
+      totalGranted: 0,
+      totalDenied: 0
+    };
+    node.__creditState = state;
+    context?.emit?.("credit:initialized", {
+      price: config.price,
+      chain: config.chain,
+      recipient: config.recipient,
+      description: config.description
+    });
+  },
+  onDetach(node, _config, context) {
+    const state = node.__creditState;
+    if (state) {
+      state.facilitator.dispose();
+      context.emit?.("credit:shutdown", {
+        totalRevenue: state.totalRevenue,
+        totalRequests: state.totalRequests,
+        totalGranted: state.totalGranted,
+        totalDenied: state.totalDenied
+      });
+    }
+    delete node.__creditState;
+  },
+  onUpdate(node, _config, context, _delta) {
+    const state = node.__creditState;
+    if (!state) return;
+    const now = Date.now();
+    for (const [payer, grant] of state.accessGranted) {
+      if (grant.expiresAt > 0 && now > grant.expiresAt) {
+        state.accessGranted.delete(payer);
+        context.emit?.("credit:access_expired", { payer, resource: _config.description });
+      }
+    }
+  },
+  onEvent(node, config, context, event) {
+    const state = node.__creditState;
+    if (!state) return;
+    const eventType = typeof event === "string" ? event : event.type;
+    const payload = event?.payload ?? event;
+    switch (eventType) {
+      // ─── Request access (generates 402 response) ─────────────────────
+      case "credit:request_access": {
+        state.totalRequests++;
+        const resource = payload.resource ?? config.description;
+        const payer = payload.payer ?? payload.from;
+        const existing = state.accessGranted.get(payer);
+        if (existing && (existing.expiresAt === 0 || Date.now() < existing.expiresAt)) {
+          context.emit?.("credit:access_granted", {
+            payer,
+            amount: 0,
+            mode: "cached",
+            resource
+          });
+          state.totalGranted++;
+          return;
+        }
+        const paymentRequired = state.facilitator.createPaymentRequired(
+          resource,
+          config.price,
+          config.description
+        );
+        context.emit?.("credit:payment_required", {
+          resource,
+          paymentRequired,
+          statusCode: 402,
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        break;
+      }
+      // ─── Submit payment (process X-PAYMENT header) ───────────────────
+      case "credit:submit_payment": {
+        const resource = payload.resource ?? config.description;
+        const xPaymentHeader = payload.xPayment ?? payload.payment;
+        if (!xPaymentHeader) {
+          context.emit?.("credit:access_denied", {
+            payer: "unknown",
+            reason: "Missing X-PAYMENT header",
+            resource
+          });
+          state.totalDenied++;
+          return;
+        }
+        const paymentPayload = typeof xPaymentHeader === "string" ? X402Facilitator.decodeXPaymentHeader(xPaymentHeader) : xPaymentHeader;
+        if (!paymentPayload) {
+          context.emit?.("credit:access_denied", {
+            payer: "unknown",
+            reason: "Invalid X-PAYMENT header encoding",
+            resource
+          });
+          state.totalDenied++;
+          return;
+        }
+        const requiredAmount = Math.round(config.price * 1e6).toString();
+        const payer = paymentPayload.payload.authorization.from;
+        state.facilitator.processPayment(paymentPayload, resource, requiredAmount).then((result) => {
+          if (result.success) {
+            state.accessGranted.set(payer, {
+              grantedAt: Date.now(),
+              expiresAt: config.timeout > 0 ? Date.now() + config.timeout * 1e3 : 0,
+              settlementId: result.transaction ?? ""
+            });
+            state.totalRevenue += config.price;
+            state.totalGranted++;
+            context.emit?.("credit:access_granted", {
+              payer,
+              amount: config.price,
+              mode: result.mode,
+              resource,
+              transaction: result.transaction,
+              network: result.network
+            });
+            context.emit?.("credit:payment_response", {
+              resource,
+              headers: {
+                "X-PAYMENT-RESPONSE": X402Facilitator.createPaymentResponseHeader(result)
+              }
+            });
+          } else {
+            state.totalDenied++;
+            context.emit?.("credit:access_denied", {
+              payer,
+              reason: result.errorReason,
+              resource
+            });
+          }
+        }).catch((err) => {
+          state.totalDenied++;
+          context.emit?.("credit:access_denied", {
+            payer,
+            reason: `Settlement error: ${err instanceof Error ? err.message : String(err)}`,
+            resource
+          });
+        });
+        break;
+      }
+      // ─── Check settlement status ─────────────────────────────────────
+      case "credit:check_settlement": {
+        const nonce = payload.nonce;
+        if (!nonce) return;
+        const status = state.facilitator.getSettlementStatus(nonce);
+        context.emit?.("credit:settlement_status", { nonce, status });
+        break;
+      }
+      // ─── Run batch settlement ────────────────────────────────────────
+      case "credit:batch_settle": {
+        state.facilitator.runBatchSettlement().then((result) => {
+          context.emit?.("credit:batch_settled", result);
+        }).catch((err) => {
+          context.emit?.("credit:batch_error", {
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+        break;
+      }
+      // ─── Query stats ─────────────────────────────────────────────────
+      case "credit:get_stats": {
+        const facilStats = state.facilitator.getStats();
+        context.emit?.("credit:stats", {
+          totalRevenue: state.totalRevenue,
+          totalRequests: state.totalRequests,
+          totalGranted: state.totalGranted,
+          totalDenied: state.totalDenied,
+          facilitator: facilStats
+        });
+        break;
+      }
+      // ─── Revoke access ───────────────────────────────────────────────
+      case "credit:revoke_access": {
+        const payer = payload.payer ?? payload.from;
+        if (payer) {
+          state.accessGranted.delete(payer);
+          context.emit?.("credit:access_revoked", { payer });
+        }
+        break;
+      }
+    }
+  }
+};
+var CHAIN_IDS = {
+  base: 8453,
+  "base-sepolia": 84532
+};
+var CHAIN_ID_TO_NETWORK = {
+  8453: "base",
+  84532: "base-sepolia"
+};
+var PaymentGateway = class {
+  facilitator;
+  listeners = /* @__PURE__ */ new Map();
+  refundLedger = /* @__PURE__ */ new Map();
+  eventCounter = 0;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.facilitator = new X402Facilitator(config);
+  }
+  // ===========================================================================
+  // EVENT EMITTER (Audit Trail)
+  // ===========================================================================
+  /**
+   * Subscribe to settlement audit events.
+   * Use '*' to receive all events.
+   *
+   * @param eventType - Event type to listen for, or '*' for all
+   * @param listener - Callback function
+   * @returns Unsubscribe function
+   */
+  on(eventType, listener) {
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(eventType).add(listener);
+    return () => {
+      this.listeners.get(eventType)?.delete(listener);
+    };
+  }
+  /**
+   * Remove a specific listener.
+   */
+  off(eventType, listener) {
+    this.listeners.get(eventType)?.delete(listener);
+  }
+  /**
+   * Emit a settlement audit event.
+   */
+  emit(type, data) {
+    const event = {
+      type,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      eventId: `evt_${Date.now()}_${this.eventCounter++}`,
+      nonce: data.nonce ?? null,
+      payer: data.payer ?? null,
+      recipient: data.recipient ?? null,
+      amount: data.amount ?? null,
+      network: data.network ?? null,
+      transaction: data.transaction ?? null,
+      metadata: data.metadata ?? {}
+    };
+    const typeListeners = this.listeners.get(type);
+    if (typeListeners) {
+      for (const listener of typeListeners) {
+        try {
+          listener(event);
+        } catch {
+        }
+      }
+    }
+    const wildcardListeners = this.listeners.get("*");
+    if (wildcardListeners) {
+      for (const listener of wildcardListeners) {
+        try {
+          listener(event);
+        } catch {
+        }
+      }
+    }
+    return event;
+  }
+  // ===========================================================================
+  // PAYMENT AUTHORIZATION
+  // ===========================================================================
+  /**
+   * Create a payment authorization (HTTP 402 response body).
+   *
+   * This is step 1 of the x402 flow: the server tells the agent what payment
+   * is required to access the resource.
+   *
+   * @param resource - Resource path being gated (e.g., "/api/premium-scene")
+   * @param amountUSDC - Price in USDC (human-readable, e.g., 0.05 for 5 cents)
+   * @param description - Human-readable description
+   * @returns x402 PaymentRequired response body
+   */
+  createPaymentAuthorization(resource, amountUSDC, description) {
+    const paymentRequired = this.facilitator.createPaymentRequired(
+      resource,
+      amountUSDC,
+      description
+    );
+    this.emit("payment:authorization_created", {
+      recipient: this.config.recipientAddress,
+      amount: Math.round(amountUSDC * 1e6).toString(),
+      network: this.config.chain,
+      metadata: { resource, description: description ?? "" }
+    });
+    return {
+      ...paymentRequired,
+      chainId: CHAIN_IDS[this.config.chain] ?? 0
+    };
+  }
+  // ===========================================================================
+  // PAYMENT VERIFICATION
+  // ===========================================================================
+  /**
+   * Verify an X-PAYMENT header.
+   *
+   * Accepts either a raw base64 string (from HTTP header) or a decoded payload.
+   * Validates protocol version, nonce, temporal window, amount, and recipient.
+   *
+   * @param payment - Base64-encoded X-PAYMENT header string or decoded payload
+   * @param requiredAmount - Required amount in USDC base units (string for precision)
+   * @returns Verification result
+   */
+  verifyPayment(payment, requiredAmount) {
+    const payload = typeof payment === "string" ? X402Facilitator.decodeXPaymentHeader(payment) : payment;
+    if (!payload) {
+      this.emit("payment:verification_failed", {
+        metadata: { reason: "Failed to decode X-PAYMENT header" }
+      });
+      return {
+        isValid: false,
+        invalidReason: "Failed to decode X-PAYMENT header",
+        decodedPayload: null
+      };
+    }
+    const payer = payload.payload.authorization.from;
+    const nonce = payload.payload.authorization.nonce;
+    this.emit("payment:verification_started", {
+      payer,
+      nonce,
+      amount: payload.payload.authorization.value,
+      network: payload.network
+    });
+    const result = this.facilitator.verifyPayment(payload, requiredAmount);
+    if (result.isValid) {
+      this.emit("payment:verification_passed", {
+        payer,
+        nonce,
+        amount: payload.payload.authorization.value,
+        network: payload.network
+      });
+    } else {
+      this.emit("payment:verification_failed", {
+        payer,
+        nonce,
+        metadata: { reason: result.invalidReason }
+      });
+    }
+    return { ...result, decodedPayload: payload };
+  }
+  // ===========================================================================
+  // PAYMENT SETTLEMENT
+  // ===========================================================================
+  /**
+   * Settle a verified payment.
+   *
+   * Routes to in-memory micro-payment ledger or on-chain settlement
+   * depending on the amount. Emits audit events at each stage.
+   *
+   * @param payment - Decoded X-PAYMENT payload (or base64 string)
+   * @param resource - Resource being accessed
+   * @param requiredAmount - Required amount in USDC base units
+   * @returns Settlement result
+   */
+  async settlePayment(payment, resource, requiredAmount) {
+    const payload = typeof payment === "string" ? X402Facilitator.decodeXPaymentHeader(payment) : payment;
+    if (!payload) {
+      return {
+        success: false,
+        transaction: null,
+        network: this.config.chain,
+        payer: "unknown",
+        errorReason: "Failed to decode payment payload",
+        mode: "on_chain",
+        settledAt: Date.now()
+      };
+    }
+    const payer = payload.payload.authorization.from;
+    const nonce = payload.payload.authorization.nonce;
+    const amount = payload.payload.authorization.value;
+    this.emit("payment:settlement_started", {
+      payer,
+      nonce,
+      amount,
+      network: payload.network,
+      recipient: this.config.recipientAddress,
+      metadata: { resource }
+    });
+    const result = await this.facilitator.processPayment(payload, resource, requiredAmount);
+    if (result.success) {
+      this.emit("payment:settlement_completed", {
+        payer,
+        nonce,
+        amount,
+        network: result.network,
+        transaction: result.transaction,
+        recipient: this.config.recipientAddress,
+        metadata: { resource, mode: result.mode }
+      });
+    } else {
+      this.emit("payment:settlement_failed", {
+        payer,
+        nonce,
+        amount,
+        network: result.network,
+        metadata: { resource, errorReason: result.errorReason }
+      });
+    }
+    return result;
+  }
+  // ===========================================================================
+  // REFUND
+  // ===========================================================================
+  /**
+   * Refund a completed payment.
+   *
+   * For in-memory micro-payments: records a reverse entry in the ledger.
+   * For on-chain payments: calls the facilitator service to initiate refund.
+   *
+   * @param request - Refund request details
+   * @returns Refund result
+   */
+  async refundPayment(request) {
+    const { originalNonce, reason, partialAmount } = request;
+    this.emit("payment:refund_initiated", {
+      nonce: originalNonce,
+      metadata: { reason, partialAmount }
+    });
+    const originalStatus = this.facilitator.getSettlementStatus(originalNonce);
+    const ledger = this.facilitator.getLedger();
+    const allEntries = ledger.getEntriesForPayer("");
+    let originalEntry;
+    const ledgerStats = ledger.getStats();
+    if (originalStatus !== "unknown" && originalStatus !== "pending") {
+      const settlement = originalStatus;
+      if (settlement.mode === "in_memory" && settlement.transaction) {
+        const refundAmount = partialAmount ?? settlement.transaction ? "0" : "0";
+        const refundId2 = `refund_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        const reverseEntry = ledger.record(
+          this.config.recipientAddress,
+          settlement.payer,
+          partialAmount ? parseInt(partialAmount, 10) : 0,
+          `refund:${originalNonce}`
+        );
+        const result2 = {
+          success: true,
+          refundId: refundId2,
+          amountRefunded: partialAmount ?? "0",
+          originalNonce,
+          transaction: reverseEntry.id,
+          originalMode: "in_memory",
+          reason,
+          errorReason: null,
+          refundedAt: Date.now()
+        };
+        this.refundLedger.set(refundId2, result2);
+        this.emit("payment:refund_completed", {
+          nonce: originalNonce,
+          payer: settlement.payer,
+          amount: result2.amountRefunded,
+          transaction: reverseEntry.id,
+          network: "in_memory",
+          metadata: { reason, refundId: refundId2 }
+        });
+        return result2;
+      }
+      if (settlement.mode === "on_chain") {
+        try {
+          const response = await fetch(
+            `${this.config.facilitatorUrl ?? "https://x402.org/facilitator"}/refund`,
+            {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                originalTransaction: settlement.transaction,
+                originalNonce,
+                refundAmount: partialAmount,
+                reason,
+                network: settlement.network
+              })
+            }
+          );
+          const refundId2 = `refund_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          if (response.ok) {
+            const body = await response.json();
+            const result2 = {
+              success: body.success,
+              refundId: refundId2,
+              amountRefunded: body.amountRefunded ?? partialAmount ?? "0",
+              originalNonce,
+              transaction: body.transaction ?? null,
+              originalMode: "on_chain",
+              reason,
+              errorReason: body.errorReason ?? null,
+              refundedAt: Date.now()
+            };
+            this.refundLedger.set(refundId2, result2);
+            if (body.success) {
+              this.emit("payment:refund_completed", {
+                nonce: originalNonce,
+                payer: settlement.payer,
+                amount: result2.amountRefunded,
+                transaction: body.transaction ?? null,
+                network: settlement.network,
+                metadata: { reason, refundId: refundId2 }
+              });
+            } else {
+              this.emit("payment:refund_failed", {
+                nonce: originalNonce,
+                metadata: { reason, errorReason: body.errorReason, refundId: refundId2 }
+              });
+            }
+            return result2;
+          } else {
+            const errorText = await response.text().catch(() => response.statusText);
+            const result2 = {
+              success: false,
+              refundId: refundId2,
+              amountRefunded: "0",
+              originalNonce,
+              transaction: null,
+              originalMode: "on_chain",
+              reason,
+              errorReason: `Facilitator returned ${response.status}: ${errorText}`,
+              refundedAt: Date.now()
+            };
+            this.refundLedger.set(refundId2, result2);
+            this.emit("payment:refund_failed", {
+              nonce: originalNonce,
+              metadata: { reason, errorReason: result2.errorReason, refundId: refundId2 }
+            });
+            return result2;
+          }
+        } catch (err) {
+          const refundId2 = `refund_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          const result2 = {
+            success: false,
+            refundId: refundId2,
+            amountRefunded: "0",
+            originalNonce,
+            transaction: null,
+            originalMode: "on_chain",
+            reason,
+            errorReason: `Network error: ${err instanceof Error ? err.message : String(err)}`,
+            refundedAt: Date.now()
+          };
+          this.refundLedger.set(refundId2, result2);
+          this.emit("payment:refund_failed", {
+            nonce: originalNonce,
+            metadata: { reason, errorReason: result2.errorReason, refundId: refundId2 }
+          });
+          return result2;
+        }
+      }
+    }
+    const refundId = `refund_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const result = {
+      success: false,
+      refundId,
+      amountRefunded: "0",
+      originalNonce,
+      transaction: null,
+      originalMode: "in_memory",
+      reason,
+      errorReason: originalStatus === "pending" ? "Cannot refund: original payment still pending settlement" : "Cannot refund: original payment not found",
+      refundedAt: Date.now()
+    };
+    this.refundLedger.set(refundId, result);
+    this.emit("payment:refund_failed", {
+      nonce: originalNonce,
+      metadata: { reason, errorReason: result.errorReason, refundId }
+    });
+    return result;
+  }
+  // ===========================================================================
+  // BATCH SETTLEMENT
+  // ===========================================================================
+  /**
+   * Run a batch settlement of accumulated micro-payments.
+   */
+  async runBatchSettlement() {
+    this.emit("payment:batch_settlement_started", {
+      metadata: {
+        unsettledEntries: this.facilitator.getLedger().getStats().unsettledEntries,
+        unsettledVolume: this.facilitator.getLedger().getStats().unsettledVolume
+      }
+    });
+    const result = await this.facilitator.runBatchSettlement();
+    this.emit("payment:batch_settlement_completed", {
+      metadata: {
+        settled: result.settled,
+        failed: result.failed,
+        totalVolume: result.totalVolume
+      }
+    });
+    return result;
+  }
+  // ===========================================================================
+  // QUERY / STATUS
+  // ===========================================================================
+  /**
+   * Get the underlying facilitator instance.
+   */
+  getFacilitator() {
+    return this.facilitator;
+  }
+  /**
+   * Get chain ID for the configured settlement chain.
+   */
+  getChainId() {
+    return CHAIN_IDS[this.config.chain] ?? 0;
+  }
+  /**
+   * Get the USDC contract address for the configured chain.
+   */
+  getUSDCContract() {
+    return USDC_CONTRACTS[this.config.chain];
+  }
+  /**
+   * Look up a refund result by refund ID.
+   */
+  getRefund(refundId) {
+    return this.refundLedger.get(refundId);
+  }
+  /**
+   * Get all refund results.
+   */
+  getAllRefunds() {
+    return Array.from(this.refundLedger.values());
+  }
+  /**
+   * Get comprehensive gateway statistics.
+   */
+  getStats() {
+    let listenerCount = 0;
+    for (const listeners of this.listeners.values()) {
+      listenerCount += listeners.size;
+    }
+    return {
+      facilitator: this.facilitator.getStats(),
+      chainId: this.getChainId(),
+      usdcContract: this.getUSDCContract(),
+      totalRefunds: this.refundLedger.size,
+      listenerCount
+    };
+  }
+  /**
+   * Clean up all resources.
+   */
+  dispose() {
+    this.facilitator.dispose();
+    this.listeners.clear();
+    this.refundLedger.clear();
+    this.eventCounter = 0;
+  }
+};
+
+// src/economy/CreatorRevenueAggregator.ts
+var CreatorRevenueAggregator = class {
+  config;
+  events = /* @__PURE__ */ new Map();
+  payouts = [];
+  eventCounter = 0;
+  constructor(config) {
+    this.config = {
+      platformFeeRate: config?.platformFeeRate ?? 0.15,
+      minPayoutThreshold: config?.minPayoutThreshold ?? 5e6,
+      maxEventsPerCreator: config?.maxEventsPerCreator ?? 1e4,
+      telemetry: config?.telemetry
+    };
+  }
+  // ===========================================================================
+  // RECORDING
+  // ===========================================================================
+  /**
+   * Record a revenue event.
+   */
+  recordRevenue(creatorId, pluginId, grossAmount, payerId, ledgerEntryId) {
+    const platformFee = Math.floor(grossAmount * this.config.platformFeeRate);
+    const netAmount = grossAmount - platformFee;
+    const event = {
+      id: `rev-${++this.eventCounter}`,
+      creatorId,
+      pluginId,
+      grossAmount,
+      platformFee,
+      netAmount,
+      timestamp: Date.now(),
+      payerId,
+      ledgerEntryId
+    };
+    const creatorEvents = this.events.get(creatorId) ?? [];
+    creatorEvents.push(event);
+    if (creatorEvents.length > this.config.maxEventsPerCreator) {
+      creatorEvents.splice(0, creatorEvents.length - this.config.maxEventsPerCreator);
+    }
+    this.events.set(creatorId, creatorEvents);
+    this.emitTelemetry("revenue_recorded", {
+      creatorId,
+      pluginId,
+      grossAmount,
+      netAmount,
+      payerId
+    });
+    return event;
+  }
+  // ===========================================================================
+  // AGGREGATION
+  // ===========================================================================
+  /**
+   * Get earnings for a specific creator.
+   */
+  getCreatorEarnings(creatorId, period = "monthly") {
+    const events = this.events.get(creatorId) ?? [];
+    const { start, end } = this.getPeriodBounds(period);
+    const filtered = events.filter((e) => e.timestamp >= start && e.timestamp < end);
+    const byPlugin = /* @__PURE__ */ new Map();
+    let totalGross = 0;
+    let totalFees = 0;
+    let totalNet = 0;
+    for (const event of filtered) {
+      totalGross += event.grossAmount;
+      totalFees += event.platformFee;
+      totalNet += event.netAmount;
+      let pluginRev = byPlugin.get(event.pluginId);
+      if (!pluginRev) {
+        pluginRev = {
+          pluginId: event.pluginId,
+          grossAmount: 0,
+          platformFee: 0,
+          netAmount: 0,
+          eventCount: 0,
+          uniquePayers: /* @__PURE__ */ new Set()
+        };
+        byPlugin.set(event.pluginId, pluginRev);
+      }
+      pluginRev.grossAmount += event.grossAmount;
+      pluginRev.platformFee += event.platformFee;
+      pluginRev.netAmount += event.netAmount;
+      pluginRev.eventCount++;
+      pluginRev.uniquePayers.add(event.payerId);
+    }
+    return {
+      creatorId,
+      totalGross,
+      totalFees,
+      totalNet,
+      byPlugin,
+      eventCount: filtered.length,
+      periodStart: new Date(start).toISOString(),
+      periodEnd: new Date(end).toISOString()
+    };
+  }
+  /**
+   * Get top creators by revenue.
+   */
+  getTopCreators(period = "monthly", limit = 10) {
+    const results = [];
+    for (const creatorId of this.events.keys()) {
+      const earnings = this.getCreatorEarnings(creatorId, period);
+      results.push({
+        creatorId,
+        totalNet: earnings.totalNet,
+        eventCount: earnings.eventCount
+      });
+    }
+    return results.sort((a, b) => b.totalNet - a.totalNet).slice(0, limit);
+  }
+  /**
+   * Get platform revenue (total fees collected).
+   */
+  getPlatformRevenue(period = "monthly") {
+    let totalFees = 0;
+    let totalGross = 0;
+    let creatorCount = 0;
+    for (const creatorId of this.events.keys()) {
+      const earnings = this.getCreatorEarnings(creatorId, period);
+      if (earnings.eventCount > 0) {
+        totalFees += earnings.totalFees;
+        totalGross += earnings.totalGross;
+        creatorCount++;
+      }
+    }
+    return { totalFees, totalGross, creatorCount };
+  }
+  // ===========================================================================
+  // PAYOUTS
+  // ===========================================================================
+  /**
+   * Get creators eligible for payout (net earnings >= threshold).
+   */
+  getPayoutEligible(period = "monthly") {
+    const eligible = [];
+    for (const creatorId of this.events.keys()) {
+      const earnings = this.getCreatorEarnings(creatorId, period);
+      const previousPayouts = this.getCreatorPayouts(creatorId, period);
+      const alreadyPaid = previousPayouts.reduce(
+        (sum, p) => sum + (p.status === "completed" ? p.amount : 0),
+        0
+      );
+      const unpaid = earnings.totalNet - alreadyPaid;
+      if (unpaid >= this.config.minPayoutThreshold) {
+        eligible.push({ creatorId, amount: unpaid });
+      }
+    }
+    return eligible.sort((a, b) => b.amount - a.amount);
+  }
+  /**
+   * Record a payout to a creator.
+   */
+  recordPayout(creatorId, amount, method, transactionHash) {
+    const now = /* @__PURE__ */ new Date();
+    const { start, end } = this.getPeriodBounds("monthly");
+    const record = {
+      id: `payout-${Date.now()}-${creatorId}`,
+      creatorId,
+      amount,
+      method,
+      transactionHash,
+      paidAt: now.toISOString(),
+      status: transactionHash ? "completed" : "pending",
+      periodStart: new Date(start).toISOString(),
+      periodEnd: new Date(end).toISOString()
+    };
+    this.payouts.push(record);
+    this.emitTelemetry("payout_recorded", {
+      creatorId,
+      amount,
+      method,
+      status: record.status
+    });
+    return record;
+  }
+  /**
+   * Update payout status.
+   */
+  updatePayoutStatus(payoutId, status, transactionHash) {
+    const payout = this.payouts.find((p) => p.id === payoutId);
+    if (!payout) return false;
+    payout.status = status;
+    if (transactionHash) {
+      payout.transactionHash = transactionHash;
+    }
+    return true;
+  }
+  /**
+   * Get payouts for a creator.
+   */
+  getCreatorPayouts(creatorId, period) {
+    let filtered = this.payouts.filter((p) => p.creatorId === creatorId);
+    if (period) {
+      const { start, end } = this.getPeriodBounds(period);
+      filtered = filtered.filter((p) => {
+        const paidAt = new Date(p.paidAt).getTime();
+        return paidAt >= start && paidAt < end;
+      });
+    }
+    return filtered;
+  }
+  /**
+   * Get all payouts.
+   */
+  getAllPayouts() {
+    return [...this.payouts];
+  }
+  // ===========================================================================
+  // QUERIES
+  // ===========================================================================
+  /**
+   * Get all tracked creator IDs.
+   */
+  getCreatorIds() {
+    return [...this.events.keys()];
+  }
+  /**
+   * Get platform fee rate.
+   */
+  getPlatformFeeRate() {
+    return this.config.platformFeeRate;
+  }
+  /**
+   * Set platform fee rate.
+   */
+  setPlatformFeeRate(rate) {
+    if (rate < 0 || rate > 1) throw new Error("Fee rate must be between 0 and 1");
+    this.config.platformFeeRate = rate;
+  }
+  // ===========================================================================
+  // INTERNALS
+  // ===========================================================================
+  getPeriodBounds(period) {
+    const now = /* @__PURE__ */ new Date();
+    switch (period) {
+      case "daily": {
+        const start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        return { start: start.getTime(), end: start.getTime() + 864e5 };
+      }
+      case "weekly": {
+        const dayOfWeek = now.getDay();
+        const start = new Date(now.getFullYear(), now.getMonth(), now.getDate() - dayOfWeek);
+        return { start: start.getTime(), end: start.getTime() + 7 * 864e5 };
+      }
+      case "monthly": {
+        const start = new Date(now.getFullYear(), now.getMonth(), 1);
+        const end = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+        return { start: start.getTime(), end: end.getTime() };
+      }
+      case "all-time":
+        return { start: 0, end: Date.now() + 864e5 };
+    }
+  }
+  emitTelemetry(type, data) {
+    this.config.telemetry?.record({
+      type,
+      severity: "info",
+      agentId: "creator-revenue",
+      data
+    });
+  }
+};
+
+// src/economy/PaymentWebhookService.ts
+function computeHmac(payload, secret) {
+  try {
+    const crypto = __require("crypto");
+    return crypto.createHmac("sha256", secret).update(payload).digest("hex");
+  } catch {
+    let hash = 0;
+    const combined = payload + secret;
+    for (let i = 0; i < combined.length; i++) {
+      const char = combined.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16).padStart(8, "0");
+  }
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return result === 0;
+}
+var PaymentWebhookService = class {
+  config;
+  handlers = /* @__PURE__ */ new Map();
+  processedEvents = /* @__PURE__ */ new Set();
+  retryQueue = [];
+  ledgerUpdateCallback;
+  // Stats
+  stats = {
+    received: 0,
+    verified: 0,
+    processed: 0,
+    failed: 0,
+    retried: 0,
+    rejected: 0,
+    duplicates: 0
+  };
+  constructor(config) {
+    this.config = {
+      secrets: config.secrets,
+      maxAgeMs: config.maxAgeMs ?? 5 * 60 * 1e3,
+      // 5 minutes
+      maxRetries: config.maxRetries ?? 3,
+      retryBackoffMs: config.retryBackoffMs ?? 1e3,
+      telemetry: config.telemetry
+    };
+  }
+  // ===========================================================================
+  // VERIFICATION
+  // ===========================================================================
+  /**
+   * Verify a webhook's HMAC-SHA256 signature.
+   */
+  verifySignature(rawBody, signature, provider) {
+    this.stats.received++;
+    const secret = this.config.secrets[provider];
+    if (!secret) {
+      this.stats.rejected++;
+      return {
+        verified: false,
+        provider,
+        error: `No secret configured for provider: ${provider}`
+      };
+    }
+    const expected = computeHmac(rawBody, secret);
+    const isValid = timingSafeEqual(expected, signature);
+    if (!isValid) {
+      this.stats.rejected++;
+      this.emitTelemetry("webhook_signature_invalid", { provider });
+      return {
+        verified: false,
+        provider,
+        error: "Invalid HMAC-SHA256 signature"
+      };
+    }
+    let payload;
+    try {
+      payload = JSON.parse(rawBody);
+    } catch {
+      this.stats.rejected++;
+      return {
+        verified: false,
+        provider,
+        error: "Invalid JSON payload"
+      };
+    }
+    const eventAge = Date.now() - new Date(payload.timestamp).getTime();
+    if (eventAge > this.config.maxAgeMs) {
+      this.stats.rejected++;
+      return {
+        verified: false,
+        provider,
+        error: `Webhook too old: ${Math.round(eventAge / 1e3)}s (max: ${Math.round(this.config.maxAgeMs / 1e3)}s)`
+      };
+    }
+    this.stats.verified++;
+    this.emitTelemetry("webhook_verified", { provider, eventId: payload.eventId });
+    return {
+      verified: true,
+      provider,
+      payload
+    };
+  }
+  // ===========================================================================
+  // PROCESSING
+  // ===========================================================================
+  /**
+   * Process a verified webhook payload.
+   */
+  async processWebhook(payload) {
+    if (this.processedEvents.has(payload.eventId)) {
+      this.stats.duplicates++;
+      return {
+        success: true,
+        eventId: payload.eventId,
+        type: payload.type
+      };
+    }
+    let updatedEntry;
+    if (payload.ledgerEntryId && this.ledgerUpdateCallback) {
+      try {
+        if (payload.type === "payment.confirmed" || payload.type === "settlement.completed") {
+          this.ledgerUpdateCallback(payload.ledgerEntryId, {
+            settled: true,
+            settlementTx: payload.transactionHash || null
+          });
+        } else if (payload.type === "payment.failed" || payload.type === "settlement.failed") {
+          this.ledgerUpdateCallback(payload.ledgerEntryId, {
+            settled: false,
+            settlementTx: null
+          });
+        }
+      } catch (err) {
+        this.emitTelemetry("webhook_ledger_update_error", {
+          eventId: payload.eventId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    const handlers = this.handlers.get(payload.type) || [];
+    const errors = [];
+    for (const handler of handlers) {
+      try {
+        const result = await handler(payload);
+        if (!result.success && result.error) {
+          errors.push(result.error);
+        }
+        if (result.updatedEntry) {
+          updatedEntry = result.updatedEntry;
+        }
+      } catch (err) {
+        errors.push(err instanceof Error ? err.message : String(err));
+      }
+    }
+    if (errors.length > 0) {
+      this.stats.failed++;
+      this.emitTelemetry("webhook_processing_failed", {
+        eventId: payload.eventId,
+        type: payload.type,
+        errors
+      });
+      this.addToRetryQueue(payload, errors.join("; "));
+      return {
+        success: false,
+        eventId: payload.eventId,
+        type: payload.type,
+        error: errors.join("; ")
+      };
+    }
+    this.processedEvents.add(payload.eventId);
+    if (this.processedEvents.size > 1e4) {
+      const entries = [...this.processedEvents];
+      this.processedEvents = new Set(entries.slice(-5e3));
+    }
+    this.stats.processed++;
+    this.emitTelemetry("webhook_processed", {
+      eventId: payload.eventId,
+      type: payload.type,
+      provider: payload.provider
+    });
+    return {
+      success: true,
+      eventId: payload.eventId,
+      type: payload.type,
+      updatedEntry
+    };
+  }
+  // ===========================================================================
+  // HANDLER REGISTRATION
+  // ===========================================================================
+  /**
+   * Register a handler for a specific webhook event type.
+   */
+  on(eventType, handler) {
+    const existing = this.handlers.get(eventType) || [];
+    existing.push(handler);
+    this.handlers.set(eventType, existing);
+  }
+  /**
+   * Remove a handler for a specific webhook event type.
+   */
+  off(eventType, handler) {
+    const existing = this.handlers.get(eventType) || [];
+    this.handlers.set(
+      eventType,
+      existing.filter((h) => h !== handler)
+    );
+  }
+  /**
+   * Set callback for ledger entry updates.
+   */
+  onLedgerUpdate(callback) {
+    this.ledgerUpdateCallback = callback;
+  }
+  // ===========================================================================
+  // RETRY QUEUE
+  // ===========================================================================
+  /**
+   * Add a failed webhook to the retry queue.
+   */
+  addToRetryQueue(payload, error) {
+    const existing = this.retryQueue.find((r) => r.payload.eventId === payload.eventId);
+    if (existing) {
+      existing.attempts++;
+      existing.lastError = error;
+      existing.nextRetryAt = Date.now() + this.config.retryBackoffMs * Math.pow(2, existing.attempts - 1);
+      return;
+    }
+    if (this.retryQueue.length >= 1e3) {
+      this.retryQueue.shift();
+    }
+    this.retryQueue.push({
+      payload,
+      attempts: 1,
+      nextRetryAt: Date.now() + this.config.retryBackoffMs,
+      lastError: error
+    });
+  }
+  /**
+   * Process retry queue entries that are ready.
+   */
+  async processRetryQueue() {
+    const now = Date.now();
+    const ready = this.retryQueue.filter(
+      (r) => r.nextRetryAt <= now && r.attempts < this.config.maxRetries
+    );
+    let processed = 0;
+    for (const entry of ready) {
+      const result = await this.processWebhook(entry.payload);
+      if (result.success) {
+        const idx = this.retryQueue.indexOf(entry);
+        if (idx >= 0) this.retryQueue.splice(idx, 1);
+        this.stats.retried++;
+        processed++;
+      }
+    }
+    this.retryQueue = this.retryQueue.filter((r) => r.attempts < this.config.maxRetries);
+    return processed;
+  }
+  /**
+   * Get retry queue length.
+   */
+  getRetryQueueLength() {
+    return this.retryQueue.length;
+  }
+  // ===========================================================================
+  // QUERIES
+  // ===========================================================================
+  /**
+   * Check if an event has been processed.
+   */
+  isProcessed(eventId) {
+    return this.processedEvents.has(eventId);
+  }
+  /**
+   * Get comprehensive stats.
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      retryQueueLength: this.retryQueue.length
+    };
+  }
+  /**
+   * Create a webhook signature for testing purposes.
+   */
+  createSignature(rawBody, provider) {
+    const secret = this.config.secrets[provider];
+    if (!secret) throw new Error(`No secret for provider: ${provider}`);
+    return computeHmac(rawBody, secret);
+  }
+  // ===========================================================================
+  // TELEMETRY
+  // ===========================================================================
+  emitTelemetry(type, data) {
+    this.config.telemetry?.record({
+      type,
+      severity: type.includes("error") || type.includes("failed") || type.includes("invalid") ? "error" : "info",
+      agentId: "payment-webhook-service",
+      data
+    });
+  }
+};
+
+// src/economy/SubscriptionManager.ts
+var SubscriptionManager = class {
+  config;
+  subscriptions = /* @__PURE__ */ new Map();
+  plans = /* @__PURE__ */ new Map();
+  renewalCallback;
+  subCounter = 0;
+  constructor(config) {
+    this.config = {
+      gracePeriodDays: config?.gracePeriodDays ?? 3,
+      maxFailedRenewals: config?.maxFailedRenewals ?? 3,
+      telemetry: config?.telemetry
+    };
+  }
+  // ===========================================================================
+  // PLAN MANAGEMENT
+  // ===========================================================================
+  /**
+   * Register a subscription plan.
+   */
+  registerPlan(plan) {
+    this.plans.set(plan.id, { ...plan });
+  }
+  /**
+   * Get a plan by ID.
+   */
+  getPlan(planId) {
+    return this.plans.get(planId);
+  }
+  /**
+   * List all plans.
+   */
+  listPlans() {
+    return [...this.plans.values()];
+  }
+  // ===========================================================================
+  // LIFECYCLE: CREATE
+  // ===========================================================================
+  /**
+   * Create a new subscription.
+   */
+  create(subscriberId, planId, metadata) {
+    const plan = this.plans.get(planId);
+    if (!plan) {
+      throw new Error(`Plan "${planId}" not found`);
+    }
+    const id = `sub-${++this.subCounter}`;
+    const now = /* @__PURE__ */ new Date();
+    const hasTrial = plan.trialDays > 0;
+    const trialEnd = hasTrial ? new Date(now.getTime() + plan.trialDays * 864e5).toISOString() : null;
+    const periodEnd = this.computePeriodEnd(now, plan.interval);
+    const subscription = {
+      id,
+      subscriberId,
+      planId,
+      state: hasTrial ? "trial" : "active",
+      amount: plan.amount,
+      interval: plan.interval,
+      createdAt: now.toISOString(),
+      currentPeriodStart: now.toISOString(),
+      currentPeriodEnd: periodEnd.toISOString(),
+      trialEnd,
+      inTrial: hasTrial,
+      failedRenewals: 0,
+      gracePeriodEnd: null,
+      cancelledAt: null,
+      cancelAtPeriodEnd: false,
+      metadata
+    };
+    this.subscriptions.set(id, subscription);
+    this.emitTelemetry("subscription_created", {
+      subscriptionId: id,
+      subscriberId,
+      planId,
+      state: subscription.state
+    });
+    return subscription;
+  }
+  // ===========================================================================
+  // LIFECYCLE: RENEW
+  // ===========================================================================
+  /**
+   * Attempt to renew a subscription.
+   */
+  async renew(subscriptionId) {
+    const sub = this.requireSubscription(subscriptionId);
+    if (sub.state === "cancelled" || sub.state === "expired") {
+      return {
+        success: false,
+        subscription: sub,
+        error: `Cannot renew ${sub.state} subscription`
+      };
+    }
+    if (sub.inTrial && sub.trialEnd) {
+      const trialEndMs = new Date(sub.trialEnd).getTime();
+      if (Date.now() >= trialEndMs) {
+        sub.inTrial = false;
+        sub.state = "active";
+      }
+    }
+    let paymentSuccess = true;
+    if (this.renewalCallback) {
+      try {
+        paymentSuccess = await this.renewalCallback(subscriptionId, sub.amount);
+      } catch {
+        paymentSuccess = false;
+      }
+    }
+    if (paymentSuccess) {
+      const now = /* @__PURE__ */ new Date();
+      sub.currentPeriodStart = now.toISOString();
+      sub.currentPeriodEnd = this.computePeriodEnd(now, sub.interval).toISOString();
+      sub.state = "active";
+      sub.failedRenewals = 0;
+      sub.gracePeriodEnd = null;
+      if (sub.cancelAtPeriodEnd) {
+        sub.state = "cancelled";
+        sub.cancelledAt = now.toISOString();
+        sub.cancelAtPeriodEnd = false;
+        this.emitTelemetry("subscription_cancelled_at_period_end", { subscriptionId });
+        return { success: true, subscription: sub };
+      }
+      this.emitTelemetry("subscription_renewed", { subscriptionId });
+      return { success: true, subscription: sub };
+    }
+    sub.failedRenewals++;
+    if (sub.failedRenewals >= this.config.maxFailedRenewals) {
+      sub.state = "suspended";
+      this.emitTelemetry("subscription_suspended", {
+        subscriptionId,
+        failedRenewals: sub.failedRenewals
+      });
+      return {
+        success: false,
+        subscription: sub,
+        error: `Subscription suspended after ${sub.failedRenewals} failed renewals`
+      };
+    }
+    sub.state = "past_due";
+    const gracePeriodEnd = new Date(
+      Date.now() + this.config.gracePeriodDays * 864e5
+    ).toISOString();
+    sub.gracePeriodEnd = gracePeriodEnd;
+    this.emitTelemetry("subscription_renewal_failed", {
+      subscriptionId,
+      failedRenewals: sub.failedRenewals,
+      gracePeriodEnd
+    });
+    return {
+      success: false,
+      subscription: sub,
+      error: `Renewal failed (attempt ${sub.failedRenewals}/${this.config.maxFailedRenewals})`,
+      enteredGracePeriod: true
+    };
+  }
+  // ===========================================================================
+  // LIFECYCLE: CANCEL
+  // ===========================================================================
+  /**
+   * Cancel a subscription.
+   * @param immediate If true, cancel immediately; otherwise cancel at period end.
+   */
+  cancel(subscriptionId, immediate = false) {
+    const sub = this.requireSubscription(subscriptionId);
+    if (sub.state === "cancelled" || sub.state === "expired") {
+      throw new Error(`Subscription already ${sub.state}`);
+    }
+    if (immediate) {
+      sub.state = "cancelled";
+      sub.cancelledAt = (/* @__PURE__ */ new Date()).toISOString();
+      sub.cancelAtPeriodEnd = false;
+    } else {
+      sub.cancelAtPeriodEnd = true;
+    }
+    this.emitTelemetry("subscription_cancel_requested", {
+      subscriptionId,
+      immediate
+    });
+    return sub;
+  }
+  // ===========================================================================
+  // LIFECYCLE: SUSPEND / REACTIVATE
+  // ===========================================================================
+  /**
+   * Suspend a subscription (e.g., after payment failures).
+   */
+  suspend(subscriptionId) {
+    const sub = this.requireSubscription(subscriptionId);
+    sub.state = "suspended";
+    this.emitTelemetry("subscription_suspended", { subscriptionId });
+    return sub;
+  }
+  /**
+   * Reactivate a suspended or cancelled subscription.
+   */
+  reactivate(subscriptionId) {
+    const sub = this.requireSubscription(subscriptionId);
+    if (sub.state !== "suspended" && sub.state !== "cancelled" && sub.state !== "past_due") {
+      throw new Error(`Cannot reactivate subscription in state: ${sub.state}`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    sub.state = "active";
+    sub.failedRenewals = 0;
+    sub.gracePeriodEnd = null;
+    sub.cancelledAt = null;
+    sub.cancelAtPeriodEnd = false;
+    sub.currentPeriodStart = now.toISOString();
+    sub.currentPeriodEnd = this.computePeriodEnd(now, sub.interval).toISOString();
+    this.emitTelemetry("subscription_reactivated", { subscriptionId });
+    return sub;
+  }
+  // ===========================================================================
+  // RENEWAL CALLBACK
+  // ===========================================================================
+  /**
+   * Set callback for renewal payment processing.
+   * Should return true if payment succeeded.
+   */
+  onRenewal(callback) {
+    this.renewalCallback = callback;
+  }
+  // ===========================================================================
+  // QUERIES
+  // ===========================================================================
+  /**
+   * Get a subscription by ID.
+   */
+  getSubscription(id) {
+    return this.subscriptions.get(id);
+  }
+  /**
+   * Get all subscriptions for a subscriber.
+   */
+  getSubscriberSubscriptions(subscriberId) {
+    return [...this.subscriptions.values()].filter((s) => s.subscriberId === subscriberId);
+  }
+  /**
+   * Get subscriptions by state.
+   */
+  getByState(state) {
+    return [...this.subscriptions.values()].filter((s) => s.state === state);
+  }
+  /**
+   * Get subscriptions due for renewal.
+   */
+  getDueForRenewal() {
+    const now = Date.now();
+    return [...this.subscriptions.values()].filter((s) => {
+      if (s.state === "cancelled" || s.state === "expired" || s.state === "suspended") {
+        return false;
+      }
+      return new Date(s.currentPeriodEnd).getTime() <= now;
+    });
+  }
+  /**
+   * Get subscriptions in grace period.
+   */
+  getInGracePeriod() {
+    return [...this.subscriptions.values()].filter(
+      (s) => s.state === "past_due" && s.gracePeriodEnd !== null
+    );
+  }
+  /**
+   * Check if grace period has expired for past_due subscriptions.
+   */
+  processExpiredGracePeriods() {
+    const now = Date.now();
+    const expired = [];
+    for (const sub of this.subscriptions.values()) {
+      if (sub.state === "past_due" && sub.gracePeriodEnd) {
+        if (new Date(sub.gracePeriodEnd).getTime() <= now) {
+          sub.state = "suspended";
+          sub.gracePeriodEnd = null;
+          expired.push(sub);
+          this.emitTelemetry("subscription_grace_expired", { subscriptionId: sub.id });
+        }
+      }
+    }
+    return expired;
+  }
+  /**
+   * Get stats.
+   */
+  getStats() {
+    const byState = {};
+    let totalMRR = 0;
+    for (const sub of this.subscriptions.values()) {
+      byState[sub.state] = (byState[sub.state] || 0) + 1;
+      if (sub.state === "active" || sub.state === "trial") {
+        totalMRR += this.normalizeToMonthly(sub.amount, sub.interval);
+      }
+    }
+    return {
+      total: this.subscriptions.size,
+      byState,
+      totalMRR,
+      planCount: this.plans.size
+    };
+  }
+  /**
+   * Total subscription count.
+   */
+  getSubscriptionCount() {
+    return this.subscriptions.size;
+  }
+  // ===========================================================================
+  // INTERNALS
+  // ===========================================================================
+  requireSubscription(id) {
+    const sub = this.subscriptions.get(id);
+    if (!sub) throw new Error(`Subscription "${id}" not found`);
+    return sub;
+  }
+  computePeriodEnd(start, interval) {
+    const end = new Date(start);
+    switch (interval) {
+      case "daily":
+        end.setDate(end.getDate() + 1);
+        break;
+      case "weekly":
+        end.setDate(end.getDate() + 7);
+        break;
+      case "monthly":
+        end.setMonth(end.getMonth() + 1);
+        break;
+      case "yearly":
+        end.setFullYear(end.getFullYear() + 1);
+        break;
+    }
+    return end;
+  }
+  normalizeToMonthly(amount, interval) {
+    switch (interval) {
+      case "daily":
+        return amount * 30;
+      case "weekly":
+        return amount * 4;
+      case "monthly":
+        return amount;
+      case "yearly":
+        return Math.floor(amount / 12);
+    }
+  }
+  emitTelemetry(type, data) {
+    this.config.telemetry?.record({
+      type,
+      severity: type.includes("failed") || type.includes("suspended") ? "warning" : "info",
+      agentId: "subscription-manager",
+      data
+    });
+  }
+};
+
+// src/economy/AgentBudgetEnforcer.ts
+var AgentBudgetEnforcer = class {
+  trackers = /* @__PURE__ */ new Map();
+  config;
+  sessionCounter = 0;
+  constructor(config) {
+    this.config = {
+      defaultBudget: {
+        agentId: "",
+        maxSpend: 1e7,
+        // $10.00 default
+        period: "daily",
+        mode: "soft",
+        warnThreshold: 0.8,
+        circuitBreakerThreshold: 5,
+        ...config?.defaultBudget
+      },
+      circuitBreakerResetMs: config?.circuitBreakerResetMs ?? 6e4,
+      telemetry: config?.telemetry
+    };
+  }
+  // ===========================================================================
+  // BUDGET MANAGEMENT
+  // ===========================================================================
+  /**
+   * Set budget for an agent.
+   */
+  setBudget(budget) {
+    const existing = this.trackers.get(budget.agentId);
+    if (existing) {
+      existing.budget = { ...budget };
+    } else {
+      this.trackers.set(budget.agentId, {
+        budget: { ...budget },
+        spent: 0,
+        requestCount: 0,
+        periodStart: Date.now(),
+        consecutiveFailures: 0,
+        circuitBreakerTrippedAt: null,
+        sessionId: `session-${++this.sessionCounter}`
+      });
+    }
+  }
+  /**
+   * Get budget configuration for an agent.
+   */
+  getBudget(agentId) {
+    return this.trackers.get(agentId)?.budget;
+  }
+  /**
+   * Remove budget for an agent.
+   */
+  removeBudget(agentId) {
+    return this.trackers.delete(agentId);
+  }
+  // ===========================================================================
+  // AUTHORIZATION
+  // ===========================================================================
+  /**
+   * Check if an agent is authorized to spend a given amount.
+   */
+  authorize(agentId, amount) {
+    const tracker = this.getOrCreateTracker(agentId);
+    this.checkPeriodReset(tracker);
+    const state = this.buildState(tracker);
+    if (state.circuitBreaker.isOpen) {
+      if (tracker.circuitBreakerTrippedAt) {
+        const elapsed = Date.now() - tracker.circuitBreakerTrippedAt;
+        if (elapsed >= this.config.circuitBreakerResetMs) {
+          tracker.consecutiveFailures = 0;
+          tracker.circuitBreakerTrippedAt = null;
+        } else {
+          this.emitTelemetry("budget_circuit_breaker_blocked", { agentId, amount });
+          return {
+            authorized: false,
+            reason: `Circuit breaker open: ${tracker.consecutiveFailures} consecutive failures. Resets in ${Math.ceil((this.config.circuitBreakerResetMs - elapsed) / 1e3)}s`,
+            state: this.buildState(tracker)
+          };
+        }
+      }
+    }
+    const wouldExceed = tracker.spent + amount > tracker.budget.maxSpend;
+    const warnThreshold = tracker.budget.warnThreshold ?? 0.8;
+    const atWarningLevel = (tracker.spent + amount) / tracker.budget.maxSpend >= warnThreshold;
+    if (wouldExceed) {
+      switch (tracker.budget.mode) {
+        case "hard":
+          this.emitTelemetry("budget_hard_denied", {
+            agentId,
+            amount,
+            spent: tracker.spent,
+            limit: tracker.budget.maxSpend
+          });
+          return {
+            authorized: false,
+            reason: `Budget exhausted (hard limit): spent ${tracker.spent} + ${amount} > limit ${tracker.budget.maxSpend}`,
+            state: this.buildState(tracker)
+          };
+        case "soft":
+          this.emitTelemetry("budget_soft_denied", { agentId, amount, spent: tracker.spent });
+          return {
+            authorized: false,
+            reason: `Budget exhausted (soft limit): spent ${tracker.spent} + ${amount} > limit ${tracker.budget.maxSpend}`,
+            state: this.buildState(tracker)
+          };
+        case "warn":
+          this.emitTelemetry("budget_warn_overspend", { agentId, amount });
+          return {
+            authorized: true,
+            state: this.buildState(tracker),
+            warning: true,
+            warningMessage: `Budget exceeded: spent ${tracker.spent} + ${amount} > limit ${tracker.budget.maxSpend}`
+          };
+      }
+    }
+    if (atWarningLevel && !wouldExceed) {
+      return {
+        authorized: true,
+        state: this.buildState(tracker),
+        warning: true,
+        warningMessage: `Approaching budget limit: ${Math.round((tracker.spent + amount) / tracker.budget.maxSpend * 100)}% used`
+      };
+    }
+    return {
+      authorized: true,
+      state: this.buildState(tracker)
+    };
+  }
+  /**
+   * Record a spend. Call after a successful tool execution.
+   */
+  recordSpend(agentId, amount) {
+    const tracker = this.getOrCreateTracker(agentId);
+    this.checkPeriodReset(tracker);
+    tracker.spent += amount;
+    tracker.requestCount++;
+    tracker.consecutiveFailures = 0;
+    this.emitTelemetry("budget_spend_recorded", { agentId, amount, totalSpent: tracker.spent });
+  }
+  /**
+   * Record a failure. Increments circuit breaker counter.
+   */
+  recordFailure(agentId) {
+    const tracker = this.getOrCreateTracker(agentId);
+    tracker.consecutiveFailures++;
+    const threshold = tracker.budget.circuitBreakerThreshold ?? 5;
+    if (tracker.consecutiveFailures >= threshold && !tracker.circuitBreakerTrippedAt) {
+      tracker.circuitBreakerTrippedAt = Date.now();
+      this.emitTelemetry("budget_circuit_breaker_tripped", {
+        agentId,
+        failures: tracker.consecutiveFailures,
+        threshold
+      });
+    }
+  }
+  // ===========================================================================
+  // QUERIES
+  // ===========================================================================
+  /**
+   * Get current budget state for an agent.
+   */
+  getState(agentId) {
+    const tracker = this.trackers.get(agentId);
+    if (!tracker) return void 0;
+    this.checkPeriodReset(tracker);
+    return this.buildState(tracker);
+  }
+  /**
+   * Get all agent budget states.
+   */
+  getAllStates() {
+    return [...this.trackers.keys()].map((id) => this.getState(id)).filter(Boolean);
+  }
+  /**
+   * Get agents that are over budget.
+   */
+  getOverBudgetAgents() {
+    return this.getAllStates().filter((s) => s.exhausted || s.circuitBreaker.isOpen);
+  }
+  /**
+   * Reset an agent's period spending.
+   */
+  resetSpending(agentId) {
+    const tracker = this.trackers.get(agentId);
+    if (tracker) {
+      tracker.spent = 0;
+      tracker.requestCount = 0;
+      tracker.periodStart = Date.now();
+      tracker.consecutiveFailures = 0;
+      tracker.circuitBreakerTrippedAt = null;
+      tracker.sessionId = `session-${++this.sessionCounter}`;
+    }
+  }
+  /**
+   * Reset circuit breaker for an agent.
+   */
+  resetCircuitBreaker(agentId) {
+    const tracker = this.trackers.get(agentId);
+    if (tracker) {
+      tracker.consecutiveFailures = 0;
+      tracker.circuitBreakerTrippedAt = null;
+    }
+  }
+  // ===========================================================================
+  // INTERNALS
+  // ===========================================================================
+  getOrCreateTracker(agentId) {
+    let tracker = this.trackers.get(agentId);
+    if (!tracker) {
+      tracker = {
+        budget: { ...this.config.defaultBudget, agentId },
+        spent: 0,
+        requestCount: 0,
+        periodStart: Date.now(),
+        consecutiveFailures: 0,
+        circuitBreakerTrippedAt: null,
+        sessionId: `session-${++this.sessionCounter}`
+      };
+      this.trackers.set(agentId, tracker);
+    }
+    return tracker;
+  }
+  checkPeriodReset(tracker) {
+    const now = Date.now();
+    const elapsed = now - tracker.periodStart;
+    let shouldReset = false;
+    switch (tracker.budget.period) {
+      case "per-request":
+        shouldReset = tracker.requestCount > 0;
+        break;
+      case "per-session":
+        break;
+      case "daily":
+        shouldReset = elapsed >= 864e5;
+        break;
+      case "monthly":
+        shouldReset = elapsed >= 30 * 864e5;
+        break;
+    }
+    if (shouldReset) {
+      tracker.spent = 0;
+      tracker.requestCount = 0;
+      tracker.periodStart = now;
+      tracker.sessionId = `session-${++this.sessionCounter}`;
+    }
+  }
+  buildState(tracker) {
+    const remaining = Math.max(0, tracker.budget.maxSpend - tracker.spent);
+    const warnThreshold = tracker.budget.warnThreshold ?? 0.8;
+    const cbThreshold = tracker.budget.circuitBreakerThreshold ?? 5;
+    return {
+      agentId: tracker.budget.agentId,
+      spent: tracker.spent,
+      limit: tracker.budget.maxSpend,
+      remaining,
+      exhausted: remaining === 0,
+      warning: tracker.spent / tracker.budget.maxSpend >= warnThreshold,
+      mode: tracker.budget.mode,
+      period: tracker.budget.period,
+      periodStart: new Date(tracker.periodStart).toISOString(),
+      requestCount: tracker.requestCount,
+      circuitBreaker: {
+        isOpen: tracker.circuitBreakerTrippedAt !== null && Date.now() - tracker.circuitBreakerTrippedAt < this.config.circuitBreakerResetMs,
+        consecutiveFailures: tracker.consecutiveFailures,
+        threshold: cbThreshold,
+        trippedAt: tracker.circuitBreakerTrippedAt ? new Date(tracker.circuitBreakerTrippedAt).toISOString() : null,
+        resetAt: tracker.circuitBreakerTrippedAt ? new Date(
+          tracker.circuitBreakerTrippedAt + this.config.circuitBreakerResetMs
+        ).toISOString() : null
+      }
+    };
+  }
+  emitTelemetry(type, data) {
+    this.config.telemetry?.record({
+      type,
+      severity: type.includes("denied") || type.includes("tripped") ? "warning" : "info",
+      agentId: data?.agentId || "budget-enforcer",
+      data
+    });
+  }
+};
+
+// src/economy/_core-stubs.ts
+var PLATFORM_BUDGETS = {
+  quest3: {
+    particles: 5e3,
+    physicsBodies: 200,
+    audioSources: 16,
+    meshInstances: 500,
+    gaussians: 18e4,
+    shaderPasses: 4,
+    networkMsgs: 60,
+    agentCount: 10,
+    memoryMB: 512,
+    gpuDrawCalls: 200
+  },
+  "desktop-vr": {
+    particles: 5e4,
+    physicsBodies: 2e3,
+    audioSources: 64,
+    meshInstances: 5e3,
+    gaussians: 2e6,
+    shaderPasses: 16,
+    networkMsgs: 200,
+    agentCount: 50,
+    memoryMB: 4096,
+    gpuDrawCalls: 2e3
+  },
+  webgpu: {
+    particles: 2e4,
+    physicsBodies: 500,
+    audioSources: 32,
+    meshInstances: 2e3,
+    gaussians: 5e5,
+    shaderPasses: 8,
+    networkMsgs: 100,
+    agentCount: 20,
+    memoryMB: 1024,
+    gpuDrawCalls: 500
+  },
+  "mobile-ar": {
+    particles: 2e3,
+    physicsBodies: 50,
+    audioSources: 8,
+    meshInstances: 200,
+    gaussians: 1e5,
+    shaderPasses: 2,
+    networkMsgs: 30,
+    agentCount: 5,
+    memoryMB: 256,
+    gpuDrawCalls: 100
+  }
+};
+var TRAIT_RESOURCE_COSTS = {
+  "@mesh": { meshInstances: 1, gpuDrawCalls: 1 },
+  "@material": { shaderPasses: 1, gpuDrawCalls: 1, memoryMB: 0.5 },
+  "@shader": { shaderPasses: 1, gpuDrawCalls: 1 },
+  "@advanced_pbr": { shaderPasses: 2, gpuDrawCalls: 1, memoryMB: 1 },
+  "@advanced_lighting": { gpuDrawCalls: 2, shaderPasses: 1 },
+  "@advanced_texturing": { memoryMB: 2, gpuDrawCalls: 1 },
+  "@light": { gpuDrawCalls: 1, shaderPasses: 1 },
+  "@lighting": { gpuDrawCalls: 2, shaderPasses: 1 },
+  "@global_illumination": { gpuDrawCalls: 4, shaderPasses: 3, memoryMB: 8 },
+  "@ray_tracing": { gpuDrawCalls: 8, shaderPasses: 4, memoryMB: 16 },
+  "@screen_space_effects": { shaderPasses: 2, gpuDrawCalls: 2 },
+  "@subsurface_scattering": { shaderPasses: 2, gpuDrawCalls: 1 },
+  "@rendering": { meshInstances: 1, gpuDrawCalls: 1, memoryMB: 1 },
+  "@render_network": { gpuDrawCalls: 2, networkMsgs: 5, memoryMB: 4 },
+  "@particle": { particles: 100, gpuDrawCalls: 1, memoryMB: 2 },
+  "@vfx": { particles: 200, shaderPasses: 1, gpuDrawCalls: 2 },
+  "@volumetric": { gpuDrawCalls: 3, shaderPasses: 2, memoryMB: 4 },
+  "@volumetric_window": { gpuDrawCalls: 2, memoryMB: 2 },
+  "@gaussian": { gaussians: 1e5, memoryMB: 10 },
+  "@gaussian_splat": { gaussians: 1e5, memoryMB: 10 },
+  "@multiview_gaussian_renderer": { gaussians: 2e5, memoryMB: 20, gpuDrawCalls: 4 },
+  "@nerf": { gpuDrawCalls: 4, memoryMB: 16, shaderPasses: 2 },
+  "@physics": { physicsBodies: 1 },
+  "@rigidbody": { physicsBodies: 1 },
+  "@collider": { physicsBodies: 1 },
+  "@joint": { physicsBodies: 2 },
+  "@trigger": { physicsBodies: 1 },
+  "@fluid_simulation": { particles: 500, physicsBodies: 10, memoryMB: 8 },
+  "@advanced_cloth": { particles: 200, physicsBodies: 5, memoryMB: 4 },
+  "@granular_material": { particles: 300, physicsBodies: 8, memoryMB: 6 },
+  "@voronoi_fracture": { physicsBodies: 20, meshInstances: 20, memoryMB: 4 },
+  "@audio": { audioSources: 1 },
+  "@spatial_audio": { audioSources: 1 },
+  "@environmental_audio": { audioSources: 4, memoryMB: 2 },
+  "@voice_mesh": { audioSources: 1, networkMsgs: 10 },
+  "@voice_input": { audioSources: 1, memoryMB: 1 },
+  "@voice_output": { audioSources: 1, memoryMB: 1 },
+  "@lip_sync": { memoryMB: 2, gpuDrawCalls: 1 },
+  "@ambisonics": { audioSources: 4, memoryMB: 4 },
+  "@networked": { networkMsgs: 1 },
+  "@networked_avatar": { networkMsgs: 10, meshInstances: 1, memoryMB: 2 },
+  "@lobby": { networkMsgs: 5, memoryMB: 2 },
+  "@mqtt_sink": { networkMsgs: 5 },
+  "@mqtt_source": { networkMsgs: 5 },
+  "@sync_tier": { networkMsgs: 2 },
+  "@crdt_room": { networkMsgs: 10, memoryMB: 4 },
+  "@shareplay": { networkMsgs: 5, memoryMB: 2 },
+  "@agent": { agentCount: 1, memoryMB: 5 },
+  "@npc": { agentCount: 1, memoryMB: 3, physicsBodies: 1 },
+  "@npc_ai": { agentCount: 1, memoryMB: 8 },
+  "@ai_npc_brain": { agentCount: 1, memoryMB: 10 },
+  "@multi_agent": { agentCount: 3, memoryMB: 15 },
+  "@agent_discovery": { agentCount: 1, memoryMB: 2 },
+  "@neural_animation": { memoryMB: 8, gpuDrawCalls: 2 },
+  "@neural_forge": { memoryMB: 16, agentCount: 1 },
+  "@local_llm": { memoryMB: 32, agentCount: 1 },
+  "@rag_knowledge": { memoryMB: 8 },
+  "@embedding_search": { memoryMB: 4 },
+  "@vector_db": { memoryMB: 8 },
+  "@stable_diffusion": { memoryMB: 32, gpuDrawCalls: 1 },
+  "@diffusion_realtime": { memoryMB: 16, gpuDrawCalls: 2 },
+  "@vision": { memoryMB: 4 },
+  "@pose_estimation": { memoryMB: 4, agentCount: 1 },
+  "@object_tracking": { memoryMB: 4 },
+  "@hand_mesh_ai": { memoryMB: 4, gpuDrawCalls: 1 },
+  "@animation": { gpuDrawCalls: 1, memoryMB: 2 },
+  "@skeleton": { gpuDrawCalls: 1, memoryMB: 1 },
+  "@ik": { memoryMB: 1 },
+  "@morph": { gpuDrawCalls: 1, memoryMB: 1 },
+  "@character": { physicsBodies: 1, meshInstances: 1, gpuDrawCalls: 2, memoryMB: 4 },
+  "@emotion_directive": { memoryMB: 1 },
+  "@dialog": { memoryMB: 2 },
+  "@scene_reconstruction": { meshInstances: 10, memoryMB: 8, gpuDrawCalls: 5 },
+  "@realitykit_mesh": { meshInstances: 5, memoryMB: 4, gpuDrawCalls: 3 },
+  "@openxr_hal": { memoryMB: 2 },
+  "@spatial_navigation": { memoryMB: 2 },
+  "@spatial_persona": { meshInstances: 1, memoryMB: 2, networkMsgs: 5 },
+  "@spatial_awareness": { memoryMB: 2 },
+  "@orbital": { physicsBodies: 1, memoryMB: 1 },
+  "@grabbable": { physicsBodies: 1 },
+  "@pressable": { physicsBodies: 1 },
+  "@slidable": { physicsBodies: 1 },
+  "@wot_thing": { networkMsgs: 2, memoryMB: 1 },
+  "@urdf_robot": { physicsBodies: 10, meshInstances: 10, memoryMB: 4 },
+  "@computer_use": { memoryMB: 4 },
+  "@pid_controller": { memoryMB: 0.5 },
+  "@biofeedback": { memoryMB: 1 }
+};
+
+// src/economy/UnifiedBudgetOptimizer.ts
+var DEFAULT_TRAIT_UTILITIES = {
+  // ── Core (required, high utility) ──
+  "@mesh": { baseUtility: 100, category: "visual", required: true, minLODLevel: 0 },
+  "@material": { baseUtility: 95, category: "visual", required: true, minLODLevel: 0 },
+  "@physics": { baseUtility: 90, category: "physics", required: true, minLODLevel: 0 },
+  "@rigidbody": { baseUtility: 90, category: "physics", required: true, minLODLevel: 0 },
+  "@collider": { baseUtility: 88, category: "physics", required: true, minLODLevel: 0 },
+  "@rendering": { baseUtility: 95, category: "visual", required: true, minLODLevel: 0 },
+  "@character": { baseUtility: 92, category: "visual", required: true, minLODLevel: 0 },
+  "@networked": { baseUtility: 85, category: "network", required: true, minLODLevel: 0 },
+  // C6 Layer 2 re-score: @agent was hand-assigned at 85 (required). Data-derived
+  // analysis shows agents are a luxury in most rendering scenes — only ~35% of
+  // compositions use @agent, and it consumes 5MB memory. Downgraded to non-required
+  // enhancement. Scenes that genuinely need agents can override via custom utilities.
+  "@agent": { baseUtility: 35, category: "ai", required: false, minLODLevel: 2 },
+  // ── Important quality (droppable at high LOD) ──
+  "@light": { baseUtility: 80, category: "visual", required: false, minLODLevel: 3 },
+  "@lighting": { baseUtility: 78, category: "visual", required: false, minLODLevel: 3 },
+  "@shader": { baseUtility: 75, category: "visual", required: false, minLODLevel: 2 },
+  "@advanced_pbr": { baseUtility: 72, category: "visual", required: false, minLODLevel: 2 },
+  "@particle": { baseUtility: 70, category: "visual", required: false, minLODLevel: 2 },
+  "@audio": { baseUtility: 75, category: "audio", required: false, minLODLevel: 3 },
+  "@spatial_audio": { baseUtility: 72, category: "audio", required: false, minLODLevel: 2 },
+  "@animation": { baseUtility: 78, category: "visual", required: false, minLODLevel: 3 },
+  "@skeleton": { baseUtility: 76, category: "visual", required: false, minLODLevel: 3 },
+  // ── Enhancement (drop at medium LOD) ──
+  "@vfx": { baseUtility: 60, category: "visual", required: false, minLODLevel: 2 },
+  "@volumetric": { baseUtility: 55, category: "visual", required: false, minLODLevel: 2 },
+  "@advanced_lighting": { baseUtility: 58, category: "visual", required: false, minLODLevel: 2 },
+  "@advanced_texturing": { baseUtility: 56, category: "visual", required: false, minLODLevel: 2 },
+  "@screen_space_effects": { baseUtility: 52, category: "visual", required: false, minLODLevel: 2 },
+  "@environmental_audio": { baseUtility: 55, category: "audio", required: false, minLODLevel: 2 },
+  "@npc": { baseUtility: 65, category: "ai", required: false, minLODLevel: 3 },
+  "@npc_ai": { baseUtility: 62, category: "ai", required: false, minLODLevel: 3 },
+  "@fluid_simulation": { baseUtility: 50, category: "physics", required: false, minLODLevel: 1 },
+  "@advanced_cloth": { baseUtility: 48, category: "physics", required: false, minLODLevel: 1 },
+  "@joint": { baseUtility: 65, category: "physics", required: false, minLODLevel: 3 },
+  // ── Nice-to-have (drop early) ──
+  "@subsurface_scattering": {
+    baseUtility: 38,
+    category: "visual",
+    required: false,
+    minLODLevel: 1
+  },
+  "@ambisonics": { baseUtility: 35, category: "audio", required: false, minLODLevel: 1 },
+  "@voronoi_fracture": { baseUtility: 40, category: "physics", required: false, minLODLevel: 1 },
+  "@granular_material": { baseUtility: 38, category: "physics", required: false, minLODLevel: 1 },
+  "@lip_sync": { baseUtility: 42, category: "visual", required: false, minLODLevel: 1 },
+  // ── Luxury (drop first) ──
+  "@ray_tracing": { baseUtility: 20, category: "visual", required: false, minLODLevel: 1 },
+  "@global_illumination": { baseUtility: 22, category: "visual", required: false, minLODLevel: 1 },
+  "@nerf": { baseUtility: 18, category: "visual", required: false, minLODLevel: 1 },
+  "@multiview_gaussian_renderer": {
+    baseUtility: 25,
+    category: "visual",
+    required: false,
+    minLODLevel: 1
+  },
+  // C6 Layer 2 re-score: @gaussian/@gaussian_splat were hand-assigned at 65.
+  // Data-derived analysis: 100K gaussians on Quest 3 = 55% of total GPU budget,
+  // making the value/cost ratio much lower than hand-scores suggested.
+  // Downgraded by 45 points to reflect actual GPU cost relative to utility.
+  "@gaussian": { baseUtility: 20, category: "visual", required: false, minLODLevel: 1 },
+  "@gaussian_splat": { baseUtility: 20, category: "visual", required: false, minLODLevel: 1 },
+  "@stable_diffusion": { baseUtility: 15, category: "ai", required: false, minLODLevel: 1 },
+  "@diffusion_realtime": { baseUtility: 18, category: "ai", required: false, minLODLevel: 1 },
+  "@local_llm": { baseUtility: 30, category: "ai", required: false, minLODLevel: 1 }
+};
+var PLATFORM_LOD_SCALING = {
+  quest3: [1, 0.6, 0.3, 0.12, 0.04],
+  // Aggressive — tight budget
+  "mobile-ar": [1, 0.5, 0.2, 0.08, 0.02],
+  // Most aggressive — tightest budget
+  webgpu: [1, 0.7, 0.4, 0.18, 0.06],
+  // Moderate — matches default
+  "desktop-vr": [1, 0.85, 0.6, 0.3, 0.1],
+  // Gentle — plenty of headroom
+  visionos: [1, 0.8, 0.5, 0.25, 0.08]
+  // Moderate-gentle — good hardware
+};
+var DEFAULT_COST_FLOOR = {
+  perGaussian: 0.01,
+  // 10K gaussians = $0.10 minimum
+  perDrawCall: 1e3,
+  // $0.001 per draw call
+  perMemoryMB: 5e3,
+  // $0.005 per MB
+  perParticle: 0.1,
+  // 1000 particles = $0.10 minimum
+  perPhysicsBody: 500,
+  // $0.0005 per body
+  baseFee: 1e5
+  // $0.10 base fee on all marketplace traits
+};
+var DEFAULT_LOD_SCALING = [1, 0.7, 0.4, 0.18, 0.06];
+var UnifiedBudgetOptimizer = class {
+  platform;
+  costFloor;
+  traitUtilities;
+  lodScaling;
+  economicBudget;
+  economicSpent;
+  constructor(config) {
+    this.platform = config.platform;
+    this.costFloor = config.costFloor;
+    this.lodScaling = config.lodScaling ?? PLATFORM_LOD_SCALING[config.platform] ?? DEFAULT_LOD_SCALING;
+    this.economicBudget = config.economicBudget ?? 0;
+    this.economicSpent = config.economicSpent ?? 0;
+    this.traitUtilities = /* @__PURE__ */ new Map();
+    for (const [trait, util] of Object.entries(DEFAULT_TRAIT_UTILITIES)) {
+      this.traitUtilities.set(trait, { trait, ...util });
+    }
+    if (config.traitUtilities) {
+      for (const [trait, util] of config.traitUtilities) {
+        this.traitUtilities.set(trait, util);
+      }
+    }
+  }
+  // ===========================================================================
+  // CORE: Equimarginal Allocation
+  // ===========================================================================
+  /**
+   * Allocate traits across a resource budget using the equimarginal principle.
+   * Instead of greedily dropping the deepest LOD first, this sorts by value/cost
+   * ratio and drops traits with the lowest marginal utility first.
+   *
+   * @param nodes - Resource usage nodes (traits + counts)
+   * @param maxLOD - Maximum LOD level to consider (default: 4)
+   * @returns Allocation decisions for each trait
+   */
+  allocate(nodes, maxLOD = 4) {
+    const limits = PLATFORM_BUDGETS[this.platform];
+    if (!limits) {
+      return this.flattenToAllocations(nodes, 0);
+    }
+    const allocations = this.flattenToAllocations(nodes, 0);
+    let pressure = this.computeResourcePressure(allocations, limits);
+    if (pressure.maxPressure <= 1) {
+      return allocations;
+    }
+    for (let lod = 1; lod <= maxLOD && pressure.maxPressure > 1; lod++) {
+      const candidates = allocations.filter((a) => a.included && !this.isRequired(a.trait) && this.canDropAtLOD(a.trait, lod)).sort((a, b) => a.valueCostRatio - b.valueCostRatio);
+      for (const candidate of candidates) {
+        if (pressure.maxPressure <= 1) break;
+        const idx = allocations.findIndex((a) => a.trait === candidate.trait);
+        if (idx >= 0) {
+          allocations[idx] = this.buildAllocation(candidate.trait, lod, 1);
+        }
+        pressure = this.computeResourcePressure(allocations, limits);
+      }
+    }
+    if (pressure.maxPressure > 1) {
+      const excludeable = allocations.filter((a) => a.included && !this.isRequired(a.trait)).sort((a, b) => a.valueCostRatio - b.valueCostRatio);
+      for (const candidate of excludeable) {
+        if (pressure.maxPressure <= 1) break;
+        const idx = allocations.findIndex((a) => a.trait === candidate.trait);
+        if (idx >= 0) {
+          allocations[idx] = {
+            ...allocations[idx],
+            included: false,
+            excludeReason: `Excluded to fit ${this.platform} budget (value/cost ratio: ${candidate.valueCostRatio.toFixed(2)})`
+          };
+        }
+        pressure = this.computeResourcePressure(allocations, limits);
+      }
+    }
+    return allocations;
+  }
+  // ===========================================================================
+  // RESOURCE COST FLOOR PRICING
+  // ===========================================================================
+  /**
+   * Calculate the minimum marketplace price for a trait based on its resource cost.
+   * Prevents economic denial-of-rendering attacks where a cheap marketplace trait
+   * consumes massive GPU resources.
+   *
+   * @param traitName - The trait to price
+   * @param instanceCount - How many instances (default: 1)
+   * @returns Minimum price in USDC base units (6 decimals)
+   */
+  calculateCostFloor(traitName, instanceCount = 1) {
+    const normalized = traitName.startsWith("@") ? traitName : `@${traitName}`;
+    const costs = TRAIT_RESOURCE_COSTS[normalized];
+    if (!costs) return this.costFloor.baseFee;
+    let floor = this.costFloor.baseFee;
+    if (costs.gaussians) floor += costs.gaussians * instanceCount * this.costFloor.perGaussian;
+    if (costs.gpuDrawCalls)
+      floor += costs.gpuDrawCalls * instanceCount * this.costFloor.perDrawCall;
+    if (costs.memoryMB) floor += costs.memoryMB * instanceCount * this.costFloor.perMemoryMB;
+    if (costs.particles) floor += costs.particles * instanceCount * this.costFloor.perParticle;
+    if (costs.physicsBodies)
+      floor += costs.physicsBodies * instanceCount * this.costFloor.perPhysicsBody;
+    return Math.ceil(floor);
+  }
+  /**
+   * Validate that a marketplace listing price meets the resource cost floor.
+   *
+   * @param traitName - The trait being listed
+   * @param listPrice - Proposed listing price (USDC base units)
+   * @param instanceCount - Expected instance count
+   * @returns Validation result
+   */
+  validateMarketplacePrice(traitName, listPrice, instanceCount = 1) {
+    const floor = this.calculateCostFloor(traitName, instanceCount);
+    const deficit = Math.max(0, floor - listPrice);
+    if (listPrice >= floor) {
+      return {
+        valid: true,
+        floor,
+        deficit: 0,
+        message: `Price ${listPrice} meets resource cost floor of ${floor}`
+      };
+    }
+    return {
+      valid: false,
+      floor,
+      deficit,
+      message: `Price ${listPrice} is below resource cost floor of ${floor}. The trait's GPU/memory cost exceeds its economic price by ${deficit} USDC base units.`
+    };
+  }
+  // ===========================================================================
+  // UNIFIED BUDGET STATE
+  // ===========================================================================
+  /**
+   * Get a unified view of budget pressure across economy + rendering.
+   *
+   * @param agentId - Agent identifier
+   * @param nodes - Current resource usage nodes
+   * @param economicSpent - Current economic spend (USDC base units)
+   * @param economicLimit - Economic budget limit (USDC base units)
+   * @returns Unified budget state
+   */
+  getUnifiedState(agentId, nodes, economicSpent, economicLimit) {
+    const spent = economicSpent ?? this.economicSpent;
+    const limit = economicLimit ?? this.economicBudget;
+    const economicPressure = limit > 0 ? spent / limit : 0;
+    const allocations = this.flattenToAllocations(nodes, 0);
+    const limits = PLATFORM_BUDGETS[this.platform] ?? {};
+    const pressure = this.computeResourcePressure(allocations, limits);
+    const overallPressure = Math.max(economicPressure, pressure.maxPressure);
+    let suggestedLOD = 0;
+    if (overallPressure > 0.95) suggestedLOD = 3;
+    else if (overallPressure > 0.8) suggestedLOD = 2;
+    else if (overallPressure > 0.6) suggestedLOD = 1;
+    const shedCandidates = allocations.filter((a) => a.included && !this.isRequired(a.trait)).sort((a, b) => a.valueCostRatio - b.valueCostRatio).slice(0, 10);
+    return {
+      agentId,
+      economicPressure: Math.min(1, economicPressure),
+      resourcePressure: pressure.perCategory,
+      overallPressure: Math.min(1, overallPressure),
+      suggestedLOD,
+      hardLimitBreached: pressure.maxPressure > 1 || economicPressure > 1,
+      shedCandidates
+    };
+  }
+  // ===========================================================================
+  // UTILITY QUERIES
+  // ===========================================================================
+  /**
+   * Get the utility score for a trait.
+   */
+  getUtility(traitName) {
+    const normalized = traitName.startsWith("@") ? traitName : `@${traitName}`;
+    return this.traitUtilities.get(normalized);
+  }
+  /**
+   * Set custom utility for a trait.
+   */
+  setUtility(utility) {
+    this.traitUtilities.set(utility.trait, utility);
+  }
+  /**
+   * Get the total weighted resource cost of a trait at a given LOD level.
+   * Collapses multi-dimensional resource cost into a single scalar
+   * using platform limits as normalization weights.
+   */
+  getWeightedCost(traitName, lodLevel = 0, instanceCount = 1) {
+    const normalized = traitName.startsWith("@") ? traitName : `@${traitName}`;
+    const costs = TRAIT_RESOURCE_COSTS[normalized];
+    if (!costs) return 0;
+    const limits = PLATFORM_BUDGETS[this.platform] ?? {};
+    const scale = this.lodScaling[Math.min(lodLevel, this.lodScaling.length - 1)] ?? 0.05;
+    let weighted = 0;
+    for (const [cat, cost] of Object.entries(costs)) {
+      const limit = limits[cat];
+      if (limit && limit > 0) {
+        weighted += cost * instanceCount * scale / limit;
+      }
+    }
+    return weighted;
+  }
+  /**
+   * Compute value/cost ratio for a trait at a given LOD level.
+   * Higher = more efficient use of resources.
+   */
+  getValueCostRatio(traitName, lodLevel = 0, instanceCount = 1) {
+    const normalized = traitName.startsWith("@") ? traitName : `@${traitName}`;
+    const util = this.traitUtilities.get(normalized);
+    const utility = util?.baseUtility ?? 50;
+    const cost = this.getWeightedCost(normalized, lodLevel, instanceCount);
+    if (cost === 0) return utility * 100;
+    return utility / cost;
+  }
+  // ===========================================================================
+  // INTERNALS
+  // ===========================================================================
+  flattenToAllocations(nodes, lodLevel) {
+    const allocations = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const node of nodes) {
+      for (const trait of node.traits) {
+        const normalized = trait.startsWith("@") ? trait : `@${trait}`;
+        if (seen.has(normalized)) continue;
+        seen.add(normalized);
+        allocations.push(this.buildAllocation(normalized, lodLevel, node.count || 1));
+      }
+    }
+    return allocations;
+  }
+  buildAllocation(trait, lodLevel, instanceCount) {
+    const normalized = trait.startsWith("@") ? trait : `@${trait}`;
+    const costs = TRAIT_RESOURCE_COSTS[normalized] ?? {};
+    const scale = this.lodScaling[Math.min(lodLevel, this.lodScaling.length - 1)] ?? 0.05;
+    const scaledCosts = {};
+    for (const [cat, cost] of Object.entries(costs)) {
+      scaledCosts[cat] = Math.ceil(cost * instanceCount * scale);
+    }
+    const utility = this.traitUtilities.get(normalized)?.baseUtility ?? 50;
+    const weightedCost = this.getWeightedCost(normalized, lodLevel, instanceCount);
+    const valueCostRatio = weightedCost > 0 ? utility / weightedCost : utility * 100;
+    return {
+      trait: normalized,
+      included: true,
+      lodLevel,
+      resourceCost: scaledCosts,
+      economicCost: 0,
+      // Set externally if marketplace pricing applies
+      utility,
+      valueCostRatio
+    };
+  }
+  isRequired(trait) {
+    const normalized = trait.startsWith("@") ? trait : `@${trait}`;
+    return this.traitUtilities.get(normalized)?.required ?? false;
+  }
+  canDropAtLOD(trait, lodLevel) {
+    const normalized = trait.startsWith("@") ? trait : `@${trait}`;
+    const util = this.traitUtilities.get(normalized);
+    if (!util) return lodLevel >= 2;
+    return lodLevel >= util.minLODLevel;
+  }
+  computeResourcePressure(allocations, limits) {
+    const totals = {};
+    for (const alloc of allocations) {
+      if (!alloc.included) continue;
+      for (const [cat, cost] of Object.entries(alloc.resourceCost)) {
+        totals[cat] = (totals[cat] || 0) + cost;
+      }
+    }
+    const perCategory = {};
+    let maxPressure = 0;
+    for (const [cat, limit] of Object.entries(limits)) {
+      const used = totals[cat] || 0;
+      const pressure = limit ? used / limit : 0;
+      perCategory[cat] = pressure;
+      if (pressure > maxPressure) maxPressure = pressure;
+    }
+    return { maxPressure, perCategory };
+  }
+};
+
+// src/economy/UsageMeter.ts
+var UsageMeter = class {
+  config;
+  /** All usage events keyed by agentId */
+  events = /* @__PURE__ */ new Map();
+  /** Free-tier consumption per agent (monthly, USDC base units) */
+  freeTierUsed = /* @__PURE__ */ new Map();
+  /** Current month key for free-tier reset */
+  currentMonthKey;
+  eventCounter = 0;
+  constructor(config) {
+    this.config = {
+      freeTier: config?.freeTier ?? { monthlyAllowance: 5e5 },
+      // $0.50 free
+      defaultToolCost: config?.defaultToolCost ?? 100,
+      // $0.0001
+      toolCosts: config?.toolCosts ?? {},
+      maxEventsPerAgent: config?.maxEventsPerAgent ?? 1e4,
+      telemetry: config?.telemetry
+    };
+    this.currentMonthKey = this.getMonthKey(Date.now());
+  }
+  // ===========================================================================
+  // RECORDING
+  // ===========================================================================
+  /**
+   * Record a tool call usage event.
+   */
+  recordUsage(agentId, toolId, metadata) {
+    this.checkMonthReset();
+    const cost = this.getToolCost(toolId);
+    const freeTierUsed = this.freeTierUsed.get(agentId) ?? 0;
+    const freeTierRemaining = Math.max(0, this.config.freeTier.monthlyAllowance - freeTierUsed);
+    const isFreeTier = cost <= freeTierRemaining;
+    if (isFreeTier) {
+      this.freeTierUsed.set(agentId, freeTierUsed + cost);
+    }
+    const event = {
+      id: `usage-${++this.eventCounter}`,
+      agentId,
+      toolId,
+      cost,
+      timestamp: Date.now(),
+      freeTier: isFreeTier,
+      metadata
+    };
+    const agentEvents = this.events.get(agentId) ?? [];
+    agentEvents.push(event);
+    if (agentEvents.length > this.config.maxEventsPerAgent) {
+      agentEvents.splice(0, agentEvents.length - this.config.maxEventsPerAgent);
+    }
+    this.events.set(agentId, agentEvents);
+    this.emitTelemetry("usage_recorded", {
+      agentId,
+      toolId,
+      cost,
+      freeTier: isFreeTier
+    });
+    return event;
+  }
+  // ===========================================================================
+  // COST LOOKUP
+  // ===========================================================================
+  /**
+   * Get the cost for a specific tool.
+   */
+  getToolCost(toolId) {
+    if (this.config.toolCosts[toolId] !== void 0) {
+      return this.config.toolCosts[toolId];
+    }
+    if (this.config.freeTier.toolOverrides?.[toolId] !== void 0) {
+      return this.config.freeTier.toolOverrides[toolId];
+    }
+    return this.config.defaultToolCost;
+  }
+  /**
+   * Set cost for a specific tool.
+   */
+  setToolCost(toolId, cost) {
+    this.config.toolCosts[toolId] = cost;
+  }
+  // ===========================================================================
+  // AGGREGATION
+  // ===========================================================================
+  /**
+   * Get usage summary for an agent within a time period.
+   */
+  getAgentUsage(agentId, period = "monthly") {
+    const events = this.events.get(agentId) ?? [];
+    const { start, end } = this.getPeriodBounds(period);
+    const filtered = events.filter((e) => e.timestamp >= start && e.timestamp < end);
+    const byTool = /* @__PURE__ */ new Map();
+    const totalAgg = {
+      totalCalls: 0,
+      totalCost: 0,
+      freeTierCalls: 0,
+      freeTierCost: 0,
+      paidCalls: 0,
+      paidCost: 0,
+      periodStart: new Date(start).toISOString(),
+      periodEnd: new Date(end).toISOString()
+    };
+    for (const event of filtered) {
+      let toolAgg = byTool.get(event.toolId);
+      if (!toolAgg) {
+        toolAgg = {
+          totalCalls: 0,
+          totalCost: 0,
+          freeTierCalls: 0,
+          freeTierCost: 0,
+          paidCalls: 0,
+          paidCost: 0,
+          periodStart: new Date(start).toISOString(),
+          periodEnd: new Date(end).toISOString()
+        };
+        byTool.set(event.toolId, toolAgg);
+      }
+      toolAgg.totalCalls++;
+      toolAgg.totalCost += event.cost;
+      totalAgg.totalCalls++;
+      totalAgg.totalCost += event.cost;
+      if (event.freeTier) {
+        toolAgg.freeTierCalls++;
+        toolAgg.freeTierCost += event.cost;
+        totalAgg.freeTierCalls++;
+        totalAgg.freeTierCost += event.cost;
+      } else {
+        toolAgg.paidCalls++;
+        toolAgg.paidCost += event.cost;
+        totalAgg.paidCalls++;
+        totalAgg.paidCost += event.cost;
+      }
+    }
+    const freeTierUsed = this.freeTierUsed.get(agentId) ?? 0;
+    const freeTierRemaining = Math.max(0, this.config.freeTier.monthlyAllowance - freeTierUsed);
+    return {
+      agentId,
+      byTool,
+      total: totalAgg,
+      freeTierRemaining
+    };
+  }
+  /**
+   * Get aggregated usage across all agents for a period.
+   */
+  getGlobalUsage(period = "monthly") {
+    const { start, end } = this.getPeriodBounds(period);
+    const agg = {
+      totalCalls: 0,
+      totalCost: 0,
+      freeTierCalls: 0,
+      freeTierCost: 0,
+      paidCalls: 0,
+      paidCost: 0,
+      periodStart: new Date(start).toISOString(),
+      periodEnd: new Date(end).toISOString()
+    };
+    for (const events of this.events.values()) {
+      for (const event of events) {
+        if (event.timestamp >= start && event.timestamp < end) {
+          agg.totalCalls++;
+          agg.totalCost += event.cost;
+          if (event.freeTier) {
+            agg.freeTierCalls++;
+            agg.freeTierCost += event.cost;
+          } else {
+            agg.paidCalls++;
+            agg.paidCost += event.cost;
+          }
+        }
+      }
+    }
+    return agg;
+  }
+  /**
+   * Get top tools by usage cost.
+   */
+  getTopTools(period = "monthly", limit = 10) {
+    const { start, end } = this.getPeriodBounds(period);
+    const toolMap = /* @__PURE__ */ new Map();
+    for (const events of this.events.values()) {
+      for (const event of events) {
+        if (event.timestamp >= start && event.timestamp < end) {
+          const existing = toolMap.get(event.toolId) ?? { calls: 0, cost: 0 };
+          existing.calls++;
+          existing.cost += event.cost;
+          toolMap.set(event.toolId, existing);
+        }
+      }
+    }
+    return [...toolMap.entries()].map(([toolId, data]) => ({ toolId, ...data })).sort((a, b) => b.cost - a.cost).slice(0, limit);
+  }
+  // ===========================================================================
+  // FREE TIER
+  // ===========================================================================
+  /**
+   * Get free-tier remaining for an agent.
+   */
+  getFreeTierRemaining(agentId) {
+    this.checkMonthReset();
+    const used = this.freeTierUsed.get(agentId) ?? 0;
+    return Math.max(0, this.config.freeTier.monthlyAllowance - used);
+  }
+  /**
+   * Check if an agent has exceeded their free tier.
+   */
+  isOverFreeTier(agentId) {
+    return this.getFreeTierRemaining(agentId) === 0;
+  }
+  // ===========================================================================
+  // QUERIES
+  // ===========================================================================
+  /**
+   * Get all tracked agent IDs.
+   */
+  getTrackedAgents() {
+    return [...this.events.keys()];
+  }
+  /**
+   * Get raw events for an agent.
+   */
+  getEvents(agentId) {
+    return [...this.events.get(agentId) ?? []];
+  }
+  /**
+   * Get total number of recorded events.
+   */
+  getTotalEventCount() {
+    let total = 0;
+    for (const events of this.events.values()) {
+      total += events.length;
+    }
+    return total;
+  }
+  // ===========================================================================
+  // INTERNALS
+  // ===========================================================================
+  getMonthKey(timestamp) {
+    const d = new Date(timestamp);
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
+  }
+  checkMonthReset() {
+    const currentKey = this.getMonthKey(Date.now());
+    if (currentKey !== this.currentMonthKey) {
+      this.freeTierUsed.clear();
+      this.currentMonthKey = currentKey;
+    }
+  }
+  getPeriodBounds(period) {
+    const now = /* @__PURE__ */ new Date();
+    let start;
+    switch (period) {
+      case "hourly":
+        start = new Date(now.getFullYear(), now.getMonth(), now.getDate(), now.getHours());
+        return { start: start.getTime(), end: start.getTime() + 36e5 };
+      case "daily":
+        start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        return { start: start.getTime(), end: start.getTime() + 864e5 };
+      case "monthly":
+        start = new Date(now.getFullYear(), now.getMonth(), 1);
+        const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+        return { start: start.getTime(), end: nextMonth.getTime() };
+    }
+  }
+  emitTelemetry(type, data) {
+    this.config.telemetry?.record({
+      type,
+      severity: "info",
+      agentId: "usage-meter",
+      data
+    });
+  }
+};
+
+// src/economy/BountyManager.ts
+var BountyManager = class {
+  bounties = /* @__PURE__ */ new Map();
+  nextId = 1;
+  config;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  /** Create a bounty for a board task. */
+  createBounty(taskId, reward, createdBy, deadline) {
+    if (reward.amount <= 0) throw new Error("Bounty reward must be positive");
+    const id = `bounty_${String(this.nextId++).padStart(4, "0")}`;
+    const now = Date.now();
+    const bounty = {
+      id,
+      taskId,
+      reward,
+      status: "open",
+      createdBy,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      deadline: deadline ?? (this.config.defaultDeadlineMs ? now + this.config.defaultDeadlineMs : void 0)
+    };
+    this.bounties.set(id, bounty);
+    return bounty;
+  }
+  /** Claim an open bounty. */
+  claimBounty(bountyId, agentId) {
+    const bounty = this.bounties.get(bountyId);
+    if (!bounty) return { success: false, bountyId, error: "Bounty not found" };
+    if (bounty.status !== "open")
+      return { success: false, bountyId, error: `Bounty is ${bounty.status}, not open` };
+    if (bounty.deadline && Date.now() > bounty.deadline) {
+      bounty.status = "expired";
+      return { success: false, bountyId, error: "Bounty has expired" };
+    }
+    bounty.status = "claimed";
+    bounty.claimedBy = agentId;
+    return { success: true, bountyId };
+  }
+  /** Complete a bounty with proof of work and trigger payout. */
+  completeBounty(bountyId, proof) {
+    const bounty = this.bounties.get(bountyId);
+    if (!bounty)
+      return {
+        success: false,
+        bountyId,
+        amount: 0,
+        currency: "credits",
+        settlement: "ledger",
+        error: "Bounty not found"
+      };
+    if (bounty.status !== "claimed")
+      return {
+        success: false,
+        bountyId,
+        amount: 0,
+        currency: bounty.reward.currency,
+        settlement: "ledger",
+        error: `Bounty is ${bounty.status}, not claimed`
+      };
+    if (!proof.summary || proof.summary.trim().length === 0) {
+      return {
+        success: false,
+        bountyId,
+        amount: 0,
+        currency: bounty.reward.currency,
+        settlement: "ledger",
+        error: "Completion proof requires a summary"
+      };
+    }
+    bounty.status = "completed";
+    bounty.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const settlement = bounty.reward.currency === "credits" ? "ledger" : bounty.reward.amount < 0.1 ? "ledger" : "on_chain";
+    return {
+      success: true,
+      bountyId,
+      amount: bounty.reward.amount,
+      currency: bounty.reward.currency,
+      settlement
+    };
+  }
+  /** Get a bounty by ID. */
+  getBounty(bountyId) {
+    return this.bounties.get(bountyId);
+  }
+  /** List bounties, optionally filtered by status. */
+  list(status) {
+    const all = Array.from(this.bounties.values());
+    if (!status) return all;
+    return all.filter((b) => b.status === status);
+  }
+  /** List bounties for a specific task. */
+  byTask(taskId) {
+    return Array.from(this.bounties.values()).filter((b) => b.taskId === taskId);
+  }
+  /** Expire bounties past their deadline. Returns count expired. */
+  expireStale() {
+    const now = Date.now();
+    let count = 0;
+    for (const bounty of this.bounties.values()) {
+      if (bounty.deadline && now > bounty.deadline && bounty.status === "open") {
+        bounty.status = "expired";
+        count++;
+      }
+    }
+    return count;
+  }
+  /** Total open bounty value in a given currency. */
+  totalOpen(currency) {
+    return this.list("open").filter((b) => !currency || b.reward.currency === currency).reduce((sum, b) => sum + b.reward.amount, 0);
+  }
+};
+
+// src/economy/KnowledgeMarketplace.ts
+var DEFAULT_TYPE_WEIGHTS = {
+  wisdom: 0.05,
+  pattern: 0.03,
+  gotcha: 0.02
+};
+var KnowledgeMarketplace = class {
+  listings = /* @__PURE__ */ new Map();
+  purchases = /* @__PURE__ */ new Map();
+  // buyer -> purchases
+  nextId = 1;
+  pricingFactors;
+  constructor(pricingFactors) {
+    this.pricingFactors = pricingFactors ?? {};
+  }
+  /** Estimate the value of a knowledge entry (in USDC). */
+  priceKnowledge(entry) {
+    const weights = this.pricingFactors.typeWeights ?? DEFAULT_TYPE_WEIGHTS;
+    let price = weights[entry.type] ?? 0.02;
+    if (entry.confidence >= 0.8) {
+      price *= this.pricingFactors.confidenceMultiplier ?? 1.5;
+    }
+    if (entry.reuseCount >= 5) {
+      price *= this.pricingFactors.reuseMultiplier ?? 2;
+    }
+    if (entry.queryCount >= 10) {
+      price *= 1.25;
+    }
+    return Math.round(price * 1e4) / 1e4;
+  }
+  /** List a knowledge entry for sale. */
+  sellKnowledge(entry, price, seller, currency = "USDC") {
+    if (price <= 0) return { success: false, listingId: "", error: "Price must be positive" };
+    for (const listing2 of this.listings.values()) {
+      if (listing2.entryId === entry.id && listing2.status === "active") {
+        return { success: false, listingId: listing2.id, error: "Entry already listed" };
+      }
+    }
+    const id = `listing_${String(this.nextId++).padStart(4, "0")}`;
+    const listing = {
+      id,
+      entryId: entry.id,
+      seller,
+      price,
+      currency,
+      status: "active",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      preview: {
+        type: entry.type,
+        domain: entry.domain,
+        snippet: entry.content.slice(0, 100)
+      }
+    };
+    this.listings.set(id, listing);
+    return { success: true, listingId: id };
+  }
+  /** Buy a listed knowledge entry. */
+  buyKnowledge(listingId, buyer) {
+    const listing = this.listings.get(listingId);
+    if (!listing) return { success: false, listingId, buyer, price: 0, error: "Listing not found" };
+    if (listing.status !== "active")
+      return {
+        success: false,
+        listingId,
+        buyer,
+        price: listing.price,
+        error: `Listing is ${listing.status}`
+      };
+    if (listing.seller === buyer)
+      return {
+        success: false,
+        listingId,
+        buyer,
+        price: listing.price,
+        error: "Cannot buy your own listing"
+      };
+    listing.status = "sold";
+    const result = {
+      success: true,
+      listingId,
+      entryId: listing.entryId,
+      buyer,
+      price: listing.price
+    };
+    const buyerPurchases = this.purchases.get(buyer) ?? [];
+    buyerPurchases.push(result);
+    this.purchases.set(buyer, buyerPurchases);
+    return result;
+  }
+  /** Get a listing by ID. */
+  getListing(listingId) {
+    return this.listings.get(listingId);
+  }
+  /** List all active listings. */
+  activeListings() {
+    return Array.from(this.listings.values()).filter((l) => l.status === "active");
+  }
+  /** Get purchase history for a buyer. */
+  purchaseHistory(buyer) {
+    return this.purchases.get(buyer) ?? [];
+  }
+  /** Delist an entry (only the seller can delist). */
+  delist(listingId, seller) {
+    const listing = this.listings.get(listingId);
+    if (!listing || listing.seller !== seller || listing.status !== "active") return false;
+    listing.status = "delisted";
+    return true;
+  }
+  /** Total revenue for a seller across all sold listings. */
+  sellerRevenue(seller) {
+    return Array.from(this.listings.values()).filter((l) => l.seller === seller && l.status === "sold").reduce((sum, l) => sum + l.price, 0);
+  }
+  /** Total marketplace volume (all completed sales). */
+  totalVolume() {
+    return Array.from(this.listings.values()).filter((l) => l.status === "sold").reduce((sum, l) => sum + l.price, 0);
+  }
+};
+
+// src/economy/RevenueSplitter.ts
+var TOTAL_BASIS_POINTS = 1e4;
+var RevenueSplitter = class {
+  recipients;
+  /**
+   * Create a revenue splitter.
+   *
+   * @param recipients — Array of recipients with basis points.
+   *   Basis points must sum to exactly 10000 (100%).
+   * @throws Error if basis points don't sum to 10000 or any are negative.
+   */
+  constructor(recipients) {
+    if (recipients.length === 0) {
+      throw new Error("At least one recipient is required");
+    }
+    const sum = recipients.reduce((acc, r) => acc + r.basisPoints, 0);
+    if (sum !== TOTAL_BASIS_POINTS) {
+      throw new Error(`Basis points must sum to ${TOTAL_BASIS_POINTS} (got ${sum})`);
+    }
+    for (const r of recipients) {
+      if (r.basisPoints < 0) {
+        throw new Error(`Negative basis points for "${r.id}": ${r.basisPoints}`);
+      }
+    }
+    const ids = new Set(recipients.map((r) => r.id));
+    if (ids.size !== recipients.length) {
+      throw new Error("Duplicate recipient IDs");
+    }
+    this.recipients = [...recipients];
+  }
+  /**
+   * Split an amount among recipients.
+   *
+   * Uses bigint arithmetic for exact splitting.
+   * Dust (remainder from integer division) goes to the first recipient.
+   *
+   * @param totalAmount — Total amount to split (in base units, e.g., USDC 6 decimals)
+   * @returns SplitResult with exact shares summing to totalAmount
+   */
+  split(totalAmount) {
+    if (totalAmount < 0n) {
+      throw new Error("Cannot split negative amount");
+    }
+    const shares = /* @__PURE__ */ new Map();
+    const breakdown = [];
+    let allocated = 0n;
+    for (const recipient of this.recipients) {
+      const share = totalAmount * BigInt(recipient.basisPoints) / BigInt(TOTAL_BASIS_POINTS);
+      shares.set(recipient.id, share);
+      allocated += share;
+      breakdown.push({
+        recipientId: recipient.id,
+        basisPoints: recipient.basisPoints,
+        amount: share,
+        percentage: `${(recipient.basisPoints / 100).toFixed(2)}%`
+      });
+    }
+    const dust = totalAmount - allocated;
+    if (dust > 0n) {
+      const firstId = this.recipients[0].id;
+      const current = shares.get(firstId);
+      shares.set(firstId, current + dust);
+      breakdown[0].amount = current + dust;
+    }
+    return { shares, total: totalAmount, dust, breakdown };
+  }
+  /**
+   * Split a numeric amount (convenience wrapper).
+   * Converts to bigint internally.
+   */
+  splitNumeric(totalAmount) {
+    return this.split(BigInt(Math.floor(totalAmount)));
+  }
+  /**
+   * Get the configured recipients.
+   */
+  getRecipients() {
+    return this.recipients;
+  }
+  /**
+   * Validate that a split result sums correctly.
+   */
+  static validate(result) {
+    let sum = 0n;
+    for (const amount of result.shares.values()) {
+      sum += amount;
+    }
+    return sum === result.total;
+  }
+};
+
+// src/economy/InvisibleWallet.ts
+var InvisibleWalletStub = class _InvisibleWalletStub {
+  address;
+  chainId;
+  isTestnet;
+  constructor(address, config = {}) {
+    this.address = address;
+    this.isTestnet = config.testnet ?? false;
+    this.chainId = this.isTestnet ? 84531 : 8453;
+  }
+  /**
+   * Create from an address string (no private key needed for read-only).
+   */
+  static fromAddress(address, config = {}) {
+    const hex = address.startsWith("0x") ? address : `0x${address}`;
+    return new _InvisibleWalletStub(hex, config);
+  }
+  /** Get the wallet address */
+  getAddress() {
+    return this.address;
+  }
+  /** Get chain ID */
+  getChainId() {
+    return this.chainId;
+  }
+  /** Get wallet info */
+  getInfo() {
+    return {
+      address: this.address,
+      chainId: this.chainId,
+      isTestnet: this.isTestnet
+    };
+  }
+};
+export {
+  AgentBudgetEnforcer,
+  BountyManager,
+  CHAIN_IDS,
+  CHAIN_ID_TO_NETWORK,
+  CreatorRevenueAggregator,
+  DEFAULT_COST_FLOOR,
+  DEFAULT_LOD_SCALING,
+  DEFAULT_TRAIT_UTILITIES,
+  InvisibleWalletStub,
+  KnowledgeMarketplace,
+  MICRO_PAYMENT_THRESHOLD,
+  MicroPaymentLedger,
+  PLATFORM_LOD_SCALING,
+  PaymentGateway,
+  PaymentWebhookService,
+  RevenueSplitter,
+  SubscriptionManager,
+  USDC_CONTRACTS,
+  UnifiedBudgetOptimizer,
+  UsageMeter,
+  X402Facilitator,
+  X402_VERSION,
+  creditTraitHandler
+};