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

package/dist/types/client/locales.d.ts

@@ -0,0 +1,116 @@
+import type { LocaleDictOf } from '@deepseek-ai/dsh-client-ui-slots';
+export declare const NS = "dshSessionBin";
+export declare const en: {
+    readonly title: "Session Bin";
+    readonly count: "{count} conversations";
+    readonly countOne: "{count} conversation";
+    readonly description: "Manage native archives with search, filters, unarchive, and explicit permanent deletion.";
+    readonly unarchive: "Unarchive";
+    readonly unarchiveSelected: "Unarchive selected";
+    readonly refresh: "Refresh";
+    readonly search: "Search archives";
+    readonly workspace: "Workspace filter";
+    readonly allWorkspaces: "All workspaces";
+    readonly ungrouped: "Ungrouped";
+    readonly unnamedWorkspace: "Untitled workspace";
+    readonly unnamed: "Untitled conversation";
+    readonly loading: "Loading archives…";
+    readonly empty: "No archived conversations";
+    readonly emptyHint: "Use Archive in the conversation menu to collect conversations here.";
+    readonly noMatches: "No matching conversations";
+    readonly noMatchesHint: "Try another search or workspace.";
+    readonly select: "Select {title}";
+    readonly selectAll: "Select visible conversations";
+    readonly selected: "{count} selected";
+    readonly clearSelection: "Clear selection";
+    readonly entries: "Archived conversations";
+    readonly unarchived: "Conversation unarchived";
+    readonly resultSuccess: "Unarchived";
+    readonly resultRejected: "Skipped";
+    readonly resultConflict: "State changed";
+    readonly resultPending: "Awaiting confirmation";
+    readonly results: "Latest operation results";
+    readonly pending: "{count} operation results need confirmation.";
+    readonly pendingOne: "{count} operation result needs confirmation.";
+    readonly checkPending: "Check and retry";
+    readonly checkResults: "Check results";
+    readonly connectionFailed: "Session Bin could not connect. Refresh to try again.";
+    readonly pendingResult: "The operation result is not confirmed yet. Check it before trying another action.";
+    readonly pendingDeletion: "Permanent deletion needs recovery before this conversation can be unarchived.";
+    readonly legacyPending: "An earlier Bin operation is awaiting a receipt. Checking only queries its result; it will not be replayed.";
+    readonly active: "This conversation has running work. Try again after it finishes.";
+    readonly stateChanged: "The conversation changed. Refresh and choose it again.";
+    readonly missing: "This conversation is no longer available.";
+    readonly notArchived: "This conversation is no longer archived.";
+    readonly operationFailed: "The operation could not finish. Refresh and try again.";
+    readonly retry: "Try again";
+    readonly permanentDelete: "Permanent delete";
+    readonly deleteConversation: "Permanently delete {title}";
+    readonly deleteTitle: "Permanently delete “{title}”?";
+    readonly deleteDescription: "Delete this one conversation’s logs and its session metadata and indexes. This cannot be undone.";
+    readonly deleteScope: "Shared attachments, independent forks, and copies in external tools are kept. Loaded conversations, retained readers, unknown files, and active writers can block deletion.";
+    readonly deletionAcknowledge: "I understand that this conversation cannot be restored.";
+    readonly cancelDeletion: "Cancel";
+    readonly confirmDeletion: "Delete permanently";
+    readonly closeDeletion: "Close confirmation";
+    readonly discardMissingDeletion: "Discard missing request";
+    readonly deletionBlockers: "Reasons deletion is blocked";
+    readonly deletionResults: "Permanent deletion results";
+    readonly deleted: "Conversation permanently deleted";
+    readonly checkDeletion: "Check deletion result";
+    readonly continueDeletion: "Continue same deletion";
+    readonly prepareDeletionAgain: "Prepare and confirm again";
+    readonly deletionPending: "Deletion is unfinished or its result is unknown. Check the saved operation before another action.";
+    readonly deletionMissing: "No matching deletion receipt was found. A fresh preparation and confirmation are required; deletion will not be replayed automatically.";
+    readonly deletionPartial: "Only part of the deletion is confirmed. The conversation remains protected until the same operation completes.";
+    readonly deletionUnsupported: "Permanent deletion is not supported by this Host and storage combination.";
+    readonly deletionLive: "This conversation is still loaded. Close its running work and let the Host release it before preparing deletion again.";
+    readonly deletionRetained: "A reader, subscription, or pending cache write still holds this conversation. Deletion remains blocked.";
+    readonly deletionWriter: "Another writer holds this conversation’s log. Wait for it to close before trying again.";
+    readonly deletionSubagent: "This conversation has subagent resources that cannot be deleted through this single-conversation operation.";
+    readonly deletionChanged: "The conversation lifecycle or confirmed resource scope changed. Prepare and confirm the target again.";
+    readonly deletionProtected: "The Host could not verify this conversation’s files or resources. Deletion remains blocked.";
+    readonly purgeCacheCapacity: "Local deletion records awaiting confirmation exceed capacity. Only check existing results; new deletions are temporarily disabled.";
+    readonly clearAllArchived: "Clear all archived ({count})";
+    readonly permanentlyDeleteSelected: "Permanently delete selected";
+    readonly batchSelectionTitle: "Permanently delete {count} selected conversations?";
+    readonly batchAllTitle: "Clear all {count} archived conversations?";
+    readonly batchPreparingDescription: "Preparing and checking each fixed target. Closing stops targets that have not started preparation.";
+    readonly batchConfirmDescription: "Review the fixed targets and resource scope before starting this irreversible batch.";
+    readonly batchRunningDescription: "Deletion runs one conversation at a time. Stop prevents unsent conversations; the current operation still finishes and remains protected.";
+    readonly closeBatchDeletion: "Close batch deletion";
+    readonly confirmBatchDeletion: "Delete executable conversations";
+    readonly stopBatchDeletion: "Stop remaining deletions";
+    readonly batchSummary: "{total} fixed · {executable} executable · {blocked} blocked";
+    readonly batchPreparationProgress: "Checked {prepared} of {total}";
+    readonly batchScope: "Executable conversations lose their logs, session metadata, and indexes permanently. Blocked conversations are not sent for deletion.";
+    readonly batchResources: "Combined resource scope";
+    readonly resourceErase: "Erase";
+    readonly resourceReleaseReference: "Release references";
+    readonly resourceRetainShared: "Keep shared";
+    readonly resourceRetainCoordination: "Keep coordination records";
+    readonly batchRetainedCopies: "Shared attachments, independent forks, and copies in external tools remain available.";
+    readonly batchItems: "Fixed deletion targets";
+    readonly batchAcknowledge: "I understand that executable conversations cannot be restored.";
+    readonly batchItemPreparing: "Checking deletion scope";
+    readonly batchItemReady: "Ready to delete";
+    readonly batchItemRunning: "Deletion in progress";
+    readonly batchItemCancelled: "Not sent";
+    readonly batchItemBlocked: "Blocked: {reason}";
+    readonly batchItemDeleted: "Permanently deleted";
+    readonly batchStatus: "Batch deletion status";
+    readonly batchPausedTitle: "Batch deletion paused";
+    readonly batchPausedDescription: "Review or handle the current operation first, then continue the remaining conversations.";
+    readonly batchDoneTitle: "Batch deletion complete";
+    readonly batchCancelledTitle: "Batch deletion stopped";
+    readonly batchOutcome: "{success} deleted · {unresolved} still needs attention";
+    readonly continueBatchDeletion: "Continue remaining";
+    readonly dismissBatchDeletion: "Dismiss batch results";
+};
+export type BinLocaleKey = keyof typeof en;
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        dshSessionBin: BinLocaleKey;
+    }
+}
+export declare const zh: LocaleDictOf<typeof NS>;

