@paybond/kit 0.11.11 → 0.12.1

package/dist/mpp-commercial.js

@@ -0,0 +1,34 @@
+/**
+ * MPP commercial denomination helpers for Paybond MVP.
+ *
+ * Paybond intent commercial fields remain USD-denominated (`amount_cents`, `currency`).
+ * Tempo session deposits use USDC base units (6 decimals): `amount_cents * 10_000`.
+ */
+/** USDC uses 6 decimal places; one USD cent maps to 10_000 base units. */
+export const USDC_BASE_UNITS_PER_USD_CENT = 10_000;
+/** Rails that require USD-denominated commercial intent fields for MVP. */
+export const USD_DENOMINATED_SETTLEMENT_RAILS = new Set([
+    "x402_usdc_base",
+    "stripe_ach_debit",
+    "stripe_mpp",
+]);
+/**
+ * Rejects non-USD intents on rails that remain USD-denominated for MVP.
+ */
+export function validateUsdDenominatedSettlement(settlementRail, currency) {
+    if (!USD_DENOMINATED_SETTLEMENT_RAILS.has(settlementRail)) {
+        return;
+    }
+    if (currency.trim().toLowerCase() !== "usd") {
+        throw new Error(`currency must be usd when settlementRail is ${settlementRail} until multi-currency policy is defined`);
+    }
+}
+/**
+ * Converts Paybond USD cents to Tempo USDC base units.
+ */
+export function usdCentsToUsdcBaseUnits(amountCents) {
+    if (!Number.isInteger(amountCents) || amountCents < 0) {
+        throw new Error("amountCents must be a non-negative integer");
+    }
+    return BigInt(amountCents) * BigInt(USDC_BASE_UNITS_PER_USD_CENT);
+}

package/dist/mpp-funding.d.ts

@@ -0,0 +1,71 @@
+import type { AgentRecognitionProofV1, FundIntentResult } from "./index.js";
+import { type FundRequestEnvelope, type X402FundPollOptions } from "./x402-funding.js";
+/** Raw `WWW-Authenticate: Payment …` challenge value from Harbor or the gateway. */
+export type PaymentAuthChallenge = string;
+/** Parsed Payment Auth challenge parameters from a `WWW-Authenticate` header value. */
+export type ParsedPaymentAuthChallenge = {
+    raw: string;
+    id?: string;
+    realm?: string;
+    method?: string;
+    intent?: string;
+    request?: string;
+};
+export type MppFundPollOptions = X402FundPollOptions;
+/** Raised when MPP funding cannot complete (missing challenge, terminal rail status, unexpected HTTP). */
+export declare class PaybondMppFundingFailedError extends Error {
+    readonly intentId: string;
+    readonly lastResult?: FundIntentResult;
+    constructor(message: string, init: {
+        intentId: string;
+        lastResult?: FundIntentResult;
+        cause?: unknown;
+    });
+}
+/** Raised when polling exhausts `maxAttempts` before Harbor returns a funded capability token. */
+export declare class PaybondMppFundingPendingError extends Error {
+    readonly intentId: string;
+    readonly lastResult: FundIntentResult;
+    readonly attempts: number;
+    constructor(message: string, init: {
+        intentId: string;
+        lastResult: FundIntentResult;
+        attempts: number;
+    });
+}
+/**
+ * Parses a `WWW-Authenticate: Payment …` challenge into structured parameters.
+ *
+ * @throws Error when the value is empty or does not start with the Payment scheme.
+ */
+export declare function parsePaymentAuthChallenge(raw: string): ParsedPaymentAuthChallenge;
+/** Selects the Stripe MPP charge challenge from `WWW-Authenticate` values. */
+export declare function selectMppChargeChallenge(wwwAuthenticate: string[] | undefined): PaymentAuthChallenge;
+/** Selects the Tempo MPP session challenge from `WWW-Authenticate` values. */
+export declare function selectMppSessionChallenge(wwwAuthenticate: string[] | undefined): PaymentAuthChallenge;
+/** Canonical `/fund` request envelope for Gateway `POST /harbor/intents/{intentId}/fund`. */
+export declare function buildMppFundRequestEnvelope(intentId: string): FundRequestEnvelope;
+export type ExecuteFundWithMppParams = {
+    intentId: string;
+    recognitionProof: AgentRecognitionProofV1 | Record<string, unknown>;
+    /** App-owned callback that turns a Payment Auth challenge into a credential token or header value. */
+    createPaymentCredential: (challenge: PaymentAuthChallenge) => Promise<string>;
+    issueRecognitionProof: (envelope: FundRequestEnvelope) => Promise<AgentRecognitionProofV1 | Record<string, unknown>>;
+    pollOptions?: MppFundPollOptions;
+    selectChallenge: (wwwAuthenticate: string[] | undefined) => PaymentAuthChallenge;
+    fund: (args: {
+        recognitionProof: AgentRecognitionProofV1 | Record<string, unknown>;
+        paymentAuthorization?: string;
+    }) => Promise<FundIntentResult>;
+};
+/**
+ * Orchestrate MPP `/fund`: handle 402 Payment Auth challenges, retry with credentials, poll until funded.
+ *
+ * Wallet and SPT secrets stay app-owned — pass injectable `createPaymentCredential` and
+ * `issueRecognitionProof` callbacks; Paybond never stores MPP signing material.
+ */
+export declare function executeFundWithMpp(params: ExecuteFundWithMppParams): Promise<FundIntentResult>;
+/** One-shot Stripe MPP charge funding through Payment Auth semantics. */
+export declare function executeFundWithMppCharge(params: Omit<ExecuteFundWithMppParams, "selectChallenge">): Promise<FundIntentResult>;
+/** Tempo MPP session funding through Payment Auth semantics. */
+export declare function executeFundWithMppSession(params: Omit<ExecuteFundWithMppParams, "selectChallenge">): Promise<FundIntentResult>;

