@paybond/kit 0.12.0 → 0.12.2

package/dist/shopify/checkout.js

@@ -0,0 +1,79 @@
+import { encodeCommerceBindingToShopifyNoteAttributes, } from "../commerce-binding.js";
+import { PAYBOND_UCP_AGENT_PROFILE_URL } from "./types.js";
+function requireNonEmptyTrimmed(value, label) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error(`shopify checkout: ${label} is required`);
+    }
+    return trimmed;
+}
+function normalizeVariantGid(variantId) {
+    const trimmed = variantId.trim();
+    if (!trimmed) {
+        throw new Error("shopify checkout: line item variantId is required");
+    }
+    if (trimmed.startsWith("gid://shopify/ProductVariant/")) {
+        return trimmed;
+    }
+    if (/^\d+$/.test(trimmed)) {
+        return `gid://shopify/ProductVariant/${trimmed}`;
+    }
+    return trimmed;
+}
+function assertPositiveQuantity(quantity) {
+    if (!Number.isInteger(quantity) || quantity <= 0) {
+        throw new Error("shopify checkout: line item quantity must be a positive integer");
+    }
+    return quantity;
+}
+/**
+ * Converts developer-friendly line items into UCP checkout `line_items`.
+ */
+export function toUcpCheckoutLineItems(lineItems) {
+    if (!Array.isArray(lineItems) || lineItems.length === 0) {
+        throw new Error("shopify checkout: at least one line item is required");
+    }
+    return lineItems.map((entry) => ({
+        item: { id: normalizeVariantGid(entry.variantId) },
+        quantity: assertPositiveQuantity(entry.quantity),
+    }));
+}
+/**
+ * Builds a UCP checkout create payload with canonical Paybond binding metadata in
+ * `note_attributes`.
+ *
+ * `tenantId` and `intentId` must be sourced from authenticated Paybond session context —
+ * never from unauthenticated client input.
+ */
+export function createCheckoutWithBinding(params) {
+    const tenantId = requireNonEmptyTrimmed(params.tenantId, "tenantId");
+    const intentId = requireNonEmptyTrimmed(params.intentId, "intentId");
+    const noteAttributes = encodeCommerceBindingToShopifyNoteAttributes({ tenantId, intentId }, params.existingNoteAttributes);
+    const payload = {
+        line_items: toUcpCheckoutLineItems(params.lineItems),
+        note_attributes: noteAttributes,
+    };
+    const cartId = params.cartId?.trim();
+    if (cartId) {
+        payload.cart_id = cartId;
+    }
+    const profileUrl = (params.agentProfileUrl ?? PAYBOND_UCP_AGENT_PROFILE_URL).trim();
+    payload.meta = { profile_url: profileUrl };
+    return payload;
+}
+/**
+ * Merges binding metadata into an existing UCP checkout mutation payload.
+ *
+ * Use for `update_checkout` and other checkout mutations so binding cannot be dropped.
+ */
+export function mergeBindingIntoCheckoutPayload(binding, checkoutPayload, agentProfileUrl = PAYBOND_UCP_AGENT_PROFILE_URL) {
+    const noteAttributes = encodeCommerceBindingToShopifyNoteAttributes(binding, checkoutPayload.note_attributes);
+    return {
+        ...checkoutPayload,
+        note_attributes: noteAttributes,
+        meta: {
+            ...(checkoutPayload.meta ?? {}),
+            profile_url: (checkoutPayload.meta?.profile_url ?? agentProfileUrl).trim(),
+        },
+    };
+}

package/dist/shopify/evidence.d.ts

@@ -0,0 +1,13 @@
+import type { MapShopifyToolResultToEvidenceOptions, ShopifyCheckoutToolResult } from "./types.js";
+export declare const SHOPIFY_COMMERCE_MAPPER_VERSION = "shopify_commerce_v1";
+/**
+ * Rejects Shopify order webhook envelopes — those fund Harbor intents and must not
+ * be submitted as tool-completion evidence.
+ */
+export declare function assertNotShopifyFundingWebhook(input: Record<string, unknown>): void;
+/**
+ * Normalizes Shopify checkout tool results into completion-catalog evidence fields.
+ *
+ * Rejects webhook-shaped funding payloads before mapping.
+ */
+export declare function mapShopifyToolResultToEvidence(toolResult: Record<string, unknown>, options: MapShopifyToolResultToEvidenceOptions): Pick<ShopifyCheckoutToolResult, "status" | "cost_cents">;

