@opendatalabs/personal-server-ts-server 1.27.0 → 1.28.0

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

@@ -45302,7 +45302,7 @@ function FpSqrt(P11) {
     return sqrt5mod8;
   return tonelliShanks(P11);
 }
-function validateField(field) {
+function validateField(field2) {
   const initial = {
     ORDER: "bigint",
     MASK: "bigint",
@@ -45313,7 +45313,7 @@ function validateField(field) {
     map2[val] = "function";
     return map2;
   }, initial);
-  return validateObject(field, opts);
+  return validateObject(field2, opts);
 }
 function FpPow(Fp2, num2, power) {
   if (power < _0n3)
@@ -45518,11 +45518,11 @@ function validateMSMPoints(points, c10) {
       throw new Error("invalid point at index " + i10);
   });
 }
-function validateMSMScalars(scalars, field) {
+function validateMSMScalars(scalars, field2) {
   if (!Array.isArray(scalars))
     throw new Error("array of scalars expected");
   scalars.forEach((s10, i10) => {
-    if (!field.isValid(s10))
+    if (!field2.isValid(s10))
       throw new Error("invalid scalar at index " + i10);
   });
 }
@@ -46827,13 +46827,13 @@ function hash_to_field(msg, count, options) {
   }
   return u10;
 }
