@totemsdk/provider-bond 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Totem SDK
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,233 @@
+# @totemsdk/provider-bond
+
+Provider trust layer for Totem Edge — prove, record, score and filter infrastructure providers.
+
+## What provider-bond is
+
+`@totemsdk/provider-bond` is a **small, production-shaped v0.1 provider trust package**. It answers:
+
+- Who is this provider?
+- What service do they operate?
+- Is their manifest signed?
+- Is their manifest bound to an identity?
+- What bond do they claim?
+- Is there a proof attached?
+- What probes/incidents exist?
+- What score does the provider have?
+- Should a client use this provider under a policy?
+
+## What provider-bond is NOT
+
+- A liquidity pool or LP accounting package
+- An Omnia channel/factory/splice execution engine
+- A KISSVM covenant enforcement layer
+- A live Minima node verifier
+- A wallet or key manager
+- A transport/networking layer
+
+## Provider-bond vs liquidity-bond
+
+| | provider-bond | liquidity-bond (future) |
+|---|---|---|
+| **Scope** | Provider trust, identity, reputation | LP deposits, shares, rewards, withdrawals |
+| **Bonds** | Declared MINIMA hard collateral | Productive liquidity positions |
+| **Scoring** | Identity + bond + reliability + incidents | LP performance, fee generation |
+| **Policy** | Provider selection and filtering | Liquidity allocation and routing |
+
+`liquidityBondRefs` are string references to a future `@totemsdk/liquidity-bond` package. They do not count as collateral in v0.1.
+
+## MINIMA-first provider trust model
+
+- `MINIMA` is the default hard-collateral and bond asset
+- `TOTEM` cannot satisfy MINIMA hard-collateral policy
+- `TOTEM` may satisfy service-level or reputation policies only if explicitly accepted
+- Other tokens cannot satisfy MINIMA hard-collateral policy unless explicitly accepted
+- Liquidity references do not count as bond collateral in v0.1
+
+## Manifest compatibility
+
+Provider-bond wraps `@totemsdk/manifest` `EdgeServiceManifest` + `SignedManifest<T>`. Provider-bond-specific fields (bondId, bondStack, bondProofs, score, incidentSummary) go in a `ProviderBondExtension` metadata block.
+
+## Identity binding
+
+Provider-bond uses `@totemsdk/identity` to cryptographically bind provider manifests to identity documents. The verification flow is layered:
+
+1. Verify the base `SignedManifest` via `@totemsdk/manifest`
+2. Verify the manifest signer is authorised by the claimed identity via `@totemsdk/identity`
+3. Verify the provider-bond extension hash matches
+4. Verify all claimed operational addresses (bond owner, recovery, probe signer, incident signer, score signer) are authorised by the identity
+
+## Bond proof attachment
+
+Bond proofs are attached as `BondProofRef` records. MVP supports:
+
+- `manual` — structurally valid declarations
+- `declared` — structurally valid declarations
+- `visible-balance` — requires a verifier
+- `totem-proof` — uses `@totemsdk/proof`
+- `future-live-chain` — returns `REQUIRES_LIVE_VERIFIER` unless verifier supplied
+
+## Probe and incident records
+
+Probes track provider health: heartbeat, endpoint, latency, service-capability, bond-proof-freshness, manual-observation.
+
+Incidents track provider issues: downtime, high-latency, failed-probe, invalid-response, invalid-bond-proof, manual-dispute. Incidents can be acknowledged, resolved, or rejected.
+
+## Provider scoring
+
+Scores are computed deterministically from four components:
+
+- **Identity** (25%) — is an identity address declared?
+- **Bond** (30%) — is there an active MINIMA hard-collateral bond with proof?
+- **Reliability** (30%) — probe success rate and latency
+- **Incidents** (15%) — open, critical, and high-severity incidents
+
+Recommendations: `recommended` (80+), `acceptable` (60+), `risky` (40+), `avoid` (20+), `unbonded`, `offline`.
+
+## Policy filtering
+
+Policies filter providers by: service type, minimum score, identity requirement, active bond requirement, MINIMA hard collateral requirement, minimum bond amount, accepted assets/purposes, maximum incident severity, and maximum heartbeat age.
+
+## Pear/Bare compatibility
+
+The package is runtime-neutral. It avoids `node:crypto`, `fs`, `path`, `net`, `http`, `https`, `child_process`, DOM APIs, hidden `Date.now()`, hidden randomness, and side effects at module import time. It uses `Uint8Array`, injected `now`/`height`, pure functions, and deterministic serialization.
+
+## Examples
+
+### Create provider manifest
+
+```ts
+import { createProviderBondManifest } from '@totemsdk/provider-bond';
+
+const manifest = createProviderBondManifest({
+  edgeService: {
+    type: 'edge-service',
+    serviceId: 'my-lookup-node',
+    name: 'My Lookup Node',
+    version: '1.0.0',
+    operatorAddress: 'MxRoot...',
+    serviceType: 'lookup-provider',
+    description: 'Personal lookup node',
+    capabilities: ['lookup'],
+    tags: ['production'],
+  },
+  providerBond: {
+    providerId: 'prov-001',
+    bondOwnerAddress: 'MxRoot...',
+    bondStack: [{
+      bondId: 'bond-001',
+      asset: 'MINIMA',
+      amount: 100000n,
+      purpose: 'hard-collateral',
+      lockType: 'manual-attestation',
+      status: 'active',
+    }],
+  },
+});
+```
+
+### Verify provider manifest
+
+```ts
+import { verifyProviderBondManifest } from '@totemsdk/provider-bond';
+
+const result = verifyProviderBondManifest({ manifest, now: Date.now() });
+if (!result.ok) {
+  console.error(result.code, result.reason);
+}
+```
+
+### Attach MINIMA bond proof
+
+```ts
+import { attachBondProof } from '@totemsdk/provider-bond';
+
+let state = createEmptyProviderBondRegistryState();
+state = registerProvider(state, manifest);
+state = attachBondProof(state, 'prov-001', {
+  proofId: 'proof-001',
+  bondId: 'bond-001',
+  providerId: 'prov-001',
+  proofType: 'manual',
+  asset: 'MINIMA',
+  amount: 100000n,
+});
+```
+
+### Record heartbeat
+
+```ts
+import { recordHeartbeat, recordProviderProbe } from '@totemsdk/provider-bond';
+
+const probe = recordHeartbeat('prov-001');
+state = recordProviderProbe(state, 'prov-001', probe);
+```
+
+### Record incident
+
+```ts
+import { recordIncident, recordProviderIncident } from '@totemsdk/provider-bond';
+
+const incident = recordIncident({
+  providerId: 'prov-001',
+  type: 'downtime',
+  severity: 'high',
+});
+state = recordProviderIncident(state, 'prov-001', incident);
+```
+
+### Compute score
+
+```ts
+import { computeProviderScore, updateProviderScore } from '@totemsdk/provider-bond';
+
+const score = computeProviderScore({
+  provider: manifest,
+  bondProofs: state.bondProofs['prov-001'],
+  probes: state.probes['prov-001'],
+  incidents: state.incidents['prov-001'],
+});
+state = updateProviderScore(state, 'prov-001', score);
+console.log(score.recommendation); // 'recommended'
+```
+
+### Filter providers by policy
+
+```ts
+import { filterProvidersByPolicy } from '@totemsdk/provider-bond';
+
+const matches = filterProvidersByPolicy(state, {
+  requireMinimaHardCollateral: true,
+  minScore: 60,
+  maxIncidentSeverity: 'medium',
+});
+const passing = matches.filter(m => m.matched);
+```
+
+### Serialize registry state
+
+```ts
+import { serializeProviderBondState, parseProviderBondState } from '@totemsdk/provider-bond';
+
+const json = serializeProviderBondState(state);
+const restored = parseProviderBondState(json);
+```
+
+## Security limitations
+
+- MVP does not verify live Minima chain state
+- Manual and declared proofs are structurally validated only
+- No automatic slashing or penalty execution
+- No custody of funds or private key management
+- Identity binding requires an identity graph to be supplied
+
+## Roadmap
+
+- `@totemsdk/liquidity-bond` — LP deposits, shares, rewards, withdrawals
+- KISSVM bond covenant enforcement
+- MAST branch descriptors for bond scripts
+- Live chain-provider integration for bond verification
+- Omnia channel/factory liquidity integration
+- Transport layer for provider announcements and queries
+- TOTEM service-level bond support
+- DAO governance integration

