@yadsh/dsh-draft-sessions 0.2.0

package/lib/constants-vAKitj5i.js

@@ -0,0 +1,11 @@
+//#region src/shared/constants.ts
+/** On-disk format version. Bump only with an explicit migration. */
+const DRAFT_FILE_VERSION = 1;
+/** Current draft record format. */
+const DRAFT_SESSION_VERSION = 1;
+/** Default maximum number of drafts in a workspace. */
+const DEFAULT_MAX_DRAFTS_PER_WORKSPACE = 50;
+/** Default maximum length of a title derived by consumers. */
+const DEFAULT_TITLE_MAX_LENGTH = 80;
+//#endregion
+export { DRAFT_SESSION_VERSION as i, DEFAULT_TITLE_MAX_LENGTH as n, DRAFT_FILE_VERSION as r, DEFAULT_MAX_DRAFTS_PER_WORKSPACE as t };

package/lib/index.js

@@ -0,0 +1,292 @@
+import { i as DRAFT_SESSION_VERSION, n as DEFAULT_TITLE_MAX_LENGTH, r as DRAFT_FILE_VERSION, t as DEFAULT_MAX_DRAFTS_PER_WORKSPACE } from "./constants-vAKitj5i.js";
+import { t as draftFileSchema } from "./schema-BkmWuQBa.js";
+import { deriveDraftTitle, displayDraftTitle } from "./shared/types.js";
+import z from "@deepseek-ai/schemastery";
+import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { ZodError } from "zod";
+//#region src/host/errors.ts
+/** Stable domain failure raised by DraftStore and exposed by the Host service. */
+var DraftStoreError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "DraftStoreError";
+	}
+};
+//#endregion
+//#region src/host/store.ts
+function defaultStoragePath() {
+	const configuredHome = process.env.DSH_HOME?.trim();
+	const dshHome = configuredHome === void 0 || configuredHome === "" ? join(homedir(), ".dsh") : resolve(configuredHome);
+	return join(dshHome, "storages", "dsh-draft-sessions", "drafts.json");
+}
+function storagePath(value) {
+	if (value === void 0 || value.trim() === "") return defaultStoragePath();
+	return isAbsolute(value) ? value : resolve(value);
+}
+function positiveLimit(value) {
+	const resolvedValue = value ?? 50;
+	if (!Number.isSafeInteger(resolvedValue) || resolvedValue < 1) throw new DraftStoreError("maxDraftsPerWorkspace must be a positive safe integer", "DRAFT_INVALID_INPUT");
+	return resolvedValue;
+}
+function requiredText(value, field) {
+	if (typeof value !== "string" || value.trim() === "") throw new DraftStoreError(`${field} must be a non-empty string`, "DRAFT_INVALID_INPUT");
+	return value;
+}
+function optionalNonBlank(value, field) {
+	if (value === void 0) return void 0;
+	return requiredText(value, field);
+}
+function orderValue(value, field = "order") {
+	if (!Number.isSafeInteger(value) || value < 0) throw new DraftStoreError(`${field} must be a non-negative safe integer`, "DRAFT_INVALID_INPUT");
+	return value;
+}
+function revisionValue(value) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new DraftStoreError("expectedRevision must be a positive safe integer", "DRAFT_INVALID_INPUT");
+	return value;
+}
+function cloneDraft(draft) {
+	return structuredClone(draft);
+}
+function sorted(drafts) {
+	return [...drafts].sort((left, right) => Number(right.pinned === true) - Number(left.pinned === true) || left.order - right.order || left.createdAt - right.createdAt || left.id.localeCompare(right.id));
+}
+/** Serialized, atomically persisted authority for unsent draft sessions. */
+var DraftStore = class {
+	path;
+	maxDraftsPerWorkspace;
+	now;
+	id;
+	drafts;
+	queue = Promise.resolve();
+	constructor(options = {}) {
+		this.path = storagePath(options.storagePath);
+		this.maxDraftsPerWorkspace = positiveLimit(options.maxDraftsPerWorkspace);
+		this.now = options.now ?? Date.now;
+		this.id = options.id ?? randomUUID;
+	}
+	list(request = {}) {
+		return this.enqueue(async () => {
+			const drafts = await this.loaded();
+			return sorted(request.workspaceId === void 0 ? drafts : drafts.filter((draft) => draft.workspaceId === request.workspaceId)).map(cloneDraft);
+		});
+	}
+	create(request) {
+		return this.enqueue(async () => {
+			const current = await this.loaded();
+			const workspaceId = requiredText(request.workspaceId, "workspaceId");
+			const workspaceDrafts = current.filter((draft) => draft.workspaceId === workspaceId);
+			if (workspaceDrafts.length >= this.maxDraftsPerWorkspace) throw new DraftStoreError(`workspace already has ${this.maxDraftsPerWorkspace} drafts`, "DRAFT_LIMIT_REACHED");
+			const now = this.now();
+			const sessionId = request.sessionId ?? null;
+			if (sessionId !== null) requiredText(sessionId, "sessionId");
+			const draft = {
+				version: 1,
+				id: requiredText(this.id(), "generated id"),
+				sessionId,
+				workspaceId,
+				...optionalNonBlank(request.workspacePath, "workspacePath") === void 0 ? {} : { workspacePath: request.workspacePath },
+				text: request.text ?? "",
+				...optionalNonBlank(request.title, "title") === void 0 ? {} : { title: request.title },
+				createdAt: now,
+				updatedAt: now,
+				order: request.order === void 0 ? Math.max(-1, ...workspaceDrafts.map((item) => item.order)) + 1 : orderValue(request.order),
+				...request.pinned === void 0 ? {} : { pinned: request.pinned },
+				...optionalNonBlank(request.agentPresetId, "agentPresetId") === void 0 ? {} : { agentPresetId: request.agentPresetId },
+				state: sessionId === null ? "draft" : "ready",
+				revision: 1
+			};
+			await this.commit([...current, draft]);
+			return cloneDraft(draft);
+		});
+	}
+	update(request) {
+		return this.enqueue(async () => {
+			const current = await this.loaded();
+			const index = this.find(current, request.id);
+			const previous = current[index];
+			this.expectRevision(previous, request.expectedRevision);
+			const now = Math.max(this.now(), previous.updatedAt);
+			const mutable = {
+				...previous,
+				...request.text === void 0 ? {} : { text: request.text },
+				...request.order === void 0 ? {} : { order: orderValue(request.order) },
+				...request.pinned === void 0 ? {} : { pinned: request.pinned },
+				...request.state === void 0 ? {} : { state: request.state },
+				updatedAt: now,
+				revision: previous.revision + 1
+			};
+			if (request.title === null) delete mutable.title;
+			else if (request.title !== void 0) mutable.title = requiredText(request.title, "title");
+			if (request.agentPresetId === null) delete mutable.agentPresetId;
+			else if (request.agentPresetId !== void 0) mutable.agentPresetId = requiredText(request.agentPresetId, "agentPresetId");
+			if (request.lastError === null) delete mutable.lastError;
+			else if (request.lastError !== void 0) mutable.lastError = requiredText(request.lastError, "lastError");
+			const changed = [...current];
+			changed[index] = mutable;
+			await this.commit(changed);
+			return cloneDraft(mutable);
+		});
+	}
+	delete(request) {
+		return this.enqueue(async () => {
+			const current = await this.loaded();
+			const index = current.findIndex((draft) => draft.id === request.id);
+			if (index < 0) return false;
+			const previous = current[index];
+			if (request.expectedRevision !== void 0) this.expectRevision(previous, request.expectedRevision);
+			const changed = current.filter((_, draftIndex) => draftIndex !== index);
+			await this.commit(changed);
+			return true;
+		});
+	}
+	rebind(request) {
+		return this.enqueue(async () => {
+			const current = await this.loaded();
+			const index = this.find(current, request.id);
+			const previous = current[index];
+			this.expectRevision(previous, request.expectedRevision);
+			if (request.sessionId !== null) requiredText(request.sessionId, "sessionId");
+			const rebound = {
+				...previous,
+				sessionId: request.sessionId,
+				state: request.sessionId === null ? "draft" : "ready",
+				updatedAt: Math.max(this.now(), previous.updatedAt),
+				revision: previous.revision + 1
+			};
+			delete rebound.lastError;
+			const changed = [...current];
+			changed[index] = rebound;
+			await this.commit(changed);
+			return cloneDraft(rebound);
+		});
+	}
+	enqueue(operation) {
+		const result = this.queue.then(operation, operation);
+		this.queue = result.then(() => void 0, () => void 0);
+		return result;
+	}
+	async loaded() {
+		if (this.drafts !== void 0) return this.drafts;
+		let contents;
+		try {
+			contents = await readFile(this.path, "utf8");
+		} catch (error) {
+			if (error.code === "ENOENT") {
+				this.drafts = [];
+				return this.drafts;
+			}
+			throw error;
+		}
+		try {
+			const parsed = draftFileSchema.parse(JSON.parse(contents));
+			const seen = /* @__PURE__ */ new Set();
+			for (const draft of parsed.drafts) {
+				if (seen.has(draft.id)) throw new DraftStoreError(`storage contains duplicate draft id ${JSON.stringify(draft.id)}`, "DRAFT_STORAGE_INVALID");
+				seen.add(draft.id);
+			}
+			this.drafts = parsed.drafts.map(cloneDraft);
+			return this.drafts;
+		} catch (error) {
+			if (error instanceof DraftStoreError) throw error;
+			throw new DraftStoreError(`invalid draft storage: ${error instanceof ZodError ? error.issues.map((issue) => issue.message).join("; ") : error instanceof Error ? error.message : String(error)}`, "DRAFT_STORAGE_INVALID");
+		}
+	}
+	find(drafts, id) {
+		requiredText(id, "id");
+		const index = drafts.findIndex((draft) => draft.id === id);
+		if (index < 0) throw new DraftStoreError(`draft ${JSON.stringify(id)} was not found`, "DRAFT_NOT_FOUND");
+		return index;
+	}
+	expectRevision(draft, expectedRevision) {
+		revisionValue(expectedRevision);
+		if (draft.revision !== expectedRevision) throw new DraftStoreError(`draft ${JSON.stringify(draft.id)} is at revision ${draft.revision}, not ${expectedRevision}`, "DRAFT_STALE_REVISION");
+	}
+	async commit(drafts) {
+		const document = {
+			version: 1,
+			drafts
+		};
+		const directory = dirname(this.path);
+		await mkdir(directory, { recursive: true });
+		const temporary = join(directory, `.${basename(this.path)}.${process.pid}.${randomUUID()}.tmp`);
+		try {
+			await writeFile(temporary, `${JSON.stringify(document, null, 2)}\n`, {
+				encoding: "utf8",
+				flag: "wx"
+			});
+			await rename(temporary, this.path);
+		} finally {
+			await unlink(temporary).catch((error) => {
+				if (error.code !== "ENOENT") throw error;
+			});
+		}
+		this.drafts = drafts;
+	}
+};
+//#endregion
+//#region src/index.ts
+/** Host service and Typert Remote boundary for persistent draft records. */
+var DraftSessionsService = class extends TypertRemoteService {
+	static Config = z.object({
+		storagePath: z.string().default(""),
+		maxDraftsPerWorkspace: z.number().default(50)
+	});
+	store;
+	constructor(ctx, config = {}) {
+		super(ctx, "draftSessions");
+		this.store = new DraftStore({
+			...config.storagePath === void 0 || config.storagePath.trim() === "" ? {} : { storagePath: config.storagePath },
+			maxDraftsPerWorkspace: config.maxDraftsPerWorkspace ?? 50
+		});
+	}
+	list(request) {
+		return this.store.list(request);
+	}
+	create(request) {
+		return this.store.create(request);
+	}
+	update(request) {
+		return this.store.update(request);
+	}
+	async delete(request) {
+		return { deleted: await this.store.delete(request) };
+	}
+	rebind(request) {
+		return this.store.rebind(request);
+	}
+};
+/**
+* Apply the standard Remote decorator without shipping decorator syntax.
+*
+* Out-of-tree tsdown builds currently preserve standard decorators even when
+* targeting Node 22. Invoking the public decorator protocol here records the
+* same class markers while keeping the published JavaScript executable.
+*/
+function registerRemoteMethod(method) {
+	const initializers = [];
+	Remote(DraftSessionsService.prototype[method], {
+		name: method,
+		private: false,
+		static: false,
+		addInitializer(initializer) {
+			initializers.push(initializer);
+		}
+	});
+	const markerReceiver = Object.create(DraftSessionsService.prototype);
+	for (const initializer of initializers) initializer.call(markerReceiver);
+}
+for (const method of [
+	"list",
+	"create",
+	"update",
+	"delete",
+	"rebind"
+]) registerRemoteMethod(method);
+//#endregion
+export { DEFAULT_MAX_DRAFTS_PER_WORKSPACE, DEFAULT_TITLE_MAX_LENGTH, DRAFT_FILE_VERSION, DRAFT_SESSION_VERSION, DraftSessionsService, DraftSessionsService as default, DraftStore, DraftStoreError, deriveDraftTitle, displayDraftTitle };

