@opengeni/db 0.28.9 → 0.36.0

package/dist/company-profile.d.ts

@@ -0,0 +1,268 @@
+import { CompanyProfileLearningWrite, type CompanyProfileContent as CompanyProfileContentType, type CompanyProfileDiffResponse, type CompanyProfileHead, type CompanyProfileListResponse, type CompanyProfileMutationResponse, type CompanyProfilePrincipalKind, type CompanyProfileRevision } from "@opengeni/contracts";
+import type { Database } from "./database.js";
+export type CompanyProfileAttemptClaims = {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    attemptId: string;
+    executionGeneration: number;
+};
+export declare class CompanyProfileConflictError extends Error {
+    readonly currentHead: CompanyProfileHead | null;
+    readonly name = "CompanyProfileConflictError";
+    readonly code = "COMPANY_PROFILE_CONFLICT";
+    constructor(currentHead: CompanyProfileHead | null);
+}
+export declare class CompanyProfileOperationReuseError extends Error {
+    readonly name = "CompanyProfileOperationReuseError";
+    readonly code = "COMPANY_PROFILE_OPERATION_REUSED";
+    constructor();
+}
+export declare class CompanyProfileNotFoundError extends Error {
+    readonly name = "CompanyProfileNotFoundError";
+    constructor(message?: string);
+}
+export declare class CompanyProfileInvalidOperationError extends Error {
+    readonly name = "CompanyProfileInvalidOperationError";
+}
+export declare class CompanyProfileSnapshotAuthorityError extends Error {
+    readonly name = "CompanyProfileSnapshotAuthorityError";
+}
+export declare function updateCompanyProfile(db: Database, input: {
+    operationId?: string;
+    accountId: string;
+    workspaceId: string;
+    profile: CompanyProfileContentType;
+    expectedCurrentRevisionId: string | null;
+    expectedActivationVersion: number;
+    actorSubjectId: string;
+    principalKind: CompanyProfilePrincipalKind;
+    reason: string;
+}): Promise<CompanyProfileMutationResponse>;
+export declare function activateCompanyProfileRevision(db: Database, input: {
+    operationId?: string;
+    accountId: string;
+    workspaceId: string;
+    revisionId: string;
+    expectedCurrentRevisionId: string | null;
+    expectedActivationVersion: number;
+    actorSubjectId: string;
+    principalKind: CompanyProfilePrincipalKind;
+    reason: string;
+}): Promise<{
+    revision: {
+        id: string;
+        revision: number;
+        contentHash: string;
+        operationId: string;
+        accountId: string;
+        intent: "active" | "proposal";
+        profile: {
+            identity: string | null;
+            mission: string | null;
+            products: {
+                key: string;
+                content: string;
+            }[];
+            customers: {
+                key: string;
+                content: string;
+            }[];
+            goals: {
+                key: string;
+                content: string;
+            }[];
+            constraints: {
+                key: string;
+                content: string;
+            }[];
+        };
+        provenance: {
+            source: "durable_learning" | "human" | "migration";
+            sourceId: string | null;
+        };
+        supersedesRevisionId: string | null;
+        createdBySubjectId: string;
+        createdAt: string;
+    } | null;
+    head: {
+        accountId: string;
+        revisionId: string;
+        revision: number;
+        contentHash: string;
+        activationVersion: number;
+        activatedAt: string;
+    } | null;
+    event: {
+        id: string;
+        operationId: string;
+        accountId: string;
+        type: "activate" | "rollback";
+        activationVersion: number;
+        oldRevision: {
+            id: string;
+            revision: number;
+            contentHash: string;
+        } | null;
+        newRevision: {
+            id: string;
+            revision: number;
+            contentHash: string;
+        } | null;
+        actorSubjectId: string;
+        reason: string;
+        createdAt: string;
+    } | null;
+}>;
+export declare function rollbackCompanyProfileRevision(db: Database, input: {
+    operationId?: string;
+    accountId: string;
+    workspaceId: string;
+    targetRevisionId: string;
+    expectedCurrentRevisionId: string;
+    expectedActivationVersion: number;
+    actorSubjectId: string;
+    principalKind: CompanyProfilePrincipalKind;
+    reason: string;
+}): Promise<{
+    revision: {
+        id: string;
+        revision: number;
+        contentHash: string;
+        operationId: string;
+        accountId: string;
+        intent: "active" | "proposal";
+        profile: {
+            identity: string | null;
+            mission: string | null;
+            products: {
+                key: string;
+                content: string;
+            }[];
+            customers: {
+                key: string;
+                content: string;
+            }[];
+            goals: {
+                key: string;
+                content: string;
+            }[];
+            constraints: {
+                key: string;
+                content: string;
+            }[];
+        };
+        provenance: {
+            source: "durable_learning" | "human" | "migration";
+            sourceId: string | null;
+        };
+        supersedesRevisionId: string | null;
+        createdBySubjectId: string;
+        createdAt: string;
+    } | null;
+    head: {
+        accountId: string;
+        revisionId: string;
+        revision: number;
+        contentHash: string;
+        activationVersion: number;
+        activatedAt: string;
+    } | null;
+    event: {
+        id: string;
+        operationId: string;
+        accountId: string;
+        type: "activate" | "rollback";
+        activationVersion: number;
+        oldRevision: {
+            id: string;
+            revision: number;
+            contentHash: string;
+        } | null;
+        newRevision: {
+            id: string;
+            revision: number;
+            contentHash: string;
+        } | null;
+        actorSubjectId: string;
+        reason: string;
+        createdAt: string;
+    } | null;
+}>;
+export type CompanyProfileLearningWriteResult = {
+    outcome: "applied" | "proposed";
+    revision: CompanyProfileRevision;
+    head: CompanyProfileHead | null;
+    effectiveBoundary: "next_accepted_attempt";
+    rollbackToken: string | null;
+};
+export declare function writeCompanyProfileLearning(db: Database, rawInput: CompanyProfileLearningWrite): Promise<CompanyProfileLearningWriteResult>;
+export declare function rollbackCompanyProfileLearning(db: Database, input: {
+    operationId: string;
+    accountId: string;
+    workspaceId: string;
+    actorSubjectId: string;
+    actorKind: "human" | "agent" | "service";
+    token: string;
+    reason: string;
+}): Promise<CompanyProfileMutationResponse>;
+export declare function listCompanyProfile(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    afterRevision?: number;
+    limit: number;
+}): Promise<CompanyProfileListResponse>;
+export declare function getCompanyProfileRevision(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    revisionId: string;
+}): Promise<CompanyProfileRevision>;
+export declare function diffCompanyProfileRevisions(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    fromRevisionId: string;
+    toRevisionId: string;
+}): Promise<CompanyProfileDiffResponse>;
+export declare function getOrCreateCompanyProfileSnapshot(db: Database, claims: CompanyProfileAttemptClaims): Promise<{
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+    attemptId: string;
+    executionGeneration: number;
+    snapshotHash: string;
+    createdAt: string;
+    profile: {
+        id: string;
+        revision: number;
+        contentHash: string;
+        activationVersion: number;
+        activatedAt: string;
+        provenance: {
+            source: "durable_learning" | "human" | "migration";
+            sourceIdHash: string | null;
+        };
+        profile: {
+            identity: string | null;
+            mission: string | null;
+            products: {
+                key: string;
+                content: string;
+            }[];
+            customers: {
+                key: string;
+                content: string;
+            }[];
+            goals: {
+                key: string;
+                content: string;
+            }[];
+            constraints: {
+                key: string;
+                content: string;
+            }[];
+        };
+    } | null;
+}>;

