@caatinga/core 0.2.4 → 2.0.1

package/dist/index.js

@@ -1,11 +1,78 @@
-import {
-  CaatingaError,
-  CaatingaErrorCode,
-  toCaatingaError
-} from "./chunk-EKHNKCJV.js";
+// src/errors/CaatingaErrorCode.ts
+var CaatingaErrorCode = {
+  CONFIG_NOT_FOUND: "CAATINGA_CONFIG_NOT_FOUND",
+  INVALID_CONFIG: "CAATINGA_INVALID_CONFIG",
+  COMMAND_FAILED: "CAATINGA_COMMAND_FAILED",
+  UNEXPECTED_ERROR: "CAATINGA_UNEXPECTED_ERROR",
+  STELLAR_CLI_NOT_FOUND: "CAATINGA_STELLAR_CLI_NOT_FOUND",
+  STELLAR_CLI_VERSION_PARSE_FAILED: "CAATINGA_STELLAR_CLI_VERSION_PARSE_FAILED",
+  UNSUPPORTED_CLI_VERSION: "CAATINGA_UNSUPPORTED_CLI_VERSION",
+  RUST_NOT_FOUND: "CAATINGA_RUST_NOT_FOUND",
+  RUST_TARGET_NOT_FOUND: "CAATINGA_RUST_TARGET_NOT_FOUND",
+  DEPLOY_FAILED: "CAATINGA_DEPLOY_FAILED",
+  BUILD_FAILED: "CAATINGA_BUILD_FAILED",
+  BINDINGS_FAILED: "CAATINGA_BINDINGS_FAILED",
+  INVOKE_FAILED: "CAATINGA_INVOKE_FAILED",
+  CONTRACT_NOT_FOUND: "CAATINGA_CONTRACT_NOT_FOUND",
+  NETWORK_NOT_FOUND: "CAATINGA_NETWORK_NOT_FOUND",
+  ARTIFACT_NOT_FOUND: "CAATINGA_ARTIFACT_NOT_FOUND",
+  ARTIFACT_INVALID: "CAATINGA_ARTIFACT_INVALID",
+  CONTRACT_ID_NOT_FOUND: "CAATINGA_CONTRACT_ID_NOT_FOUND",
+  CONTRACT_ARTIFACT_NOT_FOUND: "CAATINGA_CONTRACT_ARTIFACT_NOT_FOUND",
+  CONTRACT_DEPENDENCY_NOT_FOUND: "CAATINGA_CONTRACT_DEPENDENCY_NOT_FOUND",
+  CONTRACT_DEPENDENCY_CYCLE: "CAATINGA_CONTRACT_DEPENDENCY_CYCLE",
+  CONTRACT_DEPENDENCY_ARTIFACT_NOT_FOUND: "CAATINGA_CONTRACT_DEPENDENCY_ARTIFACT_NOT_FOUND",
+  DEPENDENCY_CONTRACT_NOT_FOUND: "CAATINGA_DEPENDENCY_CONTRACT_NOT_FOUND",
+  DEPLOY_ARG_PLACEHOLDER_INVALID: "CAATINGA_DEPLOY_ARG_PLACEHOLDER_INVALID",
+  DEPLOY_ARG_PLACEHOLDER_UNRESOLVED: "CAATINGA_DEPLOY_ARG_PLACEHOLDER_UNRESOLVED",
+  BINDING_CLIENT_NOT_FOUND: "CAATINGA_BINDING_CLIENT_NOT_FOUND",
+  BINDING_METHOD_NOT_FOUND: "CAATINGA_BINDING_METHOD_NOT_FOUND",
+  XDR_BUILD_FAILED: "CAATINGA_XDR_BUILD_FAILED",
+  XDR_PREPARE_FAILED: "CAATINGA_XDR_PREPARE_FAILED",
+  XDR_SIGN_FAILED: "CAATINGA_XDR_SIGN_FAILED",
+  XDR_SUBMIT_FAILED: "CAATINGA_XDR_SUBMIT_FAILED",
+  XDR_RESULT_FAILED: "CAATINGA_XDR_RESULT_FAILED",
+  READ_RESULT_MISSING: "CAATINGA_READ_RESULT_MISSING",
+  WALLET_NOT_CONNECTED: "CAATINGA_WALLET_NOT_CONNECTED",
+  WALLET_TIMEOUT: "CAATINGA_WALLET_TIMEOUT",
+  SOURCE_ACCOUNT_REQUIRED: "CAATINGA_SOURCE_ACCOUNT_REQUIRED",
+  SOURCE_IS_SECRET_KEY: "CAATINGA_SOURCE_IS_SECRET_KEY",
+  SOURCE_IS_SEED_PHRASE: "CAATINGA_SOURCE_IS_SEED_PHRASE",
+  SOURCE_IS_PUBLIC_KEY: "CAATINGA_SOURCE_IS_PUBLIC_KEY",
+  UNSAFE_SOURCE_ACCOUNT: "CAATINGA_UNSAFE_SOURCE_ACCOUNT",
+  INVOKE_TARGET_INVALID: "CAATINGA_INVOKE_TARGET_INVALID",
+  TEMPLATE_NOT_FOUND: "CAATINGA_TEMPLATE_NOT_FOUND",
+  INVALID_TEMPLATE_MANIFEST: "CAATINGA_INVALID_TEMPLATE_MANIFEST",
+  TEMPLATE_MANIFEST_NOT_FOUND: "CAATINGA_TEMPLATE_MANIFEST_NOT_FOUND",
+  TEMPLATE_INCOMPATIBLE: "CAATINGA_TEMPLATE_INCOMPATIBLE",
+  DOCTOR_PARTIAL_DEPLOY: "CAATINGA_DOCTOR_PARTIAL_DEPLOY"
+};
+
+// src/errors/CaatingaError.ts
+var CaatingaError = class extends Error {
+  constructor(message, code, hint, cause) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+    this.cause = cause;
+    this.name = "CaatingaError";
+  }
+  code;
+  hint;
+  cause;
+};
+function toCaatingaError(error) {
+  if (error instanceof CaatingaError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return new CaatingaError(error.message, CaatingaErrorCode.UNEXPECTED_ERROR, void 0, error);
+  }
+  return new CaatingaError("An unexpected error occurred.", CaatingaErrorCode.UNEXPECTED_ERROR);
+}
 
 // src/version.ts
