API docs

import { runDeltaEngine, validateBundle, verifyReceipt } from '@uvrn/core';

const bundle = {
  bundleId: 'example-001',
  claim: 'Sources agree within 10%.',
  thresholdPct: 0.10,
  dataSpecs: [
    {
      id: 'source-a', label: 'Source A',
      sourceKind: 'report', originDocIds: ['doc-a'],
      metrics: [{ key: 'count', value: 100 }],
    },
    {
      id: 'source-b', label: 'Source B',
      sourceKind: 'report', originDocIds: ['doc-b'],
      metrics: [{ key: 'count', value: 105 }],
    },
  ],
};

const receipt = runDeltaEngine(bundle);
console.log(receipt.outcome);    // 'consensus' | 'indeterminate'
console.log(receipt.deltaFinal); // max delta across metrics
console.log(receipt.hash);       // SHA-256 of canonical receipt

import { DeltaEngineClient, BundleBuilder } from '@uvrn/sdk';

// Local mode — runs in-process, no server needed
const client = new DeltaEngineClient({ mode: 'local' });

const bundle = new BundleBuilder()
  .setClaim('Sources agree within 5%')
  .addDataSpecQuick('src-a', 'Source A', 'report', ['doc-001'], [{ key: 'total', value: 1000 }])
  .addDataSpecQuick('src-b', 'Source B', 'report', ['doc-002'], [{ key: 'total', value: 1020 }])
  .setThreshold(0.05)
  .build();

const receipt = await client.runEngine(bundle);
console.log(receipt.outcome);    // 'consensus'
console.log(receipt.deltaFinal); // 0.02
console.log(receipt.hash);

import { runDeltaEngine } from '@uvrn/core';
import { wrapInDRVC3, validateDRVC3, extractDeltaReceipt } from '@uvrn/adapter';
import { Wallet } from 'ethers';

const receipt = runDeltaEngine(bundle);

const wallet = new Wallet(process.env.SIGNER_PRIVATE_KEY);
const drvc3 = await wrapInDRVC3(receipt, wallet, {
  issuer: 'my-service',
  event:  'delta-reconciliation',
  extensions: { source: 'https://example.com/feed' },
});

const valid = validateDRVC3(drvc3);         // true
const back  = extractDeltaReceipt(drvc3);   // original DeltaReceipt

// claude_desktop_config.json
{
  "mcpServers": {
    "delta-engine": {
      "command": "npx",
      "args": ["-y", "@uvrn/mcp"]
    }
  }
}

// Or run standalone:
npx @uvrn/mcp

// Start with npx:
npx @uvrn/api

// Or from your app:
import { startServer, createServer } from '@uvrn/api';

const server = await createServer();
await startServer(server);

// Then call it from any HTTP client:
// POST http://localhost:3000/api/v1/delta/run
// POST http://localhost:3000/api/v1/delta/validate
// POST http://localhost:3000/api/v1/delta/verify
// GET  http://localhost:3000/api/v1/health

# Run a bundle file
uvrn run bundle.json

# Pretty-print output + save receipt
uvrn run bundle.json --output receipt.json --pretty

# Pipe from stdin
cat bundle.json | uvrn run

# Validate structure without running
uvrn validate bundle.json

# Verify receipt integrity
uvrn verify receipt.json

import { computeDrift, DriftMonitor, DRIFT_PROFILES } from '@uvrn/drift';

// One-shot scoring
const result = computeDrift(receipt, DRIFT_PROFILES.fast);
console.log(result.drift.decayed_score); // e.g. 61 (was 88, 24h ago)
console.log(result.drift.status);        // 'DRIFTING'
console.log(result.drift.delta);         // -27

// Continuous monitoring
const monitor = new DriftMonitor({
  intervalMs: 60_000,
  onThreshold: (event) => {
    console.log(`${event.receipt_id}: ${event.from} → ${event.to}`);
  },
});
monitor.watch(receipt, DRIFT_PROFILES.threshold_short);
monitor.start();

