@opengeni/db 0.28.1 → 0.31.1

package/dist/attached-browser-devices.d.ts

@@ -0,0 +1,42 @@
+import { type AttachedBrowserDevice as AttachedBrowserDeviceValue, type AttachedBrowserDeviceListResponse as AttachedBrowserDeviceListResponseValue, type AttachedBrowserInventorySnapshot as AttachedBrowserInventorySnapshotValue } from "@opengeni/contracts";
+import { type Database } from "./database.js";
+export declare class AttachedBrowserDeviceNotFoundError extends Error {
+    readonly name = "AttachedBrowserDeviceNotFoundError";
+}
+export declare class AttachedBrowserInventoryConflictError extends Error {
+    readonly name = "AttachedBrowserInventoryConflictError";
+}
+export type ReconcileAttachedBrowserInventoryResult = {
+    accepted: boolean;
+    changed: boolean;
+    revision: number;
+};
+/** Reconcile one full browser-bridge snapshot. The enrollment row serializes
+ *  concurrent heartbeats; a lower revision from the same bridge generation is
+ *  ignored, and a replay only refreshes liveness. */
+export declare function reconcileAttachedBrowserInventory(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    enrollmentId: string;
+    snapshot: AttachedBrowserInventorySnapshotValue;
+}): Promise<ReconcileAttachedBrowserInventoryResult>;
+/** Immediately mark every live Chrome profile on a cleanly disconnected agent
+ *  offline. Historical endpoint rows remain discoverable and reconnect in place. */
+export declare function disconnectAttachedBrowserDevices(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    enrollmentId: string;
+}): Promise<{
+    changed: boolean;
+    revision: number;
+}>;
+export declare function listAttachedBrowserDevices(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    includeDisconnected?: boolean;
+}): Promise<AttachedBrowserDeviceListResponseValue>;
+export declare function getAttachedBrowserDevice(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    deviceId: string;
+}): Promise<AttachedBrowserDeviceValue>;

package/dist/attempt-tool-catalogs.d.ts

@@ -0,0 +1,16 @@
+import type { AttemptToolCatalog } from "@opengeni/contracts";
+import type { Database } from "./database.js";
+export declare class AttemptToolCatalogAuthorityError extends Error {
+    readonly code = "attempt_tool_catalog_authority_mismatch";
+    constructor();
+}
+export declare class AttemptToolCatalogConflictError extends Error {
+    readonly code = "attempt_tool_catalog_conflict";
+    constructor();
+}
+export declare function persistAttemptToolCatalog(db: Database, input: AttemptToolCatalog): Promise<AttemptToolCatalog>;
+export declare function getAttemptToolCatalog(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    attemptId: string;
+}): Promise<AttemptToolCatalog | null>;

package/dist/browser-auth.d.ts

