@hraness/oh 0.3.1 → 0.4.0

package/src/libsql-semantic.test.ts

@@ -147,7 +147,11 @@ function document(
 async function bootstrapped(): Promise<SqliteCompatibleLibSqlClient> {
   const client = new SqliteCompatibleLibSqlClient();
   expect(await bootstrapOhLibSqlSemanticCacheV1(client, { appliedAt: instant1 }))
-    .toMatchObject({ schemaVersion: 1, v: 1 });
+    .toEqual({
+      schemaSha256: "d9903735e900e08a8c49c9ad36ea8f277b1689117ef88b9a2c6b906456dfbace" as Sha256Hex,
+      schemaVersion: 1,
+      v: 1,
+    });
   return client;
 }
 
@@ -167,6 +171,51 @@ function authority(
 }
 
 describe("libSQL derived semantic cache", () => {
+  test("reproduces the fixed released V1 digest fixture", async () => {
+    const fixture = await Bun.file(new URL(
+      "../spec/v1/libsql-semantic-digest-fixture-v1.json",
+      import.meta.url,
+    )).json() as Readonly<{
+      authorityId: string;
+      authoritySha256: Sha256Hex;
+      content: string;
+      generation: number;
+      generationSha256: Sha256Hex;
+      inputSha256: Sha256Hex;
+      membershipSha256: Sha256Hex;
+      recordKey: string;
+      recordSha256: Sha256Hex;
+      title: string;
+      v: 1;
+    }>;
+    const client = await bootstrapped();
+    const cache = await openOhLibSqlSemanticCacheV1(client);
+    const calls: string[][] = [];
+    const staged = await cache.stage({
+      authorityId: fixture.authorityId,
+      authoritySha256: fixture.authoritySha256,
+      createdAt: instant1,
+      documents: [{
+        content: fixture.content,
+        key: fixture.recordKey,
+        recordSha256: fixture.recordSha256,
+        title: fixture.title,
+        v: fixture.v,
+      }],
+      embeddingClient: embeddingClient(calls),
+      generation: fixture.generation,
+    });
+    expect(staged).toMatchObject({
+      generationSha256: fixture.generationSha256,
+      membershipSha256: fixture.membershipSha256,
+      v: 1,
+    });
+    expect(calls).toHaveLength(1);
+    expect(sha256Hex(calls[0]?.[0] ?? "")).toBe(fixture.inputSha256);
+    await cache.close();
+    client.close();
+  });
+
   test("requires explicit bootstrap and refuses a partial or drifted schema", async () => {
     const empty = new SqliteCompatibleLibSqlClient();
     await expect(openOhLibSqlSemanticCacheV1(empty)).rejects.toMatchObject({

package/src/libsql.test.ts

@@ -18,6 +18,7 @@ import {
   OH_WORKING_STORE_PROFILE_V1,
   OhConflictError,
   OhIntegrityError,
+  OhOperationSizeError,
   OhProfileError,
   OhPurgedSpaceError,
 } from "./store";
@@ -341,6 +342,41 @@ describe("direct libSQL Oh authority", () => {
     client.close();
   });
 
+  test("honors the host-declared operation byte bound before replay or persistence", async () => {
+    const client = await bootstrappedClient();
+    const authority = await createOhLibSqlStoreAuthorityV1(client, {
+      profile: OH_CANONICAL_STORE_PROFILE_V1, realmId: "realm:operation-bound", spaceId: "operation-bound",
+    });
+    const empty = await authority.store.head();
+    const firstChanges = [{ kind: "put" as const,
+      record: entity("entity:bounded", "Bounded"), v: 1 as const }];
+    const first = await authority.store.commit({ actorId: "agent.bound", changes: firstChanges,
+      expectedHead: empty, operationId: "op_bounded_first" });
+
+    const replayError: unknown = await authority.store.commit({ actorId: "agent.bound", changes: firstChanges,
+      expectedHead: empty, maximumOperationBytes: 1,
+      operationId: "op_bounded_first" }).catch((error: unknown) => error);
+    const commitError: unknown = await authority.store.commit({ actorId: "agent.bound", changes: [{ kind: "put",
+      record: entity("entity:rejected", "Rejected"), v: 1 }], expectedHead: await authority.store.head(),
+    maximumOperationBytes: 1, operationId: "op_bounded_rejected" }).catch((error: unknown) => error);
+    for (const error of [replayError, commitError]) {
+      expect(error).toBeInstanceOf(OhOperationSizeError);
+      expect(error).toBeInstanceOf(RangeError);
+      expect(error).toMatchObject({ maximumOperationBytes: 1,
+        operationBytes: expect.any(Number) });
+    }
+
+    expect(await authority.store.head()).toMatchObject({
+      operationSha256: first.operationSha256,
+      sequence: 1,
+    });
+    expect(client.database.query<{ count: number }, [string]>(`SELECT count(*) AS count
+      FROM oh_authority_operations WHERE space_id = ?`).get("operation-bound")?.count).toBe(1);
+    expect((await authority.store.snapshot()).records.map(({ key }) => key)).toEqual(["entity:bounded"]);
+    await authority.store.close();
+    client.close();
+  });
+
   test("uses compare-and-swap guards to leave no partial remote mutation", async () => {
     const client = await bootstrappedClient();
     const first = await createOhLibSqlStoreAuthorityV1(client, {

package/src/libsql.ts

@@ -11,7 +11,11 @@ import { OH_CONTRACT_MANIFEST_V1 } from "./contract";
 import { canonicalKnowledgeGraphChangesV1, knowledgeGraphRecordRefV1, OH_GRAPH_LIMITS_V1,
   parseKnowledgeGraphRecordV1,
   type KnowledgeGraphRecordV1 } from "./graph";
-import { parseOhOperationV1, type OhOperationV1 } from "./operation";
+import {
+  OH_OPERATION_MAX_BYTES_V1,
+  parseOhOperationV1,
+  type OhOperationV1,
+} from "./operation";
 import {
   createOhDependencyClosureV1,
   createOhSpacePurgeReceiptV1,
@@ -21,6 +25,7 @@ import {
   OH_WORKING_STORE_PROFILE_V1,
   OhConflictError,
   OhIntegrityError,
+  OhOperationSizeError,
   OhProfileError,
   OhPurgedSpaceError,
   parseOhHeadRefV1,
@@ -1261,8 +1266,14 @@ class OhLibSqlStoreV1 implements OhStoreV1 {
     this.#assertOpen();
     const actorId = safeCode(input.actorId);
     const operationId = safeCode(input.operationId);
+    const maximumOperationBytes = input.maximumOperationBytes ?? OH_OPERATION_MAX_BYTES_V1;
     const changes = canonicalKnowledgeGraphChangesV1(input.changes);
-    if (actorId === null || operationId === null || changes.length === 0) throw new TypeError("Invalid Oh commit input.");
+    if (actorId === null || operationId === null || changes.length === 0
+      || !Number.isSafeInteger(maximumOperationBytes)
+      || maximumOperationBytes < 1
+      || maximumOperationBytes > OH_OPERATION_MAX_BYTES_V1) {
+      throw new TypeError("Invalid Oh commit input.");
+    }
     if (changes.length > OH_LIBSQL_STORE_LIMITS_V1.changesPerCommit) {
       throw new RangeError("A direct libSQL commit exceeds its change-count bound.");
     }
@@ -1277,6 +1288,10 @@ class OhLibSqlStoreV1 implements OhStoreV1 {
       if (duplicate.actorId !== actorId || canonicalJson(duplicate.changes) !== canonicalJson(changes)) {
         throw new OhConflictError("The operation ID is already bound to different content.");
       }
+      const operationBytes = utf8ByteLength(canonicalJson(duplicate));
+      if (operationBytes > maximumOperationBytes) {
+        throw new OhOperationSizeError(operationBytes, maximumOperationBytes);
+      }
       return duplicate;
     }
     if (!Number.isSafeInteger(input.expectedHead.generation) || input.expectedHead.generation < 0
@@ -1286,9 +1301,15 @@ class OhLibSqlStoreV1 implements OhStoreV1 {
     }
     const snapshot = await this.#currentMaterializedSnapshot(current, OH_GRAPH_LIMITS_V1.recordsPerSnapshot);
     const transition = transitionOhSnapshotV1({ actorId, changes,
-      instant: input.instant ?? canonicalNow(), operationId, snapshot, spaceId: this.binding.spaceId });
+      instant: input.instant ?? canonicalNow(), maximumOperationBytes,
+      operationId, snapshot, spaceId: this.binding.spaceId });
     const operation = transition.operation;
-    if (utf8ByteLength(canonicalJson(operation)) > OH_LIBSQL_STORE_LIMITS_V1.operationBytes) {
+    const operationJson = canonicalJson(operation);
+    const operationBytes = utf8ByteLength(operationJson);
+    if (operationBytes > maximumOperationBytes) {
+      throw new OhOperationSizeError(operationBytes, maximumOperationBytes);
+    }
+    if (operationBytes > OH_LIBSQL_STORE_LIMITS_V1.operationBytes) {
       throw new RangeError("A direct libSQL operation exceeds its canonical byte bound.");
     }
     const existsOperation = "EXISTS (SELECT 1 FROM oh_authority_operations WHERE operation_sha256 = ?)";
@@ -1301,7 +1322,7 @@ class OhLibSqlStoreV1 implements OhStoreV1 {
           WHERE space_id = ? AND generation = ? AND head_operation_sha256 IS ?)`,
       args: [operation.operationSha256, this.binding.spaceId, operation.sequence, operation.operationId,
         operation.parentOperationSha256, operation.graphRevisionSha256, operation.recordsSha256,
-        canonicalJson(operation), operation.instant, this.binding.spaceId, current.generation,
+        operationJson, operation.instant, this.binding.spaceId, current.generation,
         current.operationSha256],
     }];
     for (const [ordinal, change] of operation.changes.entries()) {