import { Agent, ConsoleEmitter, MockFarmConnector, PROFILES } from '@uvrn/agent';

const agent = new Agent({
  farmConnector:  new MockFarmConnector(),
  receiptEmitter: new ConsoleEmitter(),
});

agent.register({
  id:          'clm_sol_001',
  label:       '"Exchange X holds full reserves"',
  query:       'Exchange X proof of reserves 2026',
  driftConfig: PROFILES.solvency,
  intervalMs:  6 * 60 * 60 * 1000, // every 6h
});

agent
  .on('claim:threshold', event => console.warn('THRESHOLD', event))
  .on('receipt:emitted', receipt => { /* save or wire to canon */ })
  .start();

import { Canon, NodeSigner, MockStore } from '@uvrn/canon';

const canon = new Canon({
  stores:      [new MockStore()],
  signer:      new NodeSigner(process.env.UVRN_PRIVATE_KEY),
  canonizerId: 'my-app-prod-01',
  autoSuggest: { enabled: true, consecutiveRuns: 3, minScore: 85 },
});

// Record agent runs — canon auto-suggests when ready
const suggestion = await canon.recordRun(claimId, snapshot);

// Human confirms → canon executes
const result = await canon.canonize({
  driftReceipt:  lastReceipt,
  finalSnapshot: lastSnapshot,
  trigger: { type: 'auto_suggest', confirmed_by: 'shawn', suggestion_id: suggestion.suggestion_id },
  suggestionId: suggestion.suggestion_id,
});

console.log(result.receipt.canon_id);
console.log(result.verified); // true

import { rankSignals } from '@uvrn/algox';

const candidates = [
  { label: 'oversized blazers', url: 'https://vogue.com/a', source: 'vogue.com',
    prominence: 90, observedAt: '2026-05-20', signals: { mentions: 1200 } },
  { label: 'quiet luxury', url: 'https://vogue.com/b', source: 'vogue.com',
    prominence: 85, observedAt: '2026-05-21', signals: { mentions: 1500 } },
  // ...more from your agents
];

const result = await rankSignals(candidates, {
  topK: 10,          // how many to keep
  capPerSource: 3,   // max per source — stops one outlet dominating
  maxAgeDays: 30,    // drop stale signals (null disables)
  weights: { prominence: 1, mentions: 0.001 }, // blend signals, your weights
});

result.ranked;   // ScoredCandidate[] — highest score first, ready to render
result.dropped;  // what was filtered out, each with a 'reason'

import { SignalBus, SignalBridge } from '@uvrn/signal';

const bus = new SignalBus();

bus.on('drift:threshold', (event) => {
  console.log(event.claimId, event.snapshot.adjustedScore);
});

bus.emit('drift:threshold', {
  claimId:  'clm_sol_001',
  status:   'DRIFTING',
  snapshot: { adjustedScore: 67.4, freshness: 52, decayRate: 0.35, timestamp: Date.now() },
});

// Extend with your own events
interface AppEvents extends UVRNEventMap { 'custom:ping': { id: string; ok: boolean } }
const appBus = new SignalBus<AppEvents>();
appBus.emit('custom:ping', { id: 'ping-1', ok: true });

import { SCORE_PROFILES, ScoreBreakdown } from '@uvrn/score';
import type { ScoringProfile } from '@uvrn/score';

const breakdown = new ScoreBreakdown(
  { completeness: 88, parity: 92, freshness: 75 },
  SCORE_PROFILES.financial
);

console.log(breakdown.final);        // 85.5
console.log(breakdown.explanation);  // short factual explanation string
console.log(breakdown.toJSON());     // serializable breakdown object

// Custom profile
const custom: ScoringProfile = {
  name: 'operations',
  description: 'Operational incident claims',
  completenessNote: 'How broad the source coverage is',
  parityNote: 'How closely reports agree',
  freshnessNote: 'How recent the operational data is',
  thresholds: { stable: 78, drifting: 52 },
};

