@deepseek-ai/dsh-api-workspace-controller 0.1.2-alpha.2

package/lib/types/client/model.js

@@ -0,0 +1,292 @@
+/** Client-side Workspace state model shared by Remote transport and UI projection. */
+import { notifySubscribers } from '@deepseek-ai/dsh-client-store';
+import { isRemoteFailure } from '@deepseek-ai/dsh-api-gateway/client';
+/**
+ * Owns the Client Workspace projection, mutation echoes, and stream/unary race resolution.
+ */
+export class ClientWorkspaceModel {
+    remote;
+    items = [];
+    archivedSessionIds = [];
+    state = 'loading';
+    phase = 'pending';
+    error = null;
+    /** Latest local reorder request; only its unary echo may install order. */
+    orderRequestGeneration = 0;
+    /** Increments on stream orders so a later remote commit outranks an older unary echo. */
+    orderFrameGeneration = 0;
+    /** Last complete order accepted from a baseline, increment, or current unary echo. */
+    committedOrder = [];
+    /** Host Workspace ids are never reused, so delayed data cannot resurrect a removed row. */
+    removedIds = new Set();
+    listeners = new Set();
+    snapshotCache;
+    snapshotDirty = false;
+    notificationPending = false;
+    notificationScheduled = false;
+    notificationGeneration = 0;
+    /** @param remote - generated Workspace Remote namespace. */
+    constructor(remote) {
+        this.remote = remote;
+        this.snapshotCache = this.buildSnapshot();
+    }
+    /**
+     * Create or resolve a Workspace and merge the unary result immediately.
+     * @param input - existing absolute path to adopt.
+     * @returns generated Remote result.
+     */
+    async create(input) {
+        const result = await this.remote.create(input);
+        if (result.ok)
+            this.upsert(result.value.workspace);
+        return result;
+    }
+    /**
+     * Rename a Workspace and merge the unary result immediately.
+     * @param workspaceId - target Workspace.
+     * @param title - new display title.
+     * @returns generated Remote result.
+     */
+    async rename(workspaceId, title) {
+        const result = await this.remote.rename({ workspaceId, title });
+        if (result.ok)
+            this.upsert(result.value.workspace);
+        return result;
+    }
+    /**
+     * Delete a Workspace and remove it from the local projection immediately.
+     * @param workspaceId - target Workspace.
+     * @returns generated Remote result.
+     */
+    async delete(workspaceId) {
+        const result = await this.remote.delete({ workspaceId });
+        if (result.ok)
+            this.remove(workspaceId, true);
+        return result;
+    }
+    /**
+     * Optimistically move a Workspace and reconcile the returned complete order.
+     * @param workspaceId - Workspace to move.
+     * @param beforeWorkspaceId - anchor Workspace; omitted appends.
+     * @returns generated Remote result.
+     */
+    async insertBefore(workspaceId, beforeWorkspaceId) {
+        const requestGeneration = ++this.orderRequestGeneration;
+        const frameGeneration = this.orderFrameGeneration;
+        const localOrder = this.items.map(workspace => workspace.workspaceId);
+        this.installOrder(insertIdBefore(localOrder, workspaceId, beforeWorkspaceId));
+        const result = await this.remote.insertBefore({
+            workspaceId,
+            ...beforeWorkspaceId === undefined ? {} : { beforeWorkspaceId },
+        });
+        if (requestGeneration === this.orderRequestGeneration
+            && frameGeneration === this.orderFrameGeneration) {
+            this.installOrder(result.ok ? result.value.workspaceIds : this.committedOrder, result.ok);
+        }
+        return result;
+    }
+    /**
+     * Move a Session within its Workspace and merge the returned row.
+     * @param workspaceId - owning Workspace.
+     * @param sessionId - accounted Session to move.
+     * @param beforeSessionId - accounted anchor; omitted appends.
+     * @returns generated Remote result.
+     */
+    async insertSessionBefore(workspaceId, sessionId, beforeSessionId) {
+        const result = await this.remote.insertSessionBefore({
+            workspaceId,
+            sessionId,
+            ...beforeSessionId === undefined ? {} : { beforeSessionId },
+        });
+        if (result.ok)
+            this.upsert(result.value.workspace);
+        return result;
+    }
+    /**
+     * Archive one Session and install the returned complete archive set.
+     * @param sessionId - Session to archive.
+     * @returns generated Remote result.
+     */
+    async archiveSession(sessionId) {
+        const result = await this.remote.archiveSession({ sessionId });
+        if (result.ok)
+            this.installArchived(result.value.archivedSessionIds);
+        return result;
+    }
+    /**
+     * Replace the projection from one complete stream-generation baseline.
+     * @param baseline - complete Workspace and archive projection.
+     */
+    replaceBaseline(baseline) {
+        this.orderFrameGeneration++;
+        this.installViews(baseline.items);
+        this.installArchived(baseline.archivedSessionIds);
+        this.state = 'idle';
+        this.phase = 'ready';
+        this.error = null;
+        this.invalidate();
+    }
+    /** Merge one decoded Workspace upsert from the current follow generation. */
+    upsertView(workspace) {
+        this.upsert(workspace);
+    }
+    /** Apply one decoded Workspace removal from the current follow generation. */
+    removeView(workspaceId) {
+        this.remove(workspaceId);
+    }
+    /** Replace Host-confirmed order from the current follow generation. */
+    replaceOrder(workspaceIds) {
+        this.orderFrameGeneration++;
+        this.installOrder(workspaceIds, true);
+    }
+    /**
+     * Replace the archived Session set from the current follow generation.
+     * @param archivedSessionIds - complete Host-confirmed archive set.
+     */
+    replaceArchived(archivedSessionIds) {
+        this.installArchived(archivedSessionIds);
+    }
+    /** Keep the last complete projection visible while a lost carrier reconnects. */
+    handleCarrierFailure() {
+        this.state = 'loading';
+        this.error = null;
+        this.invalidate();
+    }
+    /**
+     * Publish a non-retryable stream or protocol failure.
+     * @param error - terminal stream failure.
+     */
+    handleStreamFailure(error) {
+        if (!isRemoteFailure(error))
+            throw error;
+        this.state = 'error';
+        this.error = error;
+        this.invalidate();
+    }
+    /**
+     * Subscribe to Workspace state invalidation.
+     * @param listener - invalidation callback.
+     * @returns unsubscribe function.
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    }
+    /**
+     * Read the cached state, rebuilding it first when necessary.
+     * @returns the current stable Workspace list snapshot.
+     */
+    getSnapshot() {
+        this.refreshSnapshot();
+        return this.snapshotCache;
+    }
+    buildSnapshot() {
+        return {
+            items: this.items,
+            archivedSessionIds: this.archivedSessionIds,
+            state: this.state,
+            phase: this.phase,
+            error: this.error,
+        };
+    }
+    installArchived(archivedSessionIds) {
+        if (archivedSessionIds.length === this.archivedSessionIds.length
+            && archivedSessionIds.every((id, index) => id === this.archivedSessionIds[index]))
+            return;
+        this.archivedSessionIds = [...archivedSessionIds];
+        this.invalidate();
+    }
+    installOrder(workspaceIds, committed = false) {
+        if (committed)
+            this.committedOrder = [...workspaceIds];
+        const rank = new Map(workspaceIds.map((id, index) => [id, index]));
+        const items = [...this.items].sort((left, right) => (rank.get(left.workspaceId) ?? Number.MAX_SAFE_INTEGER)
+            - (rank.get(right.workspaceId) ?? Number.MAX_SAFE_INTEGER));
+        if (items.every((item, index) => item === this.items[index]))
+            return;
+        this.items = items;
+        this.invalidate();
+    }
+    upsert(view) {
+        if (this.removedIds.has(view.workspaceId))
+            return;
+        const index = this.items.findIndex(item => item.workspaceId === view.workspaceId);
+        const installed = this.items[index];
+        // Unary responses and stream increments race on separate requests. Keep
+        // the newest Host projection regardless of their arrival order.
+        if (installed !== undefined && Date.parse(view.updatedAt) < Date.parse(installed.updatedAt))
+            return;
+        if (!this.committedOrder.includes(view.workspaceId)) {
+            this.committedOrder = [view.workspaceId, ...this.committedOrder];
+        }
+        this.items = index === -1
+            ? [view, ...this.items]
+            : this.items.map((item, position) => position === index ? view : item);
+        this.invalidate();
+    }
+    remove(workspaceId, immediate = false) {
+        this.removedIds.add(workspaceId);
+        this.committedOrder = this.committedOrder.filter(id => id !== workspaceId);
+        const items = this.items.filter(item => item.workspaceId !== workspaceId);
+        if (items.length === this.items.length) {
+            // A successful unary echo still publishes an earlier increment's
+            // pending removal before the user operation resolves.
+            if (immediate)
+                this.invalidate(true);
+            return;
+        }
+        this.items = items;
+        this.invalidate(immediate);
+    }
+    installViews(views) {
+        const installed = new Map();
+        for (const view of views) {
+            if (!this.removedIds.has(view.workspaceId))
+                installed.set(view.workspaceId, view);
+        }
+        this.items = [...installed.values()];
+        this.committedOrder = views.map(view => view.workspaceId);
+    }
+    invalidate(immediate = false) {
+        this.snapshotDirty = true;
+        this.notificationPending = true;
+        if (immediate) {
+            this.notificationGeneration++;
+            this.notificationScheduled = false;
+            this.flush();
+            return;
+        }
+        if (this.notificationScheduled)
+            return;
+        this.notificationScheduled = true;
+        const generation = ++this.notificationGeneration;
+        queueMicrotask(() => {
+            if (generation !== this.notificationGeneration)
+                return;
+            this.notificationScheduled = false;
+            this.flush();
+        });
+    }
+    flush() {
+        if (!this.notificationPending || this.listeners.size === 0)
+            return;
+        this.notificationPending = false;
+        this.refreshSnapshot();
+        notifySubscribers(this.listeners, '[workspace-controller]');
+    }
+    refreshSnapshot() {
+        if (!this.snapshotDirty)
+            return;
+        this.snapshotDirty = false;
+        this.snapshotCache = this.buildSnapshot();
+    }
+}
+function insertIdBefore(ids, id, beforeId) {
+    if (!ids.includes(id) || (beforeId !== undefined && !ids.includes(beforeId)) || beforeId === id) {
+        return [...ids];
+    }
+    const without = ids.filter(candidate => candidate !== id);
+    const at = beforeId === undefined ? without.length : without.indexOf(beforeId);
+    return [...without.slice(0, at), id, ...without.slice(at)];
+}
+//# sourceMappingURL=model.js.map

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

