@tinycloud/sdk-core 2.11.0-beta.1 → 2.11.0-beta.11

package/dist/index.js

@@ -147,8 +147,8 @@ function makePkhSpaceId(address, chainId, name2) {
 }
 
 // src/requester/index.ts
-import { bytesToHex as bytesToHex3, sha256 as sha2564 } from "viem";
-import { blake3 } from "@noble/hashes/blake3";
+import { bytesToHex as bytesToHex3, sha256 as sha2565 } from "viem";
+import { blake3 as blake32 } from "@noble/hashes/blake3";
 
 // ../../node_modules/multiformats/dist/src/bases/base32.js
 var base32_exports = {};
@@ -1056,7 +1056,7 @@ function encodeCID(version, code3, multihash) {
 var cidSymbol = /* @__PURE__ */ Symbol.for("@ipld/js-cid/CID");
 
 // src/requester/index.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/policy/errors.ts
 var SignedObjectProfileError = class extends Error {
@@ -1365,16 +1365,16 @@ function policyCapabilityContains(authority, request) {
   return caveatsContain(auth.caveats, req.caveats);
 }
 function normalizePolicyCapabilityWithOptions(input, options2) {
-  const object = expectObject(input, "$");
-  assertExactKeys(object, ["service", "space", "path", "actions", "caveats"], "$");
-  const service = requiredString(object, "service", "$", "policy-capability-malformed-service");
+  const object2 = expectObject(input, "$");
+  assertExactKeys(object2, ["service", "space", "path", "actions", "caveats"], "$");
+  const service = requiredString(object2, "service", "$", "policy-capability-malformed-service");
   if (!CEILING_SERVICES.has(service)) {
     throw new PolicyCapabilityError(
       "policy-capability-malformed-service",
       "$.service is outside the frozen permissionsCeiling vocabulary"
     );
   }
-  const space = requiredString(object, "space", "$", "policy-capability-malformed-space");
+  const space = requiredString(object2, "space", "$", "policy-capability-malformed-space");
   validateConcreteSpace(space);
   const canonicalSpace = space.normalize("NFC");
   if (options2.requireCanonical && canonicalSpace !== space) {
@@ -1383,7 +1383,7 @@ function normalizePolicyCapabilityWithOptions(input, options2) {
       "$.space must already be canonical NFC"
     );
   }
-  const rawPath = requiredString(object, "path", "$", "policy-capability-malformed-path");
+  const rawPath = requiredString(object2, "path", "$", "policy-capability-malformed-path");
   validateRawPath(rawPath, options2);
   const path = normalizePath(rawPath);
   if (options2.requireCanonical && path !== rawPath) {
@@ -1394,7 +1394,7 @@ function normalizePolicyCapabilityWithOptions(input, options2) {
   }
   validateRawPath(path, options2);
   const actions = normalizeActions(
-    requiredArray(object, "actions", "$", "policy-capability-malformed-action"),
+    requiredArray(object2, "actions", "$", "policy-capability-malformed-action"),
     service,
     options2
   );
@@ -1403,9 +1403,9 @@ function normalizePolicyCapabilityWithOptions(input, options2) {
   output.space = canonicalSpace;
   output.path = path;
   output.actions = actions;
-  if (hasOwn(object, "caveats")) {
+  if (hasOwn(object2, "caveats")) {
     output.caveats = validateCaveats(
-      requiredValue(object, "caveats", "$", "policy-capability-malformed-caveats"),
+      requiredValue(object2, "caveats", "$", "policy-capability-malformed-caveats"),
       output.service
     );
   }
@@ -1428,9 +1428,9 @@ function expectObject(input, path) {
     );
   }
 }
-function assertExactKeys(object, allowed, path) {
+function assertExactKeys(object2, allowed, path) {
   const allowedSet = new Set(allowed);
-  for (const key of Object.keys(object)) {
+  for (const key of Object.keys(object2)) {
     if (!allowedSet.has(key)) {
       throw new PolicyCapabilityError(
         key === "id" || key === "scope" ? "policy-capability-malformed" : "policy-capability-unknown-key",
@@ -1439,21 +1439,21 @@ function assertExactKeys(object, allowed, path) {
     }
   }
 }
-function requiredValue(object, key, path, code3) {
-  if (!hasOwn(object, key)) {
+function requiredValue(object2, key, path, code3) {
+  if (!hasOwn(object2, key)) {
     throw new PolicyCapabilityError(code3, `${path}.${key} is required`);
   }
-  return object[key];
+  return object2[key];
 }
-function requiredString(object, key, path, code3) {
-  const value = requiredValue(object, key, path, code3);
+function requiredString(object2, key, path, code3) {
+  const value = requiredValue(object2, key, path, code3);
   if (typeof value !== "string" || value.length === 0) {
     throw new PolicyCapabilityError(code3, `${path}.${key} must be a non-empty string`);
   }
   return value;
 }
-function requiredArray(object, key, path, code3) {
-  const value = requiredValue(object, key, path, code3);
+function requiredArray(object2, key, path, code3) {
+  const value = requiredValue(object2, key, path, code3);
   if (!Array.isArray(value)) {
     throw new PolicyCapabilityError(code3, `${path}.${key} must be an array`);
   }
@@ -1598,11 +1598,11 @@ function validateSqlStatement(input, path) {
   if (input === null || typeof input !== "object" || Array.isArray(input)) {
     throw new PolicyCapabilityError("policy-capability-malformed-caveats", `${path} must be an object`);
   }
-  const object = input;
-  assertCaveatKeys(object, ["name", "sql", "fixedParams"], path);
-  caveatString(object, "name", path);
-  caveatString(object, "sql", path);
-  const fixedParams = requiredCaveat(object, "fixedParams", path);
+  const object2 = input;
+  assertCaveatKeys(object2, ["name", "sql", "fixedParams"], path);
+  caveatString(object2, "name", path);
+  caveatString(object2, "sql", path);
+  const fixedParams = requiredCaveat(object2, "fixedParams", path);
   if (!Array.isArray(fixedParams)) {
     throw new PolicyCapabilityError(
       "policy-capability-malformed-caveats",
@@ -1617,20 +1617,20 @@ function validateFixedParam(input, path) {
   if (input === null || typeof input !== "object" || Array.isArray(input)) {
     throw new PolicyCapabilityError("policy-capability-malformed-caveats", `${path} must be an object`);
   }
-  const object = input;
-  assertCaveatKeys(object, ["index", "value"], path);
-  const index = requiredCaveat(object, "index", path);
+  const object2 = input;
+  assertCaveatKeys(object2, ["index", "value"], path);
+  const index = requiredCaveat(object2, "index", path);
   if (typeof index !== "number" || !Number.isSafeInteger(index) || index < 0) {
     throw new PolicyCapabilityError(
       "policy-capability-malformed-caveats",
       `${path}.index must be a non-negative integer`
     );
   }
-  requiredCaveat(object, "value", path);
+  requiredCaveat(object2, "value", path);
 }
-function assertCaveatKeys(object, allowed, path) {
+function assertCaveatKeys(object2, allowed, path) {
   const allowedSet = new Set(allowed);
-  for (const key of Object.keys(object)) {
+  for (const key of Object.keys(object2)) {
     if (!allowedSet.has(key)) {
       throw new PolicyCapabilityError(
         "policy-capability-malformed-caveats",
@@ -1639,17 +1639,17 @@ function assertCaveatKeys(object, allowed, path) {
     }
   }
 }
-function requiredCaveat(object, key, path) {
-  if (!hasOwn(object, key)) {
+function requiredCaveat(object2, key, path) {
+  if (!hasOwn(object2, key)) {
     throw new PolicyCapabilityError(
       "policy-capability-malformed-caveats",
       `${path}.${key} is required`
     );
   }
-  return object[key];
+  return object2[key];
 }
-function caveatString(object, key, path) {
-  const value = requiredCaveat(object, key, path);
+function caveatString(object2, key, path) {
+  const value = requiredCaveat(object2, key, path);
   if (typeof value !== "string" || value.length === 0) {
     throw new PolicyCapabilityError(
       "policy-capability-malformed-caveats",
@@ -1680,8 +1680,8 @@ function caveatsContain(authority, request) {
     (statement) => authorityStatements.some((candidate) => jcsCanonicalize(candidate) === jcsCanonicalize(statement))
   );
 }
-function hasOwn(object, key) {
-  return objectHasOwn2(object, key);
+function hasOwn(object2, key) {
+  return objectHasOwn2(object2, key);
 }
 
 // src/policy/signed-object.ts
@@ -1858,13 +1858,12 @@ function digest(input, options2) {
 }
 var identity2 = { code: code2, name, encode: encode4, digest };
 
-// ../../node_modules/multiformats/dist/src/hashes/sha2.js
-var sha2_exports = {};
-__export(sha2_exports, {
+// ../../node_modules/multiformats/dist/src/hashes/sha2-browser.js
+var sha2_browser_exports = {};
+__export(sha2_browser_exports, {
   sha256: () => sha2562,
   sha512: () => sha512
 });
-import crypto2 from "crypto";
 
 // ../../node_modules/multiformats/dist/src/hashes/hasher.js
 var DEFAULT_MIN_DIGEST_LENGTH = 20;
@@ -1914,21 +1913,24 @@ function createDigest(digest4, code3, truncate) {
   return create(code3, digest4);
 }
 
-// ../../node_modules/multiformats/dist/src/hashes/sha2.js
+// ../../node_modules/multiformats/dist/src/hashes/sha2-browser.js
+function sha(name2) {
+  return async (data) => new Uint8Array(await crypto.subtle.digest(name2, data));
+}
 var sha2562 = from2({
   name: "sha2-256",
   code: 18,
-  encode: (input) => coerce(crypto2.createHash("sha256").update(input).digest())
+  encode: sha("SHA-256")
 });
 var sha512 = from2({
   name: "sha2-512",
   code: 19,
-  encode: (input) => coerce(crypto2.createHash("sha512").update(input).digest())
+  encode: sha("SHA-512")
 });
 
 // ../../node_modules/multiformats/dist/src/basics.js
 var bases = { ...identity_exports, ...base2_exports, ...base8_exports, ...base10_exports, ...base16_exports, ...base32_exports, ...base36_exports, ...base58_exports, ...base64_exports, ...base256emoji_exports };
-var hashes = { ...sha2_exports, ...identity_exports2 };
+var hashes = { ...sha2_browser_exports, ...identity_exports2 };
 
 // src/policy/signed-object.ts
 import { bytesToHex as bytesToHex2, sha256 as sha2563, verifyMessage } from "viem";
@@ -2007,17 +2009,17 @@ async function createAndSignSignedObject(input, signer) {
 }
 function createAndSignPolicy(input, signer) {
   return createAndSignSignedObject(input, signer).then(
-    (object) => validatePolicySignedShape(object)
+    (object2) => validatePolicySignedShape(object2)
   );
 }
 function createAndSignPolicyStatus(input, signer) {
   return createAndSignSignedObject(input, signer).then(
-    (object) => validatePolicyStatusSignedShape(object)
+    (object2) => validatePolicyStatusSignedShape(object2)
   );
 }
 function createAndSignPolicyEngineRecord(input, signer) {
   return createAndSignSignedObject(input, signer).then(
-    (object) => validatePolicyEngineRecordSignedShape(object)
+    (object2) => validatePolicyEngineRecordSignedShape(object2)
   );
 }
 async function verifySignedObject(input) {
@@ -2121,9 +2123,9 @@ function validateUnsignedForDescriptor(input, descriptor) {
   }
 }
 function validatePolicyShape(input, signed) {
-  const object = expectJsonObject(normalizeJson(input), "$");
+  const object2 = expectJsonObject(normalizeJson(input), "$");
   assertExactKeys2(
-    object,
+    object2,
     signed ? [
       "schema",
       "policyId",
@@ -2151,30 +2153,30 @@ function validatePolicyShape(input, signed) {
     ],
     "$"
   );
-  expectConst(requiredString2(object, "schema", "$"), POLICY_SCHEMA, "$.schema");
+  expectConst(requiredString2(object2, "schema", "$"), POLICY_SCHEMA, "$.schema");
   if (signed) {
-    requiredString2(object, "policyId", "$");
-    validateSignature(requiredValue2(object, "signature", "$"));
+    requiredString2(object2, "policyId", "$");
+    validateSignature(requiredValue2(object2, "signature", "$"));
   }
-  requiredString2(object, "ownerDid", "$");
-  requiredString2(object, "signingKeyDid", "$");
-  requiredDateString(object, "createdAt", "$");
-  optionalDateString(object, "expiresAt", "$");
-  validatePolicyResource(requiredValue2(object, "resource", "$"), "$.resource");
-  validateExpression(requiredValue2(object, "when", "$"), "$.when");
-  validateGrant(requiredValue2(object, "grant", "$"), "$.grant");
-  if (hasOwn2(object, "disclosure")) {
-    validateDisclosure(requiredValue2(object, "disclosure", "$"), "$.disclosure");
+  requiredString2(object2, "ownerDid", "$");
+  requiredString2(object2, "signingKeyDid", "$");
+  requiredDateString(object2, "createdAt", "$");
+  optionalDateString(object2, "expiresAt", "$");
+  validatePolicyResource(requiredValue2(object2, "resource", "$"), "$.resource");
+  validateExpression(requiredValue2(object2, "when", "$"), "$.when");
+  validateGrant(requiredValue2(object2, "grant", "$"), "$.grant");
+  if (hasOwn2(object2, "disclosure")) {
+    validateDisclosure(requiredValue2(object2, "disclosure", "$"), "$.disclosure");
   }
-  if (hasOwn2(object, "audit")) {
-    validateAudit(requiredValue2(object, "audit", "$"), "$.audit");
+  if (hasOwn2(object2, "audit")) {
+    validateAudit(requiredValue2(object2, "audit", "$"), "$.audit");
   }
-  return object;
+  return object2;
 }
 function validatePolicyStatusShape(input, signed) {
-  const object = expectJsonObject(normalizeJson(input), "$");
+  const object2 = expectJsonObject(normalizeJson(input), "$");
   assertExactKeys2(
-    object,
+    object2,
     signed ? [
       "schema",
       "statusId",
@@ -2198,28 +2200,28 @@ function validatePolicyStatusShape(input, signed) {
     ],
     "$"
   );
-  expectConst(requiredString2(object, "schema", "$"), POLICY_STATUS_SCHEMA, "$.schema");
+  expectConst(requiredString2(object2, "schema", "$"), POLICY_STATUS_SCHEMA, "$.schema");
   if (signed) {
-    requiredString2(object, "statusId", "$");
-    validateSignature(requiredValue2(object, "signature", "$"));
+    requiredString2(object2, "statusId", "$");
+    validateSignature(requiredValue2(object2, "signature", "$"));
   }
-  requiredString2(object, "policyId", "$");
-  requiredString2(object, "ownerDid", "$");
-  requiredInteger(object, "sequence", "$", 0);
-  expectOneOf(requiredString2(object, "disposition", "$"), [
+  requiredString2(object2, "policyId", "$");
+  requiredString2(object2, "ownerDid", "$");
+  requiredInteger(object2, "sequence", "$", 0);
+  expectOneOf(requiredString2(object2, "disposition", "$"), [
     "active",
     "suspended",
     "revoked"
   ], "$.disposition");
-  requiredDateString(object, "effectiveAt", "$");
-  optionalString(object, "reasonCode", "$");
-  requiredString2(object, "signingKeyDid", "$");
-  return object;
+  requiredDateString(object2, "effectiveAt", "$");
+  optionalString(object2, "reasonCode", "$");
+  requiredString2(object2, "signingKeyDid", "$");
+  return object2;
 }
 function validatePolicyEngineRecordShape(input, signed) {
-  const object = expectJsonObject(normalizeJson(input), "$");
+  const object2 = expectJsonObject(normalizeJson(input), "$");
   assertExactKeys2(
-    object,
+    object2,
     signed ? [
       "schema",
       "engineRecordId",
@@ -2244,44 +2246,44 @@ function validatePolicyEngineRecordShape(input, signed) {
     "$"
   );
   expectConst(
-    requiredString2(object, "schema", "$"),
+    requiredString2(object2, "schema", "$"),
     POLICY_ENGINE_RECORD_SCHEMA,
     "$.schema"
   );
   if (signed) {
-    requiredString2(object, "engineRecordId", "$");
-    validateSignature(requiredValue2(object, "signature", "$"));
+    requiredString2(object2, "engineRecordId", "$");
+    validateSignature(requiredValue2(object2, "signature", "$"));
   }
-  requiredString2(object, "ownerDid", "$");
-  requiredString2(object, "endpoint", "$");
-  requiredString2(object, "audience", "$");
+  requiredString2(object2, "ownerDid", "$");
+  requiredString2(object2, "endpoint", "$");
+  requiredString2(object2, "audience", "$");
   requiredStringArray(
-    object,
+    object2,
     "supportedPolicyVersions",
     "$",
     (value, path) => expectConst(value, "v0", path)
   );
-  requiredStringArray(object, "supportedEvidenceVerifiers", "$");
-  requiredString2(object, "grantIssuerDid", "$");
-  requiredDateString(object, "expiresAt", "$");
-  return object;
+  requiredStringArray(object2, "supportedEvidenceVerifiers", "$");
+  requiredString2(object2, "grantIssuerDid", "$");
+  requiredDateString(object2, "expiresAt", "$");
+  return object2;
 }
 function validateSignature(input) {
-  const object = expectJsonObject(input, "$.signature");
-  assertExactKeys2(object, ["suite", "signerDid", "value"], "$.signature");
-  const suite = requiredString2(object, "suite", "$.signature");
+  const object2 = expectJsonObject(input, "$.signature");
+  assertExactKeys2(object2, ["suite", "signerDid", "value"], "$.signature");
+  const suite = requiredString2(object2, "suite", "$.signature");
   assertSupportedSignatureSuite(suite);
-  const signerDid = requiredString2(object, "signerDid", "$.signature");
-  const value = requiredString2(object, "value", "$.signature");
+  const signerDid = requiredString2(object2, "signerDid", "$.signature");
+  const value = requiredString2(object2, "value", "$.signature");
   decodeSignatureValue(value, suite);
   return { suite, signerDid, value };
 }
 function validatePolicyResource(input, path) {
-  const object = expectJsonObject(input, path);
-  assertExactKeys2(object, ["resourceType", "resourceId", "permissionsCeiling"], path);
-  requiredString2(object, "resourceType", path);
-  requiredString2(object, "resourceId", path);
-  const ceiling = requiredArray2(object, "permissionsCeiling", path, 1);
+  const object2 = expectJsonObject(input, path);
+  assertExactKeys2(object2, ["resourceType", "resourceId", "permissionsCeiling"], path);
+  requiredString2(object2, "resourceType", path);
+  requiredString2(object2, "resourceId", path);
+  const ceiling = requiredArray2(object2, "permissionsCeiling", path, 1);
   for (let index = 0; index < ceiling.length; index++) {
     validatePolicyCapability(ceiling[index], `${path}.permissionsCeiling[${index}]`);
   }
@@ -2297,10 +2299,10 @@ function validatePolicyPermissionsCeilingForSigning(input) {
   }
 }
 function validatePolicyCapability(input, path) {
-  const object = expectJsonObject(input, path);
+  const object2 = expectJsonObject(input, path);
   try {
-    const canonical = canonicalizePolicyCapability(object);
-    if (jcsCanonicalize(object) !== jcsCanonicalize(canonical)) {
+    const canonical = canonicalizePolicyCapability(object2);
+    if (jcsCanonicalize(object2) !== jcsCanonicalize(canonical)) {
       throw new SignedObjectSchemaError(`${path} must be canonical PolicyCapability JSON`);
     }
   } catch (error) {
@@ -2313,10 +2315,10 @@ function validatePolicyCapability(input, path) {
   }
 }
 function validatePolicyCapabilityForSigning(input, path) {
-  const object = expectJsonObject(input, path);
+  const object2 = expectJsonObject(input, path);
   try {
-    const canonical = normalizePolicyCapability(object);
-    if (jcsCanonicalize(object) !== jcsCanonicalize(canonical)) {
+    const canonical = normalizePolicyCapability(object2);
+    if (jcsCanonicalize(object2) !== jcsCanonicalize(canonical)) {
       throw new SignedObjectSchemaError(`${path} must be strict canonical PolicyCapability JSON`);
     }
   } catch (error) {
@@ -2329,43 +2331,43 @@ function validatePolicyCapabilityForSigning(input, path) {
   }
 }
 function validateExpression(input, path) {
-  const object = expectJsonObject(input, path);
-  const keys = Object.keys(object);
+  const object2 = expectJsonObject(input, path);
+  const keys = Object.keys(object2);
   if (keys.length !== 1) {
     throw new SignedObjectSchemaError(`${path} must have exactly one expression key`);
   }
   const key = keys[0];
   if (key === "allOf" || key === "anyOf") {
-    const values = requiredArray2(object, key, path, 1);
+    const values = requiredArray2(object2, key, path, 1);
     for (let index = 0; index < values.length; index++) {
       validateExpression(values[index], `${path}.${key}[${index}]`);
     }
     return;
   }
   if (key === "subject") {
-    const subject = expectJsonObject(requiredValue2(object, "subject", path), `${path}.subject`);
+    const subject = expectJsonObject(requiredValue2(object2, "subject", path), `${path}.subject`);
     assertExactKeys2(subject, ["did"], `${path}.subject`);
     requiredString2(subject, "did", `${path}.subject`);
     return;
   }
   if (key === "evidence") {
-    validateEvidenceRequirement(requiredValue2(object, "evidence", path), `${path}.evidence`);
+    validateEvidenceRequirement(requiredValue2(object2, "evidence", path), `${path}.evidence`);
     return;
   }
   throw new SignedObjectSchemaError(`${path} has unknown expression key ${key}`);
 }
 function validateEvidenceRequirement(input, path) {
-  const object = expectJsonObject(input, path);
+  const object2 = expectJsonObject(input, path);
   assertExactKeys2(
-    object,
+    object2,
     ["requirementId", "verifier", "requirements", "authority", "freshness"],
     path
   );
-  requiredString2(object, "requirementId", path);
-  requiredString2(object, "verifier", path);
-  requiredValue2(object, "requirements", path);
-  if (hasOwn2(object, "authority")) {
-    const authority = expectJsonObject(requiredValue2(object, "authority", path), `${path}.authority`);
+  requiredString2(object2, "requirementId", path);
+  requiredString2(object2, "verifier", path);
+  requiredValue2(object2, "requirements", path);
+  if (hasOwn2(object2, "authority")) {
+    const authority = expectJsonObject(requiredValue2(object2, "authority", path), `${path}.authority`);
     assertExactKeys2(
       authority,
       ["profile", "acceptedIssuers", "allowOwnerAuthorizedIssuer"],
@@ -2377,35 +2379,35 @@ function validateEvidenceRequirement(input, path) {
     }
     optionalBoolean(authority, "allowOwnerAuthorizedIssuer", `${path}.authority`);
   }
-  if (hasOwn2(object, "freshness")) {
-    const freshness = expectJsonObject(requiredValue2(object, "freshness", path), `${path}.freshness`);
+  if (hasOwn2(object2, "freshness")) {
+    const freshness = expectJsonObject(requiredValue2(object2, "freshness", path), `${path}.freshness`);
     assertExactKeys2(freshness, ["maxStatusAgeSeconds"], `${path}.freshness`);
     requiredInteger(freshness, "maxStatusAgeSeconds", `${path}.freshness`, 0);
   }
 }
 function validateGrant(input, path) {
-  const object = expectJsonObject(input, path);
-  assertExactKeys2(object, ["output", "maxTtlSeconds", "delegationMode", "revocation"], path);
-  expectConst(requiredString2(object, "output", path), "portable-delegation", `${path}.output`);
-  requiredInteger(object, "maxTtlSeconds", path, 1);
-  expectOneOf(requiredString2(object, "delegationMode", path), [
+  const object2 = expectJsonObject(input, path);
+  assertExactKeys2(object2, ["output", "maxTtlSeconds", "delegationMode", "revocation"], path);
+  expectConst(requiredString2(object2, "output", path), "portable-delegation", `${path}.output`);
+  requiredInteger(object2, "maxTtlSeconds", path, 1);
+  expectOneOf(requiredString2(object2, "delegationMode", path), [
     "terminal",
     "attenuable"
   ], `${path}.delegationMode`);
-  expectOneOf(requiredString2(object, "revocation", path), [
+  expectOneOf(requiredString2(object2, "revocation", path), [
     "refresh_only",
     "active_cutoff"
   ], `${path}.revocation`);
 }
 function validateDisclosure(input, path) {
-  const object = expectJsonObject(input, path);
-  assertExactKeys2(object, ["denial"], path);
-  expectOneOf(requiredString2(object, "denial", path), ["none", "code", "debug"], `${path}.denial`);
+  const object2 = expectJsonObject(input, path);
+  assertExactKeys2(object2, ["denial"], path);
+  expectOneOf(requiredString2(object2, "denial", path), ["none", "code", "debug"], `${path}.denial`);
 }
 function validateAudit(input, path) {
-  const object = expectJsonObject(input, path);
-  assertExactKeys2(object, ["issuance"], path);
-  expectOneOf(requiredString2(object, "issuance", path), ["off", "security", "full"], `${path}.issuance`);
+  const object2 = expectJsonObject(input, path);
+  assertExactKeys2(object2, ["issuance"], path);
+  expectOneOf(requiredString2(object2, "issuance", path), ["off", "security", "full"], `${path}.issuance`);
 }
 function materialForUnsigned(unsigned, descriptor) {
   const jcs = jcsCanonicalize(unsigned);
@@ -2554,9 +2556,9 @@ function encodeSignatureValue(value, suite) {
   decodeSignatureValue(encoded, suite);
   return encoded;
 }
-function stripOwnIdAndSignature(object, descriptor) {
+function stripOwnIdAndSignature(object2, descriptor) {
   const output = /* @__PURE__ */ Object.create(null);
-  for (const [key, value] of Object.entries(object)) {
+  for (const [key, value] of Object.entries(object2)) {
     if (key === descriptor.idField || key === "signature") {
       continue;
     }
@@ -2565,8 +2567,8 @@ function stripOwnIdAndSignature(object, descriptor) {
   return output;
 }
 function descriptorForUnsigned(input) {
-  const object = expectJsonObject(normalizeJson(input), "$");
-  return descriptorForSchema(requiredString2(object, "schema", "$"));
+  const object2 = expectJsonObject(normalizeJson(input), "$");
+  return descriptorForSchema(requiredString2(object2, "schema", "$"));
 }
 function descriptorForSchema(schema) {
   if (schema === POLICY_SCHEMA) return DESCRIPTORS.Policy;
@@ -2580,28 +2582,28 @@ function expectJsonObject(input, path) {
   }
   return input;
 }
-function assertExactKeys2(object, allowed, path) {
+function assertExactKeys2(object2, allowed, path) {
   const allowedSet = new Set(allowed);
-  for (const key of Object.keys(object)) {
+  for (const key of Object.keys(object2)) {
     if (!allowedSet.has(key)) {
       throw new SignedObjectSchemaError(`${path} has unknown field ${key}`);
     }
   }
 }
-function requiredValue2(object, key, path) {
-  if (!hasOwn2(object, key)) {
+function requiredValue2(object2, key, path) {
+  if (!hasOwn2(object2, key)) {
     throw new SignedObjectSchemaError(`${path}.${key} is required`);
   }
-  return object[key];
+  return object2[key];
 }
-function requiredString2(object, key, path) {
-  return requireStringType(requiredValue2(object, key, path), `${path}.${key}`);
+function requiredString2(object2, key, path) {
+  return requireStringType(requiredValue2(object2, key, path), `${path}.${key}`);
 }
-function optionalString(object, key, path) {
-  if (!hasOwn2(object, key)) {
+function optionalString(object2, key, path) {
+  if (!hasOwn2(object2, key)) {
     return;
   }
-  requireStringType(requiredValue2(object, key, path), `${path}.${key}`);
+  requireStringType(requiredValue2(object2, key, path), `${path}.${key}`);
 }
 function requireStringType(value, path) {
   if (typeof value !== "string" || value.length === 0) {
@@ -2609,16 +2611,16 @@ function requireStringType(value, path) {
   }
   return value;
 }
-function optionalBoolean(object, key, path) {
-  if (!hasOwn2(object, key)) {
+function optionalBoolean(object2, key, path) {
+  if (!hasOwn2(object2, key)) {
     return;
   }
-  if (typeof requiredValue2(object, key, path) !== "boolean") {
+  if (typeof requiredValue2(object2, key, path) !== "boolean") {
     throw new SignedObjectSchemaError(`${path}.${key} must be a boolean`);
   }
 }
-function requiredInteger(object, key, path, minimum) {
-  const value = requiredValue2(object, key, path);
+function requiredInteger(object2, key, path, minimum) {
+  const value = requiredValue2(object2, key, path);
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum) {
     throw new SignedObjectSchemaError(
       `${path}.${key} must be an integer >= ${minimum}`
@@ -2626,8 +2628,8 @@ function requiredInteger(object, key, path, minimum) {
   }
   return value;
 }
-function requiredArray2(object, key, path, minimum) {
-  const value = requiredValue2(object, key, path);
+function requiredArray2(object2, key, path, minimum) {
+  const value = requiredValue2(object2, key, path);
   if (!Array.isArray(value) || value.length < minimum) {
     throw new SignedObjectSchemaError(
       `${path}.${key} must be an array with at least ${minimum} item(s)`
@@ -2635,22 +2637,22 @@ function requiredArray2(object, key, path, minimum) {
   }
   return value;
 }
-function requiredStringArray(object, key, path, check) {
-  const values = requiredArray2(object, key, path, 0);
+function requiredStringArray(object2, key, path, check) {
+  const values = requiredArray2(object2, key, path, 0);
   for (let index = 0; index < values.length; index++) {
     const itemPath = `${path}.${key}[${index}]`;
     const value = requireStringType(values[index], itemPath);
     check?.(value, itemPath);
   }
 }
-function requiredDateString(object, key, path) {
-  assertRfc3339(requiredString2(object, key, path), `${path}.${key}`);
+function requiredDateString(object2, key, path) {
+  assertRfc3339(requiredString2(object2, key, path), `${path}.${key}`);
 }
-function optionalDateString(object, key, path) {
-  if (!hasOwn2(object, key)) {
+function optionalDateString(object2, key, path) {
+  if (!hasOwn2(object2, key)) {
     return;
   }
-  assertRfc3339(requiredString2(object, key, path), `${path}.${key}`);
+  assertRfc3339(requiredString2(object2, key, path), `${path}.${key}`);
 }
 function assertRfc3339(value, path) {
   const match = value.match(
@@ -2682,8 +2684,8 @@ function expectOneOf(actual, allowed, path) {
   }
   throw new SignedObjectSchemaError(`${path} has unsupported value ${actual}`);
 }
-function hasOwn2(object, key) {
-  return objectHasOwn3(object, key);
+function hasOwn2(object2, key) {
+  return objectHasOwn3(object2, key);
 }
 function assertSupportedSignatureSuite(suite) {
   if (suite !== ED25519_JCS_SIGNATURE_SUITE && suite !== EIP191_JCS_SIGNATURE_SUITE) {
@@ -2762,13 +2764,13 @@ function base64UrlDecode(value) {
   return decoded;
 }
 function hexToBytes(value) {
-  const hex = value.slice(2);
-  if (hex.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(hex)) {
+  const hex2 = value.slice(2);
+  if (hex2.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(hex2)) {
     throw new SignatureMaterialError("hex signature must have even length");
   }
-  const output = new Uint8Array(hex.length / 2);
+  const output = new Uint8Array(hex2.length / 2);
   for (let index = 0; index < output.length; index++) {
-    output[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+    output[index] = Number.parseInt(hex2.slice(index * 2, index * 2 + 2), 16);
   }
   return output;
 }
@@ -2910,9 +2912,9 @@ function expectObject2(input, path, code3) {
     );
   }
 }
-function assertExactKeys3(object, allowed, path) {
+function assertExactKeys3(object2, allowed, path) {
   const allowedSet = new Set(allowed);
-  for (const key of Object.keys(object)) {
+  for (const key of Object.keys(object2)) {
     if (!allowedSet.has(key)) {
       throw new PolicyAuthoringError(
         "policy-authoring-unknown-key",
@@ -2921,17 +2923,17 @@ function assertExactKeys3(object, allowed, path) {
     }
   }
 }
-function requiredValue3(object, key, path) {
-  if (!hasOwn3(object, key)) {
+function requiredValue3(object2, key, path) {
+  if (!hasOwn3(object2, key)) {
     throw new PolicyAuthoringError(
       "policy-authoring-malformed",
       `${path}.${key} is required`
     );
   }
-  return object[key];
+  return object2[key];
 }
-function requiredString3(object, key, path) {
-  const value = requiredValue3(object, key, path);
+function requiredString3(object2, key, path) {
+  const value = requiredValue3(object2, key, path);
   if (typeof value !== "string" || value.length === 0) {
     throw new PolicyAuthoringError(
       "policy-authoring-malformed",
@@ -2940,11 +2942,11 @@ function requiredString3(object, key, path) {
   }
   return value;
 }
-function fieldString(object, key, path, code3) {
-  if (!hasOwn3(object, key)) {
+function fieldString(object2, key, path, code3) {
+  if (!hasOwn3(object2, key)) {
     throw new PolicyAuthoringError(code3, `${path}.${key} is required`);
   }
-  const value = object[key];
+  const value = object2[key];
   if (typeof value !== "string" || value.length === 0) {
     throw new PolicyAuthoringError(
       code3,
@@ -2982,8 +2984,609 @@ function parseStrictRfc3339(value, path) {
 var objectHasOwn4 = Object.hasOwn ?? Object.prototype.hasOwnProperty.call.bind(
   Object.prototype.hasOwnProperty
 );
-function hasOwn3(object, key) {
-  return objectHasOwn4(object, key);
+function hasOwn3(object2, key) {
+  return objectHasOwn4(object2, key);
+}
+
+// src/policy/unified.ts
+import { sha256 as sha2564 } from "@noble/hashes/sha256";
+import { blake3 } from "@noble/hashes/blake3";
+import { ed25519 as ed255192 } from "@noble/curves/ed25519";
+import { z as z2 } from "zod";
+var POLICY_V1_SCHEMA = "xyz.tinycloud.policy/policy/v1";
+var POLICY_CAPABILITY_V1_SCHEMA = "xyz.tinycloud.policy/capability/v1";
+var POLICY_ENFORCEMENT_DELEGATION_V2_SCHEMA = "xyz.tinycloud.policy/enforcement-delegation/v2";
+var ATTESTED_ENFORCER_BINDING_V2_SCHEMA = "xyz.tinycloud.policy/attested-enforcer/v2";
+var ROOT_STATUS_CHECKPOINT_V1_SCHEMA = "xyz.tinycloud.policy/root-status/v1";
+var ROOT_REVOCATION_V1_SCHEMA = "xyz.tinycloud.policy/root-revocation/v1";
+var POLICY_SESSION_UCAN_V1_PROFILE = "policy-session-ucan/v1";
+var POLICY_V1_DOMAIN = "xyz.tinycloud.policy/policy/v1\0";
+var POLICY_CAPABILITY_V1_DOMAIN = "xyz.tinycloud.policy/PolicyCapability/v1\0";
+var CONTENT_SOURCE_V1_DOMAIN = "xyz.tinycloud.policy/ContentSource/v1\0";
+var NATIVE_PROJECTION_V1_DOMAIN = "xyz.tinycloud.policy/NativeProjection/v1\0";
+var ROOT_STATUS_V1_DOMAIN = "xyz.tinycloud.policy/RootStatusCheckpoint/v1\0";
+var ROOT_STATUS_RENEWAL_V1_DOMAIN = "xyz.tinycloud.policy/RootStatusRenewal/v1\0";
+var ROOT_REVOCATION_V1_DOMAIN = "xyz.tinycloud.policy/RootRevocation/v1\0";
+var LAST_V2_CREATE_AT = "2026-09-30T00:00:00Z";
+var MAX_LEGACY_ENVELOPE_EXPIRES_AT = "2026-12-29T00:00:00Z";
+var LAST_V2_READ_AT = "2027-01-05T00:00:00Z";
+function verifyPolicyRootStatusCheckpointV3(input) {
+  const checkpoint = input.checkpoint;
+  const allowed = /* @__PURE__ */ new Set(["schema", "targetCid", "targetRole", "ownerDid", "nodeAudience", "state", "sequence", "checkedAt", "freshUntil", "revokedAt", "revocationCid", "previousCheckpointDigestHex", "issuerDid", "signature"]);
+  if (Object.keys(checkpoint).some((key) => !allowed.has(key)) || checkpoint.schema !== ROOT_STATUS_CHECKPOINT_V1_SCHEMA || checkpoint.targetCid !== input.rootCid || checkpoint.targetRole !== "policy-authority" && checkpoint.targetRole !== "policy-enforcement" || checkpoint.state !== "active" && checkpoint.state !== "revoked" || typeof checkpoint.ownerDid !== "string" || typeof checkpoint.nodeAudience !== "string" || checkpoint.issuerDid !== checkpoint.nodeAudience || input.expectedNodeAudience !== void 0 && checkpoint.nodeAudience !== input.expectedNodeAudience || !Number.isInteger(checkpoint.sequence) || checkpoint.sequence < 1 || typeof checkpoint.checkedAt !== "string" || typeof checkpoint.freshUntil !== "string") return false;
+  const checkedAt = Date.parse(checkpoint.checkedAt);
+  const freshUntil = Date.parse(checkpoint.freshUntil);
+  const now = (input.now ?? /* @__PURE__ */ new Date()).getTime();
+  if (!Number.isFinite(checkedAt) || !Number.isFinite(freshUntil) || freshUntil < now || freshUntil <= checkedAt || freshUntil - checkedAt > 3e5) return false;
+  if (checkpoint.sequence === 1 !== (checkpoint.previousCheckpointDigestHex === void 0)) return false;
+  if (checkpoint.sequence !== 1 && (typeof checkpoint.previousCheckpointDigestHex !== "string" || !/^[0-9a-f]{64}$/.test(checkpoint.previousCheckpointDigestHex))) return false;
+  if (checkpoint.state === "active" && (checkpoint.revokedAt !== void 0 || checkpoint.revocationCid !== void 0)) return false;
+  if (checkpoint.state === "revoked" && (typeof checkpoint.revokedAt !== "string" || typeof checkpoint.revocationCid !== "string")) return false;
+  const signature = checkpoint.signature;
+  if (!isRecordValue(signature) || Object.keys(signature).length !== 3 || signature.suite !== "Ed25519" || signature.signerDid !== checkpoint.issuerDid || typeof signature.value !== "string") return false;
+  try {
+    const principal = checkpoint.issuerDid.split("#", 1)[0];
+    const didMaterial = principal.startsWith("did:key:") ? base58btc.decode(principal.slice("did:key:".length)) : new Uint8Array();
+    if (didMaterial.length !== 34 || didMaterial[0] !== 237 || didMaterial[1] !== 1) return false;
+    const unsigned = { ...checkpoint };
+    delete unsigned.signature;
+    return ed255192.verify(
+      decodeBase64Url(signature.value),
+      sha2564(new TextEncoder().encode(ROOT_STATUS_V1_DOMAIN + jcsCanonicalize(unsigned))),
+      didMaterial.slice(2)
+    );
+  } catch {
+    return false;
+  }
+}
+async function getPolicyRootStatusV3(input) {
+  const fetchFn = input.fetch ?? globalThis.fetch.bind(globalThis);
+  const response = await fetchFn(new URL(`/share/v3/policy/status/${encodeURIComponent(input.rootCid)}`, input.nodeOrigin), {
+    method: "GET",
+    redirect: "error",
+    headers: { accept: "application/json" }
+  });
+  if (!response.ok) throw new Error(`policy root status rejected (${response.status})`);
+  const value = object(await response.json(), "policy root status");
+  const checkpoint = object(value.checkpoint, "policy root checkpoint");
+  if (value.rootCid !== input.rootCid || value.state !== "active" && value.state !== "revoked" || value.state !== checkpoint.state || !verifyPolicyRootStatusCheckpointV3({ rootCid: input.rootCid, checkpoint, expectedNodeAudience: input.expectedNodeAudience, now: input.now }))
+    throw new Error("policy root status binding is invalid");
+  const revocation = value.revocation === void 0 ? void 0 : object(value.revocation, "policy root revocation");
+  if (value.state === "revoked" !== (revocation !== void 0) || revocation !== void 0 && !verifyPolicyRootRevocationV3({
+    rootCid: input.rootCid,
+    checkpoint,
+    revocation,
+    expectedEnforcerDid: input.expectedEnforcerDid
+  })) throw new Error("policy root status revocation evidence is invalid");
+  return { rootCid: input.rootCid, state: value.state, checkpoint, ...revocation === void 0 ? {} : { revocation } };
+}
+function verifyPolicyRootRevocationV3(input) {
+  const value = input.revocation;
+  const allowed = ["schema", "targetCid", "targetRole", "ownerDid", "nodeAudience", "revokedAt", "reason", "issuerDid", "signature"];
+  if (Object.keys(value).length !== allowed.length || Object.keys(value).some((key) => !allowed.includes(key)) || value.schema !== ROOT_REVOCATION_V1_SCHEMA || value.targetCid !== input.rootCid || value.targetRole !== input.checkpoint.targetRole || value.ownerDid !== input.checkpoint.ownerDid || value.nodeAudience !== input.checkpoint.nodeAudience || value.revokedAt !== input.checkpoint.revokedAt || typeof value.reason !== "string" || value.reason.length === 0 || typeof value.issuerDid !== "string") return false;
+  const authorized = value.issuerDid === value.ownerDid || value.targetRole === "policy-enforcement" && value.issuerDid === input.expectedEnforcerDid;
+  if (!authorized) return false;
+  const signature = value.signature;
+  if (!isRecordValue(signature) || Object.keys(signature).length !== 3 || signature.suite !== "Ed25519" || signature.signerDid !== value.issuerDid || typeof signature.value !== "string") return false;
+  try {
+    const principal = value.issuerDid.split("#", 1)[0];
+    const didMaterial = principal.startsWith("did:key:") ? base58btc.decode(principal.slice("did:key:".length)) : new Uint8Array();
+    if (didMaterial.length !== 34 || didMaterial[0] !== 237 || didMaterial[1] !== 1) return false;
+    const unsigned = { ...value };
+    delete unsigned.signature;
+    const digest4 = sha2564(new TextEncoder().encode(ROOT_REVOCATION_V1_DOMAIN + jcsCanonicalize(unsigned)));
+    return input.checkpoint.revocationCid === hex(digest4) && ed255192.verify(decodeBase64Url(signature.value), digest4, didMaterial.slice(2));
+  } catch {
+    return false;
+  }
+}
+async function renewPolicyRootStatusV3(input) {
+  const fetchFn = input.fetch ?? globalThis.fetch.bind(globalThis);
+  const current = await getPolicyRootStatusV3({ nodeOrigin: input.nodeOrigin, rootCid: input.rootCid, expectedNodeAudience: input.nodeAudience, now: input.now, fetch: fetchFn });
+  if (current.state !== "active" || current.checkpoint.ownerDid !== input.ownerDid || current.checkpoint.nodeAudience !== input.nodeAudience || current.checkpoint.state !== "active" || !Number.isInteger(current.checkpoint.sequence))
+    throw new Error("policy root status cannot be renewed");
+  const currentUnsigned = { ...current.checkpoint };
+  delete currentUnsigned.signature;
+  const previousCheckpointDigestHex = hex(sha2564(new TextEncoder().encode(ROOT_STATUS_V1_DOMAIN + jcsCanonicalize(currentUnsigned))));
+  const unsigned = {
+    schema: "xyz.tinycloud.policy/root-status-renewal/v1",
+    targetCid: input.rootCid,
+    ownerDid: input.ownerDid,
+    nodeAudience: input.nodeAudience,
+    issuedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    nonce: input.nonce ?? encodeBase64Url(crypto.getRandomValues(new Uint8Array(16))),
+    sequence: current.checkpoint.sequence + 1,
+    previousCheckpointDigestHex
+  };
+  const signature = await input.sign(sha2564(new TextEncoder().encode(ROOT_STATUS_RENEWAL_V1_DOMAIN + jcsCanonicalize(unsigned))));
+  if (signature.length !== 64) throw new Error("policy root renewal signature must be Ed25519");
+  const response = await fetchFn(new URL("/share/v3/policy/status", input.nodeOrigin), {
+    method: "POST",
+    redirect: "error",
+    headers: { accept: "application/json", "content-type": "application/json" },
+    body: JSON.stringify({ rootCid: input.rootCid, renewal: { ...unsigned, signature: { suite: "Ed25519", signerDid: input.ownerDid, value: encodeBase64Url(signature) } } })
+  });
+  if (!response.ok) throw new Error(`policy root renewal rejected (${response.status})`);
+  return object(await response.json(), "policy root renewal");
+}
+async function revokePolicyRootV3(input) {
+  if (input.reason.length === 0) throw new Error("policy root revocation reason is required");
+  const unsigned = {
+    schema: ROOT_REVOCATION_V1_SCHEMA,
+    targetCid: input.rootCid,
+    targetRole: input.targetRole,
+    ownerDid: input.ownerDid,
+    nodeAudience: input.nodeAudience,
+    revokedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    reason: input.reason,
+    issuerDid: input.issuerDid
+  };
+  const signature = await input.sign(sha2564(new TextEncoder().encode(ROOT_REVOCATION_V1_DOMAIN + jcsCanonicalize(unsigned))));
+  if (signature.length !== 64) throw new Error("policy root revocation signature must be Ed25519");
+  const fetchFn = input.fetch ?? globalThis.fetch.bind(globalThis);
+  const response = await fetchFn(new URL("/revoke", input.nodeOrigin), {
+    method: "POST",
+    redirect: "error",
+    headers: { accept: "application/json", "content-type": "application/json" },
+    body: JSON.stringify({ revocation: { ...unsigned, signature: { suite: "Ed25519", signerDid: input.issuerDid, value: encodeBase64Url(signature) } } })
+  });
+  if (!response.ok) throw new Error(`policy root revocation rejected (${response.status})`);
+  return object(await response.json(), "policy root revocation");
+}
+var POLICY_SESSION_FACT_KEYS = [
+  "profile",
+  "ownerDid",
+  "policyId",
+  "policyDigestHex",
+  "policyCid",
+  "policyDelegationCid",
+  "enforcementDelegationCid",
+  "contentSourceDigestHex",
+  "capabilityCeilingHashHex",
+  "nativeProjectionHashHex",
+  "enforcerDid",
+  "nodeAudience",
+  "recipientDid",
+  "challengeId",
+  "claimDigestHex",
+  "claimJti",
+  "vpDigestHex",
+  "credentialEvidenceDigestHex",
+  "decisionContextDigestHex",
+  "issuanceAuditDigestHex",
+  "remainingRedelegationDepth"
+];
+var KV_ACTIONS = /* @__PURE__ */ new Set([
+  "tinycloud.kv/get",
+  "tinycloud.kv/list",
+  "tinycloud.kv/metadata",
+  "tinycloud.kv/put"
+]);
+function object(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function exactKeys(value, allowed, label) {
+  const keys = new Set(allowed);
+  if (Object.keys(value).some((key) => !keys.has(key)))
+    throw new Error(`${label} contains an unknown field`);
+}
+function nonEmptyString(value, label) {
+  if (typeof value !== "string" || value.length === 0)
+    throw new Error(`${label} must be a non-empty string`);
+  return value;
+}
+function parseKvResource(resource) {
+  const match = /^tinycloud:\/\/([^/]+)\/kv\/(.+)$/.exec(resource);
+  if (!match || match[1].includes(":") || match[1].includes("?") || match[1].includes("#") || match[1].includes("%") || match[2].startsWith("/") || match[2].endsWith("/") || match[2].includes("//") || match[2].split("/").some((part) => part === "." || part === ".." || part.length === 0)) {
+    throw new Error("KV resource is not canonical");
+  }
+  return { space: match[1], path: match[2] };
+}
+function parseEncryptionResource(resource) {
+  if (!resource.startsWith("urn:tinycloud:encryption:")) throw new Error("encryption capability is invalid");
+  const rest = resource.slice("urn:tinycloud:encryption:".length);
+  const separator = rest.lastIndexOf(":");
+  const ownerDid = separator < 0 ? "" : rest.slice(0, separator);
+  const network = separator < 0 ? "" : rest.slice(separator + 1);
+  if (!ownerDid.startsWith("did:") || network.length === 0 || network.includes(":") || network.includes("/") || network.includes("%") || network.includes("?") || network.includes("#")) {
+    throw new Error("encryption capability is invalid");
+  }
+}
+function normalizeUnifiedPolicyCapability(input) {
+  const value = object(input, "capability");
+  const kind = nonEmptyString(value.kind, "capability.kind");
+  if (kind === "kv") {
+    exactKeys(
+      value,
+      ["kind", "resource", "selector", "actions"],
+      "KV capability"
+    );
+    const resource = nonEmptyString(value.resource, "capability.resource");
+    parseKvResource(resource);
+    if (value.selector !== "exact" && value.selector !== "prefix")
+      throw new Error("capability.selector is invalid");
+    if (!Array.isArray(value.actions) || value.actions.length === 0)
+      throw new Error("capability.actions is invalid");
+    const actions = value.actions.map(
+      (action) => nonEmptyString(action, "capability.actions[]")
+    );
+    if (new Set(actions).size !== actions.length || actions.some((action) => !KV_ACTIONS.has(action)))
+      throw new Error("capability.actions is invalid");
+    return {
+      kind: "kv",
+      resource,
+      selector: value.selector,
+      actions: [...actions].sort()
+    };
+  }
+  if (kind === "encryption") {
+    exactKeys(value, ["kind", "resource", "action"], "encryption capability");
+    const resource = nonEmptyString(value.resource, "capability.resource");
+    if (value.action !== "tinycloud.encryption/decrypt")
+      throw new Error("encryption capability is invalid");
+    parseEncryptionResource(resource);
+    return {
+      kind: "encryption",
+      resource,
+      action: "tinycloud.encryption/decrypt"
+    };
+  }
+  throw new Error("capability.kind is invalid");
+}
+function canonicalizeUnifiedPolicyCapability(input) {
+  return normalizeUnifiedPolicyCapability(input);
+}
+function unifiedPolicyCapabilityDigestHex(input) {
+  return hex(
+    sha2564(
+      new TextEncoder().encode(
+        POLICY_CAPABILITY_V1_DOMAIN + jcsCanonicalize(normalizeUnifiedPolicyCapability(input))
+      )
+    )
+  );
+}
+function unifiedPolicyCapabilityContains(authorityInput, requestedInput) {
+  try {
+    const authority = normalizeUnifiedPolicyCapability(authorityInput);
+    const requested = normalizeUnifiedPolicyCapability(requestedInput);
+    if (authority.kind !== requested.kind) return false;
+    if (authority.kind === "encryption" && requested.kind === "encryption")
+      return authority.resource === requested.resource && authority.action === requested.action;
+    if (authority.kind !== "kv" || requested.kind !== "kv") return false;
+    const { resource: authorized } = authority;
+    const { resource: requestedResource } = requested;
+    const pathContained = authority.selector === "exact" ? authorized === requestedResource : authorized === requestedResource || requestedResource.startsWith(`${authorized}/`);
+    if (!pathContained || authority.selector === "exact" && requested.selector === "prefix")
+      return false;
+    return requested.actions.every(
+      (action) => authority.actions.includes(action)
+    );
+  } catch {
+    return false;
+  }
+}
+function projectUnifiedPolicyCapability(input) {
+  const capability = normalizeUnifiedPolicyCapability(input);
+  if (capability.kind === "encryption") {
+    return {
+      service: "tinycloud.encryption",
+      space: capability.resource,
+      path: capability.resource,
+      actions: [capability.action]
+    };
+  }
+  const { space, path } = parseKvResource(capability.resource);
+  return {
+    service: "tinycloud.kv",
+    space,
+    path,
+    actions: [...capability.actions],
+    caveat: {
+      type: "xyz.tinycloud.resource/selector",
+      kind: capability.selector,
+      value: capability.resource
+    }
+  };
+}
+function projectUnifiedPolicyCapabilities(input) {
+  return input.map(projectUnifiedPolicyCapability).sort((left, right) => {
+    const a = jcsCanonicalize(left);
+    const b = jcsCanonicalize(right);
+    return a < b ? -1 : a > b ? 1 : 0;
+  });
+}
+function unifiedNativeProjectionHashHex(input) {
+  return hex(
+    sha2564(
+      new TextEncoder().encode(
+        NATIVE_PROJECTION_V1_DOMAIN + jcsCanonicalize(projectUnifiedPolicyCapabilities(input))
+      )
+    )
+  );
+}
+function unifiedPolicyCapabilityFromNative(input) {
+  const value = object(input, "native capability");
+  exactKeys(
+    value,
+    ["service", "space", "path", "actions", "caveat"],
+    "native capability"
+  );
+  const service = nonEmptyString(value.service, "native.service");
+  const actions = value.actions;
+  if (!Array.isArray(actions)) throw new Error("native.actions is invalid");
+  if (service === "tinycloud.encryption" && value.caveat === void 0 && value.space === value.path && actions.length === 1 && actions[0] === "tinycloud.encryption/decrypt") {
+    return normalizeUnifiedPolicyCapability({
+      kind: "encryption",
+      resource: value.space,
+      action: actions[0]
+    });
+  }
+  if (service !== "tinycloud.kv" || typeof value.space !== "string" || typeof value.path !== "string")
+    throw new Error("native capability is not supported");
+  const caveat = object(value.caveat, "native.caveat");
+  exactKeys(caveat, ["type", "kind", "value"], "native selector caveat");
+  if (caveat.type !== "xyz.tinycloud.resource/selector" || caveat.kind !== "exact" && caveat.kind !== "prefix" || caveat.value !== `tinycloud://${value.space}/kv/${value.path}`)
+    throw new Error("native selector caveat does not match capability");
+  return normalizeUnifiedPolicyCapability({
+    kind: "kv",
+    resource: caveat.value,
+    selector: caveat.kind,
+    actions
+  });
+}
+function contentSourceDigestHex(input) {
+  return hex(
+    sha2564(
+      new TextEncoder().encode(
+        CONTENT_SOURCE_V1_DOMAIN + jcsCanonicalize(input)
+      )
+    )
+  );
+}
+function policyDigestHex(policy) {
+  const canonicalPolicy = {
+    ...policy,
+    capabilityCeiling: policy.capabilityCeiling.map(
+      normalizeUnifiedPolicyCapability
+    )
+  };
+  return hex(
+    sha2564(
+      new TextEncoder().encode(
+        POLICY_V1_DOMAIN + jcsCanonicalize(canonicalPolicy)
+      )
+    )
+  );
+}
+function policyIdForDigestHex(digestHex) {
+  const digest4 = Uint8Array.from(
+    (digestHex.match(/.{2}/g) ?? []).map((byte) => Number.parseInt(byte, 16))
+  );
+  if (digest4.length !== 32) throw new Error("policy digest must be 32 bytes");
+  return `pol_${base32Lower(digest4)}`;
+}
+function policyCidFromCanonicalBytes(bytes2) {
+  return CID.createV1(85, create(18, sha2564(bytes2))).toString();
+}
+var CompactHeaderSchema = z2.object({
+  alg: z2.literal("EdDSA"),
+  jwk: z2.object({ alg: z2.literal("EdDSA"), crv: z2.literal("Ed25519"), kty: z2.literal("OKP"), x: z2.string().min(1) }).strict(),
+  typ: z2.literal("JWT"),
+  ucv: z2.literal("0.10.0")
+}).strict();
+var CompactPayloadSchema = z2.object({
+  att: z2.record(z2.record(z2.array(z2.unknown()).min(1))),
+  aud: z2.string().min(1),
+  exp: z2.number().int(),
+  fct: z2.array(z2.record(z2.unknown())).length(1),
+  iss: z2.string().min(1),
+  nbf: z2.number().int(),
+  nnc: z2.string().min(1),
+  prf: z2.array(z2.string().min(1))
+}).strict();
+async function signCompactUcanAuthorization(input) {
+  if (input.notBefore >= input.expiresAt || input.expiresAt - input.notBefore > 60)
+    throw new Error("compact invocation lifetime must be between one and 60 seconds");
+  const principal = input.issuerDid.split("#", 1)[0];
+  const didMaterial = principal.startsWith("did:key:") ? base58btc.decode(principal.slice("did:key:".length)) : new Uint8Array();
+  if (didMaterial.length !== 34 || didMaterial[0] !== 237 || didMaterial[1] !== 1)
+    throw new Error("compact UCAN signer must be did:key Ed25519");
+  const header = { alg: "EdDSA", jwk: { alg: "EdDSA", crv: "Ed25519", kty: "OKP", x: encodeBase64Url(didMaterial.slice(2)) }, 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(jcsCanonicalize(header)));
+  const payloadSegment = encodeBase64Url(new TextEncoder().encode(jcsCanonicalize(payload)));
+  const signature = await input.sign(new TextEncoder().encode(`${protectedSegment}.${payloadSegment}`));
+  if (signature.length !== 64) throw new Error("compact Authorization signature must be Ed25519");
+  return parseCompactUcanAuthorization(`${protectedSegment}.${payloadSegment}.${encodeBase64Url(signature)}`);
+}
+function createCompactPolicyInvocation(input) {
+  const session = parsePolicySessionUcan(input.sessionAuthorization);
+  if (session.cid !== input.sessionCid || session.aud !== input.recipientDid)
+    throw new Error("policy session does not bind the recipient signer");
+  const principal = input.recipientDid.split("#", 1)[0];
+  const didMaterial = base58btc.decode(principal.slice("did:key:".length));
+  if (didMaterial.length !== 34 || didMaterial[0] !== 237 || didMaterial[1] !== 1)
+    throw new Error("policy invocation signer must be did:key Ed25519");
+  const publicKey = ed255192.getPublicKey(input.privateKey);
+  if (!equalBytes(publicKey, didMaterial.slice(2)))
+    throw new Error("policy invocation private key does not bind recipient DID");
+  const now = input.now ?? Math.floor(Date.now() / 1e3);
+  const exp = Math.min(now + 60, session.exp);
+  if (exp <= now) throw new Error("policy session has expired");
+  const header = { alg: "EdDSA", jwk: { alg: "EdDSA", crv: "Ed25519", kty: "OKP", x: encodeBase64Url(publicKey) }, typ: "JWT", ucv: "0.10.0" };
+  const payload = {
+    att: { [input.resource]: { [input.action]: [input.caveat ?? {}] } },
+    aud: input.audienceDid,
+    exp,
+    fct: [input.facts ?? { type: "tinycloud.policy.invocation/v1", policyCid: session.fact.policyCid, sessionCid: session.cid }],
+    iss: input.recipientDid.includes("#") ? input.recipientDid : `${principal}#${principal.slice("did:key:".length)}`,
+    nbf: now,
+    nnc: input.nonce ?? encodeBase64Url(crypto.getRandomValues(new Uint8Array(16))),
+    prf: [session.cid]
+  };
+  const protectedSegment = encodeBase64Url(new TextEncoder().encode(jcsCanonicalize(header)));
+  const payloadSegment = encodeBase64Url(new TextEncoder().encode(jcsCanonicalize(payload)));
+  const signingInput = new TextEncoder().encode(`${protectedSegment}.${payloadSegment}`);
+  const signature = ed255192.sign(signingInput, input.privateKey);
+  return parseCompactUcanAuthorization(`${protectedSegment}.${payloadSegment}.${encodeBase64Url(signature)}`);
+}
+function createCompactPolicyDescendant(input) {
+  const parent = parseCompactUcanAuthorization(input.parentAuthorization, input.parentCid);
+  if (parent.payload.aud !== input.issuerDid) throw new Error("policy descendant issuer is not the parent audience");
+  const parentFact = parent.payload.fct[0];
+  const depth = parentFact.remainingRedelegationDepth;
+  if (!Number.isInteger(depth) || depth <= 0) throw new Error("policy descendant depth is exhausted");
+  if (!compactAttenuationContains(parent.payload.att, input.attenuation))
+    throw new Error("policy descendant exceeds the parent attenuation");
+  const principal = input.issuerDid.split("#", 1)[0];
+  const didMaterial = base58btc.decode(principal.slice("did:key:".length));
+  const publicKey = ed255192.getPublicKey(input.privateKey);
+  if (didMaterial.length !== 34 || !equalBytes(publicKey, didMaterial.slice(2))) throw new Error("policy descendant signer does not bind issuer DID");
+  const now = Math.max(input.now ?? Math.floor(Date.now() / 1e3), parent.payload.nbf + 1);
+  const exp = Math.min(input.expiresAt ?? now + 60, now + 60, parent.payload.exp - 1);
+  if (exp <= now) throw new Error("policy parent has no strictly narrower validity window");
+  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,
+    fct: [{ ...parentFact, remainingRedelegationDepth: depth - 1 }],
+    iss: input.issuerDid.includes("#") ? input.issuerDid : `${principal}#${principal.slice("did:key:".length)}`,
+    nbf: now,
+    nnc: input.nonce ?? encodeBase64Url(crypto.getRandomValues(new Uint8Array(16))),
+    prf: [parent.cid]
+  };
+  const protectedSegment = encodeBase64Url(new TextEncoder().encode(jcsCanonicalize(header)));
+  const payloadSegment = encodeBase64Url(new TextEncoder().encode(jcsCanonicalize(payload)));
+  const signature = ed255192.sign(new TextEncoder().encode(`${protectedSegment}.${payloadSegment}`), input.privateKey);
+  return parseCompactUcanAuthorization(`${protectedSegment}.${payloadSegment}.${encodeBase64Url(signature)}`);
+}
+function compactAttenuationContains(parent, child) {
+  const selector = (value) => {
+    if (value.length !== 1 || !isRecordValue(value[0])) return void 0;
+    const caveat = value[0];
+    if (Object.keys(caveat).length !== 3 || caveat.type !== "xyz.tinycloud.resource/selector" || caveat.kind !== "exact" && caveat.kind !== "prefix" || typeof caveat.value !== "string") return void 0;
+    return { kind: caveat.kind, value: caveat.value };
+  };
+  const equal = (left, right) => jcsCanonicalize(left) === jcsCanonicalize(right);
+  return Object.entries(child).every(
+    ([childResource, childActions]) => Object.entries(childActions).every(
+      ([action, childCaveats]) => Object.entries(parent).some(([parentResource, parentActions]) => {
+        const parentCaveats = parentActions[action];
+        if (parentCaveats === void 0) return false;
+        if (parentResource === childResource && equal(parentCaveats, childCaveats)) return true;
+        const parentSelector = selector(parentCaveats);
+        const childSelector = selector(childCaveats);
+        return parentSelector?.kind === "prefix" && childSelector !== void 0 && parentSelector.value === parentResource && childSelector.value === childResource && (childResource === parentResource || childResource.startsWith(`${parentResource}/`));
+      })
+    )
+  );
+}
+function isRecordValue(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseCompactUcanAuthorization(input, expectedCid) {
+  if (typeof input !== "string" || /\s/.test(input))
+    throw new Error("Authorization must be compact UCAN bytes");
+  const segments = input.split(".");
+  if (segments.length !== 3 || segments.some((segment) => segment.length === 0))
+    throw new Error("Authorization must have three compact segments");
+  const [headerSegment, payloadSegment, signatureSegment] = segments;
+  const headerBytes = decodeBase64Url(headerSegment);
+  const payloadBytes = decodeBase64Url(payloadSegment);
+  const signature = decodeBase64Url(signatureSegment);
+  const headerValue = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(headerBytes));
+  const payloadValue = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(payloadBytes));
+  if (jcsCanonicalize(headerValue) !== new TextDecoder().decode(headerBytes) || jcsCanonicalize(payloadValue) !== new TextDecoder().decode(payloadBytes))
+    throw new Error("compact UCAN segments are not canonical JCS");
+  const header = CompactHeaderSchema.parse(headerValue);
+  const payload = CompactPayloadSchema.parse(payloadValue);
+  if (payload.nbf >= payload.exp) throw new Error("compact UCAN validity is empty");
+  const principal = payload.iss.split("#", 1)[0];
+  const didMaterial = principal.startsWith("did:key:") ? base58btc.decode(principal.slice("did:key:".length)) : new Uint8Array();
+  if (didMaterial.length !== 34 || didMaterial[0] !== 237 || didMaterial[1] !== 1)
+    throw new Error("compact UCAN issuer must be did:key Ed25519");
+  const publicKey = didMaterial.slice(2);
+  if (!equalBytes(publicKey, decodeBase64Url(header.jwk.x)))
+    throw new Error("compact UCAN JWK does not bind issuer");
+  if (!ed255192.verify(signature, new TextEncoder().encode(`${headerSegment}.${payloadSegment}`), publicKey))
+    throw new Error("compact UCAN signature is invalid");
+  const cid2 = CID.createV1(85, create(30, blake3(new TextEncoder().encode(input)))).toString();
+  if (expectedCid !== void 0 && cid2 !== expectedCid)
+    throw new Error("compact UCAN CID does not match exact Authorization bytes");
+  return { authorization: input, cid: cid2, header, payload };
+}
+function parsePolicySessionUcan(authorization, expectedProofs) {
+  const parsed = parseCompactUcanAuthorization(authorization);
+  const fact = parsed.payload.fct[0];
+  if (parsed.payload.prf.length !== 2 || parsed.payload.prf[0] === parsed.payload.prf[1])
+    throw new Error("policy session UCAN requires two distinct ordered proofs");
+  if (expectedProofs !== void 0 && (parsed.payload.prf[0] !== expectedProofs[0] || parsed.payload.prf[1] !== expectedProofs[1]))
+    throw new Error("policy session UCAN ordered proofs do not match");
+  const factKeys = Object.keys(fact);
+  if (factKeys.length !== POLICY_SESSION_FACT_KEYS.length || factKeys.some((key) => !POLICY_SESSION_FACT_KEYS.includes(key)) || POLICY_SESSION_FACT_KEYS.some((key) => !(key in fact)))
+    throw new Error("policy session UCAN fact is incomplete");
+  if (fact.profile !== POLICY_SESSION_UCAN_V1_PROFILE || typeof fact.remainingRedelegationDepth !== "number" || !Number.isInteger(fact.remainingRedelegationDepth) || fact.remainingRedelegationDepth < 0 || fact.remainingRedelegationDepth > 8 || parsed.payload.exp - parsed.payload.nbf > 60 || parsed.payload.iss.split("#", 1)[0] !== fact.enforcerDid || parsed.payload.aud !== fact.recipientDid)
+    throw new Error("policy session UCAN fact is invalid");
+  return {
+    authorization,
+    cid: parsed.cid,
+    iss: parsed.payload.iss,
+    aud: parsed.payload.aud,
+    prf: parsed.payload.prf,
+    att: parsed.payload.att,
+    nbf: parsed.payload.nbf,
+    exp: parsed.payload.exp,
+    nnc: parsed.payload.nnc,
+    fact
+  };
+}
+function decodeBase64Url(value) {
+  if (!/^[A-Za-z0-9_-]+$/.test(value) || value.length % 4 === 1)
+    throw new Error("value is not canonical base64url");
+  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+  const binary = typeof Buffer !== "undefined" ? Buffer.from(normalized, "base64").toString("binary") : atob(normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "="));
+  const bytes2 = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+  const encoded = typeof Buffer !== "undefined" ? Buffer.from(bytes2).toString("base64url") : btoa(String.fromCharCode(...bytes2)).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  if (encoded !== value) throw new Error("value is not canonical base64url");
+  return bytes2;
+}
+function encodeBase64Url(value) {
+  return typeof Buffer !== "undefined" ? Buffer.from(value).toString("base64url") : btoa(String.fromCharCode(...value)).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function equalBytes(left, right) {
+  return left.length === right.length && left.every((byte, index) => byte === right[index]);
+}
+function hex(bytes2) {
+  return [...bytes2].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function base32Lower(bytes2) {
+  const alphabet2 = "abcdefghijklmnopqrstuvwxyz234567";
+  let output = "";
+  let buffer = 0;
+  let bits = 0;
+  for (const byte of bytes2) {
+    buffer = buffer << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      output += alphabet2[buffer >>> bits - 5 & 31];
+      bits -= 5;
+    }
+  }
+  if (bits > 0) output += alphabet2[buffer << 5 - bits & 31];
+  return output;
 }
 
 // src/requester/index.ts
@@ -3062,109 +3665,109 @@ var TranscriptRequesterError = class extends Error {
     this.status = status;
   }
 };
-var JsonValueSchema = z2.lazy(
-  () => z2.union([
-    z2.string(),
-    z2.number().finite(),
-    z2.boolean(),
-    z2.null(),
-    z2.array(JsonValueSchema),
-    z2.record(JsonValueSchema)
+var JsonValueSchema = z3.lazy(
+  () => z3.union([
+    z3.string(),
+    z3.number().finite(),
+    z3.boolean(),
+    z3.null(),
+    z3.array(JsonValueSchema),
+    z3.record(JsonValueSchema)
   ])
 );
-var Rfc3339Schema = z2.string().refine((value) => parseStrictRfc33392(value) !== void 0, {
+var Rfc3339Schema = z3.string().refine((value) => parseStrictRfc33392(value) !== void 0, {
   message: "must be strict RFC 3339 date-time with timezone"
 });
-var SignedRecordSchema = z2.object({
-  schema: z2.string(),
-  engineRecordId: z2.string(),
-  ownerDid: z2.string(),
-  endpoint: z2.string(),
-  audience: z2.string(),
-  supportedPolicyVersions: z2.array(z2.string()),
-  supportedEvidenceVerifiers: z2.array(z2.string()),
-  grantIssuerDid: z2.string(),
+var SignedRecordSchema = z3.object({
+  schema: z3.string(),
+  engineRecordId: z3.string(),
+  ownerDid: z3.string(),
+  endpoint: z3.string(),
+  audience: z3.string(),
+  supportedPolicyVersions: z3.array(z3.string()),
+  supportedEvidenceVerifiers: z3.array(z3.string()),
+  grantIssuerDid: z3.string(),
   expiresAt: Rfc3339Schema,
-  signature: z2.object({
-    suite: z2.string(),
-    signerDid: z2.string(),
-    value: z2.string()
+  signature: z3.object({
+    suite: z3.string(),
+    signerDid: z3.string(),
+    value: z3.string()
   }).strict()
 }).strict();
-var PolicyEngineSchema = z2.object({
-  endpoint: z2.string().url(),
-  audience: z2.string(),
-  supportedEvidenceVerifiers: z2.tuple([
-    z2.literal(W3C_VC_CREDENTIAL_VERIFIER)
+var PolicyEngineSchema = z3.object({
+  endpoint: z3.string().url(),
+  audience: z3.string(),
+  supportedEvidenceVerifiers: z3.tuple([
+    z3.literal(W3C_VC_CREDENTIAL_VERIFIER)
   ]),
   signedRecord: SignedRecordSchema
 }).strict();
-var OwnerNodeSchema = z2.object({
-  schema: z2.literal(OWNER_NODE_ENDPOINT_SCHEMA),
-  endpoint: z2.string().url(),
-  spaceId: z2.string().min(1)
+var OwnerNodeSchema = z3.object({
+  schema: z3.literal(OWNER_NODE_ENDPOINT_SCHEMA),
+  endpoint: z3.string().url(),
+  spaceId: z3.string().min(1)
 }).strict();
-var ResourceHintSchema = z2.object({
-  resourceType: z2.string(),
-  resourceId: z2.string(),
-  requestedCapabilities: z2.array(JsonValueSchema).min(1)
+var ResourceHintSchema = z3.object({
+  resourceType: z3.string(),
+  resourceId: z3.string(),
+  requestedCapabilities: z3.array(JsonValueSchema).min(1)
 }).strict();
-var BootstrapSchema = z2.object({
-  schema: z2.literal(TRANSCRIPT_SHARE_BOOTSTRAP_SCHEMA),
-  policyId: z2.string(),
+var BootstrapSchema = z3.object({
+  schema: z3.literal(TRANSCRIPT_SHARE_BOOTSTRAP_SCHEMA),
+  policyId: z3.string(),
   policyEngine: PolicyEngineSchema,
   ownerNode: OwnerNodeSchema,
   resourceHint: ResourceHintSchema
 }).strict();
-var SignatureSchema = z2.object({
-  suite: z2.string(),
-  signerDid: z2.string(),
-  value: z2.string()
+var SignatureSchema = z3.object({
+  suite: z3.string(),
+  signerDid: z3.string(),
+  value: z3.string()
 }).strict();
-var ChallengeSchema = z2.object({
-  schema: z2.literal(POLICY_ENGINE_CHALLENGE_RESPONSE_SCHEMA),
-  challengeId: z2.string(),
-  policyId: z2.string(),
-  audience: z2.string(),
-  nonce: z2.string().min(16),
+var ChallengeSchema = z3.object({
+  schema: z3.literal(POLICY_ENGINE_CHALLENGE_RESPONSE_SCHEMA),
+  challengeId: z3.string(),
+  policyId: z3.string(),
+  audience: z3.string(),
+  nonce: z3.string().min(16),
   challengeExpiresAt: Rfc3339Schema,
-  acceptedSuites: z2.array(z2.string()).min(1),
-  requestedCapabilitiesTemplate: z2.array(JsonValueSchema).optional(),
+  acceptedSuites: z3.array(z3.string()).min(1),
+  requestedCapabilitiesTemplate: z3.array(JsonValueSchema).optional(),
   signature: SignatureSchema
 }).strict();
-var ChallengeResponseSchema = z2.object({ challenge: ChallengeSchema }).strict();
-var DenialSchema = z2.object({
-  schema: z2.literal(POLICY_ENGINE_DENIAL_SCHEMA),
-  code: z2.enum(POLICY_ENGINE_GRANT_PRESENTATION_DENIAL_CODES),
-  message: z2.string().optional()
+var ChallengeResponseSchema = z3.object({ challenge: ChallengeSchema }).strict();
+var DenialSchema = z3.object({
+  schema: z3.literal(POLICY_ENGINE_DENIAL_SCHEMA),
+  code: z3.enum(POLICY_ENGINE_GRANT_PRESENTATION_DENIAL_CODES),
+  message: z3.string().optional()
 }).strict();
-var ErrorEnvelopeDenialSchema = z2.object({
-  error: z2.object({
-    code: z2.enum(POLICY_ENGINE_GRANT_PRESENTATION_DENIAL_CODES),
-    message: z2.string().optional()
+var ErrorEnvelopeDenialSchema = z3.object({
+  error: z3.object({
+    code: z3.enum(POLICY_ENGINE_GRANT_PRESENTATION_DENIAL_CODES),
+    message: z3.string().optional()
   }).strict()
 }).strict();
-var WireDelegationSchema = z2.object({
-  delegationId: z2.string(),
-  issuanceId: z2.string().min(1),
-  issuerDid: z2.string(),
-  holderDid: z2.string(),
-  policyId: z2.string(),
-  capabilityHashHex: z2.string().regex(/^[0-9a-f]{64}$/),
-  revocationMode: z2.literal("refresh_only"),
+var WireDelegationSchema = z3.object({
+  delegationId: z3.string(),
+  issuanceId: z3.string().min(1),
+  issuerDid: z3.string(),
+  holderDid: z3.string(),
+  policyId: z3.string(),
+  capabilityHashHex: z3.string().regex(/^[0-9a-f]{64}$/),
+  revocationMode: z3.literal("refresh_only"),
   issuedAt: Rfc3339Schema,
   expiresAt: Rfc3339Schema,
-  terminal: z2.boolean(),
-  encoded: z2.string()
+  terminal: z3.boolean(),
+  encoded: z3.string()
 }).strict();
-var ResolveResponseSchema = z2.object({ delegation: WireDelegationSchema }).strict();
-var DelegateReceiptSchema = z2.object({
-  cid: z2.string().min(1),
-  activated: z2.array(z2.string()),
-  skipped: z2.array(z2.string())
+var ResolveResponseSchema = z3.object({ delegation: WireDelegationSchema }).strict();
+var DelegateReceiptSchema = z3.object({
+  cid: z3.string().min(1),
+  activated: z3.array(z3.string()),
+  skipped: z3.array(z3.string())
 }).strict();
-var SqlReadResponseSchema = z2.object({ rows: z2.array(JsonValueSchema) }).strict();
-var KvReadResponseSchema = z2.object({ value: JsonValueSchema }).strict();
+var SqlReadResponseSchema = z3.object({ rows: z3.array(JsonValueSchema) }).strict();
+var KvReadResponseSchema = z3.object({ value: JsonValueSchema }).strict();
 var LISTEN_SQL_STATEMENT_CATALOG = [
   {
     name: "listen.getConversation",
@@ -3899,7 +4502,7 @@ function requestedCapabilitiesHash(capabilities) {
   const bytes2 = new Uint8Array(domain.length + body.length);
   bytes2.set(domain, 0);
   bytes2.set(body, domain.length);
-  return bytesToHex3(sha2564(bytes2, "bytes")).slice(2);
+  return bytesToHex3(sha2565(bytes2, "bytes")).slice(2);
 }
 function normalizeWireDelegation(delegation) {
   const signed = delegationAuthorityFromCompactJws(delegation.encoded);
@@ -4154,7 +4757,7 @@ function nodeErrorMessage(body) {
   return "native node refusal";
 }
 function deriveDelegationCid(encoded) {
-  const digest4 = create(30, blake3(new TextEncoder().encode(encoded)));
+  const digest4 = create(30, blake32(new TextEncoder().encode(encoded)));
   return CID.createV1(85, digest4).toString();
 }
 function headersRecord(headers) {
@@ -4301,55 +4904,55 @@ function parseStrictRfc33392(value) {
 }
 
 // src/delegations/types.schema.ts
-import { z as z3 } from "zod";
-var JWKSchema = z3.object({
+import { z as z4 } from "zod";
+var JWKSchema = z4.object({
   /** Key type (e.g., "EC", "RSA", "OKP") */
-  kty: z3.string(),
+  kty: z4.string(),
   /** Curve for EC/OKP keys (e.g., "P-256", "Ed25519") */
-  crv: z3.string().optional(),
+  crv: z4.string().optional(),
   /** X coordinate for EC keys, public key for OKP */
-  x: z3.string().optional(),
+  x: z4.string().optional(),
   /** Y coordinate for EC keys */
-  y: z3.string().optional(),
+  y: z4.string().optional(),
   /** Private key value (d parameter) */
-  d: z3.string().optional(),
+  d: z4.string().optional(),
   /** Public exponent for RSA keys */
-  e: z3.string().optional(),
+  e: z4.string().optional(),
   /** Modulus for RSA keys */
-  n: z3.string().optional(),
+  n: z4.string().optional(),
   /** Key ID */
-  kid: z3.string().optional(),
+  kid: z4.string().optional(),
   /** Algorithm */
-  alg: z3.string().optional(),
+  alg: z4.string().optional(),
   /** Key use (e.g., "sig", "enc") */
-  use: z3.string().optional(),
+  use: z4.string().optional(),
   /** Key operations (e.g., ["sign", "verify"]) */
-  key_ops: z3.array(z3.string()).optional()
+  key_ops: z4.array(z4.string()).optional()
 });
-var KeyTypeSchema = z3.enum(["main", "session", "ingested"]);
-var KeyInfoSchema = z3.object({
+var KeyTypeSchema = z4.enum(["main", "session", "ingested"]);
+var KeyInfoSchema = z4.object({
   /** Unique identifier for this key */
-  id: z3.string(),
+  id: z4.string(),
   /** DID associated with this key */
-  did: z3.string(),
+  did: z4.string(),
   /** Type of key determining its authority level */
   type: KeyTypeSchema,
   /** Private key in JWK format */
   jwk: JWKSchema.optional(),
   /** Priority for key selection (lower = higher priority) */
-  priority: z3.number()
+  priority: z4.number()
 });
-var DelegationErrorSchema = z3.object({
+var DelegationErrorSchema = z4.object({
   /** Error code for programmatic handling */
-  code: z3.string(),
+  code: z4.string(),
   /** Human-readable error message */
-  message: z3.string(),
+  message: z4.string(),
   /** The service that produced the error */
-  service: z3.literal("delegation"),
+  service: z4.literal("delegation"),
   /** Original error if wrapping another error */
-  cause: z3.instanceof(Error).optional(),
+  cause: z4.instanceof(Error).optional(),
   /** Additional metadata about the error */
-  meta: z3.record(z3.string(), z3.unknown()).optional()
+  meta: z4.record(z4.string(), z4.unknown()).optional()
 });
 var DelegationErrorCodes = {
   AUTH_REQUIRED: "AUTH_REQUIRED",
@@ -4369,313 +4972,313 @@ var DelegationErrorCodes = {
   DATA_FETCH_FAILED: "DATA_FETCH_FAILED",
   VALIDATION_ERROR: "VALIDATION_ERROR"
 };
-var DelegationSchema = z3.object({
+var DelegationSchema = z4.object({
   /** Content identifier (CID) of the delegation */
-  cid: z3.string(),
+  cid: z4.string(),
   /** DID of the delegate (the party receiving the delegation) */
-  delegateDID: z3.string(),
+  delegateDID: z4.string(),
   /** Space ID this delegation applies to */
-  spaceId: z3.string(),
+  spaceId: z4.string(),
   /** Resource path this delegation grants access to */
-  path: z3.string(),
+  path: z4.string(),
   /** Actions this delegation authorizes */
-  actions: z3.array(z3.string()),
+  actions: z4.array(z4.string()),
   /** Exact ReCap caveats that constrain every action in this scope. */
-  caveats: z3.array(z3.record(z3.string(), z3.unknown())).optional(),
+  caveats: z4.array(z4.record(z4.string(), z4.unknown())).optional(),
   /** When this delegation expires (accepts Date or ISO string from JSON) */
-  expiry: z3.coerce.date(),
+  expiry: z4.coerce.date(),
   /** Whether this delegation has been revoked */
-  isRevoked: z3.boolean(),
+  isRevoked: z4.boolean(),
   /** DID of the delegator (the party granting the delegation) */
-  delegatorDID: z3.string().optional(),
+  delegatorDID: z4.string().optional(),
   /** When this delegation was created (accepts Date or ISO string from JSON) */
-  createdAt: z3.coerce.date().optional(),
+  createdAt: z4.coerce.date().optional(),
   /** Parent delegation CID if this is a sub-delegation */
-  parentCid: z3.string().optional(),
+  parentCid: z4.string().optional(),
   /** Whether sub-delegation is allowed */
-  allowSubDelegation: z3.boolean().optional(),
+  allowSubDelegation: z4.boolean().optional(),
   /** Authorization header (UCAN bearer token) */
-  authHeader: z3.string().optional()
+  authHeader: z4.string().optional()
 });
-var DelegationStatusSchema = z3.object({
-  cid: z3.string().min(1),
-  status: z3.enum(["active", "revoked", "expired", "unavailable", "not_found"]),
-  exists: z3.boolean(),
-  active: z3.boolean(),
-  revoked: z3.boolean(),
-  expired: z3.boolean()
+var DelegationStatusSchema = z4.object({
+  cid: z4.string().min(1),
+  status: z4.enum(["active", "revoked", "expired", "unavailable", "not_found"]),
+  exists: z4.boolean(),
+  active: z4.boolean(),
+  revoked: z4.boolean(),
+  expired: z4.boolean()
 }).strict().superRefine((value, context) => {
   const valid = value.status === "active" ? value.exists && value.active && !value.revoked && !value.expired : value.status === "revoked" ? value.exists && !value.active && value.revoked && !value.expired : value.status === "expired" ? value.exists && !value.active && !value.revoked && value.expired : value.status === "unavailable" ? value.exists && !value.active && !value.revoked && !value.expired : !value.exists && !value.active && !value.revoked && !value.expired;
   if (!valid) {
     context.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       message: "delegation status flags do not match status"
     });
   }
 });
-var DelegationRevocationReceiptSchema = z3.object({
-  revoked: z3.literal(true),
-  cid: z3.string().min(1)
+var DelegationRevocationReceiptSchema = z4.object({
+  revoked: z4.literal(true),
+  cid: z4.string().min(1)
 }).strict();
-var AccountDelegationResourceSchema = z3.object({
-  resource: z3.string().min(1),
-  actions: z3.array(z3.string()),
-  caveats: z3.array(z3.record(z3.string(), z3.unknown()))
+var AccountDelegationResourceSchema = z4.object({
+  resource: z4.string().min(1),
+  actions: z4.array(z4.string()),
+  caveats: z4.array(z4.record(z4.string(), z4.unknown()))
 }).strict();
-var AccountDelegationDateSchema = z3.string().datetime({ offset: true }).transform((value) => new Date(value));
-var AccountDelegationRecordSchema = z3.object({
-  cid: z3.string().min(1),
-  direction: z3.enum(["granted", "received"]),
-  delegatorDid: z3.string().min(1),
-  delegateDid: z3.string().min(1),
-  resources: z3.array(AccountDelegationResourceSchema),
-  parents: z3.array(z3.string()),
+var AccountDelegationDateSchema = z4.string().datetime({ offset: true }).transform((value) => new Date(value));
+var AccountDelegationRecordSchema = z4.object({
+  cid: z4.string().min(1),
+  direction: z4.enum(["granted", "received"]),
+  delegatorDid: z4.string().min(1),
+  delegateDid: z4.string().min(1),
+  resources: z4.array(AccountDelegationResourceSchema),
+  parents: z4.array(z4.string()),
   issuedAt: AccountDelegationDateSchema.nullable(),
   notBefore: AccountDelegationDateSchema.nullable(),
   expiresAt: AccountDelegationDateSchema.nullable(),
-  status: z3.enum(["active", "pending", "expired", "revoked", "ancestor_revoked"]),
+  status: z4.enum(["active", "pending", "expired", "revoked", "ancestor_revoked"]),
   revokedAt: AccountDelegationDateSchema.nullable().optional(),
-  revokedBy: z3.string().optional(),
-  revokedAncestorCid: z3.string().optional()
+  revokedBy: z4.string().optional(),
+  revokedAncestorCid: z4.string().optional()
 }).strict();
-var AccountDelegationPageSchema = z3.object({
-  schemaVersion: z3.literal(2),
-  items: z3.array(AccountDelegationRecordSchema),
-  nextCursor: z3.string().optional()
+var AccountDelegationPageSchema = z4.object({
+  schemaVersion: z4.literal(2),
+  items: z4.array(AccountDelegationRecordSchema),
+  nextCursor: z4.string().optional()
 }).strict();
-var AccountDelegationQueryOptionsSchema = z3.object({
-  direction: z3.enum(["granted", "received", "all"]).optional(),
-  status: z3.enum(["active", "pending", "expired", "revoked", "ancestor_revoked"]).optional(),
-  space: z3.string().trim().min(1).optional(),
-  limit: z3.number().int().min(1).max(100).optional(),
-  cursor: z3.string().min(1).optional()
+var AccountDelegationQueryOptionsSchema = z4.object({
+  direction: z4.enum(["granted", "received", "all"]).optional(),
+  status: z4.enum(["active", "pending", "expired", "revoked", "ancestor_revoked"]).optional(),
+  space: z4.string().trim().min(1).optional(),
+  limit: z4.number().int().min(1).max(100).optional(),
+  cursor: z4.string().min(1).optional()
 }).strict();
-var CapabilityEntrySchema = z3.object({
+var CapabilityEntrySchema = z4.object({
   /** Resource URI this capability applies to */
-  resource: z3.string(),
+  resource: z4.string(),
   /** Action this capability authorizes */
-  action: z3.string(),
+  action: z4.string(),
   /** Keys that can exercise this capability, ordered by priority */
-  keys: z3.array(KeyInfoSchema),
+  keys: z4.array(KeyInfoSchema),
   /** The delegation that grants this capability */
   delegation: DelegationSchema,
   /** When this capability expires (accepts Date or ISO string from JSON) */
-  expiresAt: z3.coerce.date().optional()
+  expiresAt: z4.coerce.date().optional()
 });
-var DelegationRecordSchema = z3.object({
+var DelegationRecordSchema = z4.object({
   /** Content identifier (CID) of the delegation */
-  cid: z3.string(),
+  cid: z4.string(),
   /** Space ID this delegation applies to */
-  spaceId: z3.string(),
+  spaceId: z4.string(),
   /** DID of the delegator (grantor) */
-  delegator: z3.string(),
+  delegator: z4.string(),
   /** DID of the delegatee (recipient) */
-  delegatee: z3.string(),
+  delegatee: z4.string(),
   /** Key ID used to sign/exercise this delegation */
-  keyId: z3.string().optional(),
+  keyId: z4.string().optional(),
   /** Resource path pattern this delegation grants access to */
-  path: z3.string(),
+  path: z4.string(),
   /** Actions this delegation authorizes */
-  actions: z3.array(z3.string()),
+  actions: z4.array(z4.string()),
   /** When this delegation expires (accepts Date or ISO string from JSON) */
-  expiry: z3.coerce.date().optional(),
+  expiry: z4.coerce.date().optional(),
   /** When this delegation becomes valid (not before) (accepts Date or ISO string) */
-  notBefore: z3.coerce.date().optional(),
+  notBefore: z4.coerce.date().optional(),
   /** Whether this delegation has been revoked */
-  isRevoked: z3.boolean(),
+  isRevoked: z4.boolean(),
   /** When this delegation was created (accepts Date or ISO string from JSON) */
-  createdAt: z3.coerce.date(),
+  createdAt: z4.coerce.date(),
   /** Parent delegation CID if this is a sub-delegation */
-  parentCid: z3.string().optional()
+  parentCid: z4.string().optional()
 });
-var CreateDelegationParamsSchema = z3.object({
+var CreateDelegationParamsSchema = z4.object({
   /** DID of the delegate (the party receiving the delegation) */
-  delegateDID: z3.string(),
+  delegateDID: z4.string(),
   /** Resource path this delegation grants access to */
-  path: z3.string(),
+  path: z4.string(),
   /** Actions to authorize */
-  actions: z3.array(z3.string()),
+  actions: z4.array(z4.string()),
   /** When this delegation expires (accepts Date or ISO string) */
-  expiry: z3.coerce.date().optional(),
+  expiry: z4.coerce.date().optional(),
   /** Whether to disable sub-delegation */
-  disableSubDelegation: z3.boolean().optional(),
+  disableSubDelegation: z4.boolean().optional(),
   /** Optional statement for the SIWE message */
-  statement: z3.string().optional()
+  statement: z4.string().optional()
 });
-var DelegationChainSchema = z3.array(DelegationSchema);
-var DelegationChainV2Schema = z3.object({
+var DelegationChainSchema = z4.array(DelegationSchema);
+var DelegationChainV2Schema = z4.object({
   /** The root delegation from the original authority */
   root: DelegationSchema,
   /** Intermediate delegations in the chain (may be empty) */
-  chain: z3.array(DelegationSchema),
+  chain: z4.array(DelegationSchema),
   /** The final delegation to the current user */
   leaf: DelegationSchema
 });
-var DelegationDirectionSchema = z3.enum(["granted", "received", "all"]);
-var DelegationFiltersSchema = z3.object({
+var DelegationDirectionSchema = z4.enum(["granted", "received", "all"]);
+var DelegationFiltersSchema = z4.object({
   /** Filter by delegation direction */
   direction: DelegationDirectionSchema.optional(),
   /** Filter by resource path pattern */
-  path: z3.string().optional(),
+  path: z4.string().optional(),
   /** Filter by required actions */
-  actions: z3.array(z3.string()).optional(),
+  actions: z4.array(z4.string()).optional(),
   /** Include revoked delegations */
-  includeRevoked: z3.boolean().optional(),
+  includeRevoked: z4.boolean().optional(),
   /** Filter by delegator DID */
-  delegator: z3.string().optional(),
+  delegator: z4.string().optional(),
   /** Filter by delegatee DID */
-  delegatee: z3.string().optional(),
+  delegatee: z4.string().optional(),
   /** Only include delegations valid at this time */
-  validAt: z3.coerce.date().optional(),
+  validAt: z4.coerce.date().optional(),
   /** Maximum number of results to return */
-  limit: z3.number().optional(),
+  limit: z4.number().optional(),
   /** Cursor for pagination */
-  cursor: z3.string().optional()
+  cursor: z4.string().optional()
 });
-var SpaceOwnershipSchema = z3.enum(["owned", "delegated"]);
-var SpaceInfoSchema = z3.object({
+var SpaceOwnershipSchema = z4.enum(["owned", "delegated"]);
+var SpaceInfoSchema = z4.object({
   /** Space identifier */
-  id: z3.string(),
+  id: z4.string(),
   /** Human-readable name for the space */
-  name: z3.string().optional(),
+  name: z4.string().optional(),
   /** DID of the space owner */
-  owner: z3.string(),
+  owner: z4.string(),
   /** Whether user owns or has delegated access */
   type: SpaceOwnershipSchema,
   /** Permissions the user has in this space */
-  permissions: z3.array(z3.string()).optional(),
+  permissions: z4.array(z4.string()).optional(),
   /** When the access expires (for delegated spaces) */
-  expiresAt: z3.coerce.date().optional()
+  expiresAt: z4.coerce.date().optional()
 });
-var ShareSchemaSchema = z3.enum(["base64", "compact", "ipfs"]);
-var ShareLinkSchema = z3.object({
+var ShareSchemaSchema = z4.enum(["base64", "compact", "ipfs"]);
+var ShareLinkSchema = z4.object({
   /** Unique token identifying this share link */
-  token: z3.string(),
+  token: z4.string(),
   /** Full URL for sharing */
-  url: z3.string(),
+  url: z4.string(),
   /** The delegation this link grants access to */
   delegation: DelegationSchema,
   /** Encoding schema used for the link */
   schema: ShareSchemaSchema,
   /** When this share link expires */
-  expiresAt: z3.coerce.date().optional(),
+  expiresAt: z4.coerce.date().optional(),
   /** Human-readable description of what is being shared */
-  description: z3.string().optional()
+  description: z4.string().optional()
 });
 function createShareLinkDataSchema(dataSchema) {
-  return z3.object({
+  return z4.object({
     /** The retrieved data */
     data: dataSchema,
     /** The delegation that authorized this access */
     delegation: DelegationSchema,
     /** The space the data belongs to */
-    spaceId: z3.string(),
+    spaceId: z4.string(),
     /** The resource path that was accessed */
-    path: z3.string()
+    path: z4.string()
   });
 }
-var ShareLinkDataSchema = createShareLinkDataSchema(z3.unknown());
-var IngestOptionsSchema = z3.object({
+var ShareLinkDataSchema = createShareLinkDataSchema(z4.unknown());
+var IngestOptionsSchema = z4.object({
   /** Whether to persist the delegation to storage */
-  persist: z3.boolean().optional(),
+  persist: z4.boolean().optional(),
   /** Whether to validate the full delegation chain */
-  validateChain: z3.boolean().optional(),
+  validateChain: z4.boolean().optional(),
   /** Name for the ingested key */
-  keyName: z3.string().optional(),
+  keyName: z4.string().optional(),
   /** Whether to create a session key for this delegation */
-  createSessionKey: z3.boolean().optional(),
+  createSessionKey: z4.boolean().optional(),
   /** Override the priority for the ingested key */
-  priority: z3.number().optional()
+  priority: z4.number().optional()
 });
-var GenerateShareParamsSchema = z3.object({
+var GenerateShareParamsSchema = z4.object({
   /** Resource path to share */
-  path: z3.string(),
+  path: z4.string(),
   /** Actions to authorize */
-  actions: z3.array(z3.string()).optional(),
+  actions: z4.array(z4.string()).optional(),
   /** When the share link expires */
-  expiry: z3.coerce.date().optional(),
+  expiry: z4.coerce.date().optional(),
   /** Encoding schema for the link */
   schema: ShareSchemaSchema.optional(),
   /** Human-readable description */
-  description: z3.string().optional(),
+  description: z4.string().optional(),
   /** Base URL for the share link */
-  baseUrl: z3.string().optional()
+  baseUrl: z4.string().optional()
 });
-var DelegationManagerConfigSchema = z3.object({
+var DelegationManagerConfigSchema = z4.object({
   /** TinyCloud host URLs */
-  hosts: z3.array(z3.string()),
+  hosts: z4.array(z4.string()),
   /** Account space used by account-wide delegation history queries */
-  accountSpaceId: z3.string().min(1).optional(),
+  accountSpaceId: z4.string().min(1).optional(),
   /** Active session for authentication */
-  session: z3.unknown().refine(
+  session: z4.unknown().refine(
     (val) => val !== null && typeof val === "object",
     { message: "Expected a ServiceSession object" }
   ),
   /** Platform-specific invoke function */
-  invoke: z3.unknown().refine(
+  invoke: z4.unknown().refine(
     (val) => typeof val === "function",
     { message: "Expected an invoke function" }
   ),
   /** Platform-specific invoke function for raw resource URIs */
-  invokeAny: z3.unknown().refine(
+  invokeAny: z4.unknown().refine(
     (val) => val === void 0 || typeof val === "function",
     { message: "Expected an invokeAny function or undefined" }
   ).optional(),
   /** Optional custom fetch implementation */
-  fetch: z3.unknown().refine(
+  fetch: z4.unknown().refine(
     (val) => val === void 0 || typeof val === "function",
     { message: "Expected a fetch function or undefined" }
   ).optional()
 });
-var KeyProviderSchema = z3.object({
+var KeyProviderSchema = z4.object({
   /** Generate a new session key, returns key ID */
-  createSessionKey: z3.unknown().refine(
+  createSessionKey: z4.unknown().refine(
     (val) => typeof val === "function",
     { message: "Expected a function" }
   ),
   /** Get JWK for a key */
-  getJWK: z3.unknown().refine(
+  getJWK: z4.unknown().refine(
     (val) => typeof val === "function",
     { message: "Expected a function" }
   ),
   /** Get DID for a key */
-  getDID: z3.unknown().refine(
+  getDID: z4.unknown().refine(
     (val) => typeof val === "function",
     { message: "Expected a function" }
   )
 });
-var DelegationApiResponseSchema = z3.object({
+var DelegationApiResponseSchema = z4.object({
   /** SIWE message content */
-  siwe: z3.string(),
+  siwe: z4.string(),
   /** Signature of the SIWE message */
-  signature: z3.string(),
+  signature: z4.string(),
   /** Delegation version */
-  version: z3.number(),
+  version: z4.number(),
   /** CID of the created delegation */
-  cid: z3.string().optional()
+  cid: z4.string().optional()
 });
-var DelegatedResourceSchema = z3.object({
+var DelegatedResourceSchema = z4.object({
   /** Short-form service name, e.g. "kv", "sql", "duckdb", "capabilities", "hooks". */
-  service: z3.string(),
+  service: z4.string(),
   /** Full space id string, e.g. "tinycloud:pkh:eip155:1:0x....:default". */
-  space: z3.string(),
+  space: z4.string(),
   /** Resource path; empty string when the resource URI had no path segment. */
-  path: z3.string(),
+  path: z4.string(),
   /** Full-URN ability strings, e.g. ["tinycloud.kv/get", "tinycloud.kv/put"]. */
-  actions: z3.array(z3.string()),
+  actions: z4.array(z4.string()),
   /** Exact ReCap caveats that constrain every action in this scope. */
-  caveats: z3.array(z3.record(z3.string(), z3.unknown())).optional()
+  caveats: z4.array(z4.record(z4.string(), z4.unknown())).optional()
 });
-var CreateDelegationWasmParamsSchema = z3.object({
+var CreateDelegationWasmParamsSchema = z4.object({
   /** The session containing delegation credentials */
-  session: z3.unknown().refine(
+  session: z4.unknown().refine(
     (val) => val !== null && typeof val === "object",
     { message: "Expected a ServiceSession object" }
   ),
   /** DID of the delegate */
-  delegateDID: z3.string(),
+  delegateDID: z4.string(),
   /** Space ID this delegation applies to */
-  spaceId: z3.string(),
+  spaceId: z4.string(),
   /**
    * Multi-resource abilities map: short-service → path → full-URN actions.
    * Matches the shape accepted by `prepareSession`.
@@ -4692,26 +5295,26 @@ var CreateDelegationWasmParamsSchema = z3.object({
    * }
    * ```
    */
-  abilities: z3.record(z3.string(), z3.record(z3.string(), z3.array(z3.string()))),
+  abilities: z4.record(z4.string(), z4.record(z4.string(), z4.array(z4.string()))),
   /** Expiration time in seconds since Unix epoch */
-  expirationSecs: z3.number(),
+  expirationSecs: z4.number(),
   /** Optional not-before time in seconds since Unix epoch */
-  notBeforeSecs: z3.number().optional()
+  notBeforeSecs: z4.number().optional()
 });
-var CreateDelegationWasmResultSchema = z3.object({
+var CreateDelegationWasmResultSchema = z4.object({
   /** Base64url-encoded UCAN delegation */
-  delegation: z3.string(),
+  delegation: z4.string(),
   /** CID of the delegation */
-  cid: z3.string(),
+  cid: z4.string(),
   /** DID of the delegate */
-  delegateDID: z3.string(),
+  delegateDID: z4.string(),
   /** Expiration time */
-  expiry: z3.coerce.date(),
+  expiry: z4.coerce.date(),
   /**
    * All (service, space, path, actions) entries granted by this delegation.
    * Always non-empty on success.
    */
-  resources: z3.array(DelegatedResourceSchema)
+  resources: z4.array(DelegatedResourceSchema)
 });
 
 // src/expiry.ts
@@ -5406,66 +6009,66 @@ var DelegationManager = class {
 };
 
 // src/delegations/SharingService.schema.ts
-import { z as z4 } from "zod";
-var EncodedShareDataSchema = z4.object({
+import { z as z5 } from "zod";
+var EncodedShareDataSchema = z5.object({
   /** Private key in JWK format (must include d parameter) */
   key: JWKSchema.refine(
     (jwk) => typeof jwk.d === "string" && jwk.d.length > 0,
     { message: "JWK must include private key (d parameter)" }
   ),
   /** DID of the key */
-  keyDid: z4.string().min(1, "keyDid is required"),
+  keyDid: z5.string().min(1, "keyDid is required"),
   /** The delegation granting access */
   delegation: DelegationSchema,
   /** Resource path this link grants access to */
-  path: z4.string().min(1, "path is required"),
+  path: z5.string().min(1, "path is required"),
   /** TinyCloud host URL */
-  host: z4.string().url("host must be a valid URL"),
+  host: z5.string().url("host must be a valid URL"),
   /** Space ID */
-  spaceId: z4.string().min(1, "spaceId is required"),
+  spaceId: z5.string().min(1, "spaceId is required"),
   /** Schema version (must be 1) */
-  version: z4.literal(1)
+  version: z5.literal(1)
 });
-var ReceiveOptionsSchema = z4.object({
+var ReceiveOptionsSchema = z5.object({
   /**
    * Whether to automatically create a sub-delegation to the current session key.
    * Default: true
    */
-  autoSubdelegate: z4.boolean().optional(),
+  autoSubdelegate: z5.boolean().optional(),
   /**
    * Whether to use the current session key for operations (requires autoSubdelegate).
    * Default: true
    */
-  useSessionKey: z4.boolean().optional(),
+  useSessionKey: z5.boolean().optional(),
   /**
    * Ingestion options passed to CapabilityKeyRegistry.
    */
   ingestOptions: IngestOptionsSchema.optional()
 });
-var SharingServiceConfigSchema = z4.object({
+var SharingServiceConfigSchema = z5.object({
   /** TinyCloud host URLs */
-  hosts: z4.array(z4.string().url()).min(1, "At least one host URL is required"),
+  hosts: z5.array(z5.string().url()).min(1, "At least one host URL is required"),
   /**
    * Active session for authentication.
    * Required for generate(), optional for receive().
    */
-  session: z4.unknown().refine(
+  session: z5.unknown().refine(
     (val) => val === void 0 || val !== null && typeof val === "object",
     { message: "Expected a ServiceSession object or undefined" }
   ).optional(),
   /** Platform-specific invoke function */
-  invoke: z4.unknown().refine((val) => typeof val === "function", {
+  invoke: z5.unknown().refine((val) => typeof val === "function", {
     message: "Expected an invoke function"
   }),
   /** Optional custom fetch implementation */
-  fetch: z4.unknown().refine(
+  fetch: z5.unknown().refine(
     (val) => val === void 0 || typeof val === "function",
     { message: "Expected a fetch function or undefined" }
   ).optional(),
   /** Key provider for cryptographic operations */
   keyProvider: KeyProviderSchema,
   /** Capability key registry for key/delegation management */
-  registry: z4.unknown().refine(
+  registry: z5.unknown().refine(
     (val) => val !== null && typeof val === "object",
     { message: "Expected an ICapabilityKeyRegistry object" }
   ),
@@ -5473,47 +6076,47 @@ var SharingServiceConfigSchema = z4.object({
    * Delegation manager for creating delegations.
    * Required for generate(), optional for receive().
    */
-  delegationManager: z4.unknown().refine(
+  delegationManager: z5.unknown().refine(
     (val) => val === void 0 || val !== null && typeof val === "object",
     { message: "Expected a DelegationManager object or undefined" }
   ).optional(),
   /** Factory for creating KV service instances */
-  createKVService: z4.unknown().refine(
+  createKVService: z5.unknown().refine(
     (val) => typeof val === "function",
     { message: "Expected a createKVService factory function" }
   ),
   /** Base URL for sharing links (e.g., "https://share.myapp.com") */
-  baseUrl: z4.string().optional(),
+  baseUrl: z5.string().optional(),
   /**
    * Custom delegation creation function.
    */
-  createDelegation: z4.unknown().refine((val) => val === void 0 || typeof val === "function", {
+  createDelegation: z5.unknown().refine((val) => val === void 0 || typeof val === "function", {
     message: "Expected a createDelegation function or undefined"
   }).optional(),
   /**
    * WASM function for client-side delegation creation.
    */
-  createDelegationWasm: z4.unknown().refine((val) => val === void 0 || typeof val === "function", {
+  createDelegationWasm: z5.unknown().refine((val) => val === void 0 || typeof val === "function", {
     message: "Expected a createDelegationWasm function or undefined"
   }).optional(),
   /** CID computation used to verify transportable child delegations. */
-  computeCid: z4.unknown().refine((val) => val === void 0 || typeof val === "function", {
+  computeCid: z5.unknown().refine((val) => val === void 0 || typeof val === "function", {
     message: "Expected a computeCid function or undefined"
   }).optional(),
   /**
    * Path prefix for KV operations.
    */
-  pathPrefix: z4.string().optional(),
+  pathPrefix: z5.string().optional(),
   /**
    * Session expiry time.
    */
-  sessionExpiry: z4.date().optional(),
+  sessionExpiry: z5.date().optional(),
   /**
    * Callback to create a DIRECT delegation from wallet to share key.
    * This is the preferred method for long-lived share links because it
    * bypasses the session delegation chain entirely.
    */
-  onRootDelegationNeeded: z4.unknown().refine((val) => val === void 0 || typeof val === "function", {
+  onRootDelegationNeeded: z5.unknown().refine((val) => val === void 0 || typeof val === "function", {
     message: "Expected an onRootDelegationNeeded function or undefined"
   }).optional()
 });
@@ -5535,6 +6138,7 @@ function validateEncodedShareData(data) {
 
 // src/manifest.ts
 import ms from "ms";
+import { ACCOUNT_MANIFEST_PERMISSIONS } from "@tinycloud/bootstrap";
 import { resolveSecretPath, SECRET_NAME_RE } from "@tinycloud/sdk-services";
 var DEFAULT_KNOWLEDGE_ROOT = "knowledge/index.md";
 var ManifestValidationError = class extends Error {
@@ -6193,30 +6797,6 @@ function withCapabilitiesReadForSpaces(resources) {
     ...[...spaces].map(capabilitiesReadPermission)
   ]);
 }
-function accountRegistryPermissions() {
-  return [
-    ...[ACCOUNT_REGISTRY_PATH, "spaces/"].map((path) => ({
-      service: "tinycloud.kv",
-      space: ACCOUNT_REGISTRY_SPACE,
-      path,
-      actions: ["tinycloud.kv/get", "tinycloud.kv/put", "tinycloud.kv/list"]
-    })),
-    {
-      service: "tinycloud.delegation",
-      space: ACCOUNT_REGISTRY_SPACE,
-      path: "",
-      actions: ["tinycloud.delegation/list"]
-    }
-  ];
-}
-function accountRegistryIndexPermission() {
-  return {
-    service: "tinycloud.sql",
-    space: ACCOUNT_REGISTRY_SPACE,
-    path: "account",
-    actions: ["tinycloud.sql/read", "tinycloud.sql/write", "tinycloud.sql/schema"]
-  };
-}
 function composeManifestRequest(inputs, options2 = {}) {
   if (!Array.isArray(inputs) || inputs.length === 0) {
     throw new ManifestValidationError(
@@ -6234,8 +6814,12 @@ function composeManifestRequest(inputs, options2 = {}) {
     }))
   );
   if (includeAccountRegistryPermissions) {
-    resources.push(...accountRegistryPermissions());
-    resources.push(accountRegistryIndexPermission());
+    resources.push(
+      ...ACCOUNT_MANIFEST_PERMISSIONS.map((resource) => ({
+        ...resource,
+        actions: [...resource.actions]
+      }))
+    );
   }
   const resourcesWithImplicitCapabilities = withCapabilitiesReadForSpaces(resources);
   const manifestsByAppId = /* @__PURE__ */ new Map();
@@ -6360,15 +6944,28 @@ function normalizeSpace(space) {
 function isCapabilitySubset(requested, granted) {
   const missing = [];
   for (const req of requested) {
-    const match = granted.find((g) => canonicalizeEntryMatches(req, g));
-    if (match === void 0) {
+    const matchingScope = granted.filter(
+      (entry) => canonicalizeEntryScopeMatches(req, entry)
+    );
+    const requestedActions = expandActionShortNames(
+      req.service,
+      req.actions
+    );
+    const grantedActions = matchingScope.flatMap(
+      (entry) => expandActionShortNames(entry.service, entry.actions)
+    );
+    const covered = requestedActions.every(
+      (requestedAction) => grantedActions.some(
+        (grantedAction) => actionContains(grantedAction, requestedAction)
+      )
+    );
+    if (!covered) {
       missing.push(cloneEntry(req));
-      continue;
     }
   }
   return { subset: missing.length === 0, missing };
 }
-function canonicalizeEntryMatches(requested, granted) {
+function canonicalizeEntryScopeMatches(requested, granted) {
   if (requested.service !== granted.service) {
     return false;
   }
@@ -6378,15 +6975,6 @@ function canonicalizeEntryMatches(requested, granted) {
   if (!pathContains2(granted.path, requested.path)) {
     return false;
   }
-  const reqActions = new Set(
-    expandActionShortNames(requested.service, requested.actions)
-  );
-  const grantedActions = expandActionShortNames(granted.service, granted.actions);
-  for (const a of reqActions) {
-    if (!grantedActions.some((grantedAction) => actionContains(grantedAction, a))) {
-      return false;
-    }
-  }
   if (!recapCaveatsEqual(requested.caveats, granted.caveats)) {
     return false;
   }
@@ -6406,13 +6994,13 @@ function canonicalizeRecapCaveats(caveats) {
     }
     if (Array.isArray(value)) return `[${value.map(canonicalize).join(",")}]`;
     if (typeof value === "object") {
-      const object = value;
-      const prototype = Object.getPrototypeOf(object);
+      const object2 = value;
+      const prototype = Object.getPrototypeOf(object2);
       if (prototype !== Object.prototype && prototype !== null) {
         throw new Error("ReCap caveats must contain only JSON values.");
       }
-      return `{${Object.keys(object).sort().map(
-        (key) => `${JSON.stringify(key)}:${canonicalize(object[key])}`
+      return `{${Object.keys(object2).sort().map(
+        (key) => `${JSON.stringify(key)}:${canonicalize(object2[key])}`
       ).join(",")}}`;
     }
     throw new Error("ReCap caveats must contain only JSON values.");
@@ -6484,7 +7072,7 @@ function parseRecapCapabilities(parseWasm, siwe) {
 }
 
 // src/delegations/SharingService.ts
-import { ed25519 as ed255194 } from "@noble/curves/ed25519";
+import { ed25519 as ed255195 } from "@noble/curves/ed25519";
 
 // src/delegations/ShareRecipientClient.ts
 import {
@@ -6492,13 +7080,13 @@ import {
   KVService,
   ServiceContext
 } from "@tinycloud/sdk-services";
-import { ed25519 as ed255193 } from "@noble/curves/ed25519";
-import { sha256 as sha2567 } from "@noble/hashes/sha256";
+import { ed25519 as ed255194 } from "@noble/curves/ed25519";
+import { sha256 as sha2568 } from "@noble/hashes/sha256";
 
 // src/delegations/share-envelope.ts
-import { ed25519 as ed255192 } from "@noble/curves/ed25519";
-import { blake3 as blake32 } from "@noble/hashes/blake3";
-import { sha256 as sha2565 } from "@noble/hashes/sha256";
+import { ed25519 as ed255193 } from "@noble/curves/ed25519";
+import { blake3 as blake33 } from "@noble/hashes/blake3";
+import { sha256 as sha2566 } from "@noble/hashes/sha256";
 var ENVELOPE_SCHEMA = "xyz.tinycloud.share/envelope";
 var INLINE_PREFIX = "tc2:";
 var RAW_CID_CODEC = 85;
@@ -6547,8 +7135,8 @@ function canonicalJson(value) {
   }
   if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
   if (typeof value === "object") {
-    const object = value;
-    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(object[key])}`).join(",")}}`;
+    const object2 = value;
+    return `{${Object.keys(object2).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(object2[key])}`).join(",")}}`;
   }
   throw new ShareEnvelopeError("invalid-envelope", "unsupported JSON value");
 }
@@ -6654,6 +7242,10 @@ function normalizeRecipient(recipient) {
     }
     return { kind: recipient.kind, value: domain };
   }
+  if (recipient.kind === "recipientDid") {
+    if (!isCanonicalRecipientDid(recipient.value)) throw new ShareEnvelopeError("invalid-envelope", "recipient DID is invalid");
+    return { kind: recipient.kind, value: recipient.value };
+  }
   const exact = recipient.value.trim();
   const at = exact.lastIndexOf("@");
   const normalizedExact = at > 0 ? `${exact.slice(0, at)}@${exact.slice(at + 1).toLowerCase()}` : exact;
@@ -6662,6 +7254,28 @@ function normalizeRecipient(recipient) {
   }
   return { kind: recipient.kind, value: normalizedExact };
 }
+function isCanonicalRecipientDid(value) {
+  if (value.length === 0 || value.length > 2048 || /[\u0000-\u0020\u007f]/.test(value)) return false;
+  const parts = value.split(":");
+  if (parts.length < 3 || parts[0] !== "did" || !/^[a-z0-9]+$/.test(parts[1] ?? "")) return false;
+  const identifier = parts.slice(2);
+  if (identifier.some((part) => part.length === 0)) return false;
+  if (parts[1] === "web") {
+    const host = identifier[0] ?? "";
+    if (host.length > 253 || host.split(".").some((label) => !label || label.length > 63 || !/^[A-Za-z0-9-]+$/.test(label) || label.startsWith("-") || label.endsWith("-"))) return false;
+    return identifier.slice(1).every((part) => /^[A-Za-z0-9._%-]+$/.test(part));
+  }
+  if (parts[1] === "pkh") return identifier.length >= 3 && identifier.every((part) => /^[A-Za-z0-9._%-]+$/.test(part));
+  if (parts[1] === "key") {
+    try {
+      const bytes2 = base58btc.decode(identifier.join(":"));
+      return bytes2.length === 34 && bytes2[0] === 237 && bytes2[1] === 1;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
 function normalizeShareRecipientTarget(recipient) {
   const normalized = normalizeRecipient(recipient);
   if (normalized === void 0) throw new ShareEnvelopeError("invalid-envelope", "recipient matcher is required");
@@ -6691,17 +7305,17 @@ function createSharePolicy(input) {
   };
 }
 function contentDigest(bytes2) {
-  return bytesToBase64Url(sha2565(bytes2));
+  return bytesToBase64Url(sha2566(bytes2));
 }
 function computeShareCid(bytes2) {
-  const digest4 = create(BLAKE3_256_CODE, blake32(bytes2));
+  const digest4 = create(BLAKE3_256_CODE, blake33(bytes2));
   return CID.createV1(RAW_CID_CODEC, digest4).toString();
 }
 function verifyShareCid(cid2, bytes2) {
   try {
     const parsed = CID.parse(cid2);
     if (parsed.toString() !== cid2 || parsed.multihash.code !== BLAKE3_256_CODE) return false;
-    return parsed.equals(CID.createV1(parsed.code, create(parsed.multihash.code, blake32(bytes2))));
+    return parsed.equals(CID.createV1(parsed.code, create(parsed.multihash.code, blake33(bytes2))));
   } catch {
     return false;
   }
@@ -6711,7 +7325,7 @@ function envelopeSigningBytes(envelope) {
 }
 function signShareEnvelope(input) {
   if (input.signerPrivateKey.length !== 32) throw new ShareEnvelopeError("invalid-envelope", "Ed25519 private key must be 32 bytes");
-  const publicKey = ed255192.getPublicKey(input.signerPrivateKey);
+  const publicKey = ed255193.getPublicKey(input.signerPrivateKey);
   const unsigned = {
     schema: ENVELOPE_SCHEMA,
     version: 2,
@@ -6726,7 +7340,7 @@ function signShareEnvelope(input) {
     expiresAt: new Date(input.expiresAt).toISOString(),
     signer: { did: input.signerDid, publicKey: bytesToBase64Url(publicKey) }
   };
-  return { ...unsigned, signature: bytesToBase64Url(ed255192.sign(envelopeSigningBytes(unsigned), input.signerPrivateKey)) };
+  return { ...unsigned, signature: bytesToBase64Url(ed255193.sign(envelopeSigningBytes(unsigned), input.signerPrivateKey)) };
 }
 function verifyShareEnvelope(envelope, options2 = {}) {
   try {
@@ -6748,9 +7362,9 @@ function verifyShareEnvelope(envelope, options2 = {}) {
     const recipient = normalizeRecipient(envelope.recipient);
     if (recipient !== void 0 && JSON.stringify(recipient) !== JSON.stringify(envelope.recipient)) throw new ShareEnvelopeError("invalid-envelope", "recipient is not canonical");
     if (recipient?.kind === "exactEmail" || recipient?.kind === "emailDomain") throw new ShareEnvelopeError("unsafe-plaintext", "recipient matchers are not public envelope fields");
-    if (envelope.recipientKind !== void 0 && !["exactEmail", "emailDomain", "bearer"].includes(envelope.recipientKind)) throw new ShareEnvelopeError("invalid-envelope", "recipient mode is invalid");
+    if (envelope.recipientKind !== void 0 && !["exactEmail", "emailDomain", "recipientDid", "bearer"].includes(envelope.recipientKind)) throw new ShareEnvelopeError("invalid-envelope", "recipient mode is invalid");
     if (envelope.recipientKind === "bearer" && recipient?.kind !== void 0 && recipient.kind !== "bearer") throw new ShareEnvelopeError("invalid-envelope", "recipient mode does not match recipient");
-    if ((envelope.recipientKind === "exactEmail" || envelope.recipientKind === "emailDomain") && !envelope.encrypted) throw new ShareEnvelopeError("unsafe-plaintext", "policy shares require encryption");
+    if ((envelope.recipientKind === "exactEmail" || envelope.recipientKind === "emailDomain" || envelope.recipientKind === "recipientDid") && !envelope.encrypted) throw new ShareEnvelopeError("unsafe-plaintext", "addressed shares require encryption");
     if (typeof envelope.spaceId !== "string" || envelope.spaceId.length === 0 || typeof envelope.content.mimeType !== "string" || envelope.content.mimeType.length === 0 || typeof envelope.content.digest !== "string" || !/^[A-Za-z0-9_-]+$/.test(envelope.content.digest)) throw new ShareEnvelopeError("invalid-envelope", "content metadata is invalid");
     const maxContentBytes = envelope.encrypted ? options2.maxSealedContentBytes ?? MAX_SEALED_SHARE_CONTENT_BYTES : options2.maxContentBytes ?? MAX_SHARE_CONTENT_BYTES;
     if (!Number.isInteger(envelope.content.size) || envelope.content.size < 0 || envelope.content.size > maxContentBytes) throw new ShareEnvelopeError("content-too-large", "share content exceeds the configured limit");
@@ -6758,7 +7372,7 @@ function verifyShareEnvelope(envelope, options2 = {}) {
     const signature = base64UrlToBytes(envelope.signature);
     const unsigned = { ...envelope };
     delete unsigned.signature;
-    if (publicKey.length !== 32 || signature.length !== 64 || !ed255192.verify(signature, envelopeSigningBytes(unsigned), publicKey)) throw new ShareEnvelopeError("signature-invalid", "share envelope signature is invalid");
+    if (publicKey.length !== 32 || signature.length !== 64 || !ed255193.verify(signature, envelopeSigningBytes(unsigned), publicKey)) throw new ShareEnvelopeError("signature-invalid", "share envelope signature is invalid");
     if (options2.trustedSignerDids !== void 0 && envelope.recipientKind !== void 0 && !options2.trustedSignerDids.includes(envelope.signer.did)) throw new ShareEnvelopeError("signature-invalid", "share signer is not trusted");
     return envelope;
   } catch (error) {
@@ -6806,7 +7420,7 @@ function encodeInlineShareUrl(input) {
 }
 var PUBLISHED_AAD = new TextEncoder().encode("tinycloud-share-envelope-v1");
 function publishedCid(bytes2) {
-  return CID.create(1, code, create(sha2562.code, sha2565(bytes2))).toString();
+  return CID.create(1, code, create(sha2562.code, sha2566(bytes2))).toString();
 }
 function isPublishedCid(value) {
   try {
@@ -6846,7 +7460,7 @@ function publishedArtifact(envelope, plaintext, policy) {
       content: {
         mimeType: "application/octet-stream",
         size: plaintext.byteLength,
-        digest: bytesToBase64Url(sha2565(plaintext))
+        digest: bytesToBase64Url(sha2566(plaintext))
       },
       // Addressed policy metadata is confidential even though this function
       // is called after the outer envelope has been opened. Keep the
@@ -6889,7 +7503,7 @@ function parsePolicyMetadata(policyBytes, target, expectedExpiry) {
     assertKeys(policy, ["type", "version", "issuerDid", "recipientMatcher", "target", "delegation", "authority", "actions", "resource", "content-source", "expiresAt"], "published canonical policy material");
     if (typeof policy.issuerDid !== "string" || typeof policy.expiresAt !== "string" || policy.expiresAt !== expectedExpiry) throw new ShareEnvelopeError("invalid-envelope", "policy expiry is not bound to the envelope");
     const matcherValue = policy.recipientMatcher;
-    if (!isPlainObject(matcherValue) || matcherValue.kind !== "exactEmail" && matcherValue.kind !== "emailDomain" || typeof matcherValue.value !== "string") throw new ShareEnvelopeError("invalid-envelope", "policy matcher is invalid");
+    if (!isPlainObject(matcherValue) || matcherValue.kind !== "exactEmail" && matcherValue.kind !== "emailDomain" && matcherValue.kind !== "recipientDid" || typeof matcherValue.value !== "string") throw new ShareEnvelopeError("invalid-envelope", "policy matcher is invalid");
     const matcher2 = normalizeRecipient(matcherValue);
     if (matcher2 === void 0 || matcher2.kind === "bearer") throw new ShareEnvelopeError("invalid-envelope", "policy matcher is invalid");
     if (!isPlainObject(policy.target)) throw new ShareEnvelopeError("invalid-envelope", "policy target is invalid");
@@ -6950,9 +7564,9 @@ function parsePolicyMetadata(policyBytes, target, expectedExpiry) {
     assertKeys(source, ["kind", "space", "database", "path", "statement", "arguments", "argumentsDigest", "action"], "published SQL content source");
     if (typeof source.space !== "string" || typeof source.database !== "string" || typeof source.path !== "string" || typeof source.statement !== "string" || !source.arguments || typeof source.arguments !== "object" || Array.isArray(source.arguments) || typeof source.argumentsDigest !== "string" || source.action !== "tinycloud.sql/read") throw new ShareEnvelopeError("invalid-envelope", "published SQL content source is invalid");
     for (const argument of Object.values(source.arguments)) if (!Number.isSafeInteger(argument)) throw new ShareEnvelopeError("invalid-envelope", "published SQL arguments are invalid");
-    if (bytesToBase64Url(sha2565(new TextEncoder().encode(canonicalJson(source.arguments)))) !== source.argumentsDigest) throw new ShareEnvelopeError("invalid-envelope", "published SQL argument digest is invalid");
+    if (bytesToBase64Url(sha2566(new TextEncoder().encode(canonicalJson(source.arguments)))) !== source.argumentsDigest) throw new ShareEnvelopeError("invalid-envelope", "published SQL argument digest is invalid");
   } else throw new ShareEnvelopeError("invalid-envelope", "policy content source kind is invalid");
-  if (typeof policy.contentSourceDigest !== "string" || bytesToBase64Url(sha2565(new TextEncoder().encode(canonicalJson(source)))) !== policy.contentSourceDigest) throw new ShareEnvelopeError("invalid-envelope", "policy content source digest is invalid");
+  if (typeof policy.contentSourceDigest !== "string" || bytesToBase64Url(sha2566(new TextEncoder().encode(canonicalJson(source)))) !== policy.contentSourceDigest) throw new ShareEnvelopeError("invalid-envelope", "policy content source digest is invalid");
   return { recipientKind, actions, resource };
 }
 function parseCanonicalPublishedV2(value, options2) {
@@ -6976,7 +7590,7 @@ function parseCanonicalPublishedV2(value, options2) {
   if (!Number.isFinite(expiry) || expiry <= (options2.now ?? /* @__PURE__ */ new Date()).getTime() || new Date(expiry).toISOString() !== value.expiry) throw new ShareEnvelopeError("expired", "published share envelope has expired");
   if (typeof delegation.cid !== "string" || typeof delegation.issuerDid !== "string" || typeof delegation.audience !== "string" || typeof delegation.expiresAt !== "string" || Date.parse(delegation.expiresAt) > expiry) throw new ShareEnvelopeError("invalid-envelope", "published v2 delegation is invalid");
   const matcher = value.recipientMatcher;
-  if (!isPlainObject(matcher) || matcher.kind !== "exactEmail" && matcher.kind !== "emailDomain" || typeof matcher.value !== "string") throw new ShareEnvelopeError("invalid-envelope", "published v2 recipient matcher is invalid");
+  if (!isPlainObject(matcher) || matcher.kind !== "exactEmail" && matcher.kind !== "emailDomain" && matcher.kind !== "recipientDid" || typeof matcher.value !== "string") throw new ShareEnvelopeError("invalid-envelope", "published v2 recipient matcher is invalid");
   const normalizedMatcher = normalizeRecipient(matcher);
   if (normalizedMatcher === void 0 || normalizedMatcher.kind === "bearer") throw new ShareEnvelopeError("invalid-envelope", "published v2 recipient matcher is invalid");
   if (!Array.isArray(value.actions)) throw new ShareEnvelopeError("invalid-envelope", "published v2 actions are invalid");
@@ -7000,7 +7614,7 @@ function parseCanonicalPublishedV2(value, options2) {
   const signingBytes = new Uint8Array(domain.length + body.length);
   signingBytes.set(domain);
   signingBytes.set(body, domain.length);
-  if (signatureBytes.length !== 64 || !ed255192.verify(signatureBytes, signingBytes, signerKey)) throw new ShareEnvelopeError("signature-invalid", "published v2 envelope signature is invalid");
+  if (signatureBytes.length !== 64 || !ed255193.verify(signatureBytes, signingBytes, signerKey)) throw new ShareEnvelopeError("signature-invalid", "published v2 envelope signature is invalid");
   const content = options2.plaintext ?? new Uint8Array();
   const normalized = {
     schema: ENVELOPE_SCHEMA,
@@ -7010,7 +7624,7 @@ function parseCanonicalPublishedV2(value, options2) {
     recipientKind: normalizedMatcher.kind,
     resource,
     actions,
-    content: { mimeType: typeof contentSource.mimeType === "string" ? contentSource.mimeType : "application/octet-stream", size: content.byteLength, digest: bytesToBase64Url(sha2565(content)) },
+    content: { mimeType: typeof contentSource.mimeType === "string" ? contentSource.mimeType : "application/octet-stream", size: content.byteLength, digest: bytesToBase64Url(sha2566(content)) },
     encrypted: true,
     expiresAt: value.expiry,
     signer: { did: signature.signerDid, publicKey: bytesToBase64Url(signerKey) },
@@ -7109,7 +7723,7 @@ function parsePublishedShareEnvelope(bytes2, options2 = {}) {
   if (envelope.authorizationTarget.kind !== "bearerKey" && (options2.trustedSignerDids === void 0 || !options2.trustedSignerDids.includes(envelope.signature.signerDid))) throw new ShareEnvelopeError("signature-invalid", "a trusted authority is required for addressed shares");
   const signature = base64UrlToBytes(envelope.signature.value);
   const publicKey = publishedPublicKey(envelope.signature.signerDid);
-  if (signature.length !== 64 || !ed255192.verify(signature, publishedEnvelopeSigningBytes(envelope), publicKey)) throw new ShareEnvelopeError("signature-invalid", "published envelope signature is invalid");
+  if (signature.length !== 64 || !ed255193.verify(signature, publishedEnvelopeSigningBytes(envelope), publicKey)) throw new ShareEnvelopeError("signature-invalid", "published envelope signature is invalid");
   return { envelope, artifact: publishedArtifact(envelope, options2.plaintext ?? new Uint8Array(), policy) };
 }
 function parseLegacyPublishedShareEnvelope(bytes2, options2 = {}) {
@@ -7148,7 +7762,7 @@ function parseLegacyPublishedShareEnvelope(bytes2, options2 = {}) {
   const signingBytes = new Uint8Array(domain.length + body.length);
   signingBytes.set(domain);
   signingBytes.set(body, domain.length);
-  if (signatureBytes.length !== 64 || !ed255192.verify(signatureBytes, signingBytes, signerKey)) throw new ShareEnvelopeError("signature-invalid", "published v1 envelope signature is invalid");
+  if (signatureBytes.length !== 64 || !ed255193.verify(signatureBytes, signingBytes, signerKey)) throw new ShareEnvelopeError("signature-invalid", "published v1 envelope signature is invalid");
   const content = options2.plaintext ?? new Uint8Array();
   const artifact = {
     envelope: {
@@ -7159,7 +7773,7 @@ function parseLegacyPublishedShareEnvelope(bytes2, options2 = {}) {
       resource: { kind: resource.kind, path: resource.path },
       recipientKind: authorizationTarget.kind === "bearer" ? "bearer" : authorizationTarget.kind === "exact-email" ? "exactEmail" : authorizationTarget.kind === "email-domain" ? "emailDomain" : void 0,
       actions: ["read"],
-      content: { mimeType: "application/octet-stream", size: content.byteLength, digest: bytesToBase64Url(sha2565(content)) },
+      content: { mimeType: "application/octet-stream", size: content.byteLength, digest: bytesToBase64Url(sha2566(content)) },
       encrypted: true,
       expiresAt: envelope.expiry,
       signer: { did: signature.signerDid, publicKey: bytesToBase64Url(signerKey) },
@@ -7346,15 +7960,15 @@ function shareCapabilityAllows(capability, action, path) {
 }
 
 // src/delegations/ShareCache.ts
-import { sha256 as sha2566 } from "@noble/hashes/sha256";
+import { sha256 as sha2567 } 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 digest2(bytes2) {
-  return sha2566(bytes2);
+  return sha2567(bytes2);
 }
-function equalBytes(left, right) {
+function equalBytes2(left, right) {
   if (left.byteLength !== right.byteLength) return false;
   return left.every((byte, index) => byte === right[index]);
 }
@@ -7367,7 +7981,7 @@ var MemoryShareCache = class {
     const mapKey = cacheKey(key);
     const entry = this.entries.get(mapKey);
     if (entry === void 0) return void 0;
-    if (Date.parse(entry.key.expiresAt) <= now.getTime() || !equalBytes(entry.digest, digest2(entry.bytes))) {
+    if (Date.parse(entry.key.expiresAt) <= now.getTime() || !equalBytes2(entry.digest, digest2(entry.bytes))) {
       this.entries.delete(mapKey);
       return void 0;
     }
@@ -7376,7 +7990,7 @@ var MemoryShareCache = class {
   async getByCid(cid2, now = /* @__PURE__ */ new Date()) {
     const entries = [...this.entries.values()].filter((entry) => entry.key.cid === cid2);
     for (const entry of entries) {
-      if (Date.parse(entry.key.expiresAt) <= now.getTime() || !equalBytes(entry.digest, digest2(entry.bytes))) {
+      if (Date.parse(entry.key.expiresAt) <= now.getTime() || !equalBytes2(entry.digest, digest2(entry.bytes))) {
         this.entries.delete(cacheKey(entry.key));
         continue;
       }
@@ -7417,144 +8031,243 @@ var ShareConflict = class extends Error {
   }
 };
 var ShareAccessError = class extends Error {
-  constructor(code3, message) {
+  constructor(code3, message, details) {
     super(message ?? "shared access could not be completed");
     this.name = "ShareAccessError";
     this.code = code3;
+    this.details = details;
   }
 };
 
 // src/delegations/recipient-types.schema.ts
-import { z as z5 } from "zod";
-var ShareRecipientTargetSchema = z5.discriminatedUnion("kind", [
-  z5.object({ kind: z5.literal("exactEmail"), value: z5.string().min(1) }).strict(),
-  z5.object({ kind: z5.literal("emailDomain"), value: z5.string().min(1) }).strict(),
-  z5.object({ kind: z5.literal("bearer") }).strict()
+import { z as z6 } from "zod";
+var ShareRecipientTargetSchema = z6.discriminatedUnion("kind", [
+  z6.object({ kind: z6.literal("exactEmail"), value: z6.string().min(1) }).strict(),
+  z6.object({ kind: z6.literal("emailDomain"), value: z6.string().min(1) }).strict(),
+  z6.object({ kind: z6.literal("recipientDid"), value: z6.string().regex(/^did:[a-z0-9]+:.+$/) }).strict(),
+  z6.object({ kind: z6.literal("bearer") }).strict()
 ]);
-var ShareResourceSchema = z5.discriminatedUnion("kind", [
-  z5.object({ kind: z5.literal("exact"), path: z5.string().min(1) }).strict(),
-  z5.object({ kind: z5.literal("prefix"), path: z5.string().min(1) }).strict()
+var ShareResourceSchema = z6.discriminatedUnion("kind", [
+  z6.object({ kind: z6.literal("exact"), path: z6.string().min(1) }).strict(),
+  z6.object({ kind: z6.literal("prefix"), path: z6.string().min(1) }).strict()
 ]);
-var ShareActionSchema = z5.enum(["read", "list", "edit"]);
-var ShareRecipientPolicySchema = z5.object({
+var ShareActionSchema = z6.enum(["read", "list", "edit"]);
+var ShareRecipientPolicySchema = z6.object({
   recipientMatcher: ShareRecipientTargetSchema,
-  spaceId: z5.string().min(1),
+  spaceId: z6.string().min(1),
   resource: ShareResourceSchema,
-  actions: z5.array(ShareActionSchema).min(1),
-  expiresAt: z5.date()
+  actions: z6.array(ShareActionSchema).min(1),
+  expiresAt: z6.date()
 }).strict();
-var ShareRecipientClientOptionsSchema = z5.object({
-  trustedOrigins: z5.array(z5.string().url()).min(1),
-  maxInlineBytes: z5.number().int().positive().optional(),
-  maxArtifactBytes: z5.number().int().positive().optional(),
-  maxContentBytes: z5.number().int().positive().optional(),
-  maxSealedContentBytes: z5.number().int().positive().optional()
+var ShareRecipientClientOptionsSchema = z6.object({
+  trustedOrigins: z6.array(z6.string().url()).min(1),
+  maxInlineBytes: z6.number().int().positive().optional(),
+  maxArtifactBytes: z6.number().int().positive().optional(),
+  maxContentBytes: z6.number().int().positive().optional(),
+  maxSealedContentBytes: z6.number().int().positive().optional()
 }).strict();
-var ShareNativeActionSchema = z5.enum(["tinycloud.kv/get", "tinycloud.kv/metadata", "tinycloud.kv/list", "tinycloud.kv/put"]);
-var ShareWireActionSchema = z5.enum(["tinycloud.kv/get", "tinycloud.kv/metadata", "tinycloud.kv/list", "tinycloud.kv/put", "tinycloud.sql/read"]);
-var ShareContentSourceSchema = z5.discriminatedUnion("kind", [
-  z5.object({
-    kind: z5.literal("kv"),
+var ShareNativeActionSchema = z6.enum(["tinycloud.kv/get", "tinycloud.kv/metadata", "tinycloud.kv/list", "tinycloud.kv/put"]);
+var ShareWireActionSchema = z6.enum(["tinycloud.kv/get", "tinycloud.kv/metadata", "tinycloud.kv/list", "tinycloud.kv/put", "tinycloud.sql/read"]);
+var ShareContentSourceSchema = z6.discriminatedUnion("kind", [
+  z6.object({
+    kind: z6.literal("kv"),
     action: ShareNativeActionSchema,
-    space: z5.string().min(1),
-    path: z5.string().min(1)
+    space: z6.string().min(1),
+    path: z6.string().min(1)
   }).strict(),
-  z5.object({
-    kind: z5.literal("sql"),
-    action: z5.literal("tinycloud.sql/read"),
-    space: z5.string().min(1),
-    database: z5.string().min(1),
-    path: z5.string().min(1),
-    statement: z5.string().min(1),
-    arguments: z5.record(z5.number().int().safe()),
-    argumentsDigest: z5.string().min(1)
+  z6.object({
+    kind: z6.literal("sql"),
+    action: z6.literal("tinycloud.sql/read"),
+    space: z6.string().min(1),
+    database: z6.string().min(1),
+    path: z6.string().min(1),
+    statement: z6.string().min(1),
+    arguments: z6.record(z6.number().int().safe()),
+    argumentsDigest: z6.string().min(1)
   }).strict()
 ]);
-var ShareAddressedRecipientSchema = z5.discriminatedUnion("kind", [
-  z5.object({ kind: z5.literal("exactEmail"), value: z5.string().min(1) }).strict(),
-  z5.object({ kind: z5.literal("emailDomain"), value: z5.string().min(1) }).strict()
+var ShareAddressedRecipientSchema = z6.discriminatedUnion("kind", [
+  z6.object({ kind: z6.literal("exactEmail"), value: z6.string().min(1) }).strict(),
+  z6.object({ kind: z6.literal("emailDomain"), value: z6.string().min(1) }).strict(),
+  z6.object({ kind: z6.literal("recipientDid"), value: z6.string().regex(/^did:[a-z0-9]+:.+$/) }).strict()
 ]);
-var ShareAddressedDelegationRequestV2Schema = z5.object({
-  version: z5.literal(2),
-  nonce: z5.string().min(1),
-  jti: z5.string().min(1),
-  senderDid: z5.string().min(1),
+var ShareAddressedDelegationRequestV2Schema = z6.object({
+  version: z6.literal(2),
+  nonce: z6.string().min(1),
+  jti: z6.string().min(1),
+  senderDid: z6.string().min(1),
   recipientMatcher: ShareAddressedRecipientSchema,
-  targetOrigin: z5.string().url(),
-  nodeAudience: z5.string().min(1),
-  shareCid: z5.string().min(1),
-  shareId: z5.string().min(1),
-  delegationCid: z5.string().min(1),
-  authorityMaterialHandle: z5.string().min(1),
-  authorityMaterialDigest: z5.string().min(1),
+  targetOrigin: z6.string().url(),
+  nodeAudience: z6.string().min(1),
+  shareCid: z6.string().min(1),
+  shareId: z6.string().min(1),
+  delegationCid: z6.string().min(1),
+  authorityMaterialHandle: z6.string().min(1),
+  authorityMaterialDigest: z6.string().min(1),
   contentSource: ShareContentSourceSchema,
-  contentSourceDigest: z5.string().min(1),
-  actions: z5.array(ShareWireActionSchema).min(1).refine((actions) => new Set(actions).size === actions.length),
-  resource: z5.object({ kind: z5.enum(["exact", "prefix"]), value: z5.string().min(1) }).strict(),
-  expiresAt: z5.string().datetime({ offset: true }),
-  requestBodyDigest: z5.string().min(1)
+  contentSourceDigest: z6.string().min(1),
+  actions: z6.array(ShareWireActionSchema).min(1).refine((actions) => new Set(actions).size === actions.length),
+  resource: z6.object({ kind: z6.enum(["exact", "prefix"]), value: z6.string().min(1) }).strict(),
+  expiresAt: z6.string().datetime({ offset: true }),
+  requestBodyDigest: z6.string().min(1)
 }).strict();
-var ShareAddressedDelegationEnvelopeV2Schema = z5.object({
+var ShareAddressedDelegationEnvelopeV2Schema = z6.object({
   request: ShareAddressedDelegationRequestV2Schema,
-  proof: z5.object({ alg: z5.literal("EdDSA"), kid: z5.string().min(1), signature: z5.string().min(1) }).strict()
+  proof: z6.object({ alg: z6.literal("EdDSA"), kid: z6.string().min(1), signature: z6.string().min(1) }).strict()
 }).strict();
-var ShareAddressedDelegationResponseV2Schema = z5.object({
-  type: z5.literal("TinyCloudShareAddressedDelegation"),
-  version: z5.literal(2),
-  nonce: z5.string().min(1),
-  jti: z5.string().min(1),
-  policyCid: z5.string().min(1),
-  policyBytes: z5.string().min(1),
-  policyDigest: z5.string().min(1),
-  delegationCid: z5.string().min(1),
-  delegationBytes: z5.string().min(1),
-  delegationDigest: z5.string().min(1),
-  authorityMaterialHandle: z5.string().min(1),
-  authorityMaterialDigest: z5.string().min(1),
-  actions: z5.array(ShareWireActionSchema).min(1).refine((actions) => new Set(actions).size === actions.length),
-  resource: z5.object({ kind: z5.enum(["exact", "prefix"]), value: z5.string().min(1) }).strict(),
-  expiresAt: z5.string().datetime({ offset: true }),
-  proof: z5.object({ alg: z5.literal("EdDSA"), kid: z5.string().min(1), signature: z5.string().min(1) }).strict()
+var ShareAddressedDelegationResponseV2Schema = z6.object({
+  type: z6.literal("TinyCloudShareAddressedDelegation"),
+  version: z6.literal(2),
+  nonce: z6.string().min(1),
+  jti: z6.string().min(1),
+  policyCid: z6.string().min(1),
+  policyBytes: z6.string().min(1),
+  policyDigest: z6.string().min(1),
+  delegationCid: z6.string().min(1),
+  delegationBytes: z6.string().min(1),
+  delegationDigest: z6.string().min(1),
+  authorityMaterialHandle: z6.string().min(1),
+  authorityMaterialDigest: z6.string().min(1),
+  actions: z6.array(ShareWireActionSchema).min(1).refine((actions) => new Set(actions).size === actions.length),
+  resource: z6.object({ kind: z6.enum(["exact", "prefix"]), value: z6.string().min(1) }).strict(),
+  expiresAt: z6.string().datetime({ offset: true }),
+  proof: z6.object({ alg: z6.literal("EdDSA"), kid: z6.string().min(1), signature: z6.string().min(1) }).strict()
 }).strict();
-var ShareNativeResponseEntrySchema = z5.object({
-  path: z5.string().min(1),
-  kind: z5.enum(["file", "folder"])
+var ShareNativeResponseEntrySchema = z6.object({
+  path: z6.string().min(1),
+  kind: z6.enum(["file", "folder"])
 }).strict();
 var ShareNativeResponseBase = {
-  type: z5.literal("TinyCloudShareInvokeResponse"),
-  version: z5.literal(2),
-  resource: z5.string().min(1)
+  type: z6.literal("TinyCloudShareInvokeResponse"),
+  version: z6.literal(2),
+  resource: z6.string().min(1)
 };
-var ShareNativeResponseSchema = z5.discriminatedUnion("action", [
-  z5.object({
+var ShareNativeResponseSchema = z6.discriminatedUnion("action", [
+  z6.object({
     ...ShareNativeResponseBase,
-    action: z5.literal("tinycloud.kv/metadata"),
-    metadata: z5.record(z5.string()),
-    etag: z5.string().min(1).nullable()
+    action: z6.literal("tinycloud.kv/metadata"),
+    metadata: z6.record(z6.string()),
+    etag: z6.string().min(1).nullable()
   }).strict(),
-  z5.object({
+  z6.object({
     ...ShareNativeResponseBase,
-    action: z5.literal("tinycloud.kv/get"),
-    mediaType: z5.string().min(1),
-    content: z5.string(),
-    bodyDigest: z5.string().min(1),
-    etag: z5.string().min(1).nullable()
+    action: z6.literal("tinycloud.kv/get"),
+    mediaType: z6.string().min(1),
+    content: z6.string(),
+    bodyDigest: z6.string().min(1),
+    etag: z6.string().min(1).nullable()
   }).strict(),
-  z5.object({
+  z6.object({
     ...ShareNativeResponseBase,
-    action: z5.literal("tinycloud.kv/list"),
-    entries: z5.array(ShareNativeResponseEntrySchema),
-    nextCursor: z5.string().min(1).nullable()
+    action: z6.literal("tinycloud.kv/list"),
+    entries: z6.array(ShareNativeResponseEntrySchema),
+    nextCursor: z6.string().min(1).nullable()
   }).strict(),
-  z5.object({
+  z6.object({
     ...ShareNativeResponseBase,
-    action: z5.literal("tinycloud.kv/put"),
-    etag: z5.string().min(1),
-    bodyDigest: z5.string().min(1),
-    contentType: z5.string().min(1)
+    action: z6.literal("tinycloud.kv/put"),
+    etag: z6.string().min(1),
+    bodyDigest: z6.string().min(1),
+    contentType: z6.string().min(1)
   }).strict()
 ]);
 
+// src/delegations/portable.ts
+import { z as z7 } from "zod";
+var ResourceSchema = z7.object({
+  service: z7.string().min(1),
+  space: z7.string().min(1),
+  path: z7.string(),
+  actions: z7.array(z7.string().min(1)).min(1),
+  caveats: z7.array(z7.record(z7.unknown())).optional()
+}).strict();
+var PortableDelegationSchema = z7.object({
+  cid: z7.string().min(1),
+  delegationHeader: z7.object({ Authorization: z7.string().min(1) }).strict(),
+  ownerAddress: z7.string().min(1),
+  chainId: z7.number().int().nonnegative(),
+  host: z7.string().url().optional(),
+  spaceId: z7.string().min(1),
+  path: z7.string(),
+  actions: z7.array(z7.string().min(1)).min(1),
+  caveats: z7.array(z7.record(z7.unknown())).optional(),
+  expiry: z7.coerce.date(),
+  delegateDID: z7.string().min(1),
+  delegatorDID: z7.string().min(1).optional(),
+  parentCid: z7.string().min(1).optional(),
+  disableSubDelegation: z7.boolean().optional(),
+  resources: z7.array(ResourceSchema).min(1).optional()
+}).strict();
+function parsePortableDelegation(input) {
+  const parsed = PortableDelegationSchema.parse(input);
+  if (parsed.resources !== void 0 && parsed.resources.length === 0)
+    throw new Error("portable delegation resources must not be empty");
+  return parsed;
+}
+function serializePortableDelegation(delegation) {
+  return JSON.stringify({
+    ...delegation,
+    expiry: delegation.expiry.toISOString()
+  });
+}
+async function importPortableDelegation(fetchFn, host, delegation) {
+  const parsed = parsePortableDelegation(delegation);
+  const response = await fetchFn(`${host.replace(/\/+$/, "")}/delegate`, {
+    method: "POST",
+    headers: { Authorization: parsed.delegationHeader.Authorization }
+  });
+  if (!response.ok)
+    throw new Error(`node rejected delegation import (${response.status})`);
+  const body = await response.json().catch(() => ({}));
+  if (body === null || typeof body !== "object" || Array.isArray(body))
+    return {};
+  return body;
+}
+async function delegatePortablePolicySession(input) {
+  const parent = parsePortableDelegation(input.parent);
+  const descendant = createCompactPolicyDescendant({
+    parentAuthorization: parent.delegationHeader.Authorization.replace(/^Bearer\s+/i, ""),
+    parentCid: parent.cid,
+    issuerDid: parent.delegateDID,
+    audienceDid: input.delegateDID,
+    attenuation: input.attenuation,
+    privateKey: input.issuerPrivateKey,
+    ...input.now === void 0 ? {} : { now: input.now },
+    ...input.expiresAt === void 0 ? {} : { expiresAt: input.expiresAt },
+    ...input.nonce === void 0 ? {} : { nonce: input.nonce }
+  });
+  const resources = Object.entries(descendant.payload.att).map(([resource, abilities]) => {
+    const actions = Object.keys(abilities);
+    if (resource.startsWith("urn:tinycloud:encryption:")) {
+      return { service: "encryption", space: "encryption", path: resource, actions };
+    }
+    const match = /^tinycloud:\/\/([^/]+)\/kv\/(.+)$/.exec(resource);
+    if (match === null) throw new Error("policy descendant resource is invalid");
+    const caveats = Object.values(abilities).flat().filter((value) => value !== null && typeof value === "object" && !Array.isArray(value));
+    return { service: "kv", space: match[1], path: match[2], actions, ...caveats.length === 0 ? {} : { caveats } };
+  });
+  const primary = resources.find((resource) => resource.service === "kv") ?? resources[0];
+  if (primary === void 0) throw new Error("policy descendant attenuation is empty");
+  const portable = {
+    cid: descendant.cid,
+    delegationHeader: { Authorization: descendant.authorization },
+    ownerAddress: parent.ownerAddress,
+    chainId: parent.chainId,
+    host: input.host,
+    spaceId: primary.space,
+    path: primary.path,
+    actions: primary.actions,
+    expiry: new Date(descendant.payload.exp * 1e3),
+    delegateDID: input.delegateDID,
+    delegatorDID: parent.delegateDID,
+    parentCid: parent.cid,
+    disableSubDelegation: descendant.payload.fct[0]?.remainingRedelegationDepth === 0,
+    resources
+  };
+  await importPortableDelegation(input.fetch, input.host, portable);
+  return portable;
+}
+
 // src/delegations/ShareRecipientClient.ts
 var DEFAULT_MAX_ARTIFACT_BYTES2 = MAX_SHARE_ARTIFACT_BYTES;
 var DEFAULT_MAX_CONTENT_BYTES = MAX_SHARE_CONTENT_BYTES;
@@ -7605,8 +8318,8 @@ function canonicalJsonForProof(value) {
   }
   if (Array.isArray(value)) return `[${value.map(canonicalJsonForProof).join(",")}]`;
   if (typeof value === "object") {
-    const object = value;
-    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalJsonForProof(object[key])}`).join(",")}}`;
+    const object2 = value;
+    return `{${Object.keys(object2).sort().map((key) => `${JSON.stringify(key)}:${canonicalJsonForProof(object2[key])}`).join(",")}}`;
   }
   throw new ShareAccessError("SHARE_SESSION_INVALID");
 }
@@ -7630,7 +8343,7 @@ function randomJti() {
   return bytesToBase64Url2(bytes2);
 }
 function digestCanonical(value) {
-  return bytesToBase64Url2(sha2567(new TextEncoder().encode(canonicalJsonForProof(value))));
+  return bytesToBase64Url2(sha2568(new TextEncoder().encode(canonicalJsonForProof(value))));
 }
 function actionWire(action) {
   return action === "get" ? "tinycloud.kv/get" : action === "metadata" ? "tinycloud.kv/metadata" : action === "list" ? "tinycloud.kv/list" : "tinycloud.kv/put";
@@ -7727,15 +8440,46 @@ var ShareRecipientClient = class {
       const { envelope } = resolved.artifact;
       const { location } = resolved;
       const bearer = isBearerEnvelope(envelope);
-      const policy = envelope.recipientKind === "exactEmail" || envelope.recipientKind === "emailDomain";
+      const policy = envelope.recipientKind === "exactEmail" || envelope.recipientKind === "emailDomain" || envelope.authorizationTargetKind === "recipientDid";
       const legacyBearer = !policy && envelope.recipientKind === void 0;
-      if (envelope.authorizationTargetKind === "recipientDid") throw new ShareAccessError("SHARE_RECIPIENT_DID_UNSUPPORTED");
+      let recipientDidSession;
+      if (envelope.authorizationTargetKind === "recipientDid") {
+        if (this.options.establishRecipientDidSession === void 0) throw new ShareAccessError("SHARE_DEVICE_AUTH_REQUIRED", "an OpenKey device authorization is required");
+        const authorization = await this.options.establishRecipientDidSession({ envelope, recipientDid: envelope.recipient?.kind === "recipientDid" ? envelope.recipient.value : "" });
+        if ("state" in authorization) {
+          if (authorization.state === "authorization-required") throw new ShareAccessError("SHARE_DEVICE_AUTH_REQUIRED", "an OpenKey device authorization is required", authorization);
+          throw new ShareAccessError("SHARE_DENIED", "recipient DID authorization was denied", authorization);
+        }
+        recipientDidSession = authorization;
+      }
       if (policy && this.options.bearerSession !== void 0) throw new ShareAccessError("SHARE_POLICY_BEARER_MISMATCH");
       if (bearer && this.options.presentation !== void 0) throw new ShareAccessError("SHARE_BEARER_PRESENTATION_MISMATCH");
-      const session = bearer || legacyBearer ? this.options.bearerSession : policy && this.options.establishPolicySession !== void 0 ? await this.options.establishPolicySession({ envelope, presentation: this.options.presentation }) : policy ? await this.establishPolicySession(envelope) : void 0;
-      const kv = bearer || legacyBearer ? session === void 0 ? void 0 : this.createKV(envelope.origin, session) : void 0;
+      const session = bearer || legacyBearer ? this.options.bearerSession : recipientDidSession ? recipientDidSession : policy && this.options.establishPolicySession !== void 0 ? await this.options.establishPolicySession({ envelope, presentation: this.options.presentation }) : policy ? await this.establishPolicySession(envelope) : void 0;
       const policySession = policy ? session : void 0;
       if (policySession !== void 0) this.assertProvidedPolicySession(policySession, envelope);
+      const portableDelegation = policySession === void 0 ? void 0 : this.policySessionDelegation(policySession, envelope.origin);
+      const portableInvoke = portableDelegation === void 0 ? void 0 : this.policyInvocationSigner(portableDelegation);
+      if (portableDelegation !== void 0) {
+        if (this.options.importDelegation === void 0) {
+          await importPortableDelegation(this.fetchFn, envelope.origin, portableDelegation);
+        } else {
+          const imported = await this.options.importDelegation(portableDelegation);
+          if (imported !== void 0) {
+            const normalized = parsePortableDelegation(imported);
+            if (normalized.delegationHeader.Authorization !== portableDelegation.delegationHeader.Authorization) {
+              throw new ShareAccessError("SHARE_SESSION_INVALID", "delegation importer changed authorization bytes");
+            }
+          }
+        }
+      }
+      const ordinarySession = portableDelegation === void 0 ? void 0 : {
+        delegationHeader: portableDelegation.delegationHeader,
+        delegationCid: portableDelegation.cid,
+        spaceId: this.policySessionProjection(portableDelegation).spaceId,
+        verificationMethod: portableDelegation.delegateDID,
+        jwk: this.options.bearerSession?.jwk ?? {}
+      };
+      const kv = bearer || legacyBearer || ordinarySession !== void 0 ? session === void 0 && ordinarySession === void 0 ? void 0 : this.createKV(envelope.origin, ordinarySession ?? session, portableInvoke) : void 0;
       const advertisedCapability = { spaceId: envelope.spaceId, resource: envelope.resource, actions: envelope.actions };
       const capability = policySession?.capability === void 0 ? advertisedCapability : intersectShareCapabilities(advertisedCapability, policySession.capability);
       if (capability === void 0) throw new ShareAccessError("SHARE_CAPABILITY_EMPTY");
@@ -7760,6 +8504,11 @@ var ShareRecipientClient = class {
           const scope = normalizePath2(input.path ?? envelope.resource.path);
           this.assertAllowed(capability, "list", scope);
           if (kv === void 0 && policySession === void 0) throw new ShareAccessError("SHARE_SESSION_REQUIRED");
+          if (portableDelegation !== void 0 && kv !== void 0) {
+            const result2 = await kv.list({ path: scope, limit: input.limit, cursor: input.cursor });
+            if (!result2.ok) throw result2.error;
+            return { keys: result2.data.keys, truncated: result2.data.truncated, nextCursor: result2.data.nextCursor };
+          }
           if (policySession !== void 0) return this.nativeList(envelope, policySession, scope, input.limit, input.cursor);
           const result = await kv.list({ path: scope, limit: input.limit, cursor: input.cursor });
           if (!result.ok) throw result.error;
@@ -7773,6 +8522,14 @@ var ShareRecipientClient = class {
           const resolvedPath = normalizePath2(path);
           this.assertAllowed(capability, "save", resolvedPath);
           if (kv === void 0 && policySession === void 0) throw new ShareAccessError("SHARE_SESSION_REQUIRED");
+          if (portableDelegation !== void 0 && kv !== void 0) {
+            const result2 = await kv.put(resolvedPath, bytes2, { contentType: input.contentType ?? envelope.content.mimeType, ifMatch: input.etag });
+            if (!result2.ok) {
+              if (result2.error.code === ErrorCodes.KV_PRECONDITION_FAILED || result2.error.code === ErrorCodes.KV_CONFLICT) throw new ShareConflict(resolvedPath, result2.error.meta?.etag);
+              throw result2.error;
+            }
+            return { etag: result2.data.headers.etag };
+          }
           if (policySession !== void 0) return this.nativeSave(envelope, policySession, resolvedPath, bytes2, input);
           const result = await kv.put(resolvedPath, bytes2, { contentType: input.contentType ?? envelope.content.mimeType, ifMatch: input.etag });
           if (!result.ok) {
@@ -7788,22 +8545,79 @@ var ShareRecipientClient = class {
       const metadata = async (path = envelope.resource.kind === "exact" ? envelope.resource.path : "") => {
         const resolvedPath = normalizePath2(path);
         this.assertAllowed(capability, "metadata", resolvedPath);
+        if (portableDelegation !== void 0 && kv !== void 0) {
+          const result2 = await kv.head(resolvedPath);
+          if (!result2.ok) throw result2.error;
+          return { metadata: { "content-type": result2.data.headers.contentType ?? "application/octet-stream", "content-length": String(result2.data.headers.contentLength ?? ""), ...result2.data.headers.lastModified === void 0 ? {} : { "last-modified": result2.data.headers.lastModified } }, etag: result2.data.headers.etag, contentType: result2.data.headers.contentType, size: result2.data.headers.contentLength };
+        }
         if (policySession !== void 0) return this.nativeMetadata(envelope, policySession, resolvedPath);
         if (kv === void 0) throw new ShareAccessError("SHARE_SESSION_REQUIRED");
         const result = await kv.head(resolvedPath);
         if (!result.ok) throw result.error;
         return { metadata: { "content-type": result.data.headers.contentType ?? "application/octet-stream", "content-length": String(result.data.headers.contentLength ?? ""), ...result.data.headers.lastModified === void 0 ? {} : { "last-modified": result.data.headers.lastModified } }, etag: result.data.headers.etag, contentType: result.data.headers.contentType, size: result.data.headers.contentLength };
       };
-      return { kind: "share-v2", envelope, location: { ...location, key: void 0 }, resource: envelope.resource, actions: envelope.actions, expiresAt: new Date(envelope.expiresAt), kv, get, listChildren, save, metadata };
+      return { kind: "share-v2", envelope, location: { ...location, key: void 0 }, resource: envelope.resource, actions: envelope.actions, expiresAt: new Date(envelope.expiresAt), kv, portableDelegation, get, listChildren, save, metadata };
     } catch (error) {
       throw asError(error);
     }
   }
-  createKV(origin, session) {
+  policySessionDelegation(session, origin) {
+    if (session.runtimeDelegation === void 0) return void 0;
+    const delegation = parsePortableDelegation(session.runtimeDelegation);
+    if (delegation.host !== void 0 && delegation.host.replace(/\/+$/, "") !== origin.replace(/\/+$/, "")) throw new ShareAccessError("SHARE_ORIGIN_MISMATCH", "delegation host does not match the trusted share origin");
+    return delegation;
+  }
+  policyInvocationSigner(delegation) {
+    const privateKey = this.options.policySessionPrivateKey;
+    if (privateKey === void 0) throw new ShareAccessError("SHARE_SESSION_SIGNER_REQUIRED");
+    const session = parsePolicySessionUcan(delegation.delegationHeader.Authorization);
+    if (session.cid !== delegation.cid || session.aud !== delegation.delegateDID)
+      throw new ShareAccessError("SHARE_SESSION_INVALID");
+    return (_serviceSession, service, path, action, facts) => {
+      const serviceName = service.replace(/^tinycloud\./, "");
+      const cleanPath = path.replace(/^\//, "").replace(/\/$/, "");
+      const authority = Object.entries(session.att).find(([parentResource, abilities]) => {
+        if (!(action in abilities)) return false;
+        if (serviceName === "encryption") return parentResource.startsWith("urn:tinycloud:encryption:") && parentResource === cleanPath;
+        const match = /^tinycloud:\/\/[^/]+\/kv\/(.+)$/.exec(parentResource);
+        if (match === null) return false;
+        const parentPath = match[1];
+        const caveats = abilities[action] ?? [];
+        const prefix = caveats.some((value) => isRecord(value) && value.kind === "prefix");
+        return cleanPath === parentPath || prefix && cleanPath.startsWith(`${parentPath}/`);
+      });
+      if (authority === void 0) throw new ShareAccessError("SHARE_OUT_OF_SCOPE");
+      const resource = serviceName === "encryption" ? authority[0] : `${authority[0].slice(0, authority[0].indexOf("/kv/") + 4)}${cleanPath}`;
+      const caveat = serviceName === "encryption" ? {} : { type: "xyz.tinycloud.resource/selector", kind: "exact", value: resource };
+      const invocation = createCompactPolicyInvocation({
+        sessionAuthorization: delegation.delegationHeader.Authorization,
+        sessionCid: delegation.cid,
+        recipientDid: delegation.delegateDID,
+        audienceDid: String(session.fact.nodeAudience),
+        resource,
+        action,
+        caveat,
+        ...facts?.length === 1 ? { facts: facts[0] } : {},
+        privateKey,
+        now: Math.floor(this.now().getTime() / 1e3)
+      });
+      return { Authorization: invocation.authorization };
+    };
+  }
+  policySessionProjection(delegation) {
+    const session = parsePolicySessionUcan(delegation.delegationHeader.Authorization);
+    if (session.cid !== delegation.cid || session.aud !== delegation.delegateDID) throw new ShareAccessError("SHARE_SESSION_INVALID");
+    const kvResource = Object.keys(session.att).find((resource) => /^tinycloud:\/\/[^/]+\/kv\/.+$/.test(resource));
+    const match = kvResource === void 0 ? void 0 : /^tinycloud:\/\/([^/]+)\/kv\/(.+)$/.exec(kvResource);
+    if (match === void 0 || match === null) throw new ShareAccessError("SHARE_SESSION_INVALID");
+    return { spaceId: match[1] };
+  }
+  createKV(origin, session, invokeOverride) {
+    const invoke = invokeOverride ?? this.options.invoke ?? nativeInvoke;
     if (this.options.createKVService !== void 0) {
-      return this.options.createKVService({ hosts: [origin], session, invoke: this.options.invoke ?? nativeInvoke, fetch: this.fetchFn });
+      return this.options.createKVService({ hosts: [origin], session, invoke, fetch: this.fetchFn });
     }
-    const context = new ServiceContext({ hosts: [origin], session, invoke: this.options.invoke ?? nativeInvoke, fetch: this.fetchFn });
+    const context = new ServiceContext({ hosts: [origin], session, invoke, fetch: this.fetchFn });
     const service = new KVService({ prefix: "" });
     context.registerService("kv", service);
     service.initialize(context);
@@ -7846,7 +8660,7 @@ var ShareRecipientClient = class {
     if (bytes2.byteLength > (this.options.maxContentBytes ?? DEFAULT_MAX_CONTENT_BYTES)) throw new ShareAccessError("SHARE_TOO_LARGE");
     const contentType = input.contentType ?? envelope.content.mimeType;
     if (contentType !== envelope.content.mimeType && !/^text\/(?:plain|markdown)(?:;|$)/i.test(contentType)) throw new ShareAccessError("SHARE_CONTENT_TYPE_INVALID");
-    const result = await this.invokeNative({ envelope, session, action: "put", resource: path, body: bytes2, bodyDigest: bytesToBase64Url2(sha2567(bytes2)), contentType, ifMatch: input.etag, mediaType: "application/vnd.tinycloud.share+json" });
+    const result = await this.invokeNative({ envelope, session, action: "put", resource: path, body: bytes2, bodyDigest: bytesToBase64Url2(sha2568(bytes2)), contentType, ifMatch: input.etag, mediaType: "application/vnd.tinycloud.share+json" });
     if (result.status === 412 || result.status === 409) throw new ShareConflict(path, result.headers?.etag);
     if (result.status === 401 || result.status === 403) throw new ShareAccessError("SHARE_DENIED");
     if (result.status < 200 || result.status >= 300) throw new ShareAccessError("SHARE_WRITE_FAILED");
@@ -7968,7 +8782,7 @@ var ShareRecipientClient = class {
     };
     const signed = this.options.signNativeInvoke === void 0 ? void 0 : await this.options.signNativeInvoke({ envelope: input.envelope, session: input.session, request: body });
     const transport = this.options.invoke !== void 0 || session.authorization !== void 0 || session.delegationHeader !== void 0 ? this.defaultNativeHeaders(session, input.action, input.resource, body) : void 0;
-    const response = await this.fetchFn(v2 ? `${base3}/share/v2/invoke` : `${base3}/invoke`, {
+    const response = await this.fetchFn(`${base3}/invoke`, {
       method: "POST",
       headers: { ...headersRecord2(transport), ...headersRecord2(signed), "content-type": input.mediaType, accept: input.mediaType },
       body: JSON.stringify(body),
@@ -8092,7 +8906,7 @@ var ShareRecipientClient = class {
     }]);
   }
   digestMatches(value, bytes2) {
-    const digest4 = bytesToBase64Url2(sha2567(bytes2));
+    const digest4 = bytesToBase64Url2(sha2568(bytes2));
     return value === digest4 || value === `sha-256=:${digest4}:`;
   }
   assertNativeRequestBounds(envelope, session, operation, path, limit, cursor) {
@@ -8214,12 +9028,12 @@ var ShareRecipientClient = class {
     this.assertDetachedProof(request.proof);
   }
   parseSessionCapability(value) {
-    const object = this.requireObject(value, "session capability");
-    if (typeof object.spaceId !== "string") throw new ShareAccessError("SHARE_SESSION_INVALID", "session capability space is invalid");
-    if (!Array.isArray(object.actions) || object.actions.some((action) => !["read", "list", "edit"].includes(action))) throw new ShareAccessError("SHARE_SESSION_INVALID", "session capability actions are invalid");
-    const resource = this.requireObject(object.resource, "session capability resource");
+    const object2 = this.requireObject(value, "session capability");
+    if (typeof object2.spaceId !== "string") throw new ShareAccessError("SHARE_SESSION_INVALID", "session capability space is invalid");
+    if (!Array.isArray(object2.actions) || object2.actions.some((action) => !["read", "list", "edit"].includes(action))) throw new ShareAccessError("SHARE_SESSION_INVALID", "session capability actions are invalid");
+    const resource = this.requireObject(object2.resource, "session capability resource");
     if (resource.kind !== "exact" && resource.kind !== "prefix" || typeof resource.path !== "string") throw new ShareAccessError("SHARE_SESSION_INVALID", "session capability resource is invalid");
-    return { spaceId: object.spaceId, actions: [...new Set(object.actions)], resource: { kind: resource.kind, path: resource.path } };
+    return { spaceId: object2.spaceId, actions: [...new Set(object2.actions)], resource: { kind: resource.kind, path: resource.path } };
   }
   assertProvidedPolicySession(session, envelope) {
     const sessionExpiry = dateValue(session.expiresAt);
@@ -8310,7 +9124,7 @@ var ShareRecipientClient = class {
         nodeAudience: binding.nodeAudience,
         ...isV2 ? {
           enforcerDid: challenge.enforcerDid,
-          credentialDigest: typeof presentation.credentialDigest === "string" ? presentation.credentialDigest : bytesToBase64Url2(sha2567(new TextEncoder().encode(credential)))
+          credentialDigest: typeof presentation.credentialDigest === "string" ? presentation.credentialDigest : bytesToBase64Url2(sha2568(new TextEncoder().encode(credential)))
         } : {},
         action,
         ...binding.actions === void 0 ? {} : { actions: [...binding.actions] },
@@ -8376,7 +9190,7 @@ var ShareRecipientClient = class {
     }
     if (isJwsProof && detached.kid !== `${signerDid}#${encoded}` || isEd25519Proof && detached.signerDid !== signerDid || signature.length !== 64) throw new ShareAccessError("SHARE_SESSION_INVALID", "Node proof binding is invalid");
     const bytes2 = new TextEncoder().encode(`${domain}${canonicalJsonForProof(message)}`);
-    if (!ed255193.verify(signature, bytes2, key)) throw new ShareAccessError("SHARE_SESSION_INVALID", "Node proof signature is invalid");
+    if (!ed255194.verify(signature, bytes2, key)) throw new ShareAccessError("SHARE_SESSION_INVALID", "Node proof signature is invalid");
   }
   assertChallengeRequestBinding(request, challenge) {
     const source = isRecord(request.body) ? request.body : request;
@@ -9580,7 +10394,7 @@ function shareKeyMatchesDid(key, didUrl) {
     if (!publicKey) return false;
     const jwkBytes = decodeBase64UrlBytes(key.x);
     const privateKey = decodeBase64UrlBytes(key.d);
-    const derivedPublicKey = ed255194.getPublicKey(privateKey);
+    const derivedPublicKey = ed255195.getPublicKey(privateKey);
     return privateKey.length === 32 && publicKey.length === jwkBytes.length && publicKey.every((byte, index) => byte === jwkBytes[index]) && derivedPublicKey.length === jwkBytes.length && derivedPublicKey.every((byte, index) => byte === jwkBytes[index]);
   } catch {
     return false;
@@ -9630,8 +10444,8 @@ function verifySignedChild(result, expected, computeCid) {
 }
 
 // src/delegations/owner-policy.ts
-import { ed25519 as ed255195 } from "@noble/curves/ed25519";
-import { sha256 as sha2568 } from "@noble/hashes/sha256";
+import { ed25519 as ed255196 } from "@noble/curves/ed25519";
+import { sha256 as sha2569 } from "@noble/hashes/sha256";
 var MAX_CONTENT_BYTES = 100 * 1024 * 1024;
 var ENFORCEMENT_DOMAIN = "xyz.tinycloud.share/policy-enforcement/v2\0";
 var POLICY_DOMAIN = "xyz.tinycloud.share/policy/v2\0";
@@ -9658,10 +10472,10 @@ function fromB64(value) {
   throw new Error("base64url decoding is unavailable");
 }
 function cid(bytesValue) {
-  return CID.createV1(code, create(sha2562.code, sha2568(bytesValue))).toString(base32.encoder);
+  return CID.createV1(code, create(sha2562.code, sha2569(bytesValue))).toString(base32.encoder);
 }
 function digest3(bytesValue) {
-  return b64(sha2568(bytesValue));
+  return b64(sha2569(bytesValue));
 }
 function didKeyFromEd25519PublicKey(publicKey) {
   if (publicKey.length !== 32) throw new Error("share key public key must be 32 bytes");
@@ -9846,7 +10660,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}${canonicalizeSignedObjectUnsigned(registrationCore)}`);
-  if (signatureBytes.length !== 64 || !ed255195.verify(signatureBytes, signedBytes, publicKey)) throw new Error("owner-share registration proof signature is invalid");
+  if (signatureBytes.length !== 64 || !ed255196.verify(signatureBytes, signedBytes, publicKey)) throw new Error("owner-share registration proof signature is invalid");
   return { registration, proof };
 }
 function validateOwnerSharePolicyRegistrationBytes(bytesValue, expected) {
@@ -9860,7 +10674,7 @@ function validateOwnerSharePolicyRegistrationBytes(bytesValue, expected) {
 }
 
 // src/delegations/share-delivery.ts
-import { ed25519 as ed255196 } from "@noble/curves/ed25519";
+import { ed25519 as ed255197 } from "@noble/curves/ed25519";
 var SHARE_DELIVERY_AUTHORIZATION_DOMAIN = "xyz.tinycloud.share/delivery-authorization/v2\0";
 function isCanonicalHttpsOrigin(value) {
   let url;
@@ -9933,7 +10747,7 @@ function validateShareDeliveryAuthorizationBytes(bytesValue, expected) {
   const authorization = assertObject2(root.authorization, AUTHORIZATION_KEYS, "share delivery authorization");
   const proof = assertObject2(root.proof, ["alg", "kid", "signature"], "share delivery authorization proof");
   const request = expected.request;
-  if (authorization.type !== "TinyCloudShareDeliveryAuthorization" || authorization.version !== 2 || authorization.dataAuthority !== false || authorization.jti !== request.jti || authorization.shareCid !== request.shareCid || authorization.shareId !== request.shareId || authorization.registrationCid !== request.registrationCid || authorization.delegationCid !== request.delegationCid || authorization.enforcementDelegationCid !== request.enforcementDelegationCid || authorization.envelopeCid !== request.envelopeCid || authorization.policyCid !== request.policyCid || authorization.deliveryEmail !== request.recipientEmail || authorization.shareUrl !== request.shareUrl || authorization.documentName !== request.documentName || authorization.requestBodyDigest !== request.requestBodyDigest || authorization.expiresAt !== request.expiresAt || authorization.idempotencyKey !== request.jti || authorization.reportAbuseToken !== request.jti || authorization.authorityMaterialHandle !== request.registrationCid) {
+  if (authorization.type !== "TinyCloudShareDeliveryAuthorization" || authorization.version !== 2 || authorization.dataAuthority !== false || authorization.jti !== request.jti || authorization.shareCid !== request.shareCid || authorization.shareId !== request.shareId || authorization.registrationCid !== request.registrationCid || authorization.delegationCid !== request.delegationCid || authorization.enforcementDelegationCid !== request.enforcementDelegationCid || authorization.envelopeCid !== request.envelopeCid || authorization.policyCid !== request.policyCid || authorization.deliveryEmail !== request.recipientEmail || authorization.shareUrl !== request.shareUrl || authorization.documentName !== request.documentName || authorization.requestBodyDigest !== request.requestBodyDigest || authorization.expiresAt !== request.expiresAt || authorization.idempotencyKey !== request.idempotencyKey || authorization.reportAbuseToken !== request.jti || authorization.authorityMaterialHandle !== request.registrationCid) {
     throw new Error("share delivery authorization is not bound to the submitted request");
   }
   if (typeof authorization.issuedAt !== "string" || Date.parse(authorization.issuedAt) > Date.now() + 6e4) throw new Error("share delivery authorization issuedAt is invalid");
@@ -9948,7 +10762,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}${canonicalizeSignedObjectUnsigned(authorization)}`);
-  if (signatureBytes.length !== 64 || !ed255196.verify(signatureBytes, signedBytes, publicKey)) throw new Error("share delivery authorization proof signature is invalid");
+  if (signatureBytes.length !== 64 || !ed255197.verify(signatureBytes, signedBytes, publicKey)) throw new Error("share delivery authorization proof signature is invalid");
   return { authorization, proof };
 }
 function shareDeliveryTrustedKid(publicKey) {
@@ -10068,6 +10882,32 @@ var SenderShareStore = class {
   }
 };
 
+// src/delegations/index.ts
+import {
+  authorizeShare,
+  authorizationMethodForTarget,
+  notifyShare,
+  revokeShare,
+  listShares,
+  showShare,
+  publishTargetShare,
+  publishPolicyShare,
+  claimShare,
+  resumeShareAuthorization,
+  isLegacyShareLink,
+  receiveLegacyShare,
+  migrateShare,
+  MemoryEncryptedShareHistoryStorage,
+  EncryptedSenderShareHistory
+} from "@tinycloud/share-sdk";
+import {
+  inspectShare,
+  receiveShare,
+  ShareReceiveError,
+  toShareErrorInfo,
+  verifyBearerEnvelope
+} from "@tinycloud/share-sdk";
+
 // src/networkId.ts
 import {
   buildNetworkId,
@@ -10083,47 +10923,47 @@ function parseCanonicalNetworkId(networkId) {
 }
 
 // src/storage.schema.ts
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 var ethereumAddressPattern = /^0x[a-fA-F0-9]{40}$/;
-var EnsDataSchema2 = z6.object({
+var EnsDataSchema2 = z8.object({
   /** ENS name/domain. */
-  domain: z6.string().nullable().optional(),
+  domain: z8.string().nullable().optional(),
   /** ENS avatar URL. */
-  avatarUrl: z6.string().nullable().optional()
+  avatarUrl: z8.string().nullable().optional()
 });
-var PersistedTinyCloudSessionSchema = z6.object({
+var PersistedTinyCloudSessionSchema = z8.object({
   /** The delegation header containing the UCAN */
-  delegationHeader: z6.object({
-    Authorization: z6.string()
+  delegationHeader: z8.object({
+    Authorization: z8.string()
   }),
   /** The delegation CID */
-  delegationCid: z6.string(),
+  delegationCid: z8.string(),
   /** The space ID for this session */
-  spaceId: z6.string(),
+  spaceId: z8.string(),
   /** Additional spaces included in this session's capabilities. Key is logical name, value is full spaceId URI */
-  spaces: z6.record(z6.string(), z6.string()).optional(),
+  spaces: z8.record(z8.string(), z8.string()).optional(),
   /** The verification method DID */
-  verificationMethod: z6.string()
+  verificationMethod: z8.string()
 });
-var PersistedSessionDataSchema = z6.object({
+var PersistedSessionDataSchema = z8.object({
   /** User's Ethereum address */
-  address: z6.string().regex(ethereumAddressPattern, "Invalid Ethereum address"),
+  address: z8.string().regex(ethereumAddressPattern, "Invalid Ethereum address"),
   /** EIP-155 Chain ID */
-  chainId: z6.number().int().positive(),
+  chainId: z8.number().int().positive(),
   /** Session key in JWK format (stringified) */
-  sessionKey: z6.string(),
+  sessionKey: z8.string(),
   /** The signed SIWE message */
-  siwe: z6.string(),
+  siwe: z8.string(),
   /** User's signature of the SIWE message */
-  signature: z6.string(),
+  signature: z8.string(),
   /** TinyCloud delegation data if available */
   tinycloudSession: PersistedTinyCloudSessionSchema.optional(),
   /** Session expiration timestamp (ISO 8601 with timezone offset) */
-  expiresAt: z6.string().datetime({ offset: true }),
+  expiresAt: z8.string().datetime({ offset: true }),
   /** Session creation timestamp (ISO 8601 with timezone offset) */
-  createdAt: z6.string().datetime({ offset: true }),
+  createdAt: z8.string().datetime({ offset: true }),
   /** Schema version for migrations */
-  version: z6.string(),
+  version: z8.string(),
   /** Optional ENS data */
   ens: EnsDataSchema2.optional(),
   /**
@@ -10133,33 +10973,33 @@ var PersistedSessionDataSchema = z6.object({
    * for backward compatibility with sessions persisted before this field
    * existed — those restore and lazily re-resolve their hosts.
    */
-  tinycloudHosts: z6.array(z6.string()).optional()
+  tinycloudHosts: z8.array(z8.string()).optional()
 });
-var TinyCloudSessionSchema = z6.object({
+var TinyCloudSessionSchema = z8.object({
   /** User's Ethereum address */
-  address: z6.string().regex(ethereumAddressPattern, "Invalid Ethereum address"),
+  address: z8.string().regex(ethereumAddressPattern, "Invalid Ethereum address"),
   /** EIP-155 Chain ID */
-  chainId: z6.number().int().positive(),
+  chainId: z8.number().int().positive(),
   /** Session key ID */
-  sessionKey: z6.string(),
+  sessionKey: z8.string(),
   /** The space ID for this session */
-  spaceId: z6.string(),
+  spaceId: z8.string(),
   /** Additional spaces included in this session's capabilities. Key is logical name, value is full spaceId URI */
-  spaces: z6.record(z6.string(), z6.string()).optional(),
+  spaces: z8.record(z8.string(), z8.string()).optional(),
   /** The delegation CID */
-  delegationCid: z6.string(),
+  delegationCid: z8.string(),
   /** The delegation header for API calls */
-  delegationHeader: z6.object({
-    Authorization: z6.string()
+  delegationHeader: z8.object({
+    Authorization: z8.string()
   }),
   /** The verification method DID */
-  verificationMethod: z6.string(),
+  verificationMethod: z8.string(),
   /** The session key JWK (required for invoke operations) */
-  jwk: z6.object({}).passthrough(),
+  jwk: z8.object({}).passthrough(),
   /** The signed SIWE message */
-  siwe: z6.string(),
+  siwe: z8.string(),
   /** User's signature of the SIWE message */
-  signature: z6.string()
+  signature: z8.string()
 });
 function validatePersistedSessionData(data) {
   const result = PersistedSessionDataSchema.safeParse(data);
@@ -10272,112 +11112,112 @@ var Space = class {
 };
 
 // src/spaces/spaces.schema.ts
-import { z as z7 } from "zod";
-var SpaceConfigSchema = z7.object({
+import { z as z9 } from "zod";
+var SpaceConfigSchema = z9.object({
   /** The space identifier (full URI) */
-  id: z7.string(),
+  id: z9.string(),
   /** The short name of the space */
-  name: z7.string(),
+  name: z9.string(),
   /** Factory function to create a space-scoped KV service */
-  createKV: z7.function(),
+  createKV: z9.function(),
   /** Factory function to create a space-scoped Data Vault service */
-  createVault: z7.function(),
+  createVault: z9.function(),
   /** Optional factory function to create a space-scoped secrets service */
-  createSecrets: z7.function().optional(),
+  createSecrets: z9.function().optional(),
   /** Factory function to create space-scoped delegations */
-  createDelegations: z7.function(),
+  createDelegations: z9.function(),
   /** Factory function to create space-scoped sharing */
-  createSharing: z7.function(),
+  createSharing: z9.function(),
   /** Function to get space info */
-  getInfo: z7.function()
+  getInfo: z9.function()
 });
-var SpaceServiceConfigSchema = z7.object({
+var SpaceServiceConfigSchema = z9.object({
   /** TinyCloud host URLs */
-  hosts: z7.array(z7.string()),
+  hosts: z9.array(z9.string()),
   /** Active session for authentication */
-  session: z7.unknown(),
+  session: z9.unknown(),
   /** Platform-specific invoke function */
-  invoke: z7.function(),
+  invoke: z9.function(),
   /** Optional custom fetch implementation */
-  fetch: z7.function().optional(),
+  fetch: z9.function().optional(),
   /** Optional capability key registry for delegated space discovery */
-  capabilityRegistry: z7.unknown().optional(),
+  capabilityRegistry: z9.unknown().optional(),
   /** Factory function to create a space-scoped KV service */
-  createKVService: z7.function().optional(),
+  createKVService: z9.function().optional(),
   /** Factory function to create a space-scoped Data Vault service */
-  createVaultService: z7.function().optional(),
+  createVaultService: z9.function().optional(),
   /** Factory function to create a space-scoped secrets service */
-  createSecretsService: z7.function().optional(),
+  createSecretsService: z9.function().optional(),
   /** User's PKH DID (derived from address or provided explicitly) */
-  userDid: z7.string().optional(),
+  userDid: z9.string().optional(),
   /** Optional SharingService for v2 sharing links (client-side) */
-  sharingService: z7.unknown().optional(),
+  sharingService: z9.unknown().optional(),
   /** Factory function to create delegations using SIWE-based flow */
-  createDelegation: z7.function().optional()
+  createDelegation: z9.function().optional()
 });
 var SpaceDelegationParamsSchema = CreateDelegationParamsSchema.extend({
   /** The space ID to create the delegation for */
-  spaceId: z7.string()
+  spaceId: z9.string()
 });
-var ServerDelegationInfoSchema = z7.object({
+var ServerDelegationInfoSchema = z9.object({
   /** DID of the delegator */
-  delegator: z7.string(),
+  delegator: z9.string(),
   /** DID of the delegate */
-  delegate: z7.string(),
+  delegate: z9.string(),
   /** Parent delegation CIDs - accepts string or byte array format from server */
-  parents: z7.array(z7.union([z7.string(), z7.array(z7.number())])),
+  parents: z9.array(z9.union([z9.string(), z9.array(z9.number())])),
   /** Expiration time (ISO8601 string) */
-  expiry: z7.string().optional(),
+  expiry: z9.string().optional(),
   /** Not-before time (ISO8601 string) */
-  not_before: z7.string().optional(),
+  not_before: z9.string().optional(),
   /** Issued-at time (ISO8601 string) */
-  issued_at: z7.string().optional(),
+  issued_at: z9.string().optional(),
   /** Capabilities granted by this delegation */
-  capabilities: z7.array(
-    z7.object({
-      resource: z7.string(),
-      ability: z7.string()
+  capabilities: z9.array(
+    z9.object({
+      resource: z9.string(),
+      ability: z9.string()
     })
   )
 });
-var ServerDelegationsResponseSchema = z7.record(
-  z7.string(),
+var ServerDelegationsResponseSchema = z9.record(
+  z9.string(),
   ServerDelegationInfoSchema
 );
-var ServerOwnedSpaceSchema = z7.object({
+var ServerOwnedSpaceSchema = z9.object({
   /** Space identifier */
-  id: z7.string(),
+  id: z9.string(),
   /** Space name (optional, can be derived from id) */
-  name: z7.string().optional(),
+  name: z9.string().optional(),
   /** Owner DID */
-  owner: z7.string(),
+  owner: z9.string(),
   /** Creation timestamp */
-  createdAt: z7.string().optional()
+  createdAt: z9.string().optional()
 });
-var ServerOwnedSpacesResponseSchema = z7.array(ServerOwnedSpaceSchema);
-var ServerCreateSpaceResponseSchema = z7.object({
+var ServerOwnedSpacesResponseSchema = z9.array(ServerOwnedSpaceSchema);
+var ServerCreateSpaceResponseSchema = z9.object({
   /** Space identifier */
-  id: z7.string(),
+  id: z9.string(),
   /** Space name */
-  name: z7.string(),
+  name: z9.string(),
   /** Owner DID */
-  owner: z7.string(),
+  owner: z9.string(),
   /** Creation timestamp */
-  createdAt: z7.string().optional()
+  createdAt: z9.string().optional()
 });
-var ServerSpaceInfoResponseSchema = z7.object({
+var ServerSpaceInfoResponseSchema = z9.object({
   /** Space identifier */
-  id: z7.string(),
+  id: z9.string(),
   /** Space name (optional) */
-  name: z7.string().optional(),
+  name: z9.string().optional(),
   /** Owner DID */
-  owner: z7.string(),
+  owner: z9.string(),
   /** Ownership type */
-  type: z7.enum(["owned", "delegated"]).optional(),
+  type: z9.enum(["owned", "delegated"]).optional(),
   /** Permissions the user has in this space */
-  permissions: z7.array(z7.string()).optional(),
+  permissions: z9.array(z9.string()).optional(),
   /** Expiration for delegated access */
-  expiresAt: z7.string().optional()
+  expiresAt: z9.string().optional()
 });
 function validateServerDelegationsResponse(data) {
   if (data === null || data === void 0) {
@@ -11789,7 +12629,8 @@ var TinyCloud = class _TinyCloud {
 import {
   err as err3,
   ok as ok3,
-  serviceError as serviceError3
+  serviceError as serviceError3,
+  ErrorCodes as ErrorCodes3
 } from "@tinycloud/sdk-services";
 import { ACCOUNT_INDEX_SCHEMA } from "@tinycloud/bootstrap";
 var SERVICE_NAME2 = "account";
@@ -11799,6 +12640,22 @@ var ACCOUNT_SPACES_PATH = "spaces/";
 var AccountService = class {
   constructor(config) {
     this.config = config;
+    /**
+     * Per-account-space memo for {@link ensureAccountIndex}.
+     *
+     * Applying the index migration is a no-op once the schema exists, but the
+     * SQL service still spends two round trips discovering that (create the
+     * migrations table, then read the applied-migration rows). Account bootstrap
+     * touches the index eight times, so without a memo that is ~14 wasted
+     * requests on the cold sign-in path. The in-flight dedupe inside SQLService
+     * never helps here: the node SDK builds a fresh SQLService per
+     * `getAccountDb()` call, so its lock map is always empty.
+     *
+     * Keyed by account space id, so a different account never reuses this entry.
+     * Failures are evicted so a later call retries instead of inheriting a
+     * permanently poisoned result.
+     */
+    this.accountIndexReady = /* @__PURE__ */ new Map();
     this.applications = {
       list: async (options2 = {}) => {
         if (options2.preferIndex) {
@@ -11832,7 +12689,7 @@ var AccountService = class {
         if (!loaded.ok) return accountErr(loaded.error);
         return ok3(applicationFromRecord(key, loaded.data.data));
       },
-      register: async (manifest) => {
+      register: async (manifest, options2 = {}) => {
         const manifests = Array.isArray(manifest) ? manifest : [manifest];
         const request = composeManifestRequest(manifests);
         if (request.registryRecords.length === 0) {
@@ -11850,7 +12707,7 @@ var AccountService = class {
         let registered;
         for (const record of request.registryRecords) {
           const manifestHash = hashJson(record.manifests);
-          if (await this.indexHasApplicationHash(record.app_id, manifestHash)) {
+          if (!options2.assumeUnregistered && await this.indexHasApplicationHash(record.app_id, manifestHash)) {
             registered = {
               appId: record.app_id,
               manifests: record.manifests,
@@ -11925,6 +12782,60 @@ var AccountService = class {
         await this.upsertSpaceIndexQuietly(registered);
         return ok3(registered);
       },
+      /**
+       * Register multiple spaces in one KV batch write + one multi-row index
+       * write, instead of one `register()` round trip per space (TC-373).
+       *
+       * The stored records are computed exactly once and reused for both the
+       * batch attempt and any reconciliation below, so a fallback never mints a
+       * fresh timestamp for a space that already has a written record — a
+       * second `spaceRecordFromInput` call would produce a new content hash and
+       * leave the first attempt's blocks orphaned.
+       */
+      registerBatch: async (spaces) => {
+        if (spaces.length === 0) return ok3({ spaces: [] });
+        await this.config.ensureAccountSpaceHosted?.();
+        const kvResult = this.accountKV();
+        if (!kvResult.ok) return kvResult;
+        const stored = spaces.map((space) => spaceRecordFromInput(space));
+        const registered = stored.map(
+          (record) => spaceFromRecord(spaceKey(record.space_id), record)
+        );
+        const items = stored.map((record) => ({
+          key: spaceKey(record.space_id),
+          value: record
+        }));
+        const batchResult = await kvResult.data.batchPut(items);
+        if (batchResult.ok) {
+          await this.upsertSpacesIndexQuietly(registered);
+          return ok3({ spaces: registered });
+        }
+        if (!isAmbiguousBatchFailure(batchResult.error)) {
+          return accountErr(batchResult.error);
+        }
+        const reconcileFailures = [];
+        for (const record of stored) {
+          const written = await kvResult.data.put(spaceKey(record.space_id), record);
+          if (!written.ok) {
+            reconcileFailures.push(`${record.space_id}: ${written.error.message}`);
+          }
+        }
+        if (reconcileFailures.length > 0) {
+          return err3(
+            serviceError3(
+              "KV_BATCH_RECONCILE_FAILED",
+              `KV batch write for ${items.length} space(s) failed ambiguously (${batchResult.error.message}) and per-space reconciliation also failed for: ${reconcileFailures.join("; ")}`,
+              SERVICE_NAME2,
+              { cause: batchResult.error.cause, meta: { originalError: batchResult.error } }
+            )
+          );
+        }
+        console.warn(
+          `[AccountService] KV batch write for ${items.length} space(s) returned an ambiguous error and was reconciled via per-space fallback. Original error: ${batchResult.error.message}`
+        );
+        await this.upsertSpacesIndexQuietly(registered);
+        return ok3({ spaces: registered, recoveredFromBatchError: batchResult.error });
+      },
       syncAccessible: async () => {
         const listed = await this.config.getSpaces().list();
         if (!listed.ok) return accountErr(listed.error);
@@ -12031,6 +12942,7 @@ var AccountService = class {
         const delegations = await this.delegations.list();
         if (!delegations.ok) return delegations;
         const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+        this.invalidateAccountIndexMemo();
         const schema = await this.ensureAccountIndex(dbResult.data);
         if (!schema.ok) return schema;
         const statements = [
@@ -12310,6 +13222,47 @@ var AccountService = class {
     if (!written.ok) return accountErr(written.error);
     return ok3(void 0);
   }
+  async upsertSpacesIndexQuietly(spaces) {
+    await ignoreIndexFailure(() => this.upsertSpacesIndex(spaces));
+  }
+  /**
+   * Upsert multiple space index rows in ONE multi-row `INSERT OR REPLACE`
+   * statement (TC-373), rather than one statement per space. This matters
+   * because `IDatabaseHandle.batch()` executes its statement list as a plain
+   * loop, not a single database transaction — an N-statement batch is not
+   * atomic. A single multi-row INSERT is one SQLite statement, so it applies
+   * atomically: all rows or none.
+   */
+  async upsertSpacesIndex(spaces) {
+    if (spaces.length === 0) return ok3(void 0);
+    const dbResult = this.accountDb();
+    if (!dbResult.ok) return ok3(void 0);
+    const schema = await this.ensureAccountIndex(dbResult.data);
+    if (!schema.ok) return schema;
+    const placeholders = spaces.map(() => "(?, ?, ?, ?, ?, ?, ?, ?, ?)").join(", ");
+    const params = spaces.flatMap((space) => {
+      const updatedAt = space.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+      return [
+        space.spaceId,
+        space.name,
+        space.ownerDid,
+        space.type,
+        JSON.stringify(space.permissions),
+        space.status,
+        space.registeredAt ?? updatedAt,
+        updatedAt,
+        space.expiresAt?.toISOString() ?? null
+      ];
+    });
+    const written = await dbResult.data.batch([
+      {
+        sql: `INSERT OR REPLACE INTO spaces (space_id, name, owner_did, type, permissions_json, status, registered_at, updated_at, expires_at) VALUES ${placeholders}`,
+        params
+      }
+    ]);
+    if (!written.ok) return accountErr(written.error);
+    return ok3(void 0);
+  }
   async deleteSpaceIndexQuietly(spaceId) {
     await ignoreIndexFailure(() => this.deleteSpaceIndex(spaceId));
   }
@@ -12430,7 +13383,41 @@ var AccountService = class {
       ]);
     });
   }
+  /**
+   * Apply the account index schema at most once per account space.
+   *
+   * The index is a cache over canonical KV state, and every caller already
+   * tolerates it being absent (`ignoreIndexFailure` / `isMissingIndexError`),
+   * so a memo that is wrong in the "already applied" direction degrades to a
+   * `no such table` read that the caller handles. A memo that is wrong in the
+   * other direction would be a real bug, so failures are never cached.
+   */
   async ensureAccountIndex(db) {
+    const key = this.config.getAccountSpaceId() ?? "";
+    const cached = this.accountIndexReady.get(key);
+    if (cached) return cached;
+    const pending = this.applyAccountIndex(db);
+    this.accountIndexReady.set(key, pending);
+    const evict = () => {
+      if (this.accountIndexReady.get(key) === pending) {
+        this.accountIndexReady.delete(key);
+      }
+    };
+    let settled;
+    try {
+      settled = await pending;
+    } catch (error) {
+      evict();
+      throw error;
+    }
+    if (!settled.ok) evict();
+    return settled;
+  }
+  /** Drop the memo so the next {@link ensureAccountIndex} re-applies the schema. */
+  invalidateAccountIndexMemo() {
+    this.accountIndexReady.delete(this.config.getAccountSpaceId() ?? "");
+  }
+  async applyAccountIndex(db) {
     const migrated = await db.migrations.apply({
       namespace: ACCOUNT_INDEX_NAMESPACE,
       migrations: [
@@ -12547,8 +13534,8 @@ function stableJson(value) {
   if (Array.isArray(value)) {
     return `[${value.map(stableJson).join(",")}]`;
   }
-  const object = value;
-  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableJson(object[key])}`).join(",")}}`;
+  const object2 = value;
+  return `{${Object.keys(object2).sort().map((key) => `${JSON.stringify(key)}:${stableJson(object2[key])}`).join(",")}}`;
 }
 function indexedDelegationFromRow(row) {
   const [
@@ -12602,6 +13589,17 @@ function accountErr(error) {
 function isMissingIndexError(error) {
   return /no such table:/i.test(error.message);
 }
+var AMBIGUOUS_WRITE_STATUSES = /* @__PURE__ */ new Set([500, 502, 503, 504, 520, 522, 524]);
+function isAmbiguousBatchFailure(error) {
+  if (error.code === ErrorCodes3.NETWORK_ERROR || error.code === ErrorCodes3.TIMEOUT) {
+    return error.meta?.requestMayHaveDispatched === true;
+  }
+  if (error.code === ErrorCodes3.KV_WRITE_FAILED) {
+    const status = error.meta?.status;
+    return typeof status === "number" && AMBIGUOUS_WRITE_STATUSES.has(status);
+  }
+  return false;
+}
 async function ignoreIndexFailure(task) {
   try {
     await task();
@@ -12617,7 +13615,7 @@ import {
   ok as ok5,
   err as err5,
   serviceError as serviceError5,
-  ErrorCodes as ErrorCodes3,
+  ErrorCodes as ErrorCodes4,
   TinyCloudDebugLogger,
   tinyCloudDebugLogger,
   enableTinyCloudDebug,
@@ -13291,6 +14289,279 @@ var AutoApproveSpaceCreationHandler = class {
 };
 var defaultSpaceCreationHandler = new AutoApproveSpaceCreationHandler();
 
+// src/authorization/openkey-protocol.ts
+function validateAuthorizationResultV1(value) {
+  if (!value || typeof value !== "object") {
+    return { ok: false, error: "authorization result must be an object" };
+  }
+  const v = value;
+  if (v.protocolVersion !== 1) {
+    return { ok: false, error: `unsupported protocolVersion ${String(v.protocolVersion)}` };
+  }
+  if (typeof v.address !== "string" || !v.address) {
+    return { ok: false, error: "address must be a non-empty string" };
+  }
+  if (typeof v.signature !== "string" || !v.signature) {
+    return { ok: false, error: "signature must be a non-empty string" };
+  }
+  if (typeof v.signedMessage !== "string" || !v.signedMessage) {
+    return { ok: false, error: "signedMessage must be a non-empty string" };
+  }
+  if (!Array.isArray(v.selectedActionKeys) || v.selectedActionKeys.some((k) => typeof k !== "string")) {
+    return { ok: false, error: "selectedActionKeys must be a string[]" };
+  }
+  if (!Array.isArray(v.permissions)) {
+    return { ok: false, error: "permissions must be an array" };
+  }
+  const permissions = [];
+  for (const [index, entry] of v.permissions.entries()) {
+    if (!entry || typeof entry !== "object") {
+      return { ok: false, error: `permissions[${index}] must be an object` };
+    }
+    const e = entry;
+    if (typeof e.service !== "string" || typeof e.space !== "string" || typeof e.path !== "string") {
+      return { ok: false, error: `permissions[${index}] must have string service/space/path` };
+    }
+    if (!Array.isArray(e.actions) || e.actions.some((a) => typeof a !== "string")) {
+      return { ok: false, error: `permissions[${index}].actions must be a string[]` };
+    }
+    permissions.push({
+      service: e.service,
+      space: e.space,
+      path: e.path,
+      actions: e.actions
+    });
+  }
+  return {
+    ok: true,
+    value: {
+      protocolVersion: 1,
+      address: v.address,
+      signature: v.signature,
+      signedMessage: v.signedMessage,
+      selectedActionKeys: v.selectedActionKeys,
+      permissions
+    }
+  };
+}
+var OPENKEY_ACTION_ID_SEPARATOR = "\0";
+function isPlausibleOpenKeyActionId(id) {
+  return typeof id === "string" && id.split(OPENKEY_ACTION_ID_SEPARATOR).length === 4 && id.length > 0;
+}
+function parseCanonicalRecapResource(resource) {
+  if (!resource.startsWith("tinycloud:")) {
+    return { space: resource, path: "" };
+  }
+  const firstSlash = resource.indexOf("/");
+  if (firstSlash < 0) {
+    return { space: resource, path: "" };
+  }
+  const space = resource.slice(0, firstSlash);
+  const rest = resource.slice(firstSlash + 1);
+  const secondSlash = rest.indexOf("/");
+  if (secondSlash < 0) {
+    return { space, path: "" };
+  }
+  return { space, path: rest.slice(secondSlash + 1) };
+}
+function extractImmutableSiweFields(siwe) {
+  const lines = siwe.split(/\r?\n/);
+  const result = {};
+  const headerLine = lines[0];
+  if (headerLine) {
+    const domainMatch = headerLine.match(/^(.+?)\s+wants you to sign in/);
+    if (domainMatch) {
+      result.domain = domainMatch[1];
+    }
+  }
+  for (let i = 1; i < lines.length && i < 5; i++) {
+    const line = lines[i]?.trim() ?? "";
+    if (/^0x[0-9a-fA-F]{40}$/.test(line)) {
+      result.address = line;
+      break;
+    }
+  }
+  for (const line of lines) {
+    const match = line.match(/^([A-Z][A-Za-z ]*):\s*(.*)$/);
+    if (!match) continue;
+    const [, key, value] = match;
+    switch (key) {
+      case "URI":
+        result.uri = value;
+        break;
+      case "Version":
+        result.version = value;
+        break;
+      case "Chain ID":
+        result.chainId = value;
+        break;
+      case "Nonce":
+        result.nonce = value;
+        break;
+      case "Issued At":
+        result.issuedAt = value;
+        break;
+      // Sol MAJOR-4: complete immutable-field coverage.
+      case "Expiration Time":
+        result.expirationTime = value;
+        break;
+      case "Not Before":
+        result.notBefore = value;
+        break;
+      case "Request ID":
+        result.requestId = value;
+        break;
+      default:
+        break;
+    }
+  }
+  const uriLineIdx = lines.findIndex((l) => /^URI:/.test(l));
+  if (uriLineIdx > 3) {
+    let end = uriLineIdx - 1;
+    while (end > 3 && lines[end] === "") end -= 1;
+    if (end >= 3) {
+      result.statement = lines.slice(3, end + 1).join("\n");
+    } else {
+      result.statement = "";
+    }
+  } else {
+    result.statement = "";
+  }
+  result.nonRecapResources = lines.filter((l) => /^- /.test(l) && !/^- urn:recap:/.test(l)).join("\n");
+  return result;
+}
+function diffImmutableSiweFields(original, signed, options2) {
+  const baseKeys = [
+    "domain",
+    "address",
+    "uri",
+    "version",
+    "chainId",
+    "nonce",
+    "issuedAt",
+    "expirationTime",
+    "notBefore",
+    "requestId",
+    "nonRecapResources"
+  ];
+  const keys = options2?.originalHasRecap ? baseKeys : [...baseKeys, "statement"];
+  const diffs = [];
+  for (const key of keys) {
+    const a = original[key] ?? "";
+    const b = signed[key] ?? "";
+    if (a !== b) {
+      diffs.push(key);
+    }
+  }
+  return diffs;
+}
+function extractRecapAttenuations(siwe) {
+  const merged = {};
+  const lines = siwe.split(/\r?\n/);
+  for (const line of lines) {
+    const match = line.match(/urn:recap:([A-Za-z0-9_-]+=*)/);
+    if (!match) continue;
+    const encoded = match[1];
+    let decodedJson;
+    try {
+      const normalized = encoded.replace(/-/g, "+").replace(/_/g, "/");
+      const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
+      decodedJson = Buffer.from(padded, "base64").toString("utf8");
+    } catch (err6) {
+      throw new Error(
+        `Failed to decode urn:recap: payload: ${err6.message}`
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(decodedJson);
+    } catch (err6) {
+      throw new Error(
+        `urn:recap: payload is not valid JSON: ${err6.message}`
+      );
+    }
+    if (!parsed || typeof parsed !== "object") {
+      throw new Error("urn:recap: payload must be an object");
+    }
+    const att = parsed.att;
+    if (att === void 0) {
+      continue;
+    }
+    if (typeof att !== "object" || att === null || Array.isArray(att)) {
+      throw new Error("urn:recap: att must be an object");
+    }
+    for (const [resource, actionMap] of Object.entries(att)) {
+      if (!actionMap || typeof actionMap !== "object" || Array.isArray(actionMap)) {
+        throw new Error(`urn:recap: att[${resource}] must be an object`);
+      }
+      const existing = merged[resource] ?? {};
+      for (const [action, caveats] of Object.entries(actionMap)) {
+        if (!Array.isArray(caveats)) {
+          throw new Error(
+            `urn:recap: att[${resource}][${action}] must be an array`
+          );
+        }
+        const previous = existing[action] ?? [];
+        existing[action] = previous.concat(caveats);
+      }
+      merged[resource] = existing;
+    }
+  }
+  return merged;
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const entries = Object.entries(value).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
+}
+function caveatsDeepEqual(a, b) {
+  return stableStringify(a) === stableStringify(b);
+}
+function unauthorizedRecapCapabilities(child, parent) {
+  const unauthorized = [];
+  for (const [resource, actions] of Object.entries(child)) {
+    const parentActions = parent[resource];
+    for (const [action, childCaveatsRaw] of Object.entries(actions)) {
+      if (!parentActions || parentActions[action] === void 0) {
+        unauthorized.push({ resource, action });
+        continue;
+      }
+      const parentCaveatsRaw = parentActions[action];
+      const parentCaveats = Array.isArray(parentCaveatsRaw) ? parentCaveatsRaw : [];
+      const childCaveats = Array.isArray(childCaveatsRaw) ? childCaveatsRaw : [];
+      const parentCanonCounts = /* @__PURE__ */ new Map();
+      for (const c of parentCaveats) {
+        const k = stableStringify(c);
+        parentCanonCounts.set(k, (parentCanonCounts.get(k) ?? 0) + 1);
+      }
+      const childCanonCounts = /* @__PURE__ */ new Map();
+      for (const c of childCaveats) {
+        const k = stableStringify(c);
+        childCanonCounts.set(k, (childCanonCounts.get(k) ?? 0) + 1);
+      }
+      let equal = parentCanonCounts.size === childCanonCounts.size;
+      if (equal) {
+        for (const [k, n] of parentCanonCounts) {
+          if (childCanonCounts.get(k) !== n) {
+            equal = false;
+            break;
+          }
+        }
+      }
+      if (!equal) {
+        unauthorized.push({ resource, action });
+      }
+      void caveatsDeepEqual;
+    }
+  }
+  return unauthorized;
+}
+
 // src/version.ts
 var ProtocolMismatchError = class extends Error {
   constructor(sdkProtocol, nodeProtocol, nodeVersion, host) {
@@ -13355,8 +14626,10 @@ async function checkNodeInfo(host, sdkProtocol, fetchFn = globalThis.fetch.bind(
 
 // src/index.ts
 import {
+  ACCOUNT_MANIFEST_PERMISSIONS as ACCOUNT_MANIFEST_PERMISSIONS2,
   ACCOUNT_INDEX_SCHEMA as ACCOUNT_INDEX_SCHEMA2,
   BOOTSTRAP_ALLOWLIST,
+  BOOTSTRAP_DEFAULT_ONLY_SESSION_REQUEST,
   BOOTSTRAP_DEFAULT_SPACE,
   BOOTSTRAP_ENCRYPTION_NETWORK_NAME,
   BOOTSTRAP_ENCRYPTION_NETWORK_RESOURCE_TEMPLATE,
@@ -13402,17 +14675,9 @@ function equals3(a, b) {
   return true;
 }
 
-// ../../node_modules/uint8arrays/dist/src/alloc.node.js
-import { Buffer as Buffer2 } from "buffer";
-
-// ../../node_modules/uint8arrays/dist/src/util/as-uint8array.node.js
-function asUint8Array(buf) {
-  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-}
-
-// ../../node_modules/uint8arrays/dist/src/alloc.node.js
+// ../../node_modules/uint8arrays/dist/src/alloc.js
 function allocUnsafe(size = 0) {
-  return asUint8Array(Buffer2.allocUnsafe(size));
+  return new Uint8Array(size);
 }
 
 // ../../node_modules/uint8-varint/dist/src/index.js
@@ -13588,14 +14853,24 @@ function decode6(buf, offset = 0) {
   }
 }
 
-// ../../node_modules/uint8arrays/dist/src/concat.node.js
-import { Buffer as Buffer3 } from "buffer";
-function concat(arrays, length2) {
-  return asUint8Array(Buffer3.concat(arrays, length2));
+// ../../node_modules/uint8arrays/dist/src/util/as-uint8array.js
+function asUint8Array(buf) {
+  return buf;
 }
 
-// ../../node_modules/uint8arrays/dist/src/from-string.node.js
-import { Buffer as Buffer4 } from "buffer";
+// ../../node_modules/uint8arrays/dist/src/concat.js
+function concat(arrays, length2) {
+  if (length2 == null) {
+    length2 = arrays.reduce((acc, curr) => acc + curr.length, 0);
+  }
+  const output = allocUnsafe(length2);
+  let offset = 0;
+  for (const arr of arrays) {
+    output.set(arr, offset);
+    offset += arr.length;
+  }
+  return asUint8Array(output);
+}
 
 // ../../node_modules/uint8arrays/dist/src/util/bases.js
 function createCodec(name2, prefix, encode5, decode7) {
@@ -13644,28 +14919,21 @@ var BASES = {
 };
 var bases_default = BASES;
 
-// ../../node_modules/uint8arrays/dist/src/from-string.node.js
+// ../../node_modules/uint8arrays/dist/src/from-string.js
 function fromString2(string2, encoding = "utf8") {
   const base3 = bases_default[encoding];
   if (base3 == null) {
     throw new Error(`Unsupported encoding "${encoding}"`);
   }
-  if (encoding === "utf8" || encoding === "utf-8") {
-    return asUint8Array(Buffer4.from(string2, "utf-8"));
-  }
   return base3.decoder.decode(`${base3.prefix}${string2}`);
 }
 
-// ../../node_modules/uint8arrays/dist/src/to-string.node.js
-import { Buffer as Buffer5 } from "buffer";
+// ../../node_modules/uint8arrays/dist/src/to-string.js
 function toString2(array, encoding = "utf8") {
   const base3 = bases_default[encoding];
   if (base3 == null) {
     throw new Error(`Unsupported encoding "${encoding}"`);
   }
-  if (encoding === "utf8" || encoding === "utf-8") {
-    return Buffer5.from(array.buffer, array.byteOffset, array.byteLength).toString("utf8");
-  }
   return base3.encoder.encode(array).substring(1);
 }
 
@@ -13699,8 +14967,218 @@ var UnknownProtocolError = class extends Error {
 };
 __publicField(UnknownProtocolError, "name", "UnknownProtocolError");
 
-// ../../node_modules/@chainsafe/is-ip/lib/is-ip.node.js
-import { isIPv4, isIPv6, isIP as ipVersion } from "net";
+// ../../node_modules/@chainsafe/is-ip/lib/parser.js
+var Parser = class {
+  constructor() {
+    __publicField(this, "index", 0);
+    __publicField(this, "input", "");
+  }
+  new(input) {
+    this.index = 0;
+    this.input = input;
+    return this;
+  }
+  /** Run a parser, and restore the pre-parse state if it fails. */
+  readAtomically(fn) {
+    const index = this.index;
+    const result = fn();
+    if (result === void 0) {
+      this.index = index;
+    }
+    return result;
+  }
+  /** Run a parser, but fail if the entire input wasn't consumed. Doesn't run atomically. */
+  parseWith(fn) {
+    const result = fn();
+    if (this.index !== this.input.length) {
+      return void 0;
+    }
+    return result;
+  }
+  /** Peek the next character from the input */
+  peekChar() {
+    if (this.index >= this.input.length) {
+      return void 0;
+    }
+    return this.input[this.index];
+  }
+  /** Read the next character from the input */
+  readChar() {
+    if (this.index >= this.input.length) {
+      return void 0;
+    }
+    return this.input[this.index++];
+  }
+  /** Read the next character from the input if it matches the target. */
+  readGivenChar(target) {
+    return this.readAtomically(() => {
+      const char = this.readChar();
+      if (char !== target) {
+        return void 0;
+      }
+      return char;
+    });
+  }
+  /**
+   * Helper for reading separators in an indexed loop. Reads the separator
+   * character iff index > 0, then runs the parser. When used in a loop,
+   * the separator character will only be read on index > 0 (see
+   * readIPv4Addr for an example)
+   */
+  readSeparator(sep, index, inner) {
+    return this.readAtomically(() => {
+      if (index > 0) {
+        if (this.readGivenChar(sep) === void 0) {
+          return void 0;
+        }
+      }
+      return inner();
+    });
+  }
+  /**
+   * Read a number off the front of the input in the given radix, stopping
+   * at the first non-digit character or eof. Fails if the number has more
+   * digits than max_digits or if there is no number.
+   */
+  readNumber(radix, maxDigits, allowZeroPrefix, maxBytes) {
+    return this.readAtomically(() => {
+      let result = 0;
+      let digitCount = 0;
+      const leadingChar = this.peekChar();
+      if (leadingChar === void 0) {
+        return void 0;
+      }
+      const hasLeadingZero = leadingChar === "0";
+      const maxValue2 = 2 ** (8 * maxBytes) - 1;
+      while (true) {
+        const digit = this.readAtomically(() => {
+          const char = this.readChar();
+          if (char === void 0) {
+            return void 0;
+          }
+          const num = Number.parseInt(char, radix);
+          if (Number.isNaN(num)) {
+            return void 0;
+          }
+          return num;
+        });
+        if (digit === void 0) {
+          break;
+        }
+        result *= radix;
+        result += digit;
+        if (result > maxValue2) {
+          return void 0;
+        }
+        digitCount += 1;
+        if (maxDigits !== void 0) {
+          if (digitCount > maxDigits) {
+            return void 0;
+          }
+        }
+      }
+      if (digitCount === 0) {
+        return void 0;
+      } else if (!allowZeroPrefix && hasLeadingZero && digitCount > 1) {
+        return void 0;
+      } else {
+        return result;
+      }
+    });
+  }
+  /** Read an IPv4 address. */
+  readIPv4Addr() {
+    return this.readAtomically(() => {
+      const out = new Uint8Array(4);
+      for (let i = 0; i < out.length; i++) {
+        const ix = this.readSeparator(".", i, () => this.readNumber(10, 3, false, 1));
+        if (ix === void 0) {
+          return void 0;
+        }
+        out[i] = ix;
+      }
+      return out;
+    });
+  }
+  /** Read an IPv6 Address. */
+  readIPv6Addr() {
+    const readGroups = (groups) => {
+      for (let i = 0; i < groups.length / 2; i++) {
+        const ix = i * 2;
+        if (i < groups.length - 3) {
+          const ipv4 = this.readSeparator(":", i, () => this.readIPv4Addr());
+          if (ipv4 !== void 0) {
+            groups[ix] = ipv4[0];
+            groups[ix + 1] = ipv4[1];
+            groups[ix + 2] = ipv4[2];
+            groups[ix + 3] = ipv4[3];
+            return [ix + 4, true];
+          }
+        }
+        const group = this.readSeparator(":", i, () => this.readNumber(16, 4, true, 2));
+        if (group === void 0) {
+          return [ix, false];
+        }
+        groups[ix] = group >> 8;
+        groups[ix + 1] = group & 255;
+      }
+      return [groups.length, false];
+    };
+    return this.readAtomically(() => {
+      const head = new Uint8Array(16);
+      const [headSize, headIp4] = readGroups(head);
+      if (headSize === 16) {
+        return head;
+      }
+      if (headIp4) {
+        return void 0;
+      }
+      if (this.readGivenChar(":") === void 0) {
+        return void 0;
+      }
+      if (this.readGivenChar(":") === void 0) {
+        return void 0;
+      }
+      const tail = new Uint8Array(14);
+      const limit = 16 - (headSize + 2);
+      const [tailSize] = readGroups(tail.subarray(0, limit));
+      head.set(tail.subarray(0, tailSize), 16 - tailSize);
+      return head;
+    });
+  }
+  /** Read an IP Address, either IPv4 or IPv6. */
+  readIPAddr() {
+    return this.readIPv4Addr() ?? this.readIPv6Addr();
+  }
+};
+
+// ../../node_modules/@chainsafe/is-ip/lib/parse.js
+var MAX_IPV6_LENGTH = 45;
+var MAX_IPV4_LENGTH = 15;
+var parser = new Parser();
+function parseIPv4(input) {
+  if (input.length > MAX_IPV4_LENGTH) {
+    return void 0;
+  }
+  return parser.new(input).parseWith(() => parser.readIPv4Addr());
+}
+function parseIPv6(input) {
+  if (input.includes("%")) {
+    input = input.split("%")[0];
+  }
+  if (input.length > MAX_IPV6_LENGTH) {
+    return void 0;
+  }
+  return parser.new(input).parseWith(() => parser.readIPv6Addr());
+}
+
+// ../../node_modules/@chainsafe/is-ip/lib/is-ip.js
+function isIPv4(input) {
+  return Boolean(parseIPv4(input));
+}
+function isIPv6(input) {
+  return Boolean(parseIPv6(input));
+}
 
 // ../../node_modules/@multiformats/multiaddr/dist/src/constants.js
 var CODE_IP4 = 4;
@@ -14657,25 +16135,17 @@ ipRegex.v4 = (options2) => options2 && options2.exact ? v4exact : new RegExp(`${
 ipRegex.v6 = (options2) => options2 && options2.exact ? v6exact : new RegExp(`${boundry(options2)}${v6}${boundry(options2)}`, "g");
 var ip_regex_default = ipRegex;
 
-// ../../node_modules/function-timeout/index.js
-import vm from "vm";
-function functionTimeout(function_, { timeout } = {}) {
-  const script = new vm.Script("returnValue = function_()");
-  const wrappedFunction = (...arguments_) => {
-    const context = {
-      function_: () => function_(...arguments_)
-    };
-    script.runInNewContext(context, { timeout });
-    return context.returnValue;
-  };
+// ../../node_modules/function-timeout/browser.js
+function functionTimeout(function_) {
+  const wrappedFunction = (...arguments_) => function_(...arguments_);
   Object.defineProperty(wrappedFunction, "name", {
     value: `functionTimeout(${function_.name || "<anonymous>"})`,
     configurable: true
   });
   return wrappedFunction;
 }
-function isTimeoutError(error) {
-  return error?.code === "ERR_SCRIPT_EXECUTION_TIMEOUT";
+function isTimeoutError() {
+  return false;
 }
 
 // ../../node_modules/clone-regexp/node_modules/is-regexp/index.js
@@ -14838,7 +16308,7 @@ function portForProtocol(protocol) {
 }
 
 // src/location.ts
-import { ed25519 as ed255197 } from "@noble/curves/ed25519";
+import { ed25519 as ed255198 } from "@noble/curves/ed25519";
 import { verifyMessage as verifyMessage2 } from "viem";
 var DEFAULT_TINYCLOUD_LOCATION_REGISTRY_URL = "https://registry.tinycloud.xyz";
 var DEFAULT_TINYCLOUD_FALLBACK_HOST = "https://node.tinycloud.xyz";
@@ -15077,13 +16547,14 @@ async function discoverLocalTinyCloudNode(options2 = {}) {
   }
   const fetchFn = options2.fetch ?? globalThis.fetch;
   const identityStore = options2.identityStore ?? defaultLocalNodeIdentityStore;
-  const staticCandidates = [
-    {
+  const staticCandidates = [];
+  if (options2.localNodeUrl) {
+    staticCandidates.push({
       source: "local-loopback",
-      url: options2.localNodeUrl ?? DEFAULT_LOCAL_NODE_URL,
+      url: options2.localNodeUrl,
       timeoutMs: LOCAL_LOOPBACK_PROBE_TIMEOUT_MS
-    }
-  ];
+    });
+  }
   if (options2.localLinkName) {
     if (isValidDnsLabel(options2.localLinkName)) {
       staticCandidates.push({
@@ -15403,13 +16874,13 @@ async function verifyPkhSignature(did, payload, signature) {
 }
 function verifyDidKeySignature(did, payload, signature) {
   const publicKey = ed25519PublicKeyFromDidKey2(did);
-  const signatureBytes = decodeBase64Url(signature);
+  const signatureBytes = decodeBase64Url2(signature);
   if (signatureBytes.length !== 64) {
     throw new LocationRecordValidationError(
       "did:key signature must be a base64url Ed25519 signature"
     );
   }
-  return ed255197.verify(
+  return ed255198.verify(
     signatureBytes,
     new TextEncoder().encode(payload),
     publicKey
@@ -15417,7 +16888,7 @@ function verifyDidKeySignature(did, payload, signature) {
 }
 function verifyDidKeyEd25519Signature(did, payload, signature) {
   const publicKey = ed25519PublicKeyFromDidKey2(did);
-  return ed255197.verify(signature, payload, publicKey);
+  return ed255198.verify(signature, payload, publicKey);
 }
 function ed25519PublicKeyFromDidKey2(did) {
   const identifier = did.slice("did:key:".length);
@@ -15456,7 +16927,7 @@ function base64UrlEncode3(bytes2) {
   }
   return output;
 }
-function decodeBase64Url(value) {
+function decodeBase64Url2(value) {
   const alphabet2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
   const bytes2 = [];
   let buffer = 0;
@@ -15479,11 +16950,14 @@ function decodeBase64Url(value) {
 }
 export {
   ACCOUNT_INDEX_SCHEMA2 as ACCOUNT_INDEX_SCHEMA,
+  ACCOUNT_MANIFEST_PERMISSIONS2 as ACCOUNT_MANIFEST_PERMISSIONS,
   ACCOUNT_REGISTRY_PATH,
   ACCOUNT_REGISTRY_SPACE,
+  ATTESTED_ENFORCER_BINDING_V2_SCHEMA,
   AccountService,
   AutoApproveSpaceCreationHandler,
   BOOTSTRAP_ALLOWLIST,
+  BOOTSTRAP_DEFAULT_ONLY_SESSION_REQUEST,
   BOOTSTRAP_DEFAULT_SPACE,
   BOOTSTRAP_ENCRYPTION_NETWORK_NAME,
   BOOTSTRAP_ENCRYPTION_NETWORK_RESOURCE_TEMPLATE,
@@ -15495,6 +16969,7 @@ export {
   BOOTSTRAP_SPACE_NAMES,
   CAPABILITIES,
   CAPABILITY_REGISTRY2 as CAPABILITY_REGISTRY,
+  CONTENT_SOURCE_V1_DOMAIN,
   CapabilityKeyRegistry,
   CapabilityKeyRegistryErrorCodes,
   CaveatedDelegationUnsupportedError,
@@ -15536,19 +17011,22 @@ export {
   EXPIRY,
   EncryptionService,
   EnsDataSchema,
-  ErrorCodes3 as ErrorCodes,
+  ErrorCodes4 as ErrorCodes,
   HOLDER_KEY_BINDING_PRESENTATION_SCHEMA,
   HOOKS,
   HooksService2 as HooksService,
   IdentityParseError,
   KV,
   KVService3 as KVService,
+  LAST_V2_CREATE_AT,
+  LAST_V2_READ_AT,
   LISTEN_SQL_STATEMENT_CATALOG,
   LOCAL_LINK_HOST_SUFFIX,
   LOCAL_LINK_PROBE_TIMEOUT_MS,
   LOCAL_LOOPBACK_PROBE_TIMEOUT_MS,
   LocationRecordValidationError,
   MAX_CONTENT_BYTES,
+  MAX_LEGACY_ENVELOPE_EXPIRES_AT,
   MAX_SEALED_SHARE_CONTENT_BYTES,
   MAX_SHARE_ARTIFACT_BYTES,
   MAX_SHARE_CONTENT_BYTES,
@@ -15556,8 +17034,13 @@ export {
   MemorySenderShareKeyStorage,
   MemorySenderShareRecordStorage,
   MemoryShareCache,
+  NATIVE_PROJECTION_V1_DOMAIN,
   NETWORK_NAME_PATTERN,
   NetworkIdError,
+  OPENKEY_ACTION_ID_SEPARATOR,
+  POLICY_CAPABILITY_V1_DOMAIN,
+  POLICY_CAPABILITY_V1_SCHEMA,
+  POLICY_ENFORCEMENT_DELEGATION_V2_SCHEMA,
   POLICY_ENGINE_CHALLENGE_REQUEST_SCHEMA,
   POLICY_ENGINE_CHALLENGE_RESPONSE_SCHEMA,
   POLICY_ENGINE_DENIAL_SCHEMA,
@@ -15565,7 +17048,10 @@ export {
   POLICY_ENGINE_RECORD_SCHEMA,
   POLICY_ENGINE_RESOLVE_REQUEST_SCHEMA,
   POLICY_SCHEMA,
+  POLICY_SESSION_UCAN_V1_PROFILE,
   POLICY_STATUS_SCHEMA,
+  POLICY_V1_DOMAIN,
+  POLICY_V1_SCHEMA,
   PORTABLE_DELEGATION_SCHEMA,
   PermissionNotInManifestError,
   PrefixedKVService,
@@ -15573,6 +17059,11 @@ export {
   REQUESTER_ENGINE_RETRY_ATTEMPTS,
   REQUESTER_ENGINE_RETRY_MAX_DELAY_MS,
   REQUESTER_NEAR_EXPIRY_SECONDS,
+  ROOT_REVOCATION_V1_DOMAIN,
+  ROOT_REVOCATION_V1_SCHEMA,
+  ROOT_STATUS_CHECKPOINT_V1_SCHEMA,
+  ROOT_STATUS_RENEWAL_V1_DOMAIN,
+  ROOT_STATUS_V1_DOMAIN,
   SECRETS_SPACE,
   SECRET_NAME_RE2 as SECRET_NAME_RE,
   SECRET_RECORDS_SCHEMA,
@@ -15650,13 +17141,16 @@ export {
   canonicalizeRecapCaveats,
   canonicalizeSecretScope,
   canonicalizeSignedObjectUnsigned,
+  canonicalizeUnifiedPolicyCapability,
   checkDecryptInvocationInput,
   checkNodeInfo,
   clearTinyCloudDebugLogs,
+  compactAttenuationContains,
   composeBootstrapSpaceManifest,
   composeManifestRequest,
   computeOwnerShareRegistrationCid,
   computeShareCid,
+  contentSourceDigestHex,
   createAndSignPolicy,
   createAndSignPolicyEngineRecord,
   createAndSignPolicyStatus,
@@ -15679,11 +17173,13 @@ export {
   defaultRetryPolicy2 as defaultRetryPolicy,
   defaultSignStrategy,
   defaultSpaceCreationHandler,
+  delegatePortablePolicySession,
   deriveDelegationCid,
   deriveSignedObjectMaterial,
   deriveSignedReceiverKey,
   didCacheKey,
   didEquals,
+  diffImmutableSiweFields,
   disableTinyCloudDebug,
   discoverLocalTinyCloudNode,
   discoverNetwork,
@@ -15704,18 +17200,23 @@ export {
   expandActionShortNames,
   expandPermissionEntries,
   expandPermissionEntry,
+  extractImmutableSiweFields,
+  extractRecapAttenuations,
   fetchLocationRecord,
   fetchPeerId,
   generateRandomReceiverKey,
+  getPolicyRootStatusV3,
   getTinyCloudDebugLogs,
   hexDecode,
   hexEncode,
   httpUrlToMultiaddr,
+  importPortableDelegation,
   installTinyCloudDebugGlobals,
   intersectShareCapabilities,
   isCapabilitySubset,
   isEvmAddress,
   isNetworkId,
+  isPlausibleOpenKeyActionId,
   isV2ShareLink,
   jcsCanonicalize,
   loadManifest,
@@ -15730,21 +17231,32 @@ export {
   normalizeShareActions,
   normalizeShareRecipientTarget,
   normalizeShareResource,
+  normalizeUnifiedPolicyCapability,
   ok5 as ok,
   openWrappedKey,
   parseCanonicalNetworkId,
+  parseCanonicalRecapResource,
+  parseCompactUcanAuthorization,
   parseExpiry,
   parseNetworkId2 as parseNetworkId,
   parseNodeNativePortableDelegation,
   parsePkhDid,
+  parsePolicySessionUcan,
+  parsePortableDelegation,
   parseRecapCapabilities,
   parseShareArtifact,
   parseShareUrl,
   parseSpaceUri,
   pkhDid,
+  policyCidFromCanonicalBytes,
+  policyDigestHex,
+  policyIdForDigestHex,
   principalDid,
   principalDidEquals,
+  projectUnifiedPolicyCapabilities,
+  projectUnifiedPolicyCapability,
   recapCaveatsEqual,
+  renewPolicyRootStatusV3,
   resolveCloudLocation,
   resolveManifest,
   resolveManifestKnowledgeRoot,
@@ -15754,16 +17266,25 @@ export {
   resourceCapabilitiesToAbilitiesMap,
   resourceCapabilitiesToSpaceAbilitiesMap,
   restoreDelegatedShareKey,
+  revokePolicyRootV3,
   serialize as serializeJcsJson,
+  serializePortableDelegation,
   serviceError5 as serviceError,
   shareCapabilityAllows,
   shareDeliveryTrustedKid,
+  signCompactUcanAuthorization,
   signLocationRecord,
   signShareEnvelope,
   signedObjectIdFor,
   submitHostDelegation,
   tinyCloudDebugLogger,
   toSignedObjectError,
+  unauthorizedRecapCapabilities,
+  unifiedNativeProjectionHashHex,
+  unifiedPolicyCapabilityContains,
+  unifiedPolicyCapabilityDigestHex,
+  unifiedPolicyCapabilityFromNative,
+  validateAuthorizationResultV1,
   validateClientSession,
   validateEnvelope,
   validateLocationRecord,
@@ -15787,6 +17308,8 @@ export {
   verifyLocationRecord,
   verifyPolicy,
   verifyPolicyEngineRecord,
+  verifyPolicyRootRevocationV3,
+  verifyPolicyRootStatusCheckpointV3,
   verifyPolicyStatus,
   verifyShareCid,
   verifyShareEnvelope,