package/dist/computer-sessions.d.ts

@@ -0,0 +1,109 @@
+import { ComputerSession, type ComputerSessionCapabilities as ComputerSessionCapabilitiesValue, type ComputerSessionListResponse as ComputerSessionListResponseValue, type ComputerSessionMutationResponse as ComputerSessionMutationResponseValue, type InteractionControllerBinding as InteractionControllerBindingValue, type InteractionError as InteractionErrorValue, type InteractionLifecycleOperationKind, type InteractionLifecycleOperationReceipt as InteractionLifecycleOperationReceiptValue, type InteractionPlacement } from "@opengeni/contracts";
+import { type Database } from "./database.js";
+import * as schema from "./schema.js";
+type InteractionOperationRow = typeof schema.interactionOperations.$inferSelect;
+export declare class ComputerSessionNotFoundError extends Error {
+    readonly name = "ComputerSessionNotFoundError";
+}
+export declare class ComputerSessionOperationConflictError extends Error {
+    readonly name = "ComputerSessionOperationConflictError";
+}
+export declare class ComputerSessionStateError extends Error {
+    readonly name = "ComputerSessionStateError";
+}
+export type PrepareComputerSessionCreateInput = {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    associatedSessionId: string;
+    actorSubjectId: string;
+    name: string;
+    placement: InteractionPlacement;
+};
+export type PrepareComputerSessionEndInput = {
+    accountId: string;
+    workspaceId: string;
+    computerSessionId: string;
+    operationId: string;
+    actorSubjectId: string;
+};
+/** Internal executor view. Plaintext controller credentials are derived from
+ * this durable fence and never stored here. */
+export type ComputerSessionControlRecord = {
+    session: ComputerSession;
+    tokenGeneration: number;
+    sourceSessionId: string;
+    createOperationId: string;
+    operation: null | {
+        operationId: string;
+        kind: InteractionLifecycleOperationKind;
+        state: InteractionOperationRow["state"];
+        controllerGeneration: string | null;
+        actorSubjectId: string;
+    };
+};
+export declare function computerSessionCreateRequestDigest(input: PrepareComputerSessionCreateInput): string;
+export declare function listComputerSessions(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+}): Promise<ComputerSessionListResponseValue>;
+export declare function getComputerSession(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    computerSessionId: string;
+}): Promise<ComputerSession>;
+export declare function getComputerSessionControlRecord(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    computerSessionId: string;
+    operationId?: string;
+}): Promise<ComputerSessionControlRecord>;
+export declare function findComputerSessionControlRecordByOperation(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+}): Promise<ComputerSessionControlRecord | null>;
+export declare function prepareComputerSessionCreate(db: Database, input: PrepareComputerSessionCreateInput): Promise<ComputerSessionMutationResponseValue>;
+export declare function dispatchComputerSessionOperation(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    computerSessionId: string;
+    controllerGeneration: string;
+    controller?: InteractionControllerBindingValue;
+}): Promise<InteractionLifecycleOperationReceiptValue>;
+export declare function activateComputerSession(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    computerSessionId: string;
+    controller: InteractionControllerBindingValue;
+    platform: "linux" | "macos" | "windows";
+    adapter: string;
+    seatId: string;
+    displayId: string;
+    capabilities: ComputerSessionCapabilitiesValue;
+}): Promise<ComputerSessionMutationResponseValue>;
+export declare function failComputerSessionOperation(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    computerSessionId: string;
+    state?: "failed" | "outcome_unknown";
+    error: InteractionErrorValue;
+}): Promise<ComputerSessionMutationResponseValue>;
+export declare function prepareComputerSessionEnd(db: Database, input: PrepareComputerSessionEndInput): Promise<ComputerSessionMutationResponseValue>;
+export declare function completeComputerSessionEnd(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    computerSessionId: string;
+    expectedControllerGeneration: string | null;
+}): Promise<ComputerSessionMutationResponseValue>;
+export declare function touchComputerSessionController(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    computerSessionId: string;
+    controllerGeneration: string;
+}): Promise<boolean>;
+export {};

