@storm-software/workspace-tools 1.295.70 → 1.295.73

package/dist/chunk-QQB6GFYM.mjs

@@ -0,0 +1,79 @@
+import {
+  base_executor_untyped_default
+} from "./chunk-ZCTECGQS.mjs";
+
+// src/base/cargo-base-executor.untyped.ts
+import { defineUntypedSchema } from "untyped";
+var cargo_base_executor_untyped_default = defineUntypedSchema({
+  ...base_executor_untyped_default,
+  $schema: {
+    id: "cargoBaseExecutor",
+    title: "Cargo Base Executor",
+    description: "A base type definition for a Cargo/rust related executor schema"
+  },
+  package: {
+    $schema: {
+      title: "Cargo.toml Path",
+      type: "string",
+      format: "path",
+      description: "The path to the Cargo.toml file"
+    },
+    $default: "{projectRoot}/Cargo.toml"
+  },
+  toolchain: {
+    $schema: {
+      title: "Toolchain",
+      description: "The type of toolchain to use for the build",
+      enum: ["stable", "beta", "nightly"],
+      default: "stable"
+    },
+    $default: "stable"
+  },
+  target: {
+    $schema: {
+      title: "Target",
+      type: "string",
+      description: "The target to build"
+    }
+  },
+  allTargets: {
+    $schema: {
+      title: "All Targets",
+      type: "boolean",
+      description: "Build all targets"
+    }
+  },
+  profile: {
+    $schema: {
+      title: "Profile",
+      type: "string",
+      description: "The profile to build"
+    }
+  },
+  release: {
+    $schema: {
+      title: "Release",
+      type: "boolean",
+      description: "Build in release mode"
+    }
+  },
+  features: {
+    $schema: {
+      title: "Features",
+      type: "string",
+      description: "The features to build",
+      oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+    }
+  },
+  allFeatures: {
+    $schema: {
+      title: "All Features",
+      type: "boolean",
+      description: "Build all features"
+    }
+  }
+});
+
+export {
+  cargo_base_executor_untyped_default
+};

package/dist/chunk-QVYCDING.js

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/create-cli-options.ts
+var _devkit = require('@nx/devkit');
+function createCliOptions(obj) {
+  const args = [];
+  for (const key in obj) {
+    const value = obj[key];
+    if (value) {
+      const arg = _devkit.names.call(void 0, key).fileName;
+      if (Array.isArray(value)) {
+        args.push(
+          `--${arg.toLowerCase()}=${value.map((v) => v.trim()).join(",")}`
+        );
+      } else {
+        args.push(`--${arg.toLowerCase()}=${value}`);
+      }
+    }
+  }
+  return args;
+}
+
+
+
+exports.createCliOptions = createCliOptions;

package/dist/chunk-R4NPC2W7.mjs

