@iowarp/clio-coder 0.4.6 → 0.4.7

package/dist/{chunk-4U4TKZFR.js → chunk-WT5TRMO4.js}

@@ -10,19 +10,13 @@ import {
 } from "./chunk-77CZRFTE.js";
 import {
   credentialsPresent
-} from "./chunk-J2FYEQ5L.js";
-import {
-  readSettings
-} from "./chunk-WNGF5AJX.js";
-import {
-  warnLegacyNaming
-} from "./chunk-DVNAPPXU.js";
+} from "./chunk-VTYHHQ57.js";
 import {
   getSharedBus
 } from "./chunk-B5ZTR6KZ.js";
 import {
   BusChannels
-} from "./chunk-HL26ADLH.js";
+} from "./chunk-6CB2IL4N.js";
 import {
   CLIO_CONTEXT_WINDOW_WARN_BELOW,
   CLIO_MIN_CONTEXT_WINDOW,
@@ -39,29 +33,17 @@ import {
   registerBuiltinRuntimes,
   requestLmStudioJson,
   resolveLmStudioInstance
-} from "./chunk-WV6TDAPN.js";
-import {
-  sleep
-} from "./chunk-6EXUUOSN.js";
+} from "./chunk-SELG4SUR.js";
 import {
   listKnownModelsForRuntime
-} from "./chunk-HHVJNVUJ.js";
+} from "./chunk-KS7ETA3P.js";
 import {
   authNotRequiredStatus,
   openAuthStorage,
   registerClioOAuthProviders,
   resolveAuthTarget,
   targetRequiresAuth
-} from "./chunk-HXHFDHB6.js";
-import {
-  withStateFileLock
-} from "./chunk-2QPI3TR3.js";
-import {
-  require_dist
-} from "./chunk-B5GGDIHT.js";
-import {
-  safeResourceWrite
-} from "./chunk-ZZFWWYLX.js";
+} from "./chunk-6TAATXXH.js";
 import {
   getRuntimeRegistry
 } from "./chunk-SRCEQKQS.js";
@@ -77,6 +59,24 @@ import {
   ensurePiAiRegistered,
   registerEngineApiProvider
 } from "./chunk-5CMARGPF.js";
+import {
+  readSettings
+} from "./chunk-4QKAITQT.js";
+import {
+  warnLegacyNaming
+} from "./chunk-DVNAPPXU.js";
+import {
+  sleep
+} from "./chunk-6EXUUOSN.js";
+import {
+  withStateFileLock
+} from "./chunk-DVJL77SO.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  safeResourceWrite
+} from "./chunk-ZZFWWYLX.js";
 import {
   clioCacheDir,
   clioConfigDir,
@@ -3751,6 +3751,22 @@ function stripThinkingFromContext(context) {
     })
   };
 }
+function preserveInterruptedReasoning(context, model, resolved) {
+  if (!resolved.thinking.thinkingActive || model.compat?.requiresThinkingAsText) return context;
+  return {
+    ...context,
+    messages: context.messages.map((message) => {
+      if (message.role !== "assistant" || message.stopReason !== "length" || message.provider !== model.provider || message.api !== model.api || message.model !== model.id || message.content.length === 0 || !message.content.every(
+        (block) => block.type === "thinking" && !block.redacted && block.thinking.trim().length > 0 && ["reasoning", "reasoning_content", "reasoning_text"].includes(block.thinkingSignature ?? "")
+      ))
+        return message;
+      return {
+        ...message,
+        content: [...message.content, { type: "text", text: "Response interrupted before its answer." }]
+      };
+    })
+  };
+}
 function withStrippedPartial(event) {
   if (!("partial" in event)) return event;
   return { ...event, partial: stripThinkingFromMessage(event.partial) };
@@ -4232,7 +4248,11 @@ var openAICompletionsApiProvider = {
                       ...options?.apiKey !== void 0 ? { apiKey: options.apiKey } : {},
                       ...options?.signal !== void 0 ? { signal: options.signal } : {}
                     },
-                    (requestModel) => piOpenAICompletions.stream(requestModel, effectiveContext, capturedOptions)
+                    (requestModel) => piOpenAICompletions.stream(
+                      requestModel,
+                      preserveInterruptedReasoning(effectiveContext, requestModel, resolved),
+                      capturedOptions
+                    )
                   )
                 )
               ),
