dsh-wsl-workspace 0.3.2 → 0.4.0

package/src/host/wsl-skills.ts

@@ -11,7 +11,11 @@
  * This provider mirrors the host's discovery rules for WSL UNC session
  * workspaces: it starts at the session cwd's nearest `.git` ancestor (the
  * host's project-root rule; the cwd itself when no ancestor has a `.git`
- * marker), then walks that root (depth- and budget-bounded), collects every
+ * marker), then walks that root (depth- and budget-bounded). Directory
+ * symlinks are followed when the substrate resolves them and pruned safely
+ * when it does not — the `\\wsl.localhost` 9P share cannot resolve Linux
+ * symlink targets, so linked-in projects stay undiscoverable there today.
+ * The walk collects every
  * `.dsh/skills` and `.agents/skills` directory it finds — including nested
  * projects — and publishes their skills with the same
  * project ranks and sources the host uses, so precedence and duplicate
@@ -42,7 +46,10 @@ const MAX_SKILL_ROOTS = 64
 const MAX_VISITED_DIRECTORIES = 4096
 /** How many parent levels above the session cwd are searched for a `.git` project marker. */
 const MAX_ANCESTOR_WALK = 64
-
+/** How long a completed lookup is served from cache before the next rescan. */
+const CACHE_TTL_MS = 10_000
+/** Maximum cached lookups (one entry per distinct scan root across sessions). */
+const CACHE_MAX_ENTRIES = 32
 /** Kebab-case skill names, matching the host grammar. */
 const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
 
@@ -191,11 +198,26 @@ async function discoverSkillRoots(distro: string, linuxRoot: string, io: WslSkil
         continue
       }
       for (const entry of entries) {
-        if (!entry.isDirectory()) continue
         if (PRUNED_DIRECTORY_NAMES.has(entry.name)) continue
         if (entry.name.startsWith('.') && entry.name !== '.dsh' && entry.name !== '.agents') continue
         if (entry.name === '.dsh' || entry.name === '.agents') continue
-        next.push([posix.join(dir, entry.name), depth + 1])
+        const childPath = posix.join(dir, entry.name)
+        if (entry.isDirectory()) {
+          next.push([childPath, depth + 1])
+          continue
+        }
+        if (entry.isSymbolicLink()) {
+          // A project may be linked into the workspace via a directory
+          // symlink; follow it when the target is a directory. Symlink
+          // cycles stay bounded: every hop increments the depth (capped by
+          // MAX_SCAN_DEPTH) and the walk as a whole by MAX_VISITED_DIRECTORIES.
+          try {
+            const target = await io.stat(joinUnc(distro, childPath))
+            if (target.isDirectory()) next.push([childPath, depth + 1])
+          } catch {
+            // Dangling symlink: nothing to traverse.
+          }
+        }
       }
     }
     frontier = next
@@ -263,19 +285,33 @@ async function readSkill(path: string, io: WslSkillIo, signal?: AbortSignal): Pr
 /**
  * Parse the frontmatter subset skill files use: `---` fenced YAML with
  * `name` / `description` / `whenToUse` / `user-invocable` /
- * `disable-model-invocation`. Host-incompatible files are skipped, matching
- * the shipped provider's leniency: a bad file must not fail the catalog.
+ * `disable-model-invocation`. Single-line scalars and block scalars
+ * (`|` literal, `>` folded) are understood; anything else is skipped,
+ * matching the shipped provider's leniency: a bad file must not fail
+ * the catalog.
  */
 function parseSkillFrontmatter(raw: string, path: string): ParsedSkill | undefined {
+  // Windows editors save UTF-8 with a BOM; a leading BOM must not make the
+  // opening `---` line unmatchable and silently drop the skill.
+  if (raw.charCodeAt(0) === 0xfeff) raw = raw.slice(1)
   const firstLineEnd = raw.indexOf('\n')
   if (firstLineEnd < 0) return undefined
   if (raw.slice(0, firstLineEnd).replace(/\r$/, '') !== '---') return undefined
   const start = firstLineEnd + 1
   const closing = findFrontmatterEnd(raw, start)
   if (closing === undefined) return undefined
+  const lines = raw.slice(start, closing).split('\n')
   const fields = new Map<string, string>()
-  for (const line of raw.slice(start, closing).split('\n')) {
-    const match = /^([A-Za-z0-9-]+):\s*(.*)$/.exec(line.replace(/\r$/, ''))
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = (lines[index] ?? '').replace(/\r$/, '')
+    const block = /^([A-Za-z0-9-]+):\s*([|>])[+-]?\s*$/.exec(line)
+    if (block !== null) {
+      const value = parseBlockScalar(lines, index, block[2] === '>')
+      index = value.nextLineIndex
+      if (value.text !== '') fields.set(block[1] ?? '', value.text)
+      continue
+    }
+    const match = /^([A-Za-z0-9-]+):\s*(.*)$/.exec(line)
     if (match === null) continue
     const value = match[2]?.trim() ?? ''
     if (value !== '') fields.set(match[1] ?? '', unquote(value))
@@ -298,6 +334,40 @@ function parseSkillFrontmatter(raw: string, path: string): ParsedSkill | undefin
   }
 }
 