package/lib/remote.js

@@ -0,0 +1,71 @@
+import { n as draftSessionSchema, r as draftStateSchema } from "./schema-BkmWuQBa.js";
+import { z } from "zod";
+//#region src/remote.ts
+const listRequestSchema = z.strictObject({ workspaceId: z.string().min(1).optional() });
+const createRequestSchema = z.strictObject({
+	workspaceId: z.string().min(1),
+	sessionId: z.string().min(1).nullable().optional(),
+	workspacePath: z.string().min(1).optional(),
+	text: z.string().optional(),
+	title: z.string().min(1).optional(),
+	order: z.number().int().nonnegative().optional(),
+	pinned: z.boolean().optional(),
+	agentPresetId: z.string().min(1).optional()
+});
+const updateRequestSchema = z.strictObject({
+	id: z.string().min(1),
+	expectedRevision: z.number().int().positive(),
+	text: z.string().optional(),
+	title: z.string().min(1).nullable().optional(),
+	order: z.number().int().nonnegative().optional(),
+	pinned: z.boolean().optional(),
+	agentPresetId: z.string().min(1).nullable().optional(),
+	state: draftStateSchema.optional(),
+	lastError: z.string().min(1).nullable().optional()
+});
+const deleteRequestSchema = z.strictObject({
+	id: z.string().min(1),
+	expectedRevision: z.number().int().positive().optional()
+});
+const deleteResultSchema = z.strictObject({ deleted: z.boolean() });
+const rebindRequestSchema = z.strictObject({
+	id: z.string().min(1),
+	expectedRevision: z.number().int().positive(),
+	sessionId: z.string().min(1).nullable()
+});
+function descriptor(method, requestType, requestSchema, resultType, resultSchema) {
+	return {
+		id: `dsh-draft-sessions#draftSessions/${method}`,
+		service: "draftSessions",
+		namespace: "draftSessions",
+		method,
+		invocation: { kind: "direct" },
+		parameters: [{
+			name: "request",
+			wire: "request",
+			source: "json",
+			codec: {
+				mode: "strict",
+				typeSymbol: requestType,
+				schema: requestSchema
+			}
+		}],
+		result: {
+			mode: "strict",
+			typeSymbol: resultType,
+			schema: resultSchema
+		}
+	};
+}
+const draftSessionsRemote = {
+	package: "dsh-draft-sessions",
+	descriptors: [
+		descriptor("list", "dsh-draft-sessions/types#ListDraftsRequest", listRequestSchema, "dsh-draft-sessions/types#DraftSession[]", z.array(draftSessionSchema)),
+		descriptor("create", "dsh-draft-sessions/types#CreateDraftRequest", createRequestSchema, "dsh-draft-sessions/types#DraftSession", draftSessionSchema),
+		descriptor("update", "dsh-draft-sessions/types#UpdateDraftRequest", updateRequestSchema, "dsh-draft-sessions/types#DraftSession", draftSessionSchema),
+		descriptor("delete", "dsh-draft-sessions/types#DeleteDraftRequest", deleteRequestSchema, "dsh-draft-sessions/types#DeleteDraftResult", deleteResultSchema),
+		descriptor("rebind", "dsh-draft-sessions/types#RebindDraftRequest", rebindRequestSchema, "dsh-draft-sessions/types#DraftSession", draftSessionSchema)
+	]
+};
+//#endregion
+export { draftSessionsRemote as default };