@@ -0,0 +1,88 @@
+/** React-free Client Workspace service and command facade. */
+import { Service, type Context } from '@deepseek-ai/cordis';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { RemoteFailure } from '@deepseek-ai/dsh-typert-protocol';
+import type { WorkspaceId } from '@deepseek-ai/dsh-workspace/types';
+import type { WorkspaceView } from '../types.ts';
+import type { ClientWorkspaceModel, WorkspaceSnapshot } from './model.ts';
+/** Structured create failure for callers that distinguish Host business errors. */
+export declare class WorkspaceCreateError extends Error {
+    readonly rpcError: RemoteFailure;
+    readonly name = "WorkspaceCreateError";
+    /** @param rpcError - Host business or folded carrier failure. */
+    constructor(rpcError: RemoteFailure);
+}
+/** Bare observable source for the Workspace Controller snapshot. */
+export interface WorkspaceSource {
+    /** Read the identity-stable current snapshot. */
+    getSnapshot(): WorkspaceSnapshot;
+    /**
+     * Subscribe to snapshot changes.
+     * @param listener - invalidation callback.
+     * @returns unsubscribe function.
+     */
+    subscribe(listener: () => void): () => void;
+}
+/** Workspace Controller's Client service face. */
+export interface IWorkspaces {
+    /** Host-authoritative Workspace rows, order, archive set, and follow lifecycle. */
+    readonly list: WorkspaceSource;
+    /**
+     * Register an existing path as a Workspace.
+     * @param input - Host create payload.
+     * @returns the created or idempotently resolved Workspace.
+     */
+    create(input: {
+        path: string;
+    }): Promise<WorkspaceView>;
+    /**
+     * Rename a Workspace.
+     * @param workspaceId - target Workspace.
+     * @param title - new display title.
+     * @returns the renamed Workspace.
+     */
+    rename(workspaceId: WorkspaceId, title: string): Promise<WorkspaceView>;
+    /**
+     * Delete a Workspace registration without deleting Sessions or files.
+     * @param workspaceId - target Workspace.
+     */
+    delete(workspaceId: WorkspaceId): Promise<void>;
+    /**
+     * Move a Workspace within the Host registry order.
+     * @param workspaceId - Workspace to move.
+     * @param beforeWorkspaceId - anchor Workspace; omitted appends.
+     */
+    insertBefore(workspaceId: WorkspaceId, beforeWorkspaceId?: WorkspaceId): Promise<void>;
+    /**
+     * Archive a Session from Workspace grouping surfaces.
+     * @param sessionId - Session to archive.
+     */
+    archiveSession(sessionId: SessionId): Promise<void>;
+    /**
+     * Move a Session within one Workspace account.
+     * @param workspaceId - owning Workspace.
+     * @param sessionId - Session to move.
+     * @param beforeSessionId - anchor Session; omitted appends.
+     * @returns the changed Workspace.
+     */
+    insertSessionBefore(workspaceId: WorkspaceId, sessionId: SessionId, beforeSessionId?: SessionId): Promise<WorkspaceView>;
+}
+/** Owns the bare Workspace snapshot and Workspace-only commands. */
+export declare class WorkspaceController extends Service implements IWorkspaces {
+    private readonly model;
+    readonly list: WorkspaceSource;
+    /**
+     * @param ctx - Client root Context.
+     * @param model - Remote-backed Workspace state model.
+     */
+    constructor(ctx: Context, model: ClientWorkspaceModel);
+    create(input: {
+        path: string;
+    }): Promise<WorkspaceView>;
+    rename(workspaceId: WorkspaceId, title: string): Promise<WorkspaceView>;
+    delete(workspaceId: WorkspaceId): Promise<void>;
+    insertBefore(workspaceId: WorkspaceId, beforeWorkspaceId?: WorkspaceId): Promise<void>;
+    archiveSession(sessionId: SessionId): Promise<void>;
+    insertSessionBefore(workspaceId: WorkspaceId, sessionId: SessionId, beforeSessionId?: SessionId): Promise<WorkspaceView>;
+}
+//# sourceMappingURL=service.d.ts.map

