@holoscript/framework 6.0.3

package/dist/InvisibleWallet-BB6tFvRA.d.cts

@@ -0,0 +1,1732 @@
+import { a as ProtocolPhase, P as PhaseResult, b as ProtocolCycleResult } from './implementations-D9T3un9D.cjs';
+import { TraitHandler } from '@holoscript/core';
+
+/**
+ * Knowledge Brain — Domain-specific consolidation, excitability, half-lives.
+ *
+ * Absorbed from mcp-server/src/holomesh/types.ts (V9/V11 neuroscience model).
+ * The knowledge store uses these for search ranking, decay, and consolidation.
+ */
+declare const KNOWLEDGE_DOMAINS: readonly ["security", "rendering", "agents", "compilation", "general"];
+type KnowledgeDomain = (typeof KNOWLEDGE_DOMAINS)[number];
+interface DomainConsolidationConfig {
+    hotBufferTTL: number;
+    sleepFrequencyMs: number;
+    maxEntries: number;
+    competitionMetric: 'citation_count' | 'query_frequency' | 'peer_corroboration';
+    downscaleFactor: number;
+    minCorroborations: number;
+}
+declare const DOMAIN_CONSOLIDATION: Record<KnowledgeDomain, DomainConsolidationConfig>;
+declare const DOMAIN_HALF_LIVES: Record<KnowledgeDomain, number>;
+interface HotBufferEntry {
+    id: string;
+    domain: KnowledgeDomain;
+    content: string;
+    type: string;
+    authorDid: string;
+    tags: string[];
+    ingestedAt: number;
+    corroborations: string[];
+    sourcePeerDid: string;
+}
+interface ExcitabilityMetadata {
+    queryCount: number;
+    citationCount: number;
+    corroborationCount: number;
+    excitability: number;
+    lastRetrievedAt: number;
+    lastReconsolidatedAt: number;
+    consolidationSurvivals: number;
+}
+/** Compute excitability score from metadata. */
+declare function computeExcitability(meta: Omit<ExcitabilityMetadata, 'excitability'>): number;
+/** Apply domain half-life decay to a score. */
+declare function applyHalfLifeDecay(score: number, ageMs: number, domain: KnowledgeDomain): number;
+interface ConsolidationResult {
+    domain: KnowledgeDomain;
+    promoted: number;
+    merged: number;
+    evicted: number;
+    dropped: number;
+    downscaleFactor: number;
+    consolidatedAt: number;
+}
+interface ReconsolidationEvent {
+    entryId: string;
+    domain: KnowledgeDomain;
+    retrievedAt: number;
+    excitabilityDelta: number;
+    windowOpen: boolean;
+    windowClosesAt: number;
+}
+/** Default reconsolidation window duration (5 minutes). */
+declare const RECONSOLIDATION_WINDOW_MS: number;
+/** Create a reconsolidation event when an entry is retrieved. */
+declare function triggerReconsolidation(entryId: string, domain: KnowledgeDomain, excitabilityDelta: number): ReconsolidationEvent;
+
+/**
+ * Knowledge Marketplace — Buy, sell, and price knowledge entries via x402 micropayments.
+ *
+ * Enables agents to monetize their discovered W/P/G entries.
+ * Integrates with KnowledgeStore for entry lookup and X402Facilitator for settlement.
+ *
+ * FW-0.6
+ */
+
+type ListingStatus = 'active' | 'sold' | 'delisted';
+interface KnowledgeListing {
+    id: string;
+    entryId: string;
+    seller: string;
+    price: number;
+    /** Currency: 'USDC' for x402 settlement, 'credits' for in-memory ledger. */
+    currency: 'USDC' | 'credits';
+    status: ListingStatus;
+    createdAt: string;
+    /** Entry snapshot for buyer preview (type + domain + truncated content). */
+    preview: {
+        type: KnowledgeInsight['type'];
+        domain: string;
+        snippet: string;
+    };
+}
+interface PurchaseResult {
+    success: boolean;
+    listingId: string;
+    entryId?: string;
+    buyer: string;
+    price: number;
+    error?: string;
+}
+interface ListingResult {
+    success: boolean;
+    listingId: string;
+    error?: string;
+}
+interface PricingFactors {
+    /** Base price per type: wisdom > pattern > gotcha. */
+    typeWeights?: Record<KnowledgeInsight['type'], number>;
+    /** Multiplier for high-confidence entries (confidence >= 0.8). */
+    confidenceMultiplier?: number;
+    /** Multiplier for high-reuse entries (reuseCount >= 5). */
+    reuseMultiplier?: number;
+}
+declare class KnowledgeMarketplace {
+    private listings;
+    private purchases;
+    private nextId;
+    private pricingFactors;
+    constructor(pricingFactors?: PricingFactors);
+    /** Estimate the value of a knowledge entry (in USDC). */
+    priceKnowledge(entry: StoredEntry): number;
+    /** List a knowledge entry for sale. */
+    sellKnowledge(entry: StoredEntry, price: number, seller: string, currency?: 'USDC' | 'credits'): ListingResult;
+    /** Buy a listed knowledge entry. */
+    buyKnowledge(listingId: string, buyer: string): PurchaseResult;
+    /** Get a listing by ID. */
+    getListing(listingId: string): KnowledgeListing | undefined;
+    /** List all active listings. */
+    activeListings(): KnowledgeListing[];
+    /** Get purchase history for a buyer. */
+    purchaseHistory(buyer: string): PurchaseResult[];
+    /** Delist an entry (only the seller can delist). */
+    delist(listingId: string, seller: string): boolean;
+    /** Total revenue for a seller across all sold listings. */
+    sellerRevenue(seller: string): number;
+    /** Total marketplace volume (all completed sales). */
+    totalVolume(): number;
+}
+
+/**
+ * Knowledge Store — Local-first with remote federation
+ *
+ * Local mode: in-memory Map + optional JSON persistence (default)
+ * Remote mode: delegates to MCP Orchestrator knowledge/query + knowledge/sync
+ *
+ * The store shape aligns with MeshKnowledgeEntry from holomesh/types.ts.
+ * W/P/G taxonomy follows agent-protocol's PWGEntry format.
+ */
+
+interface StoredEntry extends KnowledgeInsight {
+    id: string;
+    queryCount: number;
+    reuseCount: number;
+    createdAt: string;
+    authorAgent: string;
+    taskId?: string;
+    cycleId?: string;
+    verifierId?: string;
+    /** Provenance hash — chain of custody */
+    provenanceHash?: string;
+    /** Excitability metadata for brain-aware ranking */
+    excitability?: ExcitabilityMetadata;
+}
+/** Result from the vector embedding pipeline. */
+interface EmbedResult {
+    entryId: string;
+    synced: boolean;
+    /** Remote entry ID returned by orchestrator (if synced). */
+    remoteId?: string;
+}
+/** Options for semantic search. */
+interface SemanticSearchOptions {
+    limit?: number;
+    type?: 'wisdom' | 'pattern' | 'gotcha';
+    /** Minimum confidence threshold (0-1). */
+    minConfidence?: number;
+    /** When true, merge remote results with local keyword fallback. */
+    hybridSearch?: boolean;
+}
+declare class KnowledgeStore {
+    private entries;
+    private config;
+    private nextId;
+    constructor(config: KnowledgeConfig);
+    /** Publish a knowledge entry. Deduplicates by normalized content. */
+    publish(insight: KnowledgeInsight, authorAgent: string, provenance?: {
+        taskId?: string;
+        cycleId?: string;
+        verifierId?: string;
+        provenanceHash?: string;
+    }): StoredEntry;
+    /** Search entries by keyword with excitability + half-life decay ranking. */
+    search(query: string, limit?: number): StoredEntry[];
+    /** Search remote knowledge store (MCP Orchestrator). */
+    searchRemote(query: string, limit?: number): Promise<StoredEntry[]>;
+    /** Sync local entries to remote knowledge store. */
+    syncToRemote(): Promise<number>;
+    /**
+     * Embed and store a knowledge entry.
+     *
+     * 1. Publishes locally (dedup, ID generation).
+     * 2. Syncs to MCP Orchestrator pgvector endpoint for vector embedding.
+     *
+     * The orchestrator generates embeddings server-side and stores them
+     * in pgvector for semantic similarity search via `/knowledge/query`.
+     */
+    embedAndStore(insight: KnowledgeInsight, authorAgent: string, provenance?: {
+        taskId?: string;
+        cycleId?: string;
+        verifierId?: string;
+        provenanceHash?: string;
+    }): Promise<EmbedResult>;
+    /**
+     * Semantic search via MCP Orchestrator pgvector.
+     *
+     * Sends the query to the orchestrator `/knowledge/query` endpoint which
+     * generates an embedding for the query and performs cosine similarity
+     * search against stored vectors.
+     *
+     * Falls back to local keyword search when remote is unavailable.
+     * When `hybridSearch` is true, merges remote + local results (deduped by ID).
+     */
+    semanticSearch(query: string, options?: SemanticSearchOptions): Promise<StoredEntry[]>;
+    /** Map a remote API response object to a StoredEntry. */
+    private mapRemoteEntry;
+    recent(limit?: number): StoredEntry[];
+    byType(type: 'wisdom' | 'pattern' | 'gotcha'): StoredEntry[];
+    byDomain(domain: string): StoredEntry[];
+    markReused(id: string): void;
+    get size(): number;
+    all(): StoredEntry[];
+    /** Cross-reference new insights against existing knowledge. */
+    compound(newInsights: KnowledgeInsight[]): number;
+    private persistIfEnabled;
+    private loadFromDisk;
+    /**
+     * Sleep consolidation: Move dormant hot-buffer entries to cold store.
+     * Entries with age > 24h and queryCount < threshold are archived.
+     */
+    sleep(archivePath?: string): Promise<{
+        archived: number;
+        evicted: number;
+    }>;
+    /**
+     * Wake consolidation: Restore archived entries back to hot buffer on query.
+     * Called by search() when a query hits cold store.
+     */
+    wake(archivePath: string, query: string): Promise<StoredEntry[]>;
+    /**
+     * Promote: Move a dormant entry back to hot buffer and boost its score.
+     * Called when an archived entry is cited or reused directly.
+     */
+    promote(id: string): boolean;
+    /**
+     * Evict: Permanently remove an entry from both hot and cold stores.
+     * Called during cleanup or when an entry is marked as stale/wrong.
+     */
+    evict(id: string, archivePath?: string): boolean;
+    /**
+     * Consolidate: Full sleep+wake cycle (once per agent work session).
+     * Moves stale entries to cold store, restores hot entries on demand.
+     */
+    consolidate(archivePath?: string): Promise<{
+        slept: number;
+        woke: number;
+    }>;
+    private _marketplace?;
+    /** Get or create the marketplace instance. */
+    get marketplace(): KnowledgeMarketplace;
+    /** Price a knowledge entry for sale. */
+    priceEntry(id: string): number | null;
+    /** List a knowledge entry for sale on the marketplace. */
+    listForSale(id: string, seller: string, price?: number, currency?: 'USDC' | 'credits'): ListingResult;
+    /** Buy a listed knowledge entry. Returns the full StoredEntry on success. */
+    buyListed(listingId: string, buyer: string): {
+        purchase: PurchaseResult;
+        entry?: StoredEntry;
+    };
+    /** Get active marketplace listings. */
+    activeListings(): KnowledgeListing[];
+}
+
+/**
+ * HoloScript Framework Types
+ *
+ * Canonical home for all agent types. No circular dependencies.
+ */
+
+type LLMProvider = 'anthropic' | 'openai' | 'xai' | 'openrouter';
+interface ModelConfig {
+    provider: LLMProvider;
+    model: string;
+    apiKey?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+type AgentRole = 'architect' | 'coder' | 'researcher' | 'reviewer';
+type SlotRole = 'coder' | 'tester' | 'researcher' | 'reviewer' | 'flex';
+interface ClaimFilter {
+    roles: SlotRole[];
+    maxPriority: number;
+}
+interface AgentConfig {
+    name: string;
+    role: AgentRole;
+    model: ModelConfig;
+    capabilities: string[];
+    claimFilter: ClaimFilter;
+    systemPrompt?: string;
+    knowledgeDomains?: string[];
+}
+interface TaskDef {
+    id: string;
+    title: string;
+    description: string;
+    status: 'open' | 'claimed' | 'done' | 'blocked';
+    priority: number;
+    role?: SlotRole;
+    source?: string;
+    claimedBy?: string;
+    createdAt: string;
+    completedAt?: string;
+}
+interface KnowledgeConfig {
+    persist: boolean;
+    path?: string;
+    /** Remote knowledge store URL (MCP orchestrator) */
+    remoteUrl?: string;
+    remoteApiKey?: string;
+}
+interface KnowledgeInsight {
+    type: 'wisdom' | 'pattern' | 'gotcha';
+    content: string;
+    domain: string;
+    confidence: number;
+    source: string;
+}
+type ConsensusMode = 'simple_majority' | 'unanimous' | 'owner_decides';
+interface TeamConfig {
+    name: string;
+    agents: AgentConfig[];
+    knowledge?: KnowledgeConfig;
+    consensus?: ConsensusMode;
+    maxSlots?: number;
+    /** Remote board API — when set, board ops delegate to HoloMesh HTTP API */
+    boardUrl?: string;
+    boardApiKey?: string;
+    /** Local presence tracking configuration (FW-0.3). */
+    presence?: PresenceConfig;
+}
+interface AgentRuntime {
+    name: string;
+    role: AgentRole;
+    config: AgentConfig;
+    tasksCompleted: number;
+    knowledgePublished: number;
+    reputationScore: number;
+    reputationTier: ReputationTier;
+}
+type ReputationTier = 'newcomer' | 'contributor' | 'expert' | 'authority';
+interface CycleResult {
+    teamName: string;
+    cycle: number;
+    agentResults: AgentCycleResult[];
+    knowledgeProduced: KnowledgeInsight[];
+    compoundedInsights: number;
+    durationMs: number;
+}
+interface AgentCycleResult {
+    agentName: string;
+    taskId: string | null;
+    taskTitle: string | null;
+    action: 'claimed' | 'completed' | 'skipped' | 'error' | 'synthesized';
+    summary: string;
+    knowledge: KnowledgeInsight[];
+}
+interface ProposalResult<T = unknown> {
+    proposalId: string;
+    accepted: boolean;
+    votesFor: number;
+    votesAgainst: number;
+    votesTotal: number;
+    value: T;
+}
+type SuggestionStatus = 'open' | 'promoted' | 'dismissed';
+interface SuggestionVoteEntry {
+    agent: string;
+    vote: 'up' | 'down';
+    reason?: string;
+    votedAt: string;
+}
+interface Suggestion {
+    id: string;
+    title: string;
+    description?: string;
+    category?: string;
+    evidence?: string;
+    proposedBy: string;
+    status: SuggestionStatus;
+    votes: SuggestionVoteEntry[];
+    /** Net score (upvotes minus downvotes) */
+    score: number;
+    createdAt: string;
+    resolvedAt?: string;
+    /** When upvotes >= this threshold, auto-promote to board task */
+    autoPromoteThreshold?: number;
+    /** When downvotes >= this threshold, auto-dismiss */
+    autoDismissThreshold?: number;
+    /** If promoted, the resulting task ID */
+    promotedTaskId?: string;
+}
+interface SuggestionCreateResult {
+    suggestion: Suggestion;
+}
+interface SuggestionVoteResult {
+    suggestion: Suggestion;
+    /** Set when a suggestion was auto-promoted via threshold */
+    promotedTaskId?: string;
+}
+interface SuggestionListResult {
+    suggestions: Suggestion[];
+}
+type TeamMode = 'audit' | 'research' | 'build' | 'review';
+interface SetModeResult {
+    mode: TeamMode;
+    previousMode?: TeamMode;
+}
+interface DeriveResult {
+    tasks: TaskDef[];
+}
+interface SlotInfo {
+    agentName: string;
+    role: SlotRole;
+    status: string;
+    lastSeen?: string;
+    ideType?: string;
+}
+interface PresenceResult {
+    slots: SlotInfo[];
+}
+interface HeartbeatResult {
+    ok: boolean;
+}
+type AgentPresenceStatus = 'online' | 'idle' | 'offline';
+interface AgentPresence {
+    name: string;
+    status: AgentPresenceStatus;
+    lastSeen: number;
+    currentTask?: string;
+    uptime: number;
+}
+interface PresenceConfig {
+    /** Milliseconds without heartbeat before agent is marked idle (default 60_000). */
+    idleTimeoutMs?: number;
+    /** Milliseconds without heartbeat before agent is marked offline (default 300_000). */
+    offlineTimeoutMs?: number;
+}
+type ProtocolStyle = 'uaa2' | 'react' | 'plan-exec' | 'debate' | 'swarm';
+type AgentStatus = 'idle' | 'running' | 'paused' | 'cancelled' | 'error';
+interface PhaseHook {
+    before?: (phase: ProtocolPhase, input: unknown) => Promise<unknown> | unknown;
+    after?: (phase: ProtocolPhase, result: PhaseResult) => Promise<PhaseResult> | PhaseResult;
+}
+interface ProtocolAgentConfig extends AgentConfig {
+    /** Protocol style — defaults to 'uaa2' (7-phase cycle). */
+    protocolStyle?: ProtocolStyle;
+    /** Phase hooks — called before/after each phase. */
+    phaseHooks?: PhaseHook;
+    /** Additional LLM overrides for lightweight phases. */
+    lightModel?: Partial<ModelConfig>;
+    /** Team knowledge context injected into phases. */
+    teamKnowledge?: string;
+    /** Maximum phase retries on failure. */
+    maxPhaseRetries?: number;
+}
+interface ProtocolAgentHandle {
+    /** Agent name. */
+    readonly name: string;
+    /** Agent role. */
+    readonly role: AgentRole;
+    /** Current status. */
+    readonly status: AgentStatus;
+    /** Phase execution history. */
+    readonly history: PhaseResult[];
+    /** Execute a task through the full protocol cycle. */
+    execute(task: {
+        title: string;
+        description: string;
+    }): Promise<ProtocolCycleResult>;
+    /** Pause execution after the current phase completes. */
+    pause(): void;
+    /** Resume a paused agent. */
+    resume(): void;
+    /** Cancel execution. The current phase will finish but no further phases run. */
+    cancel(): void;
+    /** Reset status to idle and clear history. */
+    reset(): void;
+}
+
+/**
+ * x402 Payment Protocol Facilitator
+ *
+ * Implements the x402 protocol (https://www.x402.org/) for HTTP 402 Payment Required
+ * responses, enabling native internet payments for HoloScript resources.
+ *
+ * The x402 protocol flow:
+ *   1. Client requests a resource (GET /api/premium-scene)
+ *   2. Server responds with HTTP 402 + PaymentRequired body
+ *   3. Client signs an EIP-712 authorization (gasless) and retries with X-PAYMENT header
+ *   4. Facilitator verifies signature + settles on-chain
+ *   5. Server returns the resource with X-PAYMENT-RESPONSE confirmation
+ *
+ * Dual-mode settlement:
+ *   - In-memory ledger for microtransactions < $0.10 (no gas, instant)
+ *   - On-chain x402 settlement for amounts >= $0.10 (USDC on Base or Solana)
+ *
+ * Optimistic execution:
+ *   - Proceeds on valid authorization before on-chain confirmation
+ *   - Verifies settlement asynchronously, reverts on failure
+ *
+ * @version 1.0.0
+ * @see https://www.x402.org/
+ * @see https://docs.x402.org/
+ */
+
+/** x402 protocol version */
+declare const X402_VERSION = 1;
+/** Supported settlement chains */
+type SettlementChain = 'base' | 'base-sepolia' | 'solana' | 'solana-devnet';
+/** Supported payment schemes per x402 spec */
+type PaymentScheme = 'exact';
+/** Settlement mode based on transaction amount */
+type SettlementMode = 'in_memory' | 'on_chain';
+/** USDC contract addresses per chain */
+declare const USDC_CONTRACTS: Record<SettlementChain, string>;
+/** Threshold for switching from in-memory to on-chain settlement (in USDC base units, 6 decimals) */
+declare const MICRO_PAYMENT_THRESHOLD = 100000;
+/**
+ * x402 PaymentRequired response body.
+ * Returned as HTTP 402 response when payment is needed.
+ */
+interface X402PaymentRequired {
+    /** Protocol version */
+    x402Version: number;
+    /** Accepted payment methods */
+    accepts: X402PaymentOption[];
+    /** Human-readable error description */
+    error: string;
+}
+/**
+ * A single payment option within the accepts array.
+ */
+interface X402PaymentOption {
+    /** Payment model: "exact" (fixed price) */
+    scheme: PaymentScheme;
+    /** Blockchain network identifier */
+    network: SettlementChain;
+    /** Amount in token base units (string for precision, USDC = 6 decimals) */
+    maxAmountRequired: string;
+    /** The resource being paid for */
+    resource: string;
+    /** Human-readable description */
+    description: string;
+    /** Recipient wallet address */
+    payTo: string;
+    /** Token contract address (USDC) */
+    asset: string;
+    /** Maximum seconds to complete payment */
+    maxTimeoutSeconds: number;
+}
+/**
+ * EIP-712 signed authorization payload from the client.
+ * Sent in the X-PAYMENT header (base64-encoded).
+ */
+interface X402PaymentPayload {
+    /** Protocol version */
+    x402Version: number;
+    /** Payment scheme */
+    scheme: PaymentScheme;
+    /** Target network */
+    network: SettlementChain;
+    /** Signed authorization */
+    payload: {
+        /** EIP-712 or Ed25519 signature */
+        signature: string;
+        /** Transfer authorization details */
+        authorization: {
+            /** Payer address */
+            from: string;
+            /** Recipient address */
+            to: string;
+            /** Amount in base units */
+            value: string;
+            /** Unix timestamp after which authorization is valid */
+            validAfter: string;
+            /** Unix timestamp before which authorization is valid */
+            validBefore: string;
+            /** Unique nonce to prevent replay */
+            nonce: string;
+        };
+    };
+}
+/**
+ * Settlement result after on-chain or in-memory settlement.
+ */
+interface X402SettlementResult {
+    /** Whether settlement succeeded */
+    success: boolean;
+    /** On-chain transaction hash (null for in-memory) */
+    transaction: string | null;
+    /** Network where settlement occurred */
+    network: SettlementChain | 'in_memory';
+    /** Payer address or ID */
+    payer: string;
+    /** Error reason if failed */
+    errorReason: string | null;
+    /** Settlement mode used */
+    mode: SettlementMode;
+    /** Timestamp of settlement */
+    settledAt: number;
+}
+/**
+ * Verification result from the facilitator.
+ */
+interface X402VerificationResult {
+    /** Whether the payment authorization is valid */
+    isValid: boolean;
+    /** Reason for invalidity */
+    invalidReason: string | null;
+}
+/**
+ * In-memory ledger entry for micro-payments.
+ */
+interface LedgerEntry {
+    /** Unique transaction ID */
+    id: string;
+    /** Payer identifier */
+    from: string;
+    /** Recipient identifier */
+    to: string;
+    /** Amount in USDC base units (6 decimals) */
+    amount: number;
+    /** Resource accessed */
+    resource: string;
+    /** Timestamp */
+    timestamp: number;
+    /** Whether this has been settled on-chain (batch settlement) */
+    settled: boolean;
+    /** On-chain tx hash after batch settlement */
+    settlementTx: string | null;
+}
+/**
+ * Configuration for the x402 facilitator.
+ */
+interface X402FacilitatorConfig {
+    /** Recipient wallet address for payments */
+    recipientAddress: string;
+    /** Primary settlement chain */
+    chain: SettlementChain;
+    /** Secondary chain (optional, for multi-chain support) */
+    secondaryChain?: SettlementChain;
+    /** Micro-payment threshold in USDC base units (default: 100000 = $0.10) */
+    microPaymentThreshold?: number;
+    /** Maximum timeout for payment completion in seconds */
+    maxTimeoutSeconds?: number;
+    /** Enable optimistic execution (proceed before on-chain confirmation) */
+    optimisticExecution?: boolean;
+    /** Batch settlement interval for in-memory ledger entries (ms) */
+    batchSettlementIntervalMs?: number;
+    /** Maximum in-memory ledger entries before forced batch settlement */
+    maxLedgerEntries?: number;
+    /** Facilitator service URL for on-chain verification/settlement */
+    facilitatorUrl?: string;
+    /** Resource description template */
+    resourceDescription?: string;
+}
+/**
+ * In-memory ledger for tracking micro-payments below the on-chain threshold.
+ * Entries accumulate and are batch-settled periodically.
+ *
+ * Thread-safe via synchronous JS execution model.
+ */
+declare class MicroPaymentLedger {
+    private entries;
+    private balances;
+    private txCounter;
+    private readonly maxEntries;
+    constructor(maxEntries?: number);
+    /**
+     * Record a micro-payment in the in-memory ledger.
+     */
+    record(from: string, to: string, amount: number, resource: string): LedgerEntry;
+    /**
+     * Get unsettled entries for batch settlement.
+     */
+    getUnsettled(): LedgerEntry[];
+    /**
+     * Mark entries as settled after batch on-chain settlement.
+     */
+    markSettled(entryIds: string[], txHash: string): void;
+    /**
+     * Get the net balance for an address (can be negative = owes).
+     */
+    getBalance(address: string): number;
+    /**
+     * Get total unsettled volume.
+     */
+    getUnsettledVolume(): number;
+    /**
+     * Get all entries for a specific payer.
+     */
+    getEntriesForPayer(from: string): LedgerEntry[];
+    /**
+     * Get ledger statistics.
+     */
+    getStats(): {
+        totalEntries: number;
+        unsettledEntries: number;
+        unsettledVolume: number;
+        uniquePayers: number;
+        uniqueRecipients: number;
+    };
+    /**
+     * Clear all settled entries (garbage collection).
+     */
+    pruneSettled(): number;
+    /**
+     * Reset the entire ledger.
+     */
+    reset(): void;
+}
+/**
+ * x402 Payment Protocol Facilitator
+ *
+ * Central coordinator for x402 payment flows in HoloScript. Manages:
+ * - PaymentRequired response generation for @credit-gated resources
+ * - Payment verification (signature + authorization validity)
+ * - Dual-mode settlement (in-memory micro vs on-chain macro)
+ * - Optimistic execution with async settlement verification
+ * - Batch settlement of accumulated micro-payments
+ *
+ * Security considerations:
+ * - All signatures are verified before granting access
+ * - Nonce tracking prevents replay attacks
+ * - ValidBefore/ValidAfter windowing prevents stale authorizations
+ * - In-memory ledger has hard caps to prevent memory exhaustion
+ * - Optimistic execution only for amounts below configurable threshold
+ */
+declare class X402Facilitator {
+    private config;
+    private ledger;
+    private usedNonces;
+    private pendingSettlements;
+    private settlementResults;
+    private batchSettlementTimer;
+    constructor(config: X402FacilitatorConfig);
+    /**
+     * 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: string, amountUSDC: number, description?: string): X402PaymentRequired;
+    /**
+     * 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: X402PaymentPayload, requiredAmount: string): X402VerificationResult;
+    /**
+     * Determine the settlement mode based on the payment amount.
+     *
+     * @param amountBaseUnits - Amount in USDC base units (6 decimals)
+     * @returns Settlement mode
+     */
+    getSettlementMode(amountBaseUnits: number): SettlementMode;
+    /**
+     * 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
+     */
+    processPayment(payment: X402PaymentPayload, resource: string, requiredAmount: string): Promise<X402SettlementResult>;
+    /**
+     * Settle a micro-payment in the in-memory ledger.
+     */
+    private settleMicroPayment;
+    /**
+     * 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.
+     */
+    private settleOnChain;
+    /**
+     * Verify settlement asynchronously (for optimistic execution).
+     * Calls the facilitator service to verify and execute the on-chain transfer.
+     */
+    private verifySettlementAsync;
+    /**
+     * Verify settlement synchronously (blocking).
+     */
+    private verifySettlementSync;
+    /**
+     * 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
+     */
+    private callFacilitator;
+    /**
+     * Start automatic batch settlement of in-memory ledger entries.
+     */
+    startBatchSettlement(): void;
+    /**
+     * Stop automatic batch settlement.
+     */
+    stopBatchSettlement(): void;
+    /**
+     * Run a single batch settlement cycle.
+     * Aggregates unsettled micro-payments by payer and submits on-chain.
+     */
+    runBatchSettlement(): Promise<{
+        settled: number;
+        failed: number;
+        totalVolume: number;
+    }>;
+    /**
+     * Decode a base64-encoded X-PAYMENT header into a payment payload.
+     */
+    static decodeXPaymentHeader(header: string): X402PaymentPayload | null;
+    /**
+     * Encode a payment payload into a base64 string for the X-PAYMENT header.
+     */
+    static encodeXPaymentHeader(payload: X402PaymentPayload): string;
+    /**
+     * Create an X-PAYMENT-RESPONSE header value from a settlement result.
+     */
+    static createPaymentResponseHeader(result: X402SettlementResult): string;
+    /**
+     * Check the settlement status of a pending optimistic execution.
+     */
+    getSettlementStatus(nonce: string): X402SettlementResult | 'pending' | 'unknown';
+    /**
+     * Get the in-memory ledger instance.
+     */
+    getLedger(): MicroPaymentLedger;
+    /**
+     * Get facilitator statistics.
+     */
+    getStats(): {
+        usedNonces: number;
+        pendingSettlements: number;
+        completedSettlements: number;
+        ledger: ReturnType<MicroPaymentLedger['getStats']>;
+    };
+    /**
+     * Clean up resources.
+     */
+    dispose(): void;
+}
+/**
+ * Configuration for the @credit trait.
+ * Attach to any HoloScript object to gate it behind x402 payment.
+ */
+interface CreditTraitConfig {
+    /** Price in USDC (human-readable, e.g., 0.05 = 5 cents) */
+    price: number;
+    /** Settlement chain */
+    chain: SettlementChain;
+    /** Recipient address */
+    recipient: string;
+    /** Human-readable resource description */
+    description: string;
+    /** Maximum seconds for payment timeout */
+    timeout: number;
+    /** Secondary chain for multi-chain support */
+    secondary_chain?: SettlementChain;
+    /** Enable optimistic execution */
+    optimistic: boolean;
+    /** Micro-payment threshold override (USDC, human-readable) */
+    micro_threshold?: number;
+}
+/**
+ * @credit Trait Handler
+ *
+ * When attached to a HoloScript object, this trait gates access behind
+ * x402 payment. The trait:
+ *
+ * 1. On access attempt: emits 'credit:payment_required' with the 402 response body
+ * 2. On payment received: verifies via facilitator and emits 'credit:access_granted'
+ * 3. On payment failure: emits 'credit:access_denied'
+ *
+ * Events emitted:
+ *   credit:initialized       { config }
+ *   credit:payment_required  { resource, paymentRequired: X402PaymentRequired }
+ *   credit:access_granted    { payer, amount, mode, resource }
+ *   credit:access_denied     { payer, reason, resource }
+ *   credit:settlement_status { nonce, status }
+ *   credit:batch_settled     { settled, failed, totalVolume }
+ *   credit:stats             { totalRevenue, totalRequests, totalGranted, totalDenied }
+ *
+ * @example HoloScript usage:
+ * ```holoscript
+ * object "premium_scene" {
+ *   @credit(price: 0.05, chain: "base", recipient: "0x...", description: "Premium VR scene")
+ *   geometry: "sphere"
+ *   color: "#gold"
+ * }
+ * ```
+ */
+declare const creditTraitHandler: TraitHandler<CreditTraitConfig>;
+
+/** EVM chain IDs for supported settlement networks */
+declare const CHAIN_IDS: Record<string, number>;
+/** Reverse lookup: chain ID -> settlement chain name */
+declare const CHAIN_ID_TO_NETWORK: Record<number, SettlementChain>;
+/**
+ * Settlement audit event types emitted by PaymentGateway.
+ */
+type SettlementEventType = 'payment:authorization_created' | 'payment:verification_started' | 'payment:verification_passed' | 'payment:verification_failed' | 'payment:settlement_started' | 'payment:settlement_completed' | 'payment:settlement_failed' | 'payment:refund_initiated' | 'payment:refund_completed' | 'payment:refund_failed' | 'payment:batch_settlement_started' | 'payment:batch_settlement_completed';
+/**
+ * Settlement audit event payload.
+ */
+interface SettlementEvent {
+    /** Event type */
+    type: SettlementEventType;
+    /** ISO 8601 timestamp */
+    timestamp: string;
+    /** Unique event ID */
+    eventId: string;
+    /** Associated payment nonce (if applicable) */
+    nonce: string | null;
+    /** Payer address */
+    payer: string | null;
+    /** Recipient address */
+    recipient: string | null;
+    /** Amount in USDC base units */
+    amount: string | null;
+    /** Settlement chain */
+    network: SettlementChain | 'in_memory' | null;
+    /** Transaction hash (if on-chain) */
+    transaction: string | null;
+    /** Additional metadata */
+    metadata: Record<string, unknown>;
+}
+/** Event listener type for the PaymentGateway audit trail */
+type SettlementEventListener = (event: SettlementEvent) => void;
+/**
+ * Refund request for reversing a completed payment.
+ */
+interface RefundRequest {
+    /** Original payment nonce to refund */
+    originalNonce: string;
+    /** Reason for the refund */
+    reason: string;
+    /** Partial refund amount in USDC base units (null = full refund) */
+    partialAmount: string | null;
+}
+/**
+ * Result of a refund operation.
+ */
+interface RefundResult {
+    /** Whether the refund was processed */
+    success: boolean;
+    /** Refund ID for tracking */
+    refundId: string;
+    /** Amount refunded in USDC base units */
+    amountRefunded: string;
+    /** Original payment nonce */
+    originalNonce: string;
+    /** Transaction hash (for on-chain refunds) */
+    transaction: string | null;
+    /** Mode of the original settlement */
+    originalMode: SettlementMode;
+    /** Reason for the refund */
+    reason: string;
+    /** Error reason if failed */
+    errorReason: string | null;
+    /** Timestamp of refund */
+    refundedAt: number;
+}
+/**
+ * PaymentGateway -- High-Level x402 Payment API
+ *
+ * Provides a unified, agent-friendly interface for the x402 payment protocol.
+ * Composes over X402Facilitator to add:
+ *
+ * - `createPaymentAuthorization()` -- Generate 402 Payment Required responses
+ * - `verifyPayment()` -- Validate X-PAYMENT headers
+ * - `settlePayment()` -- Process and settle payments (micro or on-chain)
+ * - `refundPayment()` -- Reverse completed transactions
+ * - Settlement event emitter for audit trail
+ * - Chain ID constants for Base L2 (8453)
+ *
+ * Settlement flow:
+ *   1. Agent calls resource -> gateway returns 402 with payment requirements
+ *   2. Agent signs EIP-712 authorization -> sends X-PAYMENT header
+ *   3. Gateway verifies signature validity and temporal window
+ *   4. Gateway settles payment (in-memory for micro, on-chain for macro)
+ *   5. Gateway emits audit events at each step
+ *
+ * @example
+ * ```typescript
+ * const gateway = new PaymentGateway({
+ *   recipientAddress: '0x...',
+ *   chain: 'base',
+ * });
+ *
+ * // Listen for audit events
+ * gateway.on('payment:settlement_completed', (event) => {
+ *   console.log(`Payment settled: ${event.transaction}`);
+ * });
+ *
+ * // Step 1: Generate 402 response
+ * const auth = gateway.createPaymentAuthorization('/api/premium-scene', 0.05);
+ *
+ * // Step 2: Verify incoming payment
+ * const verification = gateway.verifyPayment(xPaymentHeader, '50000');
+ *
+ * // Step 3: Settle
+ * const settlement = await gateway.settlePayment(paymentPayload, '/api/premium-scene', '50000');
+ *
+ * // Step 4: Refund if needed
+ * const refund = await gateway.refundPayment({
+ *   originalNonce: 'nonce_123',
+ *   reason: 'Content unavailable',
+ *   partialAmount: null,
+ * });
+ * ```
+ */
+declare class PaymentGateway {
+    private facilitator;
+    private listeners;
+    private refundLedger;
+    private eventCounter;
+    private readonly config;
+    constructor(config: X402FacilitatorConfig);
+    /**
+     * 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: SettlementEventType | '*', listener: SettlementEventListener): () => void;
+    /**
+     * Remove a specific listener.
+     */
+    off(eventType: SettlementEventType | '*', listener: SettlementEventListener): void;
+    /**
+     * Emit a settlement audit event.
+     */
+    private emit;
+    /**
+     * 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: string, amountUSDC: number, description?: string): X402PaymentRequired & {
+        chainId: number;
+    };
+    /**
+     * 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: string | X402PaymentPayload, requiredAmount: string): X402VerificationResult & {
+        decodedPayload: X402PaymentPayload | null;
+    };
+    /**
+     * 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
+     */
+    settlePayment(payment: string | X402PaymentPayload, resource: string, requiredAmount: string): Promise<X402SettlementResult>;
+    /**
+     * 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
+     */
+    refundPayment(request: RefundRequest): Promise<RefundResult>;
+    /**
+     * Run a batch settlement of accumulated micro-payments.
+     */
+    runBatchSettlement(): Promise<{
+        settled: number;
+        failed: number;
+        totalVolume: number;
+    }>;
+    /**
+     * Get the underlying facilitator instance.
+     */
+    getFacilitator(): X402Facilitator;
+    /**
+     * Get chain ID for the configured settlement chain.
+     */
+    getChainId(): number;
+    /**
+     * Get the USDC contract address for the configured chain.
+     */
+    getUSDCContract(): string;
+    /**
+     * Look up a refund result by refund ID.
+     */
+    getRefund(refundId: string): RefundResult | undefined;
+    /**
+     * Get all refund results.
+     */
+    getAllRefunds(): RefundResult[];
+    /**
+     * Get comprehensive gateway statistics.
+     */
+    getStats(): {
+        facilitator: ReturnType<X402Facilitator['getStats']>;
+        chainId: number;
+        usdcContract: string;
+        totalRefunds: number;
+        listenerCount: number;
+    };
+    /**
+     * Clean up all resources.
+     */
+    dispose(): void;
+}
+
+/**
+ * Bounty Manager — Task-based incentive system for agent teams.
+ *
+ * Creates, claims, and settles bounties tied to board tasks.
+ * Integrates with X402Facilitator for on-chain or in-memory payouts.
+ *
+ * FW-0.6
+ */
+
+type BountyCurrency = 'USDC' | 'credits';
+type BountyStatus = 'open' | 'claimed' | 'completed' | 'expired' | 'disputed';
+interface BountyReward {
+    amount: number;
+    currency: BountyCurrency;
+}
+interface Bounty {
+    id: string;
+    taskId: string;
+    reward: BountyReward;
+    status: BountyStatus;
+    createdBy: string;
+    claimedBy?: string;
+    completedAt?: string;
+    deadline?: number;
+    createdAt: string;
+}
+interface ClaimResult {
+    success: boolean;
+    bountyId: string;
+    error?: string;
+}
+interface CompletionProof {
+    commitHash?: string;
+    summary: string;
+    /** Arbitrary evidence (test output, URLs, etc.) */
+    evidence?: string[];
+}
+interface PayoutResult {
+    success: boolean;
+    bountyId: string;
+    amount: number;
+    currency: BountyCurrency;
+    /** Settlement method used (ledger for credits/micro, on-chain for larger USDC) */
+    settlement: 'ledger' | 'on_chain';
+    error?: string;
+}
+interface BountyManagerConfig {
+    /** Optional X402Facilitator for USDC payouts. Without it, only credits work. */
+    facilitator?: X402Facilitator;
+    /** Optional MicroPaymentLedger for credit-based or micro USDC payouts. */
+    ledger?: MicroPaymentLedger;
+    /** Default deadline in ms from creation (default: 7 days). */
+    defaultDeadlineMs?: number;
+}
+declare class BountyManager {
+    private bounties;
+    private nextId;
+    private config;
+    constructor(config?: BountyManagerConfig);
+    /** Create a bounty for a board task. */
+    createBounty(taskId: string, reward: BountyReward, createdBy: string, deadline?: number): Bounty;
+    /** Claim an open bounty. */
+    claimBounty(bountyId: string, agentId: string): ClaimResult;
+    /** Complete a bounty with proof of work and trigger payout. */
+    completeBounty(bountyId: string, proof: CompletionProof): PayoutResult;
+    /** Get a bounty by ID. */
+    getBounty(bountyId: string): Bounty | undefined;
+    /** List bounties, optionally filtered by status. */
+    list(status?: BountyStatus): Bounty[];
+    /** List bounties for a specific task. */
+    byTask(taskId: string): Bounty[];
+    /** Expire bounties past their deadline. Returns count expired. */
+    expireStale(): number;
+    /** Total open bounty value in a given currency. */
+    totalOpen(currency?: BountyCurrency): number;
+}
+
+/**
+ * Type stubs for @holoscript/core types used by economy module.
+ * Copied from core to avoid cross-package DTS resolution failures.
+ * The real types come from @holoscript/core at runtime.
+ *
+ * Source: packages/core/src/compiler/safety/ResourceBudgetAnalyzer.ts
+ * Source: packages/core/src/debug/TelemetryCollector.ts
+ */
+interface TelemetryCollector {
+    record(event: Record<string, unknown>): unknown;
+    recordEvent(type: string, agentId: string, data?: Record<string, unknown>, severity?: string): unknown;
+    recordError(agentId: string, error: Error, context?: Record<string, unknown>): unknown;
+    startSpan(name: string, options?: Record<string, unknown>): unknown;
+    endSpan(spanId: string, status?: string, statusMessage?: string): unknown;
+    flush(): Promise<void>;
+    getStats(): Record<string, unknown>;
+    setEnabled(enabled: boolean): void;
+    configure(config: Record<string, unknown>): void;
+    clear(): void;
+    destroy(): void;
+}
+/** Resource categories tracked by the budget analyzer */
+type ResourceCategory = 'particles' | 'physicsBodies' | 'audioSources' | 'meshInstances' | 'gaussians' | 'shaderPasses' | 'networkMsgs' | 'agentCount' | 'memoryMB' | 'gpuDrawCalls';
+/** A resource usage entry from the AST (exact shape from core) */
+interface ResourceUsageNode {
+    name: string;
+    traits: string[];
+    calls: string[];
+    count: number;
+    traitConfigs?: Record<string, Record<string, number>>;
+}
+
+/**
+ * CreatorRevenueAggregator — Earnings tracking and revenue sharing
+ *
+ * Tracks earnings by creator, plugin, and time period from LedgerEntry records.
+ * Calculates revenue shares and maintains payout history.
+ *
+ * Part of HoloScript v5.8 "Live Economy".
+ *
+ * @version 1.0.0
+ */
+
+/**
+ * A revenue event from a tool call or resource access.
+ */
+interface RevenueEvent {
+    /** Unique event ID */
+    id: string;
+    /** Creator who earned revenue */
+    creatorId: string;
+    /** Plugin or tool that generated the revenue */
+    pluginId: string;
+    /** Gross amount in USDC base units (6 decimals) */
+    grossAmount: number;
+    /** Platform fee in USDC base units */
+    platformFee: number;
+    /** Net amount (grossAmount - platformFee) */
+    netAmount: number;
+    /** Timestamp (ms since epoch) */
+    timestamp: number;
+    /** Payer (agent or user) */
+    payerId: string;
+    /** Related ledger entry ID */
+    ledgerEntryId?: string;
+}
+/**
+ * Aggregated earnings for a creator.
+ */
+interface CreatorEarnings {
+    /** Creator ID */
+    creatorId: string;
+    /** Total gross revenue (USDC base units) */
+    totalGross: number;
+    /** Total platform fees (USDC base units) */
+    totalFees: number;
+    /** Total net revenue (USDC base units) */
+    totalNet: number;
+    /** Revenue by plugin */
+    byPlugin: Map<string, PluginRevenue>;
+    /** Number of revenue events */
+    eventCount: number;
+    /** Period start (ISO 8601) */
+    periodStart: string;
+    /** Period end (ISO 8601) */
+    periodEnd: string;
+}
+/**
+ * Revenue breakdown for a specific plugin.
+ */
+interface PluginRevenue {
+    /** Plugin ID */
+    pluginId: string;
+    /** Gross revenue */
+    grossAmount: number;
+    /** Platform fee */
+    platformFee: number;
+    /** Net revenue */
+    netAmount: number;
+    /** Number of revenue events */
+    eventCount: number;
+    /** Unique payers */
+    uniquePayers: Set<string>;
+}
+/**
+ * Payout record.
+ */
+interface PayoutRecord {
+    /** Payout ID */
+    id: string;
+    /** Creator ID */
+    creatorId: string;
+    /** Amount paid out (USDC base units) */
+    amount: number;
+    /** Payout method */
+    method: 'usdc_transfer' | 'batch_settlement' | 'manual';
+    /** Transaction hash (if on-chain) */
+    transactionHash?: string;
+    /** Payout timestamp (ISO 8601) */
+    paidAt: string;
+    /** Status */
+    status: 'pending' | 'completed' | 'failed';
+    /** Period this payout covers */
+    periodStart: string;
+    periodEnd: string;
+}
+/**
+ * Revenue aggregation period.
+ */
+type RevenuePeriod = 'daily' | 'weekly' | 'monthly' | 'all-time';
+/**
+ * Revenue aggregator configuration.
+ */
+interface RevenueAggregatorConfig {
+    /** Platform fee rate (0-1, e.g. 0.15 = 15%) */
+    platformFeeRate?: number;
+    /** Minimum payout threshold (USDC base units, default: 5_000_000 = $5.00) */
+    minPayoutThreshold?: number;
+    /** Maximum events to retain per creator */
+    maxEventsPerCreator?: number;
+    /** Telemetry collector */
+    telemetry?: TelemetryCollector;
+}
+declare class CreatorRevenueAggregator {
+    private config;
+    private events;
+    private payouts;
+    private eventCounter;
+    constructor(config?: RevenueAggregatorConfig);
+    /**
+     * Record a revenue event.
+     */
+    recordRevenue(creatorId: string, pluginId: string, grossAmount: number, payerId: string, ledgerEntryId?: string): RevenueEvent;
+    /**
+     * Get earnings for a specific creator.
+     */
+    getCreatorEarnings(creatorId: string, period?: RevenuePeriod): CreatorEarnings;
+    /**
+     * Get top creators by revenue.
+     */
+    getTopCreators(period?: RevenuePeriod, limit?: number): Array<{
+        creatorId: string;
+        totalNet: number;
+        eventCount: number;
+    }>;
+    /**
+     * Get platform revenue (total fees collected).
+     */
+    getPlatformRevenue(period?: RevenuePeriod): {
+        totalFees: number;
+        totalGross: number;
+        creatorCount: number;
+    };
+    /**
+     * Get creators eligible for payout (net earnings >= threshold).
+     */
+    getPayoutEligible(period?: RevenuePeriod): Array<{
+        creatorId: string;
+        amount: number;
+    }>;
+    /**
+     * Record a payout to a creator.
+     */
+    recordPayout(creatorId: string, amount: number, method: PayoutRecord['method'], transactionHash?: string): PayoutRecord;
+    /**
+     * Update payout status.
+     */
+    updatePayoutStatus(payoutId: string, status: PayoutRecord['status'], transactionHash?: string): boolean;
+    /**
+     * Get payouts for a creator.
+     */
+    getCreatorPayouts(creatorId: string, period?: RevenuePeriod): PayoutRecord[];
+    /**
+     * Get all payouts.
+     */
+    getAllPayouts(): PayoutRecord[];
+    /**
+     * Get all tracked creator IDs.
+     */
+    getCreatorIds(): string[];
+    /**
+     * Get platform fee rate.
+     */
+    getPlatformFeeRate(): number;
+    /**
+     * Set platform fee rate.
+     */
+    setPlatformFeeRate(rate: number): void;
+    private getPeriodBounds;
+    private emitTelemetry;
+}
+
+/**
+ * PaymentWebhookService — Webhook processing for payment confirmations
+ *
+ * Receives payment provider webhooks, verifies HMAC-SHA256 signatures,
+ * updates LedgerEntry settlement status, and emits telemetry events.
+ *
+ * Part of HoloScript v5.8 "Live Economy".
+ *
+ * @version 1.0.0
+ */
+
+/**
+ * Supported webhook providers.
+ */
+type WebhookProvider = 'x402' | 'stripe' | 'coinbase' | 'custom';
+/**
+ * Webhook event types.
+ */
+type WebhookEventType = 'payment.confirmed' | 'payment.failed' | 'payment.refunded' | 'settlement.completed' | 'settlement.failed' | 'subscription.renewed' | 'subscription.cancelled';
+/**
+ * Incoming webhook payload.
+ */
+interface WebhookPayload {
+    /** Provider-specific event ID */
+    eventId: string;
+    /** Event type */
+    type: WebhookEventType;
+    /** Provider name */
+    provider: WebhookProvider;
+    /** Timestamp of the event (ISO 8601) */
+    timestamp: string;
+    /** Provider-specific data */
+    data: Record<string, unknown>;
+    /** Ledger entry ID (if applicable) */
+    ledgerEntryId?: string;
+    /** Transaction hash (if on-chain) */
+    transactionHash?: string;
+    /** Amount in USDC base units */
+    amount?: number;
+    /** Payer identifier */
+    payer?: string;
+    /** Recipient identifier */
+    recipient?: string;
+}
+/**
+ * Webhook verification result.
+ */
+interface WebhookVerificationResult {
+    /** Whether the webhook signature is valid */
+    verified: boolean;
+    /** Provider name */
+    provider: WebhookProvider;
+    /** Error message if verification failed */
+    error?: string;
+    /** Parsed payload (if verified) */
+    payload?: WebhookPayload;
+}
+/**
+ * Webhook processing result.
+ */
+interface WebhookProcessingResult {
+    /** Whether processing succeeded */
+    success: boolean;
+    /** Event ID that was processed */
+    eventId: string;
+    /** Event type */
+    type: WebhookEventType;
+    /** Updated ledger entry (if applicable) */
+    updatedEntry?: LedgerEntry;
+    /** Error message if processing failed */
+    error?: string;
+}
+/**
+ * Webhook handler function type.
+ */
+type WebhookHandler = (payload: WebhookPayload) => Promise<WebhookProcessingResult> | WebhookProcessingResult;
+/**
+ * Configuration for the webhook service.
+ */
+interface WebhookServiceConfig {
+    /** HMAC secrets per provider */
+    secrets: Partial<Record<WebhookProvider, string>>;
+    /** Maximum age for webhook events (ms, default: 5 minutes) */
+    maxAgeMs?: number;
+    /** Maximum retry attempts for failed deliveries */
+    maxRetries?: number;
+    /** Retry backoff base (ms) */
+    retryBackoffMs?: number;
+    /** Telemetry collector */
+    telemetry?: TelemetryCollector;
+}
+declare class PaymentWebhookService {
+    private config;
+    private handlers;
+    private processedEvents;
+    private retryQueue;
+    private ledgerUpdateCallback?;
+    private stats;
+    constructor(config: WebhookServiceConfig);
+    /**
+     * Verify a webhook's HMAC-SHA256 signature.
+     */
+    verifySignature(rawBody: string, signature: string, provider: WebhookProvider): WebhookVerificationResult;
+    /**
+     * Process a verified webhook payload.
+     */
+    processWebhook(payload: WebhookPayload): Promise<WebhookProcessingResult>;
+    /**
+     * Register a handler for a specific webhook event type.
+     */
+    on(eventType: WebhookEventType, handler: WebhookHandler): void;
+    /**
+     * Remove a handler for a specific webhook event type.
+     */
+    off(eventType: WebhookEventType, handler: WebhookHandler): void;
+    /**
+     * Set callback for ledger entry updates.
+     */
+    onLedgerUpdate(callback: (entryId: string, updates: Partial<LedgerEntry>) => void): void;
+    /**
+     * Add a failed webhook to the retry queue.
+     */
+    private addToRetryQueue;
+    /**
+     * Process retry queue entries that are ready.
+     */
+    processRetryQueue(): Promise<number>;
+    /**
+     * Get retry queue length.
+     */
+    getRetryQueueLength(): number;
+    /**
+     * Check if an event has been processed.
+     */
+    isProcessed(eventId: string): boolean;
+    /**
+     * Get comprehensive stats.
+     */
+    getStats(): typeof this.stats & {
+        retryQueueLength: number;
+    };
+    /**
+     * Create a webhook signature for testing purposes.
+     */
+    createSignature(rawBody: string, provider: WebhookProvider): string;
+    private emitTelemetry;
+}
+
+/**
+ * RevenueSplitter — Deterministic revenue splitting using bigint arithmetic.
+ *
+ * Splits revenue among multiple recipients with exact-sum invariant:
+ * sum(shares) === total (no rounding leakage).
+ *
+ * Moved from core into framework as part of FW-0.6.
+ *
+ * @module economy/RevenueSplitter
+ */
+interface SplitRecipient {
+    /** Unique recipient ID (agent, creator, platform) */
+    id: string;
+    /** Basis points (1/10000) — e.g., 5000 = 50% */
+    basisPoints: number;
+}
+interface SplitResult {
+    /** Individual shares keyed by recipient ID */
+    shares: Map<string, bigint>;
+    /** Total input amount */
+    total: bigint;
+    /** Any dust (remainder) allocated to the first recipient */
+    dust: bigint;
+    /** Human-readable breakdown */
+    breakdown: SplitBreakdownEntry[];
+}
+interface SplitBreakdownEntry {
+    recipientId: string;
+    basisPoints: number;
+    amount: bigint;
+    percentage: string;
+}
+declare class RevenueSplitter {
+    private 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: SplitRecipient[]);
+    /**
+     * 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: bigint): SplitResult;
+    /**
+     * Split a numeric amount (convenience wrapper).
+     * Converts to bigint internally.
+     */
+    splitNumeric(totalAmount: number): SplitResult;
+    /**
+     * Get the configured recipients.
+     */
+    getRecipients(): readonly SplitRecipient[];
+    /**
+     * Validate that a split result sums correctly.
+     */
+    static validate(result: SplitResult): boolean;
+}
+
+/**
+ * InvisibleWallet — Framework stub for zero-friction wallet abstraction.
+ *
+ * The canonical implementation lives in @holoscript/marketplace-api.
+ * This stub provides the type-compatible interface for framework consumers
+ * who don't need the full viem/blockchain dependency.
+ *
+ * For full blockchain operations, use:
+ *   import { InvisibleWallet } from '@holoscript/marketplace-api';
+ *
+ * FW-0.6 — Moved wallet interface into framework.
+ *
+ * @module economy/InvisibleWallet
+ */
+type HexAddress = `0x${string}`;
+interface InvisibleWalletConfig {
+    /** Use testnet instead of mainnet */
+    testnet?: boolean;
+    /** Custom RPC URL */
+    rpcUrl?: string;
+}
+interface WalletInfo {
+    address: HexAddress;
+    chainId: number;
+    isTestnet: boolean;
+}
+/**
+ * Lightweight InvisibleWallet for framework consumers.
+ *
+ * Provides address management and config without blockchain dependencies.
+ * For signing transactions, use the full implementation from marketplace-api.
+ */
+declare class InvisibleWalletStub {
+    private address;
+    private chainId;
+    private isTestnet;
+    constructor(address: HexAddress, config?: InvisibleWalletConfig);
+    /**
+     * Create from an address string (no private key needed for read-only).
+     */
+    static fromAddress(address: string, config?: InvisibleWalletConfig): InvisibleWalletStub;
+    /** Get the wallet address */
+    getAddress(): HexAddress;
+    /** Get chain ID */
+    getChainId(): number;
+    /** Get wallet info */
+    getInfo(): WalletInfo;
+}
+
+export { type WebhookProcessingResult as $, type RevenueEvent as A, type Bounty as B, CHAIN_IDS as C, type RevenuePeriod as D, RevenueSplitter as E, type SettlementEvent as F, type SettlementEventListener as G, type SettlementEventType as H, InvisibleWalletStub as I, type SettlementMode as J, type KnowledgeListing as K, type LedgerEntry as L, MICRO_PAYMENT_THRESHOLD as M, type SplitBreakdownEntry as N, type SplitRecipient as O, PaymentGateway as P, type SplitResult as Q, type ResourceCategory as R, type SettlementChain as S, type TelemetryCollector as T, USDC_CONTRACTS as U, type InvisibleWalletConfig as V, type HexAddress as W, type WalletInfo as X, type WebhookEventType as Y, type WebhookHandler as Z, type WebhookPayload as _, type ResourceUsageNode as a, computeExcitability as a$, type WebhookProvider as a0, type WebhookServiceConfig as a1, type WebhookVerificationResult as a2, X402Facilitator as a3, type X402FacilitatorConfig as a4, type X402PaymentOption as a5, type X402PaymentPayload as a6, type X402PaymentRequired as a7, type X402SettlementResult as a8, type X402VerificationResult as a9, type DomainConsolidationConfig as aA, type KnowledgeInsight as aB, type ProtocolAgentConfig as aC, type ProtocolAgentHandle as aD, type AgentCycleResult as aE, type AgentPresenceStatus as aF, type AgentRole as aG, type AgentStatus as aH, type ClaimFilter as aI, type ConsensusMode as aJ, DOMAIN_CONSOLIDATION as aK, DOMAIN_HALF_LIVES as aL, type EmbedResult as aM, KNOWLEDGE_DOMAINS as aN, type KnowledgeConfig as aO, type LLMProvider as aP, type PhaseHook as aQ, type PresenceConfig as aR, type ProtocolStyle as aS, RECONSOLIDATION_WINDOW_MS as aT, type ReputationTier as aU, type SemanticSearchOptions as aV, type SlotInfo as aW, type SlotRole as aX, type Suggestion as aY, type SuggestionVoteEntry as aZ, applyHalfLifeDecay as a_, X402_VERSION as aa, creditTraitHandler as ab, type StoredEntry as ac, type ModelConfig as ad, KnowledgeStore as ae, type AgentConfig as af, type TeamConfig as ag, type TaskDef as ah, type CycleResult as ai, type ProposalResult as aj, type AgentRuntime as ak, type SuggestionCreateResult as al, type SuggestionVoteResult as am, type SuggestionStatus as an, type SuggestionListResult as ao, type TeamMode as ap, type SetModeResult as aq, type DeriveResult as ar, type AgentPresence as as, type PresenceResult as at, type HeartbeatResult as au, type ExcitabilityMetadata as av, type KnowledgeDomain as aw, type HotBufferEntry as ax, type ConsolidationResult as ay, type ReconsolidationEvent as az, type BountyCurrency as b, triggerReconsolidation as b0, BountyManager as c, type BountyManagerConfig as d, type BountyReward as e, type BountyStatus as f, CHAIN_ID_TO_NETWORK as g, type ClaimResult as h, type CompletionProof as i, type CreatorEarnings as j, CreatorRevenueAggregator as k, type CreditTraitConfig as l, KnowledgeMarketplace as m, type ListingResult as n, type ListingStatus as o, MicroPaymentLedger as p, type PaymentScheme as q, PaymentWebhookService as r, type PayoutRecord as s, type PayoutResult as t, type PluginRevenue as u, type PricingFactors as v, type PurchaseResult as w, type RefundRequest as x, type RefundResult as y, type RevenueAggregatorConfig as z };