@x1a0f3n9/dsh-native-command 0.1.5-rc.5 → 0.1.7-rc.2

package/lib/types/desktop-entry.d.ts

@@ -0,0 +1,26 @@
+/** Decoded application icon bytes suitable for an image response or data URL. */
+export interface DesktopIcon {
+    readonly bytes: Buffer;
+    readonly contentType: 'image/png' | 'image/svg+xml';
+}
+/**
+ * Read the main desktop-entry section without interpreting executable commands.
+ * @param text - installed desktop-entry text.
+ * @returns its literal field values; action sections are excluded.
+ */
+export declare function desktopEntryFields(text: string): Readonly<Record<string, string>>;
+/**
+ * Resolve XDG application and icon roots in desktop precedence order.
+ * @param home - user's home directory.
+ * @param env - desktop environment values.
+ * @returns data-home followed by system data directories.
+ */
+export declare function desktopDataDirectories(home: string, env: Readonly<Record<string, string | undefined>>): readonly string[];
+/**
+ * Resolve an absolute icon path or an installed hicolor/pixmaps icon name.
+ * @param name - desktop-entry Icon field.
+ * @param directories - XDG data roots in precedence order.
+ * @returns image bytes and media type, or null when artwork is unavailable.
+ */
+export declare function desktopApplicationIcon(name: string, directories: readonly string[]): Promise<DesktopIcon | null>;
+//# sourceMappingURL=desktop-entry.d.ts.map

package/lib/types/desktop-entry.js

