@prettier-ai/dsh-win32-process 0.1.2-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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/subprocess/win32-process/README.md
+README.md: c2859996c5b5b3a82a5f78e12628613089eab3e6
+README.zh.md: 738d27f2671647921c80007f2cf7a7d974f211ce

package/README.md

@@ -0,0 +1,85 @@
+---
+description: "Low-level Win32 process primitives for maintainers implementing or debugging the Windows ACL sandbox."
+kind: "package-library"
+---
+
+# @deepseek-ai/dsh-win32-process
+
+English | [中文](README.zh.md)
+
+## Summary
+
+Low-level Win32 process library consumed by the Windows ACL sandbox. It owns the repository's one Koffi binding table for reusable restricted-process, stdio, and Job Object operations; it is not a Cordis service and does not choose sandbox policy or public child behavior. Read this page when maintaining the sandbox's native process path or checking its handle-lifetime limits.
+
+## Table of Contents
+
+- [Behavior](#behavior)
+- [Header verification](#header-verification)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="behavior"></a>
+## Behavior
+
+- **One reusable ABI owner** — `abi.ts` owns the Win32 constants and x64 layout values consumed by the sandbox process paths. `ffi.ts` lazily loads `kernel32.dll` and `advapi32.dll`, verifies `STARTUPINFOW` and `PROCESS_INFORMATION`, exposes typed operations and error formatting, and lets sandbox policy bind its remaining APIs through the same loaded libraries.
+- **Restricted-token creation** — `RestrictedProcessSpawnOptions` requires the sandbox's primary token and uses `CreateProcessAsUserW`. Piped and inherited-stdio paths share command-line quoting, cwd, the inherited environment block, checked return values, and handle cleanup.
+- **Piped process primitive** — `spawnPipedProcess()` creates anonymous stdin/stdout/stderr pipes, closes stdin immediately, returns the two read ends, and leaves process waiting and pipe draining to the caller. Every partial failure closes the handles already owned by the operation, and every Koffi out-parameter or struct allocation is freed after its Win32 lifetime.
+- **Inherited-stdio Job primitive** — `spawnInheritedJobProcess()` creates one kill-on-close Job, temporarily marks the current stdio handles inheritable, creates the restricted child suspended, assigns it to the Job, and then resumes its initial thread. Target code cannot run before Job assignment; controlled assignment or resume failures terminate the suspended child or close the assigned Job before releasing every owned handle.
+- **Explicit settlement ownership** — `waitForProcessExit()` waits and closes the process handle. `drainPipe()` reuses one native count slot while draining, frees it, and closes the pipe read handle. The sandbox retains its existing scheduling, result composition, and caller-owned Job closure.
+
+The Windows ACL sandbox adds SID, DACL, grant, workspace, and public child policy above these primitives.
+
+<a id="header-verification"></a>
+
+<a id="header-verification"></a>
+## Header verification
+
+The process, stdio, and Job constants plus selected structure sizes and offsets are checked against the MinGW Windows headers by [`verify/abi-probe.cpp`](verify/abi-probe.cpp):
+
+```sh
+g++ -std=c++20 -municode -O2 -o abi-probe.exe verify/abi-probe.cpp && ./abi-probe.exe
+```
+
+The Koffi `STARTUPINFOW` and `PROCESS_INFORMATION` definitions also assert their 64-bit sizes at module load. The probe remains the evidence for the other recorded offsets and constants.
+
+<a id="model-experience"></a>
+## Model Experience
+
+### Process primitives
+
+#### What the model sees
+
+Nothing directly. The package exposes `Win32ProcessBindings` and process primitives to the sandbox, which owns all model-visible tools, output, and diagnostics; this package contributes no prompt text or tool schema.
+
+#### Token effect
+
+None directly. Consumers decide whether process output enters a tool result or later model request.
+
+#### KV Cache effect
+
+The package contributes no stable request prefix, so it does not invalidate model KV caches.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- **Windows-only native loading** — importing the generic types is portable, but resolving the binding table loads Windows DLLs and fails on other hosts. Cross-platform tests inject a binding table instead of loading native APIs.
+- **No public process service** — the package intentionally does not wrap its primitives in Cordis or Node streams. A consumer must own its policy, async scheduling, output limits, cancellation, and final handle closure.
+- **Inherited environment only** — process creation passes a null environment block. The sandbox establishes changes through `SetEnvironmentVariableW` first because passing an explicit block through Koffi makes `CreateProcessAsUserW` fail with `ERROR_INVALID_PARAMETER`. Other callers that need environment changes must establish them before invoking the primitive or use their own runner process.
+- **Restricted-token consumer only** — ordinary `CreateProcessW`, exact `applicationName`, parent-stdio release, and whole-Job settlement are absent until an ordinary process consumer requires them.
+- **Create-to-assignment interruption** — the target starts suspended and cannot execute before Job assignment, but an external termination of the runner in the narrow interval between process creation and assignment can leave the suspended target behind. The package does not claim atomic Job attachment.
+- **Header evidence is architecture-specific** — the committed ABI probe and layout constants cover the repository's current 64-bit Windows targets. A new pointer width or incompatible Windows ABI requires updating the probe before support is claimed.
+
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -0,0 +1,85 @@
+---
+description: "面向实现或排查 Windows ACL 沙箱的维护者，说明底层 Win32 进程原语。"
+kind: "package-library"
+---
+
+# @deepseek-ai/dsh-win32-process
+
+[English](README.md) | 中文
+
+## 概述
+
+供 Windows ACL 沙箱消费的底层 Win32 进程库。它唯一拥有仓库中可复用 restricted-process、stdio 与 Job Object 操作的 Koffi 绑定表；它不是 Cordis 服务，也不决定沙箱策略或公共 child 行为。维护沙箱原生进程路径或检查 handle 生命周期限制时，请阅读本页。
+
+## 目录
+
+- [Behavior](#behavior)
+- [头部验证](#header-verification)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="behavior"></a>
+## Behavior
+
+- **唯一可复用 ABI owner** — `abi.ts` 拥有 sandbox process 路径消费的 Win32 常量与 x64 布局值。`ffi.ts` 懒加载 `kernel32.dll` 与 `advapi32.dll`，核验 `STARTUPINFOW` 和 `PROCESS_INFORMATION`，提供带类型的操作与错误格式化，并让 sandbox policy 通过同一组已加载库绑定剩余 API。
+- **restricted-token 创建** — `RestrictedProcessSpawnOptions` 要求 sandbox 的 primary token，并使用 `CreateProcessAsUserW`。pipe 与 inherited-stdio 路径共用命令行引用、cwd、继承环境块、返回值检查与句柄清理。
+- **管道进程原语** — `spawnPipedProcess()` 创建匿名 stdin/stdout/stderr 管道，立即关闭 stdin，并返回两个读取端；调用方负责等待进程与排空管道。任一局部失败都会关闭该操作已经拥有的句柄，并在各自 Win32 生命周期结束后释放每个 Koffi 输出槽与结构体分配。
+- **继承 stdio 的 Job 原语** — `spawnInheritedJobProcess()` 创建一个 kill-on-close Job，临时把当前 stdio 句柄设为可继承，以 suspended 状态创建 restricted child，把它分配给 Job，再恢复初始线程。目标代码不会在 Job 分配前运行；受控的分配或恢复失败会终止 suspended child，或在释放全部已拥有句柄前关闭已分配的 Job。
+- **显式结算归属** — `waitForProcessExit()` 等待并关闭进程句柄。`drainPipe()` 在排空期间复用一个 native count slot，释放该分配并关闭管道读取句柄。sandbox 保留既有调度、result 组合与调用方拥有的 Job 关闭行为。
+
+Windows ACL 沙箱在这些原语上增加 SID、DACL、grant、workspace 与公共 child policy。
+
+<a id="header-verification"></a>
+
+<a id="header-verification"></a>
+## 头部验证
+
+process、stdio 与 Job 的常量以及选定结构体的大小和偏移由 [`verify/abi-probe.cpp`](verify/abi-probe.cpp) 对照 MinGW Windows 头文件检查：
+
+```sh
+g++ -std=c++20 -municode -O2 -o abi-probe.exe verify/abi-probe.cpp && ./abi-probe.exe
+```
+
+Koffi 的 `STARTUPINFOW` 与 `PROCESS_INFORMATION` 定义还会在模块加载时断言各自的 64 位大小；其余已记录偏移和常量由该探针提供证据。
+
+<a id="model-experience"></a>
+## Model Experience
+
+### 进程原语
+
+#### 模型看到什么
+
+没有直接内容。本包向 sandbox 提供 `Win32ProcessBindings` 与进程原语；sandbox 拥有全部模型可见工具、输出与诊断，本包不贡献提示词或工具 schema。
+
+#### Token 影响
+
+没有直接影响。消费方决定进程输出是否进入工具结果或后续模型请求。
+
+#### KV Cache 影响
+
+本包不贡献稳定请求前缀，因此不会使模型 KV Cache 失效。
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- **仅在 Windows 原生加载** — 导入通用类型可跨平台进行，但解析绑定表会加载 Windows DLL，并在其他宿主失败。跨平台测试注入绑定表，不加载原生 API。
+- **没有公共进程服务** — 本包刻意不把原语包装成 Cordis 或 Node streams。消费方必须拥有自己的策略、异步调度、输出上限、取消与最终句柄关闭。
+- **只继承环境** — 进程创建传入空环境块。sandbox 会先通过 `SetEnvironmentVariableW` 建立改动，因为经 Koffi 传入显式环境块会使 `CreateProcessAsUserW` 以 `ERROR_INVALID_PARAMETER` 失败。其他需要改写环境的调用方必须在调用原语前建立环境，或使用自己的 runner 进程。
+- **只有 restricted-token 消费方** — ordinary `CreateProcessW`、精确 `applicationName`、parent-stdio release 与 whole-Job settlement 在 ordinary process 消费方出现前均不提供。
+- **创建到分配之间的中断** — 目标以 suspended 状态启动，不能在 Job 分配前执行，但 runner 若在进程创建到分配之间的极窄区间被外力终止，可能留下 suspended target。本包不声明原子 Job 附加保证。
+- **header 证据限定架构** — 已提交的 ABI probe 与布局常量覆盖仓库当前 64 位 Windows 目标。支持新的指针宽度或不兼容 Windows ABI 前，必须先更新 probe。
+
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/lib/index.js

@@ -0,0 +1,547 @@
+import koffi from "koffi";
+/** Win32 code reporting a caller-provided buffer is too small. */
+const ERROR_INSUFFICIENT_BUFFER = 122;
+/** Job limit that terminates every member when the final Job handle closes. */
+const JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 8192;
+//#endregion
+//#region lib/types/errors.js
+/** Win32 call failure with the exact API name and error code. */
+var Win32Error = class extends Error {
+	/** Win32 function whose checked result failed. */
+	api;
+	/** Exact GetLastError value or direct Win32 API error code. */
+	win32Code;
+	constructor(api, win32Code, detail) {
+		super(`${api} failed (Win32 ${win32Code})${detail === void 0 ? "" : `: ${detail}`}`);
+		this.name = "Win32Error";
+		this.api = api;
+		this.win32Code = win32Code;
+	}
+};
+//#endregion
+//#region lib/types/ffi.js
+/** Lazy Koffi bindings for generic Win32 process, stdio, and Job operations. */
+const PVOID = koffi.pointer("void");
+const PPVOID = koffi.pointer(PVOID);
+/**
+* Return whether a Koffi pointer represents NULL.
+* @param value - pointer value returned by Koffi or a Win32 call.
+* @returns true for null, undefined, or address zero.
+*/
+function isNullPtr(value) {
+	return value === null || value === void 0 || value === 0n;
+}
+/** Koffi STARTUPINFOW layout. */
+const STARTUPINFOW = koffi.struct("DSH_STARTUPINFOW", {
+	cb: "uint32",
+	lpReserved: "str16",
+	lpDesktop: "str16",
+	lpTitle: "str16",
+	dwX: "uint32",
+	dwY: "uint32",
+	dwXSize: "uint32",
+	dwYSize: "uint32",
+	dwXCountChars: "uint32",
+	dwYCountChars: "uint32",
+	dwFillAttribute: "uint32",
+	dwFlags: "uint32",
+	wShowWindow: "uint16",
+	cbReserved2: "uint16",
+	lpReserved2: koffi.pointer("uint8"),
+	hStdInput: PVOID,
+	hStdOutput: PVOID,
+	hStdError: PVOID
+});
+/** Koffi PROCESS_INFORMATION layout. */
+const PROCESS_INFORMATION = koffi.struct("DSH_PROCESS_INFORMATION", {
+	hProcess: PVOID,
+	hThread: PVOID,
+	dwProcessId: "uint32",
+	dwThreadId: "uint32"
+});
+/* v8 ignore start -- ABI guards are pinned by native header probes. */
+if (STARTUPINFOW.size !== 104) throw new Error(`STARTUPINFOW layout mismatch: koffi computed ${STARTUPINFOW.size}, expected 104`);
+if (PROCESS_INFORMATION.size !== 24) throw new Error(`PROCESS_INFORMATION layout mismatch: koffi computed ${PROCESS_INFORMATION.size}, expected 24`);
+/* v8 ignore stop */
+/**
+* Allocate a pointer-sized out-parameter slot.
+* @returns allocated native slot.
+*/
+function allocPtrSlot() {
+	return koffi.alloc(PVOID, 1);
+}
+/**
+* Allocate a uint32 out-parameter slot.
+* @returns allocated native slot.
+*/
+function allocUint32() {
+	return koffi.alloc("uint32", 1);
+}
+/**
+* Decode a pointer out-parameter.
+* @param slot - pointer-sized slot filled by Win32.
+* @returns decoded pointer, or null for address zero.
+*/
+function decodePtr(slot) {
+	const value = koffi.decode(slot, PVOID);
+	return isNullPtr(value) ? null : value;
+}
+/**
+* Decode a uint32 out-parameter.
+* @param slot - uint32 slot filled by Win32.
+* @returns decoded unsigned value.
+*/
+function decodeUint32(slot) {
+	return koffi.decode(slot, "uint32");
+}
+/**
+* Allocate a zeroed STARTUPINFOW.
+* @returns allocated struct pointer.
+*/
+function allocStartupInfo() {
+	return koffi.alloc(STARTUPINFOW, 1);
+}
+/**
+* Encode the stdio-bearing STARTUPINFOW fields.
+* @param startupInfo - allocated STARTUPINFOW pointer.
+* @param fields - fields required for inherited stdio.
+*/
+function encodeStartupInfo(startupInfo, fields) {
+	koffi.encode(startupInfo, STARTUPINFOW, fields);
+}
+/**
+* Allocate a zeroed PROCESS_INFORMATION.
+* @returns allocated struct pointer.
+*/
+function allocProcessInfo() {
+	return koffi.alloc(PROCESS_INFORMATION, 1);
+}
+/**
+* Decode PROCESS_INFORMATION.
+* @param processInfo - struct pointer filled by CreateProcess.
+* @returns process/thread handles and ids.
+*/
+function decodeProcessInfo(processInfo) {
+	return koffi.decode(processInfo, PROCESS_INFORMATION);
+}
+let cachedContext;
+let cached;
+/* v8 ignore start -- exercised by native Windows ABI and sandbox jobs. */
+function bindingContext() {
+	if (cachedContext !== void 0) return cachedContext;
+	const kernel32 = koffi.load("kernel32.dll");
+	const advapi32 = koffi.load("advapi32.dll");
+	const bind = (lib, name, result, args) => lib.func("__stdcall", name, result, args);
+	cachedContext = {
+		kernel32,
+		advapi32,
+		bind
+	};
+	return cachedContext;
+}
+function bindings() {
+	if (cached !== void 0) return cached;
+	const { kernel32, advapi32, bind } = bindingContext();
+	cached = {
+		closeHandle: bind(kernel32, "CloseHandle", "int", [PVOID]),
+		getLastError: bind(kernel32, "GetLastError", "uint32", []),
+		formatMessageW: bind(kernel32, "FormatMessageW", "uint32", [
+			"uint32",
+			PVOID,
+			"uint32",
+			"uint32",
+			PVOID,
+			"uint32",
+			PVOID
+		]),
+		createPipe: bind(kernel32, "CreatePipe", "int", [
+			PPVOID,
+			PPVOID,
+			PVOID,
+			"uint32"
+		]),
+		setHandleInformation: bind(kernel32, "SetHandleInformation", "int", [
+			PVOID,
+			"uint32",
+			"uint32"
+		]),
+		createProcessAsUserW: bind(advapi32, "CreateProcessAsUserW", "int", [
+			PVOID,
+			"str16",
+			"str16",
+			PVOID,
+			PVOID,
+			"int",
+			"uint32",
+			PVOID,
+			"str16",
+			koffi.pointer(STARTUPINFOW),
+			koffi.pointer(PROCESS_INFORMATION)
+		]),
+		readFile: bind(kernel32, "ReadFile", "int", [
+			PVOID,
+			PVOID,
+			"uint32",
+			koffi.pointer("uint32"),
+			PVOID
+		]),
+		peekNamedPipe: bind(kernel32, "PeekNamedPipe", "int", [
+			PVOID,
+			PVOID,
+			"uint32",
+			koffi.pointer("uint32"),
+			koffi.pointer("uint32"),
+			koffi.pointer("uint32")
+		]),
+		waitForSingleObject: bind(kernel32, "WaitForSingleObject", "uint32", [PVOID, "uint32"]),
+		getExitCodeProcess: bind(kernel32, "GetExitCodeProcess", "int", [PVOID, koffi.pointer("uint32")]),
+		createJobObjectW: bind(kernel32, "CreateJobObjectW", PVOID, [PVOID, "str16"]),
+		setInformationJobObject: bind(kernel32, "SetInformationJobObject", "int", [
+			PVOID,
+			"int",
+			PVOID,
+			"uint32"
+		]),
+		assignProcessToJobObject: bind(kernel32, "AssignProcessToJobObject", "int", [PVOID, PVOID]),
+		resumeThread: bind(kernel32, "ResumeThread", "uint32", [PVOID]),
+		terminateProcess: bind(kernel32, "TerminateProcess", "int", [PVOID, "uint32"]),
+		getStdHandle: bind(kernel32, "GetStdHandle", PVOID, ["int"])
+	};
+	return cached;
+}
+/**
+* Extend the shared process table with caller-owned Win32 API families.
+* @param create - binds only the caller-specific operations from the shared libraries.
+* @returns generic process bindings combined with the caller-specific operations.
+*/
+function extendWin32ProcessBindings(create) {
+	return {
+		...bindings(),
+		...create(bindingContext())
+	};
+}
+/* v8 ignore stop */
+/**
+* Format a Win32 error code through FormatMessageW.
+* @param api - active binding table.
+* @param win32Code - captured GetLastError value.
+* @returns trimmed system message, or an empty string when unavailable.
+*/
+function errorText(api, win32Code) {
+	const buffer = Buffer.alloc(1024);
+	const length = api.formatMessageW(4608, null, win32Code, 0, buffer, buffer.length / 2, null);
+	return length === 0 ? "" : buffer.subarray(0, length * 2).toString("utf16le").trim();
+}
+/**
+* Throw the current GetLastError value.
+* @param api - active binding table.
+* @param name - failing Win32 operation.
+* @param detail - optional operation context.
+* @returns never; always throws Win32Error.
+*/
+function throwLastError(api, name, detail) {
+	const win32Code = api.getLastError();
+	throw new Win32Error(name, win32Code, detail ?? errorText(api, win32Code));
+}
+/**
+* Throw an explicitly captured Win32 error code.
+* @param api - active binding table.
+* @param name - failing Win32 operation.
+* @param win32Code - error captured before cleanup.
+* @param detail - optional operation context.
+* @returns never; always throws Win32Error.
+*/
+function throwWin32(api, name, win32Code, detail) {
+	throw new Win32Error(name, win32Code, detail ?? errorText(api, win32Code));
+}
+//#endregion
+//#region lib/types/process.js
+/** Typed Win32 process operations over the shared binding table. */
+/**
+* Quote one argument according to CommandLineToArgvW parsing.
+* @param argument - one argv entry.
+* @returns bare or quoted command-line segment.
+*/
+function quoteArg(argument) {
+	if (argument === "") return "\"\"";
+	if (!/[\s"]/u.test(argument)) return argument;
+	let quoted = "\"";
+	for (let index = 0; index < argument.length; index++) {
+		let backslashes = 0;
+		while (index < argument.length && argument.charAt(index) === "\\") {
+			backslashes += 1;
+			index += 1;
+		}
+		if (index === argument.length) quoted += "\\".repeat(backslashes * 2);
+		else if (argument.charAt(index) === "\"") quoted += "\\".repeat(backslashes * 2 + 1) + "\"";
+		else quoted += "\\".repeat(backslashes) + argument.charAt(index);
+	}
+	return quoted + "\"";
+}
+/**
+* Build the mutable command line accepted by CreateProcessAsUserW.
+* @param program - executable argv entry.
+* @param args - remaining argv entries.
+* @returns joined Win32 command line.
+*/
+function buildCommandLine(program, args) {
+	return [program, ...args].map(quoteArg).join(" ");
+}
+function freeNative(pointer) {
+	if (pointer !== void 0) koffi.free(pointer);
+}
+function closeBestEffort(api, handle) {
+	if (!isNullPtr(handle)) api.closeHandle(handle);
+}
+function createPipe(api, owned) {
+	const readSlot = allocPtrSlot();
+	let writeSlot;
+	try {
+		writeSlot = allocPtrSlot();
+		if (api.createPipe(readSlot, writeSlot, null, 0) === 0) throwLastError(api, "CreatePipe");
+		const read = decodePtr(readSlot);
+		const write = decodePtr(writeSlot);
+		if (read === null || write === null) {
+			closeBestEffort(api, read);
+			closeBestEffort(api, write);
+			throwLastError(api, "CreatePipe", "null pipe handle");
+		}
+		owned.add(read);
+		owned.add(write);
+		return {
+			read,
+			write
+		};
+	} finally {
+		freeNative(writeSlot);
+		koffi.free(readSlot);
+	}
+}
+function closeOwned(api, owned, handle) {
+	/* v8 ignore next -- each successfully decoded pipe end is uniquely owned. */
+	if (!owned.delete(handle)) return;
+	api.closeHandle(handle);
+}
+function closeAllOwned(api, owned) {
+	for (const handle of owned) api.closeHandle(handle);
+	owned.clear();
+}
+function createRestrictedProcess(api, options, commandLine, creationFlags, startupInfo, processInfo) {
+	return api.createProcessAsUserW(options.token, null, commandLine, null, null, 1, creationFlags, null, options.cwd, startupInfo, processInfo);
+}
+/**
+* Spawn a process with anonymous-pipe stdout/stderr and immediate stdin EOF.
+* @param api - active binding table.
+* @param options - command, cwd, args, and restricted primary token.
+* @returns caller-owned process and pipe read handles.
+*/
+function spawnPipedProcess(api, options) {
+	const owned = /* @__PURE__ */ new Set();
+	let startupInfo;
+	let processInfo;
+	try {
+		const stdIn = createPipe(api, owned);
+		const stdOut = createPipe(api, owned);
+		const stdErr = createPipe(api, owned);
+		for (const [handle, label] of [
+			[stdIn.read, "stdin read end"],
+			[stdOut.write, "stdout write end"],
+			[stdErr.write, "stderr write end"]
+		]) if (api.setHandleInformation(handle, 1, 1) === 0) throwLastError(api, "SetHandleInformation", label);
+		startupInfo = allocStartupInfo();
+		encodeStartupInfo(startupInfo, {
+			cb: 104,
+			dwFlags: 256,
+			hStdInput: stdIn.read,
+			hStdOutput: stdOut.write,
+			hStdError: stdErr.write
+		});
+		processInfo = allocProcessInfo();
+		if (createRestrictedProcess(api, options, buildCommandLine(options.command, options.args), 0, startupInfo, processInfo) === 0) throwWin32(api, "CreateProcessAsUserW", api.getLastError(), `command: ${options.command}, cwd: ${options.cwd}`);
+		const info = decodeProcessInfo(processInfo);
+		if (info.hProcess === null || info.hThread === null) {
+			if (info.hProcess !== null) api.terminateProcess(info.hProcess, 1);
+			closeBestEffort(api, info.hThread);
+			closeBestEffort(api, info.hProcess);
+			throw new Error(`CreateProcessAsUserW succeeded but returned null process/thread handles (pid ${info.dwProcessId})`);
+		}
+		closeOwned(api, owned, stdIn.read);
+		closeOwned(api, owned, stdIn.write);
+		closeOwned(api, owned, stdOut.write);
+		closeOwned(api, owned, stdErr.write);
+		closeBestEffort(api, info.hThread);
+		owned.delete(stdOut.read);
+		owned.delete(stdErr.read);
+		return {
+			pid: info.dwProcessId,
+			process: info.hProcess,
+			stdoutRead: stdOut.read,
+			stderrRead: stdErr.read
+		};
+	} catch (error) {
+		closeAllOwned(api, owned);
+		throw error;
+	} finally {
+		freeNative(processInfo);
+		freeNative(startupInfo);
+	}
+}
+/**
+* Drain one anonymous pipe until the writer closes it.
+* @param api - active binding table.
+* @param handle - caller-owned pipe read end.
+* @returns complete bytes read before EOF; the handle is always closed.
+* @throws when a Win32 pipe operation fails.
+*/
+async function drainPipe(api, handle) {
+	const chunks = [];
+	let countSlot;
+	try {
+		countSlot = allocUint32();
+		for (;;) {
+			if (api.peekNamedPipe(handle, null, 0, null, countSlot, null) === 0) {
+				const win32Code = api.getLastError();
+				if (win32Code === 109 || win32Code === 232) break;
+				throwLastError(api, "PeekNamedPipe", `drain failure after ${chunks.length} chunk(s)`);
+			}
+			const available = decodeUint32(countSlot);
+			if (available > 0) {
+				const chunk = Buffer.alloc(available);
+				if (api.readFile(handle, chunk, chunk.length, countSlot, null) === 0) throwLastError(api, "ReadFile", `drain failure after ${chunks.length} chunk(s)`);
+				chunks.push(chunk.subarray(0, decodeUint32(countSlot)));
+			}
+			await new Promise((resolve) => setTimeout(resolve, 1));
+		}
+		return Buffer.concat(chunks);
+	} finally {
+		freeNative(countSlot);
+		api.closeHandle(handle);
+	}
+}
+/**
+* Wait for a process and always close its handle.
+* @param api - active binding table.
+* @param process - caller-owned process handle.
+* @returns direct process exit code.
+*/
+function waitForProcessExit(api, process) {
+	let exitCodeSlot;
+	try {
+		if (api.waitForSingleObject(process, 4294967295) === 4294967295) throwLastError(api, "WaitForSingleObject");
+		exitCodeSlot = allocUint32();
+		if (api.getExitCodeProcess(process, exitCodeSlot) === 0) throwLastError(api, "GetExitCodeProcess");
+		return decodeUint32(exitCodeSlot);
+	} finally {
+		freeNative(exitCodeSlot);
+		api.closeHandle(process);
+	}
+}
+function createKillOnCloseJob(api) {
+	const job = api.createJobObjectW(null, null);
+	if (isNullPtr(job)) throwLastError(api, "CreateJobObjectW");
+	const information = Buffer.alloc(144);
+	information.writeUInt32LE(JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, 16);
+	if (api.setInformationJobObject(job, 9, information, information.length) === 0) {
+		const win32Code = api.getLastError();
+		api.closeHandle(job);
+		throwWin32(api, "SetInformationJobObject", win32Code);
+	}
+	return job;
+}
+/**
+* Spawn suspended, assign the child to a kill-on-close Job, then resume it.
+* @param api - active binding table.
+* @param options - command, cwd, args, and restricted primary token.
+* @returns caller-owned process and Job handles after successful resume.
+* @remarks Node clears stdio handle inheritability at startup through
+* uv_disable_stdio_inheritance. This operation temporarily restores the bits
+* required by STARTF_USESTDHANDLES. Restoring them afterward is best-effort:
+* failure must not replace the already-created child's outcome.
+*/
+function spawnInheritedJobProcess(api, options) {
+	const job = createKillOnCloseJob(api);
+	const getStdHandle = (selector, label) => {
+		const handle = api.getStdHandle(selector);
+		if (!isNullPtr(handle)) return handle;
+		const win32Code = api.getLastError();
+		api.closeHandle(job);
+		throwWin32(api, "GetStdHandle", win32Code, `null ${label} handle`);
+	};
+	const stdIn = getStdHandle(-10, "stdin");
+	const stdOut = getStdHandle(-11, "stdout");
+	const stdErr = getStdHandle(-12, "stderr");
+	const enabled = [];
+	let startupInfo;
+	let processInfo;
+	let created = 0;
+	let createFailureCode = 0;
+	try {
+		for (const [handle, label] of [
+			[stdIn, "stdin"],
+			[stdOut, "stdout"],
+			[stdErr, "stderr"]
+		]) {
+			if (api.setHandleInformation(handle, 1, 1) === 0) throwLastError(api, "SetHandleInformation", `${label} (enable inherit)`);
+			enabled.push(handle);
+		}
+		startupInfo = allocStartupInfo();
+		encodeStartupInfo(startupInfo, {
+			cb: 104,
+			dwFlags: 256,
+			hStdInput: stdIn,
+			hStdOutput: stdOut,
+			hStdError: stdErr
+		});
+		processInfo = allocProcessInfo();
+		created = createRestrictedProcess(api, options, buildCommandLine(options.command, options.args), 4, startupInfo, processInfo);
+		if (created === 0) createFailureCode = api.getLastError();
+	} catch (error) {
+		freeNative(processInfo);
+		api.closeHandle(job);
+		throw error;
+	} finally {
+		freeNative(startupInfo);
+		for (const handle of enabled) api.setHandleInformation(handle, 1, 0);
+	}
+	if (created === 0) {
+		freeNative(processInfo);
+		api.closeHandle(job);
+		throwWin32(api, "CreateProcessAsUserW", createFailureCode, `command: ${options.command}, cwd: ${options.cwd}`);
+	}
+	let info;
+	try {
+		info = decodeProcessInfo(processInfo);
+	} finally {
+		freeNative(processInfo);
+	}
+	if (info.hProcess === null || info.hThread === null) {
+		if (info.hProcess !== null) api.terminateProcess(info.hProcess, 1);
+		api.closeHandle(job);
+		closeBestEffort(api, info.hThread);
+		closeBestEffort(api, info.hProcess);
+		throw new Error(`CreateProcessAsUserW succeeded but returned null process/thread handles (pid ${info.dwProcessId})`);
+	}
+	if (api.assignProcessToJobObject(job, info.hProcess) === 0) {
+		const win32Code = api.getLastError();
+		api.terminateProcess(info.hProcess, 1);
+		closeBestEffort(api, info.hThread);
+		closeBestEffort(api, info.hProcess);
+		api.closeHandle(job);
+		throwWin32(api, "AssignProcessToJobObject", win32Code, `pid ${info.dwProcessId}`);
+	}
+	if (api.resumeThread(info.hThread) === 4294967295) {
+		const win32Code = api.getLastError();
+		closeBestEffort(api, info.hThread);
+		closeBestEffort(api, info.hProcess);
+		api.closeHandle(job);
+		throwWin32(api, "ResumeThread", win32Code, `pid ${info.dwProcessId}`);
+	}
+	closeBestEffort(api, info.hThread);
+	return {
+		pid: info.dwProcessId,
+		process: info.hProcess,
+		job
+	};
+}
+//#endregion
+export { ERROR_INSUFFICIENT_BUFFER, Win32Error, allocPtrSlot, allocUint32, decodePtr, decodeUint32, drainPipe, extendWin32ProcessBindings, isNullPtr, spawnInheritedJobProcess, spawnPipedProcess, throwLastError, throwWin32, waitForProcessExit };

package/lib/invariant.js

@@ -0,0 +1,10 @@
+//#region lib/types/invariant.js
+/** Package-owned invariant companion for `@prettier-ai/dsh-win32-process`. */
+const PACKAGE_NAME = "@prettier-ai/dsh-win32-process";
+const name = "win32-process-invariant";
+const inject = ["invariants"];
+/** No runtime invariant: operations own only call-local native handles. */
+const install = () => {};
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/abi.d.ts

@@ -0,0 +1,38 @@
+/** Generic Win32 process, stdio, and Job Object constants verified on x64. */
+/** STARTUPINFOW uses the standard input, output, and error handles. */
+export declare const STARTF_USESTDHANDLES = 256;
+/** HandleInformation flag that permits child inheritance. */
+export declare const HANDLE_FLAG_INHERIT = 1;
+/** Infinite WaitForSingleObject timeout. */
+export declare const INFINITE = 4294967295;
+/** CreateProcess flag that prevents user code from running before resume. */
+export declare const CREATE_SUSPENDED = 4;
+/** GetStdHandle selector for standard input. */
+export declare const STD_INPUT_HANDLE = -10;
+/** GetStdHandle selector for standard output. */
+export declare const STD_OUTPUT_HANDLE = -11;
+/** GetStdHandle selector for standard error. */
+export declare const STD_ERROR_HANDLE = -12;
+/** FormatMessage reads the operating system message table. */
+export declare const FORMAT_MESSAGE_FROM_SYSTEM = 4096;
+/** FormatMessage leaves insertion placeholders uninterpreted. */
+export declare const FORMAT_MESSAGE_IGNORE_INSERTS = 512;
+/** Win32 code reporting a caller-provided buffer is too small. */
+export declare const ERROR_INSUFFICIENT_BUFFER = 122;
+/** Win32 code reporting that the other pipe end closed. */
+export declare const ERROR_BROKEN_PIPE = 109;
+/** Win32 code reporting that a pipe has no remaining data. */
+export declare const ERROR_NO_DATA = 232;
+/** Job limit that terminates every member when the final Job handle closes. */
+export declare const JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 8192;
+/** SetInformationJobObject class for JOBOBJECT_EXTENDED_LIMIT_INFORMATION. */
+export declare const JobObjectExtendedLimitInformation = 9;
+/** x64 JOBOBJECT_EXTENDED_LIMIT_INFORMATION byte size. */
+export declare const JOBOBJECT_EXTENDED_LIMIT_SIZE = 144;
+/** Byte offset of BasicLimitInformation.LimitFlags in the extended Job record. */
+export declare const JOBOBJECT_EXTENDED_LIMIT_FLAGS_OFFSET = 16;
+/** x64 STARTUPINFOW byte size verified by the native probe. */
+export declare const STARTUPINFOW_SIZE = 104;
+/** x64 PROCESS_INFORMATION byte size verified by the native probe. */
+export declare const PROCESS_INFORMATION_SIZE = 24;
+//# sourceMappingURL=abi.d.ts.map

package/lib/types/errors.d.ts

@@ -0,0 +1,9 @@
+/** Win32 call failure with the exact API name and error code. */
+export declare class Win32Error extends Error {
+    /** Win32 function whose checked result failed. */
+    readonly api: string;
+    /** Exact GetLastError value or direct Win32 API error code. */
+    readonly win32Code: number;
+    constructor(api: string, win32Code: number, detail?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/lib/types/ffi.d.ts

@@ -0,0 +1,137 @@
+/** Lazy Koffi bindings for generic Win32 process, stdio, and Job operations. */
+import koffi from 'koffi';
+declare const nativePtr: unique symbol;
+/** Koffi native pointer branded against accidental numeric use. */
+export type NativePtr = bigint & {
+    readonly [nativePtr]: true;
+};
+type Ptr = ReturnType<typeof koffi.pointer>;
+/** Loaded Win32 libraries and the shared stdcall binder used by process extensions. */
+export interface Win32BindingContext {
+    /** Kernel process, handle, pipe, and Job APIs. */
+    readonly kernel32: ReturnType<typeof koffi.load>;
+    /** Token and security APIs. */
+    readonly advapi32: ReturnType<typeof koffi.load>;
+    /** Bind one stdcall function from a loaded Win32 library. */
+    readonly bind: (library: ReturnType<typeof koffi.load>, name: string, result: Ptr | string, args: Array<Ptr | string>) => unknown;
+}
+/**
+ * Return whether a Koffi pointer represents NULL.
+ * @param value - pointer value returned by Koffi or a Win32 call.
+ * @returns true for null, undefined, or address zero.
+ */
+export declare function isNullPtr(value: NativePtr | null | undefined): value is null | undefined;
+/** STARTUPINFOW fields used by inherited or piped stdio launches. */
+export interface StartupInfoInput {
+    cb: number;
+    dwFlags: number;
+    hStdInput: NativePtr;
+    hStdOutput: NativePtr;
+    hStdError: NativePtr;
+}
+/** Decoded PROCESS_INFORMATION result. */
+export interface ProcessInfoOutput {
+    hProcess: NativePtr | null;
+    hThread: NativePtr | null;
+    dwProcessId: number;
+    dwThreadId: number;
+}
+/** Generic Win32 calls consumed by restricted-token sandbox process operations. */
+export interface Win32ProcessBindings {
+    closeHandle(handle: NativePtr): number;
+    getLastError(): number;
+    formatMessageW(flags: number, source: null, messageId: number, languageId: number, buffer: Buffer, size: number, args: null): number;
+    createPipe(readHandle: NativePtr, writeHandle: NativePtr, attributes: null, size: number): number;
+    setHandleInformation(handle: NativePtr, mask: number, flags: number): number;
+    createProcessAsUserW(token: NativePtr, applicationName: null, commandLine: string, processAttributes: null, threadAttributes: null, inheritHandles: number, creationFlags: number, environment: null, currentDirectory: string | null, startupInfo: NativePtr, processInfo: NativePtr): number;
+    readFile(file: NativePtr, buffer: Buffer, count: number, bytesRead: NativePtr, overlapped: null): number;
+    peekNamedPipe(pipe: NativePtr, buffer: null, size: number, bytesRead: NativePtr | null, totalAvail: NativePtr, leftThisMessage: NativePtr | null): number;
+    waitForSingleObject(handle: NativePtr, milliseconds: number): number;
+    getExitCodeProcess(process: NativePtr, exitCode: NativePtr): number;
+    createJobObjectW(attributes: null, name: null): NativePtr;
+    setInformationJobObject(job: NativePtr, cls: number, information: Buffer, length: number): number;
+    assignProcessToJobObject(job: NativePtr, process: NativePtr): number;
+    resumeThread(thread: NativePtr): number;
+    terminateProcess(process: NativePtr, exitCode: number): number;
+    getStdHandle(stdHandle: number): NativePtr;
+}
+/** Koffi STARTUPINFOW layout. */
+export declare const STARTUPINFOW: import("koffi").TypeObject;
+/** Koffi PROCESS_INFORMATION layout. */
+export declare const PROCESS_INFORMATION: import("koffi").TypeObject;
+/**
+ * Allocate a pointer-sized out-parameter slot.
+ * @returns allocated native slot.
+ */
+export declare function allocPtrSlot(): NativePtr;
+/**
+ * Allocate a uint32 out-parameter slot.
+ * @returns allocated native slot.
+ */
+export declare function allocUint32(): NativePtr;
+/**
+ * Decode a pointer out-parameter.
+ * @param slot - pointer-sized slot filled by Win32.
+ * @returns decoded pointer, or null for address zero.
+ */
+export declare function decodePtr(slot: NativePtr): NativePtr | null;
+/**
+ * Decode a uint32 out-parameter.
+ * @param slot - uint32 slot filled by Win32.
+ * @returns decoded unsigned value.
+ */
+export declare function decodeUint32(slot: NativePtr): number;
+/**
+ * Allocate a zeroed STARTUPINFOW.
+ * @returns allocated struct pointer.
+ */
+export declare function allocStartupInfo(): NativePtr;
+/**
+ * Encode the stdio-bearing STARTUPINFOW fields.
+ * @param startupInfo - allocated STARTUPINFOW pointer.
+ * @param fields - fields required for inherited stdio.
+ */
+export declare function encodeStartupInfo(startupInfo: NativePtr, fields: StartupInfoInput): void;
+/**
+ * Allocate a zeroed PROCESS_INFORMATION.
+ * @returns allocated struct pointer.
+ */
+export declare function allocProcessInfo(): NativePtr;
+/**
+ * Decode PROCESS_INFORMATION.
+ * @param processInfo - struct pointer filled by CreateProcess.
+ * @returns process/thread handles and ids.
+ */
+export declare function decodeProcessInfo(processInfo: NativePtr): ProcessInfoOutput;
+/**
+ * Extend the shared process table with caller-owned Win32 API families.
+ * @param create - binds only the caller-specific operations from the shared libraries.
+ * @returns generic process bindings combined with the caller-specific operations.
+ */
+export declare function extendWin32ProcessBindings<Extension extends object>(create: (context: Win32BindingContext) => Extension): Win32ProcessBindings & Extension;
+/**
+ * Format a Win32 error code through FormatMessageW.
+ * @param api - active binding table.
+ * @param win32Code - captured GetLastError value.
+ * @returns trimmed system message, or an empty string when unavailable.
+ */
+export declare function errorText(api: Win32ProcessBindings, win32Code: number): string;
+/**
+ * Throw the current GetLastError value.
+ * @param api - active binding table.
+ * @param name - failing Win32 operation.
+ * @param detail - optional operation context.
+ * @returns never; always throws Win32Error.
+ */
+export declare function throwLastError(api: Win32ProcessBindings, name: string, detail?: string): never;
+/**
+ * Throw an explicitly captured Win32 error code.
+ * @param api - active binding table.
+ * @param name - failing Win32 operation.
+ * @param win32Code - error captured before cleanup.
+ * @param detail - optional operation context.
+ * @returns never; always throws Win32Error.
+ */
+export declare function throwWin32(api: Win32ProcessBindings, name: string, win32Code: number, detail?: string): never;
+export {};
+//# sourceMappingURL=ffi.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,8 @@
+/** Low-level Win32 process, stdio, and Job Object primitives used by the Windows ACL sandbox. */
+export { ERROR_INSUFFICIENT_BUFFER } from './abi.ts';
+export * from './errors.ts';
+export { allocPtrSlot, allocUint32, decodePtr, decodeUint32, extendWin32ProcessBindings, isNullPtr, throwLastError, throwWin32, } from './ffi.ts';
+export type { NativePtr, Win32ProcessBindings, } from './ffi.ts';
+export { drainPipe, spawnInheritedJobProcess, spawnPipedProcess, waitForProcessExit, } from './process.ts';
+export type { SpawnedJobProcess, SpawnedPipedProcess, } from './process.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,6 @@
+/** Package-owned invariant companion for `@prettier-ai/dsh-win32-process`. */
+import type { Context } from '@prettier-ai/cordis';
+export declare const name = "win32-process-invariant";
+export declare const inject: string[];
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/process.d.ts

@@ -0,0 +1,80 @@
+/** Typed Win32 process operations over the shared binding table. */
+import type { NativePtr, Win32ProcessBindings } from './ffi.ts';
+/**
+ * Quote one argument according to CommandLineToArgvW parsing.
+ * @param argument - one argv entry.
+ * @returns bare or quoted command-line segment.
+ */
+export declare function quoteArg(argument: string): string;
+/**
+ * Build the mutable command line accepted by CreateProcessAsUserW.
+ * @param program - executable argv entry.
+ * @param args - remaining argv entries.
+ * @returns joined Win32 command line.
+ */
+export declare function buildCommandLine(program: string, args: readonly string[]): string;
+/** Restricted-token process creation inputs owned by the Windows ACL sandbox. */
+export interface RestrictedProcessSpawnOptions {
+    /** Executable argv entry passed through CreateProcessAsUserW. */
+    command: string;
+    /** Arguments excluding the executable. */
+    args: readonly string[];
+    /** Existing child working directory. */
+    cwd: string;
+    /** Restricted primary token supplied by sandbox policy. */
+    token: NativePtr;
+}
+/** Piped child resources whose process and read handles remain caller-owned. */
+export interface SpawnedPipedProcess {
+    /** Direct child process id. */
+    pid: number;
+    /** Process handle closed by waitForProcessExit. */
+    process: NativePtr;
+    /** Stdout pipe read end closed by drainPipe. */
+    stdoutRead: NativePtr;
+    /** Stderr pipe read end closed by drainPipe. */
+    stderrRead: NativePtr;
+}
+/** Suspended child assigned to one caller-owned kill-on-close Job before resume. */
+export interface SpawnedJobProcess {
+    /** Direct child process id. */
+    pid: number;
+    /** Process handle closed by waitForProcessExit. */
+    process: NativePtr;
+    /** Job handle closed by the lifecycle owner. */
+    job: NativePtr;
+}
+/**
+ * Spawn a process with anonymous-pipe stdout/stderr and immediate stdin EOF.
+ * @param api - active binding table.
+ * @param options - command, cwd, args, and restricted primary token.
+ * @returns caller-owned process and pipe read handles.
+ */
+export declare function spawnPipedProcess(api: Win32ProcessBindings, options: RestrictedProcessSpawnOptions): SpawnedPipedProcess;
+/**
+ * Drain one anonymous pipe until the writer closes it.
+ * @param api - active binding table.
+ * @param handle - caller-owned pipe read end.
+ * @returns complete bytes read before EOF; the handle is always closed.
+ * @throws when a Win32 pipe operation fails.
+ */
+export declare function drainPipe(api: Win32ProcessBindings, handle: NativePtr): Promise<Buffer>;
+/**
+ * Wait for a process and always close its handle.
+ * @param api - active binding table.
+ * @param process - caller-owned process handle.
+ * @returns direct process exit code.
+ */
+export declare function waitForProcessExit(api: Win32ProcessBindings, process: NativePtr): number;
+/**
+ * Spawn suspended, assign the child to a kill-on-close Job, then resume it.
+ * @param api - active binding table.
+ * @param options - command, cwd, args, and restricted primary token.
+ * @returns caller-owned process and Job handles after successful resume.
+ * @remarks Node clears stdio handle inheritability at startup through
+ * uv_disable_stdio_inheritance. This operation temporarily restores the bits
+ * required by STARTF_USESTDHANDLES. Restoring them afterward is best-effort:
+ * failure must not replace the already-created child's outcome.
+ */
+export declare function spawnInheritedJobProcess(api: Win32ProcessBindings, options: RestrictedProcessSpawnOptions): SpawnedJobProcess;
+//# sourceMappingURL=process.d.ts.map

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@prettier-ai/dsh-win32-process",
+  "description": "Low-level Win32 process, stdio, and Job Object primitives for the DeepSeek Harness Windows sandbox",
+  "version": "0.1.2-alpha.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/subprocess/win32-process"
+  },
+  "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"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@prettier-ai/dsh-invariants": "^0.1.2-alpha.1",
+    "@prettier-ai/cordis": "^4.0.1"
+  },
+  "dependencies": {
+    "koffi": "^3.1.0"
+  },
+  "devDependencies": {
+    "@prettier-ai/cordis": "^4.0.1",
+    "@prettier-ai/dsh-invariants": "^0.1.2-alpha.1"
+  }
+}