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

package/lib/types/directory-picker.js

@@ -0,0 +1,179 @@
+/**
+ * Host directory-picking Remote owner: capability gating, cancellation, and the
+ * stable wire failure vocabulary over the `ctx.directoryPicker` seam.
+ */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { z } from 'zod';
+import { DirectoryPickerError } from '@deepseek-ai/dsh-host-directory-picker';
+import { Remote, RemoteError, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+const createDirectoryRequestSchema = z.object({
+    path: z.string(),
+    name: z.string(),
+}).refine(request => request.name.trim() !== '' && request.name !== '.' && request.name !== '..'
+    && !/[/\\]/.test(request.name), { message: 'host.createDirectory requires a single non-blank path segment name' });
+/**
+ * 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.
+ */
+let DirectoryPickerController = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _pick_decorators;
+    let _list_decorators;
+    let _createDirectory_decorators;
+    return class DirectoryPickerController extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _pick_decorators = [Remote('pick')];
+            _list_decorators = [Remote('list')];
+            _createDirectory_decorators = [Remote('createDirectory')];
+            __esDecorate(this, null, _pick_decorators, { kind: "method", name: "pick", static: false, private: false, access: { has: obj => "pick" in obj, get: obj => obj.pick }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _list_decorators, { kind: "method", name: "list", static: false, private: false, access: { has: obj => "list" in obj, get: obj => obj.list }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createDirectory_decorators, { kind: "method", name: "createDirectory", static: false, private: false, access: { has: obj => "createDirectory" in obj, get: obj => obj.createDirectory }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static inject = ['directoryPicker'];
+        /** @param ctx - Host context carrying the composed directory-picking backend. */
+        constructor(ctx) {
+            super(ctx, 'directoryPickerController', { namespace: 'directoryPicker' });
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        /**
+         * 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.
+         */
+        async pick(signal) {
+            const capability = this.requireCapability('native', 'pick');
+            try {
+                return await capability.pick(signal);
+            }
+            catch (error) {
+                throw cancellableFailure(error, signal, 'directory picker was aborted', 'directory picker failed');
+            }
+        }
+        /**
+         * 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.
+         */
+        async list(path, signal) {
+            const capability = this.requireCapability('browse', 'list');
+            try {
+                return await capability.list(path, signal);
+            }
+            catch (error) {
+                throw cancellableFailure(error, signal, 'directory listing was aborted');
+            }
+        }
+        /**
+         * 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.
+         */
+        async createDirectory(path, name) {
+            const request = createDirectoryRequestSchema.safeParse({ path, name });
+            if (!request.success) {
+                throw new RemoteError('gateway/bad-request', 'invalid payload for host.createDirectory', { issues: request.error.issues });
+            }
+            const capability = this.requireCapability('browse', 'createDirectory');
+            try {
+                return await capability.createDirectory(request.data.path, request.data.name);
+            }
+            catch (error) {
+                throw browseFailure(error);
+            }
+        }
+        /** Resolve the capability one wire verb needs, or refuse with the kind this backend serves. */
+        requireCapability(kind, method) {
+            const capability = this.ctx.directoryPicker.capability();
+            if (capability.kind !== kind) {
+                throw new RemoteError('directory-picker/unavailable', `directoryPicker.${method} needs the ${kind} capability; the composed picker serves "${capability.kind}"`, { capability: capability.kind });
+            }
+            return capability;
+        }
+    };
+})();
+export { DirectoryPickerController };
+/**
+ * Wire code answered for each seam browse failure. The seam's closed codes are
+ * its own local vocabulary, so this controller owns the projection onto the
+ * `directory-picker/*` codes a Remote caller discriminates on.
+ */
+const BROWSE_FAILURE_CODES = {
+    'directory-unreadable': 'directory-picker/unreadable',
+    'directory-exists': 'directory-picker/exists',
+    'directory-create-failed': 'directory-picker/create-failed',
+};
+/**
+ * Classify a browse-primitive rejection: the seam's own closed codes carry the
+ * path they are about, and anything else stays an infrastructure failure.
+ * @param error - the primitive's rejection.
+ * @returns the failure to throw across the Remote boundary.
+ */
+function browseFailure(error) {
+    if (error instanceof DirectoryPickerError) {
+        return new RemoteError(BROWSE_FAILURE_CODES[error.code], error.message, { path: error.path }, { cause: error });
+    }
+    return new RemoteError('gateway/internal', errorMessage(error), {}, { cause: error });
+}
+/**
+ * Classify a cancellable primitive's rejection. An abort is the caller's own
+ * timeout or disconnect, not a backend failure, so it answers `gateway/cancelled`
+ * before the business classification runs.
+ * @param error - the primitive's rejection.
+ * @param signal - the caller lifetime the primitive ran under.
+ * @param cancelled - operator-facing text for the abort outcome.
+ * @param failed - prefix for a non-seam failure, when the verb has no closed codes.
+ * @returns the failure to throw across the Remote boundary.
+ */
+function cancellableFailure(error, signal, cancelled, failed) {
+    if (signal.aborted)
+        return new RemoteError('gateway/cancelled', cancelled, {}, { cause: error });
+    if (failed === undefined)
+        return browseFailure(error);
+    return new RemoteError('gateway/internal', `${failed}: ${errorMessage(error)}`, {}, { cause: error });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=directory-picker.js.map

package/lib/types/feed.d.ts

@@ -0,0 +1,34 @@
+/** Reconnect-safe Workspace baseline and increment producer. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Workspace } from '@deepseek-ai/dsh-workspace';
+import type { WorkspaceBaseline, WorkspaceFollowFrame, WorkspaceView } from './types.ts';
+/**
+ * Project one authoritative Workspace entity into its Remote value.
+ * @param workspace - authoritative registry entity.
+ * @returns detached Workspace projection for Remote consumers.
+ */
+export declare function workspaceView(workspace: Workspace): WorkspaceView;
+/** Owns Workspace domain observation and all active follow generations. */
+export declare class WorkspaceFeed {
+    private readonly ctx;
+    private readonly followers;
+    private knownIds;
+    private order;
+    private archived;
+    /** @param ctx - Host context containing the authoritative Workspace registry. */
+    constructor(ctx: Context);
+    /**
+     * Read the complete current projection synchronously.
+     * @returns all active Workspaces and archived Session identities.
+     */
+    baseline(): WorkspaceBaseline;
+    /**
+     * Open one generation beginning with a complete baseline.
+     * @param signal - generation cancellation.
+     * @returns baseline followed by ordered Workspace increments.
+     */
+    follow(signal: AbortSignal): AsyncIterable<WorkspaceFollowFrame>;
+    private changed;
+    private publish;
+}
+//# sourceMappingURL=feed.d.ts.map

package/lib/types/feed.js

@@ -0,0 +1,175 @@
+/** Reconnect-safe Workspace baseline and increment producer. */
+import { Deque } from '@deepseek-ai/dsh-deque';
+import { workspaceDomainState, workspaceRecord, WorkspaceId, } from '@deepseek-ai/dsh-workspace';
+/**
+ * Project one authoritative Workspace entity into its Remote value.
+ * @param workspace - authoritative registry entity.
+ * @returns detached Workspace projection for Remote consumers.
+ */
+export function workspaceView(workspace) {
+    return {
+        workspaceId: workspace.id,
+        path: workspace.path,
+        title: workspace.title,
+        sessionIds: [...workspace.sessionIds],
+        createdAt: workspace.createdAt,
+        updatedAt: workspace.updatedAt,
+    };
+}
+function changedWorkspaceView(workspaceId, value) {
+    const record = workspaceRecord.parse(value);
+    return {
+        workspaceId: WorkspaceId(workspaceId),
+        path: record.path,
+        title: record.title,
+        sessionIds: [...record.sessionIds],
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+    };
+}
+/** Owns Workspace domain observation and all active follow generations. */
+export class WorkspaceFeed {
+    ctx;
+    followers = new Set();
+    knownIds;
+    order;
+    archived;
+    /** @param ctx - Host context containing the authoritative Workspace registry. */
+    constructor(ctx) {
+        this.ctx = ctx;
+        const baseline = ctx.workspaceRegistry.list();
+        this.knownIds = new Set(baseline.map(workspace => String(workspace.id)));
+        this.order = baseline.map(workspace => String(workspace.id));
+        this.archived = ctx.workspaceRegistry.archivedSessionIds.map(String);
+        ctx.on('domain/changed', (change) => { this.changed(change); });
+        ctx.effect(() => () => {
+            for (const follower of this.followers)
+                follower.close();
+            this.followers.clear();
+        }, 'workspace-controller.feed');
+    }
+    /**
+     * Read the complete current projection synchronously.
+     * @returns all active Workspaces and archived Session identities.
+     */
+    baseline() {
+        return {
+            items: this.ctx.workspaceRegistry.list().map(workspaceView),
+            archivedSessionIds: [...this.ctx.workspaceRegistry.archivedSessionIds],
+        };
+    }
+    /**
+     * Open one generation beginning with a complete baseline.
+     * @param signal - generation cancellation.
+     * @returns baseline followed by ordered Workspace increments.
+     */
+    async *follow(signal) {
+        signal.throwIfAborted();
+        const follower = new WorkspaceFollower();
+        this.followers.add(follower);
+        try {
+            yield { type: 'baseline', value: this.baseline() };
+            yield* follower.read(signal);
+        }
+        finally {
+            this.followers.delete(follower);
+            follower.close();
+        }
+    }
+    changed(change) {
+        if (change.domain !== 'workspace')
+            return;
+        if (change.table === '') {
+            if (change.operation !== 'put')
+                return;
+            const state = workspaceDomainState.parse(change.value);
+            const nextOrder = state.workspaceIds.map(String);
+            const orderChanged = !sameStrings(this.order, nextOrder);
+            for (const id of state.workspaceIds) {
+                if (this.knownIds.has(id))
+                    continue;
+                const workspace = this.ctx.workspaceRegistry.get(id);
+                if (workspace === undefined) {
+                    throw new Error(`committed Workspace registry references missing Workspace "${id}"`);
+                }
+                this.knownIds.add(id);
+                this.publish({ type: 'upsert', workspace: workspaceView(workspace) });
+            }
+            this.order = nextOrder;
+            if (orderChanged)
+                this.publish({ type: 'order', workspaceIds: [...state.workspaceIds] });
+            const nextArchived = state.archivedSessionIds.map(String);
+            if (!sameStrings(this.archived, nextArchived)) {
+                this.archived = nextArchived;
+                this.publish({ type: 'archived', archivedSessionIds: [...state.archivedSessionIds] });
+            }
+            return;
+        }
+        if (change.table !== 'workspaces')
+            return;
+        if (change.operation === 'deleted') {
+            if (!this.knownIds.delete(change.key))
+                return;
+            this.publish({ type: 'remove', workspaceId: WorkspaceId(change.key) });
+            return;
+        }
+        if (!this.knownIds.has(change.key))
+            return;
+        this.publish({
+            type: 'upsert',
+            workspace: changedWorkspaceView(change.key, change.value),
+        });
+    }
+    publish(frame) {
+        for (const follower of this.followers)
+            follower.push(frame);
+    }
+}
+function sameStrings(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+class WorkspaceFollower {
+    frames = new Deque();
+    waiting;
+    closed = false;
+    push(frame) {
+        /* v8 ignore next -- closed followers are removed before later publication can reach them. */
+        if (this.closed)
+            return;
+        this.frames.pushBack(frame);
+        this.waiting?.();
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.waiting?.();
+    }
+    async *read(signal) {
+        while (!this.closed && !signal.aborted) {
+            const frame = this.frames.popFront();
+            if (frame !== undefined) {
+                yield frame;
+                continue;
+            }
+            await this.wait(signal);
+        }
+    }
+    wait(signal) {
+        return new Promise((resolve) => {
+            const finish = () => {
+                signal.removeEventListener('abort', finish);
+                /* v8 ignore next -- one read owns the sole installed wait callback. */
+                if (this.waiting === finish)
+                    this.waiting = undefined;
+                resolve();
+            };
+            this.waiting = finish;
+            signal.addEventListener('abort', finish, { once: true });
+            /* v8 ignore next -- native signals and the private queue cannot change during this synchronous setup. */
+            if (signal.aborted || this.closed || this.frames.size > 0)
+                finish();
+        });
+    }
+}
+//# sourceMappingURL=feed.js.map

package/lib/types/index.d.ts

@@ -0,0 +1,64 @@
+/** Host Workspace Remote owner: explicit commands and reconnect-safe state. */
+import { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { WorkspaceArchiveSessionRequest, WorkspaceArchiveValue, WorkspaceCreateRequest, WorkspaceCreateValue, WorkspaceDeleteRequest, WorkspaceDeleteValue, WorkspaceFollowFrame, WorkspaceInsertBeforeRequest, WorkspaceInsertSessionBeforeRequest, WorkspaceOrderValue, WorkspaceRenameRequest, WorkspaceValue } from './types.ts';
+export type * from './types.ts';
+export { DirectoryPickerController } from './directory-picker.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** Host Workspace business API and Remote namespace owner. */
+        workspaceController: WorkspaceController;
+    }
+}
+/** Host service backing the generated `ctx.remote.workspace` namespace. */
+export declare class WorkspaceController extends TypertRemoteService {
+    static inject: string[];
+    private readonly commands;
+    private readonly feed;
+    /** @param ctx - Host context containing the Workspace registry. */
+    constructor(ctx: Context);
+    /**
+     * Create or idempotently 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 to a unique non-blank title.
+     * @param request - Workspace identity and proposed title.
+     * @returns the updated Workspace projection.
+     */
+    rename(request: WorkspaceRenameRequest): Promise<WorkspaceValue>;
+    /**
+     * Remove one Workspace registration while retaining files and Sessions.
+     * @param request - Workspace identity to remove.
+     * @returns deletion confirmation.
+     */
+    delete(request: WorkspaceDeleteRequest): Promise<WorkspaceDeleteValue>;
+    /**
+     * Move one Workspace within the registry display 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.
+     * @param request - Workspace, Session, and optional anchor identities.
+     * @returns the updated Workspace projection.
+     */
+    insertSessionBefore(request: WorkspaceInsertSessionBeforeRequest): Promise<WorkspaceValue>;
+    /**
+     * Hide one known Session from Workspace grouping surfaces.
+     * @param request - Session identity to archive.
+     * @returns the complete resulting archive set.
+     */
+    archiveSession(request: WorkspaceArchiveSessionRequest): Promise<WorkspaceArchiveValue>;
+    /**
+     * Stream a complete Workspace baseline followed by ordered increments.
+     * @param signal - generation cancellation.
+     * @returns baseline followed by ordered Workspace increments.
+     */
+    follow(signal: AbortSignal): AsyncIterable<WorkspaceFollowFrame>;
+}
+export default WorkspaceController;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -0,0 +1,145 @@
+/** Host Workspace Remote owner: explicit commands and reconnect-safe state. */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { WorkspaceCommands } from "./commands.js";
+import { DirectoryPickerController } from "./directory-picker.js";
+import { WorkspaceFeed } from "./feed.js";
+export { DirectoryPickerController } from "./directory-picker.js";
+/** Host service backing the generated `ctx.remote.workspace` namespace. */
+let WorkspaceController = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _create_decorators;
+    let _rename_decorators;
+    let _delete_decorators;
+    let _insertBefore_decorators;
+    let _insertSessionBefore_decorators;
+    let _archiveSession_decorators;
+    let _follow_decorators;
+    return class WorkspaceController extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _create_decorators = [Remote('create')];
+            _rename_decorators = [Remote('rename')];
+            _delete_decorators = [Remote('delete')];
+            _insertBefore_decorators = [Remote('insertBefore')];
+            _insertSessionBefore_decorators = [Remote('insertSessionBefore')];
+            _archiveSession_decorators = [Remote('archiveSession')];
+            _follow_decorators = [Remote({ mode: 'stream' })];
+            __esDecorate(this, null, _create_decorators, { kind: "method", name: "create", static: false, private: false, access: { has: obj => "create" in obj, get: obj => obj.create }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _rename_decorators, { kind: "method", name: "rename", static: false, private: false, access: { has: obj => "rename" in obj, get: obj => obj.rename }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _delete_decorators, { kind: "method", name: "delete", static: false, private: false, access: { has: obj => "delete" in obj, get: obj => obj.delete }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _insertBefore_decorators, { kind: "method", name: "insertBefore", static: false, private: false, access: { has: obj => "insertBefore" in obj, get: obj => obj.insertBefore }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _insertSessionBefore_decorators, { kind: "method", name: "insertSessionBefore", static: false, private: false, access: { has: obj => "insertSessionBefore" in obj, get: obj => obj.insertSessionBefore }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _archiveSession_decorators, { kind: "method", name: "archiveSession", static: false, private: false, access: { has: obj => "archiveSession" in obj, get: obj => obj.archiveSession }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _follow_decorators, { kind: "method", name: "follow", static: false, private: false, access: { has: obj => "follow" in obj, get: obj => obj.follow }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static inject = ['typert', 'workspaceRegistry'];
+        commands = __runInitializers(this, _instanceExtraInitializers);
+        feed;
+        /** @param ctx - Host context containing the Workspace registry. */
+        constructor(ctx) {
+            super(ctx, 'workspaceController', { namespace: 'workspace' });
+            this.commands = new WorkspaceCommands(ctx);
+            this.feed = new WorkspaceFeed(ctx);
+            // This package is the Loader entry for both Remote owners it hosts: the
+            // directory-picking seam is abstract and never an entry itself. The child
+            // stays pending until a picking backend is composed, so a host without one
+            // registers no picking namespace instead of answering an unservable verb.
+            ctx.plugin(DirectoryPickerController);
+        }
+        /**
+         * Create or idempotently 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.commands.create(request);
+        }
+        /**
+         * Rename one Workspace to a unique non-blank title.
+         * @param request - Workspace identity and proposed title.
+         * @returns the updated Workspace projection.
+         */
+        rename(request) {
+            return this.commands.rename(request);
+        }
+        /**
+         * Remove one Workspace registration while retaining files and Sessions.
+         * @param request - Workspace identity to remove.
+         * @returns deletion confirmation.
+         */
+        delete(request) {
+            return this.commands.delete(request);
+        }
+        /**
+         * Move one Workspace within the registry display order.
+         * @param request - moved Workspace and optional anchor.
+         * @returns the complete resulting Workspace order.
+         */
+        insertBefore(request) {
+            return this.commands.insertBefore(request);
+        }
+        /**
+         * Move one accounted Session within a Workspace.
+         * @param request - Workspace, Session, and optional anchor identities.
+         * @returns the updated Workspace projection.
+         */
+        insertSessionBefore(request) {
+            return this.commands.insertSessionBefore(request);
+        }
+        /**
+         * Hide one known Session from Workspace grouping surfaces.
+         * @param request - Session identity to archive.
+         * @returns the complete resulting archive set.
+         */
+        archiveSession(request) {
+            return this.commands.archiveSession(request);
+        }
+        /**
+         * Stream a complete Workspace baseline followed by ordered increments.
+         * @param signal - generation cancellation.
+         * @returns baseline followed by ordered Workspace increments.
+         */
+        follow(signal) {
+            return this.feed.follow(signal);
+        }
+    };
+})();
+export { WorkspaceController };
+export default WorkspaceController;
+//# sourceMappingURL=index.js.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,9 @@
+/** Package-owned invariant companion. @module @deepseek-ai/dsh-api-workspace-controller/invariant */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "api-workspace-controller-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/** Register this package's invariant companion. */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/invariant.js

@@ -0,0 +1,12 @@
+/** Package-owned invariant companion. @module @deepseek-ai/dsh-api-workspace-controller/invariant */
+const PACKAGE_NAME = '@deepseek-ai/dsh-api-workspace-controller';
+/** Cordis companion plugin name. */
+export const name = 'api-workspace-controller-invariant';
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants'];
+/** No runtime invariant: Workspace Registry owns persistence; every stream generation is a full projection. */
+const install = () => { };
+/** Register this package's invariant companion. */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+/* jscpd:ignore-end */
+//# sourceMappingURL=invariant.js.map