@sixb/core 0.1.16 → 0.1.18

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,12 +12,16 @@ 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"
+export type { RedactionReason, Redactions } from "../security/types"
 export type {
   ShareAccessPlan,
   ShareScopedActionGrant,
@@ -351,6 +355,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 +391,7 @@ export type {
   MigrationStep,
   MigrationStepInfo,
   MigrationStepOptions,
+  StorageMigrationOptions,
   StorageMigrationResult,
   StorageMigrator,
   StorageSchemaCheck,
@@ -448,13 +460,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 +487,13 @@ export type {
   ExactEffectiveLinkWrite,
   ExactEffectiveObjectDelete,
   ExactEffectiveObjectWrite,
-  ExactEffectiveWrites,
   ExactLinkOverrideDelete,
   ExactLinkOverrideWrite,
   ExactLinkSlotOverrideDelete,
   ExactLinkSlotOverrideWrite,
   ExactObjectOverrideDelete,
   ExactObjectOverrideWrite,
-  ExactOverrideWrites,
   ExactTimeseriesPointWrite,
-  ExactTimeseriesWrites,
   ExpectedSourceRevision,
   ExpectedTimeseriesPointRevision,
   FinalizeMaterializationInput,
@@ -501,7 +516,6 @@ export type {
   MaterializationObjectExistence,
   MaterializationObjectExistenceWorkRecord,
   MaterializationObjectState,
-  MaterializationPlanChunk,
   MaterializationPlanFinalization,
   MaterializationPlanHeader,
   MaterializationPlanWorkItem,
@@ -509,8 +523,9 @@ export type {
   MaterializationSession,
   MaterializationStatePage,
   MaterializationStateRequestChunk,
+  MaterializationVectorChange,
+  MaterializationVectorChangePage,
   MaterializationWorkEntityKind,
-  MaterializationWorkPage,
   MaterializationWorkRecord,
   ObjectVectorState,
   OntologyCommitOriginSelector,
@@ -526,22 +541,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 +576,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 }
 }

package/src/storage/migrations/types.ts

@@ -1,3 +1,5 @@
+import type { OntologyDefinitionCatalog } from "../../ontology/registry"
+import type { ObjectQueryPreparationResult } from "../objects/query-preparation"
 import type { Storage } from "../types"
 
 export interface MigrationStepInfo {
@@ -123,7 +125,13 @@ export interface MigrationCapableStorage extends Storage {
   readonly migrators: readonly StorageMigrator[]
 }
 
+export interface StorageMigrationOptions {
+  readonly projectId: string
+  readonly ontology: OntologyDefinitionCatalog
+}
+
 export interface StorageMigrationResult {
+  readonly queries?: ObjectQueryPreparationResult
   readonly status: "migrated" | "current" | "skipped"
   readonly reports: readonly MigrationReport[]
 }

package/src/storage/objects/in-memory/query.ts

@@ -117,6 +117,8 @@ export function evaluateObjectQuery(
   source: InMemoryReadSource
 ): QueryEvaluation {
   switch (query.kind) {
+    case "rerank":
+      throw new Error("[Sixb] Reranking must execute in the model runtime, not storage.")
     case "start":
       return evaluateStart(query.objectTypeId, source)
     case "refs":

package/src/storage/objects/in-memory/selected-reader.ts

@@ -105,6 +105,7 @@ export function createInMemorySelectedReader(
       const result = evaluateObjectQuery(stripOuterRowShape(input.query), universe)
       return visible(
         structuredClone({
+          total: result.entries.length,
           facets: buildFacetResults(
             result.entries.map((entry) => entry.row),
             input.facets

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

@@ -305,6 +305,7 @@ export class InMemoryObjectStorage implements ObjectStorage {
       this.readSource(params.projectId)
     )
     return {
+      total: result.entries.length,
       facets: buildFacetResults(
         result.entries.map((entry) => entry.row),
         params.facets

package/src/storage/objects/query-preparation.ts

@@ -0,0 +1,77 @@
+import type { QueryScalarKind } from "../../objects/query/ir"
+import {
+  queryScalarKindForSchema,
+  resolvePropertyQueryCapabilities,
+  resolveQuerySchema,
+} from "../../ontology/query-capabilities"
+import type { OntologyDefinitionCatalog } from "../../ontology/registry"
+import type { ObjectQueryIndexDefinition } from "../../ontology/types"
+import type { Storage } from "../types"
+
+export interface ObjectQueryPreparationPlan {
+  readonly projectId: string
+  readonly objectTypes: readonly {
+    readonly objectTypeId: string
+    readonly properties: readonly {
+      readonly propertyId: string
+      readonly scalarKind?: QueryScalarKind
+      readonly filterable: boolean
+      readonly sortable: boolean
+      readonly text: boolean
+    }[]
+    readonly indexes: readonly ObjectQueryIndexDefinition[]
+  }[]
+}
+
+export interface ObjectQueryPreparationResult {
+  readonly status: "prepared" | "current"
+  readonly objectTypes: number
+  readonly indexes: number
+  readonly warnings: readonly string[]
+}
+
+/** Optional maintenance capability, separate from object reads and writes. */
+export interface QueryPreparationCapableStorage extends Storage {
+  /** Coordinate concurrent callers and skip completed plans. Backfills may block writes. */
+  prepareObjectQueries(plan: ObjectQueryPreparationPlan): Promise<ObjectQueryPreparationResult>
+}
+
+export function isQueryPreparationCapableStorage(
+  storage: Storage
+): storage is QueryPreparationCapableStorage {
+  return "prepareObjectQueries" in storage && typeof storage.prepareObjectQueries === "function"
+}
+
+/** Prepare declared query access paths after schema migration. Providers own physical layout;
+ * applications describe their ontology, not PostgreSQL expressions or generated columns.
+ * This is maintenance: backfills may block writes and must not run in a request handler. */
+export async function prepareObjectQueries(input: {
+  projectId: string
+  ontology: OntologyDefinitionCatalog
+  storage: Storage
+}): Promise<ObjectQueryPreparationResult> {
+  if (!isQueryPreparationCapableStorage(input.storage)) {
+    throw new Error("[Sixb] This storage provider does not support object query preparation")
+  }
+
+  const values = input.ontology.getValueTypesById()
+  const objectTypes = input.ontology.listObjectTypes().map((type) => ({
+    objectTypeId: type.id,
+    properties: type.properties
+      .filter((property) => property.mode !== "telemetry" && !property.primary)
+      .map((property) => {
+        const capabilities = resolvePropertyQueryCapabilities(property, values)
+        const schema = resolveQuerySchema(property.schema, values)
+        return {
+          propertyId: property.id,
+          scalarKind: schema ? queryScalarKindForSchema(schema) : undefined,
+          filterable: capabilities.operators.includes("eq"),
+          sortable: capabilities.sortable,
+          text: capabilities.text,
+        }
+      })
+      .filter((property) => property.filterable || property.sortable || property.text),
+    indexes: type.query?.indexes ?? [],
+  }))
+  return input.storage.prepareObjectQueries({ projectId: input.projectId, objectTypes })
+}

package/src/storage/objects/types.ts

@@ -6,6 +6,7 @@ import type {
   ObjectQuerySortField,
   QueryScalarKind,
 } from "../../objects/query"
+import type { Redactions } from "../../security/types"
 import type { ObjectReadExecutionLimits } from "./execution-limits"
 import type { LinkBatchKey, ObjectBatchKey } from "./keys"
 
@@ -33,6 +34,12 @@ export interface ObjectRow {
    * `.links` typing are layered on top of this runtime shape.
    */
   links?: ObjectRowLinks
+  /**
+   * Properties omitted because the reader lacks a clearance, keyed by property id.
+   *
+   * Populated by the authorized object reader; storage providers never read or write it.
+   */
+  redactions?: Redactions
 }
 
 /** Per-link expansion result keyed by link id (see {@link ObjectQueryExpand}). */
@@ -261,6 +268,8 @@ export interface FacetObjectsInput {
 }
 
 export interface FacetObjectsResult {
+  /** Exact matching rows, including absent facet values and buckets beyond the limit. */
+  total: number
   facets: readonly ObjectFacetResult[]
 }
 

package/src/storage/ontology/commits.ts

@@ -1,5 +1,3 @@
-import type { AuthorizablePrincipal } from "../../execution/types"
-import type { EventExecutor } from "../../materialization/events"
 import type {
   EditCommitResult,
   OntologyMaterializationOrigin,
@@ -56,12 +54,9 @@ interface OntologyCommitFields {
   readonly id: string
   readonly idempotencyKey: string
   readonly requestHash: string
+  /** The execution the commit ran under: who asked for it and what wrote it live there. */
   readonly executionId: string
   readonly origin: OntologyMaterializationOrigin
-  /** Principal on whose behalf the execution ran, copied from `ExecutionRecord.requestedBy`. */
-  readonly requestedBy?: AuthorizablePrincipal
-  /** Workload that wrote the commit, copied from its execution. */
-  readonly executor: EventExecutor
   readonly ontologyRevision: string
   readonly projectionRevision?: string
   readonly ownershipHash?: string