@sixb/core 0.1.21 → 0.1.22

package/src/storage/ontology/in-memory/materializations.ts

@@ -31,6 +31,7 @@ import type {
   AppliedMaterialization,
   ApplyMaterializationInput,
   ApplyMaterializationResult,
+  ExactUniqueValueWrite,
   ExpectedSourceRevision,
   ExpectedTimeseriesPointRevision,
   FinalizeMaterializationInput,
@@ -52,6 +53,7 @@ import type {
   StoredTelemetryPoint,
   StreamMaterializationStateInput,
   StreamMaterializationVectorChangesInput,
+  UniqueValueRef,
 } from "../materializations"
 import {
   assertExpectedLinkRevision,
@@ -286,6 +288,18 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
         yield { objects: [], links: [], linkScopes: [value], points: [] }
       }
 
+      const uniqueHolders = this.uniqueHolders(session, request.uniqueValues ?? [])
+      for (let offset = 0; offset < uniqueHolders.length; offset += input.pageRows) {
+        this.requireSession(input.session)
+        yield {
+          objects: [],
+          links: [],
+          linkScopes: [],
+          points: [],
+          uniqueHolders: uniqueHolders.slice(offset, offset + input.pageRows),
+        }
+      }
+
       const requestedPoints = uniqueSorted(
         request.points,
         (point) => telemetryPointKey(point.series, point.at),
@@ -503,6 +517,14 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
         this.assertLinkSync(item.expected, projectId)
         getInMemoryObjectMaterializerAdapter(this.objects).applyExactLink(item.row, projectId)
       })
+    for (const item of chunk.unique.releases)
+      write("unique.release", () => {
+        getInMemoryObjectMaterializerAdapter(this.objects).releaseUniqueValue(projectId, item)
+      })
+    for (const item of chunk.unique.claims)
+      write("unique.claim", () => {
+        getInMemoryObjectMaterializerAdapter(this.objects).claimUniqueValue(projectId, item)
+      })
     for (const item of chunk.timeseries.pointUpserts)
       write("timeseries.point.upsert", () => {
         this.assertPoint(item.expected, projectId)
@@ -779,6 +801,19 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
     }
   }
 
+  private uniqueHolders(
+    session: SessionState,
+    values: readonly UniqueValueRef[]
+  ): ExactUniqueValueWrite[] {
+    const adapter = getInMemoryObjectMaterializerAdapter(this.objects)
+    const holders: ExactUniqueValueWrite[] = []
+    for (const value of values) {
+      const primaryId = adapter.getUniqueHolder(session.header.commit.projectId, value)
+      if (primaryId !== null) holders.push({ ...value, primaryId })
+    }
+    return holders
+  }
+
   private linkSlotState(
     session: SessionState,
     source: OntologyObjectRef,

package/src/storage/ontology/in-memory/replacement-plans.ts

@@ -140,6 +140,10 @@ export function touchPlanItem(touches: InMemoryCommitTouches, item: Materializat
     case "link-slot-override-delete":
       touches.scopes.add(linkScopeKey(item.value.ref.source, item.value.ref.linkId))
       return
+    // A plan reads no unique value: its claims are checked when they apply.
+    case "unique-value-release":
+    case "unique-value-claim":
+      return
   }
 }
 

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

