@storm-software/cloudflare-tools 0.48.0 → 0.49.0

package/dist/chunk-Z46UO4N7.js

@@ -0,0 +1,3465 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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 _chunkVTHBMY4Bjs = require('./chunk-VTHBMY4B.js');
+
+
+var _chunkYE4FHRXJjs = require('./chunk-YE4FHRXJ.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkRCE3CC76js = require('./chunk-RCE3CC76.js');
+
+
+
+var _chunkJ5SB6L2Ljs = require('./chunk-J5SB6L2L.js');
+
+// ../config-tools/src/utilities/apply-workspace-tokens.ts
+var applyWorkspaceBaseTokens = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (option, tokenizerOptions) => {
+  let result = option;
+  if (!result) {
+    return result;
+  }
+  if (tokenizerOptions) {
+    const optionKeys = Object.keys(tokenizerOptions);
+    if (optionKeys.some((optionKey) => result.includes(`{${optionKey}}`))) {
+      for (const optionKey of optionKeys) {
+        if (result.includes(`{${optionKey}}`)) {
+          result = result.replaceAll(`{${optionKey}}`, _nullishCoalesce(_optionalChain([tokenizerOptions, 'access', _2 => _2.config, 'optionalAccess', _3 => _3[optionKey]]), () => ( "")));
+        }
+      }
+    }
+  }
+  if (tokenizerOptions.config) {
+    const configKeys = Object.keys(tokenizerOptions.config);
+    if (configKeys.some((configKey) => result.includes(`{${configKey}}`))) {
+      for (const configKey of configKeys) {
+        if (result.includes(`{${configKey}}`)) {
+          result = result.replaceAll(`{${configKey}}`, tokenizerOptions.config[configKey]);
+        }
+      }
+    }
+  }
+  if (result.includes("{workspaceRoot}")) {
+    result = result.replaceAll("{workspaceRoot}", _nullishCoalesce(_nullishCoalesce(tokenizerOptions.workspaceRoot, () => ( _optionalChain([tokenizerOptions, 'access', _4 => _4.config, 'optionalAccess', _5 => _5.workspaceRoot]))), () => ( _chunkRCE3CC76js.findWorkspaceRoot.call(void 0, ))));
+  }
+  return result;
+}, "applyWorkspaceBaseTokens");
+var applyWorkspaceTokens = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (options, config, tokenizerFn) => {
+  if (!options) {
+    return {};
+  }
+  const result = {};
+  for (const option of Object.keys(options)) {
+    if (typeof options[option] === "string") {
+      result[option] = await Promise.resolve(tokenizerFn(options[option], config));
+    } else if (Array.isArray(options[option])) {
+      result[option] = await Promise.all(options[option].map(async (item) => typeof item === "string" ? await Promise.resolve(tokenizerFn(item, config)) : item));
+    } else if (typeof options[option] === "object") {
+      result[option] = await applyWorkspaceTokens(options[option], config, tokenizerFn);
+    } else {
+      result[option] = options[option];
+    }
+  }
+  return result;
+}, "applyWorkspaceTokens");
+
+// ../config-tools/src/utilities/run.ts
+var _child_process = require('child_process');
+var LARGE_BUFFER = 1024 * 1e6;
+var run = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (config, command, cwd = _nullishCoalesce(config.workspaceRoot, () => ( process.cwd())), stdio = "inherit", env = process.env) => {
+  return _child_process.execSync.call(void 0, command, {
+    cwd,
+    env: {
+      ...process.env,
+      ...env,
+      CLICOLOR: "true",
+      FORCE_COLOR: "true"
+    },
+    windowsHide: true,
+    stdio,
+    maxBuffer: LARGE_BUFFER,
+    killSignal: "SIGTERM"
+  });
+}, "run");
+
+// ../workspace-tools/src/utils/apply-workspace-tokens.ts
+var applyWorkspaceExecutorTokens = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (option, tokenizerOptions) => {
+  let result = option;
+  if (!result) {
+    return result;
+  }
+  let projectName;
+  let projectRoot;
+  let sourceRoot;
+  if (_optionalChain([tokenizerOptions, 'optionalAccess', _6 => _6.projectName])) {
+    const context2 = tokenizerOptions;
+    projectName = context2.projectName;
+    projectRoot = context2.root;
+    sourceRoot = context2.sourceRoot;
+  } else {
+    const projectConfig = tokenizerOptions;
+    projectRoot = projectConfig.root;
+    if (projectConfig.name) {
+      projectName = projectConfig.name;
+    }
+    if (projectConfig.sourceRoot) {
+      sourceRoot = projectConfig.sourceRoot;
+    }
+  }
+  if (tokenizerOptions.config) {
+    const configKeys = Object.keys(tokenizerOptions.config);
+    if (configKeys.some((configKey) => result.includes(`{${configKey}}`))) {
+      for (const configKey of configKeys) {
+        if (result.includes(`{${configKey}}`)) {
+          result = result.replaceAll(`{${configKey}}`, tokenizerOptions.config[configKey]);
+        }
+      }
+    }
+  }
+  if (result.includes("{projectName}")) {
+    result = result.replaceAll("{projectName}", projectName);
+  }
+  if (result.includes("{projectRoot}")) {
+    result = result.replaceAll("{projectRoot}", projectRoot);
+  }
+  if (result.includes("{sourceRoot}")) {
+    result = result.replaceAll("{sourceRoot}", sourceRoot);
+  }
+  if (result.includes("{workspaceRoot}")) {
+    result = result.replaceAll("{workspaceRoot}", _nullishCoalesce(tokenizerOptions.workspaceRoot, () => ( _chunkRCE3CC76js.findWorkspaceRoot.call(void 0, ))));
+  }
+  return result;
+}, "applyWorkspaceExecutorTokens");
+
+// ../workspace-tools/src/base/base-executor.ts
+var withRunExecutor = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (name, executorFn, executorOptions = {}) => async (_options, context2) => {
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, name);
+  let options = _options;
+  let config = {};
+  try {
+    _chunkRCE3CC76js.writeInfo.call(void 0, `\u26A1 Running the ${name} executor...
+`, config);
+    if (!_optionalChain([context2, 'access', _7 => _7.projectsConfigurations, 'optionalAccess', _8 => _8.projects]) || !context2.projectName || !context2.projectsConfigurations.projects[context2.projectName]) {
+      throw new Error("The Build process failed because the context is not valid. Please run this command from a workspace.");
+    }
+    const workspaceRoot3 = _chunkRCE3CC76js.findWorkspaceRoot.call(void 0, );
+    const projectRoot = _nullishCoalesce(_optionalChain([context2, 'access', _9 => _9.projectsConfigurations, 'access', _10 => _10.projects, 'access', _11 => _11[context2.projectName], 'optionalAccess', _12 => _12.root]), () => ( workspaceRoot3));
+    const sourceRoot = _nullishCoalesce(_optionalChain([context2, 'access', _13 => _13.projectsConfigurations, 'access', _14 => _14.projects, 'access', _15 => _15[context2.projectName], 'optionalAccess', _16 => _16.sourceRoot]), () => ( workspaceRoot3));
+    const projectName = _nullishCoalesce(_optionalChain([context2, 'access', _17 => _17.projectsConfigurations, 'access', _18 => _18.projects, 'access', _19 => _19[context2.projectName], 'optionalAccess', _20 => _20.name]), () => ( context2.projectName));
+    config.workspaceRoot = workspaceRoot3;
+    if (!executorOptions.skipReadingConfig) {
+      _chunkRCE3CC76js.writeTrace.call(void 0, `Loading the Storm Config from environment variables and storm.config.js file...
+ - workspaceRoot: ${workspaceRoot3}
+ - projectRoot: ${projectRoot}
+ - sourceRoot: ${sourceRoot}
+ - projectName: ${projectName}
+`, config);
+      config = await _chunkYE4FHRXJjs.loadStormConfig.call(void 0, workspaceRoot3);
+    }
+    if (_optionalChain([executorOptions, 'optionalAccess', _21 => _21.hooks, 'optionalAccess', _22 => _22.applyDefaultOptions])) {
+      _chunkRCE3CC76js.writeDebug.call(void 0, "Running the applyDefaultOptions hook...", config);
+      options = await Promise.resolve(executorOptions.hooks.applyDefaultOptions(options, config));
+      _chunkRCE3CC76js.writeDebug.call(void 0, "Completed the applyDefaultOptions hook", config);
+    }
+    _chunkRCE3CC76js.writeTrace.call(void 0, `Executor schema options \u2699\uFE0F 
+${Object.keys(options).map((key) => ` - ${key}=${_isFunction(options[key]) ? "<function>" : JSON.stringify(options[key])}`).join("\n")}`, config);
+    const tokenized = await applyWorkspaceTokens(options, {
+      config,
+      workspaceRoot: workspaceRoot3,
+      projectRoot,
+      sourceRoot,
+      projectName,
+      ...context2.projectsConfigurations.projects[context2.projectName],
+      ...executorOptions
+    }, applyWorkspaceExecutorTokens);
+    if (_optionalChain([executorOptions, 'optionalAccess', _23 => _23.hooks, 'optionalAccess', _24 => _24.preProcess])) {
+      _chunkRCE3CC76js.writeDebug.call(void 0, "Running the preProcess hook...", config);
+      await Promise.resolve(executorOptions.hooks.preProcess(tokenized, config));
+      _chunkRCE3CC76js.writeDebug.call(void 0, "Completed the preProcess hook", config);
+    }
+    const ret = executorFn(tokenized, context2, config);
+    if (_isFunction(_optionalChain([ret, 'optionalAccess', _25 => _25.next]))) {
+      const asyncGen = ret;
+      for await (const iter of asyncGen) {
+      }
+    }
+    const result = await Promise.resolve(ret);
+    if (result && (!result.success || result.error && _optionalChain([result, 'optionalAccess', _26 => _26.error, 'optionalAccess', _27 => _27.message]) && typeof _optionalChain([result, 'optionalAccess', _28 => _28.error, 'optionalAccess', _29 => _29.message]) === "string" && _optionalChain([result, 'optionalAccess', _30 => _30.error, 'optionalAccess', _31 => _31.name]) && typeof _optionalChain([result, 'optionalAccess', _32 => _32.error, 'optionalAccess', _33 => _33.name]) === "string")) {
+      _chunkRCE3CC76js.writeTrace.call(void 0, `Failure determined by the ${name} executor 
+${_chunkRCE3CC76js.formatLogMessage.call(void 0, result)}`, config);
+      console.error(result);
+      throw new Error(`The ${name} executor failed to run`, {
+        cause: _optionalChain([result, 'optionalAccess', _34 => _34.error])
+      });
+    }
+    if (_optionalChain([executorOptions, 'optionalAccess', _35 => _35.hooks, 'optionalAccess', _36 => _36.postProcess])) {
+      _chunkRCE3CC76js.writeDebug.call(void 0, "Running the postProcess hook...", config);
+      await Promise.resolve(executorOptions.hooks.postProcess(config));
+      _chunkRCE3CC76js.writeDebug.call(void 0, "Completed the postProcess hook", config);
+    }
+    _chunkRCE3CC76js.writeSuccess.call(void 0, `Completed running the ${name} task executor!
+`, config);
+    return {
+      success: true
+    };
+  } catch (error) {
+    _chunkRCE3CC76js.writeFatal.call(void 0, "A fatal error occurred while running the executor - the process was forced to terminate", config);
+    _chunkRCE3CC76js.writeError.call(void 0, `An exception was thrown in the executor's process 
+ - Details: ${error.message}
+ - Stacktrace: ${error.stack}`, config);
+    return {
+      success: false
+    };
+  } finally {
+    stopwatch();
+  }
+}, "withRunExecutor");
+var _isFunction = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (value) => {
+  try {
+    return value instanceof Function || typeof value === "function" || !!(_optionalChain([value, 'optionalAccess', _37 => _37.constructor]) && _optionalChain([value, 'optionalAccess', _38 => _38.call]) && _optionalChain([value, 'optionalAccess', _39 => _39.apply]));
+  } catch (e) {
+    return false;
+  }
+}, "_isFunction");
+
+// ../workspace-tools/src/utils/cargo.ts
+var _devkit = require('@nx/devkit');
+
+var _path = require('path'); var path6 = _interopRequireWildcard(_path);
+var INVALID_CARGO_ARGS = [
+  "allFeatures",
+  "allTargets",
+  "main",
+  "outputPath",
+  "package",
+  "tsConfig"
+];
+var buildCargoCommand = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (baseCommand, options, context2) => {
+  const args = [];
+  if (options.toolchain && options.toolchain !== "stable") {
+    args.push(`+${options.toolchain}`);
+  }
+  args.push(baseCommand);
+  for (const [key, value] of Object.entries(options)) {
+    if (key === "toolchain" || key === "release" || INVALID_CARGO_ARGS.includes(key)) {
+      continue;
+    }
+    if (typeof value === "boolean") {
+      if (value) {
+        args.push(`--${key}`);
+      }
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        args.push(`--${key}`, item);
+      }
+    } else {
+      args.push(`--${key}`, String(value));
+    }
+  }
+  if (context2.projectName) {
+    args.push("-p", context2.projectName);
+  }
+  if (options.allFeatures && !args.includes("--all-features")) {
+    args.push("--all-features");
+  }
+  if (options.allTargets && !args.includes("--all-targets")) {
+    args.push("--all-targets");
+  }
+  if (options.release && !args.includes("--profile")) {
+    args.push("--release");
+  }
+  if (options.outputPath && !args.includes("--target-dir")) {
+    args.push("--target-dir", options.outputPath);
+  }
+  return args;
+}, "buildCargoCommand");
+async function cargoCommand(...args) {
+  console.log(`> cargo ${args.join(" ")}`);
+  args.push("--color", "always");
+  return await Promise.resolve(runProcess("cargo", ...args));
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, cargoCommand, "cargoCommand");
+function cargoCommandSync(args = "", options) {
+  const normalizedOptions = {
+    stdio: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _40 => _40.stdio]), () => ( "inherit")),
+    env: {
+      ...process.env,
+      ..._optionalChain([options, 'optionalAccess', _41 => _41.env])
+    }
+  };
+  try {
+    return {
+      output: _child_process.execSync.call(void 0, `cargo ${args}`, {
+        encoding: "utf8",
+        windowsHide: true,
+        stdio: normalizedOptions.stdio,
+        env: normalizedOptions.env,
+        maxBuffer: 1024 * 1024 * 10
+      }),
+      success: true
+    };
+  } catch (e) {
+    return {
+      output: e,
+      success: false
+    };
+  }
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, cargoCommandSync, "cargoCommandSync");
+function cargoMetadata() {
+  const output3 = cargoCommandSync("metadata --format-version=1", {
+    stdio: "pipe"
+  });
+  if (!output3.success) {
+    console.error("Failed to get cargo metadata");
+    return null;
+  }
+  return JSON.parse(output3.output);
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, cargoMetadata, "cargoMetadata");
+function runProcess(processCmd, ...args) {
+  const metadata = cargoMetadata();
+  const targetDir = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _42 => _42.target_directory]), () => ( _devkit.joinPathFragments.call(void 0, _devkit.workspaceRoot, "dist", "cargo")));
+  return new Promise((resolve) => {
+    if (process.env.VERCEL) {
+      return resolve({
+        success: true
+      });
+    }
+    _child_process.execSync.call(void 0, `${processCmd} ${args.join(" ")}`, {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        RUSTC_WRAPPER: "",
+        CARGO_TARGET_DIR: targetDir,
+        CARGO_BUILD_TARGET_DIR: targetDir
+      },
+      windowsHide: true,
+      stdio: [
+        "inherit",
+        "inherit",
+        "inherit"
+      ]
+    });
+    resolve({
+      success: true
+    });
+  });
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, runProcess, "runProcess");
+
+// ../workspace-tools/src/executors/cargo-build/executor.ts
+async function cargoBuildExecutor(options, context2) {
+  const command = buildCargoCommand("build", options, context2);
+  return await cargoCommand(...command);
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, cargoBuildExecutor, "cargoBuildExecutor");
+var executor_default = withRunExecutor("Cargo Build", cargoBuildExecutor, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options) => {
+      options.outputPath ??= "dist/target/{projectRoot}";
+      options.toolchain ??= "stable";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+// ../workspace-tools/src/executors/cargo-check/executor.ts
+async function cargoCheckExecutor(options, context2) {
+  const command = buildCargoCommand("check", options, context2);
+  return await cargoCommand(...command);
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, cargoCheckExecutor, "cargoCheckExecutor");
+var executor_default2 = withRunExecutor("Cargo Check", cargoCheckExecutor, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options) => {
+      options.toolchain ??= "stable";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+// ../workspace-tools/src/executors/cargo-clippy/executor.ts
+async function cargoClippyExecutor(options, context2) {
+  const command = buildCargoCommand("clippy", options, context2);
+  return await cargoCommand(...command);
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, cargoClippyExecutor, "cargoClippyExecutor");
+var executor_default3 = withRunExecutor("Cargo Clippy", cargoClippyExecutor, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options) => {
+      options.toolchain ??= "stable";
+      options.fix ??= false;
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+// ../workspace-tools/src/executors/cargo-doc/executor.ts
+var _deepclone = require('deep-clone'); var _deepclone2 = _interopRequireDefault(_deepclone);
+async function cargoDocExecutor(options, context2) {
+  const opts = _deepclone2.default.call(void 0, options);
+  opts["no-deps"] = opts.noDeps;
+  delete opts.noDeps;
+  const command = buildCargoCommand("doc", options, context2);
+  return await cargoCommand(...command);
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, cargoDocExecutor, "cargoDocExecutor");
+var executor_default4 = withRunExecutor("Cargo Doc", cargoDocExecutor, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options) => {
+      options.outputPath ??= "dist/docs/{projectRoot}";
+      options.toolchain ??= "stable";
+      options.release ??= options.profile ? false : true;
+      options.allFeatures ??= true;
+      options.lib ??= true;
+      options.bins ??= true;
+      options.examples ??= true;
+      options.noDeps ??= false;
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+// ../workspace-tools/src/executors/cargo-format/executor.ts
+async function cargoFormatExecutor(options, context2) {
+  const command = buildCargoCommand("fmt", options, context2);
+  return await cargoCommand(...command);
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, cargoFormatExecutor, "cargoFormatExecutor");
+var executor_default5 = withRunExecutor("Cargo Format", cargoFormatExecutor, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options) => {
+      options.outputPath ??= "dist/target/{projectRoot}";
+      options.toolchain ??= "stable";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+// ../workspace-tools/src/executors/cargo-publish/executor.ts
+
+
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _https = require('https'); var _https2 = _interopRequireDefault(_https);
+var LARGE_BUFFER2 = 1024 * 1e6;
+
+// ../esbuild/src/build.ts
+var _node = require('@humanfs/node');
+
+
+// ../build-tools/src/config.ts
+var DEFAULT_COMPILED_BANNER = `
+/**
+*      \u26A1 Built by Storm Software
+*/
+
+`;
+var DEFAULT_ENVIRONMENT = "production";
+var DEFAULT_TARGET = "esnext";
+var DEFAULT_ORGANIZATION = "storm-software";
+
+// ../build-tools/src/plugins/swc.ts
+var _core = require('@swc/core');
+
+// ../build-tools/src/plugins/ts-resolve.ts
+
+var _module = require('module');
+
+var _resolve2 = require('resolve'); var _resolve3 = _interopRequireDefault(_resolve2);
+
+// ../build-tools/src/plugins/type-definitions.ts
+
+
+
+// ../build-tools/src/utilities/copy-assets.ts
+
+
+var _js = require('@nx/js');
+var _glob = require('glob');
+
+// ../build-tools/src/utilities/read-nx-config.ts
+
+var readNxConfig = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (workspaceRoot3) => {
+  let rootDir = workspaceRoot3;
+  if (!rootDir) {
+    const config = await _chunkYE4FHRXJjs.loadStormConfig.call(void 0, );
+    rootDir = config.workspaceRoot;
+  }
+  const nxJsonPath = _chunkRCE3CC76js.joinPaths.call(void 0, rootDir, "nx.json");
+  if (!await _node.hfs.isFile(nxJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  return _node.hfs.json(nxJsonPath);
+}, "readNxConfig");
+
+// ../build-tools/src/utilities/copy-assets.ts
+var copyAssets = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (config, assets, outputPath, projectRoot, projectName, sourceRoot, generatePackageJson4 = true, includeSrc = false, banner, footer) => {
+  const pendingAssets = Array.from(_nullishCoalesce(assets, () => ( [])));
+  if (!_optionalChain([pendingAssets, 'optionalAccess', _43 => _43.some, 'call', _44 => _44((asset) => _optionalChain([asset, 'optionalAccess', _45 => _45.glob]) === "*.md")])) {
+    pendingAssets.push({
+      input: projectRoot,
+      glob: "*.md",
+      output: "/"
+    });
+  }
+  if (generatePackageJson4 === false) {
+    pendingAssets.push({
+      input: sourceRoot,
+      glob: "package.json",
+      output: "."
+    });
+  }
+  if (!_optionalChain([pendingAssets, 'optionalAccess', _46 => _46.some, 'call', _47 => _47((asset) => _optionalChain([asset, 'optionalAccess', _48 => _48.glob]) === "LICENSE")])) {
+    pendingAssets.push({
+      input: "",
+      glob: "LICENSE",
+      output: "."
+    });
+  }
+  if (includeSrc === true) {
+    pendingAssets.push({
+      input: sourceRoot,
+      glob: "**/{*.ts,*.tsx,*.js,*.jsx}",
+      output: "src/"
+    });
+  }
+  const nxJson = readNxConfig(config.workspaceRoot);
+  const projectGraph = await _devkit.createProjectGraphAsync.call(void 0, {
+    exitOnError: true
+  });
+  const projectsConfigurations = _devkit.readProjectsConfigurationFromProjectGraph.call(void 0, projectGraph);
+  if (!_optionalChain([projectsConfigurations, 'optionalAccess', _49 => _49.projects, 'optionalAccess', _50 => _50[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 buildTarget = _optionalChain([projectsConfigurations, 'access', _51 => _51.projects, 'access', _52 => _52[projectName], 'optionalAccess', _53 => _53.targets, 'optionalAccess', _54 => _54.build]);
+  if (!buildTarget) {
+    throw new Error(`The Build process failed because the project does not have a valid build target in the project.json file. Check if the file exists in the root of the project at ${_chunkRCE3CC76js.joinPaths.call(void 0, projectRoot, "project.json")}`);
+  }
+  const result = await _js.copyAssets.call(void 0, {
+    assets,
+    watch: false,
+    outputPath
+  }, {
+    root: config.workspaceRoot,
+    targetName: "build",
+    target: buildTarget,
+    projectName,
+    projectGraph,
+    projectsConfigurations,
+    nxJsonConfiguration: nxJson,
+    cwd: config.workspaceRoot,
+    isVerbose: _chunkRCE3CC76js.isVerbose.call(void 0, config.logLevel)
+  });
+  if (!result.success) {
+    throw new Error("The Build process failed trying to copy assets");
+  }
+  if (includeSrc === true) {
+    _chunkRCE3CC76js.writeDebug.call(void 0, `\u{1F4DD}  Adding banner and writing source files: ${_chunkRCE3CC76js.joinPaths.call(void 0, outputPath, "src")}`, config);
+    const files = await _glob.glob.call(void 0, [
+      _chunkRCE3CC76js.joinPaths.call(void 0, config.workspaceRoot, outputPath, "src/**/*.ts"),
+      _chunkRCE3CC76js.joinPaths.call(void 0, config.workspaceRoot, outputPath, "src/**/*.tsx"),
+      _chunkRCE3CC76js.joinPaths.call(void 0, config.workspaceRoot, outputPath, "src/**/*.js"),
+      _chunkRCE3CC76js.joinPaths.call(void 0, config.workspaceRoot, outputPath, "src/**/*.jsx")
+    ]);
+    await Promise.allSettled(files.map(async (file) => _node.hfs.write(file, `${banner && typeof banner === "string" ? banner.startsWith("//") ? banner : `// ${banner}` : ""}
+
+${await _node.hfs.text(file)}
+
+${footer && typeof footer === "string" ? footer.startsWith("//") ? footer : `// ${footer}` : ""}`)));
+  }
+}, "copyAssets");
+
+// ../build-tools/src/utilities/generate-package-json.ts
+
+var _buildablelibsutils = require('@nx/js/src/utils/buildable-libs-utils');
+
+var _projectgraph = require('nx/src/project-graph/project-graph');
+var addPackageDependencies = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (workspaceRoot3, projectRoot, projectName, packageJson) => {
+  const projectGraph = await _projectgraph.createProjectGraphAsync.call(void 0, {
+    exitOnError: true
+  });
+  const projectConfigurations = _projectgraph.readProjectsConfigurationFromProjectGraph.call(void 0, projectGraph);
+  if (!_optionalChain([projectConfigurations, 'optionalAccess', _55 => _55.projects, 'optionalAccess', _56 => _56[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 projectJsonPath = _chunkRCE3CC76js.joinPaths.call(void 0, workspaceRoot3, projectRoot, "project.json");
+  if (!await _node.hfs.isFile(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  if (!_optionalChain([projectConfigurations, 'optionalAccess', _57 => _57.projects, 'optionalAccess', _58 => _58[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 projectDependencies = _buildablelibsutils.calculateProjectBuildableDependencies.call(void 0, void 0, projectGraph, workspaceRoot3, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  const localPackages = [];
+  for (const project of projectDependencies.dependencies.filter((dep) => dep.node.type === "lib" && dep.node.data.root !== projectRoot && dep.node.data.root !== workspaceRoot3)) {
+    const projectNode = project.node;
+    if (projectNode.data.root) {
+      const projectPackageJsonPath = _chunkRCE3CC76js.joinPaths.call(void 0, workspaceRoot3, projectNode.data.root, "package.json");
+      if (await _node.hfs.isFile(projectPackageJsonPath)) {
+        const projectPackageJson = await _node.hfs.json(projectPackageJsonPath);
+        if (projectPackageJson.private !== false) {
+          localPackages.push(projectPackageJson);
+        }
+      }
+    }
+  }
+  if (localPackages.length > 0) {
+    _chunkRCE3CC76js.writeTrace.call(void 0, `\u{1F4E6}  Adding local packages to package.json: ${localPackages.map((p) => p.name).join(", ")}`);
+    packageJson.peerDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = `>=${localPackage.version || "0.0.1"}`;
+      }
+      return ret;
+    }, _nullishCoalesce(packageJson.peerDependencies, () => ( {})));
+    packageJson.peerDependenciesMeta = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = {
+          optional: false
+        };
+      }
+      return ret;
+    }, _nullishCoalesce(packageJson.peerDependenciesMeta, () => ( {})));
+    packageJson.devDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = localPackage.version || "0.0.1";
+      }
+      return ret;
+    }, _nullishCoalesce(packageJson.peerDependencies, () => ( {})));
+  } else {
+    _chunkRCE3CC76js.writeTrace.call(void 0, "\u{1F4E6}  No local packages dependencies to add to package.json");
+  }
+  return packageJson;
+}, "addPackageDependencies");
+var addWorkspacePackageJsonFields = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (config, projectRoot, sourceRoot, projectName, includeSrc = false, packageJson) => {
+  const workspaceRoot3 = config.workspaceRoot ? config.workspaceRoot : _chunkRCE3CC76js.findWorkspaceRoot.call(void 0, );
+  const workspacePackageJson = await _node.hfs.json(_chunkRCE3CC76js.joinPaths.call(void 0, workspaceRoot3, "package.json"));
+  packageJson.type ??= "module";
+  packageJson.sideEffects ??= false;
+  if (includeSrc === true) {
+    let distSrc = sourceRoot.replace(projectRoot, "");
+    if (distSrc.startsWith("/")) {
+      distSrc = distSrc.substring(1);
+    }
+    packageJson.source ??= `${_chunkRCE3CC76js.joinPaths.call(void 0, distSrc, "index.ts").replaceAll("\\", "/")}`;
+  }
+  packageJson.files ??= [
+    "dist/**/*"
+  ];
+  if (includeSrc === true && !packageJson.files.includes("src")) {
+    packageJson.files.push("src/**/*");
+  }
+  packageJson.publishConfig ??= {
+    access: "public"
+  };
+  packageJson.description ??= workspacePackageJson.description;
+  packageJson.homepage ??= workspacePackageJson.homepage;
+  packageJson.bugs ??= workspacePackageJson.bugs;
+  packageJson.license ??= workspacePackageJson.license;
+  packageJson.keywords ??= workspacePackageJson.keywords;
+  packageJson.funding ??= workspacePackageJson.funding;
+  packageJson.author ??= workspacePackageJson.author;
+  packageJson.maintainers ??= workspacePackageJson.maintainers;
+  if (!packageJson.maintainers && packageJson.author) {
+    packageJson.maintainers = [
+      packageJson.author
+    ];
+  }
+  packageJson.contributors ??= workspacePackageJson.contributors;
+  if (!packageJson.contributors && packageJson.author) {
+    packageJson.contributors = [
+      packageJson.author
+    ];
+  }
+  packageJson.repository ??= workspacePackageJson.repository;
+  packageJson.repository.directory ??= projectRoot ? projectRoot : _chunkRCE3CC76js.joinPaths.call(void 0, "packages", projectName);
+  return packageJson;
+}, "addWorkspacePackageJsonFields");
+var addPackageJsonExport = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (file, type = "module", sourceRoot) => {
+  let entry = file.replaceAll("\\", "/");
+  if (sourceRoot) {
+    entry = entry.replace(sourceRoot, "");
+  }
+  return {
+    "import": {
+      "types": `./dist/${entry}.d.${type === "module" ? "ts" : "mts"}`,
+      "default": `./dist/${entry}.${type === "module" ? "js" : "mjs"}`
+    },
+    "require": {
+      "types": `./dist/${entry}.d.${type === "commonjs" ? "ts" : "cts"}`,
+      "default": `./dist/${entry}.${type === "commonjs" ? "js" : "cjs"}`
+    },
+    "default": {
+      "types": `./dist/${entry}.d.ts`,
+      "default": `./dist/${entry}.js`
+    }
+  };
+}, "addPackageJsonExport");
+var addPackageJsonExports = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (sourceRoot, packageJson) => {
+  packageJson.exports ??= {};
+  const files = await new (0, _glob.Glob)("**/*.{ts,tsx}", {
+    absolute: false,
+    cwd: sourceRoot,
+    root: sourceRoot
+  }).walk();
+  files.forEach((file) => {
+    addPackageJsonExport(file, packageJson.type, sourceRoot);
+    const split = file.split(".");
+    split.pop();
+    const entry = split.join(".").replaceAll("\\", "/");
+    packageJson.exports[`./${entry}`] ??= addPackageJsonExport(entry, packageJson.type, sourceRoot);
+  });
+  packageJson.main = packageJson.type === "commonjs" ? "./dist/index.js" : "./dist/index.cjs";
+  packageJson.module = packageJson.type === "module" ? "./dist/index.js" : "./dist/index.mjs";
+  packageJson.types = "./dist/index.d.ts";
+  packageJson.exports ??= {};
+  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);
+  packageJson.exports["./package.json"] ??= "./package.json";
+  packageJson.exports["."] = _nullishCoalesce(packageJson.exports["."], () => ( addPackageJsonExport("index", packageJson.type, sourceRoot)));
+  return packageJson;
+}, "addPackageJsonExports");
+
+// ../build-tools/src/utilities/get-entry-points.ts
+
+var getEntryPoints = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (config, projectRoot, sourceRoot, entry, emitOnAll = false) => {
+  const workspaceRoot3 = config.workspaceRoot ? config.workspaceRoot : _chunkRCE3CC76js.findWorkspaceRoot.call(void 0, );
+  const entryPoints = [];
+  if (entry) {
+    if (Array.isArray(entry)) {
+      entryPoints.push(...entry);
+    } else if (typeof entry === "string") {
+      entryPoints.push(entry);
+    } else {
+      entryPoints.push(...Object.values(entry));
+    }
+  }
+  if (emitOnAll) {
+    entryPoints.push(_chunkRCE3CC76js.joinPaths.call(void 0, workspaceRoot3, sourceRoot || projectRoot, "**/*.{ts,tsx}"));
+  }
+  const results = [];
+  for (const entryPoint in entryPoints) {
+    if (entryPoint.includes("*")) {
+      const files = await _glob.glob.call(void 0, entryPoint, {
+        withFileTypes: true
+      });
+      results.push(...files.reduce((ret, filePath) => {
+        const result = _chunkRCE3CC76js.correctPaths.call(void 0, _chunkRCE3CC76js.joinPaths.call(void 0, filePath.path, filePath.name).replaceAll(_chunkRCE3CC76js.correctPaths.call(void 0, workspaceRoot3), "").replaceAll(_chunkRCE3CC76js.correctPaths.call(void 0, projectRoot), ""));
+        if (result) {
+          _chunkRCE3CC76js.writeDebug.call(void 0, `Trying to add entry point ${result} at "${_chunkRCE3CC76js.joinPaths.call(void 0, filePath.path, filePath.name)}"`, config);
+          if (!results.includes(result)) {
+            results.push(result);
+          }
+        }
+        return ret;
+      }, []));
+    } else {
+      results.push(entryPoint);
+    }
+  }
+  return results;
+}, "getEntryPoints");
+
+// ../build-tools/src/utilities/get-env.ts
+var getEnv = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (builder, options) => {
+  return {
+    STORM_BUILD: builder,
+    STORM_ORG: options.orgName || DEFAULT_ORGANIZATION,
+    STORM_NAME: options.name,
+    STORM_ENV: options.envName || DEFAULT_ENVIRONMENT,
+    STORM_PLATFORM: options.platform,
+    STORM_FORMAT: JSON.stringify(options.format),
+    STORM_TARGET: JSON.stringify(options.target),
+    ...options.env
+  };
+}, "getEnv");
+
+// ../build-tools/src/utilities/get-out-extension.ts
+function getOutExtension(format, pkgType) {
+  let jsExtension = ".js";
+  let dtsExtension = ".d.ts";
+  if (pkgType === "module" && format === "cjs") {
+    jsExtension = ".cjs";
+    dtsExtension = ".d.cts";
+  }
+  if (pkgType !== "module" && format === "esm") {
+    jsExtension = ".mjs";
+    dtsExtension = ".d.mts";
+  }
+  if (format === "iife") {
+    jsExtension = ".global.js";
+  }
+  return {
+    js: jsExtension,
+    dts: dtsExtension
+  };
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, getOutExtension, "getOutExtension");
+
+// ../build-tools/src/utilities/task-graph.ts
+var _createtaskgraph = require('nx/src/tasks-runner/create-task-graph');
+
+// ../esbuild/src/build.ts
+var _chokidar = require('chokidar');
+var _defu = require('defu'); var _defu2 = _interopRequireDefault(_defu);
+var _estoolkit = require('es-toolkit');
+var _compat = require('es-toolkit/compat');
+var _esbuild = require('esbuild'); var esbuild2 = _interopRequireWildcard(_esbuild); var esbuild = _interopRequireWildcard(_esbuild);
+var _globby = require('globby');
+var _findworkspaceroot = require('nx/src/utils/find-workspace-root');
+
+// ../esbuild/src/base/renderer-engine.ts
+
+var _sourcemap = require('source-map');
+
+// ../esbuild/src/utilities/output-file.ts
+
+
+var outputFile = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (filepath, data, options) => {
+  await _fs2.default.promises.mkdir(path6.default.dirname(filepath), {
+    recursive: true
+  });
+  await _fs2.default.promises.writeFile(filepath, data, options);
+}, "outputFile");
+
+// ../esbuild/src/base/renderer-engine.ts
+var parseSourceMap = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (map2) => {
+  return typeof map2 === "string" ? JSON.parse(map2) : map2;
+}, "parseSourceMap");
+var isJS = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (path7) => /\.(js|mjs|cjs)$/.test(path7), "isJS");
+var isCSS = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (path7) => /\.css$/.test(path7), "isCSS");
+var getSourcemapComment = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (inline, map2, filepath, isCssFile) => {
+  if (!map2) return "";
+  const prefix = isCssFile ? "/*" : "//";
+  const suffix = isCssFile ? " */" : "";
+  const url = inline ? `data:application/json;base64,${Buffer.from(typeof map2 === "string" ? map2 : JSON.stringify(map2)).toString("base64")}` : `${path6.default.basename(filepath)}.map`;
+  return `${prefix}# sourceMappingURL=${url}${suffix}`;
+}, "getSourcemapComment");
+var RendererEngine = class {
+  static {
+    _chunkJ5SB6L2Ljs.__name.call(void 0, this, "RendererEngine");
+  }
+  #renderers;
+  #options;
+  constructor(renderers) {
+    this.#renderers = renderers;
+  }
+  setOptions(options) {
+    this.#options = options;
+  }
+  getOptions() {
+    if (!this.#options) {
+      throw new Error(`Renderer options is not set`);
+    }
+    return this.#options;
+  }
+  modifyEsbuildOptions(options) {
+    for (const renderer of this.#renderers) {
+      if (renderer.esbuildOptions) {
+        renderer.esbuildOptions.call(this.getOptions(), options);
+      }
+    }
+  }
+  async buildStarted() {
+    for (const renderer of this.#renderers) {
+      if (renderer.buildStart) {
+        await renderer.buildStart.call(this.getOptions());
+      }
+    }
+  }
+  async buildFinished({ outputFiles, metafile }) {
+    const files = outputFiles.filter((file) => !file.path.endsWith(".map")).map((file) => {
+      if (isJS(file.path) || isCSS(file.path)) {
+        let relativePath = path6.default.relative(this.getOptions().config.workspaceRoot, file.path);
+        if (!relativePath.startsWith("\\\\?\\")) {
+          relativePath = relativePath.replace(/\\/g, "/");
+        }
+        const meta = _optionalChain([metafile, 'optionalAccess', _59 => _59.outputs, 'access', _60 => _60[relativePath]]);
+        return {
+          type: "chunk",
+          path: file.path,
+          code: file.text,
+          map: _optionalChain([outputFiles, 'access', _61 => _61.find, 'call', _62 => _62((f) => f.path === `${file.path}.map`), 'optionalAccess', _63 => _63.text]),
+          entryPoint: _optionalChain([meta, 'optionalAccess', _64 => _64.entryPoint]),
+          exports: _optionalChain([meta, 'optionalAccess', _65 => _65.exports]),
+          imports: _optionalChain([meta, 'optionalAccess', _66 => _66.imports])
+        };
+      } else {
+        return {
+          type: "asset",
+          path: file.path,
+          contents: file.contents
+        };
+      }
+    });
+    const writtenFiles = [];
+    await Promise.all(files.map(async (info) => {
+      for (const renderer of this.#renderers) {
+        if (info.type === "chunk" && renderer.renderChunk) {
+          const result = await renderer.renderChunk.call(this.getOptions(), info.code, info);
+          if (result) {
+            info.code = result.code;
+            if (result.map) {
+              const originalConsumer = await new (0, _sourcemap.SourceMapConsumer)(parseSourceMap(info.map));
+              const newConsumer = await new (0, _sourcemap.SourceMapConsumer)(parseSourceMap(result.map));
+              const generator = _sourcemap.SourceMapGenerator.fromSourceMap(newConsumer);
+              generator.applySourceMap(originalConsumer, info.path);
+              info.map = generator.toJSON();
+              originalConsumer.destroy();
+              newConsumer.destroy();
+            }
+          }
+        }
+      }
+      const inlineSourceMap = this.#options.sourcemap === "inline";
+      const contents = info.type === "chunk" ? info.code + getSourcemapComment(inlineSourceMap, info.map, info.path, isCSS(info.path)) : info.contents;
+      await outputFile(info.path, contents, {
+        mode: info.type === "chunk" ? info.mode : void 0
+      });
+      writtenFiles.push({
+        get name() {
+          return path6.default.relative(process.cwd(), info.path);
+        },
+        get size() {
+          return contents.length;
+        }
+      });
+      if (info.type === "chunk" && info.map && !inlineSourceMap) {
+        const map2 = typeof info.map === "string" ? JSON.parse(info.map) : info.map;
+        const outPath = `${info.path}.map`;
+        const contents2 = JSON.stringify(map2);
+        await outputFile(outPath, contents2);
+        writtenFiles.push({
+          get name() {
+            return path6.default.relative(process.cwd(), outPath);
+          },
+          get size() {
+            return contents2.length;
+          }
+        });
+      }
+    }));
+    for (const renderer of this.#renderers) {
+      if (renderer.buildEnd) {
+        await renderer.buildEnd.call(this.getOptions(), {
+          writtenFiles
+        });
+      }
+    }
+  }
+};
+
+// ../esbuild/src/clean.ts
+
+async function clean(name = "ESBuild", directory, config) {
+  _chunkRCE3CC76js.writeDebug.call(void 0, ` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, `${name} output clean`);
+  await _node.hfs.deleteAll(directory);
+  stopwatch();
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, clean, "clean");
+
+// ../esbuild/src/plugins/esm-split-code-to-cjs.ts
+
+var esmSplitCodeToCjsPlugin = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options, resolvedOptions) => ({
+  name: "storm:esm-split-code-to-cjs",
+  setup(build6) {
+    build6.onEnd(async (result) => {
+      const outFiles = Object.keys(_nullishCoalesce(_optionalChain([result, 'access', _67 => _67.metafile, 'optionalAccess', _68 => _68.outputs]), () => ( {})));
+      const jsFiles = outFiles.filter((f) => f.endsWith("js"));
+      await esbuild.build({
+        outdir: resolvedOptions.outdir,
+        entryPoints: jsFiles,
+        allowOverwrite: true,
+        format: "cjs",
+        logLevel: "error",
+        packages: "external"
+      });
+    });
+  }
+}), "esmSplitCodeToCjsPlugin");
+
+// ../esbuild/src/plugins/fix-imports.ts
+var fixImportsPlugin = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options, resolvedOptions) => ({
+  name: "storm:fix-imports",
+  setup(build6) {
+    build6.onResolve({
+      filter: /^spdx-exceptions/
+    }, () => {
+      return {
+        path: _chunkJ5SB6L2Ljs.__require.resolve("spdx-exceptions")
+      };
+    });
+    build6.onResolve({
+      filter: /^spdx-license-ids/
+    }, () => {
+      return {
+        path: _chunkJ5SB6L2Ljs.__require.resolve("spdx-license-ids")
+      };
+    });
+  }
+}), "fixImportsPlugin");
+
+// ../esbuild/src/plugins/native-node-module.ts
+
+var nativeNodeModulesPlugin = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options, resolvedOptions) => {
+  return {
+    name: "native-node-modules",
+    setup(build6) {
+      build6.onResolve({
+        filter: /\.node$/,
+        namespace: "file"
+      }, (args) => {
+        const resolvedId = _chunkJ5SB6L2Ljs.__require.resolve(args.path, {
+          paths: [
+            args.resolveDir
+          ]
+        });
+        if (resolvedId.endsWith(".node")) {
+          return {
+            path: resolvedId,
+            namespace: "node-file"
+          };
+        }
+        return {
+          path: resolvedId
+        };
+      });
+      build6.onLoad({
+        filter: /.*/,
+        namespace: "node-file"
+      }, (args) => {
+        return {
+          contents: `
+            import path from ${JSON.stringify(args.path)}
+            try { module.exports = require(path) }
+            catch {}
+          `,
+          resolveDir: _path.dirname.call(void 0, args.path)
+        };
+      });
+      build6.onResolve({
+        filter: /\.node$/,
+        namespace: "node-file"
+      }, (args) => ({
+        path: args.path,
+        namespace: "file"
+      }));
+      const opts = build6.initialOptions;
+      opts.loader = opts.loader || {};
+      opts.loader[".node"] = "file";
+    }
+  };
+}, "nativeNodeModulesPlugin");
+
+// ../esbuild/src/plugins/node-protocol.ts
+var nodeProtocolPlugin = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options, resolvedOptions) => {
+  const nodeProtocol = "node:";
+  return {
+    name: "node-protocol-plugin",
+    setup({ onResolve }) {
+      onResolve({
+        filter: /^node:/
+      }, ({ path: path7 }) => ({
+        path: path7.slice(nodeProtocol.length),
+        external: true
+      }));
+    }
+  };
+}, "nodeProtocolPlugin");
+
+// ../esbuild/src/plugins/on-error.ts
+var onErrorPlugin = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options, resolvedOptions) => ({
+  name: "storm:on-error",
+  setup(build6) {
+    build6.onEnd((result) => {
+      if (result.errors.length > 0 && process.env.WATCH !== "true") {
+        _chunkRCE3CC76js.writeError.call(void 0, `The following errors occurred during the build:
+${result.errors.map((error) => error.text).join("\n")}
+
+`, resolvedOptions.config);
+        throw new Error("Storm esbuild process failed with errors.");
+      }
+    });
+  }
+}), "onErrorPlugin");
+
+// ../esbuild/src/plugins/resolve-paths.ts
+
+function resolvePathsConfig(options, cwd) {
+  if (_optionalChain([options, 'optionalAccess', _69 => _69.compilerOptions, 'optionalAccess', _70 => _70.paths])) {
+    const paths = Object.entries(options.compilerOptions.paths);
+    const resolvedPaths = paths.map(([key, paths2]) => {
+      return [
+        key,
+        paths2.map((v) => path6.default.resolve(cwd, v))
+      ];
+    });
+    return Object.fromEntries(resolvedPaths);
+  }
+  if (options.extends) {
+    const extendsPath = path6.default.resolve(cwd, options.extends);
+    const extendsDir = path6.default.dirname(extendsPath);
+    const extendsConfig = _chunkJ5SB6L2Ljs.__require.call(void 0, extendsPath);
+    return resolvePathsConfig(extendsConfig, extendsDir);
+  }
+  return [];
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, resolvePathsConfig, "resolvePathsConfig");
+var resolvePathsPlugin = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options, resolvedOptions) => ({
+  name: "storm:resolve-paths",
+  setup(build6) {
+    const parentTsConfig = build6.initialOptions.tsconfig ? _chunkJ5SB6L2Ljs.__require.call(void 0, _chunkRCE3CC76js.joinPaths.call(void 0, resolvedOptions.config.workspaceRoot, build6.initialOptions.tsconfig)) : _chunkJ5SB6L2Ljs.__require.call(void 0, _chunkRCE3CC76js.joinPaths.call(void 0, resolvedOptions.config.workspaceRoot, "tsconfig.json"));
+    const resolvedTsPaths = resolvePathsConfig(parentTsConfig, options.projectRoot);
+    const packagesRegex = new RegExp(`^(${Object.keys(resolvedTsPaths).join("|")})$`);
+    build6.onResolve({
+      filter: packagesRegex
+    }, (args) => {
+      if (_optionalChain([build6, 'access', _71 => _71.initialOptions, 'access', _72 => _72.external, 'optionalAccess', _73 => _73.includes, 'call', _74 => _74(args.path)])) {
+        return {
+          path: args.path,
+          external: true
+        };
+      }
+      return {
+        path: `${resolvedTsPaths[args.path][0]}/index.ts`
+      };
+    });
+  }
+}), "resolvePathsPlugin");
+
+// ../esbuild/src/plugins/tsc.ts
+
+var _apiextractor = require('@microsoft/api-extractor');
+function bundleTypeDefinitions(filename, outfile, externals, options) {
+  const { dependencies, peerDependencies, devDependencies } = _chunkJ5SB6L2Ljs.__require.call(void 0, _chunkRCE3CC76js.joinPaths.call(void 0, options.projectRoot, "package.json"));
+  const dependenciesKeys = Object.keys(_nullishCoalesce(dependencies, () => ( {}))).flatMap((p) => [
+    p,
+    getTypeDependencyPackageName(p)
+  ]);
+  const peerDependenciesKeys = Object.keys(_nullishCoalesce(peerDependencies, () => ( {}))).flatMap((p) => [
+    p,
+    getTypeDependencyPackageName(p)
+  ]);
+  const devDependenciesKeys = Object.keys(_nullishCoalesce(devDependencies, () => ( {}))).flatMap((p) => [
+    p,
+    getTypeDependencyPackageName(p)
+  ]);
+  const includeDeps = devDependenciesKeys;
+  const excludeDeps = /* @__PURE__ */ new Set([
+    ...dependenciesKeys,
+    ...peerDependenciesKeys,
+    ...externals
+  ]);
+  const bundledPackages = includeDeps.filter((dep) => !excludeDeps.has(dep));
+  const extractorConfig = _apiextractor.ExtractorConfig.prepare({
+    configObject: {
+      projectFolder: options.projectRoot,
+      mainEntryPointFilePath: filename,
+      bundledPackages,
+      compiler: {
+        tsconfigFilePath: options.tsconfig,
+        overrideTsconfig: {
+          compilerOptions: {
+            paths: {}
+            // bug with api extract + paths
+          }
+        }
+      },
+      dtsRollup: {
+        enabled: true,
+        untrimmedFilePath: _chunkRCE3CC76js.joinPaths.call(void 0, options.outdir, `${outfile}.d.ts`)
+      },
+      tsdocMetadata: {
+        enabled: false
+      }
+    },
+    packageJsonFullPath: _chunkRCE3CC76js.joinPaths.call(void 0, options.projectRoot, "package.json"),
+    configObjectFullPath: void 0
+  });
+  const extractorResult = _apiextractor.Extractor.invoke(extractorConfig, {
+    showVerboseMessages: true,
+    localBuild: true
+  });
+  if (extractorResult.succeeded === false) {
+    _chunkRCE3CC76js.writeError.call(void 0, `API Extractor completed with ${extractorResult.errorCount} ${extractorResult.errorCount === 1 ? "error" : "errors"}`);
+    throw new Error("API Extractor completed with errors");
+  }
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, bundleTypeDefinitions, "bundleTypeDefinitions");
+var tscPlugin = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options, resolvedOptions) => ({
+  name: "storm:tsc",
+  setup(build6) {
+    if (options.emitTypes === false) {
+      return;
+    }
+    build6.onStart(async () => {
+      if (process.env.WATCH !== "true" && process.env.DEV !== "true") {
+        await run(resolvedOptions.config, `pnpm exec tsc --project ${resolvedOptions.tsconfig}`, resolvedOptions.config.workspaceRoot);
+      }
+      if (resolvedOptions.bundle && resolvedOptions.entryPoints && resolvedOptions.entryPoints.length > 0 && resolvedOptions.entryPoints[0] && resolvedOptions.entryPoints[0].endsWith(".ts")) {
+        const sourceRoot = resolvedOptions.sourceRoot.replaceAll(resolvedOptions.projectRoot, "");
+        const typeOutDir = resolvedOptions.outdir;
+        const entryPoint = resolvedOptions.entryPoints[0].replace(sourceRoot, "").replace(/\.ts$/, "");
+        const bundlePath = _chunkRCE3CC76js.joinPaths.call(void 0, resolvedOptions.outdir, entryPoint);
+        let dtsPath;
+        if (await _node.hfs.isFile(_chunkRCE3CC76js.joinPaths.call(void 0, resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint}.d.ts`))) {
+          dtsPath = _chunkRCE3CC76js.joinPaths.call(void 0, resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint}.d.ts`);
+        } else if (await _node.hfs.isFile(_chunkRCE3CC76js.joinPaths.call(void 0, resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint.replace(/^src\//, "")}.d.ts`))) {
+          dtsPath = _chunkRCE3CC76js.joinPaths.call(void 0, resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint.replace(/^src\//, "")}.d.ts`);
+        }
+        const ext = resolvedOptions.outExtension.dts || resolvedOptions.format === "esm" ? "d.mts" : "d.ts";
+        if (process.env.WATCH !== "true" && process.env.DEV !== "true") {
+          bundleTypeDefinitions(dtsPath, bundlePath, _nullishCoalesce(resolvedOptions.external, () => ( [])), resolvedOptions);
+          const dtsContents = await _node.hfs.text(`${bundlePath}.d.ts`);
+          await _node.hfs.write(`${bundlePath}.${ext}`, dtsContents);
+        } else {
+          await _node.hfs.write(`${bundlePath}.${ext}`, `export * from './${entryPoint}'`);
+        }
+      }
+    });
+  }
+}), "tscPlugin");
+function getTypeDependencyPackageName(npmPackage) {
+  if (npmPackage.startsWith("@")) {
+    const [scope, name] = npmPackage.split("/");
+    return `@types/${_optionalChain([scope, 'optionalAccess', _75 => _75.slice, 'call', _76 => _76(1)])}__${name}`;
+  }
+  return `@types/${npmPackage}`;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, getTypeDependencyPackageName, "getTypeDependencyPackageName");
+
+// ../esbuild/src/config.ts
+var getOutputExtensionMap = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options, pkgType) => {
+  return options.outExtension ? options.outExtension(options.format, pkgType) : getOutExtension(options.format, pkgType);
+}, "getOutputExtensionMap");
+var getDefaultBuildPlugins = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options, resolvedOptions) => [
+  nodeProtocolPlugin(options, resolvedOptions),
+  resolvePathsPlugin(options, resolvedOptions),
+  fixImportsPlugin(options, resolvedOptions),
+  nativeNodeModulesPlugin(options, resolvedOptions),
+  esmSplitCodeToCjsPlugin(options, resolvedOptions),
+  tscPlugin(options, resolvedOptions),
+  onErrorPlugin(options, resolvedOptions)
+], "getDefaultBuildPlugins");
+var DEFAULT_BUILD_OPTIONS = {
+  platform: "node",
+  target: "node22",
+  format: "cjs",
+  external: [],
+  logLevel: "error",
+  tsconfig: "tsconfig.json",
+  envName: "production",
+  keepNames: true,
+  metafile: true,
+  injectShims: true,
+  color: true,
+  watch: false,
+  bundle: true,
+  clean: true,
+  debug: false,
+  loader: {
+    ".aac": "file",
+    ".css": "file",
+    ".eot": "file",
+    ".flac": "file",
+    ".gif": "file",
+    ".jpeg": "file",
+    ".jpg": "file",
+    ".mp3": "file",
+    ".mp4": "file",
+    ".ogg": "file",
+    ".otf": "file",
+    ".png": "file",
+    ".svg": "file",
+    ".ttf": "file",
+    ".wav": "file",
+    ".webm": "file",
+    ".webp": "file",
+    ".woff": "file",
+    ".woff2": "file"
+  },
+  banner: DEFAULT_COMPILED_BANNER
+};
+
+// ../esbuild/src/plugins/deps-check.ts
+
+
+var unusedIgnore = [
+  // these are our dev dependencies
+  /@types\/.*?/,
+  /@typescript-eslint.*?/,
+  /eslint.*?/,
+  "esbuild",
+  "husky",
+  "is-ci",
+  "lint-staged",
+  "prettier",
+  "typescript",
+  "ts-node",
+  "ts-jest",
+  "@swc/core",
+  "@swc/jest",
+  "jest",
+  // these are missing 3rd party deps
+  "spdx-exceptions",
+  "spdx-license-ids",
+  // type-only, so it is not detected
+  "ts-toolbelt",
+  // these are indirectly used by build
+  "buffer"
+];
+var missingIgnore = [
+  ".prisma",
+  "@prisma/client",
+  "ts-toolbelt"
+];
+var depsCheckPlugin = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (bundle) => ({
+  name: "storm:deps-check",
+  setup(build6) {
+    const pkgJsonPath = path6.default.join(process.cwd(), "package.json");
+    const pkgContents = _chunkJ5SB6L2Ljs.__require.call(void 0, pkgJsonPath);
+    const regDependencies = Object.keys(_nullishCoalesce(pkgContents["dependencies"], () => ( {})));
+    const devDependencies = Object.keys(_nullishCoalesce(pkgContents["devDependencies"], () => ( {})));
+    const peerDependencies = Object.keys(_nullishCoalesce(pkgContents["peerDependencies"], () => ( {})));
+    const dependencies = [
+      ...regDependencies,
+      ...bundle ? devDependencies : []
+    ];
+    const collectedDependencies = /* @__PURE__ */ new Set();
+    const onlyPackages = /^[^./](?!:)|^\.[^./]|^\.\.[^/]/;
+    build6.onResolve({
+      filter: onlyPackages
+    }, (args) => {
+      if (args.importer.includes(process.cwd())) {
+        if (args.path[0] === "@") {
+          const [org, pkg] = args.path.split("/");
+          collectedDependencies.add(`${org}/${pkg}`);
+        } else {
+          const [pkg] = args.path.split("/");
+          collectedDependencies.add(pkg);
+        }
+      }
+      return {
+        external: true
+      };
+    });
+    build6.onEnd(() => {
+      const unusedDependencies = [
+        ...dependencies
+      ].filter((dep) => {
+        return !collectedDependencies.has(dep) || _module.builtinModules.includes(dep);
+      });
+      const missingDependencies = [
+        ...collectedDependencies
+      ].filter((dep) => {
+        return !dependencies.includes(dep) && !_module.builtinModules.includes(dep);
+      });
+      const filteredUnusedDeps = unusedDependencies.filter((dep) => {
+        return !unusedIgnore.some((pattern) => dep.match(pattern));
+      });
+      const filteredMissingDeps = missingDependencies.filter((dep) => {
+        return !missingIgnore.some((pattern) => dep.match(pattern)) && !peerDependencies.includes(dep);
+      });
+      _chunkRCE3CC76js.writeWarning.call(void 0, `Unused Dependencies: ${JSON.stringify(filteredUnusedDeps)}`);
+      _chunkRCE3CC76js.writeError.call(void 0, `Missing Dependencies: ${JSON.stringify(filteredMissingDeps)}`);
+      if (filteredMissingDeps.length > 0) {
+        throw new Error(`Missing dependencies detected - please install them:
+${JSON.stringify(filteredMissingDeps)}
+`);
+      }
+    });
+  }
+}), "depsCheckPlugin");
+
+// ../esbuild/src/renderers/shebang.ts
+var shebangRenderer = {
+  name: "shebang",
+  renderChunk(_, __, info) {
+    if (info.type === "chunk" && /\.(cjs|js|mjs)$/.test(info.path) && info.code.startsWith("#!")) {
+      info.mode = 493;
+    }
+  }
+};
+
+// ../esbuild/src/utilities/helpers.ts
+function handleSync(fn) {
+  try {
+    return fn();
+  } catch (error_) {
+    return error_;
+  }
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, handleSync, "handleSync");
+async function handleAsync(fn) {
+  try {
+    return await fn();
+  } catch (error_) {
+    return error_;
+  }
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, handleAsync, "handleAsync");
+var handle = handleSync;
+handle.async = handleAsync;
+var skip = Symbol("skip");
+function transduceSync(list, transformer) {
+  const transduced = [];
+  for (const [i, element_] of list.entries()) {
+    const transformed = transformer(element_, i);
+    if (transformed !== skip) {
+      transduced[transduced.length] = transformed;
+    }
+  }
+  return transduced;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, transduceSync, "transduceSync");
+async function transduceAsync(list, transformer) {
+  const transduced = [];
+  await Promise.all(list.entries().map(async ([i, element_]) => {
+    const transformed = await transformer(element_, i);
+    if (transformed !== skip) {
+      transduced[transduced.length] = transformed;
+    }
+  }));
+  return transduced;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, transduceAsync, "transduceAsync");
+var transduce = transduceSync;
+transduce.async = transduceAsync;
+function pipeSync(fn, ...fns) {
+  return (...args) => {
+    let result = fn(...args);
+    for (let i = 0; result !== skip && i < fns.length; ++i) {
+      result = _optionalChain([fns, 'access', _77 => _77[i], 'optionalCall', _78 => _78(result)]);
+    }
+    return result;
+  };
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, pipeSync, "pipeSync");
+function pipeAsync(fn, ...fns) {
+  return async (...args) => {
+    let result = await fn(...args);
+    for (let i = 0; result !== skip && i < fns.length; ++i) {
+      result = await _optionalChain([fns, 'access', _79 => _79[i], 'optionalCall', _80 => _80(result)]);
+    }
+    return result;
+  };
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, pipeAsync, "pipeAsync");
+var pipe = pipeSync;
+pipe.async = pipeAsync;
+
+// ../esbuild/src/build.ts
+var resolveOptions = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (userOptions) => {
+  const projectRoot = userOptions.projectRoot;
+  const workspaceRoot3 = _findworkspaceroot.findWorkspaceRoot.call(void 0, projectRoot);
+  if (!workspaceRoot3) {
+    throw new Error("Cannot find Nx workspace root");
+  }
+  const config = await _chunkYE4FHRXJjs.loadStormConfig.call(void 0, workspaceRoot3.dir);
+  _chunkRCE3CC76js.writeDebug.call(void 0, "  \u2699\uFE0F   Resolving build options", config);
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, "Build options resolution");
+  const projectGraph = await _devkit.createProjectGraphAsync.call(void 0, {
+    exitOnError: true
+  });
+  const projectJsonPath = _chunkRCE3CC76js.joinPaths.call(void 0, workspaceRoot3.dir, projectRoot, "project.json");
+  if (!await _node.hfs.isFile(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJson = await _node.hfs.json(projectJsonPath);
+  const projectName = projectJson.name;
+  const projectConfigurations = _devkit.readProjectsConfigurationFromProjectGraph.call(void 0, projectGraph);
+  if (!_optionalChain([projectConfigurations, 'optionalAccess', _81 => _81.projects, 'optionalAccess', _82 => _82[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 options = _defu2.default.call(void 0, userOptions, DEFAULT_BUILD_OPTIONS);
+  options.name ??= `${projectName}-${options.format}`;
+  options.target ??= DEFAULT_TARGET;
+  const packageJsonPath = _chunkRCE3CC76js.joinPaths.call(void 0, workspaceRoot3.dir, options.projectRoot, "package.json");
+  if (!await _node.hfs.isFile(packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const packageJson = await _node.hfs.json(packageJsonPath);
+  const outExtension = getOutputExtensionMap(options, packageJson.type);
+  const env = getEnv("esbuild", options);
+  const result = {
+    ...options,
+    config,
+    mainFields: options.platform === "node" ? [
+      "module",
+      "main"
+    ] : [
+      "browser",
+      "module",
+      "main"
+    ],
+    resolveExtensions: [
+      ".ts",
+      ".js",
+      ".node"
+    ],
+    ...userOptions,
+    tsconfig: _chunkRCE3CC76js.joinPaths.call(void 0, projectRoot, userOptions.tsconfig ? userOptions.tsconfig.replace(projectRoot, "") : "tsconfig.json"),
+    format: options.format || "cjs",
+    entryPoints: await getEntryPoints(config, projectRoot, projectJson.sourceRoot, userOptions.entry || [
+      "./src/index.ts"
+    ], userOptions.emitOnAll),
+    outdir: userOptions.outputPath || _chunkRCE3CC76js.joinPaths.call(void 0, "dist", projectRoot),
+    plugins: [],
+    name: userOptions.name || projectName,
+    projectConfigurations,
+    projectName,
+    projectGraph,
+    sourceRoot: userOptions.sourceRoot || projectJson.sourceRoot || _chunkRCE3CC76js.joinPaths.call(void 0, projectRoot, "src"),
+    minify: userOptions.minify || !userOptions.debug,
+    verbose: userOptions.verbose || _chunkRCE3CC76js.isVerbose.call(void 0, ) || userOptions.debug === true,
+    includeSrc: userOptions.includeSrc === true,
+    metafile: userOptions.metafile !== false,
+    generatePackageJson: userOptions.generatePackageJson !== false,
+    clean: userOptions.clean !== false,
+    emitOnAll: userOptions.emitOnAll === true,
+    assets: _nullishCoalesce(userOptions.assets, () => ( [])),
+    injectShims: userOptions.injectShims !== true,
+    bundle: userOptions.bundle !== false,
+    keepNames: true,
+    watch: userOptions.watch === true,
+    outExtension,
+    footer: userOptions.footer,
+    banner: {
+      js: options.banner || DEFAULT_COMPILED_BANNER,
+      css: options.banner || DEFAULT_COMPILED_BANNER
+    },
+    splitting: options.format === "iife" ? false : typeof options.splitting === "boolean" ? options.splitting : options.format === "esm",
+    treeShaking: options.format === "esm",
+    env,
+    define: {
+      STORM_FORMAT: JSON.stringify(options.format || "cjs"),
+      ...options.format === "cjs" && options.injectShims ? {
+        "import.meta.url": "importMetaUrl"
+      } : {},
+      ...options.define,
+      ...Object.keys(env || {}).reduce((res, key) => {
+        const value = JSON.stringify(env[key]);
+        return {
+          ...res,
+          [`process.env.${key}`]: value,
+          [`import.meta.env.${key}`]: value
+        };
+      }, {})
+    },
+    inject: [
+      options.format === "cjs" && options.injectShims ? _chunkRCE3CC76js.joinPaths.call(void 0, __dirname, "../assets/cjs_shims.js") : "",
+      options.format === "esm" && options.injectShims && options.platform === "node" ? _chunkRCE3CC76js.joinPaths.call(void 0, __dirname, "../assets/esm_shims.js") : "",
+      ..._nullishCoalesce(options.inject, () => ( []))
+    ].filter(Boolean)
+  };
+  result.plugins = _nullishCoalesce(userOptions.plugins, () => ( getDefaultBuildPlugins(userOptions, result)));
+  stopwatch();
+  return result;
+}, "resolveOptions");
+async function generatePackageJson(context2) {
+  if (context2.options.generatePackageJson !== false && await _node.hfs.isFile(_chunkRCE3CC76js.joinPaths.call(void 0, context2.options.projectRoot, "package.json"))) {
+    _chunkRCE3CC76js.writeDebug.call(void 0, "  \u270D\uFE0F   Writing package.json file", context2.options.config);
+    const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, "Write package.json file");
+    const packageJsonPath = _chunkRCE3CC76js.joinPaths.call(void 0, context2.options.projectRoot, "project.json");
+    if (!await _node.hfs.isFile(packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    let packageJson = await _node.hfs.json(_chunkRCE3CC76js.joinPaths.call(void 0, context2.options.config.workspaceRoot, context2.options.projectRoot, "package.json"));
+    if (!packageJson) {
+      throw new Error("Cannot find package.json configuration file");
+    }
+    packageJson = await addPackageDependencies(context2.options.config.workspaceRoot, context2.options.projectRoot, context2.options.projectName, packageJson);
+    packageJson = await addWorkspacePackageJsonFields(context2.options.config, context2.options.projectRoot, context2.options.sourceRoot, context2.options.projectName, false, packageJson);
+    packageJson.exports ??= {};
+    packageJson.exports["./package.json"] ??= "./package.json";
+    packageJson.exports["."] ??= addPackageJsonExport("index", packageJson.type, context2.options.sourceRoot);
+    let entryPoints = [
+      {
+        in: "./src/index.ts",
+        out: "./src/index.ts"
+      }
+    ];
+    if (context2.options.entryPoints) {
+      if (Array.isArray(context2.options.entryPoints)) {
+        entryPoints = context2.options.entryPoints.map((entryPoint) => typeof entryPoint === "string" ? {
+          in: entryPoint,
+          out: entryPoint
+        } : entryPoint);
+      }
+      for (const entryPoint of entryPoints) {
+        const split = entryPoint.out.split(".");
+        split.pop();
+        const entry = split.join(".").replaceAll("\\", "/");
+        packageJson.exports[`./${entry}`] ??= addPackageJsonExport(entry, packageJson.type, context2.options.sourceRoot);
+      }
+    }
+    packageJson.main = packageJson.type === "commonjs" ? "./dist/index.js" : "./dist/index.cjs";
+    packageJson.module = packageJson.type === "module" ? "./dist/index.js" : "./dist/index.mjs";
+    packageJson.types = "./dist/index.d.ts";
+    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, _chunkRCE3CC76js.joinPaths.call(void 0, context2.options.outdir, "package.json"), packageJson);
+    stopwatch();
+  }
+  return context2;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, generatePackageJson, "generatePackageJson");
+async function createOptions(options) {
+  return _estoolkit.flatten.call(void 0, await Promise.all(_compat.map.call(void 0, options, (opt) => [
+    // we defer it so that we don't trigger glob immediately
+    () => resolveOptions(opt)
+  ])));
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, createOptions, "createOptions");
+async function generateContext(getOptions) {
+  const options = await getOptions();
+  const rendererEngine = new RendererEngine([
+    shebangRenderer,
+    ...options.renderers || []
+  ]);
+  return {
+    options,
+    rendererEngine
+  };
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, generateContext, "generateContext");
+async function executeEsBuild(context2) {
+  _chunkRCE3CC76js.writeDebug.call(void 0, `  \u{1F680}  Running ${context2.options.name} build`, context2.options.config);
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, `${context2.options.name} build`);
+  if (process.env.WATCH === "true") {
+    const ctx = await esbuild2.context(context2.options);
+    watch(ctx, context2.options);
+  }
+  const result = await esbuild2.build(context2.options);
+  if (result.metafile) {
+    const metafilePath = `${context2.options.outdir}/${context2.options.name}.meta.json`;
+    await _node.hfs.write(metafilePath, JSON.stringify(result.metafile));
+  }
+  stopwatch();
+  return context2;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, executeEsBuild, "executeEsBuild");
+async function copyBuildAssets(context2) {
+  if (_optionalChain([context2, 'access', _83 => _83.result, 'optionalAccess', _84 => _84.errors, 'access', _85 => _85.length]) === 0) {
+    _chunkRCE3CC76js.writeDebug.call(void 0, `  \u{1F4CB}  Copying asset files to output directory: ${context2.options.outdir}`, context2.options.config);
+    const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, `${context2.options.name} asset copy`);
+    await copyAssets(context2.options.config, _nullishCoalesce(context2.options.assets, () => ( [])), context2.options.outdir, context2.options.projectRoot, context2.options.projectName, context2.options.sourceRoot, true, false);
+    stopwatch();
+  }
+  return context2;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, copyBuildAssets, "copyBuildAssets");
+async function reportResults(context2) {
+  if (_optionalChain([context2, 'access', _86 => _86.result, 'optionalAccess', _87 => _87.errors, 'access', _88 => _88.length]) === 0) {
+    if (context2.result.warnings.length > 0) {
+      _chunkRCE3CC76js.writeWarning.call(void 0, `  \u{1F6A7}  The following warnings occurred during the build: ${context2.result.warnings.map((warning) => warning.text).join("\n")}`, context2.options.config);
+    }
+    _chunkRCE3CC76js.writeSuccess.call(void 0, `  \u{1F4E6}  The ${context2.options.name} build completed successfully`, context2.options.config);
+  }
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, reportResults, "reportResults");
+async function dependencyCheck(options) {
+  if (process.env.DEV === "true") {
+    return void 0;
+  }
+  if (process.env.CI && !process.env.BUILDKITE) {
+    return void 0;
+  }
+  const buildPromise = esbuild2.build({
+    entryPoints: _globby.globbySync.call(void 0, "**/*.{j,t}s", {
+      // We don't check dependencies in ecosystem tests because tests are isolated from the build.
+      ignore: [
+        "./src/__tests__/**/*",
+        "./tests/e2e/**/*",
+        "./dist/**/*"
+      ],
+      gitignore: true
+    }),
+    logLevel: "silent",
+    bundle: true,
+    write: false,
+    outdir: "out",
+    plugins: [
+      depsCheckPlugin(options.bundle)
+    ]
+  });
+  await buildPromise.catch(() => {
+  });
+  return void 0;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, dependencyCheck, "dependencyCheck");
+async function cleanOutputPath(context2) {
+  if (context2.options.clean !== false && context2.options.outdir) {
+    await clean(context2.options.name, context2.options.outdir, context2.options.config);
+  }
+  return context2;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, cleanOutputPath, "cleanOutputPath");
+async function build3(options) {
+  _chunkRCE3CC76js.writeDebug.call(void 0, `  \u26A1   Executing Storm ESBuild pipeline`);
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, "ESBuild pipeline");
+  try {
+    const opts = Array.isArray(options) ? options : [
+      options
+    ];
+    if (opts.length === 0) {
+      throw new Error("No build options were provided");
+    }
+    void transduce.async(opts, dependencyCheck);
+    await transduce.async(await createOptions(opts), pipe.async(generateContext, cleanOutputPath, generatePackageJson, executeEsBuild, copyBuildAssets, reportResults));
+    _chunkRCE3CC76js.writeSuccess.call(void 0, "  \u{1F3C1}  ESBuild pipeline build completed successfully");
+  } catch (error) {
+    _chunkRCE3CC76js.writeFatal.call(void 0, "  \u274C  Fatal errors occurred during the build that could not be recovered from. The build process has been terminated.");
+    throw error;
+  } finally {
+    stopwatch();
+  }
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, build3, "build");
+var watch = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (context2, options) => {
+  if (!options.watch) {
+    return context2;
+  }
+  const config = {
+    ignoreInitial: true,
+    useFsEvents: true,
+    ignored: [
+      "./src/__tests__/**/*",
+      "./package.json"
+    ]
+  };
+  const changeWatcher = _chokidar.watch.call(void 0, [
+    "./src/**/*"
+  ], config);
+  const fastRebuild = _estoolkit.debounce.call(void 0, async () => {
+    const timeBefore = Date.now();
+    const rebuildResult = await handle.async(() => {
+      return context2.rebuild();
+    });
+    if (rebuildResult instanceof Error) {
+      _chunkRCE3CC76js.writeError.call(void 0, rebuildResult.message);
+    }
+    _chunkRCE3CC76js.writeTrace.call(void 0, `${Date.now() - timeBefore}ms [${_nullishCoalesce(options.name, () => ( ""))}]`);
+  }, 10);
+  changeWatcher.on("change", fastRebuild);
+  return void 0;
+}, "watch");
+
+// ../workspace-tools/src/executors/esbuild/executor.ts
+async function esbuildExecutorFn(options, context2, config) {
+  _chunkRCE3CC76js.writeInfo.call(void 0, "\u{1F4E6}  Running Storm ESBuild executor on the workspace", config);
+  if (!_optionalChain([context2, 'access', _89 => _89.projectsConfigurations, 'optionalAccess', _90 => _90.projects]) || !context2.projectName || !context2.projectsConfigurations.projects[context2.projectName] || !_optionalChain([context2, 'access', _91 => _91.projectsConfigurations, 'access', _92 => _92.projects, 'access', _93 => _93[context2.projectName], 'optionalAccess', _94 => _94.root])) {
+    throw new Error("The Build process failed because the context is not valid. Please run this command from a workspace.");
+  }
+  await build3({
+    ...options,
+    projectRoot: _optionalChain([context2, 'access', _95 => _95.projectsConfigurations, 'access', _96 => _96.projects, 'optionalAccess', _97 => _97[context2.projectName], 'access', _98 => _98.root]),
+    projectName: context2.projectName,
+    sourceRoot: _optionalChain([context2, 'access', _99 => _99.projectsConfigurations, 'access', _100 => _100.projects, 'optionalAccess', _101 => _101[context2.projectName], 'optionalAccess', _102 => _102.sourceRoot]),
+    format: options.format,
+    platform: options.format
+  });
+  return {
+    success: true
+  };
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, esbuildExecutorFn, "esbuildExecutorFn");
+var executor_default6 = withRunExecutor("Storm ESBuild build", esbuildExecutorFn, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (options, config) => {
+      options.entry ??= [
+        "src/index.ts"
+      ];
+      options.outputPath ??= "dist/{projectRoot}";
+      options.tsconfig ??= "{projectRoot}/tsconfig.json";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+// ../workspace-tools/src/executors/npm-publish/executor.ts
+
+var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
+
+// ../workspace-tools/src/utils/pnpm-deps-update.ts
+
+
+var _readyamlfile = require('read-yaml-file'); var _readyamlfile2 = _interopRequireDefault(_readyamlfile);
+
+// ../workspace-tools/src/executors/npm-publish/executor.ts
+var LARGE_BUFFER3 = 1024 * 1e6;
+
+// ../workspace-tools/src/executors/size-limit/executor.ts
+
+var _esbuild2 = require('@size-limit/esbuild'); var _esbuild3 = _interopRequireDefault(_esbuild2);
+var _esbuildwhy = require('@size-limit/esbuild-why'); var _esbuildwhy2 = _interopRequireDefault(_esbuildwhy);
+var _file = require('@size-limit/file'); var _file2 = _interopRequireDefault(_file);
+var _sizelimit = require('size-limit'); var _sizelimit2 = _interopRequireDefault(_sizelimit);
+async function sizeLimitExecutorFn(options, context2, config) {
+  if (!_optionalChain([context2, 'optionalAccess', _103 => _103.projectName]) || !_optionalChain([context2, 'access', _104 => _104.projectsConfigurations, 'optionalAccess', _105 => _105.projects]) || !context2.projectsConfigurations.projects[context2.projectName]) {
+    throw new Error("The Size-Limit process failed because the context is not valid. Please run this command from a workspace.");
+  }
+  _chunkRCE3CC76js.writeInfo.call(void 0, `\u{1F4CF} Running Size-Limit on ${context2.projectName}`, config);
+  _sizelimit2.default.call(void 0, [
+    _file2.default,
+    _esbuild3.default,
+    _esbuildwhy2.default
+  ], {
+    checks: _nullishCoalesce(_nullishCoalesce(options.entry, () => ( _optionalChain([context2, 'access', _106 => _106.projectsConfigurations, 'access', _107 => _107.projects, 'access', _108 => _108[context2.projectName], 'optionalAccess', _109 => _109.sourceRoot]))), () => ( _devkit.joinPathFragments.call(void 0, _nullishCoalesce(_optionalChain([context2, 'access', _110 => _110.projectsConfigurations, 'access', _111 => _111.projects, 'access', _112 => _112[context2.projectName], 'optionalAccess', _113 => _113.root]), () => ( "./")), "src")))
+  }).then((result) => {
+    _chunkRCE3CC76js.writeInfo.call(void 0, `\u{1F4CF} ${context2.projectName} Size-Limit result: ${JSON.stringify(result)}`, config);
+  });
+  return {
+    success: true
+  };
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, sizeLimitExecutorFn, "sizeLimitExecutorFn");
+var executor_default7 = withRunExecutor("Size-Limit Performance Test Executor", sizeLimitExecutorFn, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options) => {
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+// ../tsdown/src/build.ts
+
+
+
+
+var _tsdown = require('tsdown');
+
+// ../tsdown/src/clean.ts
+
+async function clean2(name = "ESBuild", directory, config) {
+  _chunkRCE3CC76js.writeDebug.call(void 0, ` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, `${name} output clean`);
+  await _node.hfs.deleteAll(directory);
+  stopwatch();
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, clean2, "clean");
+
+// ../tsdown/src/config.ts
+var DEFAULT_BUILD_OPTIONS2 = {
+  platform: "node",
+  target: "node22",
+  format: [
+    "esm",
+    "cjs"
+  ],
+  tsconfig: "tsconfig.json",
+  envName: "production",
+  globalName: "globalThis",
+  unused: {
+    level: "error"
+  },
+  injectShims: true,
+  watch: false,
+  bundle: true,
+  treeshake: true,
+  clean: true,
+  debug: false
+};
+
+// ../tsdown/src/build.ts
+var resolveOptions2 = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (userOptions) => {
+  const projectRoot = userOptions.projectRoot;
+  const workspaceRoot3 = _findworkspaceroot.findWorkspaceRoot.call(void 0, projectRoot);
+  if (!workspaceRoot3) {
+    throw new Error("Cannot find Nx workspace root");
+  }
+  const config = await _chunkYE4FHRXJjs.loadStormConfig.call(void 0, workspaceRoot3.dir);
+  _chunkRCE3CC76js.writeDebug.call(void 0, "  \u2699\uFE0F   Resolving build options", config);
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, "Build options resolution");
+  const projectGraph = await _devkit.createProjectGraphAsync.call(void 0, {
+    exitOnError: true
+  });
+  const projectJsonPath = _chunkRCE3CC76js.joinPaths.call(void 0, workspaceRoot3.dir, projectRoot, "project.json");
+  if (!await _node.hfs.isFile(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJson = await _node.hfs.json(projectJsonPath);
+  const projectName = projectJson.name;
+  const projectConfigurations = _devkit.readProjectsConfigurationFromProjectGraph.call(void 0, projectGraph);
+  if (!_optionalChain([projectConfigurations, 'optionalAccess', _114 => _114.projects, 'optionalAccess', _115 => _115[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 options = _defu2.default.call(void 0, userOptions, DEFAULT_BUILD_OPTIONS2);
+  options.name ??= `${projectName}-${options.format}`;
+  options.target ??= DEFAULT_TARGET;
+  const packageJsonPath = _chunkRCE3CC76js.joinPaths.call(void 0, workspaceRoot3.dir, options.projectRoot, "package.json");
+  if (!await _node.hfs.isFile(packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const env = getEnv("tsdown", options);
+  const result = {
+    ...options,
+    config,
+    ...userOptions,
+    tsconfig: _chunkRCE3CC76js.joinPaths.call(void 0, projectRoot, userOptions.tsconfig ? userOptions.tsconfig.replace(projectRoot, "") : "tsconfig.json"),
+    format: options.format || "cjs",
+    entryPoints: await getEntryPoints(config, projectRoot, projectJson.sourceRoot, userOptions.entry || [
+      "./src/index.ts"
+    ], userOptions.emitOnAll),
+    outdir: userOptions.outputPath || _chunkRCE3CC76js.joinPaths.call(void 0, "dist", projectRoot),
+    plugins: [],
+    name: userOptions.name || projectName,
+    projectConfigurations,
+    projectName,
+    projectGraph,
+    sourceRoot: userOptions.sourceRoot || projectJson.sourceRoot || _chunkRCE3CC76js.joinPaths.call(void 0, projectRoot, "src"),
+    minify: userOptions.minify || !userOptions.debug,
+    verbose: userOptions.verbose || _chunkRCE3CC76js.isVerbose.call(void 0, ) || userOptions.debug === true,
+    includeSrc: userOptions.includeSrc === true,
+    metafile: userOptions.metafile !== false,
+    generatePackageJson: userOptions.generatePackageJson !== false,
+    clean: userOptions.clean !== false,
+    emitOnAll: userOptions.emitOnAll === true,
+    dts: userOptions.emitTypes === true ? {
+      transformer: "oxc"
+    } : userOptions.emitTypes,
+    bundleDts: userOptions.emitTypes,
+    assets: _nullishCoalesce(userOptions.assets, () => ( [])),
+    shims: userOptions.injectShims !== true,
+    bundle: userOptions.bundle !== false,
+    watch: userOptions.watch === true,
+    define: {
+      STORM_FORMAT: JSON.stringify(options.format || "cjs"),
+      ...options.format === "cjs" && options.injectShims ? {
+        "import.meta.url": "importMetaUrl"
+      } : {},
+      ...Object.keys(env || {}).reduce((res, key) => {
+        const value = JSON.stringify(env[key]);
+        return {
+          ...res,
+          [`process.env.${key}`]: value,
+          [`import.meta.env.${key}`]: value
+        };
+      }, {}),
+      ...options.define
+    }
+  };
+  stopwatch();
+  return result;
+}, "resolveOptions");
+async function generatePackageJson2(options) {
+  if (options.generatePackageJson !== false && await _node.hfs.isFile(_chunkRCE3CC76js.joinPaths.call(void 0, options.projectRoot, "package.json"))) {
+    _chunkRCE3CC76js.writeDebug.call(void 0, "  \u270D\uFE0F   Writing package.json file", options.config);
+    const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, "Write package.json file");
+    const packageJsonPath = _chunkRCE3CC76js.joinPaths.call(void 0, options.projectRoot, "project.json");
+    if (!await _node.hfs.isFile(packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    let packageJson = await _node.hfs.json(_chunkRCE3CC76js.joinPaths.call(void 0, options.config.workspaceRoot, options.projectRoot, "package.json"));
+    if (!packageJson) {
+      throw new Error("Cannot find package.json configuration file");
+    }
+    packageJson = await addPackageDependencies(options.config.workspaceRoot, options.projectRoot, options.projectName, packageJson);
+    packageJson = await addWorkspacePackageJsonFields(options.config, options.projectRoot, options.sourceRoot, options.projectName, false, packageJson);
+    packageJson.exports ??= {};
+    packageJson.exports["./package.json"] ??= "./package.json";
+    packageJson.exports["."] ??= addPackageJsonExport("index", packageJson.type, options.sourceRoot);
+    let entryPoints = [
+      {
+        in: "./src/index.ts",
+        out: "./src/index.ts"
+      }
+    ];
+    if (options.entryPoints) {
+      if (Array.isArray(options.entryPoints)) {
+        entryPoints = options.entryPoints.map((entryPoint) => typeof entryPoint === "string" ? {
+          in: entryPoint,
+          out: entryPoint
+        } : entryPoint);
+      }
+      for (const entryPoint of entryPoints) {
+        const split = entryPoint.out.split(".");
+        split.pop();
+        const entry = split.join(".").replaceAll("\\", "/");
+        packageJson.exports[`./${entry}`] ??= addPackageJsonExport(entry, packageJson.type, options.sourceRoot);
+      }
+    }
+    packageJson.main = packageJson.type === "commonjs" ? "./dist/index.js" : "./dist/index.cjs";
+    packageJson.module = packageJson.type === "module" ? "./dist/index.js" : "./dist/index.mjs";
+    packageJson.types = "./dist/index.d.ts";
+    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, _chunkRCE3CC76js.joinPaths.call(void 0, options.outdir, "package.json"), packageJson);
+    stopwatch();
+  }
+  return options;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, generatePackageJson2, "generatePackageJson");
+async function executeTSDown(options) {
+  _chunkRCE3CC76js.writeDebug.call(void 0, `  \u{1F680}  Running ${options.name} build`, options.config);
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, `${options.name} build`);
+  await _tsdown.build.call(void 0, {
+    ...options,
+    entry: options.entryPoints,
+    outDir: options.outdir,
+    config: false
+  });
+  stopwatch();
+  return options;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, executeTSDown, "executeTSDown");
+async function copyBuildAssets2(options) {
+  _chunkRCE3CC76js.writeDebug.call(void 0, `  \u{1F4CB}  Copying asset files to output directory: ${options.outdir}`, options.config);
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, `${options.name} asset copy`);
+  await copyAssets(options.config, _nullishCoalesce(options.assets, () => ( [])), options.outdir, options.projectRoot, options.projectName, options.sourceRoot, true, false);
+  stopwatch();
+  return options;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, copyBuildAssets2, "copyBuildAssets");
+async function reportResults2(options) {
+  _chunkRCE3CC76js.writeSuccess.call(void 0, `  \u{1F4E6}  The ${options.name} build completed successfully`, options.config);
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, reportResults2, "reportResults");
+async function cleanOutputPath2(options) {
+  if (options.clean !== false && options.outdir) {
+    await clean2(options.name, options.outdir, options.config);
+  }
+  return options;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, cleanOutputPath2, "cleanOutputPath");
+async function build4(options) {
+  _chunkRCE3CC76js.writeDebug.call(void 0, `  \u26A1   Executing Storm TSDown pipeline`);
+  const stopwatch = _chunkRCE3CC76js.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 resolveOptions2(opt)));
+    if (resolved.length > 0) {
+      await cleanOutputPath2(resolved[0]);
+      await generatePackageJson2(resolved[0]);
+      await Promise.all(resolved.map(async (opt) => {
+        await executeTSDown(opt);
+        await copyBuildAssets2(opt);
+        await reportResults2(opt);
+      }));
+    } else {
+      _chunkRCE3CC76js.writeWarning.call(void 0, "  \u{1F6A7}   No options were passed to TSBuild. Please check the parameters passed to the `build` function.");
+    }
+    _chunkRCE3CC76js.writeSuccess.call(void 0, "  \u{1F3C1}  TSDown pipeline build completed successfully");
+  } catch (error) {
+    _chunkRCE3CC76js.writeFatal.call(void 0, "  \u274C  Fatal errors occurred during the build that could not be recovered from. The build process has been terminated.");
+    throw error;
+  } finally {
+    stopwatch();
+  }
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, build4, "build");
+
+// ../workspace-tools/src/executors/tsdown/executor.ts
+async function tsdownExecutorFn(options, context2, config) {
+  _chunkRCE3CC76js.writeInfo.call(void 0, "\u{1F4E6}  Running Storm TSDown build executor on the workspace", config);
+  if (!_optionalChain([context2, 'access', _116 => _116.projectsConfigurations, 'optionalAccess', _117 => _117.projects]) || !context2.projectName || !context2.projectsConfigurations.projects[context2.projectName] || !_optionalChain([context2, 'access', _118 => _118.projectsConfigurations, 'access', _119 => _119.projects, 'access', _120 => _120[context2.projectName], 'optionalAccess', _121 => _121.root])) {
+    throw new Error("The Build process failed because the context is not valid. Please run this command from a workspace.");
+  }
+  await build4({
+    ...options,
+    projectRoot: _optionalChain([context2, 'access', _122 => _122.projectsConfigurations, 'access', _123 => _123.projects, 'optionalAccess', _124 => _124[context2.projectName], 'access', _125 => _125.root]),
+    projectName: context2.projectName,
+    sourceRoot: _optionalChain([context2, 'access', _126 => _126.projectsConfigurations, 'access', _127 => _127.projects, 'optionalAccess', _128 => _128[context2.projectName], 'optionalAccess', _129 => _129.sourceRoot]),
+    format: options.format,
+    platform: options.platform
+  });
+  return {
+    success: true
+  };
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, tsdownExecutorFn, "tsdownExecutorFn");
+var executor_default8 = withRunExecutor("Storm TSDown build executor", tsdownExecutorFn, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (options, config) => {
+      options.entry ??= [
+        "src/index.ts"
+      ];
+      options.outputPath ??= "dist/{projectRoot}";
+      options.tsconfig ??= "{projectRoot}/tsconfig.json";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+// ../workspace-tools/src/executors/typia/executor.ts
+var _fsextra = require('fs-extra');
+var _TypiaProgrammerjs = require('typia/lib/programmers/TypiaProgrammer.js');
+async function typiaExecutorFn(options, _, config) {
+  if (options.clean !== false) {
+    _chunkRCE3CC76js.writeInfo.call(void 0, `\u{1F9F9} Cleaning output path: ${options.outputPath}`, config);
+    _fsextra.removeSync.call(void 0, options.outputPath);
+  }
+  await Promise.all(options.entry.map((entry) => {
+    _chunkRCE3CC76js.writeInfo.call(void 0, `\u{1F680} Running Typia on entry: ${entry}`, config);
+    return _TypiaProgrammerjs.TypiaProgrammer.build({
+      input: entry,
+      output: options.outputPath,
+      project: options.tsconfig
+    });
+  }));
+  return {
+    success: true
+  };
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, typiaExecutorFn, "typiaExecutorFn");
+var executor_default9 = withRunExecutor("Typia runtime validation generator", typiaExecutorFn, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options) => {
+      options.entry ??= [
+        "{sourceRoot}/index.ts"
+      ];
+      options.outputPath ??= "{sourceRoot}/__generated__/typia";
+      options.tsconfig ??= "{projectRoot}/tsconfig.json";
+      options.clean ??= true;
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+// ../unbuild/src/build.ts
+
+
+
+
+
+
+
+var _unbuild = require('unbuild');
+
+// ../unbuild/src/clean.ts
+
+async function clean3(name = "Unbuild", directory, config) {
+  _chunkRCE3CC76js.writeDebug.call(void 0, ` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, `${name} output clean`);
+  await _node.hfs.deleteAll(directory);
+  stopwatch();
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, clean3, "clean");
+
+// ../unbuild/src/plugins/analyze.ts
+var formatBytes = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (bytes) => {
+  if (bytes === 0) return "0 Byte";
+  const k = 1e3;
+  const dm = 3;
+  const sizes = [
+    "Bytes",
+    "KB",
+    "MB",
+    "GB"
+  ];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
+}, "formatBytes");
+var analyzePlugin = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options, resolvedOptions) => {
+  return {
+    name: "storm:analyzer",
+    renderChunk(source, chunk) {
+      const sourceBytes = formatBytes(source.length);
+      const fileName = chunk.fileName;
+      _chunkRCE3CC76js.writeInfo.call(void 0, ` - ${fileName} ${sourceBytes}`, resolvedOptions.config);
+    }
+  };
+}, "analyzePlugin");
+
+// ../unbuild/src/plugins/on-error.ts
+var onErrorPlugin2 = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options, resolvedOptions) => ({
+  name: "storm:on-error",
+  buildEnd(error) {
+    if (error) {
+      _chunkRCE3CC76js.writeError.call(void 0, `The following errors occurred during the build:
+${error ? error.message : "Unknown build error"}
+
+    `, resolvedOptions.config);
+      throw new Error("Storm unbuild process failed with errors.");
+    }
+  },
+  renderError(error) {
+    _chunkRCE3CC76js.writeError.call(void 0, `The following errors occurred during the build:
+${error ? error.message : "Unknown build error"}
+
+  `, resolvedOptions.config);
+    throw new Error("Storm unbuild process failed with errors.");
+  }
+}), "onErrorPlugin");
+
+// ../unbuild/src/plugins/swc.ts
+var swcPlugin = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options, resolvedOptions) => {
+  const { transform: transform3 } = _chunkJ5SB6L2Ljs.__require.call(void 0, "@swc/core");
+  return {
+    name: "storm:swc",
+    transform(code, filename) {
+      return transform3(code, {
+        filename,
+        jsc: {
+          transform: {
+            react: {
+              runtime: "automatic"
+            }
+          }
+        }
+      });
+    }
+  };
+}, "swcPlugin");
+
+// ../unbuild/src/plugins/tsc.ts
+
+
+var _compilerhelperdependency = require('@nx/js/src/utils/compiler-helper-dependency');
+var _rollupplugintypescript2 = require('rollup-plugin-typescript2'); var _rollupplugintypescript22 = _interopRequireDefault(_rollupplugintypescript2);
+
+// ../unbuild/src/utilities/helpers.ts
+
+
+
+var _url = require('url');
+var _typescript = require('typescript'); var _typescript2 = _interopRequireDefault(_typescript);
+async function loadConfig(configPath) {
+  if (!/\.(js|mjs)$/.test(_path.extname.call(void 0, configPath))) {
+    throw new Error("Unsupported config file format");
+  }
+  return Promise.resolve().then(() => _interopRequireWildcard(require(_url.pathToFileURL.call(void 0, configPath).toString()))).then((config) => config.default);
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, loadConfig, "loadConfig");
+async function createTsCompilerOptions(config, tsConfigPath, projectRoot, dependencies) {
+  const tsConfigFile = _typescript2.default.readConfigFile(_devkit.joinPathFragments.call(void 0, config.workspaceRoot, projectRoot, tsConfigPath), _typescript2.default.sys.readFile);
+  const tsConfig = _typescript2.default.parseJsonConfigFileContent(tsConfigFile.config, _typescript2.default.sys, _path.dirname.call(void 0, _devkit.joinPathFragments.call(void 0, config.workspaceRoot, projectRoot, tsConfigPath)));
+  const compilerOptions = {
+    rootDir: projectRoot,
+    declaration: true,
+    paths: _buildablelibsutils.computeCompilerOptionsPaths.call(void 0, tsConfig, _nullishCoalesce(dependencies, () => ( [])))
+  };
+  _chunkRCE3CC76js.writeTrace.call(void 0, compilerOptions, config);
+  return compilerOptions;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, createTsCompilerOptions, "createTsCompilerOptions");
+
+// ../unbuild/src/plugins/tsc.ts
+var tscPlugin2 = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (options, resolvedOptions) => {
+  const projectGraph = await _devkit.createProjectGraphAsync.call(void 0, {
+    exitOnError: true
+  });
+  const result = _buildablelibsutils.calculateProjectBuildableDependencies.call(void 0, void 0, projectGraph, resolvedOptions.config.workspaceRoot, resolvedOptions.projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  let dependencies = result.dependencies;
+  const tsLibDependency = _compilerhelperdependency.getHelperDependency.call(void 0, _compilerhelperdependency.HelperDependency.tsc, resolvedOptions.tsconfig, dependencies, projectGraph, true);
+  if (tsLibDependency) {
+    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
+    dependencies.push(tsLibDependency);
+  }
+  return _rollupplugintypescript22.default.call(void 0, {
+    check: options.emitTypes !== false,
+    tsconfig: resolvedOptions.tsconfig,
+    tsconfigOverride: {
+      compilerOptions: await createTsCompilerOptions(resolvedOptions.config, resolvedOptions.tsconfig, resolvedOptions.projectRoot, dependencies)
+    }
+  });
+}, "tscPlugin");
+
+// ../unbuild/src/plugins/type-definitions.ts
+
+var typeDefinitions = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options, resolvedOptions) => ({
+  name: "storm:dts-bundle",
+  async generateBundle(_opts, bundle) {
+    for (const file of Object.values(bundle)) {
+      if (file.type === "asset" || !file.isEntry || file.facadeModuleId == null) {
+        continue;
+      }
+      const hasDefaultExport = file.exports.includes("default");
+      const entrySourceFileName = _path.relative.call(void 0, options.projectRoot, file.facadeModuleId);
+      const entrySourceDtsName = entrySourceFileName.replace(/\.[cm]?[jt]sx?$/, "");
+      const dtsFileName = file.fileName.replace(/\.[cm]?js$/, ".d.ts");
+      const relativeSourceDtsName = JSON.stringify("./" + entrySourceDtsName);
+      const dtsFileSource = hasDefaultExport ? `
+export * from ${relativeSourceDtsName};
+export { default } from ${relativeSourceDtsName};
+            ` : `export * from ${relativeSourceDtsName};
+`;
+      this.emitFile({
+        type: "asset",
+        fileName: dtsFileName,
+        source: dtsFileSource
+      });
+    }
+  }
+}), "typeDefinitions");
+
+// ../unbuild/src/config.ts
+var getDefaultBuildPlugins2 = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (options, resolvedOptions) => Promise.all([
+  analyzePlugin(options, resolvedOptions),
+  swcPlugin(options, resolvedOptions),
+  typeDefinitions(options, resolvedOptions),
+  tscPlugin2(options, resolvedOptions),
+  onErrorPlugin2(options, resolvedOptions)
+].map((plugin) => Promise.resolve(plugin))), "getDefaultBuildPlugins");
+
+// ../unbuild/src/build.ts
+async function resolveOptions3(options) {
+  const projectRoot = options.projectRoot;
+  if (!projectRoot) {
+    throw new Error("Cannot find project root");
+  }
+  const outputPath = options.outputPath || _chunkRCE3CC76js.joinPaths.call(void 0, "dist", projectRoot);
+  const workspaceRoot3 = _findworkspaceroot.findWorkspaceRoot.call(void 0, projectRoot);
+  if (!workspaceRoot3) {
+    throw new Error("Cannot find workspace root");
+  }
+  const config = await _chunkYE4FHRXJjs.loadStormConfig.call(void 0, workspaceRoot3.dir);
+  _chunkRCE3CC76js.writeDebug.call(void 0, "  \u2699\uFE0F   Resolving build options", config);
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, "Build options resolution");
+  if (options.configPath) {
+    const configFile = await loadConfig(options.configPath);
+    if (configFile) {
+      options = _defu2.default.call(void 0, options, configFile);
+    }
+  }
+  const projectGraph = await _devkit.createProjectGraphAsync.call(void 0, {
+    exitOnError: true
+  });
+  const projectJsonPath = _chunkRCE3CC76js.joinPaths.call(void 0, config.workspaceRoot, projectRoot, "project.json");
+  if (!await _node.hfs.isFile(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJson = await _node.hfs.json(projectJsonPath);
+  const projectName = projectJson.name;
+  const packageJsonPath = _chunkRCE3CC76js.joinPaths.call(void 0, workspaceRoot3.dir, projectRoot, "package.json");
+  if (!await _node.hfs.isFile(packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const packageJson = await _node.hfs.json(packageJsonPath);
+  let tsconfig = options.tsconfig;
+  if (!tsconfig) {
+    tsconfig = _chunkRCE3CC76js.joinPaths.call(void 0, workspaceRoot3.dir, projectRoot, "tsconfig.json");
+  }
+  if (!await _node.hfs.isFile(tsconfig)) {
+    throw new Error("Cannot find tsconfig.json configuration");
+  }
+  let sourceRoot = projectJson.sourceRoot;
+  if (!sourceRoot) {
+    sourceRoot = _chunkRCE3CC76js.joinPaths.call(void 0, projectRoot, "src");
+  }
+  if (!await _node.hfs.isDirectory(sourceRoot)) {
+    throw new Error("Cannot find sourceRoot directory");
+  }
+  const projectConfigurations = _devkit.readProjectsConfigurationFromProjectGraph.call(void 0, projectGraph);
+  if (!_optionalChain([projectConfigurations, 'optionalAccess', _130 => _130.projects, 'optionalAccess', _131 => _131[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 result = _buildablelibsutils.calculateProjectBuildableDependencies.call(void 0, void 0, projectGraph, workspaceRoot3.dir, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  let dependencies = result.dependencies;
+  const tsLibDependency = _js.getHelperDependency.call(void 0, _js.HelperDependency.tsc, tsconfig, dependencies, projectGraph, true);
+  if (tsLibDependency) {
+    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
+    dependencies.push(tsLibDependency);
+  }
+  const resolvedOptions = {
+    name: projectName,
+    config,
+    projectRoot,
+    sourceRoot,
+    projectName,
+    tsconfig,
+    clean: false,
+    entries: [
+      {
+        builder: "mkdist",
+        input: `.${sourceRoot.replace(projectRoot, "")}`,
+        outDir: _chunkRCE3CC76js.joinPaths.call(void 0, _path.relative.call(void 0, _chunkRCE3CC76js.joinPaths.call(void 0, config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        declaration: options.emitTypes !== false,
+        format: "esm"
+      },
+      {
+        builder: "mkdist",
+        input: `.${sourceRoot.replace(projectRoot, "")}`,
+        outDir: _chunkRCE3CC76js.joinPaths.call(void 0, _path.relative.call(void 0, _chunkRCE3CC76js.joinPaths.call(void 0, config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        declaration: options.emitTypes !== false,
+        format: "cjs",
+        ext: "cjs"
+      }
+    ],
+    declaration: options.emitTypes !== false ? "compatible" : false,
+    failOnWarn: false,
+    sourcemap: _nullishCoalesce(options.sourcemap, () => ( !!options.debug)),
+    outDir: outputPath,
+    parallel: true,
+    stub: false,
+    stubOptions: {
+      jiti: {}
+    },
+    externals: _nullishCoalesce(options.external, () => ( [])),
+    dependencies: [],
+    peerDependencies: [],
+    devDependencies: [],
+    hooks: {},
+    alias: {},
+    replace: {},
+    rollup: {
+      replace: {},
+      alias: {},
+      json: {},
+      commonjs: {
+        sourceMap: _nullishCoalesce(options.sourcemap, () => ( true))
+      },
+      emitCJS: true,
+      cjsBridge: true,
+      dts: {
+        respectExternal: true,
+        tsconfig
+      },
+      output: {
+        banner: options.banner || `
+//      \u26A1 Built by Storm Software
+  `,
+        footer: options.footer
+      },
+      resolve: {
+        preferBuiltins: true,
+        extensions: [
+          ".cjs",
+          ".mjs",
+          ".js",
+          ".jsx",
+          ".ts",
+          ".tsx",
+          ".json"
+        ]
+      },
+      esbuild: {
+        minify: !!options.minify,
+        splitting: options.splitting !== false,
+        treeShaking: options.treeShaking !== false,
+        color: true,
+        logLevel: config.logLevel === _chunkRCE3CC76js.LogLevelLabel.FATAL ? _chunkRCE3CC76js.LogLevelLabel.ERROR : _chunkRCE3CC76js.isVerbose.call(void 0, ) ? "verbose" : config.logLevel
+      }
+    }
+  };
+  dependencies = dependencies.filter((dep) => dep.node.type === "npm" || dep.node.type === "lib" || dep.node.type === "app");
+  if (dependencies.length > 0) {
+    resolvedOptions.dependencies = dependencies.map((dep) => dep.name);
+  }
+  if (packageJson.devDependencies) {
+    resolvedOptions.devDependencies = Object.keys(packageJson.devDependencies);
+  }
+  if (packageJson.peerDependencies) {
+    resolvedOptions.peerDependencies = Object.keys(packageJson.peerDependencies);
+  }
+  if (options.rollup) {
+    let rollup = {};
+    if (typeof options.rollup === "string") {
+      const rollupFile = await loadConfig(options.rollup);
+      if (rollupFile) {
+        rollup = rollupFile;
+      }
+    } else {
+      rollup = options.rollup;
+    }
+    resolvedOptions.rollup = _defu2.default.call(void 0, _nullishCoalesce(resolvedOptions.rollup, () => ( {})), rollup);
+  }
+  resolvedOptions.hooks = {
+    "rollup:options": /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (ctx, opts) => {
+      opts.plugins = await _asyncNullishCoalesce(options.plugins, async () => ( await getDefaultBuildPlugins2(options, resolvedOptions)));
+    }, "rollup:options")
+  };
+  stopwatch();
+  return resolvedOptions;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, resolveOptions3, "resolveOptions");
+async function generatePackageJson3(options) {
+  if (options.generatePackageJson !== false && await _node.hfs.isFile(_chunkRCE3CC76js.joinPaths.call(void 0, options.projectRoot, "package.json"))) {
+    _chunkRCE3CC76js.writeDebug.call(void 0, "  \u270D\uFE0F   Writing package.json file", options.config);
+    const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, "Write package.json file");
+    const packageJsonPath = _chunkRCE3CC76js.joinPaths.call(void 0, options.projectRoot, "project.json");
+    if (!await _node.hfs.isFile(packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    let packageJson = await _node.hfs.json(_chunkRCE3CC76js.joinPaths.call(void 0, options.config.workspaceRoot, options.projectRoot, "package.json"));
+    if (!packageJson) {
+      throw new Error("Cannot find package.json configuration file");
+    }
+    packageJson = await addPackageDependencies(options.config.workspaceRoot, options.projectRoot, options.projectName, packageJson);
+    packageJson = await addWorkspacePackageJsonFields(options.config, options.projectRoot, options.sourceRoot, options.projectName, false, packageJson);
+    packageJson = await addPackageJsonExports(options.sourceRoot, packageJson);
+    await _devkit.writeJsonFile.call(void 0, _chunkRCE3CC76js.joinPaths.call(void 0, options.outDir, "package.json"), packageJson);
+    stopwatch();
+  }
+  return options;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, generatePackageJson3, "generatePackageJson");
+async function executeUnbuild(options) {
+  _chunkRCE3CC76js.writeDebug.call(void 0, `  \u{1F680}  Running ${options.name} (${options.projectRoot}) build`, options.config);
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, `${options.name} (${options.projectRoot}) build`);
+  try {
+    await _unbuild.build.call(void 0, options.projectRoot, false, {
+      ...options,
+      rootDir: options.projectRoot
+    });
+  } finally {
+    stopwatch();
+  }
+  return options;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, executeUnbuild, "executeUnbuild");
+async function copyBuildAssets3(options) {
+  _chunkRCE3CC76js.writeDebug.call(void 0, `  \u{1F4CB}  Copying asset files to output directory: ${options.outDir}`, options.config);
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, `${options.name} asset copy`);
+  await copyAssets(options.config, _nullishCoalesce(options.assets, () => ( [])), options.outDir, options.projectRoot, options.projectName, options.sourceRoot, options.generatePackageJson, options.includeSrc);
+  stopwatch();
+  return options;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, copyBuildAssets3, "copyBuildAssets");
+async function cleanOutputPath3(options) {
+  if (options.clean !== false && options.outDir) {
+    await clean3(options.name, options.outDir, options.config);
+  }
+  return options;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, cleanOutputPath3, "cleanOutputPath");
+async function build5(options) {
+  _chunkRCE3CC76js.writeDebug.call(void 0, ` \u26A1  Executing Storm Unbuild pipeline`);
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, "Unbuild pipeline");
+  try {
+    const resolvedOptions = await resolveOptions3(options);
+    await cleanOutputPath3(resolvedOptions);
+    await generatePackageJson3(resolvedOptions);
+    await executeUnbuild(resolvedOptions);
+    await copyBuildAssets3(resolvedOptions);
+    _chunkRCE3CC76js.writeSuccess.call(void 0, `  \u{1F3C1}  The ${resolvedOptions.name} build completed successfully`, resolvedOptions.config);
+  } catch (error) {
+    _chunkRCE3CC76js.writeFatal.call(void 0, "  \u274C  Fatal errors occurred during the build that could not be recovered from. The build process has been terminated.");
+    throw error;
+  } finally {
+    stopwatch();
+  }
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, build5, "build");
+
+// ../workspace-tools/src/executors/unbuild/executor.ts
+
+async function unbuildExecutorFn(options, context2, config) {
+  _chunkRCE3CC76js.writeInfo.call(void 0, "\u{1F4E6}  Running Storm Unbuild executor on the workspace", config);
+  if (!_optionalChain([context2, 'access', _132 => _132.projectsConfigurations, 'optionalAccess', _133 => _133.projects]) || !context2.projectName || !context2.projectsConfigurations.projects[context2.projectName] || !_optionalChain([context2, 'access', _134 => _134.projectsConfigurations, 'access', _135 => _135.projects, 'access', _136 => _136[context2.projectName], 'optionalAccess', _137 => _137.root])) {
+    throw new Error("The Build process failed because the context is not valid. Please run this command from a workspace.");
+  }
+  await build5(_defu.defu.call(void 0, {
+    ...options,
+    projectRoot: _optionalChain([context2, 'access', _138 => _138.projectsConfigurations, 'access', _139 => _139.projects, 'optionalAccess', _140 => _140[context2.projectName], 'access', _141 => _141.root]),
+    projectName: context2.projectName,
+    sourceRoot: _optionalChain([context2, 'access', _142 => _142.projectsConfigurations, 'access', _143 => _143.projects, 'optionalAccess', _144 => _144[context2.projectName], 'optionalAccess', _145 => _145.sourceRoot]),
+    platform: options.platform,
+    name: context2.projectName
+  }, {
+    stubOptions: {
+      jiti: {
+        cache: "node_modules/.cache/storm"
+      }
+    },
+    rollup: {
+      emitCJS: true,
+      watch: false,
+      cjsBridge: false,
+      dts: {
+        respectExternal: true
+      },
+      replace: {},
+      alias: {},
+      resolve: {},
+      json: {},
+      commonjs: {},
+      esbuild: {
+        target: options.target,
+        format: "esm",
+        platform: options.platform,
+        minify: options.minify,
+        treeShaking: options.treeShaking
+      }
+    }
+  }));
+  return {
+    success: true
+  };
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, unbuildExecutorFn, "unbuildExecutorFn");
+var executor_default10 = withRunExecutor("TypeScript Unbuild build", unbuildExecutorFn, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, async (options, config) => {
+      options.entry ??= [
+        "{sourceRoot}"
+      ];
+      options.outputPath ??= "dist/{projectRoot}";
+      options.tsconfig ??= "{projectRoot}/tsconfig.json";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+// ../workspace-tools/src/generators/browser-library/generator.ts
+
+
+// ../workspace-tools/src/base/base-generator.ts
+var withRunGenerator = /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (name, generatorFn, generatorOptions = {
+  skipReadingConfig: false
+}) => async (tree, _options) => {
+  const stopwatch = _chunkRCE3CC76js.getStopwatch.call(void 0, name);
+  let options = _options;
+  let config;
+  try {
+    _chunkRCE3CC76js.writeInfo.call(void 0, `\u26A1 Running the ${name} generator...
+
+`, config);
+    const workspaceRoot3 = _chunkRCE3CC76js.findWorkspaceRoot.call(void 0, );
+    if (!generatorOptions.skipReadingConfig) {
+      _chunkRCE3CC76js.writeDebug.call(void 0, `Loading the Storm Config from environment variables and storm.config.js file...
+ - workspaceRoot: ${workspaceRoot3}`, config);
+      config = await _chunkYE4FHRXJjs.loadStormConfig.call(void 0, workspaceRoot3);
+    }
+    if (_optionalChain([generatorOptions, 'optionalAccess', _146 => _146.hooks, 'optionalAccess', _147 => _147.applyDefaultOptions])) {
+      _chunkRCE3CC76js.writeDebug.call(void 0, "Running the applyDefaultOptions hook...", config);
+      options = await Promise.resolve(generatorOptions.hooks.applyDefaultOptions(options, config));
+      _chunkRCE3CC76js.writeDebug.call(void 0, "Completed the applyDefaultOptions hook", config);
+    }
+    _chunkRCE3CC76js.writeTrace.call(void 0, `Generator schema options \u2699\uFE0F 
+${Object.keys(_nullishCoalesce(options, () => ( {}))).map((key) => ` - ${key}=${JSON.stringify(options[key])}`).join("\n")}`, config);
+    const tokenized = await applyWorkspaceTokens(options, {
+      workspaceRoot: tree.root,
+      config
+    }, applyWorkspaceBaseTokens);
+    if (_optionalChain([generatorOptions, 'optionalAccess', _148 => _148.hooks, 'optionalAccess', _149 => _149.preProcess])) {
+      _chunkRCE3CC76js.writeDebug.call(void 0, "Running the preProcess hook...", config);
+      await Promise.resolve(generatorOptions.hooks.preProcess(tokenized, config));
+      _chunkRCE3CC76js.writeDebug.call(void 0, "Completed the preProcess hook", config);
+    }
+    const result = await Promise.resolve(generatorFn(tree, tokenized, config));
+    if (result) {
+      if (result.success === false || result.error && _optionalChain([result, 'optionalAccess', _150 => _150.error, 'optionalAccess', _151 => _151.message]) && typeof _optionalChain([result, 'optionalAccess', _152 => _152.error, 'optionalAccess', _153 => _153.message]) === "string" && _optionalChain([result, 'optionalAccess', _154 => _154.error, 'optionalAccess', _155 => _155.name]) && typeof _optionalChain([result, 'optionalAccess', _156 => _156.error, 'optionalAccess', _157 => _157.name]) === "string") {
+        throw new Error(`The ${name} generator failed to run`, {
+          cause: _optionalChain([result, 'optionalAccess', _158 => _158.error])
+        });
+      } else if (result.success && result.data) {
+        return result;
+      }
+    }
+    if (_optionalChain([generatorOptions, 'optionalAccess', _159 => _159.hooks, 'optionalAccess', _160 => _160.postProcess])) {
+      _chunkRCE3CC76js.writeDebug.call(void 0, "Running the postProcess hook...", config);
+      await Promise.resolve(generatorOptions.hooks.postProcess(config));
+      _chunkRCE3CC76js.writeDebug.call(void 0, "Completed the postProcess hook", config);
+    }
+    return () => {
+      _chunkRCE3CC76js.writeSuccess.call(void 0, `Completed running the ${name} generator!
+`, config);
+    };
+  } catch (error) {
+    return () => {
+      _chunkRCE3CC76js.writeFatal.call(void 0, "A fatal error occurred while running the generator - the process was forced to terminate", config);
+      _chunkRCE3CC76js.writeError.call(void 0, `An exception was thrown in the generator's process 
+ - Details: ${error.message}
+ - Stacktrace: ${error.stack}`, config);
+    };
+  } finally {
+    stopwatch();
+  }
+}, "withRunGenerator");
+
+// ../workspace-tools/src/base/typescript-library-generator.ts
+
+var _projectnameandrootutils = require('@nx/devkit/src/generators/project-name-and-root-utils');
+
+var _init = require('@nx/js/src/generators/init/init'); var _init2 = _interopRequireDefault(_init);
+var _generator = require('@nx/js/src/generators/setup-verdaccio/generator'); var _generator2 = _interopRequireDefault(_generator);
+
+// ../workspace-tools/src/utils/versions.ts
+var typesNodeVersion = "20.9.0";
+var nxVersion = "^18.0.4";
+var nodeVersion = "20.11.0";
+var pnpmVersion = "8.10.2";
+
+// ../workspace-tools/src/base/typescript-library-generator.ts
+async function typeScriptLibraryGeneratorFn(tree, schema, config) {
+  const options = await normalizeOptions(tree, {
+    ...schema
+  });
+  const tasks = [];
+  tasks.push(await _init2.default.call(void 0, tree, {
+    ...options,
+    tsConfigName: options.rootProject ? "tsconfig.json" : "tsconfig.base.json"
+  }));
+  tasks.push(_devkit.addDependenciesToPackageJson.call(void 0, tree, {}, {
+    "@storm-software/workspace-tools": "latest",
+    "@storm-software/testing-tools": "latest",
+    ..._nullishCoalesce(schema.devDependencies, () => ( {}))
+  }));
+  if (options.publishable) {
+    tasks.push(await _generator2.default.call(void 0, tree, {
+      ...options,
+      skipFormat: true
+    }));
+  }
+  const projectConfig = {
+    root: options.directory,
+    projectType: "library",
+    sourceRoot: _chunkRCE3CC76js.joinPaths.call(void 0, _nullishCoalesce(options.directory, () => ( "")), "src"),
+    targets: {
+      build: {
+        executor: schema.buildExecutor,
+        outputs: [
+          "{options.outputPath}"
+        ],
+        options: {
+          entry: [
+            _chunkRCE3CC76js.joinPaths.call(void 0, options.projectRoot, "src", "index.ts")
+          ],
+          outputPath: getOutputPath(options),
+          tsconfig: _chunkRCE3CC76js.joinPaths.call(void 0, options.projectRoot, "tsconfig.json"),
+          project: _chunkRCE3CC76js.joinPaths.call(void 0, options.projectRoot, "package.json"),
+          defaultConfiguration: "production",
+          platform: "neutral",
+          assets: [
+            {
+              input: options.projectRoot,
+              glob: "*.md",
+              output: "/"
+            },
+            {
+              input: "",
+              glob: "LICENSE",
+              output: "/"
+            }
+          ]
+        },
+        configurations: {
+          production: {
+            debug: false,
+            verbose: false
+          },
+          development: {
+            debug: true,
+            verbose: true
+          }
+        }
+      }
+    }
+  };
+  if (schema.platform) {
+    projectConfig.targets.build.options.platform = schema.platform === "worker" ? "node" : schema.platform;
+  }
+  _chunkVTHBMY4Bjs.addProjectTag.call(void 0, projectConfig, _chunkVTHBMY4Bjs.ProjectTagConstants.Platform.TAG_ID, schema.platform === "node" ? _chunkVTHBMY4Bjs.ProjectTagConstants.Platform.NODE : schema.platform === "worker" ? _chunkVTHBMY4Bjs.ProjectTagConstants.Platform.WORKER : schema.platform === "browser" ? _chunkVTHBMY4Bjs.ProjectTagConstants.Platform.BROWSER : _chunkVTHBMY4Bjs.ProjectTagConstants.Platform.NEUTRAL, {
+    overwrite: false
+  });
+  createProjectTsConfigJson(tree, options);
+  _devkit.addProjectConfiguration.call(void 0, tree, options.name, projectConfig);
+  let repository = {
+    type: "github",
+    url: _optionalChain([config, 'optionalAccess', _161 => _161.repository]) || `https://github.com/${_optionalChain([config, 'optionalAccess', _162 => _162.organization]) || "storm-software"}/${_optionalChain([config, 'optionalAccess', _163 => _163.namespace]) || _optionalChain([config, 'optionalAccess', _164 => _164.name]) || "repository"}.git`
+  };
+  let description = schema.description || "A package developed by Storm Software used to create modern, scalable web applications.";
+  if (tree.exists("package.json")) {
+    const packageJson = _devkit.readJson.call(void 0, tree, "package.json");
+    if (_optionalChain([packageJson, 'optionalAccess', _165 => _165.repository])) {
+      repository = packageJson.repository;
+    }
+    if (_optionalChain([packageJson, 'optionalAccess', _166 => _166.description])) {
+      description = packageJson.description;
+    }
+  }
+  if (!options.importPath) {
+    options.importPath = options.name;
+  }
+  const packageJsonPath = _chunkRCE3CC76js.joinPaths.call(void 0, options.projectRoot, "package.json");
+  if (tree.exists(packageJsonPath)) {
+    _devkit.updateJson.call(void 0, tree, packageJsonPath, (json) => {
+      if (!options.importPath) {
+        options.importPath = options.name;
+      }
+      json.name = options.importPath;
+      json.version = "0.0.1";
+      if (json.private && (options.publishable || options.rootProject)) {
+        json.private = void 0;
+      }
+      return {
+        ...json,
+        version: "0.0.1",
+        description,
+        repository: {
+          ...repository,
+          directory: options.projectRoot
+        },
+        type: "module",
+        dependencies: {
+          ...json.dependencies
+        },
+        publishConfig: {
+          access: "public"
+        }
+      };
+    });
+  } else {
+    _devkit.writeJson.call(void 0, tree, packageJsonPath, {
+      name: options.importPath,
+      version: "0.0.1",
+      description,
+      repository: {
+        ...repository,
+        directory: options.projectRoot
+      },
+      private: !options.publishable || options.rootProject,
+      type: "module",
+      publishConfig: {
+        access: "public"
+      }
+    });
+  }
+  if (tree.exists("package.json") && options.importPath) {
+    _devkit.updateJson.call(void 0, tree, "package.json", (json) => ({
+      ...json,
+      pnpm: {
+        ..._optionalChain([json, 'optionalAccess', _167 => _167.pnpm]),
+        overrides: {
+          ..._optionalChain([json, 'optionalAccess', _168 => _168.pnpm, 'optionalAccess', _169 => _169.overrides]),
+          [_nullishCoalesce(options.importPath, () => ( ""))]: "workspace:*"
+        }
+      }
+    }));
+  }
+  _js.addTsConfigPath.call(void 0, tree, options.importPath, [
+    _chunkRCE3CC76js.joinPaths.call(void 0, options.projectRoot, "./src", `index.${options.js ? "js" : "ts"}`)
+  ]);
+  _js.addTsConfigPath.call(void 0, tree, _chunkRCE3CC76js.joinPaths.call(void 0, options.importPath, "/*"), [
+    _chunkRCE3CC76js.joinPaths.call(void 0, options.projectRoot, "./src", "/*")
+  ]);
+  if (tree.exists("package.json")) {
+    const packageJson = _devkit.readJson.call(void 0, tree, "package.json");
+    if (_optionalChain([packageJson, 'optionalAccess', _170 => _170.repository])) {
+      repository = packageJson.repository;
+    }
+    if (_optionalChain([packageJson, 'optionalAccess', _171 => _171.description])) {
+      description = packageJson.description;
+    }
+  }
+  const tsconfigPath = _chunkRCE3CC76js.joinPaths.call(void 0, options.projectRoot, "tsconfig.json");
+  if (tree.exists(tsconfigPath)) {
+    _devkit.updateJson.call(void 0, tree, tsconfigPath, (json) => {
+      json.composite ??= true;
+      return json;
+    });
+  } else {
+    _devkit.writeJson.call(void 0, tree, tsconfigPath, {
+      extends: `${_devkit.offsetFromRoot.call(void 0, options.projectRoot)}tsconfig.base.json`,
+      composite: true,
+      compilerOptions: {
+        outDir: `${_devkit.offsetFromRoot.call(void 0, options.projectRoot)}dist/out-tsc`
+      },
+      files: [],
+      include: [
+        "src/**/*.ts",
+        "src/**/*.js"
+      ],
+      exclude: [
+        "jest.config.ts",
+        "src/**/*.spec.ts",
+        "src/**/*.test.ts"
+      ]
+    });
+  }
+  await _devkit.formatFiles.call(void 0, tree);
+  return null;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, typeScriptLibraryGeneratorFn, "typeScriptLibraryGeneratorFn");
+function getOutputPath(options) {
+  const parts = [
+    "dist"
+  ];
+  if (options.projectRoot === ".") {
+    parts.push(options.name);
+  } else {
+    parts.push(options.projectRoot);
+  }
+  return _chunkRCE3CC76js.joinPaths.call(void 0, ...parts);
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, getOutputPath, "getOutputPath");
+function createProjectTsConfigJson(tree, options) {
+  const tsconfig = {
+    extends: options.rootProject ? void 0 : _js.getRelativePathToRootTsConfig.call(void 0, tree, options.projectRoot),
+    ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _172 => _172.tsconfigOptions]), () => ( {})),
+    compilerOptions: {
+      ...options.rootProject ? _js.tsConfigBaseOptions : {},
+      outDir: _chunkRCE3CC76js.joinPaths.call(void 0, _devkit.offsetFromRoot.call(void 0, options.projectRoot), "dist/out-tsc"),
+      noEmit: true,
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _173 => _173.tsconfigOptions, 'optionalAccess', _174 => _174.compilerOptions]), () => ( {}))
+    },
+    files: [
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _175 => _175.tsconfigOptions, 'optionalAccess', _176 => _176.files]), () => ( []))
+    ],
+    include: [
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _177 => _177.tsconfigOptions, 'optionalAccess', _178 => _178.include]), () => ( [])),
+      "src/**/*.ts",
+      "src/**/*.js",
+      "bin/**/*"
+    ],
+    exclude: [
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _179 => _179.tsconfigOptions, 'optionalAccess', _180 => _180.exclude]), () => ( [])),
+      "jest.config.ts",
+      "src/**/*.spec.ts",
+      "src/**/*.test.ts"
+    ]
+  };
+  _devkit.writeJson.call(void 0, tree, _chunkRCE3CC76js.joinPaths.call(void 0, options.projectRoot, "tsconfig.json"), tsconfig);
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, createProjectTsConfigJson, "createProjectTsConfigJson");
+async function normalizeOptions(tree, options) {
+  if (options.publishable) {
+    if (!options.importPath) {
+      throw new Error(`For publishable libs you have to provide a proper "--importPath" which needs to be a valid npm package name (e.g. my-awesome-lib or @myorg/my-lib)`);
+    }
+  }
+  let bundler = "tsc";
+  if (options.publishable === false && options.buildable === false) {
+    bundler = "none";
+  }
+  const { Linter } = _devkit.ensurePackage.call(void 0, "@nx/eslint", nxVersion);
+  const { projectName, names: projectNames, projectRoot, importPath } = await _projectnameandrootutils.determineProjectNameAndRootOptions.call(void 0, tree, {
+    name: options.name,
+    projectType: "library",
+    directory: options.directory,
+    importPath: options.importPath,
+    rootProject: options.rootProject
+  });
+  options.rootProject = projectRoot === ".";
+  const normalized = _devkit.names.call(void 0, projectNames.projectFileName);
+  const fileName = normalized.fileName;
+  return {
+    js: false,
+    pascalCaseFiles: false,
+    skipFormat: false,
+    skipTsConfig: false,
+    includeBabelRc: false,
+    unitTestRunner: "jest",
+    linter: Linter.EsLint,
+    testEnvironment: "node",
+    config: "project",
+    compiler: "tsc",
+    bundler,
+    skipTypeCheck: false,
+    minimal: false,
+    hasPlugin: false,
+    isUsingTsSolutionConfig: false,
+    projectPackageManagerWorkspaceState: "included",
+    ...options,
+    fileName,
+    name: projectName,
+    projectNames,
+    projectRoot,
+    parsedTags: options.tags ? options.tags.split(",").map((s) => s.trim()) : [],
+    importPath
+  };
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, normalizeOptions, "normalizeOptions");
+
+// ../workspace-tools/src/generators/browser-library/generator.ts
+async function browserLibraryGeneratorFn(tree, schema, config) {
+  const filesDir = _devkit.joinPathFragments.call(void 0, __dirname, "./files");
+  const tsLibraryGeneratorOptions = {
+    buildExecutor: "@storm-software/workspace-tools:unbuild",
+    platform: "browser",
+    devDependencies: {
+      "@types/react": "^18.3.6",
+      "@types/react-dom": "^18.3.0"
+    },
+    peerDependencies: {
+      react: "^18.3.0",
+      "react-dom": "^18.3.0",
+      "react-native": "*"
+    },
+    peerDependenciesMeta: {
+      "react-dom": {
+        optional: true
+      },
+      "react-native": {
+        optional: true
+      }
+    },
+    ...schema,
+    description: schema.description,
+    directory: schema.directory
+  };
+  const options = await normalizeOptions(tree, tsLibraryGeneratorOptions);
+  const { className, name, propertyName } = _devkit.names.call(void 0, options.projectNames.projectFileName);
+  _devkit.generateFiles.call(void 0, tree, filesDir, options.projectRoot, {
+    ...schema,
+    dot: ".",
+    className,
+    name,
+    namespace: _nullishCoalesce(process.env.STORM_NAMESPACE, () => ( "storm-software")),
+    description: _nullishCoalesce(schema.description, () => ( "")),
+    propertyName,
+    js: !!options.js,
+    cliCommand: "nx",
+    strict: void 0,
+    tmpl: "",
+    offsetFromRoot: _devkit.offsetFromRoot.call(void 0, options.projectRoot),
+    buildable: options.bundler && options.bundler !== "none",
+    hasUnitTestRunner: options.unitTestRunner !== "none",
+    tsConfigOptions: {
+      compilerOptions: {
+        jsx: "react",
+        types: [
+          "node",
+          "@nx/react/typings/cssmodule.d.ts",
+          "@nx/react/typings/image.d.ts"
+        ]
+      }
+    }
+  });
+  await typeScriptLibraryGeneratorFn(tree, tsLibraryGeneratorOptions, config);
+  await _devkit.formatFiles.call(void 0, tree);
+  return null;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, browserLibraryGeneratorFn, "browserLibraryGeneratorFn");
+var generator_default = withRunGenerator("TypeScript Library Creator (Browser Platform)", browserLibraryGeneratorFn, {
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options) => {
+      options.description ??= "A library used by Storm Software to support browser applications";
+      options.platform ??= "browser";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+// ../workspace-tools/src/generators/config-schema/generator.ts
+
+var _zodtojsonschema = require('zod-to-json-schema');
+async function configSchemaGeneratorFn(tree, options, config) {
+  _chunkRCE3CC76js.writeInfo.call(void 0, "\u{1F4E6}  Running Storm Configuration JSON Schema generator", config);
+  _chunkRCE3CC76js.writeTrace.call(void 0, `Determining the Storm Configuration JSON Schema...`, config);
+  const jsonSchema = _zodtojsonschema.zodToJsonSchema.call(void 0, _chunkRCE3CC76js.StormConfigSchema, {
+    name: "StormWorkspaceConfiguration"
+  });
+  _chunkRCE3CC76js.writeTrace.call(void 0, jsonSchema, config);
+  const outputPath = options.outputFile.replaceAll("{workspaceRoot}", "").replaceAll(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _181 => _181.workspaceRoot]), () => ( _chunkRCE3CC76js.findWorkspaceRoot.call(void 0, ))), _optionalChain([options, 'access', _182 => _182.outputFile, 'optionalAccess', _183 => _183.startsWith, 'call', _184 => _184("./")]) ? "" : "./");
+  _chunkRCE3CC76js.writeTrace.call(void 0, `\u{1F4DD}  Writing Storm Configuration JSON Schema to "${outputPath}"`, config);
+  _devkit.writeJson.call(void 0, tree, outputPath, jsonSchema, {
+    spaces: 2
+  });
+  await _devkit.formatFiles.call(void 0, tree);
+  _chunkRCE3CC76js.writeSuccess.call(void 0, "\u{1F680}  Storm Configuration JSON Schema creation has completed successfully!", config);
+  return {
+    success: true
+  };
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, configSchemaGeneratorFn, "configSchemaGeneratorFn");
+var generator_default2 = withRunGenerator("Configuration Schema Creator", configSchemaGeneratorFn, {
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options) => {
+      options.outputFile ??= "{workspaceRoot}/storm-workspace.schema.json";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+// ../workspace-tools/src/generators/init/init.ts
+
+
+// ../workspace-tools/src/generators/neutral-library/generator.ts
+
+async function neutralLibraryGeneratorFn(tree, schema, config) {
+  const filesDir = _devkit.joinPathFragments.call(void 0, __dirname, "./files");
+  const tsLibraryGeneratorOptions = {
+    ...schema,
+    platform: "neutral",
+    devDependencies: {},
+    buildExecutor: "@storm-software/workspace-tools:unbuild"
+  };
+  const options = await normalizeOptions(tree, tsLibraryGeneratorOptions);
+  const { className, name, propertyName } = _devkit.names.call(void 0, options.projectNames.projectFileName);
+  _devkit.generateFiles.call(void 0, tree, filesDir, options.projectRoot, {
+    ...schema,
+    dot: ".",
+    className,
+    name,
+    namespace: _nullishCoalesce(process.env.STORM_NAMESPACE, () => ( "storm-software")),
+    description: _nullishCoalesce(schema.description, () => ( "")),
+    propertyName,
+    js: !!options.js,
+    cliCommand: "nx",
+    strict: void 0,
+    tmpl: "",
+    offsetFromRoot: _devkit.offsetFromRoot.call(void 0, options.projectRoot),
+    buildable: options.bundler && options.bundler !== "none",
+    hasUnitTestRunner: options.unitTestRunner !== "none"
+  });
+  await typeScriptLibraryGeneratorFn(tree, tsLibraryGeneratorOptions, config);
+  await _devkit.formatFiles.call(void 0, tree);
+  return null;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, neutralLibraryGeneratorFn, "neutralLibraryGeneratorFn");
+var generator_default3 = withRunGenerator("TypeScript Library Creator (Neutral Platform)", neutralLibraryGeneratorFn, {
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options) => {
+      options.description ??= "A library used by Storm Software to support either browser or NodeJs applications";
+      options.platform = "neutral";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+// ../workspace-tools/src/generators/node-library/generator.ts
+
+async function nodeLibraryGeneratorFn(tree, schema, config) {
+  const filesDir = _devkit.joinPathFragments.call(void 0, __dirname, "./files");
+  const tsLibraryGeneratorOptions = {
+    platform: "node",
+    devDependencies: {
+      "@types/node": typesNodeVersion
+    },
+    buildExecutor: "@storm-software/workspace-tools:unbuild",
+    ...schema,
+    directory: schema.directory,
+    description: schema.description
+  };
+  const options = await normalizeOptions(tree, tsLibraryGeneratorOptions);
+  const { className, name, propertyName } = _devkit.names.call(void 0, options.name);
+  _devkit.generateFiles.call(void 0, tree, filesDir, options.projectRoot, {
+    ...schema,
+    dot: ".",
+    className,
+    name,
+    namespace: _nullishCoalesce(process.env.STORM_NAMESPACE, () => ( "storm-software")),
+    description: _nullishCoalesce(schema.description, () => ( "")),
+    propertyName,
+    js: !!options.js,
+    cliCommand: "nx",
+    strict: void 0,
+    tmpl: "",
+    offsetFromRoot: _devkit.offsetFromRoot.call(void 0, options.projectRoot),
+    buildable: options.bundler && options.bundler !== "none",
+    hasUnitTestRunner: options.unitTestRunner !== "none"
+  });
+  await typeScriptLibraryGeneratorFn(tree, tsLibraryGeneratorOptions, config);
+  await _devkit.formatFiles.call(void 0, tree);
+  return null;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, nodeLibraryGeneratorFn, "nodeLibraryGeneratorFn");
+var generator_default4 = withRunGenerator("TypeScript Library Creator (NodeJs Platform)", nodeLibraryGeneratorFn, {
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunkJ5SB6L2Ljs.__name.call(void 0, (options) => {
+      options.description ??= "A library used by Storm Software to support NodeJs applications";
+      options.platform ??= "node";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+// ../workspace-tools/src/generators/preset/generator.ts
+
+
+async function presetGeneratorFn(tree, options) {
+  const projectRoot = ".";
+  options.description ??= `\u26A1The ${options.namespace ? options.namespace : options.name} monorepo contains utility applications, tools, and various libraries to create modern and scalable web applications.`;
+  options.namespace ??= options.organization;
+  _devkit.addProjectConfiguration.call(void 0, tree, `@${options.namespace}/${options.name}`, {
+    root: projectRoot,
+    projectType: "application",
+    targets: {
+      "local-registry": {
+        executor: "@nx/js:verdaccio",
+        options: {
+          port: 4873,
+          config: ".verdaccio/config.yml",
+          storage: "tmp/local-registry/storage"
+        }
+      }
+    }
+  });
+  _devkit.updateJson.call(void 0, tree, "package.json", (json) => {
+    json.scripts = json.scripts || {};
+    json.version = "0.0.0";
+    json.triggerEmptyDevReleaseByIncrementingThisNumber = 0;
+    json.private = true;
+    json.keywords ??= [
+      options.name,
+      options.namespace,
+      "storm",
+      "storm-stack",
+      "storm-ops",
+      "acidic",
+      "acidic-engine",
+      "cyclone-ui",
+      "rust",
+      "nx",
+      "graphql",
+      "sullivanpj",
+      "monorepo"
+    ];
+    json.homepage ??= "https://stormsoftware.com";
+    json.bugs ??= {
+      url: `https://github.com/${options.organization}/${options.name}/issues`,
+      email: "support@stormsoftware.com"
+    };
+    json.license = "Apache-2.0";
+    json.author ??= {
+      name: "Storm Software",
+      email: "contact@stormsoftware.com",
+      url: "https://stormsoftware.com"
+    };
+    json.maintainers ??= [
+      {
+        "name": "Storm Software",
+        "email": "contact@stormsoftware.com",
+        "url": "https://stormsoftware.com"
+      },
+      {
+        "name": "Pat Sullivan",
+        "email": "admin@stormsoftware.com",
+        "url": "https://patsullivan.org"
+      }
+    ];
+    json.funding ??= {
+      type: "github",
+      url: "https://github.com/sponsors/storm-software"
+    };
+    json.namespace ??= `@${options.namespace}`;
+    json.description ??= options.description;
+    options.repositoryUrl ??= `https://github.com/${options.organization}/${options.name}`;
+    json.repository ??= {
+      type: "github",
+      url: `${options.repositoryUrl}.git`
+    };
+    json.packageManager ??= "pnpm@9.15.2";
+    json.engines ??= {
+      "node": ">=20.11.0",
+      "pnpm": ">=9.15.2"
+    };
+    json.prettier = "@storm-software/prettier/config.json";
+    json.nx ??= {
+      "includedScripts": [
+        "lint-sherif",
+        "lint-knip",
+        "lint-ls",
+        "lint",
+        "format",
+        "format-sherif",
+        "format-readme",
+        "format-prettier",
+        "format-toml",
+        "commit",
+        "release"
+      ]
+    };
+    json.scripts.adr = "pnpm log4brains adr new";
+    json.scripts["adr-preview"] = "pnpm log4brains preview";
+    json.scripts.prepare = "pnpm add lefthook -w && pnpm lefthook install";
+    json.scripts.preinstall = "npx -y only-allow pnpm";
+    json.scripts["install-csb"] = "corepack enable && pnpm install --no-frozen-lockfile";
+    json.scripts.clean = "rimraf dist && rimraf --glob packages/**/dist && rimraf --glob tools/**/dist && rimraf --glob docs/**/dist && rimraf --glob apps/**/dist && rimraf --glob libs/**/dist";
+    json.scripts.nuke = "nx clear-cache && rimraf .nx/cache && rimraf .nx/workspace-data && pnpm clean && rimraf pnpm-lock.yaml && rimraf --glob packages/**/node_modules && rimraf --glob tools/**/node_modules && rimraf node_modules";
+    json.scripts.prebuild = "pnpm clean";
+    json.scripts.build = "nx affected -t build --parallel=5";
+    json.scripts["build-all"] = "nx run-many -t build --all --parallel=5";
+    json.scripts["build-prod"] = "nx run-many -t build --all --prod --parallel=5";
+    json.scripts["build-tools"] = "nx run-many -t build --projects=tools/* --parallel=5";
+    json.scripts["build-docs"] = "nx run-many -t build --projects=docs/* --parallel=5";
+    if (!options.includeApps) {
+      json.scripts["build-packages"] = "nx run-many -t build --projects=packages/* --parallel=5";
+    } else {
+      json.scripts["build-apps"] = "nx run-many -t build --projects=apps/* --parallel=5";
+      json.scripts["build-libs"] = "nx run-many -t build --projects=libs/* --parallel=5";
+      json.scripts["build-storybook"] = "storybook build -s public";
+    }
+    json.scripts.nx = "nx";
+    json.scripts.graph = "nx graph";
+    json.scripts.lint = "pnpm storm-lint all --skip-cspell --skip-alex";
+    if (options.includeApps) {
+      json.scripts.start = "nx serve";
+      json.scripts.storybook = "pnpm storybook dev -p 6006";
+    }
+    json.scripts.help = "nx help";
+    json.scripts["dep-graph"] = "nx dep-graph";
+    json.scripts["local-registry"] = `nx local-registry @${options.namespace}/${options.name}`;
+    json.scripts.e2e = "nx e2e";
+    if (options.includeApps) {
+      json.scripts.test = "nx test && pnpm test-storybook";
+      json.scripts["test-storybook"] = "pnpm test-storybook";
+    } else {
+      json.scripts.test = "nx test";
+    }
+    json.scripts.lint = "pnpm storm-lint all --skip-cspell --skip-alex";
+    json.scripts.commit = "pnpm storm-git commit";
+    json.scripts["api-extractor"] = 'pnpm storm-docs api-extractor --outputPath="docs/api-reference" --clean';
+    json.scripts.release = "pnpm storm-git release";
+    json.scripts.format = "nx format:write";
+    json.scripts["format-sherif"] = "pnpm exec sherif -f -i typescript -i react -i react-dom";
+    json.scripts["format-toml"] = 'pnpm exec taplo format --config="./node_modules/@storm-software/linting-tools/taplo/config.toml" --cache-path="./node_modules/.cache/storm/taplo"';
+    json.scripts["format-readme"] = 'pnpm storm-git readme --templates="tools/readme-templates"';
+    json.scripts["format-prettier"] = "pnpm exec prettier --write --ignore-unknown --no-error-on-unmatched-pattern --cache && git update-index";
+    json.scripts.lint = "pnpm storm-lint all --skip-cspell";
+    json.scripts["lint-knip"] = "pnpm exec knip";
+    json.scripts["lint-sherif"] = "pnpm exec sherif -i typescript -i react -i react-dom";
+    json.scripts["lint-ls"] = 'pnpm exec ls-lint --config="./node_modules/@storm-software/linting-tools/ls-lint/ls-lint.yml"';
+    json.packageManager ??= `pnpm@${pnpmVersion}`;
+    json.engines = {
+      node: `>=${nodeVersion}`,
+      pnpm: `>=${pnpmVersion}`
+    };
+    return json;
+  });
+  _devkit.generateFiles.call(void 0, tree, path6.join(__dirname, "files"), projectRoot, {
+    ...options,
+    pnpmVersion,
+    nodeVersion
+  });
+  await _devkit.formatFiles.call(void 0, tree);
+  let dependencies = {
+    "@ls-lint/ls-lint": "2.2.3",
+    "@ltd/j-toml": "1.38.0",
+    "@nx/devkit": "^20.2.2",
+    "@nx/eslint-plugin": "^20.2.2",
+    "@nx/js": "^20.2.2",
+    "@nx/workspace": "^20.2.2",
+    "@storm-software/config": "latest",
+    "@storm-software/git-tools": "latest",
+    "@storm-software/linting-tools": "latest",
+    "@storm-software/testing-tools": "latest",
+    "@storm-software/workspace-tools": "latest",
+    "@storm-software/eslint": "latest",
+    "@storm-software/cspell": "latest",
+    "@storm-software/prettier": "latest",
+    "@taplo/cli": "0.7.0",
+    "@types/node": "^20.14.10",
+    "copyfiles": "2.4.1",
+    "eslint": "9.5.0",
+    "jest": "29.7.0",
+    "jest-environment-node": "29.7.0",
+    "knip": "5.25.2",
+    "lefthook": "1.6.18",
+    "nx": "^20.2.2",
+    "prettier": "3.3.2",
+    "prettier-plugin-prisma": "5.0.0",
+    "rimraf": "5.0.7",
+    "sherif": "0.10.0",
+    "ts-jest": "29.1.5",
+    "ts-node": "10.9.2",
+    "tslib": "2.6.3",
+    "typescript": "5.5.3",
+    "verdaccio": "5.31.1"
+  };
+  if (options.includeApps) {
+    dependencies = {
+      ...dependencies,
+      react: "latest",
+      "react-dom": "latest",
+      storybook: "latest",
+      "@storybook/addons": "latest",
+      "@nx/react": "latest",
+      "@nx/next": "latest",
+      "@nx/node": "latest",
+      "@nx/storybook": "latest",
+      "jest-environment-jsdom": "29.7.0"
+    };
+  }
+  if (options.includeRust) {
+    dependencies = {
+      ...dependencies,
+      "@monodon/rust": "1.4.0"
+    };
+  }
+  if (options.nxCloud) {
+    dependencies = {
+      ...dependencies,
+      "nx-cloud": "latest"
+    };
+  }
+  await Promise.resolve(_devkit.addDependenciesToPackageJson.call(void 0, tree, dependencies, {}, _devkit.joinPathFragments.call(void 0, projectRoot, "package.json")));
+  return null;
+}
+_chunkJ5SB6L2Ljs.__name.call(void 0, presetGeneratorFn, "presetGeneratorFn");
+var generator_default5 = withRunGenerator("Storm Workspace Preset Generator", presetGeneratorFn);
+
+// ../workspace-tools/src/generators/release-version/generator.ts
+
+var _resolvelocalpackagedependencies = require('@nx/js/src/generators/release-version/utils/resolve-local-package-dependencies');
+var _updatelockfile = require('@nx/js/src/generators/release-version/utils/update-lock-file');
+
+// ../git-tools/src/types.ts
+var RuleConfigSeverity;
+(function(RuleConfigSeverity2) {
+  RuleConfigSeverity2[RuleConfigSeverity2["Disabled"] = 0] = "Disabled";
+  RuleConfigSeverity2[RuleConfigSeverity2["Warning"] = 1] = "Warning";
+  RuleConfigSeverity2[RuleConfigSeverity2["Error"] = 2] = "Error";
+})(RuleConfigSeverity || (RuleConfigSeverity = {}));
+
+// ../git-tools/src/release/changelog-renderer.ts
+var _index = require('nx/release/changelog-renderer/index'); var _index2 = _interopRequireDefault(_index);
+
+// ../workspace-tools/src/generators/release-version/generator.ts
+
+
+var _config = require('nx/src/command-line/release/config/config');
+var _git = require('nx/src/command-line/release/utils/git');
+var _resolvesemverspecifier = require('nx/src/command-line/release/utils/resolve-semver-specifier');
+var _semver = require('nx/src/command-line/release/utils/semver');
+var _version = require('nx/src/command-line/release/version');
+var _utils = require('nx/src/tasks-runner/utils');
+var _semver3 = require('semver');
+
+// ../workspace-tools/src/utils/get-project-configurations.ts
+var _retrieveworkspacefiles = require('nx/src/project-graph/utils/retrieve-workspace-files');
+
+// ../workspace-tools/src/utils/lock-file.ts
+
+
+var _devkitexports = require('nx/src/devkit-exports');
+var _npmparser = require('nx/src/plugins/js/lock-file/npm-parser');
+var _pnpmparser = require('nx/src/plugins/js/lock-file/pnpm-parser');
+var _yarnparser = require('nx/src/plugins/js/lock-file/yarn-parser');
+var YARN_LOCK_FILE = "yarn.lock";
+var NPM_LOCK_FILE = "package-lock.json";
+var PNPM_LOCK_FILE = "pnpm-lock.yaml";
+var YARN_LOCK_PATH = _path.join.call(void 0, _devkitexports.workspaceRoot, YARN_LOCK_FILE);
+var NPM_LOCK_PATH = _path.join.call(void 0, _devkitexports.workspaceRoot, NPM_LOCK_FILE);
+var PNPM_LOCK_PATH = _path.join.call(void 0, _devkitexports.workspaceRoot, PNPM_LOCK_FILE);
+
+// ../workspace-tools/src/utils/typia-transform.ts
+var _transform = require('typia/lib/transform'); var _transform2 = _interopRequireDefault(_transform);
+
+
+
+exports.withRunExecutor = withRunExecutor;