package/lib/types/client/service.js

@@ -0,0 +1,63 @@
+/** React-free Client Workspace service and command facade. */
+import { Service } from '@deepseek-ai/cordis';
+/** Structured create failure for callers that distinguish Host business errors. */
+export class WorkspaceCreateError extends Error {
+    rpcError;
+    name = 'WorkspaceCreateError';
+    /** @param rpcError - Host business or folded carrier failure. */
+    constructor(rpcError) {
+        super(`workspace create failed: ${rpcError.code}: ${rpcError.message}`);
+        this.rpcError = rpcError;
+    }
+}
+/** Owns the bare Workspace snapshot and Workspace-only commands. */
+export class WorkspaceController extends Service {
+    model;
+    list;
+    /**
+     * @param ctx - Client root Context.
+     * @param model - Remote-backed Workspace state model.
+     */
+    constructor(ctx, model) {
+        super(ctx, 'workspaces');
+        this.model = model;
+        this.list = model;
+    }
+    async create(input) {
+        const result = await this.model.create(input);
+        if (!result.ok)
+            throw new WorkspaceCreateError(result.error);
+        return result.value.workspace;
+    }
+    async rename(workspaceId, title) {
+        const result = await this.model.rename(workspaceId, title);
+        if (!result.ok)
+            throw commandError('rename', result.error);
+        return result.value.workspace;
+    }
+    async delete(workspaceId) {
+        const result = await this.model.delete(workspaceId);
+        if (!result.ok)
+            throw commandError('delete', result.error);
+    }
+    async insertBefore(workspaceId, beforeWorkspaceId) {
+        const result = await this.model.insertBefore(workspaceId, beforeWorkspaceId);
+        if (!result.ok)
+            throw commandError('reorder', result.error);
+    }
+    async archiveSession(sessionId) {
+        const result = await this.model.archiveSession(sessionId);
+        if (!result.ok)
+            throw commandError('session archive', result.error);
+    }
+    async insertSessionBefore(workspaceId, sessionId, beforeSessionId) {
+        const result = await this.model.insertSessionBefore(workspaceId, sessionId, beforeSessionId);
+        if (!result.ok)
+            throw commandError('move', result.error);
+        return result.value.workspace;
+    }
+}
+function commandError(operation, failure) {
+    return new Error(`workspace ${operation} failed: ${failure.code}: ${failure.message}`);
+}
+//# sourceMappingURL=service.js.map