package/lib/schema-BkmWuQBa.js

@@ -0,0 +1,33 @@
+import "./constants-vAKitj5i.js";
+import { z } from "zod";
+//#region src/host/schema.ts
+const draftStateSchema = z.union([
+	z.literal("draft"),
+	z.literal("materializing"),
+	z.literal("ready"),
+	z.literal("converting"),
+	z.literal("error")
+]);
+const draftSessionSchema = z.strictObject({
+	version: z.literal(1),
+	id: z.string().min(1),
+	sessionId: z.string().min(1).nullable(),
+	workspaceId: z.string().min(1),
+	workspacePath: z.string().min(1).optional(),
+	text: z.string(),
+	title: z.string().min(1).optional(),
+	createdAt: z.number().int().nonnegative(),
+	updatedAt: z.number().int().nonnegative(),
+	order: z.number().int().nonnegative(),
+	pinned: z.boolean().optional(),
+	agentPresetId: z.string().min(1).optional(),
+	state: draftStateSchema,
+	lastError: z.string().min(1).optional(),
+	revision: z.number().int().positive()
+});
+const draftFileSchema = z.strictObject({
+	version: z.literal(1),
+	drafts: z.array(draftSessionSchema)
+});
+//#endregion
+export { draftSessionSchema as n, draftStateSchema as r, draftFileSchema as t };

