@sixb/core 0.1.20 → 0.1.21

package/src/storage/artifacts/types.ts

@@ -0,0 +1,209 @@
+import type { ArtifactKind } from "../../artifacts/kinds"
+import type { ArtifactOutline } from "../../artifacts/outline"
+import type { ArtifactReference } from "../../artifacts/references"
+import type { Principal } from "../../auth"
+import type { FileRef } from "../../blob-storage"
+
+export type { ArtifactKind, ArtifactOutline, ArtifactReference }
+
+/** A versioned document, sheet, deck, or file. Its kind never changes. */
+export interface ArtifactRecord {
+  readonly projectId: string
+  readonly id: string
+  readonly kind: ArtifactKind
+  /** The latest version's title. */
+  readonly title: string
+  /** Who created the artifact; reading and publishing are decided from it. */
+  readonly owner: Principal
+  readonly latestVersion: number
+  readonly createdAt: Date
+  /** When the latest version was published. */
+  readonly updatedAt: Date
+}
+
+/** One file of a version, at its path inside the artifact. */
+export interface ArtifactFile {
+  /** Relative, with `/` separators and no `.` or `..` segments. */
+  readonly path: string
+  readonly file: FileRef
+}
+
+/** Where a version was published from. Provenance only: reading never depends on it. */
+export interface ArtifactOrigin {
+  readonly threadId: string
+  readonly runId: string
+}
+
+/** One published version. A version never changes once stored. */
+export interface ArtifactVersionRecord {
+  readonly projectId: string
+  readonly artifactId: string
+  readonly version: number
+  readonly title: string
+  /** The path of the file the kind renders from, one of `files`. */
+  readonly entry: string
+  readonly files: readonly ArtifactFile[]
+  readonly outline: ArtifactOutline
+  readonly references: readonly ArtifactReference[]
+  /** Who published this version. */
+  readonly author: Principal
+  readonly origin?: ArtifactOrigin
+  readonly createdAt: Date
+}
+
+/** A version's content before storage numbers it. */
+export type ArtifactVersionInput = Omit<
+  ArtifactVersionRecord,
+  "projectId" | "artifactId" | "version"
+>
+
+export interface CreateArtifactInput {
+  readonly projectId: string
+  readonly id: string
+  readonly kind: ArtifactKind
+  readonly owner: Principal
+  /** Becomes version 1. */
+  readonly version: ArtifactVersionInput
+}
+
+export interface PublishArtifactVersionInput {
+  readonly projectId: string
+  readonly artifactId: string
+  /** Must be the artifact's kind. */
+  readonly kind: ArtifactKind
+  readonly version: ArtifactVersionInput
+}
+
+export interface PublishedArtifactVersion {
+  readonly artifact: ArtifactRecord
+  readonly version: ArtifactVersionRecord
+}
+
+export interface GetArtifactInput {
+  readonly projectId: string
+  readonly id: string
+}
+
+export interface ListArtifactsInput {
+  readonly projectId: string
+  readonly owner?: Principal
+  /** Only artifacts with a version published from this thread. */
+  readonly originThreadId?: string
+  /** Only artifacts of this kind. */
+  readonly kind?: ArtifactKind
+  readonly limit?: number
+  readonly offset?: number
+}
+
+export interface ListArtifactsResult {
+  readonly artifacts: readonly ArtifactRecord[]
+  readonly hasMore: boolean
+  readonly total: number
+}
+
+export interface GetArtifactVersionInput {
+  readonly projectId: string
+  readonly artifactId: string
+  readonly version: number
+}
+
+export interface ListArtifactVersionsInput {
+  readonly projectId: string
+  readonly artifactId: string
+  readonly limit?: number
+  readonly offset?: number
+}
+
+export interface ListArtifactVersionsResult {
+  readonly versions: readonly ArtifactVersionRecord[]
+  readonly hasMore: boolean
+  readonly total: number
+}
+
+export interface DeleteArtifactInput {
+  readonly projectId: string
+  readonly id: string
+}
+
+export interface ListReferencingVersionsInput {
+  readonly projectId: string
+  /** The artifact the versions refer to. */
+  readonly artifactId: string
+}
+
+/**
+ * A short-lived link to one version, which a sandboxed frame loads a deck's files through. Only
+ * the SHA-256 of the link's token is stored; the token is the credential.
+ */
+export interface ArtifactFrameGrantRecord {
+  readonly projectId: string
+  /** SHA-256 hex of the token. */
+  readonly tokenHash: string
+  readonly artifactId: string
+  readonly version: number
+  /** What the frame may show from other artifacts, decided for its reader when it was issued. */
+  readonly targets: readonly ArtifactFrameTarget[]
+  readonly createdAt: Date
+  readonly expiresAt: Date
+}
+
+/** An address a version embeds, and the version of its target a frame shows. */
+export interface ArtifactFrameTarget {
+  readonly address: string
+  readonly artifactId: string
+  readonly version: number
+}
+
+export interface FindArtifactFrameGrantInput {
+  readonly projectId: string
+  readonly tokenHash: string
+}
+
+export interface DeleteExpiredArtifactFrameGrantsInput {
+  readonly projectId: string
+  readonly expiredBefore: Date
+  readonly limit: number
+}
+
+export interface DeleteArtifactVersionsByOriginInput {
+  readonly projectId: string
+  readonly runId: string
+}
+
+/**
+ * Persistence only: who may read or publish, and what a version may contain, are decided in Core
+ * before a call reaches storage.
+ */
+export interface ArtifactStorage {
+  /** Creates the artifact with its first version. Throws `artifact_exists` when the id is taken. */
+  create(input: CreateArtifactInput): Promise<PublishedArtifactVersion>
+  /**
+   * Stores the next version and makes it the latest. Throws `artifact_not_found` or
+   * `artifact_kind_mismatch`. A version number is never reused, even after its version is deleted.
+   */
+  publish(input: PublishArtifactVersionInput): Promise<PublishedArtifactVersion>
+  get(input: GetArtifactInput): Promise<ArtifactRecord | null>
+  /** Most recently updated first. */
+  list(input: ListArtifactsInput): Promise<ListArtifactsResult>
+  getVersion(input: GetArtifactVersionInput): Promise<ArtifactVersionRecord | null>
+  /** Newest first. */
+  listVersions(input: ListArtifactVersionsInput): Promise<ListArtifactVersionsResult>
+  /**
+   * The latest version of each artifact whose latest version has an address to this artifact, so
+   * a new version can tell which artifacts it breaks. Ordered by artifact id.
+   */
+  listReferencingVersions(input: ListReferencingVersionsInput): Promise<ArtifactVersionRecord[]>
+  /** Stores a frame grant. Throws `artifact_not_found` when its artifact does not exist. */
+  createFrameGrant(record: ArtifactFrameGrantRecord): Promise<void>
+  /** Returns expired grants too; the caller decides whether one still serves. */
+  findFrameGrant(input: FindArtifactFrameGrantInput): Promise<ArtifactFrameGrantRecord | null>
+  /** Deletes up to `limit` grants that expired before `expiredBefore`, and returns the count. */
+  deleteExpiredFrameGrants(input: DeleteExpiredArtifactFrameGrantsInput): Promise<number>
+  /** Deletes the artifact, every version, and its frame grants. `false` when it does not exist. */
+  delete(input: DeleteArtifactInput): Promise<boolean>
+  /**
+   * Deletes the versions a run published and returns how many. An artifact left without versions
+   * is deleted; one that lost its latest version points at its newest remaining one.
+   */
+  deleteVersionsByOrigin(input: DeleteArtifactVersionsByOriginInput): Promise<number>
+}