package/lib/types/commands.d.ts

@@ -0,0 +1,49 @@
+/** Workspace command implementation and stable Remote failure mapping. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { WorkspaceArchiveSessionRequest, WorkspaceArchiveValue, WorkspaceCreateRequest, WorkspaceCreateValue, WorkspaceDeleteRequest, WorkspaceDeleteValue, WorkspaceInsertBeforeRequest, WorkspaceInsertSessionBeforeRequest, WorkspaceOrderValue, WorkspaceRenameRequest, WorkspaceValue } from './types.ts';
+/** Implements Workspace mutations against the authoritative registry. */
+export declare class WorkspaceCommands {
+    private readonly ctx;
+    private operationTail;
+    /** @param ctx - Host context containing the Workspace registry. */
+    constructor(ctx: Context);
+    /**
+     * Create or resolve one Workspace over an existing directory.
+     * @param request - directory path to register.
+     * @returns the Workspace and whether this call created it.
+     */
+    create(request: WorkspaceCreateRequest): Promise<WorkspaceCreateValue>;
+    /**
+     * Rename one Workspace after serializing title ownership checks.
+     * @param request - Workspace identity and proposed title.
+     * @returns the updated Workspace projection.
+     */
+    rename(request: WorkspaceRenameRequest): Promise<WorkspaceValue>;
+    /**
+     * Delete one Workspace registration without deleting its directory or Sessions.
+     * @param request - Workspace identity to remove.
+     * @returns deletion confirmation.
+     */
+    delete(request: WorkspaceDeleteRequest): Promise<WorkspaceDeleteValue>;
+    /**
+     * Move one Workspace within the durable registry order.
+     * @param request - moved Workspace and optional anchor.
+     * @returns the complete resulting Workspace order.
+     */
+    insertBefore(request: WorkspaceInsertBeforeRequest): Promise<WorkspaceOrderValue>;
+    /**
+     * Move one accounted Session within a Workspace's manual order.
+     * @param request - Workspace, Session, and optional anchor identities.
+     * @returns the updated Workspace projection.
+     */
+    insertSessionBefore(request: WorkspaceInsertSessionBeforeRequest): Promise<WorkspaceValue>;
+    /**
+     * Add one known Session to the registry-global archive set.
+     * @param request - Session identity to archive.
+     * @returns the complete resulting archive set.
+     */
+    archiveSession(request: WorkspaceArchiveSessionRequest): Promise<WorkspaceArchiveValue>;
+    private requireWorkspace;
+    private enqueue;
+}
+//# sourceMappingURL=commands.d.ts.map