@@ -0,0 +1,213 @@
+import {
+  getCrateRegistryVersion
+} from "./chunk-EGI64HQ2.mjs";
+import {
+  parseCargoToml,
+  parseCargoTomlWithTree,
+  stringifyCargoToml
+} from "./chunk-JCPIXJ3N.mjs";
+import {
+  getWorkspaceConfig
+} from "./chunk-K7B3YICS.mjs";
+
+// src/release/rust-version-actions.ts
+import {
+  joinPathFragments
+} from "@nx/devkit";
+import { VersionActions } from "nx/release";
+var StormRustVersionActions = class extends VersionActions {
+  validManifestFilenames = ["Cargo.toml"];
+  /**
+   * The Storm workspace configuration object, which is loaded from the `storm-workspace.json` file.
+   *
+   * @remarks
+   * This member variable is populated during the {@link init} method.
+   */
+  workspaceConfig = null;
+  constructor(releaseGroup, projectGraphNode, finalConfigForProject) {
+    super(releaseGroup, projectGraphNode, finalConfigForProject);
+  }
+  /**
+   * Asynchronous initialization of the version actions and resolution of manifest paths.
+   *
+   * @remarks
+   * This does NOT validate that manifest files exist - that happens later in validate().
+   *
+   * @params tree - The file system tree to read from.
+   */
+  async init(tree) {
+    this.workspaceConfig = await getWorkspaceConfig();
+    return super.init(tree);
+  }
+  async readCurrentVersionFromSourceManifest(tree) {
+    const sourceCargoTomlPath = joinPathFragments(
+      this.projectGraphNode.data.root,
+      "Cargo.toml"
+    );
+    try {
+      const cargoToml = parseCargoTomlWithTree(
+        tree,
+        this.projectGraphNode.data.root,
+        this.projectGraphNode.name
+      );
+      return {
+        manifestPath: sourceCargoTomlPath,
+        currentVersion: cargoToml.package.version
+      };
+    } catch {
+      throw new Error(
+        `Unable to determine the current version for project "${this.projectGraphNode.name}" from ${sourceCargoTomlPath}, please ensure that the "version" field is set within the Cargo.toml file`
+      );
+    }
+  }
+  async readCurrentVersionFromRegistry(tree, currentVersionResolverMetadata) {
+    const cargoToml = parseCargoTomlWithTree(
+      tree,
+      this.projectGraphNode.data.root,
+      this.projectGraphNode.name
+    );
+    const crateName = cargoToml.package.name;
+    const metadata = currentVersionResolverMetadata;
+    const registryArg = typeof metadata?.registry === "string" ? metadata.registry : this.workspaceConfig?.registry?.cargo || "https://crates.io";
+    const tagArg = typeof metadata?.tag === "string" ? metadata.tag : "latest";
+    let currentVersion = null;
+    try {
+      currentVersion = await getCrateRegistryVersion(
+        crateName,
+        tagArg,
+        registryArg
+      );
+    } catch {
+    }
+    return {
+      currentVersion: currentVersion || "0.0.0",
+      // Make troubleshooting easier by including the registry and tag data in the log text
+      logText: `"cargoRegistry=${registryArg}" tag=${tagArg}`
+    };
+  }
+  async readCurrentVersionOfDependency(tree, projectGraph, dependencyProjectName) {
+    const cargoToml = parseCargoTomlWithTree(
+      tree,
+      this.projectGraphNode.data.root,
+      this.projectGraphNode.name
+    );
+    if (!projectGraph.nodes[dependencyProjectName]?.data?.root) {
+      return {
+        currentVersion: null,
+        dependencyCollection: null
+      };
+    }
+    const dependencyCargoToml = parseCargoTomlWithTree(
+      tree,
+      projectGraph.nodes[dependencyProjectName]?.data.root,
+      dependencyProjectName
+    );
+    if (!dependencyCargoToml?.package?.name) {
+      return {
+        currentVersion: null,
+        dependencyCollection: null
+      };
+    }
+    let currentVersion = null;
+    let dependencyCollection = null;
+    for (const depType of ["dependencies", "dev-dependencies"]) {
+      if (cargoToml[depType] && cargoToml[depType][dependencyCargoToml.package.name]) {
+        currentVersion = typeof cargoToml[depType][dependencyCargoToml.package.name] === "string" ? cargoToml[depType][dependencyCargoToml.package.name] : cargoToml[depType][dependencyCargoToml.package.name].version;
+        dependencyCollection = depType;
+        break;
+      }
+    }
+    return {
+      currentVersion,
+      dependencyCollection
+    };
+  }
+  async updateProjectVersion(tree, newVersion) {
+    const logMessages = [];
+    for (const manifestToUpdate of this.manifestsToUpdate) {
+      const cargoTomlString = tree.read(manifestToUpdate.manifestPath)?.toString();
+      if (!cargoTomlString) {
+        throw new Error(
+          `Unable to read Cargo.toml at path: ${manifestToUpdate.manifestPath}`
+        );
+      }
+      const cargoToml = parseCargoToml(cargoTomlString);
+      cargoToml.package.version = newVersion;
+      tree.write(manifestToUpdate.manifestPath, stringifyCargoToml(cargoToml));
+      logMessages.push(
+        `\u270D\uFE0F  New version ${newVersion} written to manifest: ${manifestToUpdate.manifestPath}`
+      );
+    }
+    return logMessages;
+  }
+  /**
+   * Updates the dependencies of the project in the specified Cargo.toml files.
+   *
+   * @param tree - The file system tree to read from and write to.
+   * @param projectGraph - The project graph to use for resolving dependencies.
+   * @param dependenciesToUpdate - A mapping of dependency names to their new versions.
+   * @returns An array of log messages indicating the results of the updates.
+   */
+  async updateProjectDependencies(tree, projectGraph, dependenciesToUpdate = {}) {
+    const numDependenciesToUpdate = Object.keys(dependenciesToUpdate).length;
+    if (numDependenciesToUpdate === 0) {
+      return [];
+    }
+    const logMessages = [];
+    for (const manifestToUpdate of this.manifestsToUpdate) {
+      const cargoTomlString = tree.read(manifestToUpdate.manifestPath)?.toString();
+      if (!cargoTomlString) {
+        throw new Error(
+          `Unable to read Cargo.toml at path: ${manifestToUpdate.manifestPath}`
+        );
+      }
+      const cargoToml = parseCargoToml(cargoTomlString);
+      for (const depType of ["dependencies", "dev-dependencies"]) {
+        if (cargoToml[depType]) {
+          for (const [dep, version] of Object.entries(dependenciesToUpdate)) {
+            try {
+              const projectRoot = projectGraph.nodes[dep]?.data.root;
+              if (!projectRoot) {
+                throw new Error(
+                  `Unable to determine the project root for "${dep}" from the project graph metadata, please ensure that the "@storm-software/workspace-tools" plugin is installed and the project graph has been built. If the issue persists, please report this issue on https://github.com/storm-software/storm-ops/issues`
+                );
+              }
+              const dependencyCargoTomlString = tree.read(manifestToUpdate.manifestPath)?.toString();
+              if (!dependencyCargoTomlString) {
+                throw new Error(
+                  `Unable to read Cargo.toml at path: ${manifestToUpdate.manifestPath}`
+                );
+              }
+              const dependencyCargoToml = parseCargoToml(
+                dependencyCargoTomlString
+              );
+              const dependencyCrateName = cargoToml[depType][dependencyCargoToml.package.name] ? dependencyCargoToml.package.name : dep;
+              if (typeof cargoToml[depType][dependencyCrateName] === "string") {
+                cargoToml[depType][dependencyCrateName] = version;
+              } else {
+                cargoToml[depType][dependencyCrateName].version = version;
+              }
+              tree.write(
+                manifestToUpdate.manifestPath,
+                stringifyCargoToml(cargoToml)
+              );
+            } catch (error) {
+              throw new Error(
+                `Unable to update ${depType === "dev-dependencies" ? "dev-dependency" : "dependency"} "${dep}" in manifest at path: ${manifestToUpdate.manifestPath}.`,
+                { cause: error }
+              );
+            }
+          }
+        }
+      }
+      logMessages.push(
+        `\u270D\uFE0F  Updated ${numDependenciesToUpdate} ${numDependenciesToUpdate === 1 ? "dependency" : "dependencies"} in manifest: ${manifestToUpdate.manifestPath}`
+      );
+    }
+    return logMessages;
+  }
+};
+
+export {
+  StormRustVersionActions
+};

