@opendatalabs/personal-server-ts-server 1.32.0 → 1.33.1

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

@@ -43409,10 +43409,10 @@ function concatBytes(...arrays) {
     sum += a10.length;
   }
   const res = new Uint8Array(sum);
-  for (let i10 = 0, pad2 = 0; i10 < arrays.length; i10++) {
+  for (let i10 = 0, pad3 = 0; i10 < arrays.length; i10++) {
     const a10 = arrays[i10];
-    res.set(a10, pad2);
-    pad2 += a10.length;
+    res.set(a10, pad3);
+    pad3 += a10.length;
   }
   return res;
 }
@@ -44910,16 +44910,16 @@ var init_hmac = __esm({
         this.blockLen = this.iHash.blockLen;
         this.outputLen = this.iHash.outputLen;
         const blockLen = this.blockLen;
-        const pad2 = new Uint8Array(blockLen);
-        pad2.set(key.length > blockLen ? hash2.create().update(key).digest() : key);
-        for (let i10 = 0; i10 < pad2.length; i10++)
-          pad2[i10] ^= 54;
-        this.iHash.update(pad2);
+        const pad3 = new Uint8Array(blockLen);
+        pad3.set(key.length > blockLen ? hash2.create().update(key).digest() : key);
+        for (let i10 = 0; i10 < pad3.length; i10++)
+          pad3[i10] ^= 54;
+        this.iHash.update(pad3);
         this.oHash = hash2.create();
-        for (let i10 = 0; i10 < pad2.length; i10++)
-          pad2[i10] ^= 54 ^ 92;
-        this.oHash.update(pad2);
-        clean(pad2);
+        for (let i10 = 0; i10 < pad3.length; i10++)
+          pad3[i10] ^= 54 ^ 92;
+        this.oHash.update(pad3);
+        clean(pad3);
       }
       update(buf) {
         aexists(this);
@@ -45066,10 +45066,10 @@ function concatBytes3(...arrays) {
     sum += a10.length;
   }
   const res = new Uint8Array(sum);
-  for (let i10 = 0, pad2 = 0; i10 < arrays.length; i10++) {
+  for (let i10 = 0, pad3 = 0; i10 < arrays.length; i10++) {
     const a10 = arrays[i10];
-    res.set(a10, pad2);
-    pad2 += a10.length;
+    res.set(a10, pad3);
+    pad3 += a10.length;
   }
   return res;
 }
@@ -71384,13 +71384,13 @@ var require_cipher = __commonJS({
       }
       this._input.compact();
     };
-    BlockCipher.prototype.finish = function(pad2) {
-      if (pad2 && (this.mode.name === "ECB" || this.mode.name === "CBC")) {
+    BlockCipher.prototype.finish = function(pad3) {
+      if (pad3 && (this.mode.name === "ECB" || this.mode.name === "CBC")) {
         this.mode.pad = function(input) {
-          return pad2(this.blockSize, input, false);
+          return pad3(this.blockSize, input, false);
         };
         this.mode.unpad = function(output) {
-          return pad2(this.blockSize, output, true);
+          return pad3(this.blockSize, output, true);
         };
       }
       var options = {};
@@ -75188,11 +75188,11 @@ var require_rc2 = __commonJS({
          *
          * @return true if successful, false on error.
          */
-        finish: function(pad2) {
+        finish: function(pad3) {
           var rval = true;
           if (encrypt) {
-            if (pad2) {
-              rval = pad2(8, _input, !encrypt);
+            if (pad3) {
+              rval = pad3(8, _input, !encrypt);
             } else {
               var padding = _input.length() === 8 ? 8 : 8 - _input.length();
               _input.fillWithByte(padding, padding);
@@ -75205,8 +75205,8 @@ var require_rc2 = __commonJS({
           if (!encrypt) {
             rval = _input.length() === 0;
             if (rval) {
-              if (pad2) {
-                rval = pad2(8, _output, !encrypt);
+              if (pad3) {
+                rval = pad3(8, _output, !encrypt);
               } else {
                 var len = _output.length();
                 var count = _output.at(len - 1);
@@ -75579,7 +75579,7 @@ var require_jsbn = __commonJS({
         return;
       }
       if (r10 == null) r10 = nbi();
-      var y10 = nbi(), ts3 = this.s, ms3 = m10.s;
+      var y10 = nbi(), ts3 = this.s, ms4 = m10.s;
       var nsh = this.DB - nbits(pm2.data[pm2.t - 1]);
       if (nsh > 0) {
         pm2.lShiftTo(nsh, y10);
@@ -75612,7 +75612,7 @@ var require_jsbn = __commonJS({
       }
       if (q10 != null) {
         r10.drShiftTo(ys3, q10);
-        if (ts3 != ms3) BigInteger.ZERO.subTo(q10, q10);
+        if (ts3 != ms4) BigInteger.ZERO.subTo(q10, q10);
       }
       r10.t = ys3;
       r10.clamp();
@@ -92919,12 +92919,12 @@ function field(value, key) {
 function arrayLength(value) {
   return Array.isArray(value) ? value.length : 0;
 }
-function nestedShortfall(scope, legacyItems, projectedItems) {
+function nestedShortfall(scope, legacyItems2, 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 short = legacyItems2.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;
@@ -93984,7 +93984,7 @@ var isBytes3 = (a10) => a10 instanceof Uint8Array || ArrayBuffer.isView(a10) &&
 var abytes3 = (a10, l10) => !isBytes3(a10) || typeof l10 === "number" && l10 > 0 && a10.length !== l10 ? err("Uint8Array expected") : a10;
 var u8n2 = (len) => new Uint8Array(len);
 var u8fr2 = (buf) => Uint8Array.from(buf);
-var padh = (n10, pad2) => n10.toString(16).padStart(pad2, "0");
+var padh = (n10, pad3) => n10.toString(16).padStart(pad3, "0");
 var bytesToHex4 = (b10) => Array.from(abytes3(b10)).map((e10) => padh(e10, 2)).join("");
 var C = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
 var _ch = (ch3) => {
@@ -94018,10 +94018,10 @@ var toU8 = (a10, len) => abytes3(isStr(a10) ? hexToBytes3(a10) : u8fr2(abytes3(a
 var cr2 = () => globalThis?.crypto;
 var concatBytes4 = (...arrs) => {
   const r10 = u8n2(arrs.reduce((sum, a10) => sum + abytes3(a10).length, 0));
-  let pad2 = 0;
+  let pad3 = 0;
   arrs.forEach((a10) => {
-    r10.set(a10, pad2);
-    pad2 += a10.length;
+    r10.set(a10, pad3);
+    pad3 += a10.length;
   });
   return r10;
 };
@@ -111036,8 +111036,8 @@ function parseRetryAfterBodyMs(responseText) {
 function clampRateLimitDelay(delayMs) {
   return Math.min(Math.max(0, delayMs), MAX_RATE_LIMIT_DELAY_MS);
 }
-function sleep(ms3) {
-  return new Promise((resolve) => setTimeout(resolve, ms3));
+function sleep(ms4) {
+  return new Promise((resolve) => setTimeout(resolve, ms4));
 }
 async function safeText(response) {
   try {
@@ -112982,6 +112982,998 @@ function assertCanonicalJsonBody(bodyBytes) {
   }
 }
 
+// ../core/dist/additions/record-rules.js
+var singleton = () => ({
+  collection: "profile",
+  idFields: [],
+  rowIdFields: [],
+  singleton: true
+});
+var untracked = (collection, aliases) => ({
+  collection,
+  ...aliases ? { aliases } : {},
+  idFields: [],
+  rowIdFields: []
+});
+var sameId = (collection, fields, aliases) => ({
+  collection,
+  ...aliases ? { aliases } : {},
+  idFields: fields,
+  rowIdFields: fields
+});
+var MEMORY_RECORD_RULES = {
+  // --- Empty: the owner app counts 0 records for these. -------------------
+  "chatgpt.memories": [],
+  "chatgpt.messages": [],
+  "github.profile": [],
+  "instagram.profile": [],
+  // --- Tracked: an id that is equal in both stored forms. -----------------
+  "chatgpt.conversations": [sameId("conversations", ["id"])],
+  // Claude's conversations and projects keep the row id in both forms.
+  "claude.conversations": [sameId("conversations", ["id"])],
+  "claude.projects": [sameId("projects", ["id"])],
+  // The binding projects the row's `html_url` into the legacy `url`.
+  "github.repositories": [
+    {
+      collection: "repositories",
+      idFields: ["url"],
+      rowIdFields: ["html_url"]
+    }
+  ],
+  "github.starred": [
+    { collection: "starred", idFields: ["url"], rowIdFields: ["html_url"] }
+  ],
+  "github.events": [sameId("events", ["id"])],
+  // The PDPP streams behind this legacy scope are stored as their own scopes
+  // (`github.issues`, `github.pull_requests`, `github.user`), never as one
+  // `github.history` rows scope, so these rules serve the legacy body only.
+  "github.history": [
+    sameId("issues", ["id"]),
+    sameId("pullRequests", ["id"], ["pull_requests"])
+  ],
+  "github.issues": [sameId("issues", ["id"])],
+  "github.pull_requests": [sameId("pullRequests", ["id"], ["pull_requests"])],
+  // The PDPP `contributions` stream's records become the legacy `days` array.
+  "github.contributions": [sameId("days", ["date"], ["contributions"])],
+  // The binding projects the row `id` into the legacy `recordName`.
+  "icloud_notes.notes": [
+    { collection: "notes", idFields: ["recordName"], rowIdFields: ["id"] }
+  ],
+  "icloud_notes.folders": [
+    { collection: "folders", idFields: ["recordName"], rowIdFields: ["id"] }
+  ],
+  // The legacy post has no id; `taken_at` is copied unchanged.
+  "instagram.posts": [sameId("posts", ["taken_at"])],
+  // The PDPP `following` stream's records become the legacy `accounts` array;
+  // the binding projects the row `id` into the legacy `pk`.
+  "instagram.following": [
+    {
+      collection: "accounts",
+      aliases: ["following"],
+      idFields: ["pk"],
+      rowIdFields: ["id"]
+    }
+  ],
+  // The PDPP `ads` stream carries all kinds; `streamFilter` keeps each
+  // collection to the rows the projection assigns to it. The owner app counts
+  // the category rows too, so they are counted (untracked) here.
+  "instagram.ads": [
+    {
+      ...sameId("ad_topics", ["name"], ["ads"]),
+      streamFilter: { field: "kind", equals: "ad_topic" }
+    },
+    {
+      ...sameId("advertisers", ["name"], ["ads"]),
+      streamFilter: { field: "kind", equals: "advertiser" }
+    },
+    {
+      ...untracked("categories", ["ads"]),
+      streamFilter: { field: "kind", equals: "ad_category" }
+    }
+  ],
+  "discord.servers": [sameId("servers", ["id"])],
+  "discord.messages": [sameId("messages", ["id"])],
+  "discord.connections": [sameId("connections", ["id"])],
+  // These store a PDPP `{ records }` body, whose rows are the collection. The
+  // dataset-named alias keeps a keyed body (`{ posts: [...] }`) on the same
+  // `records:` keys.
+  "x.posts": [sameId("records", ["id"], ["posts"])],
+  "x.likes": [sameId("records", ["id"], ["likes"])],
+  "x.bookmarks": [sameId("records", ["id"], ["bookmarks"])],
+  // The binding projects the row `uri` unchanged.
+  "spotify.playlists": [
+    sameId("playlists", ["uri"], ["public_playlists", "items"])
+  ],
+  "spotify.savedTracks": [
+    sameId("savedTracks", ["uri"], ["tracks", "items", "saved_tracks"])
+  ],
+  // The PDPP stream is `saved_tracks`, so the rows are stored under this
+  // scope; its keys equal the legacy `spotify.savedTracks` keys.
+  "spotify.saved_tracks": [
+    sameId("savedTracks", ["uri"], ["saved_tracks", "tracks", "items"])
+  ],
+  // The legacy body keeps the order number as `orderId`.
+  "amazon.orders": [
+    { collection: "orders", idFields: ["orderId"], rowIdFields: ["id"] }
+  ],
+  "shop.orders": [sameId("orders", ["id"])],
+  "oura.activity": [sameId("days", ["id"], ["activity"])],
+  "oura.readiness": [sameId("days", ["id"], ["readiness"])],
+  "youtube.playlists": [sameId("playlists", ["url"])],
+  // --- Counted, never tracked: the owner app counts them, but no field is --
+  // --- provably equal in both stored forms. They report a total and no -----
+  // --- additions, and a null trackedSince. ---------------------------------
+  // The legacy body drops the row id.
+  "linkedin.experience": [untracked("items", ["experience", "experiences"])],
+  "linkedin.education": [untracked("items", ["education"])],
+  "linkedin.connections": [untracked("connections")],
+  "linkedin.skills": [untracked("skills")],
+  "linkedin.languages": [untracked("languages")],
+  // One `sleep` stream feeds two legacy arrays, so both are counted.
+  "oura.sleep": [
+    untracked("sleepPeriods", ["sleep"]),
+    untracked("dailyScores")
+  ],
+  // No binding fixture proves an id equal in both forms.
+  "heb.orders": [untracked("orders")],
+  "wholefoods.orders": [untracked("orders")],
+  "heb.nutrition": [untracked("nutrition")],
+  "wholefoods.nutrition": [untracked("nutrition")],
+  "youtube.subscriptions": [untracked("subscriptions")],
+  "youtube.likes": [untracked("likedVideos", ["likes"])],
+  "youtube.watchLater": [untracked("watchLater")],
+  "youtube.watch_later": [untracked("watchLater", ["watch_later"])],
+  "youtube.history": [untracked("history")],
+  "youtube.watch_history": [untracked("history", ["watch_history"])],
+  "youtube.playlistItems": [untracked("playlists", ["playlistItems"])],
+  "youtube.playlist_items": [untracked("playlists", ["playlist_items"])],
+  // Single-record scopes.
+  "linkedin.profile": [singleton()],
+  "spotify.profile": [singleton()],
+  "youtube.profile": [singleton()],
+  "heb.profile": [singleton()],
+  "wholefoods.profile": [singleton()],
+  // Streams that only join into another scope's legacy body, which the owner
+  // app counts when they are stored as their own scopes.
+  "amazon.order_items": [untracked("order_items")],
+  "heb.order_items": [untracked("order_items")],
+  "wholefoods.order_items": [untracked("order_items")],
+  "claude.messages": [untracked("messages")],
+  "claude.account_profile": [untracked("account_profile")],
+  "claude.project_documents": [untracked("project_documents")],
+  "github.user": [untracked("user")],
+  "github.user_stats": [untracked("user_stats")],
+  "github.pinned_repositories": [untracked("pinned_repositories")],
+  "github.organizations": [untracked("organizations")],
+  "instagram.post_likes": [untracked("post_likes")],
+  "spotify.playlist_items": [untracked("playlist_items")]
+};
+function memoryRecordRulesFor(scope) {
+  if (!Object.prototype.hasOwnProperty.call(MEMORY_RECORD_RULES, scope)) {
+    return null;
+  }
+  return MEMORY_RECORD_RULES[scope] ?? null;
+}
+
+// ../core/dist/additions/first-added.js
+var MAX_TRACKED_KEYS = 2e5;
+var MAX_ID_LENGTH = 64;
+var MAX_COLLECTION_LENGTH = 64;
+var PRUNE_AFTER_MS = 90 * 24 * 60 * 60 * 1e3;
+var RETRY_UNREADABLE_MS = 60 * 60 * 1e3;
+var MAX_RETRY_VERSIONS = 20;
+var YIELD_EVERY = 2e3;
+function yieldToEventLoop() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+var ID_PROPERTIES = ["id", "uuid", "key", "uri", "url"];
+var SERVER_STAMP_KEYS2 = /* @__PURE__ */ new Set([
+  "$writtenBy",
+  "$lineage"
+]);
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasOwn(data, key) {
+  return Object.prototype.hasOwnProperty.call(data, key);
+}
+function isRowsBody(data) {
+  const keys = Object.keys(data).filter((key) => !SERVER_STAMP_KEYS2.has(key));
+  return keys.length === 1 && keys[0] === "records" && Array.isArray(data.records);
+}
+async function sha256Hex2(input) {
+  const bytes2 = new TextEncoder().encode(input);
+  const digest2 = await globalThis.crypto.subtle.digest("SHA-256", bytes2);
+  let hex3 = "";
+  for (const byte of new Uint8Array(digest2)) {
+    hex3 += byte.toString(16).padStart(2, "0");
+  }
+  return hex3;
+}
+function valueAtPath(obj, path) {
+  let current = obj;
+  for (const segment of path.split(".")) {
+    if (!isRecord3(current) || !hasOwn(current, segment))
+      return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+async function idToken(id2) {
+  if (typeof id2 === "number")
+    return `n:${String(id2)}`;
+  return id2.length > MAX_ID_LENGTH ? `h:${(await sha256Hex2(id2)).slice(0, 32)}` : `i:${id2}`;
+}
+async function collectionToken(name) {
+  if (name.length > MAX_COLLECTION_LENGTH) {
+    return `#${(await sha256Hex2(name)).slice(0, 32)}`;
+  }
+  return name.replace(/[\\:#]/g, (character) => `\\${character}`);
+}
+async function idPart(obj, fields) {
+  for (const field2 of fields) {
+    const value = valueAtPath(obj, field2);
+    if (typeof value === "string" && value.length > 0)
+      return idToken(value);
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return idToken(value);
+    }
+  }
+  return null;
+}
+var KeyCollector = class {
+  keys = /* @__PURE__ */ new Set();
+  total = 0;
+  tooMany = false;
+  /**
+   * Count `items`, and track those with an id. Once the tracked keys pass the
+   * cap it stops collecting (and frees them) but still counts, so a hostile
+   * body costs a bounded amount of work and memory.
+   */
+  async addItems(collection, items, idFields) {
+    this.total += items.length;
+    if (this.tooMany || idFields.length === 0)
+      return;
+    const prefix = await collectionToken(collection);
+    for (let index = 0; index < items.length; index += 1) {
+      if (index % YIELD_EVERY === YIELD_EVERY - 1)
+        await yieldToEventLoop();
+      const item = items[index];
+      if (!isRecord3(item))
+        continue;
+      const id2 = await idPart(item, idFields);
+      if (id2 === null)
+        continue;
+      this.keys.add(`${prefix}:${id2}`);
+      if (this.keys.size > MAX_TRACKED_KEYS) {
+        this.tooMany = true;
+        this.keys.clear();
+        return;
+      }
+    }
+  }
+  result() {
+    return {
+      keys: Array.from(this.keys),
+      total: this.total,
+      ...this.tooMany ? { tooMany: true } : {}
+    };
+  }
+};
+function datasetOf(scope) {
+  const dot = scope.indexOf(".");
+  return dot < 0 ? scope : scope.slice(dot + 1);
+}
+function passesStreamFilter(row, rule) {
+  return !rule.streamFilter || row[rule.streamFilter.field] === rule.streamFilter.equals;
+}
+function legacyItems(data, rule) {
+  for (const name of [rule.collection, ...rule.aliases ?? []]) {
+    if (!hasOwn(data, name))
+      continue;
+    const value = data[name];
+    if (!Array.isArray(value))
+      continue;
+    return value.filter(isRecord3);
+  }
+  return [];
+}
+async function extractRecordKeys(scope, data) {
+  if (!isRecord3(data))
+    return null;
+  const rules = memoryRecordRulesFor(scope);
+  if (rules !== null && rules.length === 0)
+    return { keys: [], total: 0 };
+  if (hasOwn(data, "$binary"))
+    return null;
+  const collector = new KeyCollector();
+  const rows = isRowsBody(data) ? data.records : null;
+  if (rules !== null) {
+    if (rows !== null) {
+      const dataset = datasetOf(scope);
+      const named = rules.filter((rule) => rule.collection === dataset || (rule.aliases ?? []).includes(dataset));
+      const chosen = named.length > 0 ? named : rules.length === 1 ? rules : [];
+      if (chosen.length === 0 && rules.length > 0) {
+        collector.total += rows.length;
+      }
+      for (const rule of chosen) {
+        if (rule.singleton) {
+          collector.total += rows.filter(isRecord3).length;
+          continue;
+        }
+        const items = rows.filter(isRecord3).filter((row) => passesStreamFilter(row, rule));
+        await collector.addItems(rule.collection, items, rule.rowIdFields);
+      }
+    } else {
+      for (const rule of rules) {
+        if (rule.singleton) {
+          if (Object.keys(data).some((key) => !key.startsWith("$"))) {
+            collector.total += 1;
+          }
+          continue;
+        }
+        await collector.addItems(rule.collection, legacyItems(data, rule), rule.idFields);
+      }
+    }
+    return collector.result();
+  }
+  if (rows !== null) {
+    await collector.addItems(datasetOf(scope), rows, ID_PROPERTIES);
+    return collector.result();
+  }
+  let sawArray = false;
+  for (const key of Object.keys(data)) {
+    if (key.startsWith("$"))
+      continue;
+    const value = data[key];
+    if (!Array.isArray(value))
+      continue;
+    sawArray = true;
+    await collector.addItems(key, value, ID_PROPERTIES);
+  }
+  if (!sawArray)
+    collector.total = 1;
+  return collector.result();
+}
+function ms3(value) {
+  return value === null ? Number.NaN : Date.parse(value);
+}
+function isNewer(a10, b10) {
+  if (b10 === null)
+    return true;
+  const difference = Date.parse(a10) - Date.parse(b10);
+  return difference > 0 || difference === 0 && a10 >= b10;
+}
+function isEarlier(a10, b10) {
+  const difference = Date.parse(a10) - Date.parse(b10);
+  return difference < 0 || difference === 0 && a10 < b10;
+}
+function isTrackable(extraction) {
+  return extraction !== null && !extraction.tooMany && (extraction.keys.length > 0 || extraction.total === 0);
+}
+var LedgerFold = class {
+  scope;
+  baseline = null;
+  current = null;
+  latest = null;
+  through = null;
+  retry;
+  skipped;
+  truncated = false;
+  // A Map keeps arbitrary keys (including "__proto__") out of the prototype
+  // chain; Object.fromEntries defines each one as an own property again.
+  records = /* @__PURE__ */ new Map();
+  constructor(ledger, scope) {
+    this.scope = ledger?.scope ?? scope ?? null;
+    if (!ledger)
+      return;
+    this.baseline = ledger.baseline;
+    this.current = ledger.current;
+    this.latest = { ...ledger.latest };
+    this.through = ledger.through;
+    this.retry = ledger.retry ? {
+      versions: [...ledger.retry.versions],
+      attemptedAt: ledger.retry.attemptedAt
+    } : void 0;
+    this.skipped = ledger.skipped;
+    this.truncated = ledger.truncated === true;
+    for (const [key, pair] of Object.entries(ledger.records)) {
+      this.records.set(key, [pair[0], pair[1]]);
+    }
+  }
+  async add(version4) {
+    const at3 = Date.parse(version4.collectedAt);
+    if (Number.isNaN(at3))
+      return;
+    if (this.scope === null)
+      this.scope = version4.scope;
+    if (this.scope !== version4.scope)
+      return;
+    const extraction = await extractRecordKeys(version4.scope, version4.data);
+    const total = extraction?.total ?? 1;
+    if (this.latest === null || isNewer(version4.collectedAt, this.latest.collectedAt)) {
+      this.latest = { collectedAt: version4.collectedAt, total };
+    }
+    if (isNewer(version4.collectedAt, this.through)) {
+      this.through = version4.collectedAt;
+    }
+    if (this.skipped !== void 0)
+      return;
+    if (!isTrackable(extraction))
+      return;
+    if (this.baseline === null) {
+      this.baseline = version4.collectedAt;
+    } else if (isEarlier(version4.collectedAt, this.baseline) && !this.truncated) {
+      this.baseline = version4.collectedAt;
+    }
+    if (isNewer(version4.collectedAt, this.current)) {
+      this.current = version4.collectedAt;
+    }
+    const keys = extraction.keys;
+    const fresh = [];
+    for (let index = 0; index < keys.length; index += 1) {
+      if (index % YIELD_EVERY === YIELD_EVERY - 1)
+        await yieldToEventLoop();
+      const key = keys[index];
+      const existing = this.records.get(key);
+      if (!existing) {
+        fresh.push(key);
+        continue;
+      }
+      if (isEarlier(version4.collectedAt, existing[0])) {
+        existing[0] = version4.collectedAt;
+      }
+      if (isNewer(version4.collectedAt, existing[1])) {
+        existing[1] = version4.collectedAt;
+      }
+    }
+    if (fresh.length > 0)
+      await this.insertFresh(fresh, keys, version4.collectedAt);
+  }
+  /**
+   * Insert the records this version brings that the ledger does not know.
+   * Capacity is decided ONCE: when they do not fit, absent records are evicted
+   * in a single pass (see `evict`), and whatever still does not fit is left
+   * out, smallest keys first, so the result never depends on the order of the
+   * ids in the version.
+   */
+  async insertFresh(fresh, versionKeys, collectedAt) {
+    fresh.sort();
+    let room = MAX_TRACKED_KEYS - this.records.size;
+    if (fresh.length > room) {
+      room += await this.evict(fresh.length - room, new Set(versionKeys));
+    }
+    const take = Math.min(fresh.length, Math.max(0, room));
+    for (let index = 0; index < take; index += 1) {
+      if (index % YIELD_EVERY === YIELD_EVERY - 1)
+        await yieldToEventLoop();
+      this.records.set(fresh[index], [collectedAt, collectedAt]);
+    }
+  }
+  /**
+   * Make room for `need` records by dropping some that are absent: not in the
+   * newest tracked version, not in the version being folded, and not
+   * baseline records (first seen at or before the baseline). Baseline records
+   * are never dropped. Other absent records CAN be dropped (and are
+   * dated as new if they return): that needs a scope near the cap, and
+   * whoever can write the scope can provoke it. Among the evictable ones the
+   * most recently first seen go first. Returns how many were dropped.
+   */
+  async evict(need, inVersion) {
+    const currentMs = ms3(this.current);
+    const baselineMs = ms3(this.baseline);
+    const candidates = [];
+    let seen = 0;
+    for (const [key, pair] of this.records) {
+      seen += 1;
+      if (seen % (YIELD_EVERY * 5) === 0)
+        await yieldToEventLoop();
+      if (inVersion.has(key))
+        continue;
+      if (Date.parse(pair[1]) === currentMs)
+        continue;
+      const firstMs = Date.parse(pair[0]);
+      if (firstMs <= baselineMs)
+        continue;
+      candidates.push([firstMs, key]);
+    }
+    candidates.sort((a10, b10) => b10[0] - a10[0] || (a10[1] < b10[1] ? -1 : a10[1] > b10[1] ? 1 : 0));
+    const count = Math.min(need, candidates.length);
+    for (let index = 0; index < count; index += 1) {
+      this.records.delete(candidates[index][1]);
+    }
+    return count;
+  }
+  /** Drop records that are not present and were last seen over 90 days before `current`. */
+  async prune() {
+    if (this.current === null || this.skipped !== void 0)
+      return;
+    const currentMs = ms3(this.current);
+    const cutoff = currentMs - PRUNE_AFTER_MS;
+    let seen = 0;
+    for (const [key, pair] of this.records) {
+      seen += 1;
+      if (seen % (YIELD_EVERY * 5) === 0)
+        await yieldToEventLoop();
+      const lastMs = Date.parse(pair[1]);
+      if (lastMs !== currentMs && lastMs < cutoff)
+        this.records.delete(key);
+    }
+  }
+  /**
+   * Prune and return the ledger, or null when nothing was ever folded.
+   * `truncated` marks a ledger rebuilt from only the newest retained versions;
+   * `through` overrides the completeness marker (see `ScopeFirstSeenLedger`).
+   */
+  async finish(options = {}) {
+    if (this.scope === null || this.latest === null)
+      return null;
+    await this.prune();
+    const truncated = this.truncated || options.truncated === true;
+    const retry = options.retry === void 0 ? this.retry : options.retry;
+    return {
+      version: 4,
+      scope: this.scope,
+      baseline: this.baseline,
+      current: this.current,
+      latest: this.latest,
+      through: options.through ?? this.through ?? this.latest.collectedAt,
+      ...retry ? { retry } : {},
+      ...this.skipped ? { skipped: this.skipped } : {},
+      ...truncated ? { truncated: true } : {},
+      records: Object.fromEntries(this.records)
+    };
+  }
+};
+function listAddedTimestamps(ledger) {
+  if (ledger.skipped !== void 0 || ledger.baseline === null || ledger.current === null || Date.parse(ledger.current) !== Date.parse(ledger.latest.collectedAt)) {
+    return [];
+  }
+  const baselineMs = Date.parse(ledger.baseline);
+  const currentMs = Date.parse(ledger.current);
+  const added = [];
+  for (const [first, last2] of Object.values(ledger.records)) {
+    if (Date.parse(last2) !== currentMs)
+      continue;
+    if (ledger.partial === true && Date.parse(first) <= baselineMs)
+      continue;
+    added.push(first);
+  }
+  if (added.length > ledger.latest.total) {
+    added.sort();
+    added.length = ledger.latest.total;
+  }
+  return added;
+}
+function parseableString(value) {
+  return typeof value === "string" && !Number.isNaN(Date.parse(value));
+}
+function nullableParseable(value) {
+  return value === null || parseableString(value);
+}
+var SKIP_REASONS = /* @__PURE__ */ new Set(["too_large", "unreadable"]);
+function readScopeFirstSeenLedger(value) {
+  try {
+    if (!isRecord3(value) || value.version !== 4)
+      return null;
+    const { scope, baseline, current, latest, through, records, skipped, truncated } = value;
+    if (typeof scope !== "string" || scope.length === 0)
+      return null;
+    if (!nullableParseable(baseline) || !nullableParseable(current)) {
+      return null;
+    }
+    if (!isRecord3(latest) || !parseableString(latest.collectedAt))
+      return null;
+    if (!parseableString(through))
+      return null;
+    let retryValue;
+    if (value.retry !== void 0) {
+      const retry = value.retry;
+      if (!isRecord3(retry) || !Array.isArray(retry.versions) || retry.versions.length === 0 || retry.versions.length > MAX_RETRY_VERSIONS || !retry.versions.every(parseableString) || !parseableString(retry.attemptedAt)) {
+        return null;
+      }
+      retryValue = {
+        versions: [...retry.versions],
+        attemptedAt: retry.attemptedAt
+      };
+    }
+    const newestKnown = Math.max(Date.parse(latest.collectedAt), ...retryValue?.versions.map((version4) => Date.parse(version4)) ?? []);
+    if (Date.parse(through) > newestKnown)
+      return null;
+    const total = latest.total;
+    if (typeof total !== "number" || !Number.isInteger(total) || total < 0) {
+      return null;
+    }
+    if (skipped !== void 0 && !SKIP_REASONS.has(skipped))
+      return null;
+    if (truncated !== void 0 && truncated !== true)
+      return null;
+    if (!isRecord3(records))
+      return null;
+    const entries = Object.entries(records);
+    if (entries.length > MAX_TRACKED_KEYS)
+      return null;
+    const copied = /* @__PURE__ */ new Map();
+    for (const [key, pair] of entries) {
+      if (!Array.isArray(pair) || pair.length !== 2)
+        return null;
+      if (!parseableString(pair[0]) || !parseableString(pair[1]))
+        return null;
+      copied.set(key, [pair[0], pair[1]]);
+    }
+    return {
+      version: 4,
+      scope,
+      baseline,
+      current,
+      latest: { collectedAt: latest.collectedAt, total },
+      through,
+      ...retryValue ? { retry: retryValue } : {},
+      ...skipped ? { skipped } : {},
+      ...truncated ? { truncated: true } : {},
+      records: Object.fromEntries(copied)
+    };
+  } catch {
+    return null;
+  }
+}
+
+// ../core/dist/additions/scope-lock.js
+var tails = /* @__PURE__ */ new Map();
+async function withScopeLock(scope, fn3) {
+  const previous = tails.get(scope) ?? Promise.resolve();
+  let release;
+  const mine = new Promise((resolve) => {
+    release = resolve;
+  });
+  const tail = previous.then(() => mine);
+  tails.set(scope, tail);
+  await previous;
+  try {
+    return await fn3();
+  } finally {
+    release();
+    if (tails.get(scope) === tail)
+      tails.delete(scope);
+  }
+}
+
+// ../core/dist/additions/ledger-store.js
+var OLDEST_PAGE = 20;
+var REBUILD_VERSION_LIMIT = 200;
+var REBUILD_BYTE_BUDGET = 256 * 1024 * 1024;
+function isRecord4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readsNothing(scope) {
+  return memoryRecordRulesFor(scope)?.length === 0;
+}
+async function readVersionData(storage, scope, collectedAt) {
+  if (readsNothing(scope))
+    return { scope, collectedAt, data: {} };
+  try {
+    const envelope = storage.readStoredEnvelope ? await storage.readStoredEnvelope(scope, collectedAt) : await storage.readEnvelope(scope, collectedAt);
+    if (!isRecord4(envelope.data))
+      return null;
+    return { scope, collectedAt, data: envelope.data };
+  } catch {
+    return null;
+  }
+}
+function retainedVersions(storage, scope) {
+  return storage.listVersions(scope, { limit: REBUILD_VERSION_LIMIT }).filter((entry) => !Number.isNaN(Date.parse(entry.collectedAt))).sort((a10, b10) => Date.parse(b10.collectedAt) - Date.parse(a10.collectedAt) || (a10.collectedAt < b10.collectedAt ? 1 : a10.collectedAt > b10.collectedAt ? -1 : 0));
+}
+function withinBudget(scope, entries, budget) {
+  if (readsNothing(scope))
+    return [...entries];
+  const selected = [];
+  let used = 0;
+  for (const entry of entries) {
+    used += Math.max(0, entry.sizeBytes ?? 0);
+    if (used > budget)
+      break;
+    selected.push(entry);
+  }
+  return selected;
+}
+async function readStoredLedger(storage, scope) {
+  if (!storage.readFirstSeenLedger)
+    return null;
+  try {
+    const ledger = readScopeFirstSeenLedger(await storage.readFirstSeenLedger(scope));
+    return ledger !== null && ledger.scope === scope ? ledger : null;
+  } catch {
+    return null;
+  }
+}
+async function dropIfScopeEmpty(storage, scope) {
+  if (storage.findEntry({ scope }))
+    return false;
+  await storage.deleteFirstSeenLedger?.(scope);
+  return true;
+}
+function latestStillStored(storage, ledger) {
+  return storage.findEntry({ scope: ledger.scope, at: ledger.latest.collectedAt })?.collectedAt === ledger.latest.collectedAt;
+}
+function baselineStillStored(storage, ledger) {
+  if (ledger.baseline === null)
+    return true;
+  return storage.findEntry({ scope: ledger.scope, at: ledger.baseline })?.collectedAt === ledger.baseline;
+}
+function isMarker(ledger) {
+  return ledger.skipped === "too_large" || ledger.skipped === "unreadable";
+}
+function newerThan(retained, ledger) {
+  const throughMs = Date.parse(ledger.through);
+  return retained.filter((entry) => Date.parse(entry.collectedAt) > throughMs);
+}
+async function foldEntries(storage, scope, entries, fold) {
+  let folded = 0;
+  const failed = [];
+  for (const entry of [...entries].reverse()) {
+    const version4 = await readVersionData(storage, scope, entry.collectedAt);
+    if (version4) {
+      await fold.add(version4);
+      folded += 1;
+    } else {
+      failed.push(entry);
+    }
+    await yieldToEventLoop();
+  }
+  return { folded, failed };
+}
+function oldestStartsAtFirst(oldestInstant) {
+  const lowest = oldestInstant.reduce((a10, b10) => b10.version < a10.version ? b10 : a10);
+  return lowest.version <= 1 || (lowest.afterTombstoneVersion ?? null) !== null;
+}
+function baselineIsKnown(storage, ledger) {
+  if (ledger.baseline === null || ledger.skipped !== void 0)
+    return true;
+  if (ledger.truncated === true)
+    return false;
+  const count = storage.countVersions(ledger.scope);
+  const tail = storage.listVersions(ledger.scope, {
+    limit: OLDEST_PAGE,
+    offset: Math.max(0, count - OLDEST_PAGE)
+  }).filter((entry) => !Number.isNaN(Date.parse(entry.collectedAt)));
+  if (tail.length === 0)
+    return false;
+  const oldestMs = Math.min(...tail.map((e10) => Date.parse(e10.collectedAt)));
+  if (Date.parse(ledger.baseline) !== oldestMs)
+    return false;
+  return oldestStartsAtFirst(tail.filter((entry) => Date.parse(entry.collectedAt) === oldestMs));
+}
+function withDerivedPartial(storage, ledger) {
+  if (baselineIsKnown(storage, ledger))
+    return ledger;
+  return { ...ledger, partial: true };
+}
+function retryOf(failed, now) {
+  if (failed.length === 0)
+    return null;
+  return {
+    versions: failed.slice(0, MAX_RETRY_VERSIONS).map((entry) => entry.collectedAt),
+    attemptedAt: now.toISOString()
+  };
+}
+async function rebuild(storage, scope, retained, budget, now) {
+  if (retained.length === 0)
+    return null;
+  const selected = withinBudget(scope, retained, budget);
+  const fold = new LedgerFold(null, scope);
+  const { folded, failed } = await foldEntries(storage, scope, selected, fold);
+  if (folded === 0) {
+    return {
+      version: 4,
+      scope,
+      baseline: null,
+      current: null,
+      latest: { collectedAt: retained[0].collectedAt, total: 0 },
+      through: retained[0].collectedAt,
+      skipped: selected.length === 0 ? "too_large" : "unreadable",
+      records: {}
+    };
+  }
+  const total = storage.countVersions(scope);
+  return fold.finish({
+    // Truncated only when the window or the byte budget left versions out. A
+    // version that could not be read is not a truncation: it is retried (see
+    // `retry`), and the ledger converges once it is read or deleted.
+    truncated: selected.length < retained.length || retained.length < total,
+    through: retained[0].collectedAt,
+    retry: retryOf(failed, now)
+  });
+}
+async function catchUp(storage, ledger, retained, budget, now) {
+  const newer = newerThan(retained, ledger);
+  const selected = withinBudget(ledger.scope, newer, budget);
+  const pending = (ledger.retry?.versions ?? []).filter((version4) => retained.some((entry) => entry.collectedAt === version4));
+  const due = ledger.retry !== void 0 && pending.length > 0 && now.getTime() - Date.parse(ledger.retry.attemptedAt) >= RETRY_UNREADABLE_MS;
+  const retryEntries = due ? withinBudget(ledger.scope, retained.filter((entry) => pending.includes(entry.collectedAt)), budget) : [];
+  const forgotten = pending.length !== (ledger.retry?.versions.length ?? 0);
+  if (selected.length === 0 && retryEntries.length === 0 && !forgotten) {
+    return ledger;
+  }
+  const fold = new LedgerFold(ledger);
+  const failedNew = selected.length > 0 ? (await foldEntries(storage, ledger.scope, selected, fold)).failed : [];
+  const failedRetry = retryEntries.length > 0 ? (await foldEntries(storage, ledger.scope, retryEntries, fold)).failed : [];
+  const stillFailing = due ? failedRetry.map((entry) => entry.collectedAt) : pending;
+  const versions = [
+    ...stillFailing,
+    ...failedNew.map((entry) => entry.collectedAt)
+  ].slice(0, MAX_RETRY_VERSIONS);
+  const attempted = due || failedNew.length > 0;
+  const retry = versions.length === 0 ? null : {
+    versions,
+    attemptedAt: attempted ? now.toISOString() : ledger.retry.attemptedAt
+  };
+  const beyond = storage.listVersions(ledger.scope, {
+    limit: 1,
+    offset: retained.length
+  })[0];
+  const windowCut = beyond !== void 0 && Date.parse(beyond.collectedAt) > Date.parse(ledger.through);
+  return await fold.finish({
+    truncated: windowCut || selected.length < newer.length,
+    through: selected.length > 0 ? retained[0].collectedAt : ledger.through,
+    retry
+  }) ?? ledger;
+}
+async function recordStoredVersion(storage, version4) {
+  if (!storage.readFirstSeenLedger || !storage.writeFirstSeenLedger)
+    return;
+  try {
+    await withScopeLock(version4.scope, async () => {
+      const retained = retainedVersions(storage, version4.scope);
+      let existing = await readStoredLedger(storage, version4.scope);
+      if (existing && !latestStillStored(storage, existing)) {
+        await storage.deleteFirstSeenLedger?.(version4.scope);
+        existing = null;
+      }
+      const others = retained.filter((entry) => entry.collectedAt !== version4.collectedAt);
+      let through = version4.collectedAt;
+      if (existing) {
+        if (isMarker(existing))
+          return;
+        const throughMs = Date.parse(existing.through);
+        const unfolded = others.some((entry) => Date.parse(entry.collectedAt) > throughMs);
+        through = unfolded || Date.parse(version4.collectedAt) < throughMs ? existing.through : version4.collectedAt;
+      } else if (others.length > 0) {
+        return;
+      }
+      const fold = new LedgerFold(existing, version4.scope);
+      await fold.add(version4);
+      const next = await fold.finish({ through });
+      if (!next)
+        return;
+      await storage.writeFirstSeenLedger(version4.scope, next);
+      await dropIfScopeEmpty(storage, version4.scope);
+    });
+  } catch {
+  }
+}
+async function ensureScopeLedger(storage, scope, options = {}) {
+  const budget = options.byteBudget ?? REBUILD_BYTE_BUDGET;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  return withScopeLock(scope, async () => {
+    try {
+      const retained = retainedVersions(storage, scope);
+      if (retained.length === 0) {
+        await storage.deleteFirstSeenLedger?.(scope);
+        return null;
+      }
+      let existing = await readStoredLedger(storage, scope);
+      if (existing && (!latestStillStored(storage, existing) || !baselineStillStored(storage, existing) || isMarker(existing) && newerThan(retained, existing).length > 0)) {
+        existing = null;
+      }
+      const ledger = existing ? await catchUp(storage, existing, retained, budget, now) : await rebuild(storage, scope, retained, budget, now);
+      if (ledger && ledger !== existing && storage.writeFirstSeenLedger) {
+        try {
+          await storage.writeFirstSeenLedger(scope, ledger);
+          if (await dropIfScopeEmpty(storage, scope))
+            return null;
+        } catch {
+        }
+      }
+      return ledger ? withDerivedPartial(storage, ledger) : ledger;
+    } catch {
+      return null;
+    }
+  });
+}
+
+// ../core/dist/additions/summary.js
+var InvalidTimezoneError = class extends Error {
+};
+function createFormatter(timezone) {
+  try {
+    return new Intl.DateTimeFormat("en-CA", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    });
+  } catch {
+    throw new InvalidTimezoneError(`Unknown timezone: ${timezone}`);
+  }
+}
+function localDate(formatter, instant) {
+  let year = "";
+  let month = "";
+  let day = "";
+  for (const part of formatter.formatToParts(instant)) {
+    if (part.type === "year")
+      year = part.value;
+    else if (part.type === "month")
+      month = part.value;
+    else if (part.type === "day")
+      day = part.value;
+  }
+  return `${year}-${month}-${day}`;
+}
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+function buildDayRows(formatter, now, days) {
+  const [year, month, day] = localDate(formatter, now).split("-").map(Number);
+  const rows = [];
+  for (let offset = days - 1; offset >= 0; offset -= 1) {
+    const date5 = new Date(Date.UTC(year, month - 1, day - offset));
+    rows.push({
+      date: `${date5.getUTCFullYear()}-${pad2(date5.getUTCMonth() + 1)}-${pad2(date5.getUTCDate())}`,
+      added: 0
+    });
+  }
+  return rows;
+}
+function validateTimezone(timezone) {
+  createFormatter(timezone);
+}
+async function summarizeAdditions(input) {
+  const { timezone, days, now } = input;
+  const formatter = createFormatter(timezone);
+  const dayRows = buildDayRows(formatter, now, days);
+  const dayIndex = new Map(dayRows.map((row, index) => [row.date, index]));
+  const scopes = [];
+  let total = 0;
+  let trackedSince = null;
+  let trackedSinceAt = Infinity;
+  let anyPartial = false;
+  for await (const ledger of input.ledgers) {
+    for (const firstSeen of listAddedTimestamps(ledger)) {
+      const date5 = localDate(formatter, new Date(Date.parse(firstSeen)));
+      const index = dayIndex.get(date5);
+      if (index !== void 0)
+        dayRows[index].added += 1;
+    }
+    total += ledger.latest.total;
+    const scopeTrackedSince = ledger.skipped ? null : ledger.baseline;
+    if (scopeTrackedSince !== null) {
+      const baselineAt = Date.parse(scopeTrackedSince);
+      if (baselineAt < trackedSinceAt) {
+        trackedSinceAt = baselineAt;
+        trackedSince = scopeTrackedSince;
+      }
+    }
+    const partial2 = scopeTrackedSince !== null && ledger.partial === true;
+    anyPartial ||= partial2;
+    scopes.push({
+      scope: ledger.scope,
+      total: ledger.latest.total,
+      trackedSince: scopeTrackedSince,
+      partial: partial2
+    });
+  }
+  scopes.sort((a10, b10) => a10.scope.localeCompare(b10.scope));
+  return {
+    timezone,
+    total,
+    days: dayRows,
+    trackedSince,
+    partial: anyPartial,
+    scopes
+  };
+}
+
 // ../core/dist/contracts/data.js
 var IngestPersistedError = class extends Error {
   relativePath;
@@ -113023,35 +114015,43 @@ function normalizeLimit(value) {
 function normalizeOffset(value) {
   return value ?? 0;
 }
-function isRecord3(value) {
+function isRecord5(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 var VISIBILITY_PAGE_SIZE = 200;
+async function collectScopes(storage, scopePrefix, isVisible) {
+  const scopes = [];
+  for (let scan = 0; ; scan += VISIBILITY_PAGE_SIZE) {
+    const batch = storage.listScopes({
+      scopePrefix,
+      limit: VISIBILITY_PAGE_SIZE,
+      offset: scan
+    });
+    for (const summary of batch.scopes) {
+      if (!isVisible) {
+        scopes.push(summary);
+        continue;
+      }
+      const latest = storage.findEntry({
+        scope: summary.scope,
+        at: summary.latestCollectedAt
+      });
+      if (!latest || await isVisible(summary.scope, latest)) {
+        scopes.push(summary);
+      }
+    }
+    if (batch.scopes.length < VISIBILITY_PAGE_SIZE)
+      break;
+  }
+  return scopes;
+}
 async function listDataScopesContract(input) {
   const limit = normalizeLimit(input.limit);
   const offset = normalizeOffset(input.offset);
   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;
-    }
+    const visible = await collectScopes(input.storage, input.scopePrefix, input.isVisible);
     total = visible.length;
     page = visible.slice(offset, offset + limit);
   } else {
@@ -113133,6 +114133,42 @@ async function listDataVersionsContract(input) {
     }
   };
 }
+function invalidQuery(message) {
+  return {
+    ok: false,
+    status: 400,
+    body: { error: "INVALID_QUERY", message }
+  };
+}
+async function summarizeDataAdditionsContract(input) {
+  if (!Number.isInteger(input.days) || input.days < 1 || input.days > 31) {
+    return invalidQuery("days must be an integer between 1 and 31");
+  }
+  try {
+    validateTimezone(input.timezone);
+  } catch (err2) {
+    if (err2 instanceof InvalidTimezoneError) {
+      return invalidQuery("Unknown timezone");
+    }
+    throw err2;
+  }
+  const scopes = await collectScopes(input.storage, void 0, input.isVisible);
+  async function* ledgers() {
+    for (const summary of scopes) {
+      const ledger = await ensureScopeLedger(input.storage, summary.scope, {
+        now: input.now
+      });
+      if (ledger)
+        yield ledger;
+    }
+  }
+  return summarizeAdditions({
+    ledgers: ledgers(),
+    timezone: input.timezone,
+    days: input.days,
+    now: input.now
+  });
+}
 async function readDataContract(input) {
   const scopeResult = parseDataScopeContract(input.scopeParam);
   if (!scopeResult.ok)
@@ -113162,7 +114198,7 @@ async function ingestDataContract(input) {
   const scopeResult = parseDataScopeContract(input.scopeParam);
   if (!scopeResult.ok)
     return scopeResult;
-  if (!isRecord3(input.body)) {
+  if (!isRecord5(input.body)) {
     return {
       ok: false,
       status: 400,
@@ -113207,6 +114243,11 @@ async function ingestDataContract(input) {
     sizeBytes: writeResult.sizeBytes,
     afterTombstoneVersion: input.afterTombstoneVersion ?? null
   });
+  await recordStoredVersion(input.storage, {
+    scope: scopeResult.scope,
+    collectedAt: input.collectedAt,
+    data: envelope.data
+  });
   return {
     ok: true,
     scope: scopeResult.scope,
@@ -113246,7 +114287,7 @@ async function ingestBinaryDataContract(input) {
       }
     };
   }
-  if (isRecord3(input.metadata) && (hasReservedWriterKey(input.metadata) || hasReservedLineageKey(input.metadata))) {
+  if (isRecord5(input.metadata) && (hasReservedWriterKey(input.metadata) || hasReservedLineageKey(input.metadata))) {
     return {
       ok: false,
       status: 400,
@@ -113279,6 +114320,11 @@ async function ingestBinaryDataContract(input) {
     sizeBytes: input.bytes.length,
     afterTombstoneVersion: input.afterTombstoneVersion ?? null
   });
+  await recordStoredVersion(input.storage, {
+    scope: scopeResult.scope,
+    collectedAt: input.collectedAt,
+    data: envelope.data
+  });
   return {
     ok: true,
     scope: scopeResult.scope,
@@ -114527,8 +115573,8 @@ function parseExpirySeconds(value) {
     const seconds = Number(value);
     return seconds > 0 ? seconds : void 0;
   }
-  const ms3 = Date.parse(value);
-  return Number.isFinite(ms3) ? Math.floor(ms3 / 1e3) : void 0;
+  const ms4 = Date.parse(value);
+  return Number.isFinite(ms4) ? Math.floor(ms4 / 1e3) : void 0;
 }
 function sortedUnique(values) {
   return Array.from(new Set(values)).sort();
@@ -115576,8 +116622,8 @@ async function buildChallenge(input) {
 }
 function base64decode(input) {
   let s10 = input.replace(/-/g, "+").replace(/_/g, "/");
-  const pad2 = (4 - s10.length % 4) % 4;
-  s10 += "=".repeat(pad2);
+  const pad3 = (4 - s10.length % 4) % 4;
+  s10 += "=".repeat(pad3);
   const binString = atob(s10);
   const bytes2 = Uint8Array.from(binString, (c10) => c10.codePointAt(0) ?? 0);
   return new TextDecoder().decode(bytes2);
@@ -116198,6 +117244,23 @@ async function handlePersonalServerDataRequest(request2, deps, options = {}) {
       });
       return jsonResponse(result.response);
     }
+    if (pathname === "/additions") {
+      if (request2.method !== "GET")
+        return methodNotAllowed();
+      await deps.auth.authorizeOwner(request2);
+      const daysRaw = url2.searchParams.get("days");
+      const result = await summarizeDataAdditionsContract({
+        storage: deps.storage,
+        isVisible: discoveryVisibility(deps),
+        timezone: url2.searchParams.get("tz") ?? "UTC",
+        // Digits only: Number() would also accept "", "1e1", "0x7" and " 7".
+        days: daysRaw === null ? 7 : /^\d{1,3}$/.test(daysRaw) ? Number(daysRaw) : Number.NaN,
+        now: (deps.now ?? (() => /* @__PURE__ */ new Date()))()
+      });
+      if ("ok" in result)
+        return contractErrorResponse(result);
+      return jsonResponse(result);
+    }
     const parts = pathname.split("/").filter(Boolean);
     if (parts.length === 2 && parts[1] === "versions") {
       if (request2.method !== "GET")
@@ -117359,7 +118422,8 @@ function normalizeState(state) {
     })),
     envelopes: state.envelopes,
     blockManifests: state.blockManifests ?? [],
-    blockPayloads: state.blockPayloads ?? []
+    blockPayloads: state.blockPayloads ?? [],
+    ...state.pendingLedgerDeletes?.length ? { pendingLedgerDeletes: state.pendingLedgerDeletes } : {}
   };
 }
 function createIndexedDbFallbackDataFileStore(envelopes, blockManifests = /* @__PURE__ */ new Map(), blockPayloads = /* @__PURE__ */ new Map()) {
@@ -117584,6 +118648,18 @@ function createIndexedDbPsLitePersistence(options = {}) {
     },
     async write(state) {
       await runIndexedDbTransaction(resolved, "readwrite", (store) => store.put(state, resolved.key));
+    },
+    // Side records live in the same object store under their own keys, which
+    // a build that only knows `resolved.key` never reads.
+    async readAux(name) {
+      const value = await runIndexedDbTransaction(resolved, "readonly", (store) => store.get(`${resolved.key}:${name}`));
+      return value ?? null;
+    },
+    async writeAux(name, value) {
+      await runIndexedDbTransaction(resolved, "readwrite", (store) => store.put(value, `${resolved.key}:${name}`));
+    },
+    async deleteAux(name) {
+      await runIndexedDbTransaction(resolved, "readwrite", (store) => store.delete(`${resolved.key}:${name}`));
     }
   };
 }
@@ -117595,6 +118671,9 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
   ]));
   const fallbackBlockManifests = new Map((state.blockManifests ?? []).map(({ path, manifest }) => [path, manifest]));
   const fallbackBlockPayloads = new Map((state.blockPayloads ?? []).map(({ path, block }) => [path, block]));
+  const ledgerAux = (scope) => `first-seen:${scope}`;
+  const firstSeenLedgers = /* @__PURE__ */ new Map();
+  const pendingLedgerDeletes = new Set(state.pendingLedgerDeletes ?? []);
   const fallbackStore = createIndexedDbFallbackDataFileStore(fallbackEnvelopes, fallbackBlockManifests, fallbackBlockPayloads);
   const fileStore = dataFileStore ?? (adapter.kind !== "custom" && await isOpfsAvailable() ? await createOpfsPsLiteDataFileStore() : fallbackStore);
   const capabilities = {
@@ -117608,7 +118687,8 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
       ...state,
       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 }))
+      blockPayloads: Array.from(fallbackBlockPayloads.entries()).map(([path, block]) => ({ path, block })),
+      pendingLedgerDeletes: pendingLedgerDeletes.size > 0 ? Array.from(pendingLedgerDeletes) : void 0
     };
     const write = persistQueue.then(() => persistence.write(snapshot));
     persistQueue = write.catch(() => void 0);
@@ -117886,33 +118966,55 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
       }
       return updated;
     },
-    async deleteScope(scope) {
-      let deleted = 0;
-      const deletedPaths = [];
-      const deletedBlockTrees = [];
-      state = {
-        ...state,
-        entries: state.entries.filter((entry) => {
-          if (entry.scope !== scope)
-            return true;
-          deleted += 1;
-          deletedPaths.push(envelopePath(entry.scope, entry.collectedAt));
-          deletedBlockTrees.push(blockTreePath(entry.scope, entry.collectedAt));
-          return false;
-        })
-      };
-      await Promise.all([
-        ...deletedPaths.flatMap((path) => [
-          fileStore.deleteEnvelope(path),
-          fallbackStore.deleteEnvelope(path)
-        ]),
-        ...deletedBlockTrees.flatMap((path) => [
-          fileStore.deleteBlockTree?.(path),
-          fallbackStore.deleteBlockTree?.(path)
-        ])
-      ].filter((promise2) => promise2 !== void 0));
-      await persist();
-      return deleted;
+    async readFirstSeenLedger(scope) {
+      if (!firstSeenLedgers.has(scope)) {
+        const stored = await persistence.readAux?.(ledgerAux(scope)) ?? null;
+        if (stored !== null)
+          firstSeenLedgers.set(scope, stored);
+      }
+      return structuredClone(firstSeenLedgers.get(scope) ?? null);
+    },
+    async writeFirstSeenLedger(scope, ledger) {
+      firstSeenLedgers.set(scope, structuredClone(ledger));
+      await persistence.writeAux?.(ledgerAux(scope), ledger);
+    },
+    async deleteFirstSeenLedger(scope) {
+      firstSeenLedgers.delete(scope);
+      await persistence.deleteAux?.(ledgerAux(scope));
+    },
+    // Deletions run under the scope's first-seen sidecar lock (a rebuild in
+    // flight cannot write it back), and the sidecar goes with the scope's last
+    // version, so no delete path leaves a stale ledger behind.
+    deleteScope(scope) {
+      return withScopeLock(scope, async () => {
+        await dropLedger(scope);
+        let deleted = 0;
+        const deletedPaths = [];
+        const deletedBlockTrees = [];
+        state = {
+          ...state,
+          entries: state.entries.filter((entry) => {
+            if (entry.scope !== scope)
+              return true;
+            deleted += 1;
+            deletedPaths.push(envelopePath(entry.scope, entry.collectedAt));
+            deletedBlockTrees.push(blockTreePath(entry.scope, entry.collectedAt));
+            return false;
+          })
+        };
+        await Promise.all([
+          ...deletedPaths.flatMap((path) => [
+            fileStore.deleteEnvelope(path),
+            fallbackStore.deleteEnvelope(path)
+          ]),
+          ...deletedBlockTrees.flatMap((path) => [
+            fileStore.deleteBlockTree?.(path),
+            fallbackStore.deleteBlockTree?.(path)
+          ])
+        ].filter((promise2) => promise2 !== void 0));
+        await persist();
+        return deleted;
+      });
     },
     async deleteVersion(scope, collectedAt) {
       const entry = state.entries.find((e10) => e10.scope === scope && e10.collectedAt === collectedAt);
@@ -117927,7 +119029,35 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
       return removeEntry(entry);
     }
   };
+  async function dropLedger(scope) {
+    const attempt = async (name) => {
+      try {
+        await storagePort.deleteFirstSeenLedger(name);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    const before = pendingLedgerDeletes.size;
+    if (await attempt(scope))
+      pendingLedgerDeletes.delete(scope);
+    else
+      pendingLedgerDeletes.add(scope);
+    for (const other of [...pendingLedgerDeletes]) {
+      if (other === scope)
+        continue;
+      const stillStored = state.entries.some((e10) => e10.scope === other);
+      if (stillStored || await attempt(other))
+        pendingLedgerDeletes.delete(other);
+    }
+    if (pendingLedgerDeletes.size !== before) {
+      await persist().catch(() => void 0);
+    }
+  }
   async function removeEntry(entry) {
+    return withScopeLock(entry.scope, () => removeEntryLocked(entry));
+  }
+  async function removeEntryLocked(entry) {
     const blobPath = envelopePath(entry.scope, entry.collectedAt);
     await Promise.all([
       fileStore.deleteEnvelope(blobPath),
@@ -117940,6 +119070,9 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
       entries: state.entries.filter((e10) => e10 !== entry)
     };
     await persist();
+    if (!state.entries.some((e10) => e10.scope === entry.scope)) {
+      await dropLedger(entry.scope);
+    }
     return true;
   }
   if (fileStore.readEnvelopePreview) {
@@ -117953,6 +119086,20 @@ async function createPersistentPsLiteStorage(adapter, persistence = createIndexe
       return preview;
     };
   }
+  if (pendingLedgerDeletes.size > 0) {
+    for (const scope of [...pendingLedgerDeletes]) {
+      if (state.entries.some((e10) => e10.scope === scope)) {
+        pendingLedgerDeletes.delete(scope);
+        continue;
+      }
+      try {
+        await storagePort.deleteFirstSeenLedger(scope);
+        pendingLedgerDeletes.delete(scope);
+      } catch {
+      }
+    }
+    await persist().catch(() => void 0);
+  }
   return storagePort;
 }
 async function readPreviewFromFileStore(store, path, maxBytes) {
@@ -118341,7 +119488,7 @@ var KEYS_BY_TYPE = {
   boolean: ["name", "type", "required"],
   enum: ["name", "type", "required", "values"]
 };
-function isRecord4(value) {
+function isRecord6(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function invalid(message, details) {
@@ -118402,7 +119549,7 @@ function parseEnumValues(value, index) {
   return values;
 }
 function parseField(value, index) {
-  if (!isRecord4(value)) {
+  if (!isRecord6(value)) {
     invalid(`answerShape.fields[${index}] must be an object`, { index });
   }
   const name = parseFieldName(value.name, index);
@@ -118458,7 +119605,7 @@ function parseField(value, index) {
 function parseAnswerShapeInput(value) {
   if (value === void 0 || value === null)
     return null;
-  if (!isRecord4(value)) {
+  if (!isRecord6(value)) {
     invalid("answerShape must be an object with a fields array", {});
   }
   for (const key of Object.keys(value)) {
@@ -118671,7 +119818,7 @@ 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 isRecord5(value) {
+function isRecord7(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function parseScope(value, field2) {
@@ -118687,7 +119834,7 @@ function parseScope(value, field2) {
   return parsed.scope;
 }
 function parseQuestionInput(body) {
-  if (!isRecord5(body)) {
+  if (!isRecord7(body)) {
     throw new DerivativeQuestionInvalidError("Body must be a JSON object");
   }
   const derivedScope = parseScope(body.derivedScope, "derivedScope");
@@ -118823,11 +119970,11 @@ var TIMESTAMP_KEYS = [
   "published_at"
 ];
 var RESERVED_KEYS = /* @__PURE__ */ new Set(["$lineage", "$writtenBy", "$binary"]);
-function isRecord6(value) {
+function isRecord8(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function timestampOf(item) {
-  if (!isRecord6(item))
+  if (!isRecord8(item))
     return null;
   for (const key of TIMESTAMP_KEYS) {
     const value = item[key];
@@ -118868,7 +120015,7 @@ function trimSourceData(data, options = {}) {
     total = 0;
     if (Array.isArray(data))
       return trimArray(data, limit2);
-    if (isRecord6(data)) {
+    if (isRecord8(data)) {
       const stamped = "$lineage" in data;
       const out = {};
       for (const [key, value] of Object.entries(data)) {
@@ -118982,7 +120129,7 @@ function parseAnswer(content) {
   for (const candidate of jsonFramings(content)) {
     try {
       const parsed = JSON.parse(candidate);
-      if (isRecord6(parsed) && typeof parsed.answer === "string") {
+      if (isRecord8(parsed) && typeof parsed.answer === "string") {
         return {
           answer: parsed.answer,
           evidence: typeof parsed.evidence === "string" ? parsed.evidence : null
@@ -119002,10 +120149,10 @@ function parseShapedAnswer(content) {
     } catch {
       continue;
     }
-    if (!isRecord6(parsed))
+    if (!isRecord8(parsed))
       continue;
     const evidence = typeof parsed.evidence === "string" ? parsed.evidence : null;
-    if (isRecord6(parsed.answer)) {
+    if (isRecord8(parsed.answer)) {
       found.push({ answer: parsed.answer, evidence });
     }
     found.push({ answer: parsed, evidence });
@@ -119038,11 +120185,11 @@ var InferenceRequestError = class extends Error {
     this.retryable = options.retryable;
   }
 };
-function isRecord7(value) {
+function isRecord9(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function readUsage(value) {
-  if (!isRecord7(value))
+  if (!isRecord9(value))
     return void 0;
   const num2 = (v10) => typeof v10 === "number" ? v10 : void 0;
   const usage = {
@@ -119053,10 +120200,10 @@ function readUsage(value) {
   return usage;
 }
 function readContent(body) {
-  if (!isRecord7(body) || !Array.isArray(body.choices))
+  if (!isRecord9(body) || !Array.isArray(body.choices))
     return null;
   const first = body.choices[0];
-  if (!isRecord7(first) || !isRecord7(first.message))
+  if (!isRecord9(first) || !isRecord9(first.message))
     return null;
   const index = typeof first.index === "number" ? first.index : 0;
   const field2 = `choices.${index}.message.content`;
@@ -119065,7 +120212,7 @@ function readContent(body) {
   if (typeof content === "string")
     return { content, field: field2, id: id2 };
   if (Array.isArray(content)) {
-    const text = content.map((part) => isRecord7(part) && typeof part.text === "string" ? part.text : "").join("");
+    const text = content.map((part) => isRecord9(part) && typeof part.text === "string" ? part.text : "").join("");
     return { content: text, field: field2, id: id2 };
   }
   return null;
@@ -119073,7 +120220,7 @@ function readContent(body) {
 async function readErrorType(response) {
   try {
     const body = await response.json();
-    if (isRecord7(body) && isRecord7(body.error)) {
+    if (isRecord9(body) && isRecord9(body.error)) {
       return typeof body.error.type === "string" ? body.error.type : null;
     }
   } catch {
@@ -119181,7 +120328,7 @@ function createOpenAiCompatibleInferenceProvider(options = {}) {
       ok: true,
       result: {
         content,
-        usage: readUsage(isRecord7(parsed) ? parsed.usage : void 0),
+        usage: readUsage(isRecord9(parsed) ? parsed.usage : void 0),
         ...receiptId ? { receiptId } : {},
         ...aciIdentity ? { aciIdentity } : {}
       }
@@ -119214,7 +120361,7 @@ function isRetryableInferenceError(err2) {
 }
 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)));
+  const sleep2 = deps.sleep ?? ((ms4) => new Promise((r10) => setTimeout(r10, ms4)));
   for (let index = 0; ; index += 1) {
     try {
       return await attempt();
@@ -119592,7 +120739,7 @@ function isTransientFailureOutcome(outcome) {
   return shaped.status === "failed" && shaped.registration?.errorCode === "inference_unavailable";
 }
 var defaultTimers = {
-  setTimeout: (callback, ms3) => setTimeout(callback, ms3),
+  setTimeout: (callback, ms4) => setTimeout(callback, ms4),
   clearTimeout: (handle) => clearTimeout(handle)
 };
 function createRecomputeScheduler(options) {
@@ -120287,25 +121434,25 @@ var E2eeAttestationError = class extends Error {
     this.name = "E2eeAttestationError";
   }
 };
-function isRecord8(value) {
+function isRecord10(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-async function sha256Hex2(bytes2) {
+async function sha256Hex3(bytes2) {
   const buffer = new ArrayBuffer(bytes2.byteLength);
   new Uint8Array(buffer).set(bytes2);
   const digest2 = await globalThis.crypto.subtle.digest("SHA-256", buffer);
   return bytesToHex6(new Uint8Array(digest2));
 }
 async function workloadKeysetDigest(keyset) {
-  return `sha256:${await sha256Hex2(canonicalJsonBytes(keyset))}`;
+  return `sha256:${await sha256Hex3(canonicalJsonBytes(keyset))}`;
 }
 async function reportDataFor(keysetDigest, nonce) {
   const nonceJson = nonce === null ? "null" : `"${nonce}"`;
   const statement = `{"keyset_digest":"${keysetDigest}","nonce":${nonceJson},"purpose":"${ACI_REPORT_DATA_PURPOSE}"}`;
-  return sha256Hex2(new TextEncoder().encode(statement));
+  return sha256Hex3(new TextEncoder().encode(statement));
 }
 function parseReport(body) {
-  if (!isRecord8(body) || typeof body.api_version !== "string" || typeof body.workload_keyset_digest !== "string" || !isRecord8(body.attestation) || typeof body.attestation.tee_type !== "string" || typeof body.attestation.report_data !== "string" || !isRecord8(body.attestation.workload_keyset)) {
+  if (!isRecord10(body) || typeof body.api_version !== "string" || typeof body.workload_keyset_digest !== "string" || !isRecord10(body.attestation) || typeof body.attestation.tee_type !== "string" || typeof body.attestation.report_data !== "string" || !isRecord10(body.attestation.workload_keyset)) {
     throw new E2eeAttestationError("malformed_report", "attestation report is missing required fields");
   }
   const keyset = body.attestation.workload_keyset;
@@ -120352,7 +121499,7 @@ async function verifyAciReportBinding(report, nonce, nowSeconds) {
 }
 function selectX25519Key(keyset, expectedKeyId) {
   for (const entry of keyset.e2ee_public_keys) {
-    if (!isRecord8(entry) || entry.algo !== E2EE_ALGO_X25519)
+    if (!isRecord10(entry) || entry.algo !== E2EE_ALGO_X25519)
       continue;
     if (typeof entry.public_key !== "string")
       continue;
@@ -122912,7 +124059,7 @@ var objectToNumericMapAsync = async (object3) => {
   }
   return map2;
 };
-var wait = (ms3) => new Promise((resolve) => setTimeout(resolve, ms3));
+var wait = (ms4) => new Promise((resolve) => setTimeout(resolve, ms4));
 var SPACE_OR_PUNCTUATION = /[\n\r\p{Z}\p{P}]+/u;
 
 // ../core/dist/mcp/search/index.js
@@ -137148,6 +138295,11 @@ async function downloadOne(deps, record2) {
     throw err2;
   }
   diagnostics?.onIndexEnd(record2.id, envelope.scope);
+  await recordStoredVersion(storage, {
+    scope: envelope.scope,
+    collectedAt: envelope.collectedAt,
+    data: envelope.data
+  });
   logger.info({ dataPointId: record2.id, scope: envelope.scope, path: relativePath }, "Downloaded and indexed data point");
   if (deps.onDataPointIndexed) {
     try {
@@ -137318,6 +138470,12 @@ async function reconcileDeletedDataPoint(deps, record2, deletedAt) {
   if (orphanKeys.length > 0 && deps.pendingBlobDeletions) {
     await deps.pendingBlobDeletions.add(orphanKeys);
   }
+  if (removed > 0 || kept === 0) {
+    try {
+      await storage.deleteFirstSeenLedger?.(record2.scope);
+    } catch {
+    }
+  }
   if (removed > 0 || kept > 0) {
     logger.info({ dataPointId: record2.id, scope: record2.scope, deletedAt, removed, kept }, "Reconciled gateway deletion against local index");
   }