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

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

@@ -105536,6 +105536,17 @@ var GENERIC_PAYMENT_TYPES = {
   ]
 };
 
+// ../core/dist/lineage/attestation.js
+var LINEAGE_ATTESTATION_TYPES = {
+  LineageAttestation: [
+    { name: "ownerAddress", type: "address" },
+    { name: "scope", type: "string" },
+    { name: "expectedVersion", type: "uint256" },
+    { name: "dataHash", type: "bytes32" },
+    { name: "sources", type: "bytes32[]" }
+  ]
+};
+
 // ../core/dist/signing/signer.js
 function createServerSigner(account, gatewayConfig) {
   return {
@@ -105568,6 +105579,14 @@ function createServerSigner(account, gatewayConfig) {
         message: msg
       });
     },
+    async signLineageAttestation(msg) {
+      return account.signTypedData({
+        domain: dataRegistryDomain(gatewayConfig),
+        types: LINEAGE_ATTESTATION_TYPES,
+        primaryType: "LineageAttestation",
+        message: { ...msg, sources: [...msg.sources] }
+      });
+    },
     async signRecordDataAccess(msg) {
       return account.signTypedData({
         domain: dataRegistryDomain(gatewayConfig),
@@ -105579,6 +105598,498 @@ function createServerSigner(account, gatewayConfig) {
   };
 }
 
+// ../core/dist/signing/request-signer.js
+function createRequestSigner(account) {
+  return {
+    async signRequest(params) {
+      return buildWeb3SignedHeader({
+        signMessage: (message) => account.signMessage(message),
+        aud: params.aud,
+        method: params.method,
+        uri: params.uri,
+        body: params.body,
+        grantId: params.grantId
+      });
+    }
+  };
+}
+
+// ../core/dist/errors/catalog.js
+var ProtocolError = class extends Error {
+  code;
+  errorCode;
+  details;
+  constructor(code, errorCode, message, details) {
+    super(message);
+    this.code = code;
+    this.errorCode = errorCode;
+    this.details = details;
+    this.name = this.constructor.name;
+  }
+  toJSON() {
+    return {
+      error: {
+        code: this.code,
+        errorCode: this.errorCode,
+        message: this.message,
+        ...this.details !== void 0 && { details: this.details }
+      }
+    };
+  }
+};
+var MissingAuthError2 = class extends ProtocolError {
+  constructor(details) {
+    super(401, "MISSING_AUTH", "Missing authentication", details);
+  }
+};
+var InvalidSignatureError3 = class extends ProtocolError {
+  constructor(details) {
+    super(401, "INVALID_SIGNATURE", "Invalid signature", details);
+  }
+};
+var UnregisteredBuilderError = class extends ProtocolError {
+  constructor(details) {
+    super(401, "UNREGISTERED_BUILDER", "Unregistered builder", details);
+  }
+};
+var NotOwnerError = class extends ProtocolError {
+  constructor(details) {
+    super(401, "NOT_OWNER", "Not the owner", details);
+  }
+};
+var ExpiredTokenError2 = class extends ProtocolError {
+  constructor(details) {
+    super(401, "EXPIRED_TOKEN", "Token has expired", details);
+  }
+};
+var GrantRequiredError = class extends ProtocolError {
+  constructor(details) {
+    super(403, "GRANT_REQUIRED", "Grant required", details);
+  }
+};
+var GrantExpiredError = class extends ProtocolError {
+  constructor(details) {
+    super(403, "GRANT_EXPIRED", "Grant has expired", details);
+  }
+};
+var GrantRevokedError = class extends ProtocolError {
+  constructor(details) {
+    super(403, "GRANT_REVOKED", "Grant has been revoked", details);
+  }
+};
+var ScopeMismatchError = class extends ProtocolError {
+  constructor(details) {
+    super(403, "SCOPE_MISMATCH", "Scope not granted", details);
+  }
+};
+var GrantOwnerMismatchError = class extends ProtocolError {
+  constructor(details) {
+    super(403, "GRANT_OWNER_MISMATCH", "Grant was not issued by this server's owner", details);
+  }
+};
+var PsUnavailableError = class extends ProtocolError {
+  constructor(details) {
+    super(503, "PS_UNAVAILABLE", "Personal Server runtime unavailable", details);
+  }
+};
+var ServerNotConfiguredError = class extends ProtocolError {
+  constructor(details) {
+    super(500, "SERVER_NOT_CONFIGURED", "Server is not configured", details);
+  }
+};
+var LineageInvalidError = class extends ProtocolError {
+  constructor(message, details) {
+    super(400, "LINEAGE_INVALID", message, details);
+  }
+};
+var LineageScopeUnderSourcePrefixError = class extends ProtocolError {
+  constructor(details) {
+    super(400, "LINEAGE_SCOPE_UNDER_SOURCE_PREFIX", `Derived scope "${details.scope}" shares its first segment with source scope "${details.sourceScope}"; a wildcard grant on that namespace would read both. Name derivatives under their own namespace.`, details);
+  }
+};
+var LineageSourceUnknownError = class extends ProtocolError {
+  constructor(details) {
+    super(422, "LINEAGE_SOURCE_UNKNOWN", "One or more lineage sources are not data points of this owner", details);
+  }
+};
+var LineageSourceLookupFailedError = class extends ProtocolError {
+  constructor(details) {
+    super(502, "LINEAGE_SOURCE_LOOKUP_FAILED", "Could not resolve a lineage source at the gateway", details);
+  }
+};
+var LineageUnavailableError = class extends ProtocolError {
+  constructor(details) {
+    super(503, "LINEAGE_UNAVAILABLE", "This server is not configured to reach the gateway lineage graph (gateway URL or server signing key missing)", details);
+  }
+};
+var LineageGatewayError = class extends ProtocolError {
+  constructor(details) {
+    super(502, "LINEAGE_GATEWAY_ERROR", `Gateway lineage request failed with status ${details.status}`, details);
+  }
+};
+var LineageCascadeUnavailableError = class extends ProtocolError {
+  constructor(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 {
+  constructor(details) {
+    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) {
+  return keccak256(encodeAbiParameters([
+    { name: "ownerAddress", type: "address" },
+    { name: "scope", type: "string" }
+  ], [ownerAddress.toLowerCase(), scope]));
+}
+
+// ../core/dist/lineage/lineage.js
+var LINEAGE_KEY = "$lineage";
+var LINEAGE_FIELD = "lineage";
+var MAX_LINEAGE_SOURCES = 256;
+var LOCAL_SCOPE_SCAN_PAGE = 1e3;
+var BYTES32_HEX = /^0x[0-9a-fA-F]{64}$/;
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasReservedLineageKey(data) {
+  return Object.prototype.hasOwnProperty.call(data, LINEAGE_KEY);
+}
+function stampLineage(data, lineage) {
+  return { ...data, [LINEAGE_KEY]: lineage };
+}
+var StoredLineageMalformedError = class extends Error {
+  constructor(detail) {
+    super(`Stored $lineage is malformed: ${detail}`);
+    this.name = "StoredLineageMalformedError";
+  }
+};
+function readStoredLineage(data) {
+  if (!isRecord(data) || !(LINEAGE_KEY in data))
+    return null;
+  const value = data[LINEAGE_KEY];
+  if (!isRecord(value)) {
+    throw new StoredLineageMalformedError("not an object");
+  }
+  const sources = value.sources;
+  if (!Array.isArray(sources) || !sources.every((id2) => typeof id2 === "string" && BYTES32_HEX.test(id2))) {
+    throw new StoredLineageMalformedError("sources is not a list of bytes32 ids");
+  }
+  if (typeof value.writtenAt !== "string") {
+    throw new StoredLineageMalformedError("writtenAt is not a string");
+  }
+  return {
+    sources: sources.map((id2) => id2.toLowerCase()),
+    writtenAt: value.writtenAt
+  };
+}
+function extractLineageField(container) {
+  if (!isRecord(container))
+    return void 0;
+  return container[LINEAGE_FIELD];
+}
+function parseLineageSources(value) {
+  if (!Array.isArray(value)) {
+    throw new LineageInvalidError(`${LINEAGE_FIELD} must be an array of data point ids (0x-prefixed 32-byte hex)`);
+  }
+  if (value.length > MAX_LINEAGE_SOURCES) {
+    throw new LineageInvalidError(`${LINEAGE_FIELD} lists ${value.length} sources; the maximum is ${MAX_LINEAGE_SOURCES}`, { max: MAX_LINEAGE_SOURCES, count: value.length });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const sources = [];
+  for (const entry of value) {
+    if (typeof entry !== "string" || !BYTES32_HEX.test(entry)) {
+      throw new LineageInvalidError(`${LINEAGE_FIELD} entries must be 0x-prefixed 32-byte hex data point ids`, { entry: typeof entry === "string" ? entry : typeof entry });
+    }
+    const id2 = entry.toLowerCase();
+    if (seen.has(id2)) {
+      throw new LineageInvalidError(`${LINEAGE_FIELD} lists the same source twice`, { duplicate: id2 });
+    }
+    seen.add(id2);
+    sources.push(id2);
+  }
+  return sources;
+}
+function scopeNamespace(scope) {
+  const dot = scope.indexOf(".");
+  return dot === -1 ? scope : scope.slice(0, dot);
+}
+function derivedScopeViolatesNaming(derivedScope, sourceScope) {
+  return scopeNamespace(derivedScope) === scopeNamespace(sourceScope);
+}
+function assertDerivedScopeNaming(derivedScope, sourceScopes) {
+  for (const sourceScope of sourceScopes) {
+    if (derivedScopeViolatesNaming(derivedScope, sourceScope)) {
+      throw new LineageScopeUnderSourcePrefixError({
+        scope: derivedScope,
+        sourceScope
+      });
+    }
+  }
+}
+async function resolveLineageSources(input) {
+  const ownId = computeDataPointId(input.serverOwner, input.scope);
+  const self2 = input.sources.find((id2) => id2 === ownId);
+  if (self2) {
+    throw new LineageInvalidError("A record cannot list its own data point as a lineage source", { dataPointId: self2 });
+  }
+  const local = localScopesById(input.storage, input.serverOwner, new Set(input.sources));
+  const resolved = [];
+  const unknown2 = [];
+  for (const dataPointId of input.sources) {
+    const localScope = local.get(dataPointId);
+    if (localScope !== void 0) {
+      resolved.push({
+        dataPointId,
+        scope: localScope,
+        version: null,
+        deletedAt: null
+      });
+      continue;
+    }
+    if (!input.gateway) {
+      unknown2.push(dataPointId);
+      continue;
+    }
+    let record2;
+    try {
+      record2 = await input.gateway.getDataPoint(dataPointId);
+    } catch (err2) {
+      throw new LineageSourceLookupFailedError({
+        dataPointId,
+        error: err2 instanceof Error ? err2.message : String(err2)
+      });
+    }
+    if (!record2 || record2.ownerAddress.toLowerCase() !== input.serverOwner.toLowerCase()) {
+      unknown2.push(dataPointId);
+      continue;
+    }
+    resolved.push({
+      dataPointId,
+      scope: record2.scope,
+      version: record2.version,
+      deletedAt: record2.deletedAt
+    });
+  }
+  if (unknown2.length > 0) {
+    throw new LineageSourceUnknownError({ unknown: unknown2 });
+  }
+  return resolved;
+}
+function localScopesById(storage, serverOwner, wanted) {
+  const byId = /* @__PURE__ */ new Map();
+  for (let offset = 0; ; offset += LOCAL_SCOPE_SCAN_PAGE) {
+    const { scopes, total } = storage.listScopes({
+      limit: LOCAL_SCOPE_SCAN_PAGE,
+      offset
+    });
+    for (const summary of scopes) {
+      const id2 = computeDataPointId(serverOwner, summary.scope);
+      if (wanted.has(id2))
+        byId.set(id2, summary.scope);
+    }
+    if (byId.size === wanted.size || scopes.length === 0 || offset + scopes.length >= total) {
+      break;
+    }
+  }
+  return byId;
+}
+async function prepareLineage(input) {
+  const sources = parseLineageSources(input.field);
+  if (!input.serverOwner) {
+    throw new ServerNotConfiguredError({
+      reason: "serverOwner is required to validate lineage sources"
+    });
+  }
+  const resolved = await resolveLineageSources({
+    scope: input.scope,
+    sources,
+    serverOwner: input.serverOwner,
+    storage: input.storage,
+    gateway: input.gateway
+  });
+  assertDerivedScopeNaming(input.scope, resolved.map((source) => source.scope));
+  return { sources, writtenAt: input.now().toISOString() };
+}
+
+// ../core/dist/lineage/gateway.js
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isLineageNode(value) {
+  if (!isRecord2(value))
+    return false;
+  if (value.redacted === true) {
+    return Object.keys(value).length === 1;
+  }
+  if (typeof value.dataPointId !== "string")
+    return false;
+  return typeof value.scope === "string" && typeof value.version === "string" && (value.deletedAt === null || typeof value.deletedAt === "string");
+}
+function isGatewayProof(value) {
+  return isRecord2(value) && typeof value.userSignature === "string" && typeof value.gatewaySignature === "string" && typeof value.timestamp === "number" && typeof value.status === "string" && (value.estimatedConfirmation === null || typeof value.estimatedConfirmation === "string") && (value.chainBlockHeight === null || typeof value.chainBlockHeight === "number");
+}
+function derivesDataPointId(id2, ownerAddress, scope) {
+  try {
+    return computeDataPointId(ownerAddress, scope).toLowerCase() === id2.toLowerCase();
+  } catch {
+    return false;
+  }
+}
+function parseLineageView(value) {
+  if (!isRecord2(value) || typeof value.dataPointId !== "string" || typeof value.ownerAddress !== "string" || typeof value.scope !== "string" || typeof value.version !== "string" || !(value.deletedAt === null || typeof value.deletedAt === "string") || !Array.isArray(value.sources) || !value.sources.every(isLineageNode) || !Array.isArray(value.derivatives) || !value.derivatives.every(isLineageNode) || !(value.grantId === void 0 || typeof value.grantId === "string") || !(value.derivativesTruncated === void 0 || value.derivativesTruncated === true)) {
+    return null;
+  }
+  return value;
+}
+function createGatewayLineageClient(options) {
+  const base = options.gatewayUrl.replace(/\/+$/, "");
+  const origin = new URL(base).origin;
+  const doFetch = options.fetch ?? fetch;
+  async function readJson(res) {
+    try {
+      return await res.json();
+    } catch {
+      return null;
+    }
+  }
+  return {
+    async getDataPoint(dataPointId) {
+      const res = await doFetch(`${base}/v1/data/${encodeURIComponent(dataPointId)}?includeDeleted=true`);
+      if (res.status === 404)
+        return null;
+      if (!res.ok) {
+        throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
+      }
+      const body = await readJson(res);
+      const data = isRecord2(body) ? body.data : void 0;
+      if (!isRecord2(data) || typeof data.id !== "string" || typeof data.ownerAddress !== "string" || typeof data.scope !== "string" || typeof data.expectedVersion !== "string") {
+        throw new Error("Gateway error: malformed data point response");
+      }
+      if (data.id.toLowerCase() !== dataPointId.toLowerCase()) {
+        throw new Error(`Gateway error: data point response is for ${data.id}, requested ${dataPointId}`);
+      }
+      if (!derivesDataPointId(data.id, data.ownerAddress, data.scope)) {
+        throw new Error(`Gateway error: data point ${data.id} does not derive from its owner and scope`);
+      }
+      return {
+        dataPointId: data.id,
+        ownerAddress: data.ownerAddress,
+        scope: data.scope,
+        version: data.expectedVersion,
+        deletedAt: typeof data.deletedAt === "string" ? data.deletedAt : null
+      };
+    },
+    async getLineage(input) {
+      if (!options.requestSigner) {
+        throw new LineageUnavailableError({ reason: "no request signer" });
+      }
+      const uri = `/v1/data/${input.dataPointId.toLowerCase()}/lineage` + (input.version !== void 0 ? `/${input.version}` : "");
+      const authorization = await options.requestSigner.signRequest({
+        aud: origin,
+        method: "GET",
+        uri,
+        grantId: input.grantId?.toLowerCase()
+      });
+      const res = await doFetch(`${base}${uri}`, {
+        headers: { Authorization: authorization }
+      });
+      const body = await readJson(res);
+      if (!res.ok)
+        return { ok: false, status: res.status, body };
+      const data = parseLineageView(isRecord2(body) ? body.data : void 0);
+      const proof = isRecord2(body) ? body.proof : void 0;
+      if (!data || !isGatewayProof(proof)) {
+        return {
+          ok: false,
+          status: res.status,
+          body: { error: "malformed lineage response", received: body }
+        };
+      }
+      const requestedId = input.dataPointId.toLowerCase();
+      const requestedGrant = input.grantId?.toLowerCase();
+      const servedGrant = data.grantId?.toLowerCase();
+      const viewMismatch = data.dataPointId.toLowerCase() !== requestedId || input.version !== void 0 && data.version !== input.version || requestedGrant !== servedGrant;
+      if (viewMismatch) {
+        return {
+          ok: false,
+          status: res.status,
+          body: {
+            error: "lineage response does not match the requested view",
+            requested: {
+              dataPointId: requestedId,
+              version: input.version,
+              grantId: requestedGrant
+            },
+            received: {
+              dataPointId: data.dataPointId,
+              version: data.version,
+              grantId: servedGrant
+            }
+          }
+        };
+      }
+      if (!derivesDataPointId(data.dataPointId, data.ownerAddress, data.scope)) {
+        return {
+          ok: false,
+          status: res.status,
+          body: {
+            error: "lineage view does not derive from its owner and scope",
+            received: {
+              dataPointId: data.dataPointId,
+              ownerAddress: data.ownerAddress,
+              scope: data.scope
+            }
+          }
+        };
+      }
+      return { ok: true, data, proof };
+    },
+    async registerDataPoint(params) {
+      const res = await doFetch(`${base}/v1/data`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Web3Signed ${params.signature}`
+        },
+        body: JSON.stringify({
+          ownerAddress: params.ownerAddress,
+          scope: params.scope,
+          dataHash: params.dataHash,
+          metadataHash: params.metadataHash,
+          expectedVersion: params.expectedVersion,
+          lineage: [...params.lineage],
+          lineageSignature: params.lineageSignature
+        })
+      });
+      if (!res.ok) {
+        const body2 = await readJson(res);
+        const detail = isRecord2(body2) && typeof body2.error === "string" && body2.error || res.statusText;
+        throw new Error(`Gateway error: ${res.status} ${detail}`);
+      }
+      const body = await readJson(res);
+      const record2 = isRecord2(body) ? body : {};
+      return {
+        dataPointId: typeof record2.dataPointId === "string" ? record2.dataPointId : typeof record2.id === "string" ? record2.id : void 0,
+        expectedVersion: typeof record2.expectedVersion === "string" ? record2.expectedVersion : void 0
+      };
+    }
+  };
+}
+
 // ../lite/node_modules/@opendatalabs/vana-sdk/dist/index.browser.js
 init_hmac();
 init_sha2();
@@ -108843,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()
       };
@@ -108936,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);
@@ -109588,90 +110109,6 @@ async function loadOrCreatePsLiteServerIdentity(params) {
   return { persisted, account };
 }
 
-// ../core/dist/errors/catalog.js
-var ProtocolError = class extends Error {
-  code;
-  errorCode;
-  details;
-  constructor(code, errorCode, message, details) {
-    super(message);
-    this.code = code;
-    this.errorCode = errorCode;
-    this.details = details;
-    this.name = this.constructor.name;
-  }
-  toJSON() {
-    return {
-      error: {
-        code: this.code,
-        errorCode: this.errorCode,
-        message: this.message,
-        ...this.details !== void 0 && { details: this.details }
-      }
-    };
-  }
-};
-var MissingAuthError2 = class extends ProtocolError {
-  constructor(details) {
-    super(401, "MISSING_AUTH", "Missing authentication", details);
-  }
-};
-var InvalidSignatureError3 = class extends ProtocolError {
-  constructor(details) {
-    super(401, "INVALID_SIGNATURE", "Invalid signature", details);
-  }
-};
-var UnregisteredBuilderError = class extends ProtocolError {
-  constructor(details) {
-    super(401, "UNREGISTERED_BUILDER", "Unregistered builder", details);
-  }
-};
-var NotOwnerError = class extends ProtocolError {
-  constructor(details) {
-    super(401, "NOT_OWNER", "Not the owner", details);
-  }
-};
-var ExpiredTokenError2 = class extends ProtocolError {
-  constructor(details) {
-    super(401, "EXPIRED_TOKEN", "Token has expired", details);
-  }
-};
-var GrantRequiredError = class extends ProtocolError {
-  constructor(details) {
-    super(403, "GRANT_REQUIRED", "Grant required", details);
-  }
-};
-var GrantExpiredError = class extends ProtocolError {
-  constructor(details) {
-    super(403, "GRANT_EXPIRED", "Grant has expired", details);
-  }
-};
-var GrantRevokedError = class extends ProtocolError {
-  constructor(details) {
-    super(403, "GRANT_REVOKED", "Grant has been revoked", details);
-  }
-};
-var ScopeMismatchError = class extends ProtocolError {
-  constructor(details) {
-    super(403, "SCOPE_MISMATCH", "Scope not granted", details);
-  }
-};
-var GrantOwnerMismatchError = class extends ProtocolError {
-  constructor(details) {
-    super(403, "GRANT_OWNER_MISMATCH", "Grant was not issued by this server's owner", details);
-  }
-};
-var PsUnavailableError = class extends ProtocolError {
-  constructor(details) {
-    super(503, "PS_UNAVAILABLE", "Personal Server runtime unavailable", details);
-  }
-};
-var ServerNotConfiguredError = class extends ProtocolError {
-  constructor(details) {
-    super(500, "SERVER_NOT_CONFIGURED", "Server is not configured", details);
-  }
-};
-
 // ../core/dist/auth/request.js
 function resolveOrigin(origin) {
   return typeof origin === "function" ? origin() : origin;
@@ -110323,18 +110760,47 @@ function normalizeLimit(value) {
 function normalizeOffset(value) {
   return value ?? 0;
 }
-function isRecord(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
@@ -110342,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",
@@ -110353,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
     }
@@ -110414,7 +110899,7 @@ async function ingestDataContract(input) {
   const scopeResult = parseDataScopeContract(input.scopeParam);
   if (!scopeResult.ok)
     return scopeResult;
-  if (!isRecord(input.body)) {
+  if (!isRecord3(input.body)) {
     return {
       ok: false,
       status: 400,
@@ -110434,7 +110919,17 @@ async function ingestDataContract(input) {
       }
     };
   }
-  const envelope = createDataFileEnvelope(scopeResult.scope, input.collectedAt, input.attribution ? stampWriterAttribution(input.body, input.attribution) : input.body);
+  if (hasReservedLineageKey(input.body)) {
+    return {
+      ok: false,
+      status: 400,
+      body: {
+        error: "INVALID_BODY",
+        message: "Request body must not contain the reserved $lineage key"
+      }
+    };
+  }
+  const envelope = createDataFileEnvelope(scopeResult.scope, input.collectedAt, stampServerKeys(input.body, input));
   const writeResult = await input.storage.writeEnvelope(envelope);
   try {
     await writeBlockSidecars(input.storage, envelope);
@@ -110446,20 +110941,34 @@ 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,
     scope: scopeResult.scope,
     collectedAt: input.collectedAt,
-    response: {
-      scope: scopeResult.scope,
-      collectedAt: input.collectedAt,
-      status: input.status
-    },
+    response: ingestResponse(scopeResult.scope, input),
     writeResult
   };
 }
+function stampServerKeys(data, input) {
+  let stamped = data;
+  if (input.lineage)
+    stamped = stampLineage(stamped, input.lineage);
+  if (input.attribution) {
+    stamped = stampWriterAttribution(stamped, input.attribution);
+  }
+  return stamped;
+}
+function ingestResponse(scope, input) {
+  return {
+    scope,
+    collectedAt: input.collectedAt,
+    status: input.status,
+    ...input.lineage ? { lineage: { sources: input.lineage.sources } } : {}
+  };
+}
 async function ingestBinaryDataContract(input) {
   const scopeResult = parseDataScopeContract(input.scopeParam);
   if (!scopeResult.ok)
@@ -110474,6 +110983,16 @@ async function ingestBinaryDataContract(input) {
       }
     };
   }
+  if (isRecord3(input.metadata) && (hasReservedWriterKey(input.metadata) || hasReservedLineageKey(input.metadata))) {
+    return {
+      ok: false,
+      status: 400,
+      body: {
+        error: "INVALID_BODY",
+        message: "X-Vana-Metadata must not contain the reserved $lineage or $writtenBy keys"
+      }
+    };
+  }
   const contentHash = await sha256Hex(input.bytes);
   const data = buildBinaryEnvelopeData({
     bytes: input.bytes,
@@ -110482,7 +111001,7 @@ async function ingestBinaryDataContract(input) {
     contentHash,
     metadata: input.metadata
   });
-  const envelope = createDataFileEnvelope(scopeResult.scope, input.collectedAt, input.attribution ? stampWriterAttribution(data, input.attribution) : data);
+  const envelope = createDataFileEnvelope(scopeResult.scope, input.collectedAt, stampServerKeys(data, input));
   const writeResult = await input.storage.writeEnvelope(envelope);
   try {
     await writeBlockSidecars(input.storage, envelope);
@@ -110494,29 +111013,17 @@ 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,
     scope: scopeResult.scope,
     collectedAt: input.collectedAt,
-    response: {
-      scope: scopeResult.scope,
-      collectedAt: input.collectedAt,
-      status: input.status
-    },
+    response: ingestResponse(scopeResult.scope, 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;
@@ -111102,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);
@@ -111582,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;
@@ -111613,6 +112707,30 @@ function reportPersonalServerReadFulfillment(deps, event) {
     warnReadFulfillmentReporterFailed(deps, event, err2);
   }
 }
+async function prepareWriteLineage(deps, scope, field) {
+  if (field === void 0 || field === null)
+    return void 0;
+  return prepareLineage({
+    scope,
+    field,
+    serverOwner: deps.serverOwner,
+    storage: deps.storage,
+    gateway: deps.lineageGateway,
+    now: deps.now ?? (() => /* @__PURE__ */ new Date())
+  });
+}
+function resolveLineageGrantView(authResult) {
+  if (authResult === void 0 || authResult.grantId === "owner" || authResult.grantId === "policy-bypass") {
+    return { grantId: void 0 };
+  }
+  const grantId = authResult.grantId;
+  if (typeof grantId !== "string" || grantId === "" || grantId === "unknown") {
+    throw new GrantRequiredError({
+      reason: "a lineage read by a builder needs a resolved grant"
+    });
+  }
+  return { grantId };
+}
 async function handlePersonalServerDataRequest(request2, deps, options = {}) {
   return withApiErrors(async () => {
     const url2 = new URL(request2.url);
@@ -111625,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);
     }
@@ -111634,16 +112753,78 @@ 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") {
+      if (request2.method !== "GET")
+        return methodNotAllowed();
+      const scopeResult = parseDataScopeContract(decodePathPart(parts[0]));
+      if (!scopeResult.ok)
+        return contractErrorResponse(scopeResult);
+      if (url2.searchParams.has("version")) {
+        return errorResponse(400, "INVALID_VERSION", "version is a path segment (/v1/data/:scope/lineage/:version), not a query parameter");
+      }
+      if (url2.search.length > 0) {
+        return errorResponse(400, "INVALID_QUERY", "lineage reads take no query parameters; the version is a path segment and the grant view is the signed grantId claim");
+      }
+      const version4 = parts.length === 3 ? decodePathPart(parts[2]) : void 0;
+      if (version4 !== void 0 && !/^[1-9]\d*$/.test(version4)) {
+        return errorResponse(400, "INVALID_VERSION", "version must be a positive decimal integer");
+      }
+      const authResult = await deps.auth.authorizeBuilderRead({
+        request: request2,
+        scope: scopeResult.scope,
+        grantId: selectedGrantId(request2, url2)
+      });
+      if (!deps.serverOwner) {
+        throw new ServerNotConfiguredError({
+          reason: "serverOwner is required to resolve the data point id"
+        });
+      }
+      if (!deps.lineageGateway)
+        throw new LineageUnavailableError();
+      const { grantId } = resolveLineageGrantView(authResult);
+      let result;
+      try {
+        result = await deps.lineageGateway.getLineage({
+          dataPointId: computeDataPointId(deps.serverOwner, scopeResult.scope),
+          version: version4,
+          grantId
+        });
+      } catch (err2) {
+        if (err2 instanceof ProtocolError)
+          throw err2;
+        throw new LineageGatewayError({
+          status: 0,
+          body: { error: err2 instanceof Error ? err2.message : String(err2) }
+        });
+      }
+      if (!result.ok) {
+        if (result.status === 404) {
+          return errorResponse(404, "NOT_FOUND", version4 ? `Scope "${scopeResult.scope}" has no registered version ${version4}` : `Scope "${scopeResult.scope}" is not registered at the gateway`);
+        }
+        if (result.status === 403) {
+          throw new ProtocolError(403, "LINEAGE_FORBIDDEN", "The gateway refused the lineage view for this grant", { gateway: result.body });
+        }
+        throw new LineageGatewayError({
+          status: result.status,
+          body: result.body
+        });
+      }
+      return jsonResponse({ data: result.data, proof: result.proof });
+    }
     if (parts.length !== 1)
       return notFound();
     const scopeParam = decodePathPart(parts[0]);
@@ -111665,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;
@@ -111719,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";
@@ -111800,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;
@@ -111825,16 +113012,20 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
         };
         if (!isJsonContentType(request2)) {
           const bytes2 = new Uint8Array(await request2.arrayBuffer());
+          const metadata = parseMetadataHeader(request2.headers.get("x-vana-metadata"));
+          const lineage2 = await prepareWriteLineage(deps, scopeResult.scope, extractLineageField(metadata));
           const result2 = await ingestBinaryDataContract({
             storage: deps.storage,
             scopeParam: scopeResult.scope,
             bytes: bytes2,
             mimeType: binaryMimeType(request2),
             filename: binaryFilename(request2),
-            metadata: parseMetadataHeader(request2.headers.get("x-vana-metadata")),
+            metadata,
             collectedAt: collectedAtValue,
             status: status2,
-            attribution: writeAuth?.attribution
+            attribution: writeAuth?.attribution,
+            lineage: lineage2,
+            afterTombstoneVersion
           });
           if (!result2.ok)
             return failWrite(contractErrorResponse(result2));
@@ -111854,13 +113045,16 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
         const parsed = await parseJsonObjectBody(request2, "Request body must be valid JSON");
         if (!parsed.ok)
           return failWrite(contractResponse(parsed.result));
+        const lineage = await prepareWriteLineage(deps, scopeResult.scope, extractLineageField(parsed.body));
         const result = await ingestDataContract({
           storage: deps.storage,
           scopeParam: scopeResult.scope,
           body: parsed.body,
           collectedAt: collectedAtValue,
           status: status2,
-          attribution: writeAuth?.attribution
+          attribution: writeAuth?.attribution,
+          lineage,
+          afterTombstoneVersion
         });
         if (!result.ok)
           return failWrite(contractErrorResponse(result));
@@ -111889,22 +113083,54 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
     }
     if (request2.method === "DELETE") {
       await deps.auth.authorizeOwner(request2);
+      const cascade = url2.searchParams.get("cascade");
+      if (cascade !== null && cascade !== "lineage") {
+        throw new InvalidCascadeError({ cascade });
+      }
       const parsed = parseDataScopeContract(scopeParam);
-      if (parsed.ok && deps.syncManager?.deleteScopeRemote) {
-        try {
-          await deps.syncManager.deleteScopeRemote(parsed.scope);
-        } catch (err2) {
-          deps.logger?.info?.({ scope: scopeParam, error: err2.message }, "Remote scope deletion failed; proceeding with local delete");
-        }
+      if (!parsed.ok)
+        return contractErrorResponse(parsed);
+      if (cascade === "lineage") {
+        throw new LineageCascadeUnavailableError({ scope: parsed.scope });
       }
-      const result = await deleteDataScopeContract({
+      const result = deps.syncManager?.deleteScope ? await deps.syncManager.deleteScope(parsed.scope) : await deleteScope({
         storage: deps.storage,
-        scopeParam
-      });
-      if (!result.ok)
-        return contractErrorResponse(result);
-      deps.logger?.info?.({ scope: scopeParam, deletedCount: result.deletedCount }, "Scope deleted");
-      return new Response(null, { status: 204 });
+        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();
   });
@@ -112214,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}`;
@@ -112301,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,
@@ -112329,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,
@@ -112386,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,
@@ -116049,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) {
@@ -121337,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
@@ -122660,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 {
@@ -123961,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;
       };
@@ -124693,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
@@ -124716,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;
   }
@@ -124741,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}`);
     }
   }
   /**
@@ -124954,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;
@@ -127051,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
@@ -127070,7 +128312,8 @@ function createPsLiteRuntime(options) {
             // recordDataAccess attributes the read to the correct owner; if
             // serverOwner is absent the accessRecord is safely omitted.
             serverOwner: options.serverOwner,
-            serverSigner: x402ServerSigner
+            serverSigner: x402ServerSigner,
+            lineageGateway: options.lineageGateway
           }, { basePath: dataPrefix });
         }
         if (url2.pathname.startsWith("/auth/device")) {
@@ -127526,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";
 }
@@ -127544,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));
@@ -127554,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) {
@@ -127568,14 +128864,35 @@ async function uploadOne(deps, entry) {
         metadataHash,
         expectedVersion: version4
       });
-      const dataPointResult = await gateway.registerDataPoint({
+      const registration = {
         ownerAddress: serverOwner,
         scope: entry.scope,
         dataHash,
         metadataHash,
         expectedVersion: String(version4),
         signature: addDataSignature
-      });
+      };
+      const lineage = readStoredLineage(envelope.data);
+      let dataPointResult;
+      if (lineage) {
+        if (!deps.lineageGateway) {
+          throw new Error(`Cannot register derivative ${entry.path} (scope=${entry.scope}): lineage registration needs a gateway URL (lineageGateway is not configured)`);
+        }
+        const lineageSignature = await signer.signLineageAttestation({
+          ownerAddress: serverOwner,
+          scope: entry.scope,
+          expectedVersion: version4,
+          dataHash,
+          sources: lineage.sources
+        });
+        dataPointResult = await deps.lineageGateway.registerDataPoint({
+          ...registration,
+          lineage: lineage.sources,
+          lineageSignature
+        });
+      } else {
+        dataPointResult = await gateway.registerDataPoint(registration);
+      }
       const id2 = dataPointResult.dataPointId ?? null;
       if (!id2) {
         throw new Error(`Gateway registerDataPoint did not return a dataPointId for ${entry.path} (scope=${entry.scope}, version=${version4})`);
@@ -127583,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);
@@ -127613,6 +128942,7 @@ async function uploadOne(deps, entry) {
       }
     }
     await storage.updateDataPointId(entry.path, dataPointId);
+    deps.scopeDeletions?.markLive(entry.scope);
   }
   logger.info({
     path: entry.path,
@@ -127632,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;
@@ -127660,11 +128990,100 @@ function parseGatewayNextVersion(message) {
     return Number(storedValue[1]) + 1;
   return null;
 }
-function computeDataPointId(ownerAddress, scope) {
-  return keccak256(encodeAbiParameters([
-    { name: "ownerAddress", type: "address" },
-    { name: "scope", type: "string" }
-  ], [ownerAddress.toLowerCase(), scope]));
+
+// ../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
@@ -128004,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") {
@@ -128063,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) {
@@ -128221,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) {
@@ -128260,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 });
@@ -128276,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({
@@ -128300,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
           });
@@ -128322,7 +129823,7 @@ function createSyncManager(uploadDeps, downloadDeps, options) {
         }
         lastSync = (/* @__PURE__ */ new Date()).toISOString();
       } while (rerunRequested && isRunning);
-    })();
+    });
     try {
       await cycleInFlight;
     } finally {
@@ -128411,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;
@@ -128478,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({
@@ -128534,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),
@@ -128564,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) {
@@ -128649,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,
@@ -128657,7 +130467,10 @@ async function createPsLiteSyncManager(options) {
     signer,
     masterKey,
     serverOwner,
-    logger
+    logger,
+    lineageGateway: options.lineageGateway,
+    dataPointFeed,
+    scopeDeletions
   }, {
     storage: options.storage,
     storageAdapter,
@@ -128666,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);
@@ -128689,7 +130506,7 @@ async function createPsLiteSyncManager(options) {
     }
   });
   syncManager.start();
-  return { syncManager, serverOwner };
+  return { syncManager, serverOwner, dataPointFeed, scopeDeletions };
 }
 
 // ../lite/dist/persistence.js
@@ -128750,9 +130567,14 @@ async function createIndexedDbPsLiteRuntime(options) {
     contracts: config2.gateway.contracts
   });
   const diagnostics = options.diagnostics ?? new DiagnosticsRecorder();
+  const lineageGateway = createGatewayLineageClient({
+    gatewayUrl: config2.gateway.url,
+    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,
@@ -128760,9 +130582,14 @@ async function createIndexedDbPsLiteRuntime(options) {
       ownerAddress: options.ownerAddress,
       serverAccount: identity.account,
       gateway,
+      dataPointFeed: options.dataPointFeed,
+      scopeDeletions,
       diagnostics,
-      logger: options.logger
-    })).syncManager;
+      logger: options.logger,
+      lineageGateway
+    });
+    syncManager = sync.syncManager;
+    scopeDeletions = sync.scopeDeletions;
   }
   let runtimeRef = null;
   const auth = options.auth ?? createWeb3SignedPsLiteAuth({
@@ -128791,7 +130618,9 @@ async function createIndexedDbPsLiteRuntime(options) {
     serverOwner,
     serverSigner,
     syncManager,
+    scopeDeletions,
     diagnostics,
+    lineageGateway,
     saveConfig: async (nextConfig) => {
       const saved = await savePsLiteConfig(stateStore, nextConfig);
       Object.assign(config2, saved);