@iowarp/clio-coder 0.4.1 → 0.4.2

package/dist/chunk-77QIVUZB.js

@@ -0,0 +1,1334 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  getVersionInfo
+} from "./chunk-XPLRXC72.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  clioConfigDir
+} from "./chunk-BYP5D4HI.js";
+import {
+  safeResourceWrite
+} from "./chunk-WEPFGWHJ.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/extensions/discovery.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+
+// 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 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/discovery.ts
+var MANIFEST_NAMES = ["clio-coder-extension.yaml", "clio-coder-extension.yml", "clio-coder-extension.json"];
+var MANIFEST_KEYS = /* @__PURE__ */ new Set([
+  "manifestVersion",
+  "id",
+  "name",
+  "version",
+  "description",
+  "resources",
+  "tools",
+  "settings",
+  "compatibility"
+]);
+var RESOURCE_KEYS = /* @__PURE__ */ new Set(["skills", "prompts", "agents", "fleets", "themes"]);
+var COMPATIBILITY_KEYS = /* @__PURE__ */ new Set(["clio"]);
+function compareNames(a, b) {
+  return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function trimString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function validateId(id) {
+  if (id.length > 80) return "id exceeds 80 characters";
+  if (!/^[a-z0-9][a-z0-9._-]*[a-z0-9]$/.test(id)) {
+    return "id must use lowercase letters, numbers, dots, underscores, or hyphens and start/end alphanumeric";
+  }
+  return null;
+}
+function readJsonOrYaml(filePath) {
+  const raw = readFileSync(filePath, "utf8");
+  if (filePath.endsWith(".json")) return JSON.parse(raw);
+  return (0, import_yaml.parse)(raw);
+}
+function rejectUnknownKeys(value, allowed, label, manifestPath, diagnostics) {
+  for (const key of Object.keys(value).sort()) {
+    if (!allowed.has(key)) {
+      diagnostics.push({ type: "error", message: `unknown ${label} key '${key}'`, path: manifestPath });
+    }
+  }
+}
+function normalizeResources(value, manifestPath, diagnostics) {
+  if (value === void 0) return {};
+  if (!isRecord(value)) {
+    diagnostics.push({ type: "error", message: "resources must be an object", path: manifestPath });
+    return {};
+  }
+  rejectUnknownKeys(value, RESOURCE_KEYS, "resources", manifestPath, diagnostics);
+  const out = {};
+  for (const kind of RESOURCE_KEYS) {
+    if (value[kind] === void 0) continue;
+    const resourcePath = trimString(value[kind]);
+    if (!resourcePath) {
+      diagnostics.push({
+        type: "error",
+        message: `resources.${kind} must be a non-empty string`,
+        path: manifestPath
+      });
+      continue;
+    }
+    out[kind] = resourcePath;
+  }
+  return out;
+}
+function contained(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+function validateResourceTree(root, resourcePath, kind, diagnostics) {
+  if (path.isAbsolute(resourcePath)) {
+    diagnostics.push({ type: "error", message: `resources.${kind} must be relative`, path: resourcePath });
+    return;
+  }
+  const resolvedRoot = path.resolve(root);
+  const resolved = path.resolve(resolvedRoot, resourcePath);
+  if (!contained(resolvedRoot, resolved) || resolved === resolvedRoot) {
+    diagnostics.push({ type: "error", message: `resources.${kind} escapes the extension root`, path: resourcePath });
+    return;
+  }
+  let canonicalRoot;
+  let canonicalResource;
+  try {
+    canonicalRoot = realpathSync(resolvedRoot);
+    canonicalResource = realpathSync(resolved);
+    if (!statSync(resolved).isDirectory()) {
+      diagnostics.push({ type: "error", message: `resources.${kind} is not a directory`, path: resolved });
+      return;
+    }
+  } catch (error) {
+    diagnostics.push({
+      type: "error",
+      message: `resources.${kind} cannot be resolved: ${error instanceof Error ? error.message : String(error)}`,
+      path: resolved
+    });
+    return;
+  }
+  if (!contained(canonicalRoot, canonicalResource)) {
+    diagnostics.push({ type: "error", message: `resources.${kind} escapes through a symbolic link`, path: resolved });
+    return;
+  }
+  const pending = [resolved];
+  while (pending.length > 0) {
+    const directory = pending.pop();
+    if (!directory) continue;
+    for (const entry of readdirSync(directory, { withFileTypes: true }).sort(compareNames)) {
+      const candidate = path.join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        try {
+          const canonicalTarget = realpathSync(candidate);
+          if (!contained(canonicalRoot, canonicalTarget)) {
+            diagnostics.push({
+              type: "error",
+              message: `resources.${kind} contains an escaping symbolic link`,
+              path: candidate
+            });
+            continue;
+          }
+          const targetStat = statSync(candidate);
+          if (!targetStat.isDirectory() && !targetStat.isFile()) {
+            diagnostics.push({
+              type: "error",
+              message: `resources.${kind} contains a symbolic link to an unsupported filesystem entry`,
+              path: candidate
+            });
+          } else if (targetStat.isFile() && targetStat.nlink !== 1) {
+            diagnostics.push({
+              type: "error",
+              message: `resources.${kind} contains a symbolic link to a hard-linked file`,
+              path: candidate
+            });
+          }
+        } catch (error) {
+          diagnostics.push({
+            type: "error",
+            message: `resources.${kind} contains an unresolved symbolic link: ${error instanceof Error ? error.message : String(error)}`,
+            path: candidate
+          });
+        }
+      } else if (entry.isDirectory()) {
+        pending.push(candidate);
+      } else if (entry.isFile()) {
+        try {
+          if (lstatSync(candidate).nlink !== 1) {
+            diagnostics.push({
+              type: "error",
+              message: `resources.${kind} contains a hard-linked file`,
+              path: candidate
+            });
+          }
+        } catch (error) {
+          diagnostics.push({
+            type: "error",
+            message: `resources.${kind} entry could not be inspected: ${error instanceof Error ? error.message : String(error)}`,
+            path: candidate
+          });
+        }
+      } else {
+        diagnostics.push({
+          type: "error",
+          message: `resources.${kind} contains an unsupported filesystem entry`,
+          path: candidate
+        });
+      }
+    }
+  }
+}
+function validateResourceRoots(root, resources, diagnostics) {
+  for (const [kind, resourcePath] of Object.entries(resources)) {
+    if (resourcePath) validateResourceTree(root, resourcePath, kind, diagnostics);
+  }
+}
+function stringArray(value, field, manifestPath, diagnostics) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) {
+    diagnostics.push({ type: "error", message: `${field} must be an array of non-empty strings`, path: manifestPath });
+    return void 0;
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    const parsed = trimString(entry);
+    if (!parsed) {
+      diagnostics.push({ type: "error", message: `${field} must contain only non-empty strings`, path: manifestPath });
+      continue;
+    }
+    if (seen.has(parsed)) {
+      diagnostics.push({ type: "error", message: `${field} contains duplicate entry '${parsed}'`, path: manifestPath });
+      continue;
+    }
+    seen.add(parsed);
+    out.push(parsed);
+  }
+  return out.length > 0 ? out : void 0;
+}
+function parseExtensionManifest(value, manifestPath) {
+  const diagnostics = [];
+  if (!isRecord(value)) {
+    return { diagnostics: [{ type: "error", message: "extension manifest must be an object", path: manifestPath }] };
+  }
+  rejectUnknownKeys(value, MANIFEST_KEYS, "manifest", manifestPath, diagnostics);
+  if (value.manifestVersion !== 1) {
+    diagnostics.push({ type: "error", message: "manifestVersion must be 1", path: manifestPath });
+  }
+  const id = trimString(value.id);
+  const name = trimString(value.name) ?? id;
+  const version = trimString(value.version);
+  const description = trimString(value.description);
+  if (!id) diagnostics.push({ type: "error", message: "id is required", path: manifestPath });
+  else {
+    const idError = validateId(id);
+    if (idError) diagnostics.push({ type: "error", message: idError, path: manifestPath });
+  }
+  if (!version) diagnostics.push({ type: "error", message: "version is required", path: manifestPath });
+  if (!description) diagnostics.push({ type: "error", message: "description is required", path: manifestPath });
+  const resources = normalizeResources(value.resources, manifestPath, diagnostics);
+  const tools = stringArray(value.tools, "tools", manifestPath, diagnostics);
+  const settings = stringArray(value.settings, "settings", manifestPath, diagnostics);
+  let compatibility;
+  if (value.compatibility !== void 0) {
+    if (!isRecord(value.compatibility)) {
+      diagnostics.push({ type: "error", message: "compatibility must be an object", path: manifestPath });
+    } else {
+      rejectUnknownKeys(value.compatibility, COMPATIBILITY_KEYS, "compatibility", manifestPath, diagnostics);
+      if (!("clio" in value.compatibility)) {
+        compatibility = {};
+      } else {
+        const range = trimString(value.compatibility.clio);
+        if (range === void 0) {
+          diagnostics.push({
+            type: "error",
+            message: "compatibility.clio must be a non-empty semver range",
+            path: manifestPath
+          });
+        } else {
+          const evaluation = evaluateClioCompatibility(range);
+          if (!evaluation.rangeValid) {
+            diagnostics.push({
+              type: "error",
+              message: `extension ${id ?? "<unknown>"} declares malformed compatibility.clio range '${range}'`,
+              path: manifestPath
+            });
+          } else {
+            compatibility = { clio: range };
+          }
+        }
+      }
+    }
+  }
+  if (!id || !name || !version || !description || diagnostics.some((diag) => diag.type === "error")) {
+    return { diagnostics };
+  }
+  const manifest = {
+    manifestVersion: 1,
+    id,
+    name,
+    version,
+    description,
+    resources
+  };
+  if (tools) manifest.tools = tools;
+  if (settings) manifest.settings = settings;
+  if (compatibility && Object.keys(compatibility).length > 0) manifest.compatibility = compatibility;
+  const clioRange = manifest.compatibility?.clio;
+  if (clioRange !== void 0) {
+    const evaluation = evaluateClioCompatibility(clioRange);
+    if (!evaluation.satisfied) {
+      diagnostics.push({
+        type: "error",
+        message: `extension ${manifest.id} requires Clio '${clioRange}', but running Clio version is '${evaluation.runningVersion}'`,
+        path: manifestPath
+      });
+    }
+  }
+  return { manifest, diagnostics };
+}
+function findExtensionManifestPath(root) {
+  for (const name of MANIFEST_NAMES) {
+    const candidate = path.join(root, name);
+    try {
+      if (statSync(candidate).isFile()) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function loadManifestFromRoot(root) {
+  const manifestPath = findExtensionManifestPath(root);
+  if (!manifestPath) {
+    return {
+      path: root,
+      valid: false,
+      diagnostics: [{ type: "error", message: "extension manifest not found", path: root }]
+    };
+  }
+  try {
+    const parsed = parseExtensionManifest(readJsonOrYaml(manifestPath), manifestPath);
+    if (parsed.manifest) validateResourceRoots(root, parsed.manifest.resources, parsed.diagnostics);
+    return {
+      path: root,
+      manifestPath,
+      ...parsed.manifest ? { manifest: parsed.manifest } : {},
+      valid: parsed.manifest !== void 0 && !parsed.diagnostics.some((diag) => diag.type === "error"),
+      diagnostics: parsed.diagnostics
+    };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return {
+      path: root,
+      manifestPath,
+      valid: false,
+      diagnostics: [{ type: "error", message: `extension manifest could not be read: ${reason}`, path: manifestPath }]
+    };
+  }
+}
+function discoverExtensionPackages(root) {
+  const full = path.resolve(root);
+  if (!existsSync(full)) {
+    return [{ path: full, valid: false, diagnostics: [{ type: "error", message: "path does not exist", path: full }] }];
+  }
+  let stat;
+  try {
+    stat = statSync(full);
+  } catch (error) {
+    return [
+      {
+        path: full,
+        valid: false,
+        diagnostics: [
+          {
+            type: "error",
+            message: `extension path could not be inspected: ${error instanceof Error ? error.message : String(error)}`,
+            path: full
+          }
+        ]
+      }
+    ];
+  }
+  if (!stat.isDirectory()) {
+    return [
+      {
+        path: full,
+        valid: false,
+        diagnostics: [{ type: "error", message: "extension path is not a directory", path: full }]
+      }
+    ];
+  }
+  let canonicalFull;
+  try {
+    canonicalFull = realpathSync(full);
+  } catch (error) {
+    return [
+      {
+        path: full,
+        valid: false,
+        diagnostics: [
+          {
+            type: "error",
+            message: `extension path could not be canonicalized: ${error instanceof Error ? error.message : String(error)}`,
+            path: full
+          }
+        ]
+      }
+    ];
+  }
+  const direct = loadManifestFromRoot(canonicalFull);
+  if (direct.valid || direct.manifestPath) return [direct];
+  const candidates = [];
+  const discoveryFailures = [];
+  const spellingsByCanonicalRoot = /* @__PURE__ */ new Map();
+  let entries;
+  try {
+    entries = readdirSync(canonicalFull, { withFileTypes: true, encoding: "utf8" });
+  } catch (error) {
+    return [
+      {
+        path: canonicalFull,
+        valid: false,
+        diagnostics: [
+          {
+            type: "error",
+            message: `extension directory could not be read: ${error instanceof Error ? error.message : String(error)}`,
+            path: canonicalFull
+          }
+        ]
+      }
+    ];
+  }
+  for (const entry of entries.sort(compareNames)) {
+    if (entry.name.startsWith(".")) continue;
+    const child = path.join(canonicalFull, entry.name);
+    try {
+      if (!entry.isDirectory() && !(entry.isSymbolicLink() && statSync(child).isDirectory())) continue;
+      const canonicalChild = realpathSync(child);
+      const spellings = spellingsByCanonicalRoot.get(canonicalChild) ?? [];
+      spellings.push(child);
+      spellingsByCanonicalRoot.set(canonicalChild, spellings);
+    } catch (error) {
+      discoveryFailures.push({
+        path: child,
+        valid: false,
+        diagnostics: [
+          {
+            type: "error",
+            message: `extension child could not be canonicalized: ${error instanceof Error ? error.message : String(error)}`,
+            path: child
+          }
+        ]
+      });
+    }
+  }
+  for (const canonicalChild of [...spellingsByCanonicalRoot.keys()].sort()) {
+    const loaded = loadManifestFromRoot(canonicalChild);
+    const spellings = spellingsByCanonicalRoot.get(canonicalChild) ?? [];
+    if (spellings.length > 1) {
+      loaded.diagnostics.push({
+        type: "warning",
+        message: `duplicate canonical extension root loaded once; discovered as ${spellings.sort().join(", ")}`,
+        path: canonicalChild
+      });
+    }
+    if (loaded.valid || loaded.manifestPath) candidates.push(loaded);
+  }
+  const discovered = [...candidates, ...discoveryFailures].sort(
+    (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+  );
+  if (discovered.length === 0) discovered.push(direct);
+  const ids = /* @__PURE__ */ new Map();
+  for (const candidate of discovered) {
+    const id = candidate.manifest?.id;
+    if (!id) continue;
+    const group = ids.get(id) ?? [];
+    group.push(candidate);
+    ids.set(id, group);
+  }
+  for (const [id, group] of ids) {
+    if (group.length < 2) continue;
+    for (const candidate of group) {
+      candidate.valid = false;
+      candidate.diagnostics.push({
+        type: "error",
+        message: `duplicate extension id ${id}`,
+        path: candidate.manifestPath ?? candidate.path
+      });
+    }
+  }
+  return discovered;
+}
+
+// src/domains/extensions/state.ts
+init_esm_shims();
+import { createHash as createHash2 } from "node:crypto";
+import {
+  cpSync,
+  existsSync as existsSync2,
+  lstatSync as lstatSync3,
+  mkdirSync,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync3,
+  realpathSync as realpathSync3,
+  renameSync,
+  rmSync
+} from "node:fs";
+import path3 from "node:path";
+
+// src/domains/extensions/integrity.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  lstatSync as lstatSync2,
+  openSync,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync2,
+  readlinkSync,
+  realpathSync as realpathSync2
+} from "node:fs";
+import path2 from "node:path";
+function contained2(root, candidate) {
+  const relative = path2.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path2.sep}`) && relative !== ".." && !path2.isAbsolute(relative);
+}
+function digestFrame(hash, kind, relativePath, payload) {
+  const header = Buffer.from(
+    `${kind}\0${relativePath.replaceAll(path2.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 = readFileSync2(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 = realpathSync2(linkPath);
+  if (!contained2(canonicalRoot, canonicalTarget)) {
+    throw new Error(`symbolic link escapes the extension root: ${linkPath}`);
+  }
+  const target = readlinkSync(linkPath);
+  const after = lstatSync2(linkPath);
+  if (!after.isSymbolicLink() || !sameFileState(inspected, after)) {
+    throw new Error(`symbolic link changed while being hashed: ${linkPath}`);
+  }
+  const canonicalAfter = realpathSync2(linkPath);
+  if (canonicalAfter !== canonicalTarget || !contained2(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 = lstatSync2(directoryPath);
+  if (!after.isDirectory() || !sameFileState(inspected, after)) {
+    throw new Error(`extension directory changed while being hashed: ${directoryPath}`);
+  }
+  const canonicalAfter = realpathSync2(directoryPath);
+  if (canonicalAfter !== canonicalDirectory || !contained2(canonicalRoot, canonicalAfter)) {
+    throw new Error(`extension directory changed or escapes the extension root: ${directoryPath}`);
+  }
+  if (expectedEntries !== void 0) {
+    const currentEntries = readdirSync2(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 = realpathSync2(directoryPath);
+  if (!contained2(canonicalRoot, canonicalDirectory)) {
+    throw new Error(`extension directory escapes the extension root: ${directoryPath}`);
+  }
+  const entries = readdirSync2(directoryPath).sort();
+  assertStableDirectory(directoryPath, inspected, canonicalDirectory, canonicalRoot);
+  return { canonicalDirectory, entries };
+}
+function extensionContentDigestWithCapture(root, options = {}) {
+  const resolvedRoot = path2.resolve(root);
+  const rootStat = lstatSync2(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 = realpathSync2(resolvedRoot);
+  const canonicalizedRootStat = lstatSync2(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(path2.sep, "/")));
+  const captured = /* @__PURE__ */ new Map();
+  const visit = (absolutePath, relativePath) => {
+    const stat = lstatSync2(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(path2.join(absolutePath, entry), relativePath ? path2.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(path2.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;
+}
+
+// src/domains/extensions/state.ts
+var DEFAULT_STATE = { version: 1, disabled: [], installed: {} };
+function extensionBaseDir(scope, cwd = process.cwd()) {
+  return scope === "user" ? path3.join(clioConfigDir(), "extensions") : path3.join(path3.resolve(cwd), ".clio-coder", "extensions");
+}
+function statePath(scope, cwd = process.cwd()) {
+  return path3.join(extensionBaseDir(scope, cwd), "state.json");
+}
+function recoveryPath(filePath, label) {
+  return `${filePath}.${label}-${process.pid}-${Date.now()}.bak`;
+}
+function packageRecoveryPath(root, label) {
+  return path3.join(path3.dirname(root), `.${path3.basename(root)}.${label}-${process.pid}-${Date.now()}.bak`);
+}
+function preserveFile(filePath, label) {
+  if (!existsSync2(filePath)) return void 0;
+  const backupPath = recoveryPath(filePath, label);
+  safeResourceWrite(backupPath, readFileSync3(filePath));
+  return backupPath;
+}
+function scopeRank(scope) {
+  return scope === "project" ? 2 : 1;
+}
+function readState(scope, cwd = process.cwd()) {
+  const filePath = statePath(scope, cwd);
+  if (!existsSync2(filePath)) return { status: "absent", state: structuredClone(DEFAULT_STATE) };
+  try {
+    const parsed = JSON.parse(readFileSync3(filePath, "utf8"));
+    if (!isRecord(parsed) || parsed.version !== 1) throw new Error("state must be a version 1 object");
+    if (!Array.isArray(parsed.disabled) || !parsed.disabled.every((entry) => typeof entry === "string")) {
+      throw new Error("state.disabled must be an array of strings");
+    }
+    if (!isRecord(parsed.installed)) throw new Error("state.installed must be an object");
+    const installed = {};
+    for (const [id, raw] of Object.entries(parsed.installed)) {
+      if (!isRecord(raw)) throw new Error(`state.installed.${id} must be an object`);
+      const installedAt = trimString(raw.installedAt);
+      if (!installedAt) throw new Error(`state.installed.${id}.installedAt must be a non-empty string`);
+      const source = raw.source === void 0 ? void 0 : trimString(raw.source);
+      if (raw.source !== void 0 && !source) {
+        throw new Error(`state.installed.${id}.source must be a non-empty string`);
+      }
+      const contentDigest = raw.contentDigest === void 0 ? void 0 : trimString(raw.contentDigest);
+      if (raw.contentDigest !== void 0 && (!contentDigest || !/^[a-f0-9]{64}$/u.test(contentDigest))) {
+        throw new Error(`state.installed.${id}.contentDigest must be a SHA-256 digest`);
+      }
+      installed[id] = {
+        installedAt,
+        ...source ? { source } : {},
+        ...contentDigest ? { contentDigest } : {}
+      };
+    }
+    return { status: "valid", state: { version: 1, disabled: [...parsed.disabled], installed } };
+  } catch (error) {
+    return {
+      status: "corrupt",
+      state: structuredClone(DEFAULT_STATE),
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function writeState(scope, state, cwd = process.cwd()) {
+  const filePath = statePath(scope, cwd);
+  safeResourceWrite(filePath, `${JSON.stringify(state, null, 2)}
+`, { encoding: "utf8" });
+}
+function installedFromRoot(root, scope, stateResult, cwd, fallbackId) {
+  const candidate = loadManifestFromRoot(root);
+  const manifest = candidate.manifest;
+  const diagnostics = [...candidate.diagnostics];
+  const id = manifest?.id ?? fallbackId;
+  const provenance = stateResult.state.installed[id];
+  const expectedDigest = provenance?.contentDigest;
+  let observedDigest;
+  let captured;
+  let contentVerified = false;
+  if (stateResult.status === "corrupt") {
+    diagnostics.push({
+      type: "error",
+      message: `extension install state is corrupt: ${stateResult.message}; reinstall with --force or remove the package to preserve the corrupt bytes and recover`,
+      path: statePath(scope, cwd)
+    });
+  } else if (stateResult.status === "absent") {
+    diagnostics.push({
+      type: "error",
+      message: "extension install state is absent; installed content cannot be verified; reinstall with --force",
+      path: statePath(scope, cwd)
+    });
+  } else if (!provenance) {
+    diagnostics.push({
+      type: "error",
+      message: `extension ${id} is not recorded in install state; reinstall with --force`,
+      path: statePath(scope, cwd)
+    });
+  } else if (!expectedDigest) {
+    diagnostics.push({
+      type: "error",
+      message: `extension ${id} install provenance has no content digest; run clio-coder upgrade, then reinstall with --force if it remains unverifiable`,
+      path: statePath(scope, cwd)
+    });
+  } else {
+    try {
+      const manifestName2 = candidate.manifestPath ? path3.basename(candidate.manifestPath) : void 0;
+      const digestResult = extensionContentDigestWithCapture(root, {
+        capture: [...manifestName2 ? [manifestName2] : [], "hooks.yaml"]
+      });
+      observedDigest = digestResult.digest;
+      contentVerified = observedDigest === expectedDigest;
+      if (contentVerified) captured = digestResult.captured;
+      if (!contentVerified) {
+        diagnostics.push({
+          type: "error",
+          message: `installed extension content drift detected (expected ${expectedDigest}, observed ${observedDigest})`,
+          path: root
+        });
+      }
+    } catch (error) {
+      diagnostics.push({
+        type: "error",
+        message: `installed extension content could not be verified: ${error instanceof Error ? error.message : String(error)}`,
+        path: root
+      });
+    }
+  }
+  const clioRange = manifest?.compatibility?.clio;
+  const compatible = clioRange === void 0 || evaluateClioCompatibility(clioRange).satisfied;
+  const manifestName = candidate.manifestPath ? path3.basename(candidate.manifestPath) : void 0;
+  const manifestBytes = manifestName ? captured?.get(manifestName) : void 0;
+  const extensionProvenance = contentVerified && expectedDigest && manifestBytes ? {
+    id,
+    scope,
+    ...provenance?.source ? { sourcePath: provenance.source } : {},
+    canonicalRoot: realpathSync3(root),
+    manifestDigest: createHash2("sha256").update(manifestBytes).digest("hex"),
+    contentDigest: expectedDigest
+  } : void 0;
+  const entry = {
+    id,
+    name: manifest?.name ?? id,
+    version: manifest?.version ?? "unknown",
+    description: manifest?.description ?? "Installed extension has an invalid manifest.",
+    scope,
+    rootPath: root,
+    manifestPath: candidate.manifestPath ?? root,
+    enabled: !stateResult.state.disabled.includes(id),
+    valid: manifest !== void 0 && candidate.valid && contentVerified,
+    compatible,
+    effective: false,
+    loadable: false,
+    ...extensionProvenance ? { provenance: extensionProvenance } : {},
+    ...observedDigest ? { observedContentDigest: observedDigest } : {},
+    resources: manifest?.resources ?? {},
+    diagnostics
+  };
+  return { entry, ...extensionProvenance && captured ? { captured } : {} };
+}
+function listScope(scope, cwd = process.cwd()) {
+  const base = extensionBaseDir(scope, cwd);
+  if (!existsSync2(base)) return [];
+  const state = readState(scope, cwd);
+  const out = [];
+  for (const entry of readdirSync3(base, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const root = path3.join(base, entry.name);
+    const installed = installedFromRoot(root, scope, state, cwd, entry.name);
+    if (installed) out.push(installed);
+  }
+  return out;
+}
+function upgradeLegacyExtensionInstallState(cwd = process.cwd(), scopes = ["user", "project"]) {
+  const reports = [];
+  for (const scope of scopes) {
+    const filePath = statePath(scope, cwd);
+    const report = { scope, statePath: filePath, upgraded: [], refused: [] };
+    const stateResult = readState(scope, cwd);
+    if (stateResult.status === "absent") {
+      reports.push(report);
+      continue;
+    }
+    if (stateResult.status === "corrupt") {
+      report.refused.push({ id: "<state>", reason: `install state is corrupt: ${stateResult.message}` });
+      reports.push(report);
+      continue;
+    }
+    const next = structuredClone(stateResult.state);
+    const verified = /* @__PURE__ */ new Map();
+    for (const [id, record] of Object.entries(next.installed)) {
+      if (record.contentDigest) continue;
+      const root = path3.join(extensionBaseDir(scope, cwd), id);
+      try {
+        if (!lstatSync3(root).isDirectory()) throw new Error("installed path is not a directory");
+        const candidate = loadManifestFromRoot(root);
+        if (!candidate.valid || !candidate.manifest) {
+          throw new Error(candidate.diagnostics.map((diagnostic) => diagnostic.message).join("; ") || "manifest is invalid");
+        }
+        if (candidate.manifest.id !== id) {
+          throw new Error(`manifest id ${candidate.manifest.id} does not match install record ${id}`);
+        }
+        const digest = extensionContentDigest(root);
+        record.contentDigest = digest;
+        verified.set(id, { root, digest });
+        report.upgraded.push(id);
+      } catch (error) {
+        report.refused.push({ id, reason: error instanceof Error ? error.message : String(error) });
+      }
+    }
+    if (report.upgraded.length > 0) {
+      const backupPath = `${filePath}.pre-digest.bak`;
+      safeResourceWrite(filePath, `${JSON.stringify(next, null, 2)}
+`, {
+        encoding: "utf8",
+        backup: { path: backupPath },
+        beforeRename: () => {
+          for (const [id, expected] of verified) {
+            const candidate = loadManifestFromRoot(expected.root);
+            if (!candidate.valid || candidate.manifest?.id !== id) {
+              throw new Error(`extension ${id} became invalid during digest migration`);
+            }
+            const observed = extensionContentDigest(expected.root);
+            if (observed !== expected.digest) throw new Error(`extension ${id} changed during digest migration`);
+          }
+        }
+      });
+      report.backupPath = backupPath;
+    }
+    reports.push(report);
+  }
+  return reports;
+}
+function listInstalledExtensions(cwd = process.cwd(), options = {}) {
+  return listInstalledExtensionRecords(cwd, options).map((record) => record.entry);
+}
+function listInstalledExtensionRecords(cwd = process.cwd(), options = {}) {
+  const scopes = options.scope ? [options.scope] : ["user", "project"];
+  const records = scopes.flatMap((scope) => listScope(scope, cwd));
+  const byId = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const entry = record.entry;
+    const list = byId.get(entry.id) ?? [];
+    list.push(record);
+    byId.set(entry.id, list);
+  }
+  for (const group of byId.values()) {
+    const winner = group.filter((record) => record.entry.valid && record.entry.compatible).sort((a, b) => scopeRank(a.entry.scope) - scopeRank(b.entry.scope)).at(-1);
+    for (const record of group) {
+      const entry = record.entry;
+      entry.effective = record === winner;
+      entry.loadable = entry.valid && entry.compatible && entry.enabled && entry.effective;
+      if (entry.valid && entry.compatible && !entry.effective && winner) entry.overriddenBy = winner.entry.scope;
+    }
+  }
+  const all = options.all === true ? records : records.filter(({ entry }) => entry.effective || !entry.valid || !entry.compatible);
+  return all.sort((a, b) => {
+    const id = a.entry.id.localeCompare(b.entry.id);
+    if (id !== 0) return id;
+    return scopeRank(a.entry.scope) - scopeRank(b.entry.scope);
+  });
+}
+function findInstalled(id, cwd, scope) {
+  const entries = listInstalledExtensions(cwd, { ...scope ? { scope } : {}, all: true }).filter(
+    (entry) => entry.id === id
+  );
+  if (entries.length === 0) return null;
+  return [...entries].sort((a, b) => scopeRank(a.scope) - scopeRank(b.scope)).at(-1) ?? null;
+}
+function installExtension(sourcePath, options = {}) {
+  const scope = options.scope ?? "user";
+  const cwd = options.cwd ?? process.cwd();
+  const source = path3.resolve(sourcePath);
+  const candidate = loadManifestFromRoot(source);
+  if (!candidate.manifest || !candidate.valid) return { diagnostics: candidate.diagnostics };
+  const targetRoot = path3.join(extensionBaseDir(scope, cwd), candidate.manifest.id);
+  if (existsSync2(targetRoot)) {
+    if (!options.force) {
+      return {
+        diagnostics: [
+          {
+            type: "error",
+            message: `extension ${candidate.manifest.id} is already installed; retry with --force to replace it`,
+            path: targetRoot
+          }
+        ]
+      };
+    }
+  }
+  const parent = path3.dirname(targetRoot);
+  const stagingRoot = path3.join(parent, `.${candidate.manifest.id}.install-${process.pid}-${Date.now()}`);
+  const backupRoot = path3.join(parent, `.${candidate.manifest.id}.backup-${process.pid}-${Date.now()}`);
+  let installedReplacement = false;
+  let movedExisting = false;
+  const stateResult = readState(scope, cwd);
+  if (stateResult.status === "corrupt" && !options.force) {
+    return {
+      diagnostics: [
+        {
+          type: "error",
+          message: `extension install state is corrupt: ${stateResult.message}; retry with --force to back it up and reinstall safely`,
+          path: statePath(scope, cwd)
+        }
+      ]
+    };
+  }
+  const state = stateResult.status === "corrupt" ? structuredClone(DEFAULT_STATE) : stateResult.state;
+  let stateBackup;
+  let packageBackup;
+  try {
+    mkdirSync(parent, { recursive: true });
+    if (stateResult.status === "corrupt") stateBackup = preserveFile(statePath(scope, cwd), "corrupt");
+    rmSync(stagingRoot, { recursive: true, force: true });
+    rmSync(backupRoot, { recursive: true, force: true });
+    cpSync(source, stagingRoot, {
+      recursive: true,
+      // `state.json` beside the installed extension directories belongs to
+      // Clio's extension manager. An extension may legitimately ship nested
+      // resources with the same basename (for example a project-state JSON
+      // template), so exclude only a bookkeeping file at the package root.
+      filter: (src) => path3.relative(source, src) !== "state.json"
+    });
+    const stagedCandidate = loadManifestFromRoot(stagingRoot);
+    if (!stagedCandidate.valid || !stagedCandidate.manifest) {
+      const reasons = stagedCandidate.diagnostics.map((diagnostic) => diagnostic.message).join("; ");
+      throw new Error(`staged extension content is invalid${reasons ? `: ${reasons}` : ""}`);
+    }
+    if (stagedCandidate.manifest.id !== candidate.manifest.id) {
+      throw new Error(`staged extension id changed from ${candidate.manifest.id} to ${stagedCandidate.manifest.id}`);
+    }
+    const contentDigest = extensionContentDigest(stagingRoot);
+    if (existsSync2(targetRoot)) {
+      renameSync(targetRoot, backupRoot);
+      movedExisting = true;
+      packageBackup = backupRoot;
+    }
+    renameSync(stagingRoot, targetRoot);
+    installedReplacement = true;
+    state.installed[candidate.manifest.id] = {
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      source,
+      contentDigest
+    };
+    state.disabled = state.disabled.filter((entry) => entry !== candidate.manifest?.id);
+    writeState(scope, state, cwd);
+  } catch (error) {
+    rmSync(stagingRoot, { recursive: true, force: true });
+    if (installedReplacement) rmSync(targetRoot, { recursive: true, force: true });
+    if (movedExisting && existsSync2(backupRoot) && !existsSync2(targetRoot)) {
+      renameSync(backupRoot, targetRoot);
+      packageBackup = void 0;
+    }
+    return {
+      ...stateBackup || packageBackup ? { recovery: { ...stateBackup ? { stateBackup } : {}, ...packageBackup ? { packageBackup } : {} } } : {},
+      diagnostics: [
+        {
+          type: "error",
+          message: `extension ${candidate.manifest.id} install failed: ${error instanceof Error ? error.message : String(error)}`,
+          path: targetRoot
+        }
+      ]
+    };
+  }
+  const diagnostics = [...candidate.diagnostics];
+  if (movedExisting && stateResult.status !== "valid") {
+    diagnostics.push({
+      type: "warning",
+      message: "previous unverifiable extension bytes were preserved during forced reinstall",
+      path: backupRoot
+    });
+  } else {
+    try {
+      rmSync(backupRoot, { recursive: true, force: true });
+      packageBackup = void 0;
+    } catch (error) {
+      diagnostics.push({
+        type: "warning",
+        message: `extension installed, but its backup could not be removed: ${error instanceof Error ? error.message : String(error)}`,
+        path: backupRoot
+      });
+    }
+  }
+  if (stateBackup) {
+    diagnostics.push({ type: "warning", message: "corrupt extension install state was preserved", path: stateBackup });
+  }
+  const installed = findInstalled(candidate.manifest.id, cwd, scope);
+  return {
+    ...installed ? { extension: installed } : {},
+    ...stateBackup || packageBackup ? { recovery: { ...stateBackup ? { stateBackup } : {}, ...packageBackup ? { packageBackup } : {} } } : {},
+    diagnostics
+  };
+}
+function mutateEnabled(id, enabled, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const target = findInstalled(id, cwd, options.scope);
+  if (!target) {
+    return { diagnostics: [{ type: "error", message: `extension ${id} is not installed` }] };
+  }
+  const stateResult = readState(target.scope, cwd);
+  if (stateResult.status !== "valid") {
+    return {
+      diagnostics: [
+        {
+          type: "error",
+          message: stateResult.status === "corrupt" ? `extension install state is corrupt: ${stateResult.message}` : "extension install state is absent",
+          path: statePath(target.scope, cwd)
+        }
+      ]
+    };
+  }
+  const state = stateResult.state;
+  if (enabled) state.disabled = state.disabled.filter((entry) => entry !== id);
+  else if (!state.disabled.includes(id)) state.disabled.push(id);
+  writeState(target.scope, state, cwd);
+  const extension = findInstalled(id, cwd, target.scope) ?? void 0;
+  return { ...extension ? { extension } : {}, diagnostics: [] };
+}
+function enableExtension(id, options = {}) {
+  return mutateEnabled(id, true, options);
+}
+function disableExtension(id, options = {}) {
+  return mutateEnabled(id, false, options);
+}
+function removeExtension(id, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const target = findInstalled(id, cwd, options.scope);
+  if (!target) {
+    return { diagnostics: [{ type: "error", message: `extension ${id} is not installed` }] };
+  }
+  const stateResult = readState(target.scope, cwd);
+  if (stateResult.status !== "valid") {
+    const filePath = statePath(target.scope, cwd);
+    const packageBackup = packageRecoveryPath(target.rootPath, "removed-unverifiable");
+    let stateBackup;
+    try {
+      if (stateResult.status === "corrupt") stateBackup = preserveFile(filePath, "corrupt");
+      renameSync(target.rootPath, packageBackup);
+      try {
+        writeState(target.scope, structuredClone(DEFAULT_STATE), cwd);
+      } catch (error) {
+        renameSync(packageBackup, target.rootPath);
+        throw error;
+      }
+      const diagnostics = [
+        {
+          type: "warning",
+          message: "unverifiable extension bytes were preserved while removing the package from the load path",
+          path: packageBackup
+        }
+      ];
+      if (stateBackup) {
+        diagnostics.push({ type: "warning", message: "corrupt extension install state was preserved", path: stateBackup });
+      }
+      return {
+        removed: { id, scope: target.scope, path: target.rootPath },
+        recovery: { ...stateBackup ? { stateBackup } : {}, packageBackup },
+        diagnostics
+      };
+    } catch (error) {
+      return {
+        diagnostics: [
+          {
+            type: "error",
+            message: `extension ${id} could not be removed safely: ${error instanceof Error ? error.message : String(error)}`,
+            path: target.rootPath
+          }
+        ]
+      };
+    }
+  }
+  const state = stateResult.state;
+  rmSync(target.rootPath, { recursive: true, force: true });
+  Reflect.deleteProperty(state.installed, id);
+  state.disabled = state.disabled.filter((entry) => entry !== id);
+  writeState(target.scope, state, cwd);
+  return { removed: { id, scope: target.scope, path: target.rootPath }, diagnostics: [] };
+}
+
+export {
+  loadManifestFromRoot,
+  discoverExtensionPackages,
+  extensionContentDigest,
+  extensionBaseDir,
+  upgradeLegacyExtensionInstallState,
+  listInstalledExtensions,
+  listInstalledExtensionRecords,
+  installExtension,
+  enableExtension,
+  disableExtension,
+  removeExtension
+};
+//# sourceMappingURL=chunk-77QIVUZB.js.map