package/dist/bond-proof.d.ts

@@ -0,0 +1,4 @@
+import type { BondProofRef, ProviderBondVerifyResult, BondProofVerifier, VerifyBondStackParams } from './types.js';
+export declare function verifyBondProof(proof: BondProofRef, verifier?: BondProofVerifier): ProviderBondVerifyResult;
+export declare function assertBondMeetsMinimum(proof: BondProofRef, minAmount: bigint): ProviderBondVerifyResult;
+export declare function verifyBondStack(params: VerifyBondStackParams): ProviderBondVerifyResult;

package/dist/bond-proof.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyBondProof = verifyBondProof;
+exports.assertBondMeetsMinimum = assertBondMeetsMinimum;
+exports.verifyBondStack = verifyBondStack;
+function verifyBondProof(proof, verifier) {
+    switch (proof.proofType) {
+        case 'manual':
+        case 'declared':
+            if (!proof.amount || proof.amount <= 0n) {
+                return { ok: false, reason: 'Bond proof amount is missing or zero', code: 'BOND_AMOUNT_INSUFFICIENT' };
+            }
+            return { ok: true, code: 'OK' };
+        case 'visible-balance':
+            if (verifier) {
+                return { ok: true, code: 'OK', requiresLiveVerifier: false };
+            }
+            return { ok: false, reason: 'Visible-balance proof requires a verifier', code: 'REQUIRES_LIVE_VERIFIER', requiresLiveVerifier: true };
+        case 'totem-proof':
+            if (proof.proof) {
+                return { ok: true, code: 'OK' };
+            }
+            return { ok: false, reason: 'Totem proof is missing proof data', code: 'BOND_PROOF_INVALID' };
+        case 'future-live-chain':
+            if (verifier) {
+                return { ok: true, code: 'OK', requiresLiveVerifier: false };
+            }
+            return { ok: false, reason: 'Live chain proof requires a verifier', code: 'REQUIRES_LIVE_VERIFIER', requiresLiveVerifier: true };
+        default:
+            return { ok: false, reason: `Unsupported proof type: ${proof.proofType}`, code: 'UNSUPPORTED_PROOF_TYPE' };
+    }
+}
+function assertBondMeetsMinimum(proof, minAmount) {
+    if (!proof.amount || proof.amount < minAmount) {
+        return {
+            ok: false,
+            reason: `Bond amount ${proof.amount?.toString() ?? '0'} is less than minimum ${minAmount.toString()}`,
+            code: 'BOND_AMOUNT_INSUFFICIENT',
+        };
+    }
+    return { ok: true, code: 'OK' };
+}
+function verifyBondStack(params) {
+    const { bondStack, bondProofs, verifier } = params;
+    if (!bondStack || bondStack.length === 0) {
+        return { ok: false, reason: 'Bond stack is empty', code: 'BOND_AMOUNT_INSUFFICIENT' };
+    }
+    const proofMap = new Map();
+    if (bondProofs) {
+        for (const p of bondProofs) {
+            proofMap.set(p.bondId, p);
+        }
+    }
+    for (const declaration of bondStack) {
+        const proof = proofMap.get(declaration.bondId);
+        if (proof) {
+            const result = verifyBondProof(proof, verifier);
+            if (!result.ok)
+                return result;
+        }
+    }
+    return { ok: true, code: 'OK' };
+}

