@treeship/verify 0.20.0 → 0.21.0

package/dist/index.d.ts

@@ -7,7 +7,13 @@ export interface TrustRootInput {
     key_id: string;
     /** `ed25519:<base64url-no-pad>` */
     public_key: string;
-    kind: 'hub_checkpoint' | 'ship' | 'agent_cert';
+    /**
+     * The powers a root grants, after the v0.19 trust-split. The single old
+     * `ship` kind was split into `hub_org` / `cert_issuer` / `revoker` and is
+     * now deprecated and inert (no verifier honors it), so it is intentionally
+     * not offered here. See TrustRootKind in packages/core/src/trust/mod.rs.
+     */
+    kind: 'hub_checkpoint' | 'hub_org' | 'cert_issuer' | 'revoker' | 'agent_cert' | 'session_host';
     label?: string;
     added_at?: string;
 }
@@ -23,7 +29,7 @@ export interface VerifyCheck {
     detail: string;
 }
 export interface VerifyReceiptResult {
-    outcome: 'pass' | 'fail' | 'error';
+    outcome: 'pass' | 'structural-pass' | 'fail' | 'error';
     checks: VerifyCheck[];
     session: {
         id: string;
@@ -131,3 +137,95 @@ export interface CapabilityVerifyResult {
  * completeness guarantee. It cannot prove the agent took no off-card action.
  */
 export declare function verifyCapability(card: VerifyTarget, actions: VerifyTarget[], trustRoots?: TrustRootsBundle | TrustRootInput[]): Promise<CapabilityVerifyResult>;
+/** One certificate in a resolution bundle's chain. */
+export interface ResolutionCert {
+    artifact_id: string;
+    /** An `agent_cert.v1` DSSE envelope object. */
+    envelope: Record<string, unknown>;
+}
+/**
+ * A resolution bundle: the signed bytes needed to decide whether an agent's
+ * current card is trustworthy. This is the same shape the Hub serves and the
+ * CLI re-verifies — assemble it from a `resolve` response.
+ */
+export interface ResolutionBundleInput {
+    agent: string;
+    /** The agent's current `agent_card.v1` DSSE envelope object. */
+    card: Record<string, unknown>;
+    certs?: ResolutionCert[];
+    /** `agent_card_revocation.v1` DSSE envelope objects. */
+    revocations?: Record<string, unknown>[];
+}
+/** Result of {@link verifyResolution}. Mirrors the WASM JSON output. */
+export interface ResolutionVerdict {
+    /** Card signature verified against your roots (directly or via the chain). */
+    sig_ok: boolean;
+    /** Card is key-bound: signer pinned under AgentCert, or chain-certified. */
+    key_bound: boolean;
+    /** If verified via the certificate chain, the cert artifact that vouched. */
+    chain_cert_id: string | null;
+    /** An authorized, verifying revocation was found. */
+    revoked: boolean;
+    revocation_reason: string | null;
+    error_code?: string;
+    message?: string;
+}
+/**
+ * Verify an agent resolution bundle in the browser — the same `resolve --hub`
+ * trust decision the CLI makes, via shared Rust logic
+ * (`treeship_core::verify::resolution`). Verifies the card by direct leaf pin
+ * or certificate-chain walk, then honors an authorized revocation.
+ *
+ * `trustRoots` is required for `key_bound` to be true; with none, the bundle
+ * fails closed. `now` defaults to the current time (used for cert validity
+ * windows in the chain walk).
+ */
+export declare function verifyResolution(bundle: ResolutionBundleInput, trustRoots?: TrustRootsBundle | TrustRootInput[], now?: Date | string): Promise<ResolutionVerdict>;
+/** The challenge-response outcome within a presentation. */
+export interface PresentationChallenge {
+    outcome: 'not_requested' | 'present_but_unchecked' | 'no_response' | 'no_established_key' | 'verified' | 'failed';
+    /** Bearer-signed timestamp, when `outcome` is `verified`. */
+    signed_at: string | null;
+    /** Failure reason, when `outcome` is `failed`. */
+    reason: string | null;
+}
+/** The staple portion of a presentation verdict. */
+export interface PresentationStaple {
+    verified: boolean;
+    status: 'no_staple' | 'unparseable' | 'signer_not_trusted' | 'inclusion_invalid' | 'verified';
+    checkpoint_index: number | null;
+    age_secs: number | null;
+}
+/** Result of {@link verifyPresentation}. Mirrors the WASM JSON output. */
+export interface PresentationVerdict {
+    agent: string;
+    card_id: string;
+    /** Card signature verified against your roots (directly or via the chain). */
+    sig_ok: boolean;
+    key_bound: boolean;
+    via_chain: boolean;
+    revoked: string | null;
+    challenge: PresentationChallenge;
+    challenge_ok: boolean;
+    staple: PresentationStaple;
+    /** Roll-up: not revoked, key-bound, and (if requested) challenge verified.
+     * Freshness (`--max-staple-age`) is your own policy over `staple.age_secs`. */
+    ok: boolean;
+    error_code?: string;
+    message?: string;
+}
+/**
+ * Verify an agent presentation in the browser — the same `verify-presentation`
+ * trust decision the CLI makes, via shared Rust logic
+ * (`treeship_core::verify::presentation`). Verifies the card (direct pin or
+ * chain), honors an authorized revocation, checks challenge liveness (when
+ * `nonce` is given), and verifies the staple.
+ *
+ * `trustRoots` is required for `key_bound`; with none, the presentation fails
+ * closed. `nonce` is the challenge nonce YOU issued (omit to skip liveness).
+ * `now` defaults to the current time.
+ */
+export declare function verifyPresentation(presentation: Record<string, unknown>, trustRoots?: TrustRootsBundle | TrustRootInput[], opts?: {
+    nonce?: string;
+    now?: Date | string;
+}): Promise<PresentationVerdict>;

package/dist/index.js

@@ -122,3 +122,43 @@ export async function verifyCapability(card, actions, trustRoots) {
     const wasm = await loadWasm();
     return JSON.parse(wasm.verify_capability(cardJson, actionsJson, serializeTrustRoots(trustRoots)));
 }
+/**
+ * Verify an agent resolution bundle in the browser — the same `resolve --hub`
+ * trust decision the CLI makes, via shared Rust logic
+ * (`treeship_core::verify::resolution`). Verifies the card by direct leaf pin
+ * or certificate-chain walk, then honors an authorized revocation.
+ *
+ * `trustRoots` is required for `key_bound` to be true; with none, the bundle
+ * fails closed. `now` defaults to the current time (used for cert validity
+ * windows in the chain walk).
+ */
+export async function verifyResolution(bundle, trustRoots, now) {
+    const nowStr = now === undefined
+        ? new Date().toISOString()
+        : now instanceof Date
+            ? now.toISOString()
+            : now;
+    const wasm = await loadWasm();
+    return JSON.parse(wasm.verify_resolution(JSON.stringify(bundle), serializeTrustRoots(trustRoots), nowStr));
+}
+/**
+ * Verify an agent presentation in the browser — the same `verify-presentation`
+ * trust decision the CLI makes, via shared Rust logic
+ * (`treeship_core::verify::presentation`). Verifies the card (direct pin or
+ * chain), honors an authorized revocation, checks challenge liveness (when
+ * `nonce` is given), and verifies the staple.
+ *
+ * `trustRoots` is required for `key_bound`; with none, the presentation fails
+ * closed. `nonce` is the challenge nonce YOU issued (omit to skip liveness).
+ * `now` defaults to the current time.
+ */
+export async function verifyPresentation(presentation, trustRoots, opts) {
+    const now = opts?.now;
+    const nowStr = now === undefined
+        ? new Date().toISOString()
+        : now instanceof Date
+            ? now.toISOString()
+            : now;
+    const wasm = await loadWasm();
+    return JSON.parse(wasm.verify_presentation(JSON.stringify(presentation), serializeTrustRoots(trustRoots), opts?.nonce ?? '', nowStr));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeship/verify",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Zero-dependency cryptographic verification for Treeship receipts and certificates. Runs anywhere WASM runs: Node, browser, Vercel Edge, Cloudflare Workers, AWS Lambda.",
   "license": "Apache-2.0",
   "repository": {
@@ -40,7 +40,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@treeship/core-wasm": "0.20.0"
+    "@treeship/core-wasm": "0.21.0"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",