@sixb/sqlite 0.1.21 → 0.1.23

package/src/objects/reader.ts

@@ -26,6 +26,7 @@ import {
   compileObjectQuery,
   type SqliteObjectQuerySource,
   type SqliteValue,
+  sqliteObjectsOfType,
 } from "./query-compiler"
 import type { SqliteSelectedObjectReadSource } from "./read-scope"
 import {
@@ -150,10 +151,40 @@ export class SqliteObjectReader {
     primaryId: string
   }): ObjectRow | null {
     const source = this.source
-    const objectsTable = source.objectsTable
+    const objects = sqliteObjectsOfType(source, params.objectTypeId)
     const statement = source.wrapStatement(
-      `SELECT * FROM ${objectsTable} WHERE project_id = ? AND object_type_id = ? AND primary_id = ?`,
-      [params.projectId, params.objectTypeId, params.primaryId]
+      `SELECT * FROM ${objects.table} WHERE project_id = ? AND object_type_id = ? AND primary_id = ? ${objects.filter}`,
+      [params.projectId, params.objectTypeId, params.primaryId, ...objects.args]
+    )
+    const row = this.db.query(statement.sql).get(...statement.args) as DatabaseRow | null
+
+    return row ? rowToObject(row) : null
+  }
+
+  /** On a selected source, the holder must be in scope and selected for the property. */
+  getByUniqueValue(params: Parameters<ObjectReadStorage["getByUniqueValue"]>[0]): ObjectRow | null {
+    const source = this.source
+    const selected = "objectPropertyPermissionsTable" in source
+    const permitted = selected
+      ? `AND EXISTS (
+           SELECT 1 FROM ${source.objectPropertyPermissionsTable} AS permitted
+           WHERE permitted.project_id = objects.project_id
+             AND permitted.object_type_id = objects.object_type_id
+             AND permitted.primary_id = objects.primary_id
+             AND permitted.property_id = held.property_id
+         )`
+      : ""
+    const statement = source.wrapStatement(
+      `SELECT objects.*
+       FROM object_unique_values AS held
+       JOIN ${source.objectsTable} AS objects
+         ON objects.project_id = held.project_id
+        AND objects.object_type_id = held.object_type_id
+        AND objects.primary_id = held.primary_id
+       WHERE held.project_id = ? AND held.object_type_id = ? AND held.property_id = ?
+         AND held.value_key = ?
+         ${permitted}`,
+      [params.projectId, params.objectTypeId, params.propertyId, params.valueKey]
     )
     const row = this.db.query(statement.sql).get(...statement.args) as DatabaseRow | null
 
@@ -399,17 +430,19 @@ export class SqliteObjectReader {
     total: number
   } {
     const source = this.source
-    let query = `SELECT * FROM ${source.objectsTable} WHERE project_id = ?`
-    const args: (string | number | null)[] = [params.projectId]
-
-    if (params.objectTypeId) {
-      if (typeof params.objectTypeId === "string") {
-        query += " AND object_type_id = ?"
-        args.push(params.objectTypeId)
-      } else {
-        query += ` AND object_type_id IN (${params.objectTypeId.map(() => "?").join(", ")})`
-        args.push(...params.objectTypeId)
-      }
+    const typed =
+      typeof params.objectTypeId === "string"
+        ? sqliteObjectsOfType(source, params.objectTypeId)
+        : { table: source.objectsTable, filter: "", args: [] }
+    let query = `SELECT * FROM ${typed.table} WHERE project_id = ?`
+    const args: SqliteValue[] = [params.projectId]
+
+    if (typeof params.objectTypeId === "string") {
+      query += ` AND object_type_id = ? ${typed.filter}`
+      args.push(params.objectTypeId, ...typed.args)
+    } else if (params.objectTypeId !== undefined) {
+      query += ` AND object_type_id IN (${params.objectTypeId.map(() => "?").join(", ")})`
+      args.push(...params.objectTypeId)
     }
 
     if (params.primaryIdPrefix) {

package/src/objects/scoped-reader.ts

@@ -0,0 +1,103 @@
+import type { Database } from "bun:sqlite"
+import type {
+  ObjectQueryCapabilities,
+  ObjectReadExecutionLimits,
+  ObjectReadStorage,
+} from "@sixb/core/storage"
+import {
+  assertObjectReaderProject,
+  assertObjectReadFacetCount,
+  assertObjectReadOutputWithinLimit,
+} from "@sixb/core/storage"
+import { runDeferredReadTransaction } from "../transactions"
+import type { SqliteObjectQuerySource } from "./query-compiler"
+import { assertLinkQueryLimit, SqliteObjectReader } from "./reader"
+
+/**
+ * Answer every terminal from one scoped source, each in its own synchronous snapshot so the
+ * statements of one read, and the scope's own checks before them, agree.
+ */
+export function createSqliteScopedReader(
+  db: Database,
+  params: {
+    projectId: string
+    source: SqliteObjectQuerySource
+    /** Runs first in each read's snapshot. */
+    beforeRead?: () => void
+    limits?: ObjectReadExecutionLimits
+  },
+  queryCapabilities: () => ObjectQueryCapabilities
+): ObjectReadStorage {
+  const { projectId, source, beforeRead, limits } = params
+  const reader = new SqliteObjectReader(db, source)
+  const assertProject = (actualProjectId: string): void =>
+    assertObjectReaderProject(projectId, actualProjectId)
+  const read = <T>(run: () => T): T =>
+    runDeferredReadTransaction(db, () => {
+      beforeRead?.()
+      const value = run()
+      if (limits) assertObjectReadOutputWithinLimit(value, limits)
+      return value
+    })
+  const readMap = <TKey, TValue>(run: () => Map<TKey, TValue>): Map<TKey, TValue> =>
+    runDeferredReadTransaction(db, () => {
+      beforeRead?.()
+      const value = run()
+      if (limits) assertObjectReadOutputWithinLimit([...value.entries()], limits)
+      return value
+    })
+
+  return Object.freeze({
+    queryCapabilities,
+    queryObjects: async (input) => {
+      assertProject(input.projectId)
+      return read(() => reader.queryObjects(input))
+    },
+    countObjects: async (input) => {
+      assertProject(input.projectId)
+      return read(() => reader.countObjects(input))
+    },
+    existsObjects: async (input) => {
+      assertProject(input.projectId)
+      return read(() => reader.existsObjects(input))
+    },
+    facetObjects: async (input) => {
+      assertProject(input.projectId)
+      assertObjectReadFacetCount(input.facets.length)
+      return read(() => reader.facetObjects(input))
+    },
+    getByPrimaryId: async (input) => {
+      assertProject(input.projectId)
+      return read(() => reader.getByPrimaryId(input))
+    },
+    getByUniqueValue: async (input) => {
+      assertProject(input.projectId)
+      return read(() => reader.getByUniqueValue(input))
+    },
+    selectsObjectProperties: async (input) => {
+      assertProject(input.projectId)
+      return read(() => reader.selectsObjectProperties(input))
+    },
+    listLinks: async (input) => {
+      assertProject(input.projectId)
+      return read(() => reader.listLinks(input))
+    },
+    getByPrimaryIdBatch: async (input) => {
+      assertProject(input.projectId)
+      return readMap(() => reader.getByPrimaryIdBatch(input))
+    },
+    listLinksBatch: async (input) => {
+      assertProject(input.projectId)
+      return readMap(() => reader.listLinksBatch(input))
+    },
+    queryLinks: async (input) => {
+      assertProject(input.projectId)
+      assertLinkQueryLimit(input.limit)
+      return read(() => reader.queryLinks(input))
+    },
+    list: async (input) => {
+      assertProject(input.projectId)
+      return read(() => reader.list(input))
+    },
+  } satisfies ObjectReadStorage)
+}

package/src/objects/selected-reader.ts

@@ -5,19 +5,12 @@ import type {
   ObjectReadExecutionLimits,
   ObjectReadStorage,
 } from "@sixb/core/storage"
-import {
-  assertObjectReaderProject,
-  assertObjectReadFacetCount,
-  assertObjectReadOutputWithinLimit,
-  ObjectReadLimitExceededError,
-  snapshotObjectReadExecutionLimits,
-} from "@sixb/core/storage"
-import { runDeferredReadTransaction } from "../transactions"
+import { ObjectReadLimitExceededError, snapshotObjectReadExecutionLimits } from "@sixb/core/storage"
 import {
   compileSqliteSelectedObjectReadSource,
   type SqliteSelectedObjectReadSource,
 } from "./read-scope"
-import { assertLinkQueryLimit, SqliteObjectReader } from "./reader"
+import { createSqliteScopedReader } from "./scoped-reader"
 
 /** Keep the traversal probe and every terminal statement in the same synchronous snapshot. */
 export function createSqliteSelectedReader(
@@ -36,73 +29,17 @@ export function createSqliteSelectedReader(
     params.scope,
     limits.maxTraversalFacts
   )
-  const reader = new SqliteObjectReader(db, source)
-  const assertProject = (actualProjectId: string): void =>
-    assertObjectReaderProject(projectId, actualProjectId)
-  const read = <T>(run: () => T): T =>
-    runDeferredReadTransaction(db, () => {
-      assertTraversalBudget(db, source, limits.maxTraversalFacts)
-      const value = run()
-      assertObjectReadOutputWithinLimit(value, limits)
-      return value
-    })
-  const readMap = <TKey, TValue>(run: () => Map<TKey, TValue>): Map<TKey, TValue> =>
-    runDeferredReadTransaction(db, () => {
-      assertTraversalBudget(db, source, limits.maxTraversalFacts)
-      const value = run()
-      assertObjectReadOutputWithinLimit([...value.entries()], limits)
-      return value
-    })
 
-  return Object.freeze({
-    queryCapabilities,
-    queryObjects: async (input) => {
-      assertProject(input.projectId)
-      return read(() => reader.queryObjects(input))
-    },
-    countObjects: async (input) => {
-      assertProject(input.projectId)
-      return read(() => reader.countObjects(input))
-    },
-    existsObjects: async (input) => {
-      assertProject(input.projectId)
-      return read(() => reader.existsObjects(input))
-    },
-    facetObjects: async (input) => {
-      assertProject(input.projectId)
-      assertObjectReadFacetCount(input.facets.length)
-      return read(() => reader.facetObjects(input))
-    },
-    getByPrimaryId: async (input) => {
-      assertProject(input.projectId)
-      return read(() => reader.getByPrimaryId(input))
-    },
-    selectsObjectProperties: async (input) => {
-      assertProject(input.projectId)
-      return read(() => reader.selectsObjectProperties(input))
-    },
-    listLinks: async (input) => {
-      assertProject(input.projectId)
-      return read(() => reader.listLinks(input))
-    },
-    getByPrimaryIdBatch: async (input) => {
-      assertProject(input.projectId)
-      return readMap(() => reader.getByPrimaryIdBatch(input))
-    },
-    listLinksBatch: async (input) => {
-      assertProject(input.projectId)
-      return readMap(() => reader.listLinksBatch(input))
-    },
-    queryLinks: async (input) => {
-      assertProject(input.projectId)
-      assertLinkQueryLimit(input.limit)
-      return read(() => reader.queryLinks(input))
-    },
-    list: async (input) => {
-      assertProject(input.projectId)
-      return read(() => reader.list(input))
-    },
-  } satisfies ObjectReadStorage)
+  return createSqliteScopedReader(
+    db,
+    {
+      projectId,
+      source,
+      beforeRead: () => assertTraversalBudget(db, source, limits.maxTraversalFacts),
+      limits,
+    },
+    queryCapabilities
+  )
 }
 
 function assertTraversalBudget(

package/src/objects/storage.ts

@@ -1,6 +1,7 @@
 import type { Database } from "bun:sqlite"
 import { hasVectorProfile } from "@sixb/core/internal/query"
 import type {
+  CompiledConditionalObjectReadScope,
   CompiledSelectedObjectReadScope,
   CountObjectsInput,
   CountObjectsResult,
@@ -28,6 +29,7 @@ import {
   runDeferredReadTransaction,
   type SqliteStoreConnection,
 } from "../transactions"
+import { createSqliteConditionalReader } from "./conditional-reader"
 import { DEFAULT_OBJECT_QUERY_SOURCE } from "./query-compiler"
 import { assertLinkQueryLimit, SqliteObjectReader } from "./reader"
 import { type DatabaseRow, type LinkDatabaseRow, rowToLink, rowToObject } from "./rows"
@@ -72,6 +74,7 @@ const SQLITE_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
     in: true,
     exists: true,
     contains: true,
+    constant: true,
   },
   sortKinds: {
     property: true,
@@ -137,6 +140,13 @@ export class SqliteObjectStorage implements ObjectStorage {
     return createSqliteSelectedReader(this.db, params, () => this.queryCapabilities())
   }
 
+  createConditionalReadScope(params: {
+    projectId: string
+    scope: CompiledConditionalObjectReadScope
+  }): ObjectReadStorage {
+    return createSqliteConditionalReader(this.db, params, () => this.queryCapabilities())
+  }
+
   async queryObjects(params: QueryObjectsInput): Promise<QueryObjectsResult> {
     if (hasVectorProfile(params.query))
       return runDeferredReadTransaction(this.db, () => this.reader.queryObjects(params))
@@ -167,6 +177,12 @@ export class SqliteObjectStorage implements ObjectStorage {
     return this.reader.getByPrimaryId(params)
   }
 
+  async getByUniqueValue(
+    params: Parameters<ObjectReadStorage["getByUniqueValue"]>[0]
+  ): Promise<ObjectRow | null> {
+    return this.reader.getByUniqueValue(params)
+  }
+
   async selectsObjectProperties(
     params: Parameters<ObjectReadStorage["selectsObjectProperties"]>[0]
   ): Promise<readonly boolean[]> {

package/src/ontology-storage/index.ts

@@ -7,6 +7,7 @@ import { SqliteOntologyOutboxStorage } from "./outbox"
 import { SqliteOntologyReplacementPlanStorage } from "./replacement-plans"
 import type { SqliteRootOperation } from "./shared"
 import { SqliteOntologySourceStorage } from "./sources"
+import { SqliteOntologyUniqueValueStorage } from "./unique-values"
 import { SqliteVectorIndexingStorage } from "./vector-indexing"
 import { SqliteOntologyVectorStorage } from "./vectors"
 
@@ -18,6 +19,7 @@ export class SqliteOntologyStorage implements OntologyStorage {
   readonly vectorIndexing: SqliteVectorIndexingStorage
   readonly vectors: SqliteOntologyVectorStorage
   readonly outbox: SqliteOntologyOutboxStorage
+  readonly uniqueValues: SqliteOntologyUniqueValueStorage
 
   constructor(input: {
     readonly db: Database
@@ -46,6 +48,7 @@ export class SqliteOntologyStorage implements OntologyStorage {
         this.materializations.assertVectorSession(session, projectId, commitId)
     )
     this.outbox = new SqliteOntologyOutboxStorage(input.db, input.runRootOperation)
+    this.uniqueValues = new SqliteOntologyUniqueValueStorage(input.db, input.runRootOperation)
   }
 
   deactivateSessions(): void {

package/src/ontology-storage/materialization-writer.ts

@@ -11,6 +11,11 @@ import {
 } from "@sixb/core/internal/ontology-storage-provider"
 import type { ExactEffectiveLinkWrite, ExactEffectiveObjectWrite } from "@sixb/core/storage"
 import { assertTimestamp, canonicalJson, isSqliteConstraintError, requireChanges } from "./shared"
+import {
+  assertSqliteUniquePrepared,
+  claimSqliteUniqueValue,
+  releaseSqliteUniqueValue,
+} from "./unique-values"
 
 function linkOverrideConflictMessage(identityKind: "edge" | "slot"): string {
   return identityKind === "edge"
@@ -30,9 +35,18 @@ export class SqliteMaterializationWriter {
     this.applyOverrides(projectId, chunk)
     this.applyEffective(projectId, chunk)
     this.applyTimeseries(projectId, chunk)
+    this.applyUniqueValues(projectId, chunk)
     this.applyOutbox(projectId, commitId, chunk)
   }
 
+  /** A chunk holds one phase: the commit's releases all apply before its first claim. */
+  private applyUniqueValues(projectId: string, chunk: MaterializationPlanChunk): void {
+    for (const item of chunk.unique.releases) releaseSqliteUniqueValue(this.db, projectId, item)
+
+    assertSqliteUniquePrepared(this.db, projectId, chunk.unique.claims)
+    for (const item of chunk.unique.claims) claimSqliteUniqueValue(this.db, projectId, item)
+  }
+
   private applyOverrides(projectId: string, chunk: MaterializationPlanChunk): void {
     for (const item of chunk.overrides.objects.upserts) {
       if (item.expectedLastCommitId === null) {

package/src/ontology-storage/materializations.ts

@@ -65,6 +65,7 @@ import {
   type SqliteOntologySourceRow,
 } from "./shared"
 import { activateSourceRoots } from "./source-roots"
+import { sqliteUniqueHolder } from "./unique-values"
 
 /** Rows the provider reads and writes at once while it applies a staged plan. */
 const APPLY_PAGE_ROWS = 1_000
@@ -111,7 +112,9 @@ function touchAppliedWorkStatement(workTable: string): string {
       END AS ref
     FROM ${workTable}
     WHERE work_id = $workId AND lane = 'apply'
-  )`
+  )
+  -- Unique values are no plan input: a stale claim fails when it applies.
+  WHERE kind IS NOT NULL`
 }
 
 export class SqliteOntologyMaterializationStorage implements OntologyMaterializationStorage {
@@ -225,6 +228,18 @@ export class SqliteOntologyMaterializationStorage implements OntologyMaterializa
         const page = reader.exactPoints(points.slice(offset, offset + input.pageRows))
         if (page.length > 0) yield { objects: [], links: [], linkScopes: [], points: page }
       }
+      const uniqueValues = request.uniqueValues ?? []
+      for (let offset = 0; offset < uniqueValues.length; offset += input.pageRows) {
+        const uniqueHolders = uniqueValues
+          .slice(offset, offset + input.pageRows)
+          .flatMap((value) => {
+            const primaryId = sqliteUniqueHolder(this.db, session.header.commit.projectId, value)
+            return primaryId === null ? [] : [{ ...value, primaryId }]
+          })
+        if (uniqueHolders.length > 0) {
+          yield { objects: [], links: [], linkScopes: [], points: [], uniqueHolders }
+        }
+      }
     }
   }
 

package/src/ontology-storage/unique-values.ts

@@ -0,0 +1,187 @@
+import type { Database } from "bun:sqlite"
+import {
+  uniquePropertyNotPrepared,
+  uniqueValueViolation,
+} from "@sixb/core/internal/ontology-storage-provider"
+import type {
+  ExactUniqueValueClaim,
+  ExactUniqueValueWrite,
+  OntologyUniqueValueStorage,
+  PreparedUniqueProperty,
+  UniqueValueEntry,
+  UniqueValueRef,
+} from "@sixb/core/storage"
+import type { SqliteRootOperation } from "./shared"
+
+/** The object holding a unique value, or null when none does. */
+export function sqliteUniqueHolder(
+  db: Database,
+  projectId: string,
+  value: UniqueValueRef
+): string | null {
+  const row = db
+    .query(
+      `SELECT primary_id FROM object_unique_values
+       WHERE project_id = ? AND object_type_id = ? AND property_id = ? AND value_key = ?`
+    )
+    .get(projectId, value.objectTypeId, value.propertyId, value.valueKey) as {
+    readonly primary_id: string
+  } | null
+  return row?.primary_id ?? null
+}
+
+/** Gives the value to its object, unless another object holds it. */
+export function claimSqliteUniqueValue(
+  db: Database,
+  projectId: string,
+  value: ExactUniqueValueWrite
+): void {
+  const holder = sqliteUniqueHolder(db, projectId, value)
+  if (holder === value.primaryId) return
+  if (holder !== null) throw uniqueValueViolation(value, holder, value.primaryId)
+
+  db.query(
+    `INSERT INTO object_unique_values (
+       project_id, object_type_id, property_id, value_key, primary_id
+     ) VALUES (?, ?, ?, ?, ?)`
+  ).run(projectId, value.objectTypeId, value.propertyId, value.valueKey, value.primaryId)
+}
+
+/**
+ * Refuses claims on a property whose values were not built with the claims' keys. Each property
+ * is checked once per call, however many of its values the claims take.
+ */
+export function assertSqliteUniquePrepared(
+  db: Database,
+  projectId: string,
+  claims: readonly ExactUniqueValueClaim[]
+): void {
+  const checked = new Set<string>()
+  const prepared = db.query(
+    `SELECT 1 FROM object_unique_properties
+     WHERE project_id = ? AND object_type_id = ? AND property_id = ?
+       AND key_kind = ? AND key_version = ?`
+  )
+
+  for (const claim of claims) {
+    const key = JSON.stringify([
+      claim.objectTypeId,
+      claim.propertyId,
+      claim.keyKind,
+      claim.keyVersion,
+    ])
+    if (checked.has(key)) continue
+    checked.add(key)
+
+    const row = prepared.get(
+      projectId,
+      claim.objectTypeId,
+      claim.propertyId,
+      claim.keyKind,
+      claim.keyVersion
+    )
+    if (!row) throw uniquePropertyNotPrepared(claim)
+  }
+}
+
+/** Drops the value if its object still holds it. */
+export function releaseSqliteUniqueValue(
+  db: Database,
+  projectId: string,
+  value: ExactUniqueValueWrite
+): void {
+  db.query(
+    `DELETE FROM object_unique_values
+     WHERE project_id = ? AND object_type_id = ? AND property_id = ? AND value_key = ?
+       AND primary_id = ?`
+  ).run(projectId, value.objectTypeId, value.propertyId, value.valueKey, value.primaryId)
+}
+
+export class SqliteOntologyUniqueValueStorage implements OntologyUniqueValueStorage {
+  constructor(
+    private readonly db: Database,
+    private readonly runRootOperation: SqliteRootOperation
+  ) {}
+
+  /** A SQLite database has one writer at a time: preparers already take turns. */
+  async lockPreparation(_input: { readonly projectId: string }): Promise<void> {}
+
+  async listPrepared(input: {
+    readonly projectId: string
+  }): Promise<readonly PreparedUniqueProperty[]> {
+    return this.runRootOperation(() => {
+      const rows = this.db
+        .query(
+          `SELECT object_type_id, property_id, key_kind, key_version FROM object_unique_properties
+           WHERE project_id = ?
+           ORDER BY object_type_id, property_id`
+        )
+        .all(input.projectId) as {
+        readonly object_type_id: string
+        readonly property_id: string
+        readonly key_kind: PreparedUniqueProperty["keyKind"]
+        readonly key_version: number
+      }[]
+      return rows.map((row) => ({
+        objectTypeId: row.object_type_id,
+        propertyId: row.property_id,
+        keyKind: row.key_kind,
+        keyVersion: row.key_version,
+      }))
+    })
+  }
+
+  async clear(input: {
+    readonly projectId: string
+    readonly objectTypeId: string
+    readonly propertyId: string
+  }): Promise<void> {
+    await this.runRootOperation(() => {
+      for (const table of ["object_unique_values", "object_unique_properties"]) {
+        this.db
+          .query(
+            `DELETE FROM ${table} WHERE project_id = ? AND object_type_id = ? AND property_id = ?`
+          )
+          .run(input.projectId, input.objectTypeId, input.propertyId)
+      }
+    })
+  }
+
+  async insert(input: {
+    readonly projectId: string
+    readonly objectTypeId: string
+    readonly propertyId: string
+    readonly entries: readonly UniqueValueEntry[]
+  }): Promise<void> {
+    const { projectId, objectTypeId, propertyId } = input
+    await this.runRootOperation(() => {
+      for (const entry of input.entries) {
+        claimSqliteUniqueValue(this.db, projectId, { objectTypeId, propertyId, ...entry })
+      }
+    })
+  }
+
+  async markPrepared(
+    input: PreparedUniqueProperty & { readonly projectId: string; readonly preparedAt: string }
+  ): Promise<void> {
+    await this.runRootOperation(() => {
+      this.db
+        .query(
+          `INSERT INTO object_unique_properties (
+             project_id, object_type_id, property_id, key_kind, key_version, prepared_at
+           ) VALUES (?, ?, ?, ?, ?, ?)
+           ON CONFLICT (project_id, object_type_id, property_id)
+           DO UPDATE SET key_kind = excluded.key_kind, key_version = excluded.key_version,
+             prepared_at = excluded.prepared_at`
+        )
+        .run(
+          input.projectId,
+          input.objectTypeId,
+          input.propertyId,
+          input.keyKind,
+          input.keyVersion,
+          input.preparedAt
+        )
+    })
+  }
+}

package/src/transactions.ts

@@ -108,7 +108,7 @@ export function runDeferredReadTransaction<T>(db: Database, run: () => T): T {
   }
   if (db.inTransaction) {
     throw new Error(
-      "[SixbSqlite] Selected object reads cannot join an unverified SQLite transaction."
+      "[SixbSqlite] Scoped object reads cannot join an unverified SQLite transaction."
     )
   }