@@ -0,0 +1,62 @@
+import {
+  getInMemoryObjectMaterializerAdapter,
+  type InMemoryObjectStorage,
+} from "../../objects/in-memory"
+import type {
+  OntologyUniqueValueStorage,
+  PreparedUniqueProperty,
+  UniqueValueEntry,
+} from "../unique-values"
+
+/** Unique values live with the in-memory objects, so a transaction snapshot covers both. */
+export class InMemoryOntologyUniqueValueStorage implements OntologyUniqueValueStorage {
+  constructor(
+    private readonly objects: InMemoryObjectStorage,
+    private readonly runRootOperation: <T>(run: () => Promise<T> | T) => Promise<T>
+  ) {}
+
+  /** In-memory transactions already run one at a time. */
+  async lockPreparation(_input: { readonly projectId: string }): Promise<void> {}
+
+  async listPrepared(input: {
+    readonly projectId: string
+  }): Promise<readonly PreparedUniqueProperty[]> {
+    return this.runRootOperation(() => this.adapter().listPreparedUniqueProperties(input.projectId))
+  }
+
+  async clear(input: {
+    readonly projectId: string
+    readonly objectTypeId: string
+    readonly propertyId: string
+  }): Promise<void> {
+    await this.runRootOperation(() =>
+      this.adapter().clearUniqueProperty(input.projectId, input.objectTypeId, input.propertyId)
+    )
+  }
+
+  async insert(input: {
+    readonly projectId: string
+    readonly objectTypeId: string
+    readonly propertyId: string
+    readonly entries: readonly UniqueValueEntry[]
+  }): Promise<void> {
+    await this.runRootOperation(() =>
+      this.adapter().insertUniqueValues(
+        input.projectId,
+        input.objectTypeId,
+        input.propertyId,
+        input.entries
+      )
+    )
+  }
+
+  async markPrepared(
+    input: PreparedUniqueProperty & { readonly projectId: string; readonly preparedAt: string }
+  ): Promise<void> {
+    await this.runRootOperation(() => this.adapter().markUniquePropertyPrepared(input))
+  }
+
+  private adapter() {
+    return getInMemoryObjectMaterializerAdapter(this.objects)
+  }
+}

package/src/storage/ontology/index.ts

@@ -3,6 +3,7 @@ import type { OntologyMaterializationStorage } from "./materializations"
 import type { OntologyOutboxStorage } from "./outbox"
 import type { OntologyReplacementPlanStorage } from "./replacement-plans"
 import type { OntologySourceStorage } from "./sources"
+import type { OntologyUniqueValueStorage } from "./unique-values"
 import type { OntologyVectorIndexingStorage } from "./vector-indexing"
 import type { OntologyVectorStorage } from "./vectors"
 
