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

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

@@ -105697,6 +105697,11 @@ var ServerNotConfiguredError = class extends ProtocolError {
     super(500, "SERVER_NOT_CONFIGURED", "Server is not configured", details);
   }
 };
+var ContentTooLargeError = class extends ProtocolError {
+  constructor(details) {
+    super(413, "CONTENT_TOO_LARGE", "Content too large", details);
+  }
+};
 var LineageInvalidError = class extends ProtocolError {
   constructor(message, details) {
     super(400, "LINEAGE_INVALID", message, details);
@@ -105729,7 +105734,7 @@ var LineageGatewayError = class extends ProtocolError {
 };
 var LineageCascadeUnavailableError = class extends ProtocolError {
   constructor(details) {
-    super(501, "LINEAGE_CASCADE_UNAVAILABLE", "DELETE ?cascade=lineage is specified but not implemented yet: it needs the durable (tombstone) deletion of every derivative at the gateway, which this server cannot perform. Delete scopes one at a time.", details);
+    super(501, "LINEAGE_CASCADE_UNAVAILABLE", "DELETE ?cascade=lineage is specified but not implemented yet: the lineage walk that finds every derivative is missing. Delete scopes one at a time; each single-scope delete is durable.", details);
   }
 };
 var InvalidCascadeError = class extends ProtocolError {
@@ -105737,6 +105742,41 @@ var InvalidCascadeError = class extends ProtocolError {
     super(400, "INVALID_CASCADE", 'Unsupported cascade mode; the only supported value is "lineage"', details);
   }
 };
+var DeleteTombstoneFailedError = class extends ProtocolError {
+  constructor(details) {
+    super(502, "DELETE_TOMBSTONE_FAILED", "Gateway did not acknowledge the deletion tombstone; nothing was deleted", details);
+  }
+};
+var DataDeletedError = class extends ProtocolError {
+  constructor(details) {
+    super(410, "DATA_DELETED", "Data point has been deleted", details);
+  }
+};
+var DerivativeQuestionInvalidError = class extends ProtocolError {
+  constructor(message, details) {
+    super(400, "DERIVATIVE_QUESTION_INVALID", message, details);
+  }
+};
+var DerivativeQuestionNotFoundError = class extends ProtocolError {
+  constructor(details) {
+    super(404, "DERIVATIVE_QUESTION_NOT_FOUND", "Question not found", details);
+  }
+};
+var DerivativeCycleError = class extends ProtocolError {
+  constructor(details) {
+    super(409, "DERIVATIVE_CYCLE", `Registering this question would make "${details.derivedScope}" a transitive source of itself; recompute would never settle`, details);
+  }
+};
+var DerivativeSourceNotGrantedError = class extends ProtocolError {
+  constructor(details) {
+    super(403, "DERIVATIVE_SOURCE_NOT_GRANTED", "The builder's grant does not cover reading every source scope of this question", details);
+  }
+};
+var DerivativeComputeUnavailableError = class extends ProtocolError {
+  constructor(details) {
+    super(503, "DERIVATIVE_COMPUTE_UNAVAILABLE", "This server has no derivative compute configured", details);
+  }
+};
 
 // ../core/dist/sync/data-point-id.js
 function computeDataPointId(ownerAddress, scope) {
@@ -109344,6 +109384,7 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
         schemaId: entry.schemaId ?? null,
         version: version4,
         dataPointId: entry.dataPointId ?? null,
+        afterTombstoneVersion: entry.afterTombstoneVersion ?? null,
         id: state.nextId,
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
@@ -109437,25 +109478,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);
@@ -109699,6 +109749,17 @@ var DEFAULTS = {
     enabled: true,
     serverAddr: "frpc.server.vana.org",
     serverPort: 7e3
+  },
+  inference: {
+    // OpenAI-compatible chat completions endpoint the derivative compute
+    // layer calls. Point it at the Vana inference relay (which holds the
+    // provider key) or straight at a provider for local development.
+    baseUrl: "https://inference.phala.com/v1",
+    model: "z-ai/glm-5.2",
+    // Newest-first items kept per source scope when a prompt is assembled.
+    maxSourceItems: 50,
+    // Quiet period after a source scope changes before a recompute starts.
+    recomputeDebounceMs: 5e3
   }
 };
 var StorageBackend = external_exports.enum([
@@ -109752,7 +109813,13 @@ var ServerConfigSchema = external_exports.object({
     enabled: external_exports.boolean().default(DEFAULTS.tunnel.enabled),
     serverAddr: external_exports.string().default(DEFAULTS.tunnel.serverAddr),
     serverPort: external_exports.number().int().min(1).max(65535).default(DEFAULTS.tunnel.serverPort)
-  }).default(DEFAULTS.tunnel)
+  }).default(DEFAULTS.tunnel),
+  inference: external_exports.object({
+    baseUrl: external_exports.url().default(DEFAULTS.inference.baseUrl),
+    model: external_exports.string().min(1).default(DEFAULTS.inference.model),
+    maxSourceItems: external_exports.number().int().min(1).max(1e4).default(DEFAULTS.inference.maxSourceItems),
+    recomputeDebounceMs: external_exports.number().int().min(0).max(36e5).default(DEFAULTS.inference.recomputeDebounceMs)
+  }).default(DEFAULTS.inference)
 });
 
 // ../lite/dist/state.js