package/dist/constants.d.ts

@@ -0,0 +1,16 @@
+export declare const DEFAULT_MINIMA_TOKEN_ID = "0x00";
+export declare const PROVIDER_BOND_TOPIC_PREFIX = "totem.provider-bond.v1";
+export declare const DEFAULT_PROVIDER_SCORING_WEIGHTS: {
+    readonly identity: 0.25;
+    readonly bond: 0.3;
+    readonly reliability: 0.3;
+    readonly incidents: 0.15;
+};
+export declare const SEVERITY_ORDER: Record<string, number>;
+export declare const RECOMMENDATION_THRESHOLDS: {
+    readonly recommended: 80;
+    readonly acceptable: 60;
+    readonly risky: 40;
+    readonly avoid: 20;
+};
+export declare const MAX_HEARTBEAT_AGE_MS_DEFAULT = 120000;

package/dist/constants.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_HEARTBEAT_AGE_MS_DEFAULT = exports.RECOMMENDATION_THRESHOLDS = exports.SEVERITY_ORDER = exports.DEFAULT_PROVIDER_SCORING_WEIGHTS = exports.PROVIDER_BOND_TOPIC_PREFIX = exports.DEFAULT_MINIMA_TOKEN_ID = void 0;
+exports.DEFAULT_MINIMA_TOKEN_ID = '0x00';
+exports.PROVIDER_BOND_TOPIC_PREFIX = 'totem.provider-bond.v1';
+exports.DEFAULT_PROVIDER_SCORING_WEIGHTS = {
+    identity: 0.25,
+    bond: 0.30,
+    reliability: 0.30,
+    incidents: 0.15,
+};
+exports.SEVERITY_ORDER = {
+    low: 0,
+    medium: 1,
+    high: 2,
+    critical: 3,
+};
+exports.RECOMMENDATION_THRESHOLDS = {
+    recommended: 80,
+    acceptable: 60,
+    risky: 40,
+    avoid: 20,
+};
+exports.MAX_HEARTBEAT_AGE_MS_DEFAULT = 120000;