@@ -0,0 +1,91 @@
+import { type AuthRun as AuthRunValue, type AuthRunListResponse as AuthRunListResponseValue, type AuthRunMutationResponse as AuthRunMutationResponseValue, type CreateInteractionInterventionRequest as CreateInteractionInterventionRequestValue, type CreateNetworkRouteRequest as CreateNetworkRouteRequestValue, type CreateSiteAuthConnectionRequest as CreateSiteAuthConnectionRequestValue, type InteractionIntervention as InteractionInterventionValue, type InteractionInterventionListResponse as InteractionInterventionListResponseValue, type InteractionInterventionMutationResponse as InteractionInterventionMutationResponseValue, type NetworkRoute as NetworkRouteValue, type NetworkRouteListResponse as NetworkRouteListResponseValue, type NetworkRouteMutationResponse as NetworkRouteMutationResponseValue, type ReportAuthRunRequest as ReportAuthRunRequestValue, type ResolveInteractionInterventionRequest as ResolveInteractionInterventionRequestValue, type SiteAuthConnection as SiteAuthConnectionValue, type SiteAuthConnectionListResponse as SiteAuthConnectionListResponseValue, type SiteAuthConnectionMutationResponse as SiteAuthConnectionMutationResponseValue, type StartAuthRunRequest as StartAuthRunRequestValue, type UpdateNetworkRouteRequest as UpdateNetworkRouteRequestValue, type UpdateSiteAuthConnectionRequest as UpdateSiteAuthConnectionRequestValue } from "@opengeni/contracts";
+import { type Database } from "./database.js";
+type InteractionMutationScope = {
+    accountId: string;
+    workspaceId: string;
+    actorSubjectId: string;
+};
+export declare class InteractionResourceNotFoundError extends Error {
+    readonly name = "InteractionResourceNotFoundError";
+}
+export declare class InteractionResourceConflictError extends Error {
+    readonly name = "InteractionResourceConflictError";
+}
+export declare class InteractionResourceStateError extends Error {
+    readonly name = "InteractionResourceStateError";
+}
+export declare function listNetworkRoutes(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    includeArchived?: boolean;
+}): Promise<NetworkRouteListResponseValue>;
+export declare function getNetworkRoute(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    routeId: string;
+}): Promise<NetworkRouteValue>;
+export declare function createNetworkRoute(db: Database, input: InteractionMutationScope & CreateNetworkRouteRequestValue): Promise<NetworkRouteMutationResponseValue>;
+export declare function updateNetworkRoute(db: Database, input: InteractionMutationScope & {
+    routeId: string;
+} & UpdateNetworkRouteRequestValue): Promise<NetworkRouteMutationResponseValue>;
+export declare function listSiteAuthConnections(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    includeArchived?: boolean;
+}): Promise<SiteAuthConnectionListResponseValue>;
+export declare function getSiteAuthConnection(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    siteAuthConnectionId: string;
+}): Promise<SiteAuthConnectionValue>;
+export declare function createSiteAuthConnection(db: Database, input: InteractionMutationScope & CreateSiteAuthConnectionRequestValue): Promise<SiteAuthConnectionMutationResponseValue>;
+export declare function updateSiteAuthConnection(db: Database, input: InteractionMutationScope & {
+    siteAuthConnectionId: string;
+} & UpdateSiteAuthConnectionRequestValue): Promise<SiteAuthConnectionMutationResponseValue>;
+export declare function listAuthRuns(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    browserSessionId?: string;
+    siteAuthConnectionId?: string;
+    includeSettled?: boolean;
+}): Promise<AuthRunListResponseValue>;
+export declare function getAuthRun(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    authRunId: string;
+}): Promise<AuthRunValue>;
+export declare function startAuthRun(db: Database, input: InteractionMutationScope & {
+    browserSessionId: string;
+} & StartAuthRunRequestValue): Promise<AuthRunMutationResponseValue>;
+export declare function reportAuthRun(db: Database, input: InteractionMutationScope & {
+    authRunId: string;
+    controllerGeneration: string;
+} & ReportAuthRunRequestValue): Promise<AuthRunMutationResponseValue>;
+export declare function listInteractionInterventions(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    resourceKind?: "browser_session" | "computer_session";
+    resourceId?: string;
+    includeSettled?: boolean;
+}): Promise<InteractionInterventionListResponseValue>;
+export declare function getInteractionIntervention(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    interventionId: string;
+}): Promise<InteractionInterventionValue>;
+export declare function createInteractionIntervention(db: Database, input: InteractionMutationScope & CreateInteractionInterventionRequestValue & {
+    originatingSessionId: string;
+    originatingTurnId?: string | null;
+    originatingAttemptId?: string | null;
+    originatingToolOperationId?: string | null;
+}): Promise<InteractionInterventionMutationResponseValue>;
+export declare function resolveInteractionIntervention(db: Database, input: InteractionMutationScope & {
+    interventionId: string;
+} & ResolveInteractionInterventionRequestValue): Promise<InteractionInterventionMutationResponseValue>;
+export declare function cancelOpenInteractionInterventions(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    resourceKind: "browser_session" | "computer_session";
+    resourceId: string;
+}): Promise<number>;
+export {};

package/dist/browser-identities.d.ts