@@ -0,0 +1,79 @@
+/** Shared XDG desktop-entry fields and icon lookup for directory and file application catalogs. */
+import { readFile, stat } from 'node:fs/promises';
+import { isAbsolute, join } from 'node:path';
+/**
+ * Read the main desktop-entry section without interpreting executable commands.
+ * @param text - installed desktop-entry text.
+ * @returns its literal field values; action sections are excluded.
+ */
+export function desktopEntryFields(text) {
+    let main = false;
+    const fields = new Map();
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('[')) {
+            main = trimmed === '[Desktop Entry]';
+            continue;
+        }
+        if (!main || trimmed.startsWith('#'))
+            continue;
+        const separator = trimmed.indexOf('=');
+        if (separator > 0)
+            fields.set(trimmed.slice(0, separator).trim(), trimmed.slice(separator + 1).trim());
+    }
+    return Object.fromEntries(fields);
+}
+/**
+ * Resolve XDG application and icon roots in desktop precedence order.
+ * @param home - user's home directory.
+ * @param env - desktop environment values.
+ * @returns data-home followed by system data directories.
+ */
+export function desktopDataDirectories(home, env) {
+    return [env.XDG_DATA_HOME ?? join(home, '.local', 'share'),
+        ...(env.XDG_DATA_DIRS ?? '/usr/local/share:/usr/share').split(':').filter(Boolean)];
+}
+/** Read an installed PNG or SVG icon; absent paths and directories have no pixels. */
+async function readIcon(path) {
+    const contentType = path.endsWith('.png') ? 'image/png' : path.endsWith('.svg') ? 'image/svg+xml' : null;
+    if (contentType === null)
+        return null;
+    try {
+        if (!(await stat(path)).isFile())
+            return null;
+        return { bytes: await readFile(path), contentType };
+    }
+    catch (_error) {
+        // Missing or unreadable artwork does not remove an otherwise usable application.
+        return null;
+    }
+}
+/**
+ * Resolve an absolute icon path or an installed hicolor/pixmaps icon name.
+ * @param name - desktop-entry Icon field.
+ * @param directories - XDG data roots in precedence order.
+ * @returns image bytes and media type, or null when artwork is unavailable.
+ */
+export async function desktopApplicationIcon(name, directories) {
+    if (isAbsolute(name))
+        return readIcon(name);
+    for (const directory of directories) {
+        for (const size of ['512x512', '256x256', '128x128', '64x64', '48x48', '32x32']) {
+            for (const extension of ['png', 'svg']) {
+                const icon = await readIcon(join(directory, 'icons', 'hicolor', size, 'apps', `${name}.${extension}`));
+                if (icon !== null)
+                    return icon;
+            }
+        }
+        const scalable = await readIcon(join(directory, 'icons', 'hicolor', 'scalable', 'apps', `${name}.svg`));
+        if (scalable !== null)
+            return scalable;
+        for (const extension of ['png', 'svg']) {
+            const icon = await readIcon(join(directory, 'pixmaps', `${name}.${extension}`));
+            if (icon !== null)
+                return icon;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=desktop-entry.js.map

package/lib/types/file-applications-linux.d.ts

@@ -0,0 +1,12 @@
+import type { NativeCommandRunner } from './runner.ts';
+import type { NativeFileApplication } from './types.ts';
+/**
+ * Query all registered file handlers from GIO without executing desktop-entry command text.
+ * @param path - verified local file path.
+ * @param signal - caller cancellation.
+ * @param run - native command runner.
+ * @param env - XDG and locale settings.
+ * @returns registered applications with the desktop's default marked.
+ */
+export declare function linuxFileApplications(path: string, signal: AbortSignal, run: NativeCommandRunner, env: NodeJS.ProcessEnv): Promise<readonly NativeFileApplication[]>;
+//# sourceMappingURL=file-applications-linux.d.ts.map

package/lib/types/file-applications-linux.js

@@ -0,0 +1,70 @@
+/** Linux file associations from GIO, with shared XDG metadata and artwork lookup. */
+import { readdir, readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, relative, sep } from 'node:path';
+import { desktopApplicationIcon, desktopDataDirectories, desktopEntryFields } from "./desktop-entry.js";
+/** Find a desktop id, including ids derived from nested application directories. */
+async function desktopFile(root, id, directory = root) {
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch (_error) {
+        // An absent XDG root contributes no applications.
+        return null;
+    }
+    for (const entry of entries) {
+        const path = join(directory, entry.name);
+        if (!entry.isDirectory() && relative(root, path).split(sep).join('-') === id)
+            return path;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const found = await desktopFile(root, id, join(directory, entry.name));
+            if (found !== null)
+                return found;
+        }
+    }
+    return null;
+}
+/**
+ * Query all registered file handlers from GIO without executing desktop-entry command text.
+ * @param path - verified local file path.
+ * @param signal - caller cancellation.
+ * @param run - native command runner.
+ * @param env - XDG and locale settings.
+ * @returns registered applications with the desktop's default marked.
+ */
+export async function linuxFileApplications(path, signal, run, env) {
+    const info = await run('gio', ['info', '-a', 'standard::content-type', path], signal);
+    const mime = /standard::content-type:\s*(\S+)/.exec(info.stdout)?.[1];
+    if (mime === undefined)
+        throw new Error('GIO did not identify the file content type');
+    const result = await run('env', ['LC_ALL=C', 'gio', 'mime', mime], signal);
+    const preferred = /^Default application.*:\s*(.+\.desktop)\s*$/m.exec(result.stdout)?.[1];
+    const ids = [...new Set([...(preferred === undefined ? [] : [preferred]), ...result.stdout.split(/\r?\n/)
+                .filter(line => /^\s+.*\.desktop\s*$/.test(line)).map(line => line.trim())])];
+    const directories = desktopDataDirectories(env.HOME ?? homedir(), env);
+    const locale = (env.LC_ALL ?? env.LC_MESSAGES ?? env.LANG ?? '').replace(/\..*$/, '');
+    const applications = [];
+    for (const id of ids) {
+        signal.throwIfAborted();
+        let entryPath = null;
+        for (const directory of directories) {
+            entryPath = await desktopFile(join(directory, 'applications'), id);
+            if (entryPath !== null)
+                break;
+        }
+        if (entryPath === null)
+            continue;
+        const fields = desktopEntryFields(await readFile(entryPath, 'utf8'));
+        const name = fields[`Name[${locale}]`] ?? fields[`Name[${locale.replace(/_.*/, '')}]`] ?? fields.Name;
+        if (name === undefined || fields.Hidden === 'true')
+            continue;
+        const icon = fields.Icon === undefined ? null : await desktopApplicationIcon(fields.Icon, directories);
+        applications.push({ id: entryPath, name, default: id === preferred,
+            icon: icon === null ? null : `data:${icon.contentType};base64,${icon.bytes.toString('base64')}` });
+    }
+    return applications;
+}
+//# sourceMappingURL=file-applications-linux.js.map

package/lib/types/file-applications-windows.d.ts

@@ -0,0 +1,12 @@
+import type { NativeCommandRunner } from './runner.ts';
+/**
+ * Execute the Windows Shell adapter in a Unicode STA PowerShell process; the adapter
+ * source is a private temporary script file, removed once the call settles.
+ * @param path - Windows file path, translated by the caller for WSL.
+ * @param application - registered handler to invoke; null requests the application list.
+ * @param signal - caller cancellation.
+ * @param run - native command runner.
+ * @returns adapter output; query mode emits a JSON array.
+ */
+export declare function windowsFileApplications(path: string, application: string | null, signal: AbortSignal, run: NativeCommandRunner): Promise<string>;
+//# sourceMappingURL=file-applications-windows.d.ts.map

package/lib/types/file-applications-windows.js

@@ -0,0 +1,273 @@
+/** Windows Shell association queries and invocation; paths are encoded data, never PowerShell expressions. */
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+/** Shell interfaces are declared in their native vtable order; Invoke preserves packaged-app and DDE handling. */
+const WINDOWS_ASSOCIATIONS = String.raw `
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.ComTypes;
+using System.Text;
+
+public static class DshFileAssociations {
+  [ComImport, Guid("973810ae-9599-4b88-9e4d-6ee98c9552da"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+  public interface IEnumHandlers {
+    [PreserveSig] int Next(uint count, out IHandler handler, out uint fetched);
+  }
+  [ComImport, Guid("f04061ac-1659-4a3f-a954-775aa57fc083"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+  public interface IHandler {
+    void GetName([MarshalAs(UnmanagedType.LPWStr)] out string name);
+    void GetUIName([MarshalAs(UnmanagedType.LPWStr)] out string name);
+    void GetIconLocation([MarshalAs(UnmanagedType.LPWStr)] out string path, out int index);
+    [PreserveSig] int IsRecommended();
+    void MakeDefault([MarshalAs(UnmanagedType.LPWStr)] string description);
+    void Invoke(IDataObject data);
+    void CreateInvoker(IDataObject data, [MarshalAs(UnmanagedType.Interface)] out object invoker);
+  }
+  [ComImport, Guid("43826d1e-e718-42ee-bc55-a1e261c37bfe"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+  public interface IShellItem {
+    void BindToHandler(IntPtr context, ref Guid handler, ref Guid iid, [MarshalAs(UnmanagedType.Interface)] out IDataObject data);
+  }
+  [DllImport("shell32.dll", CharSet = CharSet.Unicode, PreserveSig = false)]
+  static extern void SHAssocEnumHandlers(string extension, uint filter, out IEnumHandlers handlers);
+  [DllImport("shell32.dll", CharSet = CharSet.Unicode, PreserveSig = false)]
+  static extern void SHCreateItemFromParsingName(string path, IntPtr context, ref Guid iid, out IShellItem item);
+  [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
+  static extern int AssocQueryString(uint flags, uint kind, string association, string extra, StringBuilder output, ref uint size);
+  [DllImport("shell32.dll", CharSet = CharSet.Unicode)]
+  static extern int SHDefExtractIcon(string path, int index, uint flags, out IntPtr large, out IntPtr small, uint size);
+  [DllImport("user32.dll")]
+  static extern bool DestroyIcon(IntPtr icon);
+  [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
+  static extern int SHLoadIndirectString(string source, StringBuilder output, uint size, IntPtr reserved);
+
+  [DllImport("shlwapi.dll", PreserveSig = false)]
+  static extern void SHCreateThreadRef(IntPtr count, out IntPtr reference);
+  [DllImport("shlwapi.dll", PreserveSig = false)]
+  static extern void SHSetThreadRef(IntPtr reference);
+  [DllImport("shell32.dll")]
+  static extern void SHSetInstanceExplorer(IntPtr reference);
+  [StructLayout(LayoutKind.Sequential)]
+  struct Message {
+    public IntPtr window;
+    public uint message;
+    public UIntPtr wParam;
+    public IntPtr lParam;
+    public uint time;
+    public int x, y;
+    public uint reserved;
+  }
+  [DllImport("user32.dll", SetLastError = true)]
+  static extern UIntPtr SetTimer(IntPtr window, UIntPtr id, uint milliseconds, IntPtr callback);
+  [DllImport("user32.dll")]
+  static extern bool KillTimer(IntPtr window, UIntPtr id);
+  [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+  static extern int GetMessage(out Message message, IntPtr window, uint min, uint max);
+  [DllImport("user32.dll")]
+  static extern bool TranslateMessage(ref Message message);
+  [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+  static extern IntPtr DispatchMessage(ref Message message);
+
+  // Shell handlers may return before their asynchronous launch work releases the host.
+  // The shared Shell reference, rather than an arbitrary delay, owns that lifetime.
+  static void WithShellLifetime(Action action) {
+    IntPtr count = Marshal.AllocHGlobal(sizeof(int));
+    IntPtr reference = IntPtr.Zero;
+    try {
+      Marshal.WriteInt32(count, 0);
+      SHCreateThreadRef(count, out reference);
+      SHSetThreadRef(reference);
+      SHSetInstanceExplorer(reference);
+      int owned = Marshal.ReadInt32(count);
+      try { action(); }
+      finally {
+        if (Marshal.ReadInt32(count) > owned) {
+          // USER_TIMER_MINIMUM wakes the STA to inspect the reference count while dispatching COM work.
+          UIntPtr timer = SetTimer(IntPtr.Zero, UIntPtr.Zero, 10, IntPtr.Zero);
+          if (timer == UIntPtr.Zero) throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
+          try {
+            while (Marshal.ReadInt32(count) > owned) {
+              Message message;
+              if (GetMessage(out message, IntPtr.Zero, 0, 0) <= 0) throw new InvalidOperationException("Shell handoff message loop ended");
+              TranslateMessage(ref message);
+              DispatchMessage(ref message);
+            }
+          } finally { KillTimer(IntPtr.Zero, timer); }
+        }
+      }
+    } finally {
+      SHSetInstanceExplorer(IntPtr.Zero);
+      SHSetThreadRef(IntPtr.Zero);
+      int remaining = reference == IntPtr.Zero ? 0 : Marshal.Release(reference);
+      // An interrupted drain leaves its counter owned by the terminating helper process.
+      if (remaining == 0) Marshal.FreeHGlobal(count);
+    }
+  }
+
+  public sealed class Application {
+    public string id;
+    public string name;
+    public string icon;
+    public bool @default;
+  }
+  static string Associated(string extension, uint kind) {
+    uint size = 0;
+    AssocQueryString(0, kind, extension, null, null, ref size);
+    if (size == 0) return null;
+    var text = new StringBuilder((int)size);
+    return AssocQueryString(0, kind, extension, null, text, ref size) == 0 ? text.ToString() : null;
+  }
+  // Resolve a packaged application's indirect icon reference, for example
+  // @{Microsoft.WindowsNotepad_...?ms-resource://.../NotepadAppList.png}, to
+  // the resource file the Shell would draw; an unresolved reference is null.
+  static string ResolveIndirectIcon(string source) {
+    var output = new StringBuilder(1024);
+    return SHLoadIndirectString(source, output, (uint)output.Capacity, IntPtr.Zero) == 0 ? output.ToString() : null;
+  }
+  // Read one icon source into a 32px PNG: an image file directly, otherwise the
+  // resource the Shell extracts at the given index. A missing resource is null.
+  static string PngFromIconSource(string source, int index) {
+    IntPtr large = IntPtr.Zero, small = IntPtr.Zero;
+    try {
+      if (Path.GetExtension(source).Equals(".png", StringComparison.OrdinalIgnoreCase)) {
+        using (var original = Image.FromFile(source))
+        using (var resized = new Bitmap(original, new Size(32, 32)))
+        using (var stream = new MemoryStream()) {
+          resized.Save(stream, ImageFormat.Png);
+          return "data:image/png;base64," + Convert.ToBase64String(stream.ToArray());
+        }
+      }
+      if (SHDefExtractIcon(source, index, 0, out large, out small, 32) != 0 || large == IntPtr.Zero) return null;
+      using (var image = Icon.FromHandle(large))
+      using (var bitmap = image.ToBitmap())
+      using (var stream = new MemoryStream()) {
+        bitmap.Save(stream, ImageFormat.Png);
+        return "data:image/png;base64," + Convert.ToBase64String(stream.ToArray());
+      }
+    } catch (Exception) {
+      // Missing icon resources do not make the application unusable.
+      return null;
+    } finally {
+      if (large != IntPtr.Zero) DestroyIcon(large);
+      if (small != IntPtr.Zero) DestroyIcon(small);
+    }
+  }
+  // Best-effort fallback: some handlers return their executable path from GetName, but a
+  // packaged handler's name may be an AUMID or family name, which extracts no icon.
+  static string IconData(IHandler handler, string id) {
+    string source = null; int index = 0;
+    try { handler.GetIconLocation(out source, out index); } catch (Exception) {
+      // A handler without a drawable icon location falls back to its name.
+    }
+    if (!String.IsNullOrEmpty(source)) {
+      source = Environment.ExpandEnvironmentVariables(source);
+      if (source.StartsWith("@{", StringComparison.Ordinal) && source.EndsWith("}", StringComparison.Ordinal)) {
+        var resolved = ResolveIndirectIcon(source);
+        if (!String.IsNullOrEmpty(resolved)) source = resolved;
+      }
+      var icon = PngFromIconSource(source, index);
+      if (icon != null) return icon;
+    }
+    return String.IsNullOrEmpty(id) || String.Equals(id, source, StringComparison.OrdinalIgnoreCase)
+      ? null
+      : PngFromIconSource(id, 0);
+  }
+  static void Visit(string path, Action<IHandler> visit) {
+    var extension = Path.GetExtension(path);
+    if (extension.Length == 0) return;
+    IEnumHandlers handlers;
+    SHAssocEnumHandlers(extension, 0, out handlers);
+    try {
+      while (true) {
+        IHandler handler; uint fetched;
+        int result = handlers.Next(1, out handler, out fetched);
+        Marshal.ThrowExceptionForHR(result);
+        if (result != 0 || fetched == 0) break;
+        try { visit(handler); } finally { Marshal.FinalReleaseComObject(handler); }
+      }
+    } finally { Marshal.FinalReleaseComObject(handlers); }
+  }
+  public static Application[] List(string path) {
+    var extension = Path.GetExtension(path);
+    var executable = extension.Length == 0 ? null : Associated(extension, 2);
+    var appId = extension.Length == 0 ? null : Associated(extension, 21);
+    var apps = new List<Application>();
+    var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+    Visit(path, delegate(IHandler handler) {
+      string id, name;
+      handler.GetName(out id); handler.GetUIName(out name);
+      if (!seen.Add(id)) return;
+      apps.Add(new Application { id = id, name = name, icon = IconData(handler, id),
+        @default = String.Equals(id, executable, StringComparison.OrdinalIgnoreCase) || String.Equals(id, appId, StringComparison.OrdinalIgnoreCase) });
+    });
+    return apps.ToArray();
+  }
+  public static void Open(string path, string application) {
+    WithShellLifetime(delegate { OpenRegistered(path, application); });
+  }
+  static void OpenRegistered(string path, string application) {
+    bool opened = false;
+    Visit(path, delegate(IHandler handler) {
+      string id; handler.GetName(out id);
+      if (opened || !String.Equals(id, application, StringComparison.OrdinalIgnoreCase)) return;
+      var iid = typeof(IShellItem).GUID;
+      IShellItem item;
+      SHCreateItemFromParsingName(path, IntPtr.Zero, ref iid, out item);
+      IDataObject data = null;
+      try {
+        var bhid = new Guid("b8c0bd9f-ed24-455c-83e6-d5390c4fe8c4");
+        var dataIid = typeof(IDataObject).GUID;
+        item.BindToHandler(IntPtr.Zero, ref bhid, ref dataIid, out data);
+        handler.Invoke(data);
+        opened = true;
+      } finally {
+        if (data != null) Marshal.FinalReleaseComObject(data);
+        Marshal.FinalReleaseComObject(item);
+      }
+    });
+    if (!opened) throw new InvalidOperationException("Application is not registered for this file");
+  }
+}`;
+/**
+ * Execute the Windows Shell adapter in a Unicode STA PowerShell process; the adapter
+ * source is a private temporary script file, removed once the call settles.
+ * @param path - Windows file path, translated by the caller for WSL.
+ * @param application - registered handler to invoke; null requests the application list.
+ * @param signal - caller cancellation.
+ * @param run - native command runner.
+ * @returns adapter output; query mode emits a JSON array.
+ */
+export async function windowsFileApplications(path, application, signal, run) {
+    const encodedPath = Buffer.from(path).toString('base64');
+    const encodedApplication = Buffer.from(application ?? '').toString('base64');
+    const script = `$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
+Add-Type -ReferencedAssemblies System,System.Core,System.Drawing -TypeDefinition @'
+${WINDOWS_ASSOCIATIONS}
+'@
+$path = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encodedPath}'))
+$application = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encodedApplication}'))
+${application === null ? 'ConvertTo-Json -InputObject @([DshFileAssociations]::List($path)) -Depth 4 -Compress' : '[DshFileAssociations]::Open($path, $application)'}
+`;
+    // The script travels as a file, not as command-line data: -EncodedCommand grew with the
+    // embedded C# and overflowed the 32767-character CreateProcess limit for long paths.
+    // PowerShell 5.1 decodes a -File script as ANSI unless it carries a BOM; the BOM keeps
+    // the embedded UTF-8 source intact.
+    const directory = await mkdtemp(join(tmpdir(), 'dsh-native-command-'));
+    const scriptPath = join(directory, 'associations.ps1');
+    try {
+        await writeFile(scriptPath, `\uFEFF${script}`, 'utf8');
+        const result = await run('powershell.exe', [
+            '-NoProfile', '-NonInteractive', '-STA', '-ExecutionPolicy', 'Bypass', '-File', scriptPath,
+        ], signal);
+        return result.stdout;
+    }
+    finally {
+        await rm(directory, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=file-applications-windows.js.map

package/lib/types/file-applications.d.ts

@@ -0,0 +1,22 @@
+import type { PathOpenerInternals } from './path-opener.ts';
+import { type NativeFileApplication } from './types.ts';
+/**
+ * List registered handlers in OS preference order, including the current default and application icons.
+ * @param path - verified absolute local file path.
+ * @param signal - caller lifetime, propagated to the OS query.
+ * @param internals - platform and command adapter for deterministic tests.
+ * @returns current file handlers; on macOS, copies sharing a bundle identifier and display name collapse
+ * to one entry; an empty list when the platform has no association query.
+ */
+export declare function nativeFileApplications(path: string, signal: AbortSignal, internals?: PathOpenerInternals): Promise<readonly NativeFileApplication[]>;
+/**
+ * Open a file in a currently registered handler; stale or arbitrary application identifiers are rejected.
+ * Validation checks the complete registered list, so macOS copies collapsed out of the display list stay openable.
+ * @param path - verified absolute local file path.
+ * @param application - identifier returned by the file association query.
+ * @param signal - caller lifetime, propagated to query and launch.
+ * @param internals - platform and command adapter for deterministic tests.
+ * @returns after the system launcher accepts the file.
+ */
+export declare function openNativeFileApplication(path: string, application: string, signal: AbortSignal, internals?: PathOpenerInternals): Promise<void>;
+//# sourceMappingURL=file-applications.d.ts.map