@relayfile/sdk 0.10.32 → 0.10.34

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 CreateForkInput, type DeleteFileInput, type DeadLetterItem, type DeadLetterFeedResponse, type DeleteWebhookOptions, type DiscardForkInput, 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 ListTreeOptions, type OperationFeedResponse, type OperationStatusResponse, type QueuedResponse, type ResourceAtEventResult, type ReadFileInput, type QueryFilesOptions, 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 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 OperationFeedResponse, type OperationStatusResponse, type QueuedResponse, type ResourceAtEventResult, type ReadFileInput, type QueryFilesOptions, 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.
@@ -108,6 +108,11 @@ export declare class RelayFileClient {
     discardFork(input: DiscardForkInput): Promise<void>;
     commitFork(input: CommitForkInput): Promise<CommitForkResponse>;
     getEvents(workspaceId: string, options?: GetEventsOptions): Promise<EventFeedResponse>;
+    createOrRenewDurableResourceSubscription(input: CreateOrRenewDurableResourceSubscriptionInput): Promise<DurableResourceSubscription>;
+    listDurableResourceSubscriptions(workspaceId: string, options?: ListDurableResourceSubscriptionsOptions): Promise<DurableResourceSubscriptionListResponse>;
+    cancelDurableResourceSubscription(workspaceId: string, subscriptionId: string, options?: CancelDurableResourceSubscriptionOptions): Promise<void>;
+    claimDurableSubscriptionDeliveries(input: ClaimDurableSubscriptionDeliveriesInput): Promise<DurableSubscriptionDeliveryListResponse>;
+    acceptDurableSubscriptionDelivery(input: AcceptDurableSubscriptionDeliveryInput): Promise<DurableSubscriptionDeliveryResponse>;
     subscribe(globs: string[], onChange: (event: ChangeEvent) => void, options?: SubscribeOptions): Subscription;
     open(options: ChangeStreamConnectionOptions): ChangeStreamConnection;
     getResourceAtEvent(eventId: string, context?: ProactiveRequestContext): Promise<ResourceAtEventResult>;

package/dist/client.js

@@ -1354,6 +1354,85 @@ export class RelayFileClient {
             nextCursor: response.nextCursor ?? null
         };
     }