package/src/storage/auth/in-memory/sessions.ts

@@ -2,6 +2,8 @@ import { AuthStorageError } from "../errors"
 import type {
   AuthSessionStore,
   CreateAuthSessionInput,
+  ListAuthSessionsInput,
+  ListAuthSessionsResult,
   RotateSessionRefreshTokenResult,
   SessionRecord,
 } from "../types"
@@ -50,6 +52,25 @@ export class InMemoryAuthSessionStore implements AuthSessionStore {
       .map(cloneRecord)
   }
 
+  async listByUserId(params: ListAuthSessionsInput): Promise<ListAuthSessionsResult> {
+    const before = params.before
+    const offset = before?.skip ?? 0
+    const sessions = [...this.state.sessions.values()]
+      .filter((session) => session.projectId === params.projectId)
+      .filter((session) => session.userId === params.userId)
+      .filter((session) => !before || session.createdAt <= before.createdAt)
+      .sort((a, b) => {
+        const created = b.createdAt.getTime() - a.createdAt.getTime()
+        if (created !== 0) return created
+        return a.id < b.id ? 1 : a.id > b.id ? -1 : 0
+      })
+
+    return {
+      sessions: sessions.slice(offset, offset + params.limit).map(cloneRecord),
+      hasMore: sessions.length > offset + params.limit,
+    }
+  }
+
   async findValidByTokenHash(params: {
     readonly projectId: string
     readonly id: string

package/src/storage/auth/index.ts

@@ -42,6 +42,8 @@ export type {
   ListAuthInvitationsResult,
   ListAuthServiceAccountsInput,
   ListAuthServiceAccountsResult,
+  ListAuthSessionsInput,
+  ListAuthSessionsResult,
   ListAuthUsersInput,
   ListAuthUsersResult,
   MagicLinkRecord,

package/src/storage/auth/types.ts

@@ -324,6 +324,22 @@ export interface ListAuthAccessTokensResult {
   readonly total: number
 }
 
+export interface ListAuthSessionsInput {
+  readonly projectId: string
+  readonly userId: string
+  readonly limit: number
+  /**
+   * Continue a list: sessions created at or before `createdAt`, past the first `skip` of those
+   * created exactly then, which the previous pages returned.
+   */
+  readonly before?: { readonly createdAt: Date; readonly skip: number }
+}
+
+export interface ListAuthSessionsResult {
+  readonly sessions: readonly SessionRecord[]
+  readonly hasMore: boolean
+}
+
 export interface CompleteAuthSessionInput {
   readonly id: string
   readonly tokenHash: string
@@ -536,6 +552,8 @@ export interface AuthSessionStore {
     readonly userId: string
     readonly now: Date
   }): Promise<readonly SessionRecord[]>
+  /** Every session of a user, revoked and expired ones too, newest first: a sign-in history. */
+  listByUserId(params: ListAuthSessionsInput): Promise<ListAuthSessionsResult>
   /** A live browser (cookie) session whose secret hashes to `tokenHash`. */
   findValidByTokenHash(params: {
     readonly projectId: string

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

@@ -1,7 +1,14 @@
 import type { AuthStorage } from "../auth"
 import type { ShareSessionStorage } from "../share-sessions"
 import { ExecutionStorageError } from "./errors"
-import type { CreateExecutionInput, ExecutionRecord, ExecutionStorage } from "./types"
+import { compareExecutionCreation } from "./provider"
+import type {
+  CreateExecutionInput,
+  ExecutionRecord,
+  ExecutionStorage,
+  ListSessionExecutionsInput,
+  SessionExecutions,
+} from "./types"
 import { cloneExecutionRecord, prepareExecutionRecord } from "./validation"
 
 type RunRootOperation = <T>(run: () => Promise<T> | T) => Promise<T>
@@ -73,6 +80,59 @@ export class InMemoryExecutionStorage implements ExecutionStorage {
       return record ? cloneExecutionRecord(record) : null
     })
   }
+
+  async listBySession(input: ListSessionExecutionsInput): Promise<SessionExecutions> {
+    return this.runRootOperation(() => {
+      const rows = [...this.rows.values()].filter((row) => row.projectId === input.projectId)
+
+      const roots = rows
+        .filter(
+          (row) =>
+            row.source.type !== "execution" &&
+            row.createdAt >= input.from &&
+            row.createdAt < input.to &&
+            isFromSession(row, input.session)
+        )
+        .sort(compareExecutionCreation)
+        .slice(0, input.limit + 1)
+
+      // Level by level, as the SQL providers walk the tree, so truncation keeps roots first.
+      const found = [...roots]
+      let level = roots
+      while (level.length > 0 && found.length <= input.limit) {
+        const parents = new Set(level.map((row) => row.id))
+        level = rows
+          .filter((row) => row.source.type === "execution" && parents.has(row.source.executionId))
+          .sort(compareExecutionCreation)
+        found.push(...level)
+      }
+
+      return {
+        executions: found
+          .slice(0, input.limit)
+          .sort(compareExecutionCreation)
+          .map(cloneExecutionRecord),
+        truncated: found.length > input.limit,
+      }
+    })
+  }
+}
+
+function isFromSession(
+  row: ExecutionRecord,
+  session: ListSessionExecutionsInput["session"]
+): boolean {
+  const ref = row.authorizationRef
+
+  if (session.type === "user") {
+    return (
+      ref.type === "principal" &&
+      ref.credential?.type === "session" &&
+      ref.credential.id === session.id
+    )
+  }
+
+  return ref.type === "delegated" && ref.delegation.sessionId === session.id
 }
 
 export type InMemoryExecutionStorageSnapshot = Map<string, ExecutionRecord>

package/src/storage/executions/index.ts

@@ -12,5 +12,8 @@ export type {
   DurableExecutionExecutor,
   DurableExecutionSource,
   ExecutionRecord,
+  ExecutionSessionRef,
   ExecutionStorage,
+  ListSessionExecutionsInput,
+  SessionExecutions,
 } from "./types"

package/src/storage/executions/provider.ts

@@ -11,6 +11,18 @@ export {
   validateExecutionRecordReferences,
 } from "./validation"
 
+/** Oldest first, then by id compared byte by byte: the order `listBySession` returns. */
+export function compareExecutionCreation(
+  left: Pick<ExecutionRecord, "createdAt" | "id">,
+  right: Pick<ExecutionRecord, "createdAt" | "id">
+): number {
+  const byTime = left.createdAt.getTime() - right.createdAt.getTime()
+  if (byTime !== 0) {
+    return byTime
+  }
+  return left.id < right.id ? -1 : left.id > right.id ? 1 : 0
+}
+
 /** Provider-neutral flattened representation used by the SQL adapters. */
 export interface ExecutionStorageRow {
   readonly projectId: string

package/src/storage/executions/types.ts

@@ -44,6 +44,34 @@ export type CreateExecutionInput = Omit<ExecutionRecord, "createdAt" | "requeste
   readonly requesterGroupIds?: readonly string[]
 }
 
+/**
+ * The verified session a root execution came through: a signed-in user's `SessionRecord`, held as
+ * its authority credential, or a shared link's session, held by its delegation.
+ */
+export type ExecutionSessionRef =
+  | { readonly type: "user"; readonly id: string }
+  | { readonly type: "share"; readonly id: string }
+
+export interface ListSessionExecutionsInput {
+  readonly projectId: string
+  readonly session: ExecutionSessionRef
+  /** Roots, executions without a parent, created in `[from, to)`. */
+  readonly from: Date
+  readonly to: Date
+  /** Roots and descendants together. */
+  readonly limit: number
+}
+
+export interface SessionExecutions {
+  /** The roots and every descendant, whenever it was created, ordered by `createdAt` then id. */
+  readonly executions: readonly ExecutionRecord[]
+  /**
+   * More than `limit` were found. Roots are kept before descendants, the earliest first; which
+   * descendants are left out is otherwise unspecified.
+   */
+  readonly truncated: boolean
+}
+
 /** Immutable execution ledger. Records can be created and read, never updated or deleted. */
 export interface ExecutionStorage {
   create(input: CreateExecutionInput): Promise<ExecutionRecord>
@@ -51,4 +79,6 @@ export interface ExecutionStorage {
     readonly projectId: string
     readonly id: string
   }): Promise<ExecutionRecord | null>
+  /** What one session started: its roots in a window, and what they caused through `source`. */
+  listBySession(input: ListSessionExecutionsInput): Promise<SessionExecutions>
 }

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

@@ -1,10 +1,12 @@
 import { AsyncLocalStorage } from "node:async_hooks"
 import { InMemoryActionRunStorage } from "../action-runs"
+import { type ActivityStorage, InMemoryActivityStorage } from "../activity"
 import { type AgentStorage, InMemoryAgentStorage } from "../agents"
 import { type AiAccountingAttribution, type AiCostStorage, InMemoryAiCostStorage } from "../ai-cost"
 import { directModelCallAttribution } from "../ai-cost/attribution"
 import { type AiLimitStorage, InMemoryAiLimitStorage } from "../ai-limits"
 import { type AiUsageStorage, InMemoryAiUsageStorage } from "../ai-usage"
+import { type ArtifactStorage, InMemoryArtifactStorage } from "../artifacts"
 import { type AuthStorage, InMemoryAuthStorage } from "../auth"
 import {
   type ConnectorConnectionStorage,
@@ -80,6 +82,7 @@ export class InMemoryStorage implements Storage {
     shareSessions: this.shareSessionStorage,
   })
   private readonly agentStorage = new InMemoryAgentStorage(this.executionStorage)
+  private readonly artifactStorage = new InMemoryArtifactStorage()
   private readonly aiUsageStorage = new InMemoryAiUsageStorage(this.executionStorage)
   private readonly aiCostStorage = new InMemoryAiCostStorage(this.aiUsageStorage, {
     resolve: (input) => this.resolveAiAccountingAttribution(input),
@@ -122,9 +125,11 @@ export class InMemoryStorage implements Storage {
   private readonly fileUploadSessionStorage = new InMemoryFileUploadSessions()
   private readonly fileDownloadGrantStorage = new InMemoryFileDownloadGrantStorage()
   private readonly connectorConnectionStorage: InMemoryConnectorConnectionStorage
+  private readonly activityStorage = new InMemoryActivityStorage()
   readonly auth: AuthStorage
   readonly executions: ExecutionStorage
   readonly agents: AgentStorage
+  readonly artifacts: ArtifactStorage
   readonly aiUsage: AiUsageStorage
   readonly aiCosts: AiCostStorage
   readonly aiLimits: AiLimitStorage
@@ -141,6 +146,7 @@ export class InMemoryStorage implements Storage {
   readonly fileUploadSessions: FileUploadSessionStore
   readonly fileDownloadGrants: FileDownloadGrantStorage
   readonly connectorConnections: ConnectorConnectionStorage
+  readonly activity: ActivityStorage
 
   constructor(options: InMemoryStorageOptions = {}) {
     this.connectorConnectionStorage = new InMemoryConnectorConnectionStorage(
@@ -155,6 +161,7 @@ export class InMemoryStorage implements Storage {
     this.auth = createAuthOperationScope(this.authStorage, scope)
     this.executions = createOperationScopedFacade(this.executionStorage, scope)
     this.agents = createAgentOperationScope(this.agentStorage, scope)
+    this.artifacts = createOperationScopedFacade(this.artifactStorage, scope)
     this.aiUsage = createOperationScopedFacade(this.aiUsageStorage, scope)
     this.aiCosts = createOperationScopedFacade(this.aiCostStorage, scope)
     this.aiLimits = createOperationScopedFacade(this.aiLimitStorage, scope)
@@ -174,6 +181,7 @@ export class InMemoryStorage implements Storage {
     this.fileUploadSessions = createOperationScopedFacade(this.fileUploadSessionStorage, scope)
     this.fileDownloadGrants = createOperationScopedFacade(this.fileDownloadGrantStorage, scope)
     this.connectorConnections = createOperationScopedFacade(this.connectorConnectionStorage, scope)
+    this.activity = createOperationScopedFacade(this.activityStorage, scope)
     this.ontologyStorage = new InMemoryOntologyStorage(this.objectStorage, this.timeseriesStorage, {
       runRootOperation: async (run) => run(),
       getTransactionToken: () => this.getActiveTransactionToken(),
@@ -368,6 +376,7 @@ export class InMemoryStorage implements Storage {
       auth: this.authStorage,
       executions: this.executionStorage,
       agents: this.agentStorage,
+      artifacts: this.artifactStorage,
       aiUsage: this.aiUsageStorage,
       aiCosts: this.aiCostStorage,
       aiLimits: this.aiLimitStorage,
@@ -384,6 +393,7 @@ export class InMemoryStorage implements Storage {
       fileUploadSessions: this.fileUploadSessionStorage,
       fileDownloadGrants: this.fileDownloadGrantStorage,
       connectorConnections: this.connectorConnectionStorage,
+      activity: this.activityStorage,
       ping: async () => undefined,
       transaction: async <T>(): Promise<T> => {
         throwNestedStorageTransaction()
@@ -399,6 +409,7 @@ export class InMemoryStorage implements Storage {
       auth: this.authStorage.snapshot(),
       executions: this.executionStorage.snapshot(),
       agents: this.agentStorage.snapshot(),
+      artifacts: this.artifactStorage.snapshot(),
       aiUsage: this.aiUsageStorage.snapshot(),
       aiCosts: this.aiCostStorage.snapshot(),
       aiLimits: this.aiLimitStorage.snapshot(),
@@ -415,6 +426,7 @@ export class InMemoryStorage implements Storage {
       fileUploadSessions: this.fileUploadSessionStorage.snapshot(),
       fileDownloadGrants: this.fileDownloadGrantStorage.snapshot(),
       connectorConnections: this.connectorConnectionStorage.snapshot(),
+      activity: this.activityStorage.snapshot(),
     }
   }
 
@@ -425,6 +437,7 @@ export class InMemoryStorage implements Storage {
     this.authStorage.restore(snapshot.auth)
     this.executionStorage.restore(snapshot.executions)
     this.agentStorage.restore(snapshot.agents)
+    this.artifactStorage.restore(snapshot.artifacts)
     this.aiUsageStorage.restore(snapshot.aiUsage)
     this.aiCostStorage.restore(snapshot.aiCosts)
     this.aiLimitStorage.restore(snapshot.aiLimits)
@@ -441,6 +454,7 @@ export class InMemoryStorage implements Storage {
     this.fileUploadSessionStorage.restore(snapshot.fileUploadSessions)
     this.fileDownloadGrantStorage.restore(snapshot.fileDownloadGrants)
     this.connectorConnectionStorage.restore(snapshot.connectorConnections)
+    this.activityStorage.restore(snapshot.activity)
   }
 }
 
@@ -451,6 +465,7 @@ export interface InMemoryStorageSnapshot {
   readonly auth: ReturnType<InMemoryAuthStorage["snapshot"]>
   readonly executions: ReturnType<InMemoryExecutionStorage["snapshot"]>
   readonly agents: ReturnType<InMemoryAgentStorage["snapshot"]>
+  readonly artifacts: ReturnType<InMemoryArtifactStorage["snapshot"]>
   readonly aiUsage: ReturnType<InMemoryAiUsageStorage["snapshot"]>
   readonly aiCosts: ReturnType<InMemoryAiCostStorage["snapshot"]>
   readonly aiLimits: ReturnType<InMemoryAiLimitStorage["snapshot"]>
@@ -467,4 +482,5 @@ export interface InMemoryStorageSnapshot {
   readonly fileUploadSessions: ReturnType<InMemoryFileUploadSessions["snapshot"]>
   readonly fileDownloadGrants: ReturnType<InMemoryFileDownloadGrantStorage["snapshot"]>
   readonly connectorConnections: ReturnType<InMemoryConnectorConnectionStorage["snapshot"]>
+  readonly activity: ReturnType<InMemoryActivityStorage["snapshot"]>
 }

package/src/storage/index.ts

@@ -50,6 +50,32 @@ export {
   ActionRunError,
   InMemoryActionRunStorage,
 } from "./action-runs"
+export type {
+  ActivityActor,
+  ActivityAttribution,
+  ActivityCalendarInput,
+  ActivityCursor,
+  ActivityDay,
+  ActivityEventInput,
+  ActivityEventType,
+  ActivityInteraction,
+  ActivityPageView,
+  ActivityPeriodInput,
+  ActivitySessionVisits,
+  ActivityStorage,
+  ActivitySummary,
+  ActivityUser,
+  ActivityUsersPage,
+  ActivityVisit,
+  ActivityVisitsPage,
+  AppendActivityInput,
+  AppendActivityResult,
+  ListActivitySessionVisitsInput,
+  ListActivityUsersInput,
+  ListActivityVisitsInput,
+  ReadActivityVisitInput,
+  StoredActivityVisitPage,
+} from "./activity"
 export type {
   AgentContextCheckpointReason,
   AgentContextCheckpointRecord,
@@ -193,6 +219,35 @@ export type {
   SummarizeAiUsageExecutionsInput,
 } from "./ai-usage"
 export { AiUsageStorageError, aggregateAiModelCallUsage, InMemoryAiUsageStorage } from "./ai-usage"
+export type {
+  ArtifactFile,
+  ArtifactFrameGrantRecord,
+  ArtifactFrameTarget,
+  ArtifactKind,
+  ArtifactOrigin,
+  ArtifactOutline,
+  ArtifactRecord,
+  ArtifactReference,
+  ArtifactStorage,
+  ArtifactStorageError,
+  ArtifactStorageErrorCode,
+  ArtifactVersionInput,
+  ArtifactVersionRecord,
+  CreateArtifactInput,
+  DeleteArtifactInput,
+  DeleteArtifactVersionsByOriginInput,
+  DeleteExpiredArtifactFrameGrantsInput,
+  FindArtifactFrameGrantInput,
+  GetArtifactInput,
+  GetArtifactVersionInput,
+  ListArtifactsInput,
+  ListArtifactsResult,
+  ListArtifactVersionsInput,
+  ListArtifactVersionsResult,
+  ListReferencingVersionsInput,
+  PublishArtifactVersionInput,
+  PublishedArtifactVersion,
+} from "./artifacts"
 export type {
   AccessTokenRecord,
   AuthAccessTokenStore,
@@ -235,6 +290,8 @@ export type {
   ListAuthInvitationsResult,
   ListAuthServiceAccountsInput,
   ListAuthServiceAccountsResult,
+  ListAuthSessionsInput,
+  ListAuthSessionsResult,
   ListAuthUsersInput,
   ListAuthUsersResult,
   MagicLinkRecord,
@@ -340,9 +397,12 @@ export type {
   DurableExecutionExecutor,
   DurableExecutionSource,
   ExecutionRecord,
+  ExecutionSessionRef,
   ExecutionStorage,
   ExecutionStorageErrorCode,
   KernelOperation,
+  ListSessionExecutionsInput,
+  SessionExecutions,
   TrustedPrimitiveKind,
   TrustedPrimitiveRef,
 } from "./executions"
@@ -461,6 +521,7 @@ export type {
   AbandonRunSourceMaterializationInput,
   AbandonSourceMaterializationCandidateInput,
   AbandonSourceMaterializationInput,
+  ActiveOntologySource,
   AdoptedSourceMaterialization,
   AdoptSourceMaterializationInput,
   AppliedMaterialization,
@@ -493,6 +554,7 @@ export type {
   GetOntologyCommitByIdempotencyKeyInput,
   GetOntologyCommitByIdInput,
   GetOntologyCommitByOriginInput,
+  ListActiveOntologySourcesInput,
   ListOntologyCommitsInput,
   ListOntologyCommitsResult,
   MarkSourceMaterializationReadyInput,
@@ -658,6 +720,7 @@ export { InMemoryRulesStorage } from "./rules"
 export type {
   CreateShareGrantInput,
   GetShareGrantByIdInput,
+  GetShareGrantsByIdsInput,
   ListShareGrantsInput,
   ListShareGrantsResult,
   RevokeShareGrantInput,