@sixb/core 0.1.16 → 0.1.17

package/src/storage/ai-limits/provider.ts

@@ -1,7 +1,9 @@
+import type { ModelKind } from "../../models/definitions"
 import type { AiMoney } from "../ai-cost"
 import { AiLimitStorageError } from "./errors"
 import { aiLimitCalendarMonth } from "./period"
 import type {
+  AiLimitMeter,
   AiLimitPeriod,
   AiLimitPolicy,
   AiLimitQuantity,
@@ -16,6 +18,20 @@ import type {
 
 const SIGNED_INT64_MAX = 9_223_372_036_854_775_807n
 
+// These calls are billed per audio second or per search, and their providers report no tokens.
+// Token limits neither admit nor count them; cost limits still do.
+const TOKENLESS_MODEL_KINDS: ReadonlySet<ModelKind> = new Set(["transcription", "reranking"])
+
+/** @internal Whether a limit meter governs calls of this kind. Unclassified calls are metered. */
+export function aiLimitMeterApplies(
+  meter: AiLimitMeter,
+  modelKind: ModelKind | undefined
+): boolean {
+  return (
+    meter !== "tokens.total" || modelKind === undefined || !TOKENLESS_MODEL_KINDS.has(modelKind)
+  )
+}
+
 /** @internal Serialize compound limit operations, including within an existing transaction. */
 export class AiLimitOperationLock {
   private tail: Promise<void> = Promise.resolve()
@@ -55,6 +71,7 @@ export interface AiLimitAccountingEntry {
   readonly attempt: number
   readonly callId: string
   readonly occurredAt: Date
+  readonly modelKind?: ModelKind
   readonly totalTokens?: number
   readonly requesterGroupIds: readonly string[]
   readonly requester?:
@@ -228,6 +245,7 @@ export function normalizeReserveAiModelCall(input: ReserveAiModelCallInput): {
   readonly identity: AiModelCallReservationIdentity
   readonly subjects: readonly AiLimitSubject[]
   readonly estimates: readonly AiLimitQuantity[]
+  readonly modelKind?: ModelKind
   readonly period: AiLimitPeriod
   readonly reservedAt: Date
 } {
@@ -237,6 +255,7 @@ export function normalizeReserveAiModelCall(input: ReserveAiModelCallInput): {
     identity,
     subjects: normalizeAiLimitSubjects(input.subjects),
     estimates: normalizeAiLimitQuantities(input.estimates, "estimates"),
+    ...(input.modelKind === undefined ? {} : { modelKind: input.modelKind }),
     period: aiLimitCalendarMonth(reservedAt),
     reservedAt,
   }
@@ -297,13 +316,16 @@ export function aiLimitReservationRequestKey(
       const amount = normalizeAiLimitAmount(quantity)
       return [amount.meter, amount.currency, amount.amount.toString()]
     }),
+    // Appended only when present, so keys of reservations made before model kinds stay valid.
+    ...(request.modelKind === undefined ? [] : [request.modelKind]),
   ])
 }
 
 export function aiLimitReservationBuckets(
   policies: readonly AiLimitPolicy[],
   subjects: readonly AiLimitSubject[],
-  estimates: readonly AiLimitQuantity[]
+  estimates: readonly AiLimitQuantity[],
+  modelKind?: ModelKind
 ): readonly AiLimitReservationBucket[] {
   const subjectKeys = new Set(subjects.map(aiLimitSubjectKey))
   const estimatesByDimension = new Map(
@@ -313,7 +335,11 @@ export function aiLimitReservationBuckets(
     })
   )
   return policies
-    .filter((policy) => subjectKeys.has(aiLimitSubjectKey(policy.subject)))
+    .filter(
+      (policy) =>
+        subjectKeys.has(aiLimitSubjectKey(policy.subject)) &&
+        aiLimitMeterApplies(policy.limit.meter, modelKind)
+    )
     .flatMap((policy) => {
       const estimate = estimatesByDimension.get(
         aiLimitAmountKey(normalizeAiLimitAmount(policy.limit))
@@ -357,6 +383,7 @@ export function resolveAiLimitActual(
   let accountingStatus: ResolvedAiLimitActual["accountingStatus"] = "complete"
   for (const entry of entries) {
     if (dimension.meter === "tokens.total") {
+      if (!aiLimitMeterApplies(dimension.meter, entry.modelKind)) continue
       if (entry.totalTokens === undefined) {
         accountingStatus = "unavailable"
       } else {

package/src/storage/ai-limits/types.ts

@@ -1,3 +1,4 @@
+import type { ModelKind } from "../../models/definitions"
 import type { AiMoney } from "../ai-cost"
 
 /** A project-wide, group, or durable requester identity charged for AI model calls. */
@@ -129,6 +130,8 @@ export interface ReserveAiModelCallInput extends AiModelCallReservationIdentity
   /** The project subject is always added, even when omitted here. */
   readonly subjects: readonly AiLimitSubject[]
   readonly estimates: readonly AiLimitQuantity[]
+  /** Transcription and reranking calls are outside token limits; see `aiLimitMeterApplies`. */
+  readonly modelKind?: ModelKind
   readonly reservedAt?: Date
 }
 

package/src/storage/ai-usage/record.ts

@@ -19,6 +19,14 @@ export function normalizeAiModelCallRecord(input: RecordAiModelCallInput): AiMod
   }
   assertNonBlank(input.responseId, "responseId")
 
+  if (
+    input.modelKind !== undefined &&
+    !["language", "image", "video", "embedding", "decision", "transcription", "reranking"].includes(
+      input.modelKind
+    )
+  ) {
+    throw new TypeError("[Sixb] AI model kind is invalid.")
+  }
   const occurredAt = cloneValidDate(input.occurredAt, "occurredAt")
   const recordedAt = cloneValidDate(input.recordedAt ?? new Date(), "recordedAt")
   const requesterGroupIds = normalizeRequesterGroupIds(input.requesterGroupIds)
@@ -37,6 +45,7 @@ export function normalizeAiModelCallRecord(input: RecordAiModelCallInput): AiMod
       ? {}
       : { providerIds: normalizeModelProviderIds(input.providerIds) }),
     requestedModelId: input.requestedModelId,
+    ...(input.modelKind === undefined ? {} : { modelKind: input.modelKind }),
     ...(requestedReasoning === undefined ? {} : { requestedReasoning }),
     ...(input.responseModelId === undefined ? {} : { responseModelId: input.responseModelId }),
     responseId: input.responseId,

package/src/storage/ai-usage/types.ts

@@ -1,11 +1,13 @@
 import type { ReadonlyJsonObject } from "../../json"
 import type { ModelReasoning } from "../../models/language-model"
 
-/** How much normalized token usage a provider reported for one model call. */
+/** Coverage of normalized usage. Complete means both token totals are known; duration alone is partial. */
 export type AiUsageReportingStatus = "complete" | "partial" | "unavailable"
 
-/** Provider-neutral token counts accepted at the model-call boundary. */
+/** Provider-neutral usage accepted at the model-call boundary. */
 export interface AiModelCallUsageInput {
+  /** Audio content duration in milliseconds, rounded to the nearest millisecond. Not billed duration. */
+  readonly audioDurationMs?: number
   readonly inputTokens?: number
   readonly outputTokens?: number
   readonly uncachedInputTokens?: number
@@ -15,7 +17,7 @@ export interface AiModelCallUsageInput {
   readonly reasoningOutputTokens?: number
 }
 
-/** Normalized token counts for one completed model call. Details overlap their input/output totals. */
+/** Normalized usage for one completed model call. Token details overlap their input/output totals. */
 export interface AiModelCallUsage extends AiModelCallUsageInput {
   /** Present only when both input and output totals are known. */
   readonly totalTokens?: number
@@ -32,6 +34,8 @@ export interface AiUsageExecutionSummary {
 
 /** Input for an idempotent model-call ledger append. */
 export interface RecordAiModelCallInput {
+  /** Absent for historical calls whose kind was not captured. */
+  readonly modelKind?: import("../../models/definitions").ModelKind
   readonly providerIds?: import("../../models/events").ModelProviderIds
   readonly id: string
   readonly projectId: string
@@ -89,7 +93,7 @@ export interface GetLatestAiModelCallForExecutionInput {
   readonly executionId: string
 }
 
-/** Durable, provider-neutral accounting for completed language-model calls. */
+/** Durable, provider-neutral accounting for completed model calls. */
 export interface AiUsageStorage {
   /**
    * Append one model-call record idempotently. The identity is project, execution ID, attempt, call

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

@@ -8,6 +8,7 @@ const USAGE_FIELDS = [
   "cacheWriteInputTokens",
   "textOutputTokens",
   "reasoningOutputTokens",
+  "audioDurationMs",
 ] as const
 
 type AiUsageField = (typeof USAGE_FIELDS)[number]
@@ -30,6 +31,7 @@ export function normalizeAiModelCallUsage(input: AiModelCallUsageInput): AiModel
         : "unavailable"
 
   return {
+    ...(input.audioDurationMs === undefined ? {} : { audioDurationMs: input.audioDurationMs }),
     ...(input.inputTokens === undefined ? {} : { inputTokens: input.inputTokens }),
     ...(input.outputTokens === undefined ? {} : { outputTokens: input.outputTokens }),
     ...(totalTokens === undefined ? {} : { totalTokens }),

package/src/storage/file-download-grants/in-memory.ts

@@ -0,0 +1,73 @@
+import { cloneFileDownloadGrantRecord } from "./record"
+import type {
+  DeleteExpiredFileDownloadGrantsInput,
+  FileDownloadGrantRecord,
+  FileDownloadGrantStorage,
+  FindFileDownloadGrantInput,
+  RevokeFileDownloadGrantInput,
+} from "./types"
+
+export class InMemoryFileDownloadGrantStorage implements FileDownloadGrantStorage {
+  private rows = new Map<string, FileDownloadGrantRecord>()
+
+  async create(record: FileDownloadGrantRecord): Promise<void> {
+    const duplicate = [...this.rows.values()].some(
+      (current) =>
+        current.projectId === record.projectId &&
+        (current.id === record.id || current.tokenHash === record.tokenHash)
+    )
+    if (duplicate) {
+      throw new Error(`[Sixb] File download grant '${record.id}' conflicts with an existing one.`)
+    }
+    this.rows.set(rowKey(record.projectId, record.id), cloneFileDownloadGrantRecord(record))
+  }
+
+  async findByTokenHash(
+    input: FindFileDownloadGrantInput
+  ): Promise<FileDownloadGrantRecord | null> {
+    for (const record of this.rows.values()) {
+      if (record.projectId === input.projectId && record.tokenHash === input.tokenHash) {
+        return cloneFileDownloadGrantRecord(record)
+      }
+    }
+    return null
+  }
+
+  async revoke(input: RevokeFileDownloadGrantInput): Promise<FileDownloadGrantRecord | null> {
+    const key = rowKey(input.projectId, input.id)
+    const current = this.rows.get(key)
+    if (!current) return null
+    if (!current.revokedAt) {
+      this.rows.set(key, { ...current, revokedAt: new Date(input.revokedAt) })
+    }
+    return cloneFileDownloadGrantRecord(this.rows.get(key) as FileDownloadGrantRecord)
+  }
+
+  async deleteExpired(input: DeleteExpiredFileDownloadGrantsInput): Promise<number> {
+    const expired = [...this.rows.entries()]
+      .filter(
+        ([, record]) =>
+          record.projectId === input.projectId &&
+          record.expiresAt.getTime() < input.expiredBefore.getTime()
+      )
+      .slice(0, input.limit)
+    for (const [key] of expired) this.rows.delete(key)
+    return expired.length
+  }
+
+  snapshot(): ReadonlyMap<string, FileDownloadGrantRecord> {
+    return new Map(
+      [...this.rows].map(([key, record]) => [key, cloneFileDownloadGrantRecord(record)])
+    )
+  }
+
+  restore(snapshot: ReadonlyMap<string, FileDownloadGrantRecord>): void {
+    this.rows = new Map(
+      [...snapshot].map(([key, record]) => [key, cloneFileDownloadGrantRecord(record)])
+    )
+  }
+}
+
+function rowKey(projectId: string, id: string): string {
+  return `${projectId}\0${id}`
+}

package/src/storage/file-download-grants/index.ts

@@ -0,0 +1,8 @@
+export { InMemoryFileDownloadGrantStorage } from "./in-memory"
+export type {
+  DeleteExpiredFileDownloadGrantsInput,
+  FileDownloadGrantRecord,
+  FileDownloadGrantStorage,
+  FindFileDownloadGrantInput,
+  RevokeFileDownloadGrantInput,
+} from "./types"

package/src/storage/file-download-grants/record.ts

@@ -0,0 +1,47 @@
+import { isFileRef } from "../../blob-storage"
+import type { FileDownloadGrantRecord } from "./types"
+
+/**
+ * Rebuilds a grant from a provider row with camelCase keys. `file` may arrive parsed (jsonb) or
+ * as text (SQLite), and timestamps as `Date` or ISO text. Fails closed on corruption: a grant that
+ * cannot be read must not serve a file.
+ */
+export function parseFileDownloadGrantRow(row: {
+  readonly [column: string]: unknown
+}): FileDownloadGrantRecord {
+  const id = text(row.id, "id", String(row.id))
+  const file = typeof row.file === "string" ? JSON.parse(row.file) : row.file
+  if (!isFileRef(file)) throw corrupt(id, "file is not a file reference")
+
+  return {
+    id,
+    projectId: text(row.projectId, "projectId", id),
+    tokenHash: text(row.tokenHash, "tokenHash", id),
+    file,
+    executionId: text(row.executionId, "executionId", id),
+    createdAt: date(row.createdAt, "createdAt", id),
+    expiresAt: date(row.expiresAt, "expiresAt", id),
+    ...(row.revokedAt == null ? {} : { revokedAt: date(row.revokedAt, "revokedAt", id) }),
+  }
+}
+
+export function cloneFileDownloadGrantRecord(
+  record: FileDownloadGrantRecord
+): FileDownloadGrantRecord {
+  return structuredClone(record)
+}
+
+function text(value: unknown, column: string, id: string): string {
+  if (typeof value !== "string" || value.length === 0) throw corrupt(id, `${column} is not text`)
+  return value
+}
+
+function date(value: unknown, column: string, id: string): Date {
+  const parsed = value instanceof Date || typeof value === "string" ? new Date(value) : null
+  if (!parsed || !Number.isFinite(parsed.getTime())) throw corrupt(id, `${column} is not a date`)
+  return parsed
+}
+
+function corrupt(id: string, reason: string): Error {
+  return new Error(`[Sixb] Stored file download grant '${id}' is invalid: ${reason}.`)
+}

package/src/storage/file-download-grants/types.ts

@@ -0,0 +1,48 @@
+import type { FileRef } from "../../blob-storage"
+
+/**
+ * One download URL issued by `blobs.createDownloadUrl()`. Each call issues its own grant, so URLs
+ * for the same file expire and are revoked independently.
+ */
+export interface FileDownloadGrantRecord {
+  readonly id: string
+  readonly projectId: string
+  /** SHA-256 hex of the URL token. The token itself is never stored. */
+  readonly tokenHash: string
+  /** The file the URL serves, without `logicalPath`: serving the bytes does not need it. */
+  readonly file: FileRef
+  /** The execution that issued the URL, so an exposure can be traced back to its cause. */
+  readonly executionId: string
+  readonly createdAt: Date
+  readonly expiresAt: Date
+  readonly revokedAt?: Date
+}
+
+export interface FindFileDownloadGrantInput {
+  readonly projectId: string
+  readonly tokenHash: string
+}
+
+export interface RevokeFileDownloadGrantInput {
+  readonly projectId: string
+  readonly id: string
+  readonly revokedAt: Date
+}
+
+export interface DeleteExpiredFileDownloadGrantsInput {
+  readonly projectId: string
+  readonly expiredBefore: Date
+  readonly limit: number
+}
+
+/** Persistence only: token generation, expiry, and revocation checks live in Core. */
+export interface FileDownloadGrantStorage {
+  /** `(projectId, id)` and `(projectId, tokenHash)` are each unique. */
+  create(record: FileDownloadGrantRecord): Promise<void>
+  /** Returns expired and revoked grants too; the caller decides whether one still serves. */
+  findByTokenHash(input: FindFileDownloadGrantInput): Promise<FileDownloadGrantRecord | null>
+  /** Keeps the first revocation. Returns the grant, or `null` when it does not exist. */
+  revoke(input: RevokeFileDownloadGrantInput): Promise<FileDownloadGrantRecord | null>
+  /** Deletes up to `limit` grants that expired before `expiredBefore`, and returns the count. */
+  deleteExpired(input: DeleteExpiredFileDownloadGrantsInput): Promise<number>
+}

package/src/storage/in-memory/index.ts

@@ -13,6 +13,10 @@ import {
 import { StorageTransactionError } from "../errors"
 import { InMemoryExecutionStorage } from "../executions/in-memory"
 import type { ExecutionStorage } from "../executions/types"
+import {
+  type FileDownloadGrantStorage,
+  InMemoryFileDownloadGrantStorage,
+} from "../file-download-grants"
 import { type FileUploadSessionStore, InMemoryFileUploadSessions } from "../file-upload-sessions"
 import type { ObjectStorage } from "../objects"
 import { InMemoryObjectStorage } from "../objects/in-memory"
@@ -116,6 +120,7 @@ export class InMemoryStorage implements Storage {
   private readonly webhookRunStorage = new InMemoryWebhookRunStorage(this.executionStorage)
   private readonly rulesStorage = new InMemoryRulesStorage()
   private readonly fileUploadSessionStorage = new InMemoryFileUploadSessions()
+  private readonly fileDownloadGrantStorage = new InMemoryFileDownloadGrantStorage()
   private readonly connectorConnectionStorage: InMemoryConnectorConnectionStorage
   readonly auth: AuthStorage
   readonly executions: ExecutionStorage
@@ -134,6 +139,7 @@ export class InMemoryStorage implements Storage {
   readonly shareGrants: ShareGrantStorage
   readonly shareSessions: ShareSessionStorage
   readonly fileUploadSessions: FileUploadSessionStore
+  readonly fileDownloadGrants: FileDownloadGrantStorage
   readonly connectorConnections: ConnectorConnectionStorage
 
   constructor(options: InMemoryStorageOptions = {}) {
@@ -166,6 +172,7 @@ export class InMemoryStorage implements Storage {
     this.shareGrants = createOperationScopedFacade(this.shareGrantStorage, scope)
     this.shareSessions = createOperationScopedFacade(this.shareSessionStorage, scope)
     this.fileUploadSessions = createOperationScopedFacade(this.fileUploadSessionStorage, scope)
+    this.fileDownloadGrants = createOperationScopedFacade(this.fileDownloadGrantStorage, scope)
     this.connectorConnections = createOperationScopedFacade(this.connectorConnectionStorage, scope)
     this.ontologyStorage = new InMemoryOntologyStorage(this.objectStorage, this.timeseriesStorage, {
       runRootOperation: async (run) => run(),
@@ -173,8 +180,8 @@ export class InMemoryStorage implements Storage {
       getMaterializationLifecycle: () => this.getActiveMaterializationLifecycle(),
       assertSourceMaterializationExecution: (input) =>
         this.projectionRunStorage.assertSourceMaterializationExecutionUnlocked(input),
-      executionExists: async (projectId, executionId) =>
-        (await this.executionStorage.getById({ projectId, id: executionId })) !== null,
+      readExecution: (projectId, executionId) =>
+        this.executionStorage.getById({ projectId, id: executionId }),
     })
     this.ontology = createOntologyOperationScope(this.ontologyStorage, scope)
     this.ontologyStorage.registerTestingAlias(this.ontology)
@@ -375,6 +382,7 @@ export class InMemoryStorage implements Storage {
       shareGrants: this.shareGrantStorage,
       shareSessions: this.shareSessionStorage,
       fileUploadSessions: this.fileUploadSessionStorage,
+      fileDownloadGrants: this.fileDownloadGrantStorage,
       connectorConnections: this.connectorConnectionStorage,
       ping: async () => undefined,
       transaction: async <T>(): Promise<T> => {
@@ -405,6 +413,7 @@ export class InMemoryStorage implements Storage {
       shareGrants: this.shareGrantStorage.snapshot(),
       shareSessions: this.shareSessionStorage.snapshot(),
       fileUploadSessions: this.fileUploadSessionStorage.snapshot(),
+      fileDownloadGrants: this.fileDownloadGrantStorage.snapshot(),
       connectorConnections: this.connectorConnectionStorage.snapshot(),
     }
   }
@@ -430,6 +439,7 @@ export class InMemoryStorage implements Storage {
     this.shareGrantStorage.restore(snapshot.shareGrants)
     this.shareSessionStorage.restore(snapshot.shareSessions)
     this.fileUploadSessionStorage.restore(snapshot.fileUploadSessions)
+    this.fileDownloadGrantStorage.restore(snapshot.fileDownloadGrants)
     this.connectorConnectionStorage.restore(snapshot.connectorConnections)
   }
 }
@@ -455,5 +465,6 @@ export interface InMemoryStorageSnapshot {
   readonly shareGrants: ReturnType<InMemoryShareGrantStorage["snapshot"]>
   readonly shareSessions: ReturnType<InMemoryShareSessionStorage["snapshot"]>
   readonly fileUploadSessions: ReturnType<InMemoryFileUploadSessions["snapshot"]>
+  readonly fileDownloadGrants: ReturnType<InMemoryFileDownloadGrantStorage["snapshot"]>
   readonly connectorConnections: ReturnType<InMemoryConnectorConnectionStorage["snapshot"]>
 }

package/src/storage/index.ts

@@ -12,9 +12,12 @@ export type { StoredRuleResolvedEvent, StoredRuleTriggeredEvent } from "../event
 export type { ReadonlyJsonObject } from "../json"
 export { stableJsonStringify } from "../json"
 export type {
+  EffectiveChangeCounts,
   PinnedDatasetVersion,
+  ProjectionEntityRef,
   ProjectionExecution,
   ProjectionMaterializationIdentity,
+  ProjectionSourceRef,
 } from "../materialization/model"
 export type { ModelProviderIds } from "../models/events"
 export type { ObjectRef } from "../ontology"
@@ -351,6 +354,13 @@ export type {
   TrustedPrimitiveRef,
 } from "./executions"
 export { ExecutionStorageError } from "./executions"
+export type {
+  DeleteExpiredFileDownloadGrantsInput,
+  FileDownloadGrantRecord,
+  FileDownloadGrantStorage,
+  FindFileDownloadGrantInput,
+  RevokeFileDownloadGrantInput,
+} from "./file-download-grants"
 export type {
   CreateFileUploadSessionInput,
   FileUploadSession,
@@ -380,6 +390,7 @@ export type {
   MigrationStep,
   MigrationStepInfo,
   MigrationStepOptions,
+  StorageMigrationOptions,
   StorageMigrationResult,
   StorageMigrator,
   StorageSchemaCheck,
@@ -448,13 +459,19 @@ export {
   objectLinkCursor,
   snapshotObjectReadExecutionLimits,
 } from "./objects"
+export type {
+  ObjectQueryPreparationPlan,
+  ObjectQueryPreparationResult,
+  QueryPreparationCapableStorage,
+} from "./objects/query-preparation"
 export type {
   AbandonRunSourceMaterializationInput,
   AbandonSourceMaterializationCandidateInput,
   AbandonSourceMaterializationInput,
   AdoptedSourceMaterialization,
   AdoptSourceMaterializationInput,
-  ApplyMaterializationChunkInput,
+  AppliedMaterialization,
+  ApplyMaterializationInput,
   ApplyMaterializationResult,
   AssertSourceMaterializationExecution,
   AssertSourceMaterializationExecutionInput,
@@ -469,16 +486,13 @@ export type {
   ExactEffectiveLinkWrite,
   ExactEffectiveObjectDelete,
   ExactEffectiveObjectWrite,
-  ExactEffectiveWrites,
   ExactLinkOverrideDelete,
   ExactLinkOverrideWrite,
   ExactLinkSlotOverrideDelete,
   ExactLinkSlotOverrideWrite,
   ExactObjectOverrideDelete,
   ExactObjectOverrideWrite,
-  ExactOverrideWrites,
   ExactTimeseriesPointWrite,
-  ExactTimeseriesWrites,
   ExpectedSourceRevision,
   ExpectedTimeseriesPointRevision,
   FinalizeMaterializationInput,
@@ -501,7 +515,6 @@ export type {
   MaterializationObjectExistence,
   MaterializationObjectExistenceWorkRecord,
   MaterializationObjectState,
-  MaterializationPlanChunk,
   MaterializationPlanFinalization,
   MaterializationPlanHeader,
   MaterializationPlanWorkItem,
@@ -509,8 +522,9 @@ export type {
   MaterializationSession,
   MaterializationStatePage,
   MaterializationStateRequestChunk,
+  MaterializationVectorChange,
+  MaterializationVectorChangePage,
   MaterializationWorkEntityKind,
-  MaterializationWorkPage,
   MaterializationWorkRecord,
   ObjectVectorState,
   OntologyCommitOriginSelector,
@@ -526,22 +540,28 @@ export type {
   OntologyOutboxRecord,
   OntologyOutboxStorage,
   OntologyOutboxSummary,
-  OntologyOutboxWrite,
+  OntologyReplacementPlanStorage,
   OntologySourceMaterializationStatus,
   OntologySourceRecord,
   OntologySourceStorage,
   OntologyStorage,
   OntologyVectorStorage,
+  OpenedReplacementPlan,
+  OpenReplacementPlanInput,
+  PlannedReplacementIdentity,
   ProjectionOntologyCommitIntent,
   PurgeAbandonedSourceMaterializationsInput,
   PurgePublishedOntologyOutboxInput,
-  ReadMaterializationObjectExistenceInput,
+  PurgeReplacementPlansInput,
+  ReplacementPlanRef,
+  ReplacementPlanStatePage,
+  ReplacementPlanStatus,
   RescheduleOntologyOutboxLeaseInput,
   SourceActivationWrite,
   SourceReplacementLinkState,
   SourceReplacementObjectState,
-  SourceReplacementStatePage,
   StageMaterializationWorkInput,
+  StageReplacementPlanInput,
   StageSourceAssertion,
   StageSourceRoot,
   StageSourceRowsInput,
@@ -555,12 +575,10 @@ export type {
   StoredSourceObjectAssertion,
   StoredTelemetryPoint,
   StreamMaterializationStateInput,
-  StreamMaterializationWorkInput,
-  StreamSourceReplacementStateInput,
+  StreamMaterializationVectorChangesInput,
+  StreamReplacementPlanStateInput,
   SummarizeOntologyOutboxInput,
-  SummarizeTerminalSourceMaterializationsInput,
   TelemetryOntologyCommitIntent,
-  TerminalSourceMaterializationSummary,
 } from "./ontology"
 export { ONTOLOGY_OUTBOX_FAILURE_CODES } from "./ontology"
 export type {

package/src/storage/internal.ts

@@ -9,6 +9,7 @@ export {
 } from "./action-runs/idempotency"
 export { assertAiUsageExecutionId, normalizeAiModelCallRecord } from "./ai-usage/record"
 export { normalizeAiModelCallUsage } from "./ai-usage/usage"
+export { parseFileDownloadGrantRow } from "./file-download-grants/record"
 export { createFileUploadId, createUploadExpiresAt } from "./file-upload-sessions/utils"
 export { canRequeuePipelineRunAfterEnqueueFailure } from "./pipeline-runs/idempotency"
 export { projectionRunObjectTypesVisible, zeroProjectionRunProgress } from "./projection-runs/types"

package/src/storage/migrations/index.ts

@@ -18,6 +18,7 @@ export type {
   MigrationStep,
   MigrationStepInfo,
   MigrationStepOptions,
+  StorageMigrationOptions,
   StorageMigrationResult,
   StorageMigrator,
 } from "./types"

package/src/storage/migrations/migrate-storage.ts

@@ -1,24 +1,48 @@
+import {
+  isQueryPreparationCapableStorage,
+  type ObjectQueryPreparationResult,
+  prepareObjectQueries,
+} from "../objects/query-preparation"
 import type { Storage } from "../types"
-import type { MigrationCapableStorage, MigrationReport, StorageMigrationResult } from "./types"
+import type {
+  MigrationCapableStorage,
+  MigrationReport,
+  StorageMigrationOptions,
+  StorageMigrationResult,
+} from "./types"
 
 export function isMigrationCapableStorage(storage: Storage): storage is MigrationCapableStorage {
   return Array.isArray((storage as { migrators?: unknown }).migrators)
 }
 
-/** Runs storage adapter migrators when the configured storage exposes them. */
-export async function migrateStorage(storage: Storage): Promise<StorageMigrationResult> {
-  if (!isMigrationCapableStorage(storage) || storage.migrators.length === 0) {
-    return { status: "skipped", reports: [] }
-  }
-
+/** Run schema migrations, then prepare query indexes when the provider supports it. */
+export async function migrateStorage(
+  storage: Storage,
+  options?: StorageMigrationOptions
+): Promise<StorageMigrationResult> {
   const reports: MigrationReport[] = []
+  if (isMigrationCapableStorage(storage)) {
+    for (const migrator of storage.migrators) {
+      reports.push(await migrator.migrate())
+    }
+  }
 
-  for (const migrator of storage.migrators) {
-    reports.push(await migrator.migrate())
+  let queries: ObjectQueryPreparationResult | undefined
+  if (options && isQueryPreparationCapableStorage(storage)) {
+    queries = await prepareObjectQueries({ ...options, storage })
+    for (const warning of queries.warnings) {
+      console.warn(`[Sixb] ${warning}`)
+    }
   }
 
-  return {
-    status: reports.some((report) => report.status === "migrated") ? "migrated" : "current",
-    reports,
+  let status: StorageMigrationResult["status"] = "skipped"
+  if (reports.length > 0 || queries) {
+    status = "current"
   }
+  if (reports.some((report) => report.status === "migrated") || queries?.status === "prepared") {
+    status = "migrated"
+  }
+
+  if (queries) return { status, reports, queries }
+  return { status, reports }
 }