@@ -0,0 +1,128 @@
+import { type BrowserIdentity as BrowserIdentityValue, type BrowserIdentityListResponse as BrowserIdentityListResponseValue, type BrowserIdentityMutationResponse as BrowserIdentityMutationResponseValue, type BrowserRevision as BrowserRevisionValue, type BrowserRevisionListResponse as BrowserRevisionListResponseValue, type BrowserRevisionMaterialization as BrowserRevisionMaterializationValue, type InteractionError as InteractionErrorValue, type PublishBrowserRevisionResponse as PublishBrowserRevisionResponseValue } from "@opengeni/contracts";
+import { type Database } from "./database.js";
+import { type BrowserStateArtifactCommitInput } from "./browser-state-artifacts.js";
+export declare class BrowserIdentityNotFoundError extends Error {
+    readonly name = "BrowserIdentityNotFoundError";
+}
+export declare class BrowserIdentityConflictError extends Error {
+    readonly name = "BrowserIdentityConflictError";
+}
+export declare class BrowserIdentityStateError extends Error {
+    readonly name = "BrowserIdentityStateError";
+}
+export type { BrowserStateArtifactCommitInput } from "./browser-state-artifacts.js";
+export type BrowserRevisionPublicationPreparation = {
+    kind: "completed";
+    response: PublishBrowserRevisionResponseValue;
+} | {
+    kind: "pending";
+    operationState: "prepared" | "dispatched";
+    browserSessionId: string;
+    controllerGeneration: string;
+    identity: BrowserIdentityValue;
+    parentRevisionId: string | null;
+};
+export type BrowserRevisionPublicationDispatch = {
+    kind: "completed";
+    response: PublishBrowserRevisionResponseValue;
+} | {
+    kind: "dispatched";
+    browserSessionId: string;
+    controllerGeneration: string;
+    replayed: boolean;
+};
+export type BrowserRevisionArtifactAuthority = {
+    revision: BrowserRevisionValue;
+    artifacts: Array<{
+        componentId: string;
+        artifactId: string;
+        objectKey: string;
+        encryptedDataKey: string;
+        contentDigest: string;
+        manifestDigest: string;
+        artifactDigest: string;
+        sizeBytes: number;
+        format: string;
+        materialization: BrowserRevisionMaterializationValue;
+    }>;
+};
+export declare function listBrowserIdentities(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    includeArchived?: boolean;
+}): Promise<BrowserIdentityListResponseValue>;
+export declare function getBrowserIdentity(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    identityId: string;
+}): Promise<BrowserIdentityValue>;
+export declare function listBrowserRevisions(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    identityId: string;
+}): Promise<BrowserRevisionListResponseValue>;
+export declare function createBrowserIdentity(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    name: string;
+    actorSubjectId: string;
+}): Promise<BrowserIdentityMutationResponseValue>;
+export declare function browserRevisionPublicationRequestDigest(input: {
+    browserSessionId: string;
+    identityId: string;
+    expectedHeadGeneration: number;
+    advanceDefault: boolean;
+    actorSubjectId: string;
+}): string;
+export declare function prepareBrowserRevisionPublication(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    browserSessionId: string;
+    identityId: string;
+    expectedHeadGeneration: number;
+    advanceDefault: boolean;
+    actorSubjectId: string;
+}): Promise<BrowserRevisionPublicationPreparation>;
+export declare function dispatchBrowserRevisionPublication(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    browserSessionId: string;
+    controllerGeneration: string;
+    identityId: string;
+    expectedHeadGeneration: number;
+    advanceDefault: boolean;
+    actorSubjectId: string;
+}): Promise<BrowserRevisionPublicationDispatch>;
+export declare function commitBrowserRevisionPublication(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    browserSessionId: string;
+    controllerGeneration: string;
+    identityId: string;
+    expectedHeadGeneration: number;
+    advanceDefault: boolean;
+    actorSubjectId: string;
+    manifestDigest: string;
+    artifacts: readonly BrowserStateArtifactCommitInput[];
+}): Promise<PublishBrowserRevisionResponseValue>;
+export declare function failBrowserRevisionPublication(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    browserSessionId: string;
+    controllerGeneration: string;
+    state?: "failed" | "outcome_unknown";
+    error: InteractionErrorValue;
+}): Promise<void>;
+/** Server-only storage authority used to restore a revision. Never project this
+ *  result through HTTP, MCP, Codemode output, or the public SDK. */
+export declare function getBrowserRevisionArtifactAuthority(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    identityId: string;
+    revisionId: string;
+}): Promise<BrowserRevisionArtifactAuthority>;

package/dist/browser-sessions.d.ts

