@tinycloud/node-sdk 3.8.0-beta.0 → 3.8.0-beta.10

package/dist/index.cjs

@@ -17053,7 +17053,7 @@ function augmentSignInEntriesWithReplication(input) {
     }
     eligiblePaths.push(path);
   }
-  if (eligiblePaths.length === replication.prefixes.length && eligiblePaths.length > 0 && hasUnrestrictedGetCoverage(input.entries, input.primarySpaceId, "")) {
+  if (replication.syncScope !== "prefixes" && eligiblePaths.length === replication.prefixes.length && eligiblePaths.length > 0 && hasUnrestrictedGetCoverage(input.entries, input.primarySpaceId, "")) {
     return [{
       service: KV_SERVICE,
       space: input.primarySpaceId,
@@ -17086,6 +17086,12 @@ var init_authority_sign_in = __esm({
 
 // src/replication/config.ts
 function assertValidReplicationConfig(replication) {
+  if (replication?.syncScope !== void 0 && replication.syncScope !== "prefixes") {
+    throw new TypeError('replication.syncScope must be "prefixes"');
+  }
+  if (replication?.contentFetch !== void 0 && replication.contentFetch !== "eager" && replication.contentFetch !== "lazy") {
+    throw new TypeError('replication.contentFetch must be "eager" or "lazy"');
+  }
   if (replication === void 0 || !replication.enabled) return;
   if (replication.storage === void 0 || replication.storage === null) {
     throw new TypeError("replication.enabled requires replication.storage");
@@ -17140,6 +17146,7 @@ function resolvedOptions(options) {
     maxStalenessMs: options.maxStalenessMs ?? 12e4,
     staleSyncTimeoutMs: options.staleSyncTimeoutMs ?? 5e3,
     allowSecrets: options.allowSecrets === true,
+    contentFetch: options.contentFetch ?? "eager",
     verify: options.verify === true
   };
 }
@@ -17411,6 +17418,7 @@ __export(authority_exports, {
   assertValidReplicationConfig: () => assertValidReplicationConfig,
   augmentSignInEntriesWithReplication: () => augmentSignInEntriesWithReplication,
   createReplicationAuthority: () => createReplicationAuthority,
+  eraseReplicaLocalCopy: () => eraseReplicaLocalCopy,
   establishReplicaSessionStamp: () => establishReplicaSessionStamp,
   hasUnrestrictedGetCoverage: () => hasUnrestrictedGetCoverage,
   mintNodeReplicationGrant: () => mintNodeReplicationGrant,
@@ -17441,6 +17449,38 @@ function reportReplicaDenial(result, reason, onEvent, context) {
   } catch {
   }
 }
+async function eraseReplicaLocalCopy(lifecycle, trigger, denyStatus, handlers) {
+  if (lifecycle?.kind !== "indexeddb" || lifecycle.eraseLocalCopy === void 0) return void 0;
+  let outcome = { status: "failed", code: "STORAGE_ERROR", marker: false };
+  for (let attempt = 0; attempt <= ERASE_RETRY_DELAYS_MS.length; attempt++) {
+    if (attempt > 0) await new Promise((resolve2) => setTimeout(resolve2, ERASE_RETRY_DELAYS_MS[attempt - 1]));
+    try {
+      outcome = await lifecycle.eraseLocalCopy({ signal: AbortSignal.timeout(ERASE_ATTEMPT_MS) });
+    } catch {
+      outcome = { status: "failed", code: "STORAGE_ERROR", marker: false };
+    }
+    if (outcome.status !== "failed") break;
+  }
+  const keysKept = denyStatus === "marker" || denyStatus === "unguarded";
+  const purge = outcome.status === "erased" ? { ok: true } : { ok: false, retryNow: outcome.status === "failed" };
+  if (outcome.status === "erased" || outcome.status === "refused" && !keysKept) return { outcome, purge };
+  const logoutPending = outcome.status === "failed" && outcome.marker;
+  const event = {
+    type: "replica.purge.failed",
+    trigger,
+    reason: logoutPending ? "logout_pending" : "gate_unavailable",
+    code: outcome.code,
+    retryNow: outcome.status === "failed"
+  };
+  for (const handler of handlers) {
+    try {
+      handler(event);
+    } catch (error) {
+      console.error('Error in "replica.purge.failed" handler:', error);
+    }
+  }
+  return logoutPending ? { outcome, purge, logoutPending } : { outcome, purge };
+}
 function verifiedOwnerConsentAnchor(session, wasmBindings, exactVerifiedRecap2) {
   if (typeof session.siwe !== "string" || typeof session.signature !== "string" || typeof session.address !== "string" || typeof session.chainId !== "number") return null;
   try {
@@ -17699,7 +17739,7 @@ function createReplicationAuthority(host) {
   };
   return authority;
 }
-var import_siwe3, import_sdk_core12, import_replica, parseUcanGrant, KV_GET2, KV_SYNC2, KV_SERVICE2, AUTHORITY_EXPIRY_MARGIN_MS;
+var import_siwe3, import_sdk_core12, import_replica, parseUcanGrant, ERASE_RETRY_DELAYS_MS, ERASE_ATTEMPT_MS, KV_GET2, KV_SYNC2, KV_SERVICE2, AUTHORITY_EXPIRY_MARGIN_MS;
 var init_authority = __esm({
   "src/replication/authority.ts"() {
     "use strict";
@@ -17709,6 +17749,8 @@ var init_authority = __esm({
     init_config();
     init_authority_sign_in();
     parseUcanGrant = import_replica.parseUcanGrant;
+    ERASE_RETRY_DELAYS_MS = [150, 450];
+    ERASE_ATTEMPT_MS = 3e3;
     KV_GET2 = import_sdk_core12.KV.GET;
     KV_SYNC2 = import_sdk_core12.KV.SYNC;
     KV_SERVICE2 = "tinycloud.kv";
@@ -18786,13 +18828,42 @@ function getNodeReplicationLoaders() {
 
 // src/TinyCloudNode.ts
 var import_sdk_core10 = require("@tinycloud/sdk-core");
-var import_sdk_services3 = require("@tinycloud/sdk-services");
+var import_sdk_services4 = require("@tinycloud/sdk-services");
 var import_requestLog2 = require("@tinycloud/sdk-services/telemetry/requestLog");
+var import_resource2 = require("@tinycloud/sdk-services/encryption/resource");
 
 // src/authorization/NodeUserAuthorization.ts
 var import_node_crypto = require("crypto");
 var import_siwe = require("siwe");
 var import_sdk_core5 = require("@tinycloud/sdk-core");
+var import_resource = require("@tinycloud/sdk-services/encryption/resource");
+var import_sdk_services3 = require("@tinycloud/sdk-services");
+
+// src/authorization/appKeyHostBinding.ts
+var DOMAIN_LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+var IPV4 = /^\d+\.\d+\.\d+\.\d+$/;
+var APP_ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+function appKeyHostBinding(domain, appId) {
+  if (!APP_ID.test(appId)) return false;
+  if (domain.endsWith(":")) return false;
+  let url;
+  try {
+    url = new URL(`https://${domain}`);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "https:" || url.port !== "" || url.username !== "" || url.password !== "") return false;
+  if (url.pathname !== "/" || url.search !== "" || url.hash !== "") return false;
+  const host = url.hostname;
+  if (host.startsWith("[") || host.endsWith(".") || IPV4.test(host)) return false;
+  const labels = host.split(".");
+  if (labels.length < 2 || labels[labels.length - 1] === "localhost") return false;
+  if (!labels.every((label) => DOMAIN_LABEL.test(label))) return false;
+  const reversed = labels.reverse().join(".");
+  return appId === reversed || appId.startsWith(`${reversed}.`);
+}
+
+// src/authorization/NodeUserAuthorization.ts
 init_authority_sign_in();
 
 // src/authorization/caveatRefusal.ts
@@ -19304,6 +19375,23 @@ var NodeUserAuthorization = class {
     );
     return this._capabilityRequest;
   }
+  async refreshNamedKeyFeatureForSignIn(address, chainId) {
+    const request = this.getCapabilityRequest();
+    const siweDomain = this.siweConfig?.domain ?? this.domain;
+    const hasNamedKeys = request?.manifests.some((manifest) => manifest.keys?.length && appKeyHostBinding(siweDomain, manifest.keys_app_id ?? manifest.app_id));
+    if (hasNamedKeys) {
+      await this.resolveTinyCloudHostsForSignIn(address, chainId);
+      await this.refreshNodeInfo();
+    }
+  }
+  /** Manifest key paths that this sign-in cannot grant. */
+  get unavailableKeyPaths() {
+    const request = this.getCapabilityRequest();
+    const siweDomain = this.siweConfig?.domain ?? this.domain;
+    return (request?.manifests ?? []).flatMap(
+      (manifest) => this._nodeFeatures.includes("encryption-named-keys-v1") && appKeyHostBinding(siweDomain, manifest.keys_app_id ?? manifest.app_id) ? [] : (manifest.keys ?? []).map((entry) => "path" in entry ? entry.path : entry.prefix)
+    );
+  }
   resolveSpaceName(space, address, chainId) {
     if (space.startsWith("tinycloud:")) {
       return space;
@@ -19495,15 +19583,31 @@ var NodeUserAuthorization = class {
     }
     const rawAbilities = {};
     const currentDid = (0, import_sdk_core5.pkhDid)(address, chainId);
+    if (this._nodeFeatures.includes("encryption-named-keys-v1")) {
+      const siweDomain = this.siweConfig?.domain ?? this.domain;
+      for (const manifest of request.manifests) {
+        if (!appKeyHostBinding(siweDomain, manifest.keys_app_id ?? manifest.app_id)) continue;
+        for (const declaration of manifest.keys ?? []) {
+          const path = "path" in declaration ? declaration.path : declaration.prefix;
+          const resource = `urn:tinycloud:encryption:${currentDid}:default/${path}`;
+          for (const ability of declaration.abilities) {
+            addRawAbility(rawAbilities, resource, `tinycloud.encryption/${ability}`);
+          }
+        }
+      }
+    }
     const spaceResources = request.resources.filter((entry) => {
       if (entry.service !== import_sdk_core5.ENCRYPTION_PERMISSION_SERVICE) {
         return true;
       }
+      const parsed = entry.path.includes("/") ? (0, import_resource.parseEncryptionResource)(entry.path) : { ...(0, import_sdk_services3.parseNetworkId)(entry.path), kind: "network" };
+      if (parsed.kind !== "network") {
+        throw new import_sdk_core5.ManifestValidationError("named keys go in manifest.keys");
+      }
       for (const action of entry.actions) {
         addRawAbility(rawAbilities, entry.path, action);
       }
-      if (entry.actions.includes(DECRYPT_ACTION)) {
-        const parsed = (0, import_sdk_core5.parseNetworkId)(entry.path);
+      if (entry.actions.includes(DECRYPT_ACTION) && parsed.kind === "network") {
         if (didPrincipalMatches(parsed.ownerDid, currentDid)) {
           addRawAbility(rawAbilities, entry.path, NETWORK_CREATE_ACTION);
         }
@@ -19899,6 +20003,8 @@ var NodeUserAuthorization = class {
     this._chainId = chainId;
     await this.resolveTinyCloudHostsForSignIn(address, chainId);
     this.assertSignInCurrent(generation);
+    await this.refreshNamedKeyFeatureForSignIn(address, chainId);
+    this.assertSignInCurrent(generation);
     const keyId = `session-${Date.now()}`;
     this.sessionManager.renameSessionKeyId(this.activeSessionKeyId, keyId);
     this.activeSessionKeyId = keyId;
@@ -20045,6 +20151,7 @@ var NodeUserAuthorization = class {
     refuseCaveated(this.getCapabilityRequest()?.manifests);
     const address = (0, import_sdk_core5.canonicalizeAddress)(await this.signer.getAddress());
     const chainId = await this.signer.getChainId();
+    await this.refreshNamedKeyFeatureForSignIn(address, chainId);
     const keyId = `session-${Date.now()}`;
     this.sessionManager.renameSessionKeyId(this.activeSessionKeyId, keyId);
     this.activeSessionKeyId = keyId;
@@ -21098,6 +21205,7 @@ var ROOT_DELEGATION_ACTIONS = [
   import_sdk_core10.DUCKDB.ALL
 ];
 var DEFAULT_SESSION_EXPIRATION_MS = import_sdk_core10.EXPIRY.SESSION_MS;
+var OWNER_REVOCATION_WINDOW_MS = 10 * 6e4;
 function unifiedRootAttenuation(capabilities) {
   const attenuation = {};
   for (const capability of capabilities) {
@@ -21562,6 +21670,7 @@ function replicaRestoreRefusal(error) {
       case "purge_pending":
       case "logout_pending":
       case "gate_unavailable":
+      case "wallet_provider_required":
         return error.gate;
     }
   }
@@ -21596,6 +21705,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     this.auth = null;
     this.tc = null;
     this._chainId = 1;
+    this.replicaPurgeFailedHandlers = /* @__PURE__ */ new Set();
     /** Mints the replica session stamp on each fresh sign-in (TC-858 §4.1). Undefined when replication is off. */
     this.establishReplicaStamp = async (session) => {
       const replication = this.config.replication;
@@ -21627,6 +21737,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         return void 0;
       }
     };
+    this._keysUnavailable = [];
     this._baseVaults = /* @__PURE__ */ new Map();
     this._baseSecrets = /* @__PURE__ */ new Map();
     this._secrets = /* @__PURE__ */ new Map();
@@ -21802,6 +21913,7 @@ var _TinyCloudNode = class _TinyCloudNode {
           return instance ? instance.control.purge(input) : runtime.then((ready) => ready.control.purge(input));
         },
         clearPending: async () => (await runtime).control.clearPending(),
+        purgeLocalCopy: async () => (await this.eraseReplicaLocalCopy("purge_local_copy"))?.purge ?? { ok: false, retryNow: false },
         close: async () => (await runtime).control.close()
       };
     }
@@ -21856,18 +21968,14 @@ var _TinyCloudNode = class _TinyCloudNode {
   get freshEncryptionNetworkCreated() {
     return this._freshEncryptionNetworkCreated;
   }
-  /**
-   * Subscribe to `storage.full`. It fires on the first write any service had
-   * rejected because the owner's TinyCloud storage is full
-   * (`STORAGE_QUOTA_EXCEEDED` or `STORAGE_LIMIT_REACHED`), so an app can show
-   * one read-only banner. Reads keep working. For the signed-in account's own
-   * storage it fires once per episode: the episode ends only when a write to
-   * that storage succeeds, or on sign-out. A `storage.status()` read does not
-   * end it. A rejection on another owner's delegated space fires once per
-   * owner, until that owner's `storage.status()` reports space again. Returns
-   * the unsubscribe function.
-   */
   on(event, handler) {
+    if (event === "replica.purge.failed") {
+      const listener = handler;
+      this.replicaPurgeFailedHandlers.add(listener);
+      return () => {
+        this.replicaPurgeFailedHandlers.delete(listener);
+      };
+    }
     if (event !== "storage.full") {
       throw new Error(`Unknown TinyCloud event: ${String(event)}`);
     }
@@ -22087,7 +22195,8 @@ var _TinyCloudNode = class _TinyCloudNode {
       replication: config.replication?.enabled === true ? {
         enabled: true,
         prefixes: config.replication.prefixes,
-        allowSecrets: config.replication.allowSecrets === true
+        allowSecrets: config.replication.allowSecrets === true,
+        syncScope: config.replication.syncScope
       } : void 0
     });
     this.tc = new import_sdk_core10.TinyCloud(this.auth, {
@@ -22347,6 +22456,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     const leavingAuth = this.auth;
     const leavingContext = this._serviceContext;
     let denied;
+    let erased;
     try {
       this.teardownSession();
     } finally {
@@ -22357,6 +22467,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         try {
           await this.accountRegistryTail;
           await this.quiesceReplicaRuntime();
+          if (denied) erased = await this.eraseReplicaLocalCopy("sign_out", denied.status);
         } finally {
           if (leavingAddress) {
             await (leavingAuth ? leavingAuth.clearPersistedSession(leavingAddress) : this.config.sessionStorage?.clear(leavingAddress));
@@ -22364,8 +22475,37 @@ var _TinyCloudNode = class _TinyCloudNode {
         }
       }
     }
-    if (denied?.status === "unguarded") {
-      throw new Error(`Replica gate was not denied (${denied.code ?? "unknown"}); the replica may still be restorable.`);
+    if (denied?.status === "unguarded" && erased?.outcome.status !== "erased") {
+      throw Object.assign(
+        new Error(`Replica gate was not denied (${denied.code ?? "unknown"}); the replica may still be restorable.`),
+        {
+          code: "REPLICA_PURGE_FAILED",
+          reason: "gate_unavailable",
+          retryNow: erased?.outcome.status === "failed"
+        }
+      );
+    }
+  }
+  /**
+   * Erases the browser local copy after a deny (retry, event and next-load marker live in the lazy
+   * replication authority). Never rejects; `undefined` when replication is off or the storage keeps
+   * no browser database.
+   */
+  async eraseReplicaLocalCopy(trigger, denyStatus) {
+    const replication = this.config.replication;
+    if (!replication?.enabled) return void 0;
+    try {
+      const { eraseReplicaLocalCopy: eraseReplicaLocalCopy2 } = await getNodeReplicationLoaders().authority();
+      const erased = await eraseReplicaLocalCopy2(
+        replication.storage.lifecycle,
+        trigger,
+        denyStatus,
+        this.replicaPurgeFailedHandlers
+      );
+      if (erased?.logoutPending) this.replicaRestoreGate = "logout_pending";
+      return erased;
+    } catch {
+      return void 0;
     }
   }
   /**
@@ -22425,6 +22565,8 @@ var _TinyCloudNode = class _TinyCloudNode {
     this._hooks = void 0;
     this._vault = void 0;
     this._encryption = void 0;
+    this._namedKeyClient = void 0;
+    this._keysUnavailable = [];
     this._baseVaults.clear();
     this._baseSecrets.clear();
     this._secrets.clear();
@@ -22529,6 +22671,10 @@ var _TinyCloudNode = class _TinyCloudNode {
     const priorPrincipal = this.replicaSessionPrincipal ?? (this.address ? (0, import_sdk_core10.pkhDid)(this.address, this._chainId) : void 0);
     if (this.config.replication?.enabled && priorPrincipal && priorPrincipal !== nextPrincipal) {
       const denial = await this.denyReplicaGate({ reason: "account_switch", principal: priorPrincipal, next: nextPrincipal });
+      if (denial) {
+        await this.quiesceReplicaRuntime();
+        await this.eraseReplicaLocalCopy("account_switch", denial.status);
+      }
       this.replicaRestoreGate = denial?.status === "unguarded" ? "gate_unavailable" : "stamp_stale";
     }
     if (address !== this._address || chainId !== this._chainId) {
@@ -22543,6 +22689,8 @@ var _TinyCloudNode = class _TinyCloudNode {
     this._hooks = void 0;
     this._vault = void 0;
     this._encryption = void 0;
+    this._namedKeyClient = void 0;
+    this._keysUnavailable = [];
     this._baseVaults.clear();
     this._baseSecrets.clear();
     this._secrets.clear();
@@ -22595,6 +22743,26 @@ var _TinyCloudNode = class _TinyCloudNode {
     this.assertSessionEpoch(epoch, "Sign-in");
     await this.ensureRequestedEncryptionNetworks();
     this.assertSessionEpoch(epoch, "Sign-in");
+    this._keysUnavailable = this.auth?.unavailableKeyPaths ?? [];
+    if (this._keysUnavailable.length > 0) {
+      this.notificationHandler.warning(`Named keys unavailable: ${this._keysUnavailable.join(", ")}`);
+    }
+    if (this.nodeFeatures.includes("encryption-named-keys-v1")) {
+      for (const manifest of this.auth?.capabilityRequest?.manifests ?? []) {
+        for (const declaration of manifest.keys ?? []) {
+          if ("path" in declaration && declaration.abilities.includes("key.create") && !this._keysUnavailable.includes(declaration.path)) {
+            try {
+              await this.keys.ensureKey(declaration.path);
+            } catch (error) {
+              this._keysUnavailable.push(declaration.path);
+              const code = error && typeof error === "object" && "code" in error && typeof error.code === "string" && /^[A-Z_]+$/.test(error.code) ? error.code : "UNKNOWN";
+              this.notificationHandler.warning(`Named key unavailable: ${declaration.path} (${code})`);
+            }
+            this.assertSessionEpoch(epoch, "Sign-in");
+          }
+        }
+      }
+    }
     if (!bootstrapped && this.config.manifest === void 0 && this.config.capabilityRequest === void 0) {
       await this.ensureOwnedSpaceHostedById(this.ownedSpaceId(import_sdk_core10.SECRETS_SPACE));
     }
@@ -23171,7 +23339,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (!this.currentSessionCoversAccountRegistry()) {
       if (!_TinyCloudNode.accountRegistrySkipLogged) {
         _TinyCloudNode.accountRegistrySkipLogged = true;
-        import_sdk_services3.tinyCloudDebugLogger.log("registry.skip");
+        import_sdk_services4.tinyCloudDebugLogger.log("registry.skip");
       }
       return;
     }
@@ -23382,7 +23550,8 @@ var _TinyCloudNode = class _TinyCloudNode {
     const networkIds = /* @__PURE__ */ new Set();
     for (const resource of request.resources) {
       if (resource.service === import_sdk_core10.ENCRYPTION_PERMISSION_SERVICE && resource.path.startsWith("urn:tinycloud:encryption:") && resource.actions.includes(DECRYPT_ACTION2)) {
-        networkIds.add(resource.path);
+        const parsed = resource.path.includes("/") ? (0, import_resource2.parseEncryptionResource)(resource.path) : { ...(0, import_sdk_core10.parseNetworkId)(resource.path), kind: "network" };
+        if (parsed.kind === "network") networkIds.add(resource.path);
       }
     }
     return [...networkIds];
@@ -23932,6 +24101,8 @@ var _TinyCloudNode = class _TinyCloudNode {
     this._hooks = stagedGraph.hooks;
     this._vault = stagedGraph.vault;
     this._encryption = stagedGraph.encryption;
+    this._namedKeyClient = void 0;
+    this._keysUnavailable = [];
     this._capabilityRegistry = stagedGraph.capabilityRegistry;
     this._keyProvider = stagedGraph.keyProvider;
     this._sharingService = stagedGraph.sharingService;
@@ -24509,7 +24680,8 @@ var _TinyCloudNode = class _TinyCloudNode {
       replication: this.config.replication?.enabled === true ? {
         enabled: true,
         prefixes: this.config.replication.prefixes,
-        allowSecrets: this.config.replication.allowSecrets === true
+        allowSecrets: this.config.replication.allowSecrets === true,
+        syncScope: this.config.replication.syncScope
       } : void 0
     });
     this.tc = new import_sdk_core10.TinyCloud(this.auth, {
@@ -24571,7 +24743,8 @@ var _TinyCloudNode = class _TinyCloudNode {
       replication: this.config.replication?.enabled === true ? {
         enabled: true,
         prefixes: this.config.replication.prefixes,
-        allowSecrets: this.config.replication.allowSecrets === true
+        allowSecrets: this.config.replication.allowSecrets === true,
+        syncScope: this.config.replication.syncScope
       } : void 0
     });
     this.tc = new import_sdk_core10.TinyCloud(this.auth, {
@@ -24839,7 +25012,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         );
         graph.assertActive();
         if (!response.ok) {
-          const permissionHint = response.status === 401 || response.status === 403 ? (0, import_sdk_services3.parsePermissionHint)({
+          const permissionHint = response.status === 401 || response.status === 403 ? (0, import_sdk_services4.parsePermissionHint)({
             service: "tinycloud.encryption",
             path: networkId,
             actions: ["tinycloud.encryption/decrypt"]
@@ -25283,7 +25456,7 @@ var _TinyCloudNode = class _TinyCloudNode {
    * Sign a wallet (CACAO) revocation of the delegation `cid` for the node's
    * `POST /revoke`, and return its Authorization header value. The node
    * accepts it when the owner delegated `cid` or owns a space its abilities
-   * target, whichever key issued it. Valid for 60 seconds. Requires the
+   * target, whichever key issued it. Valid for 10 minutes. Requires the
    * owner wallet signer.
    */
   async signOwnerRevocation(cid) {
@@ -25299,7 +25472,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       chainId: session.chainId,
       nonce: (0, import_siwe2.generateNonce)(),
       issuedAt: issuedAt.toISOString(),
-      expirationTime: new Date(issuedAt.getTime() + 6e4).toISOString()
+      expirationTime: new Date(issuedAt.getTime() + OWNER_REVOCATION_WINDOW_MS).toISOString()
     }).prepareMessage();
     const signature2 = await this.signer.signMessage(siwe);
     return this.wasmBindings.siweToDelegationHeaders({ siwe, signature: signature2 }).Authorization;
@@ -25526,6 +25699,40 @@ var _TinyCloudNode = class _TinyCloudNode {
   get encryption() {
     return this.getEncryptionService();
   }
+  /** Named keys bound to the current session. */
+  get keys() {
+    return new Proxy({}, {
+      get: (_target, property) => {
+        if (property === "refreshNodeInfo") {
+          return () => {
+            void this._namedKeyClient?.then((client) => client.refreshNodeInfo());
+          };
+        }
+        if (typeof property !== "string" || ![
+          "getPublicKey",
+          "describeKey",
+          "createKey",
+          "blockKey",
+          "unblockKey",
+          "ensureKey",
+          "encrypt",
+          "decrypt",
+          "decryptMany"
+        ].includes(property)) return void 0;
+        return (...args) => {
+          this._namedKeyClient ?? (this._namedKeyClient = import("./encryption-keys.cjs").then(({ createNamedKeyClient }) => createNamedKeyClient(this)));
+          return this._namedKeyClient.then((client) => {
+            const method = client[property];
+            return method.apply(client, args);
+          });
+        };
+      }
+    });
+  }
+  /** Manifest key paths unavailable during the latest `signIn()` attempt. */
+  get keysUnavailable() {
+    return this._keysUnavailable;
+  }
   async getEncryptionNetwork(nameOrNetworkId = this.getDefaultEncryptionNetworkId()) {
     const networkId = nameOrNetworkId.startsWith("urn:tinycloud:encryption:") ? nameOrNetworkId : this.getDefaultEncryptionNetworkId(nameOrNetworkId);
     return this.fetchEncryptionNetworkAt(
@@ -25653,7 +25860,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     );
     if (result.status !== "ok") {
       if (result.status === "permission_required") {
-        const hint = (0, import_sdk_services3.parsePermissionHint)(result.hint);
+        const hint = (0, import_sdk_services4.parsePermissionHint)(result.hint);
         if (hint === void 0) return { status: "read_failed" };
         return {
           status: "permission_required",
@@ -27998,7 +28205,7 @@ var import_node_fs = require("fs");
 var import_promises = require("fs/promises");
 var import_node_path = require("path");
 var import_sdk_core14 = require("@tinycloud/sdk-core");
-var import_sdk_services4 = require("@tinycloud/sdk-services");
+var import_sdk_services5 = require("@tinycloud/sdk-services");
 var import_contractConstants = require("@tinycloud/sdk-services/kv/replication/contractConstants");
 init_authority();
 var REPLICA_LOGOUT_PENDING_FILE = "replica-logout-pending.json";
@@ -28560,7 +28767,7 @@ function sha256Base32(material) {
   return out.slice(0, 26);
 }
 function partitionDirOf(root, identity) {
-  return (0, import_node_path.join)(root, sha256Base32((0, import_sdk_services4.replicationIdentityKey)(identity)));
+  return (0, import_node_path.join)(root, sha256Base32((0, import_sdk_services5.replicationIdentityKey)(identity)));
 }
 function replicaHashOf(prefix, deviceDid) {
   return sha256Base32(`${prefix}
@@ -28634,8 +28841,8 @@ function deviceRecordOf(value) {
 }
 function sameIdentity(a, b) {
   try {
-    const left = (0, import_sdk_services4.canonicalReplicationIdentity)(a);
-    const right = (0, import_sdk_services4.canonicalReplicationIdentity)(b);
+    const left = (0, import_sdk_services5.canonicalReplicationIdentity)(a);
+    const right = (0, import_sdk_services5.canonicalReplicationIdentity)(b);
     return left.host === right.host && left.space === right.space && left.principal === right.principal;
   } catch {
     return false;
@@ -28651,7 +28858,7 @@ async function ensurePartitionIdentity(dir, identity, dirSync) {
   const file = (0, import_node_path.join)(dir, "identity.json");
   const existing = await readJsonFile(file);
   if (existing === void 0) {
-    await writeJsonAtomic(file, { v: 1, ...(0, import_sdk_services4.canonicalReplicationIdentity)(identity) }, dirSync);
+    await writeJsonAtomic(file, { v: 1, ...(0, import_sdk_services5.canonicalReplicationIdentity)(identity) }, dirSync);
     return;
   }
   const record = identityRecordOf(existing);
@@ -28750,7 +28957,7 @@ withGate_fn = async function(section) {
   if (snapshot === void 0) throw gated("gate_unavailable");
   const [principalHash, identityKeyHash] = await Promise.all([
     gate.principalHashOf(snapshot.salt, this.identity.principal),
-    gate.identityHashOf(snapshot.salt, (0, import_sdk_services4.replicationIdentityKey)(this.identity))
+    gate.identityHashOf(snapshot.salt, (0, import_sdk_services5.replicationIdentityKey)(this.identity))
   ]);
   const access = {
     stamp: __privateGet(this, _stamp),
@@ -29021,7 +29228,8 @@ var SqliteReplicaHandle = class {
     options.signal.addEventListener("abort", onAbort, { once: true });
     const engine = new (__privateGet(this, _replica)).Replica({
       store: __privateGet(this, _store),
-      transportFor
+      transportFor,
+      ...this.spec.contentFetch === void 0 ? {} : { contentFetch: this.spec.contentFetch }
     });
     const running = engine.sync({ signal: abort.signal });
     const registration = { promise: running, abort: () => abort.abort() };
@@ -29250,7 +29458,7 @@ function createSqliteReplicaStorage(options) {
     if (snapshot === void 0) throw gated("gate_unavailable");
     const [principalHash, identityKeyHash] = await Promise.all([
       gate.principalHashOf(snapshot.salt, principal),
-      identity === void 0 ? Promise.resolve(void 0) : gate.identityHashOf(snapshot.salt, (0, import_sdk_services4.replicationIdentityKey)(identity))
+      identity === void 0 ? Promise.resolve(void 0) : gate.identityHashOf(snapshot.salt, (0, import_sdk_services5.replicationIdentityKey)(identity))
     ]);
     return profileSection(async () => {
       assertLogoutClear(options.logoutPendingFile);
@@ -29273,7 +29481,7 @@ function createSqliteReplicaStorage(options) {
     if (snapshot === void 0) throw gated("gate_unavailable");
     const [principalHash, identityKeyHash] = await Promise.all([
       gate.principalHashOf(snapshot.salt, spec.identity.principal),
-      gate.identityHashOf(snapshot.salt, (0, import_sdk_services4.replicationIdentityKey)(spec.identity))
+      gate.identityHashOf(snapshot.salt, (0, import_sdk_services5.replicationIdentityKey)(spec.identity))
     ]);
     const access = {
       stamp: spec.stamp,
@@ -29357,7 +29565,7 @@ function createSqliteReplicaStorage(options) {
       const identity = identityRecordOf(await readJsonFile((0, import_node_path.join)(idDir, "identity.json")));
       if (identity === void 0) throw new ReplicaStorageError("STORAGE_ERROR", `Missing identity at ${idDir}.`);
       if (await gate.principalHashOf(salt, identity.principal) !== principalHash) continue;
-      const identityKeyHash = await gate.identityHashOf(salt, (0, import_sdk_services4.replicationIdentityKey)(identity));
+      const identityKeyHash = await gate.identityHashOf(salt, (0, import_sdk_services5.replicationIdentityKey)(identity));
       const recordedAt = Date.now();
       if (await pathExists((0, import_node_path.join)(idDir, "pending.json")) || await pathExists((0, import_node_path.join)(idDir, "device.jwk"))) {
         intents.push({ id: `pending:${identityKeyHash}`, kind: "pending", identityKeyHash, principalHash, recordedAt });
@@ -30035,7 +30243,7 @@ function createSqliteReplicaStorage(options) {
           for (const dir of await identityDirs()) {
             const identity = identityRecordOf(await readJsonFile((0, import_node_path.join)(dir, "identity.json")));
             if (identity === void 0) throw new ReplicaStorageError("STORAGE_ERROR", `Missing identity at ${dir}.`);
-            const hash3 = await gate.identityHashOf(state.salt, (0, import_sdk_services4.replicationIdentityKey)(identity));
+            const hash3 = await gate.identityHashOf(state.salt, (0, import_sdk_services5.replicationIdentityKey)(identity));
             if (intent.kind === "pending" ? hash3 === intent.identityKeyHash : intent.partitionId.startsWith(`${hash3}:`)) {
               idDir = dir;
               break;
@@ -30181,7 +30389,7 @@ function createSqliteReplicaStorage(options) {
     const gate = await fileGate();
     const snapshot = await gate.readGateSnapshot(profileDir);
     if (snapshot === void 0) throw gated("gate_unavailable");
-    const identityKeyHash = await gate.identityHashOf(snapshot.salt, (0, import_sdk_services4.replicationIdentityKey)(spec.identity));
+    const identityKeyHash = await gate.identityHashOf(snapshot.salt, (0, import_sdk_services5.replicationIdentityKey)(spec.identity));
     const resolvePolicy = async (at, recordFirst) => {
       const policy = spec.grantPolicy;
       if (!Number.isSafeInteger(policy.grantTtlMs) || policy.grantTtlMs <= 0 || policy.grantTtlMs > import_contractConstants.MAX_GRANT_TTL_MS) {
@@ -30203,7 +30411,7 @@ function createSqliteReplicaStorage(options) {
     let partitionId;
     const storeGuard = (section) => guarded(spec.identity.principal, spec.stamp, spec.identity, partitionId, section);
     return guarded(spec.identity.principal, spec.stamp, spec.identity, void 0, async () => {
-      if ((0, import_sdk_services4.requiresSecretsOptIn)(spec.space, spec.prefix) && spec.allowSecrets !== true) {
+      if ((0, import_sdk_services5.requiresSecretsOptIn)(spec.space, spec.prefix) && spec.allowSecrets !== true) {
         throw new replica.ReplicaError(
           replica.ReplicaErrorCode.SECRETS_OPT_IN_REQUIRED,
           `Replicating ${spec.space}/kv/${spec.prefix} copies secret material to disk; pass allowSecrets to opt in.`
@@ -30449,7 +30657,7 @@ function createSqliteReplicaStorage(options) {
               const gate = await fileGate();
               const currentGate = await gate.readGateSnapshot(profileDir);
               if (currentGate !== void 0 && currentGate.principalHash !== null && currentGate.principalHash === await gate.principalHashOf(currentGate.salt, target.identity.principal)) {
-                const identityKeyHash = await gate.identityHashOf(currentGate.salt, (0, import_sdk_services4.replicationIdentityKey)(target.identity));
+                const identityKeyHash = await gate.identityHashOf(currentGate.salt, (0, import_sdk_services5.replicationIdentityKey)(target.identity));
                 await retainGrantInstalls(gate, currentGate, identityKeyHash, store);
               }
               if (state.revoked === null) {