package/lib/shared/types.js

@@ -0,0 +1,13 @@
+import "../constants-vAKitj5i.js";
+//#region src/shared/types.ts
+/** First non-empty line, compacted for a session-like sidebar row. */
+function deriveDraftTitle(text, maxLength = 80) {
+	if (!Number.isSafeInteger(maxLength) || maxLength < 1) throw new RangeError("maxLength must be a positive safe integer");
+	return (text.trim().split(/\r?\n/u, 1)[0] ?? "").slice(0, maxLength);
+}
+/** Explicit title when present, otherwise a stable first-line projection. */
+function displayDraftTitle(draft, maxLength = 80) {
+	return draft.title ?? deriveDraftTitle(draft.text, maxLength);
+}
+//#endregion
+export { deriveDraftTitle, displayDraftTitle };

package/lib/types/client/composer.d.ts

@@ -0,0 +1,46 @@
+import { Service, type Context } from "@deepseek-ai/cordis";
+import type { ISessions } from "@deepseek-ai/dsh-client-runtime/client";
+import type { IConversation } from "@deepseek-ai/dsh-client-ui-conversation/client";
+import type { RemoteFailure, TypertRemoteNamespace } from "@deepseek-ai/dsh-typert-protocol";
+import type { DraftSession } from "../shared/types.js";
+import type { DraftSessionLifecycle } from "./lifecycle.js";
+import type { DraftSidebarSource } from "./sidebar.js";
+type DraftSessionsRemote = TypertRemoteNamespace<"draftSessions">;
+export interface DraftComposerBridgeOptions {
+    readonly lifecycle: Pick<DraftSessionLifecycle, "ensureShell" | "onBeforeFinalize">;
+    readonly drafts: DraftSessionsRemote;
+    readonly sessions: Pick<ISessions, "open" | "scope">;
+    readonly conversation: Pick<IConversation, "input">;
+    readonly sidebar?: Pick<DraftSidebarSource, "accept">;
+    readonly debounceMs?: number;
+}
+export declare class DraftAutosaveError extends Error {
+    readonly code: string;
+    readonly draft: DraftSession;
+    readonly localText: string;
+    constructor(failure: Pick<RemoteFailure, "code" | "message">, draft: DraftSession, localText: string);
+}
+/** Official InputHub bridge plus serialized optimistic Host autosave. */
+export declare class DraftComposerBridge extends Service {
+    private readonly lifecycle;
+    private readonly drafts;
+    private readonly sessions;
+    private readonly conversation;
+    private readonly debounceMs;
+    private readonly sidebar;
+    private active;
+    private saveQueue;
+    constructor(ctx: Context, options?: DraftComposerBridgeOptions);
+    /** Flush the previous draft, open this Session, and restore exact text. */
+    open(draft: DraftSession): Promise<DraftSession>;
+    /** Persist every pending edit before navigation continues. */
+    flush(): Promise<DraftSession | undefined>;
+    /** Flush and stop mirroring the current composer. */
+    close(): Promise<DraftSession | undefined>;
+    private inputChanged;
+    private drain;
+    private clearTimer;
+    private detach;
+}
+export {};
+//# sourceMappingURL=composer.d.ts.map

