@paybond/kit 0.10.0 → 0.11.0

package/dist/openai-agents/sandbox-demo.d.ts

@@ -0,0 +1,34 @@
+import type { Paybond } from "../index.js";
+export type RunOpenAIAgentsSandboxDemoInput = {
+    paybond: Paybond;
+    operation?: string;
+    requestedSpendCents?: number;
+    evidencePreset?: string;
+    toolCallId?: string;
+};
+export type RunOpenAIAgentsSandboxDemoResult = {
+    bind: {
+        run_id: string;
+        tenant_id: string;
+        intent_id: string;
+        capability_token: string;
+        operation: string;
+        sandbox_lifecycle_status?: string;
+    };
+    guardrail: {
+        behavior: string;
+    };
+    execute: {
+        tool_result?: unknown;
+        evidence?: {
+            submitted: boolean;
+            sandbox_lifecycle_status?: string;
+            predicate_passed?: boolean | null;
+        };
+    };
+};
+/**
+ * No-LLM OpenAI Agents SDK sandbox demo: input guardrail pre-check + guarded
+ * `invoke` + auto-evidence.
+ */
+export declare function runOpenAIAgentsSandboxDemo(input: RunOpenAIAgentsSandboxDemoInput): Promise<RunOpenAIAgentsSandboxDemoResult>;

package/dist/openai-agents/sandbox-demo.js

@@ -0,0 +1,118 @@
+import { createPaybondToolRegistry } from "../agent/registry.js";
+import { createPaybondOpenAIAgentsConfig } from "./index.js";
+function makePaidFunctionTool(name) {
+    return {
+        type: "function",
+        name,
+        description: `Paid operation ${name}`,
+        parameters: {
+            type: "object",
+            properties: {
+                estimatedPriceCents: { type: "integer", minimum: 0 },
+            },
+            required: ["estimatedPriceCents"],
+            additionalProperties: false,
+        },
+        strict: false,
+        invoke: async (_runContext, input) => {
+            const args = JSON.parse(input);
+            return JSON.stringify({
+                status: "completed",
+                cost_cents: args.estimatedPriceCents,
+            });
+        },
+        needsApproval: async () => false,
+        isEnabled: async () => true,
+    };
+}
+/**
+ * No-LLM OpenAI Agents SDK sandbox demo: input guardrail pre-check + guarded
+ * `invoke` + auto-evidence.
+ */
+export async function runOpenAIAgentsSandboxDemo(input) {
+    const operation = (input.operation ?? "paid-tool").trim();
+    const requestedSpendCents = input.requestedSpendCents ?? 100;
+    const evidencePreset = (input.evidencePreset ?? "cost_and_completion").trim();
+    const toolCallId = (input.toolCallId ?? "openai-demo-1").trim();
+    const registry = createPaybondToolRegistry({
+        defaultDeny: true,
+        sideEffecting: {
+            [operation]: {
+                operation,
+                evidencePreset,
+                spendCents: (args) => typeof args === "object" &&
+                    args !== null &&
+                    "estimatedPriceCents" in args &&
+                    typeof args.estimatedPriceCents === "number"
+                    ? args.estimatedPriceCents
+                    : requestedSpendCents,
+                evidenceMapper: (result) => {
+                    const payload = result;
+                    return {
+                        status: payload.status,
+                        cost_cents: payload.cost_cents,
+                    };
+                },
+            },
+        },
+    });
+    const run = await input.paybond.agentRun.bind({
+        bootstrap: {
+            kind: "sandbox",
+            operation,
+            requestedSpendCents,
+            completionPreset: evidencePreset,
+        },
+        registry,
+    });
+    const paidTool = makePaidFunctionTool(operation);
+    const config = createPaybondOpenAIAgentsConfig(run, [paidTool]);
+    const guarded = config.tools[0];
+    if (!guarded) {
+        throw new Error("openai-agents sandbox demo missing guarded tool");
+    }
+    const toolCall = {
+        type: "function_call",
+        name: operation,
+        callId: toolCallId,
+        arguments: JSON.stringify({ estimatedPriceCents: requestedSpendCents }),
+    };
+    const guardrail = guarded.inputGuardrails?.[0];
+    const guardrailResult = guardrail
+        ? await guardrail.run({
+            agent: {},
+            context: {},
+            toolCall,
+        })
+        : undefined;
+    const output = (await guarded.invoke({}, JSON.stringify({ estimatedPriceCents: requestedSpendCents }), { toolCall }));
+    let toolResult;
+    try {
+        toolResult = JSON.parse(output);
+    }
+    catch {
+        toolResult = output;
+    }
+    const sandboxStatus = run.binding.sandbox?.sandboxLifecycleStatus;
+    return {
+        bind: {
+            run_id: run.runId,
+            tenant_id: run.tenantId,
+            intent_id: run.intentId,
+            capability_token: run.capabilityToken,
+            operation,
+            sandbox_lifecycle_status: sandboxStatus,
+        },
+        guardrail: {
+            behavior: guardrailResult?.behavior.type ?? "not-applicable",
+        },
+        execute: {
+            tool_result: toolResult,
+            evidence: {
+                submitted: true,
+                sandbox_lifecycle_status: sandboxStatus,
+                predicate_passed: true,
+            },
+        },
+    };
+}

