@iowarp/clio-coder 0.4.6 → 0.4.7

package/dist/chunk-MNQN3X6Y.js

@@ -0,0 +1,595 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  libraryCopyState,
+  readLibraryInventory
+} from "./chunk-UWD3JD5X.js";
+import {
+  validateLibraryPackage
+} from "./chunk-WB7POC6M.js";
+import {
+  classifyLibraryRequirements,
+  commitLibraryInstallPlan,
+  discoverLibrary,
+  libraryEntryRef,
+  planLibraryInstall,
+  planLibraryUpdate,
+  releaseLibraryPlan,
+  resolveInstalledLibraryEntry,
+  resolveLibraryPackage
+} from "./chunk-MZNWZUJM.js";
+import {
+  PluginWriterRefusal,
+  disablePlugin,
+  enablePlugin,
+  isLibraryKind,
+  listInstalledPlugins,
+  newlyBrokenDependents,
+  observePluginCopy,
+  pluginBaseDir,
+  readPluginInstallRecord,
+  reloadPluginResources,
+  removePlugin,
+  withPluginScopeLock
+} from "./chunk-YKRJTYNP.js";
+import {
+  extensionContentDigest
+} from "./chunk-XW2UZICE.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/resources/library-actions.ts
+init_esm_shims();
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import path from "node:path";
+var staged = /* @__PURE__ */ new Map();
+function stepKey(identity) {
+  return `${identity.scope}:${identity.ref}`;
+}
+function retain(planId, identity, plan) {
+  const byStep = staged.get(planId) ?? /* @__PURE__ */ new Map();
+  byStep.set(stepKey(identity), plan);
+  staged.set(planId, byStep);
+}
+function releaseLibraryLifecycle(plan) {
+  const byStep = staged.get(plan.id);
+  staged.delete(plan.id);
+  for (const item of byStep?.values() ?? []) releaseLibraryPlan(item);
+}
+function libraryLifecyclePlanSummary(plan) {
+  return plan;
+}
+function peerOf(scope) {
+  return scope === "user" ? "project" : "user";
+}
+function identityOf(kind, name, scope) {
+  return { ref: `${kind}:${name}`, kind, name, scope };
+}
+function copyOf(entries, identity) {
+  return entries.find(
+    (item) => item.id === identity.name && (item.kind ?? "plugin") === identity.kind && item.scope === identity.scope
+  );
+}
+function observe(cwd, scope, id, diagnostics) {
+  try {
+    return observePluginCopy(scope, id, cwd);
+  } catch (error) {
+    diagnostics.push(`state for ${scope}:${id} unreadable: ${error instanceof Error ? error.message : String(error)}`);
+    return void 0;
+  }
+}
+function expectedFor(cwd, identity, consulted, earlier, diagnostics) {
+  const wanted = /* @__PURE__ */ new Map();
+  wanted.set(`${identity.scope}:${identity.name}`, { scope: identity.scope, id: identity.name });
+  if (existsSync(pluginBaseDir(peerOf(identity.scope), cwd)))
+    wanted.set(`${peerOf(identity.scope)}:${identity.name}`, { scope: peerOf(identity.scope), id: identity.name });
+  for (const item of consulted) wanted.set(`${item.scope}:${item.id}`, item);
+  for (const item of earlier) wanted.delete(`${item.scope}:${item.name}`);
+  const out = [];
+  for (const item of wanted.values()) {
+    const fact = observe(cwd, item.scope, item.id, diagnostics);
+    if (fact) out.push(fact);
+  }
+  return out;
+}
+function stateAfterInstall(entries, identity) {
+  const peer = entries.find(
+    (item) => item.id === identity.name && item.scope === peerOf(identity.scope) && item.valid && item.compatible
+  );
+  if (identity.scope === "user" && peer) {
+    return {
+      effectiveAfter: { scope: "project", loadable: peer.loadable, state: libraryCopyState(peer) },
+      fallbackNote: `the project copy stays effective; the new user copy is shadowed until the project copy is removed`
+    };
+  }
+  return {
+    effectiveAfter: { scope: identity.scope, loadable: true, state: "loadable" },
+    fallbackNote: peer && identity.scope === "project" ? "the new project copy shadows the existing user copy" : "this copy becomes the effective copy"
+  };
+}
+function contentOf(root) {
+  const result = validateLibraryPackage(root);
+  return {
+    valid: result.valid,
+    resources: result.validation.resources.filter((item) => item.kind !== "plugin").map((item) => ({ kind: item.kind, name: item.name, valid: item.valid })),
+    diagnostics: [...result.diagnostics.map((d) => d.message), ...result.validation.diagnostics.map((d) => d.message)]
+  };
+}
+function installStep(planId, cwd, scope, staged2, operation, entries, earlier, dependencies, diagnostics) {
+  const identity = identityOf(staged2.entry.kind, staged2.entry.name, scope);
+  retain(planId, identity, staged2);
+  const existing = copyOf(entries, identity);
+  const expected = expectedFor(cwd, identity, [], earlier, diagnostics);
+  staged2.expect = { copies: expected };
+  const refusal = existing && operation === "install" && !staged2.force ? `${identity.ref} is already installed in ${scope} scope; use update or force` : void 0;
+  return {
+    operation,
+    identity,
+    destination: staged2.path,
+    source: { sourceUrl: staged2.entry.sourceUrl, sha256: staged2.sha256, staged: staged2.sourceRoot !== void 0 },
+    content: contentOf(staged2.sourceRoot),
+    expected,
+    dependencies,
+    dependents: { newlyBroken: [], preexisting: [] },
+    ...stateAfterInstall(entries, identity),
+    recovery: existing ? "files in the current tree that differ from its record are kept beside it as a backup copy" : "nothing to recover; the destination is empty",
+    ...refusal ? { refusal } : {}
+  };
+}
+function requirementRefs(status) {
+  return {
+    requires: status.ordered.map(libraryEntryRef),
+    missing: status.unsatisfied.map(libraryEntryRef),
+    inactive: (status.inactive ?? []).map(libraryEntryRef)
+  };
+}
+function planLibraryLifecycle(request) {
+  const cwd = path.resolve(request.cwd ?? process.cwd());
+  const id = randomBytes(8).toString("hex");
+  const diagnostics = [];
+  const steps = [];
+  const discoveryOptions = { cwd, ...request.catalog ? { catalog: request.catalog } : {} };
+  const entries = listInstalledPlugins(cwd, { all: true });
+  try {
+    if (request.operation === "install") {
+      const scope = request.scope ?? "user";
+      const entry = resolveLibraryPackage(request.ref, discoveryOptions);
+      let status = { ordered: [], satisfied: [], unsatisfied: [] };
+      let refusal;
+      try {
+        status = classifyLibraryRequirements(entry, discoverLibrary(discoveryOptions).entries, { cwd });
+      } catch (error) {
+        refusal = error instanceof Error ? error.message : String(error);
+      }
+      const dependencies = requirementRefs(status);
+      if (!refusal && status.inactive?.length)
+        refusal = `library_requirement_inactive: ${dependencies.inactive.join(", ")}; enable or repair those packages first`;
+      else if (!refusal && status.unsatisfied.length && !request.withRequirements)
+        refusal = `library_requirement_missing: ${dependencies.missing.join(", ")}; plan with requirements`;
+      const identity = identityOf(entry.kind, entry.name, scope);
+      if (refusal) {
+        steps.push({
+          operation: "install",
+          identity,
+          destination: path.join(pluginBaseDir(scope, cwd), entry.name),
+          source: { sourceUrl: entry.sourceUrl, sha256: entry.sha256 ?? "", staged: false },
+          expected: [],
+          dependencies,
+          dependents: { newlyBroken: [], preexisting: [] },
+          fallbackNote: "no change",
+          recovery: "nothing changes",
+          refusal
+        });
+      } else {
+        const earlier = [];
+        for (const dependency of status.unsatisfied) {
+          const step = installStep(
+            id,
+            cwd,
+            scope,
+            planLibraryInstall(dependency, { cwd, scope }),
+            "install",
+            entries,
+            earlier,
+            requirementRefs(classifyLibraryRequirements(dependency, discoverLibrary(discoveryOptions).entries, { cwd })),
+            diagnostics
+          );
+          steps.push(step);
+          earlier.push(step.identity);
+        }
+        steps.push(
+          installStep(
+            id,
+            cwd,
+            scope,
+            planLibraryInstall(entry, { cwd, scope, force: request.force ?? false }),
+            "install",
+            entries,
+            earlier,
+            dependencies,
+            diagnostics
+          )
+        );
+      }
+    } else if (request.operation === "update") {
+      const identity = resolveInstalledLibraryEntry(request.ref, {
+        cwd,
+        ...request.scope ? { scope: request.scope } : {}
+      });
+      let stagedPlan;
+      let refusal;
+      try {
+        stagedPlan = planLibraryUpdate(request.ref, {
+          cwd,
+          scope: identity.scope,
+          force: request.force ?? false,
+          ...request.catalog ? { catalog: request.catalog } : {}
+        });
+      } catch (error) {
+        refusal = error instanceof Error ? error.message : String(error);
+      }
+      const requires = identity.requires ?? [];
+      const dependencies = {
+        requires,
+        missing: requires.filter(
+          (ref) => !entries.some((item) => item.loadable && `${item.kind ?? "plugin"}:${item.id}` === ref)
+        ),
+        inactive: []
+      };
+      if (stagedPlan)
+        steps.push(installStep(id, cwd, identity.scope, stagedPlan, "update", entries, [], dependencies, diagnostics));
+      else {
+        const target = identityOf(identity.kind, identity.name, identity.scope);
+        steps.push({
+          operation: "update",
+          identity: target,
+          destination: path.join(pluginBaseDir(identity.scope, cwd), identity.name),
+          expected: [],
+          dependencies,
+          dependents: { newlyBroken: [], preexisting: [] },
+          fallbackNote: "no change",
+          recovery: "nothing changes",
+          refusal: refusal ?? "update source unavailable"
+        });
+      }
+    } else {
+      const resolved = resolveInstalledLibraryEntry(request.ref, {
+        cwd,
+        ...request.scope ? { scope: request.scope } : {}
+      });
+      const identity = identityOf(resolved.kind, resolved.name, resolved.scope);
+      const copy = copyOf(entries, identity);
+      if (!copy) throw new Error(`package not installed: ${identity.ref} (${identity.scope})`);
+      let refusal;
+      let dependents = { newlyBroken: [], preexisting: [] };
+      let effectiveAfter;
+      let fallbackNote;
+      const requires = copy.manifest?.clio.requires ?? [];
+      const missing = requires.filter(
+        (ref) => !entries.some((item) => item.loadable && `${item.kind ?? "plugin"}:${item.id}` === ref)
+      );
+      if (request.operation === "enable") {
+        if (!copy.valid || !copy.compatible)
+          refusal = `${identity.ref} cannot be enabled: ${copy.diagnostics.map((d) => d.message).join("; ")}`;
+        else if (missing.length)
+          refusal = `library_requirement_missing: ${missing.join(", ")}; install or enable those first`;
+        const winner = entries.find((item) => item.id === identity.name && item.effective);
+        effectiveAfter = winner ? {
+          scope: winner.scope,
+          loadable: winner === copy ? copy.valid && copy.compatible : winner.loadable,
+          state: winner === copy ? "loadable" : libraryCopyState(winner)
+        } : void 0;
+        fallbackNote = winner && winner !== copy ? `the ${winner.scope} copy stays effective; this ${identity.scope} copy remains shadowed` : "this copy becomes loadable";
+      } else {
+        const projection = newlyBrokenDependents(entries, {
+          scope: identity.scope,
+          id: identity.name,
+          operation: request.operation
+        });
+        dependents = { newlyBroken: projection.newlyBroken, preexisting: projection.preexisting };
+        if (projection.newlyBroken.length)
+          refusal = `${request.operation} would break ${projection.newlyBroken.map((item) => `${item.scope}:${item.ref} (missing ${item.missing.join(", ")})`).join("; ")}; disable or remove those dependents first`;
+        const survivor = projection.effectiveAfter;
+        effectiveAfter = survivor ? { scope: survivor.scope, loadable: survivor.loadable, state: libraryCopyState(survivor) } : void 0;
+        if (request.operation === "disable")
+          fallbackNote = survivor && survivor.scope === identity.scope ? survivor.overriddenBy || entries.some((item) => item.id === identity.name && item.scope !== identity.scope) ? `the disabled ${identity.scope} copy still shadows the ${peerOf(identity.scope)} copy; removal would reveal it` : "no other copy exists; nothing falls back" : "another copy is already effective";
+        else
+          fallbackNote = survivor ? `the ${survivor.scope} copy becomes effective (${survivor.loadable ? "loadable" : libraryCopyState(survivor)})` : "no other copy exists; the package will be absent";
+      }
+      const consulted = entries.filter((item) => item.loadable && (item.manifest?.clio.requires?.length ?? 0) > 0).map((item) => ({ scope: item.scope, id: item.id }));
+      steps.push({
+        operation: request.operation,
+        identity,
+        destination: copy.rootPath,
+        ...request.operation === "enable" ? { content: contentOf(copy.rootPath) } : {},
+        expected: expectedFor(cwd, identity, consulted, [], diagnostics),
+        dependencies: { requires, missing, inactive: [] },
+        dependents,
+        ...effectiveAfter ? { effectiveAfter } : {},
+        fallbackNote,
+        recovery: request.operation === "remove" ? "files that differ from the recorded content are kept beside the destination as a removed backup" : "only the enabled flag in state.json changes; no files move",
+        ...refusal ? { refusal } : {}
+      });
+    }
+  } catch (error) {
+    releaseLibraryLifecycle({ id });
+    throw error;
+  }
+  return {
+    version: 1,
+    id,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cwd,
+    request,
+    steps,
+    applicable: steps.every((step) => !step.refusal),
+    diagnostics
+  };
+}
+function verifyLibraryStep(identity, cwd, evidence = "pre-refresh") {
+  const entries = listInstalledPlugins(cwd, { all: true });
+  const copy = copyOf(entries, identity);
+  const root = path.join(pluginBaseDir(identity.scope, cwd), identity.name);
+  let record = "absent";
+  let recordedDigest;
+  try {
+    const saved = readPluginInstallRecord(identity.name, { cwd, scope: identity.scope });
+    record = saved ? "recorded" : "absent";
+    recordedDigest = saved?.contentDigest;
+  } catch {
+    record = "unreadable";
+  }
+  let tree = "absent";
+  if (existsSync(root)) {
+    try {
+      tree = recordedDigest && extensionContentDigest(root) !== recordedDigest ? "changed" : "present";
+    } catch {
+      tree = "changed";
+    }
+  }
+  const kinds = /* @__PURE__ */ new Set();
+  for (const kind of Object.keys(copy?.resources ?? {}))
+    if (kind === "skills" || kind === "agents" || kind === "prompts" || kind === "fleets")
+      kinds.add(kind.slice(0, -1));
+  const resources = [];
+  if (copy && kinds.size) {
+    const inventory = readLibraryInventory({
+      cwd,
+      include: { packages: false, copies: false },
+      kinds: [...kinds],
+      sources: ["package"]
+    });
+    for (const resource of inventory.resources)
+      if (resource.owner?.ref === identity.ref && resource.owner.scope === identity.scope)
+        resources.push({
+          kind: resource.kind,
+          name: resource.name,
+          available: resource.availability === "available",
+          ...resource.reason ? { reason: resource.reason } : {}
+        });
+  }
+  const effective = entries.find((item) => item.id === identity.name && item.effective);
+  return {
+    evidence,
+    tree,
+    record,
+    ...copy ? { copy: libraryCopyState(copy) } : {},
+    resources,
+    effective: effective ? { scope: effective.scope, loadable: effective.loadable } : null
+  };
+}
+function nextFor(code) {
+  switch (code) {
+    case "stale_plan":
+      return "review a fresh plan";
+    case "locked":
+      return "retry the same plan when the other operation finishes";
+    case "refused":
+      return "resolve the refusal and review a fresh plan";
+    case "verification":
+      return "inspect the copy and its recovery paths";
+    default:
+      return "inspect the diagnostics and recovery paths, then review a fresh plan";
+  }
+}
+function failed(step, code, message, extra = {}) {
+  return {
+    status: "failed",
+    operation: step.operation,
+    identity: step.identity,
+    diagnostics: [],
+    ...extra,
+    error: { code, message, next: nextFor(code) }
+  };
+}
+function writerError(diagnostics) {
+  return diagnostics.find((item) => item.type === "error");
+}
+function runWriter(plan, step) {
+  const { identity } = step;
+  const scoped = { cwd: plan.cwd, scope: identity.scope, expect: { copies: step.expected } };
+  if (step.operation === "install" || step.operation === "update") {
+    const stagedPlan = staged.get(plan.id)?.get(stepKey(identity));
+    if (!stagedPlan) throw new Error(`plan ${plan.id} has no staged source for ${identity.ref}; it was released`);
+    stagedPlan.expect = scoped.expect;
+    return commitLibraryInstallPlan(stagedPlan);
+  }
+  if (step.operation === "enable") return enablePlugin(identity.name, scoped);
+  if (step.operation === "disable") return disablePlugin(identity.name, scoped);
+  return removePlugin(identity.name, scoped);
+}
+function applyStep(plan, step) {
+  const peer = peerOf(step.identity.scope);
+  const holdPeer = step.expected.some((fact) => fact.scope === peer) && existsSync(pluginBaseDir(peer, plan.cwd));
+  let result;
+  try {
+    result = holdPeer ? withPluginScopeLock(peer, plan.cwd, () => runWriter(plan, step)) : runWriter(plan, step);
+  } catch (error) {
+    if (error instanceof PluginWriterRefusal) {
+      const outcome2 = failed(step, error.code === "dependents" ? "refused" : error.code, error.message);
+      if (error.changed && outcome2.error) outcome2.error.changed = error.changed;
+      return outcome2;
+    }
+    return failed(step, "writer", error instanceof Error ? error.message : String(error));
+  }
+  const problem = writerError(result.diagnostics);
+  if (problem) {
+    const code = problem.code === "dependents" ? "refused" : problem.code ?? "writer";
+    const outcome2 = failed(step, code, problem.message, {
+      diagnostics: result.diagnostics.map((d) => d.message),
+      ...result.recovery ? { recovery: result.recovery } : {}
+    });
+    if (problem.changed && outcome2.error) outcome2.error.changed = problem.changed;
+    return outcome2;
+  }
+  const outcome = {
+    status: "committed",
+    operation: step.operation,
+    identity: step.identity,
+    ...result.recovery ? { recovery: result.recovery } : {},
+    diagnostics: result.diagnostics.map((d) => d.message)
+  };
+  annotateVerification(outcome, plan.cwd, "pre-refresh", step.operation === "remove");
+  return outcome;
+}
+function annotateVerification(outcome, cwd, evidence, wantsAbsent) {
+  let verification;
+  try {
+    verification = verifyLibraryStep(outcome.identity, cwd, evidence);
+  } catch (error) {
+    outcome.error = {
+      code: "verification",
+      message: `${evidence} read-back failed: ${error instanceof Error ? error.message : String(error)}`,
+      next: nextFor("verification")
+    };
+    return;
+  }
+  outcome.verification = verification;
+  const diskOk = wantsAbsent ? verification.tree === "absent" && verification.record === "absent" : verification.tree === "present" && verification.record === "recorded";
+  if (diskOk) delete outcome.error;
+  else
+    outcome.error = {
+      code: "verification",
+      message: `writer reported success but the ${outcome.identity.scope} copy reads back tree=${verification.tree} record=${verification.record}`,
+      next: nextFor("verification")
+    };
+}
+function unattempted(step) {
+  return { status: "unattempted", operation: step.operation, identity: step.identity, diagnostics: [] };
+}
+function applyLibraryLifecycle(plan, options = {}) {
+  const outcomes = [];
+  try {
+    if (options.dryRun) {
+      for (const step of plan.steps) outcomes.push(unattempted(step));
+      return summarize(plan, true, outcomes, { status: "not-applicable", reason: "dry run; nothing committed" });
+    }
+    if (!plan.applicable) {
+      for (const step of plan.steps)
+        outcomes.push(step.refusal ? failed(step, "refused", step.refusal) : { ...unattempted(step) });
+      return summarize(plan, false, outcomes, { status: "not-applicable", reason: "plan refused; nothing committed" });
+    }
+    let aborted = false;
+    for (const step of plan.steps) {
+      if (aborted) {
+        outcomes.push(unattempted(step));
+        continue;
+      }
+      const outcome = applyStep(plan, step);
+      outcomes.push(outcome);
+      if (outcome.status !== "committed" || outcome.error) aborted = true;
+    }
+  } finally {
+    releaseLibraryLifecycle(plan);
+  }
+  const committed = outcomes.filter((item) => item.status === "committed");
+  const refresh = committed.length ? retryLibraryRefresh(plan.cwd, options.refresh) : { status: "not-applicable", reason: "nothing committed" };
+  if (refresh.status === "refreshed")
+    for (const outcome of committed)
+      annotateVerification(outcome, plan.cwd, "post-refresh", outcome.operation === "remove");
+  return summarize(plan, false, outcomes, refresh);
+}
+function summarize(plan, dryRun, outcomes, refresh) {
+  return {
+    planId: plan.id,
+    dryRun,
+    outcomes,
+    committed: outcomes.filter((item) => item.status === "committed").length,
+    failed: outcomes.filter((item) => item.status === "failed").length,
+    unattempted: outcomes.filter((item) => item.status === "unattempted").length,
+    refresh
+  };
+}
+function retryLibraryRefresh(cwd, refresh) {
+  if (!refresh)
+    return {
+      status: "not-applicable",
+      reason: "no active session in this process; use /library reload in the running TUI"
+    };
+  try {
+    return refresh(cwd);
+  } catch (error) {
+    return { status: "failed", error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function pluginSnapshotRefreshHost(reload = reloadPluginResources, previousGeneration = () => 0) {
+  return (cwd) => {
+    const before = previousGeneration(cwd);
+    const next = reload(cwd);
+    return { status: "refreshed", generation: next.generation, changed: before === 0 || next.generation !== before };
+  };
+}
+function importedKind(plan, result, name) {
+  if (result.published) {
+    try {
+      const saved = readPluginInstallRecord(name, { cwd: plan.cwd, scope: plan.scope });
+      if (saved?.kind) return saved.kind;
+    } catch {
+    }
+  }
+  try {
+    const manifest = plan.files?.["plugin.json"];
+    const parsed = manifest ? JSON.parse(manifest) : void 0;
+    const kind = parsed?.extensions?.["ai.iowarp.clio"]?.kind;
+    if (isLibraryKind(kind)) return kind;
+  } catch {
+  }
+  return "plugin";
+}
+function libraryImportOutcome(plan, result) {
+  const name = result.installed ?? plan.id ?? path.basename(plan.source.root);
+  const identity = identityOf(importedKind(plan, result, name), name, plan.scope);
+  if (!result.published)
+    return {
+      status: "failed",
+      operation: "install",
+      identity,
+      diagnostics: result.diagnostics,
+      error: {
+        code: "refused",
+        message: result.diagnostics.join("; ") || "import not published",
+        next: nextFor("refused")
+      }
+    };
+  const outcome = {
+    status: "committed",
+    operation: "install",
+    identity,
+    diagnostics: [...result.diagnostics, `foreign trust; project-import gate ${String(result.admission.gateEnabled)}`]
+  };
+  annotateVerification(outcome, plan.cwd, "pre-refresh", false);
+  return outcome;
+}
+
+export {
+  releaseLibraryLifecycle,
+  libraryLifecyclePlanSummary,
+  planLibraryLifecycle,
+  verifyLibraryStep,
+  applyLibraryLifecycle,
+  retryLibraryRefresh,
+  pluginSnapshotRefreshHost,
+  libraryImportOutcome
+};
+//# sourceMappingURL=chunk-MNQN3X6Y.js.map

package/dist/{chunk-3QKXHCGS.js → chunk-MZHXENL7.js}

@@ -1,4 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  StringEnum
+} from "./chunk-5CMARGPF.js";
 import {
   typebox_exports
 } from "./chunk-GH5ZR6JP.js";
@@ -7,10 +10,7 @@ import {
 } from "./chunk-M4KFUXS7.js";
 import {
   ToolNames
-} from "./chunk-EHOSNVVM.js";
-import {
-  StringEnum
-} from "./chunk-5CMARGPF.js";
+} from "./chunk-WLHX3MM5.js";
 import {
   init_esm_shims
 } from "./chunk-ECBHH7LU.js";
@@ -56,4 +56,4 @@ export {
   prepareVerifyArguments,
   verifyToolSurface
 };
-//# sourceMappingURL=chunk-3QKXHCGS.js.map
+//# sourceMappingURL=chunk-MZHXENL7.js.map