@@ -4271,7 +4291,11 @@ var openAICompletionsApiProvider = {
                       ...options?.apiKey !== void 0 ? { apiKey: options.apiKey } : {},
                       ...options?.signal !== void 0 ? { signal: options.signal } : {}
                     },
-                    (requestModel) => piOpenAICompletions.streamSimple(requestModel, effectiveContext, capturedOptions)
+                    (requestModel) => piOpenAICompletions.streamSimple(
+                      requestModel,
+                      preserveInterruptedReasoning(effectiveContext, requestModel, resolved),
+                      capturedOptions
+                    )
                   )
                 )
               ),
@@ -5004,6 +5028,7 @@ export {
   residencyTargetKey,
   setGlobalDefaultMaxOutputTokens,
   resolveReservedOutputTokens,
+  estimateInputTokensFromContext,
   canonicalEndpointKey,
   endpointLabel,
   endpointCapacityFor,
@@ -5049,4 +5074,4 @@ export {
   resolveCostProvenance2 as resolveCostProvenance,
   ProvidersDomainModule
 };
-//# sourceMappingURL=chunk-4U4TKZFR.js.map
+//# sourceMappingURL=chunk-WT5TRMO4.js.map

package/dist/{chunk-XWMSPJYN.js → chunk-WURGVOZJ.js}

@@ -1,16 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   discoverAgentRecipes
-} from "./chunk-VAHLPXPY.js";
+} from "./chunk-4UHVS5T7.js";
 import {
-  assertAgentIdNamespace
-} from "./chunk-3UW3KU4A.js";
+  BusChannels
+} from "./chunk-6CB2IL4N.js";
 import {
   normalizeAgentSpec
-} from "./chunk-OQM5IVJY.js";
-import {
-  BusChannels
-} from "./chunk-HL26ADLH.js";
+} from "./chunk-34XHRVKG.js";
 import {
   init_esm_shims
 } from "./chunk-ECBHH7LU.js";
@@ -20,36 +17,82 @@ init_esm_shims();
 
 // src/domains/agents/extension.ts
 init_esm_shims();
