@heyanon-arp/sdk 0.0.15 → 0.0.23

package/dist/index.mjs

@@ -287,6 +287,7 @@ var SPL_TOKEN_PROGRAM_ID_BASE58 = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 var TOKEN_2022_PROGRAM_ID_BASE58 = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
 var ASSOCIATED_TOKEN_PROGRAM_ID_BASE58 = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
 var SYSTEM_PROGRAM_ID_BASE58 = "11111111111111111111111111111111";
+var ESCROW_PROGRAM_ID_BASE58 = "DckBAFZcE1AZWgVsz5ipnwSUy2wWeK5eBPBoyJgKVPzb";
 
 // src/settlement/token-program.ts
 function detectTokenProgramFromOwner(mintAccountOwnerBase58) {
@@ -402,6 +403,7 @@ function isSha256Hex(v) {
 }
 var ED25519_SIG_PREFIX = "ed25519:";
 var PROTOCOL_VERSIONS = ["arp/0.1"];
+var CURRENT_PROTOCOL_VERSION = PROTOCOL_VERSIONS[PROTOCOL_VERSIONS.length - 1];
 
 // src/types/body.ts
 var DECLINE_REASONS = ["missing_brief", "rate_too_low", "out_of_scope", "policy", "expired_proposal", "capacity", "unspecified", "other"];
@@ -412,18 +414,43 @@ var HANDSHAKE_DECISIONS = ["accept", "decline"];
 function isHandshakeDecision(v) {
   return typeof v === "string" && HANDSHAKE_DECISIONS.includes(v);
 }
+var HandshakeDecisions = {
+  ACCEPT: "accept",
+  DECLINE: "decline"
+};
 var DELEGATION_ACTIONS = ["offer", "accept", "decline", "cancel", "fund"];
 function isDelegationAction(v) {
   return typeof v === "string" && DELEGATION_ACTIONS.includes(v);
 }
+var DelegationActions = {
+  OFFER: "offer",
+  ACCEPT: "accept",
+  DECLINE: "decline",
+  CANCEL: "cancel",
+  FUND: "fund"
+};
 var RECEIPT_VERDICTS = ["accepted", "accepted_with_notes", "rejected"];
 function isReceiptVerdict(v) {
   return typeof v === "string" && RECEIPT_VERDICTS.includes(v);
 }
+var ReceiptVerdicts = {
+  ACCEPTED: "accepted",
+  ACCEPTED_WITH_NOTES: "accepted_with_notes",
+  REJECTED: "rejected"
+};
 var BODY_TYPES = ["handshake", "handshake_response", "delegation", "work_request", "work_response", "receipt", "dispute"];
 function isBodyType(v) {
   return typeof v === "string" && BODY_TYPES.includes(v);
 }
+var BodyTypes = {
+  HANDSHAKE: "handshake",
+  HANDSHAKE_RESPONSE: "handshake_response",
+  DELEGATION: "delegation",
+  WORK_REQUEST: "work_request",
+  WORK_RESPONSE: "work_response",
+  RECEIPT: "receipt",
+  DISPUTE: "dispute"
+};
 
 // src/types/delegation.ts
 var DELEGATION_STATES = [
@@ -443,6 +470,19 @@ var DELEGATION_ACTIVE_STATES = ["offered", "accepted", "pending_lock_finalizatio
 function isDelegationState(v) {
   return typeof v === "string" && DELEGATION_STATES.includes(v);
 }
+var DelegationStates = {
+  OFFERED: "offered",
+  ACCEPTED: "accepted",
+  PENDING_LOCK_FINALIZATION: "pending_lock_finalization",
+  LOCKED: "locked",
+  DISPUTING: "disputing",
+  COMPLETED: "completed",
+  DECLINED: "declined",
+  CANCELED: "canceled",
+  FAILED: "failed",
+  REFUNDED: "refunded",
+  DISPUTE_RESOLVED: "dispute_resolved"
+};
 
 // src/types/relationship.ts
 var RELATIONSHIP_STATE_NAMES = ["pending", "active", "paused", "closed"];
@@ -450,12 +490,53 @@ var LIVE_RELATIONSHIP_STATE_NAMES = ["pending", "active", "paused"];
 function isRelationshipState(v) {
   return typeof v === "string" && RELATIONSHIP_STATE_NAMES.includes(v);
 }
+var RelationshipStates = {
+  PENDING: "pending",
+  ACTIVE: "active",
+  PAUSED: "paused",
+  CLOSED: "closed"
+};
 
 // src/types/work-log.ts
 var WORK_LOG_STATES = ["requested", "responded"];
 function isWorkLogState(v) {
   return typeof v === "string" && WORK_LOG_STATES.includes(v);
 }
+var WorkLogStates = {
+  REQUESTED: "requested",
+  RESPONDED: "responded"
+};
+
+// src/types/event.ts
+var READ_MODEL_STATUSES = ["materialized", "rejected"];
+function isReadModelStatus(v) {
+  return typeof v === "string" && READ_MODEL_STATUSES.includes(v);
+}
+var ReadModelStatuses = {
+  MATERIALIZED: "materialized",
+  REJECTED: "rejected"
+};
+
+// src/types/discovery.ts
+var DISCOVERY_SORTS = ["reputation", "recent", "created"];
+function isDiscoverySort(v) {
+  return typeof v === "string" && DISCOVERY_SORTS.includes(v);
+}
+var DiscoverySorts = {
+  REPUTATION: "reputation",
+  RECENT: "recent",
+  CREATED: "created"
+};
+
+// src/types/inbox.ts
+var INBOX_BLOCK_SCOPES = ["account", "did"];
+function isInboxBlockScope(v) {
+  return typeof v === "string" && INBOX_BLOCK_SCOPES.includes(v);
+}
+var InboxBlockScopes = {
+  ACCOUNT: "account",
+  DID: "did"
+};
 
 // src/assets.ts
 var SOLANA_CLUSTER_IDS = {
@@ -527,12 +608,20 @@ function isWhitelistedAssetId(assetId, cluster) {
   return cluster === void 0 || hit.cluster === cluster;
 }
 var CAIP19_REGEX = /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}\/[-a-z0-9]{3,8}:[-.%a-zA-Z0-9]{1,128}$/;
+var ASSET_DECIMALS_MIN = 0;
+var ASSET_DECIMALS_MAX = 18;
+var ASSET_SYMBOL_MIN_LEN = 1;
+var ASSET_SYMBOL_MAX_LEN = 16;
+var DECIMAL_AMOUNT_REGEX = /^\d{1,30}(\.\d{1,18})?$/;
+function isDecimalAmountString(v) {
+  return typeof v === "string" && DECIMAL_AMOUNT_REGEX.test(v);
+}
 function isAssetIdentifier(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
   const v = value;
   if (typeof v.asset_id !== "string" || !CAIP19_REGEX.test(v.asset_id)) return false;
-  if (typeof v.decimals !== "number" || !Number.isInteger(v.decimals) || v.decimals < 0 || v.decimals > 18) return false;
-  if (v.symbol !== void 0 && (typeof v.symbol !== "string" || v.symbol.length === 0 || v.symbol.length > 16)) return false;
+  if (typeof v.decimals !== "number" || !Number.isInteger(v.decimals) || v.decimals < ASSET_DECIMALS_MIN || v.decimals > ASSET_DECIMALS_MAX) return false;
+  if (v.symbol !== void 0 && (typeof v.symbol !== "string" || v.symbol.length < ASSET_SYMBOL_MIN_LEN || v.symbol.length > ASSET_SYMBOL_MAX_LEN)) return false;
   return true;
 }
 function resolveAsset(input) {
@@ -699,6 +788,32 @@ var LOCK_ACCOUNT_SIZE = 269;
 var LOCK_ACCOUNT_DISCRIMINATOR = new Uint8Array([8, 255, 36, 202, 210, 22, 57, 137]);
 var LOCK_STATE_NAMES = ["created", "canceled", "in_progress", "submitted", "paid", "revoked", "disputing", "dispute_resolved", "dispute_closed"];
 var LOCK_TERMINAL_STATES = ["canceled", "paid", "revoked", "dispute_resolved", "dispute_closed"];
+var LockTerminalStates = {
+  CANCELED: "canceled",
+  PAID: "paid",
+  REVOKED: "revoked",
+  DISPUTE_RESOLVED: "dispute_resolved",
+  DISPUTE_CLOSED: "dispute_closed"
+};
+var ESCROW_RELEASE_METHODS = ["buyer_approved", "review_timeout"];
+function isEscrowReleaseMethod(v) {
+  return typeof v === "string" && ESCROW_RELEASE_METHODS.includes(v);
+}
+var LockStates = {
+  CREATED: "created",
+  CANCELED: "canceled",
+  IN_PROGRESS: "in_progress",
+  SUBMITTED: "submitted",
+  PAID: "paid",
+  REVOKED: "revoked",
+  DISPUTING: "disputing",
+  DISPUTE_RESOLVED: "dispute_resolved",
+  DISPUTE_CLOSED: "dispute_closed"
+};
+var EscrowReleaseMethods = {
+  BUYER_APPROVED: "buyer_approved",
+  REVIEW_TIMEOUT: "review_timeout"
+};
 var NATIVE_SOL_MINT_BASE58 = "11111111111111111111111111111111";
 function decodeLockAccount(data) {
   if (data.length !== LOCK_ACCOUNT_SIZE) {
@@ -751,4 +866,47 @@ function readU64LE(buf, off) {
   return v;
 }
 
-export { ASSET_WHITELIST, ASSOCIATED_TOKEN_PROGRAM_ID_BASE58, BODY_TYPES, CAIP19_REGEX, CREATE_LOCK_DISCRIMINATOR, CREATE_LOCK_NATIVE_DISCRIMINATOR, DECLINE_REASONS, DELEGATION_ACTIONS, DELEGATION_ACTIVE_STATES, DELEGATION_STATES, DEVNET_MINTS, ED25519_SIG_PREFIX, ESCROW_PDA_SEEDS, HANDSHAKE_DECISIONS, LIVE_RELATIONSHIP_STATE_NAMES, LOCK_ACCOUNT_DISCRIMINATOR, LOCK_ACCOUNT_SIZE, LOCK_STATE_NAMES, LOCK_TERMINAL_STATES, MAINNET_MINTS, MAX_CLOCK_SKEW_SECONDS, MAX_ENVELOPE_TTL_SECONDS, NATIVE_SOL_MINT_BASE58, NO_ARG_LIFECYCLE_INSTRUCTIONS, OWNER_SIGNING_METHODS, PROTOCOL_VERSIONS, Purpose, RECEIPT_VERDICTS, RELATIONSHIP_STATE_NAMES, SCRYPT_PARAMS, SHA256_HEX_RE, SLIP44_SOLANA, SOLANA_CLUSTER_IDS, SPL_TOKEN_PROGRAM_ID_BASE58, SYSTEM_PROGRAM_ID_BASE58, TOKEN_2022_PROGRAM_ID_BASE58, WELL_KNOWN_ASSETS, WELL_KNOWN_ASSET_KEYS, WORK_LOG_STATES, base58btcDecode, base58btcEncode, buildCreateLockIxData, buildLifecycleIxData, buildResolveDisputeIxData, bytes16ToDelegationId, canonicalBytes, canonicalJson, canonicalSha256Hex, computeCreateLockDiscriminator, computeLockAccountDiscriminator, decodeLockAccount, delegationIdToBytes16, deriveDelegationConditionHash, deriveLockId, deriveScryptKey, detectTokenProgramFromOwner, detectTokenProgramFromOwnerBytes, expiresAt, findAssetByAssetId, findFirstChainDivergence, formatDid, generateKeyPair, getPublicKey2 as getPublicKey, instructionDiscriminator, isAssetIdentifier, isBodyType, isDeclineReason, isDelegationAction, isDelegationState, isHandshakeDecision, isReceiptVerdict, isRelationshipState, isSha256Hex, isValidDid, isWhitelistedAssetId, isWorkLogState, listWhitelistedAssets, parseCaip19SolanaAssetId, parseDid, pollUntil, resolveAsset, rfc3339, scryptPasswordProofSign, scryptPasswordProofVerify, senderNonce, serverEventHash, sign2 as sign, signChallenge, signEnvelope, signKeyLinkAttestation, signedMessageHash, uuidV4, verify2 as verify, verifyChallenge, verifyEnvelope, verifyKeyLinkAttestation };
+// src/errors/post-commit.ts
+var POST_COMMIT_ERROR_CODES = [
+  // delegation handler (offer / accept / decline / cancel / fund)
+  "DELEGATION_ALREADY_EXISTS",
+  "DELEGATION_INVALID_STATE",
+  "DELEGATION_NOT_FOUND",
+  "DELEGATION_RELATIONSHIP_MISMATCH",
+  "DELEGATION_ACCEPTER_IS_OFFERER",
+  "DELEGATION_DECLINER_IS_OFFERER",
+  "DELEGATION_CANCELER_NOT_OFFERER",
+  "DELEGATION_ASSET_NOT_ALLOWED",
+  "DELEGATION_PRICING_MISMATCH",
+  "DELEGATION_CAPACITY_EXCEEDED",
+  "DELEGATION_PENDING_LOCK",
+  "DELEGATION_FUNDER_NOT_OFFERER",
+  "DELEGATION_ALREADY_FUNDED",
+  // work handler (request / respond)
+  "WORK_DELEGATION_NOT_FOUND",
+  "WORK_DELEGATION_NOT_ACTIVE",
+  "WORK_RELATIONSHIP_MISMATCH",
+  "WORK_REQUESTER_NOT_OFFERER",
+  "WORK_REQUEST_ALREADY_EXISTS",
+  "WORK_REQUEST_NOT_FOUND",
+  "WORK_RESPONDER_IS_CALLER",
+  "WORK_INVALID_STATE",
+  // receipt handler (propose)
+  "RECEIPT_ALREADY_EXISTS",
+  "RECEIPT_DELEGATION_NOT_FOUND",
+  "RECEIPT_DELEGATION_NOT_ACTIVE",
+  "RECEIPT_RELATIONSHIP_MISMATCH",
+  "RECEIPT_ISSUER_IS_CALLER",
+  "RECEIPT_NOT_FOUND",
+  "RECEIPT_INVALID_STATE",
+  "RECEIPT_RESPONSE_HASH_NOT_FOUND",
+  "RECEIPT_REQUEST_HASH_NOT_FOUND",
+  "RECEIPT_DELIVERABLE_HASH_MISMATCH"
+];
+var POST_COMMIT_ERROR_CODE_PREFIXES = ["ESC_LOCK_", "SDK_"];
+var POST_COMMIT_SET = new Set(POST_COMMIT_ERROR_CODES);
+function isPostCommitErrorCode(code) {
+  return POST_COMMIT_SET.has(code) || POST_COMMIT_ERROR_CODE_PREFIXES.some((p) => code.startsWith(p));
+}
+
+export { ASSET_DECIMALS_MAX, ASSET_DECIMALS_MIN, ASSET_SYMBOL_MAX_LEN, ASSET_SYMBOL_MIN_LEN, ASSET_WHITELIST, ASSOCIATED_TOKEN_PROGRAM_ID_BASE58, BODY_TYPES, BodyTypes, CAIP19_REGEX, CREATE_LOCK_DISCRIMINATOR, CREATE_LOCK_NATIVE_DISCRIMINATOR, CURRENT_PROTOCOL_VERSION, DECIMAL_AMOUNT_REGEX, DECLINE_REASONS, DELEGATION_ACTIONS, DELEGATION_ACTIVE_STATES, DELEGATION_STATES, DEVNET_MINTS, DISCOVERY_SORTS, DelegationActions, DelegationStates, DiscoverySorts, ED25519_SIG_PREFIX, ESCROW_PDA_SEEDS, ESCROW_PROGRAM_ID_BASE58, ESCROW_RELEASE_METHODS, EscrowReleaseMethods, HANDSHAKE_DECISIONS, HandshakeDecisions, INBOX_BLOCK_SCOPES, InboxBlockScopes, LIVE_RELATIONSHIP_STATE_NAMES, LOCK_ACCOUNT_DISCRIMINATOR, LOCK_ACCOUNT_SIZE, LOCK_STATE_NAMES, LOCK_TERMINAL_STATES, LockStates, LockTerminalStates, MAINNET_MINTS, MAX_CLOCK_SKEW_SECONDS, MAX_ENVELOPE_TTL_SECONDS, NATIVE_SOL_MINT_BASE58, NO_ARG_LIFECYCLE_INSTRUCTIONS, OWNER_SIGNING_METHODS, POST_COMMIT_ERROR_CODES, POST_COMMIT_ERROR_CODE_PREFIXES, PROTOCOL_VERSIONS, Purpose, READ_MODEL_STATUSES, RECEIPT_VERDICTS, RELATIONSHIP_STATE_NAMES, ReadModelStatuses, ReceiptVerdicts, RelationshipStates, SCRYPT_PARAMS, SHA256_HEX_RE, SLIP44_SOLANA, SOLANA_CLUSTER_IDS, SPL_TOKEN_PROGRAM_ID_BASE58, SYSTEM_PROGRAM_ID_BASE58, TOKEN_2022_PROGRAM_ID_BASE58, WELL_KNOWN_ASSETS, WELL_KNOWN_ASSET_KEYS, WORK_LOG_STATES, WorkLogStates, base58btcDecode, base58btcEncode, buildCreateLockIxData, buildLifecycleIxData, buildResolveDisputeIxData, bytes16ToDelegationId, canonicalBytes, canonicalJson, canonicalSha256Hex, computeCreateLockDiscriminator, computeLockAccountDiscriminator, decodeLockAccount, delegationIdToBytes16, deriveDelegationConditionHash, deriveLockId, deriveScryptKey, detectTokenProgramFromOwner, detectTokenProgramFromOwnerBytes, expiresAt, findAssetByAssetId, findFirstChainDivergence, formatDid, generateKeyPair, getPublicKey2 as getPublicKey, instructionDiscriminator, isAssetIdentifier, isBodyType, isDecimalAmountString, isDeclineReason, isDelegationAction, isDelegationState, isDiscoverySort, isEscrowReleaseMethod, isHandshakeDecision, isInboxBlockScope, isPostCommitErrorCode, isReadModelStatus, isReceiptVerdict, isRelationshipState, isSha256Hex, isValidDid, isWhitelistedAssetId, isWorkLogState, listWhitelistedAssets, parseCaip19SolanaAssetId, parseDid, pollUntil, resolveAsset, rfc3339, scryptPasswordProofSign, scryptPasswordProofVerify, senderNonce, serverEventHash, sign2 as sign, signChallenge, signEnvelope, signKeyLinkAttestation, signedMessageHash, uuidV4, verify2 as verify, verifyChallenge, verifyEnvelope, verifyKeyLinkAttestation };

package/dist/settlement/index.d.ts

@@ -1,3 +1,3 @@
-export { SPL_TOKEN_PROGRAM_ID_BASE58, TOKEN_2022_PROGRAM_ID_BASE58, ASSOCIATED_TOKEN_PROGRAM_ID_BASE58, SYSTEM_PROGRAM_ID_BASE58 } from './program-ids';
+export { SPL_TOKEN_PROGRAM_ID_BASE58, TOKEN_2022_PROGRAM_ID_BASE58, ASSOCIATED_TOKEN_PROGRAM_ID_BASE58, SYSTEM_PROGRAM_ID_BASE58, ESCROW_PROGRAM_ID_BASE58 } from './program-ids';
 export { detectTokenProgramFromOwner, detectTokenProgramFromOwnerBytes } from './token-program';
 export type { TokenProgramKind, TokenProgramDetection } from './token-program';

package/dist/settlement/program-ids.d.ts

@@ -25,3 +25,15 @@ export declare const ASSOCIATED_TOKEN_PROGRAM_ID_BASE58 = "ATokenGPvbdGVxr1b2hvZ
  * escrow module), not this constant: same string, different semantics.
  */
 export declare const SYSTEM_PROGRAM_ID_BASE58 = "11111111111111111111111111111111";
+/**
+ * ARP escrow program id (current V2 devnet deployment). This is the
+ * canonical DEFAULT only — both the CLI and server resolve the program
+ * id at runtime (flag / env / config / server probe) and that
+ * precedence chain stays authoritative; this constant is the single
+ * source for the fallback default so the two packages can't ship
+ * DIFFERENT defaults (the CLI previously hardcoded the contract's
+ * `declare_id` placeholder while the server defaulted to the deployed
+ * id). When a mainnet deployment exists, promote this to a per-cluster
+ * map keyed by `SOLANA_CLUSTER_IDS`.
+ */
+export declare const ESCROW_PROGRAM_ID_BASE58 = "DckBAFZcE1AZWgVsz5ipnwSUy2wWeK5eBPBoyJgKVPzb";

package/dist/types/agent.d.ts

@@ -1,3 +1,4 @@
+import type { DidDocument } from '../did/document';
 /**
  * Agent accept-preferences ("PricingPolicy") — the worker-side "what I
  * accept" constraints a registered agent publishes on its profile.
@@ -56,3 +57,82 @@ export interface AcceptCurrency {
      */
     maxAmount?: string;
 }
+/**
+ * Response from agent registration (`POST /v1/agents`; the server DTO
+ * is `AgentRegisteredDto`). The {@link DidDocument} shape is the SDK's
+ * canonical one from `../did/document`.
+ */
+export interface AgentRegisteredResponse {
+    did: string;
+    didDocument: DidDocument;
+}
+/**
+ * Public view of an ARP agent — signed reads (`GET /v1/agents/:did`)
+ * and the profile `PATCH` response. Owner-only material (raw scrypt,
+ * encrypted secrets) never appears here.
+ */
+export interface AgentPublic {
+    did: string;
+    /** Identity public key, base58btc. Immutable — the DID derives from it. */
+    identityPublicKey: string;
+    /** Settlement (Solana) public key, base58btc. */
+    settlementPublicKey: string;
+    /** attestationId of the live KEY-LINK row. */
+    currentAttestationId: string;
+    name?: string;
+    description?: string;
+    /** Capability tags — always present (empty array when none). */
+    tags: string[];
+    /** Accept-preferences — absent ⇒ the agent accepts anything. */
+    acceptPrefs?: AcceptPrefs;
+    registeredAt: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Partial profile-update body for `PATCH /v1/agents/:did`. Omitted
+ * fields stay as-is; `tags` present REPLACES the whole list (send `[]`
+ * to clear); `acceptPrefs` present REPLACES the object (`null` clears).
+ */
+export interface UpdateAgentBody {
+    name?: string;
+    description?: string;
+    tags?: string[];
+    acceptPrefs?: AcceptPrefs | null;
+}
+/** 0..100 reputation score vector (neutral 50 cold-start). */
+export interface ReputationScores {
+    reliability: number;
+    settlement: number;
+    disputeHealth: number;
+    composite: number;
+}
+/** Raw evidence counters behind the reputation scores. */
+export interface ReputationCounters {
+    onchainCycles: number;
+    completedDelegations: number;
+    completedAsPayer: number;
+    completedAsPayee: number;
+    failedDelegations: number;
+    settledEscrows: number;
+    refundedEscrows: number;
+    disputedEscrows: number;
+    disputesAdverse: number;
+    distinctCounterparts: number;
+    activeRelationships: number;
+}
+/**
+ * Public reputation view — `GET /v1/agents/:did/reputation`.
+ * INFORMATIONAL ONLY (a display + soft-sort signal, never a money /
+ * eligibility gate; `informational` is always true in alpha). Scores
+ * are 0..100 with a neutral 50 cold-start; `computed: false` ⇒ the
+ * agent has never settled a cycle and the neutral vector is shown.
+ */
+export interface AgentReputation {
+    did: string;
+    informational: boolean;
+    scores: ReputationScores;
+    counters: ReputationCounters;
+    computed: boolean;
+    lastComputedAt?: string | null;
+}

package/dist/types/body.d.ts

@@ -81,6 +81,11 @@ export declare function isDeclineReason(v: unknown): v is DeclineReason;
 export type HandshakeDecision = 'accept' | 'decline';
 export declare const HANDSHAKE_DECISIONS: readonly HandshakeDecision[];
 export declare function isHandshakeDecision(v: unknown): v is HandshakeDecision;
+/** Named-member accessor for {@link HandshakeDecision} (values are the wire strings; vocab-tested). */
+export declare const HandshakeDecisions: {
+    readonly ACCEPT: "accept";
+    readonly DECLINE: "decline";
+};
 /**
  * Lifecycle action on a `delegation` body. `offer` opens the
  * delegation; `accept`/`decline` are the counterparty's response;
@@ -90,6 +95,14 @@ export declare function isHandshakeDecision(v: unknown): v is HandshakeDecision;
 export type DelegationAction = 'offer' | 'accept' | 'decline' | 'cancel' | 'fund';
 export declare const DELEGATION_ACTIONS: readonly DelegationAction[];
 export declare function isDelegationAction(v: unknown): v is DelegationAction;
+/** Named-member accessor for {@link DelegationAction} (e.g. `action === DelegationActions.CANCEL`; vocab-tested). */
+export declare const DelegationActions: {
+    readonly OFFER: "offer";
+    readonly ACCEPT: "accept";
+    readonly DECLINE: "decline";
+    readonly CANCEL: "cancel";
+    readonly FUND: "fund";
+};
 /**
  * Payee's proposed verdict on a `receipt` body. The record is
  * off-chain; settlement happens on-chain via `claim_work_payment`.
@@ -97,6 +110,12 @@ export declare function isDelegationAction(v: unknown): v is DelegationAction;
 export type ReceiptVerdict = 'accepted' | 'accepted_with_notes' | 'rejected';
 export declare const RECEIPT_VERDICTS: readonly ReceiptVerdict[];
 export declare function isReceiptVerdict(v: unknown): v is ReceiptVerdict;
+/** Named-member accessor for {@link ReceiptVerdict} (values are the wire strings; vocab-tested). */
+export declare const ReceiptVerdicts: {
+    readonly ACCEPTED: "accepted";
+    readonly ACCEPTED_WITH_NOTES: "accepted_with_notes";
+    readonly REJECTED: "rejected";
+};
 /**
  * `handshake` — first signed exchange between two agents. Establishes
  * the relationship; carries no terms (those live on the delegation).
@@ -243,3 +262,13 @@ export type AnyBody = HandshakeBody | HandshakeResponseBody | DelegationBody | W
 export type BodyType = AnyBody['type'];
 export declare const BODY_TYPES: readonly BodyType[];
 export declare function isBodyType(v: unknown): v is BodyType;
+/** Named-member accessor for {@link BodyType} (values are the wire strings; vocab-tested). */
+export declare const BodyTypes: {
+    readonly HANDSHAKE: "handshake";
+    readonly HANDSHAKE_RESPONSE: "handshake_response";
+    readonly DELEGATION: "delegation";
+    readonly WORK_REQUEST: "work_request";
+    readonly WORK_RESPONSE: "work_response";
+    readonly RECEIPT: "receipt";
+    readonly DISPUTE: "dispute";
+};

package/dist/types/cli-auth.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `heyarp login` (cli-auth) wire response shapes. Single source of
+ * truth for the server's cli-auth-flow service return types and the
+ * CLI's response types — both are plain framework-agnostic interfaces
+ * (the server declares them in a service, not a NestJS DTO class), so
+ * this is a pure lift-and-share with no decorator coupling.
+ *
+ * NOT included here: the cli-auth SESSION-STATE union
+ * ('pending'|'confirmed'|'consumed'|...) — the CLI and server disagree
+ * on the terminal members, so it needs reconciliation before it can be
+ * centralized.
+ */
+/** `POST /v1/auth/cli/sessions` → a new login session. */
+export interface CliSessionCreated {
+    sessionId: string;
+    verificationUrl: string;
+}
+/** One-time token exchange result (PKCE-style clientSecret-gated). */
+export interface CliTokenIssued {
+    token: string;
+    wallet: string;
+}
+/** `GET /v1/accounts/me` → who the bearer token authenticates as. */
+export interface CliWhoami {
+    wallet: string;
+    agentCount: number;
+}
+/**
+ * One agent owned by the presented account — the shape `GET
+ * /v1/accounts/me/agents` returns. Carries enough to drive recovery
+ * (DID + attestation id the CLI rebuilds local state with) plus profile
+ * for display. The owner `accountId` itself is NEVER included.
+ */
+export interface MyAgentSummary {
+    did: string;
+    name: string | null;
+    description: string | null;
+    tags: string[];
+    currentAttestationId: string;
+    registeredAt: string;
+}

package/dist/types/delegation.d.ts

@@ -20,3 +20,24 @@ export type DelegationState = (typeof DELEGATION_STATES)[number];
  */
 export declare const DELEGATION_ACTIVE_STATES: readonly ["offered", "accepted", "pending_lock_finalization", "locked"];
 export declare function isDelegationState(v: unknown): v is DelegationState;
+/**
+ * Named-member accessor for the delegation FSM — lets consumers write
+ * `state === DelegationStates.LOCKED` / `case DelegationStates.OFFERED:`
+ * instead of bare magic strings, while the values stay the exact wire
+ * strings (so they remain assignable to {@link DelegationState} with no
+ * casts, unlike a TS string-enum). Parity with {@link DELEGATION_STATES}
+ * is pinned by the vocab test.
+ */
+export declare const DelegationStates: {
+    readonly OFFERED: "offered";
+    readonly ACCEPTED: "accepted";
+    readonly PENDING_LOCK_FINALIZATION: "pending_lock_finalization";
+    readonly LOCKED: "locked";
+    readonly DISPUTING: "disputing";
+    readonly COMPLETED: "completed";
+    readonly DECLINED: "declined";
+    readonly CANCELED: "canceled";
+    readonly FAILED: "failed";
+    readonly REFUNDED: "refunded";
+    readonly DISPUTE_RESOLVED: "dispute_resolved";
+};

package/dist/types/discovery.d.ts

@@ -0,0 +1,87 @@
+import type { AcceptPrefs, AgentReputation } from './agent';
+/**
+ * Discovery catalog sort order for `GET /v1/discovery/agents`. Single
+ * source of truth for the server's `@IsIn`/`@ApiProperty` allowlist and
+ * the CLI's `--sort` union. Same `as const` array + union + guard +
+ * named-member const-object shape as the protocol vocabularies.
+ *
+ * `reputation` = composite score desc (default); `recent` = newest
+ * first; `created` = registration order.
+ */
+export declare const DISCOVERY_SORTS: readonly ["reputation", "recent", "created"];
+export type DiscoverySort = (typeof DISCOVERY_SORTS)[number];
+export declare function isDiscoverySort(v: unknown): v is DiscoverySort;
+/** Named-member accessor for {@link DiscoverySort} (vocab-tested). */
+export declare const DiscoverySorts: {
+    readonly REPUTATION: "reputation";
+    readonly RECENT: "recent";
+    readonly CREATED: "created";
+};
+/** Reputation digest carried inline on each discovery row (the soft-sort key). */
+export interface DiscoveryReputation {
+    composite: number;
+    reliability: number;
+    settlement: number;
+    disputeHealth: number;
+    computed: boolean;
+}
+/** Liveness digest — how recently / whether the agent is reachable. */
+export interface DiscoveryLiveness {
+    /** Durable: a signed request within the liveness window (replica-accurate). */
+    online: boolean;
+    /** Live: an open SSE inbox stream on the serving instance (per-process). */
+    inboxStreamActive: boolean;
+    /** RFC 3339 of the last signed request; null ⇒ never seen since registration. */
+    lastSeenAt?: string | null;
+}
+/**
+ * One discovery search row — a privacy-safe subset of the agent
+ * profile (NO accountId / key material) enriched with the reputation
+ * soft-sort key + liveness.
+ */
+export interface DiscoveryResult {
+    id: string;
+    did: string;
+    name?: string;
+    description?: string;
+    tags: string[];
+    acceptPrefs?: AcceptPrefs;
+    reputation: DiscoveryReputation;
+    liveness: DiscoveryLiveness;
+    registeredAt: string;
+}
+/** Pagination envelope metadata on a discovery search page. */
+export interface DiscoveryPagination {
+    /** Count of ALL agents matching the filters (ignores the page window). */
+    total: number;
+    limit: number;
+    /** ceil(total / limit). */
+    totalPages: number;
+    hasMore: boolean;
+    /** Zero-based page index — offset sorts (reputation / recent) only. */
+    page?: number;
+    /** Cursor for the next page — `sort=created` only, when hasMore (pass as `after`). */
+    nextCursor?: string | null;
+}
+/** `GET /v1/discovery/search` response — a page of rows + pagination metadata. */
+export interface DiscoverySearchResponse {
+    results: DiscoveryResult[];
+    pagination: DiscoveryPagination;
+}
+/**
+ * `GET /v1/discovery/agents/:did/profile` — the composed single-agent
+ * view: public profile + full reputation + liveness in one read.
+ */
+export interface DiscoveryProfile {
+    did: string;
+    name?: string;
+    description?: string;
+    tags: string[];
+    acceptPrefs?: AcceptPrefs;
+    registeredAt: string;
+    reputation: AgentReputation;
+    /** Liveness, plus `lastEventAt` (last protocol event either side). */
+    liveness: DiscoveryLiveness & {
+        lastEventAt?: string | null;
+    };
+}

package/dist/types/envelope.d.ts

@@ -33,6 +33,13 @@ export type Did = `did:arp:${string}`;
  */
 export declare const PROTOCOL_VERSIONS: readonly ["arp/0.1"];
 export type ProtocolVersion = (typeof PROTOCOL_VERSIONS)[number];
+/**
+ * The wire version this SDK emits. Always the newest entry in
+ * {@link PROTOCOL_VERSIONS}. CLI envelope builders sign this instead of
+ * the bare `'arp/0.1'` literal, so a version bump is the one-line array
+ * change above.
+ */
+export declare const CURRENT_PROTOCOL_VERSION: ProtocolVersion;
 /**
  * Client-signed `protected` block. All fields here are part of the
  * signing input. Server-assigned chain fields (`relationship_event_index`,

package/dist/types/event.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Read-model projection outcome for a relationship event: `materialized`
+ * (the event was applied to the read model) → `rejected` (the event was
+ * recorded on the hash chain but the projector declined to apply it,
+ * e.g. an integrity mismatch). Single source of truth for the server's
+ * Mongoose `@Prop({ enum })` + the two event-query DTOs and the CLI's
+ * `EventPublic.readModelStatus` union / `--read-model-status` filter.
+ */
+export declare const READ_MODEL_STATUSES: readonly ["materialized", "rejected"];
+export type ReadModelStatus = (typeof READ_MODEL_STATUSES)[number];
+export declare function isReadModelStatus(v: unknown): v is ReadModelStatus;
+/**
+ * Named-member accessor for the read-model projection outcome (see
+ * {@link READ_MODEL_STATUSES}). Values are the wire strings; parity is
+ * vocab-tested.
+ */
+export declare const ReadModelStatuses: {
+    readonly MATERIALIZED: "materialized";
+    readonly REJECTED: "rejected";
+};

package/dist/types/inbox.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Inbox-block scope — whether a block targets a whole ACCOUNT (all the
+ * blocked party's agents) or a single DID. Single source of truth for
+ * the server's Mongoose `@Prop({ enum })` value list and the CLI's
+ * `scope` union. Same `as const` array + union + guard + named-member
+ * const-object shape as the protocol vocabularies; the server keeps a
+ * local enum for member access and sources its @Prop allowlist from
+ * `INBOX_BLOCK_SCOPES` with a parity spec.
+ */
+export declare const INBOX_BLOCK_SCOPES: readonly ["account", "did"];
+export type InboxBlockScope = (typeof INBOX_BLOCK_SCOPES)[number];
+export declare function isInboxBlockScope(v: unknown): v is InboxBlockScope;
+/** Named-member accessor for {@link InboxBlockScope} (vocab-tested). */
+export declare const InboxBlockScopes: {
+    readonly ACCOUNT: "account";
+    readonly DID: "did";
+};
+/**
+ * One row of the owner's inbox block list (`/v1/inbox/blocks`).
+ * Privacy-safe: it echoes back only the DID you NAMED + scope — never
+ * the resolved owner `accountId` and never the swept sibling DIDs. For
+ * `account` scope you learn "I blocked the owner of this DID", not who
+ * else that owner runs.
+ */
+export interface InboxBlock {
+    scope: InboxBlockScope;
+    /** The DID you named when blocking. */
+    did: string;
+    /** Your private note, or null. */
+    reason: string | null;
+    /** When the block was set (ISO 8601). */
+    blockedAt: string;
+}

package/dist/types/index.d.ts

@@ -1,13 +1,21 @@
 export type { Sha256Hex, Ed25519Sig, Did, ProtocolVersion, ProtectedBlock, Body, Attachments, EscrowLockAttachment, Envelope, PersistedEvent, } from './envelope';
-export { SHA256_HEX_RE, isSha256Hex, ED25519_SIG_PREFIX, PROTOCOL_VERSIONS } from './envelope';
+export { SHA256_HEX_RE, isSha256Hex, ED25519_SIG_PREFIX, PROTOCOL_VERSIONS, CURRENT_PROTOCOL_VERSION } from './envelope';
 export type { HandshakeBody, HandshakeContent, HandshakeResponseBody, HandshakeResponseContent, HandshakeDecision, DelegationBody, DelegationContent, DelegationAction, WorkRequestBody, WorkRequestContent, WorkResponseBody, WorkResponseContent, ReceiptBody, ReceiptContent, ReceiptVerdict, DisputeBody, DisputeContent, AnyBody, BodyType, DeclineReason, AssetIdentifier, } from './body';
-export { DECLINE_REASONS, isDeclineReason, HANDSHAKE_DECISIONS, isHandshakeDecision, DELEGATION_ACTIONS, isDelegationAction, RECEIPT_VERDICTS, isReceiptVerdict, BODY_TYPES, isBodyType, } from './body';
+export { DECLINE_REASONS, isDeclineReason, HANDSHAKE_DECISIONS, HandshakeDecisions, isHandshakeDecision, DELEGATION_ACTIONS, DelegationActions, isDelegationAction, RECEIPT_VERDICTS, ReceiptVerdicts, isReceiptVerdict, BODY_TYPES, BodyTypes, isBodyType, } from './body';
 export type { DelegationState } from './delegation';
-export { DELEGATION_STATES, DELEGATION_ACTIVE_STATES, isDelegationState } from './delegation';
+export { DELEGATION_STATES, DELEGATION_ACTIVE_STATES, DelegationStates, isDelegationState } from './delegation';
 export type { RelationshipState } from './relationship';
-export { RELATIONSHIP_STATE_NAMES, LIVE_RELATIONSHIP_STATE_NAMES, isRelationshipState } from './relationship';
+export { RELATIONSHIP_STATE_NAMES, LIVE_RELATIONSHIP_STATE_NAMES, RelationshipStates, isRelationshipState } from './relationship';
 export type { WorkLogState } from './work-log';
-export { WORK_LOG_STATES, isWorkLogState } from './work-log';
-export type { AcceptPrefs, AcceptCurrency } from './agent';
+export { WORK_LOG_STATES, WorkLogStates, isWorkLogState } from './work-log';
+export type { ReadModelStatus } from './event';
+export { READ_MODEL_STATUSES, ReadModelStatuses, isReadModelStatus } from './event';
+export type { DiscoverySort, DiscoveryReputation, DiscoveryLiveness, DiscoveryResult, DiscoveryPagination, DiscoverySearchResponse, DiscoveryProfile, } from './discovery';
+export { DISCOVERY_SORTS, DiscoverySorts, isDiscoverySort } from './discovery';
+export type { InboxBlockScope, InboxBlock } from './inbox';
+export { INBOX_BLOCK_SCOPES, InboxBlockScopes, isInboxBlockScope } from './inbox';
+export type { CliSessionCreated, CliTokenIssued, CliWhoami, MyAgentSummary } from './cli-auth';
+export type { AssetIdentifierWire, DelegationPublic, ReceiptPublic, RelationshipPublic, WorkLogPublic, EventPublic, IngestResult } from './read-model';
+export type { AcceptPrefs, AcceptCurrency, AgentRegisteredResponse, AgentPublic, UpdateAgentBody, ReputationScores, ReputationCounters, AgentReputation, } from './agent';
 export type { OwnerSigningMethod, KeyLinkPayload, ScryptPasswordAttestation } from './identity';
 export { SCRYPT_PARAMS, OWNER_SIGNING_METHODS } from './identity';