Merge pull request #6583 from loopx-project/codex/sqlite-retained-utf8-bytes-20261016

Author: huangruiteng

loopx/control_plane/coordination/sqlite_authority_store.ts

@@ -673,11 +673,12 @@ export class SqliteAuthorityStore implements AuthorityStore {
         return {status: "failed", reason_code: "provider_read_unavailable", reason: "SQLite authority database is empty"};
       }
       const counted = db.prepare("SELECT COUNT(*) AS count FROM commits").get();
+      // SQLite length(TEXT) counts characters, not the encoded JSON bytes.
       const retained = db.prepare(`SELECT
         (SELECT COUNT(*) FROM checkpoints) AS checkpoints,
-        (SELECT COALESCE(SUM(length(projection)), 0) FROM checkpoints) AS projection_bytes,
-        (SELECT COALESCE(SUM(length(delta)), 0) FROM commits) AS delta_bytes,
-        (SELECT COALESCE(SUM(length(events) + length(receipts)), 0) FROM commits) AS payload_bytes`).get();
+        (SELECT COALESCE(SUM(length(CAST(projection AS BLOB))), 0) FROM checkpoints) AS projection_bytes,
+        (SELECT COALESCE(SUM(length(CAST(delta AS BLOB))), 0) FROM commits) AS delta_bytes,
+        (SELECT COALESCE(SUM(length(CAST(events AS BLOB)) + length(CAST(receipts AS BLOB))), 0) FROM commits) AS payload_bytes`).get();
       const cursor = head.state.cursor;
       return {
         schema_version: "loopx_sqlite_authority_bounded_profile_v0",

tests/control_plane_ts/sqlite_authority_bounded_profile.test.ts

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import {mkdtemp, rm} from "node:fs/promises";
 import {tmpdir} from "node:os";
 import {join} from "node:path";
+import {DatabaseSync} from "node:sqlite";
 import test from "node:test";
 
 import {AUTHORITY_STATE_CHECKPOINT_INTERVAL} from
@@ -23,6 +24,49 @@ async function fixture(t: test.TestContext): Promise<SqliteAuthorityStore> {
   return new SqliteAuthorityStore(directory, GOAL_ID);
 }
 
+for (const text of ["plain ASCII", "中文", "😀🛰️"]) {
+  test(`SQLite retained byte counts measure UTF-8 for ${JSON.stringify(text)}`, async t => {
+    const store = await fixture(t);
+    let revision: string | null = null;
+    for (let index = 1; index <= AUTHORITY_STATE_CHECKPOINT_INTERVAL + 1; index += 1) {
+      const applied = await store.commitAuthority({expected_provider_revision: revision,
+        operation_id: `byte-profile-${index}`, next_projection: {text, index},
+        events: [{text, index}], receipts: [{text, index}]});
+      assert.equal(applied.status, "applied", JSON.stringify(applied));
+      if (applied.status !== "applied") return;
+      revision = applied.provider_revision;
+    }
+    const before = await store.loadAuthority();
+    assert.equal(before.status, "loaded");
+    const original = await store.readReceipt("byte-profile-1");
+    assert.equal(original.status, "found");
+    const profile = await store.boundedProfile();
+    assert.equal(profile.status, "available", JSON.stringify(profile));
+    if (profile.status !== "available") return;
+    assert.equal(profile.checkpoints, 2);
+    // Measure the exact retained JSON independently of the profile's SQL
+    // aggregates. UTF-8 bytes differ from SQLite TEXT character counts.
+    const utf8Bytes = (value: unknown): number => {
+      assert.equal(typeof value, "string");
+      return Buffer.byteLength(value as string, "utf8");
+    };
+    const db = new DatabaseSync(store.path, {readOnly: true});
+    try {
+      const checkpoints = db.prepare("SELECT projection FROM checkpoints").all();
+      const commits = db.prepare("SELECT delta, events, receipts FROM commits").all();
+      assert.equal(profile.retained_projection_bytes,
+        checkpoints.reduce((total, row) => total + utf8Bytes(row.projection), 0));
+      assert.equal(profile.retained_delta_bytes,
+        commits.reduce((total, row) => total + utf8Bytes(row.delta), 0));
+      assert.equal(profile.retained_payload_bytes,
+        commits.reduce((total, row) => total + utf8Bytes(row.events) + utf8Bytes(row.receipts), 0));
+    } finally { db.close(); }
+    assert.deepEqual(await store.loadAuthority(), before);
+    assert.deepEqual(await store.readReceipt("byte-profile-1"), original);
+    assert.equal((await store.verifyAuthorityHistory()).status, "verified");
+  });
+}
+
 interface ReplayedHistory {
   readonly heads: string[];
   readonly operations: string[];