@caatinga/core 2.0.2 → 2.2.0

package/dist/index.cjs

@@ -30,6 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BINDING_MARKER_FILENAME: () => BINDING_MARKER_FILENAME,
+  BindingMarkerSchema: () => BindingMarkerSchema,
   CAATINGA_CORE_VERSION: () => CAATINGA_CORE_VERSION,
   CaatingaArtifactsSchema: () => CaatingaArtifactsSchema,
   CaatingaConfigSchema: () => CaatingaConfigSchema,
@@ -43,13 +45,18 @@ __export(index_exports, {
   buildDependencyGraph: () => buildDependencyGraph,
   checkBinary: () => checkBinary,
   checkStellarCliVersion: () => checkStellarCliVersion,
+  collectProjectStatus: () => collectProjectStatus,
   createInitialArtifacts: () => createInitialArtifacts,
   createProjectFromTemplate: () => createProjectFromTemplate,
   defineConfig: () => defineConfig,
   deployContract: () => deployContract,
   deployContractGraph: () => deployContractGraph,
+  evaluateBindingFreshness: () => evaluateBindingFreshness,
+  evaluateBindingsFreshness: () => evaluateBindingsFreshness,
   evaluateStellarCliCompatibility: () => evaluateStellarCliCompatibility,
+  formatCaatingaError: () => formatCaatingaError,
   generateBindings: () => generateBindings,
+  generateBindingsGraph: () => generateBindingsGraph,
   invokeContract: () => invokeContract,
   isTransientTestnetSmokeFailure: () => isTransientTestnetSmokeFailure,
   loadConfig: () => loadConfig,
@@ -57,6 +64,7 @@ __export(index_exports, {
   parseInvokeTarget: () => parseInvokeTarget,
   parseStellarCliVersion: () => parseStellarCliVersion,
   readArtifacts: () => readArtifacts,
+  readBindingMarker: () => readBindingMarker,
   resolveContract: () => resolveContract,
   resolveDeployArgs: () => resolveDeployArgs,
   resolveDeployOrder: () => resolveDeployOrder,
@@ -65,7 +73,8 @@ __export(index_exports, {
   toCaatingaError: () => toCaatingaError,
   updateArtifact: () => updateArtifact,
   validateSourceShape: () => validateSourceShape,
-  writeArtifacts: () => writeArtifacts
+  writeArtifacts: () => writeArtifacts,
+  writeBindingMarker: () => writeBindingMarker
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -98,6 +107,7 @@ var CaatingaErrorCode = {
   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",
+  PLACEHOLDER_BINDING: "CAATINGA_PLACEHOLDER_BINDING",
   XDR_BUILD_FAILED: "CAATINGA_XDR_BUILD_FAILED",
   XDR_PREPARE_FAILED: "CAATINGA_XDR_PREPARE_FAILED",
   XDR_SIGN_FAILED: "CAATINGA_XDR_SIGN_FAILED",
@@ -142,8 +152,40 @@ function toCaatingaError(error) {
   return new CaatingaError("An unexpected error occurred.", CaatingaErrorCode.UNEXPECTED_ERROR);
 }
 
+// src/errors/format-caatinga-error.ts
+function formatCaatingaError(error) {
+  if (error instanceof CaatingaError) {
+    const lines = [`[${error.code}] ${error.message}`];
+    if (error.hint) {
+      lines.push("", error.hint);
+    }
+    const detail = formatCause(error.cause);
+    if (detail) {
+      lines.push("", `Details: ${detail}`);
+    }
+    return lines.join("\n");
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function formatCause(cause) {
+  if (cause === void 0 || cause === null) {
+    return "";
+  }
+  if (cause instanceof Error) {
+    return cause.message;
+  }
+  if (typeof cause === "string") {
+    return cause;
+  }
+  try {
+    return JSON.stringify(cause);
+  } catch {
+    return String(cause);
+  }
+}
+
 // src/version.ts
-var CAATINGA_CORE_VERSION = "2.0.2";
+var CAATINGA_CORE_VERSION = "2.2.0";
 
 // src/config/config.schema.ts
 var import_zod = require("zod");
@@ -309,18 +351,6 @@ function updateArtifact(artifacts, networkName, contractName, contractArtifact,
   };
 }
 
-// src/networks/networks.ts
-var WELL_KNOWN_NETWORKS = {
-  testnet: {
-    rpcUrl: "https://soroban-testnet.stellar.org",
-    networkPassphrase: "Test SDF Network ; September 2015"
-  },
-  mainnet: {
-    rpcUrl: "https://mainnet.sorobanrpc.com",
-    networkPassphrase: "Public Global Stellar Network ; September 2015"
-  }
-};
-
 // src/networks/resolve-network.ts
 function resolveNetwork(config, networkName) {
   const name = networkName ?? config.defaultNetwork;
@@ -335,6 +365,174 @@ function resolveNetwork(config, networkName) {
   return { name, config: network };
 }
 
+// src/bindings/binding-freshness.ts
+var import_promises5 = require("fs/promises");
+var import_node_path5 = __toESM(require("path"), 1);
+
+// src/bindings/binding-marker.ts
+var import_promises4 = require("fs/promises");
+var import_node_path4 = __toESM(require("path"), 1);
+var import_zod5 = require("zod");
+var BINDING_MARKER_FILENAME = ".caatinga-bindings.json";
+var BindingMarkerSchema = import_zod5.z.object({
+  version: import_zod5.z.literal(1),
+  contractId: import_zod5.z.string().min(1),
+  wasmHash: import_zod5.z.string().min(1),
+  network: import_zod5.z.string().min(1),
+  generatedAt: import_zod5.z.string().datetime()
+});
+async function writeBindingMarker(outputDir, marker) {
+  const markerPath = import_node_path4.default.join(outputDir, BINDING_MARKER_FILENAME);
+  await (0, import_promises4.writeFile)(markerPath, `${JSON.stringify(marker, null, 2)}
+`, "utf8");
+}
+async function readBindingMarker(outputDir) {
+  const markerPath = import_node_path4.default.join(outputDir, BINDING_MARKER_FILENAME);
+  let raw;
+  try {
+    raw = await (0, import_promises4.readFile)(markerPath, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    return BindingMarkerSchema.parse(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+
+// src/bindings/binding-freshness.ts
+async function listGeneratedEntries(outputDir) {
+  try {
+    const entries = await (0, import_promises5.readdir)(outputDir);
+    return entries.filter((entry) => entry !== BINDING_MARKER_FILENAME);
+  } catch {
+    return null;
+  }
+}
+async function evaluateBindingFreshness(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const outputDir = import_node_path5.default.resolve(cwd, options.config.frontend.bindingsOutput, options.contractName);
+  const contractArtifact = options.artifacts.networks[options.networkName]?.contracts[options.contractName];
+  if (!contractArtifact) {
+    return {
+      contractName: options.contractName,
+      status: "missing",
+      outputDir,
+      marker: null,
+      reason: `not deployed on "${options.networkName}"`
+    };
+  }
+  const generatedEntries = await listGeneratedEntries(outputDir);
+  if (generatedEntries === null || generatedEntries.length === 0) {
+    return {
+      contractName: options.contractName,
+      status: "missing",
+      outputDir,
+      marker: null,
+      reason: "no generated bindings found"
+    };
+  }
+  const marker = await readBindingMarker(outputDir);
+  if (!marker) {
+    return {
+      contractName: options.contractName,
+      status: "unknown",
+      outputDir,
+      marker: null,
+      reason: "bindings exist but have no provenance marker \u2014 rerun caatinga generate to record it"
+    };
+  }
+  if (marker.contractId !== contractArtifact.contractId) {
+    return {
+      contractName: options.contractName,
+      status: "stale",
+      outputDir,
+      marker,
+      reason: "contractId changed since last generate"
+    };
+  }
+  if (marker.wasmHash !== contractArtifact.wasmHash) {
+    return {
+      contractName: options.contractName,
+      status: "stale",
+      outputDir,
+      marker,
+      reason: "wasmHash changed since last generate"
+    };
+  }
+  return {
+    contractName: options.contractName,
+    status: "fresh",
+    outputDir,
+    marker
+  };
+}
+async function evaluateBindingsFreshness(options) {
+  const contractNames = Object.keys(
+    options.artifacts.networks[options.networkName]?.contracts ?? {}
+  );
+  const results = [];
+  for (const contractName of contractNames) {
+    results.push(await evaluateBindingFreshness({ ...options, contractName }));
+  }
+  return results;
+}
+
+// src/artifacts/project-status.ts
+async function collectProjectStatus(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const artifacts = await readArtifacts(cwd);
+  let networkNames;
+  if (options.networkName) {
+    networkNames = [resolveNetwork(options.config, options.networkName).name];
+  } else {
+    const fromArtifacts = Object.keys(artifacts.networks);
+    const fallback = options.config.defaultNetwork ?? "testnet";
+    networkNames = fromArtifacts.length > 0 ? fromArtifacts : [fallback];
+    if (!networkNames.includes(fallback) && options.config.networks[fallback]) {
+      networkNames.push(fallback);
+    }
+  }
+  const networks = [];
+  for (const networkName of networkNames) {
+    const contracts = [];
+    for (const name of Object.keys(options.config.contracts)) {
+      const artifact = artifacts.networks[networkName]?.contracts[name];
+      const bindings = await evaluateBindingFreshness({
+        config: options.config,
+        artifacts,
+        networkName,
+        contractName: name,
+        cwd
+      });
+      contracts.push({
+        name,
+        deployed: Boolean(artifact),
+        contractId: artifact?.contractId,
+        wasmHash: artifact?.wasmHash,
+        deployedAt: artifact?.deployedAt,
+        dependencies: artifact?.dependencies ?? options.config.contracts[name].dependsOn ?? [],
+        bindings
+      });
+    }
+    networks.push({ network: networkName, contracts });
+  }
+  return { project: options.config.project, networks };
+}
+
+// src/networks/networks.ts
+var WELL_KNOWN_NETWORKS = {
+  testnet: {
+    rpcUrl: "https://soroban-testnet.stellar.org",
+    networkPassphrase: "Test SDF Network ; September 2015"
+  },
+  mainnet: {
+    rpcUrl: "https://mainnet.sorobanrpc.com",
+    networkPassphrase: "Public Global Stellar Network ; September 2015"
+  }
+};
+
 // src/shell/run-command.ts
 var import_execa = require("execa");
 
@@ -656,7 +854,7 @@ function validateSourceShape(source) {
 }
 
 // src/contracts/resolve-contract.ts
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 function resolveContract(config, contractName, cwd = process.cwd()) {
   const contract = config.contracts[contractName];
   if (!contract) {
@@ -669,15 +867,15 @@ function resolveContract(config, contractName, cwd = process.cwd()) {
   return {
     name: contractName,
     config: contract,
-    sourcePath: import_node_path4.default.resolve(cwd, contract.path),
-    wasmPath: import_node_path4.default.resolve(cwd, contract.wasm)
+    sourcePath: import_node_path6.default.resolve(cwd, contract.path),
+    wasmPath: import_node_path6.default.resolve(cwd, contract.wasm)
   };
 }
 
 // src/contracts/wasm.ts
 var import_node_crypto = require("crypto");
-var import_promises4 = require("fs/promises");
-var import_node_path5 = __toESM(require("path"), 1);
+var import_promises6 = require("fs/promises");
+var import_node_path7 = __toESM(require("path"), 1);
 var LEGACY_RUST_WASM_TARGET = "wasm32-unknown-unknown";
 var CURRENT_RUST_WASM_TARGET = "wasm32v1-none";
 function toCurrentWasmTargetPath(wasmPath) {
@@ -700,12 +898,12 @@ function wasmNotFoundError(configuredWasmPath, options) {
   );
 }
 function toConfigRelativeWasmPath(absoluteWasmPath) {
-  const relative = import_node_path5.default.relative(process.cwd(), absoluteWasmPath);
-  return relative.startsWith("..") ? absoluteWasmPath : `./${relative.split(import_node_path5.default.sep).join("/")}`;
+  const relative = import_node_path7.default.relative(process.cwd(), absoluteWasmPath);
+  return relative.startsWith("..") ? absoluteWasmPath : `./${relative.split(import_node_path7.default.sep).join("/")}`;
 }
 async function resolveWasmArtifactPath(configuredWasmPath) {
   try {
-    await (0, import_promises4.access)(configuredWasmPath);
+    await (0, import_promises6.access)(configuredWasmPath);
     return configuredWasmPath;
   } catch {
     const currentTargetPath = toCurrentWasmTargetPath(configuredWasmPath);
@@ -713,7 +911,7 @@ async function resolveWasmArtifactPath(configuredWasmPath) {
       throw wasmNotFoundError(configuredWasmPath);
     }
     try {
-      await (0, import_promises4.access)(currentTargetPath);
+      await (0, import_promises6.access)(currentTargetPath);
       return currentTargetPath;
     } catch {
       throw wasmNotFoundError(configuredWasmPath, { migratedPath: currentTargetPath });
@@ -721,20 +919,20 @@ async function resolveWasmArtifactPath(configuredWasmPath) {
   }
 }
 async function hashWasm(wasmPath) {
-  const bytes = await (0, import_promises4.readFile)(wasmPath);
+  const bytes = await (0, import_promises6.readFile)(wasmPath);
   return (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
 }
 async function getNewestMtimeInDirectory(directory) {
   try {
-    await (0, import_promises4.access)(directory);
+    await (0, import_promises6.access)(directory);
   } catch {
     return void 0;
   }
   let newest = 0;
   async function walk(dir) {
-    const entries = await (0, import_promises4.readdir)(dir, { withFileTypes: true });
+    const entries = await (0, import_promises6.readdir)(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = import_node_path5.default.join(dir, entry.name);
+      const entryPath = import_node_path7.default.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(entryPath);
         continue;
@@ -742,7 +940,7 @@ async function getNewestMtimeInDirectory(directory) {
       if (!entry.isFile()) {
         continue;
       }
-      const fileStat = await (0, import_promises4.stat)(entryPath);
+      const fileStat = await (0, import_promises6.stat)(entryPath);
       newest = Math.max(newest, fileStat.mtimeMs);
     }
   }
@@ -750,14 +948,14 @@ async function getNewestMtimeInDirectory(directory) {
   return newest > 0 ? newest : void 0;
 }
 async function isWasmOlderThanSources(input) {
-  const srcDir = import_node_path5.default.join(input.contractPath, "src");
+  const srcDir = import_node_path7.default.join(input.contractPath, "src");
   const newestSourceMtime = await getNewestMtimeInDirectory(srcDir);
   if (newestSourceMtime === void 0) {
     return false;
   }
   let wasmStat;
   try {
-    wasmStat = await (0, import_promises4.stat)(input.wasmPath);
+    wasmStat = await (0, import_promises6.stat)(input.wasmPath);
   } catch {
     return false;
   }
@@ -823,7 +1021,7 @@ async function buildContract(options) {
 }
 
 // src/contracts/deploy-contract.ts
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 
 // src/contracts/dependency-graph.ts
 function buildDependencyGraph(contracts) {
@@ -924,7 +1122,7 @@ async function deployContract(options) {
       contract: contractWithWasm,
       network,
       contractId: existing.contractId,
-      artifactsPath: import_node_path6.default.resolve(cwd, "caatinga.artifacts.json"),
+      artifactsPath: import_node_path8.default.resolve(cwd, "caatinga.artifacts.json"),
       output: "",
       skipped: true,
       staleWasmWarning
@@ -1200,17 +1398,17 @@ async function deployContractGraph(options) {
 }
 
 // src/contracts/generate-bindings.ts
-var import_promises5 = require("fs/promises");
-var import_node_path7 = __toESM(require("path"), 1);
+var import_promises7 = require("fs/promises");
+var import_node_path9 = __toESM(require("path"), 1);
 function toBindingImportPath(bindingsOutput, contractName) {
-  const normalized = bindingsOutput.replace(/^\.\//, "").split(import_node_path7.default.sep).join("/");
-  return `./${import_node_path7.default.posix.join(normalized, contractName, "src", "index.js")}`;
+  const normalized = bindingsOutput.replace(/^\.\//, "").split(import_node_path9.default.sep).join("/");
+  return `./${import_node_path9.default.posix.join(normalized, contractName, "src", "index.js")}`;
 }
 async function removeLegacyBindingStub(cwd, bindingsOutput, contractName) {
-  const legacyPath = import_node_path7.default.resolve(cwd, bindingsOutput, `${contractName}.ts`);
+  const legacyPath = import_node_path9.default.resolve(cwd, bindingsOutput, `${contractName}.ts`);
   try {
-    await (0, import_promises5.access)(legacyPath);
-    await (0, import_promises5.unlink)(legacyPath);
+    await (0, import_promises7.access)(legacyPath);
+    await (0, import_promises7.unlink)(legacyPath);
     return true;
   } catch {
     return false;
@@ -1229,8 +1427,8 @@ async function generateBindings(options) {
     );
   }
   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 outputDir = import_node_path9.default.resolve(cwd, options.config.frontend.bindingsOutput, options.contractName);
+  await (0, import_promises7.mkdir)(outputDir, { recursive: true });
   const result = await runCommand("stellar", [
     "contract",
     "bindings",
@@ -1250,16 +1448,59 @@ async function generateBindings(options) {
     options.config.frontend.bindingsOutput,
     options.contractName
   );
+  const marker = {
+    version: 1,
+    contractId: contractArtifact.contractId,
+    wasmHash: contractArtifact.wasmHash,
+    network: network.name,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeBindingMarker(outputDir, marker);
   return {
     contractName: options.contractName,
     network,
     outputDir,
     importPath: toBindingImportPath(options.config.frontend.bindingsOutput, options.contractName),
     legacyStubRemoved,
+    marker,
     output: result.all || result.stdout
   };
 }
 
+// src/contracts/generate-bindings-graph.ts
+async function generateBindingsGraph(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const network = resolveNetwork(options.config, options.networkName);
+  let targets;
+  if (options.contractName) {
+    targets = [options.contractName];
+  } else if (options.contractNames && options.contractNames.length > 0) {
+    targets = options.contractNames;
+  } else {
+    const artifacts = await readArtifacts(cwd);
+    targets = Object.keys(artifacts.networks[network.name]?.contracts ?? {});
+    if (targets.length === 0) {
+      throw new CaatingaError(
+        `No deployed contracts found on "${network.name}".`,
+        CaatingaErrorCode.ARTIFACT_NOT_FOUND,
+        "Run caatinga deploy before generating bindings, or pass a contract name."
+      );
+    }
+  }
+  const results = [];
+  for (const contractName of targets) {
+    results.push(
+      await generateBindings({
+        config: options.config,
+        contractName,
+        networkName: network.name,
+        cwd
+      })
+    );
+  }
+  return { network, results };
+}
+
 // src/contracts/invoke-contract.ts
 var INVOKE_SIGNING_FAILURE_REGEX = /xdr processing error: xdr value invalid/i;
 function parseInvokeTarget(target) {
@@ -1332,33 +1573,33 @@ ${error.hint ?? ""}`)) {
 }
 
 // src/templates/create-project-from-template.ts
-var import_promises6 = require("fs/promises");
-var import_node_path8 = __toESM(require("path"), 1);
-var import_zod6 = require("zod");
+var import_promises8 = require("fs/promises");
+var import_node_path10 = __toESM(require("path"), 1);
+var import_zod7 = require("zod");
 
 // src/templates/template-manifest.schema.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 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),
-  version: import_zod5.z.string().min(1),
-  description: import_zod5.z.string().optional(),
-  caatinga: import_zod5.z.object({
-    compatibleCore: import_zod5.z.string().min(1),
-    templateVersion: import_zod5.z.number().int().positive()
+var TemplateManifestSchema = import_zod6.z.object({
+  name: import_zod6.z.string().min(1),
+  version: import_zod6.z.string().min(1),
+  description: import_zod6.z.string().optional(),
+  caatinga: import_zod6.z.object({
+    compatibleCore: import_zod6.z.string().min(1),
+    templateVersion: import_zod6.z.number().int().positive()
   }),
-  frontend: import_zod5.z.object({
-    framework: import_zod5.z.enum(["vite-react", "next", "astro"]),
-    packageManager: import_zod5.z.enum(["npm", "pnpm", "yarn", "bun"]).default("npm")
+  frontend: import_zod6.z.object({
+    framework: import_zod6.z.enum(["vite-react", "next", "astro"]),
+    packageManager: import_zod6.z.enum(["npm", "pnpm", "yarn", "bun"]).default("npm")
   }),
-  contracts: import_zod5.z.object({
-    path: import_zod5.z.string(),
-    default: import_zod5.z.string().optional()
+  contracts: import_zod6.z.object({
+    path: import_zod6.z.string(),
+    default: import_zod6.z.string().optional()
   }),
-  files: import_zod5.z.object({
-    config: import_zod5.z.string().default("caatinga.config.ts"),
-    artifacts: import_zod5.z.string().default("caatinga.artifacts.json")
+  files: import_zod6.z.object({
+    config: import_zod6.z.string().default("caatinga.config.ts"),
+    artifacts: import_zod6.z.string().default("caatinga.artifacts.json")
   })
 });
 function defaultCompatibleCoreRange(coreVersion = CAATINGA_CORE_VERSION) {
@@ -1409,10 +1650,10 @@ var TEMPLATE_COPY_EXCLUDED_DIRS = /* @__PURE__ */ new Set([
   ".git"
 ]);
 async function createProjectFromTemplate(options) {
-  const targetDir = import_node_path8.default.resolve(options.targetDir);
-  const templateDir = import_node_path8.default.resolve(options.templateDir);
+  const targetDir = import_node_path10.default.resolve(options.targetDir);
+  const templateDir = import_node_path10.default.resolve(options.templateDir);
   try {
-    await (0, import_promises6.stat)(templateDir);
+    await (0, import_promises8.stat)(templateDir);
   } catch {
     throw new CaatingaError(
       `Template directory was not found: ${templateDir}`,
@@ -1421,8 +1662,8 @@ async function createProjectFromTemplate(options) {
     );
   }
   const manifest = await readTemplateManifest(templateDir);
-  await (0, import_promises6.mkdir)(targetDir, { recursive: true });
-  await (0, import_promises6.cp)(templateDir, targetDir, {
+  await (0, import_promises8.mkdir)(targetDir, { recursive: true });
+  await (0, import_promises8.cp)(templateDir, targetDir, {
     recursive: true,
     force: false,
     errorOnExist: true,
@@ -1445,9 +1686,9 @@ async function ensureArtifacts(targetDir, projectName) {
   }
 }
 async function readTemplateManifest(templateDir) {
-  const manifestPath = import_node_path8.default.join(templateDir, "caatinga.template.json");
+  const manifestPath = import_node_path10.default.join(templateDir, "caatinga.template.json");
   try {
-    const rawManifest = await (0, import_promises6.readFile)(manifestPath, "utf8");
+    const rawManifest = await (0, import_promises8.readFile)(manifestPath, "utf8");
     const manifest = TemplateManifestSchema.parse(JSON.parse(rawManifest));
     const compatibilityIssue = getTemplateCompatibilityIssue(manifest);
     if (compatibilityIssue) {
@@ -1469,7 +1710,7 @@ async function readTemplateManifest(templateDir) {
     if (error instanceof CaatingaError) {
       throw error;
     }
-    if (error instanceof SyntaxError || error instanceof import_zod6.z.ZodError) {
+    if (error instanceof SyntaxError || error instanceof import_zod7.z.ZodError) {
       throw new CaatingaError(
         "Template manifest is invalid.",
         CaatingaErrorCode.INVALID_TEMPLATE_MANIFEST,
@@ -1480,10 +1721,10 @@ async function readTemplateManifest(templateDir) {
   }
 }
 async function replaceTemplateVariables(dir, projectName) {
-  const entries = await (0, import_promises6.readdir)(dir);
+  const entries = await (0, import_promises8.readdir)(dir);
   await Promise.all(entries.map(async (entry) => {
-    const entryPath = import_node_path8.default.join(dir, entry);
-    const entryStat = await (0, import_promises6.stat)(entryPath);
+    const entryPath = import_node_path10.default.join(dir, entry);
+    const entryStat = await (0, import_promises8.stat)(entryPath);
     if (entryStat.isDirectory()) {
       await replaceTemplateVariables(entryPath, projectName);
       return;
@@ -1491,16 +1732,16 @@ async function replaceTemplateVariables(dir, projectName) {
     if (!isTextTemplateFile(entryPath)) {
       return;
     }
-    const content = await (0, import_promises6.readFile)(entryPath, "utf8");
-    await (0, import_promises6.writeFile)(entryPath, content.replaceAll("__PROJECT_NAME__", projectName), "utf8");
+    const content = await (0, import_promises8.readFile)(entryPath, "utf8");
+    await (0, import_promises8.writeFile)(entryPath, content.replaceAll("__PROJECT_NAME__", projectName), "utf8");
   }));
 }
 function shouldCopyTemplateEntry(templateDir, source) {
-  const relativePath = import_node_path8.default.relative(templateDir, source);
+  const relativePath = import_node_path10.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));
+  return !relativePath.split(import_node_path10.default.sep).some((segment) => TEMPLATE_COPY_EXCLUDED_DIRS.has(segment));
 }
 function isTextTemplateFile(filePath) {
   return [
@@ -1512,7 +1753,7 @@ function isTextTemplateFile(filePath) {
     ".tsx",
     ".css",
     ".html"
-  ].includes(import_node_path8.default.extname(filePath));
+  ].includes(import_node_path10.default.extname(filePath));
 }
 
 // src/ci/is-transient-testnet-smoke-failure.ts
@@ -1537,6 +1778,8 @@ function isTransientTestnetSmokeFailure(logText) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BINDING_MARKER_FILENAME,
+  BindingMarkerSchema,
   CAATINGA_CORE_VERSION,
   CaatingaArtifactsSchema,
   CaatingaConfigSchema,
@@ -1550,13 +1793,18 @@ function isTransientTestnetSmokeFailure(logText) {
   buildDependencyGraph,
   checkBinary,
   checkStellarCliVersion,
+  collectProjectStatus,
   createInitialArtifacts,
   createProjectFromTemplate,
   defineConfig,
   deployContract,
   deployContractGraph,
+  evaluateBindingFreshness,
+  evaluateBindingsFreshness,
   evaluateStellarCliCompatibility,
+  formatCaatingaError,
   generateBindings,
+  generateBindingsGraph,
   invokeContract,
   isTransientTestnetSmokeFailure,
   loadConfig,
@@ -1564,6 +1812,7 @@ function isTransientTestnetSmokeFailure(logText) {
   parseInvokeTarget,
   parseStellarCliVersion,
   readArtifacts,
+  readBindingMarker,
   resolveContract,
   resolveDeployArgs,
   resolveDeployOrder,
@@ -1572,5 +1821,6 @@ function isTransientTestnetSmokeFailure(logText) {
   toCaatingaError,
   updateArtifact,
   validateSourceShape,
-  writeArtifacts
+  writeArtifacts,
+  writeBindingMarker
 });