package/dist/connection-token-resolver.d.ts

@@ -1,9 +1,9 @@
 import { environmentsEncryptionKeyBytes, type McpServerConnectionRef, type Settings } from "@opengeni/config";
-import type { ConnectionKind, ConnectionCredentialsPort, ConnectionStatus, McpConnectionResourceScope, McpCredentialAuthNeededReason, McpCredentialsRequest, TurnInitiator, TurnInitiatorContext } from "@opengeni/contracts";
+import type { ConnectionCredentialPlacement, ConnectionKind, ConnectionCredentialsPort, ConnectionStatus, McpConnectionResourceScope, McpCredentialAuthNeededReason, McpCredentialsRequest, TurnInitiator, TurnInitiatorContext } from "@opengeni/contracts";
 import { type DnsLookup, type FetchLike } from "@opengeni/network";
 export { isPrivateAddress } from "@opengeni/network";
-import { encryptEnvironmentValue } from "./environment-crypto";
-import type { Database } from "./database";
+import { encryptEnvironmentValue } from "./environment-crypto.js";
+import type { Database } from "./database.js";
 export type ConnectionCredentialForBroker = {
     id: string;
     accountId: string;
@@ -45,6 +45,8 @@ export type ConnectionStatusGuard = {
 export type ResolveConnectionCredentialResult = {
     status: "ok";
     headers: Record<string, string>;
+    /** Present when the credential bundle or embedding host supplied explicit placements. */
+    placements?: ConnectionCredentialPlacement[];
     connectionId: string;
     /** Exact durable version when the credential came from the local connection store. */
     connectionVersion?: number;
@@ -70,6 +72,8 @@ export type ResolveConnectionCredentialInput = {
     connectionRef: McpServerConnectionRef;
     /** Exact MCP destination whose request would receive the resolved headers. */
     destinationUrl: string;
+    /** Defaults to header-only MCP transport. */
+    credentialTarget?: "mcp" | "http_api";
     forceRefresh?: boolean;
 };
 export type HostMcpCredentialResolverContext = {
@@ -83,12 +87,13 @@ export type HostMcpCredentialResolverContext = {
     initiator: TurnInitiator;
     initiatorContext: TurnInitiatorContext;
     surface: McpCredentialsRequest["surface"];
+    allowOfficialGmailRestDestination?: boolean;
 };
 export declare class HostMcpCredentialScopeError extends Error {
     constructor(field: "accountId" | "workspaceId" | "sessionId");
 }
 export declare class HostMcpCredentialBindingError extends Error {
-    constructor(field: "provider" | "providerDomain" | "connectionId" | "scopes" | "resource" | "selectedResources" | "destinationUrl");
+    constructor(field: "provider" | "providerDomain" | "connectionId" | "scopes" | "resource" | "selectedResources" | "destinationUrl" | "credentialPlacements");
 }
 /**
  * Adapts the public embedding credential port to the runtime's connection

package/dist/database.d.ts

@@ -1,9 +1,18 @@
 import { type SQL } from "drizzle-orm";
 import type { PgDatabase, PgTransactionConfig } from "drizzle-orm/pg-core";
 import postgres from "postgres";
-import { type IdempotentPersistenceTransactionOptions } from "./persistence-errors";
-import * as schema from "./schema";
+import { type IdempotentPersistenceTransactionOptions } from "./persistence-errors.js";
+import * as schema from "./schema.js";
 export type Database = PgDatabase<any, typeof schema>;
+declare const sessionActivityDatabaseBrand: unique symbol;
+/**
+ * A workspace-scoped transaction whose session activity commit gate is open.
+ * Session-row writers accept this narrower handle so new call sites cannot
+ * accidentally bypass the once-per-transaction revision finalizer.
+ */
+export type SessionActivityDatabase = Database & {
+    readonly [sessionActivityDatabaseBrand]: true;
+};
 export type DbClient = {
     db: Database;
     close: () => Promise<void>;
@@ -12,6 +21,11 @@ export type RlsContext = {
     accountId: string;
     workspaceId?: string | null;
 };
+export type SessionRlsActorContext = {
+    subjectId: string;
+    initiatingHumanSubjectId?: string | null;
+};
+export declare function withSessionRlsActorContext<T>(actor: SessionRlsActorContext, fn: () => Promise<T>): Promise<T>;
 /**
  * RLS posture for the connection OpenGeni's query layer runs over (Step I, §7.7).
  *
@@ -97,6 +111,29 @@ export declare function rlsStrategyFor(db: Database): RlsStrategy;
  * an unknown driver result rather than silently treating it as an empty query.
  */
 export declare function rawRows<T extends Record<string, unknown>>(executor: Pick<Database, "execute">, query: SQL): Promise<T[]>;
+export type SandboxProviderReadLockIdentity = {
+    workspaceId: string;
+    sandboxGroupId: string;
+    leaseEpoch: number;
+    instanceId: string;
+};
+export declare class SandboxProviderReadLockUnavailableError extends Error {
+    constructor();
+}
+/**
+ * Cross-process exclusive boundary for one exact live provider instance's
+ * API-direct read request. Modal accepts concurrent commands from one attached
+ * handle, but independent API replicas reconstruct different handles; issuing
+ * overlapping command groups through those handles can make an otherwise valid
+ * read fail transiently. Keep concurrency inside one batched request while
+ * serializing only separate requests that target the same lease identity.
+ *
+ * The callback intentionally runs while one transaction-pinned DB connection
+ * holds the advisory lock. The direct lease holder separately prevents drain,
+ * and the abort-aware bounded poll prevents a disconnected HTTP request from
+ * occupying the connection indefinitely.
+ */
+export declare function withSandboxProviderReadLock<T>(db: Database, identity: SandboxProviderReadLockIdentity, signal: AbortSignal | undefined, fn: () => Promise<T>): Promise<T>;
 export declare function createDb(databaseUrl: string, options?: CreateDbOptions): DbClient;
 /**
  * Register a host's `rlsStrategy`/`userLookup` against an externally-constructed
@@ -119,7 +156,23 @@ export declare function withRlsContext<T>(db: Database, context: RlsContext, fn:
  */
 export declare function withDatabaseStatementTimeout<T>(db: Database, timeoutMs: number, fn: (db: Database) => Promise<T>): Promise<T>;
 export declare function rlsContextForWorkspace(db: Database, workspaceId: string): Promise<RlsContext>;
-export declare function withWorkspaceRls<T>(db: Database, workspaceId: string, fn: (db: Database) => Promise<T>): Promise<T>;
+export declare function withWorkspaceRls<T>(db: Database, workspaceId: string, fn: (db: Database) => Promise<T>, transactionConfig?: PgTransactionConfig): Promise<T>;
+/**
+ * Run one workspace transaction with explicit once-per-transaction session
+ * activity finalization. Nested callers reuse the outer gate; only its owner
+ * finalizes immediately before the enclosing RLS transaction commits.
+ */
+export declare function withSessionActivityRlsContext<T>(db: Database, context: RlsContext & {
+    workspaceId: string;
+}, fn: (db: SessionActivityDatabase) => Promise<T>, transactionConfig?: PgTransactionConfig): Promise<T>;
+export declare function withWorkspaceSessionActivityRls<T>(db: Database, workspaceId: string, fn: (db: SessionActivityDatabase) => Promise<T>, transactionConfig?: PgTransactionConfig): Promise<T>;
+/**
+ * Open one nested savepoint without losing the gate brand. Drizzle correctly
+ * preserves the backend-local gate GUCs, but its structural transaction type
+ * cannot express that provenance; keep the single trusted rebrand here.
+ */
+export declare function withSessionActivitySavepoint<T>(db: SessionActivityDatabase, fn: (db: SessionActivityDatabase) => Promise<T>): Promise<T>;
+export declare function retrySessionActivityRls<T>(db: Database, workspaceId: string, options: IdempotentPersistenceTransactionOptions, fn: (db: SessionActivityDatabase) => Promise<T>): Promise<T>;
 export declare function retryWorkspacePersistence<T>(db: Database, workspaceId: string, options: IdempotentPersistenceTransactionOptions, fn: (db: Database) => Promise<T>): Promise<T>;
 export declare function retryRlsPersistence<T>(db: Database, context: RlsContext, options: IdempotentPersistenceTransactionOptions, fn: (db: Database) => Promise<T>): Promise<T>;
 /**
@@ -128,6 +181,7 @@ export declare function retryRlsPersistence<T>(db: Database, context: RlsContext
  * even if a future query accidentally omits its explicit subject predicate.
  */
 export declare function withWorkspaceSubjectRls<T>(db: Database, workspaceId: string, subjectId: string, fn: (db: Database) => Promise<T>, transactionConfig?: PgTransactionConfig): Promise<T>;
+export declare function withWorkspaceSubjectSessionActivityRls<T>(db: Database, workspaceId: string, subjectId: string, fn: (db: SessionActivityDatabase) => Promise<T>, transactionConfig?: PgTransactionConfig): Promise<T>;
 /** Apply and verify actor-private RLS on an already transaction-pinned handle. */
 export declare function setSubjectRlsContext(db: Database, subjectId: string): Promise<void>;
 export declare function withWorkspaceUsageLock<T>(db: Database, workspaceId: string, fn: (db: Database) => Promise<T>): Promise<T>;

package/dist/editable-artifact-durable-export.d.ts

@@ -0,0 +1,153 @@
+import { type Database } from "./database.js";
+export type PersistedEditableArtifactExportScope = Readonly<{
+    accountId: string;
+    workspaceId: string;
+}>;
+export type PersistedEditableArtifactExportActor = Readonly<{
+    kind: "human";
+    subjectId: string;
+    replicaId: string;
+}> | Readonly<{
+    kind: "agent";
+    subjectId: string;
+    replicaId: string;
+    sessionId: string;
+    turnId: string;
+    attemptId: string;
+    generation: number;
+}> | Readonly<{
+    kind: "service";
+    subjectId: string;
+    replicaId: string;
+    service: string;
+}>;
+export type PersistedEditableArtifactExportModality = "spreadsheet" | "document" | "presentation";
+export type PersistedEditableArtifactExportFormat = "xlsx" | "pptx" | "docx" | "pdf" | "png" | "webp";
+export type PersistedEditableArtifactExportProfile = Readonly<{
+    modality: PersistedEditableArtifactExportModality;
+    format: PersistedEditableArtifactExportFormat;
+    codecId: string;
+    codecVersion: string;
+    kernelVersion: string;
+    fontRegistryHash: string;
+    policyHash: string;
+    normalizedOptions: string;
+}>;
+export type PersistedEditableArtifactPinnedVersion = Readonly<{
+    scope: PersistedEditableArtifactExportScope;
+    artifactId: string;
+    id: string;
+    modality: PersistedEditableArtifactExportModality;
+    snapshotId: string;
+    headSequence: number;
+    causalFrontier: readonly Readonly<{
+        replicaId: string;
+        counter: number;
+    }>[] | null;
+    nativeRevision: number | null;
+    stateHash: string;
+    name: string;
+    pinned: true;
+    createdBySubjectId: string;
+    createdAt: string;
+}>;
+export type PersistedEditableArtifactMaterializationResult = Readonly<{
+    id: string;
+    byteSize: number;
+    contentHash: string;
+    mimeType: string;
+    verifiedAt: string;
+    createdAt: string;
+}>;
+export type PersistedEditableArtifactMaterializationJob = Readonly<{
+    scope: PersistedEditableArtifactExportScope;
+    artifactId: string;
+    id: string;
+    versionId: string;
+    inputSnapshotId: string;
+    targetHeadSequence: number;
+    stateHash: string;
+    format: PersistedEditableArtifactExportFormat;
+    state: "pending" | "running" | "succeeded" | "failed";
+    attemptCount: number;
+    errorCode: string | null;
+    createdAt: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    result: PersistedEditableArtifactMaterializationResult | null;
+}>;
+export type PersistedEditableArtifactExportSnapshot = Readonly<{
+    modality: PersistedEditableArtifactExportModality;
+    snapshotId: string;
+    coveredHeadSequence: number;
+    stateHash: string;
+    coveredCausalFrontier: readonly Readonly<{
+        replicaId: string;
+        counter: number;
+    }>[] | null;
+    nativeRevision: number | null;
+}>;
+type ExportContext = Readonly<{
+    scope: PersistedEditableArtifactExportScope;
+    artifactId: string;
+    actor: PersistedEditableArtifactExportActor;
+}>;
+export type PinPersistedEditableArtifactVersionRequest = ExportContext & Readonly<{
+    expectedAuthorizationRevision: number;
+    authorityKey: string;
+    receiptId: string;
+    versionId: string;
+    idempotencyKey: string;
+    requestHash: string;
+    name: string;
+    snapshot: PersistedEditableArtifactExportSnapshot;
+}>;
+export type EnqueuePersistedEditableArtifactMaterializationRequest = ExportContext & Readonly<{
+    expectedAuthorizationRevision: number;
+    authorityKey: string;
+    receiptId: string;
+    jobId: string;
+    idempotencyKey: string;
+    requestHash: string;
+    versionId: string;
+    profile: PersistedEditableArtifactExportProfile;
+}>;
+export type PersistedEditableArtifactAuthorizationResult<T> = Readonly<{
+    kind: "result";
+    value: T;
+}> | Readonly<{
+    kind: "authorization_stale";
+}>;
+export declare class EditableArtifactDurableExportPersistenceError extends Error {
+    readonly code: "not_found" | "idempotency_conflict" | "snapshot_conflict" | "unsupported_format" | "database_contract_violation";
+    constructor(code: "not_found" | "idempotency_conflict" | "snapshot_conflict" | "unsupported_format" | "database_contract_violation", message: string, options?: ErrorOptions);
+}
+/** Tenant-scoped public version/export persistence; global claiming remains separate. */
+export declare class PostgresEditableArtifactDurableExportStore {
+    private readonly db;
+    constructor(db: Database);
+    pinVersion(requestInput: PinPersistedEditableArtifactVersionRequest): Promise<PersistedEditableArtifactAuthorizationResult<Readonly<{
+        version: PersistedEditableArtifactPinnedVersion;
+        replayed: boolean;
+    }>>>;
+    enqueueMaterialization(requestInput: EnqueuePersistedEditableArtifactMaterializationRequest): Promise<PersistedEditableArtifactAuthorizationResult<Readonly<{
+        job: PersistedEditableArtifactMaterializationJob;
+        replayed: boolean;
+    }>>>;
+    readVersion(input: ExportContext & {
+        expectedAuthorizationRevision: number;
+        versionId: string;
+    }): Promise<PersistedEditableArtifactAuthorizationResult<PersistedEditableArtifactPinnedVersion | null>>;
+    readMaterialization(input: ExportContext & {
+        expectedAuthorizationRevision: number;
+        jobId: string;
+    }): Promise<PersistedEditableArtifactAuthorizationResult<PersistedEditableArtifactMaterializationJob | null>>;
+    readMaterializationDownload(input: ExportContext & {
+        expectedAuthorizationRevision: number;
+        jobId: string;
+    }): Promise<PersistedEditableArtifactAuthorizationResult<Readonly<{
+        job: PersistedEditableArtifactMaterializationJob | null;
+        objectReference: string | null;
+    }>>>;
+}
+export {};