package/dist/mpp-funding.js

@@ -0,0 +1,192 @@
+import { buildX402FundRequestEnvelope, } from "./x402-funding.js";
+const DEFAULT_MAX_ATTEMPTS = 30;
+const DEFAULT_INTERVAL_MS = 2_000;
+const TERMINAL_MPP_FUNDING_STATUSES = new Set([
+    "authorization_failed",
+    "capture_failed",
+    "void_failed",
+    "credential_rejected",
+    "payment_failed",
+    "charge_failed",
+    "session_open_failed",
+]);
+const MPP_CHARGE_EXPECTED = { intent: "charge", method: "stripe" };
+const MPP_SESSION_EXPECTED = { intent: "session", method: "tempo" };
+/** Raised when MPP funding cannot complete (missing challenge, terminal rail status, unexpected HTTP). */
+export class PaybondMppFundingFailedError extends Error {
+    intentId;
+    lastResult;
+    constructor(message, init) {
+        super(message, { cause: init.cause });
+        this.name = "PaybondMppFundingFailedError";
+        this.intentId = init.intentId;
+        this.lastResult = init.lastResult;
+    }
+}
+/** Raised when polling exhausts `maxAttempts` before Harbor returns a funded capability token. */
+export class PaybondMppFundingPendingError extends Error {
+    intentId;
+    lastResult;
+    attempts;
+    constructor(message, init) {
+        super(message);
+        this.name = "PaybondMppFundingPendingError";
+        this.intentId = init.intentId;
+        this.lastResult = init.lastResult;
+        this.attempts = init.attempts;
+    }
+}
+/**
+ * Parses a `WWW-Authenticate: Payment …` challenge into structured parameters.
+ *
+ * @throws Error when the value is empty or does not start with the Payment scheme.
+ */
+export function parsePaymentAuthChallenge(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        throw new Error("Payment Auth challenge must be non-empty");
+    }
+    if (!/^payment\b/i.test(trimmed)) {
+        throw new Error("expected Payment Auth challenge");
+    }
+    const params = {};
+    const afterScheme = trimmed.replace(/^payment\s+/i, "");
+    const paramRe = /([a-zA-Z_][\w-]*)=(?:"([^"]*)"|([^,\s]+))/g;
+    let match;
+    while ((match = paramRe.exec(afterScheme)) !== null) {
+        params[match[1].toLowerCase()] = match[2] ?? match[3] ?? "";
+    }
+    return {
+        raw: trimmed,
+        id: params.id,
+        realm: params.realm,
+        method: params.method,
+        intent: params.intent,
+        request: params.request,
+    };
+}
+function selectMppPaymentChallenge(wwwAuthenticate, expected) {
+    if (!wwwAuthenticate?.length) {
+        throw new Error("MPP fund challenge missing WWW-Authenticate Payment header");
+    }
+    for (const header of wwwAuthenticate) {
+        const parsed = parsePaymentAuthChallenge(header);
+        if (parsed.intent === expected.intent && parsed.method === expected.method) {
+            return parsed.raw;
+        }
+    }
+    if (wwwAuthenticate.length === 1) {
+        const parsed = parsePaymentAuthChallenge(wwwAuthenticate[0]);
+        if (parsed.intent !== expected.intent || parsed.method !== expected.method) {
+            throw new Error(`MPP fund challenge intent/method mismatch: expected intent=${expected.intent} method=${expected.method}, got intent=${parsed.intent ?? "unknown"} method=${parsed.method ?? "unknown"}`);
+        }
+        return parsed.raw;
+    }
+    throw new Error(`MPP fund challenge missing Payment Auth header for intent=${expected.intent} method=${expected.method}`);
+}
+/** Selects the Stripe MPP charge challenge from `WWW-Authenticate` values. */
+export function selectMppChargeChallenge(wwwAuthenticate) {
+    return selectMppPaymentChallenge(wwwAuthenticate, MPP_CHARGE_EXPECTED);
+}
+/** Selects the Tempo MPP session challenge from `WWW-Authenticate` values. */
+export function selectMppSessionChallenge(wwwAuthenticate) {
+    return selectMppPaymentChallenge(wwwAuthenticate, MPP_SESSION_EXPECTED);
+}
+/** Canonical `/fund` request envelope for Gateway `POST /harbor/intents/{intentId}/fund`. */
+export function buildMppFundRequestEnvelope(intentId) {
+    return buildX402FundRequestEnvelope(intentId);
+}
+function isFundingComplete(result) {
+    if (result.capabilityToken?.trim()) {
+        return true;
+    }
+    return result.statusCode === 200 && result.funded;
+}
+function isTerminalFundingFailure(result) {
+    const status = result.funding?.status?.trim();
+    return status !== undefined && TERMINAL_MPP_FUNDING_STATUSES.has(status);
+}
+function failureMessage(result) {
+    const status = result.funding?.status ?? result.state;
+    return `MPP funding failed for intent ${result.intentId} (status=${status})`;
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Orchestrate MPP `/fund`: handle 402 Payment Auth challenges, retry with credentials, poll until funded.
+ *
+ * Wallet and SPT secrets stay app-owned — pass injectable `createPaymentCredential` and
+ * `issueRecognitionProof` callbacks; Paybond never stores MPP signing material.
+ */
+export async function executeFundWithMpp(params) {
+    const intentId = params.intentId.trim();
+    if (!intentId) {
+        throw new Error("fundWithMpp: intentId is required");
+    }
+    const maxAttempts = Math.max(1, params.pollOptions?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
+    const intervalMs = Math.max(0, params.pollOptions?.intervalMs ?? DEFAULT_INTERVAL_MS);
+    const envelope = buildMppFundRequestEnvelope(intentId);
+    let paymentAuthorization;
+    let result = await params.fund({ recognitionProof: params.recognitionProof });
+    if (result.statusCode === 402) {
+        const challenge = params.selectChallenge(result.wwwAuthenticate);
+        paymentAuthorization = (await params.createPaymentCredential(challenge)).trim();
+        if (!paymentAuthorization) {
+            throw new PaybondMppFundingFailedError("MPP createPaymentCredential returned an empty credential", {
+                intentId,
+                lastResult: result,
+            });
+        }
+        const retryProof = await params.issueRecognitionProof(envelope);
+        result = await params.fund({
+            recognitionProof: retryProof,
+            paymentAuthorization,
+        });
+    }
+    if (isTerminalFundingFailure(result)) {
+        throw new PaybondMppFundingFailedError(failureMessage(result), { intentId, lastResult: result });
+    }
+    if (isFundingComplete(result)) {
+        return result;
+    }
+    let attempts = 0;
+    while (result.statusCode === 202 || (!isFundingComplete(result) && result.statusCode === 200)) {
+        attempts += 1;
+        if (attempts > maxAttempts) {
+            throw new PaybondMppFundingPendingError(`MPP funding still pending after ${maxAttempts} poll attempt(s) for intent ${intentId}`, { intentId, lastResult: result, attempts: maxAttempts });
+        }
+        if (intervalMs > 0) {
+            await sleep(intervalMs);
+        }
+        const pollProof = await params.issueRecognitionProof(envelope);
+        result = await params.fund({
+            recognitionProof: pollProof,
+            ...(paymentAuthorization ? { paymentAuthorization } : {}),
+        });
+        if (isTerminalFundingFailure(result)) {
+            throw new PaybondMppFundingFailedError(failureMessage(result), { intentId, lastResult: result });
+        }
+        if (isFundingComplete(result)) {
+            return result;
+        }
+    }
+    if (isFundingComplete(result)) {
+        return result;
+    }
+    throw new PaybondMppFundingFailedError(`unexpected MPP fund response HTTP ${result.statusCode} for intent ${intentId}`, { intentId, lastResult: result });
+}
+/** One-shot Stripe MPP charge funding through Payment Auth semantics. */
+export async function executeFundWithMppCharge(params) {
+    return executeFundWithMpp({
+        ...params,
+        selectChallenge: selectMppChargeChallenge,
+    });
+}
+/** Tempo MPP session funding through Payment Auth semantics. */
+export async function executeFundWithMppSession(params) {
+    return executeFundWithMpp({
+        ...params,
+        selectChallenge: selectMppSessionChallenge,
+    });
+}

package/dist/payment-transport.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Payment Auth transport headers for MPP funding through the Paybond Gateway.
+ *
+ * Kit callers send `x-paybond-payment-authorization: Payment <credential>` so
+ * `Authorization: Bearer` remains available for Paybond tenant authentication.
+ * The gateway translates this to `Authorization: Payment` when forwarding to Harbor.
+ */
+/** Gateway-facing Payment Auth credential header (avoids clashing with Bearer auth). */
+export declare const PAYBOND_PAYMENT_AUTHORIZATION_HEADER = "x-paybond-payment-authorization";
+/** Payment Auth response headers propagated by the gateway from Harbor. */
+export declare const PAYMENT_TRANSPORT_RESPONSE_HEADERS: readonly ["www-authenticate", "payment-receipt", "cache-control"];
+/**
+ * Normalizes a Payment Auth credential for HTTP headers.
+ *
+ * Accepts either a raw credential token or a value already prefixed with `Payment `.
+ */
+export declare function formatPaymentAuthorizationValue(credential: string): string;
+/** Header entry for gateway Harbor fund/verify retries. */
+export declare function paymentAuthorizationGatewayHeader(credential: string): Record<string, string>;
+/**
+ * Appends `Authorization: Payment …` for direct Harbor calls that already carry Bearer auth.
+ */
+export declare function appendDirectHarborPaymentAuthorization(headers: Headers, credential: string): void;
+export type FundPaymentTransportHeaders = {
+    wwwAuthenticate?: string[];
+    paymentReceipt?: string;
+    cacheControl?: string;
+};
+/** Reads Payment Auth transport headers from a fund response. */
+export declare function readFundPaymentTransportHeaders(headers: Headers): FundPaymentTransportHeaders;

package/dist/payment-transport.js

@@ -0,0 +1,56 @@
+/**
+ * Payment Auth transport headers for MPP funding through the Paybond Gateway.
+ *
+ * Kit callers send `x-paybond-payment-authorization: Payment <credential>` so
+ * `Authorization: Bearer` remains available for Paybond tenant authentication.
+ * The gateway translates this to `Authorization: Payment` when forwarding to Harbor.
+ */
+/** Gateway-facing Payment Auth credential header (avoids clashing with Bearer auth). */
+export const PAYBOND_PAYMENT_AUTHORIZATION_HEADER = "x-paybond-payment-authorization";
+/** Payment Auth response headers propagated by the gateway from Harbor. */
+export const PAYMENT_TRANSPORT_RESPONSE_HEADERS = [
+    "www-authenticate",
+    "payment-receipt",
+    "cache-control",
+];
+/**
+ * Normalizes a Payment Auth credential for HTTP headers.
+ *
+ * Accepts either a raw credential token or a value already prefixed with `Payment `.
+ */
+export function formatPaymentAuthorizationValue(credential) {
+    const trimmed = credential.trim();
+    if (!trimmed) {
+        throw new Error("payment authorization credential must be non-empty");
+    }
+    if (/^payment\s+/i.test(trimmed)) {
+        return trimmed;
+    }
+    return `Payment ${trimmed}`;
+}
+/** Header entry for gateway Harbor fund/verify retries. */
+export function paymentAuthorizationGatewayHeader(credential) {
+    return {
+        [PAYBOND_PAYMENT_AUTHORIZATION_HEADER]: formatPaymentAuthorizationValue(credential),
+    };
+}
+/**
+ * Appends `Authorization: Payment …` for direct Harbor calls that already carry Bearer auth.
+ */
+export function appendDirectHarborPaymentAuthorization(headers, credential) {
+    headers.append("authorization", formatPaymentAuthorizationValue(credential));
+}
+/** Reads Payment Auth transport headers from a fund response. */
+export function readFundPaymentTransportHeaders(headers) {
+    const wwwAuthenticate = [];
+    headers.forEach((value, key) => {
+        if (key.toLowerCase() === "www-authenticate") {
+            wwwAuthenticate.push(value);
+        }
+    });
+    return {
+        wwwAuthenticate: wwwAuthenticate.length > 0 ? wwwAuthenticate : undefined,
+        paymentReceipt: headers.get("payment-receipt") ?? undefined,
+        cacheControl: headers.get("cache-control") ?? undefined,
+    };
+}

package/dist/policy/intent-spec.js

@@ -1,5 +1,6 @@
 import { PaybondToolRegistryValidationError } from "../agent/types.js";
 import { resolveCompletionPreset, contractSnapshotForPreset } from "../completion-resolve.js";
+import { validateUsdDenominatedSettlement } from "../mpp-commercial.js";
 import { policyToToolRegistry } from "./registry.js";
 /** Raised when policy intent fields cannot be aligned to a Harbor create payload. */
 export class PaybondPolicyIntentSpecError extends Error {
@@ -142,6 +143,7 @@ export function policyToIntentCreateInput(document, overrides) {
     const allowedTools = resolveAllowedHarborOperations(document, registry, overrides.allowedTools);
     const policyBinding = resolvePolicyBindingRef(document, overrides.publishedPolicyHead, overrides.policyBinding);
     const { budget, currency, amountCents } = resolveBudgetFields(document, overrides);
+    validateUsdDenominatedSettlement(overrides.settlementRail, currency);
     const completionPresetId = overrides.completionPresetId ??
         resolveEvidencePresetForOperations(registry, allowedTools);
     const resolvedPreset = resolveCompletionPreset(completionPresetId);

package/dist/policy/presets.d.ts

@@ -1,7 +1,7 @@
 import type { LayeredPolicyPresetId } from "./compose.js";
 import { type PaybondPolicyDocumentV1 } from "./schema.js";
 export type { LayeredPolicyPresetId };
-declare const KNOWN_POLICY_PRESET_IDS: readonly ["travel", "shopping", "saas", "aws", "read-only", "strict"];
+declare const KNOWN_POLICY_PRESET_IDS: readonly ["travel", "shopping", "saas", "aws", "stripe-commerce", "read-only", "strict"];
 export type PolicyPresetId = (typeof KNOWN_POLICY_PRESET_IDS)[number];
 /** True when `value` is a bundled vertical policy preset id (not a file path). */
 export declare function isKnownPolicyPresetId(value: string): value is PolicyPresetId;

package/dist/policy/presets.js

@@ -10,6 +10,7 @@ const KNOWN_POLICY_PRESET_IDS = [
     "shopping",
     "saas",
     "aws",
+    "stripe-commerce",
     "read-only",
     "strict",
 ];

package/dist/principal-intent.d.ts

@@ -3,7 +3,7 @@
  * Matches `crates/harbor-intent-escrow/src/signing.rs` (`intent_creation_sign_bytes_raw`).
  */
 /** Tenant-configured settlement rail names. Clients may request a rail, not a destination. */
-export type SettlementRail = "stripe_connect" | "stripe_ach_debit" | "x402_usdc_base";
+export type SettlementRail = "stripe_connect" | "stripe_ach_debit" | "stripe_mpp" | "x402_usdc_base";
 export type CompletionContractSnapshot = {
     completionPresetId: string;
     vendorContractProvider?: string;

package/dist/principal-intent.js

@@ -6,7 +6,8 @@ import { sign, getPublicKey } from "@noble/ed25519";
 import { ensureEd25519Sha512Sync } from "./ed25519-sync.js";
 import { jsonValueDigest } from "./json-digest.js";
 import { COMPLETION_CONTRACT_SIGN_VERSION, concatBytes, encodeBincodeString, encodeBincodeUuid, encodeFixed32, encodeU8, encodeVarintI64, encodeVarintU32, } from "./bincode-wire.js";
-const SETTLEMENT_RAIL_VALUES = new Set(["stripe_connect", "stripe_ach_debit", "x402_usdc_base"]);
+import { validateUsdDenominatedSettlement } from "./mpp-commercial.js";
+const SETTLEMENT_RAIL_VALUES = new Set(["stripe_connect", "stripe_ach_debit", "stripe_mpp", "x402_usdc_base"]);
 function validateSettlementRail(value) {
     if (!SETTLEMENT_RAIL_VALUES.has(value)) {
         throw new Error(`settlementRail must be one of ${[...SETTLEMENT_RAIL_VALUES].join(", ")}`);
@@ -171,6 +172,7 @@ export function buildSignedCreateIntentBodyWithPolicyBinding(params) {
         throw new Error("allowedTools must be non-empty");
     }
     const settlementRail = validateSettlementRail(params.settlementRail);
+    validateUsdDenominatedSettlement(settlementRail, params.currency);
     const predicateRef = params.predicateRef ?? "";
     const head = params.publishedPolicyHead;
     if (head.templateId !== params.policyBinding.templateId || head.versionSeq !== params.policyBinding.versionSeq) {
@@ -248,6 +250,7 @@ export function buildSignedCreateIntentBody(params) {
         throw new Error("allowedTools must be non-empty");
     }
     const settlementRail = validateSettlementRail(params.settlementRail);
+    validateUsdDenominatedSettlement(settlementRail, params.currency);
     const predicateRef = params.predicateRef ?? "";
     ensureEd25519Sha512Sync();
     const payeePub = getPublicKey(params.payeeSigningSeed);

package/dist/project-init.d.ts

@@ -1,7 +1,7 @@
 import type { PolicyPresetId } from "./policy/presets.js";
 import { type SolutionId } from "./solutions/catalog.js";
 export type ProjectInitSolution = SolutionId | "mcp-server";
-export type ProjectInitFramework = "openai" | "langgraph" | "mcp" | "generic";
+export type ProjectInitFramework = "openai" | "langgraph" | "mcp" | "generic" | "shopify";
 export type ProjectInitLanguage = "typescript" | "python";
 export type ProjectInitOptions = {
     cwd: string;

package/dist/project-init.js

@@ -33,6 +33,7 @@ const FRAMEWORK_ALIASES = {
     langgraph: "langgraph",
     mcp: "mcp",
     generic: "generic",
+    shopify: "shopify",
 };
 function usage() {
     return [

package/dist/protocol-receipt.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Local verification for protocol-v2 authorization and settlement receipts.
+ *
+ * Canonical JSON matches the Go gateway `protocolAuthorizationReceiptCanonicalV1` /
+ * `protocolSettlementReceiptCanonicalV1` marshalers (fixed struct field order, signing
+ * fields stripped, RFC3339Nano UTC timestamps, HTML-safe `\u` escapes), not Kit's generic
+ * JCS-style `normalizeJson`. Ported from `go/gateway/internal/protocolv2/receipt.go`.
+ */
+import { type AgentMandateAgentIdentity, type AgentMandateAuthorization, type AgentMandateConstraintReference, type AgentMandateSettlementRailPolicy, type AgentMandateSpendCeiling } from "./agent-mandate.js";
+export declare const PROTOCOL_RECEIPT_SCHEMA_VERSION = 1;
+export declare const PROTOCOL_RECEIPT_VERSION_V1 = "1";
+export declare const PROTOCOL_RECEIPT_SIGNING_ALGORITHM_ED25519_SHA256 = "ed25519-sha256-json-v1";
+export declare const PROTOCOL_AUTHORIZATION_RECEIPT_KIND_V1 = "paybond.protocol_authorization_receipt_v1";
+export declare const PROTOCOL_SETTLEMENT_RECEIPT_KIND_V1 = "paybond.protocol_settlement_receipt_v1";
+export declare const PROTOCOL_RECEIPT_STATUS_AUTHORIZED = "authorized";
+/** Default protocol source (AP2-aligned) for imported mandates and exported receipts. */
+export declare const PROTOCOL_SOURCE_AP2 = "ap2";
+/** Stripe Agentic Commerce Protocol (ACP) source identifier for partner receipts. */
+export declare const PROTOCOL_SOURCE_ACP = "acp";
+/** Stripe Unified Commerce Protocol (UCP) source identifier for partner receipts. */
+export declare const PROTOCOL_SOURCE_UCP = "ucp";
+/** Partner transport metadata for imported mandates and exported receipts. */
+export type ProtocolTransportBindingV1 = {
+    source_protocol: string;
+    partner_platform?: string;
+    external_authorization_id?: string;
+    request_id?: string;
+};
+/** Signed acknowledgement emitted after accepting a partner mandate binding. */
+export type ProtocolAuthorizationReceiptV1 = {
+    schema_version: number;
+    kind: string;
+    receipt_version: string;
+    receipt_id: string;
+    issued_at: string;
+    status: string;
+    intent_id: string;
+    tenant_id: string;
+    verifier_id: string;
+    transport_binding: ProtocolTransportBindingV1;
+    mandate_digest_sha256_hex: string;
+    imported_mandate_signing_public_key_ed25519_hex: string;
+    authorization: AgentMandateAuthorization;
+    agent: AgentMandateAgentIdentity;
+    allowed_actions: string[];
+    allowed_tools: string[];
+    spend_ceiling: AgentMandateSpendCeiling;
+    settlement: AgentMandateSettlementRailPolicy;
+    constraint: AgentMandateConstraintReference;
+    expires_at: string;
+    nonce: string;
+    human_presence_mode: string;
+    signing_algorithm: string;
+    message_digest_sha256_hex: string;
+    signing_public_key_ed25519_hex: string;
+    ed25519_signature_hex: string;
+};
+/** Signed terminal outcome artifact for a Harbor intent bound to a partner mandate. */
+export type ProtocolSettlementReceiptV1 = {
+    schema_version: number;
+    kind: string;
+    receipt_version: string;
+    receipt_id: string;
+    issued_at: string;
+    intent_id: string;
+    tenant_id: string;
+    verifier_id: string;
+    transport_binding: ProtocolTransportBindingV1;
+    authorization_receipt_id: string;
+    mandate_digest_sha256_hex: string;
+    harbor_state: string;
+    predicate_passed?: boolean;
+    settlement_rail: string;
+    settlement_mode: string;
+    principal_did: string;
+    payee_did: string;
+    currency: string;
+    amount_cents: number;
+    terminal_observed_at: string;
+    signing_algorithm: string;
+    message_digest_sha256_hex: string;
+    signing_public_key_ed25519_hex: string;
+    ed25519_signature_hex: string;
+};
+type ProtocolAuthorizationReceiptInput = ProtocolAuthorizationReceiptV1 | Record<string, unknown>;
+type ProtocolSettlementReceiptInput = ProtocolSettlementReceiptV1 | Record<string, unknown>;
+/**
+ * Validates and canonicalizes an authorization receipt for hashing and signing.
+ *
+ * Signing fields are lower/trim-normalized but not recomputed here.
+ *
+ * @throws When structure or field values are invalid.
+ */
+export declare function normalizeProtocolAuthorizationReceiptV1(input: ProtocolAuthorizationReceiptInput): ProtocolAuthorizationReceiptV1;
+/**
+ * Validates and canonicalizes a settlement receipt for hashing and signing.
+ *
+ * @throws When structure or field values are invalid.
+ */
+export declare function normalizeProtocolSettlementReceiptV1(input: ProtocolSettlementReceiptInput): ProtocolSettlementReceiptV1;
+/**
+ * Validates, canonicalizes, and signs an authorization receipt with
+ * Ed25519-over-SHA-256(canonical JSON).
+ *
+ * @param signingSeed - 32-byte Ed25519 seed (noble private key).
+ */
+export declare function signProtocolAuthorizationReceiptV1(signingSeed: Uint8Array, input: ProtocolAuthorizationReceiptInput): ProtocolAuthorizationReceiptV1;
+/**
+ * Validates, canonicalizes, and signs a settlement receipt with
+ * Ed25519-over-SHA-256(canonical JSON).
+ *
+ * @param signingSeed - 32-byte Ed25519 seed (noble private key).
+ */
+export declare function signProtocolSettlementReceiptV1(signingSeed: Uint8Array, input: ProtocolSettlementReceiptInput): ProtocolSettlementReceiptV1;
+/**
+ * Checks structure, canonical digest recompute, and detached Ed25519 signature.
+ *
+ * @returns The normalized authorization receipt on success.
+ * @throws When structure, digest, or signature verification fails.
+ */
+export declare function verifyProtocolAuthorizationReceiptV1(input: ProtocolAuthorizationReceiptInput): ProtocolAuthorizationReceiptV1;
+/**
+ * Checks structure, canonical digest recompute, and detached Ed25519 signature.
+ *
+ * @returns The normalized settlement receipt on success.
+ * @throws When structure, digest, or signature verification fails.
+ */
+export declare function verifyProtocolSettlementReceiptV1(input: ProtocolSettlementReceiptInput): ProtocolSettlementReceiptV1;
+export {};