import {
  MockFarmConnector, MockSigner, MockStore,
  fixtures, mockCanonReceipt, mockReceipt,
} from '@uvrn/test';

const receipt     = mockReceipt({ v_score: 88, status: 'STABLE' });
const canonReceipt = mockCanonReceipt({ claim_id: 'clm_001' });

const farm   = new MockFarmConnector({ latencyMs: 25 });
const result = await farm.fetch('clm_001');

const store = new MockStore();
await store.save(canonReceipt);

const signer = new MockSigner({ address: '0xABC123' });
const signed = await signer.sign(receipt);

console.log(fixtures.stableReceipt.v_score); // 92

import { BaseConnector, MultiFarm } from '@uvrn/farm';
import { CoinGeckoFarm, CoinbaseFarm } from '@uvrn/farm/connectors';
import type { ClaimRegistration, FarmResult } from '@uvrn/farm';

// Implement the contract
class MyConnector extends BaseConnector {
  readonly name = 'MyConnector';
  async fetch(claim: ClaimRegistration): Promise<FarmResult> {
    return {
      claimId: claim.id,
      sources: [{ url: 'https://example.com/data', title: 'My source', snippet: 'Evidence here.', publishedAt: new Date().toISOString(), credibility: 0.8 }],
      fetchedAt: new Date().toISOString(),
      durationMs: 10,
    };
  }
}

// Or use reference connectors in parallel
const farm = new MultiFarm([new CoinGeckoFarm(), new CoinbaseFarm()]);

import { normalize, NormalizationProfiles } from '@uvrn/normalize';
import type { NormalizationProfile } from '@uvrn/normalize';

// Use a built-in profile
const result = normalize(farmResult.sources, NormalizationProfiles.financial);

// Or define your own
const customProfile: NormalizationProfile = {
  name: 'custom',
  description: 'My domain normalization',
  transform(source) {
    return { name: source.title, value: source.snippet, unit: 'text', timestamp: Date.parse(source.publishedAt ?? new Date().toISOString()), credibility: source.credibility ?? 0.5, rawData: source, normalizer: 'custom' };
  },
  normalizeTimestamp: (ts) => typeof ts === 'number' ? ts : Date.parse(String(ts)),
  normalizePrecision: (v) => v,
};

import { BUILT_IN_TEMPLATES, MockDomainConnector, runLattice } from '@uvrn/lattice';

const template = BUILT_IN_TEMPLATES.find((t) => t.id === 'builder-radar');

const receipt = await runLattice(
  'Should regional robotics builders enter municipal maintenance markets?',
  template,
  { connector: new MockDomainConnector() }
);

console.log(receipt.vScore, receipt.deltaReceipt.outcome);

import { ConsensusEngine } from '@uvrn/consensus';

const engine = new ConsensusEngine({
  sources: farmResult,
  weights: { credibility: 0.4, recency: 0.3, coverage: 0.3 },
});

const bundle = engine.buildBundle('claim: Exchange X holds full reserves');
const stats  = engine.stats();

console.log(stats.agreementScore);    // weighted consensus score
console.log(stats.summary);           // verbatim-ready description
// Then: runDeltaEngine(bundle) from @uvrn/core

import { CompareEngine } from '@uvrn/compare';

// Head-to-head: two claims, most recent receipts
const result = CompareEngine.compare([receiptA, receiptB], {
  normalize:       true,
  includeTimeline: true,
});

console.log(result.winner);      // claim with higher V-Score
console.log(result.summary);     // verbatim-ready description
console.log(result.divergenceAt); // when the lead changed (if timeline provided)

// Time-series: one claim over time
const series = CompareEngine.compareSeries(receiptHistory, {
  claim: 'clm_sol_001',
});
console.log(series.trend);  // 'improving' | 'stable' | 'declining'

import { defaultRegistry } from '@uvrn/measure';

const registry = defaultRegistry();