+
+// src/domains/config/agent-namespace.ts
+init_esm_shims();
+function assertAgentIdNamespace(nativeRecipes, acpDelegates) {
+  const native = new Set(nativeRecipes.map((recipe) => recipe.id));
+  const collision = acpDelegates.find((delegate) => native.has(delegate.id));
+  if (collision !== void 0) {
+    throw new Error(
+      `agent id collision: native recipe '${collision.id}' and ACP delegation agent '${collision.id}' share one namespace`
+    );
+  }
+}
+
+// src/domains/agents/extension.ts
 function createAgentsBundle(_context) {
   let recipes = [];
   let specs = [];
   let diagnostics = [];
   let revision = 0;
+  let rediscoveryPending = false;
+  let attemptedRecipes = null;
   function discover() {
+    attemptedRecipes = null;
     const nextDiagnostics = [];
     const merged = discoverAgentRecipes(process.cwd(), nextDiagnostics);
+    attemptedRecipes = merged;
     const config = _context.getContract("config");
     assertAgentIdNamespace(merged, config?.get()?.integrations.externalAgents?.entries ?? []);
     recipes = merged;
     specs = recipes.map(normalizeAgentSpec);
     diagnostics = nextDiagnostics;
     revision += 1;
+    rediscoveryPending = false;
   }
   let unsubscribeExtensionsReload = null;
   const extension = {
     async start() {
       discover();
-      unsubscribeExtensionsReload = _context.bus.on(BusChannels.ExtensionsReloaded, (payload) => {
-        if (payload?.changed !== true) return;
+      const onResourceReload = (payload) => {
+        if (!rediscoveryPending && payload?.changed !== true) return;
         try {
           discover();
         } catch (error) {
+          rediscoveryPending = true;
+          recipes = attemptedRecipes ?? recipes.filter((recipe) => recipe.source === "builtin");
+          let conflictingIds = /* @__PURE__ */ new Set();
+          try {
+            const config = _context.getContract("config");
+            conflictingIds = new Set((config?.get()?.integrations.externalAgents?.entries ?? []).map((agent) => agent.id));
+          } catch {
+            recipes = recipes.filter((recipe) => recipe.source === "builtin");
+          }
+          recipes = recipes.filter((recipe) => recipe.source !== "plugin" && !conflictingIds.has(recipe.id));
+          specs = recipes.map(normalizeAgentSpec);
+          diagnostics = [
+            ...diagnostics,
+            {
+              source: "project",
+              filepath: process.cwd(),
+              message: `recipe reload failed; package recipes withdrawn until retry: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ].slice(-100);
+          revision += 1;
           process.stderr.write(
-            `[clio-coder:agents] rediscovery after extension reload failed: ${error instanceof Error ? error.message : String(error)}
+            `[clio-coder:agents] rediscovery after resource reload failed: ${error instanceof Error ? error.message : String(error)}
 `
           );
         }
-      });
+      };
+      const unsubscribe = [
+        _context.bus.on(BusChannels.ExtensionsReloaded, onResourceReload),
+        _context.bus.on(BusChannels.PluginsReloaded, onResourceReload)
+      ];
+      unsubscribeExtensionsReload = () => {
+        for (const stop of unsubscribe) stop();
+      };
     },
     async stop() {
       unsubscribeExtensionsReload?.();
@@ -144,6 +187,7 @@ var AgentsDomainModule = {
 };
 
 export {
+  assertAgentIdNamespace,
   AgentsDomainModule
 };
-//# sourceMappingURL=chunk-XWMSPJYN.js.map
+//# sourceMappingURL=chunk-WURGVOZJ.js.map

package/dist/{chunk-7WUZEB2M.js → chunk-XR3XJN2M.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-W2RJEH6Q.js";
 import {
   withStateFileLock
-} from "./chunk-2QPI3TR3.js";
+} from "./chunk-DVJL77SO.js";
 import {
   init_esm_shims
 } from "./chunk-ECBHH7LU.js";
@@ -162,4 +162,4 @@ export {
   buildCodewikiCandidate,
   drainCodewikiWrites
 };
-//# sourceMappingURL=chunk-7WUZEB2M.js.map
+//# sourceMappingURL=chunk-XR3XJN2M.js.map

package/dist/chunk-XW2UZICE.js

@@ -0,0 +1,372 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  getVersionInfo
+} from "./chunk-GD55RTIW.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/extensions/compatibility.ts
+init_esm_shims();
+var MAX_RANGE_CHARS = 256;
+var NUMERIC = "(?:0|[1-9]\\d*)";
+var IDENTIFIER = "[0-9A-Za-z-]+";
+var VERSION_RE = new RegExp(
+  `^v?(${NUMERIC})\\.(${NUMERIC})\\.(${NUMERIC})(?:-(${IDENTIFIER}(?:\\.${IDENTIFIER})*))?(?:\\+${IDENTIFIER}(?:\\.${IDENTIFIER})*)?$`
+);
+var PARTIAL_RE = new RegExp(
+  `^v?(${NUMERIC}|[xX*])(?:\\.(${NUMERIC}|[xX*]))?(?:\\.(${NUMERIC}|[xX*]))?(?:-(${IDENTIFIER}(?:\\.${IDENTIFIER})*))?(?:\\+${IDENTIFIER}(?:\\.${IDENTIFIER})*)?$`
+);
+function prerelease(value) {
+  if (value === void 0) return [];
+  const out = [];
+  for (const identifier of value.split(".")) {
+    if (identifier.length === 0) return null;
+    if (/^\d+$/u.test(identifier)) {
+      if (identifier.length > 1 && identifier.startsWith("0")) return null;
+      const parsed = Number(identifier);
+      if (!Number.isSafeInteger(parsed)) return null;
+      out.push(parsed);
+    } else {
+      out.push(identifier);
+    }
+  }
+  return out;
+}
+function parseSemVer(value) {
+  const match = VERSION_RE.exec(value);
+  if (match === null) return null;
+  const parsedPrerelease = prerelease(match[4]);
+  if (parsedPrerelease === null) return null;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
+  if (![major, minor, patch].every(Number.isSafeInteger)) return null;
+  return { major, minor, patch, prerelease: parsedPrerelease };
+}
+function isSemanticVersion(value) {
+  return typeof value === "string" && value.length <= MAX_RANGE_CHARS && /^[0-9]/.test(value) && parseSemVer(value) !== null;
+}
+function parsePart(value) {
+  if (value === void 0 || value === "x" || value === "X" || value === "*") return null;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
+function parsePartial(value) {
+  const match = PARTIAL_RE.exec(value);
+  if (match === null) return null;
+  for (const part of match.slice(1, 4)) {
+    if (part === void 0 || part === "x" || part === "X" || part === "*") continue;
+    if (!Number.isSafeInteger(Number(part))) return null;
+  }
+  const major = parsePart(match[1]);
+  const minor = parsePart(match[2]);
+  const patch = parsePart(match[3]);
+  if (major === null && (match[2] !== void 0 || match[3] !== void 0) || minor === null && match[3] !== void 0) {
+    return null;
+  }
+  const parsedPrerelease = prerelease(match[4]);
+  if (parsedPrerelease === null) return null;
+  if (parsedPrerelease.length > 0 && (major === null || minor === null || patch === null)) return null;
+  return { major, minor, patch, prerelease: parsedPrerelease };
+}
+function compareIdentifiers(left, right) {
+  if (left === right) return 0;
+  if (typeof left === "number" && typeof right === "number") return left < right ? -1 : 1;
+  if (typeof left === "number") return -1;
+  if (typeof right === "number") return 1;
+  return left < right ? -1 : 1;
+}
+function compare(left, right) {
+  for (const key of ["major", "minor", "patch"]) {
+    if (left[key] !== right[key]) return left[key] < right[key] ? -1 : 1;
+  }
+  if (left.prerelease.length === 0 || right.prerelease.length === 0) {
+    if (left.prerelease.length === right.prerelease.length) return 0;
+    return left.prerelease.length === 0 ? 1 : -1;
+  }
+  const length = Math.max(left.prerelease.length, right.prerelease.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = left.prerelease[index];
+    const rightPart = right.prerelease[index];
+    if (leftPart === void 0 || rightPart === void 0) {
+      if (leftPart === rightPart) return 0;
+      return leftPart === void 0 ? -1 : 1;
+    }
+    const order = compareIdentifiers(leftPart, rightPart);
+    if (order !== 0) return order;
+  }
+  return 0;
+}
+function floor(partial) {
+  return {
+    major: partial.major ?? 0,
+    minor: partial.minor ?? 0,
+    patch: partial.patch ?? 0,
+    prerelease: partial.prerelease
+  };
+}
+function nextWildcard(partial) {
+  if (partial.major === null) return null;
+  if (partial.minor === null) return { major: partial.major + 1, minor: 0, patch: 0, prerelease: [] };
+  if (partial.patch === null) return { major: partial.major, minor: partial.minor + 1, patch: 0, prerelease: [] };
+  return null;
+}
+function lowerBound(version, inclusive) {
+  return (candidate) => inclusive ? compare(candidate, version) >= 0 : compare(candidate, version) > 0;
+}
+function upperBound(version, inclusive) {
+  return (candidate) => inclusive ? compare(candidate, version) <= 0 : compare(candidate, version) < 0;
+}
+function core(version) {
+  return `${version.major}.${version.minor}.${version.patch}`;
+}
+function predicatesForToken(token) {
+  const match = /^(<=|>=|<|>|=|~|\^)?(.+)$/u.exec(token);
+  if (match === null) return null;
+  const operator = match[1] ?? "";
+  const partial = parsePartial(match[2] ?? "");
+  if (partial === null) return null;
+  const base = floor(partial);
+  const wildcardUpper = nextWildcard(partial);
+  const prereleaseCore = partial.prerelease.length > 0 ? core(base) : null;
+  if (operator === "" || operator === "=") {
+    if (partial.major === null) return { predicates: [], prereleaseCore };
+    if (wildcardUpper !== null) {
+      return { predicates: [lowerBound(base, true), upperBound(wildcardUpper, false)], prereleaseCore };
+    }
+    return { predicates: [(candidate) => compare(candidate, base) === 0], prereleaseCore };
+  }
+  if (operator === ">=") return { predicates: [lowerBound(base, true)], prereleaseCore };
+  if (operator === "<") return { predicates: [upperBound(base, false)], prereleaseCore };
+  if (operator === ">") {
+    return {
+      predicates: [wildcardUpper === null ? lowerBound(base, false) : lowerBound(wildcardUpper, true)],
+      prereleaseCore
+    };
+  }
+  if (operator === "<=") {
+    return {
+      predicates: [wildcardUpper === null ? upperBound(base, true) : upperBound(wildcardUpper, false)],
+      prereleaseCore
+    };
+  }
+  if (partial.major === null) return { predicates: [], prereleaseCore };
+  if (operator === "~") {
+    const upper2 = partial.minor === null ? { major: partial.major + 1, minor: 0, patch: 0, prerelease: [] } : { major: partial.major, minor: partial.minor + 1, patch: 0, prerelease: [] };
+    return { predicates: [lowerBound(base, true), upperBound(upper2, false)], prereleaseCore };
+  }
+  const upper = partial.major > 0 ? { major: partial.major + 1, minor: 0, patch: 0, prerelease: [] } : partial.minor === null ? { major: 1, minor: 0, patch: 0, prerelease: [] } : (partial.minor ?? 0) > 0 ? { major: 0, minor: (partial.minor ?? 0) + 1, patch: 0, prerelease: [] } : partial.patch === null ? { major: 0, minor: 1, patch: 0, prerelease: [] } : { major: 0, minor: 0, patch: (partial.patch ?? 0) + 1, prerelease: [] };
+  return { predicates: [lowerBound(base, true), upperBound(upper, false)], prereleaseCore };
+}
+function predicatesForSet(raw) {
+  const hyphen = /^(\S+)\s+-\s+(\S+)$/u.exec(raw);
+  if (hyphen !== null) {
+    const left = parsePartial(hyphen[1] ?? "");
+    const right = parsePartial(hyphen[2] ?? "");
+    if (left === null || right === null || left.major === null || right.major === null) return null;
+    const rightUpper = nextWildcard(right);
+    return {
+      predicates: [
+        lowerBound(floor(left), true),
+        rightUpper === null ? upperBound(floor(right), true) : upperBound(rightUpper, false)
+      ],
+      prereleaseCores: new Set(
+        [
+          left.prerelease.length > 0 ? core(floor(left)) : null,
+          right.prerelease.length > 0 ? core(floor(right)) : null
+        ].filter((entry) => entry !== null)
+      )
+    };
+  }
+  const normalized = raw.replace(/(<=|>=|<|>|=|~|\^)\s+/gu, "$1");
+  const tokens = normalized.split(/\s+/u).filter((entry) => entry.length > 0);
+  if (tokens.length === 0) return null;
+  const predicates = [];
+  const prereleaseCores = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    const parsed = predicatesForToken(token);
+    if (parsed === null) return null;
+    predicates.push(...parsed.predicates);
+    if (parsed.prereleaseCore !== null) prereleaseCores.add(parsed.prereleaseCore);
+  }
+  return { predicates, prereleaseCores };
+}
+function parseRange(range) {
+  const trimmed = range.trim();
+  if (trimmed.length === 0 || trimmed.length > MAX_RANGE_CHARS) return null;
+  const sets = trimmed.split("||");
+  if (sets.some((set) => set.trim().length === 0)) return null;
+  const parsed = sets.map((set) => predicatesForSet(set.trim()));
+  return parsed.every((set) => set !== null) ? parsed : null;
+}
+function isValidSemVerRange(range) {
+  return parseRange(range) !== null;
+}
+function satisfiesSemVerRange(version, range) {
+  const candidate = parseSemVer(version);
+  const sets = parseRange(range);
+  if (candidate === null || sets === null) return false;
+  return sets.some((set) => {
+    if (candidate.prerelease.length > 0 && !set.prereleaseCores.has(core(candidate))) return false;
+    return set.predicates.every((predicate) => predicate(candidate));
+  });
+}
+function evaluateClioCompatibility(range, runningVersion = getVersionInfo().clio) {
+  const rangeValid = isValidSemVerRange(range);
+  return {
+    rangeValid,
+    satisfied: rangeValid && satisfiesSemVerRange(runningVersion, range),
+    runningVersion
+  };
+}
+
+// src/domains/extensions/integrity.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  lstatSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  readlinkSync,
+  realpathSync
+} from "node:fs";
+import path from "node:path";
+function contained(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+function digestFrame(hash, kind, relativePath, payload) {
+  const header = Buffer.from(
+    `${kind}\0${relativePath.replaceAll(path.sep, "/")}\0${payload?.byteLength ?? 0}\0`,
+    "utf8"
+  );
+  hash.update(header);
+  if (payload) hash.update(payload);
+  hash.update("\0");
+}
+function sameFileState(left, right) {
+  return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode && left.nlink === right.nlink && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+function readStableRegularFile(filePath, inspected) {
+  const fd = openSync(filePath, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const opened = fstatSync(fd);
+    if (!opened.isFile() || opened.nlink !== 1 || !sameFileState(inspected, opened)) {
+      throw new Error(`extension file changed while being opened: ${filePath}`);
+    }
+    const payload = readFileSync(fd);
+    if (!sameFileState(opened, fstatSync(fd))) {
+      throw new Error(`extension file changed while being hashed: ${filePath}`);
+    }
+    return payload;
+  } finally {
+    closeSync(fd);
+  }
+}
+function readStableContainedLink(linkPath, inspected, canonicalRoot) {
+  const canonicalTarget = realpathSync(linkPath);
+  if (!contained(canonicalRoot, canonicalTarget)) {
+    throw new Error(`symbolic link escapes the extension root: ${linkPath}`);
+  }
+  const target = readlinkSync(linkPath);
+  const after = lstatSync(linkPath);
+  if (!after.isSymbolicLink() || !sameFileState(inspected, after)) {
+    throw new Error(`symbolic link changed while being hashed: ${linkPath}`);
+  }
+  const canonicalAfter = realpathSync(linkPath);
+  if (canonicalAfter !== canonicalTarget || !contained(canonicalRoot, canonicalAfter)) {
+    throw new Error(`symbolic link changed or escapes the extension root: ${linkPath}`);
+  }
+  return Buffer.from(target, "utf8");
+}
+function assertStableDirectory(directoryPath, inspected, canonicalDirectory, canonicalRoot, expectedEntries) {
+  const after = lstatSync(directoryPath);
+  if (!after.isDirectory() || !sameFileState(inspected, after)) {
+    throw new Error(`extension directory changed while being hashed: ${directoryPath}`);
+  }
+  const canonicalAfter = realpathSync(directoryPath);
+  if (canonicalAfter !== canonicalDirectory || !contained(canonicalRoot, canonicalAfter)) {
+    throw new Error(`extension directory changed or escapes the extension root: ${directoryPath}`);
+  }
+  if (expectedEntries !== void 0) {
+    const currentEntries = readdirSync(directoryPath).sort();
+    if (currentEntries.length !== expectedEntries.length || currentEntries.some((entry, index) => entry !== expectedEntries[index])) {
+      throw new Error(`extension directory entries changed while being hashed: ${directoryPath}`);
+    }
+  }
+}
+function readStableDirectory(directoryPath, inspected, canonicalRoot) {
+  const canonicalDirectory = realpathSync(directoryPath);
+  if (!contained(canonicalRoot, canonicalDirectory)) {
+    throw new Error(`extension directory escapes the extension root: ${directoryPath}`);
+  }
+  const entries = readdirSync(directoryPath).sort();
+  assertStableDirectory(directoryPath, inspected, canonicalDirectory, canonicalRoot);
+  return { canonicalDirectory, entries };
+}
+function extensionContentDigestWithCapture(root, options = {}) {
+  const resolvedRoot = path.resolve(root);
+  const rootStat = lstatSync(resolvedRoot);
+  if (rootStat.isSymbolicLink()) {
+    throw new Error(`extension root must be a directory, not a symbolic link: ${resolvedRoot}`);
+  }
+  if (!rootStat.isDirectory()) {
+    throw new Error(`extension root must be a directory: ${resolvedRoot}`);
+  }
+  const canonicalRoot = realpathSync(resolvedRoot);
+  const canonicalizedRootStat = lstatSync(resolvedRoot);
+  if (!canonicalizedRootStat.isDirectory() || !sameFileState(rootStat, canonicalizedRootStat)) {
+    throw new Error(`extension root changed while being canonicalized: ${resolvedRoot}`);
+  }
+  const hash = createHash("sha256");
+  const requested = new Set((options.capture ?? []).map((entry) => entry.replaceAll(path.sep, "/")));
+  const captured = /* @__PURE__ */ new Map();
+  const visit = (absolutePath, relativePath) => {
+    const stat = lstatSync(absolutePath);
+    if (stat.isSymbolicLink()) {
+      if (relativePath === "") {
+        throw new Error(`extension root changed to a symbolic link while being hashed: ${absolutePath}`);
+      }
+      digestFrame(hash, "link", relativePath, readStableContainedLink(absolutePath, stat, canonicalRoot));
+      return;
+    }
+    if (stat.isDirectory()) {
+      digestFrame(hash, "directory", relativePath);
+      const { canonicalDirectory, entries } = readStableDirectory(absolutePath, stat, canonicalRoot);
+      for (const entry of entries) {
+        visit(path.join(absolutePath, entry), relativePath ? path.join(relativePath, entry) : entry);
+      }
+      assertStableDirectory(absolutePath, stat, canonicalDirectory, canonicalRoot, entries);
+      return;
+    }
+    if (stat.isFile()) {
+      if (stat.nlink !== 1) {
+        throw new Error(`hard-linked file is unsupported in an extension: ${absolutePath}`);
+      }
+      const payload = readStableRegularFile(absolutePath, stat);
+      digestFrame(hash, "file", relativePath, payload);
+      const key = relativePath.replaceAll(path.sep, "/");
+      if (requested.has(key)) captured.set(key, payload);
+      return;
+    }
+    throw new Error(`unsupported filesystem entry in extension: ${absolutePath}`);
+  };
+  visit(resolvedRoot, "");
+  return { digest: hash.digest("hex"), captured };
+}
+function extensionContentDigest(root) {
+  return extensionContentDigestWithCapture(root).digest;
+}
+
+export {
+  isSemanticVersion,
+  evaluateClioCompatibility,
+  extensionContentDigestWithCapture,
+  extensionContentDigest
+};
+//# sourceMappingURL=chunk-XW2UZICE.js.map