package/lib/types/client/draft-sidebar-view.d.ts

@@ -0,0 +1,22 @@
+import { type DraftSession } from "../shared/types.js";
+export interface DraftDropTarget {
+    readonly workspaceId: string;
+    readonly beforeDraftId?: string;
+}
+export interface DraftSidebarViewProps {
+    readonly surface?: "inline" | "tab" | "popover";
+    readonly drafts: readonly DraftSession[];
+    readonly currentSessionId?: string;
+    readonly workspaceNames?: Readonly<Record<string, string>>;
+    readonly onCreate: () => Promise<void>;
+    readonly onOpen: (draft: DraftSession) => void;
+    readonly onRename: (draft: DraftSession, title: string) => Promise<void>;
+    readonly onDuplicate: (draft: DraftSession) => Promise<void>;
+    readonly onDelete: (draft: DraftSession) => Promise<void>;
+    readonly onReorder: (workspaceId: string, draftId: string, beforeDraftId?: string) => Promise<void>;
+}
+export declare function resolveDraftDropTarget(drafts: readonly DraftSession[], sourceId: string, targetId: string, half: "before" | "after"): DraftDropTarget | undefined;
+export declare function DraftSidebarView({ surface, drafts, currentSessionId, workspaceNames, onCreate, onOpen, onRename, onDuplicate, onDelete, onReorder, }: DraftSidebarViewProps): import("react").FunctionComponentElement<{
+    children?: import("react").ReactNode | undefined;
+}>;
+//# sourceMappingURL=draft-sidebar-view.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,32 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { ConnectionHandle, IApiClient } from "@deepseek-ai/dsh-client-connection/client";
+import type { ISessions, IWorkspaces } from "@deepseek-ai/dsh-client-runtime/client";
+import type { IConversation } from "@deepseek-ai/dsh-client-ui-conversation/client";
+import { DraftComposerBridge } from "./composer.js";
+import { DraftSessionLifecycle } from "./lifecycle.js";
+import { DraftSidebarSource } from "./sidebar.js";
+import { DraftShortcutController } from "./shortcut.js";
+export type * from "../shared/types.js";
+export * from "./composer.js";
+export * from "./lifecycle.js";
+export * from "./sidebar.js";
+export * from "./shortcut.js";
+export * from "./workspace-contribution.js";
+declare module "@deepseek-ai/cordis" {
+    interface Context {
+        connection: ConnectionHandle & {
+            readonly api: IApiClient;
+        };
+        sessions: ISessions;
+        workspaces: IWorkspaces;
+        conversation: IConversation;
+        draftSessionLifecycle: DraftSessionLifecycle;
+        draftComposerBridge: DraftComposerBridge;
+        draftShortcutController: DraftShortcutController;
+        draftSidebarSource: DraftSidebarSource;
+    }
+}
+export declare const inject: string[];
+/** Mount the strict Remote namespace and its blank-Session lifecycle bridge. */
+export declare function apply(ctx: Context): Promise<() => Promise<void>>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/lifecycle.d.ts

