@tinycloud/node-sdk 3.2.6-beta.6 → 3.3.0-beta.7

package/dist/index.js

@@ -4413,11 +4413,11 @@ var init_lib4 = __esm({
     init_version4();
     __awaiter = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve) {
-          resolve(value);
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve, reject2) {
+      return new (P || (P = Promise))(function(resolve2, reject2) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -4433,7 +4433,7 @@ var init_lib4 = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -8049,11 +8049,11 @@ var init_typed_data = __esm({
     init_id();
     __awaiter2 = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve) {
-          resolve(value);
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve, reject2) {
+      return new (P || (P = Promise))(function(resolve2, reject2) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -8069,7 +8069,7 @@ var init_typed_data = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -14911,7 +14911,7 @@ var require_scrypt = __commonJS({
       }
       const lib = {
         scrypt: function(password, salt, N2, r2, p, dkLen, progressCallback) {
-          return new Promise(function(resolve, reject2) {
+          return new Promise(function(resolve2, reject2) {
             let lastProgress = 0;
             if (progressCallback) {
               progressCallback(0);
@@ -14923,7 +14923,7 @@ var require_scrypt = __commonJS({
                 if (progressCallback && lastProgress !== 1) {
                   progressCallback(1);
                 }
-                resolve(new Uint8Array(key2));
+                resolve2(new Uint8Array(key2));
               } else if (progressCallback && progress !== lastProgress) {
                 lastProgress = progress;
                 return progressCallback(progress);
@@ -15303,11 +15303,11 @@ var init_keystore = __esm({
     init_version15();
     __awaiter3 = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve) {
-          resolve(value);
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve, reject2) {
+      return new (P || (P = Promise))(function(resolve2, reject2) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -15323,7 +15323,7 @@ var init_keystore = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -15616,11 +15616,11 @@ var init_lib25 = __esm({
     init_version19();
     __awaiter4 = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve) {
-          resolve(value);
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve, reject2) {
+      return new (P || (P = Promise))(function(resolve2, reject2) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -15636,7 +15636,7 @@ var init_lib25 = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -15698,11 +15698,11 @@ var init_lib26 = __esm({
     init_version20();
     __awaiter5 = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve) {
-          resolve(value);
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve, reject2) {
+      return new (P || (P = Promise))(function(resolve2, reject2) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -15718,7 +15718,7 @@ var init_lib26 = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -16020,11 +16020,11 @@ var init_lib27 = __esm({
     init_version21();
     __awaiter6 = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve) {
-          resolve(value);
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve, reject2) {
+      return new (P || (P = Promise))(function(resolve2, reject2) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -16040,7 +16040,7 @@ var init_lib27 = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -16258,11 +16258,11 @@ var init_geturl = __esm({
     init_lib2();
     __awaiter7 = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve) {
-          resolve(value);
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve, reject2) {
+      return new (P || (P = Promise))(function(resolve2, reject2) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -16278,7 +16278,7 @@ var init_geturl = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -16294,8 +16294,8 @@ __export(lib_exports21, {
   poll: () => poll
 });
 function staller(duration) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, duration);
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, duration);
   });
 }
 function bodyify(value, type) {
@@ -16415,7 +16415,7 @@ function _fetchData(connection, body, processFunc) {
   options.headers = flatHeaders;
   const runningTimeout = (function() {
     let timer = null;
-    const promise = new Promise(function(resolve, reject2) {
+    const promise = new Promise(function(resolve2, reject2) {
       if (timeout) {
         timer = setTimeout(() => {
           if (timer == null) {
@@ -16585,7 +16585,7 @@ function poll(func, options) {
   if (options.interval == null) {
     options.interval = 250;
   }
-  return new Promise(function(resolve, reject2) {
+  return new Promise(function(resolve2, reject2) {
     let timer = null;
     let done = false;
     const cancel = () => {
@@ -16611,7 +16611,7 @@ function poll(func, options) {
       return func().then(function(result) {
         if (result !== void 0) {
           if (cancel()) {
-            resolve(result);
+            resolve2(result);
           }
         } else if (options.oncePoll) {
           options.oncePoll.once("poll", check);
@@ -16657,11 +16657,11 @@ var init_lib28 = __esm({
     init_geturl();
     __awaiter8 = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve) {
-          resolve(value);
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve, reject2) {
+      return new (P || (P = Promise))(function(resolve2, reject2) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -16677,7 +16677,7 @@ var init_lib28 = __esm({
           }
         }
         function step(result) {
-          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -17035,44 +17035,6 @@ var require_utils2 = __commonJS({
   }
 });
 
-// src/replication/config.ts
-import { assertFolderPrefix as assertPureFolderPrefix, kvPrefixCovers } from "@tinycloud/sdk-services/kv/replication/prefix";
-function assertValidReplicationConfig(replication) {
-  if (replication === void 0 || replication.enabled !== true) return;
-  if (replication.storage === void 0 || replication.storage === null) {
-    throw new TypeError("replication.enabled requires replication.storage");
-  }
-  if (!Array.isArray(replication.prefixes) || replication.prefixes.length === 0) {
-    throw new TypeError("replication.prefixes must be a non-empty array");
-  }
-  for (const prefix of replication.prefixes) {
-    try {
-      assertPureFolderPrefix(prefix);
-    } catch (error) {
-      throw new TypeError(error instanceof Error ? error.message : String(error));
-    }
-  }
-  for (const [index, prefix] of replication.prefixes.entries()) {
-    for (const other of replication.prefixes.slice(index + 1)) {
-      if (kvPrefixCovers(prefix, other) || kvPrefixCovers(other, prefix)) {
-        throw new TypeError(
-          `replication.prefixes must not overlap: ${JSON.stringify(prefix)} and ${JSON.stringify(other)}`
-        );
-      }
-    }
-    if ((prefix === "/" || prefix.split("/", 1)[0] === "vault") && replication.allowSecrets !== true) {
-      throw new TypeError(
-        `replication prefix ${JSON.stringify(prefix)} overlaps the vault namespace; pass allowSecrets to opt in`
-      );
-    }
-  }
-}
-var init_config = __esm({
-  "src/replication/config.ts"() {
-    "use strict";
-  }
-});
-
 // src/replication/authority-sign-in.ts
 import {
   KV,
@@ -17130,6 +17092,49 @@ var init_authority_sign_in = __esm({
   }
 });
 
+// src/replication/config.ts
+import { MAX_GRANT_TTL_MS } from "@tinycloud/sdk-services/kv/replication/grantPolicyConstants";
+import { assertFolderPrefix as assertPureFolderPrefix, kvPrefixCovers } from "@tinycloud/sdk-services/kv/replication/prefix";
+function assertValidReplicationConfig(replication) {
+  if (replication === void 0 || !replication.enabled) return;
+  if (replication.storage === void 0 || replication.storage === null) {
+    throw new TypeError("replication.enabled requires replication.storage");
+  }
+  if (!Array.isArray(replication.prefixes) || replication.prefixes.length === 0) {
+    throw new TypeError("replication.prefixes must be a non-empty array");
+  }
+  const grantTtlMs = replication.grantTtlMs;
+  if (grantTtlMs !== void 0 && (!Number.isFinite(grantTtlMs) || grantTtlMs <= 0 || grantTtlMs > MAX_GRANT_TTL_MS)) {
+    throw new TypeError(`replication.grantTtlMs must be a positive number of milliseconds no greater than ${MAX_GRANT_TTL_MS}`);
+  }
+  for (const prefix of replication.prefixes) {
+    try {
+      assertPureFolderPrefix(prefix);
+    } catch (error) {
+      throw new TypeError(error instanceof Error ? error.message : String(error));
+    }
+  }
+  for (const [index, prefix] of replication.prefixes.entries()) {
+    for (const other of replication.prefixes.slice(index + 1)) {
+      if (kvPrefixCovers(prefix, other) || kvPrefixCovers(other, prefix)) {
+        throw new TypeError(
+          `replication.prefixes must not overlap: ${JSON.stringify(prefix)} and ${JSON.stringify(other)}`
+        );
+      }
+    }
+    if ((prefix === "/" || prefix.split("/", 1)[0] === "vault") && replication.allowSecrets !== true) {
+      throw new TypeError(
+        `replication prefix ${JSON.stringify(prefix)} overlaps the vault namespace; pass allowSecrets to opt in`
+      );
+    }
+  }
+}
+var init_config = __esm({
+  "src/replication/config.ts"() {
+    "use strict";
+  }
+});
+
 // src/replication/runtime.ts
 var runtime_exports = {};
 __export(runtime_exports, {
@@ -17173,10 +17178,23 @@ var init_runtime = __esm({
         this.control = {
           status: async () => {
             await this.binding;
+            if (this.gatedReason) return this.options.prefixes.map((prefix) => ({
+              prefix,
+              state: "gated",
+              gate: this.gatedReason,
+              errorCode: "REPLICA_GATED",
+              pending: { inFlight: 0, committed: 0, ambiguous: 0 },
+              pinned: [],
+              lagMs: null
+            }));
             return this.current ? this.current.status() : [];
           },
           sync: async (input) => {
             await this.binding;
+            if (this.gatedReason) throw Object.assign(new Error("Replica restore is gated."), {
+              code: "REPLICA_GATED",
+              gate: this.gatedReason
+            });
             if (this.purgedGeneration === this.generation) return;
             if (this.current) await this.current.sync(input);
           },
@@ -17224,11 +17242,59 @@ var init_runtime = __esm({
         for (const kv of this.attached.keys()) kv.setReadThrough(null);
         this.attached.clear();
       }
+      /** Observe a refused restore without opening replica state; loader failure leaves raw network KV usable. */
+      bindGatedNetworkOnly(input, loadGatedNetwork) {
+        if (this.closed || !this.options.enabled) return Promise.resolve();
+        const retired = this.unbind();
+        const generation = this.generation;
+        this.purgedGeneration = void 0;
+        this.pendingPurge = void 0;
+        this.pendingPurgeResult = void 0;
+        this.pending.clear();
+        this.lastController = void 0;
+        this.lastPending = void 0;
+        this.lastIdentity = void 0;
+        this.gatedReason = input.gate;
+        this.primarySpace = input.session.spaceId;
+        this.binding = retired.then(async () => {
+          let create;
+          try {
+            ({ createGatedNetworkReadThrough: create } = await loadGatedNetwork());
+          } catch {
+            return;
+          }
+          if (generation !== this.generation || this.closed || typeof create !== "function") return;
+          const networkOnly = create({
+            space: input.session.spaceId,
+            prefixes: this.options.prefixes,
+            now: () => this.clock.now(),
+            emit: (event) => {
+              if (generation !== this.generation || this.closed || this.gated !== networkOnly) return;
+              try {
+                this.options.onEvent?.(event);
+              } catch {
+              }
+              const { type, ...data } = event;
+              try {
+                input.context.emit(type, data);
+              } catch {
+              }
+            }
+          });
+          this.gated = networkOnly;
+          for (const scoped of input.primaryKV) this.attach(scoped.space, scoped.kv);
+        });
+        return this.binding;
+      }
       bind(input) {
         if (this.closed || !this.options.enabled) return Promise.resolve();
+        this.gated = void 0;
+        this.gatedReason = void 0;
         this.bindingActive = true;
         const generation = ++this.generation;
         this.purgedGeneration = void 0;
+        this.unsubscribeConsentExpired?.();
+        this.unsubscribeConsentExpired = void 0;
         const { context, session } = input;
         const emit = (event) => {
           try {
@@ -17261,11 +17327,17 @@ var init_runtime = __esm({
             return;
           }
           const key2 = services.replicationIdentityKey(identity);
-          let pending = this.pending.get(key2);
-          if (!pending) {
-            pending = this.options.storage.pendingWrites?.(identity) ?? services.createMemoryPendingStore(identity);
-            this.pending.set(key2, pending);
+          let cached = this.pending.get(key2);
+          const stamp = input.stamp;
+          if (!cached || cached.stamp?.incarnation !== stamp?.incarnation || cached.stamp?.lifecycleEpoch !== stamp?.lifecycleEpoch) {
+            const store = this.options.storage.pendingWrites?.(identity, { stamp });
+            if (!store && this.options.storage.lifecycle) {
+              throw Object.assign(new Error("Gated replication requires a stamped pending store"), { code: "REPLICA_GATED", gate: "gate_unavailable" });
+            }
+            cached = { stamp, store: store ?? services.createMemoryPendingStore(identity) };
+            this.pending.set(key2, cached);
           }
+          const pending = cached.store;
           this.lastPending = pending;
           const controller = services.createKVReplication({
             options: resolvedOptions(this.options),
@@ -17273,6 +17345,7 @@ var init_runtime = __esm({
             storage: this.options.storage,
             identity,
             session: { id: session.delegationCid, did: session.verificationMethod, space: session.spaceId },
+            stamp: input.stamp,
             authority: input.authority,
             pending,
             scheduler: this.clock,
@@ -17282,6 +17355,9 @@ var init_runtime = __esm({
             previous: previousClose
           });
           this.current = controller;
+          this.unsubscribeConsentExpired = this.options.storage.lifecycle?.subscribeConsentExpired?.(
+            (stamp2) => controller.observeConsentExpired(stamp2)
+          );
           this.lastController = controller;
           this.lastIdentity = identity;
           for (const [kv, space] of this.attached) {
@@ -17302,17 +17378,24 @@ var init_runtime = __esm({
       }
       attach(space, kv) {
         this.attached.set(kv, space);
-        kv.setReadThrough(space === this.primarySpace ? this.current ?? null : null);
+        kv.setReadThrough(space === this.primarySpace ? this.current ?? this.gated ?? null : null);
+        const generation = this.generation;
         return this.binding.then(() => {
-          kv.setReadThrough(space === this.primarySpace ? this.current ?? null : null);
+          if (generation === this.generation && !this.closed && this.attached.get(kv) === space) {
+            kv.setReadThrough(space === this.primarySpace ? this.current ?? this.gated ?? null : null);
+          }
         });
       }
       unbind() {
         this.generation++;
         this.bindingActive = false;
         this.pendingPurgeSet = false;
+        this.unsubscribeConsentExpired?.();
+        this.unsubscribeConsentExpired = void 0;
         const controller = this.current;
         this.current = void 0;
+        this.gated = void 0;
+        this.gatedReason = void 0;
         this.primarySpace = void 0;
         this.detachAll();
         const binding = this.binding;
@@ -17331,22 +17414,104 @@ var init_runtime = __esm({
 var authority_exports = {};
 __export(authority_exports, {
   AUTHORITY_EXPIRY_MARGIN_MS: () => AUTHORITY_EXPIRY_MARGIN_MS,
+  assertRenewalParent: () => assertRenewalParent,
   assertValidReplicationConfig: () => assertValidReplicationConfig,
   augmentSignInEntriesWithReplication: () => augmentSignInEntriesWithReplication,
   createReplicationAuthority: () => createReplicationAuthority,
+  establishReplicaSessionStamp: () => establishReplicaSessionStamp,
   hasUnrestrictedGetCoverage: () => hasUnrestrictedGetCoverage,
+  mintNodeReplicationGrant: () => mintNodeReplicationGrant,
   replicationScopeFromSignedSession: () => replicationScopeFromSignedSession,
+  reportReplicaDenial: () => reportReplicaDenial,
+  restoreReplicaSessionStamp: () => restoreReplicaSessionStamp,
   ucanAttCovers: () => ucanAttCovers,
-  ucanAttUnconstrainedFor: () => ucanAttUnconstrainedFor
+  ucanAttUnconstrainedFor: () => ucanAttUnconstrainedFor,
+  verifiedOwnerConsentAnchor: () => verifiedOwnerConsentAnchor
 });
+import { SiweMessage as SiweMessage4 } from "siwe";
 import {
   actionContains,
   KV as KV4,
   canonicalizeRecapCaveats as canonicalizeRecapCaveats3,
   isCapabilitySubset as isCapabilitySubset3,
+  principalDid,
   parseSpaceUri as parseSpaceUri2
 } from "@tinycloud/sdk-core";
 import { parseUcanGrant as replicaParseUcanGrant } from "@tinycloud/replica";
+function reportReplicaDenial(result, reason, onEvent, context) {
+  if (result.status !== "denied" && result.status !== "deleted" && result.status !== "marker") return;
+  const event = {
+    type: "replication.lifecycle",
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    reason,
+    action: result.status === "denied" ? "denied" : result.status === "deleted" ? "database_deleted" : "marker_set",
+    ...result.status === "denied" ? { partitions: result.intents } : {},
+    ...result.status === "marker" ? { code: result.code } : {}
+  };
+  try {
+    onEvent?.(event);
+  } catch {
+  }
+  const { type, ...data } = event;
+  try {
+    context?.emit(type, data);
+  } catch {
+  }
+}
+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 {
+    const verified = wasmBindings.validatePersistedSession?.({
+      delegationHeader: session.delegationHeader,
+      delegationCid: session.delegationCid,
+      spaceId: session.spaceId,
+      jwk: session.jwk,
+      address: session.address,
+      chainId: session.chainId,
+      siwe: session.siwe,
+      signature: session.signature
+    });
+    if (!verified || !Number.isSafeInteger(Date.parse(verified.expiresAt ?? ""))) return null;
+    const signedIssuedAt = new SiweMessage4(session.siwe).issuedAt;
+    if (typeof signedIssuedAt !== "string") return null;
+    const issuedAt = Date.parse(signedIssuedAt);
+    if (!Number.isSafeInteger(issuedAt) || issuedAt < 0) return null;
+    const granted = exactVerifiedRecap2(verified).filter((entry) => entry.space === session.spaceId && entry.service === "kv").map((entry) => ({ ...entry, service: "tinycloud.kv" }));
+    const coversGetAndSync = granted.some((entry) => isCapabilitySubset3([{
+      service: "tinycloud.kv",
+      space: session.spaceId,
+      path: entry.path,
+      actions: [KV4.GET, KV4.SYNC]
+    }], granted).subset);
+    return coversGetAndSync ? { at: issuedAt, source: "siwe" } : null;
+  } catch {
+    return null;
+  }
+}
+function establishReplicaSessionStamp(storage, principal, anchor) {
+  if (storage.kind === "indexeddb" && storage.lifecycle?.kind === "indexeddb") {
+    return storage.lifecycle.establishSessionStamp(principal, { consentAnchor: anchor });
+  }
+  if (storage.kind === "sqlite" && storage.lifecycle?.kind === "file") {
+    return storage.lifecycle.establishSessionStamp(principal, { consentAnchor: anchor });
+  }
+  throw Object.assign(new Error("Replica sign-in requires its platform lifecycle gate."), {
+    code: "REPLICA_GATED",
+    gate: "gate_unavailable"
+  });
+}
+function restoreReplicaSessionStamp(storage, principal, persisted) {
+  if (storage.kind === "indexeddb" && storage.lifecycle?.kind === "indexeddb") {
+    return storage.lifecycle.restoreSessionStamp(principal, persisted);
+  }
+  if (storage.kind === "sqlite" && storage.lifecycle?.kind === "file") {
+    return storage.lifecycle.restoreSessionStamp(principal, persisted);
+  }
+  throw Object.assign(new Error("Replica restore requires its platform lifecycle gate."), {
+    code: "REPLICA_GATED",
+    gate: "gate_unavailable"
+  });
+}
 function replicationEntries(spaceId, prefix) {
   return [{
     service: KV_SERVICE2,
@@ -17394,6 +17559,20 @@ function ucanAttCovers(att, space, prefix, ability, options) {
 function ucanAttUnconstrainedFor(att, space, prefix) {
   return ucanAttCovers(att, space, prefix, KV_GET2) && ucanAttCovers(att, space, prefix, KV_SYNC2);
 }
+async function mintNodeReplicationGrant(deviceDid, entries, options, renewalSession, node) {
+  if (options?.renewalOnly && !renewalSession) throw new Error("replication renewal lost its owner session");
+  const delegateOptions = options?.renewalOnly ? {
+    expiry: options.expiryMs,
+    onPrepared: async (prepared) => {
+      assertRenewalParent(prepared.delegationHeader.Authorization, renewalSession);
+    }
+  } : options?.expiryMs === void 0 ? void 0 : { expiry: options.expiryMs };
+  const result = await node.delegateTo(principalDid(deviceDid), entries, delegateOptions);
+  return {
+    ucan: result.delegation.delegationHeader.Authorization,
+    expiresAt: result.delegation.expiry.getTime()
+  };
+}
 function replicationScopeFromSignedSession(input) {
   let grant;
   try {
@@ -17411,9 +17590,28 @@ function replicationScopeFromSignedSession(input) {
   }
   return void 0;
 }
+function assertRenewalParent(authorization, session) {
+  const grant = parseUcanGrant(authorization);
+  if (grant.issuer !== session.verificationMethod.split("#", 1)[0] || grant.prf.length !== 1 || grant.prf[0] !== session.delegationCid) {
+    throw Object.assign(new Error("replication renewal requires the bound owner session parent"), { refused: "NOT_COVERED" });
+  }
+}
 function createReplicationAuthority(host) {
-  const planOrRefusal = (entries) => {
-    const plan = host.planDelegation(entries);
+  const boundSession = host.replicationSession();
+  let verifiedAnchor = null;
+  try {
+    const candidate = boundSession && host.verifiedConsentAnchor?.(boundSession);
+    if (candidate && Number.isFinite(candidate.at) && candidate.source !== "first_install") {
+      verifiedAnchor = { at: candidate.at, source: candidate.source };
+    }
+  } catch {
+  }
+  const activeSession = () => {
+    const session = host.replicationSession();
+    return session !== void 0 && session === boundSession ? session : void 0;
+  };
+  const planOrRefusal = (entries, expiryMs) => {
+    const plan = host.planDelegation(entries, expiryMs === void 0 ? void 0 : { expiry: expiryMs });
     if ("refused" in plan) return plan;
     return { path: plan.path, parentCid: plan.parentCid, expiresAt: plan.expiresAt };
   };
@@ -17425,12 +17623,20 @@ function createReplicationAuthority(host) {
   };
   const authority = {
     get sessionOnly() {
-      const session = host.replicationSession();
-      return session !== void 0 && session.siwe === void 0;
+      const session = activeSession();
+      return session === void 0 || session.siwe === void 0;
+    },
+    consentAnchor() {
+      return activeSession() ? verifiedAnchor : null;
+    },
+    get canRenew() {
+      const session = activeSession();
+      return verifiedAnchor?.source === "siwe" && session !== void 0 && session.siwe !== void 0;
     },
     sessionGrant(prefix) {
-      const session = host.replicationSession();
+      const session = activeSession();
       if (session === void 0) return { refused: "SESSION_EXPIRING" };
+      if (verifiedAnchor === null && session.siwe !== void 0) return { refused: "NOT_COVERED" };
       const siweExpiry = session.siwe ? host.siweExpiration(session.siwe)?.getTime() : void 0;
       if (siweExpiry !== void 0 && siweExpiry <= Date.now() + AUTHORITY_EXPIRY_MARGIN_MS) {
         return { refused: "SESSION_EXPIRING" };
@@ -17458,8 +17664,9 @@ function createReplicationAuthority(host) {
       };
     },
     plan(prefix) {
-      const session = host.replicationSession();
+      const session = activeSession();
       if (session === void 0) return { refused: "SESSION_EXPIRING" };
+      if (verifiedAnchor === null) return { refused: "NOT_COVERED" };
       const sessionGrant = this.sessionGrant(prefix);
       if (!("refused" in sessionGrant)) {
         const signed2 = signedSessionGrant(session);
@@ -17473,26 +17680,30 @@ function createReplicationAuthority(host) {
       if (authority.sessionOnly) return sessionGrant;
       return planOrRefusal(replicationEntries(session.spaceId, prefix));
     },
-    async mint(deviceDid, prefix, signal) {
-      if (authority.sessionOnly) throw new Error("compact delegate sessions cannot mint device grants");
-      const session = host.replicationSession();
-      if (session === void 0) throw new Error("replication mint without a session");
+    async mint(deviceDid, prefix, signal, options) {
+      const session = activeSession();
+      if (session === void 0) throw new Error("replication mint without the bound session");
+      if (session.siwe === void 0) throw new Error("compact delegate sessions cannot mint device grants");
+      if (verifiedAnchor?.source !== "siwe") throw new Error("replication mint requires verified owner consent");
       const entries = replicationEntries(session.spaceId, prefix);
-      const plan = planOrRefusal(entries);
+      const plan = planOrRefusal(entries, options?.expiryMs);
       if ("refused" in plan) {
         throw Object.assign(
           new Error(`replication authority refused the mint: ${plan.refused}`),
           { refused: plan.refused }
         );
       }
+      if (options?.renewalOnly && plan.path !== "session") {
+        throw Object.assign(new Error("replication renewal requires a session parent"), { refused: "NOT_COVERED" });
+      }
       signal.throwIfAborted();
-      const minted = await new Promise((resolve, reject2) => {
+      const minted = await new Promise((resolve2, reject2) => {
         const onAbort = () => reject2(signal.reason ?? new Error("replication mint aborted"));
         signal.addEventListener("abort", onAbort, { once: true });
-        host.mintDelegation(deviceDid, entries).then(
+        host.mintDelegation(deviceDid, entries, options).then(
           (result) => {
             signal.removeEventListener("abort", onAbort);
-            resolve(result);
+            resolve2(result);
           },
           (error) => {
             signal.removeEventListener("abort", onAbort);
@@ -17519,6 +17730,77 @@ var init_authority = __esm({
   }
 });
 
+// src/replication/gated-network.ts
+var gated_network_exports = {};
+__export(gated_network_exports, {
+  createGatedNetworkReadThrough: () => createGatedNetworkReadThrough
+});
+import { kvPrefixCovers as kvPrefixCovers2 } from "@tinycloud/sdk-services/kv/replication/prefix";
+function createGatedNetworkReadThrough(input) {
+  const report = (op, space, path, replica, reason, outcome, latencyMs) => input.emit({
+    type: "replication.read",
+    at: new Date(input.now()).toISOString(),
+    op,
+    space,
+    key: path,
+    replica,
+    source: reason === "cursor_restart" ? "none" : "network",
+    reason,
+    outcome,
+    latencyMs,
+    stalenessMs: null,
+    coverage: null,
+    authority: null,
+    ...reason === "replica_gated" ? { code: "REPLICA_GATED" } : {}
+  });
+  const readNetwork = async (r2, op, path, prefix, reason) => {
+    const started = input.now();
+    let outcome = "error";
+    try {
+      const result = await r2.network();
+      outcome = result.ok ? "found" : op === "get" && reason === "not_covered" && "error" in result && result.error.code === "KV_NOT_FOUND" ? "not_found" : "error";
+      return result;
+    } finally {
+      report(op, r2.space, path, prefix, reason, outcome, input.now() - started);
+    }
+  };
+  const covered = (path) => input.prefixes.find((prefix) => kvPrefixCovers2(prefix, path));
+  return {
+    get: (r2) => {
+      if (r2.space !== input.space) return r2.network();
+      if (r2.options?.source === "network") return readNetwork(r2, "get", r2.path, null, "NETWORK_REQUESTED");
+      const prefix = covered(r2.path);
+      return readNetwork(r2, "get", r2.path, prefix ?? null, prefix === void 0 ? "not_covered" : "replica_gated");
+    },
+    list: (r2) => {
+      if (r2.space !== input.space) return r2.network();
+      if (r2.options?.source === "network") return readNetwork(r2, "list", r2.listPath, null, "NETWORK_REQUESTED");
+      if (r2.options?.cursor?.startsWith("tcr1.")) {
+        report("list", r2.space, r2.listPath, null, "cursor_restart", "error", 0);
+        return Promise.resolve({ ok: false, error: {
+          code: "INVALID_INPUT",
+          message: "Local list cursor cannot be served; restart without the cursor",
+          service: "kv",
+          meta: { replication: "cursor_restart" }
+        } });
+      }
+      if (r2.options?.cursor) return readNetwork(r2, "list", r2.listPath, null, "network_cursor");
+      if (r2.options?.raw) return readNetwork(r2, "list", r2.listPath, null, "unsupported_option");
+      const prefix = covered(r2.listPath);
+      return readNetwork(r2, "list", r2.listPath, prefix ?? null, prefix === void 0 ? "not_covered" : "replica_gated");
+    },
+    write: (r2) => r2.network(),
+    observeNetworkRequested: (r2) => {
+      if (r2.space === input.space) report(r2.op, r2.space, r2.path, null, r2.reason, r2.outcome, r2.latencyMs);
+    }
+  };
+}
+var init_gated_network = __esm({
+  "src/replication/gated-network.ts"() {
+    "use strict";
+  }
+});
+
 // src/NodeWasmBindings.ts
 import {
   invoke,
@@ -18205,7 +18487,6 @@ function deserializeDelegation(data) {
 }
 
 // src/TinyCloudNode.ts
-init_config();
 import { generateNonce, SiweMessage as SiweMessage3 } from "siwe";
 
 // src/replication/module-registry.ts
@@ -18224,7 +18505,7 @@ function getNodeReplicationLoaders() {
 import {
   TinyCloud,
   checkNodeInfo as checkNodeInfo2,
-  VersionCheckError,
+  ProtocolMismatchError,
   activateSessionWithHost as activateSessionWithHost2,
   authorizationVerdictOf,
   httpResponseError,
@@ -18275,7 +18556,6 @@ import {
   verifyDidKeyEd25519Signature,
   canonicalizeAddress as canonicalizeAddress2,
   pkhDid as pkhDid2,
-  principalDid,
   resolveTinyCloudHosts as resolveTinyCloudHosts2,
   publishLocationRecord,
   principalDidEquals as principalDidEquals3,
@@ -18541,6 +18821,7 @@ var NodeUserAuthorization = class {
     this.siweConfig = config.siweConfig;
     this.includeAccountRegistryPermissions = config.includeAccountRegistryPermissions ?? true;
     this.replication = config.replication?.enabled === true ? config.replication : void 0;
+    this.establishReplicaStamp = config.establishReplicaStamp;
     this._manifest = config.manifest;
     this._capabilityRequest = config.capabilityRequest;
     this.sessionManager = config.sessionManager ?? this.wasm.createSessionManager();
@@ -19171,7 +19452,7 @@ var NodeUserAuthorization = class {
         );
         throw error;
       }
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await new Promise((resolve2) => setTimeout(resolve2, 100));
       const retryResult = await activateSessionWithHost(
         host,
         this._tinyCloudSession.delegationHeader
@@ -19211,7 +19492,7 @@ var NodeUserAuthorization = class {
         );
         throw error;
       }
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await new Promise((resolve2) => setTimeout(resolve2, 100));
       const retryResult = await activateSessionWithHost(
         host,
         this._tinyCloudSession.delegationHeader
@@ -19310,6 +19591,27 @@ var NodeUserAuthorization = class {
       signature: signature2
     };
   }
+  persistedData(session, expiresAt, createdAt, replicaStamp) {
+    return {
+      address: session.address,
+      chainId: session.chainId,
+      sessionKey: JSON.stringify(session.jwk),
+      siwe: session.siwe,
+      signature: session.signature,
+      tinycloudSession: {
+        delegationHeader: session.delegationHeader,
+        delegationCid: session.delegationCid,
+        spaceId: session.spaceId,
+        spaces: session.spaces,
+        verificationMethod: session.verificationMethod
+      },
+      expiresAt,
+      createdAt,
+      version: "1.0",
+      tinycloudHosts: this.tinycloudHosts,
+      ...replicaStamp ? { replicaStamp } : {}
+    };
+  }
   /**
    * Sign in and create a new session.
    *
@@ -19389,24 +19691,13 @@ var NodeUserAuthorization = class {
       siwe: prepared.siwe,
       signature: signature2
     };
-    const persistedData = {
-      address,
-      chainId,
-      sessionKey: JSON.stringify(jwk),
-      siwe: prepared.siwe,
-      signature: signature2,
-      tinycloudSession: {
-        delegationHeader: session.delegationHeader,
-        delegationCid: session.delegationCid,
-        spaceId,
-        spaces: spacesMetadata,
-        verificationMethod: this.sessionManager.getDID(keyId)
-      },
-      expiresAt: expirationTime.toISOString(),
-      createdAt: now.toISOString(),
-      version: "1.0",
-      tinycloudHosts: this.tinycloudHosts
-    };
+    const replicaStamp = await this.establishReplicaStamp?.(tinyCloudSession);
+    const persistedData = this.persistedData(
+      tinyCloudSession,
+      expirationTime.toISOString(),
+      now.toISOString(),
+      replicaStamp
+    );
     await this.enqueuePersistence(async () => {
       await this.sessionStorage.save(address, persistedData);
       if (generation !== this.sessionGeneration) {
@@ -19560,28 +19851,12 @@ var NodeUserAuthorization = class {
       siwe: prepared.siwe,
       signature: signature2
     };
-    const expirationMatch = prepared.siwe.match(/Expiration Time: (.+)/);
-    const issuedAtMatch = prepared.siwe.match(/Issued At: (.+)/);
+    const expirationMatch = prepared.siwe?.match(/Expiration Time: (.+)/);
+    const issuedAtMatch = prepared.siwe?.match(/Issued At: (.+)/);
     const expiresAt = expirationMatch?.[1] ?? new Date(Date.now() + this.sessionExpirationMs).toISOString();
     const createdAt = issuedAtMatch?.[1] ?? (/* @__PURE__ */ new Date()).toISOString();
-    const persistedData = {
-      address,
-      chainId,
-      sessionKey: JSON.stringify(jwk),
-      siwe: prepared.siwe,
-      signature: signature2,
-      tinycloudSession: {
-        delegationHeader: session.delegationHeader,
-        delegationCid: session.delegationCid,
-        spaceId: prepared.spaceId,
-        spaces: spacesMetadata,
-        verificationMethod: this.sessionManager.getDID(keyId)
-      },
-      expiresAt,
-      createdAt,
-      version: "1.0",
-      tinycloudHosts: this.tinycloudHosts
-    };
+    const replicaStamp = await this.establishReplicaStamp?.(tinyCloudSession);
+    const persistedData = this.persistedData(tinyCloudSession, expiresAt, createdAt, replicaStamp);
     await this.sessionStorage.save(address, persistedData);
     this._session = clientSession;
     this._tinyCloudSession = tinyCloudSession;
@@ -19644,15 +19919,36 @@ var NodeUserAuthorization = class {
     const { prepared, keyId, jwk } = await this.prepareSessionForSigning();
     const presentation = this.buildPresentationEnvelope(options?.reason);
     const hostHint = this.primaryTinyCloudHost;
-    const result = await authorizeFn({
+    const originalRequest = {
       protocolVersion: 1,
       siwe: prepared.siwe,
       jwk,
+      verificationMethod: prepared.verificationMethod,
       host: hostHint,
       keyId: options?.openkeyKeyId,
       presentation
-    });
-    return this.signInWithOpenKeyResult(result, prepared, keyId, jwk);
+    };
+    let result;
+    let signed2;
+    let signature2;
+    for (let attempt = 0; ; ) {
+      try {
+        result ?? (result = await authorizeFn(originalRequest));
+        signed2 = await this.verifyOpenKeyResult(result, prepared);
+        signature2 = result.signature;
+        break;
+      } catch (error) {
+        if (!options?.retryResult) throw error;
+        const next = await options.retryResult(
+          error instanceof Error ? error : new Error(String(error)),
+          originalRequest,
+          ++attempt
+        );
+        if (next === null) throw error;
+        result = next;
+      }
+    }
+    return this.signInWithPreparedSession(signed2, signature2, keyId, jwk);
   }
   /**
    * Build a `CapabilityPresentationEnvelopeV1` from `this._manifest`. The
@@ -19732,6 +20028,11 @@ var NodeUserAuthorization = class {
    *    (resource, action) pair in the returned SIWE.
    */
   async signInWithOpenKeyResult(result, prepared, keyId, jwk) {
+    const signed2 = await this.verifyOpenKeyResult(result, prepared);
+    return this.signInWithPreparedSession(signed2, result.signature, keyId, jwk);
+  }
+  /** Validate a candidate without activating a network session, so paste retries reuse one preparation. */
+  async verifyOpenKeyResult(result, prepared) {
     if (result.protocolVersion !== 1) {
       throw new Error(`Unsupported OpenKey protocol version ${result.protocolVersion}`);
     }
@@ -19976,17 +20277,12 @@ var NodeUserAuthorization = class {
       }
     }
     void nonRequiredGrantedPairs;
-    return this.signInWithPreparedSession(
-      {
-        siwe: result.signedMessage,
-        jwk: prepared.jwk,
-        spaceId: prepared.spaceId,
-        verificationMethod: prepared.verificationMethod
-      },
-      result.signature,
-      keyId,
-      jwk
-    );
+    return {
+      siwe: result.signedMessage,
+      jwk: prepared.jwk,
+      spaceId: prepared.spaceId,
+      verificationMethod: prepared.verificationMethod
+    };
   }
   /**
    * Clear persisted session data.
@@ -20038,7 +20334,7 @@ var NodeUserAuthorization = class {
    * Request signature via event emitter with timeout.
    */
   requestSignatureViaEmitter(request, emitter, timeout) {
-    return new Promise((resolve, reject2) => {
+    return new Promise((resolve2, reject2) => {
       const timeoutId = setTimeout(() => {
         reject2(new Error("Sign request timed out"));
       }, timeout);
@@ -20050,7 +20346,7 @@ var NodeUserAuthorization = class {
           );
         } else {
           const signature2 = response.signature ?? await this.signer.signMessage(request.message);
-          resolve(signature2);
+          resolve2(signature2);
         }
       };
       emitter.emit("sign-request", request, respond);
@@ -20982,6 +21278,20 @@ function accountIndexWarningDiagnostic(error) {
   }
   return diagnostic;
 }
+function replicaRestoreRefusal(error) {
+  if (error !== null && typeof error === "object" && "code" in error && error.code === "REPLICA_GATED" && "gate" in error) {
+    switch (error.gate) {
+      case "not_established":
+      case "stamp_stale":
+      case "principal_mismatch":
+      case "purge_pending":
+      case "logout_pending":
+      case "gate_unavailable":
+        return error.gate;
+    }
+  }
+  return "gate_unavailable";
+}
 var _TinyCloudNode = class _TinyCloudNode {
   /**
    * Create a new TinyCloudNode instance.
@@ -21011,6 +21321,37 @@ var _TinyCloudNode = class _TinyCloudNode {
     this.auth = null;
     this.tc = null;
     this._chainId = 1;
+    /** 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;
+      if (!replication?.enabled) return void 0;
+      const epoch = this.sessionEpoch;
+      const attempt = this.latestSessionAttempt;
+      try {
+        const { verifiedOwnerConsentAnchor: verifiedOwnerConsentAnchor2, establishReplicaSessionStamp: establishReplicaSessionStamp2 } = await getNodeReplicationLoaders().authority();
+        if (epoch !== this.sessionEpoch || attempt !== this.latestSessionAttempt) return void 0;
+        const anchor = verifiedOwnerConsentAnchor2(session, this.wasmBindings, exactVerifiedRecap);
+        if (anchor === null) {
+          throw Object.assign(new Error("Replica sign-in requires a verified finite owner SIWE and exact-space KV get+sync."), {
+            code: "REPLICA_GATED",
+            gate: "not_established"
+          });
+        }
+        const stamp = await establishReplicaSessionStamp2(
+          replication.storage,
+          pkhDid2(session.address, session.chainId),
+          anchor
+        );
+        if (epoch !== this.sessionEpoch || attempt !== this.latestSessionAttempt) return void 0;
+        this.replicaSessionStamp = stamp;
+        return stamp;
+      } catch (error) {
+        if (epoch === this.sessionEpoch && attempt === this.latestSessionAttempt) {
+          this.replicaRestoreGate = replicaRestoreRefusal(error);
+        }
+        return void 0;
+      }
+    };
     this._baseVaults = /* @__PURE__ */ new Map();
     this._baseSecrets = /* @__PURE__ */ new Map();
     this._secrets = /* @__PURE__ */ new Map();
@@ -21135,7 +21476,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       });
       return this.wasmBindings.invokeAny(invocationSession, caveatPreservingEntries, facts);
     };
-    assertValidReplicationConfig(config.replication);
+    if (config.replication?.enabled) getNodeReplicationLoaders().validateConfig(config.replication);
     this.explicitHost = config.host;
     this.config = {
       ...config,
@@ -21150,6 +21491,16 @@ var _TinyCloudNode = class _TinyCloudNode {
       this.replicationRuntime = runtime;
       this.replicationControl = {
         status: async () => {
+          const gate = this.replicaRestoreGate;
+          if (gate) return this.config.replication.prefixes.map((prefix) => ({
+            prefix,
+            state: "gated",
+            gate,
+            errorCode: "REPLICA_GATED",
+            pending: { inFlight: 0, committed: 0, ambiguous: 0 },
+            pinned: [],
+            lagMs: null
+          }));
           const status = await runtime.then((ready) => ready.control.status());
           const scopeError = this.replicationScopeError;
           if (!scopeError) return status;
@@ -21166,7 +21517,15 @@ var _TinyCloudNode = class _TinyCloudNode {
             lagMs: null
           }));
         },
-        sync: async (input) => (await runtime).control.sync(input),
+        sync: async (input) => {
+          if (this.replicaRestoreGate) {
+            throw Object.assign(new Error("Replica restore is gated."), {
+              code: "REPLICA_GATED",
+              gate: this.replicaRestoreGate
+            });
+          }
+          return (await runtime).control.sync(input);
+        },
         purge: (input) => {
           const instance = this.replicationRuntimeInstance;
           return instance ? instance.control.purge(input) : runtime.then((ready) => ready.control.purge(input));
@@ -21382,6 +21741,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       signer: this.signer,
       signStrategy: config.signStrategy ?? { type: "auto-sign" },
       wasmBindings: this.wasmBindings,
+      ...config.replication?.enabled === true ? { establishReplicaStamp: this.establishReplicaStamp } : {},
       sessionManager: this.sessionManager,
       sessionStorage: config.sessionStorage ?? new MemorySessionStorage(),
       domain: this.siweDomain,
@@ -21579,11 +21939,10 @@ var _TinyCloudNode = class _TinyCloudNode {
     return this.signer === null;
   }
   /**
-   * Get the space ID for this user.
-   * Available after signIn().
+   * Primary space of the signed-in or restored network session, including compact sessions.
    */
   get spaceId() {
-    return this.auth?.tinyCloudSession?.spaceId;
+    return this.auth?.tinyCloudSession?.spaceId ?? this._activeServiceSession?.spaceId;
   }
   /**
    * Get the account space ID for this wallet identity.
@@ -21631,6 +21990,12 @@ var _TinyCloudNode = class _TinyCloudNode {
   get restorableSession() {
     return this.currentTinyCloudSession();
   }
+  /** The active, verified replica stamp. Undefined when the replica is refused or the session has ended. */
+  get replicaStamp() {
+    const stamp = this.replicaSessionStamp;
+    if (!stamp || this.replicaRestoreGate !== void 0 || !this.currentTinyCloudSession()) return void 0;
+    return { incarnation: stamp.incarnation, lifecycleEpoch: stamp.lifecycleEpoch };
+  }
   /**
    * Sign out and end the session on this instance.
    *
@@ -21651,18 +22016,60 @@ var _TinyCloudNode = class _TinyCloudNode {
   }
   async endSession() {
     const leavingAddress = this.address ?? this._restoredTcSession?.address;
+    const leavingChainId = this._chainId;
+    const leavingPrincipal = this.replicaSessionPrincipal ?? (leavingAddress ? pkhDid2(leavingAddress, leavingChainId) : void 0);
     const leavingAuth = this.auth;
+    const leavingContext = this._serviceContext;
+    let denied;
     try {
       this.teardownSession();
     } finally {
+      const denial = leavingPrincipal ? this.denyReplicaGate({ reason: "sign_out", principal: leavingPrincipal }, leavingContext) : Promise.resolve(void 0);
       try {
-        await this.accountRegistryTail;
-        if (this.replicationRuntime) await (await this.replicationRuntime).unbind();
+        denied = await denial;
       } finally {
-        if (leavingAddress) {
-          await (leavingAuth ? leavingAuth.clearPersistedSession(leavingAddress) : this.config.sessionStorage?.clear(leavingAddress));
+        try {
+          await this.accountRegistryTail;
+          await this.quiesceReplicaRuntime();
+        } finally {
+          if (leavingAddress) {
+            await (leavingAuth ? leavingAuth.clearPersistedSession(leavingAddress) : this.config.sessionStorage?.clear(leavingAddress));
+          }
+        }
+      }
+    }
+    if (denied?.status === "unguarded") {
+      throw new Error(`Replica gate was not denied (${denied.code ?? "unknown"}); the replica may still be restorable.`);
+    }
+  }
+  /**
+   * Step 1 of replica sign-out. Never rejects: failures come back as `unguarded` so the session
+   * is still cleared. Returns `undefined` when replication is off.
+   */
+  async denyReplicaGate(input, context = this._serviceContext) {
+    const replication = this.config.replication;
+    if (!replication?.enabled) return void 0;
+    try {
+      const lifecycle = replication.storage.lifecycle;
+      if (lifecycle?.kind !== (replication.storage.kind === "indexeddb" ? "indexeddb" : "file")) {
+        return { status: "unguarded", code: "gate_unavailable" };
+      }
+      const result = await lifecycle.deny(input);
+      if (result.status === "denied" || result.status === "deleted" || result.status === "marker") {
+        try {
+          (await getNodeReplicationLoaders().authority()).reportReplicaDenial(
+            result,
+            input.reason,
+            replication.onEvent,
+            context
+          );
+        } catch {
         }
       }
+      return result;
+    } catch (error) {
+      const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : "gate_unavailable";
+      return { status: "unguarded", code };
     }
   }
   /**
@@ -21682,15 +22089,9 @@ var _TinyCloudNode = class _TinyCloudNode {
     this._activeServiceSession = void 0;
     oldGraph.retire();
     oldCore?.retireServices();
-    oldAuth?.resetSession(
-      this.sessionManager,
-      this.sessionKeyId,
-      this.explicitHost ? [this.explicitHost] : void 0
-    );
     this.config.host = this.explicitHost ?? DEFAULT_HOST;
     this._chainId = 1;
     this._restoredNodeFeatures = void 0;
-    this._activeServiceSession = void 0;
     this._serviceContext = void 0;
     this._kv = void 0;
     this._sql = void 0;
@@ -21715,6 +22116,9 @@ var _TinyCloudNode = class _TinyCloudNode {
     this._bootstrapStatus = { skipped: false };
     this.replicationDelegateSession = void 0;
     this.replicationScopeError = void 0;
+    this.replicaSessionPrincipal = void 0;
+    this.replicaSessionStamp = void 0;
+    this.replicaRestoreGate = void 0;
     const sessionKey = createDefaultSessionKey(this.wasmBindings);
     this.sessionManager = sessionKey.manager;
     this.sessionKeyId = sessionKey.keyId;
@@ -21724,6 +22128,9 @@ var _TinyCloudNode = class _TinyCloudNode {
       sessionKey.keyId,
       this.explicitHost ? [this.explicitHost] : void 0
     );
+    this.replicaSessionPrincipal = void 0;
+    this.replicaSessionStamp = void 0;
+    this.replicaRestoreGate = void 0;
     this._serviceGraph = this.createServiceGraphLifetime();
     this.auth = oldAuth;
     this.tc = this.auth ? new TinyCloud(this.auth, {
@@ -21753,11 +22160,25 @@ var _TinyCloudNode = class _TinyCloudNode {
         "Cannot signIn() in session-only mode. Provide a privateKey in config to create your own space."
       );
     }
+    await this.signInWith(() => this.tc.signIn(options));
+  }
+  /**
+   * Fresh OpenKey sign-in. The callback receives the SDK's original SIWE and
+   * session JWK before approval; the signed result is verified against those
+   * bytes before the network session or replica stamp is committed.
+   */
+  async signInWithOpenKey(authorizeFn, options) {
+    if (!this.signer || !this.tc || !this.auth) {
+      throw new Error("Cannot signInWithOpenKey() in session-only mode. Provide a signer in config.");
+    }
+    await this.signInWith(() => this.auth.signInWithOpenKey(authorizeFn, options));
+  }
+  async signInWith(performSignIn) {
     const epoch = this.sessionEpoch;
     const attempt = ++this.latestSessionAttempt;
     await this.signOutInFlight;
     try {
-      await this.establishSignIn(epoch, options);
+      await this.establishSignIn(epoch, performSignIn);
     } catch (error) {
       if (epoch !== this.sessionEpoch && attempt === this.latestSessionAttempt) {
         await this.endSession();
@@ -21765,7 +22186,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       throw error;
     }
   }
-  async establishSignIn(epoch, options) {
+  async establishSignIn(epoch, performSignIn) {
     if (!this.signer || !this.tc) {
       throw new Error("Not signed in. Call signIn() first.");
     }
@@ -21775,6 +22196,12 @@ var _TinyCloudNode = class _TinyCloudNode {
     const address = canonicalizeAddress2(await this.signer.getAddress());
     const chainId = await this.signer.getChainId();
     this.assertSessionEpoch(epoch, "Sign-in");
+    const nextPrincipal = pkhDid2(address, chainId);
+    const priorPrincipal = this.replicaSessionPrincipal ?? (this.address ? pkhDid2(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 });
+      this.replicaRestoreGate = denial?.status === "unguarded" ? "gate_unavailable" : "stamp_stale";
+    }
     if (address !== this._address || chainId !== this._chainId) this.storageFull.clear();
     this._address = address;
     this._chainId = chainId;
@@ -21792,7 +22219,20 @@ var _TinyCloudNode = class _TinyCloudNode {
     this.runtimePermissionGrants = [];
     this.confirmedHostedSpaceIds.clear();
     this.hostedOwnedSpaceIds.clear();
-    await this.tc.signIn(options);
+    const signInAttempt = this.latestSessionAttempt;
+    const previousReplicaGate = this.replicaRestoreGate;
+    const previousReplicaStamp = this.replicaSessionStamp;
+    this.replicaRestoreGate = void 0;
+    this.replicaSessionStamp = void 0;
+    try {
+      await performSignIn();
+    } catch (error) {
+      if (epoch === this.sessionEpoch && signInAttempt === this.latestSessionAttempt) {
+        this.replicaRestoreGate = previousReplicaGate;
+        this.replicaSessionStamp = previousReplicaStamp;
+      }
+      throw error;
+    }
     this.assertSessionEpoch(epoch, "Sign-in");
     this.cancelOwnedSpaceHosts();
     this.syncResolvedHostFromAuth();
@@ -21800,8 +22240,9 @@ var _TinyCloudNode = class _TinyCloudNode {
       this.hostedOwnedSpaceIds.add(spaceId);
     }
     this.replicationDelegateSession = void 0;
+    this.replicaSessionPrincipal = pkhDid2(address, chainId);
     this.replicationScopeError = void 0;
-    if (this.replicationRuntime) await (await this.replicationRuntime).unbind();
+    await this.quiesceReplicaRuntime();
     this.assertSessionEpoch(epoch, "Sign-in");
     const oldGraph = this._serviceGraph;
     this._serviceGraph = this.createServiceGraphLifetime();
@@ -22053,7 +22494,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         );
       }
     }
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    await new Promise((resolve2) => setTimeout(resolve2, 100));
     for (const step of steps) {
       if (step.kind !== "activate") continue;
       graph.assertActive();
@@ -22388,6 +22829,9 @@ var _TinyCloudNode = class _TinyCloudNode {
     if (this.ownStorageFull) {
       return;
     }
+    if (!this.currentSessionCoversAccountRegistry()) {
+      return;
+    }
     const controller = new AbortController();
     const deadline = setTimeout(
       () => controller.abort(new DOMException("Account registry deadline exceeded", "TimeoutError")),
@@ -22502,6 +22946,27 @@ var _TinyCloudNode = class _TinyCloudNode {
       (operation) => operation.service === "space" && this.actionContains(operation.action, "tinycloud.space/list")
     );
   }
+  /**
+   * Whether the current primary session's recap covers the account index read
+   * (`tinycloud.sql/read` on the owned account space's `account` database),
+   * the first call of every registry sync. As in
+   * {@link currentSessionCanListSpaces}, a session with no parseable recap
+   * keeps today's behavior.
+   */
+  currentSessionCoversAccountRegistry() {
+    const session = this.currentTinyCloudSession();
+    const operations = session ? this.recapOperationsFromSession(session) : [];
+    if (operations.length === 0) {
+      return true;
+    }
+    const indexRead = {
+      spaceId: this.ownedSpaceId(ACCOUNT_REGISTRY_SPACE2),
+      service: "sql",
+      path: "account",
+      action: "tinycloud.sql/read"
+    };
+    return operations.some((granted) => this.operationCovers(granted, indexRead));
+  }
   async withAccountRegistryRetry(task, signal) {
     const delays = [250, 1e3, 3e3];
     const stopped = (detail) => {
@@ -22542,10 +23007,10 @@ var _TinyCloudNode = class _TinyCloudNode {
         }
         lastError = error;
         if (attempt < delays.length - 1) {
-          await new Promise((resolve, reject2) => {
+          await new Promise((resolve2, reject2) => {
             const timer = setTimeout(() => {
               signal.removeEventListener("abort", onAbort);
-              resolve();
+              resolve2();
             }, delays[attempt]);
             const onAbort = () => {
               clearTimeout(timer);
@@ -22785,7 +23250,7 @@ var _TinyCloudNode = class _TinyCloudNode {
     }
     entry.waiters += 1;
     const shared = entry;
-    return new Promise((resolve, reject2) => {
+    return new Promise((resolve2, reject2) => {
       const onAbort = () => {
         reject2(signal.reason);
         shared.waiters -= 1;
@@ -22794,7 +23259,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         if (this.ownedSpaceHosts.get(spaceId) === shared) this.ownedSpaceHosts.delete(spaceId);
       };
       signal.addEventListener("abort", onAbort, { once: true });
-      shared.promise.then(resolve, reject2).finally(() => signal.removeEventListener("abort", onAbort));
+      shared.promise.then(resolve2, reject2).finally(() => signal.removeEventListener("abort", onAbort));
     });
   }
   /** Session replacement: cancel the replaced session's in-flight hosts and forget them. */
@@ -22968,11 +23433,12 @@ var _TinyCloudNode = class _TinyCloudNode {
     );
     const stagedHost = resolvedHost ?? this.config.host;
     let restoredNodeFeatures;
+    let replicaProtocolMismatch = false;
     if (this.config.replication?.enabled) {
       try {
         restoredNodeFeatures = (await checkNodeInfo2(stagedHost, this.wasmBindings.protocolVersion())).features;
       } catch (error) {
-        if (!(error instanceof VersionCheckError)) throw error;
+        replicaProtocolMismatch = error instanceof ProtocolMismatchError;
       }
     }
     const stagedAddress = restoredAddress;
@@ -22980,28 +23446,55 @@ var _TinyCloudNode = class _TinyCloudNode {
     let replicationPrincipal;
     let compactReplicationSession;
     let replicationScopeError;
+    let replicationScopeUnavailable = false;
     if (this.config.replication?.enabled) {
       if (stagedAddress !== void 0) {
         replicationPrincipal = pkhDid2(stagedAddress, stagedChainId);
       } else {
-        const { replicationScopeFromSignedSession: replicationScopeFromSignedSession2 } = await getNodeReplicationLoaders().authority();
-        const signedScope = replicationScopeFromSignedSession2({
-          delegationHeader: sessionData.delegationHeader,
-          delegationCid: sessionData.delegationCid,
-          verificationMethod: restoredVerificationMethod,
-          persistedSpace: sessionData.spaceId
-        });
-        if (!signedScope) {
-          replicationScopeError = "Persisted space does not match the locally verified delegation scope.";
-        } else {
-          replicationPrincipal = signedScope.principal;
-          compactReplicationSession = {
+        try {
+          const { replicationScopeFromSignedSession: replicationScopeFromSignedSession2 } = await getNodeReplicationLoaders().authority();
+          const signedScope = replicationScopeFromSignedSession2({
             delegationHeader: sessionData.delegationHeader,
             delegationCid: sessionData.delegationCid,
-            spaceId: signedScope.space,
             verificationMethod: restoredVerificationMethod,
-            jwk: stagedJwk
-          };
+            persistedSpace: sessionData.spaceId
+          });
+          if (!signedScope) {
+            replicationScopeError = "Persisted space does not match the locally verified delegation scope.";
+          } else {
+            replicationPrincipal = signedScope.principal;
+            compactReplicationSession = {
+              delegationHeader: sessionData.delegationHeader,
+              delegationCid: sessionData.delegationCid,
+              spaceId: signedScope.space,
+              verificationMethod: restoredVerificationMethod,
+              jwk: stagedJwk
+            };
+          }
+        } catch {
+          replicationScopeUnavailable = true;
+          replicationScopeError = "Replica scope could not be verified for this network session.";
+        }
+      }
+    }
+    let replicaRestoreGate;
+    let restoredReplicaStamp;
+    const replication = this.config.replication;
+    if (replication?.enabled) {
+      if (replicaProtocolMismatch) {
+        replicaRestoreGate = "gate_unavailable";
+      } else if (replicationPrincipal === void 0) {
+        replicaRestoreGate = replicationScopeUnavailable ? "gate_unavailable" : "principal_mismatch";
+      } else {
+        try {
+          const { restoreReplicaSessionStamp: restoreReplicaSessionStamp2 } = await getNodeReplicationLoaders().authority();
+          restoredReplicaStamp = await restoreReplicaSessionStamp2(
+            replication.storage,
+            replicationPrincipal,
+            sessionData.replicaStamp ?? void 0
+          );
+        } catch (error) {
+          replicaRestoreGate = replicaRestoreRefusal(error);
         }
       }
     }
@@ -23094,7 +23587,10 @@ var _TinyCloudNode = class _TinyCloudNode {
     }
     this.replicationDelegateSession = compactReplicationSession;
     this.replicationScopeError = replicationScopeError;
-    if (this.replicationRuntime) await (await this.replicationRuntime).unbind();
+    this.replicaRestoreGate = replicaRestoreGate;
+    this.replicaSessionPrincipal = replicationPrincipal;
+    this.replicaSessionStamp = restoredReplicaStamp;
+    await this.quiesceReplicaRuntime();
     if (epoch !== this.sessionEpoch) {
       oldGraph.retire();
       oldCore?.retireServices?.();
@@ -23109,7 +23605,7 @@ var _TinyCloudNode = class _TinyCloudNode {
         detail: replicationScopeError
       });
     }
-    await this.bindReplicationRuntime(stagedGraph.serviceContext, serviceSession, stagedGraph.kv, replicationPrincipal);
+    await this.bindReplicaOrGate(stagedGraph.serviceContext, serviceSession, stagedGraph.kv, replicationPrincipal);
     oldCore?.retireServices?.();
     if (epoch !== this.sessionEpoch) {
       if (attempt === this.latestSessionAttempt) await this.endSession();
@@ -23242,6 +23738,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       session: input.serviceSession,
       invoke: graph.invoke,
       invokeAny: graph.invokeAny,
+      signOwnerRevocation: this.signer ? (cid) => this.signOwnerRevocation(cid) : void 0,
       fetch: graph.fetch
     });
     const keyProvider = new WasmKeyProvider({ sessionManager: input.manager });
@@ -23585,6 +24082,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       signer: this.signer,
       signStrategy: this.config.signStrategy ?? { type: "auto-sign" },
       wasmBindings: this.wasmBindings,
+      ...this.config.replication?.enabled === true ? { establishReplicaStamp: this.establishReplicaStamp } : {},
       sessionManager: this.sessionManager,
       sessionStorage: options?.sessionStorage ?? this.config.sessionStorage ?? new MemorySessionStorage(),
       domain: this.siweDomain,
@@ -23643,6 +24141,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       signer: this.signer,
       signStrategy: this.config.signStrategy ?? { type: "auto-sign" },
       wasmBindings: this.wasmBindings,
+      ...this.config.replication?.enabled === true ? { establishReplicaStamp: this.establishReplicaStamp } : {},
       sessionManager: this.sessionManager,
       sessionStorage: options?.sessionStorage ?? this.config.sessionStorage ?? new MemorySessionStorage(),
       domain: this.siweDomain,
@@ -23723,7 +24222,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       jwk: session.jwk
     };
     this._serviceContext.setSession(serviceSession);
-    await this.bindReplicationRuntime(this._serviceContext, serviceSession, this._kv);
+    await this.bindReplicaOrGate(this._serviceContext, serviceSession, this._kv);
     this.tc.serviceContext.setSession(serviceSession);
     this._vault = this.createVaultService(session.spaceId, this._kv);
     this._vault.initialize(this._serviceContext);
@@ -24117,6 +24616,7 @@ var _TinyCloudNode = class _TinyCloudNode {
       session: serviceSession,
       invoke: graph.invoke,
       invokeAny: graph.invokeAny,
+      signOwnerRevocation: this.signer ? (cid) => this.signOwnerRevocation(cid) : void 0,
       fetch: graph.fetch
     });
     this._spaceService = new SpaceService({
@@ -25409,7 +25909,8 @@ var _TinyCloudNode = class _TinyCloudNode {
     return this.delegationManager.create(params);
   }
   /**
-   * Revoke a delegation using the v2 DelegationManager.
+   * Revoke a delegation with the owner wallet when available. Session-only
+   * clients continue to use their delegated revocation authority.
    *
    * @param cid - The CID of the delegation to revoke
    * @returns Result indicating success or failure
@@ -25684,34 +26185,67 @@ var _TinyCloudNode = class _TinyCloudNode {
     return auth.replicationSignInEntries();
   }
   async replicationAuthority() {
-    const { createReplicationAuthority: createReplicationAuthority2 } = await getNodeReplicationLoaders().authority();
+    const { createReplicationAuthority: createReplicationAuthority2, mintNodeReplicationGrant: mintNodeReplicationGrant2, verifiedOwnerConsentAnchor: verifiedOwnerConsentAnchor2 } = await getNodeReplicationLoaders().authority();
     return createReplicationAuthority2({
       replicationSession: () => this.currentTinyCloudSession() ?? this.replicationDelegateSession,
+      verifiedConsentAnchor: (session) => {
+        const current = this.currentTinyCloudSession();
+        return session === current && current !== void 0 ? verifiedOwnerConsentAnchor2(current, this.wasmBindings, exactVerifiedRecap) : null;
+      },
       siweExpiration: (siwe) => extractSiweExpiration(siwe),
       planDelegation: (entries, options) => this.planDelegation(entries, options),
-      mintDelegation: async (deviceDid, entries) => {
-        const result = await this.delegateTo(principalDid(deviceDid), entries);
-        return {
-          ucan: result.delegation.delegationHeader.Authorization,
-          expiresAt: result.delegation.expiry.getTime()
-        };
-      }
+      mintDelegation: (deviceDid, entries, options) => mintNodeReplicationGrant2(
+        deviceDid,
+        entries,
+        options,
+        options?.renewalOnly ? this.currentTinyCloudSession() : void 0,
+        this
+      )
     });
   }
-  async bindReplicationRuntime(context, session, kv, principal) {
+  async quiesceReplicaRuntime() {
     if (!this.replicationRuntime) return;
-    const identityPrincipal = principal ?? (this._address === void 0 ? void 0 : pkhDid2(this._address, this._chainId));
-    if (identityPrincipal === void 0) return;
-    const runtime = await this.replicationRuntime;
-    const authority = await this.replicationAuthority();
-    await runtime.bind({
-      context,
-      session,
-      principal: identityPrincipal,
-      authority,
-      nodeFeatures: this.replicationNodeFeatures,
-      primaryKV: [{ space: session.spaceId, kv }]
-    });
+    try {
+      await (await this.replicationRuntime).unbind();
+    } catch {
+      this.replicaRestoreGate = "gate_unavailable";
+    }
+  }
+  async bindReplicaOrGate(context, session, kv, principal) {
+    if (!this.replicationRuntime) return;
+    const gate = this.replicaRestoreGate;
+    const epoch = this.sessionEpoch;
+    const attempt = this.latestSessionAttempt;
+    try {
+      const runtime = await this.replicationRuntime;
+      if (epoch !== this.sessionEpoch || attempt !== this.latestSessionAttempt || this._kv !== kv || this._serviceContext !== context || gate !== this.replicaRestoreGate) return;
+      if (gate) {
+        await runtime.bindGatedNetworkOnly({
+          context,
+          session,
+          gate,
+          primaryKV: [{ space: session.spaceId, kv }]
+        }, getNodeReplicationLoaders().gatedNetwork);
+        return;
+      }
+      const identityPrincipal = principal ?? (this._address === void 0 ? void 0 : pkhDid2(this._address, this._chainId));
+      if (identityPrincipal === void 0) return;
+      const authority = await this.replicationAuthority();
+      if (epoch !== this.sessionEpoch || attempt !== this.latestSessionAttempt || this._kv !== kv || this._serviceContext !== context) return;
+      await runtime.bind({
+        context,
+        session,
+        principal: identityPrincipal,
+        stamp: this.replicaSessionStamp,
+        authority,
+        nodeFeatures: this.replicationNodeFeatures,
+        primaryKV: [{ space: session.spaceId, kv }]
+      });
+    } catch {
+      if (epoch !== this.sessionEpoch || attempt !== this.latestSessionAttempt || this._kv !== kv || this._serviceContext !== context) return;
+      this.replicaRestoreGate = "gate_unavailable";
+      await this.quiesceReplicaRuntime();
+    }
   }
   /** Stable control facade for this node's optional replication runtime. */
   get replication() {
@@ -26860,9 +27394,16 @@ TinyCloudNode.registerNodeDefaults({
 });
 
 // src/replication/node-loader.ts
+init_config();
 registerReplicationLoaders({
+  validateConfig: assertValidReplicationConfig,
   runtime: () => Promise.resolve().then(() => (init_runtime(), runtime_exports)),
-  authority: () => Promise.resolve().then(() => (init_authority(), authority_exports))
+  authority: () => Promise.resolve().then(() => (init_authority(), authority_exports)),
+  gatedNetwork: () => Promise.resolve().then(() => (init_gated_network(), gated_network_exports)),
+  // Lazy by contract: replica loads only when replication is enabled. Literal specifier typed by
+  // ProfileGateModule; TS2307 under moduleResolution "node" is suppressed (see replica-contract.ts).
+  // @ts-ignore
+  gate: () => import("@tinycloud/replica/profile-gate")
 });
 
 // src/index.ts
@@ -27178,8 +27719,8 @@ import {
   Space
 } from "@tinycloud/sdk-core";
 import {
-  ProtocolMismatchError,
-  VersionCheckError as VersionCheckError2,
+  ProtocolMismatchError as ProtocolMismatchError2,
+  VersionCheckError,
   UnsupportedFeatureError as UnsupportedFeatureError2,
   checkNodeInfo as checkNodeInfo3
 } from "@tinycloud/sdk-core";
@@ -27187,15 +27728,518 @@ import { ServiceContext as ServiceContext4 } from "@tinycloud/sdk-core";
 
 // src/replication/sqlite.ts
 init_authority();
+import { AsyncLocalStorage } from "async_hooks";
 import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
-import { chmod, mkdir, open as openFile, readFile, realpath, rename, rm, stat } from "fs/promises";
-import { basename, dirname as dirname2, join as join2 } from "path";
+import { lstatSync, readFileSync as readFileSync2, statSync } from "fs";
+import { chmod, lstat, mkdir, open as openFile, readFile, readdir, realpath, rename, rm, rmdir, stat } from "fs/promises";
+import { basename, dirname as dirname2, join as join2, parse as parse2, resolve, sep } from "path";
 import { KVService as KVService3, ServiceContext as ServiceContext3, principalDid as principalDid2 } from "@tinycloud/sdk-core";
 import {
   canonicalReplicationIdentity,
   replicationIdentityKey,
   requiresSecretsOptIn as requiresSecretsOptIn2
 } from "@tinycloud/sdk-services";
+import { CONSENT_WINDOW_MS, MAX_GRANT_TTL_MS as MAX_GRANT_TTL_MS2, REPLICA_GATE_FILE } from "@tinycloud/sdk-services/kv/replication/contractConstants";
+var REPLICA_LOGOUT_PENDING_FILE = "replica-logout-pending.json";
+function assertProfileLogoutClear(profileDir) {
+  assertLogoutClear(join2(profileDir, REPLICA_LOGOUT_PENDING_FILE));
+}
+function assertLogoutClear(path) {
+  if (path === void 0) return;
+  try {
+    lstatSync(path);
+  } catch (error) {
+    if (isNotFound(error)) return;
+  }
+  throw gated("gate_unavailable");
+}
+function safeInventoryPath(path) {
+  return path.length > 0 && path.split("/").every((part) => part.length > 0 && part !== "." && part !== ".." && !part.includes("\\") && !part.includes("\0")) && (path === "replication" || path.startsWith("replication/") || path === "replicas" || path.startsWith("replicas/"));
+}
+function logoutPrincipalDigest(principal) {
+  return createHash2("sha256").update("tinycloud-replica-logout\0").update(principal, "utf8").digest("hex");
+}
+function compareInventoryString(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function approvalEntries(report) {
+  return [
+    ...report.unknownEntries,
+    ...report.knownEntries,
+    ...report.knownRoots.map((root) => ({ ...root, kind: "directory" })),
+    ...report.missingDatabases.map((path) => ({ path, kind: "missing", dev: "", ino: "" }))
+  ].map(({ path, kind, dev, ino }) => ({ path, kind, dev, ino })).sort((a, b) => compareInventoryString(a.path, b.path) || compareInventoryString(a.kind, b.kind) || compareInventoryString(a.dev, b.dev) || compareInventoryString(a.ino, b.ino));
+}
+function inventoryApprovalToken(marker, principal, entries) {
+  const markerId = marker.v === 2 ? [marker.v, marker.nonce, marker.principalDigest] : [marker.v, marker.incarnation, marker.lifecycleEpoch, marker.principalDigest];
+  return createHash2("sha256").update("tc-logout-approve-v1\0").update(JSON.stringify([
+    markerId,
+    marker.approvalSalt,
+    principal,
+    marker.v === 2 ? null : marker.lifecycleEpoch,
+    entries
+  ])).digest().subarray(0, 16).toString("hex");
+}
+function changedInventoryRefusal(marker, principal, report, entries = approvalEntries(report)) {
+  const token = inventoryApprovalToken(marker, principal, entries);
+  const error = localChangesRefusal(report.unknownPaths);
+  error.message += ` Current token-bound inventory (path/kind/dev/ino): ${entries.length === 0 ? "(empty)" : entries.map((entry) => JSON.stringify(entry)).join(", ")}. To approve this exact changed inventory in a separate command, use --discard-local-changes --approve-inventory ${token}.`;
+  return Object.assign(error, { inventoryApprovalToken: token, inventoryApprovalEntries: entries });
+}
+function storedInventoryChanged(marker, report) {
+  try {
+    assertApprovedInventory(report, {
+      unknownEntries: marker.approvedUnknown,
+      knownRoots: marker.knownRoots,
+      knownEntries: marker.knownEntries,
+      missingDatabases: marker.missingDatabases
+    });
+    return false;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "REPLICA_GATED" && "gate" in error && error.gate === "gate_unavailable") {
+      return true;
+    }
+    throw error;
+  }
+}
+function decimalIdentity(value) {
+  return typeof value === "string" && /^(0|[1-9][0-9]*)$/.test(value);
+}
+function logoutMarkerOf(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw gated("gate_unavailable");
+  const row = value;
+  const entry = (item) => item !== null && typeof item === "object" && !Array.isArray(item) && Object.keys(item).length === 4 && typeof item.path === "string" && safeInventoryPath(item.path) && ["file", "directory", "symlink"].includes(item.kind) && decimalIdentity(item.dev) && decimalIdentity(item.ino);
+  const root = (item) => item !== null && typeof item === "object" && !Array.isArray(item) && Object.keys(item).length === 3 && typeof item.path === "string" && safeInventoryPath(item.path) && decimalIdentity(item.dev) && decimalIdentity(item.ino);
+  if (typeof row.principalDigest !== "string" || !/^[0-9a-f]{64}$/.test(row.principalDigest) || typeof row.approvalSalt !== "string" || !/^[0-9a-f]{32}$/.test(row.approvalSalt) || !Array.isArray(row.approvedUnknown) || !row.approvedUnknown.every(entry) || !Array.isArray(row.knownRoots) || !row.knownRoots.every(root) || !Array.isArray(row.knownEntries) || !row.knownEntries.every(entry) || !Array.isArray(row.missingDatabases) || !row.missingDatabases.every(
+    (path) => typeof path === "string" && safeInventoryPath(path) && path.endsWith("/replica.db")
+  ) || row.discardLocalChanges !== void 0 && row.discardLocalChanges !== true || row.remotePending !== void 0 && row.remotePending !== true || row.remoteAbandoned !== void 0 && row.remoteAbandoned !== true || row.remotePending === true && row.remoteAbandoned === true) throw gated("gate_unavailable");
+  const optional = Number(row.discardLocalChanges === true) + Number(row.remotePending === true) + Number(row.remoteAbandoned === true);
+  if (row.v === 2 && Object.keys(row).length === 9 + optional && row.scope === "orphan_profile" && typeof row.nonce === "string" && /^[0-9a-f]{32}$/.test(row.nonce)) return row;
+  if (row.v === 3 && Object.keys(row).length === 10 + optional && row.scope === "inactive_gate" && typeof row.incarnation === "string" && row.incarnation.length > 0 && Number.isSafeInteger(row.lifecycleEpoch) && row.lifecycleEpoch >= 0) {
+    return row;
+  }
+  const bound = Number(row.deniedEpoch !== void 0);
+  if (Object.keys(row).length !== 10 + optional + bound || row.v !== 1 || typeof row.incarnation !== "string" || row.incarnation.length === 0 || !Number.isSafeInteger(row.lifecycleEpoch) || row.lifecycleEpoch < 0 || typeof row.principalHash !== "string" || !/^[0-9a-f]{64}$/.test(row.principalHash) || bound === 1 && (!Number.isSafeInteger(row.deniedEpoch) || row.deniedEpoch <= row.lifecycleEpoch)) {
+    throw gated("gate_unavailable");
+  }
+  return row;
+}
+async function readLogoutMarker(path) {
+  const value = await readJsonFile(path);
+  return value === void 0 ? null : logoutMarkerOf(value);
+}
+async function orphanRoot(profileDir, name) {
+  let profile;
+  try {
+    profile = await lstat(profileDir);
+  } catch {
+    throw gated("gate_unavailable");
+  }
+  let pinned = false;
+  if (process.platform === "linux" && /^\/proc\/self\/fd\/[1-9]\d*$/.test(profileDir) && profile.isSymbolicLink()) {
+    try {
+      pinned = (await stat(profileDir)).isDirectory();
+    } catch {
+      throw gated("gate_unavailable");
+    }
+  }
+  if (!profile.isDirectory() && !pinned) throw gated("gate_unavailable");
+  const root = join2(profileDir, name);
+  let entry;
+  try {
+    entry = await lstat(root);
+  } catch (error) {
+    if (isNotFound(error)) return null;
+    throw error;
+  }
+  if (!entry.isDirectory() || await realpath(root) !== join2(await realpath(profileDir), name)) {
+    throw gated("gate_unavailable");
+  }
+  return root;
+}
+async function hasOrphanPending(profileDir) {
+  const root = await orphanRoot(profileDir, "replication");
+  if (root === null) return false;
+  let entries;
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch {
+    return true;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) return true;
+    const dir = join2(root, entry.name);
+    try {
+      if (!(await lstat(dir)).isDirectory()) return true;
+    } catch {
+      return true;
+    }
+    if (!/^[a-z2-7]{26}$/.test(entry.name)) return true;
+    let children;
+    try {
+      children = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return true;
+    }
+    if (children.length !== 2 || children.some((child) => !child.isFile() || child.name !== "identity.json" && child.name !== "pending.json")) return true;
+    const pendingFile = join2(dir, "pending.json");
+    let text;
+    try {
+      const pending = await lstat(pendingFile);
+      if (!pending.isFile()) return true;
+      text = await readFile(pendingFile, "utf8");
+    } catch (error) {
+      if (isNotFound(error)) return true;
+      return true;
+    }
+    try {
+      const identityFile = join2(dir, "identity.json");
+      if (!(await lstat(identityFile)).isFile()) return true;
+      const identity = identityRecordOf(await readJsonFile(identityFile));
+      if (identity === void 0 || parsePendingState(text, pendingFile, identity).records.length !== 0) {
+        return true;
+      }
+    } catch {
+      return true;
+    }
+  }
+  return false;
+}
+function inventoryIdentity(path, dev, ino) {
+  return { path, dev: dev.toString(), ino: ino.toString() };
+}
+async function inventoryUnknown(profileDir, relative, entries) {
+  const path = join2(profileDir, relative);
+  const info = await lstat(path, { bigint: true });
+  const kind = info.isDirectory() ? "directory" : info.isSymbolicLink() ? "symlink" : "file";
+  entries.push({ ...inventoryIdentity(relative, info.dev, info.ino), kind });
+  if (kind === "directory") {
+    for (const child of await readdir(path)) await inventoryUnknown(profileDir, `${relative}/${child}`, entries);
+  }
+}
+async function inspectProfileReplicaLayout(profileDir, gateReadable, approvedMarker, legacyOnly = false, diagnosticFiles = []) {
+  const report = {
+    knownLegacyReplicas: 0,
+    unknownLegacyPaths: [],
+    unknownPaths: [],
+    unknownEntries: [],
+    knownRoots: [],
+    knownEntries: [],
+    missingDatabases: []
+  };
+  const legacy = await orphanRoot(profileDir, "replicas");
+  const active = legacyOnly ? null : await orphanRoot(profileDir, "replication");
+  for (const [name, dir] of [["replicas", legacy], ["replication", active]]) {
+    if (dir === null) continue;
+    const info = await lstat(dir, { bigint: true });
+    report.knownRoots.push(inventoryIdentity(name, info.dev, info.ino));
+  }
+  if (legacy !== null) {
+    const sqlite = await import("@tinycloud/replica/sqlite");
+    for (const entry of await readdir(legacy, { withFileTypes: true })) {
+      const relative = `replicas/${entry.name}`;
+      const child = join2(legacy, entry.name);
+      if (!entry.isDirectory()) {
+        await inventoryUnknown(profileDir, relative, report.unknownEntries);
+        continue;
+      }
+      try {
+        const layout = await sqlite.inspectSqliteReplicaLayout(child);
+        report.knownRoots.push({ path: relative, ...layout.rootIdentity });
+        report.unknownEntries.push(...layout.unknownEntries.map((item) => ({
+          ...item,
+          path: `${relative}/${item.path}`
+        })));
+        report.knownEntries.push(...layout.knownEntries.map((item) => ({
+          ...item,
+          path: `${relative}/${item.path}`
+        })));
+        if (layout.unknownPaths.length === 0) report.knownLegacyReplicas++;
+        if (layout.unknownPaths.includes("replica.db") && !layout.unknownEntries.some((item) => item.path === "replica.db")) {
+          report.missingDatabases.push(`${relative}/replica.db`);
+        }
+      } catch {
+        await inventoryUnknown(profileDir, relative, report.unknownEntries);
+      }
+    }
+  }
+  if (active !== null) {
+    const cleanOrphan = !gateReadable && (approvedMarker?.v === 2 || !await hasOrphanPending(profileDir));
+    for (const entry of await readdir(active, { withFileTypes: true })) {
+      const relative = `replication/${entry.name}`;
+      const dir = join2(active, entry.name);
+      if (approvedMarker?.approvedUnknown.some((item) => item.path === relative)) {
+        await inventoryUnknown(profileDir, relative, report.unknownEntries);
+        continue;
+      }
+      if (gateReadable && diagnosticFiles.includes(entry.name)) {
+        const info2 = await lstat(dir, { bigint: true });
+        if (info2.isFile()) {
+          report.knownEntries.push({ ...inventoryIdentity(relative, info2.dev, info2.ino), kind: "file" });
+          continue;
+        }
+      }
+      if (!gateReadable && !cleanOrphan || !entry.isDirectory() || !/^[a-z2-7]{26}$/.test(entry.name)) {
+        await inventoryUnknown(profileDir, relative, report.unknownEntries);
+        continue;
+      }
+      const info = await lstat(dir, { bigint: true });
+      report.knownRoots.push(inventoryIdentity(relative, info.dev, info.ino));
+      const identityPath = join2(dir, "identity.json");
+      let identity;
+      try {
+        if ((await lstat(identityPath)).isFile()) identity = identityRecordOf(await readJsonFile(identityPath));
+      } catch {
+      }
+      if (identity === void 0) {
+        const approvedRoot = approvedMarker?.knownRoots.find((item) => item.path === relative);
+        if (approvedRoot?.dev === info.dev.toString() && approvedRoot.ino === info.ino.toString()) {
+          const children = await readdir(dir);
+          if (children.length === 0) continue;
+          if (children.length === 1 && children[0] === "replicas") {
+            const replicasPath = `${relative}/replicas`;
+            const replicasDir = join2(dir, "replicas");
+            const replicasInfo = await lstat(replicasDir, { bigint: true });
+            const approvedReplicas = approvedMarker.knownRoots.find((item) => item.path === replicasPath);
+            if (replicasInfo.isDirectory() && !replicasInfo.isSymbolicLink() && approvedReplicas?.dev === replicasInfo.dev.toString() && approvedReplicas.ino === replicasInfo.ino.toString() && (await readdir(replicasDir)).length === 0) {
+              report.knownRoots.push(inventoryIdentity(replicasPath, replicasInfo.dev, replicasInfo.ino));
+              continue;
+            }
+          }
+        }
+        report.knownRoots.pop();
+        await inventoryUnknown(profileDir, relative, report.unknownEntries);
+        continue;
+      }
+      for (const child of await readdir(dir, { withFileTypes: true })) {
+        const childRelative = `${relative}/${child.name}`;
+        const childPath = join2(dir, child.name);
+        if ((child.name === "identity.json" || child.name === "device.jwk") && child.isFile()) {
+          const childInfo = await lstat(childPath, { bigint: true });
+          report.knownEntries.push({ ...inventoryIdentity(childRelative, childInfo.dev, childInfo.ino), kind: "file" });
+          continue;
+        }
+        if (child.name === "pending.json" && child.isFile()) {
+          try {
+            if (parsePendingState(await readFile(childPath, "utf8"), childPath, identity).records.length === 0) {
+              const childInfo = await lstat(childPath, { bigint: true });
+              report.knownEntries.push({ ...inventoryIdentity(childRelative, childInfo.dev, childInfo.ino), kind: "file" });
+              continue;
+            }
+          } catch {
+          }
+        }
+        if (child.name === "replicas" && child.isDirectory()) {
+          const replicasInfo = await lstat(childPath, { bigint: true });
+          report.knownRoots.push(inventoryIdentity(childRelative, replicasInfo.dev, replicasInfo.ino));
+          for (const replicaChild of await readdir(childPath, { withFileTypes: true })) {
+            const replicaRelative = `${childRelative}/${replicaChild.name}`;
+            if (!replicaChild.isDirectory() || !/^[a-z2-7]{26}$/.test(replicaChild.name)) {
+              await inventoryUnknown(profileDir, replicaRelative, report.unknownEntries);
+              continue;
+            }
+            const sqlite = await import("@tinycloud/replica/sqlite");
+            try {
+              const layout = await sqlite.inspectSqliteReplicaLayout(join2(childPath, replicaChild.name), {
+                allowAdapterFence: true
+              });
+              report.knownRoots.push({ path: replicaRelative, ...layout.rootIdentity });
+              report.unknownEntries.push(...layout.unknownEntries.map((item) => ({
+                ...item,
+                path: `${replicaRelative}/${item.path}`
+              })));
+              report.knownEntries.push(...layout.knownEntries.map((item) => ({
+                ...item,
+                path: `${replicaRelative}/${item.path}`
+              })));
+              if (layout.unknownPaths.includes("replica.db") && !layout.unknownEntries.some((item) => item.path === "replica.db")) {
+                report.missingDatabases.push(`${replicaRelative}/replica.db`);
+              }
+            } catch {
+              await inventoryUnknown(profileDir, replicaRelative, report.unknownEntries);
+            }
+          }
+          continue;
+        }
+        await inventoryUnknown(profileDir, childRelative, report.unknownEntries);
+      }
+    }
+  }
+  report.unknownEntries.sort((a, b) => a.path.localeCompare(b.path));
+  report.knownEntries.sort((a, b) => a.path.localeCompare(b.path));
+  report.knownRoots.sort((a, b) => a.path.localeCompare(b.path));
+  report.missingDatabases.sort();
+  report.unknownPaths = [...report.unknownEntries.map((entry) => entry.path), ...report.missingDatabases].sort();
+  report.unknownLegacyPaths = [...report.unknownPaths];
+  return report;
+}
+function assertApprovedInventory(current, approval, allowRemoved = false) {
+  const approved = new Map(approval.unknownEntries.map((item) => [item.path, item]));
+  const known = new Map(approval.knownRoots.map((item) => [item.path, item]));
+  const knownFiles = new Map(approval.knownEntries.map((item) => [item.path, item]));
+  for (const entry of current.unknownEntries) {
+    const expected = approved.get(entry.path);
+    if (expected?.kind !== entry.kind || expected.dev !== entry.dev || expected.ino !== entry.ino) {
+      throw localChangesRefusal(current.unknownPaths);
+    }
+  }
+  for (const root of current.knownRoots) {
+    const expected = known.get(root.path);
+    if (expected?.dev !== root.dev || expected.ino !== root.ino) throw localChangesRefusal([root.path]);
+  }
+  for (const entry of current.knownEntries) {
+    if (allowRemoved && entry.kind === "file" && /^(?:replication\/[a-z2-7]{26}\/replicas\/[a-z2-7]{26}|replicas\/[^/]+)\/replica\.db-(?:wal|shm|journal)$/.test(entry.path)) {
+      const database = entry.path.replace(/-(?:wal|shm|journal)$/, "");
+      const original = knownFiles.get(database);
+      const present = current.knownEntries.find((item) => item.path === database);
+      if (!approved.has(entry.path) && original?.kind === "file" && present?.dev === original.dev && present.ino === original.ino) continue;
+    }
+    const expected = knownFiles.get(entry.path);
+    if (expected?.kind !== entry.kind || expected.dev !== entry.dev || expected.ino !== entry.ino) {
+      throw localChangesRefusal([entry.path]);
+    }
+  }
+  for (const path of current.missingDatabases) {
+    if (!approval.missingDatabases.includes(path) && !(allowRemoved && knownFiles.get(path)?.kind === "file")) throw localChangesRefusal([path]);
+  }
+  if (!allowRemoved && (current.unknownEntries.length !== approved.size || current.knownRoots.length !== known.size || current.knownEntries.length !== knownFiles.size || current.missingDatabases.length !== approval.missingDatabases.length)) {
+    throw localChangesRefusal(current.unknownPaths);
+  }
+}
+async function assertApprovedParents(profileDir, marker, path) {
+  if (process.platform !== "linux") {
+    const absolute = resolve(profileDir);
+    let ancestor = parse2(absolute).root;
+    for (const part of absolute.slice(ancestor.length).split(sep).filter(Boolean)) {
+      ancestor = join2(ancestor, part);
+      const details = await lstat(ancestor, { bigint: true });
+      if (!details.isDirectory() || details.isSymbolicLink()) throw localChangesRefusal([path]);
+    }
+  }
+  let relativeParent = "";
+  for (const part of path.split("/").slice(0, -1)) {
+    relativeParent = relativeParent ? `${relativeParent}/${part}` : part;
+    let details;
+    try {
+      details = await lstat(join2(profileDir, relativeParent), { bigint: true });
+    } catch (error) {
+      if (isNotFound(error)) return false;
+      throw error;
+    }
+    const expected = marker.knownRoots.find((root) => root.path === relativeParent) ?? marker.approvedUnknown.find((item) => item.path === relativeParent && item.kind === "directory");
+    if (!details.isDirectory() || details.isSymbolicLink() || expected?.dev !== details.dev.toString() || expected.ino !== details.ino.toString()) {
+      throw localChangesRefusal([relativeParent]);
+    }
+  }
+  return true;
+}
+async function eraseApprovedUnknown(profileDir, marker, prefix, diagnosticFiles) {
+  const entries = marker.approvedUnknown.filter((entry) => entry.path.startsWith(`${prefix}/`));
+  for (const entry of entries.sort((a, b) => b.path.length - a.path.length)) {
+    assertApprovedInventory(await inspectProfileReplicaLayout(profileDir, marker.v !== 2, marker, false, diagnosticFiles), {
+      unknownEntries: marker.approvedUnknown,
+      knownRoots: marker.knownRoots,
+      knownEntries: marker.knownEntries,
+      missingDatabases: marker.missingDatabases
+    }, true);
+    if (!await assertApprovedParents(profileDir, marker, entry.path)) continue;
+    const file = join2(profileDir, entry.path);
+    let current;
+    try {
+      current = await lstat(file, { bigint: true });
+    } catch (error) {
+      if (isNotFound(error)) continue;
+      throw error;
+    }
+    const kind = current.isDirectory() ? "directory" : current.isSymbolicLink() ? "symlink" : "file";
+    if (kind !== entry.kind || current.dev.toString() !== entry.dev || current.ino.toString() !== entry.ino) throw localChangesRefusal([entry.path]);
+    if (process.platform !== "linux" && kind === "symlink") throw localChangesRefusal([entry.path]);
+    if (kind === "directory") await rmdir(file);
+    else await rm(file);
+  }
+}
+async function eraseKnownFlagResidue(profileDir, marker, diagnosticFiles) {
+  const diagnostics = new Set(diagnosticFiles.map((name) => `replication/${name}`));
+  for (const entry of marker.knownEntries.filter((item) => diagnostics.has(item.path) || /^replication\/[a-z2-7]{26}\/(?:identity\.json|pending\.json|device\.jwk)$/.test(item.path)).sort((a, b) => Number(a.path.endsWith("/identity.json")) - Number(b.path.endsWith("/identity.json")))) {
+    if (!await assertApprovedParents(profileDir, marker, entry.path)) continue;
+    const file = join2(profileDir, entry.path);
+    let details;
+    try {
+      details = await lstat(file, { bigint: true });
+    } catch (error) {
+      if (isNotFound(error)) continue;
+      throw error;
+    }
+    if (!details.isFile() || details.dev.toString() !== entry.dev || details.ino.toString() !== entry.ino) throw localChangesRefusal([entry.path]);
+    await rm(file);
+  }
+  const roots = marker.knownRoots.filter((item) => item.path === "replication" || item.path.startsWith("replication/"));
+  roots.sort((a, b) => b.path.split("/").length - a.path.split("/").length);
+  for (const entry of roots) {
+    if (!await assertApprovedParents(profileDir, marker, entry.path)) continue;
+    const path = join2(profileDir, entry.path);
+    let details;
+    try {
+      details = await lstat(path, { bigint: true });
+    } catch (error) {
+      if (isNotFound(error)) continue;
+      throw error;
+    }
+    if (!details.isDirectory() || details.isSymbolicLink() || details.dev.toString() !== entry.dev || details.ino.toString() !== entry.ino) {
+      throw localChangesRefusal([entry.path]);
+    }
+    await rmdir(path);
+  }
+}
+function localChangesRefusal(unknownPaths = []) {
+  const error = gated("gate_unavailable");
+  error.message = "Unknown or unsynced local replica data may be lost; sync first, or retry logout with --discard-local-changes." + (unknownPaths.length === 0 ? "" : ` Unknown: ${unknownPaths.map((path) => JSON.stringify(path)).join(", ")}.`);
+  return error;
+}
+function gateOwnedByAnother(state, principalHash) {
+  return state.principalHash !== null ? state.principalHash !== principalHash : state.eraseDeferred && state.deferredPrincipalHash !== principalHash;
+}
+function isGateUnavailable(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "REPLICA_GATED" && "gate" in error && error.gate === "gate_unavailable";
+}
+function restoredGate() {
+  const error = gated("stamp_stale");
+  error.message = RESTORED_GATE_MESSAGE;
+  return Object.assign(error, { reportCode: "gate_restored" });
+}
+var RESTORED_GATE_MESSAGE = "The replica gate does not match this logout's recorded sign-out; an older gate may have been restored. Local replicas stay disabled for this profile: switch the default profile first if needed (`tc profile switch <other>`), then run `tc profile delete <name>` and sign in again.";
+function interruptedSignOut() {
+  const error = gated("gate_unavailable");
+  error.message = "A previous sign-out was interrupted; re-running `tc auth logout` completes it.";
+  return error;
+}
+function assertSupportedProfileLayout(report) {
+  if (process.platform === "linux") return;
+  const link = report.unknownEntries.find((entry) => entry.kind === "symlink");
+  if (link === void 0) return;
+  const error = gated("gate_unavailable");
+  error.message = `Replica symlink ${JSON.stringify(link.path)} cannot be removed safely on this platform.`;
+  throw error;
+}
+async function fileGate() {
+  return import("@tinycloud/replica/profile-gate");
+}
+function gated(reason) {
+  return Object.assign(new Error(`Replica gate refused: ${reason}`), { code: "REPLICA_GATED", gate: reason });
+}
+async function requiredGuard(guard, section) {
+  if (guard === void 0) throw gated("gate_unavailable");
+  let entered = false;
+  try {
+    return await guard(async () => {
+      entered = true;
+      return section();
+    });
+  } catch (error) {
+    if (!entered) throw gated("gate_unavailable");
+    throw error;
+  }
+}
 var ReplicaStorageError = class extends Error {
   constructor(code, message, options) {
     super(message);
@@ -27221,6 +28265,19 @@ async function pathExists(path) {
     throw storageError("STORAGE_ERROR", `Reading ${path}`, error);
   }
 }
+async function realDirectoryExists(path) {
+  let stats;
+  try {
+    stats = await lstat(path);
+  } catch (error) {
+    if (isNotFound(error)) return false;
+    throw storageError("STORAGE_ERROR", `Reading ${path}`, error);
+  }
+  if (stats.isSymbolicLink() || !stats.isDirectory()) {
+    throw new ReplicaStorageError("STORAGE_ERROR", `Refusing the replaced replica path ${path}.`);
+  }
+  return true;
+}
 function principalOf(did) {
   return principalDid2(did);
 }
@@ -27374,90 +28431,117 @@ function parsePendingState(text, file, identity) {
   }
   return state;
 }
-var _dir, _guard, _dirSync, _file, _FilePendingWriteStore_instances, canonicalFile_fn;
+var _dir, _profileDir, _guard, _stamp, _dirSync, _logoutPendingFile, _generation, _canonicalDir, _FilePendingWriteStore_instances, withGate_fn, readFile_fn;
 var FilePendingWriteStore = class {
-  constructor(identity, dir, guard, dirSync) {
+  constructor(identity, dir, profileDir, guard, stamp, dirSync, logoutPendingFile) {
     __privateAdd(this, _FilePendingWriteStore_instances);
     this.durable = true;
     __privateAdd(this, _dir);
+    __privateAdd(this, _profileDir);
     __privateAdd(this, _guard);
+    __privateAdd(this, _stamp);
     __privateAdd(this, _dirSync);
-    __privateAdd(this, _file);
+    __privateAdd(this, _logoutPendingFile);
+    __privateAdd(this, _generation);
+    __privateAdd(this, _canonicalDir);
     this.identity = identity;
     __privateSet(this, _dir, dir);
+    __privateSet(this, _profileDir, profileDir);
     __privateSet(this, _guard, guard);
+    __privateSet(this, _stamp, stamp);
     __privateSet(this, _dirSync, dirSync);
+    __privateSet(this, _logoutPendingFile, logoutPendingFile);
   }
   async read() {
-    const file = await __privateMethod(this, _FilePendingWriteStore_instances, canonicalFile_fn).call(this);
-    let text;
-    try {
-      text = await readFile(file, "utf8");
-    } catch (error) {
-      if (isNotFound(error)) {
-        return { v: 2, identity: this.identity, committedEpoch: 0, seq: 0, records: [] };
-      }
-      throw storageError("STORAGE_ERROR", `Reading ${file}`, error);
-    }
-    return parsePendingState(text, file, this.identity);
+    return __privateMethod(this, _FilePendingWriteStore_instances, withGate_fn).call(this, async (file) => await __privateMethod(this, _FilePendingWriteStore_instances, readFile_fn).call(this, file) ?? { v: 2, identity: this.identity, committedEpoch: 0, seq: 0, records: [] });
   }
   async readExisting() {
-    let file;
+    return __privateMethod(this, _FilePendingWriteStore_instances, withGate_fn).call(this, (file) => __privateMethod(this, _FilePendingWriteStore_instances, readFile_fn).call(this, file));
+  }
+  async update(mutate) {
+    return __privateMethod(this, _FilePendingWriteStore_instances, withGate_fn).call(this, async (file) => {
+      await ensurePartitionIdentity(__privateGet(this, _dir), this.identity, __privateGet(this, _dirSync));
+      const currentFile = join2(await realpath(__privateGet(this, _dir)), "pending.json");
+      if (__privateGet(this, _canonicalDir) !== void 0 && dirname2(currentFile) !== __privateGet(this, _canonicalDir)) {
+        throw new ReplicaStorageError("STORAGE_ERROR", "The pending-write partition changed while open.");
+      }
+      const state = await __privateMethod(this, _FilePendingWriteStore_instances, readFile_fn).call(this, currentFile) ?? { v: 2, identity: this.identity, committedEpoch: 0, seq: 0, records: [] };
+      const result = await mutate(state);
+      await writeJsonAtomic(currentFile, state, __privateGet(this, _dirSync));
+      return result;
+    });
+  }
+};
+_dir = new WeakMap();
+_profileDir = new WeakMap();
+_guard = new WeakMap();
+_stamp = new WeakMap();
+_dirSync = new WeakMap();
+_logoutPendingFile = new WeakMap();
+_generation = new WeakMap();
+_canonicalDir = new WeakMap();
+_FilePendingWriteStore_instances = new WeakSet();
+withGate_fn = async function(section) {
+  if (__privateGet(this, _stamp) === void 0) throw gated("not_established");
+  if (__privateGet(this, _guard) === void 0) throw gated("gate_unavailable");
+  const gate = await fileGate();
+  const snapshot = await gate.readGateSnapshot(__privateGet(this, _profileDir));
+  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, replicationIdentityKey(this.identity))
+  ]);
+  const access = {
+    stamp: __privateGet(this, _stamp),
+    incarnation: snapshot.incarnation,
+    principalHash,
+    identityKeyHash
+  };
+  let canonicalRoot;
+  try {
+    canonicalRoot = await realpath(dirname2(__privateGet(this, _dir)));
+  } catch (error) {
+    if (!isNotFound(error)) throw storageError("STORAGE_ERROR", `Resolving ${dirname2(__privateGet(this, _dir))}`, error);
+    canonicalRoot = join2(await realpath(dirname2(dirname2(__privateGet(this, _dir)))), basename(dirname2(__privateGet(this, _dir))));
+  }
+  const queueKey = join2(canonicalRoot, basename(__privateGet(this, _dir)), "pending.json");
+  return serializePendingWrite(queueKey, () => requiredGuard(__privateGet(this, _guard), async () => {
+    assertLogoutClear(__privateGet(this, _logoutPendingFile));
+    const before = await gate.assertGateAccess(__privateGet(this, _profileDir), access, snapshot.salt);
+    const generation = before.pendingGenerations[identityKeyHash] ?? 0;
+    if (__privateGet(this, _generation) !== void 0 && __privateGet(this, _generation) !== generation) {
+      throw new ReplicaStorageError("RESET_REQUIRED", "The pending identity was erased; reopen the store.");
+    }
+    let file = join2(__privateGet(this, _dir), "pending.json");
     try {
       file = join2(await realpath(__privateGet(this, _dir)), "pending.json");
+      const recorded = identityRecordOf(await readJsonFile(join2(dirname2(file), "identity.json")));
+      if (recorded === void 0 || !sameIdentity(recorded, this.identity)) {
+        throw new ReplicaStorageError("STORAGE_ERROR", "The pending partition belongs to a different identity.");
+      }
     } catch (error) {
-      if (isNotFound(error)) return void 0;
-      throw storageError("STORAGE_ERROR", `Resolving pending-write state in ${__privateGet(this, _dir)}`, error);
+      if (error instanceof ReplicaStorageError) throw error;
+      if (!isNotFound(error)) throw storageError("STORAGE_ERROR", `Resolving ${__privateGet(this, _dir)}`, error);
     }
-    try {
-      const text = await readFile(file, "utf8");
-      return parsePendingState(text, file, this.identity);
-    } catch (error) {
-      if (isNotFound(error)) return void 0;
-      if (error instanceof ReplicaStorageError) throw error;
-      throw storageError("STORAGE_ERROR", `Reading ${file}`, error);
+    if (__privateGet(this, _canonicalDir) !== void 0 && dirname2(file) !== __privateGet(this, _canonicalDir)) {
+      throw new ReplicaStorageError("STORAGE_ERROR", "The pending-write partition changed while open.");
     }
-  }
-  async update(mutate) {
-    const file = await __privateMethod(this, _FilePendingWriteStore_instances, canonicalFile_fn).call(this);
-    return serializePendingWrite(file, async () => {
-      let currentFile;
-      try {
-        currentFile = join2(await realpath(dirname2(file)), basename(file));
-      } catch (error) {
-        throw storageError("STORAGE_ERROR", "Resolving the open pending-write partition", error);
-      }
-      if (currentFile !== file) {
-        throw new ReplicaStorageError(
-          "STORAGE_ERROR",
-          `The pending-write partition changed while open: ${dirname2(file)}.`
-        );
-      }
-      return __privateGet(this, _guard).call(this, async () => {
-        const state = await this.read();
-        const result = mutate(state);
-        await writeJsonAtomic(file, state, __privateGet(this, _dirSync));
-        return result;
-      });
-    });
-  }
+    const result = await section(file);
+    await gate.assertGateAccess(__privateGet(this, _profileDir), access, snapshot.salt);
+    assertLogoutClear(__privateGet(this, _logoutPendingFile));
+    __privateSet(this, _generation, generation);
+    if (await pathExists(__privateGet(this, _dir))) __privateSet(this, _canonicalDir, await realpath(__privateGet(this, _dir)));
+    return result;
+  }));
 };
-_dir = new WeakMap();
-_guard = new WeakMap();
-_dirSync = new WeakMap();
-_file = new WeakMap();
-_FilePendingWriteStore_instances = new WeakSet();
-canonicalFile_fn = async function() {
-  __privateGet(this, _file) ?? __privateSet(this, _file, (async () => {
-    await ensurePartitionIdentity(__privateGet(this, _dir), this.identity, __privateGet(this, _dirSync));
-    const file = join2(__privateGet(this, _dir), "pending.json");
-    try {
-      return join2(await realpath(dirname2(file)), basename(file));
-    } catch (error) {
-      throw storageError("STORAGE_ERROR", `Resolving ${file}`, error);
-    }
-  })());
-  return __privateGet(this, _file);
+readFile_fn = async function(file) {
+  try {
+    return parsePendingState(await readFile(file, "utf8"), file, this.identity);
+  } catch (error) {
+    if (isNotFound(error)) return void 0;
+    if (error instanceof ReplicaStorageError) throw error;
+    throw storageError("STORAGE_ERROR", `Reading ${file}`, error);
+  }
 };
 async function loadOrCreateDevice(idDir, guard, createDevice, dirSync) {
   return guard(async () => {
@@ -27503,7 +28587,7 @@ async function readFence(replicaDir) {
   const fence = await readJsonFile(join2(replicaDir, FENCE_FILE));
   return typeof fence === "object" && fence !== null && "syncedThroughEpoch" in fence && typeof fence.syncedThroughEpoch === "number" ? fence.syncedThroughEpoch : 0;
 }
-function newestGrantInfo(replica, record, pending, spec) {
+function newestGrantInfo(replica, record, pending, spec, install) {
   if (record === null) return null;
   const parsed = replica.parseUcanGrant(record.bytes);
   return {
@@ -27511,10 +28595,11 @@ function newestGrantInfo(replica, record, pending, spec) {
     parentCid: parsed.prf[0] ?? null,
     expiresAt: record.expiresAt === null ? null : record.expiresAt * 1e3,
     state: pending !== null && record === pending ? "pending" : "active",
-    unconstrained: ucanAttUnconstrainedFor(parsed.att, spec.space, spec.prefix)
+    unconstrained: ucanAttUnconstrainedFor(parsed.att, spec.space, spec.prefix),
+    ...install === null ? {} : install
   };
 }
-var _device, _store, _replicaDir, _replica, _guard2, _dirSync2, _generation, _ino, _transportOverride, _closed, _inFlight, _transportFactory, _SqliteReplicaHandle_instances, assertOpen_fn, assertLive_fn, transports_fn;
+var _device, _store, _replicaDir, _replica, _guard2, _read, _policy, _recordGrantInstall, _dirSync2, _generation2, _ino, _transportOverride, _closed, _inFlight, _transportFactory, _SqliteReplicaHandle_instances, assertOpen_fn, assertLive_fn, transports_fn, assertEffective_fn, assertSyncEffective_fn;
 var SqliteReplicaHandle = class {
   constructor(input) {
     __privateAdd(this, _SqliteReplicaHandle_instances);
@@ -27523,9 +28608,12 @@ var SqliteReplicaHandle = class {
     __privateAdd(this, _replicaDir);
     __privateAdd(this, _replica);
     __privateAdd(this, _guard2);
+    __privateAdd(this, _read);
+    __privateAdd(this, _policy);
+    __privateAdd(this, _recordGrantInstall);
     __privateAdd(this, _dirSync2);
     /** The replica row generation this handle opened under — the durable fence a purge commits past (browser-parity wipe). */
-    __privateAdd(this, _generation);
+    __privateAdd(this, _generation2);
     /** The inode of `replica.db` at open — a directory recreated in place is a different replica. */
     __privateAdd(this, _ino);
     __privateAdd(this, _transportOverride);
@@ -27533,64 +28621,76 @@ var SqliteReplicaHandle = class {
     __privateAdd(this, _inFlight, /* @__PURE__ */ new Set());
     __privateAdd(this, _transportFactory);
     this.spec = input.spec;
+    this.replicaId = input.replicaId;
     __privateSet(this, _device, input.device);
     this.deviceDid = input.device.did;
     __privateSet(this, _store, input.store);
     __privateSet(this, _replicaDir, input.replicaDir);
     __privateSet(this, _replica, input.replica);
     __privateSet(this, _guard2, input.guard);
+    __privateSet(this, _read, input.read);
+    __privateSet(this, _policy, input.policy);
+    __privateSet(this, _recordGrantInstall, input.recordGrantInstall);
     __privateSet(this, _transportOverride, input.transportFor);
     __privateSet(this, _dirSync2, input.dirSync);
-    __privateSet(this, _generation, input.generation);
+    __privateSet(this, _generation2, input.generation);
     __privateSet(this, _ino, input.ino);
   }
   async get(key2) {
-    await __privateMethod(this, _SqliteReplicaHandle_instances, assertLive_fn).call(this);
-    const result = await new (__privateGet(this, _replica)).Replica({ store: __privateGet(this, _store) }).get(key2);
-    const meta = {
-      asOf: result.meta.asOf,
-      coverage: result.meta.coverage,
-      authority: result.meta.authority,
-      syncedThroughEpoch: await readFence(__privateGet(this, _replicaDir))
-    };
-    switch (result.status) {
-      case "present":
-        return {
-          status: "present",
-          key: result.key,
-          value: result.value,
-          etag: result.etag,
-          metadata: result.metadata,
-          meta
-        };
-      case "content_missing":
-        return {
-          status: "content_missing",
-          key: result.key,
-          etag: result.etag,
-          metadata: result.metadata,
-          meta
-        };
-      default:
-        return { status: result.status, key: result.key, meta };
-    }
-  }
-  async list(options) {
-    await __privateMethod(this, _SqliteReplicaHandle_instances, assertLive_fn).call(this);
-    const result = await new (__privateGet(this, _replica)).Replica({ store: __privateGet(this, _store) }).list({
-      prefix: options.prefix,
-      ...options.after === void 0 ? {} : { after: options.after },
-      ...options.limit === void 0 ? {} : { limit: options.limit }
-    });
-    return {
-      keys: result.entries.map((entry) => entry.key),
-      meta: {
+    return __privateGet(this, _read).call(this, async (snapshot, syncedThroughEpoch) => {
+      __privateMethod(this, _SqliteReplicaHandle_instances, assertOpen_fn).call(this);
+      await __privateMethod(this, _SqliteReplicaHandle_instances, assertEffective_fn).call(this, snapshot);
+      const result = await new (__privateGet(this, _replica)).Replica({ store: snapshot }).get(key2);
+      await __privateMethod(this, _SqliteReplicaHandle_instances, assertEffective_fn).call(this, snapshot);
+      const meta = {
         asOf: result.meta.asOf,
         coverage: result.meta.coverage,
         authority: result.meta.authority,
-        syncedThroughEpoch: await readFence(__privateGet(this, _replicaDir))
+        syncedThroughEpoch
+      };
+      switch (result.status) {
+        case "present":
+          return {
+            status: "present",
+            key: result.key,
+            value: result.value,
+            etag: result.etag,
+            metadata: result.metadata,
+            meta
+          };
+        case "content_missing":
+          return {
+            status: "content_missing",
+            key: result.key,
+            etag: result.etag,
+            metadata: result.metadata,
+            meta
+          };
+        default:
+          return { status: result.status, key: result.key, meta };
       }
-    };
+    }, true);
+  }
+  async list(options) {
+    return __privateGet(this, _read).call(this, async (snapshot, syncedThroughEpoch) => {
+      __privateMethod(this, _SqliteReplicaHandle_instances, assertOpen_fn).call(this);
+      await __privateMethod(this, _SqliteReplicaHandle_instances, assertEffective_fn).call(this, snapshot);
+      const result = await new (__privateGet(this, _replica)).Replica({ store: snapshot }).list({
+        prefix: options.prefix,
+        ...options.after === void 0 ? {} : { after: options.after },
+        ...options.limit === void 0 ? {} : { limit: options.limit }
+      });
+      await __privateMethod(this, _SqliteReplicaHandle_instances, assertEffective_fn).call(this, snapshot);
+      return {
+        keys: result.entries.map((entry) => entry.key),
+        meta: {
+          asOf: result.meta.asOf,
+          coverage: result.meta.coverage,
+          authority: result.meta.authority,
+          syncedThroughEpoch
+        }
+      };
+    }, true);
   }
   /**
    * The newest installed grant — the pending one when a not-yet-promoted
@@ -27600,43 +28700,59 @@ var SqliteReplicaHandle = class {
    * grant is still reported (unconstrained: false) and never reused.
    */
   async grant() {
-    await __privateMethod(this, _SqliteReplicaHandle_instances, assertLive_fn).call(this);
-    const state = await __privateGet(this, _store).open();
-    if (state === null) return null;
-    return newestGrantInfo(
-      __privateGet(this, _replica),
-      state.pendingGrant ?? state.grant,
-      state.pendingGrant,
-      this.spec
-    );
+    return __privateGet(this, _read).call(this, async (snapshot) => {
+      __privateMethod(this, _SqliteReplicaHandle_instances, assertOpen_fn).call(this);
+      const state = await snapshot.open();
+      if (state === null) return null;
+      const selected = state.pendingGrant ?? state.grant;
+      const install = selected === null ? null : await snapshot.getGrantInstall(selected.cid);
+      return newestGrantInfo(
+        __privateGet(this, _replica),
+        state.pendingGrant ?? state.grant,
+        state.pendingGrant,
+        this.spec,
+        install
+      );
+    });
   }
   async installGrant(ucan) {
-    await __privateMethod(this, _SqliteReplicaHandle_instances, assertLive_fn).call(this);
-    const parsed = __privateGet(this, _replica).parseUcanGrant(ucan);
-    const state = await __privateGet(this, _store).open();
-    if (state === null) {
-      throw new (__privateGet(this, _replica)).ReplicaError(
-        __privateGet(this, _replica).ReplicaErrorCode.NOT_FOUND,
-        "The replica has not been created."
-      );
-    }
-    __privateGet(this, _replica).assertGrantInstallable(parsed, {
-      deviceDid: principalOf(__privateGet(this, _device).did),
-      space: this.spec.space,
-      prefix: this.spec.prefix,
-      now: Date.now()
+    return __privateGet(this, _guard2).call(this, async () => {
+      await __privateMethod(this, _SqliteReplicaHandle_instances, assertLive_fn).call(this);
+      const parsed = __privateGet(this, _replica).parseUcanGrant(ucan);
+      const state = await __privateGet(this, _store).open();
+      if (state === null) {
+        throw new (__privateGet(this, _replica)).ReplicaError(
+          __privateGet(this, _replica).ReplicaErrorCode.NOT_FOUND,
+          "The replica has not been created."
+        );
+      }
+      __privateGet(this, _replica).assertGrantInstallable(parsed, {
+        deviceDid: principalOf(__privateGet(this, _device).did),
+        space: this.spec.space,
+        prefix: this.spec.prefix,
+        now: Date.now()
+      });
+      if (!ucanAttUnconstrainedFor(parsed.att, this.spec.space, this.spec.prefix)) {
+        throw new (__privateGet(this, _replica)).ReplicaError(
+          __privateGet(this, _replica).ReplicaErrorCode.GRANT_NOT_COVERING,
+          "The grant's get or sync coverage carries caveats; re-mint instead of installing it."
+        );
+      }
+      const now = Date.now();
+      const policy = await __privateGet(this, _policy).call(this, now, true);
+      if (policy === null || now >= policy.consentDeadline) {
+        throw new ReplicaStorageError("CONSENT_EXPIRED", "The replica's consent window has expired.");
+      }
+      const installedAt = await __privateGet(this, _recordGrantInstall).call(this, parsed.cid, now);
+      const installed = await __privateGet(this, _store).installGatedGrant(parsed, { ...policy, at: installedAt });
+      return newestGrantInfo(__privateGet(this, _replica), parsed, parsed, this.spec, installed);
     });
-    if (!ucanAttUnconstrainedFor(parsed.att, this.spec.space, this.spec.prefix)) {
-      throw new (__privateGet(this, _replica)).ReplicaError(
-        __privateGet(this, _replica).ReplicaErrorCode.GRANT_NOT_COVERING,
-        "The grant's get or sync coverage carries caveats; re-mint instead of installing it."
-      );
-    }
-    await __privateGet(this, _store).installGrant(parsed);
-    return newestGrantInfo(__privateGet(this, _replica), parsed, parsed, this.spec);
   }
   async sync(options) {
-    await __privateMethod(this, _SqliteReplicaHandle_instances, assertLive_fn).call(this);
+    await __privateGet(this, _guard2).call(this, async () => {
+      await __privateMethod(this, _SqliteReplicaHandle_instances, assertLive_fn).call(this);
+      await __privateMethod(this, _SqliteReplicaHandle_instances, assertSyncEffective_fn).call(this);
+    });
     const transportFor = await __privateMethod(this, _SqliteReplicaHandle_instances, transports_fn).call(this);
     const abort = new AbortController();
     options.signal.throwIfAborted();
@@ -27677,27 +28793,33 @@ var SqliteReplicaHandle = class {
     }
   }
   async status() {
-    await __privateMethod(this, _SqliteReplicaHandle_instances, assertLive_fn).call(this);
-    const engine = new (__privateGet(this, _replica)).Replica({ store: __privateGet(this, _store) });
-    const status = await engine.status();
-    const syncedThroughEpoch = await readFence(__privateGet(this, _replicaDir));
-    const state = await __privateGet(this, _store).open();
-    const grant = state === null ? null : newestGrantInfo(
-      __privateGet(this, _replica),
-      state.pendingGrant ?? state.grant,
-      state.pendingGrant,
-      this.spec
-    );
-    return {
-      coverage: status.coverage,
-      lastSyncAt: status.lastSyncAt,
-      syncedThroughEpoch,
-      authority: { state: status.authority.state, expiresAt: status.authority.expiresAt },
-      grant,
-      counts: status.counts,
-      bytes: status.bytes,
-      lastError: status.lastError
-    };
+    return __privateGet(this, _read).call(this, async (snapshot, syncedThroughEpoch) => {
+      __privateMethod(this, _SqliteReplicaHandle_instances, assertOpen_fn).call(this);
+      const engine = new (__privateGet(this, _replica)).Replica({ store: snapshot });
+      const status = await engine.status();
+      const state = await snapshot.open();
+      const selected = state?.pendingGrant ?? state?.grant ?? null;
+      const selectedInstall = selected === null ? null : await snapshot.getGrantInstall(selected.cid);
+      const activeRecord = state?.grant ?? null;
+      const activeInstall = activeRecord === null ? null : await snapshot.getGrantInstall(activeRecord.cid);
+      const grant = state === null ? null : newestGrantInfo(
+        __privateGet(this, _replica),
+        state.pendingGrant ?? state.grant,
+        state.pendingGrant,
+        this.spec,
+        selectedInstall
+      );
+      return {
+        coverage: status.coverage,
+        lastSyncAt: status.lastSyncAt,
+        syncedThroughEpoch,
+        authority: activeRecord !== null && (activeInstall === null || Date.now() >= activeInstall.effectiveExpiresAt || !Number.isSafeInteger(activeInstall.effectiveExpiresAt)) ? { state: "expired", expiresAt: activeInstall === null ? null : new Date(activeInstall.effectiveExpiresAt).toISOString() } : { state: status.authority.state, expiresAt: status.authority.expiresAt },
+        grant,
+        counts: status.counts,
+        bytes: status.bytes,
+        lastError: status.lastError
+      };
+    }, true);
   }
   async close() {
     if (__privateGet(this, _closed)) return;
@@ -27712,8 +28834,11 @@ _store = new WeakMap();
 _replicaDir = new WeakMap();
 _replica = new WeakMap();
 _guard2 = new WeakMap();
+_read = new WeakMap();
+_policy = new WeakMap();
+_recordGrantInstall = new WeakMap();
 _dirSync2 = new WeakMap();
-_generation = new WeakMap();
+_generation2 = new WeakMap();
 _ino = new WeakMap();
 _transportOverride = new WeakMap();
 _closed = new WeakMap();
@@ -27748,7 +28873,7 @@ assertLive_fn = async function() {
     throw error;
   }
   const state = await __privateGet(this, _store).open();
-  if (state !== null && state.generation !== __privateGet(this, _generation)) {
+  if (state !== null && state.generation !== __privateGet(this, _generation2)) {
     throw new (__privateGet(this, _replica)).ReplicaError(
       __privateGet(this, _replica).ReplicaErrorCode.RESET_REQUIRED,
       "The replica was purged or reopened; open it again to continue."
@@ -27790,97 +28915,1099 @@ transports_fn = async function() {
   })());
   return __privateGet(this, _transportFactory);
 };
+assertEffective_fn = async function(snapshot) {
+  const state = await snapshot.open();
+  if (state?.grant === void 0 || state.grant === null) return;
+  const installed = await snapshot.getGrantInstall(state.grant.cid);
+  if (installed === null || !Number.isSafeInteger(installed.effectiveExpiresAt) || Date.now() >= installed.effectiveExpiresAt || Date.now() >= installed.consentDeadline) {
+    throw new ReplicaStorageError("GRANT_EXPIRED", "The replica grant's effective lifetime has expired.");
+  }
+};
+assertSyncEffective_fn = async function() {
+  const state = await __privateGet(this, _store).open();
+  const selected = state?.pendingGrant ?? state?.grant;
+  if (selected === void 0 || selected === null) return;
+  const installed = await __privateGet(this, _store).getGrantInstall(selected.cid);
+  const now = Date.now();
+  if (installed === null || !Number.isSafeInteger(installed.effectiveExpiresAt) || now >= installed.effectiveExpiresAt || now >= installed.consentDeadline) {
+    throw new ReplicaStorageError("GRANT_EXPIRED", "The replica grant's effective lifetime has expired.");
+  }
+};
 function createSqliteReplicaStorage(options) {
   const root = options.dir;
-  const guard = options.guard ?? ((section) => section());
+  const profileDir = dirname2(options.gateFile ?? join2(dirname2(root), REPLICA_GATE_FILE));
+  const diagnosticFiles = [...options.diagnosticFiles ?? []];
+  for (const name of diagnosticFiles) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name) || /^[a-z2-7]{26}$/.test(name)) {
+      throw new TypeError(`Invalid replication diagnostics file name ${JSON.stringify(name)}.`);
+    }
+  }
+  const inspectLayout = (gateReadable, approvedMarker, legacyOnly = false) => inspectProfileReplicaLayout(profileDir, gateReadable, approvedMarker, legacyOnly, diagnosticFiles);
+  const guard = options.guard;
   const createDevice = options.createDevice ?? createDeviceKey;
-  async function openHandle(spec) {
-    const [replica, sqlite] = await Promise.all([
-      // @ts-ignore — TS2307 when replica's dist is absent (CI builds node-sdk first).
-      import("@tinycloud/replica"),
-      // @ts-ignore — same as above.
-      import("@tinycloud/replica/sqlite")
+  const heldLock = new AsyncLocalStorage();
+  let visibleStamp;
+  let visiblePrincipalHash;
+  let checkedGate;
+  async function profileSection(section) {
+    if (heldLock.getStore() === true) return section();
+    return requiredGuard(guard, () => heldLock.run(true, section));
+  }
+  async function guarded(principal, stamp, identity, partitionId, section) {
+    if (stamp === void 0) throw gated("not_established");
+    if (guard === void 0) throw gated("gate_unavailable");
+    const gate = await fileGate();
+    const snapshot = await gate.readGateSnapshot(profileDir);
+    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, replicationIdentityKey(identity))
     ]);
-    if (requiresSecretsOptIn2(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.`
-      );
-    }
-    const idDir = partitionDirOf(root, spec.identity);
-    await ensurePartitionIdentity(idDir, spec.identity, options.dirSync);
-    const createdDevice = spec.device ?? await loadOrCreateDevice(idDir, guard, createDevice, options.dirSync);
-    const device = { ...createdDevice, did: principalOf(createdDevice.did) };
-    const replicaHash = replicaHashOf(spec.prefix, device.did);
-    const replicaDir = join2(idDir, "replicas", replicaHash);
-    const store = await sqlite.SqliteReplicaStore.open(replicaDir, {
-      create: true,
-      guard
+    return profileSection(async () => {
+      assertLogoutClear(options.logoutPendingFile);
+      await gate.assertGateAccess(profileDir, {
+        stamp,
+        incarnation: snapshot.incarnation,
+        principalHash,
+        identityKeyHash,
+        partitionId
+      }, snapshot.salt);
+      const result = await section();
+      assertLogoutClear(options.logoutPendingFile);
+      return result;
     });
-    let generation;
+  }
+  async function readGated(spec, partitionId, store, replicaDir, generation, section, withFence = false) {
+    if (spec.stamp === void 0) throw gated("not_established");
+    const gate = await fileGate();
+    const snapshot = await gate.readGateSnapshot(profileDir);
+    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, replicationIdentityKey(spec.identity))
+    ]);
+    const access = {
+      stamp: spec.stamp,
+      incarnation: snapshot.incarnation,
+      principalHash,
+      identityKeyHash,
+      partitionId
+    };
+    const path = options.gateFile ?? join2(profileDir, REPLICA_GATE_FILE);
+    let checked;
+    const checkGate = async () => {
+      assertLogoutClear(options.logoutPendingFile);
+      let before;
+      try {
+        before = await stat(path, { bigint: true });
+      } catch {
+        throw gated("gate_unavailable");
+      }
+      if (checked?.ino === before.ino && checked.size === before.size && checked.mtimeNs === before.mtimeNs) return;
+      const checkedState = await gate.assertGateAccess(profileDir, access, snapshot.salt);
+      if (spec.grantPolicy?.consentAnchor === null && checkedState.firstInstall[identityKeyHash] === void 0) {
+        const installed = await store.open();
+        if (installed !== null && (installed.grant !== null || installed.pendingGrant !== null)) throw gated("gate_unavailable");
+      }
+      let after;
+      try {
+        after = await stat(path, { bigint: true });
+      } catch {
+        throw gated("gate_unavailable");
+      }
+      if (before.ino !== after.ino || before.size !== after.size || before.mtimeNs !== after.mtimeNs) {
+        throw gated("gate_unavailable");
+      }
+      checked = after;
+    };
+    if (withFence) await checkGate();
+    const fence = withFence ? await readFence(replicaDir) : 0;
+    return store.readTransaction(generation, checkGate, (sqliteSnapshot) => section(sqliteSnapshot, fence));
+  }
+  async function identityDirs() {
+    let entries;
+    try {
+      entries = await readdir(root, { withFileTypes: true });
+    } catch (error) {
+      if (isNotFound(error)) return [];
+      throw storageError("STORAGE_ERROR", `Listing ${root}`, error);
+    }
+    try {
+      const marker = await readLogoutMarker(join2(profileDir, REPLICA_LOGOUT_PENDING_FILE));
+      if (marker !== null) {
+        const inventory = await inspectLayout(true);
+        assertApprovedInventory(inventory, {
+          unknownEntries: marker.approvedUnknown,
+          knownRoots: marker.knownRoots,
+          knownEntries: marker.knownEntries,
+          missingDatabases: marker.missingDatabases
+        }, true);
+      }
+      for (const entry of entries) {
+        if (entry.isSymbolicLink() || !entry.isDirectory() || !/^[a-z2-7]{26}$/.test(entry.name)) {
+          if (marker?.approvedUnknown.some((item) => item.path === `replication/${entry.name}` && (entry.isDirectory() ? item.kind === "directory" : entry.isSymbolicLink() ? item.kind === "symlink" : item.kind === "file"))) continue;
+          if (diagnosticFiles.includes(entry.name)) {
+            const info = await lstat(join2(root, entry.name)).catch((error) => {
+              if (isNotFound(error)) return null;
+              throw error;
+            });
+            if (info === null || info.isFile()) continue;
+          }
+          throw new ReplicaStorageError("STORAGE_ERROR", `Unknown identity partition at ${root}.`);
+        }
+      }
+      return entries.filter((entry) => entry.isDirectory() && /^[a-z2-7]{26}$/.test(entry.name) && !marker?.approvedUnknown.some((item) => item.path === `replication/${entry.name}` && item.kind === "directory")).map((entry) => join2(root, entry.name));
+    } catch (error) {
+      throw storageError("STORAGE_ERROR", `Listing ${root}`, error);
+    }
+  }
+  async function collectIntents(principalHash, salt) {
+    const gate = await fileGate();
+    const intents = [];
+    for (const idDir of await identityDirs()) {
+      const identity = identityRecordOf(await readJsonFile(join2(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, replicationIdentityKey(identity));
+      const recordedAt = Date.now();
+      if (await pathExists(join2(idDir, "pending.json")) || await pathExists(join2(idDir, "device.jwk"))) {
+        intents.push({ id: `pending:${identityKeyHash}`, kind: "pending", identityKeyHash, principalHash, recordedAt });
+      }
+      const replicasDir = join2(idDir, "replicas");
+      let entries;
+      try {
+        entries = await readdir(replicasDir, { withFileTypes: true });
+      } catch (error) {
+        if (isNotFound(error)) continue;
+        throw storageError("STORAGE_ERROR", `Listing ${replicasDir}`, error);
+      }
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (!/^[a-z2-7]{26}$/.test(entry.name)) {
+          throw new ReplicaStorageError("STORAGE_ERROR", `Unrecognized replica partition at ${replicasDir}.`);
+        }
+        const partitionId = `${identityKeyHash}:${entry.name}`;
+        intents.push({ id: partitionId, kind: "partition", partitionId, principalHash, recordedAt });
+      }
+    }
+    return intents;
+  }
+  async function retainGrantInstalls(gate, gateState, identityKeyHash, store) {
+    for (const { cid, installedAt } of await store.grantInstallTimes()) {
+      const key2 = await gate.grantInstallHashOf(gateState.salt, identityKeyHash, cid);
+      await gate.recordGrantInstall(profileDir, key2, installedAt);
+    }
+  }
+  async function removeCorruptOrphanGate(gate) {
+    const path = join2(profileDir, REPLICA_GATE_FILE);
+    const before = await lstat(path, { bigint: true });
+    if (!before.isFile() || before.isSymbolicLink()) throw gated("gate_unavailable");
+    let corrupt = false;
+    try {
+      await gate.readGateSnapshot(profileDir);
+    } catch (error) {
+      if (typeof error === "object" && error !== null && "code" in error && error.code === "REPLICA_GATED" && "gate" in error && error.gate === "gate_unavailable") {
+        corrupt = true;
+      } else throw error;
+    }
+    if (!corrupt) throw gated("stamp_stale");
+    const current = await lstat(path, { bigint: true });
+    if (current.dev !== before.dev || current.ino !== before.ino || current.mtimeNs !== before.mtimeNs || current.size !== before.size) throw gated("stamp_stale");
+    await rm(path);
+    await (options.dirSync ?? fsyncDir)(profileDir);
+    if (await gate.readGateSnapshot(profileDir) !== void 0) throw gated("stamp_stale");
+  }
+  async function readLogoutState(gate) {
     try {
+      return { read: await gate.readLogoutGate(profileDir), corrupt: false };
+    } catch (error) {
+      if (isGateUnavailable(error)) return { read: void 0, corrupt: true };
+      throw error;
+    }
+  }
+  async function validateV1(gate, path, marker, read, mode) {
+    if (read === void 0 || read.state.incarnation !== marker.incarnation) throw gated("stamp_stale");
+    const { state, floorLagging } = read;
+    if (marker.deniedEpoch !== void 0) {
+      if (floorLagging || !v1Denied(marker, state, marker.deniedEpoch)) throw restoredGate();
+      return { marker, state, active: false };
+    }
+    if (!floorLagging && state.principalHash === null && state.lifecycleEpoch > marker.lifecycleEpoch && (marker.remotePending ? state.eraseDeferred && state.deferredPrincipalHash === marker.principalHash : !state.eraseDeferred && state.deferredPrincipalHash === null)) {
+      return { marker: await bindDeniedEpoch(path, marker, state.lifecycleEpoch), state, active: false };
+    }
+    if (state.principalHash !== marker.principalHash || state.lifecycleEpoch !== marker.lifecycleEpoch) {
+      throw gated("stamp_stale");
+    }
+    if (!floorLagging && !mode.denyActive) {
+      if (!mode.active) throw gated("stamp_stale");
+      return { marker, state, active: true };
+    }
+    if (mode.acceptLagging) return { marker, state, active: true };
+    if (mode.deny === void 0) throw interruptedSignOut();
+    const denied = await gate.denyGate(
+      profileDir,
+      { reason: "sign_out", principal: "" },
+      (principalHash) => collectIntents(principalHash, state.salt),
+      { salt: state.salt, principalHash: marker.principalHash },
+      { deferErase: mode.deny === "deferred" }
+    );
+    if (denied.status !== "denied") throw gated("gate_unavailable");
+    const after = await gate.readLogoutGate(profileDir);
+    if (after === void 0 || after.floorLagging || !v1Denied(marker, after.state, denied.lifecycleEpoch)) {
+      throw gated("gate_unavailable");
+    }
+    return { marker: await bindDeniedEpoch(path, marker, denied.lifecycleEpoch), state: after.state, active: false };
+  }
+  function v1Denied(marker, state, epoch) {
+    return state.incarnation === marker.incarnation && state.principalHash === null && state.lifecycleEpoch === epoch && (state.deferredPrincipalHash === marker.principalHash || !marker.remotePending && !state.eraseDeferred && state.deferredPrincipalHash === null);
+  }
+  async function bindDeniedEpoch(path, marker, deniedEpoch) {
+    if (marker.deniedEpoch !== void 0) throw gated("stamp_stale");
+    const bound = { ...marker, deniedEpoch };
+    await writeJsonAtomic(path, bound, options.dirSync);
+    return bound;
+  }
+  async function validatedRemoteMarker(path, marker, principal, mode) {
+    if (marker.principalDigest !== logoutPrincipalDigest(principal)) throw gated("principal_mismatch");
+    const gate = await fileGate();
+    const { read, corrupt } = await readLogoutState(gate);
+    if (corrupt) throw gated("gate_unavailable");
+    if (marker.v === 2) {
+      if (read !== void 0) throw gated("stamp_stale");
+      return { marker, state: void 0 };
+    }
+    if (read === void 0 || read.state.incarnation !== marker.incarnation) throw gated("stamp_stale");
+    if (marker.v === 3) {
+      if (read.floorLagging || read.state.lifecycleEpoch !== marker.lifecycleEpoch || read.state.principalHash !== null || read.state.eraseDeferred) throw gated("stamp_stale");
+      return { marker, state: read.state };
+    }
+    if (marker.principalHash !== await gate.principalHashOf(read.state.salt, principal)) {
+      throw gated("principal_mismatch");
+    }
+    const checked = await validateV1(gate, path, marker, read, mode);
+    return { marker: checked.marker, state: checked.state };
+  }
+  async function currentLayout() {
+    const { read, corrupt } = await readLogoutState(await fileGate());
+    if (corrupt) throw gated("gate_unavailable");
+    const report = await inspectLayout(read !== void 0);
+    assertSupportedProfileLayout(report);
+    return report;
+  }
+  async function commitPlainAbandon(path, marker, report, discardLocalChanges) {
+    const { remotePending: _, discardLocalChanges: _oldDiscard, ...previous } = marker;
+    const abandoned = {
+      ...previous,
+      remoteAbandoned: true,
+      approvedUnknown: discardLocalChanges ? report.unknownEntries : [],
+      knownRoots: report.knownRoots,
+      knownEntries: report.knownEntries,
+      missingDatabases: report.missingDatabases,
+      ...discardLocalChanges ? { discardLocalChanges: true } : {}
+    };
+    await writeJsonAtomic(path, abandoned, options.dirSync);
+    return abandoned;
+  }
+  function deny(input, denyOptions) {
+    const deferErase = denyOptions?.deferErase === true;
+    if (deferErase && input.reason !== "sign_out") {
+      throw new TypeError("Deferred erase is only available for sign-out.");
+    }
+    visibleStamp = void 0;
+    visiblePrincipalHash = void 0;
+    checkedGate = void 0;
+    return (async () => {
       try {
-        await store.init({
-          name: spec.prefix.replace(/\/+$/, "") || "replica",
-          replicaId: replicaHash,
-          host: spec.identity.host,
-          space: spec.space,
-          prefix: spec.prefix,
-          deviceDid: device.did,
-          allowSecrets: spec.allowSecrets,
-          localReadPolicy: "whileGrantValid",
-          retentionGrantCid: null
+        const gate = await fileGate();
+        return await profileSection(async () => {
+          const snapshot = (await gate.readLogoutGate(profileDir))?.state;
+          const precomputed = snapshot === void 0 ? void 0 : {
+            salt: snapshot.salt,
+            principalHash: await gate.principalHashOf(snapshot.salt, input.principal)
+          };
+          const result = await gate.denyGate(
+            profileDir,
+            input,
+            async (principalHash) => {
+              if (snapshot === void 0) throw gated("gate_unavailable");
+              return collectIntents(principalHash, snapshot.salt);
+            },
+            precomputed,
+            { deferErase }
+          );
+          if (result.status !== "denied") return result;
+          if (input.reason === "sign_out" && snapshot !== void 0 && precomputed !== void 0) {
+            const path = join2(profileDir, REPLICA_LOGOUT_PENDING_FILE);
+            const marker = await readLogoutMarker(path);
+            if (marker?.v === 1 && marker.deniedEpoch === void 0 && marker.incarnation === snapshot.incarnation && marker.principalHash === precomputed.principalHash && marker.remotePending === true === deferErase) {
+              await bindDeniedEpoch(path, marker, result.lifecycleEpoch);
+            }
+          }
+          if (!deferErase) return result;
+          const resumeToken = await gate.deferredGateToken(profileDir);
+          if (resumeToken === null || resumeToken.deniedEpoch !== result.lifecycleEpoch) {
+            return { status: "unguarded", code: "gate_unavailable" };
+          }
+          return { ...result, resumeToken };
         });
       } catch (error) {
-        if (!replica.isReplicaError(error, replica.ReplicaErrorCode.CONFIG_MISMATCH)) {
-          throw error;
+        return { status: "unguarded", code: typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : "gate_unavailable" };
+      }
+    })();
+  }
+  const lifecycle = {
+    kind: "file",
+    async recover({ signal }) {
+      try {
+        return await lifecycle.erasePending({ signal });
+      } catch (error) {
+        const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : "STORAGE_ERROR";
+        let remaining = 0;
+        try {
+          remaining = (await (await fileGate()).readGateSnapshot(profileDir))?.intents.length ?? 0;
+        } catch {
         }
+        return { erased: [], failed: [{ id: "gate", code }], remaining };
       }
-      const state = await store.open();
-      if (state === null) {
-        throw new replica.ReplicaError(
-          replica.ReplicaErrorCode.NOT_FOUND,
-          "The replica row vanished during init."
-        );
+    },
+    async establishSessionStamp(principal, { consentAnchor }) {
+      if (consentAnchor?.source === "first_install" || !Number.isSafeInteger(consentAnchor?.at) || consentAnchor.at < 0) {
+        throw gated("not_established");
+      }
+      const gate = await fileGate();
+      const stamp = await profileSection(async () => {
+        assertLogoutClear(options.logoutPendingFile);
+        return gate.establishSessionStamp(profileDir, principal, { siweIssuedAt: consentAnchor.at });
+      });
+      const state = await gate.readGateSnapshot(profileDir);
+      if (state === void 0) throw gated("gate_unavailable");
+      visiblePrincipalHash = await gate.principalHashOf(state.salt, principal);
+      checkedGate = void 0;
+      visibleStamp = stamp;
+      return stamp;
+    },
+    async restoreSessionStamp(principal, persisted) {
+      const gate = await fileGate();
+      const stamp = await profileSection(async () => {
+        assertLogoutClear(options.logoutPendingFile);
+        return gate.restoreSessionStamp(profileDir, principal, persisted);
+      });
+      const state = await gate.readGateSnapshot(profileDir);
+      if (state === void 0) throw gated("gate_unavailable");
+      visiblePrincipalHash = await gate.principalHashOf(state.salt, principal);
+      checkedGate = void 0;
+      visibleStamp = stamp;
+      return stamp;
+    },
+    async activationAllowed(next) {
+      if (guard === void 0) return false;
+      try {
+        const gate = await fileGate();
+        return await profileSection(async () => {
+          assertLogoutClear(options.logoutPendingFile);
+          const state = await gate.readGateSnapshot(profileDir);
+          return state !== void 0 && !state.eraseDeferred && state.intents.length === 0 && state.principalHash !== null && state.principalHash === await gate.principalHashOf(state.salt, next);
+        });
+      } catch {
+        return false;
       }
-      const config = state.config;
-      if (config.host !== spec.identity.host || config.space !== spec.space || config.prefix !== spec.prefix) {
-        throw new replica.ReplicaError(
-          replica.ReplicaErrorCode.CONFIG_MISMATCH,
-          `This replica follows ${config.host} ${config.space}/kv/${config.prefix}, not ${spec.identity.host} ${spec.space}/kv/${spec.prefix}.`
-        );
+    },
+    checkDelivery(stamp) {
+      if (guard === void 0 || visiblePrincipalHash === void 0) return { status: "gated", gate: "gate_unavailable" };
+      try {
+        assertLogoutClear(options.logoutPendingFile);
+      } catch {
+        return { status: "gated", gate: "gate_unavailable" };
       }
-      if (principalOf(config.deviceDid) !== principalOf(device.did)) {
-        throw new replica.ReplicaError(
-          replica.ReplicaErrorCode.CONFIG_MISMATCH,
-          "The stored replica belongs to a different device key; purge the partition to rekey."
-        );
+      if (!stamp || visibleStamp?.incarnation !== stamp.incarnation || visibleStamp.lifecycleEpoch !== stamp.lifecycleEpoch) {
+        return { status: "gated", gate: "stamp_stale" };
       }
-      generation = state.generation;
-    } catch (error) {
-      await store.close().catch(() => void 0);
-      throw error;
+      try {
+        const path = options.gateFile ?? join2(profileDir, REPLICA_GATE_FILE);
+        const stats = statSync(path, { bigint: true });
+        if (checkedGate === void 0 || checkedGate.ino !== stats.ino || checkedGate.mtimeNs !== stats.mtimeNs || checkedGate.size !== stats.size) {
+          const raw = JSON.parse(readFileSync2(path, "utf8"));
+          if (typeof raw.incarnation !== "string" || !Number.isSafeInteger(raw.lifecycleEpoch) || raw.principalHash !== null && typeof raw.principalHash !== "string" || !Array.isArray(raw.intents)) {
+            return { status: "gated", gate: "gate_unavailable" };
+          }
+          checkedGate = {
+            ino: stats.ino,
+            mtimeNs: stats.mtimeNs,
+            size: stats.size,
+            incarnation: raw.incarnation,
+            epoch: raw.lifecycleEpoch,
+            principalHash: raw.principalHash
+          };
+        }
+      } catch {
+        return { status: "gated", gate: "gate_unavailable" };
+      }
+      if (checkedGate.incarnation !== stamp.incarnation || checkedGate.epoch !== stamp.lifecycleEpoch) {
+        return { status: "gated", gate: "stamp_stale" };
+      }
+      return checkedGate.principalHash === visiblePrincipalHash ? { status: "allow" } : { status: "gated", gate: "principal_mismatch" };
+    },
+    consentDeadline() {
+      return null;
+    },
+    deliverable(stamp) {
+      return lifecycle.checkDelivery(stamp).status === "allow";
+    },
+    deny,
+    deferredErase() {
+      return profileSection(async () => (await fileGate()).deferredGateToken(profileDir));
+    },
+    async resumeDeferredErase(token, { signal }) {
+      signal.throwIfAborted();
+      await profileSection(async () => (await fileGate()).resumeDeferredGate(profileDir, token));
+      return lifecycle.erasePending({ signal });
+    },
+    async preflightLogout({ principal, discardLocalChanges = false }) {
+      return profileSection(async () => {
+        const marker = await readLogoutMarker(join2(profileDir, REPLICA_LOGOUT_PENDING_FILE));
+        const gate = await fileGate();
+        const { read, corrupt } = await readLogoutState(gate);
+        const state = read?.state;
+        let otherAccount = false;
+        if (state !== void 0) {
+          const hash3 = await gate.principalHashOf(state.salt, principal);
+          otherAccount = gateOwnedByAnother(state, hash3);
+          if (marker?.v === 1 && marker.principalHash !== hash3) throw gated("principal_mismatch");
+        }
+        const report = await inspectLayout(state !== void 0, void 0, otherAccount);
+        assertSupportedProfileLayout(report);
+        if (!discardLocalChanges && (report.unknownPaths.length > 0 || corrupt && !otherAccount || !otherAccount && (state === void 0 || state.principalHash === null && !state.eraseDeferred) && await hasOrphanPending(profileDir))) {
+          throw localChangesRefusal(report.unknownPaths);
+        }
+        return report;
+      });
+    },
+    async prepareLogoutPending({ principal, approval, discardLocalChanges = false, remotePending }) {
+      const gate = await fileGate();
+      return profileSection(async () => {
+        const path = join2(profileDir, REPLICA_LOGOUT_PENDING_FILE);
+        const previous = await readLogoutMarker(path);
+        const { read, corrupt: corruptGate } = await readLogoutState(gate);
+        let state = read?.state;
+        const principalHash = state === void 0 ? void 0 : await gate.principalHashOf(state.salt, principal);
+        const otherAccount = state !== void 0 && gateOwnedByAnother(state, principalHash);
+        let report = await inspectLayout(state !== void 0, void 0, otherAccount);
+        assertSupportedProfileLayout(report);
+        const assertApproved = (current) => {
+          assertApprovedInventory(current, approval);
+          if (approval.knownLegacyReplicas !== current.knownLegacyReplicas || JSON.stringify(approval.unknownPaths) !== JSON.stringify(current.unknownPaths) || JSON.stringify(approval.unknownLegacyPaths) !== JSON.stringify(current.unknownLegacyPaths)) {
+            throw localChangesRefusal(current.unknownPaths);
+          }
+        };
+        assertApproved(report);
+        if (otherAccount) {
+          if (previous !== null) throw gated("principal_mismatch");
+          if (!discardLocalChanges && report.unknownPaths.length > 0) throw localChangesRefusal(report.unknownPaths);
+          return null;
+        }
+        if (!discardLocalChanges && (report.unknownPaths.length > 0 || corruptGate || (state === void 0 || state.principalHash === null && !state.eraseDeferred) && await hasOrphanPending(profileDir))) {
+          throw localChangesRefusal(report.unknownPaths);
+        }
+        if (previous !== null) {
+          if (previous.principalDigest !== logoutPrincipalDigest(principal)) throw gated("principal_mismatch");
+          if (corruptGate) throw gated("gate_unavailable");
+          let current = previous;
+          if (previous.v === 2) {
+            if (read !== void 0) throw gated("stamp_stale");
+          } else if (read === void 0 || previous.incarnation !== read.state.incarnation) {
+            throw gated("stamp_stale");
+          } else if (previous.v === 3) {
+            if (read.floorLagging || read.state.lifecycleEpoch !== previous.lifecycleEpoch || read.state.principalHash !== null || read.state.eraseDeferred) throw gated("stamp_stale");
+          } else {
+            if (previous.principalHash !== principalHash) throw gated("principal_mismatch");
+            current = (await validateV1(gate, path, previous, read, { active: true, acceptLagging: true })).marker;
+          }
+          assertApprovedInventory(report, {
+            unknownEntries: current.approvedUnknown,
+            knownRoots: current.knownRoots,
+            knownEntries: current.knownEntries,
+            missingDatabases: current.missingDatabases
+          });
+          if (current.remotePending !== remotePending || current.remoteAbandoned) {
+            throw gated("gate_unavailable");
+          }
+          return current;
+        }
+        if (state?.eraseDeferred) throw gated("stamp_stale");
+        if (read?.floorLagging) {
+          if (state.principalHash === null) {
+            state = await gate.advanceInactiveGate(profileDir);
+          } else {
+            const salt = state.salt;
+            const denied = await gate.denyGate(
+              profileDir,
+              { reason: "sign_out", principal },
+              (hash3) => collectIntents(hash3, salt),
+              { salt, principalHash }
+            );
+            if (denied.status !== "denied") throw gated("gate_unavailable");
+            state = await gate.readGateSnapshot(profileDir);
+          }
+          report = await inspectLayout(true);
+          assertSupportedProfileLayout(report);
+          assertApproved(report);
+        }
+        if (state === void 0 && report.knownRoots.length === 0 && !corruptGate) return null;
+        if (state !== void 0 && state.principalHash === null && !state.eraseDeferred && report.knownRoots.length === 0 && state.intents.length === 0) return null;
+        const remoteState = remotePending ? { remotePending: true } : {};
+        const approvalFields = {
+          principalDigest: logoutPrincipalDigest(principal),
+          approvalSalt: randomBytes2(16).toString("hex"),
+          approvedUnknown: discardLocalChanges ? report.unknownEntries : [],
+          knownRoots: report.knownRoots,
+          knownEntries: report.knownEntries,
+          missingDatabases: report.missingDatabases,
+          ...discardLocalChanges ? { discardLocalChanges: true } : {},
+          ...remoteState
+        };
+        let marker;
+        if (state === void 0) {
+          marker = {
+            v: 2,
+            scope: "orphan_profile",
+            nonce: randomBytes2(16).toString("hex"),
+            ...approvalFields
+          };
+        } else if (state.principalHash === null) {
+          marker = {
+            v: 3,
+            scope: "inactive_gate",
+            incarnation: state.incarnation,
+            lifecycleEpoch: state.lifecycleEpoch,
+            ...approvalFields
+          };
+        } else {
+          marker = {
+            v: 1,
+            incarnation: state.incarnation,
+            lifecycleEpoch: state.lifecycleEpoch,
+            principalHash,
+            ...approvalFields
+          };
+        }
+        await writeJsonAtomic(path, marker, options.dirSync);
+        visibleStamp = void 0;
+        visiblePrincipalHash = void 0;
+        checkedGate = void 0;
+        if (corruptGate) await removeCorruptOrphanGate(gate);
+        return marker;
+      });
+    },
+    async completeRemoteLogout({ principal }) {
+      return profileSection(async () => {
+        const path = join2(profileDir, REPLICA_LOGOUT_PENDING_FILE);
+        const marker = await readLogoutMarker(path);
+        if (marker === null || marker.remotePending !== true) throw gated("gate_unavailable");
+        const checked = await validatedRemoteMarker(path, marker, principal, { active: false });
+        const { remotePending: _, ...complete } = checked.marker;
+        await writeJsonAtomic(path, complete, options.dirSync);
+        return complete;
+      });
+    },
+    async remotePendingLogout({ principal }) {
+      return profileSection(async () => {
+        const path = join2(profileDir, REPLICA_LOGOUT_PENDING_FILE);
+        const marker = await readLogoutMarker(path);
+        if (marker === null || marker.remotePending !== true) return false;
+        await validatedRemoteMarker(path, marker, principal, { active: false });
+        return true;
+      });
+    },
+    async abandonRemoteLogout({ principal, approval, discardLocalChanges = false }) {
+      return profileSection(async () => {
+        const path = join2(profileDir, REPLICA_LOGOUT_PENDING_FILE);
+        const marker = await readLogoutMarker(path);
+        if (marker === null || marker.remotePending !== true) throw gated("gate_unavailable");
+        if (marker.principalDigest !== logoutPrincipalDigest(principal)) throw gated("principal_mismatch");
+        const report = await currentLayout();
+        if (storedInventoryChanged(marker, report)) throw changedInventoryRefusal(marker, principal, report);
+        assertApprovedInventory(report, approval);
+        if (approval.knownLegacyReplicas !== report.knownLegacyReplicas || JSON.stringify(approval.unknownPaths) !== JSON.stringify(report.unknownPaths) || JSON.stringify(approval.unknownLegacyPaths) !== JSON.stringify(report.unknownLegacyPaths) || !discardLocalChanges && report.unknownPaths.length > 0) {
+          throw localChangesRefusal(report.unknownPaths);
+        }
+        const checked = await validatedRemoteMarker(path, marker, principal, { active: true, deny: "deferred" });
+        return commitPlainAbandon(path, checked.marker, report, discardLocalChanges);
+      });
+    },
+    async approveChangedPlainLogout({ principal, approval, discardLocalChanges, inventoryApprovalToken: token }) {
+      return profileSection(async () => {
+        const path = join2(profileDir, REPLICA_LOGOUT_PENDING_FILE);
+        const marker = await readLogoutMarker(path);
+        if (marker === null || marker.remotePending !== true) throw gated("gate_unavailable");
+        if (marker.principalDigest !== logoutPrincipalDigest(principal)) throw gated("principal_mismatch");
+        const report = await currentLayout();
+        if (!storedInventoryChanged(marker, report)) throw gated("gate_unavailable");
+        const entries = approvalEntries(report);
+        if (discardLocalChanges !== true || typeof token !== "string" || !/^[0-9a-f]{32}$/.test(token) || token !== inventoryApprovalToken(marker, principal, entries)) {
+          throw changedInventoryRefusal(marker, principal, report, entries);
+        }
+        assertApprovedInventory(report, approval);
+        if (approval.knownLegacyReplicas !== report.knownLegacyReplicas || JSON.stringify(approval.unknownPaths) !== JSON.stringify(report.unknownPaths) || JSON.stringify(approval.unknownLegacyPaths) !== JSON.stringify(report.unknownLegacyPaths)) {
+          throw changedInventoryRefusal(marker, principal, report, entries);
+        }
+        const checked = await validatedRemoteMarker(path, marker, principal, { active: true, deny: "deferred" });
+        return commitPlainAbandon(path, checked.marker, report, true);
+      });
+    },
+    async reapproveLogoutPending({ principal, approval }) {
+      return profileSection(async () => {
+        const path = join2(profileDir, REPLICA_LOGOUT_PENDING_FILE);
+        const marker = await readLogoutMarker(path);
+        if (marker === null || marker.remotePending) throw gated("gate_unavailable");
+        if (marker.principalDigest !== logoutPrincipalDigest(principal)) throw gated("principal_mismatch");
+        const report = await currentLayout();
+        assertApprovedInventory(report, approval);
+        if (JSON.stringify(report.unknownPaths) !== JSON.stringify(approval.unknownPaths)) {
+          throw localChangesRefusal(report.unknownPaths);
+        }
+        const checked = await validatedRemoteMarker(path, marker, principal, { active: true });
+        const amended = {
+          ...checked.marker,
+          approvedUnknown: report.unknownEntries,
+          knownRoots: report.knownRoots,
+          knownEntries: report.knownEntries,
+          missingDatabases: report.missingDatabases,
+          ...report.unknownPaths.length > 0 ? { discardLocalChanges: true } : {}
+        };
+        await writeJsonAtomic(path, amended, options.dirSync);
+        return amended;
+      });
+    },
+    async recoverLogoutPending({ signal, clearCredentials, eraseLegacyReplicas }) {
+      const path = join2(profileDir, REPLICA_LOGOUT_PENDING_FILE);
+      const failure = async (error) => ({
+        erased: [],
+        failed: [{ id: "logout", code: typeof error === "object" && error !== null && "reportCode" in error && typeof error.reportCode === "string" ? error.reportCode : typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code === "REPLICA_GATED" && "gate" in error && typeof error.gate === "string" ? error.gate : error.code : "STORAGE_ERROR" }],
+        remaining: Math.max(1, (await lifecycle.pendingPurge().catch(() => [])).length)
+      });
+      try {
+        const prepared = await profileSection(async () => {
+          const marker2 = await readLogoutMarker(path);
+          if (marker2 === null) {
+            const state2 = await (await fileGate()).readGateSnapshot(profileDir);
+            return { report: { erased: [], failed: [], remaining: state2?.intents.length ?? 0 } };
+          }
+          signal.throwIfAborted();
+          if (marker2.remotePending) throw gated("gate_unavailable");
+          const gate = await fileGate();
+          const { read, corrupt } = await readLogoutState(gate);
+          if (corrupt) throw gated("gate_unavailable");
+          let current = marker2;
+          let state = read?.state;
+          if (marker2.v === 2) {
+            if (read !== void 0) throw gated("stamp_stale");
+          } else if (read === void 0 || read.state.incarnation !== marker2.incarnation) {
+            throw gated("stamp_stale");
+          } else if (marker2.v === 3) {
+            if (read.floorLagging || read.state.principalHash !== null || read.state.eraseDeferred || read.state.lifecycleEpoch !== marker2.lifecycleEpoch) throw gated("stamp_stale");
+          } else {
+            const checked = await validateV1(
+              gate,
+              path,
+              marker2,
+              read,
+              { active: true, deny: "ordinary", denyActive: true }
+            );
+            current = checked.marker;
+            state = checked.state;
+          }
+          await clearCredentials();
+          for (const file of ["session.json", "key.json"]) {
+            try {
+              await lstat(join2(profileDir, file));
+              throw gated("gate_unavailable");
+            } catch (error) {
+              if (!isNotFound(error)) throw error;
+            }
+          }
+          await (options.dirSync ?? fsyncDir)(profileDir);
+          const report = await inspectLayout(state !== void 0, marker2);
+          assertApprovedInventory(report, {
+            unknownEntries: marker2.approvedUnknown,
+            knownRoots: marker2.knownRoots,
+            knownEntries: marker2.knownEntries,
+            missingDatabases: marker2.missingDatabases
+          }, true);
+          if (!marker2.discardLocalChanges && report.unknownEntries.length > 0) {
+            throw localChangesRefusal(report.unknownPaths);
+          }
+          if (current.v === 1 && state?.eraseDeferred) {
+            await gate.resumeDeferredGate(profileDir, {
+              deniedEpoch: current.deniedEpoch,
+              principalHash: current.principalHash
+            });
+          }
+          await eraseLegacyReplicas({
+            discardLocalChanges: marker2.discardLocalChanges === true,
+            approvedUnknown: marker2.approvedUnknown,
+            knownRoots: marker2.knownRoots,
+            knownEntries: marker2.knownEntries,
+            missingDatabases: marker2.missingDatabases
+          });
+          try {
+            await lstat(join2(profileDir, "replicas"));
+            throw gated("gate_unavailable");
+          } catch (error) {
+            if (!isNotFound(error)) throw error;
+          }
+          return { marker: current };
+        });
+        if ("report" in prepared) return prepared.report;
+        const marker = prepared.marker;
+        let erased = { erased: [], failed: [], remaining: 0 };
+        if (marker.v !== 2) {
+          erased = await eraseGateIntents({ signal }, marker);
+          if (erased.failed.length > 0 || erased.remaining > 0) return erased;
+        }
+        await profileSection(async () => {
+          const pending = await readLogoutMarker(path);
+          if (pending === null || pending.remotePending || JSON.stringify(pending) !== JSON.stringify(marker)) {
+            throw gated("stamp_stale");
+          }
+          const gate = await fileGate();
+          const state = await gate.readGateSnapshot(profileDir);
+          if (marker.v === 2 && state !== void 0) throw gated("stamp_stale");
+          const report = await inspectLayout(state !== void 0, marker);
+          assertApprovedInventory(report, {
+            unknownEntries: marker.approvedUnknown,
+            knownRoots: marker.knownRoots,
+            knownEntries: marker.knownEntries,
+            missingDatabases: marker.missingDatabases
+          }, true);
+          await eraseApprovedUnknown(profileDir, marker, "replication", diagnosticFiles);
+          await eraseKnownFlagResidue(profileDir, marker, diagnosticFiles);
+          const finalReport = await inspectLayout(state !== void 0, marker);
+          assertApprovedInventory(finalReport, {
+            unknownEntries: marker.approvedUnknown,
+            knownRoots: marker.knownRoots,
+            knownEntries: marker.knownEntries,
+            missingDatabases: marker.missingDatabases
+          }, true);
+          if (finalReport.unknownPaths.length > 0) throw localChangesRefusal(finalReport.unknownPaths);
+          if (finalReport.knownRoots.length > 0) throw gated("gate_unavailable");
+          await (options.dirSync ?? fsyncDir)(profileDir);
+          await rm(path);
+          await (options.dirSync ?? fsyncDir)(profileDir);
+        });
+        return erased;
+      } catch (error) {
+        return failure(error);
+      }
+    },
+    async pendingPurge() {
+      const gate = await fileGate();
+      return (await gate.readGateSnapshot(profileDir))?.intents ?? [];
+    },
+    erasePending({ signal }) {
+      return eraseGateIntents({ signal });
     }
-    let ino;
+  };
+  async function eraseGateIntents({ signal }, marker) {
+    const gate = await fileGate();
+    const erased = [];
+    const failed = [];
+    const intents = await lifecycle.pendingPurge();
     try {
-      ino = (await stat(join2(replicaDir, "replica.db"))).ino;
-    } catch (error) {
-      if (!isNotFound(error)) throw error;
-    }
-    return new SqliteReplicaHandle({
-      spec,
-      device,
-      store,
-      replicaDir,
-      replica,
-      guard,
-      transportFor: options.transportFor,
-      dirSync: options.dirSync,
-      generation,
-      ino
+      if (marker === void 0) assertLogoutClear(options.logoutPendingFile);
+      else if (marker.remotePending || await readLogoutMarker(join2(profileDir, REPLICA_LOGOUT_PENDING_FILE)) === null) {
+        throw gated("gate_unavailable");
+      }
+    } catch {
+      return { erased, failed: [{ id: "logout", code: "REPLICA_GATED" }], remaining: Math.max(1, intents.length) };
+    }
+    const held = await profileSection(() => gate.readGateSnapshot(profileDir));
+    if (held?.eraseDeferred) return { erased, failed, remaining: held.intents.length, deferred: true };
+    for (const intent of intents) {
+      signal.throwIfAborted();
+      try {
+        await profileSection(async () => {
+          if (marker === void 0) assertLogoutClear(options.logoutPendingFile);
+          else {
+            const pending = await readLogoutMarker(join2(profileDir, REPLICA_LOGOUT_PENDING_FILE));
+            if (pending === null || pending.remotePending || JSON.stringify(pending) !== JSON.stringify(marker)) {
+              throw gated("gate_unavailable");
+            }
+            assertApprovedInventory(await inspectLayout(true), {
+              unknownEntries: marker.approvedUnknown,
+              knownRoots: marker.knownRoots,
+              knownEntries: marker.knownEntries,
+              missingDatabases: marker.missingDatabases
+            }, true);
+          }
+          const state = await gate.readGateSnapshot(profileDir);
+          if (state?.eraseDeferred) return;
+          if (!state?.intents.some((queued) => queued.id === intent.id)) return;
+          let idDir;
+          for (const dir of await identityDirs()) {
+            const identity = identityRecordOf(await readJsonFile(join2(dir, "identity.json")));
+            if (identity === void 0) throw new ReplicaStorageError("STORAGE_ERROR", `Missing identity at ${dir}.`);
+            const hash3 = await gate.identityHashOf(state.salt, replicationIdentityKey(identity));
+            if (intent.kind === "pending" ? hash3 === intent.identityKeyHash : intent.partitionId.startsWith(`${hash3}:`)) {
+              idDir = dir;
+              break;
+            }
+          }
+          if (intent.kind === "pending") {
+            if (intent.id !== `pending:${intent.identityKeyHash}`) throw gated("gate_unavailable");
+            if (idDir !== void 0) {
+              for (const name of ["pending.json", "device.jwk"]) {
+                const file = join2(idDir, name);
+                let info;
+                try {
+                  info = await lstat(file, { bigint: true });
+                } catch (error) {
+                  if (isNotFound(error)) continue;
+                  throw error;
+                }
+                if (!info.isFile()) throw gated("gate_unavailable");
+                if (marker !== void 0) {
+                  const relative = `replication/${basename(idDir)}/${name}`;
+                  const expected = [...marker.knownEntries, ...marker.approvedUnknown].find(
+                    (item) => item.path === relative
+                  );
+                  if (expected?.kind !== "file" || expected.dev !== info.dev.toString() || expected.ino !== info.ino.toString()) throw localChangesRefusal([relative]);
+                }
+                await rm(file);
+              }
+              await fsyncDir(idDir);
+            }
+          } else {
+            if (!/^[0-9a-f]{64}:[a-z2-7]{26}$/.test(intent.partitionId) || intent.id !== intent.partitionId) {
+              throw gated("gate_unavailable");
+            }
+            if (idDir !== void 0) {
+              const replicaDir = join2(idDir, "replicas", intent.partitionId.slice(65));
+              let dirInfo;
+              if (await realDirectoryExists(join2(idDir, "replicas"))) {
+                try {
+                  dirInfo = await lstat(replicaDir, { bigint: true });
+                } catch (error) {
+                  if (!isNotFound(error)) throw error;
+                }
+              }
+              if (dirInfo !== void 0) {
+                const relative = `replication/${basename(idDir)}/replicas/${basename(replicaDir)}`;
+                const expectedRoot = marker?.knownRoots.find((item) => item.path === relative);
+                if (!dirInfo.isDirectory() || marker !== void 0 && (expectedRoot?.dev !== dirInfo.dev.toString() || expectedRoot.ino !== dirInfo.ino.toString())) throw localChangesRefusal([relative]);
+                const approvedUnknown = marker?.approvedUnknown.filter(
+                  (item) => item.path.startsWith(`${relative}/`)
+                ).map(
+                  (item) => ({ ...item, path: item.path.slice(relative.length + 1) })
+                );
+                const expectedKnown = marker?.knownEntries.filter(
+                  (item) => item.path.startsWith(`${relative}/`)
+                ).map(
+                  (item) => ({ ...item, path: item.path.slice(relative.length + 1) })
+                );
+                const sqlite = await import("@tinycloud/replica/sqlite");
+                if (!await pathExists(join2(replicaDir, "replica.db"))) {
+                  const layout = await sqlite.inspectSqliteReplicaLayout(replicaDir, { allowAdapterFence: true });
+                  if (!layout.unknownPaths.includes("replica.db") || layout.unknownEntries.some((item) => item.path === "replica.db") || layout.unknownPaths.some((path) => path !== "replica.db" && !approvedUnknown?.some((item) => item.path === path))) {
+                    throw localChangesRefusal([relative]);
+                  }
+                  await sqlite.removeSqliteReplicaLayout(replicaDir, {
+                    approvedUnknown,
+                    expectedKnown: layout.knownEntries,
+                    expectedRoot,
+                    allowAdapterFence: true,
+                    allowMissingDatabase: true
+                  });
+                } else {
+                  let store;
+                  try {
+                    store = await sqlite.SqliteReplicaStore.open(replicaDir, { create: false, guard: profileSection });
+                    const row = await store.open();
+                    if (row !== null) {
+                      const lease = await store.acquireSyncLease(SYNC_LEASE_TTL_MS);
+                      if (lease === null) throw gated("gate_unavailable");
+                      try {
+                        if (row.revoked === null) await store.reset(lease, "purged");
+                        let deletionKnown = expectedKnown;
+                        if (marker !== void 0) {
+                          const current = await sqlite.inspectSqliteReplicaLayout(replicaDir, {
+                            allowAdapterFence: true
+                          });
+                          if (current.rootIdentity.dev !== expectedRoot?.dev || current.rootIdentity.ino !== expectedRoot.ino) throw localChangesRefusal([relative]);
+                          const approved = new Map(expectedKnown?.map((entry) => [entry.path, entry]));
+                          for (const entry of current.knownEntries) {
+                            const prior = approved.get(entry.path);
+                            if (prior?.kind === entry.kind && prior.dev === entry.dev && prior.ino === entry.ino) continue;
+                            if (entry.kind !== "file" || !["replica.db-wal", "replica.db-shm", "replica.db-journal"].includes(entry.path)) {
+                              throw localChangesRefusal([`${relative}/${entry.path}`]);
+                            }
+                          }
+                          deletionKnown = current.knownEntries;
+                        }
+                        await store.destroy(lease, {
+                          approvedUnknown,
+                          expectedKnown: deletionKnown,
+                          expectedRoot,
+                          allowAdapterFence: true
+                        });
+                      } finally {
+                        await store.releaseLease(lease).catch(() => void 0);
+                      }
+                    } else {
+                      await sqlite.removeSqliteReplicaLayout(replicaDir, {
+                        approvedUnknown,
+                        expectedKnown,
+                        expectedRoot,
+                        allowAdapterFence: true
+                      });
+                    }
+                  } finally {
+                    await store?.close().catch(() => void 0);
+                  }
+                }
+                await fsyncDir(join2(idDir, "replicas"));
+              }
+            }
+          }
+          await gate.clearGateIntent(profileDir, intent.id);
+          erased.push(intent.id);
+        });
+      } catch (error) {
+        failed.push({ id: intent.id, code: typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : "STORAGE_ERROR" });
+      }
+    }
+    return { erased, failed, remaining: (await lifecycle.pendingPurge()).length };
+  }
+  async function openHandle(spec) {
+    const [replica, sqlite] = await Promise.all([
+      // @ts-ignore — TS2307 when replica's dist is absent (CI builds node-sdk first).
+      import("@tinycloud/replica"),
+      // @ts-ignore — same as above.
+      import("@tinycloud/replica/sqlite")
+    ]);
+    if (spec.stamp === void 0) throw gated("not_established");
+    if (guard === void 0) throw gated("gate_unavailable");
+    if (spec.grantPolicy === void 0) {
+      throw new ReplicaStorageError("REPLICA_INVALID_ARGUMENT", "A replica grant policy is required.");
+    }
+    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, replicationIdentityKey(spec.identity));
+    const resolvePolicy = async (at, recordFirst) => {
+      const policy = spec.grantPolicy;
+      if (!Number.isSafeInteger(policy.grantTtlMs) || policy.grantTtlMs <= 0 || policy.grantTtlMs > MAX_GRANT_TTL_MS2) {
+        throw new TypeError("A replica grant requires a finite TTL not exceeding seven days.");
+      }
+      const verified = policy.consentAnchor;
+      if (verified !== null && (!Number.isSafeInteger(verified.at) || verified.at < 0 || verified.source === "first_install")) {
+        throw new ReplicaStorageError("CONSENT_EXPIRED", "The verified consent anchor is unavailable.");
+      }
+      const first = recordFirst ? await gate.recordFirstInstall(profileDir, identityKeyHash, at) : await gate.readFirstInstall(profileDir, identityKeyHash);
+      const anchor = verified === null ? first === void 0 ? null : { at: first, source: "first_install" } : { at: Math.min(verified.at, at), source: verified.source };
+      if (anchor === null) return null;
+      const deadline = anchor.at + CONSENT_WINDOW_MS;
+      if (!Number.isSafeInteger(anchor.at) || anchor.at < 0 || !Number.isSafeInteger(deadline)) {
+        throw new ReplicaStorageError("CONSENT_EXPIRED", "The durable consent anchor is invalid.");
+      }
+      return { at, ttlMs: policy.grantTtlMs, consentDeadline: deadline, consentAnchor: anchor };
+    };
+    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 (requiresSecretsOptIn2(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.`
+        );
+      }
+      const idDir = partitionDirOf(root, spec.identity);
+      await ensurePartitionIdentity(idDir, spec.identity, options.dirSync);
+      const createdDevice = spec.device ?? await loadOrCreateDevice(idDir, profileSection, createDevice, options.dirSync);
+      const device = { ...createdDevice, did: principalOf(createdDevice.did) };
+      const replicaHash = replicaHashOf(spec.prefix, device.did);
+      partitionId = `${identityKeyHash}:${replicaHash}`;
+      const replicaDir = join2(idDir, "replicas", replicaHash);
+      const store = await sqlite.SqliteReplicaStore.open(replicaDir, {
+        create: true,
+        guard: storeGuard
+      });
+      let generation;
+      try {
+        try {
+          await store.init({
+            name: spec.prefix.replace(/\/+$/, "") || "replica",
+            replicaId: replicaHash,
+            host: spec.identity.host,
+            space: spec.space,
+            prefix: spec.prefix,
+            deviceDid: device.did,
+            allowSecrets: spec.allowSecrets,
+            localReadPolicy: "whileGrantValid",
+            retentionGrantCid: null
+          });
+        } catch (error) {
+          if (!replica.isReplicaError(error, replica.ReplicaErrorCode.CONFIG_MISMATCH)) {
+            throw error;
+          }
+        }
+        const state = await store.open();
+        if (state === null) {
+          throw new replica.ReplicaError(
+            replica.ReplicaErrorCode.NOT_FOUND,
+            "The replica row vanished during init."
+          );
+        }
+        const config = state.config;
+        if (config.host !== spec.identity.host || config.space !== spec.space || config.prefix !== spec.prefix) {
+          throw new replica.ReplicaError(
+            replica.ReplicaErrorCode.CONFIG_MISMATCH,
+            `This replica follows ${config.host} ${config.space}/kv/${config.prefix}, not ${spec.identity.host} ${spec.space}/kv/${spec.prefix}.`
+          );
+        }
+        if (principalOf(config.deviceDid) !== principalOf(device.did)) {
+          throw new replica.ReplicaError(
+            replica.ReplicaErrorCode.CONFIG_MISMATCH,
+            "The stored replica belongs to a different device key; purge the partition to rekey."
+          );
+        }
+        await retainGrantInstalls(gate, snapshot, identityKeyHash, store);
+        if (state.grant !== null || state.pendingGrant !== null) {
+          const policy = await resolvePolicy(Date.now(), false);
+          if (policy === null) throw gated("gate_unavailable");
+          if (state.grant !== null) await store.recomputeGrantInstall(state.grant, policy);
+          if (state.pendingGrant !== null) await store.recomputeGrantInstall(state.pendingGrant, policy);
+        }
+        generation = state.generation;
+      } catch (error) {
+        await store.close().catch(() => void 0);
+        throw error;
+      }
+      let ino;
+      try {
+        ino = (await stat(join2(replicaDir, "replica.db"))).ino;
+      } catch (error) {
+        if (!isNotFound(error)) throw error;
+      }
+      return new SqliteReplicaHandle({
+        spec,
+        replicaId: replicaHash,
+        device,
+        store,
+        replicaDir,
+        replica,
+        guard: storeGuard,
+        read: (section, withFence) => readGated(spec, partitionId, store, replicaDir, generation, section, withFence),
+        policy: resolvePolicy,
+        recordGrantInstall: async (cid, at) => gate.recordGrantInstall(profileDir, await gate.grantInstallHashOf(snapshot.salt, identityKeyHash, cid), at),
+        transportFor: options.transportFor,
+        dirSync: options.dirSync,
+        generation,
+        ino
+      });
     });
   }
   async function inspectStatus(spec, { signal }) {
+    assertLogoutClear(options.logoutPendingFile);
     const checkAbort = () => {
       if (signal.aborted) throw signal.reason ?? Object.assign(new Error("Replica status inspection was aborted"), { code: "ABORTED" });
     };
@@ -27913,6 +30040,8 @@ function createSqliteReplicaStorage(options) {
       import("@tinycloud/replica/sqlite")
     ]);
     checkAbort();
+    const syncedThroughEpoch = await readFence(replicaDir);
+    checkAbort();
     const inspected = await sqlite.SqliteReplicaStore.inspect(replicaDir, { signal });
     checkAbort();
     if (inspected === null) return void 0;
@@ -27920,14 +30049,17 @@ function createSqliteReplicaStorage(options) {
     if (state.config.host !== spec.identity.host || state.config.space !== spec.space || state.config.prefix !== spec.prefix || principalOf(state.config.deviceDid) !== principalOf(device.did)) {
       throw new ReplicaStorageError("STORAGE_ERROR", `The replica at ${replicaDir} does not match the requested identity, space, prefix, or device.`);
     }
-    const syncedThroughEpoch = await readFence(replicaDir);
     checkAbort();
+    assertLogoutClear(options.logoutPendingFile);
+    const gateState = await (await fileGate()).readGateSnapshot(profileDir);
+    const purgePending = gateState !== void 0 && (gateState.eraseDeferred || gateState.intents.length > 0);
     return {
+      purgePending,
       coverage: status.coverage,
       lastSyncAt: status.lastSyncAt,
       syncedThroughEpoch,
-      authority: { state: status.authority.state, expiresAt: status.authority.expiresAt },
-      grant: newestGrantInfo(replica, state.pendingGrant ?? state.grant, state.pendingGrant, spec),
+      authority: state.grant !== null && (inspected.activeGrantInstall === null || Date.now() >= inspected.activeGrantInstall.effectiveExpiresAt) ? { state: "expired", expiresAt: inspected.activeGrantInstall === null ? null : new Date(inspected.activeGrantInstall.effectiveExpiresAt).toISOString() } : { state: status.authority.state, expiresAt: status.authority.expiresAt },
+      grant: newestGrantInfo(replica, state.pendingGrant ?? state.grant, state.pendingGrant, spec, inspected.grantInstall),
       counts: status.counts,
       bytes: status.bytes,
       lastError: status.lastError
@@ -27940,89 +30072,124 @@ function createSqliteReplicaStorage(options) {
       // @ts-ignore — same as above.
       import("@tinycloud/replica/sqlite")
     ]);
-    const idDir = partitionDirOf(root, target.identity);
-    if (!await pathExists(idDir)) return;
-    const deviceDids = [];
-    const deviceFile = join2(idDir, "device.jwk");
-    const stored = await readJsonFile(deviceFile);
-    if (stored !== void 0) {
-      const device = deviceRecordOf(stored);
-      if (device === void 0) {
-        throw new ReplicaStorageError(
-          "STORAGE_ERROR",
-          `The replica device key at ${deviceFile} is unreadable.`
-        );
-      }
-      deviceDids.push(device.did);
-    }
-    if (target.sessionDeviceDid !== void 0) deviceDids.push(target.sessionDeviceDid);
-    const devices = [...new Map(deviceDids.map((did) => [principalOf(did), did])).values()];
-    let firstError;
-    for (const deviceDid of devices) {
-      const replicaDir = join2(idDir, "replicas", replicaHashOf(target.prefix, deviceDid));
-      if (!await pathExists(replicaDir)) continue;
-      try {
-        let store;
-        try {
-          store = await sqlite.SqliteReplicaStore.open(replicaDir, { create: false, guard });
-        } catch (error) {
-          if (replica.isReplicaError(error, replica.ReplicaErrorCode.NOT_FOUND)) {
-            await guard(() => rm(replicaDir, { recursive: true, force: true }));
-            continue;
-          }
-          throw error;
+    return profileSection(async () => {
+      const idDir = partitionDirOf(root, target.identity);
+      if (!await realDirectoryExists(idDir)) return;
+      const hasReplicas = await realDirectoryExists(join2(idDir, "replicas"));
+      const deviceDids = [];
+      const deviceFile = join2(idDir, "device.jwk");
+      const stored = await readJsonFile(deviceFile);
+      if (stored !== void 0) {
+        const device = deviceRecordOf(stored);
+        if (device === void 0) {
+          throw new ReplicaStorageError(
+            "STORAGE_ERROR",
+            `The replica device key at ${deviceFile} is unreadable.`
+          );
+        }
+        deviceDids.push(device.did);
+      }
+      if (target.sessionDeviceDid !== void 0) deviceDids.push(target.sessionDeviceDid);
+      const devices = [...new Map(deviceDids.map((did) => [principalOf(did), did])).values()];
+      const removeLeftover = async (replicaDir) => {
+        const layout = await sqlite.inspectSqliteReplicaLayout(replicaDir, { allowAdapterFence: true });
+        const missingDatabase = !await pathExists(join2(replicaDir, "replica.db"));
+        const unexpected = layout.unknownPaths.filter((path) => path !== "replica.db");
+        if (unexpected.length !== 0 || layout.unknownPaths.includes("replica.db") !== missingDatabase || layout.unknownEntries.some((item) => item.path === "replica.db")) {
+          throw new ReplicaStorageError(
+            "STORAGE_ERROR",
+            `Refusing to remove unexpected replica path ${join2(replicaDir, unexpected[0] ?? "replica.db")}.`
+          );
         }
+        await sqlite.removeSqliteReplicaLayout(replicaDir, {
+          expectedRoot: layout.rootIdentity,
+          expectedKnown: layout.knownEntries,
+          allowAdapterFence: true,
+          allowMissingDatabase: missingDatabase
+        });
+      };
+      let firstError;
+      for (const deviceDid of devices) {
+        const replicaDir = join2(idDir, "replicas", replicaHashOf(target.prefix, deviceDid));
+        if (!hasReplicas || !await realDirectoryExists(replicaDir)) continue;
         try {
-          const state = await store.open();
-          if (state === null) {
-            await store.close().catch(() => void 0);
-            await guard(() => rm(replicaDir, { recursive: true, force: true }));
-            continue;
-          }
-          const lease = await store.acquireSyncLease(SYNC_LEASE_TTL_MS);
-          if (lease === null) {
-            throw new replica.ReplicaError(
-              replica.ReplicaErrorCode.BUSY,
-              "Another process holds this replica's sync lease."
-            );
+          let store;
+          try {
+            store = await sqlite.SqliteReplicaStore.open(replicaDir, { create: false, guard: profileSection });
+          } catch (error) {
+            if (replica.isReplicaError(error, replica.ReplicaErrorCode.NOT_FOUND)) {
+              await removeLeftover(replicaDir);
+              continue;
+            }
+            throw error;
           }
           try {
-            if (state.revoked === null) {
-              await store.reset(lease, "purged");
+            const state = await store.open();
+            if (state === null) {
+              await store.close().catch(() => void 0);
+              await removeLeftover(replicaDir);
+              continue;
+            }
+            const lease = await store.acquireSyncLease(SYNC_LEASE_TTL_MS);
+            if (lease === null) {
+              throw new replica.ReplicaError(
+                replica.ReplicaErrorCode.BUSY,
+                "Another process holds this replica's sync lease."
+              );
+            }
+            try {
+              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, replicationIdentityKey(target.identity));
+                await retainGrantInstalls(gate, currentGate, identityKeyHash, store);
+              }
+              if (state.revoked === null) {
+                await store.reset(lease, "purged");
+              }
+              await store.destroy(lease, { allowAdapterFence: true });
+            } finally {
+              await store.releaseLease(lease).catch(() => void 0);
             }
-            await store.destroy(lease);
           } finally {
-            await store.releaseLease(lease).catch(() => void 0);
+            await store.close().catch(() => void 0);
           }
-        } finally {
-          await store.close().catch(() => void 0);
+        } catch (error) {
+          firstError ?? (firstError = error);
         }
-      } catch (error) {
-        firstError ?? (firstError = error);
       }
-    }
-    if (firstError !== void 0) throw firstError;
+      if (firstError !== void 0) throw firstError;
+    });
   }
   return {
     kind: "sqlite",
+    lifecycle,
     open: openHandle,
     inspectStatus,
     purge: purgePartition,
-    // Always the durable partitioned file store (review): the runtime
-    // must never fall back to volatile in-memory pending state — a
-    // restart that lost ambiguous write records would serve stale data.
-    // Without a guard the file store still durably serializes each update;
-    // the guard only adds cross-process read-modify-write exclusion.
-    pendingWrites(identity) {
+    // File-backed pending writes are always bound to a stamped gate.
+    pendingWrites(identity, opts) {
       return new FilePendingWriteStore(
         identity,
         partitionDirOf(root, identity),
+        profileDir,
         guard,
-        options.dirSync
+        opts?.stamp,
+        options.dirSync,
+        options.logoutPendingFile
       );
     }
   };
 }
+function createProfileReplicaPurge(options) {
+  return createSqliteReplicaStorage({
+    dir: join2(options.profileDir, "replication"),
+    guard: options.guard,
+    dirSync: options.dirSync,
+    logoutPendingFile: join2(options.profileDir, REPLICA_LOGOUT_PENDING_FILE),
+    diagnosticFiles: options.diagnosticFiles
+  }).lifecycle;
+}
 function sqliteReplicaStorage(options) {
   return createSqliteReplicaStorage(options);
 }
@@ -28074,7 +30241,9 @@ export {
   PermissionNotInManifestError2 as PermissionNotInManifestError,
   PrefixedKVService,
   PrivateKeySigner,
-  ProtocolMismatchError,
+  ProtocolMismatchError2 as ProtocolMismatchError,
+  REPLICA_LOGOUT_PENDING_FILE,
+  RESTORED_GATE_MESSAGE,
   RUNTIME_DELEGATION_REJECTIONS,
   RuntimeDelegationRejectedError,
   SECRET_NAME_RE,
@@ -28101,12 +30270,13 @@ export {
   VAULT_PERMISSION_SERVICE,
   VaultHeaders,
   VaultPublicSpaceKVActions,
-  VersionCheckError2 as VersionCheckError,
+  VersionCheckError,
   WasmKeyProvider,
   activateCompactRuntimeDelegation,
   activateValidatedRuntimeDelegation,
   addressStorageKey,
   appSecretScope,
+  assertProfileLogoutClear,
   buildCanonicalDecryptRequest,
   buildDecryptAttenuation,
   buildDecryptFacts,
@@ -28127,6 +30297,7 @@ export {
   composeManifestRequest2 as composeManifestRequest,
   createCapabilityKeyRegistry,
   createOpenKeyCallbackSigningStrategy,
+  createProfileReplicaPurge,
   createSharingService,
   createSpaceService,
   createVaultCrypto2 as createVaultCrypto,
@@ -28163,6 +30334,7 @@ export {
   isNetworkId,
   isStorageFullError2 as isStorageFullError,
   loadManifest,
+  logoutPrincipalDigest,
   makePkhSpaceId2 as makePkhSpaceId,
   makePublicSpaceId2 as makePublicSpaceId,
   networkDiscoveryKey,