@axiom-lattice/pg-stores 5.1.2 → 5.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/pg-stores",
-  "version": "5.1.2",
+  "version": "5.2.0",
   "description": "PG stores implementation for Axiom Lattice framework",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -25,8 +25,8 @@
     "@langchain/core": "1.3.2",
     "pg": "^8.16.3",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "12.2.2",
-    "@axiom-lattice/protocols": "7.2.0"
+    "@axiom-lattice/core": "12.3.0",
+    "@axiom-lattice/protocols": "7.3.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/__tests__/PostgreSQLMcpServerConfigStore.integration.test.ts

@@ -37,6 +37,10 @@ describeIfDatabase("PostgreSQLMcpServerConfigStore integration", () => {
       "DELETE FROM lattice_mcp_server_configs WHERE tenant_id = ANY($1::text[])",
       [[...tenants]],
     );
+    await pool.query(
+      "DELETE FROM lattice_personal_mcp_server_configs WHERE tenant_id = ANY($1::text[])",
+      [[...tenants]],
+    );
     tenants.clear();
   });
 
@@ -255,4 +259,122 @@ describeIfDatabase("PostgreSQLMcpServerConfigStore integration", () => {
     expect(await store.hasConfig(tenant, missing)).toBe(false);
     expect(await store.deleteConfig(tenant, missing)).toBe(false);
   });
