@relayfile/sdk 0.10.46 → 0.10.48

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import { type AdminIngressStatusResponse, type AdminSyncStatusResponse, type BulkWriteInput, type BulkWriteResponse, type BackendStatusResponse, type AckResponse, type CommitForkInput, type CommitForkResponse, type AcceptDurableSubscriptionDeliveryInput, type CancelDurableResourceSubscriptionOptions, type ClaimDurableSubscriptionDeliveriesInput, type CreateOrRenewDurableResourceSubscriptionInput, type CreateForkInput, type DeleteFileInput, type DeadLetterItem, type DeadLetterFeedResponse, type DeleteWebhookOptions, type DiscardForkInput, type DurableResourceSubscription, type DurableResourceSubscriptionListResponse, type DurableSubscriptionDeliveryListResponse, type DurableSubscriptionDeliveryResponse, type EventFeedResponse, type ExportJsonResponse, type ExportOptions, type FileQueryResponse, type FileReadResponse, type FilesystemEvent, type GetEventsOptions, type GetAdminIngressStatusOptions, type GetAdminSyncStatusOptions, type GetOperationsOptions, type GetSyncDeadLettersOptions, type GetSyncIngressStatusOptions, type GetSyncStatusOptions, type GetWebhookDeadLettersOptions, type ListWebhooksOptions, type ListDurableResourceSubscriptionsOptions, type ListTreeOptions, type MergeFileInput, type MergeFileResponse, type OperationFeedResponse, type OperationStatusResponse, type QueuedResponse, type ResourceAtEventResult, type ReadFileInput, type QueryFilesOptions, type RebaseForkInput, type RebaseForkResponse, type RegisterWebhookInput, type RegisterWebhookResponse, type RelayFileReadCacheOptions, type Subscription, type SyncIngressStatusResponse, type SyncProviderStatus, type SyncStatusResponse, type TreeResponse, type WriteFileInput, type WriteQueuedResponse, type IngestWebhookInput, type WritebackItem, type WebhookDeliveryDeadLetterFeedResponse, type WebhookSubscription, type AckWritebackInput, type AckWritebackResponse, type SweepWritebackDraftsInput, type SweepWritebackDraftsResponse, type ChangeEvent, type ChangeLogQueryResult, type ChangeStreamConnection, type ChangeStreamConnectionOptions, type SubscribeOptions, type WaitForDataOptions } from "./types.js";
+import { type AdminIngressStatusResponse, type AdminSyncStatusResponse, type BulkWriteInput, type BulkWriteResponse, type CheckpointSeal, type CheckpointSealRetentionRecord, type CheckpointSealRetentionSummary, type GetAdminCheckpointSealRetentionOptions, type ReconcileAdminCheckpointSealSourceInput, type ConsumedCheckpointSeal, type IssueCheckpointSealInput, type ConsumeCheckpointSealInput, type RecoverConsumedCheckpointSealInput, type VerifyCheckpointSealInput, type CheckpointSealOwnership, type HandbackCheckpointSealInput, type ResumeCheckpointSealInput, type BackendStatusResponse, type AckResponse, type CommitForkInput, type CommitForkResponse, type AcceptDurableSubscriptionDeliveryInput, type CancelDurableResourceSubscriptionOptions, type ClaimDurableSubscriptionDeliveriesInput, type CreateOrRenewDurableResourceSubscriptionInput, type CreateForkInput, type DeleteFileInput, type DeadLetterItem, type DeadLetterFeedResponse, type DeleteWebhookOptions, type DiscardForkInput, type DurableResourceSubscription, type DurableResourceSubscriptionListResponse, type DurableSubscriptionDeliveryListResponse, type DurableSubscriptionDeliveryResponse, type EventFeedResponse, type ExportJsonResponse, type ExportOptions, type FileQueryResponse, type FileReadResponse, type FilesystemEvent, type GetEventsOptions, type GetAdminIngressStatusOptions, type GetAdminSyncStatusOptions, type GetOperationsOptions, type GetSyncDeadLettersOptions, type GetSyncIngressStatusOptions, type GetSyncStatusOptions, type GetWebhookDeadLettersOptions, type ListWebhooksOptions, type ListDurableResourceSubscriptionsOptions, type ListTreeOptions, type MergeFileInput, type MergeFileResponse, type OperationFeedResponse, type OperationStatusResponse, type QueuedResponse, type ResourceAtEventResult, type ReadFileInput, type QueryFilesOptions, type RebaseForkInput, type RebaseForkResponse, type RegisterWebhookInput, type RegisterWebhookResponse, type RelayFileReadCacheOptions, type Subscription, type SyncIngressStatusResponse, type SyncProviderStatus, type SyncStatusResponse, type TreeResponse, type WriteFileInput, type WriteQueuedResponse, type IngestWebhookInput, type WritebackItem, type WebhookDeliveryDeadLetterFeedResponse, type WebhookSubscription, type AckWritebackInput, type AckWritebackResponse, type SweepWritebackDraftsInput, type SweepWritebackDraftsResponse, type ChangeEvent, type ChangeLogQueryResult, type ChangeStreamConnection, type ChangeStreamConnectionOptions, type SubscribeOptions, type WaitForDataOptions } from "./types.js";
 import type { ForkHandle } from "@relayfile/core";
 /**
  * Bearer token or token factory used for Relayfile API requests.
@@ -104,6 +104,12 @@ export declare class RelayFileClient {
     writeFile(input: WriteFileInput): Promise<WriteQueuedResponse>;
     mergeFile(input: MergeFileInput): Promise<MergeFileResponse>;
     bulkWrite(input: BulkWriteInput): Promise<BulkWriteResponse>;
+    issueCheckpointSeal(input: IssueCheckpointSealInput): Promise<CheckpointSeal>;
+    consumeCheckpointSeal(input: ConsumeCheckpointSealInput): Promise<ConsumedCheckpointSeal>;
+    recoverConsumedCheckpointSeal(input: RecoverConsumedCheckpointSealInput): Promise<ConsumedCheckpointSeal>;
+    verifyCheckpointSeal(input: VerifyCheckpointSealInput): Promise<ConsumedCheckpointSeal>;
+    handbackCheckpointSeal(input: HandbackCheckpointSealInput): Promise<CheckpointSealOwnership>;
+    resumeCheckpointSeal(input: ResumeCheckpointSealInput): Promise<CheckpointSealOwnership>;
     deleteFile(input: DeleteFileInput): Promise<WriteQueuedResponse>;
     createFork(input: CreateForkInput): Promise<ForkHandle>;
     discardFork(input: DiscardForkInput): Promise<void>;
@@ -130,6 +136,8 @@ export declare class RelayFileClient {
     getBackendStatus(correlationId?: string, signal?: AbortSignal): Promise<BackendStatusResponse>;
     getAdminIngressStatus(optionsOrCorrelationId?: GetAdminIngressStatusOptions | string, signal?: AbortSignal): Promise<AdminIngressStatusResponse>;
     getAdminSyncStatus(optionsOrCorrelationId?: GetAdminSyncStatusOptions | string, signal?: AbortSignal): Promise<AdminSyncStatusResponse>;
+    getAdminCheckpointSealRetention(options?: GetAdminCheckpointSealRetentionOptions): Promise<CheckpointSealRetentionSummary>;
+    reconcileAdminCheckpointSealSource(input: ReconcileAdminCheckpointSealSourceInput): Promise<CheckpointSealRetentionRecord>;
     getSyncStatus(workspaceId: string, options?: GetSyncStatusOptions): Promise<SyncStatusResponse>;
     /**
      * Wait until a provider is safe to read from the data plane.

package/dist/client.js

@@ -1317,6 +1317,107 @@ export class RelayFileClient {
         }
         return result;
     }
+    async issueCheckpointSeal(input) {
+        return this.request({
+            method: "POST",
+            path: `/v1/workspaces/${encodeURIComponent(input.workspaceId)}/sync/checkpoint-seals`,
+            correlationId: input.correlationId,
+            body: {
+                root: input.root,
+                sessionId: input.sessionId,
+                generation: input.generation,
+                expectedDigest: input.expectedDigest,
+                issuanceIdempotencyKey: input.issuanceIdempotencyKey,
+                ttlSeconds: input.ttlSeconds
+            },
+            signal: input.signal
+        });
+    }
+    async consumeCheckpointSeal(input) {
+        return this.request({
+            method: "POST",
+            path: `/v1/workspaces/${encodeURIComponent(input.workspaceId)}/sync/checkpoint-seals/consume`,
+            correlationId: input.correlationId,
+            body: {
+                sealToken: input.sealToken,
+                root: input.root,
+                sessionId: input.sessionId,
+                generation: input.generation,
+                consumerIdempotencyKey: input.consumerIdempotencyKey
+            },
+            signal: input.signal
+        });
+    }
+    async recoverConsumedCheckpointSeal(input) {
+        return this.request({
+            method: "POST",
+            path: `/v1/workspaces/${encodeURIComponent(input.workspaceId)}/sync/checkpoint-seals/recover-consume`,
+            correlationId: input.correlationId,
+            body: {
+                root: input.root,
+                sessionId: input.sessionId,
+                generation: input.generation,
+                consumerIdempotencyKey: input.consumerIdempotencyKey
+            },
+            signal: input.signal
+        });
+    }
+    async verifyCheckpointSeal(input) {
+        const receipt = input.receipt;
+        return this.request({
+            method: "POST",
+            path: `/v1/workspaces/${encodeURIComponent(input.workspaceId)}/sync/checkpoint-seals/verify`,
+            correlationId: input.correlationId,
+            body: {
+                sealId: receipt.sealId,
+                root: receipt.root,
+                sessionId: receipt.sessionId,
+                generation: receipt.generation,
+                digest: receipt.digest,
+                workspaceRevision: receipt.workspaceRevision,
+                eventCursor: receipt.eventCursor,
+                issuedAt: receipt.issuedAt,
+                expiresAt: receipt.expiresAt,
+                consumedAt: receipt.consumedAt
+            },
+            signal: input.signal
+        });
+    }
+    async handbackCheckpointSeal(input) {
+        const receipt = input.receipt;
+        return this.request({
+            method: "POST",
+            path: `/v1/workspaces/${encodeURIComponent(input.workspaceId)}/sync/checkpoint-seals/handback`,
+            correlationId: input.correlationId,
+            body: {
+                phase: input.phase,
+                sealId: receipt.sealId,
+                root: receipt.root,
+                sessionId: receipt.sessionId,
+                generation: receipt.generation,
+                consumedAt: receipt.consumedAt,
+                consumerIdempotencyKey: input.consumerIdempotencyKey,
+                handbackIdempotencyKey: input.handbackIdempotencyKey,
+                expectedDigest: input.expectedDigest
+            },
+            signal: input.signal
+        });
+    }
+    async resumeCheckpointSeal(input) {
+        return this.request({
+            method: "POST",
+            path: `/v1/workspaces/${encodeURIComponent(input.workspaceId)}/sync/checkpoint-seals/resume`,
+            correlationId: input.correlationId,
+            body: {
+                sealToken: input.sealToken,
+                root: input.root,
+                sessionId: input.sessionId,
+                generation: input.generation,
+                resumeIdempotencyKey: input.resumeIdempotencyKey
+            },
+            signal: input.signal
+        });
+    }
     async deleteFile(input) {
         const query = buildQuery({ path: input.path, forkId: input.forkId });
         const result = await this.request({
@@ -1716,6 +1817,32 @@ export class RelayFileClient {
             signal: options.signal
         });
     }
+    async getAdminCheckpointSealRetention(options = {}) {
+        const query = buildQuery({ workspaceId: options.workspaceId });
+        return this.request({
+            method: "GET",
+            path: `/v1/admin/checkpoint-seals${query}`,
+            correlationId: options.correlationId,
+            signal: options.signal
+        });
+    }
+    async reconcileAdminCheckpointSealSource(input) {
+        return this.request({
+            method: "POST",
+            path: `/v1/admin/checkpoint-seals/${encodeURIComponent(input.sealId)}/reconcile-source`,
+            correlationId: input.correlationId,
+            body: {
+                workspaceId: input.workspaceId,
+                root: input.root,
+                sessionId: input.sessionId,
+                generation: input.generation,
+                expectedOwnershipStatus: input.expectedOwnershipStatus,
+                reconciliationIdempotencyKey: input.reconciliationIdempotencyKey,
+                confirmSourceReady: input.confirmSourceReady
+            },
+            signal: input.signal
+        });
+    }
     async getSyncStatus(workspaceId, options = {}) {
         const query = buildQuery({ provider: options.provider });
         return this.request({

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export type { RelayFileReadCacheOptions } from "./types.js";
 export { RelayfileSetup, RELAYFILE_SDK_VERSION, WorkspaceHandle } from "./setup.js";
 export { type RelayfileCloudLoginOptions, type RelayfileCloudTokenSet, type RelayfileCloudTokenSetupOptions } from "./cloud-login.js";
 export { CloudAbortError, CloudApiError, CloudTimeoutError, InvalidLocalDirError, InvalidMountModeError, InvalidRemotePathError, IntegrationConnectionTimeoutError, MalformedCloudResponseError, MissingConnectionIdError, MountModeUnavailableError, MountMultiPathUnsupportedError, MountReadyTimeoutError, MountSessionInputError, ProviderNotConnectedError, ProviderNotReadyError, RelayfileSetupError, UnknownProviderError } from "./setup-errors.js";
-export { type EnsureMountedWorkspaceInput, WORKSPACE_INTEGRATION_PROVIDERS, type AgentWorkspaceInvite, type AgentWorkspaceInviteOptions, type AgentWorkspaceScopedInviteOptions, type ConnectIntegrationOptions, type ConnectIntegrationResult, type CreateWorkspaceOptions, type JoinWorkspaceOptions, type MountLauncher, type MountLauncherEvent, type MountLauncherInstance, type MountLauncherStart, type MountLocalLayout, type MountMode, type MountSessionRequest, type MountSessionResponse, type MountSessionResult, type MountSyncMode, type MountSupervisorEvent, type MountedWorkspaceHandle, type MountedWorkspaceStatus, type MountWorkspaceInput, type ReadMountedWorkspaceStatusInput, type RelayfileSetupOptions, type RelayfileSetupRetryOptions, type WaitForConnectionOptions, type WorkspaceInfo, type WorkspaceIntegrationProvider, type WorkspaceMountEnv, type WorkspaceMountEnvOptions, type WorkspacePermissions } from "./setup-types.js";
+export { type EnsureMountedWorkspaceInput, WORKSPACE_INTEGRATION_PROVIDERS, type AgentWorkspaceInvite, type AgentWorkspaceInviteOptions, type AgentWorkspaceScopedInviteOptions, type ConnectIntegrationOptions, type ConnectIntegrationResult, type CheckpointAndSealInput, type CreateWorkspaceOptions, type JoinWorkspaceOptions, type MountLauncher, type MountLauncherEvent, type MountLauncherInstance, type MountLauncherStart, type MountLocalLayout, type MountMode, type MountSessionRequest, type MountSessionResponse, type MountSessionResult, type MountSyncMode, type MountSupervisorEvent, type MountedWorkspaceHandle, type MountedWorkspaceStatus, type MountWorkspaceInput, type ReadMountedWorkspaceStatusInput, type RelayfileSetupOptions, type RelayfileSetupRetryOptions, type WaitForConnectionOptions, type WorkspaceInfo, type WorkspaceIntegrationProvider, type WorkspaceMountEnv, type WorkspaceMountEnvOptions, type WorkspacePermissions } from "./setup-types.js";
 export { RelayFileSync, type RelayFileSyncOptions, type RelayFileSyncPong, type RelayFileSyncReconnectOptions, type RelayFileSyncSocket, type RelayFileSyncStart, type RelayFileSyncState, type RelayFileSyncTokenProvider } from "./sync.js";
 export { onWrite, pathMatches, type OnWriteClient, type OnWriteHandler, type OnWriteHandlerError, type OnWriteOptions } from "./onWrite.js";
 export { InvalidStateError, MergeConflictError, ParentMovedError, PayloadTooLargeError, QueueFullError, RelayFileApiError, RevisionConflictError } from "./errors.js";
@@ -13,7 +13,7 @@ export type { ConnectCapableProvider, ConnectConnectionStatus, ConnectSession, C
 export { supportsConnect } from "./connection.js";
 export { SelfHostConnect } from "./self-host-connect.js";
 export type { SelfHostConnectOptions, SelfHostConnectResult, StartSelfHostConnectOptions, WaitForSelfHostConnectionOptions } from "./self-host-connect.js";
-export type { AckResponse, AcceptDurableSubscriptionDeliveryInput, AckWritebackInput, AckWritebackDraftDisposition, AckWritebackResponse, AdminIngressAlert, AdminIngressAlertProfile, AdminIngressEffectiveAlertProfile, AdminIngressAlertSeverity, AdminIngressAlertThresholds, AdminIngressAlertTotals, AdminIngressAlertType, AdminIngressStatusResponse, AdminSyncAlert, AdminSyncAlertSeverity, AdminSyncAlertThresholds, AdminSyncAlertTotals, AdminSyncAlertType, AdminSyncStatusResponse, BackendStatusResponse, BulkWriteFile, BulkWriteInput, BulkWriteResponse, CancelDurableResourceSubscriptionOptions, ChangeLogQueryResult, ChangeEvent, ChangeEventActor, ChangeEventResource, ChangeEventSummary, ChangeStreamConnection, ChangeStreamConnectionOptions, ClaimDurableSubscriptionDeliveriesInput, CommitForkInput, CommitForkResponse, ConflictErrorResponse, CreateOrRenewDurableResourceSubscriptionInput, CreateForkInput, ContentIdentity, DeleteFileInput, DeleteWebhookOptions, DeadLetterFeedResponse, DeadLetterItem, DigestBullet, DigestContext, DigestHandler, DigestSection, DigestWindow, DiscardForkInput, DurableResourceSubscription, DurableResourceSubscriptionListResponse, DurableResourceSubscriptionStatus, DurableSubscriptionDelivery, DurableSubscriptionDeliveryListResponse, DurableSubscriptionDeliveryResponse, DurableSubscriptionDeliveryStatus, DurableSubscriptionEvent, ErrorResponse, EventSummary, EventFeedResponse, ExportFormat, ExportJsonResponse, ExportOptions, FileQueryItem, FileQueryResponse, FileReadResponse, FileSemantics, FileWriteRequest, FilesystemEvent, FilesystemEventType, EventOrigin, Expansion, ExpansionLevel, GetEventsOptions, GetAdminSyncStatusOptions, GetAdminIngressStatusOptions, GetOperationsOptions, GetSyncDeadLettersOptions, GetSyncIngressStatusOptions, GetSyncStatusOptions, WaitForDataOptions, GetWebhookDeadLettersOptions, IngestWebhookInput, LayoutManifest, LayoutManifestAlias, LayoutManifestResource, ListWebhooksOptions, ListDurableResourceSubscriptionsOptions, ListTreeOptions, MergeConflictDetail, MergeFileInput, MergeFileResponse, OperationFeedResponse, OperationStatus, OperationStatusResponse, QueuedResponse, QueryFilesOptions, RebaseConflict, RebaseForkInput, RebaseForkResponse, ReadFileInput, RegisterWebhookInput, RegisterWebhookResponse, ReplayOptions, ResourceAtEventResult, SummaryExpansion, FullExpansion, DiffExpansion, ThreadExpansion, RelayFileJwtClaims, SubscribeOptions, Subscription, SyncIngressStatusResponse, SyncProviderStatus, SyncProviderStatusState, SyncRefreshRequest, SyncStatusResponse, SweepWritebackDraftsInput, SweepWritebackDraftsResponse, TreeEntry, TreeResponse, WebhookDeliveryDeadLetterFeedResponse, WebhookDeliveryDeadLetterItem, WebhookSubscription, WebhookSubscriptionHealth, WritebackActionType, WritebackDeadLetterError, WritebackDeadLetterErrorCode, WritebackListState, WritebackState, WritebackItem, WritebackItemDetail, WritebackSchemaRef, WriteFileInput, WriteQueuedResponse } from "./types.js";
+export type { AckResponse, AcceptDurableSubscriptionDeliveryInput, AckWritebackInput, AckWritebackDraftDisposition, AckWritebackResponse, AdminIngressAlert, AdminIngressAlertProfile, AdminIngressEffectiveAlertProfile, AdminIngressAlertSeverity, AdminIngressAlertThresholds, AdminIngressAlertTotals, AdminIngressAlertType, AdminIngressStatusResponse, AdminSyncAlert, AdminSyncAlertSeverity, AdminSyncAlertThresholds, AdminSyncAlertTotals, AdminSyncAlertType, AdminSyncStatusResponse, BackendStatusResponse, BulkWriteFile, BulkWriteInput, BulkWriteResponse, CheckpointSeal, CheckpointSealOwnershipStatus, CheckpointSealRetentionRecord, CheckpointSealRetentionSummary, GetAdminCheckpointSealRetentionOptions, ReconcileAdminCheckpointSealSourceInput, ConsumedCheckpointSeal, IssueCheckpointSealInput, ConsumeCheckpointSealInput, RecoverConsumedCheckpointSealInput, VerifyCheckpointSealInput, CheckpointSealOwnership, HandbackCheckpointSealInput, ResumeCheckpointSealInput, CancelDurableResourceSubscriptionOptions, ChangeLogQueryResult, ChangeEvent, ChangeEventActor, ChangeEventResource, ChangeEventSummary, ChangeStreamConnection, ChangeStreamConnectionOptions, ClaimDurableSubscriptionDeliveriesInput, CommitForkInput, CommitForkResponse, ConflictErrorResponse, CreateOrRenewDurableResourceSubscriptionInput, CreateForkInput, ContentIdentity, DeleteFileInput, DeleteWebhookOptions, DeadLetterFeedResponse, DeadLetterItem, DigestBullet, DigestContext, DigestHandler, DigestSection, DigestWindow, DiscardForkInput, DurableResourceSubscription, DurableResourceSubscriptionListResponse, DurableResourceSubscriptionStatus, DurableSubscriptionDelivery, DurableSubscriptionDeliveryListResponse, DurableSubscriptionDeliveryResponse, DurableSubscriptionDeliveryStatus, DurableSubscriptionEvent, ErrorResponse, EventSummary, EventFeedResponse, ExportFormat, ExportJsonResponse, ExportOptions, FileQueryItem, FileQueryResponse, FileReadResponse, FileSemantics, FileWriteRequest, FilesystemEvent, FilesystemEventType, EventOrigin, Expansion, ExpansionLevel, GetEventsOptions, GetAdminSyncStatusOptions, GetAdminIngressStatusOptions, GetOperationsOptions, GetSyncDeadLettersOptions, GetSyncIngressStatusOptions, GetSyncStatusOptions, WaitForDataOptions, GetWebhookDeadLettersOptions, IngestWebhookInput, LayoutManifest, LayoutManifestAlias, LayoutManifestResource, ListWebhooksOptions, ListDurableResourceSubscriptionsOptions, ListTreeOptions, MergeConflictDetail, MergeFileInput, MergeFileResponse, OperationFeedResponse, OperationStatus, OperationStatusResponse, QueuedResponse, QueryFilesOptions, RebaseConflict, RebaseForkInput, RebaseForkResponse, ReadFileInput, RegisterWebhookInput, RegisterWebhookResponse, ReplayOptions, ResourceAtEventResult, SummaryExpansion, FullExpansion, DiffExpansion, ThreadExpansion, RelayFileJwtClaims, SubscribeOptions, Subscription, SyncIngressStatusResponse, SyncProviderStatus, SyncProviderStatusState, SyncRefreshRequest, SyncStatusResponse, SweepWritebackDraftsInput, SweepWritebackDraftsResponse, TreeEntry, TreeResponse, WebhookDeliveryDeadLetterFeedResponse, WebhookDeliveryDeadLetterItem, WebhookSubscription, WebhookSubscriptionHealth, WritebackActionType, WritebackDeadLetterError, WritebackDeadLetterErrorCode, WritebackListState, WritebackState, WritebackItem, WritebackItemDetail, WritebackSchemaRef, WriteFileInput, WriteQueuedResponse } from "./types.js";
 export type { ForkHandle, ForkOptions } from "@relayfile/core";
 export type { WriteEvent, WriteEventActor, WriteEventOperation, WriteEventSource } from "@relayfile/core";
 export { WritebackConsumer } from "./writeback-consumer.js";

package/dist/mount-launcher.js

@@ -11,6 +11,8 @@ const DEFAULT_READY_POLL_INTERVAL_MS = 250;
 const DEFAULT_STOP_TIMEOUT_MS = 10_000;
 const LOG_ROTATION_MAX_BYTES = 10 * 1024 * 1024;
 const LOG_ROTATION_FILES = 3;
+const DEFAULT_CHECKPOINT_TIMEOUT_MS = 30_000;
+const MAX_CHECKPOINT_OUTPUT_BYTES = 1024 * 1024;
 const FUSE_UNAVAILABLE_SIGNATURE = "fuse mode is not available in this build";
 export const defaultMountLauncher = createDefaultMountLauncher();
 export function createDefaultMountLauncher(options = {}) {
@@ -81,6 +83,10 @@ async function startRelayfileMount(input, options) {
         outputBuffer,
         input,
         localDir: mountLocalDir,
+        command,
+        effectiveEnv,
+        cwd: input.cwd ?? mountLocalDir,
+        spawnImpl: options.spawnImpl ?? spawn,
         now: options.now ?? Date.now,
         readyPollIntervalMs: options.readyPollIntervalMs ?? DEFAULT_READY_POLL_INTERVAL_MS
     });
@@ -96,9 +102,17 @@ class RelayfileMountProcessInstance {
     localDir;
     now;
     readyPollIntervalMs;
+    command;
+    effectiveEnv;
+    cwd;
+    spawnImpl;
     exited = false;
     stopping;
     readyResolved = false;
+    checkpointPromise;
+    get stopped() {
+        return this.exited;
+    }
     constructor(input) {
         this.child = input.child;
         this.logStream = input.logStream;
@@ -106,6 +120,10 @@ class RelayfileMountProcessInstance {
         this.outputBuffer = input.outputBuffer;
         this.input = input.input;
         this.localDir = input.localDir;
+        this.command = input.command;
+        this.effectiveEnv = input.effectiveEnv;
+        this.cwd = input.cwd;
+        this.spawnImpl = input.spawnImpl;
         this.pid = input.child.pid ?? undefined;
         this.now = input.now;
         this.readyPollIntervalMs = input.readyPollIntervalMs;
@@ -136,6 +154,46 @@ class RelayfileMountProcessInstance {
         }
         await this.stopping;
     }
+    async checkpointAndSeal(input) {
+        this.validateCheckpointPreconditions(input);
+        if (!this.checkpointPromise) {
+            this.checkpointPromise = this.performCheckpointAndSeal(input);
+        }
+        return this.checkpointPromise;
+    }
+    validateCheckpointPreconditions(input) {
+        validateCheckpointInput(input);
+        if (normalizeMountMode(this.effectiveEnv.RELAYFILE_MOUNT_MODE) !== "poll") {
+            throw new RelayfileSetupError("checkpointAndSeal currently requires a poll-mode mount; a FUSE mount must remain running until daemon checkpoint IPC is available.", "checkpoint_seal_mode_unavailable");
+        }
+        if (normalizeMountSyncMode(this.effectiveEnv.RELAYFILE_MOUNT_SYNC_MODE) === "pull-only") {
+            throw new RelayfileSetupError("checkpointAndSeal cannot drain a pull-only mount.", "checkpoint_seal_mode_unavailable");
+        }
+        if (normalizeRemotePath(this.effectiveEnv.RELAYFILE_REMOTE_PATH ?? "/") !== "/") {
+            throw new RelayfileSetupError("checkpointAndSeal v1 requires a full-root (/) mount.", "checkpoint_seal_root_unavailable");
+        }
+        const scopes = (this.effectiveEnv.RELAYFILE_MOUNT_SCOPES ?? "")
+            .split(/\s+/)
+            .map((scope) => scope.trim())
+            .filter(Boolean);
+        if (!scopeGrants(scopes, "sync", "trigger") ||
+            !scopeGrants(scopes, "ops", "read") ||
+            !scopeGrantsFullRoot(scopes, "read") ||
+            !scopeGrantsFullRoot(scopes, "write")) {
+            throw new RelayfileSetupError("checkpointAndSeal requires sync:trigger, ops:read, and full-root fs:read/fs:write scopes.", "checkpoint_seal_scope_unavailable");
+        }
+    }
+    async performCheckpointAndSeal(input) {
+        await this.ready;
+        await this.stop();
+        return runCheckpointSealProcess({
+            command: this.command,
+            cwd: this.cwd,
+            env: this.effectiveEnv,
+            spawnImpl: this.spawnImpl,
+            input
+        });
+    }
     async waitForReady() {
         const startedAt = this.now();
         const timeoutAt = startedAt + this.input.readyTimeoutMs;
@@ -189,6 +247,178 @@ class RelayfileMountProcessInstance {
         await unlinkIfExists(this.pidPath);
     }
 }
+async function runCheckpointSealProcess(input) {
+    const { sessionId, generation, timeoutMs, ttlSeconds } = validateCheckpointInput(input.input);
+    const workspaceId = input.env.RELAYFILE_WORKSPACE?.trim() ?? "";
+    const root = normalizeRemotePath(input.env.RELAYFILE_REMOTE_PATH);
+    const args = [
+        "--checkpoint-and-seal",
+        "--checkpoint-session", sessionId,
+        "--checkpoint-generation", String(generation),
+        "--checkpoint-seal-ttl", `${ttlSeconds}s`,
+        "--timeout", `${timeoutMs}ms`
+    ];
+    const child = input.spawnImpl(input.command, args, {
+        cwd: input.cwd,
+        env: input.env,
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    return new Promise((resolve, reject) => {
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        let timer;
+        const finish = (error, seal) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            input.input.signal?.removeEventListener("abort", onAbort);
+            if (error)
+                reject(error);
+            else
+                resolve(seal);
+        };
+        const append = (current, chunk) => {
+            const next = current + (Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk));
+            if (Buffer.byteLength(next) > MAX_CHECKPOINT_OUTPUT_BYTES) {
+                child.kill("SIGKILL");
+                finish(new RelayfileSetupError("relayfile-mount checkpoint output exceeded 1 MiB.", "checkpoint_seal_invalid_output"));
+            }
+            return next;
+        };
+        child.stdout?.on("data", (chunk) => { stdout = append(stdout, chunk); });
+        child.stderr?.on("data", (chunk) => { stderr = append(stderr, chunk); });
+        child.once("error", (error) => {
+            finish(new RelayfileSetupError(`relayfile-mount checkpoint failed to start: ${error.message}`, "checkpoint_seal_failed"));
+        });
+        child.once("exit", (code, signal) => {
+            if (settled)
+                return;
+            if (code !== 0) {
+                const detail = stderr.trim().slice(-2_000);
+                finish(new RelayfileSetupError(`relayfile-mount checkpoint failed (${signal ?? `exit ${code ?? "unknown"}`})${detail ? `: ${detail}` : ""}`, "checkpoint_seal_failed"));
+                return;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(stdout.trim());
+            }
+            catch {
+                finish(new RelayfileSetupError("relayfile-mount returned malformed checkpoint JSON.", "checkpoint_seal_invalid_output"));
+                return;
+            }
+            try {
+                finish(undefined, validateCheckpointSeal(parsed, workspaceId, root, sessionId, generation));
+            }
+            catch (error) {
+                finish(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+        const onAbort = () => {
+            child.kill("SIGKILL");
+            finish(new CloudAbortError("checkpointAndSeal"));
+        };
+        input.input.signal?.addEventListener("abort", onAbort, { once: true });
+        timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            finish(new RelayfileSetupError(`checkpointAndSeal timed out after ${timeoutMs}ms.`, "checkpoint_seal_timeout"));
+        }, timeoutMs);
+        timer.unref?.();
+    });
+}
+function validateCheckpointInput(input) {
+    const sessionId = typeof input.sessionId === "string" ? input.sessionId.trim() : "";
+    const generation = input.generation;
+    const timeoutMs = input.timeoutMs ?? DEFAULT_CHECKPOINT_TIMEOUT_MS;
+    const ttlSeconds = input.ttlSeconds ?? 60;
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/.test(sessionId)) {
+        throw new RelayfileSetupError("checkpointAndSeal requires a valid sessionId.", "checkpoint_seal_invalid_input");
+    }
+    if (!Number.isSafeInteger(generation) || generation <= 0 ||
+        !Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 ||
+        !Number.isSafeInteger(ttlSeconds) || ttlSeconds <= 0 || ttlSeconds > 300) {
+        throw new RelayfileSetupError("checkpointAndSeal requires positive safe generation/timeout values and ttlSeconds <= 300.", "checkpoint_seal_invalid_input");
+    }
+    if (input.signal?.aborted) {
+        throw new CloudAbortError("checkpointAndSeal");
+    }
+    return { sessionId, generation, timeoutMs, ttlSeconds };
+}
+function scopeGrants(scopes, resource, action) {
+    const bare = `${resource}:${action}`;
+    return scopes.some((scope) => {
+        if (scope === bare)
+            return true;
+        const [plane, grantedResource, grantedAction] = scope.split(":", 4);
+        return ((plane === "relayfile" || plane === "*") &&
+            (grantedResource === resource || grantedResource === "*") &&
+            (grantedAction === action || grantedAction === "*"));
+    });
+}
+function scopeGrantsFullRoot(scopes, action) {
+    const relevantNarrowScopes = [];
+    for (const scope of scopes) {
+        const parsed = parseStructuredScope(scope);
+        if (!parsed)
+            continue;
+        const { plane, resource, action: grantedAction, path: scopePath } = parsed;
+        const actionMatches = grantedAction === action ||
+            grantedAction === "*" ||
+            grantedAction === "manage";
+        if (!actionMatches)
+            continue;
+        if ((plane === "relayfile" || plane === "*") &&
+            (resource === "fs" || resource === "*")) {
+            if (scopePath === undefined || scopePath.trim() === "*")
+                return true;
+            relevantNarrowScopes.push(scopePath.trim());
+            continue;
+        }
+        if (plane === "workspace") {
+            if (scopePath === undefined || scopePath.trim() === "*")
+                return true;
+            relevantNarrowScopes.push(scopePath.trim());
+        }
+    }
+    if (relevantNarrowScopes.some((scopePath) => scopePath === "/**")) {
+        return true;
+    }
+    return relevantNarrowScopes.length === 0 && scopes.includes(`fs:${action}`);
+}
+function parseStructuredScope(scope) {
+    const first = scope.indexOf(":");
+    const second = first < 0 ? -1 : scope.indexOf(":", first + 1);
+    if (first < 1 || second <= first + 1)
+        return null;
+    const third = scope.indexOf(":", second + 1);
+    return {
+        plane: scope.slice(0, first),
+        resource: scope.slice(first + 1, second),
+        action: scope.slice(second + 1, third < 0 ? undefined : third),
+        path: third < 0 ? undefined : scope.slice(third + 1)
+    };
+}
+function validateCheckpointSeal(value, workspaceId, root, sessionId, generation) {
+    if (!value || typeof value !== "object") {
+        throw new RelayfileSetupError("relayfile-mount returned an invalid checkpoint seal.", "checkpoint_seal_invalid_output");
+    }
+    const seal = value;
+    const strings = [seal.sealId, seal.sealToken, seal.workspaceId, seal.root, seal.digest, seal.workspaceRevision, seal.eventCursor, seal.issuedAt, seal.expiresAt];
+    if (strings.some((field) => typeof field !== "string") ||
+        seal.sealToken.trim() === "" ||
+        seal.workspaceId !== workspaceId ||
+        normalizeRemotePath(seal.root) !== root ||
+        seal.sessionId !== sessionId ||
+        seal.generation !== generation ||
+        !seal.digest.startsWith("sha256:") ||
+        Number.isNaN(Date.parse(seal.issuedAt)) ||
+        Number.isNaN(Date.parse(seal.expiresAt))) {
+        throw new RelayfileSetupError("relayfile-mount returned an unbound or incomplete checkpoint seal.", "checkpoint_seal_invalid_output");
+    }
+    return seal;
+}
 function pipeChildOutput(child, logStream, outputBuffer, input) {
     const appendChunk = (streamName, chunk) => {
         const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");

package/dist/setup-types.d.ts

@@ -1,5 +1,6 @@
 import type { WorkspaceHandle } from "./setup.js";
 import type { AccessTokenProvider } from "./client.js";
+import type { CheckpointSeal } from "./types.js";
 export declare const WORKSPACE_INTEGRATION_PROVIDERS: readonly ["github", "slack-sage", "slack-my-senior-dev", "slack-nightcto", "notion", "linear"];
 export type WorkspaceIntegrationProvider = (typeof WORKSPACE_INTEGRATION_PROVIDERS)[number];
 export interface WorkspacePermissions {
@@ -121,6 +122,13 @@ export interface MountedWorkspaceStatus {
     pendingWriteback?: number;
     pendingConflicts?: number;
 }
+export interface CheckpointAndSealInput {
+    sessionId: string;
+    generation: number;
+    timeoutMs?: number;
+    ttlSeconds?: number;
+    signal?: AbortSignal;
+}
 export interface ReadMountedWorkspaceStatusInput {
     localDir: string;
     workspaceId: string;
@@ -144,6 +152,7 @@ export interface MountedWorkspaceHandle {
     readonly suggestedRefreshAt: string | null;
     env(): Record<string, string>;
     status(): Promise<MountedWorkspaceStatus>;
+    checkpointAndSeal(input: CheckpointAndSealInput): Promise<CheckpointSeal>;
     stop(): Promise<void>;
 }
 export interface MountSupervisorEvent {
@@ -166,12 +175,26 @@ export interface MountLauncherStart {
     onEvent?: (event: MountLauncherEvent) => void;
     background?: boolean;
 }
-export interface MountLauncherInstance {
+interface MountLauncherInstanceBase {
     pid?: number;
     ready: Promise<void>;
     status(): Promise<MountedWorkspaceStatus>;
     stop(): Promise<void>;
 }
+/** A launcher without checkpoint support may report stop state optionally. */
+export interface BasicMountLauncherInstance extends MountLauncherInstanceBase {
+    readonly stopped?: boolean;
+    checkpointAndSeal?: never;
+}
+/**
+ * Checkpoint-capable launchers must report whether the physical daemon stopped.
+ * The SDK uses this signal to retire a failed checkpoint safely.
+ */
+export interface CheckpointCapableMountLauncherInstance extends MountLauncherInstanceBase {
+    readonly stopped: boolean;
+    checkpointAndSeal(input: CheckpointAndSealInput): Promise<CheckpointSeal>;
+}
+export type MountLauncherInstance = BasicMountLauncherInstance | CheckpointCapableMountLauncherInstance;
 export interface MountLauncher {
     start(input: MountLauncherStart): Promise<MountLauncherInstance>;
 }