@@ -0,0 +1,69 @@
+import { Service, type Context } from "@deepseek-ai/cordis";
+import type { IApiClient, RpcMessage } from "@deepseek-ai/dsh-client-connection/client";
+import type { RemoteFailure, TypertRemoteNamespace } from "@deepseek-ai/dsh-typert-protocol";
+import type { CreateDraftRequest, DraftSession } from "../shared/types.js";
+import type { DraftSidebarSource } from "./sidebar.js";
+type DraftSessionsRemote = TypertRemoteNamespace<"draftSessions">;
+type SessionsApi = Pick<IApiClient["sessions"], "create" | "list">;
+export interface ApiEnvelopeSource {
+    subscribeEnvelopes(listener: (batch: readonly RpcMessage[]) => void): () => void;
+}
+export type CreateManagedDraftRequest = Omit<CreateDraftRequest, "sessionId">;
+export type DraftLifecycleStage = "draft-create" | "draft-list" | "draft-update" | "draft-delete" | "session-list" | "session-create" | "draft-rebind";
+/** A lifecycle failure never implies that the durable DraftRecord was removed. */
+export declare class DraftLifecycleError extends Error {
+    readonly stage: DraftLifecycleStage;
+    readonly code: string;
+    readonly draft: DraftSession | undefined;
+    readonly sessionId: string | undefined;
+    constructor(stage: DraftLifecycleStage, failure: Pick<RemoteFailure, "code" | "message">, options?: {
+        readonly draft?: DraftSession;
+        readonly sessionId?: string;
+        readonly cause?: unknown;
+    });
+}
+export interface DraftSessionLifecycleOptions {
+    readonly drafts: DraftSessionsRemote;
+    readonly sessions: SessionsApi;
+    readonly envelopes?: ApiEnvelopeSource;
+    readonly sidebar?: Pick<DraftSidebarSource, "accept" | "remove">;
+}
+export type BeforeDraftFinalizeListener = (sessionId: string) => void | Promise<void>;
+export declare function envelopeSource(api: IApiClient): ApiEnvelopeSource | undefined;
+/**
+ * Client-side bridge between durable DraftRecords and real blank DSH Sessions.
+ *
+ * The DraftRecord is created first with no Session id. A Session id enters the
+ * durable record only after `sessions.create` has returned a successful result.
+ */
+export declare class DraftSessionLifecycle extends Service {
+    private readonly drafts;
+    private readonly sessions;
+    private readonly sidebar;
+    private readonly pendingPrompts;
+    private readonly beforeFinalizeListeners;
+    private observationQueue;
+    constructor(ctx: Context, options?: DraftSessionLifecycleOptions);
+    /** Create a durable draft and give it a distinct blank Session shell. */
+    create(request: CreateManagedDraftRequest): Promise<DraftSession>;
+    /** Return the draft unchanged when its Session exists, otherwise rebind it. */
+    ensureShell(draft: DraftSession): Promise<DraftSession>;
+    /** Recover every missing Session shell in one Workspace from one list cut. */
+    reconcileWorkspace(workspaceId: string): Promise<DraftSession[]>;
+    /** Run cleanup hooks before an accepted Session's durable draft is removed. */
+    onBeforeFinalize(listener: BeforeDraftFinalizeListener): () => void;
+    /**
+     * Finalize drafts for an accepted prompt only after DSH reports the Session
+     * as nonblank. Returns false while the transition is not yet observable.
+     */
+    finalizeAcceptedSession(sessionId: string): Promise<boolean>;
+    private materialize;
+    private markFailed;
+    private deleteDraft;
+    private observeEnvelopes;
+    private enqueueObservation;
+    private remoteValue;
+    private apiError;
+}
+export {};
+//# sourceMappingURL=lifecycle.d.ts.map

