@opendatalabs/personal-server-ts-server 1.34.0 → 1.34.2

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

@@ -42280,11 +42280,11 @@ var init_abiParameter = __esm({
 });
 
 // ../../node_modules/abitype/dist/esm/human-readable/errors/signature.js
-var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
+var InvalidSignatureError2, UnknownSignatureError, InvalidStructSignatureError;
 var init_signature = __esm({
   "../../node_modules/abitype/dist/esm/human-readable/errors/signature.js"() {
     init_errors();
-    InvalidSignatureError = class extends BaseError {
+    InvalidSignatureError2 = class extends BaseError {
       constructor({ signature, type }) {
         super(`Invalid ${type} signature.`, {
           details: signature
@@ -42471,7 +42471,7 @@ function parseSignature(signature, structs = {}) {
 function parseFunctionSignature(signature, structs = {}) {
   const match = execFunctionSignature(signature);
   if (!match)
-    throw new InvalidSignatureError({ signature, type: "function" });
+    throw new InvalidSignatureError2({ signature, type: "function" });
   const inputParams = splitParameters(match.parameters);
   const inputs = [];
   const inputLength = inputParams.length;
@@ -42505,7 +42505,7 @@ function parseFunctionSignature(signature, structs = {}) {
 function parseEventSignature(signature, structs = {}) {
   const match = execEventSignature(signature);
   if (!match)
-    throw new InvalidSignatureError({ signature, type: "event" });
+    throw new InvalidSignatureError2({ signature, type: "event" });
   const params = splitParameters(match.parameters);
   const abiParameters = [];
   const length = params.length;
@@ -42520,7 +42520,7 @@ function parseEventSignature(signature, structs = {}) {
 function parseErrorSignature(signature, structs = {}) {
   const match = execErrorSignature(signature);
   if (!match)
-    throw new InvalidSignatureError({ signature, type: "error" });
+    throw new InvalidSignatureError2({ signature, type: "error" });
   const params = splitParameters(match.parameters);
   const abiParameters = [];
   const length = params.length;
@@ -42531,7 +42531,7 @@ function parseErrorSignature(signature, structs = {}) {
 function parseConstructorSignature(signature, structs = {}) {
   const match = execConstructorSignature(signature);
   if (!match)
-    throw new InvalidSignatureError({ signature, type: "constructor" });
+    throw new InvalidSignatureError2({ signature, type: "constructor" });
   const params = splitParameters(match.parameters);
   const abiParameters = [];
   const length = params.length;
@@ -42546,7 +42546,7 @@ function parseConstructorSignature(signature, structs = {}) {
 function parseFallbackSignature(signature) {
   const match = execFallbackSignature(signature);
   if (!match)
-    throw new InvalidSignatureError({ signature, type: "fallback" });
+    throw new InvalidSignatureError2({ signature, type: "fallback" });
   return {
     type: "fallback",
     stateMutability: match.stateMutability ?? "nonpayable"
@@ -42670,7 +42670,7 @@ function parseStructs(signatures) {
       continue;
     const match = execStructSignature(signature);
     if (!match)
-      throw new InvalidSignatureError({ signature, type: "struct" });
+      throw new InvalidSignatureError2({ signature, type: "struct" });
     const properties = match.properties.split(";");
     const components = [];
     const propertiesLength = properties.length;
@@ -92182,6 +92182,9 @@ var ALTERNATE_PROFILE_BINDINGS = /* @__PURE__ */ new Map([
   ["meta", META_040_BINDINGS],
   ["oura-browser", OURA_BROWSER_BINDINGS]
 ]);
+function alternateLegacyBindingsForScope(scope) {
+  return new Map([...ALTERNATE_PROFILE_BINDINGS].filter(([, bindings]) => bindings.has(scope)).map(([profileKey, bindings]) => [profileKey, bindings.get(scope)]));
+}
 function legacyBindingsForProfile(profileKey) {
   const alternate = ALTERNATE_PROFILE_BINDINGS.get(profileKey);
   if (alternate)
@@ -92312,6 +92315,180 @@ function bindingFor(scope, profileKey) {
   return legacyBindingsForProfile(profileKey).get(scope);
 }
 
+// ../core/dist/errors/catalog.js
+var ProtocolError = class extends Error {
+  code;
+  errorCode;
+  details;
+  constructor(code, errorCode, message, details) {
+    super(message);
+    this.code = code;
+    this.errorCode = errorCode;
+    this.details = details;
+    this.name = this.constructor.name;
+  }
+  toJSON() {
+    return {
+      error: {
+        code: this.code,
+        errorCode: this.errorCode,
+        message: this.message,
+        ...this.details !== void 0 && { details: this.details }
+      }
+    };
+  }
+};
+var MissingAuthError = class extends ProtocolError {
+  constructor(details) {
+    super(401, "MISSING_AUTH", "Missing authentication", details);
+  }
+};
+var InvalidSignatureError = class extends ProtocolError {
+  constructor(details) {
+    super(401, "INVALID_SIGNATURE", "Invalid signature", details);
+  }
+};
+var UnregisteredBuilderError = class extends ProtocolError {
+  constructor(details) {
+    super(401, "UNREGISTERED_BUILDER", "Unregistered builder", details);
+  }
+};
+var NotOwnerError = class extends ProtocolError {
+  constructor(details) {
+    super(401, "NOT_OWNER", "Not the owner", details);
+  }
+};
+var ExpiredTokenError = class extends ProtocolError {
+  constructor(details) {
+    super(401, "EXPIRED_TOKEN", "Token has expired", details);
+  }
+};
+var GrantRequiredError = class extends ProtocolError {
+  constructor(details) {
+    super(403, "GRANT_REQUIRED", "Grant required", details);
+  }
+};
+var GrantExpiredError = class extends ProtocolError {
+  constructor(details) {
+    super(403, "GRANT_EXPIRED", "Grant has expired", details);
+  }
+};
+var GrantRevokedError = class extends ProtocolError {
+  constructor(details) {
+    super(403, "GRANT_REVOKED", "Grant has been revoked", details);
+  }
+};
+var ScopeMismatchError = class extends ProtocolError {
+  constructor(details) {
+    super(403, "SCOPE_MISMATCH", "Scope not granted", details);
+  }
+};
+var GrantOwnerMismatchError = class extends ProtocolError {
+  constructor(details) {
+    super(403, "GRANT_OWNER_MISMATCH", "Grant was not issued by this server's owner", details);
+  }
+};
+var PsUnavailableError = class extends ProtocolError {
+  constructor(details) {
+    super(503, "PS_UNAVAILABLE", "Personal Server runtime unavailable", details);
+  }
+};
+var ServerNotConfiguredError = class extends ProtocolError {
+  constructor(details) {
+    super(500, "SERVER_NOT_CONFIGURED", "Server is not configured", details);
+  }
+};
+var ServerSigningUnavailableError = class extends ProtocolError {
+  constructor() {
+    super(500, "SERVER_SIGNING_UNAVAILABLE", "Server signing is unavailable in this runtime");
+  }
+};
+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);
+  }
+};
+var LineageScopeUnderSourcePrefixError = class extends ProtocolError {
+  constructor(details) {
+    super(400, "LINEAGE_SCOPE_UNDER_SOURCE_PREFIX", `Derived scope "${details.scope}" shares its first segment with source scope "${details.sourceScope}"; a wildcard grant on that namespace would read both. Name derivatives under their own namespace.`, details);
+  }
+};
+var LineageSourceUnknownError = class extends ProtocolError {
+  constructor(details) {
+    super(422, "LINEAGE_SOURCE_UNKNOWN", "One or more lineage sources are not data points of this owner", details);
+  }
+};
+var LineageSourceLookupFailedError = class extends ProtocolError {
+  constructor(details) {
+    super(502, "LINEAGE_SOURCE_LOOKUP_FAILED", "Could not resolve a lineage source at the gateway", details);
+  }
+};
+var LineageUnavailableError = class extends ProtocolError {
+  constructor(details) {
+    super(503, "LINEAGE_UNAVAILABLE", "This server is not configured to reach the gateway lineage graph (gateway URL or server signing key missing)", details);
+  }
+};
+var LineageGatewayError = class extends ProtocolError {
+  constructor(details) {
+    super(502, "LINEAGE_GATEWAY_ERROR", `Gateway lineage request failed with status ${details.status}`, details);
+  }
+};
+var LineageCascadeUnavailableError = class extends ProtocolError {
+  constructor(details) {
+    super(501, "LINEAGE_CASCADE_UNAVAILABLE", "DELETE ?cascade=lineage is specified but not implemented yet: the lineage walk that finds every derivative is missing. Delete scopes one at a time; each single-scope delete is durable.", details);
+  }
+};
+var InvalidCascadeError = class extends ProtocolError {
+  constructor(details) {
+    super(400, "INVALID_CASCADE", 'Unsupported cascade mode; the only supported value is "lineage"', details);
+  }
+};
+var DeleteTombstoneFailedError = class extends ProtocolError {
+  constructor(details) {
+    super(502, "DELETE_TOMBSTONE_FAILED", "Gateway did not acknowledge the deletion tombstone; nothing was deleted", details);
+  }
+};
+var DataDeletedError = class extends ProtocolError {
+  constructor(details) {
+    super(410, "DATA_DELETED", "Data point has been deleted", details);
+  }
+};
+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 DerivativeDerivedScopeRequiredError = class extends ProtocolError {
+  constructor(details) {
+    super(400, "DERIVATIVE_DERIVED_SCOPE_REQUIRED", "Listing questions as a builder needs a derived scope: add ?derivedScope=<scope>. The unfiltered list is the owner's", 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/contracts/binary.js
 var BINARY_MARKER = "$binary";
 var BINARY_ENCODING = "base64";
@@ -93330,11 +93507,6 @@ function readJsonLiteralToken(text, startIndex) {
 }
 
 // ../core/dist/storage/legacy-projection.js
-var PROJECTED_SOURCES = /* @__PURE__ */ new Set([
-  "chatgpt",
-  "claude",
-  "youtube"
-]);
 var SERVER_STAMP_KEYS = /* @__PURE__ */ new Set([
   "$writtenBy",
   "$lineage"
@@ -93353,21 +93525,61 @@ function withLegacyProjection(raw, options = {}) {
     return raw;
   let memo = null;
   const forms = /* @__PURE__ */ new Map();
-  const rememberForm = (version4, form) => {
-    forms.set(version4, form);
+  const rememberForm = (key, value) => {
+    forms.set(key, value);
     if (forms.size > FORM_CACHE_SIZE) {
       forms.delete(forms.keys().next().value);
     }
   };
+  function failProjection(scope, collectedAt, error51) {
+    options.onIssue?.({ kind: "projection_failed", scope, collectedAt, error: error51 });
+    throw new ProtocolError(409, "LEGACY_PROJECTION_UNAVAILABLE", `Cannot serve the legacy view for scope "${scope}"`, {
+      scope,
+      collectedAt,
+      reason: "reason" in error51 ? error51.reason : error51.kind,
+      projectionError: error51.kind
+    });
+  }
   async function resolve(scope, collectedAt) {
     if (!isProjectedScope(scope))
       return { view: null };
-    const binding = LEGACY_SCOPE_BINDINGS.get(scope);
+    const requestedEntry = raw.findEntry({ scope, at: collectedAt });
+    const ownVersion = requestedEntry ? `${requestedEntry.id}@${requestedEntry.collectedAt}` : `unindexed@${collectedAt}`;
+    const formKey = JSON.stringify([scope, ownVersion]);
+    let cached2 = forms.get(formKey);
+    let own;
+    if (!cached2) {
+      own = await raw.readEnvelope(scope, collectedAt);
+      const form = classifyStoredBody(scope, own.data);
+      cached2 = {
+        form,
+        ...form === "pdpp-projected" ? {
+          selected: selectProjectionBinding(scope, own.data.records)
+        } : {}
+      };
+      rememberForm(formKey, cached2);
+    }
+    if (cached2.form === "legacy")
+      return { view: null, own };
+    if (cached2.form === "pdpp-unprojected") {
+      failProjection(scope, collectedAt, {
+        kind: "incomplete_scope",
+        scope,
+        reason: "Stored records are not rows of one stream"
+      });
+    }
+    if (!cached2.selected) {
+      failProjection(scope, collectedAt, {
+        kind: "incomplete_scope",
+        scope,
+        reason: "Stored records do not identify one compatible connector profile"
+      });
+    }
+    const { binding, profileKey } = cached2.selected;
     const source3 = scope.slice(0, scope.indexOf("."));
     const supersededAt = nextVersionTime(raw, scope, collectedAt);
     const inputs = binding.pdppStreams.map((stream) => {
       const canonicalScope = `${source3}.${stream}`;
-      const requestedEntry = raw.findEntry({ scope, at: collectedAt });
       let storedScope = binding.pdppStreams.length === 1 && requestedEntry ? scope : canonicalScope;
       let entry = storedScope === scope ? requestedEntry : supersededAt === void 0 ? raw.findEntry({ scope: storedScope }) : nearestBefore(raw, storedScope, collectedAt, supersededAt);
       if (!entry && binding.pdppStreams.length === 1 && storedScope !== scope) {
@@ -93383,38 +93595,35 @@ function withLegacyProjection(raw, options = {}) {
         version: entry ? `${entry.id}@${entry.collectedAt}` : null
       };
     });
-    const ownVersion = inputs.find((input) => input.storedScope === scope)?.version;
-    let own;
-    let form = ownVersion ? forms.get(ownVersion) : void 0;
-    if (form === void 0) {
-      own = await raw.readEnvelope(scope, collectedAt);
-      form = classifyStoredBody(scope, own.data);
-      if (ownVersion)
-        rememberForm(ownVersion, form);
-    }
-    if (form !== "pdpp-projected")
-      return { view: null, own };
     const key = JSON.stringify([
       scope,
       ownVersion,
+      profileKey,
       inputs.map(({ storedScope, version: version4 }) => [storedScope, version4])
     ]);
     if (memo?.key === key)
       return { view: memo.value, own };
     own ??= await raw.readEnvelope(scope, collectedAt);
-    let value = null;
-    if (form === "pdpp-projected") {
-      value = await project(scope, collectedAt, own, inputs);
-      if (value)
-        value.view = key;
-    }
+    const value = await project(scope, collectedAt, own, inputs, binding, profileKey);
+    if (value)
+      value.view = key;
     memo = { key, value };
     return { view: value, own };
   }
   async function projected(scope, collectedAt) {
     return (await resolve(scope, collectedAt)).view;
   }
-  async function project(scope, collectedAt, own, inputs) {
+  async function projectedForSupersede(scope, collectedAt) {
+    try {
+      return await projected(scope, collectedAt);
+    } catch (error51) {
+      if (error51 instanceof ProtocolError && error51.errorCode === "LEGACY_PROJECTION_UNAVAILABLE") {
+        return null;
+      }
+      throw error51;
+    }
+  }
+  async function project(scope, collectedAt, own, inputs, binding, profileKey) {
     const records = [];
     const fetchedStreams = [];
     let now = collectedAt;
@@ -93436,20 +93645,27 @@ function withLegacyProjection(raw, options = {}) {
         records.push({ stream: input.stream, data: row });
       }
     }
-    const result = projectPdppRecordsToLegacyPayload(scope, records, {
+    if (!recordsMatchBindingSource(records, binding, alternateLegacyBindingsForScope(scope).size > 0)) {
+      failProjection(scope, collectedAt, {
+        kind: "incomplete_scope",
+        scope,
+        reason: "Joined streams have conflicting connector identities"
+      });
+    }
+    const projectionRecords = records.map((record2) => {
+      const data = { ...record2.data };
+      delete data.$pdpp;
+      return { ...record2, data };
+    });
+    const result = projectPdppRecordsToLegacyPayload(scope, projectionRecords, {
       fetchedStreams,
       now,
-      orderByPrimaryKey: true,
+      ...profileKey ? { profileKey } : {},
+      orderByPrimaryKey: binding.rowOrder !== "arrival",
       allowMissingJoinStreams: true
     });
     if (!result.ok) {
-      options.onIssue?.({
-        kind: "projection_failed",
-        scope,
-        collectedAt,
-        error: result.error
-      });
-      return null;
+      failProjection(scope, collectedAt, result.error);
     }
     if (result.diagnostics?.length) {
       options.onIssue?.({
@@ -93477,7 +93693,7 @@ function withLegacyProjection(raw, options = {}) {
   }
   const overrides = {
     [SERVED]: true,
-    [PROJECTED_VIEW]: projected,
+    [PROJECTED_VIEW]: projectedForSupersede,
     async readEnvelope(scope, collectedAt) {
       const { view, own } = await resolve(scope, collectedAt);
       return view?.envelope ?? own ?? raw.readEnvelope(scope, collectedAt);
@@ -93529,10 +93745,6 @@ function withLegacyProjection(raw, options = {}) {
       return view ? (await builtBlocks(scope, view)).manifest : rawManifest(scope, collectedAt);
     };
   }
-  if (raw.hasScopeBlocks) {
-    const rawHas = raw.hasScopeBlocks.bind(raw);
-    overrides.hasScopeBlocks = async (scope, collectedAt) => await rawHas(scope, collectedAt) || await projected(scope, collectedAt) !== null;
-  }
   if (raw.canReadScopeBlocks) {
     const rawCan = raw.canReadScopeBlocks.bind(raw);
     overrides.canReadScopeBlocks = async (scope, collectedAt) => await rawCan(scope, collectedAt) || await projected(scope, collectedAt) !== null;
@@ -93559,8 +93771,52 @@ function legacyScopesProjectedFrom(scope) {
   return [...LEGACY_SCOPE_BINDINGS.values()].filter((binding) => binding.scope !== scope && binding.scope.startsWith(`${source3}.`) && isProjectedScope(binding.scope) && binding.pdppStreams.includes(stream)).map((binding) => binding.scope);
 }
 function isProjectedScope(scope) {
-  const dot = scope.indexOf(".");
-  return dot > 0 && PROJECTED_SOURCES.has(scope.slice(0, dot)) && LEGACY_SCOPE_BINDINGS.has(scope);
+  return LEGACY_SCOPE_BINDINGS.has(scope);
+}
+function selectProjectionBinding(scope, rows) {
+  const original2 = LEGACY_SCOPE_BINDINGS.get(scope);
+  const alternates = alternateLegacyBindingsForScope(scope);
+  const identities = rows.map(recordSourceId);
+  if (identities.includes(null))
+    return null;
+  if (alternates.size > 0 && identities.includes(void 0))
+    return null;
+  const sources = new Set(identities.filter((id2) => !!id2));
+  if (sources.size > 1)
+    return null;
+  if (sources.size === 0) {
+    return alternates.size === 0 ? { binding: original2 } : null;
+  }
+  const sourceId = [...sources][0];
+  const connectorKey = sourceId.slice(sourceId.lastIndexOf("/") + 1);
+  const alternate = alternates.get(connectorKey);
+  if (alternate && sourceIdForBinding(alternate) === sourceId) {
+    return { binding: alternate, profileKey: connectorKey };
+  }
+  return sourceIdForBinding(original2) === sourceId ? { binding: original2 } : null;
+}
+function recordSourceId(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return null;
+  }
+  if (!("$pdpp" in data))
+    return void 0;
+  const metadata = data.$pdpp;
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return null;
+  }
+  const sourceId = metadata.sourceId;
+  return typeof sourceId === "string" && sourceId ? sourceId : null;
+}
+function sourceIdForBinding(binding) {
+  return binding.pdppSource.replace("/connectors/", "/sources/");
+}
+function recordsMatchBindingSource(records, binding, requireIdentity) {
+  const expected = sourceIdForBinding(binding);
+  return records.every(({ data }) => {
+    const actual = recordSourceId(data);
+    return actual === expected || !requireIdentity && actual === void 0;
+  });
 }
 var VERSION_PAGE_SIZE = 100;
 function walkVersions(raw, scope, stop) {
@@ -93623,6 +93879,9 @@ async function supersedeLegacyVersions(storage, scope, committedAt) {
   if (scope.startsWith("youtube.")) {
     return refuse("YouTube legacy versions are retained for read-time projection");
   }
+  if (isProjectedScope(scope) && !scope.startsWith("chatgpt.") && !scope.startsWith("claude.")) {
+    return refuse("Legacy versions are retained for read-time projection");
+  }
   const readStored = (storage.readStoredEnvelope ?? storage.readEnvelope).bind(storage);
   const committed = await readStored(scope, committedAt);
   if (classifyStoredBody(scope, committed.data) !== "pdpp-projected") {
@@ -95286,21 +95545,21 @@ init_sha2();
 init_openpgp_min();
 
 // ../../node_modules/@opendatalabs/vana-sdk/dist/auth/errors.js
-var MissingAuthError = class extends VanaError {
+var MissingAuthError2 = class extends VanaError {
   constructor(message = "Missing authentication", details) {
     super(message, "MISSING_AUTH");
     this.details = details;
   }
   details;
 };
-var InvalidSignatureError2 = class extends VanaError {
+var InvalidSignatureError3 = class extends VanaError {
   constructor(details, message = "Invalid signature") {
     super(message, "INVALID_SIGNATURE");
     this.details = details;
   }
   details;
 };
-var ExpiredTokenError = class extends VanaError {
+var ExpiredTokenError2 = class extends VanaError {
   constructor(details, message = "Token has expired") {
     super(message, "EXPIRED_TOKEN");
     this.details = details;
@@ -111975,14 +112234,14 @@ function isFiniteNumber(value) {
 }
 function parsePayload(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    throw new InvalidSignatureError2({ reason: "Invalid payload shape" });
+    throw new InvalidSignatureError3({ reason: "Invalid payload shape" });
   }
   const payload = value;
   if (typeof payload["aud"] !== "string" || typeof payload["method"] !== "string" || typeof payload["uri"] !== "string" || typeof payload["bodyHash"] !== "string" || !isFiniteNumber(payload["iat"]) || !isFiniteNumber(payload["exp"])) {
-    throw new InvalidSignatureError2({ reason: "Invalid payload claims" });
+    throw new InvalidSignatureError3({ reason: "Invalid payload claims" });
   }
   if (payload["grantId"] !== void 0 && typeof payload["grantId"] !== "string") {
-    throw new InvalidSignatureError2({ reason: "Invalid grantId claim" });
+    throw new InvalidSignatureError3({ reason: "Invalid grantId claim" });
   }
   return {
     aud: payload["aud"],
@@ -111996,28 +112255,28 @@ function parsePayload(value) {
 }
 function parseWeb3SignedHeader(headerValue) {
   if (!headerValue) {
-    throw new MissingAuthError();
+    throw new MissingAuthError2();
   }
   if (!headerValue.startsWith(WEB3_SIGNED_PREFIX)) {
-    throw new InvalidSignatureError2({ reason: "Missing Web3Signed prefix" });
+    throw new InvalidSignatureError3({ reason: "Missing Web3Signed prefix" });
   }
   const value = headerValue.slice(WEB3_SIGNED_PREFIX.length);
   const dotIndex = value.indexOf(".");
   if (dotIndex === -1 || dotIndex === 0 || dotIndex === value.length - 1) {
-    throw new InvalidSignatureError2({ reason: "Invalid header format" });
+    throw new InvalidSignatureError3({ reason: "Invalid header format" });
   }
   const payloadBase64 = value.slice(0, dotIndex);
   const signatureStr = value.slice(dotIndex + 1);
   if (!signatureStr.startsWith("0x")) {
-    throw new InvalidSignatureError2({ reason: "Invalid signature format" });
+    throw new InvalidSignatureError3({ reason: "Invalid signature format" });
   }
   let payload;
   try {
     const decoded = base64urlDecode(payloadBase64);
     payload = parsePayload(JSON.parse(decoded));
   } catch (err2) {
-    if (err2 instanceof InvalidSignatureError2) throw err2;
-    throw new InvalidSignatureError2({ reason: "Invalid payload encoding" });
+    if (err2 instanceof InvalidSignatureError3) throw err2;
+    throw new InvalidSignatureError3({ reason: "Invalid payload encoding" });
   }
   return {
     payloadBase64,
@@ -112036,24 +112295,24 @@ async function verifyWeb3Signed(params) {
       signature
     });
   } catch {
-    throw new InvalidSignatureError2({ reason: "Signature recovery failed" });
+    throw new InvalidSignatureError3({ reason: "Signature recovery failed" });
   }
   if (payload.aud !== params.expectedOrigin) {
-    throw new InvalidSignatureError2({
+    throw new InvalidSignatureError3({
       reason: "Audience mismatch",
       expected: params.expectedOrigin,
       actual: payload.aud
     });
   }
   if (payload.method !== params.expectedMethod) {
-    throw new InvalidSignatureError2({
+    throw new InvalidSignatureError3({
       reason: "Method mismatch",
       expected: params.expectedMethod,
       actual: payload.method
     });
   }
   if (payload.uri !== params.expectedPath) {
-    throw new InvalidSignatureError2({
+    throw new InvalidSignatureError3({
       reason: "URI mismatch",
       expected: params.expectedPath,
       actual: payload.uri
@@ -112062,7 +112321,7 @@ async function verifyWeb3Signed(params) {
   if (params.bodyBytes !== void 0) {
     const expectedBodyHash = computeBodyHash(params.bodyBytes);
     if (payload.bodyHash !== expectedBodyHash) {
-      throw new InvalidSignatureError2({
+      throw new InvalidSignatureError3({
         reason: "Body hash mismatch",
         expected: expectedBodyHash,
         actual: payload.bodyHash
@@ -112071,10 +112330,10 @@ async function verifyWeb3Signed(params) {
   }
   const now = params.now ?? Math.floor(Date.now() / 1e3);
   if (payload.exp < now - CLOCK_SKEW_SECONDS) {
-    throw new ExpiredTokenError({ reason: "Token expired" });
+    throw new ExpiredTokenError2({ reason: "Token expired" });
   }
   if (payload.iat > now + CLOCK_SKEW_SECONDS) {
-    throw new ExpiredTokenError({ reason: "Token issued in the future" });
+    throw new ExpiredTokenError2({ reason: "Token issued in the future" });
   }
   return { signer, payload };
 }
@@ -113098,180 +113357,6 @@ function createRequestSigner(account) {
   };
 }
 
-// ../core/dist/errors/catalog.js
-var ProtocolError = class extends Error {
-  code;
-  errorCode;
-  details;
-  constructor(code, errorCode, message, details) {
-    super(message);
-    this.code = code;
-    this.errorCode = errorCode;
-    this.details = details;
-    this.name = this.constructor.name;
-  }
-  toJSON() {
-    return {
-      error: {
-        code: this.code,
-        errorCode: this.errorCode,
-        message: this.message,
-        ...this.details !== void 0 && { details: this.details }
-      }
-    };
-  }
-};
-var MissingAuthError2 = class extends ProtocolError {
-  constructor(details) {
-    super(401, "MISSING_AUTH", "Missing authentication", details);
-  }
-};
-var InvalidSignatureError3 = class extends ProtocolError {
-  constructor(details) {
-    super(401, "INVALID_SIGNATURE", "Invalid signature", details);
-  }
-};
-var UnregisteredBuilderError = class extends ProtocolError {
-  constructor(details) {
-    super(401, "UNREGISTERED_BUILDER", "Unregistered builder", details);
-  }
-};
-var NotOwnerError = class extends ProtocolError {
-  constructor(details) {
-    super(401, "NOT_OWNER", "Not the owner", details);
-  }
-};
-var ExpiredTokenError2 = class extends ProtocolError {
-  constructor(details) {
-    super(401, "EXPIRED_TOKEN", "Token has expired", details);
-  }
-};
-var GrantRequiredError = class extends ProtocolError {
-  constructor(details) {
-    super(403, "GRANT_REQUIRED", "Grant required", details);
-  }
-};
-var GrantExpiredError = class extends ProtocolError {
-  constructor(details) {
-    super(403, "GRANT_EXPIRED", "Grant has expired", details);
-  }
-};
-var GrantRevokedError = class extends ProtocolError {
-  constructor(details) {
-    super(403, "GRANT_REVOKED", "Grant has been revoked", details);
-  }
-};
-var ScopeMismatchError = class extends ProtocolError {
-  constructor(details) {
-    super(403, "SCOPE_MISMATCH", "Scope not granted", details);
-  }
-};
-var GrantOwnerMismatchError = class extends ProtocolError {
-  constructor(details) {
-    super(403, "GRANT_OWNER_MISMATCH", "Grant was not issued by this server's owner", details);
-  }
-};
-var PsUnavailableError = class extends ProtocolError {
-  constructor(details) {
-    super(503, "PS_UNAVAILABLE", "Personal Server runtime unavailable", details);
-  }
-};
-var ServerNotConfiguredError = class extends ProtocolError {
-  constructor(details) {
-    super(500, "SERVER_NOT_CONFIGURED", "Server is not configured", details);
-  }
-};
-var ServerSigningUnavailableError = class extends ProtocolError {
-  constructor() {
-    super(500, "SERVER_SIGNING_UNAVAILABLE", "Server signing is unavailable in this runtime");
-  }
-};
-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);
-  }
-};
-var LineageScopeUnderSourcePrefixError = class extends ProtocolError {
-  constructor(details) {
-    super(400, "LINEAGE_SCOPE_UNDER_SOURCE_PREFIX", `Derived scope "${details.scope}" shares its first segment with source scope "${details.sourceScope}"; a wildcard grant on that namespace would read both. Name derivatives under their own namespace.`, details);
-  }
-};
-var LineageSourceUnknownError = class extends ProtocolError {
-  constructor(details) {
-    super(422, "LINEAGE_SOURCE_UNKNOWN", "One or more lineage sources are not data points of this owner", details);
-  }
-};
-var LineageSourceLookupFailedError = class extends ProtocolError {
-  constructor(details) {
-    super(502, "LINEAGE_SOURCE_LOOKUP_FAILED", "Could not resolve a lineage source at the gateway", details);
-  }
-};
-var LineageUnavailableError = class extends ProtocolError {
-  constructor(details) {
-    super(503, "LINEAGE_UNAVAILABLE", "This server is not configured to reach the gateway lineage graph (gateway URL or server signing key missing)", details);
-  }
-};
-var LineageGatewayError = class extends ProtocolError {
-  constructor(details) {
-    super(502, "LINEAGE_GATEWAY_ERROR", `Gateway lineage request failed with status ${details.status}`, details);
-  }
-};
-var LineageCascadeUnavailableError = class extends ProtocolError {
-  constructor(details) {
-    super(501, "LINEAGE_CASCADE_UNAVAILABLE", "DELETE ?cascade=lineage is specified but not implemented yet: the lineage walk that finds every derivative is missing. Delete scopes one at a time; each single-scope delete is durable.", details);
-  }
-};
-var InvalidCascadeError = class extends ProtocolError {
-  constructor(details) {
-    super(400, "INVALID_CASCADE", 'Unsupported cascade mode; the only supported value is "lineage"', details);
-  }
-};
-var DeleteTombstoneFailedError = class extends ProtocolError {
-  constructor(details) {
-    super(502, "DELETE_TOMBSTONE_FAILED", "Gateway did not acknowledge the deletion tombstone; nothing was deleted", details);
-  }
-};
-var DataDeletedError = class extends ProtocolError {
-  constructor(details) {
-    super(410, "DATA_DELETED", "Data point has been deleted", details);
-  }
-};
-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 DerivativeDerivedScopeRequiredError = class extends ProtocolError {
-  constructor(details) {
-    super(400, "DERIVATIVE_DERIVED_SCOPE_REQUIRED", "Listing questions as a builder needs a derived scope: add ?derivedScope=<scope>. The unfiltered list is the owner's", 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) {
   return keccak256(encodeAbiParameters([
@@ -117073,7 +117158,7 @@ function verifyPdppGrantBinding(input) {
     });
   }
   if (!sameHex(input.requestSigner, binding.granteeAddress)) {
-    throw new InvalidSignatureError3({
+    throw new InvalidSignatureError({
       reason: "Request signer is not the bound grantee for this PDPP grant",
       expected: binding.granteeAddress,
       actual: input.requestSigner
@@ -117097,7 +117182,7 @@ function verifyPdppGrantBinding(input) {
     throw new GrantRevokedError({ grantId: chainGrant.id });
   }
   if (!grantVersionStillAuthorizes(binding.grantVersion, chainGrant.grantVersion)) {
-    throw new InvalidSignatureError3({
+    throw new InvalidSignatureError({
       reason: "Chain grant version no longer matches the bound grantVersion",
       expected: binding.grantVersion,
       actual: chainGrant.grantVersion
@@ -117111,7 +117196,7 @@ function verifyPdppGrantBinding(input) {
     });
   }
   if (!sameHex(chainGrant.granteeId, binding.granteeId)) {
-    throw new InvalidSignatureError3({
+    throw new InvalidSignatureError({
       reason: "Chain grant grantee no longer matches the bound grantee",
       expected: binding.granteeId,
       actual: chainGrant.granteeId
@@ -117242,7 +117327,7 @@ function assertGrantAuthorizesBuilder(grant, builder, input) {
     });
   }
   if (builder.id.toLowerCase() !== grant.granteeId.toLowerCase()) {
-    throw new InvalidSignatureError3({
+    throw new InvalidSignatureError({
       reason: "Request signer is not the grant builder",
       expected: grant.granteeId,
       actual: input.signer
@@ -117333,6 +117418,27 @@ function isTombstoneRecord(record2) {
 var DEFAULT_SCOPE_DELETION_MAX_STALENESS_MS = 12e4;
 var DEFAULT_SCOPE_DELETION_GATEWAY_RETRY_MS = 15e3;
 var DEFAULT_MAX_LIVE_ENTRIES = 1e4;
+var DeletionLookupTimeout = class extends Error {
+};
+async function beforeDeadline(request2, timeoutMs, onTimeout) {
+  if (timeoutMs === void 0)
+    return request2;
+  let timer;
+  try {
+    return await Promise.race([
+      request2,
+      new Promise((_11, reject) => {
+        timer = setTimeout(() => {
+          reject(new DeletionLookupTimeout("Deletion lookup deadline exceeded"));
+          onTimeout?.();
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer !== void 0)
+      clearTimeout(timer);
+  }
+}
 function createScopeDeletionTracker(options = {}) {
   const maxStalenessMs = options.maxStalenessMs ?? DEFAULT_SCOPE_DELETION_MAX_STALENESS_MS;
   const gatewayRetryMs = options.gatewayRetryMs ?? DEFAULT_SCOPE_DELETION_GATEWAY_RETRY_MS;
@@ -117405,24 +117511,32 @@ function createScopeDeletionTracker(options = {}) {
     rememberLive(scope, nowMs2());
     return { deleted: false, source: "gateway", verified: true };
   }
-  async function lookup2(scope) {
+  async function lookup2(scope, timeoutMs) {
     const feed = options.feed;
     const owner = options.serverOwner;
-    if (!feed || !owner)
+    if (!feed || !owner || timeoutMs !== void 0 && timeoutMs <= 0)
       return null;
     if (lastGatewayFailureMs !== null && nowMs2() - lastGatewayFailureMs < gatewayRetryMs) {
       return null;
     }
     const pending = inflight.get(scope);
-    if (pending)
-      return pending;
+    if (pending) {
+      return beforeDeadline(pending, timeoutMs).catch((error51) => {
+        if (error51 instanceof DeletionLookupTimeout)
+          return null;
+        throw error51;
+      });
+    }
+    const deletionAtStart = deleted.get(scope);
     const request2 = (async () => {
       let record2;
+      const controller = timeoutMs === void 0 ? void 0 : new AbortController();
       try {
-        record2 = await feed.getDataPoint({
+        record2 = await beforeDeadline(feed.getDataPoint({
           ownerAddress: owner,
-          scope
-        });
+          scope,
+          ...controller ? { signal: controller.signal } : {}
+        }), timeoutMs, () => controller?.abort());
         lastGatewayFailureMs = null;
       } catch (err2) {
         lastGatewayFailureMs = nowMs2();
@@ -117433,11 +117547,23 @@ function createScopeDeletionTracker(options = {}) {
         }, "Could not check gateway deletion state; serving last known state");
         return null;
       }
+      if (deleted.get(scope) !== deletionAtStart)
+        return lastKnownVerdict(scope);
       return verdictFromRecord(scope, record2);
     })().finally(() => inflight.delete(scope));
     inflight.set(scope, request2);
     return request2;
   }
+  function lastKnownVerdict(scope) {
+    const known = deleted.get(scope);
+    return known ? {
+      deleted: true,
+      deletedAt: known.deletedAt,
+      version: known.version,
+      source: known.source,
+      verified: false
+    } : { deleted: false, source: "assumed-live", verified: false };
+  }
   return {
     maxStalenessMs,
     deletionHistory,
@@ -117476,16 +117602,10 @@ function createScopeDeletionTracker(options = {}) {
             verified: true
           };
         }
-        const rechecked = await lookup2(scope);
+        const rechecked = await lookup2(scope, resolveOptions?.gatewayTimeoutMs);
         if (rechecked !== null)
           return rechecked;
-        return {
-          deleted: true,
-          deletedAt: known.deletedAt,
-          version: known.version,
-          source: known.source,
-          verified: false
-        };
+        return lastKnownVerdict(scope);
       }
       if (isFresh(live.get(scope) ?? null)) {
         return { deleted: false, source: "gateway", verified: true };
@@ -117494,11 +117614,7 @@ function createScopeDeletionTracker(options = {}) {
       if (consult === "if-stale" && isFresh(lastFeedSyncMs)) {
         return { deleted: false, source: "feed", verified: true };
       }
-      return await lookup2(scope) ?? {
-        deleted: false,
-        source: "assumed-live",
-        verified: false
-      };
+      return await lookup2(scope, resolveOptions?.gatewayTimeoutMs) ?? lastKnownVerdict(scope);
     }
   };
 }
@@ -118566,11 +118682,12 @@ async function parseProducerProvenance(encoded, body) {
     return errorResponse(400, "INVALID_PROVENANCE", "Vana-Producer-Provenance is not base64url JSON");
   }
 }
-async function resolveReadDeletion(deps, scope, entry, body = "file") {
+async function resolveReadDeletion(deps, scope, entry, body = "file", gatewayTimeoutMs) {
   if (!deps.scopeDeletions)
     return null;
   const verdict = await deps.scopeDeletions.resolve(scope, {
-    consultGateway: entry ? "if-stale" : "always"
+    consultGateway: entry ? "if-stale" : "always",
+    ...gatewayTimeoutMs === void 0 ? {} : { gatewayTimeoutMs }
   });
   const tombstone = body === "canonical" ? deps.scopeDeletions.deletionHistory?.get(scope) ?? (verdict.deleted ? verdict : null) : verdict.deleted ? verdict : null;
   if (!tombstone)
@@ -118594,8 +118711,8 @@ function discoveryVisibility(deps) {
     return void 0;
   return async (scope, entry) => await resolveReadDeletion(deps, scope, entry) === null;
 }
-function listingVisibility(deps) {
-  const deletion = discoveryVisibility(deps);
+function listingVisibility(deps, deadlineAtMs) {
+  const deletion = deps.scopeDeletions ? async (scope, entry) => await resolveReadDeletion(deps, scope, entry, "file", Math.max(0, deadlineAtMs - Date.now())) === null : void 0;
   const view = deps.legacyScopeView;
   if (!view)
     return deletion;
@@ -118604,10 +118721,10 @@ function listingVisibility(deps) {
     if (listing.kind === "refused")
       return false;
     const canonicalOwned = view.ownsScope(scope);
-    return await resolveReadDeletion(deps, scope, canonicalOwned ? void 0 : entry, canonicalOwned ? "canonical" : "file") === null;
+    return await resolveReadDeletion(deps, scope, canonicalOwned ? void 0 : entry, canonicalOwned ? "canonical" : "file", Math.max(0, deadlineAtMs - Date.now())) === null;
   };
 }
-function canonicalOnlyScopes(deps) {
+function canonicalOnlyScopes(deps, deadlineAtMs) {
   const view = deps.legacyScopeView;
   if (!view)
     return void 0;
@@ -118616,7 +118733,7 @@ function canonicalOnlyScopes(deps) {
     for (const { scope, collectedAt } of view.listCanonicalScopes(scopePrefix)) {
       if (stored.has(scope))
         continue;
-      if (await resolveReadDeletion(deps, scope, void 0, "canonical") !== null) {
+      if (await resolveReadDeletion(deps, scope, void 0, "canonical", Math.max(0, deadlineAtMs - Date.now())) !== null) {
         continue;
       }
       listed.push({ scope, latestCollectedAt: collectedAt, versionCount: 0 });
@@ -118818,14 +118935,15 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
       const listAuth = await deps.auth.authorizeBuilderList(request2, {
         grantId: selectedGrantId(request2, url2)
       });
+      const deletionDeadlineAtMs = Date.now() + 250;
       const result = await listDataScopesContract({
         storage: deps.storage,
         scopePrefix: url2.searchParams.get("scopePrefix") ?? void 0,
         limit: normalizeLimit2(url2.searchParams.get("limit"), 20),
         offset: normalizeLimit2(url2.searchParams.get("offset"), 0),
-        isVisible: listingVisibility(deps),
+        isVisible: listingVisibility(deps, deletionDeadlineAtMs),
         isListable: (scope) => !isSystemScope(scope) && (!listAuth || listAuthCovers(listAuth, scope)),
-        extraScopes: canonicalOnlyScopes(deps)
+        extraScopes: canonicalOnlyScopes(deps, deletionDeadlineAtMs)
       });
       return jsonResponse({
         ...result.response,
@@ -119687,7 +119805,7 @@ async function verifyDataWritePolicy(input, ports) {
     });
   }
   if (builder.id.toLowerCase() !== grant.granteeId.toLowerCase()) {
-    throw new InvalidSignatureError3({
+    throw new InvalidSignatureError({
       reason: "Write signer is not the grant builder",
       expected: grant.granteeId,
       actual: input.signer
@@ -119769,7 +119887,7 @@ async function createWriteSession(input, options) {
     });
   }
   if (builder.id.toLowerCase() !== grant.granteeId.toLowerCase()) {
-    throw new InvalidSignatureError3({
+    throw new InvalidSignatureError({
       reason: "Handshake signer is not the grant builder",
       expected: grant.granteeId,
       actual: input.builderAddress
@@ -119988,14 +120106,14 @@ function getErrorDetails(err2) {
   return void 0;
 }
 function mapSdkAuthError(err2) {
-  if (err2 instanceof MissingAuthError) {
-    return new MissingAuthError2(getErrorDetails(err2));
+  if (err2 instanceof MissingAuthError2) {
+    return new MissingAuthError(getErrorDetails(err2));
   }
-  if (err2 instanceof InvalidSignatureError2) {
-    return new InvalidSignatureError3(getErrorDetails(err2));
+  if (err2 instanceof InvalidSignatureError3) {
+    return new InvalidSignatureError(getErrorDetails(err2));
   }
-  if (err2 instanceof ExpiredTokenError) {
-    return new ExpiredTokenError2(getErrorDetails(err2));
+  if (err2 instanceof ExpiredTokenError2) {
+    return new ExpiredTokenError(getErrorDetails(err2));
   }
   return null;
 }
@@ -120539,6 +120657,7 @@ function normalizeState(state) {
       schemaId: entry.schemaId ?? null
     })),
     envelopes: state.envelopes,
+    readyBlockManifests: state.readyBlockManifests ?? [],
     blockManifests: state.blockManifests ?? [],
     blockPayloads: state.blockPayloads ?? [],
     ...state.pendingLedgerDeletes?.length ? { pendingLedgerDeletes: state.pendingLedgerDeletes } : {}
@@ -120788,6 +120907,10 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
     envelope
   ]));
   const fallbackBlockManifests = new Map((state.blockManifests ?? []).map(({ path, manifest }) => [path, manifest]));
+  const readyBlockManifests = /* @__PURE__ */ new Set([
+    ...state.readyBlockManifests ?? [],
+    ...fallbackBlockManifests.keys()
+  ]);
   const fallbackBlockPayloads = new Map((state.blockPayloads ?? []).map(({ path, block }) => [path, block]));
   const ledgerAux = (scope) => `first-seen:${scope}`;
   const firstSeenLedgers = /* @__PURE__ */ new Map();
@@ -120803,6 +120926,7 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
   async function persist() {
     const snapshot = {
       ...state,
+      readyBlockManifests: Array.from(readyBlockManifests),
       envelopes: fileStore.kind === "indexeddb" ? Array.from(fallbackEnvelopes.values()) : [],
       blockManifests: Array.from(fallbackBlockManifests.entries()).map(([path, manifest]) => ({ path, manifest })),
       blockPayloads: Array.from(fallbackBlockPayloads.entries()).map(([path, block]) => ({ path, block })),
@@ -120965,7 +121089,7 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
       return await fileStore.readBlockManifest?.(manifestPath) ?? (fileStore === fallbackStore ? null : await fallbackStore.readBlockManifest?.(manifestPath)) ?? null;
     },
     async hasScopeBlocks(scope, collectedAt) {
-      return Boolean(await storagePort.readBlockManifest?.(scope, collectedAt));
+      return readyBlockManifests.has(blockManifestPath(scope, collectedAt));
     },
     async canReadScopeBlocks(scope, collectedAt) {
       if (await storagePort.hasScopeBlocks?.(scope, collectedAt)) {
@@ -120979,6 +121103,8 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
       return Boolean(envelope);
     },
     async writeBlockManifest(scope, collectedAt, manifest, blocks) {
+      readyBlockManifests.delete(blockManifestPath(scope, collectedAt));
+      await persist();
       const writeTree = async (store) => {
         if (!store.writeBlockManifest || !store.writeBlockPayload) {
           throw new Error("Block sidecar storage is not available");
@@ -121009,6 +121135,7 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
       if (wrotePrimary && fileStore.kind !== "indexeddb") {
         await fallbackStore.deleteBlockTree?.(blockTreePath(scope, collectedAt));
       }
+      readyBlockManifests.add(blockManifestPath(scope, collectedAt));
       await persist();
     },
     async insertEntry(entry) {
@@ -121106,6 +121233,10 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
     deleteScope(scope) {
       return withScopeLock(scope, async () => {
         await dropLedger(scope);
+        for (const entry of entriesForScope(scope)) {
+          readyBlockManifests.delete(blockManifestPath(scope, entry.collectedAt));
+        }
+        await persist();
         let deleted = 0;
         const deletedPaths = [];
         const deletedBlockTrees = [];
@@ -121177,6 +121308,8 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
   }
   async function removeEntryLocked(entry) {
     const blobPath = envelopePath(entry.scope, entry.collectedAt);
+    readyBlockManifests.delete(blockManifestPath(entry.scope, entry.collectedAt));
+    await persist();
     await Promise.all([
       fileStore.deleteEnvelope(blobPath),
       fallbackStore.deleteEnvelope(blobPath),
@@ -124268,7 +124401,15 @@ function createMcpDataReadClient(options) {
         fileId: selectedEntry.fileId ?? void 0,
         metadataOnly: true
       });
-      const manifest = await storage.readBlockManifest(scope, selectedEntry.collectedAt);
+      let manifest;
+      try {
+        manifest = await storage.readBlockManifest(scope, selectedEntry.collectedAt);
+      } catch (err2) {
+        if (err2 instanceof ProtocolError) {
+          throw new McpDataReadError(err2.code, err2.toJSON());
+        }
+        throw err2;
+      }
       await writeReadAccessLog(request2, { scope, grantId, authResult });
       if (manifest && !isOwnerView(authResult)) {
         return {
@@ -138692,22 +138833,22 @@ function parseBearerToken(request2) {
 function assertBearerToken(request2, expectedToken, ownerOnly = false) {
   const token = parseBearerToken(request2);
   if (!token) {
-    throw new MissingAuthError2();
+    throw new MissingAuthError();
   }
   if (token !== expectedToken) {
-    throw ownerOnly ? new NotOwnerError() : new InvalidSignatureError3();
+    throw ownerOnly ? new NotOwnerError() : new InvalidSignatureError();
   }
 }
 function createMissingAuthAdapter() {
   return {
     async authorizeOwner() {
-      throw new MissingAuthError2();
+      throw new MissingAuthError();
     },
     async authorizeBuilderList() {
-      throw new MissingAuthError2();
+      throw new MissingAuthError();
     },
     async authorizeBuilderRead() {
-      throw new MissingAuthError2();
+      throw new MissingAuthError();
     }
   };
 }
@@ -138878,7 +139019,7 @@ function resolveX402Settings(config2, gateway = config2?.gateway) {
   };
 }
 function warnLegacyProjectionIssue(issue2) {
-  console.warn(issue2.kind === "projection_failed" ? "[legacy-projection] projection failed; serving stored body" : "[legacy-projection] projection left rows out", issue2);
+  console.warn(issue2.kind === "projection_failed" ? "[legacy-projection] served read refused" : "[legacy-projection] projection left rows out", issue2);
 }
 function createPsLiteRuntime(options) {
   let active = options.active ?? false;
@@ -140067,6 +140208,7 @@ function createGatewayDataPointFeed(options) {
       const url2 = `${base}${uri}?includeDeleted=true`;
       const ownerSigner = isSystemScope(input.scope) ? options.ownerRequestSigner : void 0;
       const res = ownerSigner ? await fetchImpl(url2, {
+        ...input.signal ? { signal: input.signal } : {},
         headers: {
           Authorization: await ownerSigner.signRequest({
             aud: new URL(base).origin,
@@ -140074,7 +140216,7 @@ function createGatewayDataPointFeed(options) {
             uri
           })
         }
-      }) : await fetchImpl(url2);
+      }) : input.signal ? await fetchImpl(url2, { signal: input.signal }) : await fetchImpl(url2);
       if (res.status === 404)
         return null;
       if (res.status === 410) {