@tinycloud/share-sdk 1.4.2 → 1.4.3-beta.0

package/dist/index.d.cts

@@ -2,8 +2,8 @@ export { D as DEFAULT_MAX_CONTENT_BLOB_BYTES, a as DEFAULT_MAX_SEALED_BLOB_BYTES
 export { C as CreateOwnerDelegationParams, h as DEFAULT_SHARE_LIFETIME_MS, D as DelegatedShareKey, M as MAX_CONTENT_BYTES, i as OWNER_SHARE_REGISTRATION_DOMAIN, j as OwnerDelegationPermission, g as OwnerDelegationReceipt, O as OwnerShareAction, k as OwnerShareDecryption, a as OwnerShareMatcher, l as OwnerSharePolicyRegistration, b as OwnerSharePolicyRegistrationReceipt, m as OwnerSharePolicyV2, c as PublishedShare, P as PublishedShareDeliveryMaterial, n as PublishedShareMetadata, R as RegisterOwnerSharePolicyParams, o as SHARE_CONTENT_LIMIT, p as SHARE_PUBLISH_RESULT_VERSION, f as SharePublishError, q as SharePublishErrorCode, e as SharePublishOptions, d as SharePublishTarget, S as SignedDelegation, r as canonicalOwnerSharePolicy, s as computeOwnerShareRegistrationCid, t as createDelegatedShareKey, u as createPolicyEnforcementDelegation, v as redactPublishedShare, w as restoreDelegatedShareKey, x as validateOwnerSharePolicyRegistration, y as validateOwnerSharePolicyRegistrationBytes } from './owner-policy-aPmXIR3e.cjs';
 import { ShareEnvelopeV2, ArtifactPin, UnsignedShareEnvelopeV3, ShareEnvelopeV3 } from '@tinycloud/share-envelope';
 export { CheckBearerDelegationOptions, DelegationCheckResult, canonicalize, checkBearerDelegation, fromBase64Url, requiredResourceUri, resourceUriCovers, toBase64Url } from '@tinycloud/share-envelope';
-import { T as TargetPublishOutcome, c as TargetPublishInput, S as ShareTarget } from './addressed-publish-BcvisG4a.cjs';
-export { d as ADDRESSED_SHARE_TOO_LARGE_MESSAGE, A as AddressedOwnerRootInput, a as AddressedOwnerRootReceipt, e as AddressedPolicyRegistrationInput, f as AddressedPolicyRegistrationReceipt, b as AddressedPublishAuthority, g as AddressedShareBoundInput, h as AddressedShareOverLimitError, i as AddressedSharePublishOptions, j as AddressedShareRequest, k as AddressedShareWrites, P as PreparedAddressedShare, l as TargetPublishAdapter, m as addressedCredentialRequirement, n as addressedShareBodyUpperBound, o as assertAddressedShareFits, p as normalizeShareTarget, q as prepareAddressedShare, r as publishAddressedShare, s as publishTargetShare, t as targetAuthorizationMethod } from './addressed-publish-BcvisG4a.cjs';
+import { T as TargetPublishOutcome, c as TargetPublishInput, S as ShareTarget } from './addressed-publish-BPFFqD5s.cjs';
+export { d as ADDRESSED_SHARE_TOO_LARGE_MESSAGE, e as AddressedContentSourceError, f as AddressedContentSourceErrorCode, A as AddressedOwnerRootInput, a as AddressedOwnerRootReceipt, g as AddressedPolicyRegistrationInput, h as AddressedPolicyRegistrationReceipt, b as AddressedPublishAuthority, i as AddressedShareBoundInput, j as AddressedShareKeyClient, k as AddressedShareOverLimitError, l as AddressedSharePublishOptions, m as AddressedShareRequest, n as AddressedShareWrites, E as EncryptedAddressedContent, P as PathBoundContentSource, o as PathBoundEnvelope, p as PathBoundPermissionEntry, q as PathBoundSharePlan, r as PreparedAddressedShare, s as TargetPublishAdapter, t as addressedCredentialRequirement, u as addressedShareBodyUpperBound, v as assertAddressedShareFits, w as assertPathBoundContentSource, x as bindPathBoundContentSource, y as defaultEncryptionNetworkForOwner, z as encryptAddressedShareContent, B as normalizeShareTarget, C as pathBoundKeyPath, D as pathBoundSessionPermissions, F as pathBoundStoredBytes, G as planPathBoundShare, H as prepareAddressedShare, I as publishAddressedShare, J as publishTargetShare, K as targetAuthorizationMethod, L as wrappedKeyDigestHex } from './addressed-publish-BPFFqD5s.cjs';
 import { S as SenderShareRecord, a as SenderShareRecordStorage } from './history-Bg25JIsi.cjs';
 export { E as EncryptedSenderShareHistory, b as EncryptedShareHistoryStorage, M as MemoryEncryptedShareHistoryStorage, c as MemorySenderShareKeyStorage, d as MemorySenderShareRecordStorage, e as SenderShareKeyStorage, f as SenderShareRecordProofs, g as SenderShareRevocationScope, h as SenderShareStore, i as historyRecordForPublishedShare } from './history-Bg25JIsi.cjs';
 import { b as ShareAuthorizationResult, c as ShareAuthorizationAdapter } from './authorization-CmP1skO8.cjs';

package/dist/index.d.ts

@@ -2,8 +2,8 @@ export { D as DEFAULT_MAX_CONTENT_BLOB_BYTES, a as DEFAULT_MAX_SEALED_BLOB_BYTES
 export { C as CreateOwnerDelegationParams, h as DEFAULT_SHARE_LIFETIME_MS, D as DelegatedShareKey, M as MAX_CONTENT_BYTES, i as OWNER_SHARE_REGISTRATION_DOMAIN, j as OwnerDelegationPermission, g as OwnerDelegationReceipt, O as OwnerShareAction, k as OwnerShareDecryption, a as OwnerShareMatcher, l as OwnerSharePolicyRegistration, b as OwnerSharePolicyRegistrationReceipt, m as OwnerSharePolicyV2, c as PublishedShare, P as PublishedShareDeliveryMaterial, n as PublishedShareMetadata, R as RegisterOwnerSharePolicyParams, o as SHARE_CONTENT_LIMIT, p as SHARE_PUBLISH_RESULT_VERSION, f as SharePublishError, q as SharePublishErrorCode, e as SharePublishOptions, d as SharePublishTarget, S as SignedDelegation, r as canonicalOwnerSharePolicy, s as computeOwnerShareRegistrationCid, t as createDelegatedShareKey, u as createPolicyEnforcementDelegation, v as redactPublishedShare, w as restoreDelegatedShareKey, x as validateOwnerSharePolicyRegistration, y as validateOwnerSharePolicyRegistrationBytes } from './owner-policy-aPmXIR3e.js';
 import { ShareEnvelopeV2, ArtifactPin, UnsignedShareEnvelopeV3, ShareEnvelopeV3 } from '@tinycloud/share-envelope';
 export { CheckBearerDelegationOptions, DelegationCheckResult, canonicalize, checkBearerDelegation, fromBase64Url, requiredResourceUri, resourceUriCovers, toBase64Url } from '@tinycloud/share-envelope';
-import { T as TargetPublishOutcome, c as TargetPublishInput, S as ShareTarget } from './addressed-publish-CwTTn9Jn.js';
-export { d as ADDRESSED_SHARE_TOO_LARGE_MESSAGE, A as AddressedOwnerRootInput, a as AddressedOwnerRootReceipt, e as AddressedPolicyRegistrationInput, f as AddressedPolicyRegistrationReceipt, b as AddressedPublishAuthority, g as AddressedShareBoundInput, h as AddressedShareOverLimitError, i as AddressedSharePublishOptions, j as AddressedShareRequest, k as AddressedShareWrites, P as PreparedAddressedShare, l as TargetPublishAdapter, m as addressedCredentialRequirement, n as addressedShareBodyUpperBound, o as assertAddressedShareFits, p as normalizeShareTarget, q as prepareAddressedShare, r as publishAddressedShare, s as publishTargetShare, t as targetAuthorizationMethod } from './addressed-publish-CwTTn9Jn.js';
+import { T as TargetPublishOutcome, c as TargetPublishInput, S as ShareTarget } from './addressed-publish-DorqWQJ8.js';
+export { d as ADDRESSED_SHARE_TOO_LARGE_MESSAGE, e as AddressedContentSourceError, f as AddressedContentSourceErrorCode, A as AddressedOwnerRootInput, a as AddressedOwnerRootReceipt, g as AddressedPolicyRegistrationInput, h as AddressedPolicyRegistrationReceipt, b as AddressedPublishAuthority, i as AddressedShareBoundInput, j as AddressedShareKeyClient, k as AddressedShareOverLimitError, l as AddressedSharePublishOptions, m as AddressedShareRequest, n as AddressedShareWrites, E as EncryptedAddressedContent, P as PathBoundContentSource, o as PathBoundEnvelope, p as PathBoundPermissionEntry, q as PathBoundSharePlan, r as PreparedAddressedShare, s as TargetPublishAdapter, t as addressedCredentialRequirement, u as addressedShareBodyUpperBound, v as assertAddressedShareFits, w as assertPathBoundContentSource, x as bindPathBoundContentSource, y as defaultEncryptionNetworkForOwner, z as encryptAddressedShareContent, B as normalizeShareTarget, C as pathBoundKeyPath, D as pathBoundSessionPermissions, F as pathBoundStoredBytes, G as planPathBoundShare, H as prepareAddressedShare, I as publishAddressedShare, J as publishTargetShare, K as targetAuthorizationMethod, L as wrappedKeyDigestHex } from './addressed-publish-DorqWQJ8.js';
 import { S as SenderShareRecord, a as SenderShareRecordStorage } from './history-kwJxrZgq.js';
 export { E as EncryptedSenderShareHistory, b as EncryptedShareHistoryStorage, M as MemoryEncryptedShareHistoryStorage, c as MemorySenderShareKeyStorage, d as MemorySenderShareRecordStorage, e as SenderShareKeyStorage, f as SenderShareRecordProofs, g as SenderShareRevocationScope, h as SenderShareStore, i as historyRecordForPublishedShare } from './history-kwJxrZgq.js';
 import { b as ShareAuthorizationResult, c as ShareAuthorizationAdapter } from './authorization-CmP1skO8.js';

package/dist/index.js

@@ -6419,7 +6419,220 @@ async function parseAddressedEnvelope(value) {
 }
 
 // src/addressed-publish.ts
+import { sha256 as sha2564 } from "@noble/hashes/sha256";
+
+// src/addressed-content.ts
 import { sha256 as sha2563 } from "@noble/hashes/sha256";
+import { keccak_256 } from "@noble/hashes/sha3";
+var AddressedContentSourceError = class extends TypeError {
+  code;
+  constructor(code3, message) {
+    super(message);
+    this.name = "AddressedContentSourceError";
+    this.code = code3;
+  }
+};
+var SHARE_ID = /^[a-z0-9][a-z0-9_-]{15,63}$/;
+var NETWORK = /^urn:tinycloud:encryption:(.+):default$/;
+var OWNER_PKH = /^did:pkh:eip155:([1-9][0-9]*):(0x[0-9a-fA-F]{40})$/;
+var OWNER_KEY = /^did:key:[A-Za-z0-9]+$/;
+var ENVELOPE_FIELDS = ["v", "networkId", "keyPath", "alg", "keyVersion", "encryptedSymmetricKey", "encryptedSymmetricKeyHash", "ciphertext", "aad", "metadata"];
+var ENVELOPE_ALG = "x25519-aes256gcm/v1";
+var HEX_DIGEST = /^[0-9a-f]{64}$/;
+var BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+var textEncoder = new TextEncoder();
+function hex2(bytes3) {
+  return [...bytes3].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function checksumAddress(address) {
+  const lower = address.toLowerCase().slice(2);
+  const hash = keccak_256(textEncoder.encode(lower));
+  let out = "0x";
+  for (let index = 0; index < lower.length; index++) {
+    const nibble = hash[index >> 1] >> (index % 2 === 0 ? 4 : 0) & 15;
+    out += nibble >= 8 ? lower[index].toUpperCase() : lower[index];
+  }
+  return out;
+}
+function pathBoundKeyPath(shareId) {
+  if (typeof shareId !== "string" || !SHARE_ID.test(shareId)) {
+    throw new AddressedContentSourceError("share-id-invalid", "addressed share id is invalid: 16 to 64 characters from lowercase letters, digits, '_' and '-', starting with a letter or digit (a lowercase UUID, hyphens included, is valid)");
+  }
+  return `share/${shareId}`;
+}
+function defaultEncryptionNetworkForOwner(owner) {
+  let did = owner;
+  const address = typeof owner === "string" ? /^0x[0-9a-fA-F]{40}$/.test(owner) ? owner : void 0 : owner?.address;
+  if (address !== void 0) {
+    const chainId = typeof owner === "string" ? 1 : owner.chainId ?? 1;
+    if (typeof address !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(address) || !Number.isSafeInteger(chainId) || chainId < 1) {
+      throw new AddressedContentSourceError("network-invalid", "owner address is not an Ethereum address");
+    }
+    did = `did:pkh:eip155:${chainId}:${address}`;
+  }
+  const pkh = typeof did === "string" ? OWNER_PKH.exec(did) : null;
+  const normalized = pkh === null ? did : `did:pkh:eip155:${pkh[1]}:${checksumAddress(pkh[2])}`;
+  const network = `urn:tinycloud:encryption:${String(normalized)}:default`;
+  if (typeof normalized !== "string" || !(pkh !== null || OWNER_KEY.test(normalized))) {
+    throw new AddressedContentSourceError("network-invalid", "owner does not name an encryption network");
+  }
+  return network;
+}
+function assertEncryptionNetwork(network) {
+  const match = typeof network === "string" ? NETWORK.exec(network) : null;
+  if (match === null) {
+    throw new AddressedContentSourceError("network-invalid", "encryption network must be the owner's default network: urn:tinycloud:encryption:<did>:default");
+  }
+  const owner = match[1];
+  const pkh = OWNER_PKH.exec(owner);
+  if (pkh !== null) {
+    if (pkh[2] !== checksumAddress(pkh[2])) {
+      throw new AddressedContentSourceError("network-not-checksummed", "encryption network address must be EIP-55 checksummed; use defaultEncryptionNetworkForOwner(ownerDid)");
+    }
+  } else if (!OWNER_KEY.test(owner)) {
+    throw new AddressedContentSourceError("network-invalid", "encryption network owner must be a did:pkh:eip155 address or a did:key");
+  }
+  return network;
+}
+var assertNetwork = assertEncryptionNetwork;
+function decodeWrappedKey(encryptedSymmetricKey) {
+  if (typeof encryptedSymmetricKey !== "string" || !BASE64.test(encryptedSymmetricKey)) {
+    throw new AddressedContentSourceError("envelope-invalid", "wrapped content key is not strict base64");
+  }
+  try {
+    return fromBase64Url(encryptedSymmetricKey.replace(/=+$/, "").replace(/\+/g, "-").replace(/\//g, "_"));
+  } catch {
+    throw new AddressedContentSourceError("envelope-invalid", "wrapped content key is not strict base64");
+  }
+}
+function decodeBase64(value) {
+  try {
+    return fromBase64Url(value.replace(/=+$/, "").replace(/\+/g, "-").replace(/\//g, "_"));
+  } catch {
+    throw new AddressedContentSourceError("envelope-invalid", "envelope field is not strict base64");
+  }
+}
+function wrappedKeyDigestHex(encryptedSymmetricKey) {
+  return hex2(sha2563(decodeWrappedKey(encryptedSymmetricKey)));
+}
+function canonicalKeyHashHex(encryptedSymmetricKey) {
+  return hex2(sha2563(textEncoder.encode(canonicalize(encryptedSymmetricKey))));
+}
+function pathBoundSessionPermissions(input) {
+  const encryptionNetwork = assertNetwork(input.encryptionNetwork);
+  return [{ service: "tinycloud.encryption", path: `${encryptionNetwork}/share/`, actions: ["tinycloud.encryption/decrypt", "tinycloud.encryption/key.create"] }];
+}
+function planPathBoundShare(input) {
+  const keyPath = pathBoundKeyPath(input.shareId);
+  const encryptionNetwork = assertNetwork(input.encryptionNetwork);
+  const keyResource = `${encryptionNetwork}/${keyPath}`;
+  return {
+    shareId: input.shareId,
+    encryptionNetwork,
+    keyPath,
+    keyResource,
+    requiredPermissions: [{ service: "tinycloud.encryption", path: keyResource, actions: ["tinycloud.encryption/key.create"] }],
+    sessionPermissions: pathBoundSessionPermissions({ encryptionNetwork }),
+    registrationPermissions: [{ service: "tinycloud.encryption", path: `${encryptionNetwork}/share/`, actions: ["tinycloud.encryption/decrypt"] }],
+    encryptOptions: (extra) => ({ networkId: encryptionNetwork, ...extra?.metadata === void 0 ? {} : { metadata: { ...extra.metadata } } })
+  };
+}
+function pathBoundStoredBytes(envelope) {
+  return textEncoder.encode(canonicalize(envelope));
+}
+function assertEnvelope(plan, envelope) {
+  if (envelope === null || typeof envelope !== "object" || envelope.v !== 2) {
+    throw new AddressedContentSourceError("envelope-invalid", "path-bound content must be a v2 named-key envelope (encrypt with keys.encrypt, not encryptToNetwork)");
+  }
+  if (envelope.networkId !== plan.encryptionNetwork || envelope.keyPath !== plan.keyPath) {
+    throw new AddressedContentSourceError("key-path-mismatch", "envelope network or key path does not match the share's plan");
+  }
+  if (!Number.isSafeInteger(envelope.keyVersion) || envelope.keyVersion < 1) {
+    throw new AddressedContentSourceError("envelope-invalid", "envelope key version is invalid");
+  }
+  wrappedKeyDigestHex(envelope.encryptedSymmetricKey);
+  if (envelope.encryptedSymmetricKeyHash !== canonicalKeyHashHex(envelope.encryptedSymmetricKey)) {
+    throw new AddressedContentSourceError("envelope-invalid", "envelope key hash does not match its wrapped key");
+  }
+  const record = envelope;
+  if (Object.keys(record).some((key) => !ENVELOPE_FIELDS.includes(key)) || record.alg !== ENVELOPE_ALG) {
+    throw new AddressedContentSourceError("envelope-invalid", "envelope has a field or algorithm the recipient does not accept");
+  }
+  if (typeof record.ciphertext !== "string" || !BASE64.test(record.ciphertext) || decodeBase64(record.ciphertext).length < 28) {
+    throw new AddressedContentSourceError("envelope-invalid", "envelope ciphertext is not strict base64 of at least 28 bytes");
+  }
+  if (record.aad !== void 0 && (typeof record.aad !== "string" || !BASE64.test(record.aad))) {
+    throw new AddressedContentSourceError("envelope-invalid", "envelope aad is not strict base64");
+  }
+  if (record.metadata !== void 0 && (record.metadata === null || typeof record.metadata !== "object" || Array.isArray(record.metadata) || Object.values(record.metadata).some((entry) => typeof entry !== "string"))) {
+    throw new AddressedContentSourceError("envelope-invalid", "envelope metadata must be an object of strings");
+  }
+}
+function bindPathBoundContentSource(input) {
+  const { plan, envelope } = input;
+  assertEnvelope(plan, envelope);
+  const expected = pathBoundStoredBytes(envelope);
+  if (input.storedBytes.length !== expected.length || input.storedBytes.some((byte, index) => byte !== expected[index])) {
+    throw new AddressedContentSourceError("stored-bytes-mismatch", "uploaded bytes are not the canonical v2 envelope; upload pathBoundStoredBytes(envelope)");
+  }
+  return {
+    shareId: plan.shareId,
+    kvResource: input.kvResource,
+    selector: input.selector,
+    encryptionNetwork: plan.encryptionNetwork,
+    encryptionKeyPath: plan.keyPath,
+    encryptedSymmetricKeyDigestHex: wrappedKeyDigestHex(envelope.encryptedSymmetricKey),
+    keyVersion: envelope.keyVersion,
+    mode: "immutable",
+    initialCiphertextDigestHex: hex2(sha2563(expected))
+  };
+}
+function isUnauthorized(error) {
+  const value = error;
+  return value !== null && typeof value === "object" && (value.status === 401 || value.status === 403 || value.code === "PERMISSION_DENIED" || value.code === "AUTH_UNAUTHORIZED");
+}
+async function encryptAddressedShareContent(input) {
+  const { plan, keys } = input;
+  const byteLength = input.plaintext.byteLength;
+  let receipt;
+  try {
+    receipt = await keys.createKey(plan.keyPath, { networkId: plan.encryptionNetwork });
+  } catch (error) {
+    if (isUnauthorized(error)) {
+      const status = error.status;
+      throw new AddressedContentSourceError(
+        "key-not-authorized",
+        `the owner session does not hold tinycloud.encryption/key.create on ${plan.keyResource} (the node answers "Unauthorized Action: ${plan.keyResource} / tinycloud.encryption/key.create"); hold it either at sign-in (put plan.sessionPermissions in the manifest: key.create on ${plan.encryptionNetwork}/share/) or per share (requestPermissions(plan.requiredPermissions)) before creating the key` + (status === 403 ? "; if the owner signs in through OpenKey, the request must come from a first-party TinyCloud origin" : "")
+      );
+    }
+    throw error;
+  }
+  if (receipt.networkId !== plan.encryptionNetwork || receipt.keyPath !== plan.keyPath || receipt.state !== void 0 && receipt.state !== "active") {
+    throw new AddressedContentSourceError("key-receipt-mismatch", "the created key does not match this share");
+  }
+  const envelope = await keys.encrypt(plan.keyPath, input.plaintext, plan.encryptOptions(input.metadata === void 0 ? void 0 : { metadata: input.metadata }));
+  assertEnvelope(plan, envelope);
+  if (receipt.keyVersion !== void 0 && envelope.keyVersion !== receipt.keyVersion) {
+    throw new AddressedContentSourceError("key-receipt-mismatch", "the envelope key version does not match the created key");
+  }
+  const storedBytes = pathBoundStoredBytes(envelope);
+  return { envelope, storedBytes, byteLength };
+}
+function assertPathBoundContentSource(source, shareId) {
+  if (source === void 0 || source === null || typeof source !== "object") {
+    throw new AddressedContentSourceError("key-path-required", "addressed content source is missing");
+  }
+  if (source.encryptionKeyPath === void 0) {
+    throw new AddressedContentSourceError("key-path-required", "addressed content source must name its key (encryptionKeyPath: share/<shareId>); a network-wide source is not accepted");
+  }
+  if (source.encryptionKeyPath !== pathBoundKeyPath(shareId)) {
+    throw new AddressedContentSourceError("key-path-mismatch", "addressed content source key path must be share/<shareId> of this share");
+  }
+  if (typeof source.encryptedSymmetricKeyDigestHex !== "string" || !HEX_DIGEST.test(source.encryptedSymmetricKeyDigestHex)) {
+    throw new AddressedContentSourceError("digest-invalid", "addressed content source needs encryptedSymmetricKeyDigestHex: 64 lowercase hex characters");
+  }
+  assertEncryptionNetwork(source.encryptionNetwork);
+}
 
 // src/authorization.ts
 async function authorizeShare(input) {
@@ -6917,7 +7130,7 @@ var POLICY_CAPABILITY_V1_DOMAIN2 = "xyz.tinycloud.policy/PolicyCapability/v1\0";
 var CONTENT_SOURCE_V1_DOMAIN2 = "xyz.tinycloud.policy/ContentSource/v1\0";
 var NATIVE_PROJECTION_V1_DOMAIN2 = "xyz.tinycloud.policy/NativeProjection/v1\0";
 var ENVELOPE_V3_DOMAIN = "xyz.tinycloud.share/envelope/v3\0";
-var textEncoder = new TextEncoder();
+var textEncoder2 = new TextEncoder();
 function targetMatcher(target) {
   if (target.kind === "recipientDid") return { kind: "recipientDid", value: target.did };
   if (target.kind === "email") return { kind: "exactEmail", value: target.address };
@@ -6928,17 +7141,18 @@ function targetKind(target) {
 }
 var OWNER_SHARE_ACTIONS = /* @__PURE__ */ new Set(["tinycloud.kv/get", "tinycloud.kv/list", "tinycloud.kv/metadata", "tinycloud.kv/put"]);
 function assertSafeInput(input) {
-  if (!/^[A-Za-z0-9_-]{16,128}$/.test(input.shareId)) throw new TypeError("addressed share id is invalid");
+  pathBoundKeyPath(input.shareId);
+  assertPathBoundContentSource(input.contentSource, input.shareId);
   if (!Number.isSafeInteger(input.byteLength) || input.byteLength < 0 || input.byteLength > SHARE_CONTENT_LIMIT) throw new TypeError("addressed content length is invalid");
   if (!Number.isFinite(input.expiresAt.getTime()) || input.expiresAt.getTime() <= Date.now()) throw new TypeError("addressed share expiry must be in the future");
   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.shareId !== input.shareId || input.contentSource.selector !== input.resource.kind) throw new TypeError("addressed content source is not bound to the share");
 }
-function hex2(bytes3) {
+function hex3(bytes3) {
   return [...bytes3].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 function digestHex(value, domain) {
-  return hex2(sha2563(textEncoder.encode(`${domain}${canonicalize(value)}`)));
+  return hex3(sha2564(textEncoder2.encode(`${domain}${canonicalize(value)}`)));
 }
 function sortCanonical(values) {
   return [...values].sort((left, right) => canonicalize(left).localeCompare(canonicalize(right)));
@@ -6982,19 +7196,20 @@ async function createPolicy(options, capabilities) {
   const unsigned = options.credentialRequirement === void 0 ? { schema: "xyz.tinycloud.policy/policy/v1", ...fields } : { schema: "xyz.tinycloud.policy/policy/v2", ...fields, credentialRequirement: options.credentialRequirement };
   const domain = options.credentialRequirement === void 0 ? POLICY_V1_DOMAIN : POLICY_V2_DOMAIN;
   const policyDigestHex = digestHex(unsigned, domain);
-  const signature = await options.authority.sign(sha2563(textEncoder.encode(`${domain}${canonicalize(unsigned)}`)));
+  const signature = await options.authority.sign(sha2564(textEncoder2.encode(`${domain}${canonicalize(unsigned)}`)));
   if (signature.byteLength !== 64) throw new TypeError("policy signature must be Ed25519");
   const policy = {
     ...unsigned,
     policyId: `pol_${base32Lower2(Uint8Array.from(policyDigestHex.match(/../g), (byte) => Number.parseInt(byte, 16)))}`,
     signature: { suite: "Ed25519", signerDid: options.authority.ownerDid, value: toBase64Url(signature) }
   };
-  return { policy, policyCid: await computeCid(textEncoder.encode(canonicalize(policy))), policyDigestHex };
+  return { policy, policyCid: await computeCid(textEncoder2.encode(canonicalize(policy))), policyDigestHex };
 }
 function addressedPlan(options) {
   const capabilities = sortCanonical([
     { kind: "kv", resource: options.contentSource.kvResource, selector: options.resource.kind, actions: [...options.policyActions] },
-    { kind: "encryption", resource: options.contentSource.encryptionKeyPath === void 0 ? options.contentSource.encryptionNetwork : `${options.contentSource.encryptionNetwork}/${options.contentSource.encryptionKeyPath}`, action: "tinycloud.encryption/decrypt" }
+    // Only this share's one key: there is no network-scope capability.
+    { kind: "encryption", resource: `${options.contentSource.encryptionNetwork}/${options.contentSource.encryptionKeyPath}`, action: "tinycloud.encryption/decrypt" }
   ]);
   return {
     expiry: rfc3339Seconds(options.expiresAt),
@@ -7082,7 +7297,7 @@ function mailboxCredentialCommitment(target) {
   return {
     type: "TinyCloudPolicyCredentialRequirement",
     version: 1,
-    requirementDigest: toBase64Url(sha2563(textEncoder.encode(canonicalize(requirement)))),
+    requirementDigest: toBase64Url(sha2564(textEncoder2.encode(canonicalize(requirement)))),
     descriptorDigest: target.kind === "email" ? EMAIL_DESCRIPTOR_DIGEST : EMAIL_DOMAIN_DESCRIPTOR_DIGEST,
     issuerDid: EMAIL_CREDENTIAL_ISSUER_DID,
     issuerKid: EMAIL_CREDENTIAL_ISSUER_KID,
@@ -7177,11 +7392,11 @@ async function publishAddressedShare(input) {
     expiry
   });
   unsignedShareEnvelopeV3Schema.parse(unsigned);
-  const envelopeSignature = await options.authority.sign(sha2563(textEncoder.encode(`${ENVELOPE_V3_DOMAIN}${canonicalize(unsigned)}`)));
+  const envelopeSignature = await options.authority.sign(sha2564(textEncoder2.encode(`${ENVELOPE_V3_DOMAIN}${canonicalize(unsigned)}`)));
   if (envelopeSignature.byteLength !== 64) throw new TypeError("v3 envelope signature must be Ed25519");
   const envelope = signedAddressedEnvelope(unsigned, options.authority.ownerDid, envelopeSignature);
   shareEnvelopeV3Schema.parse(envelope);
-  const envelopeBytes = textEncoder.encode(canonicalize(envelope));
+  const envelopeBytes = textEncoder2.encode(canonicalize(envelope));
   const envelopeKeyBytes = generateKey();
   const sealed = await seal(envelopeBytes, envelopeKeyBytes);
   const envelopeKey = toBase64Url(envelopeKeyBytes);
@@ -7261,7 +7476,7 @@ function rootAuthorizationBound(input) {
     nnc: "A".repeat(36),
     prf: []
   };
-  return `${toBase64Url(textEncoder.encode(canonicalize(header)))}.${toBase64Url(textEncoder.encode(canonicalize(payload)))}.${"A".repeat(86)}`;
+  return `${toBase64Url(textEncoder2.encode(canonicalize(header)))}.${toBase64Url(textEncoder2.encode(canonicalize(payload)))}.${"A".repeat(86)}`;
 }
 async function sealedBodyUpperBound(options) {
   const plan = addressedPlan(options);
@@ -7309,7 +7524,7 @@ async function sealedBodyUpperBound(options) {
     expiry: plan.expiry
   });
   const envelope = signedAddressedEnvelope(unsigned, options.ownerDid, signature);
-  return (await seal(textEncoder.encode(canonicalize(envelope)), generateKey())).blob.length;
+  return (await seal(textEncoder2.encode(canonicalize(envelope)), generateKey())).blob.length;
 }
 async function assertSealedBodyFits(options) {
   if (await sealedBodyUpperBound(options) > await linkBodyLimit()) throw new SharePublishError("max-bytes-exceeded", ADDRESSED_SHARE_TOO_LARGE_MESSAGE);
@@ -7319,12 +7534,15 @@ async function addressedShareBodyUpperBound(input) {
   const deliveryEmail = input.deliveryEmail ?? (target.kind === "email" && isEnvelopeDeliveryEmail(target.address) ? target.address : void 0);
   const artifactStorage = "artifactId" in input.storage ? input.storage : void 0;
   const path = "path" in input.storage ? input.storage.path : `${ARTIFACT_ROOT}/${input.storage.artifactId}/versions/${Number.MAX_SAFE_INTEGER}/${input.storage.storageName}`;
+  const keyPath = pathBoundKeyPath(input.shareId);
+  assertEncryptionNetwork(input.encryptionNetwork);
+  if (input.encryptionKeyPath !== void 0 && input.encryptionKeyPath !== keyPath) throw new AddressedContentSourceError("key-path-mismatch", "addressed content source key path must be share/<shareId> of this share");
   const contentSource = {
     shareId: input.shareId,
     kvResource: `${input.spaceId}/kv/${path}`,
     selector: input.resource.kind,
     encryptionNetwork: input.encryptionNetwork,
-    ...input.encryptionKeyPath === void 0 ? {} : { encryptionKeyPath: input.encryptionKeyPath },
+    encryptionKeyPath: keyPath,
     encryptedSymmetricKeyDigestHex: "f".repeat(64),
     keyVersion: Number.MAX_SAFE_INTEGER,
     mode: "immutable",
@@ -7364,13 +7582,13 @@ async function assertAddressedShareFits(input) {
 }
 
 // src/cache.ts
-import { sha256 as sha2564 } from "@noble/hashes/sha256";
+import { sha256 as sha2565 } from "@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 digest(bytes3) {
-  return sha2564(bytes3);
+  return sha2565(bytes3);
 }
 function equalBytes(left, right) {
   if (left.byteLength !== right.byteLength) return false;
@@ -7426,7 +7644,7 @@ var MemoryShareCache = class {
 
 // src/owner-policy.ts
 import { ed25519 as ed255194 } from "@noble/curves/ed25519";
-import { sha256 as sha2565 } from "@noble/hashes/sha256";
+import { sha256 as sha2566 } from "@noble/hashes/sha256";
 
 // ../../node_modules/multiformats/dist/src/bases/base32.js
 var base322 = rfc46482({
@@ -7980,10 +8198,10 @@ function fromB64(value) {
   throw new Error("base64url decoding is unavailable");
 }
 function cid(bytesValue) {
-  return CID2.createV1(code2, create2(SHA256_CODE2, sha2565(bytesValue))).toString(base322.encoder);
+  return CID2.createV1(code2, create2(SHA256_CODE2, sha2566(bytesValue))).toString(base322.encoder);
 }
 function digest2(bytesValue) {
-  return b64(sha2565(bytesValue));
+  return b64(sha2566(bytesValue));
 }
 function didKeyFromEd25519PublicKey2(publicKey) {
   if (publicKey.length !== 32) throw new Error("share key public key must be 32 bytes");
@@ -8655,7 +8873,7 @@ async function showShare(input) {
 
 // src/recipient.ts
 import { ed25519 as ed255195, x25519 } from "@noble/curves/ed25519";
-import { sha256 as sha2566 } from "@noble/hashes/sha256";
+import { sha256 as sha2567 } from "@noble/hashes/sha256";
 
 // src/protocol.ts
 var SHARE_V2_PROTOCOL = Object.freeze({
@@ -8823,12 +9041,12 @@ function requestedSessionExpiry(expiry) {
   if (!Number.isFinite(seconds) || seconds <= Math.floor(Date.now() / 1e3) + 60) return void 0;
   return new Date(seconds * 1e3).toISOString().replace(/\.\d{3}Z$/, "Z");
 }
-function hex3(value) {
+function hex4(value) {
   return [...value].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 function matchesInitialCiphertextDigest(bytes3, expected) {
   if (typeof expected !== "string" || !LOWER_SHA256_HEX.test(expected)) return false;
-  const actual = sha2566(bytes3);
+  const actual = sha2567(bytes3);
   let mismatch = 0;
   for (let index = 0; index < actual.length; index += 1) {
     mismatch |= actual[index] ^ Number.parseInt(expected.slice(index * 2, index * 2 + 2), 16);
@@ -8836,10 +9054,10 @@ function matchesInitialCiphertextDigest(bytes3, expected) {
   return mismatch === 0;
 }
 function canonicalHashHex(value) {
-  return hex3(sha2566(new TextEncoder().encode(canonicalize(value))));
+  return hex4(sha2567(new TextEncoder().encode(canonicalize(value))));
 }
 function registeredWrappedKeyDigest(encryptedSymmetricKey, pathBound) {
-  const rawDigest = hex3(sha2566(fromBase64(encryptedSymmetricKey, "v3 encrypted symmetric key")));
+  const rawDigest = hex4(sha2567(fromBase64(encryptedSymmetricKey, "v3 encrypted symmetric key")));
   return pathBound ? rawDigest : canonicalHashHex(encryptedSymmetricKey);
 }
 async function aesGcmDecrypt(key, blob, aad) {
@@ -9008,7 +9226,7 @@ var ShareRecipientClient = class {
     const receiverPublicKey = toBase64(x25519.getPublicKey(receiverPrivateKey));
     const receiverPublicKeyHash = canonicalHashHex(receiverPublicKey);
     const body = { type: "tinycloud.encryption.decrypt/v1", targetNode: this.v3NodeAudience, networkId: encrypted.networkId, ...encrypted.keyPath === void 0 ? {} : { keyPath: encrypted.keyPath }, alg: encrypted.alg, keyVersion: encrypted.keyVersion, encryptedSymmetricKey: encrypted.encryptedSymmetricKey, encryptedSymmetricKeyHash: encrypted.encryptedSymmetricKeyHash, receiverPublicKey, receiverPublicKeyHash };
-    const bodyHash = hex3(sha2566(new TextEncoder().encode(canonicalize(body))));
+    const bodyHash = hex4(sha2567(new TextEncoder().encode(canonicalize(body))));
     const session = verifyCompactUcanAuthorization(this.v3Authorization, this.session.sessionId);
     const now = Math.floor(Date.now() / 1e3);
     const decryptResource = encrypted.keyPath === void 0 ? encrypted.networkId : `${encrypted.networkId}/${encrypted.keyPath}`;
@@ -9029,7 +9247,7 @@ var ShareRecipientClient = class {
       if (!response.ok) throw await recipientHttpError(response, "v3 decrypt invocation rejected");
       const value = object3(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 !== hex3(sha2566(new TextEncoder().encode(`${invocation.cid}${bodyHash}`))) || typeof value.wrappedKey !== "string" || typeof value.nodeSignature !== "string") throw new Error("v3 decrypt response binding is invalid");
+      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 !== hex4(sha2567(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 = fromBase64(value.nodeSignature, "v3 decrypt response signature");
@@ -9194,6 +9412,7 @@ async function openNativeShare(sharing, link) {
 }
 export {
   ADDRESSED_SHARE_TOO_LARGE_MESSAGE,
+  AddressedContentSourceError,
   AddressedShareOverLimitError,
   ArtifactPinError,
   CredentialInvitationError,
@@ -9222,8 +9441,10 @@ export {
   artifactBindingView,
   assertAddressedShareFits,
   assertArtifactBinding,
+  assertPathBoundContentSource,
   authorizationMethodForTarget,
   authorizeShare,
+  bindPathBoundContentSource,
   canonicalOwnerSharePolicy,
   canonicalShareFilename,
   canonicalize,
@@ -9235,7 +9456,9 @@ export {
   createNativeShare,
   createPolicyEnforcementDelegation,
   createShareV2HolderBindingArtifact,
+  defaultEncryptionNetworkForOwner,
   deliverCredentialInvitation,
+  encryptAddressedShareContent,
   fromBase64Url,
   hasUnsafeFilenameCodePoint,
   historyRecordForPublishedShare,
@@ -9246,6 +9469,10 @@ export {
   openNativeShare,
   parseAddressedEnvelope,
   parseNativeShareUrl,
+  pathBoundKeyPath,
+  pathBoundSessionPermissions,
+  pathBoundStoredBytes,
+  planPathBoundShare,
   prepareAddressedShare,
   publishAddressedShare,
   publishPolicyShare,
@@ -9265,6 +9492,7 @@ export {
   toShareErrorInfo,
   validateOwnerSharePolicyRegistration,
   validateOwnerSharePolicyRegistrationBytes,
-  verifyArtifactShare
+  verifyArtifactShare,
+  wrappedKeyDigestHex
 };
 //# sourceMappingURL=index.js.map