@sixb/core 0.1.16 → 0.1.18

package/src/testing/ai-limit-storage-contract.ts

@@ -9,6 +9,7 @@ import type {
   AiUsageStorage,
   AuthStorage,
   ExecutionStorage,
+  RecordAiModelCallInput,
   ReserveAiModelCallInput,
   Storage,
 } from "../storage"
@@ -536,6 +537,65 @@ export function runAiLimitStorageContractSuite<TStorage extends AiLimitStorageCo
       })
     })
 
+    // Removal proof: drop aiLimitMeterApplies from a provider's reserve loop (admission reports
+    // missingEstimate) or from resolveAiLimitActual (the meter becomes unavailable).
+    test("token limits neither admit nor count transcription and reranking", async () => {
+      await withStorage(async (storage) => {
+        const status = async () =>
+          (
+            await storage.aiLimits.listPolicyStatuses({
+              projectId,
+              at: at("2026-08-15T12:00:01.000Z"),
+            })
+          )[0]
+        await recordUsageInput(storage.aiUsage, {
+          id: "usage-transcription",
+          callId: "transcription",
+          modelKind: "transcription",
+          usage: { audioDurationMs: 1250 },
+        })
+        await recordUsage(storage.aiUsage, "usage-language", "language", 4)
+        await storage.aiLimits.createPolicy({
+          id: "tokens",
+          projectId,
+          subject: project,
+          limit: { meter: "tokens.total", amount: 10 },
+        })
+        expect(await status()).toMatchObject({
+          accountingStatus: "complete",
+          consumption: { actual: { amount: 4 } },
+        })
+
+        const cost: AiLimitQuantity = {
+          meter: "cost.catalogEstimated",
+          amount: { currency: "USD", amountNanos: "100" },
+        }
+        await expect(
+          storage.aiLimits.reserveModelCall(
+            reservation("reranking", 0, { estimates: [cost], modelKind: "reranking" })
+          )
+        ).resolves.toEqual({ status: "notRequired" })
+        await expect(
+          storage.aiLimits.reserveModelCall(reservation("language", 0, { estimates: [cost] }))
+        ).resolves.toMatchObject({ status: "unavailable", reasons: ["missingEstimate"] })
+
+        await recordUsageInput(storage.aiUsage, {
+          id: "usage-reranking",
+          callId: "reranking",
+          modelKind: "reranking",
+          usage: {},
+        })
+        await storage.aiLimits.recordModelCallActuals({
+          projectId,
+          usageRecordId: "usage-reranking",
+        })
+        expect(await status()).toMatchObject({
+          accountingStatus: "complete",
+          consumption: { actual: { amount: 4 } },
+        })
+      })
+    })
+
     test("charges actuals to the ledger occurrence month", async () => {
       await withStorage(async (storage) => {
         await storage.aiLimits.createPolicy({
@@ -1062,6 +1122,7 @@ async function recordUsageInput(
     readonly executionId?: string
     readonly requesterGroupIds?: readonly string[]
     readonly occurredAt?: Date
+    readonly modelKind?: RecordAiModelCallInput["modelKind"]
     readonly usage: AiModelCallUsageInput
   }
 ): Promise<void> {
@@ -1074,6 +1135,7 @@ async function recordUsageInput(
     requesterGroupIds: input.requesterGroupIds ?? ["support"],
     providerId: "test",
     requestedModelId: "test/model",
+    ...(input.modelKind === undefined ? {} : { modelKind: input.modelKind }),
     responseId: `response:${input.callId}`,
     usage: input.usage,
     occurredAt: input.occurredAt ?? at("2026-08-15T12:00:00.500Z"),

package/src/testing/ai-usage-storage-contract.ts

@@ -69,6 +69,37 @@ export function runAiUsageStorageContractSuite<TStorage extends AiUsageStorage>(
   }
 
   describe(label, () => {
+    // Removal proof: omit audioDurationMs from a row codec; this round trip fails.
+    test("persists transcription usage and kind without invented token totals", async () => {
+      await withStorage(async (storage) => {
+        const input = modelCallInput({
+          modelKind: "transcription",
+          usage: { audioDurationMs: 1250 },
+        })
+        await storage.recordModelCall(input)
+        const latest = await storage.getLatestForExecution({
+          projectId,
+          executionId: agentExecutionId,
+        })
+        expect(latest?.modelKind).toBe("transcription")
+        expect(latest?.usage).toEqual({ audioDurationMs: 1250, reportingStatus: "partial" })
+        expect((await storage.recordModelCall(input)).created).toBe(false)
+        expect(
+          await storage.summarizeExecution({ projectId, executionId: agentExecutionId })
+        ).toMatchObject({ modelCallCount: 1, usage: { audioDurationMs: 1250 } })
+      })
+    })
+    // Removal proof: omit 'reranking' from a storage migration's model_kind check; the write fails.
+    test("persists reranking usage kind", async () => {
+      await withStorage(async (storage) => {
+        await storage.recordModelCall(modelCallInput({ modelKind: "reranking", usage: {} }))
+        const latest = await storage.getLatestForExecution({
+          projectId,
+          executionId: agentExecutionId,
+        })
+        expect(latest?.modelKind).toBe("reranking")
+      })
+    })
     test("retains native provider IDs across reads and replay", async () => {
       // Regression proof: omit providerIds in normalization or a storage row codec.
       await withStorage(async (storage) => {

package/src/testing/file-download-grant-storage-contract.ts

@@ -0,0 +1,139 @@
+import { describe, expect, test } from "bun:test"
+import type {
+  FileDownloadGrantRecord,
+  FileDownloadGrantStorage,
+} from "../storage/file-download-grants"
+
+export interface FileDownloadGrantStorageContractSuiteOptions<
+  TStorage extends FileDownloadGrantStorage = FileDownloadGrantStorage,
+> {
+  /** Returns an isolated provider capability for every test. */
+  readonly createStorage: () => TStorage | Promise<TStorage>
+  readonly cleanup?: (storage: TStorage) => void | Promise<void>
+}
+
+const projectId = "file-download-grant-contract"
+const createdAt = new Date("2026-10-05T12:00:00.000Z")
+const hour = 60 * 60 * 1000
+
+/** Provider-neutral persistence contract for file download grants. */
+export function runFileDownloadGrantStorageContractSuite<TStorage extends FileDownloadGrantStorage>(
+  label: string,
+  options: FileDownloadGrantStorageContractSuiteOptions<TStorage>
+): void {
+  const withStorage = async (run: (storage: TStorage) => Promise<void>): Promise<void> => {
+    const storage = await options.createStorage()
+    try {
+      await run(storage)
+    } finally {
+      await options.cleanup?.(storage)
+    }
+  }
+
+  describe(label, () => {
+    test("finds a grant by its project and token hash", async () => {
+      await withStorage(async (storage) => {
+        const grant = grantRecord()
+        await storage.create(grant)
+
+        expect(await storage.findByTokenHash({ projectId, tokenHash: grant.tokenHash })).toEqual(
+          grant
+        )
+        expect(
+          await storage.findByTokenHash({ projectId: "other-project", tokenHash: grant.tokenHash })
+        ).toBeNull()
+        expect(await storage.findByTokenHash({ projectId, tokenHash: "f".repeat(64) })).toBeNull()
+      })
+    })
+
+    test("rejects a second grant with the same id or token hash", async () => {
+      await withStorage(async (storage) => {
+        await storage.create(grantRecord())
+
+        await expect(storage.create(grantRecord({ tokenHash: "b".repeat(64) }))).rejects.toThrow()
+        await expect(storage.create(grantRecord({ id: "filedownload_2" }))).rejects.toThrow()
+        await storage.create(grantRecord({ projectId: "other-project" }))
+      })
+    })
+
+    test("keeps the first revocation", async () => {
+      await withStorage(async (storage) => {
+        await storage.create(grantRecord())
+        const first = new Date(createdAt.getTime() + 1_000)
+
+        const revoked = await storage.revoke({ projectId, id: "filedownload_1", revokedAt: first })
+        const again = await storage.revoke({
+          projectId,
+          id: "filedownload_1",
+          revokedAt: new Date(first.getTime() + 1_000),
+        })
+
+        expect(revoked?.revokedAt).toEqual(first)
+        expect(again?.revokedAt).toEqual(first)
+        expect(
+          (await storage.findByTokenHash({ projectId, tokenHash: "a".repeat(64) }))?.revokedAt
+        ).toEqual(first)
+        expect(
+          await storage.revoke({
+            projectId: "other-project",
+            id: "filedownload_1",
+            revokedAt: first,
+          })
+        ).toBeNull()
+      })
+    })
+
+    test("deletes only the project's grants that expired before the cutoff, up to the limit", async () => {
+      await withStorage(async (storage) => {
+        const expiringAt = (hours: number) => new Date(createdAt.getTime() + hours * hour)
+        await storage.create(
+          grantRecord({ id: "g1", tokenHash: "1".repeat(64), expiresAt: expiringAt(1) })
+        )
+        await storage.create(
+          grantRecord({ id: "g2", tokenHash: "2".repeat(64), expiresAt: expiringAt(2) })
+        )
+        await storage.create(
+          grantRecord({ id: "g3", tokenHash: "3".repeat(64), expiresAt: expiringAt(3) })
+        )
+        await storage.create(
+          grantRecord({ projectId: "other-project", id: "g1", expiresAt: expiringAt(1) })
+        )
+        const cutoff = { projectId, expiredBefore: expiringAt(3) }
+
+        expect(await storage.deleteExpired({ ...cutoff, limit: 1 })).toBe(1)
+        expect(await storage.deleteExpired({ ...cutoff, limit: 10 })).toBe(1)
+        expect(await storage.deleteExpired({ ...cutoff, limit: 10 })).toBe(0)
+
+        const remaining = await Promise.all(
+          ["1", "2", "3"].map((digit) =>
+            storage.findByTokenHash({ projectId, tokenHash: digit.repeat(64) })
+          )
+        )
+        expect(remaining.map((grant) => grant?.id ?? null)).toEqual([null, null, "g3"])
+        expect(
+          await storage.findByTokenHash({ projectId: "other-project", tokenHash: "a".repeat(64) })
+        ).not.toBeNull()
+      })
+    })
+  })
+}
+
+function grantRecord(overrides: Partial<FileDownloadGrantRecord> = {}): FileDownloadGrantRecord {
+  const digest = "c".repeat(64)
+  return {
+    id: "filedownload_1",
+    projectId,
+    tokenHash: "a".repeat(64),
+    file: {
+      blobId: `blob_${digest}`,
+      digest: `sha256:${digest}`,
+      sizeBytes: 10,
+      fileName: "photo.jpg",
+      mediaType: "image/jpeg",
+    },
+    executionId: "execution-1",
+    createdAt,
+    expiresAt: new Date(createdAt.getTime() + hour),
+    ...overrides,
+  }
+}

package/src/testing/index.ts

@@ -59,6 +59,10 @@ export {
   type ExecutionStorageContractSuiteOptions,
   runExecutionStorageContractSuite,
 } from "./execution-storage-contract"
+export {
+  type FileDownloadGrantStorageContractSuiteOptions,
+  runFileDownloadGrantStorageContractSuite,
+} from "./file-download-grant-storage-contract"
 export {
   type FileUploadSessionStorageContractSuiteOptions,
   runFileUploadSessionStorageContractSuite,

package/src/testing/lake-storage-contract.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import type { FileRef } from "../blob-storage"
-import { col, defineDataset } from "../datasets"
+import { col, type DatasetDefinition, defineDataset } from "../datasets"
 import { LakeStorageError } from "../lake-storage/errors"
 import type { DatasetRow, LakeStorage } from "../lake-storage/types"
 
@@ -284,6 +284,92 @@ export function runLakeStorageContractSuite<TStorage extends LakeStorage>(
       })
     })
 
+    describe("change feed", () => {
+      const commitSnapshot = async (
+        storage: TStorage,
+        dataset: DatasetDefinition,
+        rows: readonly DatasetRow[]
+      ) => {
+        const write = await storage.beginWrite({ dataset, mode: "snapshot" })
+        await write.writeRows(rows)
+        return write.commit()
+      }
+      const byDatasetId = <T extends { readonly datasetId: string }>(versions: readonly T[]) =>
+        [...versions].sort((left, right) => left.datasetId.localeCompare(right.datasetId))
+
+      test("reports the newest data version of each dataset changed after a cursor", async () => {
+        await withStorage(async (storage) => {
+          await storage.createDataset(writeDataset)
+          await storage.createDataset(nullableWriteDataset)
+          const start = await storage.listLatestVersionsSince({ cursor: null })
+          expect(start?.versions).toEqual([])
+
+          await commitSnapshot(storage, writeDataset, [{ orderId: "ord_1", customerName: "Ada" }])
+          const orders = await commitSnapshot(storage, writeDataset, [
+            { orderId: "ord_2", customerName: "Grace" },
+          ])
+          const notes = await commitSnapshot(storage, nullableWriteDataset, [
+            { orderId: "ord_1", note: null },
+          ])
+
+          const changed = await storage.listLatestVersionsSince({ cursor: start!.cursor })
+          expect(byDatasetId(changed?.versions ?? [])).toEqual([
+            {
+              datasetId: nullableWriteDataset.id,
+              versionId: notes.versionId,
+              mode: "snapshot",
+              createdAt: notes.createdAt,
+              rowCount: 1,
+            },
+            {
+              datasetId: writeDataset.id,
+              versionId: orders.versionId,
+              mode: "snapshot",
+              createdAt: orders.createdAt,
+              rowCount: 1,
+            },
+          ])
+          await expect(
+            storage.listLatestVersionsSince({
+              cursor: start!.cursor,
+              datasetIds: [nullableWriteDataset.id],
+            })
+          ).resolves.toMatchObject({ versions: [{ versionId: notes.versionId }] })
+          await expect(
+            storage.listLatestVersionsSince({ cursor: changed!.cursor })
+          ).resolves.toEqual({ cursor: changed!.cursor, versions: [] })
+        })
+      })
+
+      test("skips unchanged writes and schema-only versions", async () => {
+        await withStorage(async (storage) => {
+          await storage.createDataset(nullableWriteDataset)
+          const rows = [{ orderId: "ord_1", note: null }]
+          await commitSnapshot(storage, nullableWriteDataset, rows)
+          const start = await storage.listLatestVersionsSince({ cursor: null })
+
+          const unchanged = await commitSnapshot(storage, nullableWriteDataset, rows)
+          expect(unchanged.outcome).toBe("unchanged")
+          if (schemaEvolution === "addNullableColumns") {
+            await storage.createDataset(
+              defineDataset(nullableWriteDataset.id, {
+                schema: [
+                  col("orderId", "string"),
+                  col("note", "string", { nullable: true }),
+                  col("added", "string", { nullable: true }),
+                ],
+              })
+            )
+            expect((await storage.getLatestVersion(nullableWriteDataset.id))?.mode).toBe("schema")
+          }
+
+          await expect(
+            storage.listLatestVersionsSince({ cursor: start!.cursor })
+          ).resolves.toMatchObject({ versions: [] })
+        })
+      })
+    })
+
     describe("writes and reads", () => {
       test("cancels reads before starting and between rows", async () => {
         // Red check: remove readRows' signal checks in the provider under test.