-var CAATINGA_CORE_VERSION = "0.2.4";
+var CAATINGA_CORE_VERSION = "2.0.1";
 
 // src/config/config.schema.ts
 import { z } from "zod";
@@ -134,11 +201,20 @@ async function writeArtifacts(artifacts, cwd = process.cwd()) {
 `, "utf8");
   return artifactsPath;
 }
-function createInitialArtifacts(project) {
+function createInitialArtifacts(project, options = {}) {
+  const networks = Object.fromEntries(
+    Array.from(new Set(options.networks ?? [])).map((network) => [
+      network,
+      {
+        contracts: {},
+        dependencyGraph: {}
+      }
+    ])
+  );
   return {
     project,
     version: 1,
-    networks: {}
+    networks
   };
 }
 
@@ -190,10 +266,12 @@ function resolveNetwork(config, networkName) {
 // src/shell/run-command.ts
 import { execa } from "execa";
 
+// src/stellar-cli/compat.ts
+import semver2 from "semver";
+
 // src/stellar-cli/version.ts
 import semver from "semver";
 var STELLAR_CLI_MIN_VERSION = "23.0.0";
-var STELLAR_CLI_TESTED_MAX_VERSION = "25.2.0";
 var STELLAR_CLI_SEMVER_REGEX = /\b(\d+\.\d+\.\d+(?:-[0-9A-Za-z-.]+)?(?:\+[0-9A-Za-z-.]+)?)\b/;
 function parseStellarCliVersion(output) {
   const match = output.match(STELLAR_CLI_SEMVER_REGEX);
@@ -207,43 +285,66 @@ function parseStellarCliVersion(output) {
   }
   return version;
 }
-function assertSupportedStellarCliVersion(input) {
-  const normalizedVersion = semver.valid(input.version);
-  if (!normalizedVersion) {
+
+// src/stellar-cli/compat.ts
+var STELLAR_CLI_LAST_TESTED_VERSION = "25.2.0";
+function evaluateStellarCliCompatibility(input) {
+  const parsed = semver2.parse(input.version);
+  if (!parsed || !semver2.valid(input.version)) {
     throw new CaatingaError(
       "Could not parse Stellar CLI version.",
       CaatingaErrorCode.STELLAR_CLI_VERSION_PARSE_FAILED,
       "Use a semantic version such as 22.0.1."
     );
   }
-  if (semver.lt(normalizedVersion, STELLAR_CLI_MIN_VERSION)) {
+  const lastTestedVersion = semver2.valid(input.lastTestedVersion ?? STELLAR_CLI_LAST_TESTED_VERSION) ?? STELLAR_CLI_LAST_TESTED_VERSION;
+  const warnings = [];
+  let status = "supported";
+  if (semver2.lt(parsed, STELLAR_CLI_MIN_VERSION)) {
     throw new CaatingaError(
-      `Stellar CLI ${normalizedVersion} is below the supported minimum ${STELLAR_CLI_MIN_VERSION}.`,
+      `Stellar CLI ${input.version} is below the supported minimum ${STELLAR_CLI_MIN_VERSION}.`,
       CaatingaErrorCode.UNSUPPORTED_CLI_VERSION,
       `Install Stellar CLI ${STELLAR_CLI_MIN_VERSION} or newer.`
     );
   }
-  if (!input.allowUntested && semver.gt(normalizedVersion, STELLAR_CLI_TESTED_MAX_VERSION)) {
-    throw new CaatingaError(
-      `Stellar CLI ${normalizedVersion} is newer than the tested maximum ${STELLAR_CLI_TESTED_MAX_VERSION}.`,
-      CaatingaErrorCode.UNTESTED_CLI_VERSION,
-      "Pass --allow-untested-stellar-cli only after accepting the compatibility risk."
-    );
+  if (semver2.gt(parsed, lastTestedVersion)) {
+    status = "untested";
+    warnings.push({
+      code: "STELLAR_CLI_UNTESTED_VERSION",
+      message: `Stellar CLI ${input.version} is newer than the last-tested ${lastTestedVersion}; proceeding without compatibility guarantees.`,
+      remediation: "Pin Stellar CLI to the last-tested version, or update Caatinga after re-running the parser fixtures."
+    });
+  }
+  if (input.features) {
+    for (const feature of input.features) {
+      if (!feature) {
+        continue;
+      }
+      status = "untested";
+      warnings.push({
+        code: "STELLAR_CLI_MISSING_FEATURE",
+        message: `Stellar CLI ${input.version} did not advertise the required feature "${feature}".`,
+        remediation: "Upgrade Stellar CLI or run `caatinga doctor` for diagnostics."
+      });
+    }
   }
-  return normalizedVersion;
+  return {
+    version: input.version,
+    status,
+    minVersion: STELLAR_CLI_MIN_VERSION,
+    lastTestedVersion,
+    warnings
+  };
 }
 
 // src/stellar-cli/check-stellar-cli-version.ts
-async function checkStellarCliVersion(input) {
+async function checkStellarCliVersion(input = {}) {
+  let rawOutput;
   try {
     const result = await runCommand("stellar", ["--version"], {
       skipStellarVersionCheck: true
     });
-    const output = result.all || result.stdout || result.stderr;
-    return assertSupportedStellarCliVersion({
-      version: parseStellarCliVersion(output),
-      allowUntested: input.allowUntested
-    });
+    rawOutput = result.all || result.stdout || result.stderr;
   } catch (error) {
     if (typeof error === "object" && error && "code" in error && error.code === "ENOENT") {
       throw new CaatingaError(
@@ -255,15 +356,34 @@ async function checkStellarCliVersion(input) {
     }
     throw error;
   }
+  const report = evaluateStellarCliCompatibility({
+    version: parseStellarCliVersion(rawOutput),
+    features: input.features,
+    lastTestedVersion: input.lastTestedVersion
+  });
+  for (const warning of report.warnings) {
+    if (input.onWarning) {
+      input.onWarning(warning);
+    } else {
+      defaultEmitWarning(warning);
+    }
+  }
+  return report;
+}
+function defaultEmitWarning(warning) {
+  const lines = [
+    `Warning: ${warning.message}`,
+    warning.remediation ? `  ${warning.remediation}` : void 0
+  ].filter((line) => Boolean(line));
+  process.stderr.write(`${lines.join("\n")}
+`);
 }
 
 // src/shell/run-command.ts
 async function runCommand(command, args, options = {}) {
   try {
     if (command === "stellar" && !options.skipStellarVersionCheck) {
-      await checkStellarCliVersion({
-        allowUntested: options.allowUntestedStellarCli === true
-      });
+      await checkStellarCliVersion();
     }
     const result = await execa(command, args, {
       cwd: options.cwd,
@@ -404,7 +524,6 @@ async function resolveContractIdFromDeploySalt(options) {
     ...buildStellarNetworkArgsFromConfig(options.network)
   ], {
     cwd: options.cwd,
-    allowUntestedStellarCli: options.allowUntestedStellarCli,
     skipStellarVersionCheck: true
   });
   return parseContractId(result.all || `${result.stdout}
@@ -427,8 +546,7 @@ async function tryRecoverContractIdFromDeployFailure(options) {
     salt,
     source: options.source,
     network: options.network,
-    cwd: options.cwd,
-    allowUntestedStellarCli: options.allowUntestedStellarCli
+    cwd: options.cwd
   });
 }
 
