@opendatalabs/personal-server-ts-server 1.7.0 → 1.8.0

package/dist/ui/ps-lite-debug.js

@@ -105729,7 +105729,7 @@ var LineageGatewayError = class extends ProtocolError {
 };
 var LineageCascadeUnavailableError = class extends ProtocolError {
   constructor(details) {
-    super(501, "LINEAGE_CASCADE_UNAVAILABLE", "DELETE ?cascade=lineage is specified but not implemented yet: it needs the durable (tombstone) deletion of every derivative at the gateway, which this server cannot perform. Delete scopes one at a time.", details);
+    super(501, "LINEAGE_CASCADE_UNAVAILABLE", "DELETE ?cascade=lineage is specified but not implemented yet: the lineage walk that finds every derivative is missing. Delete scopes one at a time; each single-scope delete is durable.", details);
   }
 };
 var InvalidCascadeError = class extends ProtocolError {
@@ -105737,6 +105737,16 @@ var InvalidCascadeError = class extends ProtocolError {
     super(400, "INVALID_CASCADE", 'Unsupported cascade mode; the only supported value is "lineage"', details);
   }
 };
+var DeleteTombstoneFailedError = class extends ProtocolError {
+  constructor(details) {
+    super(502, "DELETE_TOMBSTONE_FAILED", "Gateway did not acknowledge the deletion tombstone; nothing was deleted", details);
+  }
+};
+var DataDeletedError = class extends ProtocolError {
+  constructor(details) {
+    super(410, "DATA_DELETED", "Data point has been deleted", details);
+  }
+};
 
 // ../core/dist/sync/data-point-id.js
 function computeDataPointId(ownerAddress, scope) {
@@ -109344,6 +109354,7 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
         schemaId: entry.schemaId ?? null,
         version: version4,
         dataPointId: entry.dataPointId ?? null,
+        afterTombstoneVersion: entry.afterTombstoneVersion ?? null,
         id: state.nextId,
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
@@ -109437,25 +109448,34 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
       await persist();
       return deleted;
     },
+    async deleteVersion(scope, collectedAt2) {
+      const entry = state.entries.find((e10) => e10.scope === scope && e10.collectedAt === collectedAt2);
+      if (!entry)
+        return false;
+      return removeEntry(entry);
+    },
     async deleteByFileId(fileId) {
       const entry = state.entries.find((e10) => e10.fileId === fileId);
       if (!entry)
         return false;
-      const blobPath = envelopePath(entry.scope, entry.collectedAt);
-      await Promise.all([
-        fileStore.deleteEnvelope(blobPath),
-        fallbackStore.deleteEnvelope(blobPath),
-        fileStore.deleteBlockTree?.(blockTreePath(entry.scope, entry.collectedAt)) ?? Promise.resolve(),
-        fallbackStore.deleteBlockTree?.(blockTreePath(entry.scope, entry.collectedAt)) ?? Promise.resolve()
-      ]);
-      state = {
-        ...state,
-        entries: state.entries.filter((e10) => e10 !== entry)
-      };
-      await persist();
-      return true;
+      return removeEntry(entry);
     }
   };
