@reliverse/dler 1.7.15 → 1.7.17

package/bin/libs/sdk/sdk-impl/utils/comments.js

@@ -0,0 +1,41 @@
+export const DEFAULT_COMMENT = "// ";
+const createCommentMapping = (extensions, comment) => Object.fromEntries(extensions.map((ext) => [ext, comment]));
+export const COMMENT_MAP = {
+  // Single-line comment style //
+  ...createCommentMapping(
+    [
+      "js",
+      "jsx",
+      "ts",
+      "tsx",
+      "c",
+      "cpp",
+      "h",
+      "java",
+      "go",
+      "kt",
+      "swift",
+      "rs",
+      "cs",
+      "json",
+      "proto",
+      "dart",
+      "inc",
+      "pwn"
+    ],
+    "// "
+  ),
+  // Single-line comment style #
+  ...createCommentMapping(["py", "rb", "sh", "pl", "r", "yml", "yaml"], "# "),
+  // Single-line comment style --
+  ...createCommentMapping(["sql", "lua"], "-- "),
+  // Multi-line comment style /* */
+  ...createCommentMapping(["css", "scss", "less"], "/* "),
+  // Multi-line comment style <!-- -->
+  ...createCommentMapping(["html", "htm", "xml", "md"], "<!-- ")
+};
+export const getCommentPrefix = (filePath, forceComment, customComment) => {
+  if (forceComment && customComment) return customComment;
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  return COMMENT_MAP[ext] ?? customComment ?? DEFAULT_COMMENT;
+};

package/bin/libs/sdk/sdk-impl/utils/finalize.d.ts

@@ -1,4 +1,5 @@
-import type { LibConfig, PerfTimer } from "../../sdk-types.js";
+import type { LibConfig } from "../config/types.js";
+import type { PerfTimer } from "../../sdk-types.js";
 /**
  * Finalizes the build process and reports completion.
  */

package/bin/libs/sdk/sdk-impl/utils/finalize.js

@@ -19,6 +19,7 @@ export async function finalizeBuildPub(timer, commonPubPause, libsList, distNpmD
   if (!commonPubPause) {
     relinka("success", `\u{1F389} Publish completed successfully (build time: ${transpileFormattedTime})`);
   } else {
+    console.log("-".repeat(50));
     relinka("success", `\u{1F389} Build completed successfully (done in: ${transpileFormattedTime})`);
     relinka("info", "\u{1F4DD} Publish process is currently paused in your config file");
   }

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pu-constants.d.ts

@@ -0,0 +1,6 @@
+export declare const WHITELABEL_DEFAULT = "DLER";
+export declare const JSON_EXTS: Set<string>;
+export declare const TEMPLATE_VAR: (tpl: string, wl: string) => string;
+export declare const TPLS_DIR = "tpls";
+export declare const BINARIES_DIR = "binaries";
+export declare const isJsonExt: (f: string) => boolean;

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pu-constants.js

@@ -0,0 +1,7 @@
+import path from "@reliverse/pathkit";
+export const WHITELABEL_DEFAULT = "DLER";
+export const JSON_EXTS = /* @__PURE__ */ new Set(["json", "jsonc", "json5", "jsonl"]);
+export const TEMPLATE_VAR = (tpl, wl) => `${tpl.toUpperCase()}_${wl.toUpperCase()}_TEMPLATE`;
+export const TPLS_DIR = "tpls";
+export const BINARIES_DIR = "binaries";
+export const isJsonExt = (f) => JSON_EXTS.has(path.extname(f).slice(1).toLowerCase());

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pu-file-utils.d.ts

@@ -0,0 +1,5 @@
+import type { FileType, TemplatesFileContent } from "./pu-types";
+export declare const walkDir: (dir: string) => Promise<string[]>;
+export declare const detectFileType: (file: string) => Promise<FileType>;
+export declare const readFileForTemplate: (absPath: string) => Promise<TemplatesFileContent>;
+export declare const escapeTemplateString: (src: string) => string;

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pu-file-utils.js

@@ -0,0 +1,40 @@
+import path from "@reliverse/pathkit";
+import { promises as fs } from "node:fs";
+import { isBinaryExt } from "../binary.js";
+import { isJsonExt } from "./pu-constants.js";
+import { extractJsonComments, stripComments } from "./pub-json-utils.js";
+export const walkDir = async (dir) => {
+  const entries = [];
+  for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      entries.push(...await walkDir(full));
+    } else {
+      entries.push(full);
+    }
+  }
+  return entries;
+};
+export const detectFileType = async (file) => {
+  if (await isBinaryExt(file)) return "binary";
+  if (isJsonExt(file)) return "json";
+  return "text";
+};
+export const readFileForTemplate = async (absPath) => {
+  const type = await detectFileType(absPath);
+  try {
+    if (type === "binary") {
+      return { type, content: "" };
+    }
+    const data = await fs.readFile(absPath, "utf8");
+    if (type === "json") {
+      const jsonComments = extractJsonComments(data);
+      const json = JSON.parse(stripComments(data));
+      return { type, content: json, jsonComments };
+    }
+    return { type, content: data };
+  } catch {
+    return { type, content: "", hasError: true };
+  }
+};
+export const escapeTemplateString = (src) => src.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pu-types.d.ts