package/lib/types/commands.js

@@ -0,0 +1,144 @@
+/** Workspace command implementation and stable Remote failure mapping. */
+import { WorkspaceId, WorkspaceMoveInvalidError, WorkspaceOrderInvalidError, WorkspaceUnknownSessionError, } from '@deepseek-ai/dsh-workspace';
+import { RemoteError, remoteErrorOf } from '@deepseek-ai/dsh-typert-protocol';
+import { workspaceView } from "./feed.js";
+/** Implements Workspace mutations against the authoritative registry. */
+export class WorkspaceCommands {
+    ctx;
+    operationTail = Promise.resolve();
+    /** @param ctx - Host context containing the Workspace registry. */
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * Create or resolve one Workspace over an existing directory.
+     * @param request - directory path to register.
+     * @returns the Workspace and whether this call created it.
+     */
+    create(request) {
+        return this.enqueue(async () => {
+            try {
+                const existing = await this.ctx.workspaceRegistry.resolveByPath(request.path);
+                if (existing !== undefined) {
+                    return { workspace: workspaceView(existing), created: false };
+                }
+                const workspace = await this.ctx.workspaceRegistry.create(request.path);
+                return { workspace: workspaceView(workspace), created: true };
+            }
+            catch (error) {
+                if (remoteErrorOf(error) !== undefined)
+                    throw error;
+                throw new RemoteError('workspace/invalid-path', `cannot create a Workspace at "${request.path}": ${errorMessage(error)}`, { path: request.path }, { cause: error });
+            }
+        });
+    }
+    /**
+     * Rename one Workspace after serializing title ownership checks.
+     * @param request - Workspace identity and proposed title.
+     * @returns the updated Workspace projection.
+     */
+    rename(request) {
+        const title = request.title.trim();
+        if (title === '') {
+            return Promise.reject(new RemoteError('gateway/bad-request', 'Workspace rename requires a non-blank title', {}));
+        }
+        return this.enqueue(async () => {
+            const workspace = this.requireWorkspace(request.workspaceId);
+            if (title !== workspace.title) {
+                if (this.ctx.workspaceRegistry.list().some(candidate => candidate.id !== workspace.id && candidate.title === title)) {
+                    throw new RemoteError('workspace/name-conflict', `Workspace name '${title}' is already in use`, { name: title });
+                }
+                await workspace.setTitle(title);
+            }
+            return { workspace: workspaceView(workspace) };
+        });
+    }
+    /**
+     * Delete one Workspace registration without deleting its directory or Sessions.
+     * @param request - Workspace identity to remove.
+     * @returns deletion confirmation.
+     */
+    delete(request) {
+        return this.enqueue(async () => {
+            if (!await this.ctx.workspaceRegistry.delete(WorkspaceId(request.workspaceId))) {
+                throw workspaceNotFound(request.workspaceId);
+            }
+            return { deleted: true };
+        });
+    }
+    /**
+     * Move one Workspace within the durable registry order.
+     * @param request - moved Workspace and optional anchor.
+     * @returns the complete resulting Workspace order.
+     */
+    async insertBefore(request) {
+        try {
+            const workspaceIds = await this.ctx.workspaceRegistry.insertBefore(WorkspaceId(request.workspaceId), request.beforeWorkspaceId === undefined
+                ? undefined
+                : WorkspaceId(request.beforeWorkspaceId));
+            return { workspaceIds: [...workspaceIds] };
+        }
+        catch (error) {
+            if (!(error instanceof WorkspaceOrderInvalidError))
+                throw error;
+            throw workspaceNotFound(error.workspaceId);
+        }
+    }
+    /**
+     * Move one accounted Session within a Workspace's manual order.
+     * @param request - Workspace, Session, and optional anchor identities.
+     * @returns the updated Workspace projection.
+     */
+    async insertSessionBefore(request) {
+        const workspace = this.requireWorkspace(request.workspaceId);
+        try {
+            await workspace.insertSessionBefore(request.sessionId, request.beforeSessionId);
+        }
+        catch (error) {
+            if (!(error instanceof WorkspaceMoveInvalidError))
+                throw error;
+            throw new RemoteError('workspace/move-invalid', error.message, {
+                workspaceId: request.workspaceId,
+                sessionId: request.sessionId,
+                ...request.beforeSessionId === undefined
+                    ? {}
+                    : { beforeSessionId: request.beforeSessionId },
+            }, { cause: error });
+        }
+        return { workspace: workspaceView(workspace) };
+    }
+    /**
+     * Add one known Session to the registry-global archive set.
+     * @param request - Session identity to archive.
+     * @returns the complete resulting archive set.
+     */
+    async archiveSession(request) {
+        try {
+            await this.ctx.workspaceRegistry.archiveSession(request.sessionId);
+        }
+        catch (error) {
+            if (!(error instanceof WorkspaceUnknownSessionError))
+                throw error;
+            throw new RemoteError('session/not-found', error.message, { sessionId: request.sessionId }, { cause: error });
+        }
+        return { archivedSessionIds: [...this.ctx.workspaceRegistry.archivedSessionIds] };
+    }
+    requireWorkspace(workspaceId) {
+        const workspace = this.ctx.workspaceRegistry.get(WorkspaceId(workspaceId));
+        if (workspace === undefined)
+            throw workspaceNotFound(workspaceId);
+        return workspace;
+    }
+    enqueue(operation) {
+        const result = this.operationTail.then(operation);
+        this.operationTail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+}
+function workspaceNotFound(workspaceId) {
+    return new RemoteError('workspace/not-found', `Workspace "${workspaceId}" not found`, { workspaceId });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=commands.js.map

package/lib/types/directory-picker.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Host directory-picking Remote owner: capability gating, cancellation, and the
+ * stable wire failure vocabulary over the `ctx.directoryPicker` seam.
+ */
+import { Context } from '@deepseek-ai/cordis';
+import type { DirectoryListing } from '@deepseek-ai/dsh-host-directory-picker/types';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** Host directory-picking Remote namespace owner. */
+        directoryPickerController: DirectoryPickerController;
+    }
+}
+/**
+ * Host service backing the generated `ctx.remote.directoryPicker` namespace. The
+ * seam it exports is abstract and therefore never a Loader entry of its own, so
+ * this controller carries the wire verbs: one composed backend serves either the
+ * native chooser or the browse primitives, and a verb the composition cannot
+ * serve is refused rather than approximated.
+ */
+export declare class DirectoryPickerController extends TypertRemoteService {
+    static inject: string[];
+    /** @param ctx - Host context carrying the composed directory-picking backend. */
+    constructor(ctx: Context);
+    /**
+     * Open the host's OS chooser for a Remote caller.
+     * @param signal - caller lifetime; abort terminates the chooser.
+     * @returns the chosen absolute path, or null when the operator cancels.
+     */
+    pick(signal: AbortSignal): Promise<string | null>;
+    /**
+     * List one directory level for a Remote caller's in-app browser.
+     * @param path - absolute directory to list; absent lists the home directory.
+     * @param signal - caller lifetime; abort stops the backend's scan instead of
+     *   letting it outlive a disconnected caller.
+     * @returns the level's listing with its ancestry.
+     */
+    list(path: string | undefined, signal: AbortSignal): Promise<DirectoryListing>;
+    /**
+     * Create one child directory for a Remote caller's in-app browser.
+     * @param path - absolute existing parent directory.
+     * @param name - single non-blank path segment.
+     * @returns the created directory's absolute path.
+     */
+    createDirectory(path: string, name: string): Promise<string>;
+    /** Resolve the capability one wire verb needs, or refuse with the kind this backend serves. */
+    private requireCapability;
+}
+//# sourceMappingURL=directory-picker.d.ts.map