@tinycloud/share-sdk 0.2.0-beta.0 → 0.2.0-beta.1

package/dist/index.cjs

@@ -235,10 +235,10 @@ var util;
       return obj[e];
     });
   };
-  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object2) => {
+  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object3) => {
     const keys = [];
-    for (const key in object2) {
-      if (Object.prototype.hasOwnProperty.call(object2, key)) {
+    for (const key in object3) {
+      if (Object.prototype.hasOwnProperty.call(object3, key)) {
         keys.push(key);
       }
     }
@@ -4134,6 +4134,9 @@ var NEVER = INVALID;
 
 // ../share-envelope/dist/index.js
 var import_ed255192 = require("@noble/curves/ed25519");
+var import_blake3 = require("@noble/hashes/blake3");
+var import_ed255193 = require("@noble/curves/ed25519");
+var import_sha256 = require("@noble/hashes/sha256");
 var empty = new Uint8Array(0);
 function equals(aa, bb) {
   if (aa === bb) {
@@ -5306,6 +5309,128 @@ function validateV2Invariants(value, ctx) {
 }
 var unsignedShareEnvelopeV2Schema = unsignedShareEnvelopeV2BaseSchema.superRefine(validateV2Invariants);
 var shareEnvelopeV2Schema = unsignedShareEnvelopeV2BaseSchema.extend({ signature: signatureSchema }).strict().superRefine(validateV2Invariants);
+var unifiedResourceSchema = external_exports.string().refine((value) => {
+  const match = /^tinycloud:\/\/([^/]+)\/kv\/(.+)$/.exec(value);
+  if (match === null || /[:?#%]/.test(match[1])) return false;
+  const path = match[2];
+  return !path.startsWith("/") && !path.endsWith("/") && !path.includes("//") && path.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}, { message: "expected canonical TinyCloud KV resource" });
+var unifiedEncryptionNetworkSchema = external_exports.string().refine((value) => {
+  if (!value.startsWith("urn:tinycloud:encryption:")) return false;
+  const rest = value.slice("urn:tinycloud:encryption:".length);
+  const separator = rest.lastIndexOf(":");
+  const owner = separator < 0 ? "" : rest.slice(0, separator);
+  const network = separator < 0 ? "" : rest.slice(separator + 1);
+  return owner.startsWith("did:") && owner.length > 4 && network.length > 0 && !/[:/%?#\s]/.test(network);
+}, { message: "expected canonical TinyCloud encryption network" });
+var unifiedKvCapabilitySchema = external_exports.object({
+  kind: external_exports.literal("kv"),
+  resource: unifiedResourceSchema,
+  selector: external_exports.union([external_exports.literal("exact"), external_exports.literal("prefix")]),
+  actions: external_exports.array(external_exports.union([
+    external_exports.literal("tinycloud.kv/get"),
+    external_exports.literal("tinycloud.kv/list"),
+    external_exports.literal("tinycloud.kv/metadata"),
+    external_exports.literal("tinycloud.kv/put")
+  ])).min(1)
+}).strict();
+var unifiedEncryptionCapabilitySchema = external_exports.object({
+  kind: external_exports.literal("encryption"),
+  resource: unifiedEncryptionNetworkSchema,
+  action: external_exports.literal("tinycloud.encryption/decrypt")
+}).strict();
+var unifiedCapabilitySchema = external_exports.union([unifiedKvCapabilitySchema, unifiedEncryptionCapabilitySchema]);
+var unifiedContentSourceSchema = external_exports.object({
+  shareId: external_exports.string().min(1),
+  kvResource: unifiedResourceSchema,
+  selector: external_exports.union([external_exports.literal("exact"), external_exports.literal("prefix")]),
+  encryptionNetwork: unifiedEncryptionNetworkSchema,
+  encryptedSymmetricKeyDigestHex: external_exports.string().regex(/^[0-9a-f]{64}$/),
+  keyVersion: external_exports.number().int().positive(),
+  mode: external_exports.union([external_exports.literal("mutable"), external_exports.literal("immutable")]),
+  initialCiphertextDigestHex: external_exports.string().regex(/^[0-9a-f]{64}$/).optional()
+}).strict();
+var unifiedPolicySchema = external_exports.object({
+  schema: external_exports.literal("xyz.tinycloud.policy/policy/v1"),
+  policyId: external_exports.string().regex(/^pol_[a-z2-7]+$/),
+  ownerDid: external_exports.string().min(1),
+  createdAt: external_exports.string().datetime({ offset: true }),
+  expiresAt: external_exports.string().datetime({ offset: true }).optional(),
+  contentSource: unifiedContentSourceSchema,
+  capabilityCeiling: external_exports.array(unifiedCapabilitySchema).min(2),
+  signature: external_exports.object({ suite: external_exports.string().min(1), signerDid: external_exports.string().min(1), value: external_exports.string().min(1) }).strict()
+}).strict();
+var unifiedRootSchema = external_exports.object({
+  cid: external_exports.string().min(1),
+  authorization: external_exports.string().regex(/^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/),
+  role: external_exports.union([external_exports.literal("policy-authority"), external_exports.literal("policy-enforcement")])
+}).strict();
+var attestedEnforcerBindingV2Schema = external_exports.object({
+  schema: external_exports.literal("xyz.tinycloud.policy/attested-enforcer/v2"),
+  enforcerDid: external_exports.string().regex(/^did:key:z[1-9A-HJ-NP-Za-km-z]+$/),
+  nodeAudience: external_exports.string().min(1),
+  attestationBindingDigestHex: external_exports.string().regex(/^[0-9a-f]{64}$/),
+  issuedAt: external_exports.string().datetime({ offset: true }),
+  expiresAt: external_exports.string().datetime({ offset: true }),
+  signature: external_exports.object({ suite: external_exports.literal("Ed25519"), signerDid: external_exports.string().min(1), value: base64UrlString() }).strict()
+}).strict();
+var v3TargetSchema = external_exports.object({
+  origin: external_exports.string().refine(isCanonicalHttpsOrigin, { message: "expected a canonical https origin" }),
+  nodeAudience: external_exports.string().min(1),
+  spaceId: external_exports.string().refine(isCanonicalPathSegment, { message: "expected a canonical space id" })
+}).strict();
+var unsignedShareEnvelopeV3BaseSchema = external_exports.object({
+  version: external_exports.literal(3),
+  shareId: external_exports.string().min(1),
+  recipientMatcher: recipientMatcherSchema,
+  deliveryEmail: external_exports.string().email().optional(),
+  actions: external_exports.array(shareActionSchema).min(1).max(3),
+  resource: resourceSelectorSchema,
+  target: v3TargetSchema,
+  policy: unifiedPolicySchema,
+  policyCid: external_exports.string().min(1),
+  policyRoot: unifiedRootSchema,
+  enforcementRoot: unifiedRootSchema,
+  attestedEnforcerBinding: attestedEnforcerBindingV2Schema,
+  contentSource: unifiedContentSourceSchema,
+  contentSourceDigestHex: external_exports.string().regex(/^[0-9a-f]{64}$/),
+  encryptionNetwork: unifiedEncryptionNetworkSchema,
+  expiry: external_exports.string().datetime({ offset: true }),
+  display: displaySchema,
+  encrypted: external_exports.literal(true),
+  metadata: contentMetadataSchema
+}).strict();
+function validateV3Invariants(value, ctx) {
+  const actions = [...value.actions];
+  if (new Set(actions).size !== actions.length || actions.some((action, index) => action !== ["read", "list", "edit"].filter((candidate) => actions.includes(candidate))[index])) {
+    ctx.addIssue({ code: external_exports.ZodIssueCode.custom, path: ["actions"], message: "actions must be unique and canonically ordered" });
+  }
+  if (value.policyRoot.role !== "policy-authority" || value.enforcementRoot.role !== "policy-enforcement") {
+    ctx.addIssue({ code: external_exports.ZodIssueCode.custom, path: ["policyRoot", "role"], message: "root roles are fixed" });
+  }
+  if (value.policyCid.length === 0 || value.policyCid === value.policyRoot.cid || value.policyCid === value.enforcementRoot.cid) {
+    ctx.addIssue({ code: external_exports.ZodIssueCode.custom, path: ["policyCid"], message: "policy CID must be distinct from both roots" });
+  }
+  if (value.contentSource.encryptionNetwork !== value.encryptionNetwork) {
+    ctx.addIssue({ code: external_exports.ZodIssueCode.custom, path: ["encryptionNetwork"], message: "encryption network is not bound to the source" });
+  }
+  if (value.attestedEnforcerBinding.enforcerDid !== value.target.nodeAudience || value.attestedEnforcerBinding.nodeAudience !== value.target.nodeAudience || value.attestedEnforcerBinding.signature.signerDid !== value.target.nodeAudience || Date.parse(value.attestedEnforcerBinding.expiresAt) < Date.parse(value.expiry)) {
+    ctx.addIssue({ code: external_exports.ZodIssueCode.custom, path: ["attestedEnforcerBinding"], message: "enforcer binding does not cover the target and share lifetime" });
+  }
+  if (value.policy.contentSource.shareId !== value.contentSource.shareId || value.policy.contentSource.kvResource !== value.contentSource.kvResource || value.policy.contentSource.selector !== value.contentSource.selector || value.policy.contentSource.encryptionNetwork !== value.encryptionNetwork || value.policy.contentSource.encryptedSymmetricKeyDigestHex !== value.contentSource.encryptedSymmetricKeyDigestHex || value.policy.contentSource.keyVersion !== value.contentSource.keyVersion || value.policy.contentSource.mode !== value.contentSource.mode || value.policy.contentSource.initialCiphertextDigestHex !== value.contentSource.initialCiphertextDigestHex) {
+    ctx.addIssue({ code: external_exports.ZodIssueCode.custom, path: ["contentSource"], message: "content source is not bound to policy" });
+  }
+  if (value.policy.signature.suite !== "Ed25519" || value.policy.signature.signerDid !== value.policy.ownerDid) {
+    ctx.addIssue({ code: external_exports.ZodIssueCode.custom, path: ["policy", "signature"], message: "policy must be signed by its owner" });
+  }
+  const kvCapabilities = value.policy.capabilityCeiling.filter((capability) => capability.kind === "kv");
+  const decryptCapabilities = value.policy.capabilityCeiling.filter((capability) => capability.kind === "encryption" && capability.resource === value.encryptionNetwork && capability.action === "tinycloud.encryption/decrypt");
+  if (value.policy.capabilityCeiling.length !== 2 || kvCapabilities.length !== 1 || decryptCapabilities.length !== 1 || kvCapabilities[0]?.resource !== value.contentSource.kvResource || kvCapabilities[0]?.selector !== value.contentSource.selector) {
+    ctx.addIssue({ code: external_exports.ZodIssueCode.custom, path: ["policy", "capabilityCeiling"], message: "policy ceiling must contain exact decrypt network" });
+  }
+}
+var unsignedShareEnvelopeV3Schema = unsignedShareEnvelopeV3BaseSchema.superRefine(validateV3Invariants);
+var shareEnvelopeV3Schema = unsignedShareEnvelopeV3BaseSchema.extend({ signature: signatureSchema }).strict().superRefine(validateV3Invariants);
 var BEARER_READ_ABILITY = "kv/get";
 var READ_ABILITIES = /* @__PURE__ */ new Set([BEARER_READ_ABILITY]);
 var ED25519_VERIFY_OPTS = { zip215: false };
@@ -5645,6 +5770,83 @@ function serialize(value) {
 function canonicalize(value) {
   return serialize(value);
 }
+async function signCompactUcanAuthorization(input) {
+  if (input.notBefore >= input.expiresAt || input.expiresAt - input.notBefore > 60) {
+    throw new TypeError("compact invocation lifetime must be between one and 60 seconds");
+  }
+  const principal = input.issuerDid.split("#", 1)[0];
+  const publicKey = ed25519PublicKeyFromDidKey(principal);
+  const header = {
+    alg: "EdDSA",
+    jwk: { alg: "EdDSA", crv: "Ed25519", kty: "OKP", x: encodeBase64Url(publicKey) },
+    typ: "JWT",
+    ucv: "0.10.0"
+  };
+  const payload = {
+    att: input.attenuation,
+    aud: input.audienceDid,
+    exp: input.expiresAt,
+    fct: input.facts,
+    iss: input.issuerDid.includes("#") ? input.issuerDid : `${principal}#${principal.slice("did:key:".length)}`,
+    nbf: input.notBefore,
+    nnc: input.nonce,
+    prf: input.proofs
+  };
+  const protectedSegment = encodeBase64Url(new TextEncoder().encode(canonicalize(header)));
+  const payloadSegment = encodeBase64Url(new TextEncoder().encode(canonicalize(payload)));
+  const signingInput = new TextEncoder().encode(`${protectedSegment}.${payloadSegment}`);
+  const signature = await input.sign(signingInput);
+  if (signature.length !== 64) throw new TypeError("compact Authorization signature must be Ed25519");
+  return verifyCompactUcanAuthorization(
+    `${protectedSegment}.${payloadSegment}.${encodeBase64Url(signature)}`
+  );
+}
+function verifyCompactUcanAuthorization(authorization, expectedCid) {
+  if (/\s/.test(authorization)) throw new TypeError("compact Authorization contains whitespace");
+  const segments = authorization.split(".");
+  if (segments.length !== 3 || segments.some((segment) => segment.length === 0)) throw new TypeError("compact Authorization must contain three segments");
+  const [headerSegment, payloadSegment, signatureSegment] = segments;
+  const headerBytes = decodeBase64Url(headerSegment);
+  const payloadBytes = decodeBase64Url(payloadSegment);
+  const signature = decodeBase64Url(signatureSegment);
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const header = JSON.parse(decoder.decode(headerBytes));
+  const payload = JSON.parse(decoder.decode(payloadBytes));
+  if (canonicalize(header) !== decoder.decode(headerBytes) || canonicalize(payload) !== decoder.decode(payloadBytes)) throw new TypeError("compact Authorization JSON is not canonical");
+  assertExactKeys(header, ["alg", "jwk", "typ", "ucv"], "protected header");
+  const jwk = object(header.jwk, "protected JWK");
+  assertExactKeys(jwk, ["alg", "crv", "kty", "x"], "protected JWK");
+  if (header.alg !== "EdDSA" || header.typ !== "JWT" || header.ucv !== "0.10.0" || jwk.alg !== "EdDSA" || jwk.crv !== "Ed25519" || jwk.kty !== "OKP" || typeof jwk.x !== "string") throw new TypeError("compact Authorization header is invalid");
+  assertExactKeys(payload, ["att", "aud", "exp", "fct", "iss", "nbf", "nnc", "prf"], "UCAN payload");
+  if (typeof payload.iss !== "string" || typeof payload.aud !== "string" || typeof payload.nnc !== "string" || !Number.isInteger(payload.nbf) || !Number.isInteger(payload.exp) || payload.nbf >= payload.exp || !Array.isArray(payload.prf) || payload.prf.some((proof) => typeof proof !== "string") || !Array.isArray(payload.fct) || payload.fct.length !== 1) throw new TypeError("compact Authorization payload is invalid");
+  const principal = payload.iss.split("#", 1)[0];
+  const publicKey = ed25519PublicKeyFromDidKey(principal);
+  if (!equal(publicKey, decodeBase64Url(jwk.x))) throw new TypeError("compact Authorization JWK does not bind issuer");
+  if (!import_ed255192.ed25519.verify(signature, new TextEncoder().encode(`${headerSegment}.${payloadSegment}`), publicKey, { zip215: false })) throw new TypeError("compact Authorization signature is invalid");
+  const cid2 = CID.createV1(85, create(30, (0, import_blake3.blake3)(new TextEncoder().encode(authorization)))).toString();
+  if (expectedCid !== void 0 && cid2 !== expectedCid) throw new TypeError("compact Authorization CID mismatch");
+  return { authorization, cid: cid2, header, payload };
+}
+function object(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be an object`);
+  return value;
+}
+function assertExactKeys(value, keys, label) {
+  if (Object.keys(value).length !== keys.length || Object.keys(value).some((key) => !keys.includes(key))) throw new TypeError(`${label} has unknown or missing fields`);
+}
+function decodeBase64Url(value) {
+  if (!/^[A-Za-z0-9_-]+$/.test(value) || value.length % 4 === 1) throw new TypeError("compact Authorization segment is not base64url");
+  const bytes3 = typeof Buffer !== "undefined" ? new Uint8Array(Buffer.from(value, "base64url")) : Uint8Array.from(atob(value.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.length / 4) * 4, "=")), (character) => character.charCodeAt(0));
+  const encoded = typeof Buffer !== "undefined" ? Buffer.from(bytes3).toString("base64url") : btoa(String.fromCharCode(...bytes3)).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  if (encoded !== value) throw new TypeError("compact Authorization segment is not canonical");
+  return bytes3;
+}
+function encodeBase64Url(value) {
+  return typeof Buffer !== "undefined" ? Buffer.from(value).toString("base64url") : btoa(String.fromCharCode(...value)).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function equal(left, right) {
+  return left.length === right.length && left.every((byte, index) => byte === right[index]);
+}
 var ED25519_VERIFY_OPTS2 = { zip215: false };
 var ENVELOPE_SIGNATURE_DOMAIN = "xyz.tinycloud.share/envelope/v1\0";
 var ENVELOPE_V2_SIGNATURE_DOMAIN = "xyz.tinycloud.share/envelope/v2\0";
@@ -5666,8 +5868,8 @@ function signingBytesV2(unsigned) {
 }
 function signEnvelope(envelopeWithoutSig, ed25519PrivKey) {
   const unsigned = unsignedShareEnvelopeSchema.parse(envelopeWithoutSig);
-  const publicKey = import_ed255192.ed25519.getPublicKey(ed25519PrivKey);
-  const signature = import_ed255192.ed25519.sign(signingBytes(unsigned), ed25519PrivKey);
+  const publicKey = import_ed255193.ed25519.getPublicKey(ed25519PrivKey);
+  const signature = import_ed255193.ed25519.sign(signingBytes(unsigned), ed25519PrivKey);
   return {
     ...unsigned,
     signature: {
@@ -5681,7 +5883,7 @@ function verifyEnvelopeSignatureOnly(envelope) {
   const parsed = shareEnvelopeSchema.parse(envelope);
   const { signature, ...unsigned } = parsed;
   const publicKey = ed25519PublicKeyFromDidKey(signature.signerDid);
-  return import_ed255192.ed25519.verify(
+  return import_ed255193.ed25519.verify(
     fromBase64Url(signature.value),
     signingBytes(unsigned),
     publicKey,
@@ -5703,7 +5905,7 @@ async function verifyEnvelope(envelope, options) {
 function verifyEnvelopeV2SignatureOnly(envelope) {
   const parsed = shareEnvelopeV2Schema.parse(envelope);
   const { signature, ...unsigned } = parsed;
-  return import_ed255192.ed25519.verify(fromBase64Url(signature.value), signingBytesV2(unsigned), ed25519PublicKeyFromDidKey(signature.signerDid), ED25519_VERIFY_OPTS2);
+  return import_ed255193.ed25519.verify(fromBase64Url(signature.value), signingBytesV2(unsigned), ed25519PublicKeyFromDidKey(signature.signerDid), ED25519_VERIFY_OPTS2);
 }
 async function verifyEnvelopeV2(envelope, options) {
   const parsed = shareEnvelopeV2Schema.parse(envelope);
@@ -6141,7 +6343,7 @@ async function receiveShare(link, options = {}) {
 }
 
 // src/publish.ts
-var import_ed255193 = require("@noble/curves/ed25519");
+var import_ed255194 = require("@noble/curves/ed25519");
 var SHARE_CONTENT_LIMIT = 100 * 1024 * 1024;
 var SHARE_SEALED_OVERHEAD = 1 + 12 + 16;
 var SHARE_PUBLISH_RESULT_VERSION = 1;
@@ -6326,12 +6528,12 @@ async function publishShare(options) {
   const spaceId = options.spaceId ?? "bearer";
   const shareId = toBase64Url(globalThis.crypto.getRandomValues(new Uint8Array(16)));
   const path = `shares/${shareId}/${options.filename}`;
-  const sessionPrivateKey = import_ed255193.ed25519.utils.randomPrivateKey();
-  const senderPrivateKey = import_ed255193.ed25519.utils.randomPrivateKey();
+  const sessionPrivateKey = import_ed255194.ed25519.utils.randomPrivateKey();
+  const senderPrivateKey = import_ed255194.ed25519.utils.randomPrivateKey();
   let contentKey;
   let envelopeKey;
   try {
-    const sessionPublicKey = import_ed255193.ed25519.getPublicKey(sessionPrivateKey);
+    const sessionPublicKey = import_ed255194.ed25519.getPublicKey(sessionPrivateKey);
     const sessionDid = didKeyFromEd25519PublicKey(sessionPublicKey);
     const delegation = mintBearerDelegation({
       issuerPrivateKey: senderPrivateKey,
@@ -6423,8 +6625,8 @@ async function parseAddressedEnvelope(value) {
 }
 
 // src/owner-policy.ts
-var import_ed255194 = require("@noble/curves/ed25519");
-var import_sha256 = require("@noble/hashes/sha256");
+var import_ed255195 = require("@noble/curves/ed25519");
+var import_sha2562 = require("@noble/hashes/sha256");
 
 // ../../node_modules/multiformats/dist/src/bytes.js
 var empty2 = new Uint8Array(0);
@@ -7331,10 +7533,10 @@ function fromB64(value) {
   throw new Error("base64url decoding is unavailable");
 }
 function cid(bytesValue) {
-  return CID2.createV1(code2, create2(SHA256_CODE2, (0, import_sha256.sha256)(bytesValue))).toString(base322.encoder);
+  return CID2.createV1(code2, create2(SHA256_CODE2, (0, import_sha2562.sha256)(bytesValue))).toString(base322.encoder);
 }
 function digest(bytesValue) {
-  return b64((0, import_sha256.sha256)(bytesValue));
+  return b64((0, import_sha2562.sha256)(bytesValue));
 }
 function didKeyFromEd25519PublicKey2(publicKey) {
   if (publicKey.length !== 32) throw new Error("share key public key must be 32 bytes");
@@ -7512,7 +7714,7 @@ function validateOwnerSharePolicyRegistration(value, expected) {
   const publicKey = encodedKid.length === 34 ? encodedKid.slice(2) : encodedKid;
   const signatureBytes = fromB64(proof.signature);
   const signedBytes = new TextEncoder().encode(`${OWNER_SHARE_REGISTRATION_DOMAIN}${canonicalize(registrationCore)}`);
-  if (signatureBytes.length !== 64 || !import_ed255194.ed25519.verify(signatureBytes, signedBytes, publicKey)) throw new Error("owner-share registration proof signature is invalid");
+  if (signatureBytes.length !== 64 || !import_ed255195.ed25519.verify(signatureBytes, signedBytes, publicKey)) throw new Error("owner-share registration proof signature is invalid");
   return { registration, proof };
 }
 function validateOwnerSharePolicyRegistrationBytes(bytesValue, expected) {
@@ -7672,7 +7874,7 @@ function assertSafeInput(input) {
   if (input.artifact === "html" && (input.resource.kind !== "prefix" || !input.actions.includes("read") || !input.actions.includes("list"))) throw new TypeError("html artifacts require a readable prefix");
   if (input.contentSource.kind !== "kv") throw new TypeError("addressed policy publication requires a KV content source");
 }
-async function sha2563(value) {
+async function sha2564(value) {
   return toBase64Url(new Uint8Array(await crypto.subtle.digest("SHA-256", value)));
 }
 function publicationResult(input) {
@@ -7721,7 +7923,7 @@ async function publishAddressedShare(options) {
   const contentSource = options.contentSource;
   const matcher = targetMatcher(target);
   const expiresAt = options.expiresAt.toISOString();
-  const contentSourceDigest = options.contentSourceDigest ?? await sha2563(new TextEncoder().encode(canonicalize(contentSource)));
+  const contentSourceDigest = options.contentSourceDigest ?? await sha2564(new TextEncoder().encode(canonicalize(contentSource)));
   const shareKey = await createDelegatedShareKey({ extractable: false });
   let envelopeKey;
   try {
@@ -7785,7 +7987,7 @@ async function publishAddressedShare(options) {
       enforcementDelegation,
       contentSourceDigest
     });
-    const authorityMaterialDigest = await sha2563(fromBase64Url(enforcementDelegation.dagCbor));
+    const authorityMaterialDigest = await sha2564(fromBase64Url(enforcementDelegation.dagCbor));
     const authorityTarget = {
       origin: options.nodeOrigin,
       nodeAudience: options.nodeAudience,
@@ -7885,7 +8087,7 @@ async function publishAddressedShare(options) {
 }
 
 // src/policy-authority.ts
-var import_ed255195 = require("@noble/curves/ed25519");
+var import_ed255196 = require("@noble/curves/ed25519");
 var ENVELOPE_DOMAIN2 = "xyz.tinycloud.share/envelope/v2\0";
 function record(value, keys, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${label} is invalid`);
@@ -7941,7 +8143,7 @@ async function verifyEnforcement(delegation) {
     });
     if (expectedDagCbor.length !== dagCbor.length || expectedDagCbor.some((byte, index) => byte !== dagCbor[index])) return false;
     const signature = fromBase64Url(delegation.signature);
-    return signature.length === 64 && import_ed255195.ed25519.verify(
+    return signature.length === 64 && import_ed255196.ed25519.verify(
       signature,
       dagCbor,
       ed25519PublicKeyFromDidKey(delegation.issuerDid),
@@ -7965,7 +8167,7 @@ async function verifyOuterEnvelope(value, envelope, policyCid, expectedEnforcerD
     if (shareCid !== await computeCid(new TextEncoder().encode(canonicalize({ version: 2, shareId: envelope.shareId, policyCid, envelopeCid })))) return void 0;
     const unsigned = { ...identity, envelopeCid, shareCid };
     const signatureBytes = fromBase64Url(requiredString(signature.value, "outer signature"));
-    if (signatureBytes.length !== 64 || !import_ed255195.ed25519.verify(
+    if (signatureBytes.length !== 64 || !import_ed255196.ed25519.verify(
       signatureBytes,
       new TextEncoder().encode(`${ENVELOPE_DOMAIN2}${canonicalize(unsigned)}`),
       ed25519PublicKeyFromDidKey(envelope.signature.signerDid),
@@ -8032,13 +8234,13 @@ function createRegisteredPolicyAuthority(options) {
 }
 
 // src/cache.ts
-var import_sha2562 = require("@noble/hashes/sha256");
+var import_sha2563 = require("@noble/hashes/sha256");
 function cacheKey(key) {
   if (!key.cid || !key.expiresAt) throw new Error("share cache keys require CID and expiry");
   return `${key.cid}\0${key.expiresAt}`;
 }
 function digest2(bytes3) {
-  return (0, import_sha2562.sha256)(bytes3);
+  return (0, import_sha2563.sha256)(bytes3);
 }
 function equalBytes(left, right) {
   if (left.byteLength !== right.byteLength) return false;
@@ -8093,7 +8295,7 @@ var MemoryShareCache = class {
 };
 
 // src/delivery.ts
-var import_ed255196 = require("@noble/curves/ed25519");
+var import_ed255197 = require("@noble/curves/ed25519");
 var SHARE_DELIVERY_AUTHORIZATION_DOMAIN = "xyz.tinycloud.share/delivery-authorization/v2\0";
 function isCanonicalHttpsOrigin2(value) {
   let url;
@@ -8185,7 +8387,7 @@ function validateShareDeliveryAuthorizationBytes(bytesValue, expected) {
   if (publicKey.length !== 32) throw new Error("share delivery authorization proof key is invalid");
   const signatureBytes = fromB642(proof.signature);
   const signedBytes = new TextEncoder().encode(`${SHARE_DELIVERY_AUTHORIZATION_DOMAIN}${canonicalize(authorization)}`);
-  if (signatureBytes.length !== 64 || !import_ed255196.ed25519.verify(signatureBytes, signedBytes, publicKey)) throw new Error("share delivery authorization proof signature is invalid");
+  if (signatureBytes.length !== 64 || !import_ed255197.ed25519.verify(signatureBytes, signedBytes, publicKey)) throw new Error("share delivery authorization proof signature is invalid");
   return { authorization, proof };
 }
 function shareDeliveryTrustedKid(publicKey) {
@@ -8484,7 +8686,8 @@ async function migrateShare(input) {
 }
 
 // src/recipient.ts
-var import_ed255197 = require("@noble/curves/ed25519");
+var import_ed255198 = require("@noble/curves/ed25519");
+var import_sha2564 = require("@noble/hashes/sha256");
 
 // src/protocol.ts
 var SHARE_V2_PROTOCOL = Object.freeze({
@@ -8529,7 +8732,7 @@ var DOMAIN = SHARE_V2_PROTOCOL.challengeDomain;
 var PRESENTATION_DOMAIN = SHARE_V2_PROTOCOL.sessionDomain;
 var SESSION_DOMAIN = SHARE_V2_PROTOCOL.sessionDomain;
 var INVOCATION_DOMAIN = SHARE_V2_PROTOCOL.invocationDomain;
-function object(value, label) {
+function object2(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${label} is invalid`);
   return value;
 }
@@ -8555,12 +8758,12 @@ function trustedPublicKey(value) {
   return value.invitationPublicKey;
 }
 async function verifyWrapped(value, key, domain, trust) {
-  const wrapper = object(value, `${key} response`);
+  const wrapper = object2(value, `${key} response`);
   if (Object.keys(wrapper).length !== 2 || !Object.hasOwn(wrapper, key) || !Object.hasOwn(wrapper, "proof")) throw new Error(`${key} response is invalid`);
-  const artifact = object(wrapper[key], `${key} artifact`);
-  const proof = object(wrapper.proof, `${key} proof`);
+  const artifact = object2(wrapper[key], `${key} artifact`);
+  const proof = object2(wrapper.proof, `${key} proof`);
   if (proof.alg !== "EdDSA" || proof.kid !== trust.invitationKid) throw new Error(`${key} proof is invalid`);
-  if (!import_ed255197.ed25519.verify(bytes2(proof.signature, `${key} signature`), new TextEncoder().encode(`${domain}${canonicalize(artifact)}`), trustedPublicKey(trust))) throw new Error(`${key} proof is invalid`);
+  if (!import_ed255198.ed25519.verify(bytes2(proof.signature, `${key} signature`), new TextEncoder().encode(`${domain}${canonicalize(artifact)}`), trustedPublicKey(trust))) throw new Error(`${key} proof is invalid`);
   return artifact;
 }
 function nativeAction(action) {
@@ -8572,6 +8775,42 @@ function uiAction(action) {
 function selectedAction(envelope) {
   return envelope.actions.includes("list") ? "tinycloud.kv/list" : envelope.actions.includes("edit") ? "tinycloud.kv/put" : "tinycloud.kv/get";
 }
+function hex(value) {
+  return [...value].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function canonicalHashHex(value) {
+  return hex((0, import_sha2564.sha256)(new TextEncoder().encode(canonicalize(value))));
+}
+async function aesGcmDecrypt(key, blob) {
+  if (key.length !== 32 || blob.length < 28) throw new Error("encrypted content is malformed");
+  const cryptoKey = await crypto.subtle.importKey("raw", key, "AES-GCM", false, ["decrypt"]);
+  return new Uint8Array(await crypto.subtle.decrypt({ name: "AES-GCM", iv: blob.slice(0, 12) }, cryptoKey, blob.slice(12)));
+}
+async function aesGcmEncrypt(key, plaintext) {
+  if (key.length !== 32) throw new Error("encrypted content key is malformed");
+  const nonce = crypto.getRandomValues(new Uint8Array(12));
+  const cryptoKey = await crypto.subtle.importKey("raw", key, "AES-GCM", false, ["encrypt"]);
+  const ciphertext = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv: nonce }, cryptoKey, plaintext));
+  const output = new Uint8Array(nonce.length + ciphertext.length);
+  output.set(nonce);
+  output.set(ciphertext, nonce.length);
+  return output;
+}
+function parseV3InlineEncryptedEnvelope(bytes3, expected) {
+  let value;
+  try {
+    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes3));
+  } catch {
+    throw new Error("encrypted content envelope is malformed");
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("encrypted content envelope is malformed");
+  const record2 = value;
+  const allowed = ["v", "networkId", "alg", "keyVersion", "encryptedSymmetricKey", "encryptedSymmetricKeyHash", "ciphertext", "metadata"];
+  if (Object.keys(record2).some((key) => !allowed.includes(key)) || record2.v !== 1 || record2.networkId !== expected.encryptionNetwork || record2.alg !== "x25519-aes256gcm/v1" || record2.keyVersion !== expected.contentSource.keyVersion || typeof record2.encryptedSymmetricKey !== "string" || typeof record2.encryptedSymmetricKeyHash !== "string" || record2.encryptedSymmetricKeyHash !== expected.contentSource.encryptedSymmetricKeyDigestHex || record2.encryptedSymmetricKeyHash !== canonicalHashHex(record2.encryptedSymmetricKey) || typeof record2.ciphertext !== "string" || record2.metadata !== void 0 && (record2.metadata === null || typeof record2.metadata !== "object" || Array.isArray(record2.metadata) || Object.values(record2.metadata).some((entry) => typeof entry !== "string"))) {
+    throw new Error("encrypted content envelope binding is invalid");
+  }
+  return record2;
+}
 async function verifyDetachedResponse(response, trust) {
   let value;
   try {
@@ -8579,12 +8818,12 @@ async function verifyDetachedResponse(response, trust) {
   } catch {
     throw new Error("share read response is invalid");
   }
-  const record2 = object(value, "share read response");
-  const proof = object(record2.proof, "share read detached proof");
+  const record2 = object2(value, "share read response");
+  const proof = object2(record2.proof, "share read detached proof");
   if (proof.alg !== "EdDSA" || proof.kid !== trust.invitationKid) throw new Error("share read detached proof is invalid");
   const unsigned = { ...record2 };
   delete unsigned.proof;
-  if (!import_ed255197.ed25519.verify(bytes2(proof.signature, "share read signature"), new TextEncoder().encode(`${SHARE_V2_PROTOCOL.readResponseDomain}${canonicalize(unsigned)}`), trustedPublicKey(trust))) throw new Error("share read detached proof is invalid");
+  if (!import_ed255198.ed25519.verify(bytes2(proof.signature, "share read signature"), new TextEncoder().encode(`${SHARE_V2_PROTOCOL.readResponseDomain}${canonicalize(unsigned)}`), trustedPublicKey(trust))) throw new Error("share read detached proof is invalid");
 }
 async function post(fetchFn, origin, path, body) {
   const response = await fetchFn(new URL(path, origin), { method: "POST", redirect: "error", headers: { accept: "application/json", "content-type": "application/json" }, body: JSON.stringify(body) });
@@ -8600,15 +8839,19 @@ var ShareRecipientClient = class {
   fetchFn;
   session;
   signer;
+  nativeSigner;
   holderProof;
+  v3Authorization;
+  v3ContentKey;
+  v3ContentEnvelope;
   async beginChallenge(envelope) {
     const authority = envelope.ownerAuthority;
     if (authority === void 0) throw new Error("addressed owner authority is required");
-    const outer = object(authority.outerEnvelope, "owner authority outer envelope");
-    const enforcement = object(authority.enforcementDelegation, "owner authority enforcement delegation");
-    const target = object(outer.target, "owner authority target");
-    const outerResource = object(outer.resource, "owner authority resource");
-    const source = object(outer.contentSource, "owner authority content source");
+    const outer = object2(authority.outerEnvelope, "owner authority outer envelope");
+    const enforcement = object2(authority.enforcementDelegation, "owner authority enforcement delegation");
+    const target = object2(outer.target, "owner authority target");
+    const outerResource = object2(outer.resource, "owner authority resource");
+    const source = object2(outer.contentSource, "owner authority content source");
     if (!Array.isArray(outer.actions) || outer.actions.length === 0 || outer.actions.some((value) => typeof value !== "string")) throw new Error("owner authority outer envelope actions are invalid");
     const actions = [...outer.actions];
     const action = selectedAction(envelope);
@@ -8621,11 +8864,11 @@ var ShareRecipientClient = class {
   async establish(envelope) {
     const authority = envelope.ownerAuthority;
     if (authority === void 0) throw new Error("addressed owner authority is required");
-    const outer = object(authority.outerEnvelope, "owner authority outer envelope");
-    const enforcement = object(authority.enforcementDelegation, "owner authority enforcement delegation");
-    const target = object(outer.target, "owner authority target");
-    const outerResource = object(outer.resource, "owner authority resource");
-    const source = object(outer.contentSource, "owner authority content source");
+    const outer = object2(authority.outerEnvelope, "owner authority outer envelope");
+    const enforcement = object2(authority.enforcementDelegation, "owner authority enforcement delegation");
+    const target = object2(outer.target, "owner authority target");
+    const outerResource = object2(outer.resource, "owner authority resource");
+    const source = object2(outer.contentSource, "owner authority content source");
     if (!Array.isArray(outer.actions) || outer.actions.length === 0 || outer.actions.some((value) => typeof value !== "string")) throw new Error("owner authority outer envelope actions are invalid");
     const actions = [...outer.actions];
     const action = selectedAction(envelope);
@@ -8637,6 +8880,7 @@ var ShareRecipientClient = class {
     const material = await this.options.buildPresentation({ challenge, envelope, policy: {} });
     this.holderProof = material.proof;
     this.signer = material.sign;
+    this.nativeSigner = material.sign;
     if (this.signer === void 0) throw new Error("share holder signer is required");
     const presentation = {
       type: "TinyCloudSharePolicyPresentation",
@@ -8672,7 +8916,7 @@ var ShareRecipientClient = class {
     if (this.session === void 0) await this.establish(envelope);
     const response = await this.nativeInvoke({ action: "get", resource: envelope.resource });
     if (!response.ok) throw new Error("share recipient read was rejected");
-    const value = object(await response.json(), "share read response");
+    const value = object2(await response.json(), "share read response");
     const expectedAction = nativeAction("read");
     if (value.type !== "TinyCloudShareInvokeResponse" || value.version !== 2 || value.action !== expectedAction || value.resource !== envelope.resource.path || typeof value.content !== "string" || typeof value.bodyDigest !== "string" || !/^[A-Za-z0-9_-]{43}$/.test(value.bodyDigest) || !Object.hasOwn(value, "proof")) throw new Error("share read response is invalid");
     const content = fromBase64Url(value.content);
@@ -8681,18 +8925,110 @@ var ShareRecipientClient = class {
   }
   async establishPolicySession() {
     if (this.session !== void 0) return this.session;
-    return this.establish(this.options.envelope);
+    const envelope = this.options.envelope;
+    if (envelope.version === 3) return this.establishV3(envelope);
+    return this.establish(envelope);
+  }
+  async establishV3(envelope) {
+    if (this.options.buildPresentation === void 0) throw new Error("share presentation builder is required");
+    const challengeResponse = await this.fetchFn(new URL("/share/v3/policy/challenges", this.options.nodeOrigin), {
+      method: "POST",
+      redirect: "error",
+      headers: { accept: "application/json", "content-type": "application/json" },
+      body: JSON.stringify({ policyCid: envelope.policyCid, recipientDid: this.options.holderDid, requestedCapabilities: envelope.policy.capabilityCeiling })
+    });
+    if (!challengeResponse.ok) throw new Error(`v3 policy challenge rejected (${challengeResponse.status})`);
+    const challenge = object2(await challengeResponse.json(), "v3 policy challenge");
+    if (typeof challenge.challengeId !== "string" || typeof challenge.nonce !== "string" || challenge.policyCid !== envelope.policyCid || challenge.recipientDid !== this.options.holderDid) throw new Error("v3 policy challenge binding mismatch");
+    const material = await this.options.buildPresentation({
+      challenge,
+      envelope,
+      policy: envelope.policy
+    });
+    if (material.sign === void 0 || material.claim === void 0 || material.presentation === void 0) throw new Error("v3 ceremony requires a recipient signer, claim, and presentation");
+    const delegationResponse = await this.fetchFn(new URL("/share/v3/policy/delegations", this.options.nodeOrigin), {
+      method: "POST",
+      redirect: "error",
+      headers: { accept: "application/json", "content-type": "application/json" },
+      body: JSON.stringify({ policyCid: envelope.policyCid, challengeId: challenge.challengeId, nonce: challenge.nonce, claim: material.claim, presentation: material.presentation })
+    });
+    if (!delegationResponse.ok) throw new Error(`v3 policy delegation rejected (${delegationResponse.status})`);
+    const delegation = object2(await delegationResponse.json(), "v3 policy delegation");
+    if (delegation.admitted !== true || typeof delegation.sessionCid !== "string" || typeof delegation.authorization !== "string") throw new Error("v3 policy delegation response is not admitted");
+    const compact = verifyCompactUcanAuthorization(delegation.authorization, delegation.sessionCid);
+    const fact = compact.payload.fct[0];
+    if (compact.payload.aud !== this.options.holderDid || fact.profile !== "policy-session-ucan/v1" || fact.policyCid !== envelope.policyCid || fact.recipientDid !== this.options.holderDid || fact.policyDelegationCid !== envelope.policyRoot.cid || fact.enforcementDelegationCid !== envelope.enforcementRoot.cid || compact.payload.prf.length !== 2 || compact.payload.prf[0] !== envelope.policyRoot.cid || compact.payload.prf[1] !== envelope.enforcementRoot.cid || compact.payload.exp - compact.payload.nbf > 60) throw new Error("v3 policy delegation signed binding mismatch");
+    const imported = await this.fetchFn(new URL("/delegate", this.options.nodeOrigin), { method: "POST", redirect: "error", headers: { Authorization: delegation.authorization } });
+    if (!imported.ok) throw new Error(`ordinary delegation import rejected (${imported.status})`);
+    this.signer = material.sign;
+    this.v3Authorization = delegation.authorization;
+    this.session = { sessionId: delegation.sessionCid, expiresAt: new Date(compact.payload.exp * 1e3).toISOString(), actions: envelope.actions, resource: envelope.resource };
+    return this.session;
+  }
+  /** Decrypt a v3 KV value through a fresh recipient-signed decrypt invocation. */
+  async decryptV3Content(bytes3) {
+    const envelope = this.options.envelope;
+    const signer = this.nativeSigner ?? this.signer;
+    if (envelope.version !== 3 || this.session === void 0 || this.v3Authorization === void 0 || signer === void 0) throw new Error("v3 policy session signer is required");
+    const encrypted = parseV3InlineEncryptedEnvelope(bytes3, envelope);
+    const receiverPrivateKey = crypto.getRandomValues(new Uint8Array(32));
+    const receiverPublicKey = toBase64Url(import_ed255198.x25519.getPublicKey(receiverPrivateKey));
+    const receiverPublicKeyHash = canonicalHashHex(receiverPublicKey);
+    const body = { type: "tinycloud.encryption.decrypt/v1", targetNode: envelope.target.nodeAudience, networkId: encrypted.networkId, alg: encrypted.alg, keyVersion: encrypted.keyVersion, encryptedSymmetricKey: encrypted.encryptedSymmetricKey, encryptedSymmetricKeyHash: encrypted.encryptedSymmetricKeyHash, receiverPublicKey, receiverPublicKeyHash };
+    const bodyHash = hex((0, import_sha2564.sha256)(new TextEncoder().encode(canonicalize(body))));
+    const session = verifyCompactUcanAuthorization(this.v3Authorization, this.session.sessionId);
+    const now = Math.floor(Date.now() / 1e3);
+    const invocation = await signCompactUcanAuthorization({
+      issuerDid: this.options.holderDid,
+      audienceDid: envelope.target.nodeAudience,
+      attenuation: { [encrypted.networkId]: { "tinycloud.encryption/decrypt": [{}] } },
+      facts: [{ type: body.type, targetNode: body.targetNode, networkId: body.networkId, bodyHash, encryptedSymmetricKeyHash: body.encryptedSymmetricKeyHash, receiverPublicKeyHash, alg: body.alg, keyVersion: body.keyVersion }],
+      proofs: [session.cid],
+      notBefore: now,
+      expiresAt: Math.min(now + 60, session.payload.exp),
+      nonce: toBase64Url(crypto.getRandomValues(new Uint8Array(16))),
+      sign: signer
+    });
+    try {
+      const response = await this.fetchFn(new URL("/invoke", this.options.nodeOrigin), { method: "POST", redirect: "error", headers: { accept: "application/json", "content-type": "application/json", Authorization: invocation.authorization }, body: JSON.stringify(body) });
+      if (!response.ok) throw new Error(`v3 decrypt invocation rejected (${response.status})`);
+      const value = object2(await response.json(), "v3 decrypt response");
+      const allowed = ["type", "targetNode", "networkId", "invocationCid", "encryptedSymmetricKeyHash", "receiverPublicKeyHash", "wrappedKey", "alg", "keyVersion", "requestHash", "nodeId", "nodeSignature"];
+      if (Object.keys(value).length !== allowed.length || Object.keys(value).some((key) => !allowed.includes(key)) || value.type !== "tinycloud.encryption.decrypt-result/v1" || value.targetNode !== body.targetNode || value.nodeId !== body.targetNode || value.networkId !== body.networkId || value.invocationCid !== invocation.cid || value.encryptedSymmetricKeyHash !== body.encryptedSymmetricKeyHash || value.receiverPublicKeyHash !== receiverPublicKeyHash || value.alg !== body.alg || value.keyVersion !== body.keyVersion || value.requestHash !== hex((0, import_sha2564.sha256)(new TextEncoder().encode(`${invocation.cid}${bodyHash}`))) || typeof value.wrappedKey !== "string" || typeof value.nodeSignature !== "string") throw new Error("v3 decrypt response binding is invalid");
+      const unsigned = { ...value };
+      delete unsigned.nodeSignature;
+      const signature = fromBase64Url(value.nodeSignature);
+      if (signature.length !== 64 || !import_ed255198.ed25519.verify(signature, new TextEncoder().encode(canonicalize(unsigned)), ed25519PublicKeyFromDidKey(body.targetNode), { zip215: false })) throw new Error("v3 decrypt response signature is invalid");
+      const wrapped = fromBase64Url(value.wrappedKey);
+      if (wrapped.length < 60) throw new Error("v3 wrapped content key is malformed");
+      const shared = import_ed255198.x25519.getSharedSecret(receiverPrivateKey, wrapped.slice(0, 32));
+      const symmetricKey = await aesGcmDecrypt(shared, wrapped.slice(32));
+      shared.fill(0);
+      if (symmetricKey.length !== 32) throw new Error("v3 content key is malformed");
+      const plaintext = await aesGcmDecrypt(symmetricKey, fromBase64Url(encrypted.ciphertext));
+      this.v3ContentKey?.fill(0);
+      this.v3ContentKey = symmetricKey;
+      this.v3ContentEnvelope = encrypted;
+      return { bytes: plaintext, mediaType: encrypted.metadata?.contentType ?? envelope.metadata.mediaType ?? "application/octet-stream" };
+    } finally {
+      receiverPrivateKey.fill(0);
+    }
+  }
+  /** Re-encrypt edited v3 content with the admitted content key. */
+  async encryptV3Content(bytes3, mediaType) {
+    if (this.options.envelope.version !== 3 || this.v3ContentKey === void 0 || this.v3ContentEnvelope === void 0) throw new Error("v3 content must be decrypted before it can be saved");
+    return new TextEncoder().encode(canonicalize({ ...this.v3ContentEnvelope, ciphertext: toBase64Url(await aesGcmEncrypt(this.v3ContentKey, bytes3)), metadata: { ...this.v3ContentEnvelope.metadata ?? {}, contentType: mediaType } }));
   }
   async resumeWithProof(envelope, resumeToken, proof) {
-    const material = object(proof, "share authorization proof");
-    const presentation = object(material.presentation, "share presentation");
-    const presentationProof = object(material.presentationProof, "share presentation proof");
+    const material = object2(proof, "share authorization proof");
+    const presentation = object2(material.presentation, "share presentation");
+    const presentationProof = object2(material.presentationProof, "share presentation proof");
     const nonce = material.nonce;
     const credential = material.credential;
     const holderDid = material.holderDid;
     const holderBinding = material.holderBinding;
     if (typeof nonce !== "string" || typeof credential !== "string" || typeof holderDid !== "string" || holderDid !== this.options.holderDid || typeof holderBinding !== "object" || holderBinding === null || presentationProof.alg !== "EdDSA" || typeof presentationProof.signature !== "string") throw new Error("share authorization proof is incomplete");
-    const value = object(await post(this.fetchFn, this.options.nodeOrigin, "/share/v2/policy/session", { challengeId: resumeToken, nonce, presentation, credential, proof: presentationProof, holderBinding, readSignerDid: holderDid }), "share policy session");
+    const value = object2(await post(this.fetchFn, this.options.nodeOrigin, "/share/v2/policy/session", { challengeId: resumeToken, nonce, presentation, credential, proof: presentationProof, holderBinding, readSignerDid: holderDid }), "share policy session");
     const session = await verifyWrapped(value, "session", SESSION_DOMAIN, this.options.trustedNode);
     const authority = envelope.ownerAuthority;
     if (authority === void 0 || session.type !== "TinyCloudSharePolicySession" || session.version !== 2 || typeof session.sessionId !== "string" || session.shareCid !== authority.shareCid || session.shareId !== envelope.shareId || session.registrationCid !== authority.registrationCid || session.envelopeCid !== authority.envelopeCid || session.delegationCid !== envelope.delegationCid || typeof session.resource !== "string" || typeof session.expiresAt !== "string") throw new Error("share authority returned an unbound session");
@@ -8706,27 +9042,61 @@ var ShareRecipientClient = class {
   }
   async nativeInvoke(request) {
     if (this.session === void 0) throw new Error("share policy session is required");
-    if (this.options.envelope.ownerAuthority === void 0 || this.signer === void 0 || this.holderProof === void 0) throw new Error("share holder signer is required");
-    const authority = this.options.envelope.ownerAuthority;
+    const envelope = this.options.envelope;
+    if (envelope.version === 3) return this.nativeInvokeV3(request, envelope);
+    if (envelope.ownerAuthority === void 0 || this.signer === void 0 || this.holderProof === void 0) throw new Error("share holder signer is required");
+    const authority = envelope.ownerAuthority;
     const action = request.action === "list" ? "tinycloud.kv/list" : request.action === "put" ? "tinycloud.kv/put" : request.action === "metadata" ? "tinycloud.kv/metadata" : "tinycloud.kv/get";
     const resource = typeof request.resource?.path === "string" ? request.resource.path : this.session.resource.path;
     const actions = [...new Set(this.session.actions.map(nativeAction).concat(action === "tinycloud.kv/metadata" ? [action] : []))].sort();
     const bodyBytes = request.body === void 0 ? void 0 : Uint8Array.from(request.body);
     const bodyDigest = bodyBytes === void 0 ? void 0 : toBase64Url(new Uint8Array(await crypto.subtle.digest("SHA-256", bodyBytes)));
-    const outer = object(authority.outerEnvelope, "owner authority outer envelope");
-    const enforcement = object(authority.enforcementDelegation, "owner authority enforcement delegation");
-    const invocationBase = { type: "TinyCloudShareReadInvocation", version: 2, sessionId: this.session.sessionId, envelopeCid: authority.envelopeCid, shareCid: authority.shareCid, shareId: this.options.envelope.shareId, registrationCid: authority.registrationCid, delegationCid: this.options.envelope.delegationCid, policyCid: this.options.envelope.authorizationTarget.kind === "policy" ? this.options.envelope.authorizationTarget.policyCid : "", enforcementDelegationCid: String(enforcement.cid), contentSource: outer.contentSource, contentSourceDigest: String(outer.contentSourceDigest), holderDid: this.options.holderDid, targetOrigin: String(object(outer.target, "owner authority target").origin), nodeAudience: String(object(outer.target, "owner authority target").nodeAudience), action, actions, resource, ...action === "tinycloud.kv/list" ? { limit: 100 } : {}, ...bodyDigest === void 0 ? {} : { bodyDigest, ifMatch: request.ifMatch, contentType: request.contentType }, issuedAt: (/* @__PURE__ */ new Date()).toISOString(), expiresAt: new Date(Math.min(Date.now() + 6e4, Date.parse(this.session.expiresAt))).toISOString(), jti: toBase64Url(crypto.getRandomValues(new Uint8Array(16))) };
+    const outer = object2(authority.outerEnvelope, "owner authority outer envelope");
+    const enforcement = object2(authority.enforcementDelegation, "owner authority enforcement delegation");
+    const invocationBase = { type: "TinyCloudShareReadInvocation", version: 2, sessionId: this.session.sessionId, envelopeCid: authority.envelopeCid, shareCid: authority.shareCid, shareId: envelope.shareId, registrationCid: authority.registrationCid, delegationCid: envelope.delegationCid, policyCid: envelope.authorizationTarget.kind === "policy" ? envelope.authorizationTarget.policyCid : "", enforcementDelegationCid: String(enforcement.cid), contentSource: outer.contentSource, contentSourceDigest: String(outer.contentSourceDigest), holderDid: this.options.holderDid, targetOrigin: String(object2(outer.target, "owner authority target").origin), nodeAudience: String(object2(outer.target, "owner authority target").nodeAudience), action, actions, resource, ...action === "tinycloud.kv/list" ? { limit: 100 } : {}, ...bodyDigest === void 0 ? {} : { bodyDigest, ifMatch: request.ifMatch, contentType: request.contentType }, issuedAt: (/* @__PURE__ */ new Date()).toISOString(), expiresAt: new Date(Math.min(Date.now() + 6e4, Date.parse(this.session.expiresAt))).toISOString(), jti: toBase64Url(crypto.getRandomValues(new Uint8Array(16))) };
     const requestBodyDigest = await digest3(invocationBase);
     const invocation = { ...invocationBase, requestBodyDigest };
     const proof = { ...this.holderProof, signature: toBase64Url(await this.signer(new TextEncoder().encode(`${INVOCATION_DOMAIN}${canonicalize(invocation)}`))) };
-    const signedRequest = { sessionId: this.session.sessionId, envelopeCid: authority.envelopeCid, shareCid: authority.shareCid, shareId: this.options.envelope.shareId, registrationCid: authority.registrationCid, delegationCid: this.options.envelope.delegationCid, policyCid: this.options.envelope.authorizationTarget.kind === "policy" ? this.options.envelope.authorizationTarget.policyCid : "", enforcementDelegationCid: String(enforcement.cid), contentSource: outer.contentSource, contentSourceDigest: String(outer.contentSourceDigest), holderDid: this.options.holderDid, nodeAudience: String(object(outer.target, "owner authority target").nodeAudience), action, actions, resource, requestBodyDigest, invocation, proof };
+    const signedRequest = { sessionId: this.session.sessionId, envelopeCid: authority.envelopeCid, shareCid: authority.shareCid, shareId: envelope.shareId, registrationCid: authority.registrationCid, delegationCid: envelope.delegationCid, policyCid: envelope.authorizationTarget.kind === "policy" ? envelope.authorizationTarget.policyCid : "", enforcementDelegationCid: String(enforcement.cid), contentSource: outer.contentSource, contentSourceDigest: String(outer.contentSourceDigest), holderDid: this.options.holderDid, nodeAudience: String(object2(outer.target, "owner authority target").nodeAudience), action, actions, resource, requestBodyDigest, invocation, proof };
     const response = await this.fetchFn(new URL("/share/v2/invoke", this.options.nodeOrigin), { method: "POST", redirect: "error", headers: { accept: "application/vnd.tinycloud.share+json", "content-type": "application/vnd.tinycloud.share+json" }, body: JSON.stringify({ request: signedRequest, ...action === "tinycloud.kv/list" ? { limit: 100 } : {}, ...bodyBytes === void 0 ? {} : { body: toBase64Url(bodyBytes), bodyDigest, ifMatch: request.ifMatch, contentType: request.contentType } }) });
     if (response.ok) await verifyDetachedResponse(response, this.options.trustedNode);
     return response;
   }
+  async nativeInvokeV3(request, envelope) {
+    const signer = this.nativeSigner ?? this.signer;
+    if (this.session === void 0 || this.v3Authorization === void 0 || signer === void 0) throw new Error("v3 policy session signer is required");
+    const session = verifyCompactUcanAuthorization(this.v3Authorization, this.session.sessionId);
+    if (session.payload.aud !== this.options.holderDid) throw new Error("v3 session recipient mismatch");
+    const action = request.action === "list" ? "tinycloud.kv/list" : request.action === "put" ? "tinycloud.kv/put" : request.action === "metadata" ? "tinycloud.kv/metadata" : "tinycloud.kv/get";
+    const path = typeof request.resource?.path === "string" ? request.resource.path.replace(/^\//, "").replace(/\/$/, "") : envelope.resource.path;
+    const capability = envelope.policy.capabilityCeiling.find((candidate) => candidate.kind === "kv");
+    if (capability === void 0 || !capability.actions.includes(action)) throw new Error("v3 requested capability is not in the signed policy");
+    const marker = "/kv/";
+    const split = capability.resource.indexOf(marker);
+    if (split < 0) throw new Error("v3 KV resource is invalid");
+    const root = capability.resource.slice(split + marker.length).replace(/\/$/, "");
+    if (path !== root && !(capability.selector === "prefix" && path.startsWith(`${root}/`))) throw new Error("v3 KV request is outside the signed selector");
+    const resource = `${capability.resource.slice(0, split + marker.length)}${path}`;
+    const now = Math.floor(Date.now() / 1e3);
+    const invocation = await signCompactUcanAuthorization({ issuerDid: this.options.holderDid, audienceDid: envelope.target.nodeAudience, attenuation: { [resource]: { [action]: [{ type: "xyz.tinycloud.resource/selector", kind: capability.selector, value: resource }] } }, facts: [{ type: "tinycloud.policy.invocation/v1", policyCid: envelope.policyCid, sessionCid: session.cid }], proofs: [session.cid], notBefore: now, expiresAt: Math.min(now + 60, session.payload.exp), nonce: toBase64Url(crypto.getRandomValues(new Uint8Array(16))), sign: signer });
+    const headers = new Headers({ accept: "application/json", Authorization: invocation.authorization });
+    let body;
+    if (action === "tinycloud.kv/put") {
+      if (request.body === void 0) throw new Error("v3 KV put requires bytes");
+      body = Uint8Array.from(request.body);
+      headers.set("content-type", request.contentType ?? "application/octet-stream");
+      if (request.ifMatch !== void 0) headers.set("if-match", request.ifMatch);
+    }
+    return this.fetchFn(new URL("/invoke", this.options.nodeOrigin), { method: "POST", redirect: "error", headers, ...body === void 0 ? {} : { body } });
+  }
 };
 function createAddressedAuthorization(input) {
-  const client = (envelope) => new ShareRecipientClient({ ...input, envelope });
+  const { buildPresentation, ...options } = input;
+  const client = (envelope) => new ShareRecipientClient({
+    ...options,
+    envelope,
+    ...buildPresentation === void 0 ? {} : { buildPresentation: ({ challenge, envelope: candidate, policy }) => buildPresentation({ challenge, envelope: candidate, policy }) }
+  });
   return {
     async begin({ envelope, method }) {
       const current = client(envelope);
@@ -8740,15 +9110,15 @@ function createAddressedAuthorization(input) {
     },
     async verifyResult({ envelope, value, proof }) {
       try {
-        const wrapper = object(proof, "share read proof");
-        const response = object(wrapper.response, "share read response proof");
+        const wrapper = object2(proof, "share read proof");
+        const response = object2(wrapper.response, "share read response proof");
         const envelopeAction = nativeAction("read");
         if (response.type !== "TinyCloudShareInvokeResponse" || response.version !== 2 || response.action !== envelopeAction || response.resource !== envelope.resource.path || typeof response.bodyDigest !== "string" || response.bodyDigest !== value.bodyDigest || response.bodyDigest !== await digestBytes2(value.bytes)) return false;
-        const detached = object(wrapper.detached, "share read detached proof");
+        const detached = object2(wrapper.detached, "share read detached proof");
         if (detached.alg !== "EdDSA" || detached.kid !== input.trustedNode.invitationKid) return false;
         const unsigned = { ...response };
         delete unsigned.proof;
-        return import_ed255197.ed25519.verify(bytes2(detached.signature, "share read signature"), new TextEncoder().encode(`${SHARE_V2_PROTOCOL.readResponseDomain}${canonicalize(unsigned)}`), trustedPublicKey(input.trustedNode));
+        return import_ed255198.ed25519.verify(bytes2(detached.signature, "share read signature"), new TextEncoder().encode(`${SHARE_V2_PROTOCOL.readResponseDomain}${canonicalize(unsigned)}`), trustedPublicKey(input.trustedNode));
       } catch {
         return false;
       }