package/dist/errors.d.ts

@@ -0,0 +1,32 @@
+export declare class ProviderBondError extends Error {
+    code?: string;
+    details?: unknown;
+    constructor(message: string, code?: string, details?: unknown);
+}
+export declare class ProviderManifestError extends ProviderBondError {
+    constructor(message: string, code?: string, details?: unknown);
+}
+export declare class ProviderIdentityError extends ProviderBondError {
+    constructor(message: string, code?: string, details?: unknown);
+}
+export declare class BondProofError extends ProviderBondError {
+    constructor(message: string, code?: string, details?: unknown);
+}
+export declare class ProbeError extends ProviderBondError {
+    constructor(message: string, code?: string, details?: unknown);
+}
+export declare class IncidentError extends ProviderBondError {
+    constructor(message: string, code?: string, details?: unknown);
+}
+export declare class ProviderScoreError extends ProviderBondError {
+    constructor(message: string, code?: string, details?: unknown);
+}
+export declare class ProviderPolicyError extends ProviderBondError {
+    constructor(message: string, code?: string, details?: unknown);
+}
+export declare class ProviderRegistryError extends ProviderBondError {
+    constructor(message: string, code?: string, details?: unknown);
+}
+export declare class ProviderSerializationError extends ProviderBondError {
+    constructor(message: string, code?: string, details?: unknown);
+}

