@sixb/core 0.1.20 → 0.1.22

package/src/storage/ontology/provider-work.ts

@@ -1,6 +1,8 @@
 import {
   MaterializationConflictError,
   MaterializationValidationError,
+  UniquePropertyNotPreparedError,
+  UniqueValueViolationError,
 } from "../../materialization/errors"
 import { eventAttribution, materializationEvent } from "../../materialization/event-envelopes"
 import type {
@@ -34,6 +36,8 @@ import {
   type ExactObjectOverrideDelete,
   type ExactObjectOverrideWrite,
   type ExactTimeseriesPointWrite,
+  type ExactUniqueValueClaim,
+  type ExactUniqueValueWrite,
   type MaterializationCardinalityOccupantWorkRecord,
   type MaterializationEventWorkRecord,
   type MaterializationPlanHeader,
@@ -41,6 +45,7 @@ import {
   type MaterializationPlanWorkRecord,
   type MaterializationWorkRecord,
   materializationApplyPhase,
+  type UniqueValueRef,
 } from "./materializations"
 import type { ClaimedOntologyOutboxRow, OntologyMaterializationEventDraft } from "./outbox"
 import { assertMaterializationHeader } from "./provider-header-validation"
@@ -67,6 +72,8 @@ export function materializationChunkRows(chunk: MaterializationPlanChunk): numbe
     chunk.effective.linkUpserts.length +
     chunk.effective.linkDeletes.length +
     chunk.timeseries.pointUpserts.length +
+    chunk.unique.releases.length +
+    chunk.unique.claims.length +
     chunk.outbox.length
   )
 }
@@ -99,11 +106,18 @@ export interface ExactTimeseriesWrites {
   readonly pointUpserts: readonly ExactTimeseriesPointWrite[]
 }
 
+/** A chunk holds one phase, so releases and claims never share one. */
+export interface ExactUniqueValueWrites {
+  readonly releases: readonly ExactUniqueValueWrite[]
+  readonly claims: readonly ExactUniqueValueClaim[]
+}
+
 /** Plan items and outbox writes of one bounded provider write, grouped by table. */
 export interface MaterializationPlanChunk {
   readonly overrides: ExactOverrideWrites
   readonly effective: ExactEffectiveWrites
   readonly timeseries: ExactTimeseriesWrites
+  readonly unique: ExactUniqueValueWrites
   readonly outbox: readonly OntologyOutboxWrite[]
 }
 
@@ -136,6 +150,10 @@ export function materializationPlanChunk(
       linkDeletes: [] as ExactEffectiveLinkDelete[],
     },
     timeseries: { pointUpserts: [] as ExactTimeseriesPointWrite[] },
+    unique: {
+      releases: [] as ExactUniqueValueWrite[],
+      claims: [] as ExactUniqueValueClaim[],
+    },
     outbox,
   }
   for (const item of items) {
@@ -173,6 +191,12 @@ export function materializationPlanChunk(
       case "point-upsert":
         chunk.timeseries.pointUpserts.push(item.value)
         break
+      case "unique-value-release":
+        chunk.unique.releases.push(item.value)
+        break
+      case "unique-value-claim":
+        chunk.unique.claims.push(item.value)
+        break
     }
   }
   return chunk
@@ -422,6 +446,30 @@ export function cardinalityViolation(
   )
 }
 
+/**
+ * The error for a unique value `claimant` takes while `holder` keeps it. Two claimants of one value
+ * in the same commit report each other.
+ */
+export function uniqueValueViolation(
+  value: Pick<UniqueValueRef, "objectTypeId" | "propertyId">,
+  holderPrimaryId: string,
+  claimantPrimaryId: string
+): UniqueValueViolationError {
+  return new UniqueValueViolationError(
+    value.objectTypeId,
+    value.propertyId,
+    holderPrimaryId,
+    claimantPrimaryId
+  )
+}
+
+/** The error for a claim on a property whose stored values were not prepared with its key. */
+export function uniquePropertyNotPrepared(
+  value: Pick<UniqueValueRef, "objectTypeId" | "propertyId">
+): UniquePropertyNotPreparedError {
+  return new UniquePropertyNotPreparedError(value.objectTypeId, value.propertyId)
+}
+
 export function assertWorkRecord(
   record: MaterializationWorkRecord,
   header: MaterializationPlanHeader
@@ -517,6 +565,10 @@ export function materializationPlanKindRank(kind: MaterializationPlanWorkItem["k
       return 9
     case "link-upsert":
       return 10
+    case "unique-value-release":
+      return 11
+    case "unique-value-claim":
+      return 12
   }
 }
 
@@ -605,9 +657,33 @@ function assertPlanItemCorrelation(
     case "point-upsert":
       assertPointWriteCorrelation(item.value, commit)
       return
+    case "unique-value-release":
+      assertUniqueValueWrite(item.value)
+      return
+    case "unique-value-claim":
+      assertUniqueValueWrite(item.value)
+      if (!Number.isSafeInteger(item.value.keyVersion) || !isNonblank(item.value.keyKind)) {
+        invalidCorrelation("Unique value claim must name how its key was computed.")
+      }
+      return
   }
 }
 
