@reliverse/dler 1.7.10 → 1.7.11

package/bin/app/mkdist/cmd.d.ts

@@ -75,9 +75,5 @@ declare const _default: import("@reliverse/rempts").Command<{
         type: "string";
         description: string;
     };
-    dontBuildCopyInstead: {
-        type: "string";
-        description: string;
-    };
 }>;
 export default _default;

package/bin/app/mkdist/cmd.js

@@ -86,10 +86,6 @@ export default defineCommand({
     target: {
       type: "string",
       description: "Target environment (esbuild)"
-    },
-    dontBuildCopyInstead: {
-      type: "string",
-      description: "Don't build copy instead of (glob patterns, e.g. '**/*.json') (default: ['**/templates'])"
     }
   }),
   async run({ args }) {

package/bin/app/mock/cmd.d.ts

@@ -0,0 +1,41 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    template: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    "template-file": {
+        type: "string";
+        description: string;
+    };
+    "template-consts": {
+        type: "string";
+        description: string;
+    };
+    cleanup: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    "dry-run": {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    verbose: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    whitelabel: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    force: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
+}>;
+export default _default;

package/bin/app/mock/cmd.js

@@ -0,0 +1,284 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+import { createJiti } from "jiti";
+import prettyMilliseconds from "pretty-ms";
+import { isBinaryExt } from "../../libs/sdk/sdk-impl/utils/binary.js";
+import { createPerfTimer, getElapsedPerfTime } from "../../libs/sdk/sdk-impl/utils/utils-perf.js";
+import {
+  validatePath,
+  validateFileType,
+  validateContent,
+  checkPermissions,
+  handleError,
+  validateTemplate,
+  checkRateLimit,
+  sanitizeInput
+} from "../../libs/sdk/sdk-impl/utils/utils-security.js";
+import { DLER_TEMPLATES, dlerTemplatesMap } from "./mock.js";
+const jiti = createJiti(import.meta.url);
+async function writeFile(filePath, file, dryRun) {
+  try {
+    const { content, type } = file;
+    validateFileType(type);
+    validateContent(content, type);
+    const sanitizedPath = sanitizeInput(filePath);
+    checkRateLimit(`write_${sanitizedPath}`);
+    if (dryRun) {
+      relinka("log", `[DRY RUN] Would write file: ${sanitizedPath}`);
+      return;
+    }
+    const isBinary = await isBinaryExt(sanitizedPath);
+    if (isBinary && type !== "binary") {
+      relinka(
+        "warn",
+        `Warning: File ${sanitizedPath} appears to be binary but is not marked as such in template`
+      );
+    }
+    await checkPermissions(sanitizedPath, "write");
+    if (type === "json") {
+      await fs.writeJson(sanitizedPath, content, { spaces: 2 });
+    } else {
+      await fs.writeFile(sanitizedPath, content, "utf8");
+    }
+  } catch (error) {
+    handleError(error, `writeFile(${filePath})`);
+  }
+}
+async function createMockStructure(template, dryRun) {
+  try {
+    validateTemplate(template);
+    const normalizePath = (filePath) => {
+      return validatePath(filePath, process.cwd());
+    };
+    await Promise.all(
+      Object.entries(template.config.files).map(async ([filePath, file]) => {
+        const normalizedPath = normalizePath(filePath);
+        if (!dryRun) {
+          await fs.ensureDir(path.dirname(normalizedPath));
+        }
+        await writeFile(normalizedPath, file, dryRun);
+      })
+    );
+    if (!dryRun) {
+      relinka(
+        "success",
+        "Mock structure created successfully (used template: " + template.name + ")"
+      );
+    } else {
+      relinka("success", "[DRY RUN] Mock structure would be created successfully");
+    }
+  } catch (error) {
+    handleError(error, "createMockStructure");
+  }
+}
+async function cleanupMockStructure(template, dryRun) {
+  try {
+    validateTemplate(template);
+    const paths = Object.keys(template.config.files);
+    let filesRemoved = 0;
+    for (const filePath of paths) {
+      const normalizedPath = validatePath(filePath, process.cwd());
+      if (dryRun) {
+        relinka("log", `[DRY RUN] Would remove: ${normalizedPath}`);
+        continue;
+      }
+      try {
+        if (await fs.pathExists(normalizedPath)) {
+          await fs.remove(normalizedPath);
+          filesRemoved++;
+          const parentDir = path.dirname(normalizedPath);
+          if (await fs.pathExists(parentDir)) {
+            const files = await fs.readdir(parentDir);
+            if (files.length === 0) {
+              await fs.remove(parentDir);
+              relinka("log", `Removed empty directory: ${parentDir}`);
+            }
+          }
+        }
+      } catch (error) {
+        relinka(
+          "warn",
+          `Failed to remove ${normalizedPath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (dryRun) {
+      relinka("success", "[DRY RUN] Mock structure would be cleaned up successfully");
+    } else {
+      relinka("success", `Mock structure cleaned up successfully (removed ${filesRemoved} files)`);
+    }
+  } catch (error) {
+    handleError(error, "cleanupMockStructure");
+  }
+}
+async function handleExistingPaths(template, force) {
+  try {
+    validateTemplate(template);
+    const paths = Object.keys(template.config.files);
+    const existingPaths = await Promise.all(
+      paths.map(async (filePath) => {
+        const normalizedPath = validatePath(filePath, process.cwd());
+        return { path: normalizedPath, exists: await fs.pathExists(normalizedPath) };
+      })
+    );
+    const conflicts = existingPaths.filter((p) => p.exists);
+    if (conflicts.length > 0) {
+      if (!force) {
+        throw new Error(
+          `Path conflicts detected. Cannot proceed with the following existing paths:
+${conflicts.map((c) => c.path).join("\n")}`
+        );
+      }
+      for (const conflict of conflicts) {
+        await checkPermissions(conflict.path, "write");
+        await fs.remove(conflict.path);
+      }
+    }
+    return true;
+  } catch (error) {
+    handleError(error, "handleExistingPaths");
+    return false;
+  }
+}
+export default defineCommand({
+  meta: {
+    name: "mock",
+    version: "1.0.0",
+    description: "Bootstraps file structure based on the specified mock template. Pro tip: Run e.g. 'dler merge --s src/templates --d templates/my-template.ts --as-template' (glob supported) to create mock template based on your own file structure."
+  },
+  args: {
+    template: {
+      type: "string",
+      description: "Mock template to use (default: react) (available: " + Object.keys(DLER_TEMPLATES).join(", ") + ")",
+      default: "react"
+    },
+    "template-file": {
+      type: "string",
+      description: "Custom template file to use instead of default dler's src/app/template/mock-template.ts"
+    },
+    "template-consts": {
+      type: "string",
+      description: "Space-separated list of template constants to target (e.g., BASIC_DLER_TEMPLATE REACT_DLER_TEMPLATE)"
+    },
+    cleanup: {
+      type: "boolean",
+      description: "Clean up existing mock",
+      default: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview changes without applying them",
+      default: false
+    },
+    verbose: {
+      type: "boolean",
+      description: "Enable verbose logging",
+      default: false
+    },
+    whitelabel: {
+      type: "string",
+      description: "Custom prefix to use instead of 'DLER' in template handling",
+      default: "DLER"
+    },
+    force: {
+      type: "boolean",
+      description: "Clean existing paths before proceeding (default: true)",
+      default: true
+    }
+  },
+  async run({ args }) {
+    try {
+      const {
+        template,
+        "template-file": templateFile,
+        "template-consts": templateConsts,
+        cleanup,
+        "dry-run": dryRun,
+        verbose,
+        whitelabel = "DLER",
+        force
+      } = args;
+      if (verbose) {
+        relinka("log", "Verbose logging enabled");
+      }
+      let templates;
+      if (templateFile) {
+        try {
+          const module = await jiti.import(templateFile);
+          const templatesKey = `${whitelabel}_TEMPLATES`;
+          const loadedTemplates = module[templatesKey];
+          if (!loadedTemplates) {
+            throw new Error(`No templates found with prefix: ${whitelabel}`);
+          }
+          templates = loadedTemplates;
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          relinka("error", `Failed to load template file: ${errorMessage}`);
+          process.exit(1);
+        }
+      } else {
+        templates = DLER_TEMPLATES;
+      }
+      if (templateConsts) {
+        const requestedConsts = templateConsts.split(" ").map((c) => c.trim());
+        const filteredTemplates = {};
+        for (const constName of requestedConsts) {
+          let templateConst;
+          try {
+            if (templateFile) {
+              const module = await jiti.import(templateFile);
+              templateConst = module[constName];
+            } else {
+              const templateKey = dlerTemplatesMap[constName];
+              if (!templateKey) {
+                throw new Error(
+                  `Invalid template constant: ${constName}. Available constants: ${Object.keys(dlerTemplatesMap).join(", ")}`
+                );
+              }
+              templateConst = DLER_TEMPLATES[templateKey];
+            }
+            if (!templateConst) {
+              throw new Error(`Template constant not found: ${constName}`);
+            }
+            filteredTemplates[templateConst.name.toLowerCase()] = templateConst;
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            relinka("error", errorMessage);
+            process.exit(1);
+          }
+        }
+        templates = filteredTemplates;
+      }
+      if (!templates[template]) {
+        throw new Error(
+          `Invalid template: ${template}. Available templates: ${Object.keys(templates).join(", ")}`
+        );
+      }
+      const timer = createPerfTimer();
+      if (cleanup) {
+        await cleanupMockStructure(templates[template], dryRun);
+        const elapsed2 = getElapsedPerfTime(timer);
+        relinka(
+          "success",
+          `Successfully ${dryRun ? "would clean up" : "cleaned up"} template structure in ${prettyMilliseconds(elapsed2)}`
+        );
+        return;
+      }
+      if (!await handleExistingPaths(templates[template], force)) {
+        return;
+      }
+      await createMockStructure(templates[template], dryRun);
+      const elapsed = getElapsedPerfTime(timer);
+      relinka(
+        "success",
+        `Successfully ${dryRun ? "would create" : "created"} mock structure in ${prettyMilliseconds(elapsed)}`
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      relinka("error", `Error during mock creation: ${errorMessage}`);
+      process.exit(1);
+    }
+  }
+});

package/bin/app/mock/mock.d.ts

@@ -0,0 +1,11 @@
+import type { Template } from "../../libs/sdk/sdk-types.js";
+export declare const BASIC_DLER_TEMPLATE: Template;
+export declare const API_DLER_TEMPLATE: Template;
+export declare const REACT_DLER_TEMPLATE: Template;
+export declare const DLER_TEMPLATES: {
+    readonly basic: Template;
+    readonly api: Template;
+    readonly react: Template;
+};
+export type DLER_TEMPLATE_NAMES = keyof typeof DLER_TEMPLATES;
+export declare const dlerTemplatesMap: Record<string, DLER_TEMPLATE_NAMES>;

package/bin/app/mock/mock.js

@@ -0,0 +1,97 @@
+export const BASIC_DLER_TEMPLATE = {
+  name: "basic",
+  description: "Template generated from 4 files",
+  config: {
+    files: {
+      "src/templates/README.md": {
+        content: "# Mock Project\n\nThis is a mock project created for testing purposes.",
+        type: "text"
+      },
+      "src/templates/config.json": {
+        content: {
+          name: "mock-project",
+          version: "1.0.0",
+          dependencies: {
+            "@reliverse/relifso": "^latest",
+            "@reliverse/relinka": "^latest"
+          }
+        },
+        type: "json"
+      },
+      "src/templates/index.ts": {
+        content: "export const mock = () => console.log('Hello from mock!');",
+        type: "text"
+      },
+      "src/templates/utils/helper.ts": {
+        content: "export const helper = () => 'Helper function';",
+        type: "text"
+      }
+    }
+  }
+};
+export const API_DLER_TEMPLATE = {
+  name: "api",
+  description: "Template generated from 3 files",
+  config: {
+    files: {
+      "src/templates/README.md": {
+        content: "# Mock Project\n\nThis is a mock project created for testing purposes.\n",
+        type: "text"
+      },
+      "src/templates/index.ts": {
+        content: '// @ts-expect-error this is a mock file\nimport express from "express";\n\nconst app = express();\napp.listen(3000);\n',
+        type: "text"
+      },
+      "src/templates/routes/index.ts": {
+        content: '// @ts-expect-error this is a mock file\nimport { Router } from "express";\n\nexport const router = Router();\n',
+        type: "text"
+      }
+    }
+  }
+};
+export const REACT_DLER_TEMPLATE = {
+  name: "react",
+  description: "Template generated from 7 files",
+  config: {
+    files: {
+      "src/templates/App.css": {
+        content: "#root {\n  max-width: 1280px;\n  margin: 0 auto;\n  padding: 2rem;\n  text-align: center;\n}\n\n.card {\n  padding: 2em;\n}\n\nbutton {\n  border-radius: 8px;\n  border: 1px solid transparent;\n  padding: 0.6em 1.2em;\n  font-size: 1em;\n  font-weight: 500;\n  font-family: inherit;\n  background-color: #1a1a1a;\n  cursor: pointer;\n  transition: border-color 0.25s;\n}\n\nbutton:hover {\n  border-color: #646cff;\n}\n\nbutton:focus,\nbutton:focus-visible {\n  outline: 4px auto -webkit-focus-ring-color;\n}",
+        type: "text"
+      },
+      "src/templates/App.tsx": {
+        content: 'import { useState } from "react";\nimport "./App.css";\n\nfunction App() {\n  const [count, setCount] = useState(0);\n\n  return (\n    // @ts-expect-error mock\n    <div className="App">\n      {/* @ts-expect-error mock */}\n      <h1>React TSX App</h1>\n      {/* @ts-expect-error mock */}\n      <div className="card">\n        {/* @ts-expect-error mock */}\n        <button onClick={() => setCount((count) => count + 1)}>count is {count}</button>\n      </div>\n    </div>\n  );\n}\n\nexport default App;\n',
+        type: "text"
+      },
+      "src/templates/DOCS.md": {
+        content: "# React TSX Project\n\nA modern React project with TypeScript and Vite.\n\n## Features\n\n- React 19 with TypeScript\n- Vite for fast development and building\n- Modern CSS with CSS modules support\n- Hot Module Replacement (HMR)\n- ESLint and Prettier configuration\n\n## Getting Started\n\n1. Install dependencies:\n\n   ```bash\n   npm install\n   ```\n\n2. Start development server:\n\n   ```bash\n   npm run dev\n   ```\n\n3. Build for production:\n\n   ```bash\n   npm run build\n   ```\n",
+        type: "text"
+      },
+      "src/templates/globals.css": {
+        content: ":root {\n  font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;\n  line-height: 1.5;\n  font-weight: 400;\n\n  color-scheme: light dark;\n  color: rgba(255, 255, 255, 0.87);\n  background-color: #242424;\n\n  font-synthesis: none;\n  text-rendering: optimizeLegibility;\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n}\n\nbody {\n  margin: 0;\n  display: flex;\n  place-items: center;\n  min-width: 320px;\n  min-height: 100vh;\n}\n\nh1 {\n  font-size: 3.2em;\n  line-height: 1.1;\n}",
+        type: "text"
+      },
+      "src/templates/hello/world.ts": {
+        content: 'console.log("Hello, world!");\r\n',
+        type: "text"
+      },
+      "src/templates/index.html": {
+        content: '<!DOCTYPE html>\n<html lang="en">\n  <head>\n    <meta charset="UTF-8" />\n    <meta name="viewport" content="width=device-width, initial-scale=1.0" />\n    <title>React TSX App</title>\n  </head>\n  <body>\n    <div id="root"></div>\n    <script type="module" src="/src/main.tsx"><\/script>\n  </body>\n</html>',
+        type: "text"
+      },
+      "src/templates/main.tsx": {
+        content: 'import React from "react";\n// @ts-expect-error mock\nimport ReactDOM from "react-dom/client";\nimport App from "./App";\nimport "./index.css";\n\nReactDOM.createRoot(document.getElementById("root")!).render(\n  <React.StrictMode>\n    <App />\n  </React.StrictMode>,\n);\n',
+        type: "text"
+      }
+    }
+  }
+};
+export const DLER_TEMPLATES = {
+  basic: BASIC_DLER_TEMPLATE,
+  api: API_DLER_TEMPLATE,
+  react: REACT_DLER_TEMPLATE
+};
+export const dlerTemplatesMap = {
+  BASIC_DLER_TEMPLATE: "basic",
+  API_DLER_TEMPLATE: "api",
+  REACT_DLER_TEMPLATE: "react"
+};

package/bin/app/pub/cmd.js

@@ -1,6 +1,8 @@
 import { defineArgs, defineCommand } from "@reliverse/rempts";
 import { dlerPub } from "../build/impl.js";
 import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/cfg/init.js";
+import { loadConfig } from "../../libs/sdk/sdk-impl/cfg/load.js";
+import { removeDistFolders } from "../../libs/sdk/sdk-mod.js";
 export default defineCommand({
   meta: {
     name: "build",
@@ -14,6 +16,13 @@ export default defineCommand({
   }),
   async run({ args }) {
     await ensureDlerConfig(args.dev);
-    await dlerPub(args.dev);
+    const config = await loadConfig();
+    await removeDistFolders(
+      config.distNpmDirName,
+      config.distJsrDirName,
+      config.libsDirDist,
+      config.libsList
+    );
+    await dlerPub(args.dev, config);
   }
 });

package/bin/libs/sdk/sdk-impl/build/build-library.js

@@ -140,7 +140,6 @@ async function library_buildJsrDist(options) {
   };
   await library_buildDistributionTarget(buildParams);
   relinka("verbose", `[JSR] Performing JSR-specific transformations in ${outputDirBinResolved}`);
-  await renameTsxFiles(outputDirBinResolved);
   await createJsrJSON(
     outputDirRootResolved,
     true,
@@ -149,6 +148,7 @@ async function library_buildJsrDist(options) {
     libName,
     libConfig?.libDescription ?? ""
   );
+  await renameTsxFiles(outputDirBinResolved);
   const dirSize = await getDirectorySize(outputDirRootResolved, options.isDev);
   const filesCount = await outDirBinFilesCount(outputDirBinResolved);
   relinka(
@@ -485,7 +485,14 @@ async function library_bundleUsingUnified(entryPoint, outDirBin, builder, _sourc
     stub: transpileStub
   };
   try {
-    await unifiedBuild(entryPoint, false, true, rootDir, unifiedBuildConfig, outDirBin);
+    await unifiedBuild(
+      entryPoint,
+      { enabled: false, scripts: {} },
+      true,
+      rootDir,
+      unifiedBuildConfig,
+      outDirBin
+    );
     const duration = getElapsedPerfTime(timer);
     relinka(
       "success",

package/bin/libs/sdk/sdk-impl/build/build-regular.js

@@ -14,13 +14,16 @@ import {
   PROJECT_ROOT,
   validExtensions
 } from "../utils/utils-consts.js";
-import { copyRootFile, deleteSpecificFiles } from "../utils/utils-fs.js";
+import {
+  copyInsteadOfBuild,
+  copyRootFile,
+  deleteSpecificFiles
+} from "../utils/utils-fs.js";
 import { createJsrJSON, renameTsxFiles } from "../utils/utils-jsr-json.js";
 import { regular_createPackageJSON } from "../utils/utils-package-json-regular.js";
 import { getElapsedPerfTime } from "../utils/utils-perf.js";
 const ALIAS_PREFIX_TO_CONVERT = "~";
 export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrcDir, distJsrDirName, distJsrBuilder, coreEntryFile, transpileTarget, transpileFormat, transpileSplitting, transpileMinify, transpileSourcemap, transpilePublicPath, unifiedBundlerOutExt, config, timer, transpileStub, transpileWatch, distJsrGenTsconfig, coreDeclarations) {
-  const isCLI = coreIsCLI.enabled;
   const outDirRoot = path.join(process.cwd(), distJsrDirName);
   const outDirBin = path.join(outDirRoot, config.coreBuildOutDir || "bin");
   const singleFile = path.join(process.cwd(), coreEntrySrcDir, coreEntryFile);
@@ -29,7 +32,7 @@ export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrc
   try {
     await fs.ensureDir(outDirBin);
     await regular_bundleWithBuilder(distJsrBuilder, {
-      isCLI,
+      coreIsCLI: { enabled: coreIsCLI.enabled, scripts: coreIsCLI.scripts },
       coreDeclarations,
       outDir: outDirBin,
       singleFile,
@@ -59,7 +62,6 @@ export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrc
       await regular_createTsconfig(outDirRoot);
     }
     relinka("verbose", `Performing JSR-specific transformations in ${outDirBin}`);
-    await renameTsxFiles(outDirBin);
     await createJsrJSON(
       outDirRoot,
       false,
@@ -71,6 +73,13 @@ export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrc
       // libName (not needed for regular builds)
       config.coreDescription
     );
+    if (coreIsCLI.enabled) {
+      await copyInsteadOfBuild(path.join(PROJECT_ROOT, coreEntrySrcDir), outDirBin, [
+        `${config.distNpmDirName}/**/templates`,
+        `${config.distJsrDirName}/**/templates`
+      ]);
+    }
+    await renameTsxFiles(outDirBin);
     const duration = getElapsedPerfTime(timer);
     const transpileFormattedDuration = prettyMilliseconds(duration, {
       verbose: true
@@ -87,7 +96,6 @@ export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrc
   }
 }
 export async function regular_buildNpmDist(isDev, coreIsCLI, coreEntrySrcDir, distNpmDirName, distNpmBuilder, coreEntryFile, unifiedBundlerOutExt, config, transpileTarget, transpileFormat, transpileSplitting, transpileMinify, transpileSourcemap, transpilePublicPath, transpileStub, transpileWatch, timer, coreDeclarations) {
-  const isCLI = coreIsCLI.enabled;
   const outDirRoot = path.join(process.cwd(), distNpmDirName);
   const outDirBin = path.join(outDirRoot, config.coreBuildOutDir || "bin");
   const singleFile = path.join(process.cwd(), coreEntrySrcDir, coreEntryFile);
@@ -96,7 +104,7 @@ export async function regular_buildNpmDist(isDev, coreIsCLI, coreEntrySrcDir, di
   try {
     await fs.ensureDir(outDirBin);
     await regular_bundleWithBuilder(distNpmBuilder, {
-      isCLI,
+      coreIsCLI: { enabled: coreIsCLI.enabled, scripts: coreIsCLI.scripts },
       coreDeclarations,
       outDir: outDirBin,
       singleFile,
@@ -122,6 +130,12 @@ export async function regular_buildNpmDist(isDev, coreIsCLI, coreEntrySrcDir, di
       coreDescription: config.coreDescription,
       coreBuildOutDir: config.coreBuildOutDir
     });
+    if (coreIsCLI.enabled) {
+      await copyInsteadOfBuild(path.join(PROJECT_ROOT, coreEntrySrcDir), outDirBin, [
+        `${config.distNpmDirName}/**/templates`,
+        `${config.distJsrDirName}/**/templates`
+      ]);
+    }
     const duration = getElapsedPerfTime(timer);
     const transpileFormattedDuration = prettyMilliseconds(duration, {
       verbose: true
@@ -214,7 +228,7 @@ async function regular_bundleUsingJsr(src, dest) {
     throw new Error(errorMessage);
   }
 }
-async function regular_bundleUsingUnified(isCLI, coreEntryFile, outDirBin, builder, unifiedBundlerOutExt, coreEntrySrcDir, transpileStub, transpileWatch, transpileTarget, transpileMinify, transpileSourcemap, timer, coreDeclarations) {
+async function regular_bundleUsingUnified(coreIsCLI, coreEntryFile, outDirBin, builder, unifiedBundlerOutExt, coreEntrySrcDir, transpileStub, transpileWatch, transpileTarget, transpileMinify, transpileSourcemap, timer, coreDeclarations) {
   if (builder === "jsr" || builder === "bun") {
     throw new Error("'jsr'/'bun' builder not supported for regular_bundleUsingUnified");
   }
@@ -256,10 +270,9 @@ async function regular_bundleUsingUnified(isCLI, coreEntryFile, outDirBin, build
       },
       showOutLog: true,
       transpileStub,
-      transpileWatch: transpileWatch ?? false,
-      dontBuildCopyInstead: ["**/templates"]
+      transpileWatch: transpileWatch ?? false
     };
-    await unifiedBuild(coreEntrySrcDir, isCLI, false, rootDir, unifiedBuildConfig, outDirBin);
+    await unifiedBuild(coreEntrySrcDir, coreIsCLI, false, rootDir, unifiedBuildConfig, outDirBin);
     const duration = getElapsedPerfTime(timer);
     const transpileFormattedDuration = prettyMilliseconds(duration, {
       verbose: true
@@ -280,7 +293,7 @@ async function regular_bundleUsingUnified(isCLI, coreEntryFile, outDirBin, build
 }
 async function regular_bundleWithBuilder(builder, params) {
   const {
-    isCLI,
+    coreIsCLI,
     coreDeclarations,
     outDir,
     singleFile,
@@ -315,7 +328,7 @@ async function regular_bundleWithBuilder(builder, params) {
     return;
   }
   await regular_bundleUsingUnified(
-    isCLI,
+    coreIsCLI,
     singleFile,
     outDir,
     builder,

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/build.d.ts

@@ -1,5 +1,8 @@
 import type { UnifiedBuildConfig } from "../../../../sdk-types.js";
-export declare function unifiedBuild(inputSourceDir: string, isCLI: boolean, isLib: boolean, rootDir: string, inputConfig: UnifiedBuildConfig & {
+export declare function unifiedBuild(inputSourceDir: string, coreIsCLI: {
+    enabled: boolean;
+    scripts: Record<string, string>;
+}, isLib: boolean, rootDir: string, inputConfig: UnifiedBuildConfig & {
     config?: string;
     showOutLog?: boolean;
 }, outDir: string, transpileStub?: boolean): Promise<void>;