-function isogenyMap(field, map2) {
+function isogenyMap(field2, map2) {
   const coeff = map2.map((i10) => Array.from(i10).reverse());
   return (x10, y10) => {
-    const [xn3, xd2, yn3, yd2] = coeff.map((val) => val.reduce((acc, i10) => field.add(field.mul(acc, x10), i10)));
-    const [xd_inv, yd_inv] = FpInvertBatch(field, [xd2, yd2], true);
-    x10 = field.mul(xn3, xd_inv);
-    y10 = field.mul(y10, field.mul(yn3, yd_inv));
+    const [xn3, xd2, yn3, yd2] = coeff.map((val) => val.reduce((acc, i10) => field2.add(field2.mul(acc, x10), i10)));
+    const [xd_inv, yd_inv] = FpInvertBatch(field2, [xd2, yd2], true);
+    x10 = field2.mul(xn3, xd_inv);
+    y10 = field2.mul(y10, field2.mul(yn3, yd_inv));
     return { x: x10, y: y10 };
   };
 }
@@ -90109,24 +90109,24 @@ var hebNutrition = {
       if (["high", "medium", "low"].includes(String(n10.confidence))) {
         item.confidence = n10.confidence;
       }
-      for (const field of hebNutritionFields.slice(4, 19)) {
-        if (n10[field] === null || typeof n10[field] === "number") {
-          item[field] = n10[field];
+      for (const field2 of hebNutritionFields.slice(4, 19)) {
+        if (n10[field2] === null || typeof n10[field2] === "number") {
+          item[field2] = n10[field2];
         }
       }
       if (n10.serving_size === null || typeof n10.serving_size === "string")
         item.servingSize = n10.serving_size;
       if (n10.servings_per_container === null || typeof n10.servings_per_container === "string")
         item.servingsPerContainer = n10.servings_per_container;
-      for (const field of [
+      for (const field2 of [
         "upc",
         "ingredients",
         "allergens",
         "category",
         "highlights"
       ]) {
-        if (n10[field] !== void 0)
-          item[field] = n10[field];
+        if (n10[field2] !== void 0)
+          item[field2] = n10[field2];
       }
       const paddedProductId = n10.product_id.padStart(9, "0");
       item.images = {
@@ -90580,7 +90580,7 @@ var wholefoodsNutrition = {
       if (["high", "medium", "low"].includes(String(n10.confidence))) {
         item.confidence = n10.confidence;
       }
-      for (const field of [
+      for (const field2 of [
         "calories",
         "protein_g",
         "carbs_g",
@@ -90589,8 +90589,8 @@ var wholefoodsNutrition = {
         "fiber_g",
         "sugar_g"
       ]) {
-        if (n10[field] === null || typeof n10[field] === "number") {
-          item[field] = n10[field];
+        if (n10[field2] === null || typeof n10[field2] === "number") {
+          item[field2] = n10[field2];
         }
       }
       if (n10.serving_size === null || typeof n10.serving_size === "string")
@@ -90721,8 +90721,8 @@ var icloudNotes = {
     const notes = byStream(records, "notes").map((note) => {
       if (typeof note.id !== "string" || note.id.length === 0)
         return void 0;
-      const optionalString = (field) => {
-        const value = note[field];
+      const optionalString = (field2) => {
+        const value = note[field2];
         return value == null || typeof value === "string" ? value ?? null : void 0;
       };
       const title = optionalString("title");
@@ -90899,22 +90899,22 @@ function browserBinding(stream) {
           }
         };
       }
-      for (const field of requiredByStream[stream]) {
-        if (snapshot[field] === void 0 || snapshot[field] === null) {
+      for (const field2 of requiredByStream[stream]) {
+        if (snapshot[field2] === void 0 || snapshot[field2] === null) {
           return {
             ok: false,
             error: {
               kind: "incomplete_scope",
               scope,
-              reason: `${stream}.${field} is unavailable`
+              reason: `${stream}.${field2} is unavailable`
             }
           };
         }
       }
       const payload = {};
-      for (const field of fields) {
-        if (Object.hasOwn(snapshot, field))
-          payload[field] = snapshot[field];
+      for (const field2 of fields) {
+        if (Object.hasOwn(snapshot, field2))
+          payload[field2] = snapshot[field2];
       }
       if (stream === "events" && Object.hasOwn(payload, "windowDescription")) {
         payload.windowDescription = legacyEventsWindowDescription;
@@ -91211,7 +91211,7 @@ function inPrimaryKeyOrder(records, primaryKey) {
   const keyOf = (record2) => {
     const data = record2.data;
     const fields = primaryKey[record2.stream] ?? [];
-    return JSON.stringify(fields.map((field) => data && typeof data === "object" ? data[field] ?? null : null));
+    return JSON.stringify(fields.map((field2) => data && typeof data === "object" ? data[field2] ?? null : null));
   };
   return records.map((record2, index) => ({ record: record2, index, key: keyOf(record2) })).sort((a10, b10) => {
     if (a10.record.stream !== b10.record.stream)
@@ -91788,14 +91788,14 @@ function malformedCursor(message) {
     }
   };
 }
-function assertNonEmptyString(value, field) {
+function assertNonEmptyString(value, field2) {
   if (value.length === 0) {
-    throw new Error(`${field} must be a non-empty string`);
+    throw new Error(`${field2} must be a non-empty string`);
   }
 }
-function assertNonNegativeInteger(value, field) {
+function assertNonNegativeInteger(value, field2) {
   if (!isNonNegativeInteger(value)) {
-    throw new Error(`${field} must be a non-negative integer`);
+    throw new Error(`${field2} must be a non-negative integer`);
   }
 }
 function isNonNegativeInteger(value) {
@@ -92257,6 +92257,7 @@ function classifyStoredBody(scope, data) {
   return isProjectedScope(scope) && !data.records.some(isTaggedRecord) ? "pdpp-projected" : "pdpp-unprojected";
 }
 var SERVED = /* @__PURE__ */ Symbol.for("personal-server-ts.legacy-projection.served");
+var PROJECTED_VIEW = /* @__PURE__ */ Symbol.for("personal-server-ts.legacy-projection.projected-view");
 var textEncoder5 = new TextEncoder();
 var FORM_CACHE_SIZE = 64;
 function withLegacyProjection(raw, options = {}) {
@@ -92361,7 +92362,8 @@ function withLegacyProjection(raw, options = {}) {
     const envelope = { ...own, data: result.payload };
     return {
       envelope,
-      bytes: textEncoder5.encode(JSON.stringify(envelope))
+      bytes: textEncoder5.encode(JSON.stringify(envelope)),
+      ...result.diagnostics?.length ? { diagnostics: result.diagnostics } : {}
     };
   }
   async function builtBlocks(scope, view) {
@@ -92375,6 +92377,7 @@ function withLegacyProjection(raw, options = {}) {
   }
   const overrides = {
     [SERVED]: true,
+    [PROJECTED_VIEW]: projected,
     async readEnvelope(scope, collectedAt) {
       const { view, own } = await resolve(scope, collectedAt);
       return view?.envelope ?? own ?? raw.readEnvelope(scope, collectedAt);
@@ -92512,6 +92515,128 @@ function isRecordsBody(data) {
   const keys = Object.keys(data).filter((key) => !SERVER_STAMP_KEYS.has(key));
   return keys.length === 1 && keys[0] === "records" && Array.isArray(data.records);
 }
+async function supersedeLegacyVersions(storage, scope, committedAt) {
+  const refuse = (refused) => ({
+    superseded: [],
+    refused
+  });
+  const readStored = (storage.readStoredEnvelope ?? storage.readEnvelope).bind(storage);
+  const committed = await readStored(scope, committedAt);
+  if (classifyStoredBody(scope, committed.data) !== "pdpp-projected") {
+    return refuse("the new version is not PDPP records of a projected scope");
+  }
+  const projectedView = storage[PROJECTED_VIEW];
+  const view = projectedView ? await projectedView(scope, committedAt) : null;
+  if (!view)
+    return refuse("the new version cannot be projected");
+  if (view.diagnostics?.length) {
+    const kinds = [...new Set(view.diagnostics.map((d10) => d10.kind))];
+    return refuse(`the projection is partial (${kinds.join(", ")})`);
+  }
+  const collection = legacyCollectionKey(scope);
+  const projectedItems = view.envelope.data[collection];
+  const projectedCount = projectedItems.length;
+  const committedMs = Date.parse(committedAt);
+  const older = [];
+  const pageSize = 100;
+  for (let offset = 0; ; offset += pageSize) {
+    const page = storage.listVersions(scope, { limit: pageSize, offset });
+    for (const entry of page) {
+      if (Date.parse(entry.collectedAt) < committedMs) {
+        older.push(entry.collectedAt);
+      }
+    }
+    if (page.length < pageSize)
+      break;
+  }
+  const legacy = [];
+  for (const collectedAt of older) {
+    const envelope = await readStored(scope, collectedAt);
+    if (isBinaryEnvelope(envelope))
+      continue;
+    const items = legacyCollection(scope, envelope.data);
+    if (items === null)
+      continue;
+    legacy.push({
+      collectedAt,
+      count: items.length,
+      ids: items.map(itemId).filter((id2) => id2 !== void 0),
+      items
+    });
+  }
+  const newest = legacy.reduce((best, version4) => !best || Date.parse(version4.collectedAt) > Date.parse(best.collectedAt) ? version4 : best, void 0);
+  if (newest && projectedCount < newest.count) {
+    return refuse(`the projection has ${projectedCount} ${collection}; the newest legacy version has ${newest.count}`);
+  }
+  if (newest) {
+    const projectedIds = new Set(projectedItems.map(itemId).filter((id2) => id2 !== void 0));
+    const missing = newest.ids.filter((id2) => !projectedIds.has(id2));
+    if (missing.length > 0) {
+      return refuse(`the projection lacks ${missing.length} of the ${collection} in the newest legacy version`);
+    }
+    const shortfall = nestedShortfall(scope, newest.items, projectedItems);
+    if (shortfall)
+      return refuse(shortfall);
+  }
+  const superseded = [];
+  for (const { collectedAt } of legacy) {
+    if (await storage.deleteVersion(scope, collectedAt)) {
+      superseded.push(collectedAt);
+    }
+  }
+  return { superseded };
+}
+var NESTED_ITEMS = {
+  "claude.conversations": (item) => ({
+    held: arrayLength(field(item, "messages")),
+    selfShort: false
+  }),
+  "claude.projects": (item) => {
+    const detail = field(item, "detail");
+    const rawDocs = field(detail, "raw_docs");
+    const raw = Array.isArray(rawDocs) ? rawDocs : [];
+    const withId = raw.filter((doc) => typeof field(doc, "uuid") === "string");
+    const docs = arrayLength(field(detail, "docs"));
+    return {
+      held: docs + raw.length - withId.length,
+      selfShort: docs < withId.length
+    };
+  }
+};
+function field(value, key) {
+  return value !== null && typeof value === "object" ? value[key] : void 0;
+}
+function arrayLength(value) {
+  return Array.isArray(value) ? value.length : 0;
+}
+function nestedShortfall(scope, legacyItems, projectedItems) {
+  const nested = NESTED_ITEMS[scope];
+  if (!nested)
+    return void 0;
+  const projectedById = new Map(projectedItems.map((item) => [itemId(item), nested(item).held]));
+  const short = legacyItems.filter((item) => (projectedById.get(itemId(item)) ?? 0) < nested(item).held);
+  const incomplete = projectedItems.filter((item) => nested(item).selfShort);
+  const count = short.length + incomplete.length;
+  return count > 0 ? `the projection holds fewer nested rows than the source or the newest legacy version for ${count} of the ${legacyCollectionKey(scope)}` : void 0;
+}
+function legacyCollectionKey(scope) {
+  return scope.slice(scope.indexOf(".") + 1);
+}
+function legacyCollection(scope, data) {
+  if (data === null || typeof data !== "object" || Array.isArray(data)) {
+    return null;
+  }
+  if (isRecordsBody(data) || "$writtenBy" in data)
+    return null;
+  const items = data[legacyCollectionKey(scope)];
+  return Array.isArray(items) ? items : null;
+}
+function itemId(item) {
+  if (item === null || typeof item !== "object")
+    return void 0;
+  const { id: id2, uuid: uuid3 } = item;
+  return typeof id2 === "string" ? id2 : typeof uuid3 === "string" ? uuid3 : void 0;
+}
 
 // ../../node_modules/viem/_esm/index.js
 init_exports();
@@ -93400,12 +93525,12 @@ function hashStruct({ data, primaryType, types }) {
 function encodeData({ data, primaryType, types }) {
   const encodedTypes = [{ type: "bytes32" }];
   const encodedValues = [hashType({ primaryType, types })];
-  for (const field of types[primaryType]) {
+  for (const field2 of types[primaryType]) {
     const [type, value] = encodeField({
       types,
-      name: field.name,
-      type: field.type,
-      value: data[field.name]
+      name: field2.name,
+      type: field2.type,
+      value: data[field2.name]
     });
     encodedTypes.push(type);
     encodedValues.push(value);
@@ -93433,8 +93558,8 @@ function findTypeDependencies({ primaryType: primaryType_, types }, results = /*
     return results;
   }
   results.add(primaryType);
-  for (const field of types[primaryType]) {
-    findTypeDependencies({ primaryType: field.type, types }, results);
+  for (const field2 of types[primaryType]) {
+    findTypeDependencies({ primaryType: field2.type, types }, results);
   }
   return results;
 }
@@ -97185,10 +97310,10 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     const shape = def.shape;
     const propValues = {};
     for (const key in shape) {
-      const field = shape[key]._zod;
-      if (field.values) {
+      const field2 = shape[key]._zod;
+      if (field2.values) {
         propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
-        for (const v10 of field.values)
+        for (const v10 of field2.values)
           propValues[key].add(v10);
       }
     }
@@ -115112,6 +115237,25 @@ function encodePaymentResponseHeader(body) {
 function contractResponse(result) {
   return jsonResponse(result.body, { status: result.status });
 }
+async function supersedeAfterCommit(deps, scope, committedAt) {
+  try {
+    const result = await supersedeLegacyVersions(deps.storage, scope, committedAt);
+    if (result.superseded.length > 0) {
+      deps.logger?.info?.({ scope, committedAt, superseded: result.superseded }, "Deleted legacy-form versions superseded by a PDPP write");
+    }
+    if (result.refused) {
+      deps.logger?.info?.({ scope, committedAt, refused: result.refused }, "Kept legacy-form versions; superseding was refused");
+    }
+    return result;
+  } catch (err2) {
+    deps.logger?.warn?.({
+      scope,
+      committedAt,
+      error: err2 instanceof Error ? err2.message : String(err2)
+    }, "Superseding legacy-form versions failed; the write is stored");
+    return { superseded: [], refused: "superseding failed" };
+  }
+}
 function contractErrorResponse(err2) {
   return jsonResponse(err2.body, { status: err2.status });
 }
@@ -115412,12 +115556,12 @@ function fireReadReport(deps, event, send) {
     warnReadFulfillmentReporterFailed(deps, event, err2);
   }
 }
-async function prepareWriteLineage(deps, scope, field) {
-  if (field === void 0 || field === null)
+async function prepareWriteLineage(deps, scope, field2) {
+  if (field2 === void 0 || field2 === null)
     return void 0;
   return prepareLineage({
     scope,
-    field,
+    field: field2,
     serverOwner: deps.serverOwner,
     storage: deps.storage,
     gateway: deps.lineageGateway,
@@ -115730,6 +115874,15 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
       } else {
         await deps.auth.authorizeOwner(request2);
       }
+      const supersede = url2.searchParams.get("supersede");
+      if (supersede !== null && supersede !== "legacy") {
+        await writeAuth?.releaseProof?.();
+        return errorResponse(400, "INVALID_SUPERSEDE", 'supersede must be "legacy" or absent');
+      }
+      if (supersede !== null && writeAuth) {
+        await writeAuth.releaseProof?.();
+        return errorResponse(403, "FORBIDDEN", "Only the owner can supersede stored versions");
+      }
       let committed = false;
       let releaseStamp;
       const failWrite = async (response) => {
@@ -115769,6 +115922,9 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
           }
         };
         if (!isJsonContentType(request2)) {
+          if (supersede !== null) {
+            return failWrite(errorResponse(400, "INVALID_SUPERSEDE", "supersede applies to JSON writes only"));
+          }
           const bytes2 = new Uint8Array(await request2.arrayBuffer());
           const metadata = parseMetadataHeader(request2.headers.get("x-vana-metadata"));
           const lineage2 = await prepareWriteLineage(deps, scopeResult.scope, extractLineageField(metadata));
@@ -115829,13 +115985,18 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
           ...writeAuth ? { builder: writeAuth.builder } : {}
         }, "Data file ingested");
         await logBuilderWrite();
+        const supersedeResult = supersede === "legacy" ? await supersedeAfterCommit(deps, scopeResult.scope, collectedAtValue) : void 0;
         notifyNewData(deps.syncManager);
         notifyDataWritten(deps, {
           scope: scopeResult.scope,
           collectedAt: collectedAtValue,
           lineageSources: lineage?.sources
         });
-        return jsonResponse(result.response, { status: 201 });
+        return jsonResponse(supersedeResult ? {
+          ...result.response,
+          superseded: supersedeResult.superseded,
+          ...supersedeResult.refused ? { supersedeRefused: supersedeResult.refused } : {}
+        } : result.response, { status: 201 });
       } catch (err2) {
         if (err2 instanceof IngestPersistedError) {
           deps.logger?.error?.({
@@ -117684,7 +117845,7 @@ function parseField(value, index) {
     }
     required2 = value.required;
   }
-  const field = { name, type, required: required2 };
+  const field2 = { name, type, required: required2 };
   if (type === "string") {
     let maxLength = MAX_ANSWER_STRING_CHARS;
     if (value.maxLength !== void 0 && value.maxLength !== null) {
@@ -117693,26 +117854,26 @@ function parseField(value, index) {
       }
       maxLength = value.maxLength;
     }
-    field.maxLength = maxLength;
+    field2.maxLength = maxLength;
   }
   if (type === "number" || type === "integer") {
     const integer2 = type === "integer";
     if (value.min !== void 0 && value.min !== null) {
-      field.min = parseBound(value.min, index, "min", integer2);
+      field2.min = parseBound(value.min, index, "min", integer2);
     }
     if (value.max !== void 0 && value.max !== null) {
-      field.max = parseBound(value.max, index, "max", integer2);
+      field2.max = parseBound(value.max, index, "max", integer2);
     }
-    if (field.min !== void 0 && field.max !== void 0 && field.min > field.max) {
+    if (field2.min !== void 0 && field2.max !== void 0 && field2.min > field2.max) {
       invalid(`answerShape.fields[${index}].min is greater than its max`, {
         index
       });
     }
   }
   if (type === "enum") {
-    field.values = parseEnumValues(value.values, index);
+    field2.values = parseEnumValues(value.values, index);
   }
-  return field;
+  return field2;
 }
 function parseAnswerShapeInput(value) {
   if (value === void 0 || value === null)
@@ -117736,30 +117897,30 @@ function parseAnswerShapeInput(value) {
   const fields = [];
   const names = /* @__PURE__ */ new Set();
   value.fields.forEach((entry, index) => {
-    const field = parseField(entry, index);
-    if (names.has(field.name)) {
-      invalid(`answerShape.fields names "${field.name}" twice`, { index });
+    const field2 = parseField(entry, index);
+    if (names.has(field2.name)) {
+      invalid(`answerShape.fields names "${field2.name}" twice`, { index });
     }
-    names.add(field.name);
-    fields.push(field);
+    names.add(field2.name);
+    fields.push(field2);
   });
   return { fields };
 }
 function compileAnswerShape(shape) {
   const entries = {};
-  for (const field of shape.fields) {
+  for (const field2 of shape.fields) {
     let schema;
-    switch (field.type) {
+    switch (field2.type) {
       case "string":
-        schema = external_exports.string().max(field.maxLength ?? MAX_ANSWER_STRING_CHARS);
+        schema = external_exports.string().max(field2.maxLength ?? MAX_ANSWER_STRING_CHARS);
         break;
       case "number":
       case "integer": {
-        let numeric = field.type === "integer" ? external_exports.int() : external_exports.number();
-        if (field.min !== void 0)
-          numeric = numeric.min(field.min);
-        if (field.max !== void 0)
-          numeric = numeric.max(field.max);
+        let numeric = field2.type === "integer" ? external_exports.int() : external_exports.number();
+        if (field2.min !== void 0)
+          numeric = numeric.min(field2.min);
+        if (field2.max !== void 0)
+          numeric = numeric.max(field2.max);
         schema = numeric;
         break;
       }
@@ -117767,10 +117928,10 @@ function compileAnswerShape(shape) {
         schema = external_exports.boolean();
         break;
       case "enum":
-        schema = external_exports.enum(field.values ?? []);
+        schema = external_exports.enum(field2.values ?? []);
         break;
     }
-    entries[field.name] = field.required ? schema : schema.nullish();
+    entries[field2.name] = field2.required ? schema : schema.nullish();
   }
   return external_exports.object(entries);
 }
@@ -117789,44 +117950,44 @@ function validateAnswerShape(shape, compiled, candidate) {
     };
   }
   const value = {};
-  for (const field of shape.fields) {
-    const entry = parsed.data[field.name];
+  for (const field2 of shape.fields) {
+    const entry = parsed.data[field2.name];
     if (entry === void 0 || entry === null)
       continue;
-    value[field.name] = entry;
+    value[field2.name] = entry;
   }
   return { ok: true, value };
 }
-function describeField(field) {
-  const requirement = field.required ? "required" : "optional";
-  switch (field.type) {
+function describeField(field2) {
+  const requirement = field2.required ? "required" : "optional";
+  switch (field2.type) {
     case "string":
-      return `"${field.name}": string, at most ${field.maxLength ?? MAX_ANSWER_STRING_CHARS} characters (${requirement})`;
+      return `"${field2.name}": string, at most ${field2.maxLength ?? MAX_ANSWER_STRING_CHARS} characters (${requirement})`;
     case "number":
     case "integer": {
-      const kind = field.type === "integer" ? "integer" : "number";
-      const range = field.min !== void 0 && field.max !== void 0 ? ` between ${field.min} and ${field.max}` : field.min !== void 0 ? ` of at least ${field.min}` : field.max !== void 0 ? ` of at most ${field.max}` : "";
-      return `"${field.name}": ${kind}${range} (${requirement})`;
+      const kind = field2.type === "integer" ? "integer" : "number";
+      const range = field2.min !== void 0 && field2.max !== void 0 ? ` between ${field2.min} and ${field2.max}` : field2.min !== void 0 ? ` of at least ${field2.min}` : field2.max !== void 0 ? ` of at most ${field2.max}` : "";
+      return `"${field2.name}": ${kind}${range} (${requirement})`;
     }
     case "boolean":
-      return `"${field.name}": true or false (${requirement})`;
+      return `"${field2.name}": true or false (${requirement})`;
     case "enum":
-      return `"${field.name}": exactly one of ${(field.values ?? []).map((entry) => JSON.stringify(entry)).join(", ")} (${requirement})`;
+      return `"${field2.name}": exactly one of ${(field2.values ?? []).map((entry) => JSON.stringify(entry)).join(", ")} (${requirement})`;
   }
 }
 function describeAnswerShape(shape) {
-  return shape.fields.map((field) => `  ${describeField(field)}`);
+  return shape.fields.map((field2) => `  ${describeField(field2)}`);
 }
 function renderShapedAnswer(shape, value) {
-  return shape.fields.filter((field) => value[field.name] !== void 0).map((field) => `${field.name}: ${String(value[field.name])}`).join("\n");
+  return shape.fields.filter((field2) => value[field2.name] !== void 0).map((field2) => `${field2.name}: ${String(value[field2.name])}`).join("\n");
 }
 function cloneAnswerShape(shape) {
   if (!shape)
     return null;
   return {
-    fields: shape.fields.map((field) => ({
-      ...field,
-      ...field.values ? { values: [...field.values] } : {}
+    fields: shape.fields.map((field2) => ({
+      ...field2,
+      ...field2.values ? { values: [...field2.values] } : {}
     }))
   };
 }
@@ -117933,15 +118094,15 @@ var MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/;
 function isRecord5(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function parseScope(value, field) {
+function parseScope(value, field2) {
   if (typeof value !== "string") {
-    throw new DerivativeQuestionInvalidError(`${field} must be a scope string`, {
-      field
+    throw new DerivativeQuestionInvalidError(`${field2} must be a scope string`, {
+      field: field2
     });
   }
   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) });
+    throw new DerivativeQuestionInvalidError(`${field2} is not a valid scope: ${parsed.body.message}`, { field: field2, scope: value.slice(0, MAX_ECHOED_SCOPE_CHARS) });
   }
   return parsed.scope;
 }
@@ -118318,14 +118479,14 @@ function readContent(body) {
   if (!isRecord7(first) || !isRecord7(first.message))
     return null;
   const index = typeof first.index === "number" ? first.index : 0;
-  const field = `choices.${index}.message.content`;
+  const field2 = `choices.${index}.message.content`;
   const id2 = typeof body.id === "string" ? body.id : "";
   const content = first.message.content;
   if (typeof content === "string")
-    return { content, field, id: id2 };
+    return { content, field: field2, id: id2 };
   if (Array.isArray(content)) {
     const text = content.map((part) => isRecord7(part) && typeof part.text === "string" ? part.text : "").join("");
-    return { content: text, field, id: id2 };
+    return { content: text, field: field2, id: id2 };
   }
   return null;
 }
@@ -118558,7 +118719,7 @@ async function produceAnswer(deps, registration, model, messages) {
       answerShape: shape
     });
   }
-  throw new ComputeFailure(`answer did not match the declared shape (fields: ${shape.fields.map((field) => field.name).join(", ")})`, "internal");
+  throw new ComputeFailure(`answer did not match the declared shape (fields: ${shape.fields.map((field2) => field2.name).join(", ")})`, "internal");
 }
 function collectedAtStamp(now, isTaken) {
   const base = now();
@@ -119379,23 +119540,23 @@ function canonicalJsonBytes(value) {
 // ../core/dist/derivatives/e2ee/aad.js
 var E2EE_REQUEST_AAD_PURPOSE = "aci.e2ee.request.v2";
 var E2EE_RESPONSE_AAD_PURPOSE = "aci.e2ee.response.v2";
-function requestFieldAad(context, field) {
+function requestFieldAad(context, field2) {
   return canonicalJsonBytes({
     purpose: E2EE_REQUEST_AAD_PURPOSE,
     algo: context.algo,
     model: context.model,
-    field,
+    field: field2,
     nonce: context.nonce,
     ts: context.ts
   });
 }
-function responseFieldAad(context, field, id2) {
+function responseFieldAad(context, field2, id2) {
   return canonicalJsonBytes({
     purpose: E2EE_RESPONSE_AAD_PURPOSE,
     algo: context.algo,
     model: context.model,
     id: id2,
-    field,
+    field: field2,
     nonce: context.nonce,
     ts: context.ts
   });
@@ -119815,7 +119976,7 @@ function createPhalaE2eeEncryption(options) {
       }
       const request2 = {
         messages: encrypted,
-        async decryptResponse({ content, field, id: id2, headers: response }) {
+        async decryptResponse({ content, field: field2, id: id2, headers: response }) {
           const served = response.get(ACI_HEADER_KEYSET_DIGEST);
           if (served && served !== gatewayKey.keysetDigest) {
             options.logger?.warn?.({ pinned: gatewayKey.keysetDigest, served }, "E2EE keyset digest changed; refetching the attestation report");
@@ -119825,11 +119986,11 @@ function createPhalaE2eeEncryption(options) {
             return await decryptField({
               wire: content,
               privateKey: client.privateKey,
-              aad: responseFieldAad(context, field, id2)
+              aad: responseFieldAad(context, field2, id2)
             });
           } catch (err2) {
             const detail = err2 instanceof E2eeCipherError ? err2.message : "unexpected error";
-            throw new InferenceRequestError(`e2ee response decryption failed for ${field} (${detail})`, null, { errorType: "e2ee_decryption_failed", retryable: false });
+            throw new InferenceRequestError(`e2ee response decryption failed for ${field2} (${detail})`, null, { errorType: "e2ee_decryption_failed", retryable: false });
           }
         }
       };
@@ -120946,16 +121107,16 @@ var MiniSearch = class _MiniSearch {
     }
     const shortDocumentId = this.addDocumentId(id2);
     this.saveStoredFields(shortDocumentId, document2);
-    for (const field of fields) {
-      const fieldValue = extractField(document2, field);
+    for (const field2 of fields) {
+      const fieldValue = extractField(document2, field2);
       if (fieldValue == null)
         continue;
-      const tokens = tokenize(stringifyField(fieldValue, field), field);
-      const fieldId = this._fieldIds[field];
+      const tokens = tokenize(stringifyField(fieldValue, field2), field2);
+      const fieldId = this._fieldIds[field2];
       const uniqueTerms = new Set(tokens).size;
       this.addFieldLength(shortDocumentId, fieldId, this._documentCount - 1, uniqueTerms);
       for (const term of tokens) {
-        const processedTerm = processTerm2(term, field);
+        const processedTerm = processTerm2(term, field2);
         if (Array.isArray(processedTerm)) {
           for (const t10 of processedTerm) {
             this.addTerm(fieldId, shortDocumentId, t10);
@@ -121026,16 +121187,16 @@ var MiniSearch = class _MiniSearch {
     if (shortId == null) {
       throw new Error(`MiniSearch: cannot remove document with ID ${id2}: it is not in the index`);
     }
-    for (const field of fields) {
-      const fieldValue = extractField(document2, field);
+    for (const field2 of fields) {
+      const fieldValue = extractField(document2, field2);
       if (fieldValue == null)
         continue;
-      const tokens = tokenize(stringifyField(fieldValue, field), field);
-      const fieldId = this._fieldIds[field];
+      const tokens = tokenize(stringifyField(fieldValue, field2), field2);
+      const fieldId = this._fieldIds[field2];
       const uniqueTerms = new Set(tokens).size;
       this.removeFieldLength(shortId, fieldId, this._documentCount, uniqueTerms);
       for (const term of tokens) {
-        const processedTerm = processTerm2(term, field);
+        const processedTerm = processTerm2(term, field2);
         if (Array.isArray(processedTerm)) {
           for (const t10 of processedTerm) {
             this.removeTerm(fieldId, shortId, t10);
@@ -121785,7 +121946,7 @@ var MiniSearch = class _MiniSearch {
    */
   executeQuerySpec(query, searchOptions) {
     const options = { ...this._options.searchOptions, ...searchOptions };
-    const boosts = (options.fields || this._options.fields).reduce((boosts2, field) => ({ ...boosts2, [field]: getOwnProperty(options.boost, field) || 1 }), {});
+    const boosts = (options.fields || this._options.fields).reduce((boosts2, field2) => ({ ...boosts2, [field2]: getOwnProperty(options.boost, field2) || 1 }), {});
     const { boostDocument, weights, maxFuzzy, bm25: bm25params } = options;
     const { fuzzy: fuzzyWeight, prefix: prefixWeight } = { ...defaultSearchOptions.weights, ...weights };
     const data = this._index.get(query.term);
@@ -121906,9 +122067,9 @@ var MiniSearch = class _MiniSearch {
   termResults(sourceTerm, derivedTerm, termWeight, termBoost, fieldTermData, fieldBoosts, boostDocumentFn, bm25params, results = /* @__PURE__ */ new Map()) {
     if (fieldTermData == null)
       return results;
-    for (const field of Object.keys(fieldBoosts)) {
-      const fieldBoost = fieldBoosts[field];
-      const fieldId = this._fieldIds[field];
+    for (const field2 of Object.keys(fieldBoosts)) {
+      const fieldBoost = fieldBoosts[field2];
+      const fieldId = this._fieldIds[field2];
       const fieldTermFreqs = fieldTermData.get(fieldId);
       if (fieldTermFreqs == null)
         continue;
@@ -121933,15 +122094,15 @@ var MiniSearch = class _MiniSearch {
           assignUniqueTerm(result.terms, sourceTerm);
           const match = getOwnProperty(result.match, derivedTerm);
           if (match) {
-            match.push(field);
+            match.push(field2);
           } else {
-            result.match[derivedTerm] = [field];
+            result.match[derivedTerm] = [field2];
           }
         } else {
           results.set(docId, {
             score: weightedScore,
             terms: [sourceTerm],
-            match: { [derivedTerm]: [field] }
+            match: { [derivedTerm]: [field2] }
           });
         }
       }
@@ -132709,11 +132870,11 @@ var McpServer = class {
       return EMPTY_COMPLETION_RESULT;
     }
     const promptShape = getObjectShape(prompt.argsSchema);
-    const field = promptShape?.[request2.params.argument.name];
-    if (!isCompletable(field)) {
+    const field2 = promptShape?.[request2.params.argument.name];
+    if (!isCompletable(field2)) {
       return EMPTY_COMPLETION_RESULT;
     }
-    const completer = getCompleter(field);
+    const completer = getCompleter(field2);
     if (!completer) {
       return EMPTY_COMPLETION_RESULT;
     }
@@ -132986,8 +133147,8 @@ var McpServer = class {
     };
     this._registeredPrompts[name] = registeredPrompt;
     if (argsSchema) {
-      const hasCompletable = Object.values(argsSchema).some((field) => {
-        const inner = field instanceof ZodOptional ? field._def?.innerType : field;
+      const hasCompletable = Object.values(argsSchema).some((field2) => {
+        const inner = field2 instanceof ZodOptional ? field2._def?.innerType : field2;
         return isCompletable(inner);
       });
       if (hasCompletable) {
@@ -133220,9 +133381,9 @@ function promptArgumentsFromSchema(schema) {
   const shape = getObjectShape(schema);
   if (!shape)
     return [];
-  return Object.entries(shape).map(([name, field]) => {
-    const description = getSchemaDescription(field);
-    const isOptional = isSchemaOptional(field);
+  return Object.entries(shape).map(([name, field2]) => {
+    const description = getSchemaDescription(field2);
+    const isOptional = isSchemaOptional(field2);
     return {
       name,
       description,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opendatalabs/personal-server-ts-server",
-  "version": "1.27.0",
+  "version": "1.28.0",
   "description": "Hono HTTP server for the Vana Personal Server — routes, middleware, composition root",
   "license": "MIT",
   "repository": {
@@ -51,8 +51,8 @@
   },
   "dependencies": {
     "@hono/node-server": "^1.19.13",
-    "@opendatalabs/personal-server-ts-core": "1.27.0",
-    "@opendatalabs/personal-server-ts-lite": "1.27.0",
+    "@opendatalabs/personal-server-ts-core": "1.28.0",
+    "@opendatalabs/personal-server-ts-lite": "1.28.0",
     "@opendatalabs/vana-sdk": "3.23.0-pr.211.36da1d8",
     "better-sqlite3": "^12.11.1",
     "hono": "^4.12.27",