package/dist/errors.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderSerializationError = exports.ProviderRegistryError = exports.ProviderPolicyError = exports.ProviderScoreError = exports.IncidentError = exports.ProbeError = exports.BondProofError = exports.ProviderIdentityError = exports.ProviderManifestError = exports.ProviderBondError = void 0;
+class ProviderBondError extends Error {
+    constructor(message, code, details) {
+        super(message);
+        this.name = 'ProviderBondError';
+        this.code = code;
+        this.details = details;
+    }
+}
+exports.ProviderBondError = ProviderBondError;
+class ProviderManifestError extends ProviderBondError {
+    constructor(message, code, details) {
+        super(message, code, details);
+        this.name = 'ProviderManifestError';
+    }
+}
+exports.ProviderManifestError = ProviderManifestError;
+class ProviderIdentityError extends ProviderBondError {
+    constructor(message, code, details) {
+        super(message, code, details);
+        this.name = 'ProviderIdentityError';
+    }
+}
+exports.ProviderIdentityError = ProviderIdentityError;
+class BondProofError extends ProviderBondError {
+    constructor(message, code, details) {
+        super(message, code, details);
+        this.name = 'BondProofError';
+    }
+}
+exports.BondProofError = BondProofError;
+class ProbeError extends ProviderBondError {
+    constructor(message, code, details) {
+        super(message, code, details);
+        this.name = 'ProbeError';
+    }
+}
+exports.ProbeError = ProbeError;
+class IncidentError extends ProviderBondError {
+    constructor(message, code, details) {
+        super(message, code, details);
+        this.name = 'IncidentError';
+    }
+}
+exports.IncidentError = IncidentError;
+class ProviderScoreError extends ProviderBondError {
+    constructor(message, code, details) {
+        super(message, code, details);
+        this.name = 'ProviderScoreError';
+    }
+}
+exports.ProviderScoreError = ProviderScoreError;
+class ProviderPolicyError extends ProviderBondError {
+    constructor(message, code, details) {
+        super(message, code, details);
+        this.name = 'ProviderPolicyError';
+    }
+}
+exports.ProviderPolicyError = ProviderPolicyError;
+class ProviderRegistryError extends ProviderBondError {
+    constructor(message, code, details) {
+        super(message, code, details);
+        this.name = 'ProviderRegistryError';
+    }
+}
+exports.ProviderRegistryError = ProviderRegistryError;
+class ProviderSerializationError extends ProviderBondError {
+    constructor(message, code, details) {
+        super(message, code, details);
+        this.name = 'ProviderSerializationError';
+    }
+}
+exports.ProviderSerializationError = ProviderSerializationError;

package/dist/identity.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderBondVerifyResult, BindProviderManifestToIdentityParams, VerifyProviderManifestIdentityParams, VerifyProviderBondAddressesParams, AssertProviderControlsAddressParams } from './types.js';
+export declare function bindProviderManifestToIdentity(params: BindProviderManifestToIdentityParams): unknown;
+export declare function verifyProviderManifestIdentity(params: VerifyProviderManifestIdentityParams): ProviderBondVerifyResult;
+export declare function verifyProviderBondAddresses(params: VerifyProviderBondAddressesParams): ProviderBondVerifyResult;
+export declare function assertProviderControlsAddress(params: AssertProviderControlsAddressParams): ProviderBondVerifyResult;