+function assertUniqueValueWrite(value: ExactUniqueValueWrite): void {
+  if (
+    !isNonblank(value.objectTypeId) ||
+    !isNonblank(value.propertyId) ||
+    !isNonblank(value.primaryId) ||
+    typeof value.valueKey !== "string"
+  ) {
+    invalidCorrelation("Unique value write must name its type, property, value and object.")
+  }
+}
+
+function isNonblank(value: unknown): boolean {
+  return typeof value === "string" && value.trim().length > 0
+}
+
 function assertPointWriteCorrelation(
   value: ExactTimeseriesPointWrite,
   commit: MaterializationPlanHeader["commit"]

package/src/storage/ontology/provider.ts

@@ -66,6 +66,7 @@ export {
   type ExactEffectiveWrites,
   type ExactOverrideWrites,
   type ExactTimeseriesWrites,
+  type ExactUniqueValueWrites,
   type MaterializationPlanChunk,
   materializationChunkRows,
   materializationOutboxWrite,
@@ -75,6 +76,8 @@ export {
   type OutboxEventContext,
   type PreparedReplacementIdentity,
   prepareReplacementIdentities,
+  uniquePropertyNotPrepared,
+  uniqueValueViolation,
   workUniquenessKey,
 } from "./provider-work"
 

package/src/storage/ontology/sources.ts

@@ -69,6 +69,21 @@ export interface GetActiveOntologySourceInput {
   readonly source: ProjectionSourceRef
 }
 
+export interface ListActiveOntologySourcesInput {
+  readonly projectId: string
+}
+
+/**
+ * What one source applied: the dataset version its active materialization replaced the source
+ * with, under which projection revision. A delta applies like a full replacement by its version,
+ * so the version describes every value of the source.
+ */
+export interface ActiveOntologySource {
+  readonly source: ProjectionSourceRef
+  readonly datasetVersion: PinnedDatasetVersion
+  readonly projectionRevision: string
+}
+
 export interface BeginSourceMaterializationInput {
   readonly projectId: string
   readonly source: ProjectionSourceRef
@@ -210,6 +225,8 @@ export interface OntologySourceStorage {
   stageRows(input: StageSourceRowsInput): Promise<StageSourceRowsResult>
   markReady(input: MarkSourceMaterializationReadyInput): Promise<OntologySourceRecord>
   getActive(input: GetActiveOntologySourceInput): Promise<OntologySourceRecord | null>
+  /** Every source of the project with an active materialization, in no particular order. */
+  listActive(input: ListActiveOntologySourcesInput): Promise<readonly ActiveOntologySource[]>
   /** Hands a redelivered run's candidate to its current execution; null when it has none. */
   adopt(input: AdoptSourceMaterializationInput): Promise<AdoptedSourceMaterialization | null>
   abandon(input: AbandonSourceMaterializationCandidateInput): Promise<OntologySourceRecord>

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

@@ -0,0 +1,56 @@
+/**
+ * The stored values of unique properties, outside the write path.
+ *
+ * Every object write keeps them current through its plan's unique value items. This capability
+ * builds them for a property that becomes unique over existing objects, and drops them for one
+ * that stops being unique. Core drives it from `migrateStorage`, inside serializable transactions
+ * that each start with `lockPreparation`.
+ */
+
+/** A unique property whose values storage holds, and how their keys were computed. */
+export interface PreparedUniqueProperty {
+  readonly objectTypeId: string
+  readonly propertyId: string
+  readonly keyKind: UniqueValueKind
+  readonly keyVersion: number
+}
+
+import type { UniqueValueKind } from "../../ontology/unique-values"
+
+export interface UniqueValueEntry {
+  readonly valueKey: string
+  readonly primaryId: string
+}
+
+export interface OntologyUniqueValueStorage {
+  /**
+   * The first call of a preparation transaction: waits while another preparation transaction
+   * runs, so concurrent startups queue instead of each scanning every object, and the snapshot
+   * taken after it sees what the previous one committed. Writes are not blocked.
+   */
+  lockPreparation(input: { readonly projectId: string }): Promise<void>
+
+  listPrepared(input: { readonly projectId: string }): Promise<readonly PreparedUniqueProperty[]>
+
+  /** Drops every value of the property and its prepared record. */
+  clear(input: {
+    readonly projectId: string
+    readonly objectTypeId: string
+    readonly propertyId: string
+  }): Promise<void>
+
+  /**
+   * Adds values of the property. A value another object already holds, or that two entries give
+   * to different objects, throws `UniqueValueViolationError` naming both objects.
+   */
+  insert(input: {
+    readonly projectId: string
+    readonly objectTypeId: string
+    readonly propertyId: string
+    readonly entries: readonly UniqueValueEntry[]
+  }): Promise<void>
+
+  markPrepared(
+    input: PreparedUniqueProperty & { readonly projectId: string; readonly preparedAt: string }
+  ): Promise<void>
+}

package/src/storage/operation-scope.ts

@@ -250,6 +250,9 @@ export function createAgentOperationScope<T extends AgentStorage>(
     runs: createOperationScopedFacade(target.runs, scope),
     messages: createOperationScopedFacade(target.messages, scope),
     checkpoints: createOperationScopedFacade(target.checkpoints, scope),
+    memory: createOperationScopedFacade(target.memory, scope),
+    approvals: createOperationScopedFacade(target.approvals, scope),
+    approvalModes: createOperationScopedFacade(target.approvalModes, scope),
   }) as T
 }
 
@@ -263,11 +266,12 @@ export function createOntologyOperationScope<T extends OntologyStorage>(
     materializations: createOperationScopedFacade(target.materializations, scope),
     replacementPlans: createOperationScopedFacade(target.replacementPlans, scope),
     outbox: createOperationScopedFacade(target.outbox, scope),
+    uniqueValues: createOperationScopedFacade(target.uniqueValues, scope),
     ...(target.vectors ? { vectors: createOperationScopedFacade(target.vectors, scope) } : {}),
   }) as T
 }
 
