@storm-software/cloudflare-tools 0.50.2 → 0.50.3

package/dist/{chunk-T6VDL633.mjs → chunk-6PVMDNO7.mjs}

@@ -4,9 +4,8 @@ import {
 } from "./chunk-XU6MTFCV.mjs";
 import {
   loadStormConfig
-} from "./chunk-4AMWR76J.mjs";
+} from "./chunk-UOZU7VQX.mjs";
 import {
-  LogLevelLabel,
   StormConfigSchema,
   correctPaths,
   findWorkspaceRoot,
@@ -21,7 +20,7 @@ import {
   writeSuccess,
   writeTrace,
   writeWarning
-} from "./chunk-NSLK6ZDO.mjs";
+} from "./chunk-XBFOA367.mjs";
 import {
   __dirname,
   __name,
@@ -516,7 +515,7 @@ var readNxConfig = /* @__PURE__ */ __name(async (workspaceRoot3) => {
 }, "readNxConfig");
 
 // ../build-tools/src/utilities/copy-assets.ts
-var copyAssets = /* @__PURE__ */ __name(async (config, assets, outputPath, projectRoot, projectName, sourceRoot, generatePackageJson4 = true, includeSrc = false, banner, footer) => {
+var copyAssets = /* @__PURE__ */ __name(async (config, assets, outputPath, projectRoot, projectName, sourceRoot, generatePackageJson3 = true, includeSrc = false, banner, footer) => {
   const pendingAssets = Array.from(assets ?? []);
   if (!pendingAssets?.some((asset) => asset?.glob === "*.md")) {
     pendingAssets.push({
@@ -525,7 +524,7 @@ var copyAssets = /* @__PURE__ */ __name(async (config, assets, outputPath, proje
       output: "/"
     });
   }
-  if (generatePackageJson4 === false) {
+  if (generatePackageJson3 === false) {
     pendingAssets.push({
       input: sourceRoot,
       glob: "package.json",
@@ -704,34 +703,6 @@ var addPackageJsonExport = /* @__PURE__ */ __name((file, type = "module", source
     }
   };
 }, "addPackageJsonExport");
-var addPackageJsonExports = /* @__PURE__ */ __name(async (sourceRoot, packageJson) => {
-  packageJson.exports ??= {};
-  const files = await new 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["."] = packageJson.exports["."] ?? addPackageJsonExport("index", packageJson.type, sourceRoot);
-  return packageJson;
-}, "addPackageJsonExports");
 
 // ../build-tools/src/utilities/get-entry-points.ts
 import { glob as glob2 } from "glob";
@@ -976,8 +947,8 @@ __name(clean, "clean");
 import * as esbuild from "esbuild";
 var esmSplitCodeToCjsPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
   name: "storm:esm-split-code-to-cjs",
-  setup(build6) {
-    build6.onEnd(async (result) => {
+  setup(build5) {
+    build5.onEnd(async (result) => {
       const outFiles = Object.keys(result.metafile?.outputs ?? {});
       const jsFiles = outFiles.filter((f) => f.endsWith("js"));
       await esbuild.build({
@@ -995,15 +966,15 @@ var esmSplitCodeToCjsPlugin = /* @__PURE__ */ __name((options, resolvedOptions)
 // ../esbuild/src/plugins/fix-imports.ts
 var fixImportsPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
   name: "storm:fix-imports",
-  setup(build6) {
-    build6.onResolve({
+  setup(build5) {
+    build5.onResolve({
       filter: /^spdx-exceptions/
     }, () => {
       return {
         path: __require.resolve("spdx-exceptions")
       };
     });
-    build6.onResolve({
+    build5.onResolve({
       filter: /^spdx-license-ids/
     }, () => {
       return {
@@ -1018,8 +989,8 @@ import { dirname } from "node:path";
 var nativeNodeModulesPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => {
   return {
     name: "native-node-modules",
-    setup(build6) {
-      build6.onResolve({
+    setup(build5) {
+      build5.onResolve({
         filter: /\.node$/,
         namespace: "file"
       }, (args) => {
@@ -1038,7 +1009,7 @@ var nativeNodeModulesPlugin = /* @__PURE__ */ __name((options, resolvedOptions)
           path: resolvedId
         };
       });
-      build6.onLoad({
+      build5.onLoad({
         filter: /.*/,
         namespace: "node-file"
       }, (args) => {
@@ -1051,14 +1022,14 @@ var nativeNodeModulesPlugin = /* @__PURE__ */ __name((options, resolvedOptions)
           resolveDir: dirname(args.path)
         };
       });
-      build6.onResolve({
+      build5.onResolve({
         filter: /\.node$/,
         namespace: "node-file"
       }, (args) => ({
         path: args.path,
         namespace: "file"
       }));
-      const opts = build6.initialOptions;
+      const opts = build5.initialOptions;
       opts.loader = opts.loader || {};
       opts.loader[".node"] = "file";
     }
@@ -1084,8 +1055,8 @@ var nodeProtocolPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => {
 // ../esbuild/src/plugins/on-error.ts
 var onErrorPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
   name: "storm:on-error",
-  setup(build6) {
-    build6.onEnd((result) => {
+  setup(build5) {
+    build5.onEnd((result) => {
       if (result.errors.length > 0 && process.env.WATCH !== "true") {
         writeError(`The following errors occurred during the build:
 ${result.errors.map((error) => error.text).join("\n")}
@@ -1121,14 +1092,14 @@ function resolvePathsConfig(options, cwd) {
 __name(resolvePathsConfig, "resolvePathsConfig");
 var resolvePathsPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
   name: "storm:resolve-paths",
-  setup(build6) {
-    const parentTsConfig = build6.initialOptions.tsconfig ? __require(joinPaths(resolvedOptions.config.workspaceRoot, build6.initialOptions.tsconfig)) : __require(joinPaths(resolvedOptions.config.workspaceRoot, "tsconfig.json"));
+  setup(build5) {
+    const parentTsConfig = build5.initialOptions.tsconfig ? __require(joinPaths(resolvedOptions.config.workspaceRoot, build5.initialOptions.tsconfig)) : __require(joinPaths(resolvedOptions.config.workspaceRoot, "tsconfig.json"));
     const resolvedTsPaths = resolvePathsConfig(parentTsConfig, options.projectRoot);
     const packagesRegex = new RegExp(`^(${Object.keys(resolvedTsPaths).join("|")})$`);
-    build6.onResolve({
+    build5.onResolve({
       filter: packagesRegex
     }, (args) => {
-      if (build6.initialOptions.external?.includes(args.path)) {
+      if (build5.initialOptions.external?.includes(args.path)) {
         return {
           path: args.path,
           external: true
@@ -1202,11 +1173,11 @@ function bundleTypeDefinitions(filename, outfile, externals, options) {
 __name(bundleTypeDefinitions, "bundleTypeDefinitions");
 var tscPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
   name: "storm:tsc",
-  setup(build6) {
+  setup(build5) {
     if (options.emitTypes === false) {
       return;
     }
-    build6.onStart(async () => {
+    build5.onStart(async () => {
       if (process.env.WATCH !== "true" && process.env.DEV !== "true") {
         await run(resolvedOptions.config, `pnpm exec tsc --project ${resolvedOptions.tsconfig}`, resolvedOptions.config.workspaceRoot);
       }
@@ -1329,7 +1300,7 @@ var missingIgnore = [
 ];
 var depsCheckPlugin = /* @__PURE__ */ __name((bundle) => ({
   name: "storm:deps-check",
-  setup(build6) {
+  setup(build5) {
     const pkgJsonPath = path5.join(process.cwd(), "package.json");
     const pkgContents = __require(pkgJsonPath);
     const regDependencies = Object.keys(pkgContents["dependencies"] ?? {});
@@ -1341,7 +1312,7 @@ var depsCheckPlugin = /* @__PURE__ */ __name((bundle) => ({
     ];
     const collectedDependencies = /* @__PURE__ */ new Set();
     const onlyPackages = /^[^./](?!:)|^\.[^./]|^\.\.[^/]/;
-    build6.onResolve({
+    build5.onResolve({
       filter: onlyPackages
     }, (args) => {
       if (args.importer.includes(process.cwd())) {
@@ -1357,7 +1328,7 @@ var depsCheckPlugin = /* @__PURE__ */ __name((bundle) => ({
         external: true
       };
     });
-    build6.onEnd(() => {
+    build5.onEnd(() => {
       const unusedDependencies = [
         ...dependencies
       ].filter((dep) => {
@@ -2148,429 +2119,20 @@ var executor_default9 = withRunExecutor("Typia runtime validation generator", ty
   }
 });
 
-// ../unbuild/src/build.ts
-import { readCachedProjectGraph as readCachedProjectGraph4, writeJsonFile as writeJsonFile3 } from "@nx/devkit";
-import { getHelperDependency as getHelperDependency2, HelperDependency as HelperDependency2 } from "@nx/js";
-import { calculateProjectBuildableDependencies as calculateProjectBuildableDependencies3 } from "@nx/js/src/utils/buildable-libs-utils";
-import defu3 from "defu";
-import { createJiti } from "jiti";
-import { existsSync as existsSync4 } from "node:fs";
-import { readFile as readFile5 } from "node:fs/promises";
-import { relative as relative4 } from "node:path";
-import { findWorkspaceRoot as findWorkspaceRoot4 } from "nx/src/utils/find-workspace-root";
-
-// ../unbuild/src/clean.ts
-import { rm } from "node:fs/promises";
-async function clean3(name = "Unbuild", directory, config) {
-  writeDebug(` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
-  const stopwatch = getStopwatch(`${name} output clean`);
-  await rm(directory, {
-    recursive: true,
-    force: true
-  });
-  stopwatch();
-}
-__name(clean3, "clean");
-
-// ../unbuild/src/plugins/analyze.ts
-var formatBytes = /* @__PURE__ */ __name((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__ */ __name((options, resolvedOptions) => {
-  return {
-    name: "storm:analyzer",
-    renderChunk(source, chunk) {
-      const sourceBytes = formatBytes(source.length);
-      const fileName = chunk.fileName;
-      writeInfo(` - ${fileName} ${sourceBytes}`, resolvedOptions.config);
-    }
-  };
-}, "analyzePlugin");
-
-// ../unbuild/src/plugins/on-error.ts
-var onErrorPlugin2 = /* @__PURE__ */ __name((options, resolvedOptions) => ({
-  name: "storm:on-error",
-  buildEnd(error) {
-    if (error) {
-      writeError(`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) {
-    writeError(`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/tsc.ts
-import { readCachedProjectGraph as readCachedProjectGraph3 } from "@nx/devkit";
-import { calculateProjectBuildableDependencies as calculateProjectBuildableDependencies2 } from "@nx/js/src/utils/buildable-libs-utils";
-import { getHelperDependency, HelperDependency } from "@nx/js/src/utils/compiler-helper-dependency";
-import ts2Plugin from "rollup-plugin-typescript2";
-
-// ../unbuild/src/utilities/helpers.ts
-import { joinPathFragments as joinPathFragments4 } from "@nx/devkit";
-import { computeCompilerOptionsPaths } from "@nx/js/src/utils/buildable-libs-utils";
-import { dirname as dirname2, extname } from "node:path";
-import { pathToFileURL } from "node:url";
-import ts from "typescript";
-async function loadConfig(configPath) {
-  if (!/\.(js|mjs)$/.test(extname(configPath))) {
-    throw new Error("Unsupported config file format");
-  }
-  return import(pathToFileURL(configPath).toString()).then((config) => config.default);
-}
-__name(loadConfig, "loadConfig");
-async function createTsCompilerOptions(config, tsConfigPath, projectRoot, dependencies) {
-  const tsConfigFile = ts.readConfigFile(joinPathFragments4(config.workspaceRoot, projectRoot, tsConfigPath), ts.sys.readFile);
-  const tsConfig = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, dirname2(joinPathFragments4(config.workspaceRoot, projectRoot, tsConfigPath)));
-  const compilerOptions = {
-    rootDir: projectRoot,
-    declaration: true,
-    paths: computeCompilerOptionsPaths(tsConfig, dependencies ?? [])
-  };
-  writeTrace(compilerOptions, config);
-  return compilerOptions;
-}
-__name(createTsCompilerOptions, "createTsCompilerOptions");
-
-// ../unbuild/src/plugins/tsc.ts
-var tscPlugin2 = /* @__PURE__ */ __name(async (options, resolvedOptions) => {
-  const projectGraph = readCachedProjectGraph3();
-  const result = calculateProjectBuildableDependencies2(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 = getHelperDependency(HelperDependency.tsc, resolvedOptions.tsconfig, dependencies, projectGraph, true);
-  if (tsLibDependency) {
-    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
-    dependencies.push(tsLibDependency);
-  }
-  return ts2Plugin({
-    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
-import { relative as relative3 } from "node:path";
-function typeDefinitions(projectRoot) {
-  return {
-    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 = relative3(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
-        });
-      }
-    }
-  };
-}
-__name(typeDefinitions, "typeDefinitions");
-
-// ../unbuild/src/config.ts
-var getDefaultBuildPlugins2 = /* @__PURE__ */ __name(async (options, resolvedOptions) => Promise.all([
-  analyzePlugin(options, resolvedOptions),
-  typeDefinitions(resolvedOptions.projectRoot),
-  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 || joinPaths("dist", projectRoot);
-  const workspaceRoot3 = findWorkspaceRoot4(projectRoot);
-  if (!workspaceRoot3) {
-    throw new Error("Cannot find workspace root");
-  }
-  const config = await loadStormConfig(workspaceRoot3.dir);
-  writeDebug("  \u2699\uFE0F   Resolving build options", config);
-  const stopwatch = getStopwatch("Build options resolution");
-  if (options.configPath) {
-    const configFile = await loadConfig(options.configPath);
-    if (configFile) {
-      options = defu3(options, configFile);
-    }
-  }
-  const projectGraph = readCachedProjectGraph4();
-  const projectJsonPath = joinPaths(config.workspaceRoot, projectRoot, "project.json");
-  if (!existsSync4(projectJsonPath)) {
-    throw new Error("Cannot find project.json configuration");
-  }
-  const projectJsonContent = await readFile5(projectJsonPath, "utf8");
-  const projectJson = JSON.parse(projectJsonContent);
-  const projectName = projectJson.name;
-  const packageJsonPath = joinPaths(workspaceRoot3.dir, projectRoot, "package.json");
-  if (!existsSync4(packageJsonPath)) {
-    throw new Error("Cannot find package.json configuration");
-  }
-  const packageJsonContent = await readFile5(packageJsonPath, "utf8");
-  const packageJson = JSON.parse(packageJsonContent);
-  let tsconfig = options.tsconfig;
-  if (!tsconfig) {
-    tsconfig = joinPaths(workspaceRoot3.dir, projectRoot, "tsconfig.json");
-  }
-  if (!existsSync4(tsconfig)) {
-    throw new Error("Cannot find tsconfig.json configuration");
-  }
-  let sourceRoot = projectJson.sourceRoot;
-  if (!sourceRoot) {
-    sourceRoot = joinPaths(projectRoot, "src");
-  }
-  if (!existsSync4(sourceRoot)) {
-    throw new Error("Cannot find sourceRoot directory");
-  }
-  const result = calculateProjectBuildableDependencies3(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 = getHelperDependency2(HelperDependency2.tsc, tsconfig, dependencies, projectGraph, true);
-  if (tsLibDependency) {
-    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
-    dependencies.push(tsLibDependency);
-  }
-  const jiti = createJiti(config.workspaceRoot, {
-    cache: true,
-    fsCache: config.skipCache ? false : joinPaths(config.directories.cache || "node_modules/.cache/storm", "jiti"),
-    interopDefault: true
-  });
-  const resolvedOptions = {
-    name: projectName,
-    config,
-    projectRoot,
-    sourceRoot,
-    projectName,
-    tsconfig,
-    jiti,
-    clean: false,
-    entries: [
-      {
-        builder: "mkdist",
-        input: `.${sourceRoot.replace(projectRoot, "")}`,
-        outDir: joinPaths(relative4(joinPaths(config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
-        declaration: options.emitTypes !== false,
-        format: "esm"
-      },
-      {
-        builder: "mkdist",
-        input: `.${sourceRoot.replace(projectRoot, "")}`,
-        outDir: joinPaths(relative4(joinPaths(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: options.sourcemap ?? !!options.debug,
-    outDir: outputPath,
-    parallel: true,
-    stub: false,
-    stubOptions: {
-      jiti: {}
-    },
-    externals: options.external ?? [],
-    dependencies: [],
-    peerDependencies: [],
-    devDependencies: [],
-    hooks: {},
-    alias: {},
-    replace: {},
-    rollup: {
-      replace: {},
-      alias: {},
-      json: {},
-      commonjs: {
-        sourceMap: 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 !== false,
-        splitting: options.splitting !== false,
-        treeShaking: options.treeShaking !== false,
-        color: true,
-        logLevel: config.logLevel === LogLevelLabel.FATAL ? LogLevelLabel.ERROR : isVerbose() ? "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 = defu3(resolvedOptions.rollup ?? {}, rollup);
-  }
-  resolvedOptions.hooks = {
-    "rollup:options": /* @__PURE__ */ __name(async (ctx, opts) => {
-      opts.plugins = options.plugins ?? await getDefaultBuildPlugins2(options, resolvedOptions);
-    }, "rollup:options")
-  };
-  stopwatch();
-  return resolvedOptions;
-}
-__name(resolveOptions3, "resolveOptions");
-async function generatePackageJson3(options) {
-  if (options.generatePackageJson !== false && existsSync4(joinPaths(options.projectRoot, "package.json"))) {
-    writeDebug("  \u270D\uFE0F   Writing package.json file", options.config);
-    const stopwatch = getStopwatch("Write package.json file");
-    const packageJsonPath = joinPaths(options.projectRoot, "project.json");
-    if (!existsSync4(packageJsonPath)) {
-      throw new Error("Cannot find package.json configuration");
-    }
-    let packageJsonContent = await readFile5(joinPaths(options.config.workspaceRoot, options.projectRoot, "package.json"), "utf8");
-    if (!packageJsonContent) {
-      throw new Error("Cannot find package.json configuration file");
-    }
-    let packageJson = JSON.parse(packageJsonContent);
-    packageJson = await addPackageDependencies(options.config.workspaceRoot, options.projectRoot, options.projectName, packageJson);
-    packageJson = await addWorkspacePackageJsonFields(options.config, options.projectRoot, options.sourceRoot, options.projectName, false, packageJson);
-    await writeJsonFile3(joinPaths(options.outDir, "package.json"), await addPackageJsonExports(options.sourceRoot, packageJson));
-    stopwatch();
-  }
-  return options;
-}
-__name(generatePackageJson3, "generatePackageJson");
-async function resolveUnbuild(options) {
-  writeTrace(`Resolving Unbuild package with Jiti`, options.config);
-  try {
-    return options.jiti.import("unbuild");
-  } catch (error) {
-    writeError("  \u274C  An error occurred while resolving the Unbuild package", options.config);
-    throw new Error("An error occurred while resolving the Unbuild package", {
-      cause: error
-    });
-  }
-}
-__name(resolveUnbuild, "resolveUnbuild");
-async function executeUnbuild(options) {
-  writeDebug(`  \u{1F680}  Running ${options.name} (${options.projectRoot}) build`, options.config);
-  const stopwatch = getStopwatch(`${options.name} (${options.projectRoot}) build`);
-  try {
-    const unbuild = await resolveUnbuild(options);
-    await unbuild.build(options.projectRoot, false, {
-      ...options,
-      rootDir: options.projectRoot
-    });
-  } finally {
-    stopwatch();
-  }
-  return options;
-}
-__name(executeUnbuild, "executeUnbuild");
-async function copyBuildAssets3(options) {
-  writeDebug(`  \u{1F4CB}  Copying asset files to output directory: ${options.outDir}`, options.config);
-  const stopwatch = getStopwatch(`${options.name} asset copy`);
-  await copyAssets(options.config, options.assets ?? [], options.outDir, options.projectRoot, options.projectName, options.sourceRoot, options.generatePackageJson, options.includeSrc);
-  stopwatch();
-  return options;
-}
-__name(copyBuildAssets3, "copyBuildAssets");
-async function cleanOutputPath3(options) {
-  if (options.clean !== false && options.outDir) {
-    await clean3(options.name, options.outDir, options.config);
-  }
-  return options;
-}
-__name(cleanOutputPath3, "cleanOutputPath");
-async function build5(options) {
-  writeDebug(` \u26A1  Executing Storm Unbuild pipeline`);
-  const stopwatch = getStopwatch("Unbuild pipeline");
-  try {
-    const resolvedOptions = await resolveOptions3(options);
-    await cleanOutputPath3(resolvedOptions);
-    await generatePackageJson3(resolvedOptions);
-    await executeUnbuild(resolvedOptions);
-    await copyBuildAssets3(resolvedOptions);
-    writeSuccess(`  \u{1F3C1}  The ${resolvedOptions.name} build completed successfully`, resolvedOptions.config);
-  } catch (error) {
-    writeFatal("  \u274C  Fatal errors occurred during the build that could not be recovered from. The build process has been terminated.");
-    throw error;
-  } finally {
-    stopwatch();
-  }
-}
-__name(build5, "build");
-
 // ../workspace-tools/src/executors/unbuild/executor.ts
-import { defu as defu4 } from "defu";
+import { defu as defu3 } from "defu";
+import { createJiti } from "jiti";
 async function unbuildExecutorFn(options, context2, config) {
   writeInfo("\u{1F4E6}  Running Storm Unbuild executor on the workspace", config);
   if (!context2.projectsConfigurations?.projects || !context2.projectName || !context2.projectsConfigurations.projects[context2.projectName] || !context2.projectsConfigurations.projects[context2.projectName]?.root) {
     throw new Error("The Build process failed because the context is not valid. Please run this command from a workspace.");
   }
-  await build5(defu4({
+  const jiti = createJiti(config.workspaceRoot, {
+    fsCache: config.skipCache ? false : joinPaths(config.directories.cache || "node_modules/.cache/storm", "jiti"),
+    interopDefault: true
+  });
+  const stormUnbuild = await jiti.import("@storm-software/unbuild");
+  await stormUnbuild.build(defu3({
     ...options,
     projectRoot: context2.projectsConfigurations.projects?.[context2.projectName].root,
     projectName: context2.projectName,
@@ -2624,7 +2186,7 @@ var executor_default10 = withRunExecutor("TypeScript Unbuild build", unbuildExec
 });
 
 // ../workspace-tools/src/generators/browser-library/generator.ts
-import { formatFiles as formatFiles2, generateFiles, joinPathFragments as joinPathFragments5, names as names2, offsetFromRoot as offsetFromRoot2 } from "@nx/devkit";
+import { formatFiles as formatFiles2, generateFiles, joinPathFragments as joinPathFragments4, names as names2, offsetFromRoot as offsetFromRoot2 } from "@nx/devkit";
 
 // ../workspace-tools/src/base/base-generator.ts
 var withRunGenerator = /* @__PURE__ */ __name((name, generatorFn, generatorOptions = {
@@ -2986,7 +2548,7 @@ __name(normalizeOptions, "normalizeOptions");
 
 // ../workspace-tools/src/generators/browser-library/generator.ts
 async function browserLibraryGeneratorFn(tree, schema, config) {
-  const filesDir = joinPathFragments5(__dirname, "./files");
+  const filesDir = joinPathFragments4(__dirname, "./files");
   const tsLibraryGeneratorOptions = {
     buildExecutor: "@storm-software/workspace-tools:unbuild",
     platform: "browser",
@@ -3089,9 +2651,9 @@ var generator_default2 = withRunGenerator("Configuration Schema Creator", config
 import { addDependenciesToPackageJson as addDependenciesToPackageJson2, formatFiles as formatFiles4 } from "@nx/devkit";
 
 // ../workspace-tools/src/generators/neutral-library/generator.ts
-import { formatFiles as formatFiles5, generateFiles as generateFiles2, joinPathFragments as joinPathFragments6, names as names3, offsetFromRoot as offsetFromRoot3 } from "@nx/devkit";
+import { formatFiles as formatFiles5, generateFiles as generateFiles2, joinPathFragments as joinPathFragments5, names as names3, offsetFromRoot as offsetFromRoot3 } from "@nx/devkit";
 async function neutralLibraryGeneratorFn(tree, schema, config) {
-  const filesDir = joinPathFragments6(__dirname, "./files");
+  const filesDir = joinPathFragments5(__dirname, "./files");
   const tsLibraryGeneratorOptions = {
     ...schema,
     platform: "neutral",
@@ -3132,9 +2694,9 @@ var generator_default3 = withRunGenerator("TypeScript Library Creator (Neutral P
 });
 
 // ../workspace-tools/src/generators/node-library/generator.ts
-import { formatFiles as formatFiles6, generateFiles as generateFiles3, joinPathFragments as joinPathFragments7, names as names4, offsetFromRoot as offsetFromRoot4 } from "@nx/devkit";
+import { formatFiles as formatFiles6, generateFiles as generateFiles3, joinPathFragments as joinPathFragments6, names as names4, offsetFromRoot as offsetFromRoot4 } from "@nx/devkit";
 async function nodeLibraryGeneratorFn(tree, schema, config) {
-  const filesDir = joinPathFragments7(__dirname, "./files");
+  const filesDir = joinPathFragments6(__dirname, "./files");
   const tsLibraryGeneratorOptions = {
     platform: "node",
     devDependencies: {
@@ -3179,7 +2741,7 @@ var generator_default4 = withRunGenerator("TypeScript Library Creator (NodeJs Pl
 });
 
 // ../workspace-tools/src/generators/preset/generator.ts
-import { addDependenciesToPackageJson as addDependenciesToPackageJson3, addProjectConfiguration as addProjectConfiguration2, formatFiles as formatFiles7, generateFiles as generateFiles4, joinPathFragments as joinPathFragments8, updateJson as updateJson2 } from "@nx/devkit";
+import { addDependenciesToPackageJson as addDependenciesToPackageJson3, addProjectConfiguration as addProjectConfiguration2, formatFiles as formatFiles7, generateFiles as generateFiles4, joinPathFragments as joinPathFragments7, updateJson as updateJson2 } from "@nx/devkit";
 import * as path6 from "node:path";
 async function presetGeneratorFn(tree, options) {
   const projectRoot = ".";
@@ -3397,14 +2959,14 @@ async function presetGeneratorFn(tree, options) {
       "nx-cloud": "latest"
     };
   }
-  await Promise.resolve(addDependenciesToPackageJson3(tree, dependencies, {}, joinPathFragments8(projectRoot, "package.json")));
+  await Promise.resolve(addDependenciesToPackageJson3(tree, dependencies, {}, joinPathFragments7(projectRoot, "package.json")));
   return null;
 }
 __name(presetGeneratorFn, "presetGeneratorFn");
 var generator_default5 = withRunGenerator("Storm Workspace Preset Generator", presetGeneratorFn);
 
 // ../workspace-tools/src/generators/release-version/generator.ts
-import { formatFiles as formatFiles8, joinPathFragments as joinPathFragments9, output, readJson as readJson2, updateJson as updateJson3, writeJson as writeJson3 } from "@nx/devkit";
+import { formatFiles as formatFiles8, joinPathFragments as joinPathFragments8, output, readJson as readJson2, updateJson as updateJson3, writeJson as writeJson3 } from "@nx/devkit";
 import { resolveLocalPackageDependencies as resolveLocalPackageJsonDependencies } from "@nx/js/src/generators/release-version/utils/resolve-local-package-dependencies";
 import { updateLockFile } from "@nx/js/src/generators/release-version/utils/update-lock-file";
 
@@ -3421,7 +2983,7 @@ import ChangelogRenderer from "nx/release/changelog-renderer/index";
 
 // ../workspace-tools/src/generators/release-version/generator.ts
 import { exec as exec2, execSync as execSync5 } from "node:child_process";
-import { relative as relative5 } from "node:path";
+import { relative as relative3 } from "node:path";
 import { IMPLICIT_DEFAULT_RELEASE_GROUP } from "nx/src/command-line/release/config/config";
 import { getFirstGitCommit, getLatestGitTagForPattern } from "nx/src/command-line/release/utils/git";
 import { resolveSemverSpecifierFromConventionalCommits, resolveSemverSpecifierFromPrompt } from "nx/src/command-line/release/utils/resolve-semver-specifier";
@@ -4010,7 +3572,7 @@ var typescript_library_generator_untyped_default = defineUntypedSchema5({
 import { retrieveProjectConfigurationsWithoutPluginInference } from "nx/src/project-graph/utils/retrieve-workspace-files";
 
 // ../workspace-tools/src/utils/lock-file.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { join as join2 } from "node:path";
 import { output as output2, readJsonFile, workspaceRoot as workspaceRoot2 } from "nx/src/devkit-exports";
 import { getNpmLockfileDependencies, getNpmLockfileNodes } from "nx/src/plugins/js/lock-file/npm-parser";