const results = registry.runAll({
  claim: 'Two sources report similar revenue.',
  sources: [
    { id: 'source-a', kind: 'numeric', value: 100, label: 'Source A' },
    { id: 'source-b', kind: 'numeric', value: 104, label: 'Source B' },
  ],
  context: {
    agreeThreshold: 0.9,
    divergenceThreshold: 0.1,
    history: [0.55, 0.62, 0.74],
  },
});

import { IdentityRegistry, MockIdentityStore } from '@uvrn/identity';

const registry = new IdentityRegistry({ store: new MockIdentityStore() });

await registry.record({
  signerAddress:  '0xA9F1...',
  receiptId:      'rec_001',
  vScore:         88,
  consensusVScore: 91,
  canonized:       true,
  timestamp:       Date.now(),
});

const rep = await registry.reputation('0xA9F1...');
console.log(rep.score);  // 0–100
console.log(rep.level);  // 'trusted' | 'established' | 'new' | 'unknown'

import { MockTimelineStore, Timeline } from '@uvrn/timeline';

const timeline = new Timeline({ store: new MockTimelineStore() });

const history = await timeline.query('clm_sol_001', {
  from:       '2026-01-01',
  to:         '2026-03-29',
  resolution: 'daily',
});

console.log(history.summary);      // verbatim-ready description
console.log(history.chart.labels); // date labels aligned to resolution
console.log(history.chart.vScores); // V-Score per bucket
// chart data is recharts + chart.js compatible

import { Watcher } from '@uvrn/watch';

const watcher = new Watcher({ agent });

// In-process callback — zero external dependencies
watcher.subscribe('clm_sol_001', {
  on:      'CRITICAL',
  notify:  { callback: (event) => console.log(event.summary) },
  mode:    'once',
  cooldown: 300_000, // 5 min
});

// Custom delivery target
class PagerDutyDelivery {
  async deliver(event) { /* call PagerDuty API */ }
}

watcher.subscribe('clm_sol_001', {
  on:     'DRIFTING',
  notify: { targets: [new PagerDutyDelivery()] },
  mode:   'every',
});

// React
import { ConsensusBadge } from '@uvrn/embed';

<ConsensusBadge
  claimId="clm_sol_001"
  apiUrl="https://api.uvrn.org"
  theme="dark"
  showScore={true}
  showStatus={true}
/>

// Plain HTML (no install)
// <script src="/path/to/embed.umd.js"></script>
// <div data-uvrn-claim="clm_sol_001" data-uvrn-api="https://api.uvrn.org" data-uvrn-theme="dark"></div>

// Programmatic UMD
UVRN.renderBadge(element, { claimId: 'clm_sol_001', apiUrl: 'https://api.uvrn.org', theme: 'dark' });
UVRN.init(); // auto-init all data-uvrn-claim elements

import { generateReceiptKeyPair, wrapMasterReceipt, signReceipt, toHumanView } from '@uvrn/receipt';
import { buildMasterReceipt, runDeltaEngine } from '@uvrn/core';

const master = buildMasterReceipt({ /* base, claim, measurements, nodes */ });
const keys = generateReceiptKeyPair();
const signed = signReceipt(
  wrapMasterReceipt(master, { claim: 'My claim', source: 'my-host', action: 'master.measured' }),
  { privateKey: keys.privateKey, publicKeyRef: 'my-pk-2026-v1' }
);
const view = toHumanView(signed);

import { openUvrnDatabase, SqliteReceiptStore } from '@uvrn/store-sqlite';

const db = openUvrnDatabase('./uvrn.db');
const store = new SqliteReceiptStore(db);
store.save(signedReceipt);
await store.pushToNetwork(workerClient);

import { runDeltaEngine, buildMasterReceipt, wrapMasterReceipt, signReceipt, generateReceiptKeyPair } from '@uvrn/protocol';

const base = runDeltaEngine(bundle);
const master = buildMasterReceipt({ base, claim, measurements, nodes });
const keys = generateReceiptKeyPair();
const signed = signReceipt(wrapMasterReceipt(master, { claim, source: 'my-host', action: 'master.measured' }), { privateKey: keys.privateKey, publicKeyRef: 'my-pk' });