@deepseek-ai/dsh-host-directory-picker-native 0.0.1-rc.1

package/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, DeepSeek
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/host/directory-picker-native/README.md
+README.md: 4dd0c79d080fe097d063cfd2200e30aafc2d2d42
+README.zh.md: e7d0ec99c1aaca8f22f8d5dc29fcbddd73d9f7c0

package/README.md

@@ -0,0 +1,20 @@
+# @deepseek-ai/dsh-host-directory-picker-native
+
+English | [中文](README.zh.md)
+
+The **native-OS-chooser backend** of the [directory-picker seam](../directory-picker/README.md): `NativeDirectoryPicker` registers `ctx.directoryPicker` with the `native` capability, whose `pick(signal)` opens one native chooser per call and resolves the chosen absolute path (`null` on cancel). Platform tools run without a shell: `osascript` on macOS and Zenity with a KDialog fallback on Linux; the caller's abort terminates the native process. Windows opens the modern `IFileOpenDialog` in a spawned child process — a koffi-driven COM conversation on the child's main thread with the best thread DPI awareness the host accepts (per-monitor-v2 first), aborted by posting `WM_CLOSE` to the dialog thread. Only viable when the operator sits at the host's display — remote deployments compose [`-browse`](../directory-picker-browse/README.md) instead. The command boundary (`DirectoryPickerRunner`) and platform facts are injectable. The shared no-shell subprocess runner lives in [`dsh-native-command`](../../util/native-command/README.md).
+
+**Dual-face package**: the browser half (`./client`) registers a renderless flow occupant into [ui-workspace's](../../client/ui-workspace/README.md) two directory-flow holes — each `open` request drives `host.pickDirectory` and reports the one outcome (picked path / cancel / failure) through the hole's owner conversation. Both directory-flow declarations must be live before either contribution installs. One cordis.yml row therefore composes both sides of the native interaction; the client carries no capability-kind branching, and mounting a second flow package fails at load (the holes are `single` kind).
+
+## Model Experience
+
+None, as the backend serves the GUI host's directory selection; nothing here reaches a model request.
+
+#### KV Cache effect
+
+None; this package neither assembles nor sends a provider request.
+
+## Known Limitations and Deferred Work
+
+- **Linux requires desktop tooling** — with neither Zenity nor KDialog installed, `pick` rejects with an actionable error; it does not fall back to a typed-path prompt (the browse backend is that fallback at the composition level).
+- **Windows has no mechanism fallback** — the child-process picker through packaged koffi is the only native tier, so a COM refusal or dialog crash surfaces the failure. The browse backend remains the fallback at the composition level.

package/README.zh.md

@@ -0,0 +1,20 @@
+# @deepseek-ai/dsh-host-directory-picker-native
+
+[English](README.md) | 中文
+
+[目录选择 seam](../directory-picker/README.md) 的**原生 OS 选择器后端**：`NativeDirectoryPicker` 以 `native` 能力注册 `ctx.directoryPicker`，其 `pick(signal)` 每次调用打开一个原生选择器并解析出所选绝对路径（取消时为 `null`）。平台工具不经 shell 调用：macOS 使用 `osascript`，Linux 使用 Zenity 并以 KDialog 回退；调用方的中止信号会终止原生进程。Windows 在 spawn 的子进程中打开现代 `IFileOpenDialog`——由 koffi 在子进程主线程上驱动的 COM 会话，采用宿主接受的最佳线程 DPI 感知（优先 per-monitor-v2），中止时向对话框线程投递 `WM_CLOSE`。只有操作者坐在宿主屏幕前时才可用——远程部署应组合 [`-browse`](../directory-picker-browse/README.md)。命令边界（`DirectoryPickerRunner`）与平台事实可注入。共享的免 shell 子进程运行器位于 [`dsh-native-command`](../../util/native-command/README.md)。
+
+**双面包**：浏览器端（`./client`）向 [ui-workspace](../../client/ui-workspace/README.md) 的两个目录流 slot 注册一个无渲染的流程占用者——每次 `open` 请求驱动 `host.pickDirectory`，并通过 slot 的属主交互约定上报唯一结果（所选路径／取消／失败）。两个目录流程声明必须同时处于有效状态，任一贡献才会安装。因此一行 cordis.yml 同时组合原生交互的两侧；客户端不包含任何按能力类型进行的分支，挂载第二个流程包会在加载期失败（slot 的 kind 为 `single`）。
+
+## 模型体验
+
+无。该后端服务于 GUI 宿主的目录选择；这里没有任何内容进入模型请求。
+
+#### KV Cache 影响
+
+无；该包既不组装也不发送提供方请求。
+
+## 已知限制与延期工作
+
+- **Linux 依赖桌面工具**——Zenity 与 KDialog 均未安装时，`pick` 以包含解决建议的错误拒绝；它不会回退为手输路径提示（组合层面的回退是 browse 后端）。
+- **Windows 没有机制级回退**——通过打包依赖 koffi 运行的子进程选择器是唯一原生层级，因此 COM 拒绝或对话框崩溃会直接上报失败。组合层面的回退仍是 browse 后端。

package/lib/client.js

@@ -0,0 +1,82 @@
+window.__ModuleLoader__.load({
+	id: "@deepseek-ai/dsh-host-directory-picker-native",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react = require("react");
+		//#region lib/types/client/flow.js
+		/**
+		* The native picking occupant (package-internal; the `./client` surface
+		* exposes only the Loader exports). Same-package tests exercise it directly
+		* through this module.
+		*/
+		/**
+		* Renderless flow occupant: each rising `open` edge runs exactly one pick and
+		* reports exactly one outcome; the ref arms once per open so re-renders (and
+		* an adoption keeping `open` true while `busy`) never launch a second
+		* chooser. The owner withdrawing `open` re-arms the next request.
+		* @param props - owner conversation plus the injected pick call.
+		* @returns nothing — the native chooser renders on the host display.
+		*/
+		function NativeDirectoryFlow(props) {
+			const { open, pick } = props;
+			const armed = (0, react.useRef)(false);
+			const outcome = (0, react.useRef)(props);
+			outcome.current = props;
+			const alive = (0, react.useRef)(true);
+			(0, react.useEffect)(() => {
+				alive.current = true;
+				return () => {
+					alive.current = false;
+				};
+			}, []);
+			(0, react.useEffect)(() => {
+				if (!open) {
+					armed.current = false;
+					return;
+				}
+				if (armed.current) return;
+				armed.current = true;
+				pick().then((path) => {
+					if (!alive.current) return;
+					if (path === null) outcome.current.onCancel();
+					else outcome.current.onPicked(path);
+				}, (reason) => {
+					if (!alive.current) return;
+					outcome.current.onError(reason instanceof Error ? reason.message : String(reason));
+				});
+			}, [open, pick]);
+			return null;
+		}
+		//#endregion
+		//#region lib/types/client/index.js
+		/** Required services (cordis fiber inject): the slot registry and the wire-facing workspace service. */
+		const inject = ["slots", "workspaces"];
+		/**
+		* Client plugin body: register the renderless native flow into both
+		* directory-flow holes through `slots.inject()` because the ui-workspace
+		* entries may activate later or replace their declarations.
+		* @param ctx - client root context.
+		*/
+		function apply(ctx) {
+			const injected = () => ({ pick: () => ctx.workspaces.pickDirectory() });
+			ctx.slots.inject("conversation.hero.workspace.directoryFlow", () => ctx.slots.inject("sidebar.workspaces.directoryFlow", function* () {
+				yield ctx.slots.register({
+					name: "conversation.hero.workspace.directoryFlow",
+					inject: injected
+				}, NativeDirectoryFlow);
+				yield ctx.slots.register({
+					name: "sidebar.workspaces.directoryFlow",
+					inject: injected
+				}, NativeDirectoryFlow);
+			}));
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map

package/lib/index.js

@@ -0,0 +1,300 @@
+import { DirectoryPicker } from "@deepseek-ai/dsh-host-directory-picker";
+import { runNativeCommand } from "@deepseek-ai/dsh-native-command";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+//#region lib/types/win32-dialog-bindings.js
+const WM_CLOSE = 16;
+/**
+* Encode a canonical GUID string as its 16 little-endian bytes.
+* @param text - the `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` form.
+* @returns the in-memory GUID bytes CoCreateInstance expects.
+*/
+function guidBytes(text) {
+	const match = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i.exec(text);
+	const bytes = Buffer.alloc(16);
+	bytes.writeUInt32LE(parseInt(match[1], 16), 0);
+	bytes.writeUInt16LE(parseInt(match[2], 16), 4);
+	bytes.writeUInt16LE(parseInt(match[3], 16), 6);
+	Buffer.from(match[4] + match[5], "hex").copy(bytes, 8);
+	return bytes;
+}
+guidBytes("dc1c5a9c-e88a-4dde-a5a1-60f82a20aef7");
+guidBytes("d57c7288-d4ad-4768-be02-9d969532d960");
+/**
+* Post `WM_CLOSE` to every window of a native thread — the driver's abort
+* lever against the worker blocked inside `Show`, after which `Show` returns
+* `HRESULT_CANCELLED` and the worker unwinds normally.
+* @param threadId - the dialog thread's native id (from the `showing` notice).
+*/
+async function closeThreadWindows(threadId) {
+	const koffi = (await import("koffi")).default;
+	const user32 = koffi.load("user32.dll");
+	const enumThreadWindows = user32.func("__stdcall", "EnumThreadWindows", "int", [
+		"uint32",
+		"void *",
+		"intptr"
+	]);
+	const postMessageW = user32.func("__stdcall", "PostMessageW", "int", [
+		"void *",
+		"uint32",
+		"uintptr",
+		"intptr"
+	]);
+	const protoEnumProc = koffi.proto("int __stdcall DshEnumThreadWndProc(void *hwnd, intptr lparam)");
+	const callback = koffi.register((hwnd) => {
+		postMessageW(hwnd, WM_CLOSE, 0, 0);
+		return 1;
+	}, koffi.pointer(protoEnumProc));
+	try {
+		enumThreadWindows(threadId, callback, 0);
+	} finally {
+		koffi.unregister(callback);
+	}
+}
+//#endregion
+//#region lib/types/win32-dialog-host.js
+/**
+* Real-process half of the Win32 dialog driver: spawn the dialog child
+* process (source or built plane) and close a dialog thread's windows. The
+* module itself loads everywhere (the import chain from native-picker.ts is
+* static); what stays win32-only is koffi, imported dynamically inside the
+* bindings' functions. The driver's logic is tested against fakes of this
+* surface instead.
+*/
+/**
+* Spawn the dialog child process. Built consumers launch the bundled CJS
+* entry next to this module under plain node; unbuilt (source) consumers
+* bootstrap tsx first, mirroring the dsh CLI's source launch. The dialog is
+* the child's first window, so Windows activates it without a foreground
+* call.
+* @param data - the child payload (dialog title).
+* @returns the spawned child process.
+*/
+function spawnDialogWorker(data) {
+	const env = {
+		...process.env,
+		DSH_DIALOG_TITLE: data.title
+	};
+	const stdio = [
+		"ignore",
+		"inherit",
+		"inherit",
+		"ipc"
+	];
+	/* v8 ignore next 3 -- the built-output arm: tests always run unbuilt (src/) */
+	if (!import.meta.url.endsWith(".ts")) return spawn(process.execPath, [fileURLToPath(new URL("./worker.cjs", import.meta.url))], {
+		env,
+		stdio,
+		windowsHide: true
+	});
+	return spawn(process.execPath, [
+		"--import",
+		import.meta.resolve("tsx/esm"),
+		fileURLToPath(new URL("./win32-dialog-worker.ts", import.meta.url))
+	], {
+		env,
+		stdio,
+		windowsHide: true
+	});
+}
+//#endregion
+//#region lib/types/win32-dialog.js
+/**
+* Main-thread driver for the Win32 folder dialog: spawns the dialog child
+* process (which blocks inside the modal `Show`), maps its message protocol
+* onto a promise, and services aborts by posting `WM_CLOSE` to the dialog
+* thread's windows until the child reports back. The real process/window
+* surface is injectable so every driver path is testable on any platform.
+*/
+/** The dialog title every host shows. */
+const DIALOG_TITLE = "Select Workspace Directory";
+/** `WM_CLOSE` re-post cadence while an abort waits for the worker to unwind. */
+const CLOSE_RETRY_MS = 150;
+/** Abort-service attempts before force-terminating the worker. */
+const CLOSE_MAX_ATTEMPTS = 20;
+/** Fail loudly if the closed worker-to-driver union gains an unhandled member. */
+/* v8 ignore start -- closed-union backstop; unreachable without a TypeScript contract violation */
+function assertNever(value) {
+	throw new TypeError(`unknown win32 dialog worker message kind: ${String(value)}`);
+}
+/* v8 ignore stop */
+/**
+* Open the modern Win32 folder picker off the event loop.
+* @param signal - caller lifetime; abort closes the dialog and rejects.
+* @param internals - Worker/window hooks for deterministic tests.
+* @returns the selected path, or null when the user cancels.
+*/
+async function pickWin32Directory(signal, internals = {}) {
+	if (signal.aborted) throw new Error("native directory picker aborted");
+	const spawnWorker = internals.spawnWorker ?? spawnDialogWorker;
+	const closeWindows = internals.closeThreadWindows ?? closeThreadWindows;
+	const closeRetryMs = internals.closeRetryMs ?? CLOSE_RETRY_MS;
+	const worker = spawnWorker({ title: DIALOG_TITLE });
+	let dialogThreadId;
+	let closeTimer;
+	let settled = false;
+	return await new Promise((resolve, reject) => {
+		const settle = (outcome) => {
+			if (settled) return;
+			settled = true;
+			if (closeTimer !== void 0) clearInterval(closeTimer);
+			signal.removeEventListener("abort", onAbort);
+			worker.unref?.();
+			outcome();
+		};
+		const postClose = () => {
+			if (dialogThreadId !== void 0) closeWindows(dialogThreadId).catch(() => void 0);
+		};
+		const serviceAbort = () => {
+			let attempts = 0;
+			closeTimer = setInterval(() => {
+				attempts += 1;
+				if (attempts > CLOSE_MAX_ATTEMPTS) {
+					settle(() => {
+						worker.kill();
+						reject(/* @__PURE__ */ new Error("native directory picker aborted (dialog unresponsive; worker killed)"));
+					});
+					return;
+				}
+				postClose();
+			}, closeRetryMs);
+			postClose();
+		};
+		const onAbort = () => {
+			serviceAbort();
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		worker.on("message", (message) => {
+			switch (message.kind) {
+				case "showing":
+					dialogThreadId = message.threadId;
+					if (signal.aborted) postClose();
+					return;
+				case "done":
+					settle(() => {
+						if (signal.aborted) reject(/* @__PURE__ */ new Error("native directory picker aborted"));
+						else resolve(message.path);
+					});
+					return;
+				case "error":
+					settle(() => {
+						reject(/* @__PURE__ */ new Error(`win32 folder dialog failed: ${message.message}`));
+					});
+					return;
+				/* v8 ignore next 2 -- closed worker-owned union; a fourth kind becomes a compile error */
+				default: assertNever(message);
+			}
+		});
+		worker.on("error", (error) => {
+			settle(() => {
+				reject(error);
+			});
+		});
+		worker.on("exit", () => {
+			settle(() => {
+				reject(/* @__PURE__ */ new Error("win32 folder dialog worker exited before reporting a result"));
+			});
+		});
+	});
+}
+//#endregion
+//#region lib/types/native-picker.js
+/** Cross-platform native single-directory chooser behind the native backend's capability. */
+function outputPath(stdout) {
+	const path = stdout.replace(/[\r\n]+$/, "");
+	return path === "" ? null : path;
+}
+function errorCode(error) {
+	if (typeof error !== "object" || error === null || !("code" in error)) return void 0;
+	const code = error.code;
+	return typeof code === "string" || typeof code === "number" ? code : void 0;
+}
+function errorStderr(error) {
+	if (typeof error !== "object" || error === null || !("stderr" in error)) return "";
+	const stderr = error.stderr;
+	return typeof stderr === "string" ? stderr : "";
+}
+function isMissingCommand(error) {
+	return errorCode(error) === "ENOENT";
+}
+function rethrowIfAborted(signal, error) {
+	if (signal.aborted) throw error;
+}
+/**
+* Open the platform directory picker.
+* @param signal - caller/connection lifetime; abort terminates the native command.
+* @param internals - Platform and runner hooks for deterministic tests.
+* @returns the selected path, or null when the user cancels.
+*/
+async function pickNativeDirectory(signal, internals = {}) {
+	const platform = internals.platform ?? process.platform;
+	const run = internals.run ?? runNativeCommand;
+	if (platform === "darwin") try {
+		return outputPath((await run("osascript", [
+			"-e",
+			"set selectedFolder to choose folder with prompt \"Select Workspace Directory\"",
+			"-e",
+			"POSIX path of selectedFolder"
+		], signal)).stdout);
+	} catch (error) {
+		if (!signal.aborted && errorCode(error) === 1 && /(?:User canceled|-128)/i.test(errorStderr(error))) return null;
+		throw error;
+	}
+	if (platform === "win32") return await (internals.pickWin32Dialog ?? pickWin32Directory)(signal);
+	if (platform === "linux") {
+		try {
+			return outputPath((await run("zenity", [
+				"--file-selection",
+				"--directory",
+				"--title=Select Workspace Directory"
+			], signal)).stdout);
+		} catch (error) {
+			rethrowIfAborted(signal, error);
+			if (errorCode(error) === 1) return null;
+			if (!isMissingCommand(error)) throw error;
+		}
+		try {
+			return outputPath((await run("kdialog", [
+				"--getexistingdirectory",
+				".",
+				"--title",
+				"Select Workspace Directory"
+			], signal)).stdout);
+		} catch (error) {
+			rethrowIfAborted(signal, error);
+			if (errorCode(error) === 1) return null;
+			if (isMissingCommand(error)) throw new Error("no supported native directory picker found (install zenity or kdialog)");
+			throw error;
+		}
+	}
+	throw new Error(`native directory picker is unsupported on ${platform}`);
+}
+//#endregion
+//#region lib/types/index.js
+/**
+* Native backend of the directory-picker seam: registers `ctx.directoryPicker`
+* with the `native` capability, opening one native OS chooser on the host
+* display per pick (macOS `osascript`, Linux Zenity with a KDialog fallback;
+* Windows opens the modern `IFileOpenDialog` in a spawned child process — a
+* koffi-driven COM conversation on the child's main thread). Only viable when
+* the operator sits at the host's screen; remote deployments compose the
+* browse backend instead.
+* @module @deepseek-ai/dsh-host-directory-picker-native
+*/
+/** The `ctx.directoryPicker` native implementation (stable capability object per service life). */
+var NativeDirectoryPicker = class extends DirectoryPicker {
+	nativeCapability = {
+		kind: "native",
+		/* v8 ignore next -- pure forward to pickNativeDirectory (its spec owns behavior); invoking here opens a real chooser. */
+		pick: (signal) => pickNativeDirectory(signal)
+	};
+	/**
+	* The native interaction capability.
+	* @returns the stable `native` capability object.
+	*/
+	capability() {
+		return this.nativeCapability;
+	}
+};
+//#endregion
+export { NativeDirectoryPicker as default, pickNativeDirectory };

package/lib/invariant.js

@@ -0,0 +1,20 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for the native directory-picker backend.
+* @module @deepseek-ai/dsh-host-directory-picker-native/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-host-directory-picker-native";
+/** Cordis companion plugin name. */
+const name = "host-directory-picker-native-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/** No runtime invariant: each pick is one stateless subprocess round trip; the chooser outcome is only the returned path. */
+const install = () => {};
+/**
+* Register the native directory-picker invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

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

@@ -0,0 +1,17 @@
+import type { ReactElement } from 'react';
+import type { DirectoryFlowOwnerProps } from '@deepseek-ai/dsh-client-ui-workspace/client';
+/** Injected face: the wire call the flow drives (bound in apply's closure). */
+export interface NativeFlowInjected {
+    /** Ask the local Host to open its native single-directory chooser. */
+    pick: () => Promise<string | null>;
+}
+/**
+ * Renderless flow occupant: each rising `open` edge runs exactly one pick and
+ * reports exactly one outcome; the ref arms once per open so re-renders (and
+ * an adoption keeping `open` true while `busy`) never launch a second
+ * chooser. The owner withdrawing `open` re-arms the next request.
+ * @param props - owner conversation plus the injected pick call.
+ * @returns nothing — the native chooser renders on the host display.
+ */
+export declare function NativeDirectoryFlow(props: DirectoryFlowOwnerProps & NativeFlowInjected): ReactElement | null;
+//# sourceMappingURL=flow.d.ts.map

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

@@ -0,0 +1,20 @@
+/**
+ * Browser half of the native directory-picker backend: fills ui-workspace's
+ * two directory-flow holes with a renderless occupant that answers each
+ * `open` by driving `host.pickDirectory` (the node half's OS chooser) and
+ * reporting the one outcome — picked path, cancellation, or failure — back
+ * through the owner conversation. Mounting this package therefore composes
+ * both sides of the native interaction with one cordis.yml row; no client
+ * code branches on a capability kind.
+ */
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+/** Required services (cordis fiber inject): the slot registry and the wire-facing workspace service. */
+export declare const inject: string[];
+/**
+ * Client plugin body: register the renderless native flow into both
+ * directory-flow holes through `slots.inject()` because the ui-workspace
+ * entries may activate later or replace their declarations.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Native backend of the directory-picker seam: registers `ctx.directoryPicker`
+ * with the `native` capability, opening one native OS chooser on the host
+ * display per pick (macOS `osascript`, Linux Zenity with a KDialog fallback;
+ * Windows opens the modern `IFileOpenDialog` in a spawned child process — a
+ * koffi-driven COM conversation on the child's main thread). Only viable when
+ * the operator sits at the host's screen; remote deployments compose the
+ * browse backend instead.
+ * @module @deepseek-ai/dsh-host-directory-picker-native
+ */
+import { DirectoryPicker } from '@deepseek-ai/dsh-host-directory-picker';
+import type { DirectoryPickerCapability } from '@deepseek-ai/dsh-host-directory-picker';
+export type { DirectoryPickerInternals, DirectoryPickerRunner } from './native-picker.ts';
+export { pickNativeDirectory } from './native-picker.ts';
+/** The `ctx.directoryPicker` native implementation (stable capability object per service life). */
+export default class NativeDirectoryPicker extends DirectoryPicker {
+    private readonly nativeCapability;
+    /**
+     * The native interaction capability.
+     * @returns the stable `native` capability object.
+     */
+    capability(): DirectoryPickerCapability;
+}
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for the native directory-picker backend.
+ * @module @deepseek-ai/dsh-host-directory-picker-native/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "host-directory-picker-native-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register the native directory-picker invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

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

@@ -0,0 +1,19 @@
+/** Cross-platform native single-directory chooser behind the native backend's capability. */
+import { type NativeCommandRunner } from '@deepseek-ai/dsh-native-command';
+/** Testable command boundary; native implementations never invoke a shell. */
+export type DirectoryPickerRunner = NativeCommandRunner;
+/** Injectable platform facts for deterministic adapter tests. */
+export interface DirectoryPickerInternals {
+    platform?: NodeJS.Platform;
+    run?: DirectoryPickerRunner;
+    /** Replaces the in-process Win32 dialog (`pickWin32Directory`) for deterministic tests. */
+    pickWin32Dialog?: (signal: AbortSignal) => Promise<string | null>;
+}
+/**
+ * Open the platform directory picker.
+ * @param signal - caller/connection lifetime; abort terminates the native command.
+ * @param internals - Platform and runner hooks for deterministic tests.
+ * @returns the selected path, or null when the user cancels.
+ */
+export declare function pickNativeDirectory(signal: AbortSignal, internals?: DirectoryPickerInternals): Promise<string | null>;
+//# sourceMappingURL=native-picker.d.ts.map

package/lib/types/win32-dialog-bindings.d.ts

@@ -0,0 +1,27 @@
+/**
+ * koffi-backed Win32 bindings for the folder dialog: the COM vtable calls
+ * behind {@link Win32DialogBindings} plus the cross-thread window closer the
+ * driver uses to service aborts. The module loads on every platform; koffi
+ * itself is imported lazily inside each function, so non-Windows processes
+ * never load it — the same containment as the repo's other `win32.ts`
+ * modules.
+ *
+ * The COM surface used here (IModalWindow/IFileDialog/IFileOpenDialog and
+ * IShellItem vtable order, the GUIDs, `FOS_*` and `SIGDN_FILESYSPATH`) is
+ * frozen Windows ABI since Vista; slots are offsets into the vtable at the
+ * object's first pointer.
+ */
+import type { Win32DialogBindings } from './win32-dialog-logic.ts';
+/**
+ * Load koffi and expose the dialog bindings for this thread.
+ * @returns the bindings {@link runFolderDialog} sequences against.
+ */
+export declare function loadWin32DialogBindings(): Promise<Win32DialogBindings>;
+/**
+ * Post `WM_CLOSE` to every window of a native thread — the driver's abort
+ * lever against the worker blocked inside `Show`, after which `Show` returns
+ * `HRESULT_CANCELLED` and the worker unwinds normally.
+ * @param threadId - the dialog thread's native id (from the `showing` notice).
+ */
+export declare function closeThreadWindows(threadId: number): Promise<void>;
+//# sourceMappingURL=win32-dialog-bindings.d.ts.map

package/lib/types/win32-dialog-host.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Real-process half of the Win32 dialog driver: spawn the dialog child
+ * process (source or built plane) and close a dialog thread's windows. The
+ * module itself loads everywhere (the import chain from native-picker.ts is
+ * static); what stays win32-only is koffi, imported dynamically inside the
+ * bindings' functions. The driver's logic is tested against fakes of this
+ * surface instead.
+ */
+import { spawn } from 'node:child_process';
+import type { Win32DialogWorkerData } from './win32-dialog-worker.ts';
+/**
+ * Spawn the dialog child process. Built consumers launch the bundled CJS
+ * entry next to this module under plain node; unbuilt (source) consumers
+ * bootstrap tsx first, mirroring the dsh CLI's source launch. The dialog is
+ * the child's first window, so Windows activates it without a foreground
+ * call.
+ * @param data - the child payload (dialog title).
+ * @returns the spawned child process.
+ */
+export declare function spawnDialogWorker(data: Win32DialogWorkerData): ReturnType<typeof spawn>;
+export { closeThreadWindows } from './win32-dialog-bindings.ts';
+//# sourceMappingURL=win32-dialog-host.d.ts.map

package/lib/types/win32-dialog-logic.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Pure sequencing of the Win32 `IFileOpenDialog` folder-picker COM
+ * conversation over injectable platform bindings, so every outcome path
+ * (selection, cancellation, HRESULT failure, cleanup ordering) is testable on
+ * any platform. The koffi-backed bindings live in
+ * `win32-dialog-bindings.ts`, which only a real win32 process ever loads.
+ */
+/** `HRESULT_FROM_WIN32(ERROR_CANCELLED)`: the user dismissed the dialog. */
+export declare const HRESULT_CANCELLED: number;
+/** `FOS_PICKFOLDERS`: the dialog selects directories, not files. */
+export declare const FOS_PICKFOLDERS = 32;
+/** `FOS_FORCEFILESYSTEM`: only results with a filesystem path can be chosen. */
+export declare const FOS_FORCEFILESYSTEM = 64;
+/** `FOS_NOCHANGEDIR`: never mutate the process working directory. */
+export declare const FOS_NOCHANGEDIR = 8;
+/** One created folder dialog: the vtable calls the sequencing needs. */
+export interface Win32FolderDialog {
+    /**
+     * `IFileDialog::SetOptions`.
+     * @param options - the `FOS_*` flag union to apply.
+     * @returns the call's HRESULT.
+     */
+    setOptions(options: number): number;
+    /**
+     * `IFileDialog::SetTitle`.
+     * @param title - the dialog title text.
+     * @returns the call's HRESULT.
+     */
+    setTitle(title: string): number;
+    /**
+     * `IModalWindow::Show` with no owner window; blocks the calling thread
+     * until the user selects or dismisses.
+     * @returns the call's HRESULT (`HRESULT_CANCELLED` on dismissal).
+     */
+    show(): number;
+    /**
+     * `IFileDialog::GetResult` + `IShellItem::GetDisplayName(SIGDN_FILESYSPATH)`,
+     * releasing the shell item and freeing the COM string.
+     * @returns the call chain's HRESULT and, on success, the selected path.
+     */
+    resultPath(): {
+        hr: number;
+        path?: string;
+    };
+    /** Release the dialog's COM reference. */
+    release(): void;
+}
+/** The thread-level native surface the dialog sequencing runs against. */
+export interface Win32DialogBindings {
+    /**
+     * Opt the calling thread into the best supported DPI awareness
+     * (per-monitor-v2, then per-monitor, then system-aware), checking each
+     * call's result. Best-effort on purpose: a host accepting none of them
+     * (or lacking the API, pre-1607) still shows the modern dialog — possibly
+     * blurry above 100 % scaling — because a cosmetic degradation must not
+     * cost the tier.
+     */
+    setThreadDpiAwareness(): void;
+    /**
+     * `CoInitializeEx(COINIT_APARTMENTTHREADED)` on the calling thread.
+     * @returns the call's HRESULT (`S_FALSE` re-entry is still a success).
+     */
+    coInitializeSta(): number;
+    /**
+     * `CoUninitialize` on the calling thread — COM requires one pairing call
+     * for every successful (including `S_FALSE`) `CoInitializeEx`, even on a
+     * thread that exits right after the conversation.
+     */
+    coUninitialize(): void;
+    /**
+     * `CoCreateInstance(CLSID_FileOpenDialog)`.
+     * @returns the created dialog surface; throws when creation fails.
+     */
+    createFolderDialog(): Win32FolderDialog;
+    /**
+     * `GetCurrentThreadId` — the native id a driver needs to close this
+     * thread's windows from outside.
+     * @returns the calling thread's native id.
+     */
+    currentThreadId(): number;
+}
+/**
+ * Run one modal folder-picker conversation on the calling thread: DPI opt-in,
+ * STA init, dialog creation, `Show`, and result extraction, releasing the
+ * dialog on every path.
+ * @param bindings - the native surface (koffi-backed in production, fakes in tests).
+ * @param title - the dialog title text.
+ * @param onShowing - called with the native thread id immediately before the
+ *   blocking `Show`, so a driver on another thread can close the dialog.
+ * @returns the selected filesystem path, or null when the user cancels.
+ */
+export declare function runFolderDialog(bindings: Win32DialogBindings, title: string, onShowing: (threadId: number) => void): string | null;
+//# sourceMappingURL=win32-dialog-logic.d.ts.map

package/lib/types/win32-dialog-worker.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Child-process entry for the Win32 folder dialog: blocks THIS process
+ * inside the modal `Show` so the host event loop stays live, reporting over
+ * the IPC channel. Spawned as a child process (not a worker thread) so the
+ * dialog is the process's first window and Windows activates it without a
+ * manual foreground call. Protocol: `{kind:'showing',threadId}` right
+ * before the blocking call (the driver's abort lever needs the native
+ * thread id), then exactly one of `{kind:'done',path}` or
+ * `{kind:'error',message}`.
+ */
+/** The driver-to-child payload: the dialog title (passed via env). */
+export interface Win32DialogWorkerData {
+    title: string;
+}
+/** One notice or outcome posted back to the driver. */
+export type Win32DialogWorkerMessage = {
+    kind: 'showing';
+    threadId: number;
+} | {
+    kind: 'done';
+    path: string | null;
+} | {
+    kind: 'error';
+    message: string;
+};
+//# sourceMappingURL=win32-dialog-worker.d.ts.map

package/lib/types/win32-dialog.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Main-thread driver for the Win32 folder dialog: spawns the dialog child
+ * process (which blocks inside the modal `Show`), maps its message protocol
+ * onto a promise, and services aborts by posting `WM_CLOSE` to the dialog
+ * thread's windows until the child reports back. The real process/window
+ * surface is injectable so every driver path is testable on any platform.
+ */
+import type { Win32DialogWorkerData, Win32DialogWorkerMessage } from './win32-dialog-worker.ts';
+/** The child-process surface the driver drives (satisfied by `node:child_process`). */
+export interface Win32DialogWorkerLike {
+    /**
+     * Subscribe to a child-process event.
+     * @param event - `message`, `error`, or `exit`.
+     * @param listener - the event consumer.
+     */
+    on(event: 'message', listener: (message: Win32DialogWorkerMessage) => void): unknown;
+    on(event: 'error', listener: (error: Error) => void): unknown;
+    on(event: 'exit', listener: (code: number) => void): unknown;
+    /**
+     * Force-stop the child; the abort path's last resort when `WM_CLOSE`
+     * never lands (e.g. the dialog window was never created).
+     * @returns whether a kill signal was delivered.
+     */
+    kill(): boolean;
+    /**
+     * Release the event-loop reference. Called once the pick settles so a
+     * child stuck in the native modal call never blocks process exit.
+     */
+    unref?(): void;
+}
+/** Injectable process surface for deterministic driver tests. */
+export interface Win32DialogInternals {
+    /** Replaces the real child spawn (`win32-dialog-host.ts`). */
+    spawnWorker?: (data: Win32DialogWorkerData) => Win32DialogWorkerLike;
+    /** Replaces the real `WM_CLOSE` poster (`win32-dialog-host.ts`). */
+    closeThreadWindows?: (threadId: number) => Promise<void>;
+    /** Abort-service cadence override so tests never wait wall-clock time. */
+    closeRetryMs?: number;
+}
+/** The dialog title every host shows. */
+export declare const DIALOG_TITLE = "Select Workspace Directory";
+/**
+ * Open the modern Win32 folder picker off the event loop.
+ * @param signal - caller lifetime; abort closes the dialog and rejects.
+ * @param internals - Worker/window hooks for deterministic tests.
+ * @returns the selected path, or null when the user cancels.
+ */
+export declare function pickWin32Directory(signal: AbortSignal, internals?: Win32DialogInternals): Promise<string | null>;
+//# sourceMappingURL=win32-dialog.d.ts.map

package/lib/worker.cjs

@@ -0,0 +1,233 @@
+//#region lib/types/win32-dialog-bindings.js
+/**
+* koffi-backed Win32 bindings for the folder dialog: the COM vtable calls
+* behind {@link Win32DialogBindings} plus the cross-thread window closer the
+* driver uses to service aborts. The module loads on every platform; koffi
+* itself is imported lazily inside each function, so non-Windows processes
+* never load it — the same containment as the repo's other `win32.ts`
+* modules.
+*
+* The COM surface used here (IModalWindow/IFileDialog/IFileOpenDialog and
+* IShellItem vtable order, the GUIDs, `FOS_*` and `SIGDN_FILESYSPATH`) is
+* frozen Windows ABI since Vista; slots are offsets into the vtable at the
+* object's first pointer.
+*/
+/**
+* Read a NUL-terminated UTF-16 string at a native address. koffi's
+* `_Out_ void **` out-params surface a raw address, and
+* `koffi.decode(addr, 'str16')` would dereference it as a pointer — crash
+* on real Windows — so view the memory directly instead.
+*/
+function readUtf16(koffi, address) {
+	const bytes = Buffer.from(koffi.view(address, 32768));
+	let end = 0;
+	while (end + 1 < bytes.length && bytes[end] !== 0) end += 2;
+	return bytes.toString("utf16le", 0, end);
+}
+const COINIT_APARTMENTTHREADED = 2;
+const CLSCTX_INPROC_SERVER = 1;
+const SIGDN_FILESYSPATH = -2147123200;
+/**
+* Thread DPI awareness contexts, best first: per-monitor-v2 (Windows 10
+* 1703+), per-monitor (1607+), then system-aware. `SetThreadDpiAwarenessContext`
+* returns NULL for an unsupported context instead of throwing, so the caller
+* cascades to the best one the host accepts; DPI stays a cosmetic
+* best-effort — an unsupported host still gets the modern dialog.
+*/
+const DPI_AWARENESS_CONTEXTS = [
+	-4,
+	-3,
+	-2
+];
+/** IFileOpenDialog vtable slots (IUnknown 0-2, IModalWindow 3, IFileDialog 4+). */
+const SLOT_RELEASE = 2;
+const SLOT_SHOW = 3;
+const SLOT_SET_OPTIONS = 9;
+const SLOT_SET_TITLE = 17;
+const SLOT_GET_RESULT = 20;
+/** IShellItem vtable slot for `GetDisplayName`. */
+const SLOT_GET_DISPLAY_NAME = 5;
+/**
+* Encode a canonical GUID string as its 16 little-endian bytes.
+* @param text - the `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` form.
+* @returns the in-memory GUID bytes CoCreateInstance expects.
+*/
+function guidBytes(text) {
+	const match = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i.exec(text);
+	const bytes = Buffer.alloc(16);
+	bytes.writeUInt32LE(parseInt(match[1], 16), 0);
+	bytes.writeUInt16LE(parseInt(match[2], 16), 4);
+	bytes.writeUInt16LE(parseInt(match[3], 16), 6);
+	Buffer.from(match[4] + match[5], "hex").copy(bytes, 8);
+	return bytes;
+}
+const CLSID_FILE_OPEN_DIALOG = guidBytes("dc1c5a9c-e88a-4dde-a5a1-60f82a20aef7");
+const IID_IFILE_OPEN_DIALOG = guidBytes("d57c7288-d4ad-4768-be02-9d969532d960");
+/**
+* Load koffi and expose the dialog bindings for this thread.
+* @returns the bindings {@link runFolderDialog} sequences against.
+*/
+async function loadWin32DialogBindings() {
+	const koffi = (await import("koffi")).default;
+	const ole32 = koffi.load("ole32.dll");
+	const user32 = koffi.load("user32.dll");
+	const kernel32 = koffi.load("kernel32.dll");
+	const pointerSize = koffi.sizeof("void *");
+	const coInitializeEx = ole32.func("__stdcall", "CoInitializeEx", "int32", ["void *", "uint32"]);
+	const coUninitialize = ole32.func("__stdcall", "CoUninitialize", "void", []);
+	const coCreateInstance = ole32.func("__stdcall", "CoCreateInstance", "int32", [
+		"void *",
+		"void *",
+		"uint32",
+		"void *",
+		"void *"
+	]);
+	const coTaskMemFree = ole32.func("__stdcall", "CoTaskMemFree", "void", ["void *"]);
+	const getCurrentThreadId = kernel32.func("__stdcall", "GetCurrentThreadId", "uint32", []);
+	const protoShow = koffi.proto("int32 __stdcall DshDialogShow(void *self, void *owner)");
+	const protoSetOptions = koffi.proto("int32 __stdcall DshDialogSetOptions(void *self, uint32 options)");
+	const protoSetTitle = koffi.proto("int32 __stdcall DshDialogSetTitle(void *self, str16 title)");
+	const protoGetResult = koffi.proto("int32 __stdcall DshDialogGetResult(void *self, _Out_ void **item)");
+	const protoGetDisplayName = koffi.proto("int32 __stdcall DshItemGetDisplayName(void *self, int32 form, _Out_ void **name)");
+	const protoRelease = koffi.proto("uint32 __stdcall DshComRelease(void *self)");
+	/** Bind vtable slot `slot` of COM object `self` to a caller through `proto`. */
+	const method = (self, slot, proto) => {
+		const vtable = koffi.decode(self, "void *");
+		const fn = koffi.decode(vtable, slot * pointerSize, "void *");
+		return (...args) => koffi.call(fn, proto, self, ...args);
+	};
+	return {
+		setThreadDpiAwareness: () => {
+			let setContext;
+			try {
+				setContext = user32.func("__stdcall", "SetThreadDpiAwarenessContext", "void *", ["intptr"]);
+			} catch {
+				return;
+			}
+			for (const context of DPI_AWARENESS_CONTEXTS) if (setContext(context) !== null) return;
+		},
+		coInitializeSta: () => coInitializeEx(null, COINIT_APARTMENTTHREADED),
+		coUninitialize: () => {
+			coUninitialize();
+		},
+		currentThreadId: () => getCurrentThreadId(),
+		createFolderDialog: () => {
+			const out = Buffer.alloc(pointerSize);
+			const created = coCreateInstance(CLSID_FILE_OPEN_DIALOG, null, CLSCTX_INPROC_SERVER, IID_IFILE_OPEN_DIALOG, out);
+			if (created < 0) throw new Error(`CoCreateInstance(FileOpenDialog) failed: HRESULT 0x${(created >>> 0).toString(16)}`);
+			const dialog = koffi.decode(out, "void *");
+			return {
+				setOptions: (options) => method(dialog, SLOT_SET_OPTIONS, protoSetOptions)(options),
+				setTitle: (title) => method(dialog, SLOT_SET_TITLE, protoSetTitle)(title),
+				show: () => method(dialog, SLOT_SHOW, protoShow)(null),
+				resultPath: () => {
+					const itemOut = [null];
+					const gotItem = method(dialog, SLOT_GET_RESULT, protoGetResult)(itemOut);
+					if (gotItem < 0) return { hr: gotItem };
+					const item = itemOut[0];
+					try {
+						const nameOut = [null];
+						const gotName = method(item, SLOT_GET_DISPLAY_NAME, protoGetDisplayName)(SIGDN_FILESYSPATH, nameOut);
+						if (gotName < 0) return { hr: gotName };
+						const path = readUtf16(koffi, nameOut[0]);
+						coTaskMemFree(nameOut[0]);
+						return {
+							hr: gotName,
+							path
+						};
+					} finally {
+						method(item, SLOT_RELEASE, protoRelease)();
+					}
+				},
+				release: () => {
+					method(dialog, SLOT_RELEASE, protoRelease)();
+				}
+			};
+		}
+	};
+}
+/**
+* Throw when an HRESULT signals failure.
+* @param hr - the HRESULT to check.
+* @param what - the failing call's name for the error message.
+* @returns the (successful) HRESULT unchanged.
+*/
+function check(hr, what) {
+	if (hr < 0) throw new Error(`${what} failed: HRESULT 0x${(hr >>> 0).toString(16)}`);
+	return hr;
+}
+/**
+* Run one modal folder-picker conversation on the calling thread: DPI opt-in,
+* STA init, dialog creation, `Show`, and result extraction, releasing the
+* dialog on every path.
+* @param bindings - the native surface (koffi-backed in production, fakes in tests).
+* @param title - the dialog title text.
+* @param onShowing - called with the native thread id immediately before the
+*   blocking `Show`, so a driver on another thread can close the dialog.
+* @returns the selected filesystem path, or null when the user cancels.
+*/
+function runFolderDialog(bindings, title, onShowing) {
+	bindings.setThreadDpiAwareness();
+	check(bindings.coInitializeSta(), "CoInitializeEx");
+	try {
+		const dialog = bindings.createFolderDialog();
+		try {
+			check(dialog.setOptions(104), "SetOptions");
+			check(dialog.setTitle(title), "SetTitle");
+			onShowing(bindings.currentThreadId());
+			const shown = dialog.show();
+			if (shown === -2147023673) return null;
+			check(shown, "Show");
+			const result = dialog.resultPath();
+			check(result.hr, "GetResult");
+			return result.path;
+		} finally {
+			dialog.release();
+		}
+	} finally {
+		bindings.coUninitialize();
+	}
+}
+//#endregion
+//#region lib/types/win32-dialog-worker.js
+/**
+* Child-process entry for the Win32 folder dialog: blocks THIS process
+* inside the modal `Show` so the host event loop stays live, reporting over
+* the IPC channel. Spawned as a child process (not a worker thread) so the
+* dialog is the process's first window and Windows activates it without a
+* manual foreground call. Protocol: `{kind:'showing',threadId}` right
+* before the blocking call (the driver's abort lever needs the native
+* thread id), then exactly one of `{kind:'done',path}` or
+* `{kind:'error',message}`.
+*/
+const title = process.env.DSH_DIALOG_TITLE ?? "";
+if (title === "") throw new Error("win32-dialog-worker: DSH_DIALOG_TITLE is required");
+if (process.send === void 0) throw new Error("win32-dialog-worker must run as a child process with an IPC channel");
+const send = process.send.bind(process);
+const post = (message) => {
+	/* v8 ignore next 3 -- disconnect needs a live IPC channel the unit lane must not sever (built-worker.e2e.ts owns the real close path). */
+	send(message, () => {
+		if (process.connected) process.disconnect();
+	});
+};
+/* v8 ignore next 3 -- the handler exits(0), which would kill the unit lane; built-worker.e2e.ts owns the real disconnect lifecycle. */
+process.on("disconnect", () => process.exit(0));
+(async () => {
+	try {
+		post({
+			kind: "done",
+			path: runFolderDialog(await loadWin32DialogBindings(), title, (threadId) => {
+				post({
+					kind: "showing",
+					threadId
+				});
+			})
+		});
+	} catch (error) {
+		post({
+			kind: "error",
+			message: error instanceof Error ? error.stack ?? error.message : String(error)
+		});
+	}
+})();
+//#endregion

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@deepseek-ai/dsh-host-directory-picker-native",
+  "description": "Native-OS-chooser backend of the directory-picker seam for the DeepSeek Harness web GUI host",
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/host/directory-picker-native"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./worker": {
+      "types": "./lib/types/win32-dialog-worker.d.ts",
+      "default": "./lib/worker.cjs"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/worker.cjs",
+    "lib/client.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "BSD-3-Clause",
+  "dependencies": {
+    "koffi": "^3.1.0",
+    "@deepseek-ai/dsh-host-directory-picker": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-native-command": "^0.0.1-rc.1"
+  },
+  "peerDependencies": {
+    "react": "^18.2.0",
+    "@deepseek-ai/dsh-client-runtime": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-client-ui-workspace": "^0.0.1-rc.1",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1"
+  },
+  "devDependencies": {
+    "@types/react": "~18.3.1",
+    "react": "^18.2.0",
+    "tsx": "^4.19.2",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-client-ui-workspace": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1",
+    "@deepseek-ai/dsh-client-runtime": "^0.0.1-rc.1"
+  },
+  "dsh": {
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-workspace"
+      ],
+      "platform": "web"
+    }
+  }
+}