+
+  describe("personal data domain", () => {
+    it("creates a personal config without exposing it to tenant queries", async () => {
+      const tenant = tenantId();
+      const owner = `pa-${randomUUID()}`;
+      const id = randomUUID();
+      const key = `personal-${randomUUID()}`;
+
+      const created = await store.createConfigForAssistant(tenant, owner, id, {
+        key,
+        config: config(),
+        selectedTools: ["read_file"],
+      });
+
+      expect(created.ownerAssistantId).toBe(owner);
+      expect(await store.getConfigByIdForAssistant(tenant, owner, id)).toMatchObject({ id, ownerAssistantId: owner });
+      expect(await store.getConfigByKeyForAssistant(tenant, owner, key)).toMatchObject({ id });
+      expect(await store.hasConfigForAssistant(tenant, owner, id)).toBe(true);
+
+      expect(await store.getConfigById(tenant, id)).toBeNull();
+      expect(await store.getConfigByKey(tenant, key)).toBeNull();
+      expect(await store.getAllConfigs(tenant)).toEqual([]);
+      expect(
+        (await store.getAllConfigsWithoutTenant()).filter((entry) => entry.tenantId === tenant),
+      ).toEqual([]);
+    });
+
+    it("allows the same key in the tenant and personal domains", async () => {
+      const tenant = tenantId();
+      const owner = `pa-${randomUUID()}`;
+      const key = `shared-${randomUUID()}`;
+      const tenantIdValue = randomUUID();
+      const personalId = randomUUID();
+
+      await store.createConfig(tenant, tenantIdValue, { key, config: config() });
+      await store.createConfigForAssistant(tenant, owner, personalId, {
+        key,
+        config: config({ url: "https://personal.example.com/mcp" }),
+      });
+
+      expect((await store.getConfigByKey(tenant, key))?.id).toBe(tenantIdValue);
+      expect((await store.getConfigByKeyForAssistant(tenant, owner, key))?.id).toBe(personalId);
+    });
+
+    it("scopes personal reads and writes to the owning assistant", async () => {
+      const tenant = tenantId();
+      const ownerA = `pa-${randomUUID()}`;
+      const ownerB = `pa-${randomUUID()}`;
+      const id = randomUUID();
+      const key = `scoped-${randomUUID()}`;
+
+      await store.createConfigForAssistant(tenant, ownerA, id, { key, config: config() });
+
+      expect(await store.getConfigByIdForAssistant(tenant, ownerB, id)).toBeNull();
+      expect(await store.getConfigByKeyForAssistant(tenant, ownerB, key)).toBeNull();
+      expect(await store.hasConfigForAssistant(tenant, ownerB, id)).toBe(false);
+      expect(await store.updateConfigForAssistant(tenant, ownerB, id, { name: "hijack" })).toBeNull();
+      expect(await store.deleteConfigForAssistant(tenant, ownerB, id)).toBe(false);
+    });
+
+    it("enforces the (tenant, owner, key) unique index", async () => {
+      const tenant = tenantId();
+      const owner = `pa-${randomUUID()}`;
+      const key = `dup-${randomUUID()}`;
+
+      await store.createConfigForAssistant(tenant, owner, randomUUID(), { key, config: config() });
+
+      await expect(
+        store.createConfigForAssistant(tenant, owner, randomUUID(), { key, config: config() }),
+      ).rejects.toThrow();
+    });
+
+    it("deletes every personal config for one assistant only", async () => {
+      const tenant = tenantId();
+      const ownerA = `pa-${randomUUID()}`;
+      const ownerB = `pa-${randomUUID()}`;
+
+      await store.createConfigForAssistant(tenant, ownerA, randomUUID(), {
+        key: `a-${randomUUID()}`,
+        config: config(),
+      });
+      await store.createConfigForAssistant(tenant, ownerA, randomUUID(), {
+        key: `b-${randomUUID()}`,
+        config: config(),
+      });
+      await store.createConfigForAssistant(tenant, ownerB, randomUUID(), {
+        key: `c-${randomUUID()}`,
+        config: config(),
+      });
+
+      expect(await store.deleteConfigsForAssistant(tenant, ownerA)).toBe(2);
+      expect(await store.getAllConfigsForAssistant(tenant, ownerA)).toEqual([]);
+      expect(await store.getAllConfigsForAssistant(tenant, ownerB)).toHaveLength(1);
+    });
+
+    it("encrypts personal env and header secrets at rest", async () => {
+      const tenant = tenantId();
+      const owner = `pa-${randomUUID()}`;
+      const id = randomUUID();
+
+      await store.createConfigForAssistant(tenant, owner, id, {
+        key: `secret-${randomUUID()}`,
+        config: config(),
+      });
+
+      const row = await pool.query(
+        "SELECT config, is_env_encrypted FROM lattice_personal_mcp_server_configs WHERE id = $1",
+        [id],
+      );
+      expect(row.rows[0].is_env_encrypted).toBe(true);
+      expect(row.rows[0].config.env.API_TOKEN).not.toBe("env-secret");
+      expect(row.rows[0].config.headers.Authorization).not.toBe("Bearer header-secret");
+
+      const read = await store.getConfigByIdForAssistant(tenant, owner, id);
+      expect(read?.config.env?.API_TOKEN).toBe("env-secret");
+      expect(read?.config.headers?.Authorization).toBe("Bearer header-secret");
+    });
+  });
 });

package/src/__tests__/PostgreSQLMcpServerConfigStore.test.ts

@@ -120,3 +120,84 @@ describe("PostgreSQLMcpServerConfigStore header encryption", () => {
     expect(read?.config.command).toBe("npx");
   });
 });