package/dist/types/client/model.d.ts

@@ -0,0 +1,137 @@
+import type { RemoteStream } from '@deepseek-ai/dsh-api-gateway/client';
+import type { BinPlan } from '../operations/schema.js';
+import type { ArchiveEntry, ArchivePlan, ArchiveResult } from '../operations/archive.js';
+import type { PurgePlan } from '../operations/retirement.js';
+import type { SessionBinRemoteApi, BinSnapshot } from '../remote/contracts.js';
+import type { PurgeBatchScope, PurgeBatchState, PurgeClientOutcome } from './purge-batch.js';
+export { retirementManifestDigest } from './retirement-digest.js';
+export type { PurgeBatchItem, PurgeBatchScope, PurgeBatchState, PurgeClientOutcome } from './purge-batch.js';
+export type PendingPlan = ArchivePlan | BinPlan;
+export interface ClientOutcome {
+    sessionId: string;
+    entryId: string | null;
+    status: ArchiveResult['status'] | 'pending';
+    reason: string | null;
+}
+export interface BinNotice {
+    sequence: number;
+    kind: 'unarchived' | 'deleted' | 'failed';
+    sessionId: string;
+    entryId: string | null;
+    reason: string | null;
+}
+export interface PurgeConfirmation {
+    plan: PurgePlan;
+    title: string;
+    acknowledged: boolean;
+}
+export interface BinClientState {
+    phase: 'loading' | 'ready' | 'error';
+    entries: readonly ArchiveEntry[];
+    busy: readonly string[];
+    pending: readonly PendingPlan[];
+    results: readonly ClientOutcome[];
+    error: string | null;
+    notice: BinNotice | null;
+    purgeConfirmation: PurgeConfirmation | null;
+    purgePending: readonly PurgePlan[];
+    purgeResults: readonly PurgeClientOutcome[];
+    purgeBatch: PurgeBatchState | null;
+    purgeBatchOperationIds: readonly string[];
+    purgeCacheBlocked: boolean;
+}
+export interface PurgeGrantSnapshot {
+    operationId: string;
+    authorizationId: string;
+}
+export interface PurgeGrantObservationSnapshot {
+    operationId: string;
+}
+export interface PendingCache {
+    load(): unknown;
+    save(plans: readonly PendingPlan[]): void;
+    loadPurge?(): unknown;
+    savePurge?(plans: readonly PurgePlan[], batchOperationIds?: readonly string[]): void;
+    loadPurgeGrants?(): unknown;
+    savePurgeGrants?(grants: readonly PurgeGrantSnapshot[]): void;
+    loadPurgeGrantObservations?(): unknown;
+    stagePurgeGrantObservation?(operationId: string): void;
+    loadPurgeBatchOperations?(): unknown;
+    isPurgeCacheBlocked?(): boolean;
+}
+/** One browser page model; native mutations only pass through the Host API. */
+export declare class SessionBinClientModel {
+    private readonly api;
+    private readonly createStream;
+    private readonly cache?;
+    private state;
+    private snapshot;
+    private readonly listeners;
+    private readonly lifetime;
+    private stream;
+    private consumption;
+    private epoch;
+    private noticeSequence;
+    private readonly checking;
+    private readonly purgeExecuting;
+    private readonly purgeChecking;
+    private purgeDiscovering;
+    private readonly settledPurgeIds;
+    private readonly observedPurgeGrants;
+    private readonly uncertainPurgeGrants;
+    private readonly unpersistedPurgeGrants;
+    private readonly batchPurgeOperationIds;
+    private confirmation;
+    private purgeBatch;
+    private purgeBatchRun;
+    private purgePreparationEpoch;
+    constructor(api: SessionBinRemoteApi, createStream: () => RemoteStream<BinSnapshot>, cache?: PendingCache | undefined);
+    getSnapshot: () => BinClientState;
+    subscribe: (listener: () => void) => (() => void);
+    private publish;
+    private persist;
+    private pending;
+    refresh(): Promise<void>;
+    dispose(): Promise<void>;
+    dismissNotice(): void;
+    private hasActivePurgeBatch;
+    private isPurgeCacheBlocked;
+    private rejectPurgeCacheCapacity;
+    private publishPurgeBatch;
+    private savePurgePending;
+    private persistPurgeGrants;
+    private stagePurgeGrantObservation;
+    private validatePurgeOwnerState;
+    private purgeOutcome;
+    private publishConfirmation;
+    private requestPurgePlan;
+    preparePurge(entry: Pick<ArchiveEntry, 'sessionId' | 'entryId'>, title: string): Promise<PurgePlan | null>;
+    acknowledgePurge(acknowledged: boolean): void;
+    cancelPurge(): void;
+    confirmPurge(): Promise<PurgeClientOutcome | undefined>;
+    preparePurgeBatch(scope: PurgeBatchScope, titlesBySessionId?: Readonly<Record<string, string>>): Promise<PurgeBatchState | null>;
+    acknowledgePurgeBatch(acknowledged: boolean): void;
+    runPurgeBatch(): Promise<PurgeBatchState | undefined>;
+    stopPurgeBatch(): void;
+    dismissPurgeBatch(): void;
+    private readPurgeOperation;
+    private discoverPurgePending;
+    /** Automatic checks and reload only observe; no missing or unfinished deletion is replayed. */
+    checkPurgePending(): Promise<void>;
+    /** Explicit continuation may only submit a known saved operation's original plan. */
+    retryPurge(operationId: string): Promise<PurgeClientOutcome | undefined>;
+    /** A confirmed missing operation requires fresh preparation and another explicit confirmation. */
+    preparePurgeAgain(operationId: string, title: string): Promise<PurgePlan | null>;
+    discardMissingPurge(operationId: string): Promise<boolean>;
+    private settlePurge;
+    private runPurge;
+    unarchive(entry: Pick<ArchiveEntry, 'sessionId' | 'entryId'>): Promise<ClientOutcome>;
+    unarchiveMany(entries: readonly ArchiveEntry[]): Promise<ClientOutcome[]>;
+    /** Baselines only query receipts. Explicit retry can resend the same missing
+     * v2 unarchive identity/plan; v1 bin/restore plans remain query-only forever.
+     */
+    checkPending(retryMissing?: boolean): Promise<void>;
+    private settle;
+    private run;
+}
+export declare function browserPendingCache(storage: Storage): PendingCache;

