@caatinga/core 0.2.3 → 2.0.0

package/README.md

@@ -27,7 +27,7 @@ Most applications should install `@caatinga/cli` or `@caatinga/client` instead o
 - `buildDependencyGraph`, `resolveDeployOrder`, `resolveDeployArgs`
 - `generateBindings`, `invokeContract`, `parseInvokeTarget`
 - `resolveContract`, `parseContractId`
-- Stellar CLI version constants and guards (`STELLAR_CLI_MIN_VERSION`, `STELLAR_CLI_TESTED_MAX_VERSION`, `assertSupportedStellarCliVersion`)
+- Stellar CLI compatibility — `parseStellarCliVersion`, `checkStellarCliVersion`, `evaluateStellarCliCompatibility`, and the `STELLAR_CLI_MIN_VERSION` / `STELLAR_CLI_LAST_TESTED_VERSION` constants. The compatibility model is feature-aware: the hard floor (`23.0.0`) is the only hard failure, the last-tested version is advisory, and the optional `features` argument is a forward-compatible hook for capability checks. See the [Stellar CLI version contract](https://github.com/Dione-b/caatinga/blob/main/docs/stellar-cli-version-contract.md) for the full contract.
 
 ### Templates
 
@@ -87,7 +87,7 @@ Core owns the canonical `CAATINGA_*` enum used by CLI, client, and templates. Au
 Common codes surfaced through core-backed commands:
 
 - config and artifacts: `CAATINGA_CONFIG_NOT_FOUND`, `CAATINGA_INVALID_CONFIG`, `CAATINGA_ARTIFACT_NOT_FOUND`, `CAATINGA_ARTIFACT_INVALID`
-- Stellar CLI: `CAATINGA_STELLAR_CLI_NOT_FOUND`, `CAATINGA_UNSUPPORTED_CLI_VERSION`, `CAATINGA_UNTESTED_CLI_VERSION`
+- Stellar CLI: `CAATINGA_STELLAR_CLI_NOT_FOUND`, `CAATINGA_UNSUPPORTED_CLI_VERSION`
 - contracts: `CAATINGA_BUILD_FAILED`, `CAATINGA_DEPLOY_FAILED`, `CAATINGA_BINDINGS_FAILED`, `CAATINGA_INVOKE_FAILED`
 - dependencies: `CAATINGA_CONTRACT_DEPENDENCY_NOT_FOUND`, `CAATINGA_CONTRACT_DEPENDENCY_CYCLE`, `CAATINGA_DEPLOY_ARG_PLACEHOLDER_UNRESOLVED`
 - templates: `CAATINGA_TEMPLATE_MANIFEST_NOT_FOUND`, `CAATINGA_TEMPLATE_INCOMPATIBLE`

package/dist/{browser-CuET2GqM.d.cts → browser-djYObNl8.d.cts}

@@ -8,7 +8,6 @@ declare const CaatingaErrorCode: {
     readonly STELLAR_CLI_NOT_FOUND: "CAATINGA_STELLAR_CLI_NOT_FOUND";
     readonly STELLAR_CLI_VERSION_PARSE_FAILED: "CAATINGA_STELLAR_CLI_VERSION_PARSE_FAILED";
     readonly UNSUPPORTED_CLI_VERSION: "CAATINGA_UNSUPPORTED_CLI_VERSION";
-    readonly UNTESTED_CLI_VERSION: "CAATINGA_UNTESTED_CLI_VERSION";
     readonly RUST_NOT_FOUND: "CAATINGA_RUST_NOT_FOUND";
     readonly RUST_TARGET_NOT_FOUND: "CAATINGA_RUST_TARGET_NOT_FOUND";
     readonly DEPLOY_FAILED: "CAATINGA_DEPLOY_FAILED";

package/dist/{browser-CuET2GqM.d.ts → browser-djYObNl8.d.ts}

@@ -8,7 +8,6 @@ declare const CaatingaErrorCode: {
     readonly STELLAR_CLI_NOT_FOUND: "CAATINGA_STELLAR_CLI_NOT_FOUND";
     readonly STELLAR_CLI_VERSION_PARSE_FAILED: "CAATINGA_STELLAR_CLI_VERSION_PARSE_FAILED";
     readonly UNSUPPORTED_CLI_VERSION: "CAATINGA_UNSUPPORTED_CLI_VERSION";
-    readonly UNTESTED_CLI_VERSION: "CAATINGA_UNTESTED_CLI_VERSION";
     readonly RUST_NOT_FOUND: "CAATINGA_RUST_NOT_FOUND";
     readonly RUST_TARGET_NOT_FOUND: "CAATINGA_RUST_TARGET_NOT_FOUND";
     readonly DEPLOY_FAILED: "CAATINGA_DEPLOY_FAILED";

package/dist/browser.cjs

@@ -35,7 +35,6 @@ var CaatingaErrorCode = {
   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",
-  UNTESTED_CLI_VERSION: "CAATINGA_UNTESTED_CLI_VERSION",
   RUST_NOT_FOUND: "CAATINGA_RUST_NOT_FOUND",
   RUST_TARGET_NOT_FOUND: "CAATINGA_RUST_TARGET_NOT_FOUND",
   DEPLOY_FAILED: "CAATINGA_DEPLOY_FAILED",

package/dist/browser.d.cts

@@ -1,2 +1,2 @@
-export { C as CaatingaArtifacts, c as CaatingaError, e as CaatingaErrorCode, a as ContractArtifact, t as toCaatingaError } from './browser-CuET2GqM.cjs';
+export { C as CaatingaArtifacts, c as CaatingaError, e as CaatingaErrorCode, a as ContractArtifact, t as toCaatingaError } from './browser-djYObNl8.cjs';
 import 'zod';

package/dist/browser.d.ts

@@ -1,2 +1,2 @@
-export { C as CaatingaArtifacts, c as CaatingaError, e as CaatingaErrorCode, a as ContractArtifact, t as toCaatingaError } from './browser-CuET2GqM.js';
+export { C as CaatingaArtifacts, c as CaatingaError, e as CaatingaErrorCode, a as ContractArtifact, t as toCaatingaError } from './browser-djYObNl8.js';
 import 'zod';

package/dist/browser.js

@@ -1,8 +1,75 @@
-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);
+}
 export {
   CaatingaError,
   CaatingaErrorCode,

package/dist/index.cjs

@@ -35,19 +35,20 @@ __export(index_exports, {
   CaatingaConfigSchema: () => CaatingaConfigSchema,
   CaatingaError: () => CaatingaError,
   CaatingaErrorCode: () => CaatingaErrorCode,
+  STELLAR_CLI_LAST_TESTED_VERSION: () => STELLAR_CLI_LAST_TESTED_VERSION,
   STELLAR_CLI_MIN_VERSION: () => STELLAR_CLI_MIN_VERSION,
-  STELLAR_CLI_TESTED_MAX_VERSION: () => STELLAR_CLI_TESTED_MAX_VERSION,
   TemplateManifestSchema: () => TemplateManifestSchema,
   WELL_KNOWN_NETWORKS: () => WELL_KNOWN_NETWORKS,
-  assertSupportedStellarCliVersion: () => assertSupportedStellarCliVersion,
   buildContract: () => buildContract,
   buildDependencyGraph: () => buildDependencyGraph,
   checkBinary: () => checkBinary,
+  checkStellarCliVersion: () => checkStellarCliVersion,
   createInitialArtifacts: () => createInitialArtifacts,
   createProjectFromTemplate: () => createProjectFromTemplate,
   defineConfig: () => defineConfig,
   deployContract: () => deployContract,
   deployContractGraph: () => deployContractGraph,
+  evaluateStellarCliCompatibility: () => evaluateStellarCliCompatibility,
   generateBindings: () => generateBindings,
   invokeContract: () => invokeContract,
   isTransientTestnetSmokeFailure: () => isTransientTestnetSmokeFailure,
@@ -77,7 +78,6 @@ var CaatingaErrorCode = {
   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",
-  UNTESTED_CLI_VERSION: "CAATINGA_UNTESTED_CLI_VERSION",
   RUST_NOT_FOUND: "CAATINGA_RUST_NOT_FOUND",
   RUST_TARGET_NOT_FOUND: "CAATINGA_RUST_TARGET_NOT_FOUND",
   DEPLOY_FAILED: "CAATINGA_DEPLOY_FAILED",
@@ -143,7 +143,7 @@ function toCaatingaError(error) {
 }
 
 // src/version.ts
-var CAATINGA_CORE_VERSION = "0.2.3";
+var CAATINGA_CORE_VERSION = "2.0.0";
 
 // src/config/config.schema.ts
 var import_zod = require("zod");
@@ -273,11 +273,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
   };
 }
 
@@ -329,10 +338,12 @@ function resolveNetwork(config, networkName) {
 // src/shell/run-command.ts
 var import_execa = require("execa");
 
+// src/stellar-cli/compat.ts
+var import_semver2 = __toESM(require("semver"), 1);
+
 // src/stellar-cli/version.ts
 var import_semver = __toESM(require("semver"), 1);
 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);
@@ -346,43 +357,66 @@ function parseStellarCliVersion(output) {
   }
   return version;
 }
-function assertSupportedStellarCliVersion(input) {
-  const normalizedVersion = import_semver.default.valid(input.version);
-  if (!normalizedVersion) {
+
+// src/stellar-cli/compat.ts
+var STELLAR_CLI_LAST_TESTED_VERSION = "25.2.0";
+function evaluateStellarCliCompatibility(input) {
+  const parsed = import_semver2.default.parse(input.version);
+  if (!parsed || !import_semver2.default.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 (import_semver.default.lt(normalizedVersion, STELLAR_CLI_MIN_VERSION)) {
+  const lastTestedVersion = import_semver2.default.valid(input.lastTestedVersion ?? STELLAR_CLI_LAST_TESTED_VERSION) ?? STELLAR_CLI_LAST_TESTED_VERSION;
+  const warnings = [];
+  let status = "supported";
+  if (import_semver2.default.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 && import_semver.default.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 (import_semver2.default.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."
+    });
   }
-  return normalizedVersion;
+  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 {
+    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(
@@ -394,15 +428,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 (0, import_execa.execa)(command, args, {
       cwd: options.cwd,
@@ -543,7 +596,6 @@ async function resolveContractIdFromDeploySalt(options) {
     ...buildStellarNetworkArgsFromConfig(options.network)
   ], {
     cwd: options.cwd,
-    allowUntestedStellarCli: options.allowUntestedStellarCli,
     skipStellarVersionCheck: true
   });
   return parseContractId(result.all || `${result.stdout}
@@ -566,8 +618,7 @@ async function tryRecoverContractIdFromDeployFailure(options) {
     salt,
     source: options.source,
     network: options.network,
-    cwd: options.cwd,
-    allowUntestedStellarCli: options.allowUntestedStellarCli
+    cwd: options.cwd
   });
 }
 
@@ -717,7 +768,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",
@@ -735,7 +785,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));
@@ -744,22 +794,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
       );
     }
@@ -854,9 +901,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,
@@ -924,7 +969,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}
@@ -939,8 +983,7 @@ ${result.stderr}`;
 ${error.hint ?? ""}`,
       source,
       network: network.config,
-      cwd,
-      allowUntestedStellarCli: options.allowUntestedStellarCli
+      cwd
     });
     if (!recoveredContractId) {
       throw error;
@@ -1033,6 +1076,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 {
@@ -1045,7 +1098,6 @@ async function verifyDependencyContract(options) {
       ...buildStellarNetworkArgs(options.network)
     ], {
       cwd: options.cwd,
-      allowUntestedStellarCli: options.allowUntestedStellarCli,
       failureCode: CaatingaErrorCode.DEPENDENCY_CONTRACT_NOT_FOUND
     });
   } catch (error) {
@@ -1074,8 +1126,7 @@ async function verifyDependencyContracts(options) {
       dependencyName,
       contractId: contractArtifact.contractId,
       network: options.network,
-      cwd: options.cwd,
-      allowUntestedStellarCli: options.allowUntestedStellarCli
+      cwd: options.cwd
     });
   }
 }
@@ -1101,8 +1152,7 @@ async function deployContractGraph(options) {
         dependencies: contractConfig.dependsOn,
         artifacts,
         network,
-        cwd,
-        allowUntestedStellarCli: options.allowUntestedStellarCli
+        cwd
       });
     }
     const resolvedDeployArgs = resolveDeployArgs({
@@ -1111,12 +1161,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({
@@ -1125,7 +1172,6 @@ async function deployContractGraph(options) {
       networkName: network.name,
       source: options.source,
       cwd,
-      allowUntestedStellarCli: options.allowUntestedStellarCli,
       force: options.force,
       checkStaleWasm: options.checkStaleWasm,
       resolvedDeployArgs,
@@ -1138,12 +1184,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 });
     }
@@ -1171,9 +1214,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 = import_node_path7.default.resolve(cwd, options.config.frontend.bindingsOutput, options.contractName);
   await (0, import_promises5.mkdir)(outputDir, { recursive: true });
   const result = await runCommand("stellar", [
@@ -1188,7 +1229,6 @@ async function generateBindings(options) {
     ...buildStellarNetworkArgs(network)
   ], {
     cwd,
-    allowUntestedStellarCli: options.allowUntestedStellarCli,
     failureCode: CaatingaErrorCode.BINDINGS_FAILED
   });
   return {
@@ -1226,9 +1266,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", [
@@ -1244,7 +1282,6 @@ async function invokeContract(options) {
       ...options.args ?? []
     ], {
       cwd,
-      allowUntestedStellarCli: options.allowUntestedStellarCli,
       failureCode: CaatingaErrorCode.INVOKE_FAILED
     });
   } catch (error) {
@@ -1280,7 +1317,7 @@ var import_zod6 = require("zod");
 
 // src/templates/template-manifest.schema.ts
 var import_zod5 = require("zod");
-var import_semver2 = __toESM(require("semver"), 1);
+var import_semver3 = __toESM(require("semver"), 1);
 var CURRENT_TEMPLATE_VERSION = 1;
 var TemplateManifestSchema = import_zod5.z.object({
   name: import_zod5.z.string().min(1),
@@ -1304,14 +1341,14 @@ var TemplateManifestSchema = import_zod5.z.object({
   })
 });
 function defaultCompatibleCoreRange(coreVersion = CAATINGA_CORE_VERSION) {
-  const version = import_semver2.default.valid(import_semver2.default.coerce(coreVersion));
+  const version = import_semver3.default.valid(import_semver3.default.coerce(coreVersion));
   if (!version) {
     throw new Error(`Invalid core version: ${coreVersion}`);
   }
   return `^${version}`;
 }
 function isCoreVersionCompatible(range, coreVersion = CAATINGA_CORE_VERSION) {
-  return import_semver2.default.satisfies(coreVersion, range);
+  return import_semver3.default.satisfies(coreVersion, range);
 }
 function getTemplateCompatibilityIssue(manifest, coreVersion = CAATINGA_CORE_VERSION) {
   if (manifest.caatinga.templateVersion !== CURRENT_TEMPLATE_VERSION) {
@@ -1344,6 +1381,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 = import_node_path8.default.resolve(options.targetDir);
   const templateDir = import_node_path8.default.resolve(options.templateDir);
@@ -1361,12 +1404,25 @@ async function createProjectFromTemplate(options) {
   await (0, import_promises6.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 = import_node_path8.default.join(templateDir, "caatinga.template.json");
   try {
@@ -1418,6 +1474,13 @@ async function replaceTemplateVariables(dir, projectName) {
     await (0, import_promises6.writeFile)(entryPath, content.replaceAll("__PROJECT_NAME__", projectName), "utf8");
   }));
 }
+function shouldCopyTemplateEntry(templateDir, source) {
+  const relativePath = import_node_path8.default.relative(templateDir, source);
+  if (!relativePath || relativePath === ".") {
+    return true;
+  }
+  return !relativePath.split(import_node_path8.default.sep).some((segment) => TEMPLATE_COPY_EXCLUDED_DIRS.has(segment));
+}
 function isTextTemplateFile(filePath) {
   return [
     ".json",
@@ -1434,7 +1497,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",
@@ -1459,19 +1521,20 @@ function isTransientTestnetSmokeFailure(logText) {
   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,