package/dist/chunk-RGPA6TMT.js

@@ -0,0 +1,364 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+var _chunkTX5O64JJjs = require('./chunk-TX5O64JJ.js');
+
+
+var _chunkGSGT2T27js = require('./chunk-GSGT2T27.js');
+
+
+var _chunkZJ75AYXEjs = require('./chunk-ZJ75AYXE.js');
+
+
+
+
+
+
+
+
+var _chunkAGR3NCGAjs = require('./chunk-AGR3NCGA.js');
+
+
+var _chunkLMYTVXGXjs = require('./chunk-LMYTVXGX.js');
+
+
+var _chunkCQDBLKPFjs = require('./chunk-CQDBLKPF.js');
+
+// ../tsdown/src/build.ts
+
+
+
+
+var _devkit = require('@nx/devkit');
+var _defu = require('defu'); var _defu2 = _interopRequireDefault(_defu);
+var _fs = require('fs');
+var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
+var _tsdown = require('tsdown');
+
+// ../tsdown/src/clean.ts
+
+async function cleanDirectories(name = "TSDown", directory, config) {
+  await _promises.rm.call(void 0, directory, { recursive: true, force: true });
+}
+
+// ../tsdown/src/config.ts
+function getDefaultOptions(config) {
+  return {
+    entry: ["./src/*.ts"],
+    platform: "node",
+    target: "esnext",
+    mode: "production",
+    dts: true,
+    unused: {
+      level: "error",
+      ignore: ["typescript"]
+    },
+    publint: true,
+    fixedExtension: true,
+    ...config
+  };
+}
+function toTSDownFormat(format) {
+  if (!format || Array.isArray(format) && format.length === 0) {
+    return ["cjs", "es"];
+  } else if (format === "esm") {
+    return "es";
+  } else if (Array.isArray(format)) {
+    return format.map((f) => f === "esm" ? "es" : f);
+  }
+  return format;
+}
+
+// ../tsdown/src/build.ts
+var resolveOptions = async (userOptions) => {
+  const options = getDefaultOptions(userOptions);
+  const workspaceRoot = _chunkLMYTVXGXjs.findWorkspaceRoot.call(void 0, options.projectRoot);
+  if (!workspaceRoot) {
+    throw new Error("Cannot find Nx workspace root");
+  }
+  const workspaceConfig = await _chunkZJ75AYXEjs.getWorkspaceConfig.call(void 0, options.debug === true, {
+    workspaceRoot
+  });
+  _chunkAGR3NCGAjs.writeDebug.call(void 0, "  \u2699\uFE0F   Resolving build options", workspaceConfig);
+  const stopwatch = _chunkAGR3NCGAjs.getStopwatch.call(void 0, "Build options resolution");
+  const projectGraph = await _devkit.createProjectGraphAsync.call(void 0, {
+    exitOnError: true
+  });
+  const projectJsonPath = _chunkCQDBLKPFjs.joinPaths.call(void 0, 
+    workspaceRoot,
+    options.projectRoot,
+    "project.json"
+  );
+  if (!_fs.existsSync.call(void 0, projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJsonFile = await _promises2.default.readFile(projectJsonPath, "utf8");
+  const projectJson = JSON.parse(projectJsonFile);
+  const projectName = projectJson.name;
+  const projectConfigurations = _devkit.readProjectsConfigurationFromProjectGraph.call(void 0, projectGraph);
+  if (!_optionalChain([projectConfigurations, 'optionalAccess', _ => _.projects, 'optionalAccess', _2 => _2[projectName]])) {
+    throw new Error(
+      "The Build process failed because the project does not have a valid configuration in the project.json file. Check if the file exists in the root of the project."
+    );
+  }
+  const packageJsonPath = _chunkCQDBLKPFjs.joinPaths.call(void 0, 
+    workspaceRoot,
+    options.projectRoot,
+    "package.json"
+  );
+  if (!_fs.existsSync.call(void 0, packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const debug = _nullishCoalesce(options.debug, () => ( (options.mode || workspaceConfig.mode) === "development"));
+  const sourceRoot = projectJson.sourceRoot || _chunkCQDBLKPFjs.joinPaths.call(void 0, options.projectRoot, "src");
+  const result = {
+    name: projectName,
+    mode: "production",
+    target: _chunkTX5O64JJjs.DEFAULT_TARGET,
+    generatePackageJson: true,
+    outDir: _chunkCQDBLKPFjs.joinPaths.call(void 0, "dist", options.projectRoot),
+    minify: !debug,
+    plugins: [],
+    assets: [],
+    dts: true,
+    shims: true,
+    silent: !debug,
+    logLevel: workspaceConfig.logLevel === "success" || workspaceConfig.logLevel === "performance" || workspaceConfig.logLevel === "debug" || workspaceConfig.logLevel === "trace" || workspaceConfig.logLevel === "all" ? "info" : workspaceConfig.logLevel === "fatal" ? "error" : workspaceConfig.logLevel,
+    sourcemap: debug ? "inline" : false,
+    clean: false,
+    fixedExtension: true,
+    nodeProtocol: true,
+    tsconfig: _chunkCQDBLKPFjs.joinPaths.call(void 0, options.projectRoot, "tsconfig.json"),
+    debug,
+    sourceRoot,
+    cwd: workspaceConfig.workspaceRoot,
+    entry: {
+      ["index"]: _chunkCQDBLKPFjs.joinPaths.call(void 0, sourceRoot, "index.ts")
+    },
+    workspace: true,
+    ...options,
+    treeshake: options.treeShaking !== false,
+    format: toTSDownFormat(options.format),
+    workspaceConfig,
+    projectName,
+    projectGraph,
+    projectConfigurations
+  };
+  result.env = _defu2.default.call(void 0, 
+    options.env,
+    _chunkTX5O64JJjs.getEnv.call(void 0, "tsdown", result)
+  );
+  stopwatch();
+  return result;
+};
+async function generatePackageJson(options) {
+  if (options.generatePackageJson !== false && _fs.existsSync.call(void 0, _chunkCQDBLKPFjs.joinPaths.call(void 0, options.projectRoot, "package.json"))) {
+    _chunkAGR3NCGAjs.writeDebug.call(void 0, "  \u270D\uFE0F   Writing package.json file", options.workspaceConfig);
+    const stopwatch = _chunkAGR3NCGAjs.getStopwatch.call(void 0, "Write package.json file");
+    const packageJsonPath = _chunkCQDBLKPFjs.joinPaths.call(void 0, options.projectRoot, "project.json");
+    if (!_fs.existsSync.call(void 0, packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    const packageJsonFile = await _promises2.default.readFile(
+      _chunkCQDBLKPFjs.joinPaths.call(void 0, 
+        options.workspaceConfig.workspaceRoot,
+        options.projectRoot,
+        "package.json"
+      ),
+      "utf8"
+    );
+    if (!packageJsonFile) {
+      throw new Error("Cannot find package.json configuration file");
+    }
+    let packageJson = JSON.parse(packageJsonFile);
+    packageJson = await _chunkTX5O64JJjs.addPackageDependencies.call(void 0, 
+      options.workspaceConfig.workspaceRoot,
+      options.projectRoot,
+      options.projectName,
+      packageJson
+    );
+    packageJson = await _chunkTX5O64JJjs.addWorkspacePackageJsonFields.call(void 0, 
+      options.workspaceConfig,
+      options.projectRoot,
+      options.sourceRoot,
+      options.projectName,
+      false,
+      packageJson
+    );
+    packageJson.exports ??= {};
+    packageJson.exports["./package.json"] ??= "./package.json";
+    packageJson.exports["."] ??= _chunkTX5O64JJjs.addPackageJsonExport.call(void 0, 
+      "index",
+      packageJson.type,
+      options.sourceRoot
+    );
+    let entry = [{ in: "./src/index.ts", out: "./src/index.ts" }];
+    if (options.entry) {
+      if (Array.isArray(options.entry)) {
+        entry = options.entry.map(
+          (entryPoint) => typeof entryPoint === "string" ? { in: entryPoint, out: entryPoint } : entryPoint
+        );
+      }
+      for (const entryPoint of entry) {
+        const split = entryPoint.out.split(".");
+        split.pop();
+        const entry2 = split.join(".").replaceAll("\\", "/");
+        packageJson.exports[`./${entry2}`] ??= _chunkTX5O64JJjs.addPackageJsonExport.call(void 0, 
+          entry2,
+          options.fixedExtension ? "fixed" : packageJson.type,
+          options.sourceRoot
+        );
+      }
+    }
+    packageJson.main = !options.fixedExtension && packageJson.type === "commonjs" ? "./dist/index.js" : "./dist/index.cjs";
+    packageJson.module = !options.fixedExtension && packageJson.type === "module" ? "./dist/index.js" : "./dist/index.mjs";
+    packageJson.types = `./dist/index.d.${!options.fixedExtension ? "ts" : "mts"}`;
+    packageJson.exports = Object.keys(packageJson.exports).reduce(
+      (ret, key) => {
+        if (key.endsWith("/index") && !ret[key.replace("/index", "")]) {
+          ret[key.replace("/index", "")] = packageJson.exports[key];
+        }
+        return ret;
+      },
+      packageJson.exports
+    );
+    await _devkit.writeJsonFile.call(void 0, _chunkCQDBLKPFjs.joinPaths.call(void 0, options.outDir, "package.json"), packageJson);
+    stopwatch();
+  }
+  return options;
+}
+async function executeTSDown(options) {
+  _chunkAGR3NCGAjs.writeDebug.call(void 0, `  \u{1F680}  Running ${options.name} build`, options.workspaceConfig);
+  const stopwatch = _chunkAGR3NCGAjs.getStopwatch.call(void 0, `${options.name} build`);
+  await _tsdown.build.call(void 0, {
+    ...options,
+    entry: options.entry,
+    config: false
+  });
+  stopwatch();
+  return options;
+}
+async function copyBuildAssets(options) {
+  _chunkAGR3NCGAjs.writeDebug.call(void 0, 
+    `  \u{1F4CB}  Copying asset files to output directory: ${options.outDir}`,
+    options.workspaceConfig
+  );
+  const stopwatch = _chunkAGR3NCGAjs.getStopwatch.call(void 0, `${options.name} asset copy`);
+  await _chunkTX5O64JJjs.copyAssets.call(void 0, 
+    options.workspaceConfig,
+    _nullishCoalesce(options.assets, () => ( [])),
+    options.outDir,
+    options.projectRoot,
+    options.sourceRoot,
+    true,
+    false
+  );
+  stopwatch();
+  return options;
+}
+async function reportResults(options) {
+  _chunkAGR3NCGAjs.writeSuccess.call(void 0, 
+    `  \u{1F4E6}  The ${options.name} build completed successfully`,
+    options.workspaceConfig
+  );
+}
+async function cleanOutputPath(options) {
+  if (options.clean !== false && options.workspaceConfig) {
+    _chunkAGR3NCGAjs.writeDebug.call(void 0, 
+      ` \u{1F9F9}  Cleaning ${options.name} output path: ${options.workspaceConfig}`,
+      options.workspaceConfig
+    );
+    const stopwatch = _chunkAGR3NCGAjs.getStopwatch.call(void 0, `${options.name} output clean`);
+    await cleanDirectories(
+      options.name,
+      options.outDir,
+      options.workspaceConfig
+    );
+    stopwatch();
+  }
+  return options;
+}
+async function build(options) {
+  _chunkAGR3NCGAjs.writeDebug.call(void 0, `  ${_chunkAGR3NCGAjs.brandIcon.call(void 0, )}   Executing Storm TSDown pipeline`);
+  const stopwatch = _chunkAGR3NCGAjs.getStopwatch.call(void 0, "TSDown pipeline");
+  try {
+    const opts = Array.isArray(options) ? options : [options];
+    if (opts.length === 0) {
+      throw new Error("No build options were provided");
+    }
+    const resolved = await Promise.all(
+      opts.map(async (opt) => await resolveOptions(opt))
+    );
+    if (resolved.length > 0) {
+      await cleanOutputPath(resolved[0]);
+      await generatePackageJson(resolved[0]);
+      await Promise.all(
+        resolved.map(async (opt) => {
+          await executeTSDown(opt);
+          await copyBuildAssets(opt);
+          await reportResults(opt);
+        })
+      );
+    } else {
+      _chunkAGR3NCGAjs.writeWarning.call(void 0, 
+        "  \u{1F6A7}   No options were passed to TSBuild. Please check the parameters passed to the `build` function."
+      );
+    }
+    _chunkAGR3NCGAjs.writeSuccess.call(void 0, "  \u{1F3C1}  TSDown pipeline build completed successfully");
+  } catch (error) {
+    _chunkAGR3NCGAjs.writeFatal.call(void 0, 
+      "Fatal errors that the build process could not recover from have occured. The build process has been terminated."
+    );
+    throw error;
+  } finally {
+    stopwatch();
+  }
+}
+
+// src/executors/tsdown/executor.ts
+async function tsdownExecutorFn(options, context, config) {
+  _chunkAGR3NCGAjs.writeInfo.call(void 0, "\u{1F4E6}  Running Storm TSDown executor on the workspace", config);
+  if (!_optionalChain([context, 'access', _3 => _3.projectsConfigurations, 'optionalAccess', _4 => _4.projects]) || !context.projectName || !context.projectsConfigurations.projects[context.projectName] || !_optionalChain([context, 'access', _5 => _5.projectsConfigurations, 'access', _6 => _6.projects, 'access', _7 => _7[context.projectName], 'optionalAccess', _8 => _8.root])) {
+    throw new Error(
+      "The Build process failed because the context is not valid. Please run this command from a workspace."
+    );
+  }
+  await build({
+    ...options,
+    projectRoot: (
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      _optionalChain([context, 'access', _9 => _9.projectsConfigurations, 'access', _10 => _10.projects, 'optionalAccess', _11 => _11[context.projectName], 'access', _12 => _12.root])
+    ),
+    name: context.projectName,
+    sourceRoot: _optionalChain([context, 'access', _13 => _13.projectsConfigurations, 'access', _14 => _14.projects, 'optionalAccess', _15 => _15[context.projectName], 'optionalAccess', _16 => _16.sourceRoot]),
+    format: options.format,
+    platform: options.platform
+  });
+  return {
+    success: true
+  };
+}
+var executor_default = _chunkGSGT2T27js.withRunExecutor.call(void 0, 
+  "Storm TSDown build",
+  tsdownExecutorFn,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: async (options) => {
+        options.entry ??= ["src/index.ts"];
+        options.outputPath ??= "dist/{projectRoot}";
+        options.tsconfig ??= "{projectRoot}/tsconfig.json";
+        return options;
+      }
+    }
+  }
+);
+
+
+
+
+exports.tsdownExecutorFn = tsdownExecutorFn; exports.executor_default = executor_default;