@dsh-electron/dsh-plugin-multi-root-workspace 0.1.10 → 0.1.12

package/lib/skills.js

@@ -1,4 +1,5 @@
 import { t as wrapMethod } from "./method-wrapper-CFY3p3j2.js";
+import { c as withRegistryRead } from "./registry-operation-C2ZV3Jhw.js";
 import { r as isPackageInstalled, t as createInstructionMessage } from "./llm-message-fYORacvh.js";
 import { n as skillsMetadataValid } from "./metadata-DgqSdVX_.js";
 import { constants, statSync } from "node:fs";
@@ -6,8 +7,8 @@ import { createHash } from "node:crypto";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { Service } from "@deepseek-ai/cordis";
 import { canonicalPath } from "@deepseek-ai/dsh-sandbox";
-import { lstat, open, readdir, stat } from "node:fs/promises";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { lstat, open, readdir, stat } from "node:fs/promises";
 import z from "@deepseek-ai/schemastery";
 //#region \0@oxc-project+runtime@0.149.0/helpers/esm/usingCtx.js
 function _usingCtx() {
@@ -191,9 +192,10 @@ var SkillReaderPool = class {
 		return this.entries.size;
 	}
 	get roots() {
-		return [...this.entries.keys()];
+		return [...new Set([...this.entries.values()].map((entry) => entry.root))];
 	}
-	async use(key, create, run, signal) {
+	async use(root, create, run, signal, identity = root) {
+		const key = identity;
 		for (;;) {
 			signal?.throwIfAborted();
 			if (this.closing) throw new Error("multi-root skills: reader pool is closing");
@@ -225,6 +227,7 @@ var SkillReaderPool = class {
 				const controller = new AbortController();
 				entry = {
 					key,
+					root,
 					controller,
 					reader: create(controller.signal),
 					busy: 0
@@ -235,7 +238,7 @@ var SkillReaderPool = class {
 			this.entries.set(key, entry);
 			entry.busy++;
 			try {
-				if (entry.stamp === void 0) entry.stamp = await skillTreeStamp(key);
+				if (entry.stamp === void 0) entry.stamp = await skillTreeStamp(entry.root);
 				signal?.throwIfAborted();
 				return await run(await entry.reader);
 			} finally {
@@ -249,7 +252,7 @@ var SkillReaderPool = class {
 		this.polling ??= (async () => {
 			let changed = false;
 			for (const entry of [...this.entries.values()]) {
-				const stamp = await skillTreeStamp(entry.key);
+				const stamp = await skillTreeStamp(entry.root);
 				if (entry.stamp !== void 0 && entry.stamp !== stamp) changed = true;
 				entry.stamp = stamp;
 			}
@@ -285,10 +288,10 @@ var SkillReaderPool = class {
 /** No symlink target outside the Root is read or enumerated. Content reads stay on demand. */
 async function skillTreeStamp(root) {
 	const rows = [canonicalPath(root)];
-	const stamp = async (path) => {
+	const stamp = async (path, identityOnly = false) => {
 		try {
 			const link = await lstat(path, { bigint: true });
-			rows.push(`${path}:${link.dev}:${link.ino}:${link.size}:${link.mtimeNs}:${link.ctimeNs}:${canonicalPath(path)}`);
+			rows.push(identityOnly ? `${path}:${link.dev}:${link.ino}:${link.mode}:${canonicalPath(path)}` : `${path}:${link.dev}:${link.ino}:${link.size}:${link.mtimeNs}:${link.ctimeNs}:${canonicalPath(path)}`);
 			if (!containsPath(root, canonicalPath(path))) return void 0;
 			return await stat(path);
 		} catch {
@@ -296,7 +299,7 @@ async function skillTreeStamp(root) {
 			return;
 		}
 	};
-	await stamp(root);
+	await stamp(root, true);
 	for (const directory of [".dsh/skills", ".agents/skills"]) {
 		const path = join(root, directory);
 		if (!(await stamp(path))?.isDirectory()) continue;
@@ -336,7 +339,7 @@ var AdditionalSkillCatalog = class {
 		return this.generation();
 	}
 	current(primary, id) {
-		if (this.signal.aborted || !this.enabled() || this.ctx.multiRootRegistry.authority.kind !== "active" || this.ctx.multiRootScope.resolve({
+		if (this.signal.aborted || !this.enabled() || !this.ctx.multiRootRegistry.available || this.ctx.multiRootScope.snapshot({
 			mode: "read-only",
 			workspaceRoot: primary
 		}).authority !== "available") return void 0;
@@ -355,13 +358,17 @@ var AdditionalSkillCatalog = class {
 		if (root === void 0) return await run(void 0);
 		return await this.requests.run({
 			primary,
-			id
+			id,
+			epoch: this.ctx.multiRootRegistry.epoch
 		}, () => this.pool.use(root.path, (signal) => rootReader(this.ctx, root.path, AbortSignal.any([signal, this.signal]), () => {
 			const request = this.requests.getStore();
-			return request !== void 0 && this.current(request.primary, request.id)?.path === root.path;
-		}), run, options.signal));
+			return request !== void 0 && request.epoch === this.ctx.multiRootRegistry.epoch && this.current(request.primary, request.id)?.path === root.path;
+		}), run, options.signal, `${this.ctx.multiRootRegistry.epoch ?? "unavailable"}\0${root.path}`));
 	}
 	async list(primary, options) {
+		return withRegistryRead(this.ctx, primary, "skills", () => this.listAdmitted(primary, options));
+	}
+	async listAdmitted(primary, options) {
 		options.signal?.throwIfAborted();
 		if (!this.enabled()) return [];
 		const roots = await this.ctx.multiRootRegistry.refresh(primary);
@@ -381,6 +388,7 @@ var AdditionalSkillCatalog = class {
 					seen.add(candidate.name);
 					const locator = {
 						primary,
+						authorityEpoch: this.ctx.multiRootRegistry.epoch,
 						rootId: root.id,
 						aliasId: root.aliasId,
 						candidate
@@ -408,8 +416,11 @@ var AdditionalSkillCatalog = class {
 	}
 	/** Locators are created here and are not accepted from a client path or object. */
 	async load(primary, entry, options, user) {
+		return withRegistryRead(this.ctx, primary, "skills", () => this.loadAdmitted(primary, entry, options, user));
+	}
+	async loadAdmitted(primary, entry, options, user) {
 		const locator = entry.locator;
-		if (typeof locator !== "object" || locator === null || !this.locators.has(locator) || locator.primary !== primary) return void 0;
+		if (typeof locator !== "object" || locator === null || !this.locators.has(locator) || locator.primary !== primary || locator.authorityEpoch !== this.ctx.multiRootRegistry.epoch) return void 0;
 		const root = this.current(primary, locator.rootId);
 		if (root === void 0 || root.aliasId !== locator.aliasId || entry.name !== internalSkillName(primary, root.id, locator.candidate.name)) return void 0;
 		const revision = this.generation();
@@ -446,14 +457,16 @@ var AdditionalSkillCatalog = class {
 	}
 	async admissionValid(definition) {
 		const receipt = this.loadedReceipts.get(definition);
-		if (receipt === void 0) return false;
-		const current = this.current(receipt.locator.primary, receipt.locator.rootId);
-		if (current === void 0 || current.aliasId !== receipt.locator.aliasId || receipt.revision !== this.generation()) return false;
-		try {
-			return receipt.stamp === await fileStamp(definition.path) && receipt.revision === this.generation() && this.current(receipt.locator.primary, receipt.locator.rootId)?.aliasId === receipt.locator.aliasId;
-		} catch {
-			return false;
-		}
+		if (receipt === void 0 || receipt.locator.authorityEpoch !== this.ctx.multiRootRegistry.epoch) return false;
+		return withRegistryRead(this.ctx, receipt.locator.primary, "skills", async () => {
+			const current = this.current(receipt.locator.primary, receipt.locator.rootId);
+			if (current === void 0 || current.aliasId !== receipt.locator.aliasId || receipt.revision !== this.generation()) return false;
+			try {
+				return receipt.stamp === await fileStamp(definition.path) && receipt.revision === this.generation() && this.current(receipt.locator.primary, receipt.locator.rootId)?.aliasId === receipt.locator.aliasId;
+			} catch {
+				return false;
+			}
+		});
 	}
 	async dispose() {
 		await this.pool.dispose();
@@ -574,16 +587,22 @@ function installSkillRouting(ctx) {
 	fibers.push(ctx.inject(["skills"], (scope) => {
 		const registry = scope.skills;
 		scope.effect(() => wrapMethod(registry, "snapshot", (original) => async function(options = {}) {
-			const result = await original.call(this, optionsFor(options));
-			const primary = skillOrigin(scope, options);
-			if (primary !== void 0) for (const skill of result.skills) {
-				if (skill.provider === "multi-root-workspace") continue;
-				if (scope.multiRootRegistry.list(primary).some((root) => skill.name.startsWith(internalSkillName(primary, root.id, "")))) scope.logger.warn(`multi-root skills: internal ID conflict; native winner retained: ${skill.name} (${skill.provider})`);
-			}
-			return result;
+			const primaryOrigin = skillOrigin(scope, options) ?? cold.getStore();
+			const run = async () => {
+				const result = await original.call(this, optionsFor(options));
+				const primary = skillOrigin(scope, options);
+				if (primary !== void 0) for (const skill of result.skills) {
+					if (skill.provider === "multi-root-workspace") continue;
+					if (scope.multiRootRegistry.list(primary).some((root) => skill.name.startsWith(internalSkillName(primary, root.id, "")))) scope.logger.warn(`multi-root skills: internal ID conflict; native winner retained: ${skill.name} (${skill.provider})`);
+				}
+				return result;
+			};
+			return primaryOrigin === void 0 ? run() : withRegistryRead(scope, primaryOrigin, "skills", run);
 		}));
 		scope.effect(() => wrapMethod(registry, "get", (original) => function(name, options = {}) {
-			return original.call(this, name, optionsFor(options));
+			const primary = skillOrigin(scope, options) ?? cold.getStore();
+			const run = () => original.call(this, name, optionsFor(options));
+			return primary === void 0 ? run() : withRegistryRead(scope, primary, "skills", run);
 		}));
 	}));
 	fibers.push(ctx.inject(["sessionSkillCatalog", "sessionQuery"], (scope) => {

package/lib/types/authority/native-win32.d.ts

@@ -0,0 +1,7 @@
+import type { Channel, Listener } from './native.ts';
+export declare function connectWindows(endpoint: string): Promise<Channel>;
+export declare function listenWindows(endpoint: string, accepted: (channel: Channel) => void): Promise<Listener>;
+export declare function windowsHostAvailability(): Promise<{
+    available: boolean;
+    reason?: string;
+}>;

package/lib/types/authority/native.d.ts

@@ -0,0 +1,23 @@
+import type { EventEmitter } from 'node:events';
+export interface Channel {
+    on: EventEmitter['on'];
+    readonly writableLength?: number;
+    write(data: string): boolean;
+    destroy(): unknown;
+}
+export interface Listener {
+    close(): void;
+}
+export declare function storeIdentity(root: string): {
+    root: string;
+    id: string;
+    endpoint: string;
+};
+export declare function connectNative(endpoint: string): Promise<Channel>;
+/** Called only by the kernel lease holder. Never removes another epoch's socket. */
+export declare function listenNative(endpoint: string, accepted: (channel: Channel) => void): Promise<Listener>;
+/** Capability probe for native tests and diagnostics; not an authorization bypass. */
+export declare function nativeHostAvailability(): Promise<{
+    available: boolean;
+    reason?: string;
+}>;

package/lib/types/authority/protocol.d.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+declare const methods: readonly ["hello", "snapshot", "admit", "add", "removeAt", "setAccess", "setAlias", "setSkillsEnabled", "setAliasId", "move", "recheck"];
+export type Method = typeof methods[number];
+export declare const snapshotSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<1>;
+    store: z.ZodString;
+    epoch: z.ZodString;
+    revision: z.ZodNumber;
+    primary: z.ZodString;
+    roots: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        access: z.ZodEnum<{
+            inherit: "inherit";
+            "read-only": "read-only";
+            "read-write": "read-write";
+        }>;
+        addedAt: z.ZodString;
+        recordedPath: z.ZodOptional<z.ZodString>;
+        readOnlyRecordedPath: z.ZodOptional<z.ZodString>;
+        readWriteRecordedPath: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodString>;
+        aliasId: z.ZodOptional<z.ZodUnknown>;
+        skillsEnabled: z.ZodOptional<z.ZodUnknown>;
+        state: z.ZodEnum<{
+            available: "available";
+            missing: "missing";
+            redirected: "redirected";
+            invalid: "invalid";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+        invalidReason: z.ZodOptional<z.ZodLiteral<"membership-conflict">>;
+    }, z.core.$strict>>;
+    available: z.ZodBoolean;
+}, z.core.$strict>;
+export type Snapshot = z.infer<typeof snapshotSchema>;
+export declare class AuthorityRpcError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class AuthorityClient {
+    private readonly channel;
+    private readonly store;
+    private readonly limit;
+    private readonly pending;
+    private closed;
+    epoch: string | undefined;
+    private constructor();
+    static connect(endpoint: string, store: string, limit: number, onChange: (snapshot: Snapshot) => void, disconnected: () => void): Promise<AuthorityClient>;
+    request(method: Method, args: readonly unknown[]): Promise<unknown>;
+    close(): void;
+}
+export declare class AuthorityServer {
+    private readonly store;
+    private readonly epoch;
+    private readonly limit;
+    private readonly dispatch;
+    private listener;
+    private readonly peers;
+    private readonly readyPeers;
+    private closed;
+    private inFlight;
+    private constructor();
+    static listen(endpoint: string, store: string, epoch: string, limit: number, dispatch: (method: Method, args: unknown[]) => Promise<unknown>): Promise<AuthorityServer>;
+    private accept;
+    changed(snapshot: Snapshot): void;
+    close(): void;
+}
+export declare function parseArguments(method: Method, args: unknown[]): unknown[];
+export {};

package/lib/types/client/open-in-app/OpenInAppAction.d.ts

@@ -1,17 +1,19 @@
 import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
 import type { InjectFace, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
 import type { OpenInAppLaunchState } from './controller.ts';
+import type { OpenInAppOutcome } from './outcome.ts';
 import type { ShortcutCatalogEntry } from '@deepseek-ai/dsh-client-shortcuts/client';
 import { NS } from './locales.ts';
+import { type OpenTargetReporter } from './OpenTargetButton.tsx';
 /** Browser operations and state shared by the Session header and file tree contributions. */
-export interface OpenInAppActionInjected {
+export interface OpenInAppActionInjected extends OpenTargetReporter {
     hooks: {
         openInAppApps: ObservableSnapshot<readonly string[] | null>;
         openInAppChoice: ObservableSnapshot<string>;
         openInAppLaunch: ObservableSnapshot<OpenInAppLaunchState>;
         shortcuts: ObservableSnapshot<readonly ShortcutCatalogEntry[]>;
     };
-    launch: (appId: string, path: string) => Promise<void>;
+    launch: (appId: string, path: string) => Promise<OpenInAppOutcome>;
     choose: (appId: string) => void;
     iconUrl: (appId: string) => string;
 }
@@ -21,7 +23,7 @@ export type OpenInAppActionProps = PropsLocale<typeof NS> & InjectFace<OpenInApp
 };
 /**
  * Adapt the installed directory catalog to the shared opening control.
- * @param props - displayed directory, installed catalog, and launch operations.
+ * @param props - displayed directory, installed catalog, launch operations, and the announcement seat.
  * @returns the shared control, or null without an eligible application.
  */
 export declare function OpenInAppAction(props: OpenInAppActionProps): React.JSX.Element | null;

package/lib/types/client/open-in-app/OpenTargetButton.d.ts

@@ -1,7 +1,7 @@
 import type { ReactNode } from 'react';
 import type { ShortcutCatalogEntry } from '@deepseek-ai/dsh-client-shortcuts/client';
 import type { TranslateNS } from '@deepseek-ai/dsh-client-ui-slots';
-import type { OpenInAppPathFailure } from './open-path.ts';
+import type { OpenInAppOutcome } from './outcome.ts';
 import type { NS } from './locales.ts';
 /** Application metadata supplied by either the directory catalog or a file association query. */
 export interface OpenTargetApplication {
@@ -18,8 +18,13 @@ export type OpenTargetOperation = {
 } | {
     readonly kind: 'reveal';
 };
+/** Seat a contribution sends one settled gesture to for app-wide announcement. */
+export interface OpenTargetReporter {
+    /** Report the settled outcome; `{ kind: 'skipped' }` announces nothing. */
+    readonly report: (outcome: OpenInAppOutcome) => void;
+}
 /** Inputs shared by both target adapters and the file empty-state action. */
-export interface OpenTargetButtonProps {
+export interface OpenTargetButtonProps extends OpenTargetReporter {
     readonly shortcut?: Pick<ShortcutCatalogEntry, 'keys' | 'aria'> | undefined;
     readonly kind: 'file' | 'directory';
     readonly applications: readonly OpenTargetApplication[];
@@ -29,24 +34,25 @@ export interface OpenTargetButtonProps {
     readonly loading?: boolean;
     readonly prominent?: boolean;
     readonly t: TranslateNS<typeof NS>;
-    readonly execute: (operation: OpenTargetOperation) => Promise<OpenInAppPathFailure | null>;
+    /** Resolve every gesture to an outcome, including Host and transport failures; never reject. */
+    readonly execute: (operation: OpenTargetOperation) => Promise<OpenInAppOutcome>;
     readonly refresh?: () => void;
 }
 /**
- * Serialize gestures and announce their failures through the initiating control's toast.
- * @param execute - target adapter that returns the failure to announce, or null.
- * @param t - localized control copy.
- * @returns the pending state, feedback, and guarded action callback.
+ * Serialize gestures and report the outcome each one settles on to the app-wide
+ * announcer, which outlives this control and the panel holding it.
+ * @param execute - target adapter that settles on the gesture's outcome.
+ * @param report - announcement seat the settled outcome is sent to.
+ * @returns the pending state and the guarded action callback.
  */
-export declare function useOpenTargetGesture(execute: OpenTargetButtonProps['execute'], t: TranslateNS<typeof NS>): {
+export declare function useOpenTargetGesture(execute: OpenTargetButtonProps['execute'], report: OpenTargetButtonProps['report']): {
     pending: boolean;
-    toast: ReactNode;
     act: (operation: OpenTargetOperation) => void;
 };
 /**
  * Render identical split buttons for files and directories. File reveal always
  * stays last; it is the default only when no application is registered.
  * @param props - target applications, default selection, and operations.
- * @returns the control and its transient failure feedback.
+ * @returns the control alone: its settled outcomes are announced by the seat it reports to.
  */
 export declare function OpenTargetButton(props: OpenTargetButtonProps): ReactNode;

package/lib/types/client/open-in-app/adapter.d.ts

@@ -25,6 +25,7 @@
 import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
 import type { ShortcutCatalogEntry } from '@deepseek-ai/dsh-client-shortcuts/client';
 import { OpenInAppAction, type OpenInAppActionProps } from './OpenInAppAction.tsx';
+import { type OpenInAppToastSource } from './open-toast.tsx';
 import { NS } from './locales.ts';
 /**
  * The props `OpenInAppAction` consumes, minus the per-render `absolutePath`
@@ -42,5 +43,8 @@ export type OpenInAppAdapter = Omit<OpenInAppActionProps, 'absolutePath'>;
 export declare function createOpenInAppAdapter(deps: {
     readonly t: (key: string, params?: Record<string, unknown>) => string;
     readonly shortcuts?: ObservableSnapshot<readonly ShortcutCatalogEntry[]> | undefined;
-}): OpenInAppAdapter | undefined;
+}): {
+    readonly adapter: OpenInAppAdapter;
+    readonly toast: OpenInAppToastSource;
+} | undefined;
 export { OpenInAppAction, NS as OPEN_IN_APP_NS };

package/lib/types/client/open-in-app/controller.d.ts

@@ -1,5 +1,6 @@
 /** Browser availability/choice state and the launch carrier for the split button. */
 import { type SnapshotStore } from '@deepseek-ai/dsh-client-store';
+import type { OpenInAppOutcome } from './outcome.ts';
 /** Shared launch status for controls targeting the captured workspace path. */
 export interface OpenInAppLaunchState {
     readonly phase: 'idle' | 'busy' | 'error';
@@ -45,9 +46,11 @@ export declare class OpenInAppController {
      * @param appId - catalog id from the availability list.
      * @param path - the session's absolute workspace directory.
      * Concurrent gestures are ignored until the current Host request settles.
-     * @returns after the host acknowledged the launch; rejects on any failure.
+     * @returns the acknowledged handoff, or `{ kind: 'skipped' }` while another
+     * launch holds the operation, or a named failure when the Host refuses or
+     * cannot be reached. Host and transport failures resolve without rejecting.
      */
-    launch(appId: string, path: string): Promise<void>;
+    launch(appId: string, path: string): Promise<OpenInAppOutcome>;
     private run;
 }
 export {};

package/lib/types/client/open-in-app/device.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Fork-facing shim for `isMobileDevice` from
+ * `@deepseek-ai/dsh-client-ui-primitives`.
+ *
+ * The verbatim `open-toast.tsx` spells this specifier where upstream writes
+ * the primitives import (joined only in `0.2.2-alpha.2`); the
+ * release-dependent probe and fallback live in
+ * `src/compat/open-in-app-device.ts` — version-dependent code belongs only
+ * under `src/compat/`. See FORK.md.
+ */
+export { isMobileDevice } from '../../compat/open-in-app-device.ts';

package/lib/types/client/open-in-app/locales.d.ts

@@ -1,7 +1,7 @@
 /** Dictionary namespace owned by upstream's plugin (verbatim). */
 export declare const NS = "open-in-app";
 /** Key domain of the `open-in-app` namespace (verbatim union of upstream's zh keys). */
-export type OpenInAppKey = 'open.title' | 'path.appDefault' | 'path.appsError' | 'shortcut.busy' | 'shortcut.unavailable' | 'open.tooltip' | 'path.open' | 'path.more' | 'path.reveal' | 'path.openError' | 'path.revealError' | 'app.cursor' | 'app.vscode' | 'app.vscodeinsiders' | 'app.windsurf' | 'app.zed' | 'app.sublimetext' | 'app.xcode' | 'app.androidstudio' | 'app.intellij' | 'app.pycharm' | 'app.webstorm' | 'app.phpstorm' | 'app.goland' | 'app.rider' | 'app.rustrover' | 'app.fork' | 'app.sourcetree' | 'app.github' | 'app.tower' | 'app.gitkraken' | 'app.smartgit' | 'app.sublimemerge' | 'app.ghostty' | 'app.warp' | 'app.iterm' | 'app.kitty' | 'app.terminal' | 'app.windowsterminal' | 'app.gitbash' | 'app.gnometerminal' | 'app.konsole' | 'app.finder' | 'app.explorer' | 'app.filemanager';
+export type OpenInAppKey = 'open.title' | 'path.appDefault' | 'path.appsError' | 'shortcut.busy' | 'shortcut.unavailable' | 'open.tooltip' | 'path.open' | 'path.more' | 'path.reveal' | 'path.opened' | 'path.revealed' | 'path.openError' | 'path.revealError' | 'app.cursor' | 'app.vscode' | 'app.vscodeinsiders' | 'app.windsurf' | 'app.zed' | 'app.sublimetext' | 'app.xcode' | 'app.androidstudio' | 'app.intellij' | 'app.pycharm' | 'app.webstorm' | 'app.phpstorm' | 'app.goland' | 'app.rider' | 'app.rustrover' | 'app.fork' | 'app.sourcetree' | 'app.github' | 'app.tower' | 'app.gitkraken' | 'app.smartgit' | 'app.sublimemerge' | 'app.ghostty' | 'app.warp' | 'app.iterm' | 'app.kitty' | 'app.terminal' | 'app.windowsterminal' | 'app.gitbash' | 'app.gnometerminal' | 'app.konsole' | 'app.finder' | 'app.explorer' | 'app.filemanager';
 declare module '@deepseek-ai/dsh-client-ui-slots' {
     interface LocaleNamespaceMap {
         /** Session-header "open workspace in application" copy (upstream declaration). */

package/lib/types/client/open-in-app/open-path.d.ts

@@ -1,13 +1,14 @@
 /**
  * Fork-facing shim for upstream `ui-open-in-app/src/client/open-path.ts`.
  *
- * The fork only needs the failure union `OpenInAppPathButton`'s `execute`
+ * The fork only needs the failure union the path gestures' `execute`
  * returns; upstream's file also carries `OpenInAppPathController`, the
  * document-preview path controller that speaks to a Session Remote this
  * plugin does not hold. Keeping the verbatim file would pull
  * `@deepseek-ai/dsh-api-remotes` and `dsh-api-session-controller` into the
- * bundle for a class nothing here calls — so this shim owns just the type,
- * spelled verbatim. See FORK.md.
+ * bundle for a class nothing here calls. From `0.2.2-alpha.2` the failure
+ * union lives in upstream's `outcome.ts` (an alias of the deliverables
+ * `PresentedOpenFailure`), so this shim re-exports the fork's own outcome
+ * shim under the same name. See FORK.md.
  */
-/** Failure kind of one settled path gesture, for the initiating control to announce. */
-export type OpenInAppPathFailure = 'openError' | 'revealError';
+export type { OpenInAppPathFailure } from './outcome.ts';

package/lib/types/client/open-in-app/open-toast.d.ts

@@ -0,0 +1,39 @@
+/** Native-open feedback that survives the initiating panel: mobile success and all failures. */
+import type { ReactNode } from 'react';
+import type { HostObservable, InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import { NS } from './locales.ts';
+import type { OpenInAppOutcome } from './outcome.ts';
+/** One announced gesture; `seq` keys the banner so a repeat restarts it. */
+export type OpenInAppToastState = Exclude<OpenInAppOutcome, {
+    kind: 'skipped';
+}> & {
+    readonly seq: number;
+};
+/** Store every contribution reports into and the overlay entry reads. */
+export interface OpenInAppToastSource {
+    /** Current notice for the overlay entry, or null while none shows. */
+    readonly hooks: {
+        readonly toast: HostObservable<OpenInAppToastState | null>;
+    };
+    /**
+     * Announce failures on every device and acknowledged opens or reveals on mobile.
+     * Desktop successes and skipped gestures leave the current notice unchanged.
+     * @param outcome - settled native-open result.
+     */
+    readonly report: (outcome: OpenInAppOutcome) => void;
+    /** Clear the shown notice. */
+    readonly dismiss: () => void;
+}
+/**
+ * Create the one outcome store the overlay entry shows.
+ * @returns the observable notice with its report and dismiss actions.
+ */
+export declare function createOpenInAppToastSource(): OpenInAppToastSource;
+/** Props of the `shell.overlay` entry: the notice store, its dismissal, and localized copy. */
+export type OpenInAppToastProps = PropsRuntime<'shell.overlay'> & PropsLocale<typeof NS> & InjectFace<Omit<OpenInAppToastSource, 'report'>>;
+/**
+ * Render a mobile handoff confirmation or a native-open failure.
+ * @param props - the notice hook, its dismissal, and the locale seat.
+ * @returns the banner on display, or null.
+ */
+export declare function OpenInAppToast({ useToast, dismiss, t }: OpenInAppToastProps): ReactNode;

package/lib/types/client/open-in-app/outcome.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Fork-facing shim for upstream `ui-open-in-app/src/client/outcome.ts`.
+ *
+ * Upstream's file aliases `PresentedOpenFailure`/`PresentedOpenOutcome` out
+ * of `@deepseek-ai/dsh-client-ui-deliverables` — a package this plugin does
+ * not depend on. Both aliases are types only, so this shim spells the same
+ * structural unions verbatim (upstream
+ * `ui-deliverables/src/client/present-open.ts`) instead of importing them.
+ * See FORK.md.
+ */
+/** Failure kind of one settled gesture, keyed to the `path.*` copy it announces. */
+export type OpenInAppPathFailure = 'openError' | 'revealError';
+/** Acknowledged open or reveal, named failure, or deliberately skipped gesture. */
+export type OpenInAppOutcome = {
+    readonly kind: 'opened';
+} | {
+    readonly kind: 'revealed';
+} | {
+    readonly kind: 'failed';
+    readonly failure: OpenInAppPathFailure;
+} | {
+    readonly kind: 'skipped';
+};