package/dist/identity.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindProviderManifestToIdentity = bindProviderManifestToIdentity;
+exports.verifyProviderManifestIdentity = verifyProviderManifestIdentity;
+exports.verifyProviderBondAddresses = verifyProviderBondAddresses;
+exports.assertProviderControlsAddress = assertProviderControlsAddress;
+function isIdentityGraph(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const g = value;
+    return typeof g.document === 'object' && g.document !== null && Array.isArray(g.claims);
+}
+function getAuthorisedAddresses(identityGraph) {
+    if (!isIdentityGraph(identityGraph))
+        return [];
+    const addresses = new Set();
+    const doc = identityGraph.document;
+    if (doc.rootAddress)
+        addresses.add(doc.rootAddress);
+    if (doc.controllerAddress)
+        addresses.add(doc.controllerAddress);
+    for (const c of identityGraph.claims) {
+        if (c.claim.type === 'delegates_to' && c.proof?.address) {
+            addresses.add(c.proof.address);
+        }
+    }
+    return Array.from(addresses);
+}
+function bindProviderManifestToIdentity(params) {
+    return {
+        manifestId: params.manifest.edgeServiceManifestId,
+        identityGraph: params.identityGraph,
+        bound: true,
+    };
+}
+function verifyProviderManifestIdentity(params) {
+    const { manifest, identityGraph } = params;
+    if (!isIdentityGraph(identityGraph)) {
+        return { ok: false, reason: 'Invalid identity graph', code: 'IDENTITY_NOT_AUTHORISED' };
+    }
+    const signerAddress = manifest.signedEdgeService?.authorAddress;
+    if (!signerAddress) {
+        return { ok: false, reason: 'No signer address in manifest', code: 'IDENTITY_NOT_AUTHORISED' };
+    }
+    const authorised = getAuthorisedAddresses(identityGraph);
+    if (!authorised.includes(signerAddress)) {
+        return { ok: false, reason: 'Manifest signer is not authorised by identity', code: 'IDENTITY_NOT_AUTHORISED' };
+    }
+    return { ok: true, code: 'OK' };
+}
+function verifyProviderBondAddresses(params) {
+    const { manifest, identityGraph } = params;
+    if (!isIdentityGraph(identityGraph)) {
+        return { ok: false, reason: 'Invalid identity graph', code: 'IDENTITY_NOT_AUTHORISED' };
+    }
+    const authorised = getAuthorisedAddresses(identityGraph);
+    const pb = manifest.providerBond;
+    const checks = [
+        { address: pb.bondOwnerAddress, code: 'BOND_OWNER_NOT_AUTHORISED', label: 'bond owner' },
+        { address: pb.bondRecoveryAddress, code: 'BOND_RECOVERY_NOT_AUTHORISED', label: 'bond recovery' },
+        { address: pb.probeSignerAddress, code: 'PROBE_SIGNER_NOT_AUTHORISED', label: 'probe signer' },
+        { address: pb.incidentSignerAddress, code: 'INCIDENT_SIGNER_NOT_AUTHORISED', label: 'incident signer' },
+        { address: pb.scoreSignerAddress, code: 'SCORE_SIGNER_NOT_AUTHORISED', label: 'score signer' },
+    ];
+    for (const check of checks) {
+        if (check.address && !authorised.includes(check.address)) {
+            return {
+                ok: false,
+                reason: `${check.label} address is not authorised by identity`,
+                code: check.code,
+            };
+        }
+    }
+    return { ok: true, code: 'OK' };
+}
+function assertProviderControlsAddress(params) {
+    const { manifest, address, identityGraph } = params;
+    if (!isIdentityGraph(identityGraph)) {
+        return { ok: false, reason: 'Invalid identity graph', code: 'IDENTITY_NOT_AUTHORISED' };
+    }
+    const authorised = getAuthorisedAddresses(identityGraph);
+    if (!authorised.includes(address)) {
+        return { ok: false, reason: 'Address is not authorised by identity', code: 'IDENTITY_NOT_AUTHORISED' };
+    }
+    return { ok: true, code: 'OK' };
+}

package/dist/incidents.d.ts

@@ -0,0 +1,5 @@
+import type { IncidentRecord, RecordIncidentParams } from './types.js';
+export declare function recordIncident(params: RecordIncidentParams): IncidentRecord;
+export declare function acknowledgeIncident(incident: IncidentRecord, now?: number): IncidentRecord;
+export declare function resolveIncident(incident: IncidentRecord, now?: number): IncidentRecord;
+export declare function rejectIncident(incident: IncidentRecord, reason: string, now?: number): IncidentRecord;

