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

package/dist/host/retirement-store.d.ts

@@ -0,0 +1,311 @@
+import type { Domain } from '@deepseek-ai/dsh-storage-domain';
+import type { PurgeOperation, RetirementBinding } from '../operations/retirement.js';
+/** Separate sidecar accepts unchanged legacy v1 records and explicitly tagged native v2 records.
+ * Its storage domain version stays 1; no automatic data migration or native mutation. */
+export declare const retirementDomainSpec: {
+    readonly name: "session_bin_purge";
+    readonly version: 1;
+    readonly layout: "single";
+    readonly tables: {
+        readonly bindings: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            schemaVersion: 1;
+            entryId: string;
+            entryVersion: 1;
+            lifecycle: {
+                storeId: string;
+                sessionId: string;
+                lifecycleId: string;
+            };
+            capabilities: {
+                protocolVersion: 1;
+                ownerId: string;
+                hostVersion: string;
+                providerId: string;
+                storeId: string;
+                participants: {
+                    id: string;
+                    version: string;
+                }[];
+            };
+        } | {
+            schemaVersion: 2;
+            target: "native-archive";
+            entryId: string;
+            entryVersion: 2;
+            lifecycle: {
+                storeId: string;
+                sessionId: string;
+                lifecycleId: string;
+            };
+            capabilities: {
+                protocolVersion: 1;
+                ownerId: string;
+                hostVersion: string;
+                providerId: string;
+                storeId: string;
+                participants: {
+                    id: string;
+                    version: string;
+                }[];
+            };
+        }>;
+        readonly operations: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            schemaVersion: 1 | 2;
+            plan: {
+                schemaVersion: 1 | 2;
+                action: "purge";
+                operationId: string;
+                sessionId: string;
+                expectedEntryId: string | null;
+                binding: {
+                    schemaVersion: 1;
+                    entryId: string;
+                    entryVersion: 1;
+                    lifecycle: {
+                        storeId: string;
+                        sessionId: string;
+                        lifecycleId: string;
+                    };
+                    capabilities: {
+                        protocolVersion: 1;
+                        ownerId: string;
+                        hostVersion: string;
+                        providerId: string;
+                        storeId: string;
+                        participants: {
+                            id: string;
+                            version: string;
+                        }[];
+                    };
+                } | {
+                    schemaVersion: 2;
+                    target: "native-archive";
+                    entryId: string;
+                    entryVersion: 2;
+                    lifecycle: {
+                        storeId: string;
+                        sessionId: string;
+                        lifecycleId: string;
+                    };
+                    capabilities: {
+                        protocolVersion: 1;
+                        ownerId: string;
+                        hostVersion: string;
+                        providerId: string;
+                        storeId: string;
+                        participants: {
+                            id: string;
+                            version: string;
+                        }[];
+                    };
+                } | null;
+                manifest: {
+                    schemaVersion: 1;
+                    lifecycle: {
+                        storeId: string;
+                        sessionId: string;
+                        lifecycleId: string;
+                    };
+                    capabilities: {
+                        protocolVersion: 1;
+                        ownerId: string;
+                        hostVersion: string;
+                        providerId: string;
+                        storeId: string;
+                        participants: {
+                            id: string;
+                            version: string;
+                        }[];
+                    };
+                    resources: {
+                        ownerId: string;
+                        resourceId: string;
+                        revision: string;
+                        kind: "transcript" | "workspace" | "index" | "cache" | "attachment" | "spill" | "coordination";
+                        disposition: "erase" | "release-reference" | "retain-shared" | "retain-coordination";
+                        retention: {
+                            reason: "shared-reference" | "coordination-identity";
+                            retainedBy: {
+                                storeId: string;
+                                sessionId: string;
+                                lifecycleId: string;
+                            }[];
+                        } | null;
+                    }[];
+                } | null;
+                blockers: {
+                    code: string;
+                    activity?: string[] | undefined;
+                }[];
+            };
+            createdAt: string;
+            phase: "intent" | "done" | "authorizing" | "owner-pending";
+            entry: {
+                schemaVersion: 1;
+                sessionId: string;
+                entryId: string;
+                operationId: string;
+                binnedAt: string;
+                workspaceIdAtBin: string | null;
+                wasArchived: boolean;
+            } | {
+                schemaVersion: 2;
+                sessionId: string;
+                entryId: string;
+            } | null;
+            authorizationId: string | null;
+            ownerState: {
+                schemaVersion: 1;
+                request: {
+                    operationId: string;
+                    expected: {
+                        storeId: string;
+                        sessionId: string;
+                        lifecycleId: string;
+                    };
+                    bin: {
+                        entryId: string;
+                        entryVersion: 1;
+                    } | {
+                        kind: "native-archive";
+                        entryId: string;
+                        entryVersion: 2;
+                    };
+                    manifestDigest: string;
+                };
+                manifest: {
+                    schemaVersion: 1;
+                    lifecycle: {
+                        storeId: string;
+                        sessionId: string;
+                        lifecycleId: string;
+                    };
+                    capabilities: {
+                        protocolVersion: 1;
+                        ownerId: string;
+                        hostVersion: string;
+                        providerId: string;
+                        storeId: string;
+                        participants: {
+                            id: string;
+                            version: string;
+                        }[];
+                    };
+                    resources: {
+                        ownerId: string;
+                        resourceId: string;
+                        revision: string;
+                        kind: "transcript" | "workspace" | "index" | "cache" | "attachment" | "spill" | "coordination";
+                        disposition: "erase" | "release-reference" | "retain-shared" | "retain-coordination";
+                        retention: {
+                            reason: "shared-reference" | "coordination-identity";
+                            retainedBy: {
+                                storeId: string;
+                                sessionId: string;
+                                lifecycleId: string;
+                            }[];
+                        } | null;
+                    }[];
+                };
+                authorizationId: string | null;
+                phase: "rejected" | "conflict" | "done" | "fenced" | "quiesced" | "erasing" | "converging";
+                reason: string | null;
+                resources: {
+                    ownerId: string;
+                    resourceId: string;
+                    status: "erased" | "reference-released" | "retained" | "failed";
+                    reason: string | null;
+                }[];
+            } | null;
+            result: {
+                action: "purge";
+                operationId: string;
+                sessionId: string;
+                entryId: string | null;
+                status: "success" | "rejected" | "conflict" | "pending-recovery" | "partial-failure";
+                reason: string | null;
+                ownerState: {
+                    schemaVersion: 1;
+                    request: {
+                        operationId: string;
+                        expected: {
+                            storeId: string;
+                            sessionId: string;
+                            lifecycleId: string;
+                        };
+                        bin: {
+                            entryId: string;
+                            entryVersion: 1;
+                        } | {
+                            kind: "native-archive";
+                            entryId: string;
+                            entryVersion: 2;
+                        };
+                        manifestDigest: string;
+                    };
+                    manifest: {
+                        schemaVersion: 1;
+                        lifecycle: {
+                            storeId: string;
+                            sessionId: string;
+                            lifecycleId: string;
+                        };
+                        capabilities: {
+                            protocolVersion: 1;
+                            ownerId: string;
+                            hostVersion: string;
+                            providerId: string;
+                            storeId: string;
+                            participants: {
+                                id: string;
+                                version: string;
+                            }[];
+                        };
+                        resources: {
+                            ownerId: string;
+                            resourceId: string;
+                            revision: string;
+                            kind: "transcript" | "workspace" | "index" | "cache" | "attachment" | "spill" | "coordination";
+                            disposition: "erase" | "release-reference" | "retain-shared" | "retain-coordination";
+                            retention: {
+                                reason: "shared-reference" | "coordination-identity";
+                                retainedBy: {
+                                    storeId: string;
+                                    sessionId: string;
+                                    lifecycleId: string;
+                                }[];
+                            } | null;
+                        }[];
+                    };
+                    authorizationId: string | null;
+                    phase: "rejected" | "conflict" | "done" | "fenced" | "quiesced" | "erasing" | "converging";
+                    reason: string | null;
+                    resources: {
+                        ownerId: string;
+                        resourceId: string;
+                        status: "erased" | "reference-released" | "retained" | "failed";
+                        reason: string | null;
+                    }[];
+                } | null;
+            } | null;
+        }>;
+    };
+};
+export interface RetirementStore {
+    binding(entryId: string): RetirementBinding | undefined;
+    putBinding(binding: RetirementBinding): Promise<void>;
+    operation(operationId: string): PurgeOperation | undefined;
+    operations(): PurgeOperation[];
+    putOperation(operation: PurgeOperation): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class DomainRetirementStore implements RetirementStore {
+    private readonly domain;
+    constructor(domain: Domain<typeof retirementDomainSpec>);
+    binding(entryId: string): RetirementBinding | undefined;
+    putBinding(value: RetirementBinding): Promise<void>;
+    operation(operationId: string): PurgeOperation | undefined;
+    operations(): PurgeOperation[];
+    putOperation(value: PurgeOperation): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/host/retirement.d.ts

@@ -0,0 +1,76 @@
+import type { BinEntry } from '../operations/schema.js';
+import type { ArchiveEntry } from '../operations/archive.js';
+import type { LifecycleKey, PreparePurgeRequest, PurgeOperation, PurgePlan, PurgeResult, RetirementCapabilities, RetirementManifest, RetirementRequest, RetirementState, RetirementAuthorization } from '../operations/retirement.js';
+import type { RetirementStore } from './retirement-store.js';
+export declare function isRetirementOwnerRefusal(error: unknown): boolean;
+export declare function retirementOwnerRefusal(reason: string): Error;
+/** The resource owner implements its own durable admission fence and recovery.
+ * This interface is a plugin seam, not a native DSH SDK service. */
+export interface SessionRetirementOwnerV1 {
+    capabilities(): Promise<RetirementCapabilities>;
+    eligibility?(sessionId: string): Promise<string | null>;
+    inspect(sessionId: string): Promise<LifecycleKey | null>;
+    prepare(expected: LifecycleKey): Promise<RetirementManifest>;
+    retire(request: RetirementRequest, authorize: () => Promise<RetirementAuthorization>, frozenManifest?: RetirementManifest): Promise<RetirementState>;
+    getOperation(operationId: string): Promise<RetirementState | null>;
+    recover(operationId: string): Promise<RetirementState>;
+}
+export interface RetirementOptions {
+    store: RetirementStore;
+    /** False when the composition closes a journal shared by multiple consumers after draining both. */
+    closeStore?: boolean;
+    owner?: SessionRetirementOwnerV1;
+    resolveOwner?: () => Promise<SessionRetirementOwnerV1 | undefined>;
+    /** Admission is supplied by the Host composition, never by owner self-report or Client Config. */
+    verified?: (capabilities: RetirementCapabilities) => boolean;
+    /** Separate qualification for native archive admission and visibility coordination. */
+    verifiedNativeArchive?: (capabilities: RetirementCapabilities) => boolean;
+}
+export interface PurgeHooks {
+    newRequestsDisabled?: boolean;
+    target?: 'native-archive';
+    entry(sessionId: string): BinEntry | ArchiveEntry | undefined;
+    invalidated(entryId: string): boolean;
+    archived(sessionId: string): Promise<boolean>;
+    activity(sessionId: string): Promise<string[]>;
+    deleteEntry(sessionId: string): Promise<void>;
+    hasArchiveOperation(operationId: string): boolean;
+    hasPendingArchiveOperation(sessionId: string): boolean;
+}
+export interface PurgeReconcileReport {
+    completed: PurgeResult[];
+    pending: string[];
+}
+export declare function retirementManifestDigest(input: RetirementManifest): string;
+/** Inner operations only: the owning archive/legacy Module supplies the queue, failure fence and lifetime lease. */
+export declare class SessionBinPurgeModule {
+    private readonly options;
+    private readonly hooks;
+    private readonly store;
+    constructor(options: RetirementOptions, hooks: PurgeHooks);
+    operation(operationId: string): PurgeOperation | undefined;
+    operations(): PurgeOperation[];
+    blocks(sessionId: string): boolean;
+    blocksTarget(sessionId: string): boolean;
+    ownsPendingEntry(entryId: string): boolean;
+    close(): Promise<void>;
+    capture(entry: BinEntry): Promise<void>;
+    bindingMatches(entry: BinEntry): Promise<boolean>;
+    prepare(input: PreparePurgeRequest): Promise<PurgePlan>;
+    execute(input: PurgePlan): Promise<PurgeResult>;
+    reconcile(resume?: boolean): Promise<PurgeReconcileReport>;
+    private ownerCall;
+    private refusalReason;
+    private eligibility;
+    private admittedCapabilities;
+    private check;
+    private checkInner;
+    private validateManifest;
+    private validateOwnerState;
+    private recover;
+    private assertProgress;
+    private acceptState;
+    private pendingResult;
+    private finalize;
+    private finish;
+}

package/dist/host/store.d.ts

@@ -0,0 +1,215 @@
+import type { Domain } from '@deepseek-ai/dsh-storage-domain';
+import type { ArchiveEntry, ArchiveOperation } from '../operations/archive.js';
+import type { BinEntry, BinOperation } from '../operations/schema.js';
+export declare const binDomainSpec: {
+    readonly name: "session_bin";
+    readonly version: 1;
+    readonly layout: "single";
+    readonly tables: {
+        readonly entries: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            schemaVersion: 1;
+            sessionId: string;
+            entryId: string;
+            operationId: string;
+            binnedAt: string;
+            workspaceIdAtBin: string | null;
+            wasArchived: boolean;
+        }>;
+        readonly operations: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            schemaVersion: 1;
+            plan: {
+                schemaVersion: 1;
+                operationId: string;
+                action: "bin" | "restore";
+                sessionId: string;
+                expected: {
+                    archived: boolean;
+                    entryId: string | null;
+                };
+                blockers: {
+                    code: string;
+                    activity?: string[] | undefined;
+                }[];
+            };
+            createdAt: string;
+            phase: "intent" | "applied" | "done";
+            ownershipInvalidated: boolean;
+            entry: {
+                schemaVersion: 1;
+                sessionId: string;
+                entryId: string;
+                operationId: string;
+                binnedAt: string;
+                workspaceIdAtBin: string | null;
+                wasArchived: boolean;
+            } | null;
+            result: {
+                operationId: string;
+                action: "bin" | "restore";
+                sessionId: string;
+                status: "success" | "rejected" | "conflict";
+                reason: string | null;
+                entryId: string | null;
+            } | null;
+        }>;
+    };
+};
+export interface BinStore {
+    entries(): BinEntry[];
+    operations(): BinOperation[];
+    entry(sessionId: string): BinEntry | undefined;
+    operation(operationId: string): BinOperation | undefined;
+    putEntry(entry: BinEntry): Promise<void>;
+    deleteEntry(sessionId: string): Promise<void>;
+    putOperation(operation: BinOperation): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class DomainBinStore implements BinStore {
+    private readonly domain;
+    constructor(domain: Domain<typeof binDomainSpec>);
+    entries(): BinEntry[];
+    operations(): BinOperation[];
+    entry(sessionId: string): BinEntry | undefined;
+    operation(operationId: string): BinOperation | undefined;
+    putEntry(value: BinEntry): Promise<void>;
+    deleteEntry(sessionId: string): Promise<void>;
+    putOperation(value: BinOperation): Promise<void>;
+    close(): Promise<void>;
+}
+/** Observation identities live apart from the immutable v1 ownership journal. */
+export declare const archiveDomainSpec: {
+    readonly name: "session_archive";
+    readonly version: 1;
+    readonly layout: "single";
+    readonly tables: {
+        readonly entries: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            schemaVersion: 2;
+            sessionId: string;
+            entryId: string;
+        }>;
+        readonly operations: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            schemaVersion: 2;
+            plan: {
+                schemaVersion: 2;
+                operationId: string;
+                action: "unarchive";
+                sessionId: string;
+                expected: {
+                    archived: boolean;
+                    entryId: string | null;
+                };
+                blockers: {
+                    code: string;
+                    activity?: string[] | undefined;
+                }[];
+            };
+            createdAt: string;
+            phase: "intent" | "applied" | "done";
+            entry: {
+                schemaVersion: 2;
+                sessionId: string;
+                entryId: string;
+            } | null;
+            result: {
+                operationId: string;
+                action: "unarchive";
+                sessionId: string;
+                status: "success" | "rejected" | "conflict";
+                reason: string | null;
+                entryId: string | null;
+            } | null;
+        }>;
+    };
+};
+export interface ArchiveStore {
+    entries(): ArchiveEntry[];
+    entry(sessionId: string): ArchiveEntry | undefined;
+    operations(): ArchiveOperation[];
+    operation(operationId: string): ArchiveOperation | undefined;
+    putEntry(entry: ArchiveEntry): Promise<void>;
+    deleteEntry(sessionId: string): Promise<void>;
+    putOperation(operation: ArchiveOperation): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class DomainArchiveStore implements ArchiveStore {
+    private readonly domain;
+    constructor(domain: Domain<typeof archiveDomainSpec>);
+    entries(): {
+        schemaVersion: 2;
+        sessionId: string;
+        entryId: string;
+    }[];
+    entry(sessionId: string): {
+        schemaVersion: 2;
+        sessionId: string;
+        entryId: string;
+    } | undefined;
+    operations(): {
+        schemaVersion: 2;
+        plan: {
+            schemaVersion: 2;
+            operationId: string;
+            action: "unarchive";
+            sessionId: string;
+            expected: {
+                archived: boolean;
+                entryId: string | null;
+            };
+            blockers: {
+                code: string;
+                activity?: string[] | undefined;
+            }[];
+        };
+        createdAt: string;
+        phase: "intent" | "applied" | "done";
+        entry: {
+            schemaVersion: 2;
+            sessionId: string;
+            entryId: string;
+        } | null;
+        result: {
+            operationId: string;
+            action: "unarchive";
+            sessionId: string;
+            status: "success" | "rejected" | "conflict";
+            reason: string | null;
+            entryId: string | null;
+        } | null;
+    }[];
+    operation(operationId: string): {
+        schemaVersion: 2;
+        plan: {
+            schemaVersion: 2;
+            operationId: string;
+            action: "unarchive";
+            sessionId: string;
+            expected: {
+                archived: boolean;
+                entryId: string | null;
+            };
+            blockers: {
+                code: string;
+                activity?: string[] | undefined;
+            }[];
+        };
+        createdAt: string;
+        phase: "intent" | "applied" | "done";
+        entry: {
+            schemaVersion: 2;
+            sessionId: string;
+            entryId: string;
+        } | null;
+        result: {
+            operationId: string;
+            action: "unarchive";
+            sessionId: string;
+            status: "success" | "rejected" | "conflict";
+            reason: string | null;
+            entryId: string | null;
+        } | null;
+    } | undefined;
+    putEntry(value: ArchiveEntry): Promise<void>;
+    deleteEntry(sessionId: string): Promise<void>;
+    putOperation(value: ArchiveOperation): Promise<void>;
+    close(): Promise<void>;
+}