@@ -578,7 +696,6 @@ function formatStaleWasmWarning(contractName) {
 }
 
 // src/contracts/build-contract.ts
-var RUST_WASM_TARGET = "wasm32v1-none";
 var MISSING_WASM_TARGET_HINT_SUBSTRINGS = [
   "not installed",
   "not found",
@@ -596,7 +713,7 @@ function isMissingRustWasmTargetError(error) {
     error.cause === void 0 ? "" : String(error.cause)
   ];
   const haystack = parts.join("\n").toLowerCase();
-  if (!haystack.includes(RUST_WASM_TARGET)) {
+  if (!haystack.includes(CURRENT_RUST_WASM_TARGET)) {
     return false;
   }
   return MISSING_WASM_TARGET_HINT_SUBSTRINGS.some((needle) => haystack.includes(needle));
@@ -605,22 +722,19 @@ async function buildContract(options) {
   const cwd = options.cwd ?? process.cwd();
   const contract = resolveContract(options.config, options.contractName, cwd);
   await checkBinary("rustc", "Install Rust before running caatinga build.");
-  await checkBinary("stellar", "Install Stellar CLI before running caatinga build.", {
-    allowUntestedStellarCli: options.allowUntestedStellarCli
-  });
+  await checkBinary("stellar", "Install Stellar CLI before running caatinga build.");
   let result;
   try {
     result = await runCommand("stellar", ["contract", "build"], {
       cwd: contract.sourcePath,
-      allowUntestedStellarCli: options.allowUntestedStellarCli,
       failureCode: CaatingaErrorCode.BUILD_FAILED
     });
   } catch (error) {
     if (error instanceof CaatingaError && error.code === CaatingaErrorCode.BUILD_FAILED && isMissingRustWasmTargetError(error)) {
       throw new CaatingaError(
-        `Required Rust wasm target "${RUST_WASM_TARGET}" is missing.`,
+        `Required Rust wasm target "${CURRENT_RUST_WASM_TARGET}" is missing.`,
         CaatingaErrorCode.RUST_TARGET_NOT_FOUND,
-        `Run \`rustup target add ${RUST_WASM_TARGET}\` and retry.`,
+        `Run \`rustup target add ${CURRENT_RUST_WASM_TARGET}\` and retry.`,
         error
       );
     }
@@ -715,9 +829,7 @@ async function deployContract(options) {
   const contract = resolveContract(options.config, options.contractName, cwd);
   const network = resolveNetwork(options.config, options.networkName);
   const source = assertSafeSourceAccount(options.source);
-  await checkBinary("stellar", "Install Stellar CLI before running caatinga deploy.", {
-    allowUntestedStellarCli: options.allowUntestedStellarCli
-  });
+  await checkBinary("stellar", "Install Stellar CLI before running caatinga deploy.");
   const wasmPath = await resolveWasmArtifactPath(contract.wasmPath);
   const contractWithWasm = {
     ...contract,
@@ -785,7 +897,6 @@ async function deployContract(options) {
   try {
     const result = await runCommand("stellar", stellarArgs, {
       cwd,
-      allowUntestedStellarCli: options.allowUntestedStellarCli,
       failureCode: CaatingaErrorCode.DEPLOY_FAILED
     });
     output = result.all || `${result.stdout}
@@ -800,8 +911,7 @@ ${result.stderr}`;
 ${error.hint ?? ""}`,
       source,
       network: network.config,
-      cwd,
-      allowUntestedStellarCli: options.allowUntestedStellarCli
+      cwd
     });
     if (!recoveredContractId) {
       throw error;
@@ -894,6 +1004,16 @@ function resolveDeployOrder(input) {
   }
 }
 
+// src/contracts/deploy-skip.ts
+function toSkippedContract(name, contractId, network) {
+  return {
+    name,
+    contractId,
+    network,
+    reason: "already-deployed"
+  };
+}
+
 // src/contracts/verify-dependency-contract.ts
 async function verifyDependencyContract(options) {
   try {
@@ -906,7 +1026,6 @@ async function verifyDependencyContract(options) {
       ...buildStellarNetworkArgs(options.network)
     ], {
       cwd: options.cwd,
-      allowUntestedStellarCli: options.allowUntestedStellarCli,
       failureCode: CaatingaErrorCode.DEPENDENCY_CONTRACT_NOT_FOUND
     });
   } catch (error) {
@@ -935,8 +1054,7 @@ async function verifyDependencyContracts(options) {
       dependencyName,
       contractId: contractArtifact.contractId,
       network: options.network,
-      cwd: options.cwd,
-      allowUntestedStellarCli: options.allowUntestedStellarCli
+      cwd: options.cwd
     });
   }
 }
@@ -962,8 +1080,7 @@ async function deployContractGraph(options) {
         dependencies: contractConfig.dependsOn,
         artifacts,
         network,
-        cwd,
-        allowUntestedStellarCli: options.allowUntestedStellarCli
+        cwd
       });
     }
     const resolvedDeployArgs = resolveDeployArgs({
@@ -972,12 +1089,9 @@ async function deployContractGraph(options) {
       network: network.name
     });
     if (existing?.contractId && !options.force) {
-      skippedContracts.push({
-        name: contractName,
-        contractId: existing.contractId,
-        network: network.name,
-        reason: "already-deployed"
-      });
+      skippedContracts.push(
+        toSkippedContract(contractName, existing.contractId, network.name)
+      );
       continue;
     }
     const result = await deployContract({
@@ -986,7 +1100,6 @@ async function deployContractGraph(options) {
       networkName: network.name,
       source: options.source,
       cwd,
-      allowUntestedStellarCli: options.allowUntestedStellarCli,
       force: options.force,
       checkStaleWasm: options.checkStaleWasm,
       resolvedDeployArgs,
@@ -999,12 +1112,9 @@ async function deployContractGraph(options) {
       });
     }
     if (result.skipped) {
-      skippedContracts.push({
-        name: contractName,
-        contractId: result.contractId,
-        network: network.name,
-        reason: "already-deployed"
-      });
+      skippedContracts.push(
+        toSkippedContract(contractName, result.contractId, network.name)
+      );
     } else {
       deployedContracts.push({ name: contractName, contractId: result.contractId });
     }
@@ -1032,9 +1142,7 @@ async function generateBindings(options) {
       "Run caatinga deploy for this contract and network before generating bindings."
     );
   }
-  await checkBinary("stellar", "Install Stellar CLI before running caatinga generate.", {
-    allowUntestedStellarCli: options.allowUntestedStellarCli
-  });
+  await checkBinary("stellar", "Install Stellar CLI before running caatinga generate.");
   const outputDir = path7.resolve(cwd, options.config.frontend.bindingsOutput, options.contractName);
   await mkdir2(outputDir, { recursive: true });
   const result = await runCommand("stellar", [
@@ -1049,7 +1157,6 @@ async function generateBindings(options) {
     ...buildStellarNetworkArgs(network)
   ], {
     cwd,
-    allowUntestedStellarCli: options.allowUntestedStellarCli,
     failureCode: CaatingaErrorCode.BINDINGS_FAILED
   });
   return {
@@ -1087,9 +1194,7 @@ async function invokeContract(options) {
       "Run caatinga deploy for this contract and network before invoking it."
     );
   }
-  await checkBinary("stellar", "Install Stellar CLI before running caatinga invoke.", {
-    allowUntestedStellarCli: options.allowUntestedStellarCli
-  });
+  await checkBinary("stellar", "Install Stellar CLI before running caatinga invoke.");
   let result;
   try {
     result = await runCommand("stellar", [
@@ -1105,7 +1210,6 @@ async function invokeContract(options) {
       ...options.args ?? []
     ], {
       cwd,
-      allowUntestedStellarCli: options.allowUntestedStellarCli,
       failureCode: CaatingaErrorCode.INVOKE_FAILED
     });
   } catch (error) {
@@ -1141,7 +1245,7 @@ import { z as z6 } from "zod";
 
 // src/templates/template-manifest.schema.ts
 import { z as z5 } from "zod";
-import semver2 from "semver";
+import semver3 from "semver";
 var CURRENT_TEMPLATE_VERSION = 1;
 var TemplateManifestSchema = z5.object({
   name: z5.string().min(1),
@@ -1165,14 +1269,14 @@ var TemplateManifestSchema = z5.object({
   })
 });
 function defaultCompatibleCoreRange(coreVersion = CAATINGA_CORE_VERSION) {
-  const version = semver2.valid(semver2.coerce(coreVersion));
+  const version = semver3.valid(semver3.coerce(coreVersion));
   if (!version) {
     throw new Error(`Invalid core version: ${coreVersion}`);
   }
   return `^${version}`;
 }
 function isCoreVersionCompatible(range, coreVersion = CAATINGA_CORE_VERSION) {
-  return semver2.satisfies(coreVersion, range);
+  return semver3.satisfies(coreVersion, range);
 }
 function getTemplateCompatibilityIssue(manifest, coreVersion = CAATINGA_CORE_VERSION) {
   if (manifest.caatinga.templateVersion !== CURRENT_TEMPLATE_VERSION) {
@@ -1205,6 +1309,12 @@ function formatTemplateCompatibilityHint(issue) {
 }
 
 // src/templates/create-project-from-template.ts
+var TEMPLATE_COPY_EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  "target",
+  "test_snapshots",
+  "node_modules",
+  ".git"
+]);
 async function createProjectFromTemplate(options) {
   const targetDir = path8.resolve(options.targetDir);
   const templateDir = path8.resolve(options.templateDir);
@@ -1222,12 +1332,25 @@ async function createProjectFromTemplate(options) {
   await cp(templateDir, targetDir, {
     recursive: true,
     force: false,
-    errorOnExist: true
+    errorOnExist: true,
+    filter: (source) => shouldCopyTemplateEntry(templateDir, source)
   });
   await replaceTemplateVariables(targetDir, options.projectName);
-  await writeArtifacts(createInitialArtifacts(options.projectName), targetDir);
+  await ensureArtifacts(targetDir, options.projectName);
   return { targetDir, template: manifest };
 }
+async function ensureArtifacts(targetDir, projectName) {
+  try {
+    const artifacts = await readArtifacts(targetDir);
+    await writeArtifacts({ ...artifacts, project: projectName }, targetDir);
+  } catch (error) {
+    if (error instanceof CaatingaError && error.code === CaatingaErrorCode.ARTIFACT_NOT_FOUND) {
+      await writeArtifacts(createInitialArtifacts(projectName, { networks: ["testnet"] }), targetDir);
+      return;
+    }
+    throw error;
+  }
+}
 async function readTemplateManifest(templateDir) {
   const manifestPath = path8.join(templateDir, "caatinga.template.json");
   try {
@@ -1279,6 +1402,13 @@ async function replaceTemplateVariables(dir, projectName) {
     await writeFile2(entryPath, content.replaceAll("__PROJECT_NAME__", projectName), "utf8");
   }));
 }
+function shouldCopyTemplateEntry(templateDir, source) {
+  const relativePath = path8.relative(templateDir, source);
+  if (!relativePath || relativePath === ".") {
+    return true;
+  }
+  return !relativePath.split(path8.sep).some((segment) => TEMPLATE_COPY_EXCLUDED_DIRS.has(segment));
+}
 function isTextTemplateFile(filePath) {
   return [
     ".json",
@@ -1295,7 +1425,6 @@ function isTextTemplateFile(filePath) {
 // src/ci/is-transient-testnet-smoke-failure.ts
 var NO_RETRY_CAATINGA_SUBSTRINGS = [
   "CAATINGA_UNSUPPORTED_CLI_VERSION",
-  "CAATINGA_UNTESTED_CLI_VERSION",
   "CAATINGA_STELLAR_CLI_VERSION_PARSE_FAILED",
   "CAATINGA_STELLAR_CLI_NOT_FOUND",
   "CAATINGA_INVALID_CONFIG",
@@ -1319,19 +1448,20 @@ export {
   CaatingaConfigSchema,
   CaatingaError,
   CaatingaErrorCode,
+  STELLAR_CLI_LAST_TESTED_VERSION,
   STELLAR_CLI_MIN_VERSION,
-  STELLAR_CLI_TESTED_MAX_VERSION,
   TemplateManifestSchema,
   WELL_KNOWN_NETWORKS,
-  assertSupportedStellarCliVersion,
   buildContract,
   buildDependencyGraph,
   checkBinary,
+  checkStellarCliVersion,
   createInitialArtifacts,
   createProjectFromTemplate,
   defineConfig,
   deployContract,
   deployContractGraph,
+  evaluateStellarCliCompatibility,
   generateBindings,
   invokeContract,
   isTransientTestnetSmokeFailure,

package/dist/runtime/requirements.cjs

@@ -0,0 +1,50 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime/requirements.ts
+var requirements_exports = {};
+__export(requirements_exports, {
+  CURRENT_RUST_WASM_TARGET: () => CURRENT_RUST_WASM_TARGET,
+  NODE_MIN_MAJOR: () => NODE_MIN_MAJOR
+});
+module.exports = __toCommonJS(requirements_exports);
+
+// src/contracts/wasm.ts
+var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+var CURRENT_RUST_WASM_TARGET = "wasm32v1-none";
+
+// src/runtime/requirements.ts
+var NODE_MIN_MAJOR = 20;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CURRENT_RUST_WASM_TARGET,
+  NODE_MIN_MAJOR
+});

package/dist/runtime/requirements.d.cts

@@ -0,0 +1,5 @@
+declare const CURRENT_RUST_WASM_TARGET = "wasm32v1-none";
+
+declare const NODE_MIN_MAJOR = 20;
+
+export { CURRENT_RUST_WASM_TARGET, NODE_MIN_MAJOR };

package/dist/runtime/requirements.d.ts

@@ -0,0 +1,5 @@
+declare const CURRENT_RUST_WASM_TARGET = "wasm32v1-none";
+
+declare const NODE_MIN_MAJOR = 20;
+
+export { CURRENT_RUST_WASM_TARGET, NODE_MIN_MAJOR };

package/dist/runtime/requirements.js

@@ -0,0 +1,12 @@
+// src/contracts/wasm.ts
+import { createHash } from "crypto";
+import { access, readdir, readFile, stat } from "fs/promises";
+import path from "path";
+var CURRENT_RUST_WASM_TARGET = "wasm32v1-none";
+
+// src/runtime/requirements.ts
+var NODE_MIN_MAJOR = 20;
+export {
+  CURRENT_RUST_WASM_TARGET,
+  NODE_MIN_MAJOR
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caatinga/core",
-  "version": "0.2.4",
+  "version": "2.0.1",
   "description": "Core config, artifacts, command orchestration, and error primitives for Caatinga/Soroban toolkit",
   "keywords": [
     "stellar",
@@ -36,6 +36,11 @@
       "types": "./dist/browser.d.ts",
       "import": "./dist/browser.js",
       "require": "./dist/browser.cjs"
+    },
+    "./runtime/requirements": {
+      "types": "./dist/runtime/requirements.d.ts",
+      "import": "./dist/runtime/requirements.js",
+      "require": "./dist/runtime/requirements.cjs"
     }
   },
   "files": [
@@ -56,7 +61,7 @@
     "vitest": "^2.1.8"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/browser.ts --format esm,cjs --dts",
+    "build": "tsup",
     "test": "vitest run --pool=threads",
     "typecheck": "tsc --noEmit"
   }