-/** Keep synchronously created selected readers inside the provider's root operation scope. */
+/** Keep synchronously created scoped readers inside the provider's root operation scope. */
 export function createObjectOperationScope<T extends ObjectStorage>(
   target: T,
   scope: StorageOperationScope
@@ -278,6 +282,10 @@ export function createObjectOperationScope<T extends ObjectStorage>(
       scope.assertAvailable()
       return createGuardedObjectReadStorage(factory.createSelectedReadScope(params), scope)
     },
+    createConditionalReadScope: (params) => {
+      scope.assertAvailable()
+      return createGuardedObjectReadStorage(factory.createConditionalReadScope(params), scope)
+    },
   }) as T
 }
 

package/src/storage/projection-runs/in-memory.ts

@@ -74,37 +74,25 @@ function compareRuns(a: ProjectionRunRecord, b: ProjectionRunRecord, order: "asc
 
 export class InMemoryProjectionRunStorage implements ProjectionRunStorage {
   private readonly rows = new Map<string, StoredProjectionRunRecord>()
-  /** Durable per-run history prevents a reclaimed execution token from becoming valid again. */
-  private readonly executionTokensByRun = new Map<string, Set<string>>()
   private readonly runRootOperation: RunRootOperation
-  private readonly createExecutionToken: () => string
 
   constructor(input: {
     readonly executions: ExecutionStorage
     readonly runRootOperation?: RunRootOperation
-    readonly executionToken?: () => string
   }) {
     this.executions = input.executions
     this.runRootOperation = input.runRootOperation ?? runDirectly
-    this.createExecutionToken = input.executionToken ?? randomUUID
   }
 
   private readonly executions: ExecutionStorage
 
   snapshot(): InMemoryProjectionRunStorageSnapshot {
-    return structuredClone({
-      rows: this.rows,
-      executionTokensByRun: this.executionTokensByRun,
-    })
+    return structuredClone({ rows: this.rows })
   }
 
   restore(snapshot: InMemoryProjectionRunStorageSnapshot): void {
     this.rows.clear()
-    this.executionTokensByRun.clear()
     for (const [key, record] of structuredClone(snapshot.rows)) this.rows.set(key, record)
-    for (const [key, tokens] of structuredClone(snapshot.executionTokensByRun)) {
-      this.executionTokensByRun.set(key, tokens)
-    }
   }
 
   async queue(input: QueueProjectionRunInput): Promise<ProjectionRunRecord> {
@@ -152,12 +140,12 @@ export class InMemoryProjectionRunStorage implements ProjectionRunStorage {
       const existing = this.rows.get(key)
       if (!existing) throw projectionRunNotFound(input.projectId, input.id)
       const attempt = planProjectionRunReclaim(existing, input).attempt
-      const executionToken = this.issueExecutionToken(key, input.id, existing.executionToken)
       const record: StoredProjectionRunRecord = {
         ...existing,
         status: "running",
         attempt,
-        executionToken,
+        // A fresh token per claim fences every earlier execution of this run.
+        executionToken: randomUUID(),
         startedAt: existing.startedAt ?? new Date(input.startedAt ?? new Date()),
         finishedAt: undefined,
       }
@@ -383,25 +371,6 @@ export class InMemoryProjectionRunStorage implements ProjectionRunStorage {
     }
   }
 
-  private issueExecutionToken(
-    key: string,
-    runId: string,
-    currentToken: string | undefined
-  ): string {
-    const executionToken = this.createExecutionToken()
-    assertProjectionRunNonEmpty(executionToken, "executionToken")
-    const usedTokens = this.executionTokensByRun.get(key) ?? new Set<string>()
-    if (currentToken) usedTokens.add(currentToken)
-    if (usedTokens.has(executionToken)) {
-      throw new ProjectionRunError(
-        `[Sixb] Projection run '${runId}' execution token was already used.`
-      )
-    }
-    usedTokens.add(executionToken)
-    this.executionTokensByRun.set(key, usedTokens)
-    return executionToken
-  }
-
   private requireExecution(
     input: LockProjectionRunForMaterializationInput
   ): StoredProjectionRunRecord & { readonly executionToken: string } {
@@ -431,5 +400,4 @@ export class InMemoryProjectionRunStorage implements ProjectionRunStorage {
 
 export interface InMemoryProjectionRunStorageSnapshot {
   readonly rows: Map<string, StoredProjectionRunRecord>
-  readonly executionTokensByRun: Map<string, Set<string>>
 }

package/src/storage/share-grants/in-memory.ts

@@ -10,6 +10,7 @@ import {
 import type {
   CreateShareGrantInput,
   GetShareGrantByIdInput,
+  GetShareGrantsByIdsInput,
   ListShareGrantsInput,
   ListShareGrantsResult,
   RevokeShareGrantInput,
@@ -43,6 +44,13 @@ export class InMemoryShareGrantStorage implements ShareGrantStorage {
     return record ? cloneShareGrantRecord(record) : null
   }
 
+  async getByIds(input: GetShareGrantsByIdsInput): Promise<readonly ShareGrantRecord[]> {
+    return [...new Set(input.ids)].flatMap((id) => {
+      const record = this.rows.get(rowKey(input.projectId, id))
+      return record ? [cloneShareGrantRecord(record)] : []
+    })
+  }
+
   async list(input: ListShareGrantsInput): Promise<ListShareGrantsResult> {
     const normalized = normalizeListShareGrantsInput(input)
     const matching = [...this.rows.values()]

package/src/storage/share-grants/index.ts

@@ -4,6 +4,7 @@ export { InMemoryShareGrantStorage } from "./in-memory"
 export type {
   CreateShareGrantInput,
   GetShareGrantByIdInput,
+  GetShareGrantsByIdsInput,
   ListShareGrantsInput,
   ListShareGrantsResult,
   RevokeShareGrantInput,

package/src/storage/share-grants/types.ts

@@ -43,6 +43,11 @@ export interface GetShareGrantByIdInput {
   readonly id: string
 }
 
+export interface GetShareGrantsByIdsInput {
+  readonly projectId: string
+  readonly ids: readonly string[]
+}
+
 export interface ListShareGrantsInput {
   readonly projectId: string
   readonly definitionId?: string
@@ -96,6 +101,9 @@ export interface ShareGrantStorage {
   /** Load one project-scoped grant, including expired or revoked grants, or return null. */
   getById(input: GetShareGrantByIdInput): Promise<ShareGrantRecord | null>
 
+  /** The grants found, revoked and expired ones included, in first-occurrence input order. */
+  getByIds(input: GetShareGrantsByIdsInput): Promise<readonly ShareGrantRecord[]>
+
   /**
    * List in deterministic `createdAt DESC, id DESC` order. Expired and revoked rows are excluded
    * unless requested; `total` is computed after filtering and before pagination. A root call may

package/src/storage/types.ts

@@ -1,8 +1,10 @@
 import type { ActionRunStorage } from "./action-runs"
+import type { ActivityStorage } from "./activity"
 import type { AgentStorage } from "./agents"
 import type { AiCostStorage } from "./ai-cost"
 import type { AiLimitStorage } from "./ai-limits"
 import type { AiUsageStorage } from "./ai-usage"
+import type { ArtifactStorage } from "./artifacts"
 import type { AuthStorage } from "./auth"
 import type { ConnectorConnectionStorage } from "./connector-connections"
 import type { ExecutionStorage } from "./executions"
@@ -68,6 +70,7 @@ export type {
   ListAgentThreadsResult,
   ReclaimAgentRunInput,
   StartAgentRunInput,
+  SubagentRunFile,
   SubagentRunRecord,
   SubagentRunResult,
   SubagentRunSpec,
@@ -155,6 +158,7 @@ export type {
   SessionRecord,
   SuspendUserAndRevokeSessionsInput,
   UpdateAuthUserProfileInput,
+  UpdateAuthUserResult,
   UpdateAuthUserStatusInput,
   UpsertAuthGroupMembershipInput,
   UpsertAuthUserIdentityInput,
@@ -355,6 +359,7 @@ export interface Storage {
   executions: ExecutionStorage
   auth?: AuthStorage
   agents?: AgentStorage
+  artifacts?: ArtifactStorage
   aiUsage?: AiUsageStorage
   aiCosts?: AiCostStorage
   aiLimits?: AiLimitStorage
@@ -371,6 +376,7 @@ export interface Storage {
   fileUploadSessions?: FileUploadSessionStore
   fileDownloadGrants?: FileDownloadGrantStorage
   connectorConnections?: ConnectorConnectionStorage
+  activity?: ActivityStorage
 
   /** Lightweight reachability probe. It must not open a write transaction or run migrations. */
   ping(): Promise<void>

package/src/storage/workflow-runs/in-memory.ts

@@ -267,6 +267,22 @@ export class InMemoryWorkflowRunStorage implements WorkflowRunStorage {
     return record ? cloneRecord(record) : null
   }
 
+  async getByExecutionIds(params: {
+    readonly projectId: string
+    readonly executionIds: readonly string[]
+  }): Promise<readonly WorkflowRunRecord[]> {
+    const byExecution = new Map(
+      [...this.runs.values()]
+        .filter((record) => record.projectId === params.projectId)
+        .map((record) => [record.executionId, record])
+    )
+
+    return [...new Set(params.executionIds)].flatMap((executionId) => {
+      const record = byExecution.get(executionId)
+      return record ? [cloneRecord(record)] : []
+    })
+  }
+
   async list(input: ListWorkflowRunsInput): Promise<ListWorkflowRunsResult> {
     if (hasEmptyStatuses(input) || input.workflowIds?.length === 0) {
       return {

package/src/storage/workflow-runs/types.ts

@@ -328,6 +328,11 @@ export interface WorkflowRunStorage {
   resume(input: ResumeWorkflowRunInput): Promise<WorkflowRunRecord>
   finish(input: FinishWorkflowRunInput): Promise<WorkflowRunRecord>
   getById(params: { projectId: string; id: string }): Promise<WorkflowRunRecord | null>
+  /** The runs of these executions, in first-occurrence input order; a missing one is omitted. */
+  getByExecutionIds(params: {
+    readonly projectId: string
+    readonly executionIds: readonly string[]
+  }): Promise<readonly WorkflowRunRecord[]>
   list(input: ListWorkflowRunsInput): Promise<ListWorkflowRunsResult>
   listLatestByWorkflowIds(input: ListLatestWorkflowRunsInput): Promise<ListLatestWorkflowRunsResult>
 }

package/src/testing/action-run-storage-contract.ts

@@ -310,6 +310,31 @@ export function runActionRunStorageContractSuite<TStorage extends ActionRunStora
       })
     })
 
+    test("reads the runs of several executions at once", async () => {
+      await withStorage(async (storage) => {
+        const first = await recordTestActionRun(storage, run("act_1"))
+        const second = await recordTestActionRun(storage, run("act_2"))
+        // An execution whose run is still in flight has no record.
+        const inFlight = await createTestActionRunRecord(storage.executions, run("act_in_flight"))
+
+        const runs = await storage.actionRuns.getByExecutionIds({
+          projectId,
+          executionIds: [second.executionId, inFlight.executionId, first.executionId, "missing"],
+        })
+        expect(runs).toEqual([second, first])
+
+        await expect(
+          storage.actionRuns.getByExecutionIds({
+            projectId: "other-project",
+            executionIds: [first.executionId],
+          })
+        ).resolves.toEqual([])
+        await expect(
+          storage.actionRuns.getByExecutionIds({ projectId, executionIds: [] })
+        ).resolves.toEqual([])
+      })
+    })
+
     test("drops a record written in a transaction that rolls back", async () => {
       await withStorage(async (storage) => {
         const input = await createTestActionRunRecord(storage.executions, run("act_rolled_back"))