package/lib/types/client/shortcut.d.ts

@@ -0,0 +1,40 @@
+import { Service, type Context } from "@deepseek-ai/cordis";
+import type { ISessions, IWorkspaces, SessionListState, WorkspaceListState } from "@deepseek-ai/dsh-client-runtime/client";
+import type { DraftSession } from "../shared/types.js";
+import type { DraftComposerBridge } from "./composer.js";
+import type { DraftSessionLifecycle } from "./lifecycle.js";
+interface ShortcutEvent {
+    readonly key: string;
+    readonly ctrlKey: boolean;
+    readonly metaKey: boolean;
+    readonly shiftKey: boolean;
+    readonly altKey: boolean;
+    readonly repeat: boolean;
+    preventDefault(): void;
+}
+interface ShortcutSource {
+    subscribe(listener: (event: ShortcutEvent) => void): () => void;
+}
+export interface DraftShortcutControllerOptions {
+    readonly lifecycle: Pick<DraftSessionLifecycle, "create">;
+    readonly composer: Pick<DraftComposerBridge, "flush" | "open">;
+    readonly sessions: Pick<ISessions, "list">;
+    readonly workspaces: Pick<IWorkspaces, "list">;
+    readonly shortcuts?: ShortcutSource;
+}
+/** Resolve the same current/recent Workspace axis used by New Session. */
+export declare function resolveDraftWorkspace(sessions: Pick<SessionListState, "current">, workspaces: Pick<WorkspaceListState, "items" | "recentWorkspaceId">): string | undefined;
+/** Global Ctrl/Cmd+Shift+N action for a distinct draft Session. */
+export declare class DraftShortcutController extends Service {
+    private readonly lifecycle;
+    private readonly composer;
+    private readonly sessions;
+    private readonly workspaces;
+    private creating;
+    constructor(ctx: Context, options?: DraftShortcutControllerOptions);
+    /** Flush the current draft, create another, and open its composer. */
+    create(workspaceId?: string): Promise<DraftSession>;
+    private onShortcut;
+}
+export {};
+//# sourceMappingURL=shortcut.d.ts.map