@@ -0,0 +1,272 @@
+import { BrowserSession, InteractionControllerBinding, type BrowserSessionCapabilities as BrowserSessionCapabilitiesValue, type BrowserRevisionMaterialization as BrowserRevisionMaterializationValue, type BrowserSessionListResponse as BrowserSessionListResponseValue, type BrowserSessionMutationResponse as BrowserSessionMutationResponseValue, type InteractionError as InteractionErrorValue, type InteractionLifecycleOperationKind, type InteractionLifecycleOperationReceipt as InteractionLifecycleOperationReceiptValue, type InteractionPlacement } from "@opengeni/contracts";
+import { type Database } from "./database.js";
+import { type BrowserStateArtifactCommitInput } from "./browser-state-artifacts.js";
+import * as schema from "./schema.js";
+type BrowserSessionRow = typeof schema.browserSessions.$inferSelect;
+type InteractionOperationRow = typeof schema.interactionOperations.$inferSelect;
+export declare const MANAGED_BROWSER_SESSION_CAPABILITIES: {
+    semanticObservation: boolean;
+    screenshots: boolean;
+    liveFrames: boolean;
+    humanInput: boolean;
+    tabs: boolean;
+    downloads: boolean;
+    uploads: boolean;
+    clipboard: boolean;
+    diagnostics: boolean;
+    rawCdp: boolean;
+    linkedComputer: boolean;
+    privateCheckpoint: boolean;
+    identityPublication: boolean;
+    parallelTargets: boolean;
+};
+export declare const ATTACHED_BROWSER_SESSION_CAPABILITIES: {
+    semanticObservation: boolean;
+    screenshots: boolean;
+    liveFrames: boolean;
+    humanInput: boolean;
+    tabs: boolean;
+    downloads: boolean;
+    uploads: boolean;
+    clipboard: boolean;
+    diagnostics: boolean;
+    rawCdp: boolean;
+    linkedComputer: boolean;
+    privateCheckpoint: boolean;
+    identityPublication: boolean;
+    parallelTargets: boolean;
+};
+export declare class BrowserSessionNotFoundError extends Error {
+    readonly name = "BrowserSessionNotFoundError";
+}
+export declare class BrowserSessionOperationConflictError extends Error {
+    readonly name = "BrowserSessionOperationConflictError";
+}
+export declare class BrowserSessionStateError extends Error {
+    readonly name = "BrowserSessionStateError";
+}
+export type PrepareBrowserSessionCreateInput = {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    associatedSessionId: string;
+    actorSubjectId: string;
+    name: string;
+    initialUrl: string | null;
+    placement: InteractionPlacement;
+    driverId: string;
+    engine: BrowserSessionRow["engine"];
+    headless: boolean;
+    identityId: string | null;
+    baseRevisionId: string | null;
+    networkRouteId?: string | null;
+    linkedComputerSessionId?: string | null;
+    resolveDefaultRevision?: boolean;
+    capabilities?: BrowserSessionCapabilitiesValue;
+};
+export type PrepareBrowserSessionEndInput = {
+    accountId: string;
+    workspaceId: string;
+    browserSessionId: string;
+    operationId: string;
+    actorSubjectId: string;
+};
+export type PrepareBrowserSessionLifecycleInput = PrepareBrowserSessionEndInput;
+export type BrowserPrivateCheckpointAuthority = {
+    artifactId: string;
+    sourceBrowserSessionId: string;
+    objectKey: string;
+    encryptedDataKey: string;
+    format: string;
+    artifactDigest: string;
+    contentDigest: string;
+    manifestDigest: string;
+    sizeBytes: number;
+    materialization: BrowserRevisionMaterializationValue;
+};
+/** Internal executor view of one BrowserSession. Plaintext controller
+ * credentials are deliberately absent; callers derive them from this fenced
+ * durable state. */
+export type BrowserSessionControlRecord = {
+    session: BrowserSession;
+    tokenGeneration: number;
+    sourceSessionId: string;
+    createOperationId: string;
+    operation: null | {
+        operationId: string;
+        kind: InteractionLifecycleOperationKind;
+        state: InteractionOperationRow["state"];
+        controllerGeneration: string | null;
+        actorSubjectId: string;
+    };
+};
+export declare function browserSessionCreateRequestDigest(input: PrepareBrowserSessionCreateInput): string;
+export declare function listBrowserSessions(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+}): Promise<BrowserSessionListResponseValue>;
+export declare function getBrowserSession(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    browserSessionId: string;
+}): Promise<{
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    name: string;
+    lifecycle: "active" | "ended" | "ending" | "failed" | "lost" | "repair_required" | "restoring" | "starting" | "suspended" | "suspending";
+    placement: {
+        kind: "sandbox_group";
+        sandboxGroupId: string;
+    } | {
+        kind: "connected_machine";
+        sandboxId: string;
+    } | {
+        kind: "attached_device";
+        deviceId: string;
+    } | {
+        kind: "external_provider";
+        providerId: string;
+        placementId: string;
+    };
+    controller: {
+        controllerId: string;
+        controllerGeneration: string;
+        placementInstanceId: string;
+    } | null;
+    driverId: string;
+    engine: "chrome" | "chromium" | "external" | "firefox" | "lightpanda" | "webkit";
+    engineVersion: string | null;
+    headless: boolean;
+    identityId: string | null;
+    baseRevisionId: string | null;
+    networkRouteId: string | null;
+    linkedComputerSessionId: string | null;
+    capabilities: {
+        semanticObservation: boolean;
+        screenshots: boolean;
+        liveFrames: boolean;
+        humanInput: boolean;
+        tabs: boolean;
+        downloads: boolean;
+        uploads: boolean;
+        clipboard: boolean;
+        diagnostics: boolean;
+        rawCdp: boolean;
+        linkedComputer: boolean;
+        privateCheckpoint: boolean;
+        identityPublication: boolean;
+        parallelTargets: boolean;
+    };
+    associations: {
+        sessionId: string;
+        turnId: string | null;
+        attemptId: string | null;
+        relationship: "created" | "observing" | "related" | "using";
+        actorSubjectId: string;
+        lastUsedAt: string;
+    }[];
+    createdBySubjectId: string;
+    createdAt: string;
+    lastUsedAt: string;
+    failureCode: string | null;
+}>;
+export declare function getBrowserSessionControlRecord(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    browserSessionId: string;
+    operationId?: string;
+}): Promise<BrowserSessionControlRecord>;
+export declare function getBrowserPrivateCheckpointAuthority(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    browserSessionId: string;
+}): Promise<BrowserPrivateCheckpointAuthority | null>;
+/** Resolve an idempotency key before inspecting mutable placement. This keeps
+ * a retried create bound to its original BrowserSession even if the source
+ * session's active sandbox pointer has since changed. */
+export declare function findBrowserSessionControlRecordByOperation(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+}): Promise<BrowserSessionControlRecord | null>;
+export declare function prepareBrowserSessionCreate(db: Database, input: PrepareBrowserSessionCreateInput): Promise<BrowserSessionMutationResponseValue>;
+export declare function dispatchBrowserSessionOperation(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    browserSessionId: string;
+    controllerGeneration: string;
+    controller?: InteractionControllerBinding;
+}): Promise<InteractionLifecycleOperationReceiptValue>;
+export declare function activateBrowserSession(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    browserSessionId: string;
+    controller: InteractionControllerBinding;
+    engineVersion: string | null;
+}): Promise<BrowserSessionMutationResponseValue>;
+export declare function failBrowserSessionOperation(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    browserSessionId: string;
+    state?: "failed" | "outcome_unknown";
+    error: InteractionErrorValue;
+}): Promise<BrowserSessionMutationResponseValue>;
+export declare function prepareBrowserSessionSuspend(db: Database, input: PrepareBrowserSessionLifecycleInput): Promise<BrowserSessionMutationResponseValue>;
+export declare function prepareBrowserSessionResume(db: Database, input: PrepareBrowserSessionLifecycleInput): Promise<BrowserSessionMutationResponseValue>;
+export declare function commitBrowserSessionSuspension(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    browserSessionId: string;
+    controllerGeneration: string;
+    artifact: BrowserStateArtifactCommitInput;
+}): Promise<BrowserSessionMutationResponseValue>;
+export declare function clearSuspendedBrowserSessionController(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    browserSessionId: string;
+    expectedControllerGeneration: string;
+}): Promise<boolean>;
+export declare function failBrowserSessionSuspension(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    browserSessionId: string;
+    controllerGeneration: string;
+    state?: "failed" | "outcome_unknown";
+    error: InteractionErrorValue;
+}): Promise<BrowserSessionMutationResponseValue>;
+export declare function failBrowserSessionResume(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    browserSessionId: string;
+    controllerGeneration: string;
+    error: InteractionErrorValue;
+}): Promise<BrowserSessionMutationResponseValue>;
+export declare function failBrowserSessionResumePreparation(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    browserSessionId: string;
+    error: InteractionErrorValue;
+}): Promise<BrowserSessionMutationResponseValue>;
+export declare function prepareBrowserSessionEnd(db: Database, input: PrepareBrowserSessionEndInput): Promise<BrowserSessionMutationResponseValue>;
+export declare function completeBrowserSessionEnd(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    operationId: string;
+    browserSessionId: string;
+    expectedControllerGeneration: string | null;
+}): Promise<BrowserSessionMutationResponseValue>;
+export declare function touchBrowserSessionController(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    browserSessionId: string;
+    controllerGeneration: string;
+}): Promise<boolean>;
+export {};