@@ -110743,15 +110810,44 @@ function normalizeOffset(value) {
 function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+var VISIBILITY_PAGE_SIZE = 200;
 async function listDataScopesContract(input) {
   const limit = normalizeLimit(input.limit);
   const offset = normalizeOffset(input.offset);
-  const result = input.storage.listScopes({
-    scopePrefix: input.scopePrefix,
-    limit,
-    offset
-  });
-  const scopes = await Promise.all(result.scopes.map(async (summary) => {
+  let page;
+  let total;
+  if (input.isVisible) {
+    const visible = [];
+    for (let scan = 0; ; scan += VISIBILITY_PAGE_SIZE) {
+      const batch = input.storage.listScopes({
+        scopePrefix: input.scopePrefix,
+        limit: VISIBILITY_PAGE_SIZE,
+        offset: scan
+      });
+      for (const summary of batch.scopes) {
+        const latest = input.storage.findEntry({
+          scope: summary.scope,
+          at: summary.latestCollectedAt
+        });
+        if (!latest || await input.isVisible(summary.scope, latest)) {
+          visible.push(summary);
+        }
+      }
+      if (batch.scopes.length < VISIBILITY_PAGE_SIZE)
+        break;
+    }
+    total = visible.length;
+    page = visible.slice(offset, offset + limit);
+  } else {
+    const result = input.storage.listScopes({
+      scopePrefix: input.scopePrefix,
+      limit,
+      offset
+    });
+    page = result.scopes;
+    total = result.total;
+  }
+  const scopes = await Promise.all(page.map(async (summary) => {
     const entry = input.storage.findEntry({
       scope: summary.scope,
       at: summary.latestCollectedAt
@@ -110759,7 +110855,7 @@ async function listDataScopesContract(input) {
     if (!entry) {
       return summary;
     }
-    const hasBlocks = typeof input.storage.canReadScopeBlocks === "function" ? await input.storage.canReadScopeBlocks(summary.scope, summary.latestCollectedAt) : typeof input.storage.hasScopeBlocks === "function" ? await input.storage.hasScopeBlocks(summary.scope, summary.latestCollectedAt) : false;
+    const hasBlocks = typeof input.storage.hasScopeBlocks === "function" ? await input.storage.hasScopeBlocks(summary.scope, summary.latestCollectedAt) : false;
     return {
       ...summary,
       dataStatus: hasBlocks ? "ready" : "indexing",
@@ -110770,33 +110866,52 @@ async function listDataScopesContract(input) {
     ok: true,
     response: {
       scopes,
-      total: result.total,
+      total,
       limit,
       offset
     }
   };
 }
-function listDataVersionsContract(input) {
+async function listDataVersionsContract(input) {
   const scopeResult = parseDataScopeContract(input.scopeParam);
   if (!scopeResult.ok)
     return scopeResult;
   const limit = normalizeLimit(input.limit);
   const offset = normalizeOffset(input.offset);
-  const entries = input.storage.listVersions(scopeResult.scope, {
-    limit,
-    offset
-  });
+  let page;
+  let total;
+  if (input.isVisible) {
+    const visible = [];
+    for (let scan = 0; ; scan += VISIBILITY_PAGE_SIZE) {
+      const batch = input.storage.listVersions(scopeResult.scope, {
+        limit: VISIBILITY_PAGE_SIZE,
+        offset: scan
+      });
+      for (const entry of batch) {
+        if (await input.isVisible(scopeResult.scope, entry)) {
+          visible.push(entry);
+        }
+      }
+      if (batch.length < VISIBILITY_PAGE_SIZE)
+        break;
+    }
+    total = visible.length;
+    page = visible.slice(offset, offset + limit);
+  } else {
+    page = input.storage.listVersions(scopeResult.scope, { limit, offset });
+    total = input.storage.countVersions(scopeResult.scope);
+  }
   return {
     ok: true,
     scope: scopeResult.scope,
     response: {
       scope: scopeResult.scope,
-      versions: entries.map((entry) => ({
+      versions: page.map((entry) => ({
         fileId: entry.fileId,
         schemaId: entry.schemaId,
         collectedAt: entry.collectedAt
       })),
-      total: input.storage.countVersions(scopeResult.scope),
+      total,
       limit,
       offset
     }
@@ -110873,7 +110988,8 @@ async function ingestDataContract(input) {
     path: writeResult.relativePath,
     scope: scopeResult.scope,
     collectedAt: input.collectedAt,
-    sizeBytes: writeResult.sizeBytes
+    sizeBytes: writeResult.sizeBytes,
+    afterTombstoneVersion: input.afterTombstoneVersion ?? null
   });
   return {
     ok: true,
@@ -110944,7 +111060,8 @@ async function ingestBinaryDataContract(input) {
     path: writeResult.relativePath,
     scope: scopeResult.scope,
     collectedAt: input.collectedAt,
-    sizeBytes: input.bytes.length
+    sizeBytes: input.bytes.length,
+    afterTombstoneVersion: input.afterTombstoneVersion ?? null
   });
   return {
     ok: true,
@@ -110954,15 +111071,6 @@ async function ingestBinaryDataContract(input) {
     writeResult
   };
 }
-async function deleteDataScopeContract(input) {
-  const scopeResult = parseDataScopeContract(input.scopeParam);
-  if (!scopeResult.ok)
-    return scopeResult;
-  return {
-    ok: true,
-    deletedCount: await input.storage.deleteScope(scopeResult.scope)
-  };
-}
 async function writeBlockSidecars(storage, envelope) {
   if (!storage.writeBlockManifest)
     return;
@@ -111548,6 +111656,548 @@ async function syncFileContract(input) {
   return contractOk({ fileId: input.fileId, status: "started" }, 202);
 }
 
+// ../core/dist/sync/tombstone.js
+var TOMBSTONE_DATA_HASH_LABEL = "vana.data-point.tombstone.v1";
+var TOMBSTONE_METADATA_HASH_LABEL = "vana.data-point.tombstone.metadata.v1";
+var TOMBSTONE_DATA_HASH = keccak256(stringToHex(TOMBSTONE_DATA_HASH_LABEL));
+var TOMBSTONE_METADATA_HASH = keccak256(stringToHex(TOMBSTONE_METADATA_HASH_LABEL));
+function isTombstoneRecord(record2) {
+  return record2.dataHash.toLowerCase() === TOMBSTONE_DATA_HASH && record2.metadataHash.toLowerCase() === TOMBSTONE_METADATA_HASH;
+}
+
+// ../core/dist/sync/scope-deletions.js
+var DEFAULT_SCOPE_DELETION_MAX_STALENESS_MS = 12e4;
+var DEFAULT_SCOPE_DELETION_GATEWAY_RETRY_MS = 15e3;
+var DEFAULT_MAX_LIVE_ENTRIES = 1e4;
+function createScopeDeletionTracker(options = {}) {
+  const maxStalenessMs = options.maxStalenessMs ?? DEFAULT_SCOPE_DELETION_MAX_STALENESS_MS;
+  const gatewayRetryMs = options.gatewayRetryMs ?? DEFAULT_SCOPE_DELETION_GATEWAY_RETRY_MS;
+  const maxLiveEntries = options.maxLiveEntries ?? DEFAULT_MAX_LIVE_ENTRIES;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const nowMs = () => now().getTime();
+  const deleted = /* @__PURE__ */ new Map();
+  const live = /* @__PURE__ */ new Map();
+  let lastFeedSyncMs = null;
+  let lastGatewayFailureMs = null;
+  const inflight = /* @__PURE__ */ new Map();
+  function rememberLive(scope, at3) {
+    deleted.delete(scope);
+    live.delete(scope);
+    live.set(scope, at3);
+    while (live.size > maxLiveEntries) {
+      const oldest = live.keys().next().value;
+      if (oldest === void 0)
+        break;
+      live.delete(oldest);
+    }
+  }
+  function rememberDeleted(scope, tombstone, source) {
+    deleted.set(scope, {
+      deletedAt: tombstone.deletedAt,
+      version: normalizeVersion(tombstone.version),
+      source,
+      verifiedAtMs: nowMs()
+    });
+    live.delete(scope);
+  }
+  function isFresh(at3) {
+    return at3 !== null && nowMs() - at3 <= maxStalenessMs;
+  }
+  function verdictFromRecord(scope, record2) {
+    const deletedAt = deletionTimestamp(record2);
+    if (deletedAt !== null) {
+      const version4 = tombstoneVersion(record2);
+      rememberDeleted(scope, { deletedAt, version: version4 }, "gateway");
+      return {
+        deleted: true,
+        deletedAt,
+        version: version4,
+        source: "gateway",
+        verified: true
+      };
+    }
+    rememberLive(scope, nowMs());
+    return { deleted: false, source: "gateway", verified: true };
+  }
+  async function lookup2(scope) {
+    const feed = options.feed;
+    const owner = options.serverOwner;
+    if (!feed || !owner)
+      return null;
+    if (lastGatewayFailureMs !== null && nowMs() - lastGatewayFailureMs < gatewayRetryMs) {
+      return null;
+    }
+    const pending = inflight.get(scope);
+    if (pending)
+      return pending;
+    const request2 = (async () => {
+      try {
+        const record2 = await feed.getDataPoint({
+          ownerAddress: owner,
+          scope
+        });
+        lastGatewayFailureMs = null;
+        return verdictFromRecord(scope, record2);
+      } catch (err2) {
+        lastGatewayFailureMs = nowMs();
+        options.logger?.warn?.({
+          scope,
+          error: err2 instanceof Error ? err2.message : String(err2),
+          retryAfterMs: gatewayRetryMs
+        }, "Could not check gateway deletion state; serving last known state");
+        return null;
+      } finally {
+        inflight.delete(scope);
+      }
+    })();
+    inflight.set(scope, request2);
+    return request2;
+  }
+  return {
+    maxStalenessMs,
+    markDeleted(scope, tombstone, source = "feed") {
+      rememberDeleted(scope, tombstone, source);
+    },
+    markLive(scope) {
+      rememberLive(scope, nowMs());
+    },
+    noteFeedSynced(at3, options2) {
+      lastFeedSyncMs = (at3 ?? now()).getTime();
+      if (!options2?.full)
+        return;
+      for (const tombstone of deleted.values()) {
+        tombstone.verifiedAtMs = Math.max(tombstone.verifiedAtMs, lastFeedSyncMs);
+      }
+    },
+    knownDeletion(scope) {
+      const known = deleted.get(scope);
+      return known === void 0 ? null : { deletedAt: known.deletedAt, version: known.version };
+    },
+    feedAgeMs() {
+      return lastFeedSyncMs === null ? null : nowMs() - lastFeedSyncMs;
+    },
+    async resolve(scope, resolveOptions) {
+      const known = deleted.get(scope);
+      if (known !== void 0) {
+        if (isFresh(known.verifiedAtMs)) {
+          return {
+            deleted: true,
+            deletedAt: known.deletedAt,
+            version: known.version,
+            source: known.source,
+            verified: true
+          };
+        }
+        const rechecked = await lookup2(scope);
+        if (rechecked !== null)
+          return rechecked;
+        return {
+          deleted: true,
+          deletedAt: known.deletedAt,
+          version: known.version,
+          source: known.source,
+          verified: false
+        };
+      }
+      if (isFresh(live.get(scope) ?? null)) {
+        return { deleted: false, source: "gateway", verified: true };
+      }
+      const consult = resolveOptions?.consultGateway ?? "if-stale";
+      if (consult === "if-stale" && isFresh(lastFeedSyncMs)) {
+        return { deleted: false, source: "feed", verified: true };
+      }
+      return await lookup2(scope) ?? {
+        deleted: false,
+        source: "assumed-live",
+        verified: false
+      };
+    }
+  };
+}
+function deletionTimestamp(record2) {
+  if (!record2)
+    return null;
+  if (record2.deletedAt)
+    return record2.deletedAt;
+  return isTombstoneRecord(record2) ? record2.addedAt : null;
+}
+function tombstoneVersion(record2) {
+  return normalizeVersion(record2?.expectedVersion ?? null);
+}
+function normalizeVersion(value) {
+  if (typeof value !== "string" || !/^\d+$/.test(value))
+    return null;
+  return BigInt(value) > 0n ? BigInt(value).toString() : null;
+}
+function isEntryCoveredByTombstone(entry, tombstone) {
+  const version4 = normalizeVersion(tombstone.version);
+  if (version4 === null)
+    return true;
+  const tombstoned = BigInt(version4);
+  if (entry.dataPointId !== null)
+    return BigInt(entry.version) <= tombstoned;
+  const marker = entry.afterTombstoneVersion;
+  if (marker === null || marker === void 0 || !Number.isSafeInteger(marker)) {
+    return true;
+  }
+  return BigInt(marker) < tombstoned;
+}
+
+// ../core/dist/sync/workers/delete.js
+var BLOB_DELETE_BATCH_SIZE = 15;
+function planBlobDeletions(storage, scope, tombstoneVersionValue) {
+  const tombstone = { version: tombstoneVersionValue };
+  const last2 = tombstoneVersionValue === null ? null : BigInt(tombstoneVersionValue);
+  const keys = /* @__PURE__ */ new Set();
+  const PAGE_SIZE = 500;
+  for (let offset = 0; ; offset += PAGE_SIZE) {
+    const entries = storage.listVersions(scope, { limit: PAGE_SIZE, offset });
+    for (const entry of entries) {
+      if (!isEntryCoveredByTombstone(entry, tombstone))
+        continue;
+      const version4 = BigInt(entry.version);
+      if (last2 !== null && version4 >= 1n && version4 <= last2)
+        continue;
+      keys.add(version4.toString());
+    }
+    if (entries.length < PAGE_SIZE)
+      break;
+  }
+  return {
+    keys: [...keys].sort((a10, b10) => BigInt(a10) < BigInt(b10) ? -1 : 1),
+    range: last2 === null || last2 < 1n ? null : { from: "1", to: last2.toString() }
+  };
+}
+function takeFromRange(range, count) {
+  const from = BigInt(range.from);
+  const to3 = BigInt(range.to);
+  const versions = [];
+  let cursor = from;
+  while (cursor <= to3 && versions.length < count) {
+    versions.push(cursor.toString());
+    cursor += 1n;
+  }
+  return {
+    versions,
+    rest: cursor <= to3 ? { from: cursor.toString(), to: range.to } : null
+  };
+}
+function rangeSize(range) {
+  return BigInt(range.to) - BigInt(range.from) + 1n;
+}
+function countPendingKeys(markers) {
+  let total = 0n;
+  for (const marker of markers) {
+    if (marker.version !== null)
+      total += 1n;
+    else if (marker.range)
+      total += rangeSize(marker.range);
+    else
+      total += 1n;
+  }
+  return total > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(total);
+}
+async function deleteScope(deps, scope) {
+  const { storage, deleteData, pendingBlobDeletions, scopeDeletions, logger } = deps;
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const dataPointId = deps.serverOwner ? computeDataPointId(deps.serverOwner, scope) : null;
+  const result = {
+    scope,
+    dataPointId,
+    durable: false,
+    steps: {
+      gateway: { status: "skipped", reason: "sync-disabled" },
+      storage: { status: "skipped", reason: "sync-disabled" },
+      local: { status: "skipped" }
+    },
+    pendingBlobDeletion: false
+  };
+  if (deleteData) {
+    let tombstoneVersionValue = null;
+    let tombstoneKnown = false;
+    try {
+      let outcome = await deleteData.tombstone(scope);
+      if (outcome.status === "not-registered") {
+        let registry2 = await registryState(deps, scope);
+        if (registry2.status === "live") {
+          outcome = await deleteData.tombstone(scope);
+          registry2 = await registryState(deps, scope);
+        }
+        if (outcome.status === "not-registered" && registry2.status !== "deleted-or-absent") {
+          throw registry2.status === "unknown" ? registry2.error : new Error("Scope was registered concurrently while it was being deleted; retry the delete");
+        }
+      }
+      if (outcome.status === "not-registered") {
+        result.steps.gateway = { status: "skipped", reason: "not-registered" };
+      } else {
+        tombstoneKnown = true;
+        tombstoneVersionValue = outcome.version === null ? null : tombstoneVersion({ expectedVersion: outcome.version });
+        result.steps.gateway = {
+          status: "ok",
+          ...outcome.status === "already-deleted" && {
+            reason: "already-deleted"
+          },
+          version: outcome.version,
+          deletedAt: outcome.deletedAt
+        };
+        scopeDeletions?.markDeleted(scope, {
+          deletedAt: outcome.deletedAt ?? now().toISOString(),
+          version: outcome.version
+        }, "local-delete");
+      }
+      result.durable = true;
+    } catch (err2) {
+      const message = errorMessage2(err2);
+      result.steps.gateway = { status: "failed", error: message };
+      result.steps.storage = { status: "skipped", reason: "gateway-failed" };
+      result.steps.local = { status: "skipped", reason: "gateway-failed" };
+      logger.error({ scope, dataPointId, error: message }, "Gateway tombstone failed; scope NOT deleted (local copy kept so sync cannot resurrect a half-deleted scope)");
+      return result;
+    }
+    const plan = planBlobDeletions(storage, scope, tombstoneVersionValue);
+    const batch = plan.keys.slice(0, BLOB_DELETE_BATCH_SIZE);
+    const leftovers = plan.keys.slice(BLOB_DELETE_BATCH_SIZE).map((version4) => ({ scope, version: version4 }));
+    if (plan.range) {
+      const taken = takeFromRange(plan.range, BLOB_DELETE_BATCH_SIZE - batch.length);
+      batch.push(...taken.versions);
+      if (taken.rest)
+        leftovers.push({ scope, version: null, range: taken.rest });
+    }
+    if (tombstoneKnown && tombstoneVersionValue === null) {
+      leftovers.push({ scope, version: null });
+    }
+    const storageStep = await deleteBlobKeys({ deleteData, pendingBlobDeletions, logger }, scope, batch, leftovers);
+    result.steps.storage = storageStep.step;
+    result.pendingBlobDeletion = storageStep.pending > 0;
+  }
+  try {
+    const deletedCount = await storage.deleteScope(scope);
+    result.steps.local = { status: "ok", deletedCount };
+  } catch (err2) {
+    const message = errorMessage2(err2);
+    result.steps.local = { status: "failed", error: message };
+    logger.error({ scope, error: message }, "Local scope deletion failed");
+  }
+  logger.info({
+    scope,
+    dataPointId,
+    durable: result.durable,
+    gateway: result.steps.gateway.status,
+    storage: result.steps.storage.status,
+    local: result.steps.local.status
+  }, "Scope deletion finished");
+  return result;
+}
+async function deleteBlobKeys(deps, scope, batch, leftovers) {
+  const { deleteData, pendingBlobDeletions, logger } = deps;
+  let outcome;
+  try {
+    outcome = batch.length > 0 && deleteData ? await deleteData.deleteBlobVersions(scope, batch) : { deleted: [], missing: [], failed: [] };
+  } catch (err2) {
+    outcome = {
+      deleted: [],
+      missing: [],
+      failed: batch.map((version4) => ({ version: version4, error: errorMessage2(err2) }))
+    };
+  }
+  const completed = [...outcome.deleted, ...outcome.missing].map((version4) => ({ scope, version: version4 }));
+  const remaining = [
+    ...outcome.failed.map(({ version: version4 }) => ({ scope, version: version4 })),
+    ...leftovers
+  ];
+  const remainingKeys = countPendingKeys(remaining);
+  let recorded = remainingKeys;
+  if (pendingBlobDeletions) {
+    try {
+      if (completed.length > 0)
+        await pendingBlobDeletions.remove(completed);
+      if (remaining.length > 0)
+        await pendingBlobDeletions.add(remaining);
+    } catch (markerErr) {
+      recorded = 0;
+      logger.error({ scope, error: errorMessage2(markerErr), keys: remainingKeys }, "Could not record pending blob deletion markers");
+    }
+  } else if (remaining.length > 0) {
+    recorded = 0;
+    logger.error({ scope, keys: remainingKeys }, "Blob deletions left unfinished with no marker store to retry them");
+  }
+  const counts = {
+    blobsDeleted: outcome.deleted.length,
+    blobsMissing: outcome.missing.length,
+    blobsPending: remainingKeys
+  };
+  if (outcome.failed.length > 0) {
+    const first = outcome.failed[0];
+    logger.warn({
+      scope,
+      failed: outcome.failed.length,
+      pending: recorded,
+      error: first.error
+    }, "Storage blob deletion failed for some keys after gateway tombstone; will retry");
+    return {
+      step: {
+        status: "failed",
+        error: `${outcome.failed.length} blob delete(s) failed: ${first.error}`,
+        ...counts
+      },
+      pending: recorded
+    };
+  }
+  if (remaining.length > 0) {
+    logger.info({ scope, ...counts }, "Storage blob deletion continues on later sync cycles (rate-limited batch)");
+    return { step: { status: "deferred", ...counts }, pending: recorded };
+  }
+  return { step: { status: "ok", ...counts }, pending: 0 };
+}
+async function retryPendingBlobDeletions(deps) {
+  const { deleteData, pendingBlobDeletions, logger } = deps;
+  const result = {
+    completed: [],
+    superseded: [],
+    failed: [],
+    remaining: 0
+  };
+  if (!deleteData || !pendingBlobDeletions)
+    return result;
+  let markers = await pendingBlobDeletions.list();
+  if (markers.length === 0)
+    return result;
+  for (const marker of markers.filter((key) => key.version === null && !key.range)) {
+    const registry2 = await registryState(deps, marker.scope);
+    if (registry2.status === "unknown") {
+      result.failed.push({
+        scope: marker.scope,
+        version: null,
+        error: registry2.error.message
+      });
+      continue;
+    }
+    if (registry2.status === "live") {
+      await pendingBlobDeletions.remove([marker]);
+      result.superseded.push(marker.scope);
+      logger.warn({
+        scope: marker.scope,
+        dataPointId: registry2.record.id,
+        version: registry2.record.expectedVersion
+      }, "Scope was re-added after its tombstone; dropping the unexpanded blob deletion marker so the live version's ciphertext survives");
+      continue;
+    }
+    const plan = planBlobDeletions(deps.storage ?? { listVersions: () => [] }, marker.scope, registry2.status === "deleted" ? registry2.version : null);
+    const expanded = plan.keys.map((version4) => ({
+      scope: marker.scope,
+      version: version4
+    }));
+    if (plan.range) {
+      expanded.push({ scope: marker.scope, version: null, range: plan.range });
+    }
+    await pendingBlobDeletions.remove([marker]);
+    await pendingBlobDeletions.add(expanded);
+  }
+  markers = await pendingBlobDeletions.list();
+  let budget = BLOB_DELETE_BATCH_SIZE;
+  const byScope = /* @__PURE__ */ new Map();
+  const exactOrigin = /* @__PURE__ */ new Set();
+  const advancedRanges = [];
+  const enqueue = (scope, version4) => {
+    const versions = byScope.get(scope) ?? [];
+    versions.push(version4);
+    byScope.set(scope, versions);
+  };
+  for (const marker of markers) {
+    if (budget === 0)
+      break;
+    if (marker.version !== null) {
+      enqueue(marker.scope, marker.version);
+      exactOrigin.add(`${marker.scope}\0${marker.version}`);
+      budget -= 1;
+    }
+  }
+  for (const marker of markers) {
+    if (budget === 0)
+      break;
+    if (marker.version === null && marker.range) {
+      const taken = takeFromRange(marker.range, budget);
+      for (const version4 of taken.versions)
+        enqueue(marker.scope, version4);
+      budget -= taken.versions.length;
+      advancedRanges.push({
+        old: marker,
+        next: taken.rest ? { scope: marker.scope, version: null, range: taken.rest } : null
+      });
+    }
+  }
+  for (const [scope, versions] of byScope) {
+    let outcome;
+    try {
+      outcome = await deleteData.deleteBlobVersions(scope, versions);
+    } catch (err2) {
+      const message = errorMessage2(err2);
+      outcome = {
+        deleted: [],
+        missing: [],
+        failed: versions.map((version4) => ({ version: version4, error: message }))
+      };
+    }
+    const completed = [...outcome.deleted, ...outcome.missing].filter((version4) => exactOrigin.has(`${scope}\0${version4}`)).map((version4) => ({ scope, version: version4 }));
+    if (completed.length > 0)
+      await pendingBlobDeletions.remove(completed);
+    result.completed.push(...[...outcome.deleted, ...outcome.missing].map((version4) => ({ scope, version: version4 })));
+    const failedFromRange = outcome.failed.filter(({ version: version4 }) => !exactOrigin.has(`${scope}\0${version4}`)).map(({ version: version4 }) => ({ scope, version: version4 }));
+    if (failedFromRange.length > 0) {
+      await pendingBlobDeletions.add(failedFromRange);
+    }
+    for (const failure of outcome.failed) {
+      result.failed.push({ scope, ...failure });
+    }
+    if (outcome.deleted.length + outcome.missing.length > 0) {
+      logger.info({
+        scope,
+        deleted: outcome.deleted.length,
+        missing: outcome.missing.length
+      }, "Completed pending blob deletions");
+    }
+    if (outcome.failed.length > 0) {
+      logger.warn({
+        scope,
+        failed: outcome.failed.length,
+        error: outcome.failed[0].error
+      }, "Pending blob deletion failed again");
+    }
+  }
+  for (const { old, next } of advancedRanges) {
+    await pendingBlobDeletions.remove([old]);
+    if (next)
+      await pendingBlobDeletions.add([next]);
+  }
+  result.remaining = (await pendingBlobDeletions.list()).length;
+  return result;
+}
+async function registryState(deps, scope) {
+  if (!deps.dataPointFeed || !deps.serverOwner) {
+    return { status: "deleted-or-absent" };
+  }
+  let record2;
+  try {
+    record2 = await deps.dataPointFeed.getDataPoint({
+      ownerAddress: deps.serverOwner,
+      scope
+    });
+  } catch (err2) {
+    return {
+      status: "unknown",
+      error: err2 instanceof Error ? err2 : new Error(String(err2))
+    };
+  }
+  if (record2 === null)
+    return { status: "deleted-or-absent" };
+  if (deletionTimestamp(record2) === null)
+    return { status: "live", record: record2 };
+  return { status: "deleted", version: tombstoneVersion(record2) };
+}
+function errorMessage2(err2) {
+  return err2 instanceof Error ? err2.message : String(err2);
+}
+
 // ../core/dist/payment/x402.js
 function generateRecordId() {
   const bytes2 = new Uint8Array(32);
@@ -112028,6 +112678,63 @@ 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 notifyDataWritten(deps, event) {
+  if (!deps.onDataWritten)
+    return;
+  try {
+    deps.onDataWritten(event);
+  } catch (err2) {
+    deps.logger?.warn?.({
+      scope: event.scope,
+      error: err2 instanceof Error ? err2.message : String(err2)
+    }, "onDataWritten hook failed; record already stored");
+  }
+}
 function notifyNewData(syncManager) {
   if (!syncManager)
     return;
@@ -112083,24 +112790,6 @@ function resolveLineageGrantView(authResult) {
   }
   return { grantId };
 }
-async function deleteOneScope(deps, scope) {
-  if (deps.syncManager?.deleteScopeRemote) {
-    try {
-      await deps.syncManager.deleteScopeRemote(scope);
-    } catch (err2) {
-      deps.logger?.info?.({ scope, error: err2.message }, "Remote scope deletion failed; proceeding with local delete");
-    }
-  }
-  const result = await deleteDataScopeContract({
-    storage: deps.storage,
-    scopeParam: scope
-  });
-  if (!result.ok) {
-    throw new ProtocolError(result.status, result.body.error, result.body.message);
-  }
-  deps.logger?.info?.({ scope, deletedCount: result.deletedCount }, "Scope deleted");
-  return result.deletedCount;
-}
 async function handlePersonalServerDataRequest(request2, deps, options = {}) {
   return withApiErrors(async () => {
     const url2 = new URL(request2.url);
@@ -112113,7 +112802,8 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
         storage: deps.storage,
         scopePrefix: url2.searchParams.get("scopePrefix") ?? void 0,
         limit: normalizeLimit2(url2.searchParams.get("limit"), 20),
-        offset: normalizeLimit2(url2.searchParams.get("offset"), 0)
+        offset: normalizeLimit2(url2.searchParams.get("offset"), 0),
+        isVisible: discoveryVisibility(deps)
       });
       return jsonResponse(result.response);
     }
@@ -112122,14 +112812,18 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
       if (request2.method !== "GET")
         return methodNotAllowed();
       await deps.auth.authorizeBuilderList(request2);
-      const result = listDataVersionsContract({
+      const result = await listDataVersionsContract({
         storage: deps.storage,
         scopeParam: decodePathPart(parts[0]),
         limit: normalizeLimit2(url2.searchParams.get("limit"), 20),
-        offset: normalizeLimit2(url2.searchParams.get("offset"), 0)
+        offset: normalizeLimit2(url2.searchParams.get("offset"), 0),
+        isVisible: discoveryVisibility(deps)
       });
       if (!result.ok)
         return contractErrorResponse(result);
+      if (result.response.total === 0) {
+        await assertScopeNotDeleted(deps, result.scope, void 0);
+      }
       return jsonResponse(result.response);
     }
     if ((parts.length === 2 || parts.length === 3) && parts[1] === "lineage") {
@@ -112211,6 +112905,7 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
         fileId: url2.searchParams.get("fileId") ?? selectedEntry?.fileId ?? void 0,
         at: url2.searchParams.get("at") ?? void 0
       });
+      await assertScopeNotDeleted(deps, scopeResult.scope, selectedEntry);
       const isOwnerSignal = authResult?.grantId === "owner" || authResult?.grantId === "policy-bypass";
       const builder = authResult?.builder;
       const resolvedGrantId = !isOwnerSignal && authResult?.grantId ? authResult.grantId : void 0;
@@ -112265,8 +112960,12 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
         fileId: url2.searchParams.get("fileId") ?? void 0,
         at: url2.searchParams.get("at") ?? void 0
       });
-      if (!result.ok)
+      if (!result.ok) {
+        if (result.status === 404) {
+          await assertScopeNotDeleted(deps, scopeResult.scope, void 0);
+        }
         return contractErrorResponse(result);
+      }
       const logId = deps.createLogId?.() ?? crypto.randomUUID();
       const timestamp = (deps.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
       const ipAddress = request2.headers.get("x-forwarded-for") ?? request2.headers.get("x-real-ip") ?? "unknown";
@@ -112346,6 +113045,7 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
           return failWrite(contractErrorResponse(scopeResult));
         const collectedAtValue = collectedAt(deps.now ?? (() => /* @__PURE__ */ new Date()));
         const status2 = deps.syncManager ? "syncing" : "stored";
+        const afterTombstoneVersion = await ingestTombstoneMarker(deps, scopeResult.scope);
         const logBuilderWrite = async () => {
           if (!writeAuth)
             return;
@@ -112383,7 +113083,8 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
             collectedAt: collectedAtValue,
             status: status2,
             attribution: writeAuth?.attribution,
-            lineage: lineage2
+            lineage: lineage2,
+            afterTombstoneVersion
           });
           if (!result2.ok)
             return failWrite(contractErrorResponse(result2));
@@ -112398,6 +113099,11 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
           }, "Binary data file ingested");
           await logBuilderWrite();
           notifyNewData(deps.syncManager);
+          notifyDataWritten(deps, {
+            scope: scopeResult.scope,
+            collectedAt: collectedAtValue,
+            lineageSources: lineage2?.sources
+          });
           return jsonResponse(result2.response, { status: 201 });
         }
         const parsed = await parseJsonObjectBody(request2, "Request body must be valid JSON");
@@ -112411,7 +113117,8 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
           collectedAt: collectedAtValue,
           status: status2,
           attribution: writeAuth?.attribution,
-          lineage
+          lineage,
+          afterTombstoneVersion
         });
         if (!result.ok)
           return failWrite(contractErrorResponse(result));
@@ -112424,6 +113131,11 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
         }, "Data file ingested");
         await logBuilderWrite();
         notifyNewData(deps.syncManager);
+        notifyDataWritten(deps, {
+          scope: scopeResult.scope,
+          collectedAt: collectedAtValue,
+          lineageSources: lineage?.sources
+        });
         return jsonResponse(result.response, { status: 201 });
       } catch (err2) {
         if (err2 instanceof IngestPersistedError) {
@@ -112450,8 +113162,44 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
       if (cascade === "lineage") {
         throw new LineageCascadeUnavailableError({ scope: parsed.scope });
       }
-      await deleteOneScope(deps, parsed.scope);
-      return new Response(null, { status: 204 });
+      const result = deps.syncManager?.deleteScope ? await deps.syncManager.deleteScope(parsed.scope) : await deleteScope({
+        storage: deps.storage,
+        serverOwner: deps.serverOwner,
+        deleteData: null,
+        logger: apiLoggerAsLogger(deps.logger)
+      }, parsed.scope);
+      if (result.steps.gateway.status === "failed") {
+        throw new DeleteTombstoneFailedError({
+          scope: parsed.scope,
+          result
+        });
+      }
+      try {
+        await deps.accessLogWriter.write({
+          logId: deps.createLogId?.() ?? crypto.randomUUID(),
+          grantId: "owner",
+          builder: deps.serverOwner ?? "owner",
+          action: "delete",
+          scope: parsed.scope,
+          timestamp: (deps.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+          ipAddress: request2.headers.get("x-forwarded-for") ?? request2.headers.get("x-real-ip") ?? "unknown",
+          userAgent: request2.headers.get("user-agent") ?? "unknown"
+        });
+      } catch (err2) {
+        deps.logger?.warn?.({
+          scope: parsed.scope,
+          error: err2 instanceof Error ? err2.message : String(err2)
+        }, "Delete access-log entry failed; scope already deleted");
+      }
+      deps.logger?.info?.({
+        scope: parsed.scope,
+        durable: result.durable,
+        gateway: result.steps.gateway.status,
+        storage: result.steps.storage.status,
+        local: result.steps.local.status,
+        deletedCount: result.steps.local.deletedCount
+      }, "Scope deleted");
+      return jsonResponse(result, { status: 200 });
     }
     return methodNotAllowed();
   });
@@ -112614,6 +113362,93 @@ async function handlePersonalServerOauthTokenRequest(request2, deps) {
   });
 }
 
+// ../core/dist/derivatives/types.js
+function questionRegistrationView(registration) {
+  return {
+    questionId: registration.questionId,
+    derivedScope: registration.derivedScope,
+    sourceScopes: [...registration.sourceScopes],
+    question: registration.question,
+    model: registration.model,
+    registeredBy: registration.registeredBy,
+    status: registration.status,
+    error: registration.error,
+    createdAt: registration.createdAt,
+    updatedAt: registration.updatedAt,
+    lastComputedAt: registration.lastComputedAt,
+    derivedVersion: registration.derivedVersion,
+    derivedCollectedAt: registration.derivedCollectedAt
+  };
+}
+
+// ../core/dist/derivatives/store.js
+function clone2(registration) {
+  return {
+    ...registration,
+    sourceScopes: [...registration.sourceScopes],
+    registeredBy: { ...registration.registeredBy }
+  };
+}
+function matchesQuestionFilter(registration, filter) {
+  if (!filter)
+    return true;
+  if (filter.derivedScope && registration.derivedScope !== filter.derivedScope)
+    return false;
+  if (filter.sourceScope && !registration.sourceScopes.includes(filter.sourceScope))
+    return false;
+  if (filter.builder) {
+    const by2 = registration.registeredBy;
+    if (by2.kind !== "builder" || by2.builder.toLowerCase() !== filter.builder.toLowerCase())
+      return false;
+  }
+  return true;
+}
+function sortQuestions(registrations) {
+  return [...registrations].sort((a10, b10) => a10.createdAt.localeCompare(b10.createdAt) || a10.questionId.localeCompare(b10.questionId));
+}
+function createInMemoryQuestionStore(options = {}) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const registration of options.initial ?? []) {
+    byId.set(registration.questionId, clone2(registration));
+  }
+  async function changed() {
+    if (!options.onChange)
+      return;
+    await options.onChange(sortQuestions([...byId.values()]).map(clone2));
+  }
+  return {
+    async list(filter) {
+      return sortQuestions([...byId.values()].filter((registration) => matchesQuestionFilter(registration, filter))).map(clone2);
+    },
+    async get(questionId) {
+      const registration = byId.get(questionId);
+      return registration ? clone2(registration) : null;
+    },
+    async insert(registration) {
+      if (byId.has(registration.questionId)) {
+        throw new Error(`Question ${registration.questionId} is already registered`);
+      }
+      byId.set(registration.questionId, clone2(registration));
+      await changed();
+    },
+    async update(questionId, patch) {
+      const current = byId.get(questionId);
+      if (!current)
+        return null;
+      const next = { ...current, ...patch };
+      byId.set(questionId, next);
+      await changed();
+      return clone2(next);
+    },
+    async delete(questionId) {
+      const existed = byId.delete(questionId);
+      if (existed)
+        await changed();
+      return existed;
+    }
+  };
+}
+
 // ../core/dist/policy/data-read.js
 function parseGrantExpiresAtSeconds(value) {
   if (value === null || value === void 0 || value === "0")
@@ -112703,6 +113538,1084 @@ async function verifyDataReadPolicy(input, ports) {
   return grant;
 }
 
+// ../core/dist/policy/data-write.js
+var WRITE_SCOPE_PREFIX = "write:";
+function isWriteScopeEntry(entry) {
+  return entry.startsWith(WRITE_SCOPE_PREFIX);
+}
+function writeScopePatterns(grantScopes) {
+  return grantScopes.filter(isWriteScopeEntry).map((entry) => entry.slice(WRITE_SCOPE_PREFIX.length)).filter((pattern) => pattern.length > 0);
+}
+function scopeCoveredByWriteGrant(requestedScope, grantScopes) {
+  return writeScopePatterns(grantScopes).some((pattern) => scopeMatchesPattern(requestedScope, pattern));
+}
+async function verifyDataWritePolicy(input, ports) {
+  const available = await ports.runtimeAvailability?.isAvailable();
+  if (available === false) {
+    throw new PsUnavailableError();
+  }
+  const builder = await ports.authSessionVerifier.getBuilder(input.signer);
+  if (!builder) {
+    throw new UnregisteredBuilderError();
+  }
+  if (!input.grantId) {
+    throw new GrantRequiredError({
+      reason: "No grantId bound to the write session"
+    });
+  }
+  const grant = await ports.grantVerifier.getGrant(input.grantId);
+  if (!grant) {
+    throw new GrantRequiredError({
+      reason: "Grant not found",
+      grantId: input.grantId
+    });
+  }
+  if (grant.revokedAt !== null) {
+    throw new GrantRevokedError({ grantId: grant.id });
+  }
+  if (!grant.scopes || writeScopePatterns(grant.scopes).length === 0) {
+    throw new ScopeMismatchError({
+      requestedScope: input.requestedScope,
+      reason: "Grant has no write scopes"
+    });
+  }
+  if (grant.expiresAt !== null && grant.expiresAt !== void 0) {
+    const expiresAtSec = parseGrantExpiresAtSeconds(grant.expiresAt);
+    if (expiresAtSec === null) {
+      throw new ScopeMismatchError({
+        requestedScope: input.requestedScope,
+        reason: "Grant expiry is invalid"
+      });
+    }
+    if (expiresAtSec > 0) {
+      const nowSec = Math.floor(Date.now() / 1e3);
+      if (expiresAtSec < nowSec) {
+        throw new GrantExpiredError({
+          expiresAt: expiresAtSec
+        });
+      }
+    }
+  }
+  if (!scopeCoveredByWriteGrant(input.requestedScope, grant.scopes)) {
+    throw new ScopeMismatchError({
+      requestedScope: input.requestedScope,
+      grantedScopes: grant.scopes,
+      reason: "Grant does not authorize writing to this scope"
+    });
+  }
+  if (builder.id.toLowerCase() !== grant.granteeId.toLowerCase()) {
+    throw new InvalidSignatureError3({
+      reason: "Write signer is not the grant builder",
+      expected: grant.granteeId,
+      actual: input.signer
+    });
+  }
+  if (!input.serverOwner) {
+    throw new ServerNotConfiguredError({
+      reason: "serverOwner is required to verify grant ownership"
+    });
+  }
+  if (!grant.grantorAddress || grant.grantorAddress.toLowerCase() !== input.serverOwner.toLowerCase()) {
+    throw new GrantOwnerMismatchError({
+      grantId: grant.id,
+      expected: input.serverOwner,
+      actual: grant.grantorAddress ?? null
+    });
+  }
+  await ports.writeFeeVerifier?.assertWriteAllowed({
+    builder: input.signer,
+    grant,
+    scope: input.requestedScope
+  });
+  return grant;
+}
+
+// ../core/dist/derivatives/registration.js
+var MAX_QUESTION_SOURCE_SCOPES = 16;
+var MAX_QUESTION_CHARS = 8e3;
+var MAX_MODEL_CHARS = 128;
+var MAX_ECHOED_SCOPE_CHARS = 128;
+var MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/;
+function isRecord4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseScope(value, field) {
+  if (typeof value !== "string") {
+    throw new DerivativeQuestionInvalidError(`${field} must be a scope string`, {
+      field
+    });
+  }
+  const parsed = parseDataScopeContract(value);
+  if (!parsed.ok) {
+    throw new DerivativeQuestionInvalidError(`${field} is not a valid scope: ${parsed.body.message}`, { field, scope: value.slice(0, MAX_ECHOED_SCOPE_CHARS) });
+  }
+  return parsed.scope;
+}
+function parseQuestionInput(body) {
+  if (!isRecord4(body)) {
+    throw new DerivativeQuestionInvalidError("Body must be a JSON object");
+  }
+  const derivedScope = parseScope(body.derivedScope, "derivedScope");
+  if (!Array.isArray(body.sourceScopes) || body.sourceScopes.length === 0) {
+    throw new DerivativeQuestionInvalidError("sourceScopes must be a non-empty array of scopes", { field: "sourceScopes" });
+  }
+  if (body.sourceScopes.length > MAX_QUESTION_SOURCE_SCOPES) {
+    throw new DerivativeQuestionInvalidError(`sourceScopes lists ${body.sourceScopes.length} scopes; the maximum is ${MAX_QUESTION_SOURCE_SCOPES}`, { field: "sourceScopes", max: MAX_QUESTION_SOURCE_SCOPES });
+  }
+  const sourceScopes = [];
+  for (const entry of body.sourceScopes) {
+    const scope = parseScope(entry, "sourceScopes[]");
+    if (sourceScopes.includes(scope)) {
+      throw new DerivativeQuestionInvalidError("sourceScopes lists the same scope twice", { field: "sourceScopes", duplicate: scope });
+    }
+    if (scope === derivedScope) {
+      throw new DerivativeQuestionInvalidError("derivedScope cannot be one of its own sources", { field: "sourceScopes", scope });
+    }
+    sourceScopes.push(scope);
+  }
+  if (typeof body.question !== "string" || body.question.trim() === "") {
+    throw new DerivativeQuestionInvalidError("question must be a non-empty string", { field: "question" });
+  }
+  if (body.question.length > MAX_QUESTION_CHARS) {
+    throw new DerivativeQuestionInvalidError(`question is ${body.question.length} characters; the maximum is ${MAX_QUESTION_CHARS}`, { field: "question", max: MAX_QUESTION_CHARS });
+  }
+  let model = null;
+  if (body.model !== void 0 && body.model !== null) {
+    if (typeof body.model !== "string" || body.model.length > MAX_MODEL_CHARS || !MODEL_ID.test(body.model)) {
+      throw new DerivativeQuestionInvalidError("model must be a provider model id", { field: "model" });
+    }
+    model = body.model;
+  }
+  assertDerivedScopeNaming(derivedScope, sourceScopes);
+  return { derivedScope, sourceScopes, question: body.question, model };
+}
+function findDerivationCycle(candidate, existing) {
+  const sourcesOf = /* @__PURE__ */ new Map();
+  const add2 = (derived, sources) => {
+    const set2 = sourcesOf.get(derived) ?? /* @__PURE__ */ new Set();
+    for (const source of sources)
+      set2.add(source);
+    sourcesOf.set(derived, set2);
+  };
+  for (const registration of existing) {
+    add2(registration.derivedScope, registration.sourceScopes);
+  }
+  add2(candidate.derivedScope, candidate.sourceScopes);
+  const target = candidate.derivedScope;
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [
+    { scope: target, path: [target] }
+  ];
+  while (stack.length > 0) {
+    const { scope, path } = stack.pop();
+    for (const source of sourcesOf.get(scope) ?? []) {
+      if (source === target)
+        return [...path, source];
+      if (visited.has(source))
+        continue;
+      visited.add(source);
+      stack.push({ scope: source, path: [...path, source] });
+    }
+  }
+  return null;
+}
+async function createQuestionRegistration(input) {
+  const parsed = parseQuestionInput(input.body);
+  const cycle = findDerivationCycle(parsed, await input.store.list());
+  if (cycle) {
+    throw new DerivativeCycleError({
+      derivedScope: parsed.derivedScope,
+      path: cycle
+    });
+  }
+  const at3 = input.now().toISOString();
+  const registration = {
+    questionId: input.questionId,
+    derivedScope: parsed.derivedScope,
+    sourceScopes: parsed.sourceScopes,
+    question: parsed.question,
+    model: parsed.model,
+    registeredBy: input.registeredBy,
+    status: "pending",
+    error: null,
+    createdAt: at3,
+    updatedAt: at3,
+    lastComputedAt: null,
+    derivedVersion: null,
+    derivedCollectedAt: null
+  };
+  await input.store.insert(registration);
+  return registration;
+}
+function uncoveredSourceScopes(sourceScopes, grantScopes) {
+  const readEntries = (grantScopes ?? []).filter((entry) => !isWriteScopeEntry(entry));
+  return sourceScopes.filter((scope) => !scopeCoveredByGrant(scope, readEntries));
+}
+
+// ../core/dist/derivatives/prompt.js
+var DEFAULT_MAX_SOURCE_ITEMS = 50;
+var DEFAULT_MAX_SOURCE_CHARS = 2e5;
+var TIMESTAMP_KEYS = [
+  "collectedAt",
+  "updatedAt",
+  "updated_at",
+  "update_time",
+  "createdAt",
+  "created_at",
+  "create_time",
+  "timestamp",
+  "time",
+  "date",
+  "publishedAt",
+  "published_at"
+];
+var RESERVED_KEYS = /* @__PURE__ */ new Set(["$lineage", "$writtenBy", "$binary"]);
+function isRecord5(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function timestampOf(item) {
+  if (!isRecord5(item))
+    return null;
+  for (const key of TIMESTAMP_KEYS) {
+    const value = item[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value < 1e12 ? value * 1e3 : value;
+    }
+    if (typeof value === "string") {
+      const parsed = Date.parse(value);
+      if (!Number.isNaN(parsed))
+        return parsed;
+    }
+  }
+  return null;
+}
+function sortNewestFirst(items) {
+  const indexed = items.map((item, index) => ({
+    item,
+    index,
+    at: timestampOf(item)
+  }));
+  const dated = indexed.filter((entry) => entry.at !== null).sort((a10, b10) => b10.at - a10.at || b10.index - a10.index);
+  const undated = indexed.filter((entry) => entry.at === null).reverse();
+  return [...dated, ...undated].map((entry) => entry.item);
+}
+function trimSourceData(data, options = {}) {
+  const maxItems = Math.max(1, options.maxItems ?? DEFAULT_MAX_SOURCE_ITEMS);
+  const maxChars = Math.max(1, options.maxChars ?? DEFAULT_MAX_SOURCE_CHARS);
+  let kept = 0;
+  let total = 0;
+  const trimArray = (items, limit2) => {
+    total += items.length;
+    const sorted = sortNewestFirst(items).slice(0, limit2);
+    kept += sorted.length;
+    return sorted;
+  };
+  const build = (limit2) => {
+    kept = 0;
+    total = 0;
+    if (Array.isArray(data))
+      return trimArray(data, limit2);
+    if (isRecord5(data)) {
+      const out = {};
+      for (const [key, value] of Object.entries(data)) {
+        if (RESERVED_KEYS.has(key))
+          continue;
+        out[key] = Array.isArray(value) ? trimArray(value, limit2) : value;
+      }
+      return out;
+    }
+    return data;
+  };
+  let limit = maxItems;
+  let result = build(limit);
+  let text = JSON.stringify(result) ?? "null";
+  while (text.length > maxChars && limit > 1) {
+    limit = Math.max(1, Math.floor(limit / 2));
+    result = build(limit);
+    text = JSON.stringify(result) ?? "null";
+  }
+  if (text.length > maxChars) {
+    return {
+      data: `${text.slice(0, maxChars)}...[truncated]`,
+      kept,
+      total,
+      truncated: true
+    };
+  }
+  return { data: result, kept, total, truncated: false };
+}
+var SYSTEM_PROMPT = [
+  "You answer a question about a person using ONLY the user data provided in the message.",
+  "Do not use outside knowledge and do not guess; if the data does not support an answer, say so in the answer.",
+  "Respond with a single JSON object and nothing else, with exactly these fields:",
+  '  "answer": string, the answer to the question, written for the person the data belongs to;',
+  '  "evidence": string, a short summary of which parts of the data support the answer.'
+].join("\n");
+function buildQuestionMessages(input) {
+  const sections = input.sources.map((source) => {
+    const note = source.total > source.kept ? ` (newest ${source.kept} of ${source.total} items)` : "";
+    const cut = source.truncated ? " (truncated)" : "";
+    return [
+      `### Scope: ${source.scope}${note}${cut}`,
+      `Collected at: ${source.collectedAt}`,
+      JSON.stringify(source.data)
+    ].join("\n");
+  });
+  const user = [
+    "## Question",
+    input.question,
+    "",
+    "## User data",
+    ...sections,
+    "",
+    "Answer the question as a JSON object with the fields answer and evidence."
+  ].join("\n");
+  return [
+    { role: "system", content: SYSTEM_PROMPT },
+    { role: "user", content: user }
+  ];
+}
+function parseAnswer(content) {
+  const candidates = [content.trim()];
+  const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(content);
+  if (fenced?.[1])
+    candidates.unshift(fenced[1].trim());
+  const first = content.indexOf("{");
+  const last2 = content.lastIndexOf("}");
+  if (first !== -1 && last2 > first) {
+    candidates.push(content.slice(first, last2 + 1));
+  }
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      if (isRecord5(parsed) && typeof parsed.answer === "string") {
+        return {
+          answer: parsed.answer,
+          evidence: typeof parsed.evidence === "string" ? parsed.evidence : null
+        };
+      }
+    } catch {
+    }
+  }
+  return { answer: content.trim(), evidence: null };
+}
+
+// ../core/dist/derivatives/inference.js
+var DEFAULT_INFERENCE_BASE_URL = "https://inference.phala.com/v1";
+var DEFAULT_INFERENCE_MODEL = "z-ai/glm-5.2";
+var DEFAULT_INFERENCE_TIMEOUT_MS = 12e4;
+var DEFAULT_INFERENCE_MAX_TOKENS = 2048;
+var DEFAULT_INFERENCE_REQUEST_FIELDS = {
+  provider: { aci_verified: true, zdr: true }
+};
+var InferenceRequestError = class extends Error {
+  status;
+  constructor(message, status2) {
+    super(message);
+    this.status = status2;
+    this.name = "InferenceRequestError";
+  }
+};
+function isRecord6(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readUsage(value) {
+  if (!isRecord6(value))
+    return void 0;
+  const num2 = (v10) => typeof v10 === "number" ? v10 : void 0;
+  const usage = {
+    promptTokens: num2(value.prompt_tokens),
+    completionTokens: num2(value.completion_tokens),
+    totalTokens: num2(value.total_tokens)
+  };
+  return usage;
+}
+function readContent(body) {
+  if (!isRecord6(body) || !Array.isArray(body.choices))
+    return null;
+  const first = body.choices[0];
+  if (!isRecord6(first) || !isRecord6(first.message))
+    return null;
+  const content = first.message.content;
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    const text = content.map((part) => isRecord6(part) && typeof part.text === "string" ? part.text : "").join("");
+    return text;
+  }
+  return null;
+}
+function createOpenAiCompatibleInferenceProvider(options = {}) {
+  const base = (options.baseUrl ?? DEFAULT_INFERENCE_BASE_URL).replace(/\/+$/, "");
+  const defaultModel = options.model ?? DEFAULT_INFERENCE_MODEL;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_INFERENCE_TIMEOUT_MS;
+  const doFetch = options.fetch ?? fetch;
+  const requestFields = options.requestFields ?? DEFAULT_INFERENCE_REQUEST_FIELDS;
+  return {
+    defaultModel,
+    async chat(input) {
+      const headers = new Headers({ "Content-Type": "application/json" });
+      if (options.apiKey) {
+        headers.set("Authorization", `Bearer ${options.apiKey}`);
+      }
+      let messages = input.messages;
+      if (options.encryption) {
+        ({ messages } = await options.encryption.encryptRequest({
+          messages,
+          headers
+        }));
+      }
+      const body = {
+        ...requestFields,
+        model: input.model || defaultModel,
+        messages,
+        max_tokens: input.maxTokens ?? DEFAULT_INFERENCE_MAX_TOKENS
+      };
+      let response;
+      try {
+        response = await doFetch(`${base}/chat/completions`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+      } catch (err2) {
+        const name = err2 instanceof Error ? err2.name : "Error";
+        throw new InferenceRequestError(`inference request failed before a response (${name})`, null);
+      }
+      if (!response.ok) {
+        throw new InferenceRequestError(`inference request failed with status ${response.status}`, response.status);
+      }
+      let parsed;
+      try {
+        parsed = await response.json();
+      } catch {
+        throw new InferenceRequestError("inference response was not JSON", response.status);
+      }
+      let content = readContent(parsed);
+      if (content === null || content.trim() === "") {
+        throw new InferenceRequestError("inference response carried no assistant content", response.status);
+      }
+      if (options.encryption) {
+        content = await options.encryption.decryptResponse({
+          content,
+          headers: response.headers
+        });
+      }
+      const receiptId = response.headers.get("x-receipt-id") ?? void 0;
+      const aciIdentity = response.headers.get("x-aci-identity") ?? void 0;
+      return {
+        content,
+        usage: readUsage(isRecord6(parsed) ? parsed.usage : void 0),
+        ...receiptId ? { receiptId } : {},
+        ...aciIdentity ? { aciIdentity } : {}
+      };
+    }
+  };
+}
+
+// ../core/dist/derivatives/compute.js
+var DEFAULT_RETRY_DELAYS_MS = [1e3, 4e3];
+function isRetryableInferenceError(err2) {
+  return err2 instanceof InferenceRequestError && (err2.status === null || err2.status === 429 || err2.status >= 500);
+}
+async function withRetries(deps, attempt, retryable) {
+  const delays = deps.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS;
+  const sleep2 = deps.sleep ?? ((ms3) => new Promise((r10) => setTimeout(r10, ms3)));
+  for (let index = 0; ; index += 1) {
+    try {
+      return await attempt();
+    } catch (err2) {
+      if (index >= delays.length || !retryable(err2))
+        throw err2;
+      await sleep2(delays[index]);
+    }
+  }
+}
+var ComputeFailure = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ComputeFailure";
+  }
+};
+function shortError(err2) {
+  if (err2 instanceof ComputeFailure)
+    return err2.message;
+  if (err2 instanceof InferenceRequestError)
+    return err2.message;
+  if (err2 instanceof ProtocolError)
+    return `${err2.errorCode}: ${err2.message}`;
+  return `compute failed (${err2 instanceof Error ? err2.name : "Error"})`;
+}
+function collectedAtStamp(now, isTaken) {
+  const base = now();
+  base.setUTCMilliseconds(0);
+  for (let bump = 0; bump < 60; bump += 1) {
+    const candidate = new Date(base.getTime() + bump * 1e3).toISOString().replace(/\.\d{3}Z$/, "Z");
+    if (!isTaken(candidate))
+      return candidate;
+  }
+  throw new ComputeFailure("could not allocate a version stamp");
+}
+async function tombstoneMarker(scopeDeletions, scope) {
+  if (!scopeDeletions)
+    return null;
+  const verdict = await scopeDeletions.resolve(scope);
+  if (!verdict.deleted || verdict.version === null)
+    return null;
+  const version4 = Number(verdict.version);
+  return Number.isSafeInteger(version4) ? version4 : null;
+}
+function localScopesById2(storage, serverOwner) {
+  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) {
+      byId.set(computeDataPointId(serverOwner, summary.scope), summary.scope);
+    }
+    if (scopes.length === 0 || offset + scopes.length >= total)
+      break;
+  }
+  return byId;
+}
+async function assertNoLineageCycle(deps, registration, serverOwner, sourceLineage) {
+  const derivedId = computeDataPointId(serverOwner, registration.derivedScope);
+  let byId = null;
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [];
+  for (const [scope, sources] of sourceLineage) {
+    for (const id2 of sources)
+      stack.push({ id: id2, path: [scope] });
+  }
+  while (stack.length > 0) {
+    const { id: id2, path } = stack.pop();
+    if (id2 === derivedId) {
+      throw new DerivativeCycleError({
+        derivedScope: registration.derivedScope,
+        path: [registration.derivedScope, ...path, registration.derivedScope]
+      });
+    }
+    if (visited.has(id2))
+      continue;
+    visited.add(id2);
+    byId ??= localScopesById2(deps.storage, serverOwner);
+    const scope = byId.get(id2);
+    if (!scope)
+      continue;
+    const entry = deps.storage.findEntry({ scope });
+    if (!entry)
+      continue;
+    let sources = [];
+    try {
+      const envelope = await deps.storage.readEnvelope(scope, entry.collectedAt);
+      sources = readStoredLineage(envelope.data)?.sources ?? [];
+    } catch {
+    }
+    for (const next of sources)
+      stack.push({ id: next, path: [...path, scope] });
+  }
+}
+async function loadSource(deps, scope) {
+  const entry = deps.storage.findEntry({ scope });
+  const deletion = await resolveReadDeletion({ scopeDeletions: deps.scopeDeletions, serverOwner: deps.serverOwner }, scope, entry);
+  if (deletion) {
+    throw new ComputeFailure(`source scope ${scope} is deleted`);
+  }
+  if (!entry) {
+    throw new ComputeFailure(`source scope ${scope} has no local data`);
+  }
+  let envelope;
+  try {
+    envelope = await deps.storage.readEnvelope(scope, entry.collectedAt);
+  } catch {
+    throw new ComputeFailure(`source scope ${scope} could not be read`);
+  }
+  let lineageSources = [];
+  try {
+    lineageSources = readStoredLineage(envelope.data)?.sources ?? [];
+  } catch {
+  }
+  const raw = isBinaryEnvelope(envelope) ? {
+    binary: true,
+    note: "binary record; its content is not included in the prompt"
+  } : envelope.data;
+  const trimmed = trimSourceData(raw, {
+    maxItems: deps.maxSourceItems,
+    maxChars: deps.maxSourceChars
+  });
+  return {
+    source: {
+      scope,
+      collectedAt: entry.collectedAt,
+      version: entry.version,
+      data: trimmed.data,
+      kept: trimmed.kept,
+      total: trimmed.total,
+      truncated: trimmed.truncated
+    },
+    lineageSources
+  };
+}
+async function assertGrantStillValid(deps, registration) {
+  if (registration.registeredBy.kind !== "builder")
+    return;
+  if (!deps.writePolicyPorts) {
+    throw new ComputeFailure("builder grant verification is not configured");
+  }
+  if (!deps.serverOwner) {
+    throw new ComputeFailure("server owner is not configured");
+  }
+  const { builder, grantId } = registration.registeredBy;
+  const ports = deps.writePolicyPorts;
+  const serverOwner = deps.serverOwner;
+  const grant = await withRetries(deps, () => verifyDataWritePolicy({
+    signer: builder,
+    grantId,
+    requestedScope: registration.derivedScope,
+    serverOwner
+  }, ports), (err2) => !(err2 instanceof ProtocolError));
+  const uncovered = uncoveredSourceScopes(registration.sourceScopes, grant.scopes ?? []);
+  if (uncovered.length > 0) {
+    throw new DerivativeSourceNotGrantedError({ scopes: uncovered });
+  }
+}
+async function computeQuestion(questionId, deps) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  if (await deps.runtimeAvailability?.isAvailable() === false) {
+    return { status: "skipped", reason: "runtime-unavailable" };
+  }
+  const registration = await deps.store.get(questionId);
+  if (!registration)
+    return { status: "skipped", reason: "unknown-question" };
+  try {
+    if (!deps.serverOwner) {
+      throw new ComputeFailure("server owner is not configured");
+    }
+    const serverOwner = deps.serverOwner;
+    await assertGrantStillValid(deps, registration);
+    assertDerivedScopeNaming(registration.derivedScope, registration.sourceScopes);
+    const sources = [];
+    const sourceLineage = /* @__PURE__ */ new Map();
+    for (const scope of registration.sourceScopes) {
+      const loaded = await loadSource(deps, scope);
+      sources.push(loaded.source);
+      sourceLineage.set(scope, loaded.lineageSources);
+    }
+    await assertNoLineageCycle(deps, registration, serverOwner, sourceLineage);
+    const messages = buildQuestionMessages({
+      question: registration.question,
+      sources
+    });
+    const model = registration.model ?? deps.provider.defaultModel;
+    const reply = await withRetries(deps, () => deps.provider.chat({ model, messages, maxTokens: deps.maxTokens }), isRetryableInferenceError);
+    const parsed = parseAnswer(reply.content);
+    const computedAt = now().toISOString();
+    const lineageIds = registration.sourceScopes.map((scope) => computeDataPointId(serverOwner, scope));
+    const record2 = {
+      questionId: registration.questionId,
+      question: registration.question,
+      answer: parsed.answer,
+      evidence: parsed.evidence,
+      model,
+      computedAt,
+      sources: sources.map((source) => ({
+        scope: source.scope,
+        version: source.version,
+        collectedAt: source.collectedAt
+      })),
+      lineage: lineageIds,
+      ...reply.receiptId || reply.aciIdentity ? {
+        inference: {
+          ...reply.receiptId ? { receiptId: reply.receiptId } : {},
+          ...reply.aciIdentity ? { aciIdentity: reply.aciIdentity } : {}
+        }
+      } : {}
+    };
+    const lineage = {
+      sources: lineageIds,
+      writtenAt: computedAt
+    };
+    const collectedAt2 = collectedAtStamp(now, (candidate) => deps.storage.findEntry({
+      scope: registration.derivedScope,
+      at: candidate
+    })?.collectedAt === candidate);
+    const written = await ingestDataContract({
+      storage: deps.storage,
+      scopeParam: registration.derivedScope,
+      body: record2,
+      collectedAt: collectedAt2,
+      status: deps.syncManager ? "syncing" : "stored",
+      lineage,
+      afterTombstoneVersion: await tombstoneMarker(deps.scopeDeletions, registration.derivedScope)
+    });
+    if (!written.ok) {
+      throw new ComputeFailure(`derived record rejected: ${written.body.error}`);
+    }
+    const entry = deps.storage.findEntry({
+      scope: registration.derivedScope,
+      at: collectedAt2
+    });
+    const updated = await deps.store.update(questionId, {
+      status: "ready",
+      error: null,
+      updatedAt: computedAt,
+      lastComputedAt: computedAt,
+      derivedVersion: entry?.version ?? null,
+      derivedCollectedAt: collectedAt2
+    });
+    if (deps.syncManager?.notifyNewData) {
+      deps.syncManager.notifyNewData();
+    } else if (deps.syncManager?.trigger) {
+      void deps.syncManager.trigger().catch(() => void 0);
+    }
+    try {
+      deps.onDerivedWritten?.({
+        scope: registration.derivedScope,
+        collectedAt: collectedAt2,
+        lineageSources: lineageIds
+      });
+    } catch (err2) {
+      deps.logger?.warn?.({
+        questionId,
+        derivedScope: registration.derivedScope,
+        error: err2 instanceof Error ? err2.name : String(err2)
+      }, "onDerivedWritten hook failed; derivative already written");
+    }
+    deps.logger?.info?.({
+      questionId,
+      derivedScope: registration.derivedScope,
+      sourceScopes: registration.sourceScopes,
+      model,
+      version: entry?.version ?? null,
+      receiptId: reply.receiptId ?? null
+    }, "Derivative question computed");
+    return {
+      status: "ready",
+      registration: updated ?? { ...registration, status: "ready" }
+    };
+  } catch (err2) {
+    const error51 = shortError(err2);
+    const at3 = now().toISOString();
+    const updated = await deps.store.update(questionId, {
+      status: "failed",
+      error: error51,
+      updatedAt: at3
+    });
+    deps.logger?.warn?.({ questionId, derivedScope: registration.derivedScope, error: error51 }, "Derivative question compute failed");
+    return {
+      status: "failed",
+      registration: updated ?? { ...registration, status: "failed", error: error51 },
+      error: error51
+    };
+  }
+}
+
+// ../core/dist/derivatives/scheduler.js
+var defaultTimers = {
+  setTimeout: (callback, ms3) => setTimeout(callback, ms3),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
+function createRecomputeScheduler(options) {
+  const debounceMs = options.debounceMs ?? 5e3;
+  const timers = options.timers ?? defaultTimers;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const states = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Set();
+  let stopped = false;
+  function track(promise2) {
+    pending.add(promise2);
+    const done = () => pending.delete(promise2);
+    promise2.then(done, done);
+    return promise2;
+  }
+  function warn(payload, message) {
+    options.logger?.warn?.(payload, message);
+  }
+  function stateFor(questionId) {
+    let state = states.get(questionId);
+    if (!state) {
+      state = { timer: null, running: null, rerun: false };
+      states.set(questionId, state);
+    }
+    return state;
+  }
+  function run(questionId) {
+    if (stopped)
+      return;
+    const state = stateFor(questionId);
+    if (state.running) {
+      state.rerun = true;
+      return;
+    }
+    state.running = track(Promise.resolve().then(() => options.compute(questionId)).then(() => void 0, (err2) => warn({
+      questionId,
+      error: err2 instanceof Error ? err2.name : String(err2)
+    }, "Derivative compute threw")).then(async () => {
+      state.running = null;
+      if (state.rerun) {
+        state.rerun = false;
+        await markStale(questionId);
+        schedule(questionId, 0);
+      } else if (!states.get(questionId)?.timer) {
+        states.delete(questionId);
+      }
+    }));
+  }
+  function schedule(questionId, delayMs) {
+    if (stopped)
+      return;
+    const state = stateFor(questionId);
+    if (state.timer !== null)
+      timers.clearTimeout(state.timer);
+    state.timer = timers.setTimeout(() => {
+      state.timer = null;
+      run(questionId);
+    }, delayMs);
+  }
+  async function markStale(questionId) {
+    const registration = await options.store.get(questionId);
+    if (!registration)
+      return;
+    if (registration.status === "ready" || registration.status === "failed") {
+      await options.store.update(questionId, {
+        status: "stale",
+        updatedAt: now().toISOString()
+      });
+    }
+  }
+  return {
+    markSourceChanged(scope, opts) {
+      if (stopped)
+        return;
+      const lineage = new Set((opts?.lineageSources ?? []).map((id2) => id2.toLowerCase()));
+      void track((async () => {
+        const affected = await options.store.list({ sourceScope: scope });
+        for (const registration of affected) {
+          if (options.serverOwner && lineage.has(computeDataPointId(options.serverOwner, registration.derivedScope))) {
+            continue;
+          }
+          await markStale(registration.questionId);
+          schedule(registration.questionId, debounceMs);
+        }
+      })().catch((err2) => warn({ scope, error: err2 instanceof Error ? err2.name : String(err2) }, "Could not mark derivative questions stale")));
+    },
+    requestRecompute(questionId, opts) {
+      if (stopped)
+        return;
+      void track(markStale(questionId).catch((err2) => warn({
+        questionId,
+        error: err2 instanceof Error ? err2.name : String(err2)
+      }, "Could not mark derivative question stale")).then(() => schedule(questionId, opts?.immediate ? 0 : debounceMs)));
+    },
+    async whenIdle() {
+      const waitForTimers = !options.timers;
+      for (; ; ) {
+        while (pending.size > 0) {
+          await Promise.allSettled([...pending]);
+        }
+        const busy = [...states.values()].some((state) => state.running !== null || waitForTimers && state.timer !== null);
+        if (!busy)
+          return;
+        await new Promise((resolve) => setTimeout(resolve, 5));
+      }
+    },
+    stop() {
+      stopped = true;
+      for (const state of states.values()) {
+        if (state.timer !== null)
+          timers.clearTimeout(state.timer);
+        state.timer = null;
+      }
+    },
+    start() {
+      if (!stopped)
+        return;
+      stopped = false;
+      void track((async () => {
+        for (const registration of await options.store.list()) {
+          if (registration.status === "pending" || registration.status === "stale") {
+            schedule(registration.questionId, 0);
+          }
+        }
+      })().catch((err2) => warn({ error: err2 instanceof Error ? err2.name : String(err2) }, "Could not reschedule derivative questions")));
+    }
+  };
+}
+
+// ../core/dist/derivatives/api.js
+var MAX_QUESTION_BODY_BYTES = 16 * 1024;
+function jsonResponse2(body, init) {
+  const headers = new Headers(init?.headers);
+  headers.set("Content-Type", "application/json");
+  return new Response(JSON.stringify(body), { ...init, headers });
+}
+function errorResponse2(status2, errorCode, message) {
+  return jsonResponse2({ error: { code: status2, errorCode, message } }, { status: status2 });
+}
+function stripBasePath2(pathname, basePath) {
+  if (!basePath || basePath === "/")
+    return pathname;
+  if (pathname === basePath)
+    return "/";
+  if (pathname.startsWith(`${basePath}/`))
+    return pathname.slice(basePath.length);
+  return pathname;
+}
+async function authorizeOwnerOrWriter(deps, request2, scope) {
+  if (deps.auth.authorizeWrite) {
+    return await deps.auth.authorizeWrite({ request: request2, scope }) ?? void 0;
+  }
+  await deps.auth.authorizeOwner(request2);
+  return void 0;
+}
+function sameBuilder(a10, b10) {
+  return a10.toLowerCase() === b10.toLowerCase();
+}
+async function loadForCaller(deps, request2, store, questionId) {
+  const registration = await store.get(questionId);
+  if (!registration) {
+    await deps.auth.authorizeOwner(request2);
+    throw new DerivativeQuestionNotFoundError({ questionId });
+  }
+  const writer = await authorizeOwnerOrWriter(deps, request2, registration.derivedScope);
+  if (writer) {
+    const by2 = registration.registeredBy;
+    if (by2.kind !== "builder" || !sameBuilder(by2.builder, writer.builder)) {
+      await writer.releaseProof?.();
+      throw new DerivativeQuestionNotFoundError({ questionId });
+    }
+  }
+  return { registration, writer };
+}
+async function handlePersonalServerDerivativesRequest(request2, deps, options = {}) {
+  try {
+    const url2 = new URL(request2.url);
+    const pathname = stripBasePath2(url2.pathname, options.basePath);
+    const parts = pathname.split("/").filter(Boolean);
+    if (parts[0] !== "questions" || parts.length > 3) {
+      return errorResponse2(404, "NOT_FOUND", "Not found");
+    }
+    const compute = deps.compute;
+    if (!compute)
+      throw new DerivativeComputeUnavailableError();
+    const { store, scheduler } = compute;
+    const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+    if (parts.length === 1) {
+      if (request2.method === "GET") {
+        const derivedScope = url2.searchParams.get("derivedScope") ?? void 0;
+        if (derivedScope) {
+          const writer = await authorizeOwnerOrWriter(deps, request2, derivedScope);
+          const registrations2 = await store.list({
+            derivedScope,
+            ...writer ? { builder: writer.builder } : {}
+          });
+          return jsonResponse2({
+            questions: registrations2.map(questionRegistrationView)
+          });
+        }
+        await deps.auth.authorizeOwner(request2);
+        const registrations = await store.list();
+        return jsonResponse2({
+          questions: registrations.map(questionRegistrationView)
+        });
+      }
+      if (request2.method === "POST") {
+        const declared = Number(request2.headers.get("content-length") ?? "0");
+        if (declared > MAX_QUESTION_BODY_BYTES) {
+          throw new ContentTooLargeError({ max: MAX_QUESTION_BODY_BYTES });
+        }
+        const bodyBytes = new Uint8Array(await request2.clone().arrayBuffer());
+        if (bodyBytes.byteLength > MAX_QUESTION_BODY_BYTES) {
+          throw new ContentTooLargeError({ max: MAX_QUESTION_BODY_BYTES });
+        }
+        const parsed = await parseJsonObjectBody(request2.clone(), "Request body must be valid JSON");
+        if (!parsed.ok) {
+          return jsonResponse2(parsed.result.body, {
+            status: parsed.result.status
+          });
+        }
+        const rawScope = parsed.body.derivedScope;
+        const scopeForAuth = typeof rawScope === "string" ? rawScope : "";
+        const writer = await authorizeOwnerOrWriter(deps, request2, scopeForAuth);
+        const registeredBy = writer ? {
+          kind: "builder",
+          builder: writer.builder,
+          grantId: writer.grantId
+        } : { kind: "owner" };
+        let registration;
+        try {
+          if (writer) {
+            const input = parseQuestionInput(parsed.body);
+            const uncovered = uncoveredSourceScopes(input.sourceScopes, writer.grantScopes);
+            if (uncovered.length > 0) {
+              throw new DerivativeSourceNotGrantedError({ scopes: uncovered });
+            }
+          }
+          registration = await createQuestionRegistration({
+            body: parsed.body,
+            registeredBy,
+            store,
+            questionId: deps.createQuestionId?.() ?? crypto.randomUUID(),
+            now
+          });
+        } catch (err2) {
+          await writer?.releaseProof?.();
+          throw err2;
+        }
+        deps.logger?.info?.({
+          questionId: registration.questionId,
+          derivedScope: registration.derivedScope,
+          sourceScopes: registration.sourceScopes,
+          registeredBy: registeredBy.kind,
+          ...writer ? { builder: writer.builder, grantId: writer.grantId } : {}
+        }, "Derivative question registered");
+        scheduler.requestRecompute(registration.questionId, {
+          immediate: true
+        });
+        return jsonResponse2(questionRegistrationView(registration), {
+          status: 201
+        });
+      }
+      return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+    }
+    const questionId = decodeURIComponent(parts[1] ?? "");
+    if (parts.length === 3) {
+      if (parts[2] !== "recompute") {
+        return errorResponse2(404, "NOT_FOUND", "Not found");
+      }
+      if (request2.method !== "POST") {
+        return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+      }
+      const { registration } = await loadForCaller(deps, request2, store, questionId);
+      scheduler.requestRecompute(questionId, { immediate: true });
+      return jsonResponse2({
+        questionId,
+        status: registration.status === "pending" ? "pending" : "stale",
+        derivedScope: registration.derivedScope
+      }, { status: 202 });
+    }
+    if (request2.method === "GET") {
+      const { registration } = await loadForCaller(deps, request2, store, questionId);
+      return jsonResponse2(questionRegistrationView(registration));
+    }
+    if (request2.method === "DELETE") {
+      const { registration } = await loadForCaller(deps, request2, store, questionId);
+      await store.delete(questionId);
+      deps.logger?.info?.({ questionId, derivedScope: registration.derivedScope }, "Derivative question deleted");
+      return jsonResponse2({ questionId, deleted: true });
+    }
+    return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+  } catch (err2) {
+    if (err2 instanceof ProtocolError) {
+      return jsonResponse2(err2.toJSON(), { status: err2.code });
+    }
+    return errorResponse2(500, "INTERNAL_ERROR", "Internal server error");
+  }
+}
+
 // ../core/dist/mcp/store.js
 function createInMemoryMcpOAuthAuthorizationStore() {
   const byId = /* @__PURE__ */ new Map();
@@ -112761,6 +114674,16 @@ var McpDataReadError = class extends Error {
 };
 function createMcpDataReadClient(options) {
   const basePath = options.basePath ?? "/v1/data";
+  async function assertScopeReadable(scope, entry) {
+    try {
+      await assertScopeNotDeleted(options.dataApiDeps, scope, entry);
+    } catch (err2) {
+      if (err2 instanceof ProtocolError) {
+        throw new McpDataReadError(err2.code, err2.toJSON());
+      }
+      throw err2;
+    }
+  }
   async function authorizeScopeRead(params) {
     const safeScope = encodeURIComponent(params.scope);
     const signingUri = `${basePath}/${safeScope}`;
@@ -112848,6 +114771,9 @@ function createMcpDataReadClient(options) {
       const entry = storage.findEntry({ scope });
       if (!entry)
         return null;
+      if (await resolveReadDeletion(options.dataApiDeps, scope, entry)) {
+        return null;
+      }
       const hasBlocks = typeof storage.hasScopeBlocks === "function" ? await storage.hasScopeBlocks(scope, entry.collectedAt) : false;
       return {
         scope,
@@ -112876,6 +114802,7 @@ function createMcpDataReadClient(options) {
           message: `No data found for scope "${scope}"`
         });
       }
+      await assertScopeReadable(scope, selectedEntry);
       const { request: request2, authResult } = await authorizeScopeRead({
         scope,
         grantId,
@@ -112933,6 +114860,7 @@ function createMcpDataReadClient(options) {
           message: `No data found for scope "${scope}"`
         });
       }
+      await assertScopeReadable(scope, selectedEntry);
       const { request: request2, authResult } = await authorizeScopeRead({
         scope,
         grantId,
@@ -116596,15 +118524,15 @@ var makeIssue = (params) => {
       message: issueData.message
     };
   }
-  let errorMessage2 = "";
+  let errorMessage3 = "";
   const maps = errorMaps.filter((m10) => !!m10).slice().reverse();
   for (const map2 of maps) {
-    errorMessage2 = map2(fullIssue, { data, defaultError: errorMessage2 }).message;
+    errorMessage3 = map2(fullIssue, { data, defaultError: errorMessage3 }).message;
   }
   return {
     ...issueData,
     path: fullPath,
-    message: errorMessage2
+    message: errorMessage3
   };
 };
 function addIssueToContext(ctx, issueData) {
@@ -121884,19 +123812,19 @@ var getRefs = (options) => {
 };
 
 // ../../node_modules/zod-to-json-schema/dist/esm/errorMessages.js
-function addErrorMessage(res, key, errorMessage2, refs) {
+function addErrorMessage(res, key, errorMessage3, refs) {
   if (!refs?.errorMessages)
     return;
-  if (errorMessage2) {
+  if (errorMessage3) {
     res.errorMessage = {
       ...res.errorMessage,
-      [key]: errorMessage2
+      [key]: errorMessage3
     };
   }
 }
-function setResponseValueAndErrors(res, key, value, errorMessage2, refs) {
+function setResponseValueAndErrors(res, key, value, errorMessage3, refs) {
   res[key] = value;
-  addErrorMessage(res, key, errorMessage2, refs);
+  addErrorMessage(res, key, errorMessage3, refs);
 }
 
 // ../../node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
@@ -123207,8 +125135,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 {
@@ -123396,7 +125324,7 @@ var Protocol = class {
     const capturedTransport = this._transport;
     const relatedTaskId = request2.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
     if (handler === void 0) {
-      const errorResponse3 = {
+      const errorResponse4 = {
         jsonrpc: "2.0",
         id: request2.id,
         error: {
@@ -123407,11 +125335,11 @@ var Protocol = class {
       if (relatedTaskId && this._taskMessageQueue) {
         this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
-          message: errorResponse3,
+          message: errorResponse4,
           timestamp: Date.now()
         }, capturedTransport?.sessionId).catch((error51) => this._onerror(new Error(`Failed to enqueue error response: ${error51}`)));
       } else {
-        capturedTransport?.send(errorResponse3).catch((error51) => this._onerror(new Error(`Failed to send an error response: ${error51}`)));
+        capturedTransport?.send(errorResponse4).catch((error51) => this._onerror(new Error(`Failed to send an error response: ${error51}`)));
       }
       return;
     }
@@ -123481,7 +125409,7 @@ var Protocol = class {
       if (abortController.signal.aborted) {
         return;
       }
-      const errorResponse3 = {
+      const errorResponse4 = {
         jsonrpc: "2.0",
         id: request2.id,
         error: {
@@ -123493,11 +125421,11 @@ var Protocol = class {
       if (relatedTaskId && this._taskMessageQueue) {
         await this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
-          message: errorResponse3,
+          message: errorResponse4,
           timestamp: Date.now()
         }, capturedTransport?.sessionId);
       } else {
-        await capturedTransport?.send(errorResponse3);
+        await capturedTransport?.send(errorResponse4);
       }
     }).catch((error51) => this._onerror(new Error(`Failed to send response: ${error51}`))).finally(() => {
       if (this._requestHandlerAbortControllers.get(request2.id) === abortController) {
@@ -124508,23 +126436,23 @@ var Server = class extends Protocol {
       const wrappedHandler = async (request2, extra) => {
         const validatedRequest = safeParse3(CallToolRequestSchema, request2);
         if (!validatedRequest.success) {
-          const errorMessage2 = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage2}`);
+          const errorMessage3 = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage3}`);
         }
         const { params } = validatedRequest.data;
         const result = await Promise.resolve(handler(request2, extra));
         if (params.task) {
           const taskValidationResult = safeParse3(CreateTaskResultSchema, result);
           if (!taskValidationResult.success) {
-            const errorMessage2 = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage2}`);
+            const errorMessage3 = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage3}`);
           }
           return taskValidationResult.data;
         }
         const validationResult = safeParse3(CallToolResultSchema, result);
         if (!validationResult.success) {
-          const errorMessage2 = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage2}`);
+          const errorMessage3 = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage3}`);
         }
         return validationResult.data;
       };
@@ -125240,12 +127168,12 @@ var McpServer = class {
    * @param errorMessage - The error message.
    * @returns The tool error result.
    */
-  createToolError(errorMessage2) {
+  createToolError(errorMessage3) {
     return {
       content: [
         {
           type: "text",
-          text: errorMessage2
+          text: errorMessage3
         }
       ],
       isError: true
@@ -125263,8 +127191,8 @@ var McpServer = class {
     const parseResult = await safeParseAsync3(schemaToParse, args);
     if (!parseResult.success) {
       const error51 = "error" in parseResult ? parseResult.error : "Unknown error";
-      const errorMessage2 = getParseErrorMessage(error51);
-      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage2}`);
+      const errorMessage3 = getParseErrorMessage(error51);
+      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage3}`);
     }
     return parseResult.data;
   }
@@ -125288,8 +127216,8 @@ var McpServer = class {
     const parseResult = await safeParseAsync3(outputObj, result.structuredContent);
     if (!parseResult.success) {
       const error51 = "error" in parseResult ? parseResult.error : "Unknown error";
-      const errorMessage2 = getParseErrorMessage(error51);
-      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage2}`);
+      const errorMessage3 = getParseErrorMessage(error51);
+      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage3}`);
     }
   }
   /**
@@ -125501,8 +127429,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;
@@ -127120,16 +129048,16 @@ async function collectDiagnosticsWithTimeout(recorder, options, timeoutMs = DIAG
 }
 
 // ../lite/dist/runtime.js
-function jsonResponse2(body, init) {
+function jsonResponse3(body, init) {
   const headers = new Headers(init?.headers);
   headers.set("Content-Type", "application/json");
   return new Response(JSON.stringify(body), { ...init, headers });
 }
 function protocolErrorResponse2(err2) {
-  return jsonResponse2(err2.toJSON(), { status: err2.code });
+  return jsonResponse3(err2.toJSON(), { status: err2.code });
 }
-function errorResponse2(status2, errorCode, message) {
-  return jsonResponse2({
+function errorResponse3(status2, errorCode, message) {
+  return jsonResponse3({
     error: {
       code: status2,
       errorCode,
@@ -127138,7 +129066,7 @@ function errorResponse2(status2, errorCode, message) {
   }, { status: status2 });
 }
 function mcpUnauthorized(origin, message = "MCP authorization required") {
-  return jsonResponse2({
+  return jsonResponse3({
     error: {
       code: 401,
       errorCode: "MCP_AUTH_REQUIRED",
@@ -127187,7 +129115,7 @@ function redirectWithOAuthError(redirectUri, error51, description, state) {
       url2.searchParams.set("state", state);
     return Response.redirect(url2.toString(), 302);
   } catch {
-    return jsonResponse2({
+    return jsonResponse3({
       error: error51,
       error_description: description,
       ...state ? { state } : {}
@@ -127393,11 +129321,11 @@ function createPsLiteRuntime(options) {
       if (err2 instanceof ProtocolError) {
         return protocolErrorResponse2(err2);
       }
-      return errorResponse2(500, "INTERNAL_ERROR", "Internal server error");
+      return errorResponse3(500, "INTERNAL_ERROR", "Internal server error");
     }
   }
   function sendContractResult(result) {
-    return jsonResponse2(result.body, { status: result.status });
+    return jsonResponse3(result.body, { status: result.status });
   }
   function ownerAddress() {
     return options.serverOwner ?? options.identity?.address;
@@ -127405,7 +129333,7 @@ function createPsLiteRuntime(options) {
   async function handleAuthDevice(request2, url2) {
     if (url2.pathname === "/auth/device") {
       if (request2.method !== "POST") {
-        return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+        return errorResponse3(405, "METHOD_NOT_ALLOWED", "Method not allowed");
       }
       return sendContractResult(initiateDeviceSessionContract({
         sessionStore: deviceSessions,
@@ -127419,7 +129347,7 @@ function createPsLiteRuntime(options) {
     }
     if (url2.pathname === "/auth/device/poll") {
       if (request2.method !== "GET") {
-        return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+        return errorResponse3(405, "METHOD_NOT_ALLOWED", "Method not allowed");
       }
       return sendContractResult(pollDeviceSessionContract({
         sessionStore: deviceSessions,
@@ -127431,11 +129359,11 @@ function createPsLiteRuntime(options) {
     if (url2.pathname === "/auth/device/approve") {
       const sessionId = url2.searchParams.get("session");
       if (!sessionId) {
-        return request2.method === "GET" ? new Response("Missing session parameter", { status: 400 }) : jsonResponse2({ error: { code: 400, message: "Missing session parameter" } }, { status: 400 });
+        return request2.method === "GET" ? new Response("Missing session parameter", { status: 400 }) : jsonResponse3({ error: { code: 400, message: "Missing session parameter" } }, { status: 400 });
       }
       const session = deviceSessions.get(sessionId);
       if (!session) {
-        return request2.method === "GET" ? new Response("Session expired or invalid", { status: 404 }) : jsonResponse2({ error: { code: 404, message: "Session expired or invalid" } }, { status: 404 });
+        return request2.method === "GET" ? new Response("Session expired or invalid", { status: 404 }) : jsonResponse3({ error: { code: 404, message: "Session expired or invalid" } }, { status: 404 });
       }
       if (request2.method === "GET") {
         return new Response("Device authorization pending", {
@@ -127443,10 +129371,10 @@ function createPsLiteRuntime(options) {
         });
       }
       if (request2.method !== "POST") {
-        return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+        return errorResponse3(405, "METHOD_NOT_ALLOWED", "Method not allowed");
       }
       if (session.status === "approved") {
-        return jsonResponse2({ status: "already_approved" });
+        return jsonResponse3({ status: "already_approved" });
       }
       await auth.authorizeOwner(request2);
       return sendContractResult(await approveDeviceSessionContract({
@@ -127462,7 +129390,7 @@ function createPsLiteRuntime(options) {
       if (request2.method === "DELETE") {
         const token2 = bearerToken(request2);
         if (!token2) {
-          return jsonResponse2({ error: { code: 401, message: "Missing Bearer token" } }, { status: 401 });
+          return jsonResponse3({ error: { code: 401, message: "Missing Bearer token" } }, { status: 401 });
         }
         return sendContractResult(await revokeDeviceTokenContract({
           tokenStore,
@@ -127470,11 +129398,11 @@ function createPsLiteRuntime(options) {
         }));
       }
       if (request2.method !== "POST") {
-        return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+        return errorResponse3(405, "METHOD_NOT_ALLOWED", "Method not allowed");
       }
       const token = bearerToken(request2);
       if (!options.accessToken || token !== options.accessToken) {
-        return jsonResponse2({
+        return jsonResponse3({
           error: {
             code: 403,
             message: "Only control-plane tokens can provision Personal Server session tokens"
@@ -127485,10 +129413,10 @@ function createPsLiteRuntime(options) {
       try {
         body = await request2.json();
       } catch {
-        return jsonResponse2({ error: { code: 400, message: "Request body must be valid JSON" } }, { status: 400 });
+        return jsonResponse3({ error: { code: 400, message: "Request body must be valid JSON" } }, { status: 400 });
       }
       if (!body.token || typeof body.token !== "string") {
-        return jsonResponse2({ error: { code: 400, message: "Missing token" } }, { status: 400 });
+        return jsonResponse3({ error: { code: 400, message: "Missing token" } }, { status: 400 });
       }
       return sendContractResult(await provisionDeviceTokenContract({
         tokenStore,
@@ -127504,10 +129432,12 @@ function createPsLiteRuntime(options) {
     activate() {
       active = true;
       options.syncManager?.start?.();
+      options.derivatives?.scheduler.start();
     },
     deactivate() {
       active = false;
       void options.syncManager?.stop?.();
+      options.derivatives?.scheduler.stop();
     },
     isAvailable() {
       return active;
@@ -127541,7 +129471,7 @@ function createPsLiteRuntime(options) {
             accessLogs: accessLogReader.capabilities?.accessLogs ?? "custom",
             config: options.stateCapabilities?.config ?? (options.saveConfig ? "custom" : "indexeddb")
           };
-          return jsonResponse2({
+          return jsonResponse3({
             status: active ? "healthy" : "unavailable",
             runtime: "ps-lite",
             storage: options.storage.kind,
@@ -127559,7 +129489,7 @@ function createPsLiteRuntime(options) {
         }
         if (url2.pathname === "/v1/diagnostics") {
           if (request2.method !== "GET") {
-            return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+            return errorResponse3(405, "METHOD_NOT_ALLOWED", "Method not allowed");
           }
           try {
             await auth.authorizeOwner(request2);
@@ -127570,7 +129500,7 @@ function createPsLiteRuntime(options) {
             throw err2;
           }
           if (!options.diagnostics) {
-            return jsonResponse2({
+            return jsonResponse3({
               error: {
                 code: 404,
                 errorCode: "DIAGNOSTICS_NOT_CONFIGURED",
@@ -127584,7 +129514,7 @@ function createPsLiteRuntime(options) {
             syncStatus: syncStatus2,
             storage: dataStorage
           });
-          return jsonResponse2(snapshot);
+          return jsonResponse3(snapshot);
         }
         if (!active) {
           return unavailableResponse();
@@ -127598,6 +129528,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
@@ -127618,9 +129549,16 @@ function createPsLiteRuntime(options) {
             // serverOwner is absent the accessRecord is safely omitted.
             serverOwner: options.serverOwner,
             serverSigner: x402ServerSigner,
-            lineageGateway: options.lineageGateway
+            lineageGateway: options.lineageGateway,
+            // Recompute on refresh: a new local version marks every
+            // question that reads the scope stale.
+            onDataWritten: options.derivatives ? (event) => options.derivatives?.scheduler.markSourceChanged(event.scope, { lineageSources: event.lineageSources }) : void 0
           }, { basePath: dataPrefix });
         }
+        const derivativesPrefix = "/v1/derivatives";
+        if (url2.pathname.startsWith(`${derivativesPrefix}/`)) {
+          return handlePersonalServerDerivativesRequest(request2, { auth, compute: options.derivatives ?? null, now }, { basePath: derivativesPrefix });
+        }
         if (url2.pathname.startsWith("/auth/device")) {
           const response = await handleAuthDevice(request2, url2);
           if (response)
@@ -127709,7 +129647,7 @@ function createPsLiteRuntime(options) {
           if (mcpResponse)
             return mcpResponse;
         }
-        return errorResponse2(404, "NOT_FOUND", "Not found");
+        return errorResponse3(404, "NOT_FOUND", "Not found");
       });
     }
   };
@@ -127720,22 +129658,22 @@ async function handleMcpRoute(input) {
   const ownerAuthorizationPrefix = "/v1/mcp/oauth/authorizations";
   if (pathname === "/.well-known/oauth-protected-resource/mcp") {
     if (!resolveMcpApprovalUrl(input.approvalUrl)) {
-      return errorResponse2(404, "MCP_OAUTH_NOT_CONFIGURED", "MCP OAuth is not configured");
+      return errorResponse3(404, "MCP_OAUTH_NOT_CONFIGURED", "MCP OAuth is not configured");
     }
-    return jsonResponse2(protectedResourceMetadata(input.serverOrigin));
+    return jsonResponse3(protectedResourceMetadata(input.serverOrigin));
   }
   if (pathname === "/.well-known/oauth-authorization-server") {
     if (!resolveMcpApprovalUrl(input.approvalUrl)) {
-      return errorResponse2(404, "MCP_OAUTH_NOT_CONFIGURED", "MCP OAuth is not configured");
+      return errorResponse3(404, "MCP_OAUTH_NOT_CONFIGURED", "MCP OAuth is not configured");
     }
-    return jsonResponse2(authorizationServerMetadata(input.serverOrigin));
+    return jsonResponse3(authorizationServerMetadata(input.serverOrigin));
   }
   if (pathname === "/mcp/oauth/register") {
     if (!resolveMcpApprovalUrl(input.approvalUrl)) {
-      return errorResponse2(404, "MCP_OAUTH_NOT_CONFIGURED", "MCP OAuth is not configured");
+      return errorResponse3(404, "MCP_OAUTH_NOT_CONFIGURED", "MCP OAuth is not configured");
     }
     if (input.request.method !== "POST") {
-      return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+      return errorResponse3(405, "METHOD_NOT_ALLOWED", "Method not allowed");
     }
     let body = {};
     try {
@@ -127743,7 +129681,7 @@ async function handleMcpRoute(input) {
     } catch {
       body = {};
     }
-    return jsonResponse2({
+    return jsonResponse3({
       client_id: `mcp-client-${crypto.randomUUID()}`,
       client_name: body.client_name ?? "Claude",
       redirect_uris: Array.isArray(body.redirect_uris) ? body.redirect_uris : [],
@@ -127754,10 +129692,10 @@ async function handleMcpRoute(input) {
   }
   if (pathname === "/mcp/oauth/authorize") {
     if (!resolveMcpApprovalUrl(input.approvalUrl)) {
-      return errorResponse2(404, "MCP_OAUTH_NOT_CONFIGURED", "MCP OAuth is not configured");
+      return errorResponse3(404, "MCP_OAUTH_NOT_CONFIGURED", "MCP OAuth is not configured");
     }
     if (input.request.method !== "GET") {
-      return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+      return errorResponse3(405, "METHOD_NOT_ALLOWED", "Method not allowed");
     }
     const responseType = input.url.searchParams.get("response_type");
     const clientId = input.url.searchParams.get("client_id") ?? "";
@@ -127785,7 +129723,7 @@ async function handleMcpRoute(input) {
       });
       const approvalUrl = resolveMcpApprovalUrl(input.approvalUrl);
       if (!approvalUrl) {
-        return errorResponse2(500, "MCP_APPROVAL_URL_MISSING", "MCP OAuth approval URL is not configured");
+        return errorResponse3(500, "MCP_APPROVAL_URL_MISSING", "MCP OAuth approval URL is not configured");
       }
       const approve = new URL(approvalUrl);
       approve.searchParams.set("mcp_authorization", created.authorizationId);
@@ -127798,14 +129736,14 @@ async function handleMcpRoute(input) {
   }
   if (pathname === "/mcp/oauth/token") {
     if (!resolveMcpApprovalUrl(input.approvalUrl)) {
-      return errorResponse2(404, "MCP_OAUTH_NOT_CONFIGURED", "MCP OAuth is not configured");
+      return errorResponse3(404, "MCP_OAUTH_NOT_CONFIGURED", "MCP OAuth is not configured");
     }
     if (input.request.method !== "POST") {
-      return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+      return errorResponse3(405, "METHOD_NOT_ALLOWED", "Method not allowed");
     }
     const body = await parseFormBody(input.request);
     if (body.get("grant_type") !== "authorization_code") {
-      return jsonResponse2({
+      return jsonResponse3({
         error: "unsupported_grant_type",
         error_description: "Only authorization_code is supported"
       }, { status: 400 });
@@ -127821,13 +129759,13 @@ async function handleMcpRoute(input) {
         connectionStore: input.store,
         now: input.now
       });
-      return jsonResponse2({
+      return jsonResponse3({
         access_token: token.accessToken,
         token_type: "Bearer",
         ...token.scope ? { scope: token.scope } : {}
       });
     } catch (err2) {
-      return jsonResponse2({
+      return jsonResponse3({
         error: err2 instanceof McpOAuthAuthorizationError ? err2.code : "invalid_grant",
         error_description: err2 instanceof Error ? err2.message : String(err2)
       }, { status: 400 });
@@ -127845,28 +129783,28 @@ async function handleMcpRoute(input) {
     const tail = pathname.slice(ownerAuthorizationPrefix.length + 1);
     const [id2, action] = tail.split("/");
     if (!id2) {
-      return errorResponse2(404, "NOT_FOUND", "Not found");
+      return errorResponse3(404, "NOT_FOUND", "Not found");
     }
     if (!action && input.request.method === "GET") {
       const record2 = await input.authorizationStore.getById(id2);
       if (!record2) {
-        return errorResponse2(404, "NOT_FOUND", "Authorization not found");
+        return errorResponse3(404, "NOT_FOUND", "Authorization not found");
       }
-      return jsonResponse2(toMcpOAuthAuthorizationView(record2));
+      return jsonResponse3(toMcpOAuthAuthorizationView(record2));
     }
     if (action === "approve") {
       if (input.request.method !== "POST") {
-        return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+        return errorResponse3(405, "METHOD_NOT_ALLOWED", "Method not allowed");
       }
       let body = {};
       try {
         body = await input.request.json();
       } catch {
-        return errorResponse2(400, "INVALID_BODY", "Body must be JSON");
+        return errorResponse3(400, "INVALID_BODY", "Body must be JSON");
       }
       if (Array.isArray(body.scopes) && body.scopes.length > 0) {
         if (!input.gateway || !input.gatewayConfig?.url) {
-          return errorResponse2(500, "SERVER_NOT_CONFIGURED", "Gateway config is not configured");
+          return errorResponse3(500, "SERVER_NOT_CONFIGURED", "Gateway config is not configured");
         }
         try {
           const approved = await approveMcpOAuthAuthorizationWithScopes({
@@ -127884,16 +129822,16 @@ async function handleMcpRoute(input) {
             serverSigner: input.serverSigner,
             now: input.now
           });
-          return jsonResponse2({ redirectTo: approved.redirectTo });
+          return jsonResponse3({ redirectTo: approved.redirectTo });
         } catch (err2) {
           if (err2 instanceof McpOAuthAuthorizationError) {
-            return errorResponse2(err2.status, err2.code, err2.message);
+            return errorResponse3(err2.status, err2.code, err2.message);
           }
           throw err2;
         }
       }
       if (!Array.isArray(body.grants) || body.grants.length === 0) {
-        return errorResponse2(400, "GRANTS_REQUIRED", "Approve requires grants or scopes");
+        return errorResponse3(400, "GRANTS_REQUIRED", "Approve requires grants or scopes");
       }
       try {
         const approved = await approveMcpOAuthAuthorization({ authorizationId: id2, grants: body.grants }, {
@@ -127901,15 +129839,15 @@ async function handleMcpRoute(input) {
           authorizationStore: input.authorizationStore,
           now: input.now
         });
-        return jsonResponse2({ redirectTo: approved.redirectTo });
+        return jsonResponse3({ redirectTo: approved.redirectTo });
       } catch (err2) {
         if (err2 instanceof McpOAuthAuthorizationError) {
-          return errorResponse2(err2.status, err2.code, err2.message);
+          return errorResponse3(err2.status, err2.code, err2.message);
         }
         throw err2;
       }
     }
-    return errorResponse2(404, "NOT_FOUND", "Not found");
+    return errorResponse3(404, "NOT_FOUND", "Not found");
   }
   if (pathname === ownerPrefix || pathname.startsWith(`${ownerPrefix}/`)) {
     try {
@@ -127933,41 +129871,41 @@ async function handleMcpRoute(input) {
           publicOrigin: input.serverOrigin,
           now: input.now
         });
-        return jsonResponse2(created, { status: 201 });
+        return jsonResponse3(created, { status: 201 });
       }
       if (input.request.method === "GET") {
         const records = await listMcpConnectionViews(input.store);
-        return jsonResponse2({ connections: records });
+        return jsonResponse3({ connections: records });
       }
-      return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+      return errorResponse3(405, "METHOD_NOT_ALLOWED", "Method not allowed");
     }
     const tail = pathname.slice(ownerPrefix.length + 1);
     const [id2, action] = tail.split("/");
     if (!id2) {
-      return errorResponse2(404, "NOT_FOUND", "Not found");
+      return errorResponse3(404, "NOT_FOUND", "Not found");
     }
     if (action === "approve") {
       if (input.request.method !== "POST") {
-        return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+        return errorResponse3(405, "METHOD_NOT_ALLOWED", "Method not allowed");
       }
       let body = {};
       try {
         body = await input.request.json();
       } catch {
-        return errorResponse2(400, "INVALID_BODY", "Body must be JSON");
+        return errorResponse3(400, "INVALID_BODY", "Body must be JSON");
       }
       if (!Array.isArray(body.grants) || body.grants.length === 0) {
-        return errorResponse2(400, "GRANTS_REQUIRED", "Approve requires at least one grant \u2014 mint grants in the consent flow first");
+        return errorResponse3(400, "GRANTS_REQUIRED", "Approve requires at least one grant \u2014 mint grants in the consent flow first");
       }
       try {
         const updated = await approveMcpConnection({ connectionId: id2, grants: body.grants }, { store: input.store, now: input.now });
-        return jsonResponse2(toMcpConnectionView(updated));
+        return jsonResponse3(toMcpConnectionView(updated));
       } catch (err2) {
         if (err2 instanceof McpConnectionNotFoundError) {
-          return errorResponse2(404, "NOT_FOUND", err2.message);
+          return errorResponse3(404, "NOT_FOUND", err2.message);
         }
         if (err2 instanceof McpConnectionStateError) {
-          return errorResponse2(409, "INVALID_STATE", err2.message);
+          return errorResponse3(409, "INVALID_STATE", err2.message);
         }
         throw err2;
       }
@@ -127979,22 +129917,22 @@ async function handleMcpRoute(input) {
             store: input.store,
             now: input.now
           });
-          return jsonResponse2(toMcpConnectionView(updated));
+          return jsonResponse3(toMcpConnectionView(updated));
         } catch (err2) {
           if (err2 instanceof McpConnectionNotFoundError) {
-            return errorResponse2(404, "NOT_FOUND", err2.message);
+            return errorResponse3(404, "NOT_FOUND", err2.message);
           }
           throw err2;
         }
       }
-      return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+      return errorResponse3(405, "METHOD_NOT_ALLOWED", "Method not allowed");
     }
-    return errorResponse2(404, "NOT_FOUND", "Not found");
+    return errorResponse3(404, "NOT_FOUND", "Not found");
   }
   async function handleMcpToken(rawToken, options) {
     if (!rawToken) {
       if (!options.oauthChallenge) {
-        return errorResponse2(401, "INVALID_TOKEN", "Missing MCP connection token");
+        return errorResponse3(401, "INVALID_TOKEN", "Missing MCP connection token");
       }
       return mcpUnauthorized(input.serverOrigin);
     }
@@ -128002,7 +129940,7 @@ async function handleMcpRoute(input) {
     const record2 = await input.store.getByTokenHash(tokenHash);
     if (!record2) {
       if (!options.oauthChallenge) {
-        return errorResponse2(401, "INVALID_TOKEN", "Unknown or revoked MCP connection");
+        return errorResponse3(401, "INVALID_TOKEN", "Unknown or revoked MCP connection");
       }
       return mcpUnauthorized(input.serverOrigin, "Unknown or revoked MCP connection");
     }
@@ -128046,10 +129984,10 @@ async function handleMcpRoute(input) {
       throw err2;
     }
     if (input.request.method !== "GET") {
-      return errorResponse2(405, "METHOD_NOT_ALLOWED", "Method not allowed");
+      return errorResponse3(405, "METHOD_NOT_ALLOWED", "Method not allowed");
     }
     const snapshot = input.activityRecorder ? input.activityRecorder.snapshot() : { events: [], running: 0, total: 0 };
-    return jsonResponse2(snapshot);
+    return jsonResponse3(snapshot);
   }
   if (pathname === "/mcp") {
     return handleMcpToken(bearerToken(input.request), {
@@ -128060,7 +129998,7 @@ async function handleMcpRoute(input) {
   if (pathname.startsWith(mcpPrefix)) {
     const rawToken = decodeURIComponent(pathname.slice(mcpPrefix.length));
     if (!rawToken || rawToken.includes("/")) {
-      return errorResponse2(404, "NOT_FOUND", "Not found");
+      return errorResponse3(404, "NOT_FOUND", "Not found");
     }
     return handleMcpToken(rawToken, { oauthChallenge: false });
   }
@@ -128074,6 +130012,45 @@ var OrphanedEntryError = class extends Error {
     this.name = "OrphanedEntryError";
   }
 };
+var DeletedScopeEntryError = class extends Error {
+  constructor(path, deletedAt) {
+    super(`Dropped local entry for a scope deleted at ${deletedAt}: ${path}`);
+    this.name = "DeletedScopeEntryError";
+  }
+};
+async function dropIfCoveredByDeletion(deps, entry, tombstone, deletedAt, uploaded) {
+  const version4 = tombstoneVersion(tombstone);
+  if (!isEntryCoveredByTombstone(entry, { version: version4 }))
+    return;
+  if (uploaded) {
+    try {
+      await deps.storageAdapter.delete(uploaded.url);
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : String(err2);
+      if (deps.pendingBlobDeletions) {
+        await deps.pendingBlobDeletions.add([
+          { scope: entry.scope, version: String(entry.version) }
+        ]);
+      }
+      deps.logger.warn({
+        scope: entry.scope,
+        url: uploaded.url,
+        error: message,
+        queuedForCleanup: Boolean(deps.pendingBlobDeletions)
+      }, "Could not delete the ciphertext uploaded for an entry the tombstone covers");
+    }
+  }
+  await deps.storage.deleteVersion(entry.scope, entry.collectedAt);
+  deps.logger.warn({
+    path: entry.path,
+    scope: entry.scope,
+    deletedAt,
+    tombstoneVersion: version4,
+    entryVersion: entry.version,
+    afterTombstoneVersion: entry.afterTombstoneVersion ?? null
+  }, "Dropped unsynced local entry: the gateway reports its scope as deleted");
+  throw new DeletedScopeEntryError(entry.path, deletedAt);
+}
 function isMissingPayloadError(err2) {
   return err2 instanceof Error && err2.code === "ENOENT";
 }
@@ -128092,6 +130069,20 @@ async function uploadOne(deps, entry) {
     }
     throw err2;
   }
+  let registerVersion = BigInt(entry.version);
+  if (!entry.dataPointId && deps.dataPointFeed) {
+    const remote = await deps.dataPointFeed.getDataPoint({
+      ownerAddress: serverOwner,
+      scope: entry.scope
+    });
+    const deletedAt = deletionTimestamp(remote);
+    if (remote && deletedAt !== null) {
+      await dropIfCoveredByDeletion(deps, entry, remote, deletedAt);
+      const afterTombstone = BigInt(remote.expectedVersion) + 1n;
+      if (afterTombstone > registerVersion)
+        registerVersion = afterTombstone;
+    }
+  }
   const scopeKey = deriveScopeKey(masterKey, entry.scope);
   const scopeKeyHex = uint8ToHex(scopeKey);
   const plaintext = new TextEncoder().encode(JSON.stringify(envelope));
@@ -128102,7 +130093,7 @@ async function uploadOne(deps, entry) {
     collectedAt: entry.collectedAt,
     sizeBytes: encrypted.byteLength
   })));
-  const storageKey = `${entry.scope}/${entry.version}`;
+  const storageKey = `${entry.scope}/${registerVersion}`;
   let url2 = await storageAdapter.upload(storageKey, encrypted);
   let dataPointId;
   if (entry.dataPointId) {
@@ -128152,11 +130143,23 @@ async function uploadOne(deps, entry) {
       return id2;
     };
     try {
-      dataPointId = await registerAt(BigInt(entry.version));
+      dataPointId = await registerAt(registerVersion);
+      if (registerVersion !== BigInt(entry.version)) {
+        await storage.updateEntryVersion(entry.path, Number(registerVersion));
+      }
     } catch (err2) {
       if (!isStaleVersionConflict(err2))
         throw err2;
-      const record2 = await gateway.getDataPoint(computeDataPointId(serverOwner, entry.scope));
+      const record2 = deps.dataPointFeed ? await deps.dataPointFeed.getDataPoint({
+        ownerAddress: serverOwner,
+        scope: entry.scope
+      }) : await gateway.getDataPoint(computeDataPointId(serverOwner, entry.scope));
+      const conflictDeletedAt = record2 ? deletionTimestamp(record2) : null;
+      if (record2 && conflictDeletedAt !== null) {
+        await dropIfCoveredByDeletion(deps, entry, record2, conflictDeletedAt, {
+          url: url2
+        });
+      }
       if (record2 && record2.dataHash.toLowerCase() === dataHash.toLowerCase()) {
         dataPointId = record2.id;
         const adoptedVersion = Number(record2.expectedVersion);
@@ -128182,6 +130185,7 @@ async function uploadOne(deps, entry) {
       }
     }
     await storage.updateDataPointId(entry.path, dataPointId);
+    deps.scopeDeletions?.markLive(entry.scope);
   }
   logger.info({
     path: entry.path,
@@ -128201,7 +130205,7 @@ async function uploadAll(deps, options) {
       const result = await uploadOne(deps, entry);
       results.push(result);
     } catch (err2) {
-      if (err2 instanceof OrphanedEntryError) {
+      if (err2 instanceof OrphanedEntryError || err2 instanceof DeletedScopeEntryError) {
         continue;
       }
       const error51 = err2;
@@ -128230,6 +130234,101 @@ function parseGatewayNextVersion(message) {
   return null;
 }
 
+// ../core/dist/sync/data-point-feed.js
+function createGatewayDataPointFeed(options) {
+  const base = options.gatewayUrl.replace(/\/+$/, "");
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  return {
+    async listDataPointsByOwner(owner, cursor, listOptions) {
+      const params = new URLSearchParams({ user: owner });
+      if (cursor !== null)
+        params.set("cursor", cursor);
+      if (listOptions?.since)
+        params.set("since", listOptions.since);
+      if (listOptions?.limit !== void 0) {
+        params.set("limit", String(listOptions.limit));
+      }
+      if (listOptions?.includeDeleted)
+        params.set("includeDeleted", "true");
+      const res = await fetchImpl(`${base}/v1/data?${params.toString()}`);
+      if (!res.ok) {
+        throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
+      }
+      const envelope = await res.json();
+      const nextCursor = envelope.pagination?.hasMore === false ? null : envelope.pagination?.nextCursor ?? null;
+      const rows = envelope.data?.dataPoints ?? [];
+      return {
+        dataPoints: rows.map((row) => normalizeRecord(row)),
+        cursor: nextCursor
+      };
+    },
+    async getDataPoint(input) {
+      const dataPointId = computeDataPointId(input.ownerAddress, input.scope);
+      const res = await fetchImpl(`${base}/v1/data/${dataPointId}?includeDeleted=true`);
+      if (res.status === 404)
+        return null;
+      if (res.status === 410) {
+        const body2 = await res.json().catch(() => null);
+        const echoed = unwrap(body2);
+        const deletedAt = stringField(echoed, "deletedAt") ?? now().toISOString();
+        return {
+          id: dataPointId,
+          ownerAddress: input.ownerAddress,
+          scope: input.scope,
+          dataHash: stringField(echoed, "dataHash") ?? TOMBSTONE_DATA_HASH,
+          metadataHash: stringField(echoed, "metadataHash") ?? TOMBSTONE_METADATA_HASH,
+          expectedVersion: stringField(echoed, "expectedVersion") ?? "0",
+          addedAt: stringField(echoed, "addedAt") ?? deletedAt,
+          deletedAt
+        };
+      }
+      if (!res.ok) {
+        throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
+      }
+      const body = await res.json();
+      return normalizeRecord(unwrap(body));
+    }
+  };
+}
+function unwrap(body) {
+  if (typeof body !== "object" || body === null)
+    return null;
+  const record2 = body;
+  if (typeof record2.data === "object" && record2.data !== null) {
+    return record2.data;
+  }
+  return record2;
+}
+function stringField(record2, key) {
+  const value = record2?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function normalizeRecord(row) {
+  const record2 = row ?? {};
+  const deletedAt = record2.deletedAt;
+  return {
+    ...record2,
+    deletedAt: typeof deletedAt === "string" ? deletedAt : null
+  };
+}
+function feedFromGatewayClient(gateway) {
+  return {
+    async listDataPointsByOwner(owner, cursor, listOptions) {
+      const { includeDeleted: _includeDeleted, ...sdkOptions } = listOptions ?? {};
+      const result = Object.keys(sdkOptions).length > 0 ? await gateway.listDataPointsByOwner(owner, cursor, sdkOptions) : await gateway.listDataPointsByOwner(owner, cursor);
+      return {
+        dataPoints: result.dataPoints.map((row) => normalizeRecord(row)),
+        cursor: result.cursor
+      };
+    },
+    async getDataPoint(input) {
+      const row = await gateway.getDataPoint(computeDataPointId(input.ownerAddress, input.scope));
+      return row === null ? null : normalizeRecord(row);
+    }
+  };
+}
+
 // ../core/dist/sync/issues.js
 var DETERMINISTIC_STAGES = /* @__PURE__ */ new Set([
   "openpgp_parse",
@@ -128546,6 +130645,24 @@ async function downloadOne(deps, record2) {
   }
   diagnostics?.onIndexEnd(record2.id, envelope.scope);
   logger.info({ dataPointId: record2.id, scope: envelope.scope, path: relativePath }, "Downloaded and indexed data point");
+  if (deps.onDataPointIndexed) {
+    try {
+      let lineageSources;
+      try {
+        lineageSources = readStoredLineage(envelope.data)?.sources;
+      } catch {
+      }
+      deps.onDataPointIndexed({
+        scope: envelope.scope,
+        dataPointId: record2.id,
+        version: Number(record2.expectedVersion),
+        collectedAt: envelope.collectedAt,
+        lineageSources
+      });
+    } catch (err2) {
+      logger.warn({ scope: envelope.scope, error: err2.message }, "onDataPointIndexed hook failed; data point already indexed");
+    }
+  }
   return {
     dataPointId: record2.id,
     scope: envelope.scope,
@@ -128567,10 +130684,43 @@ async function downloadAll(deps, options = {}) {
   if (options.fullReconcile || repairSummary.missingEnvelopeEntries > 0) {
     options.retryMemory?.onListingReset();
   }
-  const { dataPoints, cursor: nextCursor } = await gateway.listDataPointsByOwner(serverOwner, lastCursor);
+  const feed = deps.dataPointFeed ?? feedFromGatewayClient(gateway);
+  const { dataPoints, cursor: nextCursor } = await feed.listDataPointsByOwner(serverOwner, lastCursor, { includeDeleted: true });
+  if (deps.scopeDeletions) {
+    for (const dataPoint of dataPoints) {
+      const deletedAt = deletionTimestamp(dataPoint);
+      if (deletedAt !== null) {
+        deps.scopeDeletions.markDeleted(dataPoint.scope, {
+          deletedAt,
+          version: tombstoneVersion(dataPoint)
+        });
+      } else {
+        deps.scopeDeletions.markLive(dataPoint.scope);
+      }
+    }
+    if (nextCursor === null) {
+      deps.scopeDeletions.noteFeedSynced(void 0, {
+        full: lastCursor === null
+      });
+    }
+  }
   const results = [];
   let failed = false;
   for (const dataPoint of dataPoints) {
+    const deletedAt = deletionTimestamp(dataPoint);
+    if (deletedAt !== null) {
+      try {
+        await reconcileDeletedDataPoint(deps, dataPoint, deletedAt);
+      } catch (err2) {
+        logger.error({
+          dataPointId: dataPoint.id,
+          scope: dataPoint.scope,
+          error: err2.message
+        }, "Failed to reconcile deleted data point locally");
+        failed = true;
+      }
+      continue;
+    }
     const retryKey = downloadRetryKey(dataPoint);
     const decision = options.retryMemory?.decide(retryKey) ?? "attempt";
     if (decision === "give-up") {
@@ -128626,6 +130776,49 @@ async function downloadAll(deps, options = {}) {
   }
   return results;
 }
+async function reconcileDeletedDataPoint(deps, record2, deletedAt) {
+  const tombstone = { version: tombstoneVersion(record2) };
+  const tombstoned = tombstone.version === null ? null : BigInt(tombstone.version);
+  const orphanKeys = [];
+  const { storage, logger } = deps;
+  const PAGE_SIZE = 500;
+  const stale = [];
+  let kept = 0;
+  for (let offset = 0; ; offset += PAGE_SIZE) {
+    const entries = storage.listVersions(record2.scope, {
+      limit: PAGE_SIZE,
+      offset
+    });
+    for (const entry of entries) {
+      if (isEntryCoveredByTombstone(entry, tombstone)) {
+        stale.push({ scope: entry.scope, collectedAt: entry.collectedAt });
+        if (entry.dataPointId === null && (tombstoned === null || BigInt(entry.version) > tombstoned)) {
+          orphanKeys.push({
+            scope: entry.scope,
+            version: String(entry.version)
+          });
+        }
+      } else {
+        kept += 1;
+      }
+    }
+    if (entries.length < PAGE_SIZE)
+      break;
+  }
+  let removed = 0;
+  for (const version4 of stale) {
+    if (await storage.deleteVersion(version4.scope, version4.collectedAt)) {
+      removed += 1;
+    }
+  }
+  if (orphanKeys.length > 0 && deps.pendingBlobDeletions) {
+    await deps.pendingBlobDeletions.add(orphanKeys);
+  }
+  if (removed > 0 || kept > 0) {
+    logger.info({ dataPointId: record2.id, scope: record2.scope, deletedAt, removed, kept }, "Reconciled gateway deletion against local index");
+  }
+  return { scope: record2.scope, deletedAt, removed, kept };
+}
 async function repairLocalMissingBlockSidecars(deps) {
   const { storage, logger, diagnostics } = deps;
   if (!storage.writeBlockManifest || !storage.hasScopeBlocks) {
@@ -128784,28 +130977,6 @@ async function repairMissingBlockSidecars(storage, logger, ctx, entry, diagnosti
   }
 }
 
-// ../core/dist/sync/workers/delete.js
-async function deleteScopeRemote(deps, scope) {
-  const { storage, logger } = deps;
-  let syncedVersions = 0;
-  const PAGE_SIZE = 1e3;
-  for (let offset = 0; ; offset += PAGE_SIZE) {
-    const entries = storage.listVersions(scope, { limit: PAGE_SIZE, offset });
-    syncedVersions += entries.filter((e10) => e10.dataPointId !== null).length;
-    if (entries.length < PAGE_SIZE)
-      break;
-  }
-  if (syncedVersions > 0) {
-    logger.warn({ scope, syncedVersions }, "Remote scope deletion is not supported on the DPv2 gateway (no de-registration endpoint); local data was removed but the remote data point(s) and ciphertext blob(s) remain");
-  }
-  return {
-    scope,
-    filesDeregistered: 0,
-    blobsDeleted: 0,
-    errors: []
-  };
-}
-
 // ../core/dist/sync/engine/sync-manager.js
 var MAX_ERRORS = 10;
 function createSyncManager(uploadDeps, downloadDeps, options) {
@@ -128823,12 +130994,28 @@ function createSyncManager(uploadDeps, downloadDeps, options) {
   let rerunRequested = false;
   let needsFullReconcile = true;
   const downloadRetryMemory = createDownloadRetryMemory();
+  const dataPointFeed = downloadDeps.dataPointFeed ?? uploadDeps.dataPointFeed;
+  const scopeDeletions = uploadDeps.scopeDeletions ?? downloadDeps.scopeDeletions;
+  const workerUploadDeps = {
+    ...uploadDeps,
+    pendingBlobDeletions: uploadDeps.pendingBlobDeletions ?? options?.pendingBlobDeletions
+  };
+  const workerDownloadDeps = {
+    ...downloadDeps,
+    pendingBlobDeletions: downloadDeps.pendingBlobDeletions ?? options?.pendingBlobDeletions
+  };
+  let mutationQueue = Promise.resolve();
+  function exclusive(operation) {
+    const run = mutationQueue.then(operation, operation);
+    mutationQueue = run.catch(() => void 0);
+    return run;
+  }
   async function runCycle() {
     if (cycleInFlight) {
       rerunRequested = true;
       return cycleInFlight;
     }
-    cycleInFlight = (async () => {
+    cycleInFlight = exclusive(async () => {
       do {
         rerunRequested = false;
         const canRun = await (options?.canSync?.() ?? { ok: true });
@@ -128839,7 +131026,19 @@ function createSyncManager(uploadDeps, downloadDeps, options) {
         }
         blocked = null;
         try {
-          const uploadResults = await uploadAll(uploadDeps, {
+          await retryPendingBlobDeletions({
+            deleteData: options?.deleteData,
+            pendingBlobDeletions: options?.pendingBlobDeletions,
+            dataPointFeed,
+            serverOwner: uploadDeps.serverOwner,
+            storage: uploadDeps.storage,
+            logger: uploadDeps.logger
+          });
+        } catch (err2) {
+          uploadDeps.logger.warn({ error: err2.message }, "Pending blob deletion retry failed");
+        }
+        try {
+          const uploadResults = await uploadAll(workerUploadDeps, {
             batchSize: uploadBatchSize,
             onError(entry, error51) {
               pushError({
@@ -128863,7 +131062,7 @@ function createSyncManager(uploadDeps, downloadDeps, options) {
         }
         try {
           const fullReconcile = needsFullReconcile;
-          const downloadResults = await downloadAll(downloadDeps, {
+          const downloadResults = await downloadAll(workerDownloadDeps, {
             fullReconcile,
             retryMemory: downloadRetryMemory
           });
@@ -128885,7 +131084,7 @@ function createSyncManager(uploadDeps, downloadDeps, options) {
         }
         lastSync = (/* @__PURE__ */ new Date()).toISOString();
       } while (rerunRequested && isRunning);
-    })();
+    });
     try {
       await cycleInFlight;
     } finally {
@@ -128974,13 +131173,291 @@ function createSyncManager(uploadDeps, downloadDeps, options) {
       uploadDeps.logger.debug("New data notification received");
       scheduleNotifiedCycle();
     },
-    async deleteScopeRemote(scope) {
-      await deleteScopeRemote(uploadDeps, scope);
+    deleteScope(scope) {
+      return exclusive(() => deleteScope({
+        storage: uploadDeps.storage,
+        serverOwner: uploadDeps.serverOwner,
+        deleteData: options?.deleteData,
+        pendingBlobDeletions: options?.pendingBlobDeletions,
+        scopeDeletions,
+        dataPointFeed,
+        logger: uploadDeps.logger
+      }, scope));
     }
   };
   return manager;
 }
 
+// ../core/dist/sync/delete-data-port.js
+function createGatewayDeleteDataPort(options) {
+  const gatewayBase = options.gatewayUrl.replace(/\/+$/, "");
+  const storageBase = options.storage.endpoint.replace(/\/+$/, "");
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const owner = options.serverOwner.toLowerCase();
+  async function sendTombstone(scope, dataPointId, version4) {
+    const signature = await options.signer.signAddData({
+      ownerAddress: options.serverOwner,
+      scope,
+      dataHash: TOMBSTONE_DATA_HASH,
+      metadataHash: TOMBSTONE_METADATA_HASH,
+      expectedVersion: version4
+    });
+    return fetchImpl(`${gatewayBase}/v1/data/${dataPointId}`, {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Web3Signed ${signature}`
+      },
+      body: JSON.stringify({
+        ownerAddress: options.serverOwner,
+        scope,
+        expectedVersion: String(version4),
+        signature
+      })
+    });
+  }
+  return {
+    async tombstone(scope) {
+      const dataPointId = computeDataPointId(options.serverOwner, scope);
+      const current = await options.dataPointFeed.getDataPoint({
+        ownerAddress: options.serverOwner,
+        scope
+      });
+      if (current === null) {
+        return { status: "not-registered", dataPointId };
+      }
+      if (current.deletedAt !== null) {
+        return {
+          status: "already-deleted",
+          dataPointId,
+          version: current.expectedVersion,
+          deletedAt: current.deletedAt
+        };
+      }
+      let version4 = BigInt(current.expectedVersion) + 1n;
+      let res = await sendTombstone(scope, dataPointId, version4);
+      if (res.status === 409) {
+        const body2 = await res.json().catch(() => null);
+        const conflict = unwrap2(body2);
+        const nextExplicit = integerField(conflict, "nextExpectedVersion") ?? integerField(body2, "nextExpectedVersion");
+        const currentExpected = integerField(conflict, "currentExpectedVersion") ?? integerField(body2, "currentExpectedVersion");
+        const legacyNext = parseGatewayNextVersion(detailFromBody(body2, res.statusText));
+        const next = nextExplicit !== null ? nextExplicit : currentExpected !== null ? currentExpected + 1n : legacyNext !== null ? BigInt(legacyNext) : null;
+        if (next === null) {
+          throw new Error(`Gateway error: 409 ${detailFromBody(body2, res.statusText)}`);
+        }
+        version4 = next;
+        res = await sendTombstone(scope, dataPointId, version4);
+      }
+      if (res.status === 404) {
+        return { status: "not-registered", dataPointId };
+      }
+      if (res.status === 410) {
+        const body2 = await res.json().catch(() => null);
+        const echoed = unwrap2(body2);
+        let winning = normalizeVersionString(stringField2(echoed, "expectedVersion"));
+        let deletedAt = stringField2(echoed, "deletedAt");
+        if (winning === null) {
+          const reread = await options.dataPointFeed.getDataPoint({ ownerAddress: options.serverOwner, scope }).catch(() => null);
+          if (reread && reread.deletedAt !== null) {
+            winning = normalizeVersionString(reread.expectedVersion);
+            deletedAt = deletedAt ?? reread.deletedAt;
+          }
+        }
+        return {
+          status: "already-deleted",
+          dataPointId,
+          version: winning,
+          deletedAt
+        };
+      }
+      if (!res.ok) {
+        throw new Error(`Gateway error: ${res.status} ${await errorDetail(res)}`);
+      }
+      const body = await res.json().catch(() => null);
+      const row = unwrap2(body);
+      return {
+        status: "tombstoned",
+        dataPointId: stringField2(row, "dataPointId") ?? dataPointId,
+        version: stringField2(row, "expectedVersion") ?? String(version4),
+        deletedAt: stringField2(row, "deletedAt")
+      };
+    },
+    async deleteBlobVersions(scope, versions) {
+      const outcome = {
+        deleted: [],
+        missing: [],
+        failed: []
+      };
+      for (const version4 of versions) {
+        const path = `/v1/chains/${options.storage.chainId}/blobs/${owner}/${encodeURIComponent(scope)}/${encodeURIComponent(version4)}`;
+        try {
+          const authorization = await buildWeb3SignedHeader({
+            signMessage: (message) => options.storage.signMessage(message),
+            aud: storageBase,
+            method: "DELETE",
+            uri: path
+          });
+          const res = await fetchImpl(`${storageBase}${path}`, {
+            method: "DELETE",
+            headers: { authorization }
+          });
+          if (res.status === 404) {
+            outcome.missing.push(version4);
+          } else if (res.ok) {
+            outcome.deleted.push(version4);
+          } else {
+            outcome.failed.push({
+              version: version4,
+              error: `vana-storage delete failed: ${res.status} ${res.statusText}`
+            });
+          }
+        } catch (err2) {
+          outcome.failed.push({
+            version: version4,
+            error: err2 instanceof Error ? err2.message : String(err2)
+          });
+        }
+      }
+      return outcome;
+    }
+  };
+}
+async function errorDetail(res) {
+  const body = await res.json().catch(() => null);
+  return detailFromBody(body, res.statusText);
+}
+function detailFromBody(body, fallback) {
+  if (typeof body === "object" && body !== null) {
+    const record2 = body;
+    if (typeof record2.error === "string")
+      return record2.error;
+    if (typeof record2.message === "string")
+      return record2.message;
+    if (typeof record2.error === "object" && record2.error !== null) {
+      const nested = record2.error;
+      if (typeof nested.message === "string")
+        return nested.message;
+    }
+  }
+  return fallback;
+}
+function normalizeVersionString(value) {
+  if (value === null || !/^\d+$/.test(value))
+    return null;
+  const parsed = BigInt(value);
+  return parsed > 0n ? parsed.toString() : null;
+}
+function integerField(record2, key) {
+  if (typeof record2 !== "object" || record2 === null)
+    return null;
+  const value = record2[key];
+  if (typeof value === "number" && Number.isSafeInteger(value)) {
+    return BigInt(value);
+  }
+  if (typeof value === "string" && /^\d+$/.test(value))
+    return BigInt(value);
+  return null;
+}
+function unwrap2(body) {
+  if (typeof body !== "object" || body === null)
+    return null;
+  const record2 = body;
+  if (typeof record2.data === "object" && record2.data !== null) {
+    return record2.data;
+  }
+  return record2;
+}
+function stringField2(record2, key) {
+  const value = record2?.[key];
+  return typeof value === "string" ? value : null;
+}
+
+// ../core/dist/sync/pending-blob-deletions.js
+function markerId(key) {
+  const range = key.range ? `${key.range.from}-${key.range.to}` : "";
+  return `${key.scope}\0${key.version ?? ""}\0${range}`;
+}
+function normalizeRange(value) {
+  if (typeof value !== "object" || value === null)
+    return void 0;
+  const { from, to: to3 } = value;
+  if (typeof from !== "string" || typeof to3 !== "string" || !/^\d+$/.test(from) || !/^\d+$/.test(to3) || BigInt(from) > BigInt(to3)) {
+    return void 0;
+  }
+  return { from, to: to3 };
+}
+function normalizePendingBlobDeletions(stored) {
+  if (!Array.isArray(stored))
+    return [];
+  const keys = [];
+  for (const item of stored) {
+    if (typeof item === "string") {
+      keys.push({ scope: item, version: null });
+    } else if (typeof item === "object" && item !== null && typeof item.scope === "string") {
+      const version4 = item.version;
+      const range = typeof version4 === "string" ? void 0 : normalizeRange(item.range);
+      keys.push({
+        scope: item.scope,
+        version: typeof version4 === "string" ? version4 : null,
+        ...range ? { range } : {}
+      });
+    }
+  }
+  return keys;
+}
+function createPendingBlobDeletionStore(kv) {
+  let queue = Promise.resolve();
+  function serialized(operation) {
+    const run = queue.then(operation, operation);
+    queue = run.catch(() => void 0);
+    return run;
+  }
+  async function current() {
+    return normalizePendingBlobDeletions(await kv.read());
+  }
+  return {
+    list() {
+      return serialized(current);
+    },
+    add(keys) {
+      return serialized(async () => {
+        if (keys.length === 0)
+          return;
+        const existing = await current();
+        const known = new Set(existing.map(markerId));
+        const next = [...existing];
+        for (const key of keys) {
+          const id2 = markerId(key);
+          if (known.has(id2))
+            continue;
+          known.add(id2);
+          next.push({
+            scope: key.scope,
+            version: key.version,
+            ...key.range ? { range: { ...key.range } } : {}
+          });
+        }
+        if (next.length === existing.length)
+          return;
+        await kv.write(next);
+      });
+    },
+    remove(keys) {
+      return serialized(async () => {
+        if (keys.length === 0)
+          return;
+        const existing = await current();
+        const gone = new Set(keys.map(markerId));
+        const next = existing.filter((key) => !gone.has(markerId(key)));
+        if (next.length === existing.length)
+          return;
+        await kv.write(next);
+      });
+    }
+  };
+}
+
 // ../core/dist/storage/adapters/sdk.js
 function createSdkStorageAdapter(providerOrFactory, options) {
   let cachedProvider;
@@ -129041,8 +131518,11 @@ function copyBytes(data) {
 
 // ../core/dist/storage/adapters/vana.js
 var DEFAULT_VANA_STORAGE_ENDPOINT = "https://storage.vana.org";
+function resolveVanaStorageEndpoint(config2) {
+  return (config2.storage.config.vana?.apiUrl ?? DEFAULT_VANA_STORAGE_ENDPOINT).replace(/\/+$/, "");
+}
 function createVanaSyncStorageAdapter(params) {
-  const endpoint = (params.config.storage.config.vana?.apiUrl ?? DEFAULT_VANA_STORAGE_ENDPOINT).replace(/\/+$/, "");
+  const endpoint = resolveVanaStorageEndpoint(params.config);
   const owner = params.serverOwner.toLowerCase();
   const chainId = params.config.gateway.chainId;
   return createSdkStorageAdapter(createVanaStorageProvider({
@@ -129097,6 +131577,7 @@ async function resolvePsLiteOwner(input) {
 
 // ../lite/dist/sync.js
 var SYNC_CURSOR_KEY = "sync-cursor-v1";
+var PENDING_BLOB_DELETIONS_KEY = "pending-blob-deletions-v1";
 function createBrowserLogger(logger) {
   const fallback = {
     info: console.info.bind(console),
@@ -129127,6 +131608,19 @@ function createPsLiteSyncCursor(stateStore) {
     }
   };
 }
+function createPsLitePendingBlobDeletionStore(stateStore) {
+  return createPendingBlobDeletionStore({
+    async read() {
+      const state = await stateStore.get(PENDING_BLOB_DELETIONS_KEY);
+      if (!state)
+        return null;
+      return normalizePendingBlobDeletions(state.keys ?? state.scopes);
+    },
+    async write(keys) {
+      await stateStore.set(PENDING_BLOB_DELETIONS_KEY, { keys });
+    }
+  });
+}
 function buildDownloadDiagnosticsHook(recorder) {
   return {
     onDownloadStart(fileId) {
@@ -129212,6 +131706,20 @@ async function createPsLiteSyncManager(options) {
   });
   const cursor = createPsLiteSyncCursor(options.stateStore);
   const logger = createBrowserLogger(options.logger);
+  const dataPointFeed = options.dataPointFeed ?? createGatewayDataPointFeed({ gatewayUrl: options.config.gateway.url });
+  const scopeDeletions = options.scopeDeletions ?? createScopeDeletionTracker({ feed: dataPointFeed, serverOwner, logger });
+  const deleteData = createGatewayDeleteDataPort({
+    gatewayUrl: options.config.gateway.url,
+    dataPointFeed,
+    serverOwner,
+    signer,
+    storage: {
+      endpoint: resolveVanaStorageEndpoint(options.config),
+      chainId: options.config.gateway.chainId,
+      signMessage: (message) => options.serverAccount.signMessage(message)
+    }
+  });
+  const pendingBlobDeletions = createPsLitePendingBlobDeletionStore(options.stateStore);
   const downloadDiagnostics = options.diagnostics ? buildDownloadDiagnosticsHook(options.diagnostics) : void 0;
   const syncManager = createSyncManager({
     storage: options.storage,
@@ -129221,7 +131729,9 @@ async function createPsLiteSyncManager(options) {
     masterKey,
     serverOwner,
     logger,
-    lineageGateway: options.lineageGateway
+    lineageGateway: options.lineageGateway,
+    dataPointFeed,
+    scopeDeletions
   }, {
     storage: options.storage,
     storageAdapter,
@@ -129230,8 +131740,13 @@ async function createPsLiteSyncManager(options) {
     masterKey,
     serverOwner,
     logger,
-    diagnostics: downloadDiagnostics
+    diagnostics: downloadDiagnostics,
+    dataPointFeed,
+    scopeDeletions,
+    onDataPointIndexed: options.onDataPointIndexed
   }, {
+    deleteData,
+    pendingBlobDeletions,
     async canSync() {
       try {
         const serverInfo = await gateway.getServer(options.serverAccount.address);
@@ -129253,7 +131768,59 @@ async function createPsLiteSyncManager(options) {
     }
   });
   syncManager.start();
-  return { syncManager, serverOwner };
+  return { syncManager, serverOwner, dataPointFeed, scopeDeletions };
+}
+
+// ../lite/dist/derivatives.js
+var QUESTIONS_KEY = "derivative-questions-v1";
+async function createPsLiteQuestionStore(stateStore) {
+  const saved = await stateStore.get(QUESTIONS_KEY);
+  const initial = saved?.version === 1 ? saved.questions : [];
+  return createInMemoryQuestionStore({
+    initial,
+    onChange: (questions) => stateStore.set(QUESTIONS_KEY, {
+      version: 1,
+      questions
+    })
+  });
+}
+function psLiteInferenceConfigured(config2) {
+  return config2.inference.baseUrl.replace(/\/+$/, "") !== DEFAULT_INFERENCE_BASE_URL.replace(/\/+$/, "");
+}
+function createPsLiteDerivativeCompute(options) {
+  const provider = options.provider ?? createOpenAiCompatibleInferenceProvider({
+    baseUrl: options.config.inference.baseUrl,
+    model: options.config.inference.model
+  });
+  const logger = options.logger ? {
+    info: (payload, message) => options.logger?.info(payload, message),
+    warn: (payload, message) => options.logger?.warn(payload, message)
+  } : void 0;
+  const scheduler = createRecomputeScheduler({
+    store: options.store,
+    debounceMs: options.config.inference.recomputeDebounceMs,
+    serverOwner: options.serverOwner,
+    now: options.now,
+    logger,
+    compute: (questionId) => computeQuestion(questionId, {
+      // A -> B -> C: a question reading this derived scope recomputes.
+      onDerivedWritten: (event) => scheduler.markSourceChanged(event.scope, {
+        lineageSources: event.lineageSources
+      }),
+      runtimeAvailability: options.runtimeAvailability,
+      storage: options.storage,
+      store: options.store,
+      provider,
+      serverOwner: options.serverOwner,
+      maxSourceItems: options.config.inference.maxSourceItems,
+      syncManager: options.syncManager?.() ?? null,
+      scopeDeletions: options.scopeDeletions?.(),
+      writePolicyPorts: options.writePolicyPorts,
+      now: options.now,
+      logger
+    })
+  });
+  return { store: options.store, scheduler, provider };
 }
 
 // ../lite/dist/persistence.js
@@ -129319,8 +131886,32 @@ async function createIndexedDbPsLiteRuntime(options) {
     requestSigner: createRequestSigner(identity.account)
   });
   let syncManager = options.syncManager ?? null;
+  let scopeDeletions = options.scopeDeletions;
+  let runtimeRef = null;
+  let derivatives = options.derivatives ?? null;
+  if (derivatives === null && options.derivatives === void 0 && (options.inferenceProvider || psLiteInferenceConfigured(config2))) {
+    derivatives = createPsLiteDerivativeCompute({
+      config: config2,
+      storage,
+      store: await createPsLiteQuestionStore(stateStore),
+      serverOwner,
+      syncManager: () => syncManager,
+      scopeDeletions: () => scopeDeletions,
+      writePolicyPorts: {
+        authSessionVerifier: gateway,
+        grantVerifier: gateway
+      },
+      runtimeAvailability: {
+        isAvailable: () => runtimeRef?.isAvailable() ?? Boolean(options.active)
+      },
+      provider: options.inferenceProvider,
+      logger: options.logger
+    });
+  } else if (derivatives === null && options.derivatives === void 0) {
+    options.logger?.warn({ baseUrl: config2.inference.baseUrl }, "Derivative compute disabled: inference.baseUrl is the direct-provider default; point it at the Vana inference relay");
+  }
   if (!syncManager && config2.sync.enabled) {
-    syncManager = (await createPsLiteSyncManager({
+    const sync = await createPsLiteSyncManager({
       config: config2,
       stateStore,
       storage,
@@ -129328,12 +131919,18 @@ async function createIndexedDbPsLiteRuntime(options) {
       ownerAddress: options.ownerAddress,
       serverAccount: identity.account,
       gateway,
+      dataPointFeed: options.dataPointFeed,
+      scopeDeletions,
       diagnostics,
       logger: options.logger,
-      lineageGateway
-    })).syncManager;
+      lineageGateway,
+      onDataPointIndexed: (event) => derivatives?.scheduler.markSourceChanged(event.scope, {
+        lineageSources: event.lineageSources
+      })
+    });
+    syncManager = sync.syncManager;
+    scopeDeletions = sync.scopeDeletions;
   }
-  let runtimeRef = null;
   const auth = options.auth ?? createWeb3SignedPsLiteAuth({
     origin: () => options.runtimeOrigin ?? config2.server.origin,
     ownerAddress: serverOwner,
@@ -129360,8 +131957,10 @@ async function createIndexedDbPsLiteRuntime(options) {
     serverOwner,
     serverSigner,
     syncManager,
+    scopeDeletions,
     diagnostics,
     lineageGateway,
+    derivatives,
     saveConfig: async (nextConfig) => {
       const saved = await savePsLiteConfig(stateStore, nextConfig);
       Object.assign(config2, saved);
@@ -129384,7 +131983,8 @@ async function createIndexedDbPsLiteRuntime(options) {
     storage,
     tokenStore,
     accessLogStore,
-    syncManager
+    syncManager,
+    derivatives
   };
 }