@tinycloud/sdk-core 3.0.0-beta.0 → 3.0.0-beta.10

package/dist/index.cjs

@@ -64,6 +64,7 @@ __export(index_exports, {
   CREDENTIAL_CONTRACT_VERSION: () => CREDENTIAL_CONTRACT_VERSION,
   CREDENTIAL_ERROR_CODES: () => CREDENTIAL_ERROR_CODES,
   CREDENTIAL_FORMAT: () => CREDENTIAL_FORMAT,
+  CREDENTIAL_INVITATION_REQUEST_DOMAIN: () => CREDENTIAL_INVITATION_REQUEST_DOMAIN,
   CREDENTIAL_PROTOCOL: () => CREDENTIAL_ACQUISITION_PROTOCOL,
   CREDENTIAL_STEP_REGISTRY_VERSION: () => CREDENTIAL_STEP_REGISTRY_VERSION,
   CapabilityKeyRegistry: () => CapabilityKeyRegistry,
@@ -87,6 +88,7 @@ __export(index_exports, {
   DEFAULT_SIGNED_READ_URL_EXPIRY_MS: () => DEFAULT_SIGNED_READ_URL_EXPIRY_MS,
   DEFAULT_TINYCLOUD_FALLBACK_HOST: () => DEFAULT_TINYCLOUD_FALLBACK_HOST,
   DEFAULT_TINYCLOUD_LOCATION_REGISTRY_URL: () => DEFAULT_TINYCLOUD_LOCATION_REGISTRY_URL,
+  DELIVERY_ADMISSION_DOMAIN: () => DELIVERY_ADMISSION_DOMAIN,
   DUCKDB: () => import_bootstrap4.DUCKDB,
   DataVaultService: () => import_sdk_services8.DataVaultService,
   DatabaseHandle: () => import_sdk_services8.DatabaseHandle,
@@ -98,6 +100,7 @@ __export(index_exports, {
   DuckDbService: () => import_sdk_services8.DuckDbService,
   ED25519_JCS_SIGNATURE_SUITE: () => ED25519_JCS_SIGNATURE_SUITE,
   EIP191_JCS_SIGNATURE_SUITE: () => EIP191_JCS_SIGNATURE_SUITE,
+  EMAIL_CREDENTIAL_MAX_AGE_SECONDS: () => EMAIL_CREDENTIAL_MAX_AGE_SECONDS,
   ENCRYPTION: () => import_bootstrap4.ENCRYPTION,
   ENCRYPTION_MANIFEST_SPACE: () => ENCRYPTION_MANIFEST_SPACE,
   ENCRYPTION_NETWORK_URN_PREFIX: () => import_sdk_services8.ENCRYPTION_NETWORK_URN_PREFIX,
@@ -136,6 +139,8 @@ __export(index_exports, {
   NETWORK_NAME_PATTERN: () => import_sdk_services8.NETWORK_NAME_PATTERN,
   NetworkIdError: () => import_sdk_services8.NetworkIdError,
   OPENKEY_ACTION_ID_SEPARATOR: () => OPENKEY_ACTION_ID_SEPARATOR,
+  OWNER_NODE_BINDING_TIMEOUT_MS: () => OWNER_NODE_BINDING_TIMEOUT_MS,
+  OpenKeyManageKeyError: () => OpenKeyManageKeyError,
   POLICY_CAPABILITY_V1_DOMAIN: () => POLICY_CAPABILITY_V1_DOMAIN,
   POLICY_CAPABILITY_V1_SCHEMA: () => POLICY_CAPABILITY_V1_SCHEMA,
   POLICY_CREDENTIAL_REQUIREMENT_V1_TYPE: () => POLICY_CREDENTIAL_REQUIREMENT_V1_TYPE,
@@ -148,6 +153,8 @@ __export(index_exports, {
   POLICY_ENGINE_RESOLVE_REQUEST_SCHEMA: () => POLICY_ENGINE_RESOLVE_REQUEST_SCHEMA,
   POLICY_PRESENTATION_V3_DOMAIN: () => POLICY_PRESENTATION_V3_DOMAIN,
   POLICY_PRESENTATION_V3_SCHEMA: () => POLICY_PRESENTATION_V3_SCHEMA,
+  POLICY_PRESENTATION_V4_DOMAIN: () => POLICY_PRESENTATION_V4_DOMAIN,
+  POLICY_PRESENTATION_V4_SCHEMA: () => POLICY_PRESENTATION_V4_SCHEMA,
   POLICY_SCHEMA: () => POLICY_SCHEMA,
   POLICY_SESSION_UCAN_V1_PROFILE: () => POLICY_SESSION_UCAN_V1_PROFILE,
   POLICY_STATUS_SCHEMA: () => POLICY_STATUS_SCHEMA,
@@ -172,7 +179,6 @@ __export(index_exports, {
   SECRET_RECORDS_SCHEMA: () => import_bootstrap4.SECRET_RECORDS_SCHEMA,
   SERVICE_LONG_TO_SHORT: () => SERVICE_LONG_TO_SHORT,
   SERVICE_SHORT_TO_LONG: () => SERVICE_SHORT_TO_LONG,
-  SHARE_DELIVERY_AUTHORIZATION_DOMAIN: () => SHARE_DELIVERY_AUTHORIZATION_DOMAIN,
   SPACE: () => import_bootstrap4.SPACE,
   SQL: () => import_bootstrap4.SQL,
   SQLAction: () => import_sdk_services8.SQLAction,
@@ -206,7 +212,9 @@ __export(index_exports, {
   SpaceService: () => SpaceService,
   TINYCLOUD_ACCOUNT_SPACE_MANIFEST: () => import_bootstrap4.TINYCLOUD_ACCOUNT_SPACE_MANIFEST,
   TINYCLOUD_APPLICATIONS_SPACE_MANIFEST: () => import_bootstrap4.TINYCLOUD_APPLICATIONS_SPACE_MANIFEST,
+  TINYCLOUD_CANONICAL_IDENTITY_CLAIM: () => TINYCLOUD_CANONICAL_IDENTITY_CLAIM,
   TINYCLOUD_DEFAULT_SPACE_MANIFEST: () => import_bootstrap4.TINYCLOUD_DEFAULT_SPACE_MANIFEST,
+  TINYCLOUD_MANAGE_KEY_SCOPE: () => TINYCLOUD_MANAGE_KEY_SCOPE,
   TINYCLOUD_PUBLIC_SPACE_MANIFEST: () => import_bootstrap4.TINYCLOUD_PUBLIC_SPACE_MANIFEST,
   TINYCLOUD_SECRETS_BOOTSTRAP_MANIFEST: () => import_bootstrap4.TINYCLOUD_SECRETS_BOOTSTRAP_MANIFEST,
   TinyCloud: () => TinyCloud,
@@ -223,6 +231,7 @@ __export(index_exports, {
   activateSessionWithHost: () => activateSessionWithHost,
   addressStorageKey: () => addressStorageKey,
   admitPolicyCredentialV3: () => admitPolicyCredentialV3,
+  admitPolicyCredentialV4: () => admitPolicyCredentialV4,
   applyPrefix: () => applyPrefix,
   bootstrapEncryptionNetworkId: () => import_bootstrap4.bootstrapEncryptionNetworkId,
   bootstrapSpaceId: () => import_bootstrap4.bootstrapSpaceId,
@@ -233,6 +242,7 @@ __export(index_exports, {
   buildDecryptInvocation: () => import_sdk_services8.buildDecryptInvocation,
   buildNetworkId: () => import_sdk_services8.buildNetworkId,
   buildPolicyCredentialPresentationV3: () => buildPolicyCredentialPresentationV3,
+  buildPolicyCredentialPresentationV4: () => buildPolicyCredentialPresentationV4,
   buildSpaceUri: () => buildSpaceUri,
   canonicalDigest: () => canonicalDigest,
   canonicalHashHex: () => import_sdk_services8.canonicalHashHex,
@@ -263,10 +273,12 @@ __export(index_exports, {
   createAndSignSignedObject: () => createAndSignSignedObject,
   createCapabilityKeyRegistry: () => createCapabilityKeyRegistry,
   createDelegatedShareKey: () => createDelegatedShareKey,
+  createEmailCredentialRequirement: () => createEmailCredentialRequirement,
   createHolderBinding: () => createHolderBinding,
   createInMemoryLocalNodeIdentityStore: () => createInMemoryLocalNodeIdentityStore,
   createLocalStorageLocalNodeIdentityStore: () => createLocalStorageLocalNodeIdentityStore,
   createOpenKeyCallbackSigningStrategy: () => createOpenKeyCallbackSigningStrategy,
+  createOpenKeyManageKeySigningStrategy: () => createOpenKeyManageKeySigningStrategy,
   createPolicyEnforcementDelegation: () => createPolicyEnforcementDelegation,
   createShareArtifact: () => createShareArtifact,
   createShareArtifactAsync: () => createShareArtifactAsync,
@@ -325,6 +337,7 @@ __export(index_exports, {
   generateRandomReceiverKey: () => import_sdk_services8.generateRandomReceiverKey,
   getPolicyRootStatusV3: () => getPolicyRootStatusV3,
   getTinyCloudDebugLogs: () => import_sdk_services8.getTinyCloudDebugLogs,
+  hasTinyCloudManageKeyScope: () => hasTinyCloudManageKeyScope,
   hexDecode: () => import_sdk_services8.hexDecode,
   hexEncode: () => import_sdk_services8.hexEncode,
   holderBindingCanonicalBytes: () => holderBindingCanonicalBytes,
@@ -339,6 +352,7 @@ __export(index_exports, {
   isNetworkId: () => import_sdk_services8.isNetworkId,
   isPlausibleOpenKeyActionId: () => isPlausibleOpenKeyActionId,
   isV2ShareLink: () => isV2ShareLink,
+  issuedCredentialEnvelopeFromVerified: () => issuedCredentialEnvelopeFromVerified,
   jcsCanonicalize: () => jcsCanonicalize,
   loadManifest: () => loadManifest,
   locationPayloadForRecord: () => locationPayloadForRecord,
@@ -357,6 +371,8 @@ __export(index_exports, {
   openWrappedKey: () => import_sdk_services8.openWrappedKey,
   parseCanonicalNetworkId: () => parseCanonicalNetworkId,
   parseCanonicalRecapResource: () => parseCanonicalRecapResource,
+  parseCanonicalTinyCloudIdentity: () => parseCanonicalTinyCloudIdentity,
+  parseCanonicalTinyCloudIdentityClaims: () => parseCanonicalTinyCloudIdentityClaims,
   parseCompactUcanAuthorization: () => parseCompactUcanAuthorization,
   parseExpiry: () => parseExpiry,
   parseNetworkId: () => import_sdk_services8.parseNetworkId,
@@ -365,6 +381,7 @@ __export(index_exports, {
   parsePolicySessionUcan: () => parsePolicySessionUcan,
   parsePortableDelegation: () => parsePortableDelegation,
   parseRecapCapabilities: () => parseRecapCapabilities,
+  parseSecretCatalogKey: () => import_sdk_services8.parseSecretCatalogKey,
   parseShareArtifact: () => parseShareArtifact,
   parseShareUrl: () => parseShareUrl,
   parseSpaceUri: () => parseSpaceUri,
@@ -377,8 +394,11 @@ __export(index_exports, {
   principalDidEquals: () => principalDidEquals,
   projectUnifiedPolicyCapabilities: () => projectUnifiedPolicyCapabilities,
   projectUnifiedPolicyCapability: () => projectUnifiedPolicyCapability,
+  publishLocationRecord: () => publishLocationRecord,
   recapCaveatsEqual: () => recapCaveatsEqual,
+  registerPolicyV3: () => registerPolicyV3,
   renewPolicyRootStatusV3: () => renewPolicyRootStatusV3,
+  requestTinyCloudManageKeyScope: () => requestTinyCloudManageKeyScope,
   resolveCloudLocation: () => resolveCloudLocation,
   resolveManifest: () => resolveManifest,
   resolveManifestKnowledgeRoot: () => resolveManifestKnowledgeRoot,
@@ -394,10 +414,10 @@ __export(index_exports, {
   serviceError: () => import_sdk_services8.serviceError,
   sha256Base64Url: () => sha256Base64Url,
   shareCapabilityAllows: () => shareCapabilityAllows,
-  shareDeliveryTrustedKid: () => shareDeliveryTrustedKid,
   signCompactUcanAuthorization: () => signCompactUcanAuthorization,
   signCompactUcanRootAuthorization: () => signCompactUcanRootAuthorization,
   signLocationRecord: () => signLocationRecord,
+  signPolicyCredentialPresentationV4: () => signPolicyCredentialPresentationV4,
   signShareEnvelope: () => signShareEnvelope,
   signedObjectIdFor: () => signedObjectIdFor,
   submitHostDelegation: () => submitHostDelegation,
@@ -430,13 +450,14 @@ __export(index_exports, {
   validatePolicyStatusSignedShape: () => validatePolicyStatusSignedShape,
   validatePolicyStatusUnsigned: () => validatePolicyStatusUnsigned,
   validatePolicyUnsigned: () => validatePolicyUnsigned,
-  validateShareDeliveryAuthorizationBytes: () => validateShareDeliveryAuthorizationBytes,
+  validateShareDeliveryAuthorizationV3Bytes: () => validateShareDeliveryAuthorizationV3Bytes,
   validateUnifiedPolicyV2: () => validateUnifiedPolicyV2,
   verifyDecryptResponse: () => import_sdk_services8.verifyDecryptResponse,
   verifyDidKeyEd25519Signature: () => verifyDidKeyEd25519Signature,
   verifyEip191MessageSignature: () => verifyEip191MessageSignature,
   verifyIssuedCredential: () => verifyIssuedCredential,
   verifyLocationRecord: () => verifyLocationRecord,
+  verifyOwnerNodeBinding: () => verifyOwnerNodeBinding,
   verifyPolicy: () => verifyPolicy,
   verifyPolicyEngineRecord: () => verifyPolicyEngineRecord,
   verifyPolicyRootRevocationV3: () => verifyPolicyRootRevocationV3,
@@ -1001,6 +1022,17 @@ function isDigest(value) {
 
 // src/credentials/requirement.ts
 var ID2 = /^[a-z0-9][a-z0-9._-]{0,127}(?:\/v1)?$/;
+var EMAIL_CREDENTIAL_MAX_AGE_SECONDS = 3600;
+function createEmailCredentialRequirement(input) {
+  return validateCredentialRequirement({
+    type: "TinyCloudCredentialRequirement",
+    version: 1,
+    profile: input.profile,
+    credentialType: input.credentialType,
+    claims: { email: input.email },
+    maxAgeSeconds: EMAIL_CREDENTIAL_MAX_AGE_SECONDS
+  });
+}
 function validateCredentialRequirement(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) throw new CredentialError("UNSUPPORTED_PROFILE", "Credential requirement is invalid");
   const raw = value;
@@ -2215,16 +2247,16 @@ function policyCapabilityContains(authority, request) {
   return caveatsContain(auth.caveats, req.caveats);
 }
 function normalizePolicyCapabilityWithOptions(input, options2) {
-  const object3 = expectObject(input, "$");
-  assertExactKeys(object3, ["service", "space", "path", "actions", "caveats"], "$");
-  const service = requiredString(object3, "service", "$", "policy-capability-malformed-service");
+  const object4 = expectObject(input, "$");
+  assertExactKeys(object4, ["service", "space", "path", "actions", "caveats"], "$");
+  const service = requiredString(object4, "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(object3, "space", "$", "policy-capability-malformed-space");
+  const space = requiredString(object4, "space", "$", "policy-capability-malformed-space");
   validateConcreteSpace(space);
   const canonicalSpace = space.normalize("NFC");
   if (options2.requireCanonical && canonicalSpace !== space) {
@@ -2233,7 +2265,7 @@ function normalizePolicyCapabilityWithOptions(input, options2) {
       "$.space must already be canonical NFC"
     );
   }
-  const rawPath = requiredString(object3, "path", "$", "policy-capability-malformed-path");
+  const rawPath = requiredString(object4, "path", "$", "policy-capability-malformed-path");
   validateRawPath(rawPath, options2);
   const path = normalizePath(rawPath);
   if (options2.requireCanonical && path !== rawPath) {
@@ -2244,7 +2276,7 @@ function normalizePolicyCapabilityWithOptions(input, options2) {
   }
   validateRawPath(path, options2);
   const actions = normalizeActions(
-    requiredArray(object3, "actions", "$", "policy-capability-malformed-action"),
+    requiredArray(object4, "actions", "$", "policy-capability-malformed-action"),
     service,
     options2
   );
@@ -2253,9 +2285,9 @@ function normalizePolicyCapabilityWithOptions(input, options2) {
   output.space = canonicalSpace;
   output.path = path;
   output.actions = actions;
-  if (hasOwn(object3, "caveats")) {
+  if (hasOwn(object4, "caveats")) {
     output.caveats = validateCaveats(
-      requiredValue(object3, "caveats", "$", "policy-capability-malformed-caveats"),
+      requiredValue(object4, "caveats", "$", "policy-capability-malformed-caveats"),
       output.service
     );
   }
@@ -2278,9 +2310,9 @@ function expectObject(input, path) {
     );
   }
 }
-function assertExactKeys(object3, allowed, path) {
+function assertExactKeys(object4, allowed, path) {
   const allowedSet = new Set(allowed);
-  for (const key of Object.keys(object3)) {
+  for (const key of Object.keys(object4)) {
     if (!allowedSet.has(key)) {
       throw new PolicyCapabilityError(
         key === "id" || key === "scope" ? "policy-capability-malformed" : "policy-capability-unknown-key",
@@ -2289,21 +2321,21 @@ function assertExactKeys(object3, allowed, path) {
     }
   }
 }
-function requiredValue(object3, key, path, code3) {
-  if (!hasOwn(object3, key)) {
+function requiredValue(object4, key, path, code3) {
+  if (!hasOwn(object4, key)) {
     throw new PolicyCapabilityError(code3, `${path}.${key} is required`);
   }
-  return object3[key];
+  return object4[key];
 }
-function requiredString(object3, key, path, code3) {
-  const value = requiredValue(object3, key, path, code3);
+function requiredString(object4, key, path, code3) {
+  const value = requiredValue(object4, 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(object3, key, path, code3) {
-  const value = requiredValue(object3, key, path, code3);
+function requiredArray(object4, key, path, code3) {
+  const value = requiredValue(object4, key, path, code3);
   if (!Array.isArray(value)) {
     throw new PolicyCapabilityError(code3, `${path}.${key} must be an array`);
   }
@@ -2448,11 +2480,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 object3 = input;
-  assertCaveatKeys(object3, ["name", "sql", "fixedParams"], path);
-  caveatString(object3, "name", path);
-  caveatString(object3, "sql", path);
-  const fixedParams = requiredCaveat(object3, "fixedParams", path);
+  const object4 = input;
+  assertCaveatKeys(object4, ["name", "sql", "fixedParams"], path);
+  caveatString(object4, "name", path);
+  caveatString(object4, "sql", path);
+  const fixedParams = requiredCaveat(object4, "fixedParams", path);
   if (!Array.isArray(fixedParams)) {
     throw new PolicyCapabilityError(
       "policy-capability-malformed-caveats",
@@ -2467,20 +2499,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 object3 = input;
-  assertCaveatKeys(object3, ["index", "value"], path);
-  const index = requiredCaveat(object3, "index", path);
+  const object4 = input;
+  assertCaveatKeys(object4, ["index", "value"], path);
+  const index = requiredCaveat(object4, "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(object3, "value", path);
+  requiredCaveat(object4, "value", path);
 }
-function assertCaveatKeys(object3, allowed, path) {
+function assertCaveatKeys(object4, allowed, path) {
   const allowedSet = new Set(allowed);
-  for (const key of Object.keys(object3)) {
+  for (const key of Object.keys(object4)) {
     if (!allowedSet.has(key)) {
       throw new PolicyCapabilityError(
         "policy-capability-malformed-caveats",
@@ -2489,17 +2521,17 @@ function assertCaveatKeys(object3, allowed, path) {
     }
   }
 }
-function requiredCaveat(object3, key, path) {
-  if (!hasOwn(object3, key)) {
+function requiredCaveat(object4, key, path) {
+  if (!hasOwn(object4, key)) {
     throw new PolicyCapabilityError(
       "policy-capability-malformed-caveats",
       `${path}.${key} is required`
     );
   }
-  return object3[key];
+  return object4[key];
 }
-function caveatString(object3, key, path) {
-  const value = requiredCaveat(object3, key, path);
+function caveatString(object4, key, path) {
+  const value = requiredCaveat(object4, key, path);
   if (typeof value !== "string" || value.length === 0) {
     throw new PolicyCapabilityError(
       "policy-capability-malformed-caveats",
@@ -2530,8 +2562,8 @@ function caveatsContain(authority, request) {
     (statement) => authorityStatements.some((candidate) => jcsCanonicalize(candidate) === jcsCanonicalize(statement))
   );
 }
-function hasOwn(object3, key) {
-  return objectHasOwn2(object3, key);
+function hasOwn(object4, key) {
+  return objectHasOwn2(object4, key);
 }
 
 // src/policy/signed-object.ts
@@ -2859,17 +2891,17 @@ async function createAndSignSignedObject(input, signer) {
 }
 function createAndSignPolicy(input, signer) {
   return createAndSignSignedObject(input, signer).then(
-    (object3) => validatePolicySignedShape(object3)
+    (object4) => validatePolicySignedShape(object4)
   );
 }
 function createAndSignPolicyStatus(input, signer) {
   return createAndSignSignedObject(input, signer).then(
-    (object3) => validatePolicyStatusSignedShape(object3)
+    (object4) => validatePolicyStatusSignedShape(object4)
   );
 }
 function createAndSignPolicyEngineRecord(input, signer) {
   return createAndSignSignedObject(input, signer).then(
-    (object3) => validatePolicyEngineRecordSignedShape(object3)
+    (object4) => validatePolicyEngineRecordSignedShape(object4)
   );
 }
 async function verifySignedObject(input) {
@@ -2973,9 +3005,9 @@ function validateUnsignedForDescriptor(input, descriptor) {
   }
 }
 function validatePolicyShape(input, signed) {
-  const object3 = expectJsonObject(normalizeJson(input), "$");
+  const object4 = expectJsonObject(normalizeJson(input), "$");
   assertExactKeys2(
-    object3,
+    object4,
     signed ? [
       "schema",
       "policyId",
@@ -3003,30 +3035,30 @@ function validatePolicyShape(input, signed) {
     ],
     "$"
   );
-  expectConst(requiredString2(object3, "schema", "$"), POLICY_SCHEMA, "$.schema");
+  expectConst(requiredString2(object4, "schema", "$"), POLICY_SCHEMA, "$.schema");
   if (signed) {
-    requiredString2(object3, "policyId", "$");
-    validateSignature(requiredValue2(object3, "signature", "$"));
+    requiredString2(object4, "policyId", "$");
+    validateSignature(requiredValue2(object4, "signature", "$"));
   }
-  requiredString2(object3, "ownerDid", "$");
-  requiredString2(object3, "signingKeyDid", "$");
-  requiredDateString(object3, "createdAt", "$");
-  optionalDateString(object3, "expiresAt", "$");
-  validatePolicyResource(requiredValue2(object3, "resource", "$"), "$.resource");
-  validateExpression(requiredValue2(object3, "when", "$"), "$.when");
-  validateGrant(requiredValue2(object3, "grant", "$"), "$.grant");
-  if (hasOwn2(object3, "disclosure")) {
-    validateDisclosure(requiredValue2(object3, "disclosure", "$"), "$.disclosure");
+  requiredString2(object4, "ownerDid", "$");
+  requiredString2(object4, "signingKeyDid", "$");
+  requiredDateString(object4, "createdAt", "$");
+  optionalDateString(object4, "expiresAt", "$");
+  validatePolicyResource(requiredValue2(object4, "resource", "$"), "$.resource");
+  validateExpression(requiredValue2(object4, "when", "$"), "$.when");
+  validateGrant(requiredValue2(object4, "grant", "$"), "$.grant");
+  if (hasOwn2(object4, "disclosure")) {
+    validateDisclosure(requiredValue2(object4, "disclosure", "$"), "$.disclosure");
   }
-  if (hasOwn2(object3, "audit")) {
-    validateAudit(requiredValue2(object3, "audit", "$"), "$.audit");
+  if (hasOwn2(object4, "audit")) {
+    validateAudit(requiredValue2(object4, "audit", "$"), "$.audit");
   }
-  return object3;
+  return object4;
 }
 function validatePolicyStatusShape(input, signed) {
-  const object3 = expectJsonObject(normalizeJson(input), "$");
+  const object4 = expectJsonObject(normalizeJson(input), "$");
   assertExactKeys2(
-    object3,
+    object4,
     signed ? [
       "schema",
       "statusId",
@@ -3050,28 +3082,28 @@ function validatePolicyStatusShape(input, signed) {
     ],
     "$"
   );
-  expectConst(requiredString2(object3, "schema", "$"), POLICY_STATUS_SCHEMA, "$.schema");
+  expectConst(requiredString2(object4, "schema", "$"), POLICY_STATUS_SCHEMA, "$.schema");
   if (signed) {
-    requiredString2(object3, "statusId", "$");
-    validateSignature(requiredValue2(object3, "signature", "$"));
+    requiredString2(object4, "statusId", "$");
+    validateSignature(requiredValue2(object4, "signature", "$"));
   }
-  requiredString2(object3, "policyId", "$");
-  requiredString2(object3, "ownerDid", "$");
-  requiredInteger(object3, "sequence", "$", 0);
-  expectOneOf(requiredString2(object3, "disposition", "$"), [
+  requiredString2(object4, "policyId", "$");
+  requiredString2(object4, "ownerDid", "$");
+  requiredInteger(object4, "sequence", "$", 0);
+  expectOneOf(requiredString2(object4, "disposition", "$"), [
     "active",
     "suspended",
     "revoked"
   ], "$.disposition");
-  requiredDateString(object3, "effectiveAt", "$");
-  optionalString(object3, "reasonCode", "$");
-  requiredString2(object3, "signingKeyDid", "$");
-  return object3;
+  requiredDateString(object4, "effectiveAt", "$");
+  optionalString(object4, "reasonCode", "$");
+  requiredString2(object4, "signingKeyDid", "$");
+  return object4;
 }
 function validatePolicyEngineRecordShape(input, signed) {
-  const object3 = expectJsonObject(normalizeJson(input), "$");
+  const object4 = expectJsonObject(normalizeJson(input), "$");
   assertExactKeys2(
-    object3,
+    object4,
     signed ? [
       "schema",
       "engineRecordId",
@@ -3096,44 +3128,44 @@ function validatePolicyEngineRecordShape(input, signed) {
     "$"
   );
   expectConst(
-    requiredString2(object3, "schema", "$"),
+    requiredString2(object4, "schema", "$"),
     POLICY_ENGINE_RECORD_SCHEMA,
     "$.schema"
   );
   if (signed) {
-    requiredString2(object3, "engineRecordId", "$");
-    validateSignature(requiredValue2(object3, "signature", "$"));
+    requiredString2(object4, "engineRecordId", "$");
+    validateSignature(requiredValue2(object4, "signature", "$"));
   }
-  requiredString2(object3, "ownerDid", "$");
-  requiredString2(object3, "endpoint", "$");
-  requiredString2(object3, "audience", "$");
+  requiredString2(object4, "ownerDid", "$");
+  requiredString2(object4, "endpoint", "$");
+  requiredString2(object4, "audience", "$");
   requiredStringArray(
-    object3,
+    object4,
     "supportedPolicyVersions",
     "$",
     (value, path) => expectConst(value, "v0", path)
   );
-  requiredStringArray(object3, "supportedEvidenceVerifiers", "$");
-  requiredString2(object3, "grantIssuerDid", "$");
-  requiredDateString(object3, "expiresAt", "$");
-  return object3;
+  requiredStringArray(object4, "supportedEvidenceVerifiers", "$");
+  requiredString2(object4, "grantIssuerDid", "$");
+  requiredDateString(object4, "expiresAt", "$");
+  return object4;
 }
 function validateSignature(input) {
-  const object3 = expectJsonObject(input, "$.signature");
-  assertExactKeys2(object3, ["suite", "signerDid", "value"], "$.signature");
-  const suite = requiredString2(object3, "suite", "$.signature");
+  const object4 = expectJsonObject(input, "$.signature");
+  assertExactKeys2(object4, ["suite", "signerDid", "value"], "$.signature");
+  const suite = requiredString2(object4, "suite", "$.signature");
   assertSupportedSignatureSuite(suite);
-  const signerDid = requiredString2(object3, "signerDid", "$.signature");
-  const value = requiredString2(object3, "value", "$.signature");
+  const signerDid = requiredString2(object4, "signerDid", "$.signature");
+  const value = requiredString2(object4, "value", "$.signature");
   decodeSignatureValue(value, suite);
   return { suite, signerDid, value };
 }
 function validatePolicyResource(input, path) {
-  const object3 = expectJsonObject(input, path);
-  assertExactKeys2(object3, ["resourceType", "resourceId", "permissionsCeiling"], path);
-  requiredString2(object3, "resourceType", path);
-  requiredString2(object3, "resourceId", path);
-  const ceiling = requiredArray2(object3, "permissionsCeiling", path, 1);
+  const object4 = expectJsonObject(input, path);
+  assertExactKeys2(object4, ["resourceType", "resourceId", "permissionsCeiling"], path);
+  requiredString2(object4, "resourceType", path);
+  requiredString2(object4, "resourceId", path);
+  const ceiling = requiredArray2(object4, "permissionsCeiling", path, 1);
   for (let index = 0; index < ceiling.length; index++) {
     validatePolicyCapability(ceiling[index], `${path}.permissionsCeiling[${index}]`);
   }
@@ -3149,10 +3181,10 @@ function validatePolicyPermissionsCeilingForSigning(input) {
   }
 }
 function validatePolicyCapability(input, path) {
-  const object3 = expectJsonObject(input, path);
+  const object4 = expectJsonObject(input, path);
   try {
-    const canonical = canonicalizePolicyCapability(object3);
-    if (jcsCanonicalize(object3) !== jcsCanonicalize(canonical)) {
+    const canonical = canonicalizePolicyCapability(object4);
+    if (jcsCanonicalize(object4) !== jcsCanonicalize(canonical)) {
       throw new SignedObjectSchemaError(`${path} must be canonical PolicyCapability JSON`);
     }
   } catch (error) {
@@ -3165,10 +3197,10 @@ function validatePolicyCapability(input, path) {
   }
 }
 function validatePolicyCapabilityForSigning(input, path) {
-  const object3 = expectJsonObject(input, path);
+  const object4 = expectJsonObject(input, path);
   try {
-    const canonical = normalizePolicyCapability(object3);
-    if (jcsCanonicalize(object3) !== jcsCanonicalize(canonical)) {
+    const canonical = normalizePolicyCapability(object4);
+    if (jcsCanonicalize(object4) !== jcsCanonicalize(canonical)) {
       throw new SignedObjectSchemaError(`${path} must be strict canonical PolicyCapability JSON`);
     }
   } catch (error) {
@@ -3181,43 +3213,43 @@ function validatePolicyCapabilityForSigning(input, path) {
   }
 }
 function validateExpression(input, path) {
-  const object3 = expectJsonObject(input, path);
-  const keys = Object.keys(object3);
+  const object4 = expectJsonObject(input, path);
+  const keys = Object.keys(object4);
   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(object3, key, path, 1);
+    const values = requiredArray2(object4, 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(object3, "subject", path), `${path}.subject`);
+    const subject = expectJsonObject(requiredValue2(object4, "subject", path), `${path}.subject`);
     assertExactKeys2(subject, ["did"], `${path}.subject`);
     requiredString2(subject, "did", `${path}.subject`);
     return;
   }
   if (key === "evidence") {
-    validateEvidenceRequirement(requiredValue2(object3, "evidence", path), `${path}.evidence`);
+    validateEvidenceRequirement(requiredValue2(object4, "evidence", path), `${path}.evidence`);
     return;
   }
   throw new SignedObjectSchemaError(`${path} has unknown expression key ${key}`);
 }
 function validateEvidenceRequirement(input, path) {
-  const object3 = expectJsonObject(input, path);
+  const object4 = expectJsonObject(input, path);
   assertExactKeys2(
-    object3,
+    object4,
     ["requirementId", "verifier", "requirements", "authority", "freshness"],
     path
   );
-  requiredString2(object3, "requirementId", path);
-  requiredString2(object3, "verifier", path);
-  requiredValue2(object3, "requirements", path);
-  if (hasOwn2(object3, "authority")) {
-    const authority = expectJsonObject(requiredValue2(object3, "authority", path), `${path}.authority`);
+  requiredString2(object4, "requirementId", path);
+  requiredString2(object4, "verifier", path);
+  requiredValue2(object4, "requirements", path);
+  if (hasOwn2(object4, "authority")) {
+    const authority = expectJsonObject(requiredValue2(object4, "authority", path), `${path}.authority`);
     assertExactKeys2(
       authority,
       ["profile", "acceptedIssuers", "allowOwnerAuthorizedIssuer"],
@@ -3229,35 +3261,35 @@ function validateEvidenceRequirement(input, path) {
     }
     optionalBoolean(authority, "allowOwnerAuthorizedIssuer", `${path}.authority`);
   }
-  if (hasOwn2(object3, "freshness")) {
-    const freshness = expectJsonObject(requiredValue2(object3, "freshness", path), `${path}.freshness`);
+  if (hasOwn2(object4, "freshness")) {
+    const freshness = expectJsonObject(requiredValue2(object4, "freshness", path), `${path}.freshness`);
     assertExactKeys2(freshness, ["maxStatusAgeSeconds"], `${path}.freshness`);
     requiredInteger(freshness, "maxStatusAgeSeconds", `${path}.freshness`, 0);
   }
 }
 function validateGrant(input, path) {
-  const object3 = expectJsonObject(input, path);
-  assertExactKeys2(object3, ["output", "maxTtlSeconds", "delegationMode", "revocation"], path);
-  expectConst(requiredString2(object3, "output", path), "portable-delegation", `${path}.output`);
-  requiredInteger(object3, "maxTtlSeconds", path, 1);
-  expectOneOf(requiredString2(object3, "delegationMode", path), [
+  const object4 = expectJsonObject(input, path);
+  assertExactKeys2(object4, ["output", "maxTtlSeconds", "delegationMode", "revocation"], path);
+  expectConst(requiredString2(object4, "output", path), "portable-delegation", `${path}.output`);
+  requiredInteger(object4, "maxTtlSeconds", path, 1);
+  expectOneOf(requiredString2(object4, "delegationMode", path), [
     "terminal",
     "attenuable"
   ], `${path}.delegationMode`);
-  expectOneOf(requiredString2(object3, "revocation", path), [
+  expectOneOf(requiredString2(object4, "revocation", path), [
     "refresh_only",
     "active_cutoff"
   ], `${path}.revocation`);
 }
 function validateDisclosure(input, path) {
-  const object3 = expectJsonObject(input, path);
-  assertExactKeys2(object3, ["denial"], path);
-  expectOneOf(requiredString2(object3, "denial", path), ["none", "code", "debug"], `${path}.denial`);
+  const object4 = expectJsonObject(input, path);
+  assertExactKeys2(object4, ["denial"], path);
+  expectOneOf(requiredString2(object4, "denial", path), ["none", "code", "debug"], `${path}.denial`);
 }
 function validateAudit(input, path) {
-  const object3 = expectJsonObject(input, path);
-  assertExactKeys2(object3, ["issuance"], path);
-  expectOneOf(requiredString2(object3, "issuance", path), ["off", "security", "full"], `${path}.issuance`);
+  const object4 = expectJsonObject(input, path);
+  assertExactKeys2(object4, ["issuance"], path);
+  expectOneOf(requiredString2(object4, "issuance", path), ["off", "security", "full"], `${path}.issuance`);
 }
 function materialForUnsigned(unsigned, descriptor) {
   const jcs = jcsCanonicalize(unsigned);
@@ -3406,9 +3438,9 @@ function encodeSignatureValue(value, suite) {
   decodeSignatureValue(encoded, suite);
   return encoded;
 }
-function stripOwnIdAndSignature(object3, descriptor) {
+function stripOwnIdAndSignature(object4, descriptor) {
   const output = /* @__PURE__ */ Object.create(null);
-  for (const [key, value] of Object.entries(object3)) {
+  for (const [key, value] of Object.entries(object4)) {
     if (key === descriptor.idField || key === "signature") {
       continue;
     }
@@ -3417,8 +3449,8 @@ function stripOwnIdAndSignature(object3, descriptor) {
   return output;
 }
 function descriptorForUnsigned(input) {
-  const object3 = expectJsonObject(normalizeJson(input), "$");
-  return descriptorForSchema(requiredString2(object3, "schema", "$"));
+  const object4 = expectJsonObject(normalizeJson(input), "$");
+  return descriptorForSchema(requiredString2(object4, "schema", "$"));
 }
 function descriptorForSchema(schema) {
   if (schema === POLICY_SCHEMA) return DESCRIPTORS.Policy;
@@ -3432,28 +3464,28 @@ function expectJsonObject(input, path) {
   }
   return input;
 }
-function assertExactKeys2(object3, allowed, path) {
+function assertExactKeys2(object4, allowed, path) {
   const allowedSet = new Set(allowed);
-  for (const key of Object.keys(object3)) {
+  for (const key of Object.keys(object4)) {
     if (!allowedSet.has(key)) {
       throw new SignedObjectSchemaError(`${path} has unknown field ${key}`);
     }
   }
 }
-function requiredValue2(object3, key, path) {
-  if (!hasOwn2(object3, key)) {
+function requiredValue2(object4, key, path) {
+  if (!hasOwn2(object4, key)) {
     throw new SignedObjectSchemaError(`${path}.${key} is required`);
   }
-  return object3[key];
+  return object4[key];
 }
-function requiredString2(object3, key, path) {
-  return requireStringType(requiredValue2(object3, key, path), `${path}.${key}`);
+function requiredString2(object4, key, path) {
+  return requireStringType(requiredValue2(object4, key, path), `${path}.${key}`);
 }
-function optionalString(object3, key, path) {
-  if (!hasOwn2(object3, key)) {
+function optionalString(object4, key, path) {
+  if (!hasOwn2(object4, key)) {
     return;
   }
-  requireStringType(requiredValue2(object3, key, path), `${path}.${key}`);
+  requireStringType(requiredValue2(object4, key, path), `${path}.${key}`);
 }
 function requireStringType(value, path) {
   if (typeof value !== "string" || value.length === 0) {
@@ -3461,16 +3493,16 @@ function requireStringType(value, path) {
   }
   return value;
 }
-function optionalBoolean(object3, key, path) {
-  if (!hasOwn2(object3, key)) {
+function optionalBoolean(object4, key, path) {
+  if (!hasOwn2(object4, key)) {
     return;
   }
-  if (typeof requiredValue2(object3, key, path) !== "boolean") {
+  if (typeof requiredValue2(object4, key, path) !== "boolean") {
     throw new SignedObjectSchemaError(`${path}.${key} must be a boolean`);
   }
 }
-function requiredInteger(object3, key, path, minimum) {
-  const value = requiredValue2(object3, key, path);
+function requiredInteger(object4, key, path, minimum) {
+  const value = requiredValue2(object4, key, path);
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum) {
     throw new SignedObjectSchemaError(
       `${path}.${key} must be an integer >= ${minimum}`
@@ -3478,8 +3510,8 @@ function requiredInteger(object3, key, path, minimum) {
   }
   return value;
 }
-function requiredArray2(object3, key, path, minimum) {
-  const value = requiredValue2(object3, key, path);
+function requiredArray2(object4, key, path, minimum) {
+  const value = requiredValue2(object4, key, path);
   if (!Array.isArray(value) || value.length < minimum) {
     throw new SignedObjectSchemaError(
       `${path}.${key} must be an array with at least ${minimum} item(s)`
@@ -3487,22 +3519,22 @@ function requiredArray2(object3, key, path, minimum) {
   }
   return value;
 }
-function requiredStringArray(object3, key, path, check) {
-  const values = requiredArray2(object3, key, path, 0);
+function requiredStringArray(object4, key, path, check) {
+  const values = requiredArray2(object4, 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(object3, key, path) {
-  assertRfc3339(requiredString2(object3, key, path), `${path}.${key}`);
+function requiredDateString(object4, key, path) {
+  assertRfc3339(requiredString2(object4, key, path), `${path}.${key}`);
 }
-function optionalDateString(object3, key, path) {
-  if (!hasOwn2(object3, key)) {
+function optionalDateString(object4, key, path) {
+  if (!hasOwn2(object4, key)) {
     return;
   }
-  assertRfc3339(requiredString2(object3, key, path), `${path}.${key}`);
+  assertRfc3339(requiredString2(object4, key, path), `${path}.${key}`);
 }
 function assertRfc3339(value, path) {
   const match = value.match(
@@ -3534,8 +3566,8 @@ function expectOneOf(actual, allowed, path) {
   }
   throw new SignedObjectSchemaError(`${path} has unsupported value ${actual}`);
 }
-function hasOwn2(object3, key) {
-  return objectHasOwn3(object3, key);
+function hasOwn2(object4, key) {
+  return objectHasOwn3(object4, key);
 }
 function assertSupportedSignatureSuite(suite) {
   if (suite !== ED25519_JCS_SIGNATURE_SUITE && suite !== EIP191_JCS_SIGNATURE_SUITE) {
@@ -3762,9 +3794,9 @@ function expectObject2(input, path, code3) {
     );
   }
 }
-function assertExactKeys3(object3, allowed, path) {
+function assertExactKeys3(object4, allowed, path) {
   const allowedSet = new Set(allowed);
-  for (const key of Object.keys(object3)) {
+  for (const key of Object.keys(object4)) {
     if (!allowedSet.has(key)) {
       throw new PolicyAuthoringError(
         "policy-authoring-unknown-key",
@@ -3773,17 +3805,17 @@ function assertExactKeys3(object3, allowed, path) {
     }
   }
 }
-function requiredValue3(object3, key, path) {
-  if (!hasOwn3(object3, key)) {
+function requiredValue3(object4, key, path) {
+  if (!hasOwn3(object4, key)) {
     throw new PolicyAuthoringError(
       "policy-authoring-malformed",
       `${path}.${key} is required`
     );
   }
-  return object3[key];
+  return object4[key];
 }
-function requiredString3(object3, key, path) {
-  const value = requiredValue3(object3, key, path);
+function requiredString3(object4, key, path) {
+  const value = requiredValue3(object4, key, path);
   if (typeof value !== "string" || value.length === 0) {
     throw new PolicyAuthoringError(
       "policy-authoring-malformed",
@@ -3792,11 +3824,11 @@ function requiredString3(object3, key, path) {
   }
   return value;
 }
-function fieldString(object3, key, path, code3) {
-  if (!hasOwn3(object3, key)) {
+function fieldString(object4, key, path, code3) {
+  if (!hasOwn3(object4, key)) {
     throw new PolicyAuthoringError(code3, `${path}.${key} is required`);
   }
-  const value = object3[key];
+  const value = object4[key];
   if (typeof value !== "string" || value.length === 0) {
     throw new PolicyAuthoringError(
       code3,
@@ -3834,8 +3866,8 @@ function parseStrictRfc3339(value, path) {
 var objectHasOwn4 = Object.hasOwn ?? Object.prototype.hasOwnProperty.call.bind(
   Object.prototype.hasOwnProperty
 );
-function hasOwn3(object3, key) {
-  return objectHasOwn4(object3, key);
+function hasOwn3(object4, key) {
+  return objectHasOwn4(object4, key);
 }
 
 // src/policy/unified.ts
@@ -3862,9 +3894,11 @@ var MAX_LEGACY_ENVELOPE_EXPIRES_AT = "2026-12-29T00:00:00Z";
 var LAST_V2_READ_AT = "2027-01-05T00:00:00Z";
 async function requestPolicyChallengeV3(input) {
   const fetchFn = input.fetch ?? globalThis.fetch.bind(globalThis);
-  const response = await fetchFn(new URL("/share/v3/policy/challenges", input.nodeOrigin), {
+  const policyRuntimePath = policyRuntimeBasePath(input.policyRuntimePath);
+  const response = await fetchFn(new URL(`${policyRuntimePath}/challenges`, input.nodeOrigin), {
     method: "POST",
     redirect: "error",
+    signal: input.signal,
     headers: { accept: "application/json", "content-type": "application/json" },
     body: JSON.stringify({ policyCid: input.policyCid, recipientDid: input.recipientDid, requestedCapabilities: input.requestedCapabilities.map(normalizeUnifiedPolicyCapability) })
   });
@@ -3874,6 +3908,13 @@ async function requestPolicyChallengeV3(input) {
     throw new Error("policy challenge binding is invalid");
   return value;
 }
+function policyRuntimeBasePath(value) {
+  const path = value ?? "/policy/v3";
+  if (!/^\/policy(?:\/[a-z0-9-]+)*$/.test(path)) {
+    throw new Error("policy runtime path is invalid");
+  }
+  return path;
+}
 function compactAttenuationForPolicyCapabilities(input) {
   const attenuation = {};
   for (const raw of input) {
@@ -3919,7 +3960,7 @@ function verifyPolicyRootStatusCheckpointV3(input) {
 }
 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), {
+  const response = await fetchFn(new URL(`/policy/v3/status/${encodeURIComponent(input.rootCid)}`, input.nodeOrigin), {
     method: "GET",
     redirect: "error",
     headers: { accept: "application/json" }
@@ -3978,7 +4019,7 @@ async function renewPolicyRootStatusV3(input) {
   };
   const signature = await input.sign((0, import_sha256.sha256)(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), {
+  const response = await fetchFn(new URL("/policy/v3/status", input.nodeOrigin), {
     method: "POST",
     redirect: "error",
     headers: { accept: "application/json", "content-type": "application/json" },
@@ -4034,6 +4075,11 @@ var POLICY_SESSION_FACT_KEYS = [
   "issuanceAuditDigestHex",
   "remainingRedelegationDepth"
 ];
+var POLICY_SESSION_V4_AUDIT_FACT_KEYS = [
+  "credentialIdAuditDigestHex",
+  "presentationJtiAuditDigestHex"
+];
+var LOWER_SHA256_HEX = /^[0-9a-f]{64}$/;
 var KV_ACTIONS = /* @__PURE__ */ new Set([
   "tinycloud.kv/get",
   "tinycloud.kv/list",
@@ -4228,6 +4274,133 @@ function contentSourceDigestHex(input) {
     )
   );
 }
+function exactObject(value, keys, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} is invalid`);
+  }
+  const record2 = value;
+  if (Object.keys(record2).length !== keys.length || keys.some((key) => !Object.prototype.hasOwnProperty.call(record2, key))) {
+    throw new Error(`${label} is invalid`);
+  }
+  return record2;
+}
+function didKeyEd25519PublicKey(value) {
+  const principal = value.split("#", 1)[0];
+  if (!principal.startsWith("did:key:")) {
+    throw new Error("policy enforcer binding signer is invalid");
+  }
+  const material = base58btc.decode(principal.slice("did:key:".length));
+  if (material.length !== 34 || material[0] !== 237 || material[1] !== 1) {
+    throw new Error("policy enforcer binding signer is invalid");
+  }
+  return material.slice(2);
+}
+async function registerPolicyV3(input) {
+  const fetchFn = input.fetch ?? globalThis.fetch.bind(globalThis);
+  const rootExpiresAt = new Date(input.rootExpiresAt);
+  const canonicalRootExpiresAt = new Date(
+    Math.floor(rootExpiresAt.getTime() / 1e3) * 1e3
+  ).toISOString().replace(/\.000Z$/, "Z");
+  if (!Number.isFinite(rootExpiresAt.getTime()) || canonicalRootExpiresAt !== input.rootExpiresAt || rootExpiresAt.getTime() <= Date.now()) {
+    throw new Error("policy root expiry is invalid");
+  }
+  const bindingResponse = await fetchFn(
+    new URL("/policy/v3/enforcer-bindings", input.nodeOrigin),
+    {
+      method: "POST",
+      redirect: "error",
+      signal: input.signal,
+      headers: { accept: "application/json", "content-type": "application/json" },
+      body: JSON.stringify({
+        rootExpiresAt: input.rootExpiresAt,
+        enforcerDid: input.enforcerDid
+      })
+    }
+  );
+  if (!bindingResponse.ok) {
+    throw new Error(`policy enforcer binding rejected (${bindingResponse.status})`);
+  }
+  const binding = exactObject(
+    await bindingResponse.json(),
+    [
+      "schema",
+      "enforcerDid",
+      "nodeAudience",
+      "attestationBindingDigestHex",
+      "issuedAt",
+      "expiresAt",
+      "signature"
+    ],
+    "policy enforcer binding"
+  );
+  const signature = exactObject(
+    binding.signature,
+    ["suite", "signerDid", "value"],
+    "policy enforcer binding signature"
+  );
+  const expectedBindingDigestHex = hex(
+    (0, import_sha256.sha256)(
+      new TextEncoder().encode(
+        jcsCanonicalize({
+          enforcerDid: input.enforcerDid,
+          nodeAudience: input.expectedNodeAudience
+        })
+      )
+    )
+  );
+  if (binding.schema !== ATTESTED_ENFORCER_BINDING_V2_SCHEMA || binding.enforcerDid !== input.enforcerDid || binding.nodeAudience !== input.expectedNodeAudience || binding.attestationBindingDigestHex !== expectedBindingDigestHex || binding.expiresAt !== input.rootExpiresAt || typeof binding.issuedAt !== "string" || Date.parse(binding.issuedAt) > Date.now() || signature.suite !== "Ed25519" || signature.signerDid !== input.expectedNodeAudience || typeof signature.value !== "string") {
+    throw new Error("policy enforcer binding is invalid");
+  }
+  const { signature: _signature, ...unsignedBinding } = binding;
+  const signedBinding = (0, import_sha256.sha256)(
+    new TextEncoder().encode(
+      `xyz.tinycloud.policy/AttestedEnforcerBinding/v2\0${jcsCanonicalize(unsignedBinding)}`
+    )
+  );
+  if (!import_ed255193.ed25519.verify(
+    decodeBase64Url2(signature.value),
+    signedBinding,
+    didKeyEd25519PublicKey(input.expectedNodeAudience),
+    { zip215: false }
+  )) {
+    throw new Error("policy enforcer binding signature is invalid");
+  }
+  const response = await fetchFn(
+    new URL("/policy/v3/policies", input.nodeOrigin),
+    {
+      method: "POST",
+      redirect: "error",
+      signal: input.signal,
+      headers: { accept: "application/json", "content-type": "application/json" },
+      body: JSON.stringify({
+        policyCid: input.policyCid,
+        policy: input.policy,
+        policyRoot: input.policyRoot.authorization.replace(/^Bearer\s+/i, ""),
+        enforcementRoot: input.enforcementRoot.authorization.replace(/^Bearer\s+/i, ""),
+        contentSourceDigestHex: input.contentSourceDigestHex,
+        nativeProjectionHashHex: input.nativeProjectionHashHex,
+        attestedEnforcerBinding: binding
+      })
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`policy registration rejected (${response.status})`);
+  }
+  const receipt = exactObject(
+    await response.json(),
+    ["policyCid", "policyRootCid", "enforcementRootCid"],
+    "policy registration response"
+  );
+  if (receipt.policyCid !== input.policyCid || receipt.policyRootCid !== input.policyRoot.cid || receipt.enforcementRootCid !== input.enforcementRoot.cid) {
+    throw new Error("policy registration response binding is invalid");
+  }
+  return {
+    policyCid: input.policyCid,
+    policyRootCid: input.policyRoot.cid,
+    enforcementRootCid: input.enforcementRoot.cid,
+    attestedEnforcerBinding: binding
+  };
+}
 function policyDigestHex(policy) {
   const canonicalPolicy = {
     ...policy,
@@ -4426,9 +4599,13 @@ function parsePolicySessionUcan(authorization, expectedProofs) {
   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)))
+  const hasLegacyFactShape = factKeys.length === POLICY_SESSION_FACT_KEYS.length && factKeys.every((key) => POLICY_SESSION_FACT_KEYS.includes(key)) && POLICY_SESSION_FACT_KEYS.every((key) => key in fact);
+  const hasV4AuditFactShape = factKeys.length === POLICY_SESSION_FACT_KEYS.length + POLICY_SESSION_V4_AUDIT_FACT_KEYS.length && factKeys.every((key) => POLICY_SESSION_FACT_KEYS.includes(key) || POLICY_SESSION_V4_AUDIT_FACT_KEYS.includes(key)) && POLICY_SESSION_FACT_KEYS.every((key) => key in fact) && POLICY_SESSION_V4_AUDIT_FACT_KEYS.every((key) => key in fact);
+  if (!hasLegacyFactShape && !hasV4AuditFactShape)
     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)
+  if (hasV4AuditFactShape && (!LOWER_SHA256_HEX.test(fact.credentialIdAuditDigestHex) || !LOWER_SHA256_HEX.test(fact.presentationJtiAuditDigestHex)))
+    throw new Error("policy session UCAN v4 audit facts are invalid");
+  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.nodeAudience || parsed.payload.aud !== fact.recipientDid)
     throw new Error("policy session UCAN fact is invalid");
   return {
     authorization,
@@ -4487,6 +4664,8 @@ var POLICY_V2_DOMAIN = "xyz.tinycloud.policy/policy/v2\0";
 var POLICY_CREDENTIAL_REQUIREMENT_V1_TYPE = "TinyCloudPolicyCredentialRequirement";
 var POLICY_PRESENTATION_V3_SCHEMA = "xyz.tinycloud.policy/presentation/v3";
 var POLICY_PRESENTATION_V3_DOMAIN = "xyz.tinycloud.policy/Presentation/v3\0";
+var POLICY_PRESENTATION_V4_SCHEMA = "xyz.tinycloud.policy/presentation/v4";
+var POLICY_PRESENTATION_V4_DOMAIN = "xyz.tinycloud.policy/Presentation/v4\0";
 function record(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new Error(`${label} must be an object`);
@@ -4661,6 +4840,97 @@ function envelopeFromVerified(verified) {
   } = verified;
   return envelope;
 }
+function issuedCredentialEnvelopeFromVerified(verified) {
+  return envelopeFromVerified(verified);
+}
+async function signPolicyCredentialPresentationV4(value, sign) {
+  const item = record(value, "Policy presentation v4");
+  exactKeys2(item, [
+    "schema",
+    "jti",
+    "challengeId",
+    "nonce",
+    "policyCid",
+    "nodeAudience",
+    "holderDid",
+    "subjectDid",
+    "credentialDigest",
+    "requirementDigest",
+    "descriptorDigest",
+    "requestedCapabilities",
+    "issuedAt",
+    "expiresAt"
+  ], "Policy presentation v4");
+  if (item.schema !== POLICY_PRESENTATION_V4_SCHEMA || item.holderDid !== item.subjectDid || !Array.isArray(item.requestedCapabilities)) throw new Error("Policy presentation v4 is invalid");
+  const holderDid = nonEmpty(item.holderDid, "Policy presentation v4 holder DID");
+  didKeyBytes(holderDid);
+  const unsigned = Object.freeze({
+    schema: POLICY_PRESENTATION_V4_SCHEMA,
+    jti: nonEmpty(item.jti, "Policy presentation v4 jti"),
+    challengeId: nonEmpty(item.challengeId, "Policy presentation v4 challenge"),
+    nonce: nonEmpty(item.nonce, "Policy presentation v4 nonce"),
+    policyCid: nonEmpty(item.policyCid, "Policy presentation v4 policy CID"),
+    nodeAudience: nonEmpty(item.nodeAudience, "Policy presentation v4 audience"),
+    holderDid,
+    subjectDid: holderDid,
+    credentialDigest: nonEmpty(item.credentialDigest, "Policy presentation v4 credential digest"),
+    requirementDigest: nonEmpty(item.requirementDigest, "Policy presentation v4 requirement digest"),
+    descriptorDigest: nonEmpty(item.descriptorDigest, "Policy presentation v4 descriptor digest"),
+    // The low-level signer preserves the frozen wire bytes exactly. The
+    // policy-aware builder performs capability normalization and containment.
+    requestedCapabilities: Object.freeze(item.requestedCapabilities),
+    issuedAt: date(item.issuedAt, "Policy presentation v4 issuedAt"),
+    expiresAt: date(item.expiresAt, "Policy presentation v4 expiresAt")
+  });
+  const digest4 = (0, import_sha2562.sha256)(new TextEncoder().encode(
+    POLICY_PRESENTATION_V4_DOMAIN + jcsCanonicalize(unsigned)
+  ));
+  const signature = await sign(digest4);
+  if (signature.length !== 64 || !import_ed255194.ed25519.verify(signature, digest4, didKeyBytes(holderDid))) throw new Error("policy presentation signature is invalid");
+  return Object.freeze({
+    ...unsigned,
+    signature: Object.freeze({
+      suite: "Ed25519",
+      signerDid: holderDid,
+      value: encodeBase64Url(signature)
+    })
+  });
+}
+async function buildPolicyCredentialPresentationV4(input) {
+  const policy = validateUnifiedPolicyV2(input.policy, input.policyCid);
+  const requirement = validateCredentialRequirement(input.requirement);
+  const commitment = policy.credentialRequirement;
+  const requirementDigest = await credentialRequirementDigest(requirement);
+  const credentialDigest = await sha256Base64Url(input.credential.credential);
+  if (requirementDigest !== commitment.requirementDigest || input.credential.descriptorDigest !== commitment.descriptorDigest || input.credential.credentialDigest !== credentialDigest || input.credential.issuerDid !== commitment.issuerDid || input.credential.issuerKid !== commitment.issuerKid || jcsCanonicalize(input.credential.profile) !== jcsCanonicalize(commitment.profile) || jcsCanonicalize(input.credential.credentialType) !== jcsCanonicalize(commitment.credentialType)) throw new Error("credential does not match the signed Policy/v2 requirement");
+  const requestedCapabilities = input.requestedCapabilities.map(normalizeUnifiedPolicyCapability);
+  if (requestedCapabilities.length === 0 || requestedCapabilities.some((requested) => !policy.capabilityCeiling.some((authority) => unifiedPolicyCapabilityContains(authority, requested)))) throw new Error("requested capabilities exceed the signed Policy/v2 ceiling");
+  const holderDid = input.credential.holderDid;
+  if (input.challenge.policyCid !== input.policyCid || input.challenge.recipientDid !== holderDid || input.credential.subjectDid !== holderDid || typeof input.challenge.nodeAudience !== "string" || input.challenge.nodeAudience.length === 0 || typeof input.challenge.expiresAt !== "string" || !Number.isFinite(Date.parse(input.challenge.expiresAt))) throw new Error("policy challenge binding is invalid");
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const expiresAtMs = Math.min(
+    now.getTime() + 6e4,
+    Date.parse(input.challenge.expiresAt),
+    Date.parse(input.credential.expiresAt)
+  );
+  if (expiresAtMs <= now.getTime()) throw new Error("policy challenge is expired");
+  return signPolicyCredentialPresentationV4(Object.freeze({
+    schema: POLICY_PRESENTATION_V4_SCHEMA,
+    jti: input.jti ?? encodeBase64Url(crypto.getRandomValues(new Uint8Array(16))),
+    challengeId: input.challenge.challengeId,
+    nonce: input.challenge.nonce,
+    policyCid: input.policyCid,
+    nodeAudience: input.challenge.nodeAudience,
+    holderDid,
+    subjectDid: holderDid,
+    credentialDigest,
+    requirementDigest,
+    descriptorDigest: input.credential.descriptorDigest,
+    requestedCapabilities: Object.freeze(requestedCapabilities),
+    issuedAt: rfc3339Seconds(now),
+    expiresAt: rfc3339Seconds(new Date(expiresAtMs))
+  }), input.sign);
+}
 async function buildPolicyCredentialPresentationV3(input) {
   const policy = validateUnifiedPolicyV2(input.policy, input.policyCid);
   const requirement = validateCredentialRequirement(input.requirement);
@@ -4747,10 +5017,12 @@ async function admitPolicyCredentialV3(input) {
   const fetchFn = input.fetch ?? globalThis.fetch.bind(globalThis);
   const challenge = await requestPolicyChallengeV3({
     nodeOrigin,
+    policyRuntimePath: input.policyRuntimePath,
     policyCid: input.policyCid,
     recipientDid: input.credential.holderDid,
     requestedCapabilities: input.requestedCapabilities,
-    fetch: fetchFn
+    fetch: fetchFn,
+    signal: input.signal
   });
   const presentation = await buildPolicyCredentialPresentationV3({
     ...input,
@@ -4758,10 +5030,11 @@ async function admitPolicyCredentialV3(input) {
     challenge
   });
   const response = await fetchFn(
-    new URL("/share/v3/policy/delegations", nodeOrigin),
+    new URL(`${policyRuntimeBasePath2(input.policyRuntimePath)}/delegations`, nodeOrigin),
     {
       method: "POST",
       redirect: "error",
+      signal: input.signal,
       headers: { accept: "application/json", "content-type": "application/json" },
       body: JSON.stringify({
         policyCid: input.policyCid,
@@ -4790,8 +5063,74 @@ async function admitPolicyCredentialV3(input) {
   if (session.cid !== value.sessionCid || session.aud !== input.credential.holderDid || session.fact.policyCid !== input.policyCid || session.fact.recipientDid !== input.credential.holderDid || session.fact.policyDelegationCid !== input.policyRootCid || session.fact.enforcementDelegationCid !== input.enforcementRootCid || jcsCanonicalize(session.att) !== jcsCanonicalize(expectedAttenuation)) {
     throw new Error("policy delegation signed binding is invalid");
   }
+  input.signal?.throwIfAborted();
   return Object.freeze({ challenge, presentation, session });
 }
+function validatePolicyCredentialAdmissionV4Authority(session, expected) {
+  if (session.iss.split("#", 1)[0] !== expected.nodeAudience || session.fact.nodeAudience !== expected.nodeAudience || session.fact.enforcerDid !== expected.enforcerDid) throw new Error("policy delegation authority binding is invalid");
+}
+async function admitPolicyCredentialV4(input) {
+  const policy = validateUnifiedPolicyV2(input.policy, input.policyCid);
+  const nodeOrigin = policyNodeOrigin(input.nodeOrigin);
+  const fetchFn = input.fetch ?? globalThis.fetch.bind(globalThis);
+  const challenge = await requestPolicyChallengeV3({
+    nodeOrigin,
+    policyRuntimePath: input.policyRuntimePath,
+    policyCid: input.policyCid,
+    recipientDid: input.credential.holderDid,
+    requestedCapabilities: input.requestedCapabilities,
+    fetch: fetchFn,
+    signal: input.signal
+  });
+  const presentation = await buildPolicyCredentialPresentationV4({
+    ...input,
+    policy,
+    challenge
+  });
+  const response = await fetchFn(new URL(`${policyRuntimeBasePath2(input.policyRuntimePath)}/delegations`, nodeOrigin), {
+    method: "POST",
+    redirect: "error",
+    signal: input.signal,
+    headers: { accept: "application/json", "content-type": "application/json" },
+    body: JSON.stringify({
+      policyCid: input.policyCid,
+      challengeId: challenge.challengeId,
+      nonce: challenge.nonce,
+      requirement: validateCredentialRequirement(input.requirement),
+      credential: envelopeFromVerified(input.credential),
+      presentation
+    })
+  });
+  if (!response.ok) throw new Error(`policy delegation rejected (${response.status})`);
+  const value = record(await response.json(), "policy delegation");
+  if (value.admitted !== true || typeof value.sessionCid !== "string" || typeof value.authorization !== "string") throw new Error("policy delegation response is invalid");
+  const session = parsePolicySessionUcan(value.authorization, [
+    input.policyRootCid,
+    input.enforcementRootCid
+  ]);
+  const expectedAttenuation = compactAttenuationForPolicyCapabilities(input.requestedCapabilities);
+  validatePolicyCredentialAdmissionV4Authority(session, {
+    nodeAudience: input.expectedNodeAudience,
+    enforcerDid: input.expectedEnforcerDid
+  });
+  if (session.cid !== value.sessionCid || session.aud !== input.credential.holderDid || session.fact.policyCid !== input.policyCid || session.fact.recipientDid !== input.credential.holderDid || session.fact.policyDelegationCid !== input.policyRootCid || session.fact.enforcementDelegationCid !== input.enforcementRootCid || jcsCanonicalize(session.att) !== jcsCanonicalize(expectedAttenuation)) throw new Error("policy delegation signed binding is invalid");
+  const importResponse = await fetchFn(new URL("/delegate", nodeOrigin), {
+    method: "POST",
+    redirect: "error",
+    signal: input.signal,
+    headers: { Authorization: session.authorization }
+  });
+  if (!importResponse.ok) throw new Error(`delegation import rejected (${importResponse.status})`);
+  input.signal?.throwIfAborted();
+  return Object.freeze({ challenge, presentation, session, delegationImported: true });
+}
+function policyRuntimeBasePath2(value) {
+  const path = value ?? "/policy/v3";
+  if (!/^\/policy(?:\/[a-z0-9-]+)*$/.test(path)) {
+    throw new Error("policy runtime path is invalid");
+  }
+  return path;
+}
 
 // src/requester/index.ts
 var REQUESTER_NEAR_EXPIRY_SECONDS = 30;
@@ -8198,13 +8537,13 @@ function canonicalizeRecapCaveats(caveats) {
     }
     if (Array.isArray(value)) return `[${value.map(canonicalize).join(",")}]`;
     if (typeof value === "object") {
-      const object3 = value;
-      const prototype = Object.getPrototypeOf(object3);
+      const object4 = value;
+      const prototype = Object.getPrototypeOf(object4);
       if (prototype !== Object.prototype && prototype !== null) {
         throw new Error("ReCap caveats must contain only JSON values.");
       }
-      return `{${Object.keys(object3).sort().map(
-        (key) => `${JSON.stringify(key)}:${canonicalize(object3[key])}`
+      return `{${Object.keys(object4).sort().map(
+        (key) => `${JSON.stringify(key)}:${canonicalize(object4[key])}`
       ).join(",")}}`;
     }
     throw new Error("ReCap caveats must contain only JSON values.");
@@ -8288,7 +8627,6 @@ var import_ed255195 = require("@noble/curves/ed25519");
 var import_blake33 = require("@noble/hashes/blake3");
 var import_sha2563 = require("@noble/hashes/sha256");
 var ENVELOPE_SCHEMA = "xyz.tinycloud.share/envelope";
-var INLINE_PREFIX = "tc2:";
 var RAW_CID_CODEC = 85;
 var BLAKE3_256_CODE = 30;
 var DEFAULT_MAX_INLINE_BYTES = 256 * 1024;
@@ -8335,8 +8673,8 @@ function canonicalJson(value) {
   }
   if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
   if (typeof value === "object") {
-    const object3 = value;
-    return `{${Object.keys(object3).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(object3[key])}`).join(",")}}`;
+    const object4 = value;
+    return `{${Object.keys(object4).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(object4[key])}`).join(",")}}`;
   }
   throw new ShareEnvelopeError("invalid-envelope", "unsupported JSON value");
 }
@@ -8993,25 +9331,8 @@ function parsePublishedShareLink(link, options2 = {}) {
   }
   const origin2 = normalizeOrigin(url.origin);
   if (options2.trustedOrigins !== void 0 && !options2.trustedOrigins.map(normalizeOrigin).includes(origin2)) throw new ShareEnvelopeError("origin-mismatch", "share link origin is not trusted");
-  if (url.search !== "" || url.username !== "" || url.password !== "") throw new ShareEnvelopeError("invalid-link", "share link is not canonical");
-  if (url.pathname === "/s/inline" && url.hash.startsWith("#v=2&p=")) {
-    let payload;
-    try {
-      const bytes2 = base64UrlToBytes(url.hash.slice("#v=2&p=".length));
-      if (bytes2.length > (options2.maxInlineBytes ?? DEFAULT_MAX_INLINE_BYTES) * 2) throw new Error("inline payload too large");
-      const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes2));
-      if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("inline payload shape");
-      payload = value;
-    } catch (error) {
-      throw new ShareEnvelopeError("invalid-link", error instanceof Error ? error.message : "invalid inline payload");
-    }
-    if (payload.v !== 2 || typeof payload.c !== "string" || typeof payload.cid !== "string" || payload.k !== void 0 && typeof payload.k !== "string" || Object.keys(payload).some((key3) => !["v", "c", "cid", "k"].includes(key3))) throw new ShareEnvelopeError("invalid-link", "inline payload fields are invalid");
-    const sealed = base64UrlToBytes(payload.c);
-    if (!verifyPublishedShareCid(payload.cid, sealed)) throw new ShareEnvelopeError("cid-mismatch", "inline payload CID does not match");
-    const key2 = payload.k === void 0 ? void 0 : base64UrlToBytes(payload.k);
-    if (key2 !== void 0 && key2.length !== 32) throw new ShareEnvelopeError("invalid-link", "inline payload key is invalid");
-    return { origin: origin2, cid: payload.cid, ...key2 === void 0 ? {} : { key: key2 }, sealed };
-  }
+  if (url.username !== "" || url.password !== "") throw new ShareEnvelopeError("invalid-link", "share link is not canonical");
+  if (url.search !== "") throw new ShareEnvelopeError("invalid-link", "share link is not canonical");
   const match = /^\/s\/([a-z2-7]+)$/.exec(url.pathname);
   if (match === null || !url.hash.startsWith("#k=")) throw new ShareEnvelopeError("invalid-link", "published share link is invalid");
   const key = base64UrlToBytes(url.hash.slice(3));
@@ -9031,13 +9352,10 @@ function parseShareUrl(link, options2 = {}) {
   } catch {
     throw new ShareEnvelopeError("invalid-link", "share link must be an absolute URL");
   }
-  if (url.search !== "") throw new ShareEnvelopeError("invalid-link", "share links must not contain query parameters");
   const origin2 = normalizeOrigin(url.origin);
   if (options2.trustedOrigins !== void 0 && !options2.trustedOrigins.map(normalizeOrigin).includes(origin2)) throw new ShareEnvelopeError("origin-mismatch", "share link origin is not trusted");
-  if (url.pathname === "/s/inline" && url.hash.startsWith("#v=2&p=")) {
-    const published = parsePublishedShareLink(link, options2);
-    return { kind: "inline", origin: origin2, cid: published.cid, key: published.key, url: `${url.origin}${url.pathname}`, protocol: "share-envelope-v2" };
-  }
+  if (url.pathname === "/viewer") throw new ShareEnvelopeError("invalid-link", "retired viewer links are not accepted");
+  if (url.search !== "") throw new ShareEnvelopeError("invalid-link", "share links must not contain query parameters");
   const match = url.pathname.match(/^\/s\/(i\/)?([^/]+)$/);
   if (!match) throw new ShareEnvelopeError("invalid-link", "share link path is invalid");
   const fragmentParams = url.hash === "" ? void 0 : new URLSearchParams(url.hash.slice(1));
@@ -9060,9 +9378,10 @@ function parseShareUrl(link, options2 = {}) {
 }
 function isV2ShareLink(link) {
   try {
-    return new URL(link).pathname.startsWith("/s/");
+    const url = new URL(link);
+    return url.search === "" && url.pathname.startsWith("/s/");
   } catch {
-    return link.startsWith(INLINE_PREFIX);
+    return false;
   }
 }
 async function encryptShareBytes(bytes2, key) {
@@ -9518,8 +9837,8 @@ function canonicalJsonForProof(value) {
   }
   if (Array.isArray(value)) return `[${value.map(canonicalJsonForProof).join(",")}]`;
   if (typeof value === "object") {
-    const object3 = value;
-    return `{${Object.keys(object3).sort().map((key) => `${JSON.stringify(key)}:${canonicalJsonForProof(object3[key])}`).join(",")}}`;
+    const object4 = value;
+    return `{${Object.keys(object4).sort().map((key) => `${JSON.stringify(key)}:${canonicalJsonForProof(object4[key])}`).join(",")}}`;
   }
   throw new ShareAccessError("SHARE_SESSION_INVALID");
 }
@@ -10228,12 +10547,12 @@ var ShareRecipientClient = class {
     this.assertDetachedProof(request.proof);
   }
   parseSessionCapability(value) {
-    const object3 = this.requireObject(value, "session capability");
-    if (typeof object3.spaceId !== "string") throw new ShareAccessError("SHARE_SESSION_INVALID", "session capability space is invalid");
-    if (!Array.isArray(object3.actions) || object3.actions.some((action) => !["read", "list", "edit"].includes(action))) throw new ShareAccessError("SHARE_SESSION_INVALID", "session capability actions are invalid");
-    const resource = this.requireObject(object3.resource, "session capability resource");
+    const object4 = this.requireObject(value, "session capability");
+    if (typeof object4.spaceId !== "string") throw new ShareAccessError("SHARE_SESSION_INVALID", "session capability space is invalid");
+    if (!Array.isArray(object4.actions) || object4.actions.some((action) => !["read", "list", "edit"].includes(action))) throw new ShareAccessError("SHARE_SESSION_INVALID", "session capability actions are invalid");
+    const resource = this.requireObject(object4.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: object3.spaceId, actions: [...new Set(object3.actions)], resource: { kind: resource.kind, path: resource.path } };
+    return { spaceId: object4.spaceId, actions: [...new Set(object4.actions)], resource: { kind: resource.kind, path: resource.path } };
   }
   assertProvidedPolicySession(session, envelope) {
     const sessionExpiry = dateValue(session.expiresAt);
@@ -11873,62 +12192,21 @@ function validateOwnerSharePolicyRegistrationBytes(bytesValue, expected) {
   return validateOwnerSharePolicyRegistration(value, expected);
 }
 
-// src/delegations/share-delivery.ts
+// src/delegations/share-delivery-v3.ts
 var import_ed255199 = require("@noble/curves/ed25519");
-var SHARE_DELIVERY_AUTHORIZATION_DOMAIN = "xyz.tinycloud.share/delivery-authorization/v2\0";
-function isCanonicalHttpsOrigin(value) {
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    return false;
-  }
-  return url.protocol === "https:" && url.origin === value && url.pathname === "/" && url.search === "" && url.hash === "" && url.username === "" && url.password === "";
-}
-var AUTHORIZATION_KEYS = [
-  "type",
-  "version",
-  "jti",
-  "shareCid",
-  "shareId",
-  "registrationCid",
-  "delegationCid",
-  "enforcementDelegationCid",
-  "envelopeCid",
-  "policyCid",
-  "nodeAudience",
-  "targetOrigin",
-  "openCredentialsAudience",
-  "holder",
-  "recipientMatcher",
-  "deliveryEmail",
-  "shareUrl",
-  "returnOrigin",
-  "documentName",
-  "senderDid",
-  "senderTrust",
-  "contentSource",
-  "contentSourceDigest",
-  "shareExpiresAt",
-  "issuedAt",
-  "reportAbuseToken",
-  "actions",
-  "resource",
-  "authorityMaterialHandle",
-  "authorityMaterialDigest",
-  "requestBodyDigest",
-  "idempotencyKey",
-  "expiresAt",
-  "dataAuthority"
-];
-function assertObject2(value, keys, label) {
+var import_sha2567 = require("@noble/hashes/sha256");
+var CREDENTIAL_INVITATION_REQUEST_DOMAIN = "xyz.tinycloud.credentials/invitation-request/v1\0";
+var DELIVERY_ADMISSION_DOMAIN = "xyz.tinycloud.policy/delivery-admission/v0\0";
+var REQUEST_KEYS = ["schema", "policyId", "recipient", "resource", "credentialType", "returnLink", "envelopeRef", "label", "shareExpiresAt", "audience", "issuedAt", "expiresAt", "nonce"];
+var ADMISSION_KEYS = ["schema", "policyId", "ownerDid", "recipient", "resource", "actions", "credentialType", "returnLink", "envelopeRef", "label", "shareExpiresAt", "senderKeyDid", "audience", "issuedAt", "expiresAt", "nonce", "signature"];
+function exactObject2(value, keys, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${label} is invalid`);
   const record2 = value;
   if (Object.keys(record2).length !== keys.length || keys.some((key) => !Object.prototype.hasOwnProperty.call(record2, key))) throw new Error(`${label} has unknown or missing fields`);
   return record2;
 }
-function fromB642(value) {
-  if (!/^[A-Za-z0-9_-]+$/.test(value)) throw new Error("share delivery value is not canonical base64url");
+function decodeBase64Url3(value) {
+  if (typeof value !== "string" || !/^[A-Za-z0-9_-]+$/.test(value)) throw new Error("share delivery value is not canonical base64url");
   if (typeof atob === "function") {
     const padded = value.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat((4 - value.length % 4) % 4);
     return Uint8Array.from(atob(padded), (character) => character.charCodeAt(0));
@@ -11936,42 +12214,45 @@ function fromB642(value) {
   if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(value, "base64url"));
   throw new Error("base64url decoding is unavailable");
 }
-function validateShareDeliveryAuthorizationBytes(bytesValue, expected) {
-  let value;
+function object3(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${label} is invalid`);
+  return value;
+}
+function didKeyBytes2(did) {
+  if (!did.startsWith("did:key:z") || /[#/?]/.test(did.slice("did:key:".length))) throw new Error("v3 delivery admission signer is invalid");
+  const decoded = base58btc.decode(did.slice("did:key:".length));
+  if (decoded.length !== 34 || decoded[0] !== 237 || decoded[1] !== 1) throw new Error("v3 delivery admission signer is invalid");
+  return decoded.slice(2);
+}
+function validateShareDeliveryAuthorizationV3Bytes(bytes2, expected) {
+  let parsed;
   try {
-    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytesValue));
+    parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes2));
   } catch {
-    throw new Error("share delivery authorization response is not valid UTF-8 JSON");
-  }
-  const root = assertObject2(value, ["authorization", "proof"], "share delivery authorization response");
-  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.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");
-  if (new Date(authorization.expiresAt).toISOString() !== authorization.expiresAt) throw new Error("share delivery authorization expiresAt is non-canonical");
-  if (typeof authorization.openCredentialsAudience !== "string" || !isCanonicalHttpsOrigin(authorization.openCredentialsAudience) || authorization.openCredentialsAudience !== expected.credentialsAudience || authorization.openCredentialsAudience === authorization.nodeAudience || authorization.openCredentialsAudience === authorization.returnOrigin) {
-    throw new Error("share delivery authorization openCredentialsAudience is missing or untrusted");
-  }
-  if (proof.alg !== "EdDSA" || typeof proof.kid !== "string" || typeof proof.signature !== "string") throw new Error("share delivery authorization proof is invalid");
-  if (proof.kid !== expected.nodeProof.kid) throw new Error("share delivery authorization proof key is not trusted");
-  const encodedKid = expected.nodeProof.publicKey;
-  const publicKey = encodedKid.length === 34 && encodedKid[0] === 237 && encodedKid[1] === 1 ? encodedKid.slice(2) : encodedKid;
-  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 || !import_ed255199.ed25519.verify(signatureBytes, signedBytes, publicKey)) throw new Error("share delivery authorization proof signature is invalid");
-  return { authorization, proof };
-}
-function shareDeliveryTrustedKid(publicKey) {
-  if (publicKey.length !== 32) throw new Error("share delivery node key must be a raw 32-byte Ed25519 public key");
-  const prefixed = new Uint8Array(34);
-  prefixed.set([237, 1]);
-  prefixed.set(publicKey, 2);
-  const did = `did:key:${base58btc.encode(prefixed)}`;
-  return `${did}#${did.slice("did:key:".length)}`;
+    throw new Error("v3 share delivery response is not valid UTF-8 JSON");
+  }
+  const root = exactObject2(parsed, ["request", "admission"], "v3 share delivery response");
+  const request = exactObject2(root.request, REQUEST_KEYS, "credential invitation request");
+  const admission = exactObject2(root.admission, ADMISSION_KEYS, "delivery admission");
+  const signature = exactObject2(admission.signature, ["suite", "signerDid", "value"], "delivery admission signature");
+  const envelope = object3(expected.request.envelope, "v3 share envelope");
+  const policy = object3(envelope.policy, "v3 share policy");
+  const requirement = object3(policy.credentialRequirement, "v3 credential requirement");
+  const credentialType = object3(requirement.credentialType, "v3 credential type");
+  const contentSource = object3(envelope.contentSource, "v3 content source");
+  const envelopeSignature = object3(envelope.signature, "v3 envelope signature");
+  const target = object3(envelope.target, "v3 target");
+  const binding = object3(envelope.attestedEnforcerBinding, "v3 attested enforcer binding");
+  const fields = ["policyId", "recipient", "resource", "credentialType", "returnLink", "envelopeRef", "label", "shareExpiresAt", "audience", "issuedAt", "expiresAt", "nonce"];
+  if (request.schema !== "xyz.tinycloud.credentials/invitation-request/v1" || admission.schema !== "xyz.tinycloud.policy/delivery-admission/v0" || fields.some((field) => request[field] !== admission[field]) || request.policyId !== envelope.policyCid || request.recipient !== expected.request.recipientEmail || request.resource !== contentSource.kvResource || request.credentialType !== credentialType.id || request.credentialType !== "opencredentials.email/v1" || request.returnLink !== expected.request.shareUrl || request.envelopeRef !== expected.request.shareCid || request.label !== expected.request.documentName || request.shareExpiresAt !== envelope.expiry || request.audience !== expected.deliveryAudience || request.expiresAt !== expected.request.expiresAt || request.nonce !== expected.request.jti || admission.ownerDid !== envelopeSignature.signerDid || admission.senderKeyDid !== expected.senderKeyDid || canonicalizeSignedObjectUnsigned(admission.actions) !== canonicalizeSignedObjectUnsigned(["tinycloud.kv/get"]) || signature.suite !== "eddsa-ed25519-sha256-jcs-v1" || target.nodeAudience !== binding.nodeAudience || signature.signerDid !== binding.nodeAudience) throw new Error("v3 share delivery authorization is not bound to the submitted request");
+  const issuedAt = Date.parse(String(request.issuedAt));
+  const expiresAt = Date.parse(String(request.expiresAt));
+  if (!Number.isFinite(issuedAt) || !Number.isFinite(expiresAt) || expiresAt <= issuedAt || expiresAt - issuedAt > 15 * 6e4) throw new Error("v3 share delivery authorization time is invalid");
+  const admissionSignature = decodeBase64Url3(signature.value);
+  const { signature: _signature, ...unsignedAdmission } = admission;
+  const digest4 = (0, import_sha2567.sha256)(new TextEncoder().encode(`${DELIVERY_ADMISSION_DOMAIN}${canonicalizeSignedObjectUnsigned(unsignedAdmission)}`));
+  if (admissionSignature.length !== 64 || !import_ed255199.ed25519.verify(admissionSignature, digest4, didKeyBytes2(String(signature.signerDid)))) throw new Error("v3 share delivery admission signature is invalid");
+  return { request, admission };
 }
 
 // src/delegations/sender-share-store.ts
@@ -14694,8 +14975,8 @@ function stableJson(value) {
   if (Array.isArray(value)) {
     return `[${value.map(stableJson).join(",")}]`;
   }
-  const object3 = value;
-  return `{${Object.keys(object3).sort().map((key) => `${JSON.stringify(key)}:${stableJson(object3[key])}`).join(",")}}`;
+  const object4 = value;
+  return `{${Object.keys(object4).sort().map((key) => `${JSON.stringify(key)}:${stableJson(object4[key])}`).join(",")}}`;
 }
 function indexedDelegationFromRow(row) {
   const [
@@ -15367,6 +15648,236 @@ function createOpenKeyCallbackSigningStrategy(options2) {
 }
 var defaultSignStrategy = { type: "auto-sign" };
 
+// src/authorization/manage-key.ts
+var TINYCLOUD_MANAGE_KEY_SCOPE = "tinycloud:manage-key";
+var TINYCLOUD_CANONICAL_IDENTITY_CLAIM = "https://tinycloud.xyz/canonical_identity";
+function requestTinyCloudManageKeyScope(scopes = []) {
+  const requested = typeof scopes === "string" ? scopes.split(/\s+/u) : scopes;
+  return [
+    ...new Set([...requested, TINYCLOUD_MANAGE_KEY_SCOPE].filter(Boolean))
+  ].sort().join(" ");
+}
+function hasTinyCloudManageKeyScope(scopes) {
+  const values = Array.isArray(scopes) ? scopes : typeof scopes === "string" ? scopes.split(/\s+/u) : [];
+  return values.includes(TINYCLOUD_MANAGE_KEY_SCOPE);
+}
+var OpenKeyManageKeyError = class extends Error {
+  constructor(code3, message, approvalUrl, retryable = false) {
+    super(message);
+    this.code = code3;
+    this.approvalUrl = approvalUrl;
+    this.retryable = retryable;
+    this.name = "OpenKeyManageKeyError";
+  }
+};
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function rejected(message) {
+  return new OpenKeyManageKeyError("MESSAGE_REJECTED", message);
+}
+function identityMismatch(message) {
+  return new OpenKeyManageKeyError("IDENTITY_MISMATCH", message);
+}
+function parseCanonicalTinyCloudIdentity(value) {
+  if (!isRecord2(value))
+    throw rejected("Canonical TinyCloud identity is missing");
+  const expectedKeys = [
+    "address",
+    "chainId",
+    "did",
+    "keyId",
+    "spaceId",
+    "version"
+  ];
+  const actualKeys = Object.keys(value).sort();
+  if (actualKeys.length !== expectedKeys.length || actualKeys.some((key, index) => key !== expectedKeys[index])) {
+    throw rejected("Canonical TinyCloud identity has an invalid shape");
+  }
+  if (value.version !== "v1")
+    throw rejected("Canonical TinyCloud identity version is unsupported");
+  if (typeof value.keyId !== "string" || value.keyId.trim() === "") {
+    throw rejected("Canonical TinyCloud identity key ID is invalid");
+  }
+  if (typeof value.address !== "string") {
+    throw rejected("Canonical TinyCloud identity address is invalid");
+  }
+  let address;
+  try {
+    address = canonicalizeAddress(value.address);
+  } catch {
+    throw rejected("Canonical TinyCloud identity address is invalid");
+  }
+  if (address !== value.address) {
+    throw rejected(
+      "Canonical TinyCloud identity address must use EIP-55 checksum casing"
+    );
+  }
+  if (typeof value.chainId !== "number" || !Number.isSafeInteger(value.chainId) || value.chainId <= 0) {
+    throw rejected("Canonical TinyCloud identity chain ID is invalid");
+  }
+  const did = pkhDid(address, value.chainId);
+  const spacePrefix = `tinycloud:pkh:eip155:${value.chainId}:${address}:`;
+  if (typeof value.spaceId !== "string" || !value.spaceId.startsWith(spacePrefix)) {
+    throw rejected("Canonical TinyCloud identity space is invalid");
+  }
+  const spaceName = value.spaceId.slice(spacePrefix.length);
+  let spaceId;
+  try {
+    spaceId = makePkhSpaceId(address, value.chainId, spaceName);
+  } catch {
+    throw rejected("Canonical TinyCloud identity space is invalid");
+  }
+  if (value.did !== did || value.spaceId !== spaceId) {
+    throw rejected("Canonical TinyCloud identity does not match its address");
+  }
+  return {
+    version: "v1",
+    keyId: value.keyId,
+    address,
+    chainId: value.chainId,
+    did,
+    spaceId
+  };
+}
+function parseCanonicalTinyCloudIdentityClaims(claims) {
+  if (!isRecord2(claims)) throw rejected("OAuth claims are missing");
+  return parseCanonicalTinyCloudIdentity(
+    claims[TINYCLOUD_CANONICAL_IDENTITY_CLAIM]
+  );
+}
+function identitiesEqual(left, right) {
+  return left.version === right.version && left.keyId === right.keyId && left.address === right.address && left.chainId === right.chainId && left.did === right.did && left.spaceId === right.spaceId;
+}
+function errorForResponse(body, status) {
+  const message = body?.reason ?? body?.error ?? `OpenKey manage-key signing failed with HTTP ${status}`;
+  switch (body?.code ?? body?.error) {
+    case "missing_scope":
+    case "consent_required":
+      return new OpenKeyManageKeyError("CONSENT_REQUIRED", message, body?.approvalUrl);
+    case "client_disabled":
+    case "signing_disabled":
+    case "grant_disabled":
+      return new OpenKeyManageKeyError("GRANT_DISABLED", message, body?.approvalUrl);
+    case "user_exclusive":
+      return new OpenKeyManageKeyError("USER_EXCLUSIVE", message, body?.approvalUrl);
+    case "token_expired":
+    case "token_too_old":
+    case "invalid_token":
+    case "expired_token":
+      return new OpenKeyManageKeyError("TOKEN_EXPIRED", message, body?.approvalUrl);
+    case "canonical_key_unavailable":
+    case "signer_failed":
+      return new OpenKeyManageKeyError(
+        "SIGNER_UNAVAILABLE",
+        "The canonical key signer is temporarily unavailable",
+        void 0,
+        true
+      );
+    default:
+      return new OpenKeyManageKeyError(
+        status === 401 ? "TOKEN_EXPIRED" : "MESSAGE_REJECTED",
+        message,
+        body?.approvalUrl
+      );
+  }
+}
+async function resolveToken(token) {
+  const value = typeof token === "function" ? await token() : token;
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new OpenKeyManageKeyError(
+      "CONSENT_REQUIRED",
+      "A manage-key OAuth bearer token is required"
+    );
+  }
+  return value;
+}
+function normalizeEndpoint(value) {
+  let endpoint;
+  try {
+    endpoint = new URL(value);
+  } catch {
+    throw rejected("OpenKey manage-key signing endpoint must be an absolute URL");
+  }
+  const rawHttpAuthority = value.match(/^http:\/\/([^/?#]*)/iu)?.[1];
+  const loopback = rawHttpAuthority !== void 0 && /^(?:localhost|127\.0\.0\.1|\[::1\])(?::[0-9]+)?$/u.test(rawHttpAuthority);
+  if (endpoint.protocol !== "https:" && !(endpoint.protocol === "http:" && loopback) || endpoint.username !== "" || endpoint.password !== "" || endpoint.search !== "" || endpoint.hash !== "") {
+    throw rejected("OpenKey manage-key signing endpoint must use HTTPS or exact loopback HTTP");
+  }
+  return endpoint.href;
+}
+function assertSignInRequest(request, identity3) {
+  if (request.type !== "siwe" || request.purpose !== "sign-in" || request.chainId !== identity3.chainId || request.address !== identity3.address || typeof request.message !== "string" || request.message.length === 0) {
+    throw rejected(
+      "Manage-key signing only permits the canonical sign-in SIWE request"
+    );
+  }
+}
+function createOpenKeyManageKeySigningStrategy(options2) {
+  const identity3 = parseCanonicalTinyCloudIdentity(options2.identity);
+  const endpoint = normalizeEndpoint(options2.endpoint);
+  return {
+    type: "callback",
+    openKeyAutoSign: true,
+    handler: async (request) => {
+      assertSignInRequest(request, identity3);
+      const fetchImpl = options2.fetch ?? globalThis.fetch;
+      if (!fetchImpl)
+        throw rejected("OpenKey manage-key signing requires fetch");
+      if (!hasTinyCloudManageKeyScope(options2.scopes)) {
+        throw new OpenKeyManageKeyError(
+          "CONSENT_REQUIRED",
+          "The OAuth bearer token was not granted tinycloud:manage-key"
+        );
+      }
+      const token = await resolveToken(options2.token);
+      const response = await fetchImpl(endpoint, {
+        method: "POST",
+        credentials: "omit",
+        headers: {
+          authorization: `Bearer ${token}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          address: request.address,
+          chainId: request.chainId,
+          message: request.message,
+          type: "siwe"
+        })
+      });
+      let body;
+      try {
+        const value = await response.json();
+        body = isRecord2(value) ? value : void 0;
+      } catch {
+        body = void 0;
+      }
+      if (!response.ok || body?.approved !== true)
+        throw errorForResponse(body, response.status);
+      if (typeof body.signature !== "string")
+        throw rejected("OpenKey manage-key signer did not return a signature");
+      const responseIdentity = parseCanonicalTinyCloudIdentity(
+        body.canonicalIdentity
+      );
+      if (!identitiesEqual(identity3, responseIdentity)) {
+        throw identityMismatch(
+          "OpenKey manage-key signer returned a different canonical identity"
+        );
+      }
+      if (!await verifyEip191MessageSignature(
+        request.message,
+        body.signature,
+        identity3.address
+      )) {
+        throw rejected(
+          "OpenKey manage-key signer returned an invalid signature"
+        );
+      }
+      return { approved: true, signature: body.signature };
+    }
+  };
+}
+
 // src/authorization/spaceCreation.ts
 var AutoApproveSpaceCreationHandler = class {
   /**
@@ -17373,6 +17884,7 @@ var DEFAULT_LOCAL_NODE_URL = "http://127.0.0.1:8000";
 var LOCAL_LOOPBACK_PROBE_TIMEOUT_MS = 250;
 var LOCAL_LINK_PROBE_TIMEOUT_MS = 750;
 var LOCAL_LINK_HOST_SUFFIX = ".local.tinycloud.link";
+var OWNER_NODE_BINDING_TIMEOUT_MS = 5e3;
 function createInMemoryLocalNodeIdentityStore() {
   const pins = /* @__PURE__ */ new Map();
   return {
@@ -17505,21 +18017,80 @@ async function verifyLocationRecord(input) {
   }
   return false;
 }
-async function fetchLocationRecord(registryUrl, subject, fetchFn = globalThis.fetch) {
+async function fetchLocationRecord(registryUrl, subject, fetchFn = globalThis.fetch, signal) {
   const url = `${registryUrl.replace(/\/$/, "")}/v1/locations/${encodeURIComponent(subject)}`;
-  const response = await fetchFn(url);
+  const response = await fetchFn(url, {
+    redirect: "error",
+    headers: { accept: "application/json" },
+    ...signal === void 0 ? {} : { signal }
+  });
   if (response.status === 404) {
     return null;
   }
   if (!response.ok) {
     throw new Error(`location registry returned HTTP ${response.status}`);
   }
-  const body = await response.json();
+  const text2 = await boundedResponseText(response, "location registry", 64 * 1024);
+  let body;
+  try {
+    body = JSON.parse(text2);
+  } catch {
+    throw new LocationRecordValidationError("registry response is not JSON");
+  }
   if (body.record === void 0) {
     throw new LocationRecordValidationError("registry response missing record");
   }
   return validateLocationRecord(body.record);
 }
+async function publishLocationRecord(options2) {
+  validateSubject(options2.subject);
+  const registryUrl = exactHttpOrigin(options2.registryUrl, "registry URL");
+  const nodeOrigin = exactHttpOrigin(options2.nodeOrigin, "node origin");
+  const fetchFn = options2.fetch ?? globalThis.fetch.bind(globalThis);
+  const current = await fetchLocationRecord(registryUrl, options2.subject, fetchFn);
+  if (current !== null) {
+    if (current.subject !== options2.subject || !await verifyLocationRecord(current)) {
+      throw new LocationRecordValidationError("existing location record signature is invalid");
+    }
+    if (publishedHttpOrigins(current).includes(nodeOrigin)) {
+      return current;
+    }
+  }
+  const record2 = await signLocationRecord({
+    version: 1,
+    subject: options2.subject,
+    multiaddrs: [...current?.multiaddrs ?? [], httpUrlToMultiaddr(nodeOrigin)],
+    updated_at: (options2.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+    sequence: (current?.sequence ?? -1) + 1
+  }, options2.signer);
+  const response = await fetchFn(
+    `${registryUrl}/v1/locations/${encodeURIComponent(options2.subject)}`,
+    {
+      method: "PUT",
+      redirect: "error",
+      headers: { accept: "application/json", "content-type": "application/json" },
+      body: JSON.stringify(record2)
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`location registry publish returned HTTP ${response.status}`);
+  }
+  const text2 = await boundedResponseText(response, "location registry", 64 * 1024);
+  let body;
+  try {
+    body = JSON.parse(text2);
+  } catch {
+    throw new LocationRecordValidationError("registry publish response is not JSON");
+  }
+  if (body.record === void 0) {
+    throw new LocationRecordValidationError("registry publish response missing record");
+  }
+  const published = validateLocationRecord(body.record);
+  if (canonicalLocationPayload(locationPayloadForRecord(published)) !== canonicalLocationPayload(locationPayloadForRecord(record2)) || published.signature !== record2.signature || !await verifyLocationRecord(published)) {
+    throw new LocationRecordValidationError("registry publish response does not match the signed record");
+  }
+  return published;
+}
 async function resolveCloudLocation(subject, options2 = {}) {
   validateSubject(subject);
   const verifyRecords = options2.verifyRecords ?? true;
@@ -17770,6 +18341,123 @@ function multiaddrToHttpUrl(input) {
   }
   return uri;
 }
+function exactHttpOrigin(value, label) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new LocationRecordValidationError(`${label} must be an absolute URL origin`);
+  }
+  const loopback = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]";
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) {
+    throw new LocationRecordValidationError(`${label} must use HTTPS (or loopback HTTP)`);
+  }
+  if (url.username !== "" || url.password !== "" || url.pathname !== "/" || url.search !== "" || url.hash !== "") {
+    throw new LocationRecordValidationError(`${label} must be an origin without credentials, path, query, or fragment`);
+  }
+  return url.origin;
+}
+function publishedHttpOrigins(record2) {
+  const origins = [];
+  for (const address of record2.multiaddrs) {
+    try {
+      origins.push(exactHttpOrigin(multiaddrToHttpUrl(address), "published node URL"));
+    } catch {
+    }
+  }
+  return origins;
+}
+async function boundedResponseText(response, label, maxBytes) {
+  const declaredLength = response.headers.get("content-length");
+  if (declaredLength !== null && (!/^\d+$/.test(declaredLength) || Number(declaredLength) > maxBytes)) {
+    throw new LocationRecordValidationError(`${label} response is too large`);
+  }
+  if (response.body === null) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value === void 0) continue;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel().catch(() => void 0);
+        throw new LocationRecordValidationError(`${label} response is too large`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes2 = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes2.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder("utf-8", { fatal: true }).decode(bytes2);
+}
+function boundedSignal(parent, timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new LocationRecordValidationError("owner-node binding timeout must be positive");
+  }
+  const controller = new AbortController();
+  const abortFromParent = () => controller.abort(parent?.reason);
+  if (parent?.aborted) abortFromParent();
+  else parent?.addEventListener("abort", abortFromParent, { once: true });
+  const timer = setTimeout(() => controller.abort(new DOMException("owner-node binding timed out", "TimeoutError")), timeoutMs);
+  return {
+    signal: controller.signal,
+    dispose() {
+      clearTimeout(timer);
+      parent?.removeEventListener("abort", abortFromParent);
+    }
+  };
+}
+async function verifyOwnerNodeBinding(options2) {
+  validateSubject(options2.ownerDid);
+  validateSubject(options2.nodeDid);
+  const registryUrl = exactHttpOrigin(options2.registryUrl, "registry URL");
+  const nodeOrigin = exactHttpOrigin(options2.nodeOrigin, "node origin");
+  const fetchFn = options2.fetch ?? globalThis.fetch.bind(globalThis);
+  const lookup = boundedSignal(options2.signal, options2.timeoutMs ?? OWNER_NODE_BINDING_TIMEOUT_MS);
+  try {
+    const record2 = await fetchLocationRecord(registryUrl, options2.ownerDid, fetchFn, lookup.signal);
+    if (record2 === null) {
+      throw new LocationRecordValidationError("owner has no published location record");
+    }
+    if (record2.subject !== options2.ownerDid || !await verifyLocationRecord(record2)) {
+      throw new LocationRecordValidationError("owner location record signature is invalid");
+    }
+    const publishedOrigins = publishedHttpOrigins(record2);
+    if (!publishedOrigins.includes(nodeOrigin)) {
+      throw new LocationRecordValidationError("share target is not in the owner's signed location record");
+    }
+    const response = await fetchFn(new URL("/info", nodeOrigin), {
+      redirect: "error",
+      headers: { accept: "application/json" },
+      signal: lookup.signal
+    });
+    if (!response.ok) {
+      throw new LocationRecordValidationError(`target node /info returned HTTP ${response.status}`);
+    }
+    const text2 = await boundedResponseText(response, "target node /info", 16 * 1024);
+    let body;
+    try {
+      body = JSON.parse(text2);
+    } catch {
+      throw new LocationRecordValidationError("target node /info response is not JSON");
+    }
+    if (body === null || typeof body !== "object" || Array.isArray(body) || body.nodeId !== options2.nodeDid) {
+      throw new LocationRecordValidationError("target node identity does not match the share attestation");
+    }
+    return Object.freeze({ record: record2, nodeOrigin, nodeDid: options2.nodeDid });
+  } finally {
+    lookup.dispose();
+  }
+}
 function httpUrlToMultiaddr(input) {
   const url = new URL(input);
   if (url.protocol !== "http:" && url.protocol !== "https:") {
@@ -17931,7 +18619,7 @@ async function verifyPkhSignature(did, payload, signature) {
 }
 function verifyDidKeySignature(did, payload, signature) {
   const publicKey = ed25519PublicKeyFromDidKey2(did);
-  const signatureBytes = decodeBase64Url3(signature);
+  const signatureBytes = decodeBase64Url4(signature);
   if (signatureBytes.length !== 64) {
     throw new LocationRecordValidationError(
       "did:key signature must be a base64url Ed25519 signature"
@@ -17984,7 +18672,7 @@ function base64UrlEncode3(bytes2) {
   }
   return output;
 }
-function decodeBase64Url3(value) {
+function decodeBase64Url4(value) {
   const alphabet2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
   const bytes2 = [];
   let buffer = 0;