package/dist/payee-evidence.js

@@ -3,28 +3,9 @@
  */
 import { sign, getPublicKey } from "@noble/ed25519";
 import { createHash } from "blake3";
-import { parse as parseUuid } from "uuid";
 import { ensureEd25519Sha512Sync } from "./ed25519-sync.js";
 import { jsonValueDigest } from "./json-digest.js";
-function concatBytes(...parts) {
-    const n = parts.reduce((a, p) => a + p.length, 0);
-    const out = new Uint8Array(n);
-    let o = 0;
-    for (const p of parts) {
-        out.set(p, o);
-        o += p.length;
-    }
-    return out;
-}
-function encodeU64(n) {
-    const b = new Uint8Array(8);
-    new DataView(b.buffer).setBigUint64(0, BigInt(n), true);
-    return b;
-}
-function encodeBincodeString(s) {
-    const utf8 = new TextEncoder().encode(s);
-    return concatBytes(encodeU64(utf8.length), utf8);
-}
+import { concatBytes, encodeBincodeString, encodeBincodeUuid, encodeFixed32, encodeU8, EVIDENCE_SIGN_VERSION, } from "./bincode-wire.js";
 /** BLAKE3 digest of concatenated artifact hashes (empty list matches Harbor / `paybond-evidence`). */
 export function artifactsDigest(artifactHashes32) {
     const h = createHash();
@@ -35,15 +16,7 @@ export function artifactsDigest(artifactHashes32) {
     return new Uint8Array(buf);
 }
 function encodeEvidenceSignV1(input) {
-    const version = new Uint8Array([1]);
-    const intentBytes = parseUuid(input.intentId);
-    if (intentBytes.length !== 16) {
-        throw new Error("intentId must be a UUID string");
-    }
-    if (input.payloadDigest.length !== 32 || input.artifactsDigest.length !== 32) {
-        throw new Error("digest must be 32 bytes");
-    }
-    return concatBytes(version, encodeBincodeString(input.tenantId), encodeU64(16), intentBytes, encodeBincodeString(input.payeeDid), input.payloadDigest, input.artifactsDigest, encodeBincodeString(input.submittedAtRfc3339));
+    return concatBytes(encodeU8(EVIDENCE_SIGN_VERSION), encodeBincodeString(input.tenantId), encodeBincodeUuid(input.intentId), encodeBincodeString(input.payeeDid), encodeFixed32(input.payloadDigest), encodeFixed32(input.artifactsDigest), encodeBincodeString(input.submittedAtRfc3339));
 }
 function bytesToBase64(bytes) {
     let binary = "";

package/dist/policy/catalog.d.ts

@@ -0,0 +1,31 @@
+import { listGuardrailCatalogEntries } from "./guardrail-spec.js";
+export type PolicyDomainCatalogEntry = {
+    id: string;
+    title: string;
+    layered: boolean;
+};
+export type PolicyPresetCatalogEntry = {
+    id: string;
+    kind: "composed" | "flat";
+    layered: boolean;
+};
+export type PolicySolutionCatalogEntry = {
+    id: string;
+    title: string;
+    domain: string;
+    guardrails: string[];
+    primary_operation: string;
+};
+/** List bundled domain layers for CLI and docs. */
+export declare function listPolicyDomainCatalog(): PolicyDomainCatalogEntry[];
+/** List flat and composed policy presets. */
+export declare function listPolicyPresetCatalog(): PolicyPresetCatalogEntry[];
+/** List bundled solution manifests. */
+export declare function listPolicySolutionCatalog(): PolicySolutionCatalogEntry[];
+/** Combined catalog payload for `paybond policy presets list`. */
+export declare function listPolicyPresetsCatalog(): {
+    domains: PolicyDomainCatalogEntry[];
+    guardrails: ReturnType<typeof listGuardrailCatalogEntries>;
+    solutions: PolicySolutionCatalogEntry[];
+    presets: PolicyPresetCatalogEntry[];
+};

package/dist/policy/catalog.js

@@ -0,0 +1,48 @@
+import { LAYERED_POLICY_PRESET_IDS } from "./compose.js";
+import { listGuardrailCatalogEntries } from "./guardrail-spec.js";
+import { isLayeredPolicyPresetId, listPolicyPresetIds } from "./presets.js";
+import { listSolutionIds, loadSolutionManifest } from "../solutions/catalog.js";
+const DOMAIN_TITLES = {
+    travel: "Travel booking",
+    shopping: "Shopping checkout",
+    saas: "SaaS provisioning",
+    aws: "AWS operator",
+};
+/** List bundled domain layers for CLI and docs. */
+export function listPolicyDomainCatalog() {
+    return LAYERED_POLICY_PRESET_IDS.map((id) => ({
+        id,
+        title: DOMAIN_TITLES[id] ?? id,
+        layered: true,
+    }));
+}
+/** List flat and composed policy presets. */
+export function listPolicyPresetCatalog() {
+    return listPolicyPresetIds().map((id) => ({
+        id,
+        kind: isLayeredPolicyPresetId(id) ? "composed" : "flat",
+        layered: isLayeredPolicyPresetId(id),
+    }));
+}
+/** List bundled solution manifests. */
+export function listPolicySolutionCatalog() {
+    return listSolutionIds().map((id) => {
+        const manifest = loadSolutionManifest(id);
+        return {
+            id: manifest.id,
+            title: manifest.title,
+            domain: manifest.policy_default.domain,
+            guardrails: [...manifest.policy_default.guardrails],
+            primary_operation: manifest.primary_operation,
+        };
+    });
+}
+/** Combined catalog payload for `paybond policy presets list`. */
+export function listPolicyPresetsCatalog() {
+    return {
+        domains: listPolicyDomainCatalog(),
+        guardrails: listGuardrailCatalogEntries(),
+        solutions: listPolicySolutionCatalog(),
+        presets: listPolicyPresetCatalog(),
+    };
+}

package/dist/policy/compose-utils.d.ts

@@ -0,0 +1,3 @@
+import type { PaybondPolicyToolEntry } from "./schema.js";
+/** Clone a tool registry entry for compose merges. */
+export declare function cloneToolEntry(entry: PaybondPolicyToolEntry): PaybondPolicyToolEntry;

package/dist/policy/compose-utils.js

@@ -0,0 +1,4 @@
+/** Clone a tool registry entry for compose merges. */
+export function cloneToolEntry(entry) {
+    return { ...entry };
+}

package/dist/policy/compose.d.ts

@@ -0,0 +1,20 @@
+import { type PolicyGuardrailLayer } from "./guardrails.js";
+import { type PolicyPresetId } from "./presets.js";
+import { type PaybondPolicyDocumentV1 } from "./schema.js";
+export declare const LAYERED_POLICY_PRESET_IDS: readonly ["travel", "shopping", "saas", "aws"];
+export type LayeredPolicyPresetId = (typeof LAYERED_POLICY_PRESET_IDS)[number];
+/** Stack a domain document with one or more guardrail layers (same-tenant compose, not org inheritance). */
+export declare function composePolicyLayers(domainDocument: PaybondPolicyDocumentV1, ...layers: PolicyGuardrailLayer[]): PaybondPolicyDocumentV1;
+/** True when a bundled preset is composed from domain + guardrails layers. */
+export declare function isLayeredPolicyPreset(presetId: string): presetId is LayeredPolicyPresetId;
+/** Merge domain and guardrail YAML objects (bundled preset file generation). */
+export declare function composePolicyPresetLayers(domain: Record<string, unknown>, guardrails: Record<string, unknown>): Record<string, unknown>;
+/** Default bundled guardrail layers for a vertical preset id. */
+export declare function bundledDefaultGuardrails(presetId: LayeredPolicyPresetId): PolicyGuardrailLayer[];
+/** Compose the shipped default for a vertical preset (domain + bundled guardrails). */
+export declare function composeBundledPresetDefault(presetId: LayeredPolicyPresetId): PaybondPolicyDocumentV1;
+/** Load and compose a layered vertical preset (domain + guardrails YAML files). */
+export declare function composeLayeredPolicyPresetDocument(presetId: LayeredPolicyPresetId): Record<string, unknown>;
+/** Compare composed layered presets with bundled flat preset files (tests). */
+export declare function assertLayeredPresetMatchesFlat(presetId: PolicyPresetId): void;
+export { readPresetLayerYaml } from "./layers-io.js";

package/dist/policy/compose.js

@@ -0,0 +1,240 @@
+import { cloneToolEntry } from "./compose-utils.js";
+import { guardrailLayerFromDocument } from "./guardrails.js";
+import { loadBundledDefaultGuardrailsDocument, loadBundledDomainDocument, } from "./layers-io.js";
+import { parsePolicyDocumentText } from "./parse-text.js";
+import { readPolicyPresetYaml, resolvePolicyPresetPath } from "./presets.js";
+import { parsePaybondPolicyDocumentV1, } from "./schema.js";
+export const LAYERED_POLICY_PRESET_IDS = ["travel", "shopping", "saas", "aws"];
+function mergeStricterDefaultDeny(...values) {
+    return values.some((value) => value === true);
+}
+function cloneDocument(document) {
+    return {
+        ...document,
+        tools: Object.fromEntries(Object.entries(document.tools).map(([name, entry]) => [name, cloneToolEntry(entry)])),
+        intent: document.intent
+            ? {
+                ...document.intent,
+                ...(document.intent.allowed_tools
+                    ? { allowed_tools: [...document.intent.allowed_tools] }
+                    : {}),
+                ...(document.intent.budget ? { budget: { ...document.intent.budget } } : {}),
+                ...(document.intent.policy_binding
+                    ? { policy_binding: { ...document.intent.policy_binding } }
+                    : {}),
+            }
+            : undefined,
+    };
+}
+function mergeToolEntry(base, patch) {
+    const merged = cloneToolEntry(base);
+    if (patch.side_effecting !== undefined) {
+        merged.side_effecting = patch.side_effecting;
+    }
+    if (patch.max_spend_cents !== undefined) {
+        merged.max_spend_cents =
+            merged.max_spend_cents !== undefined
+                ? Math.min(merged.max_spend_cents, patch.max_spend_cents)
+                : patch.max_spend_cents;
+    }
+    if (patch.spend_from_args !== undefined) {
+        merged.spend_from_args = patch.spend_from_args;
+        delete merged.max_spend_cents;
+    }
+    if (patch.evidence_preset !== undefined) {
+        merged.evidence_preset = patch.evidence_preset;
+    }
+    if (patch.vendor_pack !== undefined) {
+        merged.vendor_pack = patch.vendor_pack;
+    }
+    if (patch.operation !== undefined) {
+        merged.operation = patch.operation;
+    }
+    return merged;
+}
+function mergeBudgetCaps(current, nextUsd) {
+    const currency = current?.currency ?? "usd";
+    const currentUsd = current?.max_spend_usd;
+    return {
+        ...current,
+        currency,
+        max_spend_usd: currentUsd !== undefined ? Math.min(currentUsd, nextUsd) : nextUsd,
+    };
+}
+function applyReadOnlyFilter(document, searchOnly) {
+    const filteredEntries = Object.entries(document.tools).filter(([name, entry]) => {
+        if (entry.side_effecting) {
+            return false;
+        }
+        return !searchOnly || name.startsWith("search.");
+    });
+    document.tools = Object.fromEntries(filteredEntries);
+    if (document.intent?.allowed_tools) {
+        const allowed = new Set(Object.keys(document.tools));
+        document.intent.allowed_tools = document.intent.allowed_tools.filter((tool) => allowed.has(tool));
+    }
+}
+function assertEvidenceRequired(document) {
+    for (const [name, entry] of Object.entries(document.tools)) {
+        if (entry.side_effecting && !entry.evidence_preset) {
+            throw new Error(`side-effecting tool "${name}" must declare evidence_preset`);
+        }
+    }
+}
+function applyGuardrailLayer(document, layer) {
+    if (layer.default_deny !== undefined) {
+        document.default_deny = mergeStricterDefaultDeny(document.default_deny, layer.default_deny);
+    }
+    if (layer.tools) {
+        for (const [toolName, patch] of Object.entries(layer.tools)) {
+            const existing = document.tools[toolName];
+            if (existing) {
+                document.tools[toolName] = mergeToolEntry(existing, patch);
+            }
+        }
+    }
+    if (layer.intent) {
+        document.intent = {
+            ...document.intent,
+            ...layer.intent,
+            ...(layer.intent.allowed_tools
+                ? {
+                    allowed_tools: layer.intent.allowed_tools,
+                }
+                : {}),
+            ...(layer.intent.budget
+                ? {
+                    budget: {
+                        ...document.intent?.budget,
+                        ...layer.intent.budget,
+                    },
+                }
+                : {}),
+            ...(layer.intent.policy_binding
+                ? {
+                    policy_binding: {
+                        ...document.intent?.policy_binding,
+                        ...layer.intent.policy_binding,
+                    },
+                }
+                : {}),
+        };
+    }
+    if (layer.caps?.sideEffectingMaxSpendCents !== undefined) {
+        const cents = layer.caps.sideEffectingMaxSpendCents;
+        for (const [toolName, entry] of Object.entries(document.tools)) {
+            if (entry.side_effecting) {
+                document.tools[toolName] = mergeToolEntry(entry, { max_spend_cents: cents });
+            }
+        }
+    }
+    if (layer.caps?.budgetMaxSpendUsd !== undefined) {
+        document.intent = {
+            ...document.intent,
+            budget: mergeBudgetCaps(document.intent?.budget, layer.caps.budgetMaxSpendUsd),
+        };
+    }
+    if (layer.filters?.readOnly || layer.filters?.readOnlySearch) {
+        applyReadOnlyFilter(document, Boolean(layer.filters.readOnlySearch));
+    }
+    if (layer.requireEvidence) {
+        assertEvidenceRequired(document);
+    }
+}
+/** Stack a domain document with one or more guardrail layers (same-tenant compose, not org inheritance). */
+export function composePolicyLayers(domainDocument, ...layers) {
+    const composed = cloneDocument(domainDocument);
+    for (const layer of layers) {
+        applyGuardrailLayer(composed, layer);
+    }
+    assertEvidenceRequired(composed);
+    return composed;
+}
+/** True when a bundled preset is composed from domain + guardrails layers. */
+export function isLayeredPolicyPreset(presetId) {
+    return LAYERED_POLICY_PRESET_IDS.includes(presetId.trim());
+}
+function guardrailsFileName(presetId) {
+    return `default-${presetId}.yaml`;
+}
+function deepMergeRecord(base, patch) {
+    const result = { ...base };
+    for (const [key, patchValue] of Object.entries(patch)) {
+        const baseValue = result[key];
+        if (baseValue &&
+            patchValue &&
+            typeof baseValue === "object" &&
+            typeof patchValue === "object" &&
+            !Array.isArray(baseValue) &&
+            !Array.isArray(patchValue)) {
+            result[key] = deepMergeRecord(baseValue, patchValue);
+        }
+        else {
+            result[key] = patchValue;
+        }
+    }
+    return result;
+}
+/** Merge domain and guardrail YAML objects (bundled preset file generation). */
+export function composePolicyPresetLayers(domain, guardrails) {
+    return deepMergeRecord(domain, guardrails);
+}
+/** Default bundled guardrail layers for a vertical preset id. */
+export function bundledDefaultGuardrails(presetId) {
+    return [guardrailLayerFromDocument(loadBundledDefaultGuardrailsDocument(presetId))];
+}
+/** Compose the shipped default for a vertical preset (domain + bundled guardrails). */
+export function composeBundledPresetDefault(presetId) {
+    return composePolicyLayers(parsePaybondPolicyDocumentV1(loadBundledDomainDocument(presetId)), ...bundledDefaultGuardrails(presetId));
+}
+/** Load and compose a layered vertical preset (domain + guardrails YAML files). */
+export function composeLayeredPolicyPresetDocument(presetId) {
+    const domain = loadBundledDomainDocument(presetId);
+    const guardrails = loadBundledDefaultGuardrailsDocument(presetId);
+    return composePolicyPresetLayers(domain, guardrails);
+}
+/** Compare composed layered presets with bundled flat preset files (tests). */
+export function assertLayeredPresetMatchesFlat(presetId) {
+    if (!isLayeredPolicyPreset(presetId)) {
+        return;
+    }
+    const composed = composeLayeredPolicyPresetDocument(presetId);
+    const flatPath = resolvePolicyPresetPath(presetId);
+    const flat = parsePolicyDocumentText(readPolicyPresetYaml(presetId), flatPath);
+    if (JSON.stringify(normalizePolicyPresetDocument(composed)) !==
+        JSON.stringify(normalizePolicyPresetDocument(flat))) {
+        throw new Error(`composed preset ${presetId} does not match flat bundled file`);
+    }
+}
+function normalizePolicyPresetDocument(document) {
+    const tools = document.tools;
+    const normalizedTools = tools && typeof tools === "object" && !Array.isArray(tools)
+        ? Object.fromEntries(Object.entries(tools)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([name, entry]) => [
+            name,
+            entry && typeof entry === "object" && !Array.isArray(entry)
+                ? Object.fromEntries(Object.entries(entry).sort(([left], [right]) => left.localeCompare(right)))
+                : entry,
+        ]))
+        : tools;
+    const intent = document.intent;
+    const normalizedIntent = intent && typeof intent === "object" && !Array.isArray(intent)
+        ? {
+            ...intent,
+            ...(Array.isArray(intent.allowed_tools)
+                ? {
+                    allowed_tools: [
+                        ...intent.allowed_tools,
+                    ].sort(),
+                }
+                : {}),
+        }
+        : intent;
+    return {
+        ...document,
+        ...(normalizedTools !== undefined ? { tools: normalizedTools } : {}),
+        ...(normalizedIntent !== undefined ? { intent: normalizedIntent } : {}),
+    };
+}
+export { readPresetLayerYaml } from "./layers-io.js";

package/dist/policy/digest.d.ts

@@ -0,0 +1,7 @@
+import type { PaybondPolicyDocumentV1 } from "./schema.js";
+/** Serialize a validated v1 policy document to Gateway-compatible JSON dict form. */
+export declare function policyDocumentToDict(document: PaybondPolicyDocumentV1): Record<string, unknown>;
+/** Return `sha256:<hex>` for the canonical JSON encoding of a v1 policy document. */
+export declare function canonicalPolicyDocumentDigest(document: PaybondPolicyDocumentV1): string;
+/** Human-readable policy version label (`{name}@{digest_short}`). */
+export declare function policyVersionLabel(name: string, digest: string): string;

package/dist/policy/digest.js

@@ -0,0 +1,75 @@
+import { createHash } from "node:crypto";
+/** Serialize a validated v1 policy document to Gateway-compatible JSON dict form. */
+export function policyDocumentToDict(document) {
+    const tools = Object.fromEntries(Object.entries(document.tools).map(([toolName, entry]) => [
+        toolName,
+        {
+            side_effecting: entry.side_effecting,
+            ...(entry.max_spend_cents !== undefined ? { max_spend_cents: entry.max_spend_cents } : {}),
+            ...(entry.spend_from_args !== undefined ? { spend_from_args: entry.spend_from_args } : {}),
+            ...(entry.evidence_preset !== undefined ? { evidence_preset: entry.evidence_preset } : {}),
+            ...(entry.vendor_pack !== undefined ? { vendor_pack: entry.vendor_pack } : {}),
+            ...(entry.operation !== undefined ? { operation: entry.operation } : {}),
+        },
+    ]));
+    const payload = {
+        version: document.version,
+        name: document.name,
+        default_deny: document.default_deny,
+        tools,
+    };
+    if (document.intent) {
+        const intent = {};
+        if (document.intent.policy_binding) {
+            const binding = {
+                template_id: document.intent.policy_binding.template_id,
+            };
+            if (document.intent.policy_binding.version_seq !== undefined) {
+                binding.version_seq = document.intent.policy_binding.version_seq;
+            }
+            if (document.intent.policy_binding.head_digest !== undefined) {
+                binding.head_digest = document.intent.policy_binding.head_digest;
+            }
+            intent.policy_binding = binding;
+        }
+        if (document.intent.budget) {
+            intent.budget = document.intent.budget;
+        }
+        if (document.intent.allowed_tools?.length) {
+            intent.allowed_tools = document.intent.allowed_tools;
+        }
+        if (Object.keys(intent).length > 0) {
+            payload.intent = intent;
+        }
+    }
+    return payload;
+}
+function canonicalizeJson(value) {
+    if (Array.isArray(value)) {
+        return value.map(canonicalizeJson);
+    }
+    if (value && typeof value === "object") {
+        const row = value;
+        const out = {};
+        for (const key of Object.keys(row).sort()) {
+            out[key] = canonicalizeJson(row[key]);
+        }
+        return out;
+    }
+    return value;
+}
+/** Return `sha256:<hex>` for the canonical JSON encoding of a v1 policy document. */
+export function canonicalPolicyDocumentDigest(document) {
+    const wire = policyDocumentToDict(document);
+    const text = JSON.stringify(canonicalizeJson(wire));
+    const hash = createHash("sha256").update(text, "utf8").digest("hex");
+    return `sha256:${hash}`;
+}
+/** Human-readable policy version label (`{name}@{digest_short}`). */
+export function policyVersionLabel(name, digest) {
+    const trimmed = digest.trim();
+    const short = trimmed.startsWith("sha256:") && trimmed.length >= 15
+        ? trimmed.slice(7, 15)
+        : trimmed.slice(0, 8);
+    return `${name}@${short}`;
+}

package/dist/policy/domain.d.ts

@@ -0,0 +1,15 @@
+import { type PaybondPolicyDocumentV1 } from "./schema.js";
+/** Travel booking domain: hotel booking + read-only web search. */
+export declare function travel(): PaybondPolicyDocumentV1;
+/** Shopping domain: checkout + product search. */
+export declare function shopping(): PaybondPolicyDocumentV1;
+/** SaaS domain: seat provisioning + plan listing. */
+export declare function saas(): PaybondPolicyDocumentV1;
+/** AWS operator domain: EC2 start + describe. */
+export declare function aws(): PaybondPolicyDocumentV1;
+export declare const domain: {
+    readonly travel: typeof travel;
+    readonly shopping: typeof shopping;
+    readonly saas: typeof saas;
+    readonly aws: typeof aws;
+};

package/dist/policy/domain.js

@@ -0,0 +1,28 @@
+import { parsePaybondPolicyDocumentV1, } from "./schema.js";
+import { loadBundledDomainDocument } from "./layers-io.js";
+const LAYERED_POLICY_PRESET_IDS = ["travel", "shopping", "saas", "aws"];
+function loadDomain(presetId) {
+    return parsePaybondPolicyDocumentV1(loadBundledDomainDocument(presetId));
+}
+/** Travel booking domain: hotel booking + read-only web search. */
+export function travel() {
+    return loadDomain("travel");
+}
+/** Shopping domain: checkout + product search. */
+export function shopping() {
+    return loadDomain("shopping");
+}
+/** SaaS domain: seat provisioning + plan listing. */
+export function saas() {
+    return loadDomain("saas");
+}
+/** AWS operator domain: EC2 start + describe. */
+export function aws() {
+    return loadDomain("aws");
+}
+export const domain = {
+    travel,
+    shopping,
+    saas,
+    aws,
+};