@@ -239,3 +262,4 @@ export interface AgentWorkspaceInvite {
     createdAt?: string;
     name?: string;
 }
+export {};

package/dist/setup.js

@@ -21,6 +21,11 @@ const DEFAULT_MOUNT_SYNC_MODE = "mirror";
 const DEFAULT_MOUNT_HEALTH_INTERVAL_MS = 30_000;
 const DEFAULT_MOUNT_REFRESH_RETRY_BASE_MS = 1_000;
 const DEFAULT_MOUNT_REFRESH_RETRY_MAX_MS = 60_000;
+const confirmedMountStop = Symbol("confirmedMountStop");
+function hasConfirmedMountStop(handle) {
+    const candidate = handle;
+    return candidate[confirmedMountStop]?.() === true;
+}
 const TOKEN_REFRESH_AGE_MS = 55 * 60 * 1000;
 const nodeOnlyMountLauncher = {
     async start() {
@@ -752,6 +757,8 @@ class MountedWorkspaceHandleImpl {
     readStatus;
     readySnapshot = true;
     stopPromise;
+    checkpointPromise;
+    checkpointStopped = false;
     constructor(input) {
         this.mountSession = input.mountSession;
         this.workspaceId = input.mountSession.workspaceId;
@@ -803,6 +810,41 @@ class MountedWorkspaceHandleImpl {
         }
         await this.stopPromise;
     }
+    async checkpointAndSeal(input) {
+        if (!this.checkpointPromise) {
+            if (this.probeOnly || !this.launcherInstance?.checkpointAndSeal) {
+                throw new RelayfileSetupError("checkpointAndSeal requires a locally managed relayfile-mount launcher.", "checkpoint_seal_unavailable");
+            }
+            if (typeof this.launcherInstance.stopped !== "boolean") {
+                throw new RelayfileSetupError("checkpointAndSeal requires a launcher that reports physical stop state.", "checkpoint_seal_launcher_contract_invalid");
+            }
+            this.checkpointPromise = this.performCheckpointAndSeal(input);
+        }
+        return this.checkpointPromise;
+    }
+    [confirmedMountStop]() {
+        return this.checkpointStopped;
+    }
+    async performCheckpointAndSeal(input) {
+        try {
+            const seal = await this.launcherInstance.checkpointAndSeal(input);
+            this.checkpointStopped = true;
+            this.readySnapshot = false;
+            return seal;
+        }
+        catch (error) {
+            if (this.launcherInstance?.stopped === true) {
+                this.checkpointStopped = true;
+                this.readySnapshot = false;
+            }
+            else {
+                // A launcher precondition can reject before touching the daemon. Keep
+                // both readiness and retryability when no physical stop was confirmed.
+                this.checkpointPromise = undefined;
+            }
+            throw error;
+        }
+    }
     async performStop() {
         this.readySnapshot = false;
         if (this.probeOnly || !this.launcherInstance) {
@@ -846,6 +888,16 @@ class SharedMountedWorkspaceHandle {
     status() {
         return this.mounted.status();
     }
+    async checkpointAndSeal(input) {
+        try {
+            return await this.mounted.checkpointAndSeal(input);
+        }
+        finally {
+            if (hasConfirmedMountStop(this.mounted)) {
+                this.onStopped();
+            }
+        }
+    }
     async stop() {
         if (!this.stopPromise)
             this.stopPromise = this.performStop();
@@ -872,6 +924,8 @@ class SupervisedMountedWorkspaceHandle {
     refreshPromise;
     stopPromise;
     stopped = false;
+    checkpointing = false;
+    supervisorEpoch = 0;
     supervisorReady = true;
     refreshAttempts = 0;
     constructor(input) {
@@ -928,8 +982,52 @@ class SupervisedMountedWorkspaceHandle {
             this.stopPromise = this.performStop();
         await this.stopPromise;
     }
+    async checkpointAndSeal(input) {
+        this.checkpointing = true;
+        this.supervisorEpoch += 1;
+        this.supervisorReady = false;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        await this.refreshPromise?.catch(() => { });
+        try {
+            const seal = await this.mounted.checkpointAndSeal(input);
+            this.retireAfterCheckpointStop();
+            return seal;
+        }
+        catch (error) {
+            if (hasConfirmedMountStop(this.mounted)) {
+                this.retireAfterCheckpointStop();
+            }
+            else {
+                // Validation/mode failures occur before the daemon is stopped. Restore
+                // the supervisor with a fresh epoch and leave the shared ensured
+                // handle reusable. Work from the fenced epoch cannot replace it.
+                this.checkpointing = false;
+                this.supervisorEpoch += 1;
+                this.supervisorReady = this.mounted.ready;
+                this.schedule();
+            }
+            throw error;
+        }
+    }
+    [confirmedMountStop]() {
+        return this.stopped && hasConfirmedMountStop(this.mounted);
+    }
+    retireAfterCheckpointStop() {
+        this.stopped = true;
+        this.checkpointing = false;
+        this.supervisorEpoch += 1;
+        this.supervisorReady = false;
+        this.signal?.removeEventListener("abort", this.handleAbort);
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+    }
     async performStop() {
         this.stopped = true;
+        this.checkpointing = false;
+        this.supervisorEpoch += 1;
         this.supervisorReady = false;
         this.signal?.removeEventListener("abort", this.handleAbort);
         if (this.timer)
@@ -942,8 +1040,9 @@ class SupervisedMountedWorkspaceHandle {
         void this.stop();
     };
     schedule(delayOverrideMs) {
-        if (this.stopped || this.timer)
+        if (this.stopped || this.checkpointing || this.timer)
             return;
+        const epoch = this.supervisorEpoch;
         const suggestedRefreshAtMs = Date.parse(this.mounted.suggestedRefreshAt ?? "");
         const untilRefresh = Number.isFinite(suggestedRefreshAtMs)
             ? Math.max(0, suggestedRefreshAtMs - Date.now())
@@ -951,20 +1050,27 @@ class SupervisedMountedWorkspaceHandle {
         const delayMs = delayOverrideMs ?? Math.min(this.healthCheckIntervalMs, untilRefresh);
         this.timer = setTimeout(() => {
             this.timer = undefined;
-            this.refreshPromise = this.checkAndRefresh().finally(() => {
-                this.refreshPromise = undefined;
+            if (!this.isActiveEpoch(epoch))
+                return;
+            const refresh = this.checkAndRefresh(epoch);
+            const tracked = refresh.finally(() => {
+                if (this.refreshPromise === tracked)
+                    this.refreshPromise = undefined;
             });
+            this.refreshPromise = tracked;
         }, Math.max(1_000, delayMs));
         this.timer.unref?.();
     }
-    async checkAndRefresh() {
-        if (this.stopped)
+    async checkAndRefresh(epoch) {
+        if (!this.isActiveEpoch(epoch))
             return;
         try {
             const suggestedRefreshAtMs = Date.parse(this.mounted.suggestedRefreshAt ?? "");
             const refreshDue = Number.isFinite(suggestedRefreshAtMs) && Date.now() >= suggestedRefreshAtMs;
             if (!refreshDue) {
                 const status = await this.mounted.status();
+                if (!this.isActiveEpoch(epoch))
+                    return;
                 if (status.ready) {
                     this.supervisorReady = true;
                     this.refreshAttempts = 0;
@@ -972,8 +1078,8 @@ class SupervisedMountedWorkspaceHandle {
                     return;
                 }
             }
-            await this.replaceMount();
-            if (this.stopped)
+            await this.replaceMount(epoch);
+            if (!this.isActiveEpoch(epoch))
                 return;
             this.supervisorReady = true;
             this.refreshAttempts = 0;
@@ -986,7 +1092,7 @@ class SupervisedMountedWorkspaceHandle {
             this.schedule();
         }
         catch (error) {
-            if (this.stopped)
+            if (!this.isActiveEpoch(epoch))
                 return;
             this.supervisorReady = false;
             this.refreshAttempts += 1;
@@ -1002,20 +1108,23 @@ class SupervisedMountedWorkspaceHandle {
             this.schedule(retryInMs);
         }
     }
-    async replaceMount() {
+    async replaceMount(epoch) {
         const previous = this.mounted;
-        if (this.stopped)
+        if (!this.isActiveEpoch(epoch))
             return;
         await previous.stop().catch(() => { });
-        if (this.stopped)
+        if (!this.isActiveEpoch(epoch))
             return;
         const replacement = await this.launch();
-        if (this.stopped) {
+        if (!this.isActiveEpoch(epoch)) {
             await replacement.stop().catch(() => { });
             return;
         }
         this.mounted = replacement;
     }
+    isActiveEpoch(epoch) {
+        return !this.stopped && !this.checkpointing && epoch === this.supervisorEpoch;
+    }
     emit(event) {
         void Promise.resolve(this.onEvent?.(event)).catch(() => { });
     }

package/dist/types.d.ts

@@ -128,6 +128,134 @@ export interface BulkWriteResponse {
     }>;
     correlationId: string;
 }
+export interface CheckpointSeal {
+    sealId: string;
+    sealToken?: string;
+    workspaceId: string;
+    root: string;
+    sessionId: string;
+    generation: number;
+    digest: string;
+    workspaceRevision: string;
+    eventCursor: string;
+    issuedAt: string;
+    expiresAt: string;
+    consumedAt?: string;
+}
+export type CheckpointSealOwnershipStatus = "unconsumed" | "consumed" | "released" | "source-resumed";
+export interface CheckpointSealRetentionRecord {
+    sealId: string;
+    workspaceId: string;
+    root: string;
+    sessionId: string;
+    generation: number;
+    ownershipStatus: CheckpointSealOwnershipStatus;
+    issuedAt: string;
+    expiresAt: string;
+    consumedAt?: string;
+    handbackReleasedAt?: string;
+    sourceResumedAt?: string;
+    adminReconciledAt?: string;
+}
+export interface CheckpointSealRetentionSummary {
+    generatedAt: string;
+    unresumedTotal: number;
+    unresumedByWorkspace: Record<string, number>;
+    records: CheckpointSealRetentionRecord[];
+}
+export interface GetAdminCheckpointSealRetentionOptions {
+    workspaceId?: string;
+    correlationId?: string;
+    signal?: AbortSignal;
+}
+export interface ReconcileAdminCheckpointSealSourceInput {
+    sealId: string;
+    workspaceId: string;
+    root: string;
+    sessionId: string;
+    generation: number;
+    expectedOwnershipStatus: "unconsumed" | "released";
+    reconciliationIdempotencyKey: string;
+    confirmSourceReady: true;
+    correlationId?: string;
+    signal?: AbortSignal;
+}
+export interface ConsumedCheckpointSeal extends Omit<CheckpointSeal, "sealToken" | "consumedAt"> {
+    sealToken?: never;
+    consumedAt: string;
+}
+export interface IssueCheckpointSealInput {
+    workspaceId: string;
+    root: string;
+    sessionId: string;
+    generation: number;
+    expectedDigest: string;
+    /** Stable per-attempt key. Response-loss retries rotate the lost bearer safely. */
+    issuanceIdempotencyKey: string;
+    ttlSeconds?: number;
+    correlationId?: string;
+    signal?: AbortSignal;
+}
+export interface ConsumeCheckpointSealInput {
+    workspaceId: string;
+    sealToken: string;
+    root: string;
+    sessionId: string;
+    generation: number;
+    consumerIdempotencyKey: string;
+    correlationId?: string;
+    signal?: AbortSignal;
+}
+export interface RecoverConsumedCheckpointSealInput {
+    workspaceId: string;
+    root: string;
+    sessionId: string;
+    generation: number;
+    consumerIdempotencyKey: string;
+    correlationId?: string;
+    signal?: AbortSignal;
+}
+export interface VerifyCheckpointSealInput {
+    workspaceId: string;
+    receipt: ConsumedCheckpointSeal;
+    correlationId?: string;
+    signal?: AbortSignal;
+}
+export interface CheckpointSealOwnership {
+    sealId: string;
+    workspaceId: string;
+    root: string;
+    sessionId: string;
+    generation: number;
+    status: "prepared" | "released" | "source-resumed";
+    digest: string;
+    workspaceRevision: string;
+    eventCursor: string;
+    consumedAt?: string;
+    preparedAt?: string;
+    releasedAt?: string;
+    sourceResumedAt?: string;
+}
+export interface HandbackCheckpointSealInput {
+    workspaceId: string;
+    phase: "prepare" | "commit";
+    receipt: ConsumedCheckpointSeal;
+    consumerIdempotencyKey: string;
+    handbackIdempotencyKey: string;
+    expectedDigest: string;
+    correlationId?: string;
+    signal?: AbortSignal;
+}
+export interface ResumeCheckpointSealInput {
+    workspaceId: string;
+    sealToken: string;
+    root: string;
+    sessionId: string;
+    generation: number;
+    resumeIdempotencyKey: string;
+    correlationId?: string;
+    signal?: AbortSignal;
+}
 export interface FileQueryItem {
     path: string;
     revision: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relayfile/sdk",
-  "version": "0.10.46",
+  "version": "0.10.48",
   "description": "TypeScript SDK for relayfile — real-time filesystem for humans and agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -59,15 +59,15 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@relayfile/core": "0.10.46",
+    "@relayfile/core": "0.10.48",
     "ignore": "^7.0.5",
     "tar": "^7.5.10"
   },
   "optionalDependencies": {
-    "@relayfile/mount-darwin-arm64": "0.10.46",
-    "@relayfile/mount-darwin-x64": "0.10.46",
-    "@relayfile/mount-linux-arm64": "0.10.46",
-    "@relayfile/mount-linux-x64": "0.10.46"
+    "@relayfile/mount-darwin-arm64": "0.10.48",
+    "@relayfile/mount-darwin-x64": "0.10.48",
+    "@relayfile/mount-linux-arm64": "0.10.48",
+    "@relayfile/mount-linux-x64": "0.10.48"
   },
   "devDependencies": {
     "typescript": "^5.7.3",