@@ -0,0 +1,24 @@
+export type FileContent = string | Record<string, unknown>;
+export type FileType = "text" | "json" | "binary";
+export interface FileMetadata {
+    updatedAt: string;
+    updatedHash: string;
+}
+export interface TemplatesFileContent {
+    content: FileContent;
+    type: FileType;
+    hasError?: boolean;
+    jsonComments?: Record<number, string>;
+    binaryHash?: string;
+    metadata?: FileMetadata;
+}
+export interface TemplateConfig {
+    files: Record<string, TemplatesFileContent>;
+}
+export interface Template {
+    name: string;
+    description: string;
+    config: TemplateConfig;
+    updatedAt: string;
+}
+export type Templates = Record<string, Template>;

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pub-json-utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Helpers for reading / writing JSON-with-comments files while
+ * preserving (or later reinjecting) on–line and block comments.
+ *
+ * Supported comment styles:
+ *   // single-line
+ *   /* … *\/
+ *   /** … *\/
+ */
+export declare const extractJsonComments: (raw: string) => Record<number, string> | undefined;
+/**
+ * Very small "strip comments" helper:
+ * removes // … and /* … *\/  (including multi-line).
+ * This is intentionally simple; for complex JSONC we may want
+ * use something like `strip-json-comments` in the future.
+ */
+export declare const stripComments: (raw: string) => string;

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pub-json-utils.js

@@ -0,0 +1,46 @@
+export const extractJsonComments = (raw) => {
+  const out = {};
+  const lines = raw.split("\n");
+  for (let i = 0; i < lines.length; ) {
+    const line = lines[i];
+    if (!line) {
+      i += 1;
+      continue;
+    }
+    const trimmed = line.trimStart();
+    const indent = line.length - trimmed.length;
+    if (trimmed.startsWith("//")) {
+      out[i + 1] = trimmed.slice(2).trimStart();
+      i += 1;
+      continue;
+    }
+    if (trimmed.startsWith("/*")) {
+      const isSupported = trimmed.startsWith("/**") || trimmed.startsWith("/*");
+      if (!isSupported) {
+        i += 1;
+        continue;
+      }
+      const buff = [trimmed];
+      let j = i + 1;
+      while (j < lines.length) {
+        const currentLine = lines[j];
+        if (!currentLine) {
+          j += 1;
+          continue;
+        }
+        if (currentLine.trimEnd().endsWith("*/")) {
+          buff.push(currentLine.slice(indent));
+          break;
+        }
+        buff.push(currentLine.slice(indent));
+        j += 1;
+      }
+      out[i + 1] = buff.join("\n");
+      i = j + 1;
+      continue;
+    }
+    i += 1;
+  }
+  return Object.keys(out).length ? out : void 0;
+};
+export const stripComments = (raw) => raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\r\n]*/g, "");

package/bin/libs/sdk/sdk-impl/utils/resolve-cross-libs.d.ts

@@ -0,0 +1,3 @@
+declare function resolveCrossLibs(libBinDir: string, alias?: string, subFolders?: ("npm" | "jsr")[]): Promise<string[]>;
+declare function resolveAllCrossLibs(alias?: string, subFolders?: ("npm" | "jsr")[]): Promise<string[]>;
+export { resolveCrossLibs, resolveAllCrossLibs };