+
+describe("PostgreSQLMcpServerConfigStore personal domain SQL", () => {
+  const personalRow = (configJson: string) => ({
+    id: "cfg-personal",
+    tenant_id: "tenant-1",
+    owner_assistant_id: "pa-1",
+    key: "remote",
+    name: "Remote",
+    description: null,
+    config: configJson,
+    selected_tools: ["echo"],
+    is_env_encrypted: false,
+    status: "connected",
+    created_at: new Date("2026-01-01T00:00:00Z"),
+    updated_at: new Date("2026-01-02T00:00:00Z"),
+  });
+
+  it("writes the owner column and reads it back as the entry owner", async () => {
+    const calls: Array<{ sql: string; values: unknown[] }> = [];
+    const configJson = JSON.stringify({
+      name: "remote",
+      version: "1.0.0",
+      transport: "streamable_http",
+      url: "https://mcp.example.com/mcp",
+    });
+    const query = jest.fn(async (sql: string, values: unknown[] = []) => {
+      calls.push({ sql, values });
+      if (sql.includes("SELECT id, tenant_id, owner_assistant_id")) {
+        return { rows: [personalRow(configJson)] };
+      }
+      return { rows: [], rowCount: 0 };
+    });
+    const store = new PostgreSQLMcpServerConfigStore({ pool: { query } as unknown as Pool });
+
+    await store.createConfigForAssistant("tenant-1", "pa-1", "cfg-personal", {
+      key: "remote",
+      config: {
+        name: "remote",
+        version: "1.0.0",
+        transport: "streamable_http",
+        url: "https://mcp.example.com/mcp",
+      },
+    });
+
+    const insert = calls.find((call) => call.sql.includes("INSERT INTO lattice_personal_mcp_server_configs"));
+    expect(insert).toBeDefined();
+    expect(insert!.values[0]).toBe("cfg-personal");
+    expect(insert!.values[1]).toBe("tenant-1");
+    expect(insert!.values[2]).toBe("pa-1");
+    expect(insert!.sql).toContain("ON CONFLICT (tenant_id, owner_assistant_id, id)");
+
+    const read = await store.getConfigByKeyForAssistant("tenant-1", "pa-1", "remote");
+    expect(read).toMatchObject({
+      id: "cfg-personal",
+      tenantId: "tenant-1",
+      ownerAssistantId: "pa-1",
+      key: "remote",
+      selectedTools: ["echo"],
+    });
+
+    const select = calls.find((call) =>
+      call.sql.includes("FROM lattice_personal_mcp_server_configs") && call.sql.includes("key = $3"),
+    );
+    expect(select!.values).toEqual(["tenant-1", "pa-1", "remote"]);
+  });
+
+  it("scopes personal deletes to tenant and owner", async () => {
+    const calls: Array<{ sql: string; values: unknown[] }> = [];
+    const query = jest.fn(async (sql: string, values: unknown[] = []) => {
+      calls.push({ sql, values });
+      return { rows: [], rowCount: 2 };
+    });
+    const store = new PostgreSQLMcpServerConfigStore({ pool: { query } as unknown as Pool });
+
+    expect(await store.deleteConfigsForAssistant("tenant-1", "pa-1")).toBe(2);
+
+    const del = calls.find((call) => call.sql.includes("DELETE FROM lattice_personal_mcp_server_configs"));
+    expect(del!.sql).toContain("owner_assistant_id = $2");
+    expect(del!.values).toEqual(["tenant-1", "pa-1"]);
+  });
+});

package/src/__tests__/PostgreSQLPlatformAuditStore.test.ts