package/dist/browser-state-artifacts.d.ts

@@ -0,0 +1,17 @@
+import { type BrowserRevisionMaterialization as BrowserRevisionMaterializationValue } from "@opengeni/contracts";
+import type * as schema from "./schema.js";
+type BrowserStateArtifactRow = typeof schema.browserStateArtifacts.$inferSelect;
+export type BrowserStateArtifactCommitInput = {
+    kind: BrowserStateArtifactRow["kind"];
+    format: string;
+    artifactDigest: string;
+    contentDigest: string;
+    manifestDigest: string;
+    objectKey: string;
+    encryptedDataKey: string;
+    sizeBytes: number;
+    materialization: BrowserRevisionMaterializationValue;
+};
+/** Validate storage authority before it can become durable state. */
+export declare function validateBrowserStateArtifactCommitInput(workspaceId: string, value: BrowserStateArtifactCommitInput): BrowserStateArtifactCommitInput;
+export {};

package/dist/capability-components.d.ts

@@ -0,0 +1,37 @@
+import { sql, type SQLWrapper } from "drizzle-orm";
+import type { Database } from "./database.js";
+export type CapabilityComponentOwnerIdentity = {
+    kind: "direct" | "plugin" | "pack" | "migration";
+    id: string;
+};
+export declare class CapabilityComponentVersionConflictError extends Error {
+    readonly pluginKey: string;
+    readonly name = "CapabilityComponentVersionConflictError";
+    constructor(pluginKey: string);
+}
+/**
+ * An owner row is runtime-effective only while its lifecycle-owning Plugin or
+ * v2 Pack installation is active. Direct, migration, and legacy textual Pack
+ * ownership is intrinsic so the rolling migration does not hide pre-v2 shared
+ * components before those Packs are reinstalled into the normalized ledger.
+ */
+export declare function effectiveCapabilityOwnerSql(ownerKind: SQLWrapper, ownerId: SQLWrapper): ReturnType<typeof sql>;
+/** Serialize one workspace-local component identity across direct, Plugin, and Pack installers. */
+export declare function lockCapabilityComponentIdentity(db: Database, workspaceId: string, pluginKey: string): Promise<void>;
+/**
+ * A child installation selects exactly one immutable Plugin version. Changing
+ * that version is safe only when every retained facet owner is the caller.
+ */
+export declare function assertCapabilityComponentVersionCanChange(db: Database, input: {
+    workspaceId: string;
+    pluginKey: string;
+    pluginInstallationId: string;
+    owner: CapabilityComponentOwnerIdentity;
+}): Promise<void>;
+/**
+ * Delete physically ownerless facet installations and disable now-empty child
+ * components. Inactive lifecycle owners still preserve storage: a Pack may
+ * have claimed a component while its installation is pending or repairing,
+ * even though that owner is intentionally hidden from runtime reads.
+ */
+export declare function cleanupOrphanedCapabilityComponents(db: Database, workspaceId: string, facetInstallationIds: string[]): Promise<void>;