+/**
+ * Collect a YAML block scalar (`key: |` literal or `key: >` folded) starting
+ * at `startIndex`'s following lines. The block runs until the first
+ * non-indented, non-blank line; its common indentation is stripped.
+ * @returns the scalar text and the index of the last consumed line.
+ */
+function parseBlockScalar(
+  lines: string[],
+  startIndex: number,
+  folded: boolean,
+): { text: string; nextLineIndex: number } {
+  const collected: string[] = []
+  let indent: string | undefined
+  let index = startIndex
+  while (index + 1 < lines.length) {
+    index += 1
+    const next = (lines[index] ?? '').replace(/\r$/, '')
+    if (next.trim() === '') {
+      collected.push('')
+      continue
+    }
+    const indented = /^([ \t]+)(.*)$/.exec(next)
+    if (indented === null) {
+      index -= 1
+      break
+    }
+    indent ??= indented[1]
+    collected.push(indented[1]?.startsWith(indent) === true ? indented[2] : indented[1].replace(/^[ \t]+/, '') + indented[2])
+  }
+  while (collected.length > 0 && collected[collected.length - 1] === '') collected.pop()
+  const text = (folded ? collected.filter(line => line !== '').join(' ') : collected.join('\n')).trim()
+  return { text, nextLineIndex: index }
+}
+
 /** Locate the closing `---` line of a frontmatter block. */
 function findFrontmatterEnd(raw: string, start: number): number | undefined {
   let lineStart = start
@@ -346,15 +416,25 @@ function frontmatterBoolean(fields: Map<string, string>, key: string, dflt = fal
 /**
  * The WSL workspace skill provider. Registered on the host's `ctx.skills`
  * registry; serves only lookups whose cwd is a WSL UNC workspace path.
+ *
+ * Completed `list()` lookups are cached per scan root for CACHE_TTL_MS so
+ * repeated catalog builds over the slow 9P share do not rescan the tree;
+ * `get()` always re-reads the skill file so body edits are picked up
+ * immediately. `control.invalidate` remains reserved for host-driven
+ * invalidation; the provider self-invalidates through the TTL.
  */
 export class WslSkillsProvider {
   readonly name = 'wsl-workspace'
   private readonly control: WslSkillProviderControl
   private readonly io: WslSkillIo
+  private readonly now: () => number
+  private readonly cache = new Map<string, { expiresAt: number; candidates: WslSkillCandidate[] }>()
+  private readonly refreshing = new Set<string>()
 
-  constructor(control: WslSkillProviderControl, io: WslSkillIo = nodeSkillIo) {
+  constructor(control: WslSkillProviderControl, io: WslSkillIo = nodeSkillIo, now: () => number = Date.now) {
     this.control = control
     this.io = io
+    this.now = now
   }
 
   /**
@@ -375,14 +455,50 @@ export class WslSkillsProvider {
     // Without a `.git` ancestor the session cwd itself is the scan root (the
     // issue #10 workspace layout).
     const scanRoot = (await nearestGitAncestor(unc.distro, unc.linuxPath, this.io)) ?? unc.linuxPath
-    const roots = await discoverSkillRoots(unc.distro, scanRoot, this.io)
+    const cacheKey = `${unc.distro}\u0000${scanRoot}`
+    const cached = this.cache.get(cacheKey)
+    if (cached !== undefined) {
+      if (cached.expiresAt > this.now()) {
+        this.cache.delete(cacheKey)
+        this.cache.set(cacheKey, cached)
+        return [...cached.candidates]
+      }
+      // Expired: serve the stale copy immediately and refresh in the
+      // background, so a slow scan (e.g. a distro-root workspace) never
+      // blocks the caller. A failed refresh keeps the stale entry and is
+      // retried on the next lookup.
+      if (!this.refreshing.has(cacheKey)) {
+        this.refreshing.add(cacheKey)
+        void this.scan(cacheKey, unc.distro, scanRoot, options.signal)
+          .catch(() => { /* keep the stale entry; retried on the next lookup */ })
+          .finally(() => { this.refreshing.delete(cacheKey) })
+      }
+      return [...cached.candidates]
+    }
+    return this.scan(cacheKey, unc.distro, scanRoot, options.signal)
+  }
+
+  /**
+   * Run one discovery pass for a scan root and publish it into the cache.
+   * @returns the fresh candidates.
+   */
+  private async scan(cacheKey: string, distro: string, scanRoot: string, signal?: AbortSignal): Promise<WslSkillCandidate[]> {
+    const roots = await discoverSkillRoots(distro, scanRoot, this.io)
     const candidates: WslSkillCandidate[] = []
+    const seenSkills = new Set<string>()
     for (const root of roots) {
       const entries = await listSkillEntries(root, this.io)
       for (const entry of entries) {
-        options.signal?.throwIfAborted()
-        const parsed = await readSkill(entry.path, this.io, options.signal)
+        signal?.throwIfAborted()
+        const parsed = await readSkill(entry.path, this.io, signal)
         if (parsed === undefined) continue
+        // A project reachable through both its real path and a directory
+        // symlink yields aliasing roots whose locators differ; publish each
+        // distinct (name, description, body) once so the catalog shows no
+        // duplicates.
+        const fingerprint = `${parsed.name}\u0000${parsed.description}\u0000${parsed.content}`
+        if (seenSkills.has(fingerprint)) continue
+        seenSkills.add(fingerprint)
         candidates.push({
           name: parsed.name,
           description: parsed.description,
@@ -401,6 +517,12 @@ export class WslSkillsProvider {
         })
       }
     }
+    this.cache.set(cacheKey, { expiresAt: this.now() + CACHE_TTL_MS, candidates })
+    while (this.cache.size > CACHE_MAX_ENTRIES) {
+      const oldest = this.cache.keys().next().value
+      if (oldest === undefined) break
+      this.cache.delete(oldest)
+    }
     return candidates
   }
 

package/src/shared/paths.ts

@@ -32,10 +32,13 @@ export function parseWslUnc(raw: string): WslUncTarget | null {
   const segments = normalized.slice(2).split('/')
   const host = (segments[0] ?? '').toLowerCase()
   if (!UNC_HOSTS.includes(host)) return null
-  const distro = segments[1] ?? ''
+  // Empty segments (double separators anywhere after the host) are
+  // collapsed: `\\wsl.localhost\\Ubuntu\home` and trailing slashes must
+  // parse the same as their single-separator spelling.
+  const parts = segments.filter(segment => segment.length > 0)
+  const distro = parts[1] ?? ''
   if (distro === '') return null
-  const rest = segments.slice(2).filter(segment => segment.length > 0)
-  return { distro, linuxPath: `/${rest.join('/')}` }
+  return { distro, linuxPath: `/${parts.slice(2).join('/')}` }
 }
 
 /**

package/lib/wsl-C5_mxGPM.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"wsl-C5_mxGPM.js","names":[],"sources":["../src/shared/paths.ts","../src/shared/wsl.ts"],"sourcesContent":["/**\r\n * WSL path helpers shared by the client and host halves. Pure and\r\n * dependency-free so both planes can import them without a runtime edge.\r\n */\r\n\r\n/** WSL2 default loopback bridge host: `\\\\wsl.localhost\\<distro>\\...`. */\r\nconst WSL_LOCALHOST_HOST = 'wsl.localhost'\r\n/** Legacy WSL interop host: `\\\\wsl$\\<distro>\\...`. */\r\nconst WSL_LEGACY_HOST = 'wsl$'\r\n\r\n/** The two UNC hosts WSL exposes a distribution's filesystem under. */\r\nconst UNC_HOSTS = [WSL_LOCALHOST_HOST, WSL_LEGACY_HOST]\r\n\r\n/** One WSL workspace coordinate parsed out of a UNC path. */\r\nexport interface WslUncTarget {\r\n  /** Distro name (e.g. `Ubuntu`) as `wsl -l -q` reports it. */\r\n  readonly distro: string\r\n  /** Normalized absolute Linux path (leading `/`; no trailing slash except root). */\r\n  readonly linuxPath: string\r\n}\r\n\r\n/**\r\n * Parse a WSL UNC path into its distro and Linux path. Accepts the WSL2\r\n * `\\\\wsl.localhost\\<distro>\\<linux>` form, the legacy `\\\\wsl$\\<distro>\\<linux>`\r\n * interop form, and forward-slash spellings of either.\r\n * @param raw - candidate absolute path.\r\n * @returns the parsed target, or null when the path is not a WSL UNC.\r\n */\r\nexport function parseWslUnc(raw: string): WslUncTarget | null {\r\n  const normalized = raw.replace(/\\\\/g, '/').replace(/\\/\\/+/g, '//')\r\n  if (!normalized.startsWith('//')) return null\r\n  const segments = normalized.slice(2).split('/')\r\n  const host = (segments[0] ?? '').toLowerCase()\r\n  if (!UNC_HOSTS.includes(host)) return null\r\n  const distro = segments[1] ?? ''\r\n  if (distro === '') return null\r\n  const rest = segments.slice(2).filter(segment => segment.length > 0)\r\n  return { distro, linuxPath: `/${rest.join('/')}` }\r\n}\r\n\r\n/**\r\n * Whether a path resolves into a WSL distro through either UNC form.\r\n * @param raw - candidate absolute path.\r\n * @returns whether the path parses as a WSL UNC.\r\n */\r\nexport function isWslUnc(raw: string): boolean {\r\n  return parseWslUnc(raw) !== null\r\n}\r\n\r\n/**\r\n * Translate a WSL UNC path to the absolute Linux path a process inside the\r\n * distribution can open. Throws on non-WSL input: callers rely on this\r\n * conversion to hand paths to the Linux world, so a silent pass-through\r\n * would hand a Windows path to bash.\r\n * @param uncPath - a path {@link parseWslUnc} accepts.\r\n * @returns the absolute Linux path.\r\n */\r\nexport function uncToLinux(uncPath: string): string {\r\n  const parts = parseWslUnc(uncPath)\r\n  if (parts === null) {\r\n    throw new Error(`wsl-workspace: \"${uncPath}\" is not a WSL UNC path`)\r\n  }\r\n  return parts.linuxPath\r\n}\r\n\r\n/**\r\n * Normalize a Linux absolute path for the Host: collapse repeated slashes and\r\n * strip a trailing slash (root becomes `/`).\r\n * @param path - absolute Linux path.\r\n * @returns the normalized path.\r\n */\r\nexport function normalizeLinuxPath(path: string): string {\r\n  const collapsed = path.replace(/\\/+/g, '/')\r\n  return collapsed === '/' ? '/' : collapsed.replace(/\\/$/, '')\r\n}\r\n\r\n/**\r\n * Whether a path is an absolute, non-empty Linux path.\r\n * @param path - candidate.\r\n * @returns whether it starts with `/` and contains no NUL.\r\n */\r\nexport function isAbsoluteLinuxPath(path: string): boolean {\r\n  return path.startsWith('/') && !path.includes('\\0')\r\n}\r\n\r\n/**\r\n * Join a distro and a Linux absolute path into the WSL2 UNC form used as the\r\n * workspace identity (`\\\\wsl.localhost\\<distro>\\<linux>`, backslash segments).\r\n * @param distro - distro name.\r\n * @param linuxPath - absolute Linux path (leading `/`).\r\n * @returns the UNC path.\r\n */\r\nexport function joinUnc(distro: string, linuxPath: string): string {\r\n  if (!isAbsoluteLinuxPath(linuxPath)) {\r\n    throw new Error(`wsl-workspace: cannot map a non-absolute Linux path \"${linuxPath}\" to UNC`)\r\n  }\r\n  // Defense in depth: a distribution name with separators or dot-dirs would\r\n  // escape the `\\\\wsl.localhost\\` share structure (the host route validates\r\n  // wire-supplied names too; every other caller passes through here).\r\n  if (distro === '' || distro === '.' || distro === '..' || /[\\\\/]/.test(distro)) {\r\n    throw new Error(`wsl-workspace: invalid distribution name \"${distro}\"`)\r\n  }\r\n  const normalized = linuxPath.replace(/\\/+/g, '/').replace(/\\/$/, '')\r\n  const withoutLeading = normalized.startsWith('/') ? normalized.slice(1) : normalized\r\n  const windowsSegments = withoutLeading.replace(/\\//g, '\\\\')\r\n  const suffix = windowsSegments === '' ? '' : `\\\\${windowsSegments}`\r\n  return `\\\\\\\\wsl.localhost\\\\${distro}${suffix}`\r\n}\r\n\r\n/**\r\n * Translate a Windows drive path to the drvfs mount path WSL distributions\r\n * conventionally expose it at (`C:\\foo` → `/mnt/c/foo`). Only single-letter\r\n * drives under `/mnt` are mapped; custom mount points are out of scope.\r\n * @param path - the candidate Windows path.\r\n * @returns the `/mnt/<drive>/…` path, or `null` for non-drive paths.\r\n */\r\nexport function windowsToMntPath(path: string): string | null {\r\n  const match = /^([A-Za-z]):[\\\\/](.*)$/.exec(path)\r\n  if (match === null) return null\r\n  const rest = (match[2] ?? '').replace(/\\\\/g, '/').replace(/\\/+/g, '/').replace(/\\/$/, '')\r\n  return `/mnt/${(match[1] ?? '').toLowerCase()}${rest === '' ? '' : `/${rest}`}`\r\n}\r\n\r\n/**\r\n * Translate a `/mnt/<drive>/…` path back to its Windows drive path.\r\n * @param linuxPath - the candidate Linux path.\r\n * @returns the `X:\\…` drive path, or `null` when the path is not a drvfs mount.\r\n */\r\nexport function mntToWindowsPath(linuxPath: string): string | null {\r\n  const match = /^\\/mnt\\/([a-zA-Z])(?:\\/(.*))?$/.exec(linuxPath)\r\n  if (match === null) return null\r\n  const rest = (match[2] ?? '').replace(/\\//g, '\\\\')\r\n  return `${(match[1] ?? '').toUpperCase()}:\\\\${rest}`\r\n}\r\n\r\n/**\r\n * Canonical Windows drive path for store keys and cross-realm identity:\r\n * separators unified to `\\`, trailing separator stripped, and the WHOLE path\r\n * lowercased — Windows paths compare case-insensitively, and the workspace\r\n * registry may realpath a different casing than the caller spelled (8.3 or\r\n * on-disk casing), so the store key must collide across casings.\r\n * @param path - candidate Windows drive path.\r\n * @returns the canonical form, or `null` when not drive-shaped.\r\n */\r\nexport function canonicalWindowsPath(path: string): string | null {\r\n  const match = /^([A-Za-z]):[\\\\/](.*)$/.exec(path)\r\n  if (match === null) return null\r\n  const rest = (match[2] ?? '').replace(/[\\\\/]+/g, '\\\\').replace(/\\\\$/, '').toLowerCase()\r\n  return `${(match[1] ?? '').toLowerCase()}:\\\\${rest}`\r\n}\r\n\r\n/**\r\n * True when a value is a Windows-shaped path (drive or UNC), which is how\r\n * the shell executor decides the WSLENV `/p` translation flag: only Windows\r\n * path values need translation when they cross into the Linux process.\r\n * @param value - the environment value to classify.\r\n * @returns whether the value looks like a Windows path.\r\n */\r\nexport function isWindowsPathShaped(value: string): boolean {\r\n  return /^[A-Za-z]:[\\\\/]/.test(value) || value.startsWith('\\\\\\\\')\r\n}\r\n\r\n/** Linux username shape for `wsl.exe -u`: starts with a letter or underscore, then letters/digits/`_`/`.`/`-` (max 64). */\r\nconst WSL_USERNAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_.-]{0,63}$/\r\n\r\n/**\r\n * Whether a value is a safe Linux username for `wsl.exe -u`. The check is\r\n * strict on purpose: a value starting with `-` could be parsed as a wsl.exe\r\n * option instead of a username.\r\n * @param value - candidate username.\r\n * @returns whether it matches the Linux username shape.\r\n */\r\nexport function isValidWslUsername(value: string): boolean {\r\n  return WSL_USERNAME_PATTERN.test(value)\r\n}\r\n","/**\n * WSL discovery helpers (host side): enumerate installed distributions\n * through `wsl.exe -l -q` and read the default distribution from the Lxss\n * registry key. `wsl.exe` output is UTF-16LE on most builds, so decoding\n * sniffs for NUL bytes before choosing an encoding.\n * @module dsh-wsl-workspace/shared/wsl\n */\n\nimport { execFile, execFileSync } from 'node:child_process'\nimport { promisify } from 'node:util'\n\nconst execFileAsync = promisify(execFile)\n\n/** Executable timeout for the short discovery calls. */\nconst DISCOVERY_TIMEOUT_MS = 10_000\n\nconst LXSS_KEY = 'HKCU\\\\Software\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Lxss'\n\n/** Human text for an unknown rejection. */\nfunction messageOf(value: unknown): string {\n  return value instanceof Error ? value.message : String(value)\n}\n\n/**\n * Decode `wsl.exe -l -q` output. Newer builds emit UTF-8; most emit UTF-16LE\n * with NUL bytes interleaved — the NUL probe picks the right one.\n * @param buffer - the raw captured output.\n * @returns the decoded text.\n */\nexport function decodeWslOutput(buffer: Buffer): string {\n  return buffer.includes(0) ? buffer.toString('utf16le') : buffer.toString('utf8')\n}\n\n/**\n * List installed WSL distributions in `wsl.exe` order.\n * @param wslPath - the `wsl.exe` executable (absolute or PATH name).\n * @returns distribution names, blank lines dropped.\n */\nexport async function listDistros(wslPath = 'wsl.exe'): Promise<string[]> {\n  let stdout: Buffer\n  try {\n    const result = await execFileAsync(wslPath, ['-l', '-q'], { encoding: 'buffer', timeout: DISCOVERY_TIMEOUT_MS })\n    stdout = result.stdout as Buffer\n  } catch (error) {\n    throw new Error(`wsl-workspace: cannot list WSL distributions (${messageOf(error)}); is WSL installed?`)\n  }\n  return decodeWslOutput(stdout)\n    .split(/\\r?\\n/)\n    .map(line => line.trim())\n    .filter(line => line.length > 0)\n}\n\n/**\n * Read the user's default distribution from the Lxss registry. Non-fatal:\n * returns `undefined` when the value is absent or unreadable (the caller\n * falls back to list order).\n * @returns the default distribution name, or `undefined`.\n */\nexport async function defaultDistro(): Promise<string | undefined> {\n  try {\n    const value = await execFileAsync('reg.exe', ['query', LXSS_KEY, '/v', 'DefaultDistribution'], {\n      timeout: DISCOVERY_TIMEOUT_MS,\n    })\n    const guid = /DefaultDistribution\\s+REG_SZ\\s+(\\{[0-9a-fA-F-]+\\})/i.exec(value.stdout)?.[1]\n    if (guid === undefined) return undefined\n    const name = await execFileAsync('reg.exe', ['query', `${LXSS_KEY}\\\\${guid}`, '/v', 'DistributionName'], {\n      timeout: DISCOVERY_TIMEOUT_MS,\n    })\n    const distro = /DistributionName\\s+REG_SZ\\s+(.+)/i.exec(name.stdout)?.[1]?.trim()\n    return distro === undefined || distro === '' ? undefined : distro\n  } catch {\n    return undefined\n  }\n}\n\n/** Module-level cache for {@link defaultDistroSync} (one registry read per process). */\nlet syncDefaultResolved = false\nlet syncDefault: string | undefined\n\n/**\n * Synchronous variant of {@link defaultDistro} for executors that must\n * resolve a distribution inside a synchronous plan step. Cached after the\n * first read; non-fatal (returns `undefined` when the registry is\n * unreadable, letting the caller fail loud with its own message).\n * @returns the default distribution name, or `undefined`.\n */\nexport function defaultDistroSync(): string | undefined {\n  if (syncDefaultResolved) return syncDefault\n  syncDefaultResolved = true\n  try {\n    const value = execFileSync('reg.exe', ['query', LXSS_KEY, '/v', 'DefaultDistribution'], {\n      timeout: DISCOVERY_TIMEOUT_MS,\n    })\n    const guid = /DefaultDistribution\\s+REG_SZ\\s+(\\{[0-9a-fA-F-]+\\})/i.exec(String(value))?.[1]\n    if (guid === undefined) return undefined\n    const name = execFileSync('reg.exe', ['query', `${LXSS_KEY}\\\\${guid}`, '/v', 'DistributionName'], {\n      timeout: DISCOVERY_TIMEOUT_MS,\n    })\n    const distro = /DistributionName\\s+REG_SZ\\s+(.+)/i.exec(String(name))?.[1]?.trim()\n    syncDefault = distro === undefined || distro === '' ? undefined : distro\n  } catch {\n    syncDefault = undefined\n  }\n  return syncDefault\n}\n"],"mappings":"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"}