package/dist/shopify/evidence.js

@@ -0,0 +1,85 @@
+export const SHOPIFY_COMMERCE_MAPPER_VERSION = "shopify_commerce_v1";
+const SHOPIFY_FUNDING_TOPICS = new Set([
+    "orders/create",
+    "orders/paid",
+    "orders/updated",
+    "orders/cancelled",
+    "orders/fulfilled",
+    "refunds/create",
+]);
+function readObject(value) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return undefined;
+}
+function readString(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function readNumber(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Rejects Shopify order webhook envelopes — those fund Harbor intents and must not
+ * be submitted as tool-completion evidence.
+ */
+export function assertNotShopifyFundingWebhook(input) {
+    const topic = readString(input, "topic", "X-Shopify-Topic");
+    if (topic && SHOPIFY_FUNDING_TOPICS.has(topic)) {
+        throw new Error(`${topic} webhooks are funding signals, not tool-completion evidence`);
+    }
+    if (readString(input, "X-Shopify-Shop-Domain") && readString(input, "X-Shopify-Webhook-Id")) {
+        throw new Error("Shopify webhook envelopes are funding signals, not tool-completion evidence");
+    }
+    const adminGraphqlId = readString(input, "admin_graphql_api_id");
+    const orderNumber = readString(input, "order_number");
+    if (adminGraphqlId?.includes("gid://shopify/Order/") && orderNumber && !("status" in input)) {
+        throw new Error("Shopify order webhook payloads are funding signals, not tool-completion evidence");
+    }
+}
+function resolveCostCents(record) {
+    const cost = readNumber(record, "cost_cents", "costCents", "amount_cents", "amountCents") ??
+        readNumber(record, "total_price_cents", "totalPriceCents");
+    if (cost === undefined) {
+        throw new Error("Shopify tool result missing cost_cents");
+    }
+    if (!Number.isInteger(cost) || cost < 0) {
+        throw new Error("Shopify tool result cost_cents must be a non-negative integer");
+    }
+    return cost;
+}
+function mapCostAndCompletionEvidence(record) {
+    const status = readString(record, "status");
+    if (!status) {
+        throw new Error("Shopify tool result missing status");
+    }
+    return {
+        status: status,
+        cost_cents: resolveCostCents(record),
+    };
+}
+/**
+ * Normalizes Shopify checkout tool results into completion-catalog evidence fields.
+ *
+ * Rejects webhook-shaped funding payloads before mapping.
+ */
+export function mapShopifyToolResultToEvidence(toolResult, options) {
+    assertNotShopifyFundingWebhook(toolResult);
+    const preset = options.preset;
+    if (preset === "cost_and_completion") {
+        return mapCostAndCompletionEvidence(toolResult);
+    }
+    throw new Error(`mapShopifyToolResultToEvidence: unsupported preset ${preset}`);
+}

package/dist/shopify/index.d.ts

@@ -0,0 +1,8 @@
+export { PAYBOND_UCP_AGENT_PROFILE_URL, PAYBOND_SHOPIFY_UCP_VERSION } from "./types.js";
+export { SHOPIFY_COMMERCE_MAPPER_VERSION } from "./evidence.js";
+export { createCheckoutWithBinding, mergeBindingIntoCheckoutPayload, toUcpCheckoutLineItems, } from "./checkout.js";
+export { assertNotShopifyFundingWebhook, mapShopifyToolResultToEvidence, } from "./evidence.js";
+export { getOrder } from "./order.js";
+export { createGuardedShopifyCheckoutHandler, instrumentShopifyCheckout, } from "./instrument.js";
+export type { CreateCheckoutWithBindingParams, GetShopifyOrderParams, MapShopifyToolResultToEvidenceOptions, ShopifyCheckoutCreatePayload, ShopifyCheckoutExecuteInput, ShopifyCheckoutLineItemInput, ShopifyCheckoutToolArgs, ShopifyCheckoutToolResult, ShopifyCommerceEvidencePreset, ShopifyOrderSummary, ShopifyUcpCheckoutLineItem, ShopifyUcpFetch, } from "./types.js";
+export type { CreateGuardedShopifyCheckoutHandlerOptions, InstrumentShopifyCheckoutInput, ShopifyCheckoutExecutor, ShopifyCheckoutSessionBinding, } from "./instrument.js";

package/dist/shopify/index.js

@@ -0,0 +1,6 @@
+export { PAYBOND_UCP_AGENT_PROFILE_URL, PAYBOND_SHOPIFY_UCP_VERSION } from "./types.js";
+export { SHOPIFY_COMMERCE_MAPPER_VERSION } from "./evidence.js";
+export { createCheckoutWithBinding, mergeBindingIntoCheckoutPayload, toUcpCheckoutLineItems, } from "./checkout.js";
+export { assertNotShopifyFundingWebhook, mapShopifyToolResultToEvidence, } from "./evidence.js";
+export { getOrder } from "./order.js";
+export { createGuardedShopifyCheckoutHandler, instrumentShopifyCheckout, } from "./instrument.js";

package/dist/shopify/instrument.d.ts

@@ -0,0 +1,61 @@
+import type { Paybond } from "../index.js";
+import type { PaybondPolicyLoadSource } from "../policy/load.js";
+import type { PaybondInstrumentInput } from "../agent/instrument.js";
+import type { ShopifyCheckoutExecuteInput, ShopifyCheckoutToolArgs, ShopifyCheckoutToolResult } from "./types.js";
+/** Paybond session binding for Shopify checkout — never sourced from client input. */
+export type ShopifyCheckoutSessionBinding = {
+    tenantId: string;
+    intentId: string;
+};
+export type ShopifyCheckoutExecutor = (input: ShopifyCheckoutExecuteInput) => Promise<ShopifyCheckoutToolResult>;
+export type CreateGuardedShopifyCheckoutHandlerOptions = {
+    binding: () => ShopifyCheckoutSessionBinding;
+    executeCheckout: ShopifyCheckoutExecutor;
+    agentProfileUrl?: string;
+};
+export type InstrumentShopifyCheckoutInput = Omit<PaybondInstrumentInput<{
+    "commerce.checkout": (args: ShopifyCheckoutToolArgs) => Promise<ShopifyCheckoutToolResult>;
+}>, "tools"> & {
+    policy: PaybondPolicyLoadSource;
+    executeCheckout: ShopifyCheckoutExecutor;
+    agentProfileUrl?: string;
+    /**
+     * Mutable binding populated after sandbox bind or production attach.
+     * When omitted, a private ref is created for sandbox quickstarts.
+     */
+    bindingRef?: ShopifyCheckoutSessionBinding;
+};
+/**
+ * Wraps a checkout executor so binding metadata is injected on every call.
+ *
+ * `tenantId` and `intentId` are read from the Paybond session binding ref — never from tool args.
+ */
+export declare function createGuardedShopifyCheckoutHandler(options: CreateGuardedShopifyCheckoutHandlerOptions): (args: ShopifyCheckoutToolArgs) => Promise<ShopifyCheckoutToolResult>;
+/**
+ * Instruments `commerce.checkout` with Paybond middleware and guaranteed binding injection.
+ *
+ * Returns the standard {@link PaybondInstrumentRuntime} surface from `paybond.instrument()`.
+ */
+export declare function instrumentShopifyCheckout(paybond: Paybond, input: InstrumentShopifyCheckoutInput): Promise<{
+    bindingRef: ShopifyCheckoutSessionBinding;
+    tools: {
+        "commerce.checkout": (args: ShopifyCheckoutToolArgs) => Promise<ShopifyCheckoutToolResult>;
+    };
+    policy: import("../index.js").PaybondPolicy;
+    binding: Extract<import("../index.js").PaybondInstrumentBinding, {
+        phase: "deferred";
+    } | {
+        phase: "lazy";
+    }>;
+} | {
+    bindingRef: ShopifyCheckoutSessionBinding;
+    tools: {
+        "commerce.checkout": (args: ShopifyCheckoutToolArgs) => Promise<ShopifyCheckoutToolResult>;
+    };
+    run: import("../index.js").PaybondAgentRun;
+    policy: import("../index.js").PaybondPolicy;
+    hooks: import("../index.js").PaybondAgentHooks;
+    binding: Extract<import("../index.js").PaybondInstrumentBinding, {
+        phase: "bound";
+    }>;
+}>;

package/dist/shopify/instrument.js

@@ -0,0 +1,52 @@
+import { createCheckoutWithBinding } from "./checkout.js";
+import { PAYBOND_UCP_AGENT_PROFILE_URL } from "./types.js";
+/**
+ * Wraps a checkout executor so binding metadata is injected on every call.
+ *
+ * `tenantId` and `intentId` are read from the Paybond session binding ref — never from tool args.
+ */
+export function createGuardedShopifyCheckoutHandler(options) {
+    const profileUrl = (options.agentProfileUrl ?? PAYBOND_UCP_AGENT_PROFILE_URL).trim();
+    return async (args) => {
+        const { tenantId, intentId } = options.binding();
+        if (!tenantId.trim() || !intentId.trim()) {
+            throw new Error("Paybond session binding is required before commerce.checkout");
+        }
+        const checkoutPayload = createCheckoutWithBinding({
+            tenantId,
+            intentId,
+            lineItems: args.lineItems,
+            existingNoteAttributes: args.noteAttributes,
+            cartId: args.cartId,
+            agentProfileUrl: profileUrl,
+        });
+        return options.executeCheckout({
+            ...args,
+            tenantId,
+            intentId,
+            checkoutPayload,
+            agentProfileUrl: profileUrl,
+        });
+    };
+}
+/**
+ * Instruments `commerce.checkout` with Paybond middleware and guaranteed binding injection.
+ *
+ * Returns the standard {@link PaybondInstrumentRuntime} surface from `paybond.instrument()`.
+ */
+export async function instrumentShopifyCheckout(paybond, input) {
+    const bindingRef = input.bindingRef ?? { tenantId: "", intentId: "" };
+    const checkoutHandler = createGuardedShopifyCheckoutHandler({
+        binding: () => bindingRef,
+        executeCheckout: input.executeCheckout,
+        agentProfileUrl: input.agentProfileUrl,
+    });
+    const { bindingRef: _ignored, executeCheckout: _execute, ...instrumentInput } = input;
+    const instrumented = await paybond.instrument({
+        ...instrumentInput,
+        tools: {
+            "commerce.checkout": checkoutHandler,
+        },
+    });
+    return { ...instrumented, bindingRef };
+}

package/dist/shopify/order.d.ts

@@ -0,0 +1,8 @@
+import type { GetShopifyOrderParams, ShopifyOrderSummary } from "./types.js";
+/**
+ * Fetches an order via Shopify UCP Order MCP for reconciliation.
+ *
+ * Agents must not pass Shopify offline access tokens. This helper uses the UCP transport
+ * at `{shop}/api/ucp/mcp` with the Paybond agent profile URL.
+ */
+export declare function getOrder(params: GetShopifyOrderParams): Promise<ShopifyOrderSummary>;

package/dist/shopify/order.js

@@ -0,0 +1,110 @@
+import { decodeCommerceBindingFromShopifyNoteAttributes } from "../commerce-binding.js";
+import { PAYBOND_SHOPIFY_UCP_VERSION, PAYBOND_UCP_AGENT_PROFILE_URL } from "./types.js";
+function requireShopDomain(shopDomain) {
+    const trimmed = shopDomain.trim();
+    if (!trimmed) {
+        throw new Error("shopify order: shopDomain is required");
+    }
+    return trimmed.replace(/^https?:\/\//, "").replace(/\/$/, "");
+}
+function normalizeOrderGid(orderId) {
+    const trimmed = orderId.trim();
+    if (!trimmed) {
+        throw new Error("shopify order: orderId is required");
+    }
+    if (trimmed.startsWith("gid://shopify/Order/")) {
+        return trimmed;
+    }
+    if (/^\d+$/.test(trimmed)) {
+        return `gid://shopify/Order/${trimmed}`;
+    }
+    return trimmed;
+}
+function shopOrigin(shopDomain) {
+    const host = requireShopDomain(shopDomain);
+    return host.includes(".") ? `https://${host}` : `https://${host}.myshopify.com`;
+}
+function defaultFetchUcp(url, init) {
+    return fetch(url, init);
+}
+function readNoteAttributes(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const attrs = [];
+    for (const entry of value) {
+        if (!entry || typeof entry !== "object") {
+            continue;
+        }
+        const name = entry.name;
+        const attrValue = entry.value;
+        if (typeof name === "string" && typeof attrValue === "string") {
+            attrs.push({ name, value: attrValue });
+        }
+    }
+    return attrs;
+}
+function orderSummaryFromPayload(shop, orderId, payload) {
+    const noteAttributes = readNoteAttributes(payload.note_attributes);
+    const binding = decodeCommerceBindingFromShopifyNoteAttributes(noteAttributes);
+    return {
+        order_id: readString(payload, "id", "order_id", "admin_graphql_api_id") ?? orderId,
+        shop,
+        financial_status: readString(payload, "financial_status"),
+        note_attributes: noteAttributes,
+        binding: {
+            tenant_id: binding?.tenantId ?? null,
+            paybond_intent_id: binding?.intentId ?? null,
+        },
+    };
+}
+function readString(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+/**
+ * Fetches an order via Shopify UCP Order MCP for reconciliation.
+ *
+ * Agents must not pass Shopify offline access tokens. This helper uses the UCP transport
+ * at `{shop}/api/ucp/mcp` with the Paybond agent profile URL.
+ */
+export async function getOrder(params) {
+    const shop = requireShopDomain(params.shopDomain);
+    const orderId = normalizeOrderGid(params.orderId);
+    const profileUrl = (params.agentProfileUrl ?? PAYBOND_UCP_AGENT_PROFILE_URL).trim();
+    const fetchUcp = params.fetchUcp ?? defaultFetchUcp;
+    const response = await fetchUcp(`${shopOrigin(shop)}/api/ucp/mcp`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            "UCP-Agent": profileUrl,
+        },
+        body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: "paybond-kit-get-order",
+            method: "order/get",
+            params: {
+                order_id: orderId,
+                meta: {
+                    profile_url: profileUrl,
+                    ucp_version: PAYBOND_SHOPIFY_UCP_VERSION,
+                },
+            },
+        }),
+    });
+    const body = (await response.json());
+    if (!response.ok) {
+        const message = readString(body, "message", "error") ?? `UCP order/get failed (${response.status})`;
+        throw new Error(message);
+    }
+    const result = body.result;
+    if (!result || typeof result !== "object") {
+        throw new Error("shopify order: UCP response missing result");
+    }
+    return orderSummaryFromPayload(shop, orderId, result);
+}