@@ -37,6 +38,8 @@ export type {
   ExactObjectOverrideDelete,
   ExactObjectOverrideWrite,
   ExactTimeseriesPointWrite,
+  ExactUniqueValueClaim,
+  ExactUniqueValueWrite,
   ExpectedSourceRevision,
   ExpectedTimeseriesPointRevision,
   FinalizeMaterializationInput,
@@ -74,6 +77,7 @@ export type {
   StoredTelemetryPoint,
   StreamMaterializationStateInput,
   StreamMaterializationVectorChangesInput,
+  UniqueValueRef,
 } from "./materializations"
 export type {
   ClaimedOntologyOutboxRow,
@@ -130,6 +134,11 @@ export type {
   StoredSourceLinkAssertion,
   StoredSourceObjectAssertion,
 } from "./sources"
+export type {
+  OntologyUniqueValueStorage,
+  PreparedUniqueProperty,
+  UniqueValueEntry,
+} from "./unique-values"
 
 export type { ObjectVectorState, OntologyVectorStorage, StoredObjectVector } from "./vectors"
 
@@ -141,6 +150,7 @@ export interface OntologyStorage {
   readonly materializations: OntologyMaterializationStorage
   readonly replacementPlans: OntologyReplacementPlanStorage
   readonly outbox: OntologyOutboxStorage
+  readonly uniqueValues: OntologyUniqueValueStorage
 }
 
 export type {

package/src/storage/ontology/materializations.ts

@@ -19,6 +19,7 @@ import type {
   TelemetryCommitResult,
   TelemetrySeriesRef,
 } from "../../materialization/model"
+import type { UniqueValueKind } from "../../ontology/unique-values"
 import type { OntologyCommitRecord, OntologyCommitWrite } from "./commits"
 import type { OntologyMaterializationEventDraft } from "./outbox"
 import type { StoredSourceLinkAssertion, StoredSourceObjectAssertion } from "./sources"
@@ -61,6 +62,27 @@ export interface ExpectedTimeseriesPointRevision {
   readonly lastCommitId: string | null
 }
 
+/** One value of a unique property, as the key core computes for it. */
+export interface UniqueValueRef {
+  readonly objectTypeId: string
+  readonly propertyId: string
+  readonly valueKey: string
+}
+
+/** A unique value and the object that gives it up or takes it. */
+export interface ExactUniqueValueWrite extends UniqueValueRef {
+  readonly primaryId: string
+}
+
+/**
+ * A unique value an object takes, with how its key was computed. Storage refuses it unless the
+ * property's stored values were prepared with that same key kind and version.
+ */
+export interface ExactUniqueValueClaim extends ExactUniqueValueWrite {
+  readonly keyKind: UniqueValueKind
+  readonly keyVersion: number
+}
+
 export interface MaterializationObjectState {
   readonly ref: OntologyObjectRef
   readonly source: StoredSourceObjectAssertion | null
@@ -100,6 +122,8 @@ export interface MaterializationStatePage {
   readonly links: readonly MaterializationLinkState[]
   readonly linkScopes: readonly MaterializationLinkScopeState[]
   readonly points: readonly StoredTelemetryPoint[]
+  /** The objects holding requested unique values; a value no object holds is left out. */
+  readonly uniqueHolders?: readonly ExactUniqueValueWrite[]
 }
 
 export interface SourceReplacementObjectState extends Omit<MaterializationObjectState, "source"> {
@@ -125,6 +149,8 @@ export interface MaterializationStateRequestChunk {
     readonly series: TelemetrySeriesRef
     readonly at: string
   }[]
+  /** Unique values whose holders to read. */
+  readonly uniqueValues?: readonly UniqueValueRef[]
 }
 
 /**
@@ -314,12 +340,16 @@ export type MaterializationPlanWorkItem =
   | { readonly kind: "link-upsert"; readonly value: ExactEffectiveLinkWrite }
   | { readonly kind: "link-delete"; readonly value: ExactEffectiveLinkDelete }
   | { readonly kind: "point-upsert"; readonly value: ExactTimeseriesPointWrite }
+  /** Drops the value's holder row if it still names this object; a missing row is no conflict. */
+  | { readonly kind: "unique-value-release"; readonly value: ExactUniqueValueWrite }
+  /** Rejects a value another object holds once every release of the commit has applied. */
+  | { readonly kind: "unique-value-claim"; readonly value: ExactUniqueValueClaim }
 
 /**
  * Safe physical phases shared by the core planner and provider validation through
  * {@link materializationApplyPhase}.
  */
-export type MaterializationApplyPhase = 0 | 1 | 2 | 3 | 4 | 5
+export type MaterializationApplyPhase = 0 | 1 | 2 | 3 | 4 | 5 | 6
 
 export interface MaterializationPlanWorkRecord {
   readonly kind: "plan"
@@ -344,6 +374,7 @@ export function materializationApplyPhase(
     case "link-override-delete":
     case "link-slot-override-upsert":
     case "link-slot-override-delete":
+    case "unique-value-release":
       return 0
     case "point-upsert":
       return 1
@@ -355,6 +386,9 @@ export function materializationApplyPhase(
       return 4
     case "link-upsert":
       return 5
+    // Last, after every release of the commit in any chunk: values can move between objects.
+    case "unique-value-claim":
+      return 6
   }
 }
 

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/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/types.ts

@@ -70,6 +70,7 @@ export type {
   ListAgentThreadsResult,
   ReclaimAgentRunInput,
   StartAgentRunInput,
+  SubagentRunFile,
   SubagentRunRecord,
   SubagentRunResult,
   SubagentRunSpec,
@@ -157,6 +158,7 @@ export type {
   SessionRecord,
   SuspendUserAndRevokeSessionsInput,
   UpdateAuthUserProfileInput,
+  UpdateAuthUserResult,
   UpdateAuthUserStatusInput,
   UpsertAuthGroupMembershipInput,
   UpsertAuthUserIdentityInput,