+    async createOrRenewDurableResourceSubscription(input) {
+        if (!input.workspaceId)
+            throw new Error("workspaceId is required");
+        if (!input.provider)
+            throw new Error("provider is required");
+        if (!input.resourceRef)
+            throw new Error("resourceRef is required");
+        if (!input.subscriberId)
+            throw new Error("subscriberId is required");
+        if (!Array.isArray(input.eventTypes) || input.eventTypes.length === 0) {
+            throw new Error("eventTypes is required and must be a non-empty array");
+        }
+        if (!Number.isInteger(input.ttlSeconds) || input.ttlSeconds < 60 || input.ttlSeconds > 2_592_000) {
+            throw new Error("ttlSeconds must be an integer between 60 and 2592000");
+        }
+        return this.request({
+            method: "POST",
+            path: `/v1/workspaces/${encodeURIComponent(input.workspaceId)}/subscriptions`,
+            correlationId: input.correlationId,
+            body: {
+                provider: input.provider,
+                resourceRef: input.resourceRef,
+                eventTypes: input.eventTypes,
+                terminalEventTypes: input.terminalEventTypes,
+                subscriberId: input.subscriberId,
+                intent: input.intent,
+                ttlSeconds: input.ttlSeconds
+            },
+            signal: input.signal
+        });
+    }
+    async listDurableResourceSubscriptions(workspaceId, options = {}) {
+        if (!workspaceId)
+            throw new Error("workspaceId is required");
+        return this.request({
+            method: "GET",
+            path: `/v1/workspaces/${encodeURIComponent(workspaceId)}/subscriptions`,
+            correlationId: options.correlationId,
+            signal: options.signal
+        });
+    }
+    async cancelDurableResourceSubscription(workspaceId, subscriptionId, options = {}) {
+        if (!workspaceId)
+            throw new Error("workspaceId is required");
+        if (!subscriptionId)
+            throw new Error("subscriptionId is required");
+        await this.performRequest({
+            method: "DELETE",
+            path: `/v1/workspaces/${encodeURIComponent(workspaceId)}/subscriptions/${encodeURIComponent(subscriptionId)}`,
+            correlationId: options.correlationId,
+            signal: options.signal
+        });
+    }
+    async claimDurableSubscriptionDeliveries(input) {
+        if (!input.workspaceId)
+            throw new Error("workspaceId is required");
+        return this.request({
+            method: "POST",
+            path: `/v1/workspaces/${encodeURIComponent(input.workspaceId)}/subscriptions/deliveries/claim`,
+            correlationId: input.correlationId,
+            body: input.limit === undefined ? {} : { limit: input.limit },
+            signal: input.signal
+        });
+    }
+    async acceptDurableSubscriptionDelivery(input) {
+        if (!input.workspaceId)
+            throw new Error("workspaceId is required");
+        if (!input.deliveryId)
+            throw new Error("deliveryId is required");
+        if (!input.claimToken)
+            throw new Error("claimToken is required");
+        return this.request({
+            method: "POST",
+            path: `/v1/workspaces/${encodeURIComponent(input.workspaceId)}/subscriptions/deliveries/${encodeURIComponent(input.deliveryId)}/accept`,
+            correlationId: input.correlationId,
+            body: { claimToken: input.claimToken },
+            signal: input.signal
+        });
+    }
     subscribe(globs, onChange, options) {
         const setup = this.resolveWorkspaceId(options?.aclToken)
             .then((workspaceId) => {

package/dist/index.d.ts

@@ -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, AckWritebackInput, AckWritebackDraftDisposition, AckWritebackResponse, AdminIngressAlert, AdminIngressAlertProfile, AdminIngressEffectiveAlertProfile, AdminIngressAlertSeverity, AdminIngressAlertThresholds, AdminIngressAlertTotals, AdminIngressAlertType, AdminIngressStatusResponse, AdminSyncAlert, AdminSyncAlertSeverity, AdminSyncAlertThresholds, AdminSyncAlertTotals, AdminSyncAlertType, AdminSyncStatusResponse, BackendStatusResponse, BulkWriteFile, BulkWriteInput, BulkWriteResponse, ChangeLogQueryResult, ChangeEvent, ChangeEventActor, ChangeEventResource, ChangeEventSummary, ChangeStreamConnection, ChangeStreamConnectionOptions, CommitForkInput, CommitForkResponse, ConflictErrorResponse, CreateForkInput, ContentIdentity, DeleteFileInput, DeleteWebhookOptions, DeadLetterFeedResponse, DeadLetterItem, DigestBullet, DigestContext, DigestHandler, DigestSection, DigestWindow, DiscardForkInput, 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, ListTreeOptions, OperationFeedResponse, OperationStatus, OperationStatusResponse, QueuedResponse, QueryFilesOptions, 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, 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, OperationFeedResponse, OperationStatus, OperationStatusResponse, QueuedResponse, QueryFilesOptions, 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/setup.d.ts

@@ -42,6 +42,7 @@ export declare class RelayfileSetup {
     private readonly accessToken?;
     private readonly requestTimeoutMs;
     private readonly retryOptions;
+    private readonly ensuredMounts;
     static login(options?: RelayfileCloudLoginOptions): Promise<RelayfileSetup>;
     static fromCloudTokens(tokens: RelayfileCloudTokenSet, options?: RelayfileCloudTokenSetupOptions): RelayfileSetup;
     constructor(options?: RelayfileSetupOptions);
@@ -49,6 +50,7 @@ export declare class RelayfileSetup {
     joinWorkspace(workspaceId: string, options?: JoinWorkspaceOptions): Promise<WorkspaceHandle>;
     mountWorkspace(input: MountWorkspaceInput): Promise<MountedWorkspaceHandle>;
     ensureMountedWorkspace(input: EnsureMountedWorkspaceInput): Promise<MountedWorkspaceHandle>;
+    private startEnsuredMount;
     joinWorkspaceResponse(workspaceId: string, options: NormalizedJoinWorkspaceOptions, overrides?: {
         tokenProvider?: AccessTokenProvider;
     }): Promise<ValidatedJoinWorkspaceResponse>;

package/dist/setup.js

@@ -32,6 +32,7 @@ export class RelayfileSetup {
     accessToken;
     requestTimeoutMs;
     retryOptions;
+    ensuredMounts = new Map();
     static async login(options = {}) {
         void options;
         throw new RelayfileSetupError("RelayfileSetup.login() starts a local HTTP callback server and is only available from @relayfile/sdk/cli. Import RelayfileSetup from @relayfile/sdk/cli for interactive Cloud login.", "node_only_sdk_feature");
@@ -136,6 +137,35 @@ export class RelayfileSetup {
     async ensureMountedWorkspace(input) {
         const normalized = normalizeEnsureMountedWorkspaceInput(input);
         const workspace = await this.resolveWorkspaceForMount(normalized);
+        throwIfAborted(normalized.signal, "ensureMountedWorkspace");
+        const mountKey = ensuredMountKey(workspace, normalized);
+        const existing = this.ensuredMounts.get(mountKey);
+        if (existing) {
+            return waitForEnsuredMount(existing, normalized.signal);
+        }
+        let shared;
+        // The physical mount belongs to the logical target, not the first caller.
+        // Individual abort signals only cancel that caller's wait below.
+        shared = this.startEnsuredMount(workspace, {
+            ...normalized,
+            signal: undefined
+        }).then((mounted) => new SharedMountedWorkspaceHandle({
+            mounted,
+            onStopped: () => {
+                if (this.ensuredMounts.get(mountKey) === shared) {
+                    this.ensuredMounts.delete(mountKey);
+                }
+            }
+        }));
+        this.ensuredMounts.set(mountKey, shared);
+        void shared.catch(() => {
+            if (this.ensuredMounts.get(mountKey) === shared) {
+                this.ensuredMounts.delete(mountKey);
+            }
+        });
+        return waitForEnsuredMount(shared, normalized.signal);
+    }
+    async startEnsuredMount(workspace, normalized) {
         if (normalized.verifyProvider) {
             if (!normalized.provider) {
                 throw new MountSessionInputError("provider required when verifyProvider=true");
@@ -781,6 +811,55 @@ class MountedWorkspaceHandleImpl {
         await safeStopLauncher(this.launcherInstance);
     }
 }
+class SharedMountedWorkspaceHandle {
+    mounted;
+    onStopped;
+    stopPromise;
+    constructor(input) {
+        this.mounted = input.mounted;
+        this.onStopped = input.onStopped;
+    }
+    get workspaceId() {
+        return this.mounted.workspaceId;
+    }
+    get localDir() {
+        return this.mounted.localDir;
+    }
+    get remotePath() {
+        return this.mounted.remotePath;
+    }
+    get mode() {
+        return this.mounted.mode;
+    }
+    get ready() {
+        return this.mounted.ready;
+    }
+    get expiresAt() {
+        return this.mounted.expiresAt;
+    }
+    get suggestedRefreshAt() {
+        return this.mounted.suggestedRefreshAt;
+    }
+    env() {
+        return this.mounted.env();
+    }
+    status() {
+        return this.mounted.status();
+    }
+    async stop() {
+        if (!this.stopPromise)
+            this.stopPromise = this.performStop();
+        await this.stopPromise;
+    }
+    async performStop() {
+        try {
+            await this.mounted.stop();
+        }
+        finally {
+            this.onStopped();
+        }
+    }
+}
 class SupervisedMountedWorkspaceHandle {
     mounted;
     launch;
@@ -941,6 +1020,37 @@ class SupervisedMountedWorkspaceHandle {
         void Promise.resolve(this.onEvent?.(event)).catch(() => { });
     }
 }
+function ensuredMountKey(workspace, input) {
+    return JSON.stringify([
+        workspace.workspaceId,
+        input.localDir,
+        input.remotePath,
+        input.mode,
+        input.localLayout,
+        input.syncMode,
+        input.background
+    ]);
+}
+async function waitForEnsuredMount(mounted, signal) {
+    if (!signal)
+        return mounted;
+    if (signal.aborted)
+        throw new CloudAbortError("ensureMountedWorkspace");
+    let onAbort;
+    try {
+        return await Promise.race([
+            mounted,
+            new Promise((_, reject) => {
+                onAbort = () => reject(new CloudAbortError("ensureMountedWorkspace"));
+                signal.addEventListener("abort", onAbort, { once: true });
+            })
+        ]);
+    }
+    finally {
+        if (onAbort)
+            signal.removeEventListener("abort", onAbort);
+    }
+}
 function setupErrorCode(error) {
     return error instanceof RelayfileSetupError ? error.code : "mount_refresh_failed";
 }

package/dist/types.d.ts

@@ -312,6 +312,96 @@ export interface EventFeedResponse {
     events: FilesystemEvent[];
     nextCursor: string | null;
 }
+export type DurableResourceSubscriptionStatus = "active" | "cancelled" | "expired" | "retired";
+export type DurableSubscriptionDeliveryStatus = "pending" | "claimed" | "accepted" | "cancelled";
+/**
+ * Create-or-renew request for an owner-scoped durable resource subscription.
+ * The server derives ownerId from the bearer token; callers cannot supply it.
+ */
+export interface CreateOrRenewDurableResourceSubscriptionInput {
+    workspaceId: string;
+    provider: string;
+    resourceRef: string;
+    eventTypes: string[];
+    terminalEventTypes?: string[];
+    subscriberId: string;
+    intent?: string;
+    ttlSeconds: number;
+    correlationId?: string;
+    signal?: AbortSignal;
+}
+export interface DurableResourceSubscription {
+    id: string;
+    ownerId: string;
+    subscriberId: string;
+    provider: string;
+    resourceRef: string;
+    eventTypes: string[];
+    terminalEventTypes: string[];
+    intent: string | null;
+    status: DurableResourceSubscriptionStatus;
+    createdAt: string;
+    updatedAt: string;
+    expiresAt: string;
+    retiredAt: string | null;
+}
+export interface ListDurableResourceSubscriptionsOptions {
+    correlationId?: string;
+    signal?: AbortSignal;
+}
+export interface DurableResourceSubscriptionListResponse {
+    subscriptions: DurableResourceSubscription[];
+}
+export interface DurableSubscriptionEvent {
+    id: string;
+    type: string;
+    path: string;
+    revision: string;
+    origin: string;
+    provider: string;
+    correlationId: string;
+    timestamp: string;
+}
+export interface DurableSubscriptionDelivery {
+    id: string;
+    subscriptionId: string;
+    ownerId: string;
+    subscriberId: string;
+    provider: string;
+    resourceRef: string;
+    event: DurableSubscriptionEvent;
+    terminal: boolean;
+    status: DurableSubscriptionDeliveryStatus;
+    createdAt: string;
+    claimedAt: string | null;
+    claimLeaseExpiresAt: string | null;
+    /** Present only while the delivery has a live claim. */
+    claimToken: string | null;
+    acceptedAt: string | null;
+}
+export interface ClaimDurableSubscriptionDeliveriesInput {
+    workspaceId: string;
+    limit?: number;
+    correlationId?: string;
+    signal?: AbortSignal;
+}
+export interface DurableSubscriptionDeliveryListResponse {
+    deliveries: DurableSubscriptionDelivery[];
+}
+export interface AcceptDurableSubscriptionDeliveryInput {
+    workspaceId: string;
+    deliveryId: string;
+    claimToken: string;
+    correlationId?: string;
+    signal?: AbortSignal;
+}
+export interface DurableSubscriptionDeliveryResponse {
+    delivery: DurableSubscriptionDelivery;
+}
+export interface CancelDurableResourceSubscriptionOptions {
+    correlationId?: string;
+    signal?: AbortSignal;
+}
 export type ExportFormat = "tar" | "json" | "patch";
 export interface ExportOptions {
     workspaceId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relayfile/sdk",
-  "version": "0.10.32",
+  "version": "0.10.34",
   "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.32",
+    "@relayfile/core": "0.10.34",
     "ignore": "^7.0.5",
     "tar": "^7.5.10"
   },
   "optionalDependencies": {
-    "@relayfile/mount-darwin-arm64": "0.10.32",
-    "@relayfile/mount-darwin-x64": "0.10.32",
-    "@relayfile/mount-linux-arm64": "0.10.32",
-    "@relayfile/mount-linux-x64": "0.10.32"
+    "@relayfile/mount-darwin-arm64": "0.10.34",
+    "@relayfile/mount-darwin-x64": "0.10.34",
+    "@relayfile/mount-linux-arm64": "0.10.34",
+    "@relayfile/mount-linux-x64": "0.10.34"
   },
   "devDependencies": {
     "typescript": "^5.7.3",