@takboo/dsh-session-bin 0.0.0-stage → 0.1.0

package/dist/types/remote/contracts.d.ts

@@ -0,0 +1,891 @@
+import { z } from 'zod';
+import type { RemoteResult, RemoteStreamHandle, TypertRemoteContribution } from '@deepseek-ai/dsh-typert-protocol';
+import type { TypertContribution } from '@deepseek-ai/dsh-typert-registry';
+import type { BinOperation } from '../operations/schema.js';
+import type { ArchiveEntry, ArchiveOperation, ArchivePlan, ArchivePrepareRequest, ArchiveResult } from '../operations/archive.js';
+import type { PreparePurgeRequest, PurgePlan, PurgeResult, PurgeOperation } from '../operations/retirement.js';
+export declare const sessionBinRemoteNamespace = "sessionBin";
+export declare const sessionBinRemoteServiceKey = "sessionBinRemote";
+export declare const snapshotSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    entries: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        sessionId: z.ZodString;
+        entryId: z.ZodUUID;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type BinSnapshot = z.infer<typeof snapshotSchema>;
+export type ArchiveSnapshot = BinSnapshot;
+export declare const operationIdSchema: z.ZodString;
+export declare const entriesSchema: z.ZodArray<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    sessionId: z.ZodString;
+    entryId: z.ZodUUID;
+}, z.core.$strict>>;
+export declare const optionalOperationSchema: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    plan: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"unarchive">;
+        sessionId: z.ZodString;
+        expected: z.ZodObject<{
+            archived: z.ZodBoolean;
+            entryId: z.ZodNullable<z.ZodUUID>;
+        }, z.core.$strict>;
+        blockers: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            activity: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        intent: "intent";
+        applied: "applied";
+        done: "done";
+    }>;
+    entry: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        sessionId: z.ZodString;
+        entryId: z.ZodUUID;
+    }, z.core.$strict>>;
+    result: z.ZodNullable<z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"unarchive">;
+        sessionId: z.ZodString;
+        status: z.ZodEnum<{
+            success: "success";
+            rejected: "rejected";
+            conflict: "conflict";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        entryId: z.ZodNullable<z.ZodUUID>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    plan: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        operationId: z.ZodString;
+        action: z.ZodEnum<{
+            bin: "bin";
+            restore: "restore";
+        }>;
+        sessionId: z.ZodString;
+        expected: z.ZodObject<{
+            archived: z.ZodBoolean;
+            entryId: z.ZodNullable<z.ZodUUID>;
+        }, z.core.$strict>;
+        blockers: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            activity: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        intent: "intent";
+        applied: "applied";
+        done: "done";
+    }>;
+    ownershipInvalidated: z.ZodBoolean;
+    entry: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        sessionId: z.ZodString;
+        entryId: z.ZodUUID;
+        operationId: z.ZodString;
+        binnedAt: z.ZodISODateTime;
+        workspaceIdAtBin: z.ZodNullable<z.ZodString>;
+        wasArchived: z.ZodBoolean;
+    }, z.core.$strict>>;
+    result: z.ZodNullable<z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodEnum<{
+            bin: "bin";
+            restore: "restore";
+        }>;
+        sessionId: z.ZodString;
+        status: z.ZodEnum<{
+            success: "success";
+            rejected: "rejected";
+            conflict: "conflict";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        entryId: z.ZodNullable<z.ZodUUID>;
+    }, z.core.$strict>>;
+}, z.core.$strict>]>>;
+export declare const nativePurgePlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    action: z.ZodLiteral<"purge">;
+    operationId: z.ZodString;
+    sessionId: z.ZodString;
+    expectedEntryId: z.ZodNullable<z.ZodUUID>;
+    binding: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        entryId: z.ZodUUID;
+        entryVersion: z.ZodLiteral<1>;
+        lifecycle: z.ZodObject<{
+            storeId: z.ZodString;
+            sessionId: z.ZodString;
+            lifecycleId: z.ZodString;
+        }, z.core.$strict>;
+        capabilities: z.ZodObject<{
+            protocolVersion: z.ZodLiteral<1>;
+            ownerId: z.ZodString;
+            hostVersion: z.ZodString;
+            providerId: z.ZodString;
+            storeId: z.ZodString;
+            participants: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        target: z.ZodLiteral<"native-archive">;
+        entryId: z.ZodUUID;
+        entryVersion: z.ZodLiteral<2>;
+        lifecycle: z.ZodObject<{
+            storeId: z.ZodString;
+            sessionId: z.ZodString;
+            lifecycleId: z.ZodString;
+        }, z.core.$strict>;
+        capabilities: z.ZodObject<{
+            protocolVersion: z.ZodLiteral<1>;
+            ownerId: z.ZodString;
+            hostVersion: z.ZodString;
+            providerId: z.ZodString;
+            storeId: z.ZodString;
+            participants: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>>;
+    manifest: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        lifecycle: z.ZodObject<{
+            storeId: z.ZodString;
+            sessionId: z.ZodString;
+            lifecycleId: z.ZodString;
+        }, z.core.$strict>;
+        capabilities: z.ZodObject<{
+            protocolVersion: z.ZodLiteral<1>;
+            ownerId: z.ZodString;
+            hostVersion: z.ZodString;
+            providerId: z.ZodString;
+            storeId: z.ZodString;
+            participants: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        resources: z.ZodArray<z.ZodObject<{
+            ownerId: z.ZodString;
+            resourceId: z.ZodString;
+            revision: z.ZodString;
+            kind: z.ZodEnum<{
+                transcript: "transcript";
+                workspace: "workspace";
+                index: "index";
+                cache: "cache";
+                attachment: "attachment";
+                spill: "spill";
+                coordination: "coordination";
+            }>;
+            disposition: z.ZodEnum<{
+                erase: "erase";
+                "release-reference": "release-reference";
+                "retain-shared": "retain-shared";
+                "retain-coordination": "retain-coordination";
+            }>;
+            retention: z.ZodNullable<z.ZodObject<{
+                reason: z.ZodEnum<{
+                    "shared-reference": "shared-reference";
+                    "coordination-identity": "coordination-identity";
+                }>;
+                retainedBy: z.ZodArray<z.ZodObject<{
+                    storeId: z.ZodString;
+                    sessionId: z.ZodString;
+                    lifecycleId: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    blockers: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        activity: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const optionalPurgeOperationSchema: z.ZodNullable<z.ZodObject<{
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    plan: z.ZodObject<{
+        schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+        action: z.ZodLiteral<"purge">;
+        operationId: z.ZodString;
+        sessionId: z.ZodString;
+        expectedEntryId: z.ZodNullable<z.ZodUUID>;
+        binding: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            entryId: z.ZodUUID;
+            entryVersion: z.ZodLiteral<1>;
+            lifecycle: z.ZodObject<{
+                storeId: z.ZodString;
+                sessionId: z.ZodString;
+                lifecycleId: z.ZodString;
+            }, z.core.$strict>;
+            capabilities: z.ZodObject<{
+                protocolVersion: z.ZodLiteral<1>;
+                ownerId: z.ZodString;
+                hostVersion: z.ZodString;
+                providerId: z.ZodString;
+                storeId: z.ZodString;
+                participants: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            schemaVersion: z.ZodLiteral<2>;
+            target: z.ZodLiteral<"native-archive">;
+            entryId: z.ZodUUID;
+            entryVersion: z.ZodLiteral<2>;
+            lifecycle: z.ZodObject<{
+                storeId: z.ZodString;
+                sessionId: z.ZodString;
+                lifecycleId: z.ZodString;
+            }, z.core.$strict>;
+            capabilities: z.ZodObject<{
+                protocolVersion: z.ZodLiteral<1>;
+                ownerId: z.ZodString;
+                hostVersion: z.ZodString;
+                providerId: z.ZodString;
+                storeId: z.ZodString;
+                participants: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>>;
+        manifest: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            lifecycle: z.ZodObject<{
+                storeId: z.ZodString;
+                sessionId: z.ZodString;
+                lifecycleId: z.ZodString;
+            }, z.core.$strict>;
+            capabilities: z.ZodObject<{
+                protocolVersion: z.ZodLiteral<1>;
+                ownerId: z.ZodString;
+                hostVersion: z.ZodString;
+                providerId: z.ZodString;
+                storeId: z.ZodString;
+                participants: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            resources: z.ZodArray<z.ZodObject<{
+                ownerId: z.ZodString;
+                resourceId: z.ZodString;
+                revision: z.ZodString;
+                kind: z.ZodEnum<{
+                    transcript: "transcript";
+                    workspace: "workspace";
+                    index: "index";
+                    cache: "cache";
+                    attachment: "attachment";
+                    spill: "spill";
+                    coordination: "coordination";
+                }>;
+                disposition: z.ZodEnum<{
+                    erase: "erase";
+                    "release-reference": "release-reference";
+                    "retain-shared": "retain-shared";
+                    "retain-coordination": "retain-coordination";
+                }>;
+                retention: z.ZodNullable<z.ZodObject<{
+                    reason: z.ZodEnum<{
+                        "shared-reference": "shared-reference";
+                        "coordination-identity": "coordination-identity";
+                    }>;
+                    retainedBy: z.ZodArray<z.ZodObject<{
+                        storeId: z.ZodString;
+                        sessionId: z.ZodString;
+                        lifecycleId: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        blockers: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            activity: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        intent: "intent";
+        done: "done";
+        authorizing: "authorizing";
+        "owner-pending": "owner-pending";
+    }>;
+    entry: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        sessionId: z.ZodString;
+        entryId: z.ZodUUID;
+        operationId: z.ZodString;
+        binnedAt: z.ZodISODateTime;
+        workspaceIdAtBin: z.ZodNullable<z.ZodString>;
+        wasArchived: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        sessionId: z.ZodString;
+        entryId: z.ZodUUID;
+    }, z.core.$strict>]>>;
+    authorizationId: z.ZodNullable<z.ZodUUID>;
+    ownerState: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        request: z.ZodObject<{
+            operationId: z.ZodString;
+            expected: z.ZodObject<{
+                storeId: z.ZodString;
+                sessionId: z.ZodString;
+                lifecycleId: z.ZodString;
+            }, z.core.$strict>;
+            bin: z.ZodUnion<readonly [z.ZodObject<{
+                entryId: z.ZodUUID;
+                entryVersion: z.ZodLiteral<1>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"native-archive">;
+                entryId: z.ZodUUID;
+                entryVersion: z.ZodLiteral<2>;
+            }, z.core.$strict>]>;
+            manifestDigest: z.ZodString;
+        }, z.core.$strict>;
+        manifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            lifecycle: z.ZodObject<{
+                storeId: z.ZodString;
+                sessionId: z.ZodString;
+                lifecycleId: z.ZodString;
+            }, z.core.$strict>;
+            capabilities: z.ZodObject<{
+                protocolVersion: z.ZodLiteral<1>;
+                ownerId: z.ZodString;
+                hostVersion: z.ZodString;
+                providerId: z.ZodString;
+                storeId: z.ZodString;
+                participants: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            resources: z.ZodArray<z.ZodObject<{
+                ownerId: z.ZodString;
+                resourceId: z.ZodString;
+                revision: z.ZodString;
+                kind: z.ZodEnum<{
+                    transcript: "transcript";
+                    workspace: "workspace";
+                    index: "index";
+                    cache: "cache";
+                    attachment: "attachment";
+                    spill: "spill";
+                    coordination: "coordination";
+                }>;
+                disposition: z.ZodEnum<{
+                    erase: "erase";
+                    "release-reference": "release-reference";
+                    "retain-shared": "retain-shared";
+                    "retain-coordination": "retain-coordination";
+                }>;
+                retention: z.ZodNullable<z.ZodObject<{
+                    reason: z.ZodEnum<{
+                        "shared-reference": "shared-reference";
+                        "coordination-identity": "coordination-identity";
+                    }>;
+                    retainedBy: z.ZodArray<z.ZodObject<{
+                        storeId: z.ZodString;
+                        sessionId: z.ZodString;
+                        lifecycleId: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        authorizationId: z.ZodNullable<z.ZodUUID>;
+        phase: z.ZodEnum<{
+            rejected: "rejected";
+            conflict: "conflict";
+            done: "done";
+            fenced: "fenced";
+            quiesced: "quiesced";
+            erasing: "erasing";
+            converging: "converging";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        resources: z.ZodArray<z.ZodObject<{
+            ownerId: z.ZodString;
+            resourceId: z.ZodString;
+            status: z.ZodEnum<{
+                erased: "erased";
+                "reference-released": "reference-released";
+                retained: "retained";
+                failed: "failed";
+            }>;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    result: z.ZodNullable<z.ZodObject<{
+        action: z.ZodLiteral<"purge">;
+        operationId: z.ZodString;
+        sessionId: z.ZodString;
+        entryId: z.ZodNullable<z.ZodUUID>;
+        status: z.ZodEnum<{
+            success: "success";
+            rejected: "rejected";
+            conflict: "conflict";
+            "pending-recovery": "pending-recovery";
+            "partial-failure": "partial-failure";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        ownerState: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            request: z.ZodObject<{
+                operationId: z.ZodString;
+                expected: z.ZodObject<{
+                    storeId: z.ZodString;
+                    sessionId: z.ZodString;
+                    lifecycleId: z.ZodString;
+                }, z.core.$strict>;
+                bin: z.ZodUnion<readonly [z.ZodObject<{
+                    entryId: z.ZodUUID;
+                    entryVersion: z.ZodLiteral<1>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"native-archive">;
+                    entryId: z.ZodUUID;
+                    entryVersion: z.ZodLiteral<2>;
+                }, z.core.$strict>]>;
+                manifestDigest: z.ZodString;
+            }, z.core.$strict>;
+            manifest: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                lifecycle: z.ZodObject<{
+                    storeId: z.ZodString;
+                    sessionId: z.ZodString;
+                    lifecycleId: z.ZodString;
+                }, z.core.$strict>;
+                capabilities: z.ZodObject<{
+                    protocolVersion: z.ZodLiteral<1>;
+                    ownerId: z.ZodString;
+                    hostVersion: z.ZodString;
+                    providerId: z.ZodString;
+                    storeId: z.ZodString;
+                    participants: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        version: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                resources: z.ZodArray<z.ZodObject<{
+                    ownerId: z.ZodString;
+                    resourceId: z.ZodString;
+                    revision: z.ZodString;
+                    kind: z.ZodEnum<{
+                        transcript: "transcript";
+                        workspace: "workspace";
+                        index: "index";
+                        cache: "cache";
+                        attachment: "attachment";
+                        spill: "spill";
+                        coordination: "coordination";
+                    }>;
+                    disposition: z.ZodEnum<{
+                        erase: "erase";
+                        "release-reference": "release-reference";
+                        "retain-shared": "retain-shared";
+                        "retain-coordination": "retain-coordination";
+                    }>;
+                    retention: z.ZodNullable<z.ZodObject<{
+                        reason: z.ZodEnum<{
+                            "shared-reference": "shared-reference";
+                            "coordination-identity": "coordination-identity";
+                        }>;
+                        retainedBy: z.ZodArray<z.ZodObject<{
+                            storeId: z.ZodString;
+                            sessionId: z.ZodString;
+                            lifecycleId: z.ZodString;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            authorizationId: z.ZodNullable<z.ZodUUID>;
+            phase: z.ZodEnum<{
+                rejected: "rejected";
+                conflict: "conflict";
+                done: "done";
+                fenced: "fenced";
+                quiesced: "quiesced";
+                erasing: "erasing";
+                converging: "converging";
+            }>;
+            reason: z.ZodNullable<z.ZodString>;
+            resources: z.ZodArray<z.ZodObject<{
+                ownerId: z.ZodString;
+                resourceId: z.ZodString;
+                status: z.ZodEnum<{
+                    erased: "erased";
+                    "reference-released": "reference-released";
+                    retained: "retained";
+                    failed: "failed";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const purgeOperationsSchema: z.ZodArray<z.ZodObject<{
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    plan: z.ZodObject<{
+        schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+        action: z.ZodLiteral<"purge">;
+        operationId: z.ZodString;
+        sessionId: z.ZodString;
+        expectedEntryId: z.ZodNullable<z.ZodUUID>;
+        binding: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            entryId: z.ZodUUID;
+            entryVersion: z.ZodLiteral<1>;
+            lifecycle: z.ZodObject<{
+                storeId: z.ZodString;
+                sessionId: z.ZodString;
+                lifecycleId: z.ZodString;
+            }, z.core.$strict>;
+            capabilities: z.ZodObject<{
+                protocolVersion: z.ZodLiteral<1>;
+                ownerId: z.ZodString;
+                hostVersion: z.ZodString;
+                providerId: z.ZodString;
+                storeId: z.ZodString;
+                participants: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            schemaVersion: z.ZodLiteral<2>;
+            target: z.ZodLiteral<"native-archive">;
+            entryId: z.ZodUUID;
+            entryVersion: z.ZodLiteral<2>;
+            lifecycle: z.ZodObject<{
+                storeId: z.ZodString;
+                sessionId: z.ZodString;
+                lifecycleId: z.ZodString;
+            }, z.core.$strict>;
+            capabilities: z.ZodObject<{
+                protocolVersion: z.ZodLiteral<1>;
+                ownerId: z.ZodString;
+                hostVersion: z.ZodString;
+                providerId: z.ZodString;
+                storeId: z.ZodString;
+                participants: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>>;
+        manifest: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            lifecycle: z.ZodObject<{
+                storeId: z.ZodString;
+                sessionId: z.ZodString;
+                lifecycleId: z.ZodString;
+            }, z.core.$strict>;
+            capabilities: z.ZodObject<{
+                protocolVersion: z.ZodLiteral<1>;
+                ownerId: z.ZodString;
+                hostVersion: z.ZodString;
+                providerId: z.ZodString;
+                storeId: z.ZodString;
+                participants: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            resources: z.ZodArray<z.ZodObject<{
+                ownerId: z.ZodString;
+                resourceId: z.ZodString;
+                revision: z.ZodString;
+                kind: z.ZodEnum<{
+                    transcript: "transcript";
+                    workspace: "workspace";
+                    index: "index";
+                    cache: "cache";
+                    attachment: "attachment";
+                    spill: "spill";
+                    coordination: "coordination";
+                }>;
+                disposition: z.ZodEnum<{
+                    erase: "erase";
+                    "release-reference": "release-reference";
+                    "retain-shared": "retain-shared";
+                    "retain-coordination": "retain-coordination";
+                }>;
+                retention: z.ZodNullable<z.ZodObject<{
+                    reason: z.ZodEnum<{
+                        "shared-reference": "shared-reference";
+                        "coordination-identity": "coordination-identity";
+                    }>;
+                    retainedBy: z.ZodArray<z.ZodObject<{
+                        storeId: z.ZodString;
+                        sessionId: z.ZodString;
+                        lifecycleId: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        blockers: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            activity: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+    phase: z.ZodEnum<{
+        intent: "intent";
+        done: "done";
+        authorizing: "authorizing";
+        "owner-pending": "owner-pending";
+    }>;
+    entry: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        sessionId: z.ZodString;
+        entryId: z.ZodUUID;
+        operationId: z.ZodString;
+        binnedAt: z.ZodISODateTime;
+        workspaceIdAtBin: z.ZodNullable<z.ZodString>;
+        wasArchived: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        sessionId: z.ZodString;
+        entryId: z.ZodUUID;
+    }, z.core.$strict>]>>;
+    authorizationId: z.ZodNullable<z.ZodUUID>;
+    ownerState: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        request: z.ZodObject<{
+            operationId: z.ZodString;
+            expected: z.ZodObject<{
+                storeId: z.ZodString;
+                sessionId: z.ZodString;
+                lifecycleId: z.ZodString;
+            }, z.core.$strict>;
+            bin: z.ZodUnion<readonly [z.ZodObject<{
+                entryId: z.ZodUUID;
+                entryVersion: z.ZodLiteral<1>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"native-archive">;
+                entryId: z.ZodUUID;
+                entryVersion: z.ZodLiteral<2>;
+            }, z.core.$strict>]>;
+            manifestDigest: z.ZodString;
+        }, z.core.$strict>;
+        manifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            lifecycle: z.ZodObject<{
+                storeId: z.ZodString;
+                sessionId: z.ZodString;
+                lifecycleId: z.ZodString;
+            }, z.core.$strict>;
+            capabilities: z.ZodObject<{
+                protocolVersion: z.ZodLiteral<1>;
+                ownerId: z.ZodString;
+                hostVersion: z.ZodString;
+                providerId: z.ZodString;
+                storeId: z.ZodString;
+                participants: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            resources: z.ZodArray<z.ZodObject<{
+                ownerId: z.ZodString;
+                resourceId: z.ZodString;
+                revision: z.ZodString;
+                kind: z.ZodEnum<{
+                    transcript: "transcript";
+                    workspace: "workspace";
+                    index: "index";
+                    cache: "cache";
+                    attachment: "attachment";
+                    spill: "spill";
+                    coordination: "coordination";
+                }>;
+                disposition: z.ZodEnum<{
+                    erase: "erase";
+                    "release-reference": "release-reference";
+                    "retain-shared": "retain-shared";
+                    "retain-coordination": "retain-coordination";
+                }>;
+                retention: z.ZodNullable<z.ZodObject<{
+                    reason: z.ZodEnum<{
+                        "shared-reference": "shared-reference";
+                        "coordination-identity": "coordination-identity";
+                    }>;
+                    retainedBy: z.ZodArray<z.ZodObject<{
+                        storeId: z.ZodString;
+                        sessionId: z.ZodString;
+                        lifecycleId: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        authorizationId: z.ZodNullable<z.ZodUUID>;
+        phase: z.ZodEnum<{
+            rejected: "rejected";
+            conflict: "conflict";
+            done: "done";
+            fenced: "fenced";
+            quiesced: "quiesced";
+            erasing: "erasing";
+            converging: "converging";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        resources: z.ZodArray<z.ZodObject<{
+            ownerId: z.ZodString;
+            resourceId: z.ZodString;
+            status: z.ZodEnum<{
+                erased: "erased";
+                "reference-released": "reference-released";
+                retained: "retained";
+                failed: "failed";
+            }>;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    result: z.ZodNullable<z.ZodObject<{
+        action: z.ZodLiteral<"purge">;
+        operationId: z.ZodString;
+        sessionId: z.ZodString;
+        entryId: z.ZodNullable<z.ZodUUID>;
+        status: z.ZodEnum<{
+            success: "success";
+            rejected: "rejected";
+            conflict: "conflict";
+            "pending-recovery": "pending-recovery";
+            "partial-failure": "partial-failure";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        ownerState: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            request: z.ZodObject<{
+                operationId: z.ZodString;
+                expected: z.ZodObject<{
+                    storeId: z.ZodString;
+                    sessionId: z.ZodString;
+                    lifecycleId: z.ZodString;
+                }, z.core.$strict>;
+                bin: z.ZodUnion<readonly [z.ZodObject<{
+                    entryId: z.ZodUUID;
+                    entryVersion: z.ZodLiteral<1>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"native-archive">;
+                    entryId: z.ZodUUID;
+                    entryVersion: z.ZodLiteral<2>;
+                }, z.core.$strict>]>;
+                manifestDigest: z.ZodString;
+            }, z.core.$strict>;
+            manifest: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                lifecycle: z.ZodObject<{
+                    storeId: z.ZodString;
+                    sessionId: z.ZodString;
+                    lifecycleId: z.ZodString;
+                }, z.core.$strict>;
+                capabilities: z.ZodObject<{
+                    protocolVersion: z.ZodLiteral<1>;
+                    ownerId: z.ZodString;
+                    hostVersion: z.ZodString;
+                    providerId: z.ZodString;
+                    storeId: z.ZodString;
+                    participants: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        version: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                resources: z.ZodArray<z.ZodObject<{
+                    ownerId: z.ZodString;
+                    resourceId: z.ZodString;
+                    revision: z.ZodString;
+                    kind: z.ZodEnum<{
+                        transcript: "transcript";
+                        workspace: "workspace";
+                        index: "index";
+                        cache: "cache";
+                        attachment: "attachment";
+                        spill: "spill";
+                        coordination: "coordination";
+                    }>;
+                    disposition: z.ZodEnum<{
+                        erase: "erase";
+                        "release-reference": "release-reference";
+                        "retain-shared": "retain-shared";
+                        "retain-coordination": "retain-coordination";
+                    }>;
+                    retention: z.ZodNullable<z.ZodObject<{
+                        reason: z.ZodEnum<{
+                            "shared-reference": "shared-reference";
+                            "coordination-identity": "coordination-identity";
+                        }>;
+                        retainedBy: z.ZodArray<z.ZodObject<{
+                            storeId: z.ZodString;
+                            sessionId: z.ZodString;
+                            lifecycleId: z.ZodString;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            authorizationId: z.ZodNullable<z.ZodUUID>;
+            phase: z.ZodEnum<{
+                rejected: "rejected";
+                conflict: "conflict";
+                done: "done";
+                fenced: "fenced";
+                quiesced: "quiesced";
+                erasing: "erasing";
+                converging: "converging";
+            }>;
+            reason: z.ZodNullable<z.ZodString>;
+            resources: z.ZodArray<z.ZodObject<{
+                ownerId: z.ZodString;
+                resourceId: z.ZodString;
+                status: z.ZodEnum<{
+                    erased: "erased";
+                    "reference-released": "reference-released";
+                    retained: "retained";
+                    failed: "failed";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+/** Browser-safe contract. Native archive is the sole entry path. */
+export interface SessionBinRemoteApi {
+    prepare(request: ArchivePrepareRequest, signal?: AbortSignal): Promise<RemoteResult<ArchivePlan>>;
+    execute(plan: ArchivePlan, signal?: AbortSignal): Promise<RemoteResult<ArchiveResult>>;
+    list(signal?: AbortSignal): Promise<RemoteResult<ArchiveEntry[]>>;
+    getOperation(operationId: string, signal?: AbortSignal): Promise<RemoteResult<ArchiveOperation | BinOperation | null>>;
+    preparePurge(request: PreparePurgeRequest, signal?: AbortSignal): Promise<RemoteResult<PurgePlan>>;
+    executePurge(plan: PurgePlan, signal?: AbortSignal): Promise<RemoteResult<PurgeResult>>;
+    getPurgeOperation(operationId: string, signal?: AbortSignal): Promise<RemoteResult<PurgeOperation | null>>;
+    purgeOperations(signal?: AbortSignal): Promise<RemoteResult<PurgeOperation[]>>;
+    follow(signal?: AbortSignal): RemoteStreamHandle<BinSnapshot, never>;
+}
+export declare const binRemoteErrorCodes: readonly ["bin/closed", "bin/recovery-required", "bin/not-ready", "bin/operation-id-reused"];
+export type BinRemoteErrorCode = typeof binRemoteErrorCodes[number];
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface RemoteErrorDetailsMap {
+        'bin/closed': {};
+        'bin/recovery-required': {};
+        'bin/not-ready': {};
+        'bin/operation-id-reused': {};
+    }
+}
+export declare const sessionBinRemoteContribution: TypertRemoteContribution;
+export declare const sessionBinHostContribution: TypertContribution;