package/bin/libs/sdk/sdk-impl/utils/resolve-cross-libs.js

@@ -0,0 +1,194 @@
+import { relinka } from "@reliverse/relinka";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const PROCESS_DTS_FILES = true;
+async function resolveCrossLibs(libBinDir, alias = "~", subFolders = ["npm", "jsr"]) {
+  const normalizedPath = libBinDir.replace(/\\/g, "/");
+  if (!normalizedPath.startsWith("dist-libs") && !normalizedPath.startsWith("dist-jsr") && !normalizedPath.startsWith("dist-npm")) {
+    throw new Error(
+      `[resolve-cross-libs] libBinDir must start with "dist-libs", "dist-jsr", or "dist-npm", got: ${libBinDir}`
+    );
+  }
+  if (normalizedPath.startsWith("dist-libs")) {
+    const pathParts = normalizedPath.replace(/\/$/, "").split("/");
+    if (pathParts.length < 4) {
+      throw new Error(
+        `[resolve-cross-libs] Invalid libBinDir structure: ${libBinDir}, expected dist-libs/<lib>/<subfolder>/bin`
+      );
+    }
+    const currentLib = pathParts[1];
+    const files = await findSourceFiles(libBinDir);
+    const modifiedFiles = [];
+    await Promise.all(
+      files.map(async (filePath) => {
+        const content = await fs.readFile(filePath, "utf-8");
+        const processed = await processFile(content, currentLib, alias, subFolders, filePath);
+        if (processed !== content) {
+          relinka("log", `[resolve-cross-libs] File modified: ${filePath}`);
+          await fs.writeFile(filePath, processed, "utf-8");
+          modifiedFiles.push(path.resolve(filePath));
+        }
+      })
+    );
+    return modifiedFiles;
+  }
+  return [];
+}
+async function findSourceFiles(dir) {
+  const files = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  await Promise.all(
+    entries.map(async (entry) => {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const subFiles = await findSourceFiles(fullPath);
+        files.push(...subFiles);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        const isDts = entry.name.endsWith(".d.ts");
+        if (ext === ".js" || ext === ".ts" && !isDts || PROCESS_DTS_FILES && isDts) {
+          files.push(fullPath);
+        }
+      }
+    })
+  );
+  return files;
+}
+function escapeRegex(str) {
+  if (!str || typeof str !== "string") {
+    return "";
+  }
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function processFile(content, currentLib, alias, subFolders, currentFilePath) {
+  const lines = content.split("\n");
+  const result = [];
+  let insideInlined = false;
+  for (const line of lines) {
+    if (line.includes("/* inlined-start ")) {
+      insideInlined = true;
+      relinka("log", `[resolve-cross-libs] Entering inlined block: ${line.trim()}`);
+      result.push(line);
+      continue;
+    }
+    if (line.includes("/* inlined-end */")) {
+      insideInlined = false;
+      result.push(line);
+      continue;
+    }
+    if (insideInlined) {
+      result.push(line);
+      continue;
+    }
+    const pattern = new RegExp(
+      `^(\\s*)((?:export\\s+.*?\\s+from|import\\s+.*?\\s+from)\\s+(['"])${escapeRegex(alias)}/libs/([^/]+)/([^'"]*?)\\3[^;]*;?)(\\s*//.*)?\\s*$`
+    );
+    const match = line.match(pattern);
+    if (match) {
+      const [, indentation, fullStatement, quote, libName, rest, comment] = match;
+      relinka("log", `[resolve-cross-libs] Processing import/export: ${libName}/${rest}`);
+      if (fullStatement?.includes(`${quote}./`)) {
+        result.push(line);
+        continue;
+      }
+      if (libName === currentLib) {
+        const newStatement = fullStatement?.replace(`${quote}${alias}/libs/${libName}/`, `${quote}./`) ?? "";
+        result.push(`${indentation}${newStatement}${comment || ""}`);
+      } else {
+        try {
+          if (!libName || !rest) {
+            throw new Error("Library name or path is undefined");
+          }
+          relinka("log", `[resolve-cross-libs] Attempting to inline: ${libName}/${rest}`);
+          const targetPath = await resolveTargetFile(libName, rest, subFolders, currentFilePath);
+          const targetContent = await fs.readFile(targetPath, "utf-8");
+          result.push(`${indentation}/* inlined-start ${alias}/libs/${libName}/${rest} */`);
+          const targetLines = targetContent.split("\n");
+          relinka(
+            "log",
+            `[resolve-cross-libs] Inlining ${targetLines.length} lines from ${targetPath}`
+          );
+          for (const targetLine of targetLines) {
+            result.push(`${indentation}${targetLine}`);
+          }
+          result.push(`${indentation}/* inlined-end */`);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          relinka(
+            "error",
+            `[resolve-cross-libs] Failed to inline ${alias}/libs/${libName}/${rest}: ${errorMessage}`
+          );
+          throw error;
+        }
+      }
+    } else {
+      result.push(line);
+    }
+  }
+  return result.join("\n");
+}
+async function resolveTargetFile(libName, rest, subFolders, currentFilePath) {
+  relinka("log", `[resolve-cross-libs] Resolving target file for ${libName}/${rest}`);
+  const isCurrentFileDts = currentFilePath.endsWith(".d.ts");
+  const extensions = isCurrentFileDts ? [".d.ts", ".ts", ".js"] : [".ts", ".js", ".d.ts"];
+  for (const subFolder of subFolders) {
+    const basePath = path.join("dist-libs", libName, subFolder, "bin", rest);
+    for (const ext of extensions) {
+      const fullPath = `${basePath}${ext}`;
+      try {
+        await fs.access(fullPath);
+        return fullPath;
+      } catch {
+      }
+    }
+  }
+  throw new Error(
+    `Could not resolve target file for libs/${libName}/${rest} in any subfolder: ${subFolders.join(", ")}`
+  );
+}
+async function directoryExists(dirPath) {
+  try {
+    const stat = await fs.stat(dirPath);
+    return stat.isDirectory();
+  } catch (error) {
+    if (error instanceof Error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function resolveAllCrossLibs(alias = "~", subFolders = ["npm", "jsr"]) {
+  const distLibsDir = "dist-libs";
+  const allModifiedFiles = [];
+  const distLibsExists = await directoryExists(distLibsDir);
+  if (distLibsExists) {
+    const entries = await fs.readdir(distLibsDir, { withFileTypes: true });
+    const libDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    await Promise.all(
+      libDirs.map(async (libName) => {
+        for (const subFolder of subFolders) {
+          const binDir = path.join(distLibsDir, libName, subFolder, "bin");
+          const binDirExists = await directoryExists(binDir);
+          if (binDirExists) {
+            try {
+              const modifiedFiles = await resolveCrossLibs(binDir, alias, subFolders);
+              allModifiedFiles.push(...modifiedFiles);
+            } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : String(error);
+              relinka("error", `[resolveAllCrossLibs] Error processing ${binDir}: ${errorMessage}`);
+              throw error;
+            }
+          } else {
+            relinka("error", `[resolveAllCrossLibs] Bin directory does not exist: ${binDir}`);
+          }
+        }
+      })
+    );
+  }
+  if (allModifiedFiles.length > 0) {
+    relinka("info", "[resolveAllCrossLibs] Cross libraries replacements done in:");
+    relinka("log", "[resolveAllCrossLibs] " + allModifiedFiles.join(", "));
+  }
+  return allModifiedFiles;
+}
+export { resolveCrossLibs, resolveAllCrossLibs };

package/bin/libs/sdk/sdk-impl/utils/utils-build.d.ts

@@ -1,5 +1,4 @@
-import type { NpmOutExt, Sourcemap } from "../../sdk-types.js";
-import type { DlerConfig } from "../../sdk-types.js";
+import type { DlerConfig, NpmOutExt, Sourcemap } from "../config/types.js";
 /**
  * Converts the Unified build sourcemap option to a Bun-friendly value.
  * @param transpileSourcemap - The sourcemap configuration ('none', 'inline', 'linked', 'external', true, false).

package/bin/libs/sdk/sdk-impl/utils/utils-clean.d.ts

@@ -1,4 +1,4 @@
-import type { LibConfig } from "../../sdk-types.js";
+import type { LibConfig } from "../config/types.js";
 /**
  * Recursively removes any existing distribution folders.
  */

package/bin/libs/sdk/sdk-impl/utils/utils-deps.d.ts

@@ -1,4 +1,4 @@
-import type { DlerConfig } from "../../sdk-types.js";
+import type { DlerConfig } from "../config/types.js";
 /**
  * Filters out development dependencies from a dependency record.
  */

package/bin/libs/sdk/sdk-impl/utils/utils-determine.d.ts

@@ -1,4 +1,4 @@
-import type { LibConfig } from "../../sdk-types.js";
+import type { LibConfig } from "../config/types.js";
 /**
  * Determines the distribution name based on the file path and build type.
  * This function is used for logging and determining output paths.

package/bin/libs/sdk/sdk-impl/utils/utils-error-cwd.d.ts

@@ -13,3 +13,7 @@ export declare function withWorkingDirectory<T>(transpileTargetDir: string, fn:
  * Throws an error if the current directory does not contain any of the required paths.
  */
 export declare function validateDevCwd(isDev: boolean, paths: string[], cliName: string, cliOrg?: string): Promise<void>;
+/**
+ * Converts unknown errors to readable strings.
+ */
+export declare const formatError: (error: unknown) => string;

package/bin/libs/sdk/sdk-impl/utils/utils-error-cwd.js

@@ -48,3 +48,4 @@ export async function validateDevCwd(isDev, paths, cliName, cliOrg = "") {
     );
   }
 }
+export const formatError = (error) => error instanceof Error ? error.message : String(error);

package/bin/libs/sdk/sdk-impl/utils/utils-jsr-json.d.ts

@@ -1,4 +1,4 @@
-import type { DlerConfig, LibConfig } from "../../sdk-types.js";
+import type { DlerConfig, LibConfig } from "../config/types.js";
 /**
  * Generates a jsr.json configuration file for JSR distributions.
  */

package/bin/libs/sdk/sdk-impl/utils/utils-package-json-libraries.d.ts

@@ -1,4 +1,4 @@
-import type { NpmOutExt, DlerConfig, LibConfig } from "../../sdk-types.js";
+import type { NpmOutExt, DlerConfig, LibConfig } from "../config/types.js";
 /**
  * Creates a package.json for a lib distribution.
  */

package/bin/libs/sdk/sdk-impl/utils/utils-package-json-regular.d.ts

@@ -1,4 +1,4 @@
-import type { NpmOutExt, DlerConfig } from "../../sdk-types.js";
+import type { DlerConfig, NpmOutExt } from "../config/types.js";
 /**
  * Creates a package.json for the main distribution.
  */

package/bin/libs/sdk/sdk-impl/utils/utils-security.d.ts

@@ -1,7 +1,5 @@
-export declare const MAX_FILE_SIZE: number;
-export declare const MAX_MERGE_SIZE: number;
+export declare const setFileSizeLimits: (maxFileSize?: number, maxMergeSize?: number) => void;
 export declare const ALLOWED_FILE_TYPES: Set<string>;
-export declare const checkRateLimit: (operation: string, limit?: number) => void;
 export declare const validatePath: (filePath: string, baseDir: string) => string;
 export declare const validateFileType: (type: string) => void;
 export declare const validateContent: (content: unknown, type: string) => void;

package/bin/libs/sdk/sdk-impl/utils/utils-security.js

@@ -1,18 +1,19 @@
 import path from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
-export const MAX_FILE_SIZE = 10 * 1024 * 1024;
-export const MAX_MERGE_SIZE = MAX_FILE_SIZE * 10;
-export const ALLOWED_FILE_TYPES = /* @__PURE__ */ new Set(["text", "json", "binary"]);
-const rateLimiter = /* @__PURE__ */ new Map();
-export const checkRateLimit = (operation, limit = 1e3) => {
-  const now = Date.now();
-  const lastOperation = rateLimiter.get(operation) || 0;
-  if (now - lastOperation < limit) {
-    throw new Error(`Rate limit exceeded for operation: ${operation}`);
+const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
+const DEFAULT_MAX_MERGE_SIZE = DEFAULT_MAX_FILE_SIZE * 10;
+let MAX_FILE_SIZE = DEFAULT_MAX_FILE_SIZE;
+let MAX_MERGE_SIZE = DEFAULT_MAX_MERGE_SIZE;
+export const setFileSizeLimits = (maxFileSize, maxMergeSize) => {
+  if (maxFileSize !== void 0) {
+    MAX_FILE_SIZE = maxFileSize;
+  }
+  if (maxMergeSize !== void 0) {
+    MAX_MERGE_SIZE = maxMergeSize;
   }
-  rateLimiter.set(operation, now);
 };
+export const ALLOWED_FILE_TYPES = /* @__PURE__ */ new Set(["text", "json", "binary"]);
 export const validatePath = (filePath, baseDir) => {
   const normalizedPath = path.normalize(filePath);
   const normalizedBaseDir = path.normalize(baseDir);

package/bin/libs/sdk/sdk-mod.d.ts

@@ -23,16 +23,11 @@ export { processLibraryFlow, libraries_buildPublish, } from "./sdk-impl/library-
 export { library_publishLibrary } from "./sdk-impl/pub/pub-library";
 export { regular_pubToJsr, regular_pubToNpm, } from "./sdk-impl/pub/pub-regular";
 export { processRegularFlow } from "./sdk-impl/regular-flow";
-export { replaceLineExecutor, renameFileExecutor, removeCommentExecutor, removeLineExecutor, removeFileExecutor, copyFileExecutor, moveFileExecutor, transformContentExecutor, insertAtExecutor, } from "./sdk-impl/spell/spell-executors";
-export { fileExists, readFile, writeFile, removeFile, renameFile, copyFile, findFiles, } from "./sdk-impl/spell/spell-filesystem";
-export { executeSpell, processFile, spells, } from "./sdk-impl/spell/spell-mod";
-export { parseParams, parseSpellFromComment, extractSpellsFromFile, } from "./sdk-impl/spell/spell-parser";
-export type { SpellType, SpellParams, Spell, SpellExecutionOptions, FileOperation, SpellResult, } from "./sdk-impl/spell/spell-types";
 export { useAggregator } from "./sdk-impl/utils/tools-agg";
 export { printUsage } from "./sdk-impl/utils/tools-impl";
 export { getBunSourcemapOption, getUnifiedSourcemapOption, renameEntryFile, } from "./sdk-impl/utils/utils-build";
 export { removeDistFolders } from "./sdk-impl/utils/utils-clean";
-export { PROJECT_ROOT, CONCURRENCY_DEFAULT, tsconfigJson, cliDomainDocs, validExtensions, SHOW_VERBOSE, } from "./sdk-impl/utils/utils-consts";
+export { PROJECT_ROOT, CONCURRENCY_DEFAULT, cliDomainDocs, validExtensions, SHOW_VERBOSE, } from "./sdk-impl/utils/utils-consts";
 export { validateDevCwd, withWorkingDirectory, } from "./sdk-impl/utils/utils-error-cwd";
 export { filterDeps } from "./sdk-impl/utils/utils-deps";
 export { determineDistName } from "./sdk-impl/utils/utils-determine";

package/bin/libs/sdk/sdk-mod.js

@@ -59,36 +59,6 @@ export {
   regular_pubToNpm
 } from "./sdk-impl/pub/pub-regular.js";
 export { processRegularFlow } from "./sdk-impl/regular-flow.js";
-export {
-  replaceLineExecutor,
-  renameFileExecutor,
-  removeCommentExecutor,
-  removeLineExecutor,
-  removeFileExecutor,
-  copyFileExecutor,
-  moveFileExecutor,
-  transformContentExecutor,
-  insertAtExecutor
-} from "./sdk-impl/spell/spell-executors.js";
-export {
-  fileExists,
-  readFile,
-  writeFile,
-  removeFile,
-  renameFile,
-  copyFile,
-  findFiles
-} from "./sdk-impl/spell/spell-filesystem.js";
-export {
-  executeSpell,
-  processFile,
-  spells
-} from "./sdk-impl/spell/spell-mod.js";
-export {
-  parseParams,
-  parseSpellFromComment,
-  extractSpellsFromFile
-} from "./sdk-impl/spell/spell-parser.js";
 export { useAggregator } from "./sdk-impl/utils/tools-agg.js";
 export { printUsage } from "./sdk-impl/utils/tools-impl.js";
 export {
@@ -100,7 +70,6 @@ export { removeDistFolders } from "./sdk-impl/utils/utils-clean.js";
 export {
   PROJECT_ROOT,
   CONCURRENCY_DEFAULT,
-  tsconfigJson,
   cliDomainDocs,
   validExtensions,
   SHOW_VERBOSE