package/dist/shopify/types.d.ts

@@ -0,0 +1,82 @@
+import type { ShopifyNoteAttribute } from "../commerce-binding.js";
+/** Canonical Paybond UCP agent profile URL for Shopify partner registration. */
+export declare const PAYBOND_UCP_AGENT_PROFILE_URL = "https://paybond.ai/.well-known/ucp/profile.json";
+/** Default UCP protocol version supported by Paybond Kit Shopify helpers. */
+export declare const PAYBOND_SHOPIFY_UCP_VERSION = "2026-04-08";
+/** Shopify commerce evidence presets supported by {@link mapShopifyToolResultToEvidence}. */
+export type ShopifyCommerceEvidencePreset = "cost_and_completion";
+export type MapShopifyToolResultToEvidenceOptions = {
+    preset: ShopifyCommerceEvidencePreset;
+};
+/** Line item input for {@link createCheckoutWithBinding}. */
+export type ShopifyCheckoutLineItemInput = {
+    variantId: string;
+    quantity: number;
+};
+/** UCP checkout line item shape (Shopify Checkout MCP). */
+export type ShopifyUcpCheckoutLineItem = {
+    item: {
+        id: string;
+    };
+    quantity: number;
+};
+/** Inputs for {@link createCheckoutWithBinding}. Binding ids must come from Paybond session context. */
+export type CreateCheckoutWithBindingParams = {
+    intentId: string;
+    tenantId: string;
+    lineItems: readonly ShopifyCheckoutLineItemInput[];
+    existingNoteAttributes?: readonly ShopifyNoteAttribute[];
+    cartId?: string;
+    agentProfileUrl?: string;
+};
+/** UCP `create_checkout` payload with binding metadata injected. */
+export type ShopifyCheckoutCreatePayload = {
+    line_items: ShopifyUcpCheckoutLineItem[];
+    note_attributes: ShopifyNoteAttribute[];
+    cart_id?: string;
+    meta?: {
+        profile_url: string;
+    };
+};
+/** Checkout tool completion envelope for `commerce.checkout` evidence mapping. */
+export type ShopifyCheckoutToolResult = {
+    status: "completed" | "requires_escalation" | "failed";
+    cost_cents: number;
+    order_id?: string;
+    shop: string;
+    continue_url?: string;
+};
+/** Arguments accepted by guarded `commerce.checkout` tool handlers. */
+export type ShopifyCheckoutToolArgs = {
+    shopDomain: string;
+    lineItems: readonly ShopifyCheckoutLineItemInput[];
+    amountCents: number;
+    cartId?: string;
+    noteAttributes?: readonly ShopifyNoteAttribute[];
+};
+/** Arguments passed to the checkout executor after binding injection. */
+export type ShopifyCheckoutExecuteInput = ShopifyCheckoutToolArgs & {
+    tenantId: string;
+    intentId: string;
+    checkoutPayload: ShopifyCheckoutCreatePayload;
+    agentProfileUrl: string;
+};
+export type ShopifyUcpFetch = (url: string, init: RequestInit) => Promise<Response>;
+/** Inputs for {@link getOrder}. Agents must not pass Shopify offline access tokens. */
+export type GetShopifyOrderParams = {
+    shopDomain: string;
+    orderId: string;
+    agentProfileUrl?: string;
+    fetchUcp?: ShopifyUcpFetch;
+};
+/** Normalized order view for reconciliation helpers. */
+export type ShopifyOrderSummary = {
+    order_id: string;
+    shop: string;
+    financial_status?: string;
+    note_attributes: ShopifyNoteAttribute[];
+    binding: {
+        tenant_id: string | null;
+        paybond_intent_id: string | null;
+    };
+};