package/dist/types/client/purge-batch.d.ts

@@ -0,0 +1,45 @@
+import type { PurgePlan, PurgeResult } from '../operations/retirement.js';
+export type PurgeBatchScope = {
+    kind: 'selection';
+    entryIds: readonly string[];
+} | {
+    kind: 'all-archived';
+};
+export interface PurgeClientOutcome {
+    operationId: string;
+    sessionId: string;
+    entryId: string | null;
+    status: PurgeResult['status'] | 'pending';
+    reason: string | null;
+}
+export interface PurgeBatchTarget {
+    sessionId: string;
+    entryId: string;
+    title: string;
+}
+export interface PurgeBatchItem {
+    target: PurgeBatchTarget;
+    state: 'preparing' | 'blocked' | 'ready' | 'running' | 'settled' | 'cancelled';
+    plan: PurgePlan | null;
+    reason: string | null;
+    outcome: PurgeClientOutcome | null;
+}
+export interface PurgeBatchResourceCounts {
+    erase: number;
+    releaseReference: number;
+    retainShared: number;
+    retainCoordination: number;
+}
+export interface PurgeBatchState {
+    batchId: string;
+    scope: 'selection' | 'all-archived';
+    phase: 'preparing' | 'confirming' | 'running' | 'paused' | 'done' | 'cancelled';
+    frozenCount: number;
+    acknowledged: boolean;
+    stopRequested: boolean;
+    items: PurgeBatchItem[];
+    resourceCounts: PurgeBatchResourceCounts;
+}
+export declare function emptyPurgeBatchResourceCounts(): PurgeBatchResourceCounts;
+export declare function countPurgeBatchResources(items: readonly PurgeBatchItem[]): PurgeBatchResourceCounts;
+export declare function clonePurgeBatch(batch: PurgeBatchState | null): PurgeBatchState | null;

package/dist/types/client/retirement-digest.d.ts

@@ -0,0 +1,3 @@
+import type { RetirementManifest } from '../operations/retirement.js';
+export declare function canonicalRetirementManifest(input: RetirementManifest): string;
+export declare function retirementManifestDigest(input: RetirementManifest): string;

package/dist/types/operations/archive.d.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+export declare const archiveEntrySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    sessionId: z.ZodString;
+    entryId: z.ZodUUID;
+}, z.core.$strict>;
+export declare const archivePlanSchema: 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>;
+export declare const archiveResultSchema: 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>;
+export declare const archiveOperationSchema: 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>;
+export declare const archivePrepareRequestSchema: z.ZodObject<{
+    action: z.ZodLiteral<"unarchive">;
+    sessionId: z.ZodString;
+    operationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ArchiveEntry = z.infer<typeof archiveEntrySchema>;
+export type ArchivePlan = z.infer<typeof archivePlanSchema>;
+export type ArchiveResult = z.infer<typeof archiveResultSchema>;
+export type ArchiveOperation = z.infer<typeof archiveOperationSchema>;
+export type ArchivePrepareRequest = z.infer<typeof archivePrepareRequestSchema>;