@@ -0,0 +1,446 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "@jest/globals";
+import { Pool } from "pg";
+import type {
+  PlatformAuditAppendInput,
+  PlatformAuditInitiator,
+  PlatformAuditRecord,
+} from "@axiom-lattice/protocols";
+import { createPlatformAuditTable } from "../migrations/platform_audit_migration";
+import { PostgreSQLPlatformAuditStore } from "../stores/PostgreSQLPlatformAuditStore";
+
+const databaseUrl = process.env.TEST_DATABASE_URL;
+const describeIfDatabase = databaseUrl ? describe : describe.skip;
+
+const TABLE = "lattice_platform_audit";
+
+const USER_1 = "11111111-1111-4111-8111-111111111111";
+const USER_2 = "22222222-2222-4222-8222-222222222222";
+const SYSTEM = "33333333-3333-4333-8333-333333333333";
+const BOOTSTRAP = "44444444-4444-4444-8444-444444444444";
+
+const humanInput = (
+  overrides: Partial<PlatformAuditAppendInput> = {},
+): PlatformAuditAppendInput => ({
+  initiator: { type: "human", userId: "user-1", role: "admin" },
+  source: "admin_center",
+  executor: { type: "admin_center", route: "PATCH /api/platform/settings" },
+  action: "write",
+  status: "ok",
+  summary: { changed: ["invite.defaultMaxUses"] },
+  durationMs: 12,
+  ...overrides,
+});
+
+interface RawRow {
+  id: string;
+  createdAt: string;
+  initiator?: PlatformAuditInitiator;
+  source?: PlatformAuditRecord["source"];
+  executor?: PlatformAuditRecord["executor"];
+  tenantId?: string;
+  action?: PlatformAuditRecord["action"];
+  status?: PlatformAuditRecord["status"];
+  summary?: Record<string, unknown>;
+  before?: Record<string, unknown>;
+  after?: Record<string, unknown>;
+  errorCode?: string;
+  durationMs?: number;
+}
+
+describeIfDatabase("PostgreSQLPlatformAuditStore", () => {
+  let pool: Pool;
+  let store: PostgreSQLPlatformAuditStore;
+
+  beforeAll(async () => {
+    pool = new Pool({ connectionString: databaseUrl });
+    const client = await pool.connect();
+    try {
+      await createPlatformAuditTable.up(client);
+    } finally {
+      client.release();
+    }
+    store = new PostgreSQLPlatformAuditStore({ pool });
+  });
+
+  afterAll(async () => {
+    const client = await pool.connect();
+    try {
+      await createPlatformAuditTable.down(client);
+    } finally {
+      client.release();
+    }
+    await pool.end();
+  });
+
+  beforeEach(async () => {
+    await pool.query(`DELETE FROM ${TABLE}`);
+  });
+
+  async function insertRow(row: RawRow): Promise<void> {
+    const initiator: PlatformAuditInitiator =
+      row.initiator ?? { type: "system", component: "test" };
+    const userId = initiator.type === "human" ? initiator.userId : null;
+    const role = initiator.type === "human" ? initiator.role : null;
+    await pool.query(
+      `INSERT INTO ${TABLE}
+         (id, initiator_user_id, initiator_role, initiator, source,
+          executor, tenant_id, action, status, summary, before,
+          after, error_code, duration_ms, created_at)
+       VALUES ($1,$2,$3,$4::jsonb,$5,$6::jsonb,$7,$8,$9,$10::jsonb,$11::jsonb,
+               $12::jsonb,$13,$14,$15)`,
+      [
+        row.id,
+        userId,
+        role,
+        JSON.stringify(initiator),
+        row.source ?? "system",
+        JSON.stringify(row.executor ?? { type: "system", component: "test" }),
+        row.tenantId ?? null,
+        row.action ?? "write",
+        row.status ?? "ok",
+        JSON.stringify(row.summary ?? {}),
+        row.before === undefined ? null : JSON.stringify(row.before),
+        row.after === undefined ? null : JSON.stringify(row.after),
+        row.errorCode ?? null,
+        row.durationMs ?? 1,
+        row.createdAt,
+      ],
+    );
+  }
+
+  describe("migration", () => {
+    it("applies and reverses idempotently", async () => {
+      const client = await pool.connect();
+      try {
+        await expect(createPlatformAuditTable.up(client)).resolves.toBeUndefined();
+        const exists = await client.query(
+          "SELECT to_regclass('public.lattice_platform_audit') AS name",
+        );
+        expect(exists.rows[0].name).not.toBeNull();
+
+        await createPlatformAuditTable.down(client);
+        const dropped = await client.query(
+          "SELECT to_regclass('public.lattice_platform_audit') AS name",
+        );
+        expect(dropped.rows[0].name).toBeNull();
+
+        await createPlatformAuditTable.up(client);
+      } finally {
+        client.release();
+      }
+    });
+  });
+
+  describe("append and get", () => {
+    it("returns the inserted row with a generated id and createdAt", async () => {
+      const input = humanInput({ tenantId: "tenant-1", errorCode: "NOPE" });
+      const record = await store.append(input);
+
+      expect(record.id).toEqual(expect.any(String));
+      expect(record.createdAt).toBeInstanceOf(Date);
+      expect(record.initiator).toEqual(input.initiator);
+      expect(record.source).toBe(input.source);
+      expect(record.executor).toEqual(input.executor);
+      expect(record.tenantId).toBe("tenant-1");
+      expect(record.action).toBe(input.action);
+      expect(record.status).toBe(input.status);
+      expect(record.summary).toEqual(input.summary);
+      expect(record.errorCode).toBe("NOPE");
+      expect(record.durationMs).toBe(12);
+
+      await expect(store.get(record.id)).resolves.toEqual(record);
+    });
+
+    it("returns null for a missing id", async () => {
+      await expect(
+        store.get("00000000-0000-0000-0000-000000000000"),
+      ).resolves.toBeNull();
+    });
+
+    it("round-trips nested JSON in initiator, executor, summary, before and after", async () => {
+      const input = humanInput({
+        initiator: { type: "human", userId: "user-7", role: "owner" },
+        executor: {
+          type: "ops_agent",
+          agentId: "platform-ops",
+          threadId: "thread-1",
+          runId: "run-1",
+          toolName: "update_platform_settings",
+        },
+        summary: { nested: { list: [1, "two", { three: true }] } },
+        before: { enabled: false, tags: ["a", "b"] },
+        after: { enabled: true, tags: [] },
+      });
+      const record = await store.append(input);
+      const reloaded = await store.get(record.id);
+
+      expect(reloaded).not.toBeNull();
+      expect(reloaded?.initiator).toEqual(input.initiator);
+      expect(reloaded?.executor).toEqual(input.executor);
+      expect(reloaded?.summary).toEqual(input.summary);
+      expect(reloaded?.before).toEqual(input.before);
+      expect(reloaded?.after).toEqual(input.after);
+    });
+
+    it("omits optional fields that were not provided", async () => {
+      const record = await store.append(humanInput());
+      expect(record).not.toHaveProperty("tenantId");
+      expect(record).not.toHaveProperty("before");
+      expect(record).not.toHaveProperty("after");
+      expect(record).not.toHaveProperty("errorCode");
+    });
+
+    it("normalizes durationMs to a non-negative integer", async () => {
+      const rounded = await store.append(humanInput({ durationMs: 4.6 }));
+      expect(rounded.durationMs).toBe(5);
+
+      const clamped = await store.append(humanInput({ durationMs: -3 }));
+      expect(clamped.durationMs).toBe(0);
+    });
+  });
+
+  describe("query filters", () => {
+    const ids = (rows: PlatformAuditRecord[]) => rows.map((row) => row.id);
+
+    beforeEach(async () => {
+      await insertRow({
+        id: USER_1,
+        createdAt: "2024-01-01T00:00:00.000Z",
+        initiator: { type: "human", userId: "user-1", role: "admin" },
+        source: "admin_center",
+        tenantId: "tenant-1",
+        action: "write",
+        status: "ok",
+      });
+      await insertRow({
+        id: USER_2,
+        createdAt: "2024-01-01T00:00:01.000Z",
+        initiator: { type: "human", userId: "user-2", role: "owner" },
+        source: "admin_center",
+        tenantId: "tenant-2",
+        action: "playbook",
+        status: "error",
+      });
+      await insertRow({
+        id: SYSTEM,
+        createdAt: "2024-01-01T00:00:02.000Z",
+        initiator: { type: "system", component: "scheduler" },
+        source: "system",
+        tenantId: "tenant-1",
+        action: "write",
+        status: "ok",
+      });
+      await insertRow({
+        id: BOOTSTRAP,
+        createdAt: "2024-01-01T00:00:03.000Z",
+        initiator: { type: "bootstrap" },
+        source: "bootstrap",
+        action: "playbook",
+        status: "cancelled",
+      });
+    });
+
+    it("returns everything without filters", async () => {
+      expect(ids(await store.query({}))).toEqual([
+        BOOTSTRAP,
+        SYSTEM,
+        USER_2,
+        USER_1,
+      ]);
+    });
+
+    it("filters by human initiator user id only", async () => {
+      expect(ids(await store.query({ initiatorUserId: "user-1" }))).toEqual([
+        USER_1,
+      ]);
+      expect(await store.query({ initiatorUserId: "nobody" })).toEqual([]);
+    });
+
+    it("keeps non-human records visible when initiatorUserId is absent", async () => {
+      const rows = await store.query({});
+      expect(rows.some((row) => row.initiator.type === "system")).toBe(true);
+      expect(rows.some((row) => row.initiator.type === "bootstrap")).toBe(true);
+    });
+
+    it("does not match non-human rows by component under initiatorUserId", async () => {
+      await expect(
+        store.query({ initiatorUserId: "scheduler" }),
+      ).resolves.toEqual([]);
+    });
+
+    it("filters by source", async () => {
+      expect(ids(await store.query({ source: "system" }))).toEqual([SYSTEM]);
+      expect(ids(await store.query({ source: "admin_center" }))).toEqual([
+        USER_2,
+        USER_1,
+      ]);
+    });
+
+    it("filters by tenantId", async () => {
+      expect(ids(await store.query({ tenantId: "tenant-1" }))).toEqual([
+        SYSTEM,
+        USER_1,
+      ]);
+    });
+
+    it("filters by action", async () => {
+      expect(ids(await store.query({ action: "playbook" }))).toEqual([
+        BOOTSTRAP,
+        USER_2,
+      ]);
+    });
+
+    it("filters by status", async () => {
+      expect(ids(await store.query({ status: "error" }))).toEqual([USER_2]);
+    });
+
+    it("combines filters", async () => {
+      expect(
+        ids(await store.query({ tenantId: "tenant-1", action: "write" })),
+      ).toEqual([SYSTEM, USER_1]);
+    });
+  });
+
+  describe("query ordering and pagination", () => {
+    const ids = (rows: PlatformAuditRecord[]) => rows.map((row) => row.id);
+
+    it("orders by createdAt descending then id descending", async () => {
+      const a = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
+      const b = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
+      const c = "cccccccc-cccc-4ccc-8ccc-cccccccccccc";
+      const z = "dddddddd-dddd-4ddd-8ddd-dddddddddddd";
+
+      await insertRow({ id: b, createdAt: "2024-01-01T00:00:00.000Z" });
+      await insertRow({ id: a, createdAt: "2024-01-01T00:00:00.000Z" });
+      await insertRow({ id: c, createdAt: "2024-01-01T00:00:00.000Z" });
+      await insertRow({ id: z, createdAt: "2024-01-02T00:00:00.000Z" });
+
+      expect(ids(await store.query({}))).toEqual([z, c, b, a]);
+    });
+
+    it("treats from as inclusive and to as exclusive on createdAt", async () => {
+      const early = "00000000-0000-4000-8000-000000000001";
+      const boundary = "00000000-0000-4000-8000-000000000002";
+      const late = "00000000-0000-4000-8000-000000000003";
+
+      await insertRow({ id: early, createdAt: "2024-01-01T00:00:00.000Z" });
+      await insertRow({ id: boundary, createdAt: "2024-01-01T00:00:01.000Z" });
+      await insertRow({ id: late, createdAt: "2024-01-01T00:00:02.000Z" });
+
+      expect(
+        ids(await store.query({ from: "2024-01-01T00:00:01.000Z" })),
+      ).toEqual([late, boundary]);
+      expect(
+        ids(await store.query({ to: "2024-01-01T00:00:01.000Z" })),
+      ).toEqual([early]);
+      expect(
+        ids(
+          await store.query({
+            from: "2024-01-01T00:00:00.000Z",
+            to: "2024-01-01T00:00:02.000Z",
+          }),
+        ),
+      ).toEqual([boundary, early]);
+    });
+
+    it("normalizes equivalent non-canonical and date-only boundaries", async () => {
+      const early = "00000000-0000-4000-8000-000000000001";
+      const boundary = "00000000-0000-4000-8000-000000000002";
+      const late = "00000000-0000-4000-8000-000000000003";
+
+      await insertRow({ id: early, createdAt: "2024-01-01T00:00:00.000Z" });
+      await insertRow({ id: boundary, createdAt: "2024-01-01T00:00:01.000Z" });
+      await insertRow({ id: late, createdAt: "2024-01-01T00:00:02.000Z" });
+
+      expect(
+        ids(await store.query({ from: "2024-01-01T08:00:01+08:00" })),
+      ).toEqual([late, boundary]);
+      expect(
+        ids(await store.query({ to: "2024-01-01T08:00:02+08:00" })),
+      ).toEqual([boundary, early]);
+      expect(ids(await store.query({ from: "2024-01-01" }))).toEqual([
+        late,
+        boundary,
+        early,
+      ]);
+      expect(await store.query({ to: "2024-01-01" })).toEqual([]);
+    });
+
+    it("ignores invalid or empty boundaries", async () => {
+      const a = "00000000-0000-4000-8000-000000000001";
+      const b = "00000000-0000-4000-8000-000000000002";
+
+      await insertRow({ id: a, createdAt: "2024-01-01T00:00:00.000Z" });
+      await insertRow({ id: b, createdAt: "2024-01-01T00:00:01.000Z" });
+
+      expect(ids(await store.query({ from: "not-a-date" }))).toEqual([b, a]);
+      expect(ids(await store.query({ from: "" }))).toEqual([b, a]);
+      expect(ids(await store.query({ to: "" }))).toEqual([b, a]);
+      expect(ids(await store.query({ to: "also-not-a-date" }))).toEqual([b, a]);
+    });
+
+    it("defaults to a limit of 100", async () => {
+      for (let i = 0; i < 101; i += 1) {
+        const hex = i.toString(16).padStart(12, "0");
+        await insertRow({
+          id: `00000000-0000-4000-8000-${hex}`,
+          createdAt: "2024-01-01T00:00:00.000Z",
+        });
+      }
+
+      const rows = await store.query({});
+      expect(rows).toHaveLength(100);
+      expect(rows[0].id).toBe("00000000-0000-4000-8000-000000000064");
+      expect(rows[99].id).toBe("00000000-0000-4000-8000-000000000001");
+    });
+
+    it("honors explicit limit and offset", async () => {
+      for (let i = 0; i < 5; i += 1) {
+        const hex = i.toString(16).padStart(12, "0");
+        await insertRow({
+          id: `00000000-0000-4000-8000-${hex}`,
+          createdAt: `2024-01-01T00:00:0${i}.000Z`,
+        });
+      }
+
+      expect(
+        ids(await store.query({ limit: 2, offset: 1 })),
+      ).toEqual([
+        "00000000-0000-4000-8000-000000000003",
+        "00000000-0000-4000-8000-000000000002",
+      ]);
+    });
+
+    it("clamps negative offset and limit to zero", async () => {
+      const a = "00000000-0000-4000-8000-000000000001";
+      const b = "00000000-0000-4000-8000-000000000002";
+
+      await insertRow({ id: a, createdAt: "2024-01-01T00:00:00.000Z" });
+      await insertRow({ id: b, createdAt: "2024-01-01T00:00:01.000Z" });
+
+      expect(await store.query({ limit: -1 })).toEqual([]);
+      expect(ids(await store.query({ offset: -5 }))).toEqual([b, a]);
+    });
+
+    it("falls back to defaults for non-finite and truncates fractional pagination", async () => {
+      for (let i = 0; i < 5; i += 1) {
+        const hex = i.toString(16).padStart(12, "0");
+        await insertRow({
+          id: `00000000-0000-4000-8000-${hex}`,
+          createdAt: `2024-01-01T00:00:0${i}.000Z`,
+        });
+      }
+
+      expect(await store.query({ limit: Number.NaN })).toHaveLength(5);
+      expect(
+        await store.query({ limit: Number.POSITIVE_INFINITY }),
+      ).toHaveLength(5);
+      expect(await store.query({ offset: Number.NaN })).toHaveLength(5);
+
+      expect(ids(await store.query({ limit: 2.9, offset: 1.9 }))).toEqual([
+        "00000000-0000-4000-8000-000000000003",
+        "00000000-0000-4000-8000-000000000002",
+      ]);
+    });
+  });
+});