+  async function removeEntry(entry) {
+    const blobPath = envelopePath(entry.scope, entry.collectedAt);
+    await Promise.all([
+      fileStore.deleteEnvelope(blobPath),
+      fallbackStore.deleteEnvelope(blobPath),
+      fileStore.deleteBlockTree?.(blockTreePath(entry.scope, entry.collectedAt)) ?? Promise.resolve(),
+      fallbackStore.deleteBlockTree?.(blockTreePath(entry.scope, entry.collectedAt)) ?? Promise.resolve()
+    ]);
+    state = {
+      ...state,
+      entries: state.entries.filter((e10) => e10 !== entry)
+    };
+    await persist();
+    return true;
+  }
   if (fileStore.readEnvelopePreview) {
     storagePort.readEnvelopePreview = async (scope, collectedAt2, { maxBytes }) => {
       const path = envelopePath(scope, collectedAt2);
@@ -110743,15 +110763,44 @@ function normalizeOffset(value) {
 function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+var VISIBILITY_PAGE_SIZE = 200;
 async function listDataScopesContract(input) {
   const limit = normalizeLimit(input.limit);
   const offset = normalizeOffset(input.offset);
-  const result = input.storage.listScopes({
-    scopePrefix: input.scopePrefix,
-    limit,
-    offset
-  });
-  const scopes = await Promise.all(result.scopes.map(async (summary) => {
+  let page;
+  let total;
+  if (input.isVisible) {
+    const visible = [];
+    for (let scan = 0; ; scan += VISIBILITY_PAGE_SIZE) {
+      const batch = input.storage.listScopes({
+        scopePrefix: input.scopePrefix,
+        limit: VISIBILITY_PAGE_SIZE,
+        offset: scan
+      });
+      for (const summary of batch.scopes) {
+        const latest = input.storage.findEntry({
+          scope: summary.scope,
+          at: summary.latestCollectedAt
+        });
+        if (!latest || await input.isVisible(summary.scope, latest)) {
+          visible.push(summary);
+        }
+      }
+      if (batch.scopes.length < VISIBILITY_PAGE_SIZE)
+        break;
+    }
+    total = visible.length;
+    page = visible.slice(offset, offset + limit);
+  } else {
+    const result = input.storage.listScopes({
+      scopePrefix: input.scopePrefix,
+      limit,
+      offset
+    });
+    page = result.scopes;
+    total = result.total;
+  }
+  const scopes = await Promise.all(page.map(async (summary) => {
     const entry = input.storage.findEntry({
       scope: summary.scope,
       at: summary.latestCollectedAt
@@ -110759,7 +110808,7 @@ async function listDataScopesContract(input) {
     if (!entry) {
       return summary;
     }
-    const hasBlocks = typeof input.storage.canReadScopeBlocks === "function" ? await input.storage.canReadScopeBlocks(summary.scope, summary.latestCollectedAt) : typeof input.storage.hasScopeBlocks === "function" ? await input.storage.hasScopeBlocks(summary.scope, summary.latestCollectedAt) : false;
+    const hasBlocks = typeof input.storage.hasScopeBlocks === "function" ? await input.storage.hasScopeBlocks(summary.scope, summary.latestCollectedAt) : false;
     return {
       ...summary,
       dataStatus: hasBlocks ? "ready" : "indexing",
@@ -110770,33 +110819,52 @@ async function listDataScopesContract(input) {
     ok: true,
     response: {
       scopes,
-      total: result.total,
+      total,
       limit,
       offset
     }
   };
 }
-function listDataVersionsContract(input) {
+async function listDataVersionsContract(input) {
   const scopeResult = parseDataScopeContract(input.scopeParam);
   if (!scopeResult.ok)
     return scopeResult;
   const limit = normalizeLimit(input.limit);
   const offset = normalizeOffset(input.offset);
-  const entries = input.storage.listVersions(scopeResult.scope, {
-    limit,
-    offset
-  });
+  let page;
+  let total;
+  if (input.isVisible) {
+    const visible = [];
+    for (let scan = 0; ; scan += VISIBILITY_PAGE_SIZE) {
+      const batch = input.storage.listVersions(scopeResult.scope, {
+        limit: VISIBILITY_PAGE_SIZE,
+        offset: scan
+      });
+      for (const entry of batch) {
+        if (await input.isVisible(scopeResult.scope, entry)) {
+          visible.push(entry);
+        }
+      }
+      if (batch.length < VISIBILITY_PAGE_SIZE)
+        break;
+    }
+    total = visible.length;
+    page = visible.slice(offset, offset + limit);
+  } else {
+    page = input.storage.listVersions(scopeResult.scope, { limit, offset });
+    total = input.storage.countVersions(scopeResult.scope);
+  }
   return {
     ok: true,
     scope: scopeResult.scope,
     response: {
       scope: scopeResult.scope,
-      versions: entries.map((entry) => ({
+      versions: page.map((entry) => ({
         fileId: entry.fileId,
         schemaId: entry.schemaId,
         collectedAt: entry.collectedAt
       })),
-      total: input.storage.countVersions(scopeResult.scope),
+      total,
       limit,
       offset
     }
@@ -110873,7 +110941,8 @@ async function ingestDataContract(input) {
     path: writeResult.relativePath,
     scope: scopeResult.scope,
     collectedAt: input.collectedAt,
-    sizeBytes: writeResult.sizeBytes
+    sizeBytes: writeResult.sizeBytes,
+    afterTombstoneVersion: input.afterTombstoneVersion ?? null
   });
   return {
     ok: true,
@@ -110944,7 +111013,8 @@ async function ingestBinaryDataContract(input) {
     path: writeResult.relativePath,
     scope: scopeResult.scope,
     collectedAt: input.collectedAt,
-    sizeBytes: input.bytes.length
+    sizeBytes: input.bytes.length,
+    afterTombstoneVersion: input.afterTombstoneVersion ?? null
   });
   return {
     ok: true,
@@ -110954,15 +111024,6 @@ async function ingestBinaryDataContract(input) {
     writeResult
   };
 }
-async function deleteDataScopeContract(input) {
-  const scopeResult = parseDataScopeContract(input.scopeParam);
-  if (!scopeResult.ok)
-    return scopeResult;
-  return {
-    ok: true,
-    deletedCount: await input.storage.deleteScope(scopeResult.scope)
-  };
-}
 async function writeBlockSidecars(storage, envelope) {
   if (!storage.writeBlockManifest)
     return;
@@ -111548,6 +111609,548 @@ async function syncFileContract(input) {
   return contractOk({ fileId: input.fileId, status: "started" }, 202);
 }
 
+// ../core/dist/sync/tombstone.js
+var TOMBSTONE_DATA_HASH_LABEL = "vana.data-point.tombstone.v1";
+var TOMBSTONE_METADATA_HASH_LABEL = "vana.data-point.tombstone.metadata.v1";
+var TOMBSTONE_DATA_HASH = keccak256(stringToHex(TOMBSTONE_DATA_HASH_LABEL));
+var TOMBSTONE_METADATA_HASH = keccak256(stringToHex(TOMBSTONE_METADATA_HASH_LABEL));
+function isTombstoneRecord(record2) {
+  return record2.dataHash.toLowerCase() === TOMBSTONE_DATA_HASH && record2.metadataHash.toLowerCase() === TOMBSTONE_METADATA_HASH;
+}
+
+// ../core/dist/sync/scope-deletions.js
+var DEFAULT_SCOPE_DELETION_MAX_STALENESS_MS = 12e4;
+var DEFAULT_SCOPE_DELETION_GATEWAY_RETRY_MS = 15e3;
+var DEFAULT_MAX_LIVE_ENTRIES = 1e4;
+function createScopeDeletionTracker(options = {}) {
+  const maxStalenessMs = options.maxStalenessMs ?? DEFAULT_SCOPE_DELETION_MAX_STALENESS_MS;
+  const gatewayRetryMs = options.gatewayRetryMs ?? DEFAULT_SCOPE_DELETION_GATEWAY_RETRY_MS;
+  const maxLiveEntries = options.maxLiveEntries ?? DEFAULT_MAX_LIVE_ENTRIES;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const nowMs = () => now().getTime();
+  const deleted = /* @__PURE__ */ new Map();
+  const live = /* @__PURE__ */ new Map();
+  let lastFeedSyncMs = null;
+  let lastGatewayFailureMs = null;
+  const inflight = /* @__PURE__ */ new Map();
+  function rememberLive(scope, at3) {
+    deleted.delete(scope);
+    live.delete(scope);
+    live.set(scope, at3);
+    while (live.size > maxLiveEntries) {
+      const oldest = live.keys().next().value;
+      if (oldest === void 0)
+        break;
+      live.delete(oldest);
+    }
+  }
+  function rememberDeleted(scope, tombstone, source) {
+    deleted.set(scope, {
+      deletedAt: tombstone.deletedAt,
+      version: normalizeVersion(tombstone.version),
+      source,
+      verifiedAtMs: nowMs()
+    });
+    live.delete(scope);
+  }
+  function isFresh(at3) {
+    return at3 !== null && nowMs() - at3 <= maxStalenessMs;
+  }
+  function verdictFromRecord(scope, record2) {
+    const deletedAt = deletionTimestamp(record2);
+    if (deletedAt !== null) {
+      const version4 = tombstoneVersion(record2);
+      rememberDeleted(scope, { deletedAt, version: version4 }, "gateway");
+      return {
+        deleted: true,
+        deletedAt,
+        version: version4,
+        source: "gateway",
+        verified: true
+      };
+    }
+    rememberLive(scope, nowMs());
+    return { deleted: false, source: "gateway", verified: true };
+  }
+  async function lookup2(scope) {
+    const feed = options.feed;
+    const owner = options.serverOwner;
+    if (!feed || !owner)
+      return null;
+    if (lastGatewayFailureMs !== null && nowMs() - lastGatewayFailureMs < gatewayRetryMs) {
+      return null;
+    }
+    const pending = inflight.get(scope);
+    if (pending)
+      return pending;
+    const request2 = (async () => {
+      try {
+        const record2 = await feed.getDataPoint({
+          ownerAddress: owner,
+          scope
+        });
+        lastGatewayFailureMs = null;
+        return verdictFromRecord(scope, record2);
+      } catch (err2) {
+        lastGatewayFailureMs = nowMs();
+        options.logger?.warn?.({
+          scope,
+          error: err2 instanceof Error ? err2.message : String(err2),
+          retryAfterMs: gatewayRetryMs
+        }, "Could not check gateway deletion state; serving last known state");
+        return null;
+      } finally {
+        inflight.delete(scope);
+      }
+    })();
+    inflight.set(scope, request2);
+    return request2;
+  }
+  return {
+    maxStalenessMs,
+    markDeleted(scope, tombstone, source = "feed") {
+      rememberDeleted(scope, tombstone, source);
+    },
+    markLive(scope) {
+      rememberLive(scope, nowMs());
+    },
+    noteFeedSynced(at3, options2) {
+      lastFeedSyncMs = (at3 ?? now()).getTime();
+      if (!options2?.full)
+        return;
+      for (const tombstone of deleted.values()) {
+        tombstone.verifiedAtMs = Math.max(tombstone.verifiedAtMs, lastFeedSyncMs);
+      }
+    },
+    knownDeletion(scope) {
+      const known = deleted.get(scope);
+      return known === void 0 ? null : { deletedAt: known.deletedAt, version: known.version };
+    },
+    feedAgeMs() {
+      return lastFeedSyncMs === null ? null : nowMs() - lastFeedSyncMs;
+    },
+    async resolve(scope, resolveOptions) {
+      const known = deleted.get(scope);
+      if (known !== void 0) {
+        if (isFresh(known.verifiedAtMs)) {
+          return {
+            deleted: true,
+            deletedAt: known.deletedAt,
+            version: known.version,
+            source: known.source,
+            verified: true
+          };
+        }
+        const rechecked = await lookup2(scope);
+        if (rechecked !== null)
+          return rechecked;
+        return {
+          deleted: true,
+          deletedAt: known.deletedAt,
+          version: known.version,
+          source: known.source,
+          verified: false
+        };
+      }
+      if (isFresh(live.get(scope) ?? null)) {
+        return { deleted: false, source: "gateway", verified: true };
+      }
+      const consult = resolveOptions?.consultGateway ?? "if-stale";
+      if (consult === "if-stale" && isFresh(lastFeedSyncMs)) {
+        return { deleted: false, source: "feed", verified: true };
+      }
+      return await lookup2(scope) ?? {
+        deleted: false,
+        source: "assumed-live",
+        verified: false
+      };
+    }
+  };
+}
+function deletionTimestamp(record2) {
+  if (!record2)
+    return null;
+  if (record2.deletedAt)
+    return record2.deletedAt;
+  return isTombstoneRecord(record2) ? record2.addedAt : null;
+}
+function tombstoneVersion(record2) {
+  return normalizeVersion(record2?.expectedVersion ?? null);
+}
+function normalizeVersion(value) {
+  if (typeof value !== "string" || !/^\d+$/.test(value))
+    return null;
+  return BigInt(value) > 0n ? BigInt(value).toString() : null;
+}
+function isEntryCoveredByTombstone(entry, tombstone) {
+  const version4 = normalizeVersion(tombstone.version);
+  if (version4 === null)
+    return true;
+  const tombstoned = BigInt(version4);
+  if (entry.dataPointId !== null)
+    return BigInt(entry.version) <= tombstoned;
+  const marker = entry.afterTombstoneVersion;
+  if (marker === null || marker === void 0 || !Number.isSafeInteger(marker)) {
+    return true;
+  }
+  return BigInt(marker) < tombstoned;
+}
+
+// ../core/dist/sync/workers/delete.js
+var BLOB_DELETE_BATCH_SIZE = 15;
+function planBlobDeletions(storage, scope, tombstoneVersionValue) {
+  const tombstone = { version: tombstoneVersionValue };
+  const last2 = tombstoneVersionValue === null ? null : BigInt(tombstoneVersionValue);
+  const keys = /* @__PURE__ */ new Set();
+  const PAGE_SIZE = 500;
+  for (let offset = 0; ; offset += PAGE_SIZE) {
+    const entries = storage.listVersions(scope, { limit: PAGE_SIZE, offset });
+    for (const entry of entries) {
+      if (!isEntryCoveredByTombstone(entry, tombstone))
+        continue;
+      const version4 = BigInt(entry.version);
+      if (last2 !== null && version4 >= 1n && version4 <= last2)
+        continue;
+      keys.add(version4.toString());
+    }
+    if (entries.length < PAGE_SIZE)
+      break;
+  }
+  return {
+    keys: [...keys].sort((a10, b10) => BigInt(a10) < BigInt(b10) ? -1 : 1),
+    range: last2 === null || last2 < 1n ? null : { from: "1", to: last2.toString() }
+  };
+}
+function takeFromRange(range, count) {
+  const from = BigInt(range.from);
+  const to3 = BigInt(range.to);
+  const versions = [];
+  let cursor = from;
+  while (cursor <= to3 && versions.length < count) {
+    versions.push(cursor.toString());
+    cursor += 1n;
+  }
+  return {
+    versions,
+    rest: cursor <= to3 ? { from: cursor.toString(), to: range.to } : null
+  };
+}
+function rangeSize(range) {
+  return BigInt(range.to) - BigInt(range.from) + 1n;
+}
+function countPendingKeys(markers) {
+  let total = 0n;
+  for (const marker of markers) {
+    if (marker.version !== null)
+      total += 1n;
+    else if (marker.range)
+      total += rangeSize(marker.range);
+    else
+      total += 1n;
+  }
+  return total > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(total);
+}
+async function deleteScope(deps, scope) {
+  const { storage, deleteData, pendingBlobDeletions, scopeDeletions, logger } = deps;
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const dataPointId = deps.serverOwner ? computeDataPointId(deps.serverOwner, scope) : null;
+  const result = {
+    scope,
+    dataPointId,
+    durable: false,
+    steps: {
+      gateway: { status: "skipped", reason: "sync-disabled" },
+      storage: { status: "skipped", reason: "sync-disabled" },
+      local: { status: "skipped" }
+    },
+    pendingBlobDeletion: false
+  };
+  if (deleteData) {
+    let tombstoneVersionValue = null;
+    let tombstoneKnown = false;
+    try {
+      let outcome = await deleteData.tombstone(scope);
+      if (outcome.status === "not-registered") {
+        let registry2 = await registryState(deps, scope);
+        if (registry2.status === "live") {
+          outcome = await deleteData.tombstone(scope);
+          registry2 = await registryState(deps, scope);
+        }
+        if (outcome.status === "not-registered" && registry2.status !== "deleted-or-absent") {
+          throw registry2.status === "unknown" ? registry2.error : new Error("Scope was registered concurrently while it was being deleted; retry the delete");
+        }
+      }
+      if (outcome.status === "not-registered") {
+        result.steps.gateway = { status: "skipped", reason: "not-registered" };
+      } else {
+        tombstoneKnown = true;
+        tombstoneVersionValue = outcome.version === null ? null : tombstoneVersion({ expectedVersion: outcome.version });
+        result.steps.gateway = {
+          status: "ok",
+          ...outcome.status === "already-deleted" && {
+            reason: "already-deleted"
+          },
+          version: outcome.version,
+          deletedAt: outcome.deletedAt
+        };
+        scopeDeletions?.markDeleted(scope, {
+          deletedAt: outcome.deletedAt ?? now().toISOString(),
+          version: outcome.version
+        }, "local-delete");
+      }
+      result.durable = true;
+    } catch (err2) {
+      const message = errorMessage2(err2);
+      result.steps.gateway = { status: "failed", error: message };
+      result.steps.storage = { status: "skipped", reason: "gateway-failed" };
+      result.steps.local = { status: "skipped", reason: "gateway-failed" };
+      logger.error({ scope, dataPointId, error: message }, "Gateway tombstone failed; scope NOT deleted (local copy kept so sync cannot resurrect a half-deleted scope)");
+      return result;
+    }
+    const plan = planBlobDeletions(storage, scope, tombstoneVersionValue);
+    const batch = plan.keys.slice(0, BLOB_DELETE_BATCH_SIZE);
+    const leftovers = plan.keys.slice(BLOB_DELETE_BATCH_SIZE).map((version4) => ({ scope, version: version4 }));
+    if (plan.range) {
+      const taken = takeFromRange(plan.range, BLOB_DELETE_BATCH_SIZE - batch.length);
+      batch.push(...taken.versions);
+      if (taken.rest)
+        leftovers.push({ scope, version: null, range: taken.rest });
+    }
+    if (tombstoneKnown && tombstoneVersionValue === null) {
+      leftovers.push({ scope, version: null });
+    }
+    const storageStep = await deleteBlobKeys({ deleteData, pendingBlobDeletions, logger }, scope, batch, leftovers);
+    result.steps.storage = storageStep.step;
+    result.pendingBlobDeletion = storageStep.pending > 0;
+  }
+  try {
+    const deletedCount = await storage.deleteScope(scope);
+    result.steps.local = { status: "ok", deletedCount };
+  } catch (err2) {
+    const message = errorMessage2(err2);
+    result.steps.local = { status: "failed", error: message };
+    logger.error({ scope, error: message }, "Local scope deletion failed");
+  }
+  logger.info({
+    scope,
+    dataPointId,
+    durable: result.durable,
+    gateway: result.steps.gateway.status,
+    storage: result.steps.storage.status,
+    local: result.steps.local.status
+  }, "Scope deletion finished");
+  return result;
+}
+async function deleteBlobKeys(deps, scope, batch, leftovers) {
+  const { deleteData, pendingBlobDeletions, logger } = deps;
+  let outcome;
+  try {
+    outcome = batch.length > 0 && deleteData ? await deleteData.deleteBlobVersions(scope, batch) : { deleted: [], missing: [], failed: [] };
+  } catch (err2) {
+    outcome = {
+      deleted: [],
+      missing: [],
+      failed: batch.map((version4) => ({ version: version4, error: errorMessage2(err2) }))
+    };
+  }
+  const completed = [...outcome.deleted, ...outcome.missing].map((version4) => ({ scope, version: version4 }));
+  const remaining = [
+    ...outcome.failed.map(({ version: version4 }) => ({ scope, version: version4 })),
+    ...leftovers
+  ];
+  const remainingKeys = countPendingKeys(remaining);
+  let recorded = remainingKeys;
+  if (pendingBlobDeletions) {
+    try {
+      if (completed.length > 0)
+        await pendingBlobDeletions.remove(completed);
+      if (remaining.length > 0)
+        await pendingBlobDeletions.add(remaining);
+    } catch (markerErr) {
+      recorded = 0;
+      logger.error({ scope, error: errorMessage2(markerErr), keys: remainingKeys }, "Could not record pending blob deletion markers");
+    }
+  } else if (remaining.length > 0) {
+    recorded = 0;
+    logger.error({ scope, keys: remainingKeys }, "Blob deletions left unfinished with no marker store to retry them");
+  }
+  const counts = {
+    blobsDeleted: outcome.deleted.length,
+    blobsMissing: outcome.missing.length,
+    blobsPending: remainingKeys
+  };
+  if (outcome.failed.length > 0) {
+    const first = outcome.failed[0];
+    logger.warn({
+      scope,
+      failed: outcome.failed.length,
+      pending: recorded,
+      error: first.error
+    }, "Storage blob deletion failed for some keys after gateway tombstone; will retry");
+    return {
+      step: {
+        status: "failed",
+        error: `${outcome.failed.length} blob delete(s) failed: ${first.error}`,
+        ...counts
+      },
+      pending: recorded
+    };
+  }
+  if (remaining.length > 0) {
+    logger.info({ scope, ...counts }, "Storage blob deletion continues on later sync cycles (rate-limited batch)");
+    return { step: { status: "deferred", ...counts }, pending: recorded };
+  }
+  return { step: { status: "ok", ...counts }, pending: 0 };
+}
+async function retryPendingBlobDeletions(deps) {
+  const { deleteData, pendingBlobDeletions, logger } = deps;
+  const result = {
+    completed: [],
+    superseded: [],
+    failed: [],
+    remaining: 0
+  };
+  if (!deleteData || !pendingBlobDeletions)
+    return result;
+  let markers = await pendingBlobDeletions.list();
+  if (markers.length === 0)
+    return result;
+  for (const marker of markers.filter((key) => key.version === null && !key.range)) {
+    const registry2 = await registryState(deps, marker.scope);
+    if (registry2.status === "unknown") {
+      result.failed.push({
+        scope: marker.scope,
+        version: null,
+        error: registry2.error.message
+      });
+      continue;
+    }
+    if (registry2.status === "live") {
+      await pendingBlobDeletions.remove([marker]);
+      result.superseded.push(marker.scope);
+      logger.warn({
+        scope: marker.scope,
+        dataPointId: registry2.record.id,
+        version: registry2.record.expectedVersion
+      }, "Scope was re-added after its tombstone; dropping the unexpanded blob deletion marker so the live version's ciphertext survives");
+      continue;
+    }
+    const plan = planBlobDeletions(deps.storage ?? { listVersions: () => [] }, marker.scope, registry2.status === "deleted" ? registry2.version : null);
+    const expanded = plan.keys.map((version4) => ({
+      scope: marker.scope,
+      version: version4
+    }));
+    if (plan.range) {
+      expanded.push({ scope: marker.scope, version: null, range: plan.range });
+    }
+    await pendingBlobDeletions.remove([marker]);
+    await pendingBlobDeletions.add(expanded);
+  }
+  markers = await pendingBlobDeletions.list();
+  let budget = BLOB_DELETE_BATCH_SIZE;
+  const byScope = /* @__PURE__ */ new Map();
+  const exactOrigin = /* @__PURE__ */ new Set();
+  const advancedRanges = [];
+  const enqueue = (scope, version4) => {
+    const versions = byScope.get(scope) ?? [];
+    versions.push(version4);
+    byScope.set(scope, versions);
+  };
+  for (const marker of markers) {
+    if (budget === 0)
+      break;
+    if (marker.version !== null) {
+      enqueue(marker.scope, marker.version);
+      exactOrigin.add(`${marker.scope}\0${marker.version}`);
+      budget -= 1;
+    }
+  }
+  for (const marker of markers) {
+    if (budget === 0)
+      break;
+    if (marker.version === null && marker.range) {
+      const taken = takeFromRange(marker.range, budget);
+      for (const version4 of taken.versions)
+        enqueue(marker.scope, version4);
+      budget -= taken.versions.length;
+      advancedRanges.push({
+        old: marker,
+        next: taken.rest ? { scope: marker.scope, version: null, range: taken.rest } : null
+      });
+    }
+  }
+  for (const [scope, versions] of byScope) {
+    let outcome;
+    try {
+      outcome = await deleteData.deleteBlobVersions(scope, versions);
+    } catch (err2) {
+      const message = errorMessage2(err2);
+      outcome = {
+        deleted: [],
+        missing: [],
+        failed: versions.map((version4) => ({ version: version4, error: message }))
+      };
+    }
+    const completed = [...outcome.deleted, ...outcome.missing].filter((version4) => exactOrigin.has(`${scope}\0${version4}`)).map((version4) => ({ scope, version: version4 }));
+    if (completed.length > 0)
+      await pendingBlobDeletions.remove(completed);
+    result.completed.push(...[...outcome.deleted, ...outcome.missing].map((version4) => ({ scope, version: version4 })));
+    const failedFromRange = outcome.failed.filter(({ version: version4 }) => !exactOrigin.has(`${scope}\0${version4}`)).map(({ version: version4 }) => ({ scope, version: version4 }));
+    if (failedFromRange.length > 0) {
+      await pendingBlobDeletions.add(failedFromRange);
+    }
+    for (const failure of outcome.failed) {
+      result.failed.push({ scope, ...failure });
+    }
+    if (outcome.deleted.length + outcome.missing.length > 0) {
+      logger.info({
+        scope,
+        deleted: outcome.deleted.length,
+        missing: outcome.missing.length
+      }, "Completed pending blob deletions");
+    }
+    if (outcome.failed.length > 0) {
+      logger.warn({
+        scope,
+        failed: outcome.failed.length,
+        error: outcome.failed[0].error
+      }, "Pending blob deletion failed again");
+    }
+  }
+  for (const { old, next } of advancedRanges) {
+    await pendingBlobDeletions.remove([old]);
+    if (next)
+      await pendingBlobDeletions.add([next]);
+  }
+  result.remaining = (await pendingBlobDeletions.list()).length;
+  return result;
+}
+async function registryState(deps, scope) {
+  if (!deps.dataPointFeed || !deps.serverOwner) {
+    return { status: "deleted-or-absent" };
+  }
+  let record2;
+  try {
+    record2 = await deps.dataPointFeed.getDataPoint({
+      ownerAddress: deps.serverOwner,
+      scope
+    });
+  } catch (err2) {
+    return {
+      status: "unknown",
+      error: err2 instanceof Error ? err2 : new Error(String(err2))
+    };
+  }
+  if (record2 === null)
+    return { status: "deleted-or-absent" };
+  if (deletionTimestamp(record2) === null)
+    return { status: "live", record: record2 };
+  return { status: "deleted", version: tombstoneVersion(record2) };
+}
+function errorMessage2(err2) {
+  return err2 instanceof Error ? err2.message : String(err2);
+}
+
 // ../core/dist/payment/x402.js
 function generateRecordId() {
   const bytes2 = new Uint8Array(32);
@@ -112028,6 +112631,51 @@ async function handleX402Cycle(input) {
 function collectedAt(now) {
   return now().toISOString().replace(/\.\d{3}Z$/, "Z");
 }
+async function resolveReadDeletion(deps, scope, entry) {
+  if (!deps.scopeDeletions)
+    return null;
+  const verdict = await deps.scopeDeletions.resolve(scope, {
+    consultGateway: entry ? "if-stale" : "always"
+  });
+  if (!verdict.deleted)
+    return null;
+  if (entry && !isEntryCoveredByTombstone(entry, verdict)) {
+    return null;
+  }
+  return {
+    scope,
+    dataPointId: deps.serverOwner ? computeDataPointId(deps.serverOwner, scope) : null,
+    deletedAt: verdict.deletedAt
+  };
+}
+async function assertScopeNotDeleted(deps, scope, entry) {
+  const deletion = await resolveReadDeletion(deps, scope, entry);
+  if (deletion)
+    throw new DataDeletedError(deletion);
+}
+function discoveryVisibility(deps) {
+  if (!deps.scopeDeletions)
+    return void 0;
+  return async (scope, entry) => await resolveReadDeletion(deps, scope, entry) === null;
+}
+async function ingestTombstoneMarker(deps, scope) {
+  if (!deps.scopeDeletions)
+    return null;
+  const verdict = await deps.scopeDeletions.resolve(scope);
+  if (!verdict.deleted || verdict.version === null)
+    return null;
+  const version4 = Number(verdict.version);
+  return Number.isSafeInteger(version4) ? version4 : null;
+}
+function apiLoggerAsLogger(logger) {
+  const noop = () => void 0;
+  return {
+    debug: (payload, message) => (logger?.debug ?? noop)(payload, message ?? ""),
+    info: (payload, message) => (logger?.info ?? noop)(payload, message ?? ""),
+    warn: (payload, message) => (logger?.warn ?? noop)(payload, message ?? ""),
+    error: (payload, message) => (logger?.error ?? noop)(payload, message ?? "")
+  };
+}
 function notifyNewData(syncManager) {
   if (!syncManager)
     return;
@@ -112083,24 +112731,6 @@ function resolveLineageGrantView(authResult) {
   }
   return { grantId };
 }
-async function deleteOneScope(deps, scope) {
-  if (deps.syncManager?.deleteScopeRemote) {
-    try {
-      await deps.syncManager.deleteScopeRemote(scope);
-    } catch (err2) {
-      deps.logger?.info?.({ scope, error: err2.message }, "Remote scope deletion failed; proceeding with local delete");
-    }
-  }
-  const result = await deleteDataScopeContract({
-    storage: deps.storage,
-    scopeParam: scope
-  });
-  if (!result.ok) {
-    throw new ProtocolError(result.status, result.body.error, result.body.message);
-  }
-  deps.logger?.info?.({ scope, deletedCount: result.deletedCount }, "Scope deleted");
-  return result.deletedCount;
-}
 async function handlePersonalServerDataRequest(request2, deps, options = {}) {
   return withApiErrors(async () => {
     const url2 = new URL(request2.url);
@@ -112113,7 +112743,8 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
         storage: deps.storage,
         scopePrefix: url2.searchParams.get("scopePrefix") ?? void 0,
         limit: normalizeLimit2(url2.searchParams.get("limit"), 20),
-        offset: normalizeLimit2(url2.searchParams.get("offset"), 0)
+        offset: normalizeLimit2(url2.searchParams.get("offset"), 0),
+        isVisible: discoveryVisibility(deps)
       });
       return jsonResponse(result.response);
     }
@@ -112122,14 +112753,18 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
       if (request2.method !== "GET")
         return methodNotAllowed();
       await deps.auth.authorizeBuilderList(request2);
-      const result = listDataVersionsContract({
+      const result = await listDataVersionsContract({
         storage: deps.storage,
         scopeParam: decodePathPart(parts[0]),
         limit: normalizeLimit2(url2.searchParams.get("limit"), 20),
-        offset: normalizeLimit2(url2.searchParams.get("offset"), 0)
+        offset: normalizeLimit2(url2.searchParams.get("offset"), 0),
+        isVisible: discoveryVisibility(deps)
       });
       if (!result.ok)
         return contractErrorResponse(result);
+      if (result.response.total === 0) {
+        await assertScopeNotDeleted(deps, result.scope, void 0);
+      }
       return jsonResponse(result.response);
     }
     if ((parts.length === 2 || parts.length === 3) && parts[1] === "lineage") {
@@ -112211,6 +112846,7 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
         fileId: url2.searchParams.get("fileId") ?? selectedEntry?.fileId ?? void 0,
         at: url2.searchParams.get("at") ?? void 0
       });
+      await assertScopeNotDeleted(deps, scopeResult.scope, selectedEntry);
       const isOwnerSignal = authResult?.grantId === "owner" || authResult?.grantId === "policy-bypass";
       const builder = authResult?.builder;
       const resolvedGrantId = !isOwnerSignal && authResult?.grantId ? authResult.grantId : void 0;
@@ -112265,8 +112901,12 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
         fileId: url2.searchParams.get("fileId") ?? void 0,
         at: url2.searchParams.get("at") ?? void 0
       });
-      if (!result.ok)
+      if (!result.ok) {
+        if (result.status === 404) {
+          await assertScopeNotDeleted(deps, scopeResult.scope, void 0);
+        }
         return contractErrorResponse(result);
+      }
       const logId = deps.createLogId?.() ?? crypto.randomUUID();
       const timestamp = (deps.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
       const ipAddress = request2.headers.get("x-forwarded-for") ?? request2.headers.get("x-real-ip") ?? "unknown";
@@ -112346,6 +112986,7 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
           return failWrite(contractErrorResponse(scopeResult));
         const collectedAtValue = collectedAt(deps.now ?? (() => /* @__PURE__ */ new Date()));
         const status2 = deps.syncManager ? "syncing" : "stored";
+        const afterTombstoneVersion = await ingestTombstoneMarker(deps, scopeResult.scope);
         const logBuilderWrite = async () => {
           if (!writeAuth)
             return;
@@ -112383,7 +113024,8 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
             collectedAt: collectedAtValue,
             status: status2,
             attribution: writeAuth?.attribution,
-            lineage: lineage2
+            lineage: lineage2,
+            afterTombstoneVersion
           });
           if (!result2.ok)
             return failWrite(contractErrorResponse(result2));
@@ -112411,7 +113053,8 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
           collectedAt: collectedAtValue,
           status: status2,
           attribution: writeAuth?.attribution,
-          lineage
+          lineage,
+          afterTombstoneVersion
         });
         if (!result.ok)
           return failWrite(contractErrorResponse(result));
@@ -112450,8 +113093,44 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
       if (cascade === "lineage") {
         throw new LineageCascadeUnavailableError({ scope: parsed.scope });
       }
-      await deleteOneScope(deps, parsed.scope);
-      return new Response(null, { status: 204 });
+      const result = deps.syncManager?.deleteScope ? await deps.syncManager.deleteScope(parsed.scope) : await deleteScope({
+        storage: deps.storage,
+        serverOwner: deps.serverOwner,
+        deleteData: null,
+        logger: apiLoggerAsLogger(deps.logger)
+      }, parsed.scope);
+      if (result.steps.gateway.status === "failed") {
+        throw new DeleteTombstoneFailedError({
+          scope: parsed.scope,
+          result
+        });
+      }
+      try {
+        await deps.accessLogWriter.write({
+          logId: deps.createLogId?.() ?? crypto.randomUUID(),
+          grantId: "owner",
+          builder: deps.serverOwner ?? "owner",
+          action: "delete",
+          scope: parsed.scope,
+          timestamp: (deps.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+          ipAddress: request2.headers.get("x-forwarded-for") ?? request2.headers.get("x-real-ip") ?? "unknown",
+          userAgent: request2.headers.get("user-agent") ?? "unknown"
+        });
+      } catch (err2) {
+        deps.logger?.warn?.({
+          scope: parsed.scope,
+          error: err2 instanceof Error ? err2.message : String(err2)
+        }, "Delete access-log entry failed; scope already deleted");
+      }
+      deps.logger?.info?.({
+        scope: parsed.scope,
+        durable: result.durable,
+        gateway: result.steps.gateway.status,
+        storage: result.steps.storage.status,
+        local: result.steps.local.status,
+        deletedCount: result.steps.local.deletedCount
+      }, "Scope deleted");
+      return jsonResponse(result, { status: 200 });
     }
     return methodNotAllowed();
   });
@@ -112761,6 +113440,16 @@ var McpDataReadError = class extends Error {
 };
 function createMcpDataReadClient(options) {
   const basePath = options.basePath ?? "/v1/data";
+  async function assertScopeReadable(scope, entry) {
+    try {
+      await assertScopeNotDeleted(options.dataApiDeps, scope, entry);
+    } catch (err2) {
+      if (err2 instanceof ProtocolError) {
+        throw new McpDataReadError(err2.code, err2.toJSON());
+      }
+      throw err2;
+    }
+  }
   async function authorizeScopeRead(params) {
     const safeScope = encodeURIComponent(params.scope);
     const signingUri = `${basePath}/${safeScope}`;
@@ -112848,6 +113537,9 @@ function createMcpDataReadClient(options) {
       const entry = storage.findEntry({ scope });
       if (!entry)
         return null;
+      if (await resolveReadDeletion(options.dataApiDeps, scope, entry)) {
+        return null;
+      }
       const hasBlocks = typeof storage.hasScopeBlocks === "function" ? await storage.hasScopeBlocks(scope, entry.collectedAt) : false;
       return {
         scope,
@@ -112876,6 +113568,7 @@ function createMcpDataReadClient(options) {
           message: `No data found for scope "${scope}"`
         });
       }
+      await assertScopeReadable(scope, selectedEntry);
       const { request: request2, authResult } = await authorizeScopeRead({
         scope,
         grantId,
@@ -112933,6 +113626,7 @@ function createMcpDataReadClient(options) {
           message: `No data found for scope "${scope}"`
         });
       }
+      await assertScopeReadable(scope, selectedEntry);
       const { request: request2, authResult } = await authorizeScopeRead({
         scope,
         grantId,
@@ -116596,15 +117290,15 @@ var makeIssue = (params) => {
       message: issueData.message
     };
   }
-  let errorMessage2 = "";
+  let errorMessage3 = "";
   const maps = errorMaps.filter((m10) => !!m10).slice().reverse();
   for (const map2 of maps) {
-    errorMessage2 = map2(fullIssue, { data, defaultError: errorMessage2 }).message;
+    errorMessage3 = map2(fullIssue, { data, defaultError: errorMessage3 }).message;
   }
   return {
     ...issueData,
     path: fullPath,
-    message: errorMessage2
+    message: errorMessage3
   };
 };
 function addIssueToContext(ctx, issueData) {
@@ -121884,19 +122578,19 @@ var getRefs = (options) => {
 };
 
 // ../../node_modules/zod-to-json-schema/dist/esm/errorMessages.js
-function addErrorMessage(res, key, errorMessage2, refs) {
+function addErrorMessage(res, key, errorMessage3, refs) {
   if (!refs?.errorMessages)
     return;
-  if (errorMessage2) {
+  if (errorMessage3) {
     res.errorMessage = {
       ...res.errorMessage,
-      [key]: errorMessage2
+      [key]: errorMessage3
     };
   }
 }
-function setResponseValueAndErrors(res, key, value, errorMessage2, refs) {
+function setResponseValueAndErrors(res, key, value, errorMessage3, refs) {
   res[key] = value;
-  addErrorMessage(res, key, errorMessage2, refs);
+  addErrorMessage(res, key, errorMessage3, refs);
 }
 
 // ../../node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
@@ -123207,8 +123901,8 @@ var Protocol = class {
                   if (queuedMessage.type === "response") {
                     resolver(message);
                   } else {
-                    const errorMessage2 = message;
-                    const error51 = new McpError(errorMessage2.error.code, errorMessage2.error.message, errorMessage2.error.data);
+                    const errorMessage3 = message;
+                    const error51 = new McpError(errorMessage3.error.code, errorMessage3.error.message, errorMessage3.error.data);
                     resolver(error51);
                   }
                 } else {
@@ -124508,23 +125202,23 @@ var Server = class extends Protocol {
       const wrappedHandler = async (request2, extra) => {
         const validatedRequest = safeParse3(CallToolRequestSchema, request2);
         if (!validatedRequest.success) {
-          const errorMessage2 = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage2}`);
+          const errorMessage3 = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage3}`);
         }
         const { params } = validatedRequest.data;
         const result = await Promise.resolve(handler(request2, extra));
         if (params.task) {
           const taskValidationResult = safeParse3(CreateTaskResultSchema, result);
           if (!taskValidationResult.success) {
-            const errorMessage2 = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage2}`);
+            const errorMessage3 = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage3}`);
           }
           return taskValidationResult.data;
         }
         const validationResult = safeParse3(CallToolResultSchema, result);
         if (!validationResult.success) {
-          const errorMessage2 = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage2}`);
+          const errorMessage3 = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage3}`);
         }
         return validationResult.data;
       };
@@ -125240,12 +125934,12 @@ var McpServer = class {
    * @param errorMessage - The error message.
    * @returns The tool error result.
    */
-  createToolError(errorMessage2) {
+  createToolError(errorMessage3) {
     return {
       content: [
         {
           type: "text",
-          text: errorMessage2
+          text: errorMessage3
         }
       ],
       isError: true
@@ -125263,8 +125957,8 @@ var McpServer = class {
     const parseResult = await safeParseAsync3(schemaToParse, args);
     if (!parseResult.success) {
       const error51 = "error" in parseResult ? parseResult.error : "Unknown error";
-      const errorMessage2 = getParseErrorMessage(error51);
-      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage2}`);
+      const errorMessage3 = getParseErrorMessage(error51);
+      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage3}`);
     }
     return parseResult.data;
   }
@@ -125288,8 +125982,8 @@ var McpServer = class {
     const parseResult = await safeParseAsync3(outputObj, result.structuredContent);
     if (!parseResult.success) {
       const error51 = "error" in parseResult ? parseResult.error : "Unknown error";
-      const errorMessage2 = getParseErrorMessage(error51);
-      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage2}`);
+      const errorMessage3 = getParseErrorMessage(error51);
+      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage3}`);
     }
   }
   /**
@@ -125501,8 +126195,8 @@ var McpServer = class {
         const parseResult = await safeParseAsync3(argsObj, request2.params.arguments);
         if (!parseResult.success) {
           const error51 = "error" in parseResult ? parseResult.error : "Unknown error";
-          const errorMessage2 = getParseErrorMessage(error51);
-          throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request2.params.name}: ${errorMessage2}`);
+          const errorMessage3 = getParseErrorMessage(error51);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request2.params.name}: ${errorMessage3}`);
         }
         const args = parseResult.data;
         const cb2 = prompt.callback;
@@ -127598,6 +128292,7 @@ function createPsLiteRuntime(options) {
             accessLogWriter,
             readFulfillmentReporter: options.readFulfillmentReporter,
             syncManager: options.syncManager ?? null,
+            scopeDeletions: options.scopeDeletions,
             now,
             createLogId,
             // x402 payment enforcement for builder reads. Only engages with a
@@ -128074,6 +128769,45 @@ var OrphanedEntryError = class extends Error {
     this.name = "OrphanedEntryError";
   }
 };
+var DeletedScopeEntryError = class extends Error {
+  constructor(path, deletedAt) {
+    super(`Dropped local entry for a scope deleted at ${deletedAt}: ${path}`);
+    this.name = "DeletedScopeEntryError";
+  }
+};
+async function dropIfCoveredByDeletion(deps, entry, tombstone, deletedAt, uploaded) {
+  const version4 = tombstoneVersion(tombstone);
+  if (!isEntryCoveredByTombstone(entry, { version: version4 }))
+    return;
+  if (uploaded) {
+    try {
+      await deps.storageAdapter.delete(uploaded.url);
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : String(err2);
+      if (deps.pendingBlobDeletions) {
+        await deps.pendingBlobDeletions.add([
+          { scope: entry.scope, version: String(entry.version) }
+        ]);
+      }
+      deps.logger.warn({
+        scope: entry.scope,
+        url: uploaded.url,
+        error: message,
+        queuedForCleanup: Boolean(deps.pendingBlobDeletions)
+      }, "Could not delete the ciphertext uploaded for an entry the tombstone covers");
+    }
+  }
+  await deps.storage.deleteVersion(entry.scope, entry.collectedAt);
+  deps.logger.warn({
+    path: entry.path,
+    scope: entry.scope,
+    deletedAt,
+    tombstoneVersion: version4,
+    entryVersion: entry.version,
+    afterTombstoneVersion: entry.afterTombstoneVersion ?? null
+  }, "Dropped unsynced local entry: the gateway reports its scope as deleted");
+  throw new DeletedScopeEntryError(entry.path, deletedAt);
+}
 function isMissingPayloadError(err2) {
   return err2 instanceof Error && err2.code === "ENOENT";
 }
@@ -128092,6 +128826,20 @@ async function uploadOne(deps, entry) {
     }
     throw err2;
   }
+  let registerVersion = BigInt(entry.version);
+  if (!entry.dataPointId && deps.dataPointFeed) {
+    const remote = await deps.dataPointFeed.getDataPoint({
+      ownerAddress: serverOwner,
+      scope: entry.scope
+    });
+    const deletedAt = deletionTimestamp(remote);
+    if (remote && deletedAt !== null) {
+      await dropIfCoveredByDeletion(deps, entry, remote, deletedAt);
+      const afterTombstone = BigInt(remote.expectedVersion) + 1n;
+      if (afterTombstone > registerVersion)
+        registerVersion = afterTombstone;
+    }
+  }
   const scopeKey = deriveScopeKey(masterKey, entry.scope);
   const scopeKeyHex = uint8ToHex(scopeKey);
   const plaintext = new TextEncoder().encode(JSON.stringify(envelope));
@@ -128102,7 +128850,7 @@ async function uploadOne(deps, entry) {
     collectedAt: entry.collectedAt,
     sizeBytes: encrypted.byteLength
   })));
-  const storageKey = `${entry.scope}/${entry.version}`;
+  const storageKey = `${entry.scope}/${registerVersion}`;
   let url2 = await storageAdapter.upload(storageKey, encrypted);
   let dataPointId;
   if (entry.dataPointId) {
@@ -128152,11 +128900,23 @@ async function uploadOne(deps, entry) {
       return id2;
     };
     try {
-      dataPointId = await registerAt(BigInt(entry.version));
+      dataPointId = await registerAt(registerVersion);
+      if (registerVersion !== BigInt(entry.version)) {
+        await storage.updateEntryVersion(entry.path, Number(registerVersion));
+      }
     } catch (err2) {
       if (!isStaleVersionConflict(err2))
         throw err2;
-      const record2 = await gateway.getDataPoint(computeDataPointId(serverOwner, entry.scope));
+      const record2 = deps.dataPointFeed ? await deps.dataPointFeed.getDataPoint({
+        ownerAddress: serverOwner,
+        scope: entry.scope
+      }) : await gateway.getDataPoint(computeDataPointId(serverOwner, entry.scope));
+      const conflictDeletedAt = record2 ? deletionTimestamp(record2) : null;
+      if (record2 && conflictDeletedAt !== null) {
+        await dropIfCoveredByDeletion(deps, entry, record2, conflictDeletedAt, {
+          url: url2
+        });
+      }
       if (record2 && record2.dataHash.toLowerCase() === dataHash.toLowerCase()) {
         dataPointId = record2.id;
         const adoptedVersion = Number(record2.expectedVersion);
@@ -128182,6 +128942,7 @@ async function uploadOne(deps, entry) {
       }
     }
     await storage.updateDataPointId(entry.path, dataPointId);
+    deps.scopeDeletions?.markLive(entry.scope);
   }
   logger.info({
     path: entry.path,
@@ -128201,7 +128962,7 @@ async function uploadAll(deps, options) {
       const result = await uploadOne(deps, entry);
       results.push(result);
     } catch (err2) {
-      if (err2 instanceof OrphanedEntryError) {
+      if (err2 instanceof OrphanedEntryError || err2 instanceof DeletedScopeEntryError) {
         continue;
       }
       const error51 = err2;
@@ -128230,6 +128991,101 @@ function parseGatewayNextVersion(message) {
   return null;
 }
 
+// ../core/dist/sync/data-point-feed.js
+function createGatewayDataPointFeed(options) {
+  const base = options.gatewayUrl.replace(/\/+$/, "");
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  return {
+    async listDataPointsByOwner(owner, cursor, listOptions) {
+      const params = new URLSearchParams({ user: owner });
+      if (cursor !== null)
+        params.set("cursor", cursor);
+      if (listOptions?.since)
+        params.set("since", listOptions.since);
+      if (listOptions?.limit !== void 0) {
+        params.set("limit", String(listOptions.limit));
+      }
+      if (listOptions?.includeDeleted)
+        params.set("includeDeleted", "true");
+      const res = await fetchImpl(`${base}/v1/data?${params.toString()}`);
+      if (!res.ok) {
+        throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
+      }
+      const envelope = await res.json();
+      const nextCursor = envelope.pagination?.hasMore === false ? null : envelope.pagination?.nextCursor ?? null;
+      const rows = envelope.data?.dataPoints ?? [];
+      return {
+        dataPoints: rows.map((row) => normalizeRecord(row)),
+        cursor: nextCursor
+      };
+    },
+    async getDataPoint(input) {
+      const dataPointId = computeDataPointId(input.ownerAddress, input.scope);
+      const res = await fetchImpl(`${base}/v1/data/${dataPointId}?includeDeleted=true`);
+      if (res.status === 404)
+        return null;
+      if (res.status === 410) {
+        const body2 = await res.json().catch(() => null);
+        const echoed = unwrap(body2);
+        const deletedAt = stringField(echoed, "deletedAt") ?? now().toISOString();
+        return {
+          id: dataPointId,
+          ownerAddress: input.ownerAddress,
+          scope: input.scope,
+          dataHash: stringField(echoed, "dataHash") ?? TOMBSTONE_DATA_HASH,
+          metadataHash: stringField(echoed, "metadataHash") ?? TOMBSTONE_METADATA_HASH,
+          expectedVersion: stringField(echoed, "expectedVersion") ?? "0",
+          addedAt: stringField(echoed, "addedAt") ?? deletedAt,
+          deletedAt
+        };
+      }
+      if (!res.ok) {
+        throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
+      }
+      const body = await res.json();
+      return normalizeRecord(unwrap(body));
+    }
+  };
+}
+function unwrap(body) {
+  if (typeof body !== "object" || body === null)
+    return null;
+  const record2 = body;
+  if (typeof record2.data === "object" && record2.data !== null) {
+    return record2.data;
+  }
+  return record2;
+}
+function stringField(record2, key) {
+  const value = record2?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function normalizeRecord(row) {
+  const record2 = row ?? {};
+  const deletedAt = record2.deletedAt;
+  return {
+    ...record2,
+    deletedAt: typeof deletedAt === "string" ? deletedAt : null
+  };
+}
+function feedFromGatewayClient(gateway) {
+  return {
+    async listDataPointsByOwner(owner, cursor, listOptions) {
+      const { includeDeleted: _includeDeleted, ...sdkOptions } = listOptions ?? {};
+      const result = Object.keys(sdkOptions).length > 0 ? await gateway.listDataPointsByOwner(owner, cursor, sdkOptions) : await gateway.listDataPointsByOwner(owner, cursor);
+      return {
+        dataPoints: result.dataPoints.map((row) => normalizeRecord(row)),
+        cursor: result.cursor
+      };
+    },
+    async getDataPoint(input) {
+      const row = await gateway.getDataPoint(computeDataPointId(input.ownerAddress, input.scope));
+      return row === null ? null : normalizeRecord(row);
+    }
+  };
+}
+
 // ../core/dist/sync/issues.js
 var DETERMINISTIC_STAGES = /* @__PURE__ */ new Set([
   "openpgp_parse",
@@ -128567,10 +129423,43 @@ async function downloadAll(deps, options = {}) {
   if (options.fullReconcile || repairSummary.missingEnvelopeEntries > 0) {
     options.retryMemory?.onListingReset();
   }
-  const { dataPoints, cursor: nextCursor } = await gateway.listDataPointsByOwner(serverOwner, lastCursor);
+  const feed = deps.dataPointFeed ?? feedFromGatewayClient(gateway);
+  const { dataPoints, cursor: nextCursor } = await feed.listDataPointsByOwner(serverOwner, lastCursor, { includeDeleted: true });
+  if (deps.scopeDeletions) {
+    for (const dataPoint of dataPoints) {
+      const deletedAt = deletionTimestamp(dataPoint);
+      if (deletedAt !== null) {
+        deps.scopeDeletions.markDeleted(dataPoint.scope, {
+          deletedAt,
+          version: tombstoneVersion(dataPoint)
+        });
+      } else {
+        deps.scopeDeletions.markLive(dataPoint.scope);
+      }
+    }
+    if (nextCursor === null) {
+      deps.scopeDeletions.noteFeedSynced(void 0, {
+        full: lastCursor === null
+      });
+    }
+  }
   const results = [];
   let failed = false;
   for (const dataPoint of dataPoints) {
+    const deletedAt = deletionTimestamp(dataPoint);
+    if (deletedAt !== null) {
+      try {
+        await reconcileDeletedDataPoint(deps, dataPoint, deletedAt);
+      } catch (err2) {
+        logger.error({
+          dataPointId: dataPoint.id,
+          scope: dataPoint.scope,
+          error: err2.message
+        }, "Failed to reconcile deleted data point locally");
+        failed = true;
+      }
+      continue;
+    }
     const retryKey = downloadRetryKey(dataPoint);
     const decision = options.retryMemory?.decide(retryKey) ?? "attempt";
     if (decision === "give-up") {
@@ -128626,6 +129515,49 @@ async function downloadAll(deps, options = {}) {
   }
   return results;
 }
+async function reconcileDeletedDataPoint(deps, record2, deletedAt) {
+  const tombstone = { version: tombstoneVersion(record2) };
+  const tombstoned = tombstone.version === null ? null : BigInt(tombstone.version);
+  const orphanKeys = [];
+  const { storage, logger } = deps;
+  const PAGE_SIZE = 500;
+  const stale = [];
+  let kept = 0;
+  for (let offset = 0; ; offset += PAGE_SIZE) {
+    const entries = storage.listVersions(record2.scope, {
+      limit: PAGE_SIZE,
+      offset
+    });
+    for (const entry of entries) {
+      if (isEntryCoveredByTombstone(entry, tombstone)) {
+        stale.push({ scope: entry.scope, collectedAt: entry.collectedAt });
+        if (entry.dataPointId === null && (tombstoned === null || BigInt(entry.version) > tombstoned)) {
+          orphanKeys.push({
+            scope: entry.scope,
+            version: String(entry.version)
+          });
+        }
+      } else {
+        kept += 1;
+      }
+    }
+    if (entries.length < PAGE_SIZE)
+      break;
+  }
+  let removed = 0;
+  for (const version4 of stale) {
+    if (await storage.deleteVersion(version4.scope, version4.collectedAt)) {
+      removed += 1;
+    }
+  }
+  if (orphanKeys.length > 0 && deps.pendingBlobDeletions) {
+    await deps.pendingBlobDeletions.add(orphanKeys);
+  }
+  if (removed > 0 || kept > 0) {
+    logger.info({ dataPointId: record2.id, scope: record2.scope, deletedAt, removed, kept }, "Reconciled gateway deletion against local index");
+  }
+  return { scope: record2.scope, deletedAt, removed, kept };
+}
 async function repairLocalMissingBlockSidecars(deps) {
   const { storage, logger, diagnostics } = deps;
   if (!storage.writeBlockManifest || !storage.hasScopeBlocks) {
@@ -128784,28 +129716,6 @@ async function repairMissingBlockSidecars(storage, logger, ctx, entry, diagnosti
   }
 }
 
-// ../core/dist/sync/workers/delete.js
-async function deleteScopeRemote(deps, scope) {
-  const { storage, logger } = deps;
-  let syncedVersions = 0;
-  const PAGE_SIZE = 1e3;
-  for (let offset = 0; ; offset += PAGE_SIZE) {
-    const entries = storage.listVersions(scope, { limit: PAGE_SIZE, offset });
-    syncedVersions += entries.filter((e10) => e10.dataPointId !== null).length;
-    if (entries.length < PAGE_SIZE)
-      break;
-  }
-  if (syncedVersions > 0) {
-    logger.warn({ scope, syncedVersions }, "Remote scope deletion is not supported on the DPv2 gateway (no de-registration endpoint); local data was removed but the remote data point(s) and ciphertext blob(s) remain");
-  }
-  return {
-    scope,
-    filesDeregistered: 0,
-    blobsDeleted: 0,
-    errors: []
-  };
-}
-
 // ../core/dist/sync/engine/sync-manager.js
 var MAX_ERRORS = 10;
 function createSyncManager(uploadDeps, downloadDeps, options) {
@@ -128823,12 +129733,28 @@ function createSyncManager(uploadDeps, downloadDeps, options) {
   let rerunRequested = false;
   let needsFullReconcile = true;
   const downloadRetryMemory = createDownloadRetryMemory();
+  const dataPointFeed = downloadDeps.dataPointFeed ?? uploadDeps.dataPointFeed;
+  const scopeDeletions = uploadDeps.scopeDeletions ?? downloadDeps.scopeDeletions;
+  const workerUploadDeps = {
+    ...uploadDeps,
+    pendingBlobDeletions: uploadDeps.pendingBlobDeletions ?? options?.pendingBlobDeletions
+  };
+  const workerDownloadDeps = {
+    ...downloadDeps,
+    pendingBlobDeletions: downloadDeps.pendingBlobDeletions ?? options?.pendingBlobDeletions
+  };
+  let mutationQueue = Promise.resolve();
+  function exclusive(operation) {
+    const run = mutationQueue.then(operation, operation);
+    mutationQueue = run.catch(() => void 0);
+    return run;
+  }
   async function runCycle() {
     if (cycleInFlight) {
       rerunRequested = true;
       return cycleInFlight;
     }
-    cycleInFlight = (async () => {
+    cycleInFlight = exclusive(async () => {
       do {
         rerunRequested = false;
         const canRun = await (options?.canSync?.() ?? { ok: true });
@@ -128839,7 +129765,19 @@ function createSyncManager(uploadDeps, downloadDeps, options) {
         }
         blocked = null;
         try {
-          const uploadResults = await uploadAll(uploadDeps, {
+          await retryPendingBlobDeletions({
+            deleteData: options?.deleteData,
+            pendingBlobDeletions: options?.pendingBlobDeletions,
+            dataPointFeed,
+            serverOwner: uploadDeps.serverOwner,
+            storage: uploadDeps.storage,
+            logger: uploadDeps.logger
+          });
+        } catch (err2) {
+          uploadDeps.logger.warn({ error: err2.message }, "Pending blob deletion retry failed");
+        }
+        try {
+          const uploadResults = await uploadAll(workerUploadDeps, {
             batchSize: uploadBatchSize,
             onError(entry, error51) {
               pushError({
@@ -128863,7 +129801,7 @@ function createSyncManager(uploadDeps, downloadDeps, options) {
         }
         try {
           const fullReconcile = needsFullReconcile;
-          const downloadResults = await downloadAll(downloadDeps, {
+          const downloadResults = await downloadAll(workerDownloadDeps, {
             fullReconcile,
             retryMemory: downloadRetryMemory
           });
@@ -128885,7 +129823,7 @@ function createSyncManager(uploadDeps, downloadDeps, options) {
         }
         lastSync = (/* @__PURE__ */ new Date()).toISOString();
       } while (rerunRequested && isRunning);
-    })();
+    });
     try {
       await cycleInFlight;
     } finally {
@@ -128974,13 +129912,291 @@ function createSyncManager(uploadDeps, downloadDeps, options) {
       uploadDeps.logger.debug("New data notification received");
       scheduleNotifiedCycle();
     },
-    async deleteScopeRemote(scope) {
-      await deleteScopeRemote(uploadDeps, scope);
+    deleteScope(scope) {
+      return exclusive(() => deleteScope({
+        storage: uploadDeps.storage,
+        serverOwner: uploadDeps.serverOwner,
+        deleteData: options?.deleteData,
+        pendingBlobDeletions: options?.pendingBlobDeletions,
+        scopeDeletions,
+        dataPointFeed,
+        logger: uploadDeps.logger
+      }, scope));
     }
   };
   return manager;
 }
 
+// ../core/dist/sync/delete-data-port.js
+function createGatewayDeleteDataPort(options) {
+  const gatewayBase = options.gatewayUrl.replace(/\/+$/, "");
+  const storageBase = options.storage.endpoint.replace(/\/+$/, "");
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const owner = options.serverOwner.toLowerCase();
+  async function sendTombstone(scope, dataPointId, version4) {
+    const signature = await options.signer.signAddData({
+      ownerAddress: options.serverOwner,
+      scope,
+      dataHash: TOMBSTONE_DATA_HASH,
+      metadataHash: TOMBSTONE_METADATA_HASH,
+      expectedVersion: version4
+    });
+    return fetchImpl(`${gatewayBase}/v1/data/${dataPointId}`, {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Web3Signed ${signature}`
+      },
+      body: JSON.stringify({
+        ownerAddress: options.serverOwner,
+        scope,
+        expectedVersion: String(version4),
+        signature
+      })
+    });
+  }
+  return {
+    async tombstone(scope) {
+      const dataPointId = computeDataPointId(options.serverOwner, scope);
+      const current = await options.dataPointFeed.getDataPoint({
+        ownerAddress: options.serverOwner,
+        scope
+      });
+      if (current === null) {
+        return { status: "not-registered", dataPointId };
+      }
+      if (current.deletedAt !== null) {
+        return {
+          status: "already-deleted",
+          dataPointId,
+          version: current.expectedVersion,
+          deletedAt: current.deletedAt
+        };
+      }
+      let version4 = BigInt(current.expectedVersion) + 1n;
+      let res = await sendTombstone(scope, dataPointId, version4);
+      if (res.status === 409) {
+        const body2 = await res.json().catch(() => null);
+        const conflict = unwrap2(body2);
+        const nextExplicit = integerField(conflict, "nextExpectedVersion") ?? integerField(body2, "nextExpectedVersion");
+        const currentExpected = integerField(conflict, "currentExpectedVersion") ?? integerField(body2, "currentExpectedVersion");
+        const legacyNext = parseGatewayNextVersion(detailFromBody(body2, res.statusText));
+        const next = nextExplicit !== null ? nextExplicit : currentExpected !== null ? currentExpected + 1n : legacyNext !== null ? BigInt(legacyNext) : null;
+        if (next === null) {
+          throw new Error(`Gateway error: 409 ${detailFromBody(body2, res.statusText)}`);
+        }
+        version4 = next;
+        res = await sendTombstone(scope, dataPointId, version4);
+      }
+      if (res.status === 404) {
+        return { status: "not-registered", dataPointId };
+      }
+      if (res.status === 410) {
+        const body2 = await res.json().catch(() => null);
+        const echoed = unwrap2(body2);
+        let winning = normalizeVersionString(stringField2(echoed, "expectedVersion"));
+        let deletedAt = stringField2(echoed, "deletedAt");
+        if (winning === null) {
+          const reread = await options.dataPointFeed.getDataPoint({ ownerAddress: options.serverOwner, scope }).catch(() => null);
+          if (reread && reread.deletedAt !== null) {
+            winning = normalizeVersionString(reread.expectedVersion);
+            deletedAt = deletedAt ?? reread.deletedAt;
+          }
+        }
+        return {
+          status: "already-deleted",
+          dataPointId,
+          version: winning,
+          deletedAt
+        };
+      }
+      if (!res.ok) {
+        throw new Error(`Gateway error: ${res.status} ${await errorDetail(res)}`);
+      }
+      const body = await res.json().catch(() => null);
+      const row = unwrap2(body);
+      return {
+        status: "tombstoned",
+        dataPointId: stringField2(row, "dataPointId") ?? dataPointId,
+        version: stringField2(row, "expectedVersion") ?? String(version4),
+        deletedAt: stringField2(row, "deletedAt")
+      };
+    },
+    async deleteBlobVersions(scope, versions) {
+      const outcome = {
+        deleted: [],
+        missing: [],
+        failed: []
+      };
+      for (const version4 of versions) {
+        const path = `/v1/chains/${options.storage.chainId}/blobs/${owner}/${encodeURIComponent(scope)}/${encodeURIComponent(version4)}`;
+        try {
+          const authorization = await buildWeb3SignedHeader({
+            signMessage: (message) => options.storage.signMessage(message),
+            aud: storageBase,
+            method: "DELETE",
+            uri: path
+          });
+          const res = await fetchImpl(`${storageBase}${path}`, {
+            method: "DELETE",
+            headers: { authorization }
+          });
+          if (res.status === 404) {
+            outcome.missing.push(version4);
+          } else if (res.ok) {
+            outcome.deleted.push(version4);
+          } else {
+            outcome.failed.push({
+              version: version4,
+              error: `vana-storage delete failed: ${res.status} ${res.statusText}`
+            });
+          }
+        } catch (err2) {
+          outcome.failed.push({
+            version: version4,
+            error: err2 instanceof Error ? err2.message : String(err2)
+          });
+        }
+      }
+      return outcome;
+    }
+  };
+}
+async function errorDetail(res) {
+  const body = await res.json().catch(() => null);
+  return detailFromBody(body, res.statusText);
+}
+function detailFromBody(body, fallback) {
+  if (typeof body === "object" && body !== null) {
+    const record2 = body;
+    if (typeof record2.error === "string")
+      return record2.error;
+    if (typeof record2.message === "string")
+      return record2.message;
+    if (typeof record2.error === "object" && record2.error !== null) {
+      const nested = record2.error;
+      if (typeof nested.message === "string")
+        return nested.message;
+    }
+  }
+  return fallback;
+}
+function normalizeVersionString(value) {
+  if (value === null || !/^\d+$/.test(value))
+    return null;
+  const parsed = BigInt(value);
+  return parsed > 0n ? parsed.toString() : null;
+}
+function integerField(record2, key) {
+  if (typeof record2 !== "object" || record2 === null)
+    return null;
+  const value = record2[key];
+  if (typeof value === "number" && Number.isSafeInteger(value)) {
+    return BigInt(value);
+  }
+  if (typeof value === "string" && /^\d+$/.test(value))
+    return BigInt(value);
+  return null;
+}
+function unwrap2(body) {
+  if (typeof body !== "object" || body === null)
+    return null;
+  const record2 = body;
+  if (typeof record2.data === "object" && record2.data !== null) {
+    return record2.data;
+  }
+  return record2;
+}
+function stringField2(record2, key) {
+  const value = record2?.[key];
+  return typeof value === "string" ? value : null;
+}
+
+// ../core/dist/sync/pending-blob-deletions.js
+function markerId(key) {
+  const range = key.range ? `${key.range.from}-${key.range.to}` : "";
+  return `${key.scope}\0${key.version ?? ""}\0${range}`;
+}
+function normalizeRange(value) {
+  if (typeof value !== "object" || value === null)
+    return void 0;
+  const { from, to: to3 } = value;
+  if (typeof from !== "string" || typeof to3 !== "string" || !/^\d+$/.test(from) || !/^\d+$/.test(to3) || BigInt(from) > BigInt(to3)) {
+    return void 0;
+  }
+  return { from, to: to3 };
+}
+function normalizePendingBlobDeletions(stored) {
+  if (!Array.isArray(stored))
+    return [];
+  const keys = [];
+  for (const item of stored) {
+    if (typeof item === "string") {
+      keys.push({ scope: item, version: null });
+    } else if (typeof item === "object" && item !== null && typeof item.scope === "string") {
+      const version4 = item.version;
+      const range = typeof version4 === "string" ? void 0 : normalizeRange(item.range);
+      keys.push({
+        scope: item.scope,
+        version: typeof version4 === "string" ? version4 : null,
+        ...range ? { range } : {}
+      });
+    }
+  }
+  return keys;
+}
+function createPendingBlobDeletionStore(kv) {
+  let queue = Promise.resolve();
+  function serialized(operation) {
+    const run = queue.then(operation, operation);
+    queue = run.catch(() => void 0);
+    return run;
+  }
+  async function current() {
+    return normalizePendingBlobDeletions(await kv.read());
+  }
+  return {
+    list() {
+      return serialized(current);
+    },
+    add(keys) {
+      return serialized(async () => {
+        if (keys.length === 0)
+          return;
+        const existing = await current();
+        const known = new Set(existing.map(markerId));
+        const next = [...existing];
+        for (const key of keys) {
+          const id2 = markerId(key);
+          if (known.has(id2))
+            continue;
+          known.add(id2);
+          next.push({
+            scope: key.scope,
+            version: key.version,
+            ...key.range ? { range: { ...key.range } } : {}
+          });
+        }
+        if (next.length === existing.length)
+          return;
+        await kv.write(next);
+      });
+    },
+    remove(keys) {
+      return serialized(async () => {
+        if (keys.length === 0)
+          return;
+        const existing = await current();
+        const gone = new Set(keys.map(markerId));
+        const next = existing.filter((key) => !gone.has(markerId(key)));
+        if (next.length === existing.length)
+          return;
+        await kv.write(next);
+      });
+    }
+  };
+}
+
 // ../core/dist/storage/adapters/sdk.js
 function createSdkStorageAdapter(providerOrFactory, options) {
   let cachedProvider;
@@ -129041,8 +130257,11 @@ function copyBytes(data) {
 
 // ../core/dist/storage/adapters/vana.js
 var DEFAULT_VANA_STORAGE_ENDPOINT = "https://storage.vana.org";
+function resolveVanaStorageEndpoint(config2) {
+  return (config2.storage.config.vana?.apiUrl ?? DEFAULT_VANA_STORAGE_ENDPOINT).replace(/\/+$/, "");
+}
 function createVanaSyncStorageAdapter(params) {
-  const endpoint = (params.config.storage.config.vana?.apiUrl ?? DEFAULT_VANA_STORAGE_ENDPOINT).replace(/\/+$/, "");
+  const endpoint = resolveVanaStorageEndpoint(params.config);
   const owner = params.serverOwner.toLowerCase();
   const chainId = params.config.gateway.chainId;
   return createSdkStorageAdapter(createVanaStorageProvider({
@@ -129097,6 +130316,7 @@ async function resolvePsLiteOwner(input) {
 
 // ../lite/dist/sync.js
 var SYNC_CURSOR_KEY = "sync-cursor-v1";
+var PENDING_BLOB_DELETIONS_KEY = "pending-blob-deletions-v1";
 function createBrowserLogger(logger) {
   const fallback = {
     info: console.info.bind(console),
@@ -129127,6 +130347,19 @@ function createPsLiteSyncCursor(stateStore) {
     }
   };
 }
+function createPsLitePendingBlobDeletionStore(stateStore) {
+  return createPendingBlobDeletionStore({
+    async read() {
+      const state = await stateStore.get(PENDING_BLOB_DELETIONS_KEY);
+      if (!state)
+        return null;
+      return normalizePendingBlobDeletions(state.keys ?? state.scopes);
+    },
+    async write(keys) {
+      await stateStore.set(PENDING_BLOB_DELETIONS_KEY, { keys });
+    }
+  });
+}
 function buildDownloadDiagnosticsHook(recorder) {
   return {
     onDownloadStart(fileId) {
@@ -129212,6 +130445,20 @@ async function createPsLiteSyncManager(options) {
   });
   const cursor = createPsLiteSyncCursor(options.stateStore);
   const logger = createBrowserLogger(options.logger);
+  const dataPointFeed = options.dataPointFeed ?? createGatewayDataPointFeed({ gatewayUrl: options.config.gateway.url });
+  const scopeDeletions = options.scopeDeletions ?? createScopeDeletionTracker({ feed: dataPointFeed, serverOwner, logger });
+  const deleteData = createGatewayDeleteDataPort({
+    gatewayUrl: options.config.gateway.url,
+    dataPointFeed,
+    serverOwner,
+    signer,
+    storage: {
+      endpoint: resolveVanaStorageEndpoint(options.config),
+      chainId: options.config.gateway.chainId,
+      signMessage: (message) => options.serverAccount.signMessage(message)
+    }
+  });
+  const pendingBlobDeletions = createPsLitePendingBlobDeletionStore(options.stateStore);
   const downloadDiagnostics = options.diagnostics ? buildDownloadDiagnosticsHook(options.diagnostics) : void 0;
   const syncManager = createSyncManager({
     storage: options.storage,
@@ -129221,7 +130468,9 @@ async function createPsLiteSyncManager(options) {
     masterKey,
     serverOwner,
     logger,
-    lineageGateway: options.lineageGateway
+    lineageGateway: options.lineageGateway,
+    dataPointFeed,
+    scopeDeletions
   }, {
     storage: options.storage,
     storageAdapter,
@@ -129230,8 +130479,12 @@ async function createPsLiteSyncManager(options) {
     masterKey,
     serverOwner,
     logger,
-    diagnostics: downloadDiagnostics
+    diagnostics: downloadDiagnostics,
+    dataPointFeed,
+    scopeDeletions
   }, {
+    deleteData,
+    pendingBlobDeletions,
     async canSync() {
       try {
         const serverInfo = await gateway.getServer(options.serverAccount.address);
@@ -129253,7 +130506,7 @@ async function createPsLiteSyncManager(options) {
     }
   });
   syncManager.start();
-  return { syncManager, serverOwner };
+  return { syncManager, serverOwner, dataPointFeed, scopeDeletions };
 }
 
 // ../lite/dist/persistence.js
@@ -129319,8 +130572,9 @@ async function createIndexedDbPsLiteRuntime(options) {
     requestSigner: createRequestSigner(identity.account)
   });
   let syncManager = options.syncManager ?? null;
+  let scopeDeletions = options.scopeDeletions;
   if (!syncManager && config2.sync.enabled) {
-    syncManager = (await createPsLiteSyncManager({
+    const sync = await createPsLiteSyncManager({
       config: config2,
       stateStore,
       storage,
@@ -129328,10 +130582,14 @@ async function createIndexedDbPsLiteRuntime(options) {
       ownerAddress: options.ownerAddress,
       serverAccount: identity.account,
       gateway,
+      dataPointFeed: options.dataPointFeed,
+      scopeDeletions,
       diagnostics,
       logger: options.logger,
       lineageGateway
-    })).syncManager;
+    });
+    syncManager = sync.syncManager;
+    scopeDeletions = sync.scopeDeletions;
   }
   let runtimeRef = null;
   const auth = options.auth ?? createWeb3SignedPsLiteAuth({
@@ -129360,6 +130618,7 @@ async function createIndexedDbPsLiteRuntime(options) {
     serverOwner,
     serverSigner,
     syncManager,
+    scopeDeletions,
     diagnostics,
     lineageGateway,
     saveConfig: async (nextConfig) => {