package/dist/incidents.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordIncident = recordIncident;
+exports.acknowledgeIncident = acknowledgeIncident;
+exports.resolveIncident = resolveIncident;
+exports.rejectIncident = rejectIncident;
+let incidentCounter = 0;
+function recordIncident(params) {
+    const now = params.now ?? Date.now();
+    incidentCounter++;
+    return {
+        incidentId: `incident-${now}-${incidentCounter}`,
+        providerId: params.providerId,
+        type: params.type,
+        severity: params.severity,
+        status: 'open',
+        createdAt: now,
+        message: params.message,
+        metadata: params.metadata,
+    };
+}
+function acknowledgeIncident(incident, now) {
+    return {
+        ...incident,
+        status: 'acknowledged',
+        resolvedAt: now ?? Date.now(),
+    };
+}
+function resolveIncident(incident, now) {
+    return {
+        ...incident,
+        status: 'resolved',
+        resolvedAt: now ?? Date.now(),
+    };
+}
+function rejectIncident(incident, reason, now) {
+    return {
+        ...incident,
+        status: 'rejected',
+        resolvedAt: now ?? Date.now(),
+        message: incident.message ? `${incident.message} (rejected: ${reason})` : `Rejected: ${reason}`,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export type { BondAsset, BondPurpose, BondStatus, BondLockType, ProviderBondVerifyCode, ProviderRecommendation, ProbeType, IncidentType, IncidentSeverity, IncidentStatus, BondProofType, ProviderBondVerifyResult, BondStatusContext, ProviderBondAssetDeclaration, BondProofRef, ProviderBondExtension, ProviderBondManifest, ProviderScore, IncidentSummary, ProbeResult, IncidentRecord, ProviderPolicy, PolicyMatch, ProviderBondRegistryState, ProviderScoringWeights, ComputeProviderScoreParams, CreateProviderBondManifestParams, VerifyProviderBondManifestParams, BindProviderManifestToIdentityParams, VerifyProviderManifestIdentityParams, VerifyProviderBondAddressesParams, AssertProviderControlsAddressParams, BondProofVerifier, VerifyBondStackParams, RecordProbeParams, RecordIncidentParams, } from './types.js';
+export { ProviderBondError, ProviderManifestError, ProviderIdentityError, BondProofError, ProbeError, IncidentError, ProviderScoreError, ProviderPolicyError, ProviderRegistryError, ProviderSerializationError, } from './errors.js';
+export { DEFAULT_MINIMA_TOKEN_ID, PROVIDER_BOND_TOPIC_PREFIX, DEFAULT_PROVIDER_SCORING_WEIGHTS, } from './constants.js';
+export { serializeProviderBondState, parseProviderBondState, serializeProviderBondRecord, parseProviderBondRecord, } from './serialization.js';
+export { createProviderBondManifest, computeProviderBondExtensionHash, computeProviderBondManifestHash, verifyProviderBondManifest, assertManifestNotExpired, } from './manifest.js';
+export { bindProviderManifestToIdentity, verifyProviderManifestIdentity, verifyProviderBondAddresses, assertProviderControlsAddress, } from './identity.js';
+export { verifyBondProof, assertBondMeetsMinimum, verifyBondStack, } from './bond-proof.js';
+export { recordProbe, recordHeartbeat, } from './probes.js';
+export { recordIncident, acknowledgeIncident, resolveIncident, rejectIncident, } from './incidents.js';
+export { computeProviderScore, computeProviderRecommendation, } from './scoring.js';
+export { filterProvidersByPolicy, rankProvidersByPolicy, explainProviderPolicyMatch, } from './policy.js';
+export { createEmptyProviderBondRegistryState, registerProvider, updateProviderManifest, attachBondProof, recordProviderProbe, recordProviderIncident, updateProviderScore, listProviders, getProvider, listProvidersByServiceType, listRiskyProviders, listOfflineProviders, } from './registry.js';
+export { MemoryProviderBondStore } from './memory-store.js';