package/dist/shopify/types.js

@@ -0,0 +1,4 @@
+/** Canonical Paybond UCP agent profile URL for Shopify partner registration. */
+export const PAYBOND_UCP_AGENT_PROFILE_URL = "https://paybond.ai/.well-known/ucp/profile.json";
+/** Default UCP protocol version supported by Paybond Kit Shopify helpers. */
+export const PAYBOND_SHOPIFY_UCP_VERSION = "2026-04-08";

package/dist/solutions/catalog.d.ts

@@ -21,7 +21,7 @@ export type SolutionSmokeDefaults = {
     evidencePreset: string;
     resultBody: Record<string, unknown>;
 };
-declare const KNOWN_SOLUTION_IDS: readonly ["travel", "shopping", "saas", "aws"];
+declare const KNOWN_SOLUTION_IDS: readonly ["travel", "shopping", "saas", "aws", "stripe-commerce"];
 export type SolutionId = (typeof KNOWN_SOLUTION_IDS)[number];
 /** True when `value` is a bundled solution id (travel, shopping, saas, aws). */
 export declare function isKnownSolutionId(value: string): value is SolutionId;

package/dist/solutions/catalog.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-const KNOWN_SOLUTION_IDS = ["travel", "shopping", "saas", "aws"];
+const KNOWN_SOLUTION_IDS = ["travel", "shopping", "saas", "aws", "stripe-commerce"];
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 function solutionCandidatePaths(solutionId) {
     const fileName = `${solutionId}.json`;

package/dist/stripe-commerce/evidence.d.ts

@@ -0,0 +1,13 @@
+import type { CostAndCompletionEvidence, MapStripeToolResultToEvidenceOptions, StripeChargeVendorEvidence } from "./types.js";
+export declare const STRIPE_COMMERCE_MAPPER_VERSION = "stripe_commerce_v1";
+/**
+ * Rejects Stripe funding webhook envelopes — those fund Harbor intents and must not
+ * be submitted as tool-completion evidence.
+ */
+export declare function assertNotStripeFundingWebhook(input: Record<string, unknown>): void;
+/**
+ * Normalizes Stripe SDK tool results into completion-catalog evidence fields.
+ *
+ * Rejects webhook-shaped funding payloads before mapping.
+ */
+export declare function mapStripeToolResultToEvidence(toolResult: Record<string, unknown>, options: MapStripeToolResultToEvidenceOptions): StripeChargeVendorEvidence | CostAndCompletionEvidence;