@reliverse/dler 1.7.21 → 1.7.23

package/bin/libs/cfg/constants.d.ts

@@ -0,0 +1,68 @@
+import type { DlerConfig } from "./types";
+/**
+ * Default configuration for the build and publish logic.
+ */
+export declare const DEFAULT_CONFIG_DLER: DlerConfig;
+export declare const defineConfigDler: (userConfig?: Partial<DlerConfig>) => {
+    bumpDisable: boolean;
+    bumpFilter: string[];
+    bumpMode: import("./types").BumpMode;
+    bumpSet: string;
+    commonPubPause: boolean;
+    commonPubRegistry: "jsr" | "npm" | "npm-jsr";
+    commonVerbose: boolean;
+    coreDeclarations: boolean;
+    coreEntryFile: string;
+    coreEntrySrcDir: string;
+    coreBuildOutDir: string;
+    coreIsCLI: {
+        enabled: boolean;
+        scripts: Record<string, string>;
+    };
+    coreDescription: string;
+    distJsrAllowDirty: boolean;
+    distJsrBuilder: import("./types").BundlerName;
+    distJsrDirName: string;
+    distJsrDryRun: boolean;
+    distJsrFailOnWarn: boolean;
+    distJsrGenTsconfig: boolean;
+    distJsrOutFilesExt: import("./types").NpmOutExt;
+    distJsrSlowTypes: boolean;
+    distNpmBuilder: import("./types").BundlerName;
+    distNpmDirName: string;
+    distNpmOutFilesExt: import("./types").NpmOutExt;
+    libsActMode: "libs-only" | "main-and-libs" | "main-project-only";
+    libsDirDist: string;
+    libsDirSrc: string;
+    libsList: Record<string, import("./types").LibConfig>;
+    logsFileName: string;
+    logsFreshFile: boolean;
+    filterDepsPatterns: {
+        global: string[];
+        "dist-npm": string[];
+        "dist-jsr": string[];
+        "dist-libs": Record<string, {
+            npm: string[];
+            jsr: string[];
+        }>;
+    };
+    transpileFailOnWarn: boolean;
+    transpileEsbuild: import("./types").Esbuild;
+    transpileFormat: import("./types").transpileFormat;
+    transpileMinify: boolean;
+    transpilePublicPath: string;
+    transpileSourcemap: import("./types").Sourcemap;
+    transpileSplitting: boolean;
+    transpileStub: boolean;
+    transpileTarget: import("./types").transpileTarget;
+    transpileWatch: boolean;
+    publishArtifacts?: {
+        global: string[];
+        "dist-jsr": string[];
+        "dist-npm": string[];
+        "dist-libs": Record<string, {
+            jsr: string[];
+            npm: string[];
+        }>;
+    };
+};

package/bin/libs/cfg/constants.js

@@ -0,0 +1,60 @@
+export const DEFAULT_CONFIG_DLER = {
+  bumpDisable: false,
+  bumpFilter: ["package.json", ".config/rse.ts"],
+  bumpMode: "patch",
+  bumpSet: "",
+  commonPubPause: true,
+  commonPubRegistry: "npm",
+  commonVerbose: false,
+  coreDeclarations: true,
+  coreDescription: "",
+  coreEntryFile: "mod.ts",
+  coreEntrySrcDir: "src",
+  coreBuildOutDir: "bin",
+  coreIsCLI: { enabled: false, scripts: {} },
+  distJsrAllowDirty: true,
+  distJsrBuilder: "jsr",
+  distJsrDirName: "dist-jsr",
+  distJsrDryRun: false,
+  distJsrFailOnWarn: false,
+  distJsrGenTsconfig: false,
+  distJsrOutFilesExt: "ts",
+  distJsrSlowTypes: true,
+  distNpmBuilder: "mkdist",
+  distNpmDirName: "dist-npm",
+  distNpmOutFilesExt: "js",
+  libsActMode: "main-project-only",
+  libsDirDist: "dist-libs",
+  libsDirSrc: "src/libs",
+  libsList: {},
+  logsFileName: ".logs/relinka.log",
+  logsFreshFile: true,
+  // Dependency filtering
+  filterDepsPatterns: {
+    global: ["@types", "biome", "eslint", "knip", "prettier", "typescript", "@reliverse/dler"],
+    "dist-npm": [],
+    "dist-jsr": [],
+    "dist-libs": {}
+  },
+  // Build setup
+  transpileFailOnWarn: false,
+  transpileEsbuild: "es2023",
+  transpileFormat: "esm",
+  transpileMinify: true,
+  transpilePublicPath: "/",
+  transpileSourcemap: "none",
+  transpileSplitting: false,
+  transpileStub: false,
+  transpileTarget: "node",
+  transpileWatch: false,
+  // Publish artifacts configuration
+  publishArtifacts: {
+    global: ["package.json", "README.md", "LICENSE"],
+    "dist-jsr": [],
+    "dist-npm": [],
+    "dist-libs": {}
+  }
+};
+export const defineConfigDler = (userConfig = {}) => {
+  return { ...DEFAULT_CONFIG_DLER, ...userConfig };
+};

package/bin/libs/cfg/rse/rse-impl/rse-create.js

@@ -5,12 +5,12 @@ import { confirmPrompt } from "@reliverse/rempts";
 import { Value } from "@sinclair/typebox/value";
 import { execaCommand } from "execa";
 import { addDevDependency } from "nypm";
+import { injectSectionComments } from "./rse-comments.js";
 import { cliDomainDocs } from "./rse-consts.js";
 import { UNKNOWN_VALUE, rseName, DEFAULT_DOMAIN, RSE_SCHEMA_DEV } from "./rse-consts.js";
 import { generateDefaultRulesForProject, getDefaultRseConfig } from "./rse-def-utils.js";
 import { DEFAULT_CONFIG_RSE } from "./rse-default.js";
 import { getPackageJson, detectFeatures } from "./rse-detect.js";
-import { injectSectionComments } from "./rse-inject.js";
 import { getRseConfigPath } from "./rse-path.js";
 import { readRseConfig } from "./rse-read.js";
 import { rseSchema } from "./rse-schema.js";

package/bin/libs/cfg/rse/rse-impl/rse-define.d.ts

@@ -11,10 +11,10 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
     projectGitService?: "none" | "github" | "gitlab" | "bitbucket" | undefined;
     projectDeployService?: "none" | "vercel" | "netlify" | "railway" | "deno" | undefined;
     projectPackageManager?: "npm" | "bun" | "pnpm" | "yarn" | undefined;
-    projectState?: "created" | "creating" | undefined;
+    projectState?: "creating" | "created" | undefined;
     projectCategory?: "browser" | "cli" | "unknown" | "website" | "vscode" | "library" | "mobile" | undefined;
     projectSubcategory?: "unknown" | "e-commerce" | "tool" | undefined;
-    projectFramework?: "vue" | "npm-jsr" | "rempts" | "unknown" | "vscode" | "nextjs" | "vite" | "svelte" | "remix" | "astro" | "nuxt" | "solid" | "qwik" | "wxt" | "lynx" | "react-native" | "expo" | "capacitor" | "ionic" | "electron" | "tauri" | "neutralino" | "citty" | "commander" | "cac" | "meow" | "yargs" | "webextension" | "browser-extension" | undefined;
+    projectFramework?: "npm-jsr" | "unknown" | "vscode" | "nextjs" | "vite" | "svelte" | "remix" | "astro" | "nuxt" | "solid" | "qwik" | "vue" | "wxt" | "lynx" | "react-native" | "expo" | "capacitor" | "ionic" | "electron" | "tauri" | "neutralino" | "rempts" | "citty" | "commander" | "cac" | "meow" | "yargs" | "webextension" | "browser-extension" | undefined;
     projectTemplate?: "unknown" | "blefnk/relivator-nextjs-template" | "blefnk/relivator-docker-template" | "blefnk/next-react-ts-src-minimal" | "blefnk/all-in-one-nextjs-template" | "blefnk/create-t3-app" | "blefnk/create-next-app" | "blefnk/astro-starlight-template" | "blefnk/versator-nextjs-template" | "blefnk/relivator-lynxjs-template" | "blefnk/relivator-react-native-template" | "reliverse/template-browser-extension" | "microsoft/vscode-extension-samples" | "microsoft/vscode-extension-template" | "rsetarter-template" | "blefnk/deno-cli-tutorial" | undefined;
     projectTemplateDate?: string | undefined;
     features?: {
@@ -41,12 +41,12 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         testing?: "bun" | "unknown" | "vitest" | "jest" | "playwright" | "cypress" | undefined;
         stateManagement?: "unknown" | "zustand" | "jotai" | "redux-toolkit" | undefined;
         formManagement?: "unknown" | "react-hook-form" | "formik" | undefined;
-        styling?: "sass" | "unknown" | "tailwind" | "styled-components" | "css-modules" | undefined;
+        styling?: "unknown" | "tailwind" | "styled-components" | "css-modules" | "sass" | undefined;
         uiComponents?: "unknown" | "shadcn-ui" | "chakra-ui" | "material-ui" | undefined;
         databaseLibrary?: "unknown" | "drizzle" | "prisma" | "supabase" | undefined;
-        databaseProvider?: "unknown" | "sqlite" | "pg" | "mysql" | "mongodb" | undefined;
-        linting?: "unknown" | "eslint" | undefined;
-        formatting?: "unknown" | "biome" | undefined;
+        databaseProvider?: "unknown" | "pg" | "mysql" | "sqlite" | "mongodb" | undefined;
+        linting?: "eslint" | "unknown" | undefined;
+        formatting?: "biome" | "unknown" | undefined;
         payment?: "unknown" | "stripe" | undefined;
         monitoring?: "unknown" | "sentry" | undefined;
         logging?: "unknown" | "axiom" | undefined;
@@ -75,7 +75,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         indentStyle?: "space" | "tab" | undefined;
         quoteMark?: "single" | "double" | undefined;
         semicolons?: boolean | undefined;
-        trailingComma?: "all" | "none" | "es5" | undefined;
+        trailingComma?: "none" | "es5" | "all" | undefined;
         bracketSpacing?: boolean | undefined;
         arrowParens?: "always" | "avoid" | undefined;
         tabWidth?: number | undefined;
@@ -83,7 +83,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         dontRemoveComments?: boolean | undefined;
         shouldAddComments?: boolean | undefined;
         typeOrInterface?: "type" | "interface" | "mixed" | undefined;
-        importOrRequire?: "import" | "require" | "mixed" | undefined;
+        importOrRequire?: "mixed" | "import" | "require" | undefined;
         cjsToEsm?: boolean | undefined;
         modernize?: {
             replaceFs?: boolean | undefined;
@@ -96,7 +96,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         importSymbol?: string | undefined;
     } | undefined;
     monorepo?: {
-        type?: "bun" | "none" | "turborepo" | "nx" | "pnpm" | undefined;
+        type?: "none" | "bun" | "turborepo" | "nx" | "pnpm" | undefined;
         packages?: string[] | undefined;
         sharedPackages?: string[] | undefined;
     } | undefined;
@@ -111,9 +111,9 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
     customReposOnNewProject?: boolean | undefined;
     envComposerOpenBrowser?: boolean | undefined;
     repoBranch?: string | undefined;
-    repoPrivacy?: "private" | "public" | "unknown" | undefined;
+    repoPrivacy?: "unknown" | "public" | "private" | undefined;
     projectArchitecture?: "unknown" | "fullstack" | "separated" | undefined;
-    projectRuntime?: "bun" | "node" | "deno" | undefined;
+    projectRuntime?: "node" | "bun" | "deno" | undefined;
     skipPromptsUseAutoBehavior?: boolean | undefined;
     deployBehavior?: "prompt" | "autoYes" | "autoNo" | undefined;
     depsBehavior?: "prompt" | "autoYes" | "autoNo" | undefined;

package/bin/libs/cfg/rse/rse-mod.d.ts

@@ -8,7 +8,7 @@ export * from "./rse-impl/rse-default";
 export * from "./rse-impl/rse-define";
 export * from "./rse-impl/rse-detect";
 export * from "./rse-impl/rse-gen-cfg";
-export * from "./rse-impl/rse-inject";
+export * from "./rse-impl/rse-comments";
 export * from "./rse-impl/rse-migrate";
 export * from "./rse-impl/rse-path";
 export * from "./rse-impl/rse-prompts";

package/bin/libs/cfg/rse/rse-mod.js

@@ -8,7 +8,7 @@ export * from "./rse-impl/rse-default.js";
 export * from "./rse-impl/rse-define.js";
 export * from "./rse-impl/rse-detect.js";
 export * from "./rse-impl/rse-gen-cfg.js";
-export * from "./rse-impl/rse-inject.js";
+export * from "./rse-impl/rse-comments.js";
 export * from "./rse-impl/rse-migrate.js";
 export * from "./rse-impl/rse-path.js";
 export * from "./rse-impl/rse-prompts.js";

package/bin/libs/sdk/sdk-impl/cmds/inject/inject-impl-mod.d.ts

@@ -0,0 +1,63 @@
+/**
+ * inject-impl-mod.ts
+ * -----------
+ * Utility for injecting content into files at specific line/column positions.
+ *
+ * Fully async -– works with Node, Bun, and other
+ * runtimes that support the `fs/promises` API.
+ *
+ * @author blefnk
+ */
+export interface InjectionConfig {
+    /** Absolute or relative path to target file. */
+    filePath: string;
+    /** 1-based line number (1 == first visible line in editors) */
+    line: number;
+    /** 1-based column number (1 == first visible column in editors) */
+    column?: number;
+    /** String or array of strings to inject. */
+    content: string | string[];
+    /** If `true`, inserts string (or first element of array) content on a new line AFTER the target line. */
+    createNewLine?: boolean;
+    /** Configuration for comment wrapping. */
+    commentsMode?: {
+        /** Whether to wrap content in comments. */
+        activate: boolean;
+        /** Whether to use JSDoc style for multiline comments. */
+        useJsdocForMultiline?: boolean;
+    };
+}
+export interface InjectionResult {
+    /** Absolute or relative path to target file. */
+    filePath: string;
+    /** Whether the injection was successful. */
+    success: boolean;
+    /** Error message if injection failed. */
+    error?: string;
+    /** Generated source map if available. */
+    sourcemap?: string;
+}
+/**
+ * Injects content into the given file at the requested location.
+ *
+ * @param filePath       Absolute or relative path to target file.
+ * @param line           1-based line number (1 == first visible line in editors, internally == 0).
+ * @param column         1-based column number (optional, 1 == first visible column in editors, internally == 0).
+ * @param content        String or array of strings to inject.
+ * @param createNewLine  If `true`, inserts string (or first element of array) content on a new line AFTER the target line.
+ * @param commentsMode   If `true`, wraps injected content in file-type comments.
+ * @param generateSourceMap If `true`, generates a source map for the transformation.
+ *
+ * @returns `true` on success, `false` on failure (errors are logged).
+ */
+export declare function injectAtLocation(filePath: string, line: number, column: number | undefined, content: string | string[], createNewLine?: boolean, commentsMode?: {
+    activate: boolean;
+}, generateSourceMap?: boolean): Promise<boolean>;
+/**
+ * Processes multiple injections efficiently by grouping by file and applying in reverse order.
+ *
+ * @param configs Array of {@link InjectionConfig}.
+ * @param generateSourceMaps If `true`, generates source maps for transformations.
+ * @returns Array of {@link InjectionResult} in the same order as `configs`.
+ */
+export declare function injectMultiple(configs: InjectionConfig[], generateSourceMaps?: boolean): Promise<InjectionResult[]>;

package/bin/libs/sdk/sdk-impl/cmds/inject/inject-impl-mod.js

@@ -0,0 +1,237 @@
+import MagicString from "magic-string";
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { isBinaryExt } from "../../utils/binary.js";
+export async function injectAtLocation(filePath, line, column, content, createNewLine = false, commentsMode = { activate: false }, generateSourceMap = false) {
+  try {
+    await validateInput(filePath, line, column);
+    const originalContent = await fs.readFile(filePath, "utf8");
+    const magicString = new MagicString(originalContent, {
+      filename: path.basename(filePath)
+    });
+    const pieces = Array.isArray(content) ? content : [content];
+    const preparedContent = prepareContentForInjection(
+      pieces,
+      commentsMode,
+      path.extname(filePath),
+      createNewLine
+    );
+    const success = injectWithMagicString(
+      magicString,
+      originalContent,
+      line,
+      column,
+      preparedContent,
+      createNewLine
+    );
+    if (!success) return false;
+    const result = magicString.toString();
+    await fs.writeFile(filePath, result, "utf8");
+    if (generateSourceMap) {
+      const map = magicString.generateMap({
+        source: filePath,
+        file: `${filePath}.map`,
+        includeContent: true,
+        hires: true
+      });
+      await fs.writeFile(`${filePath}.map`, map.toString(), "utf8");
+    }
+    return true;
+  } catch (err) {
+    console.error(`[injector] ${filePath}: ${err.message}`);
+    return false;
+  }
+}
+export async function injectMultiple(configs, generateSourceMaps = false) {
+  const configsByFile = /* @__PURE__ */ new Map();
+  configs.forEach((config, index) => {
+    if (!configsByFile.has(config.filePath)) {
+      configsByFile.set(config.filePath, []);
+    }
+    configsByFile.get(config.filePath)?.push({ config, originalIndex: index });
+  });
+  const results = new Array(configs.length);
+  for (const [filePath, fileConfigs] of configsByFile) {
+    try {
+      const firstConfig = fileConfigs[0]?.config;
+      if (!firstConfig) {
+        throw new Error(`No valid configs found for file: ${filePath}`);
+      }
+      await validateInput(firstConfig.filePath, firstConfig.line, firstConfig.column);
+      const originalContent = await fs.readFile(filePath, "utf8");
+      const magicString = new MagicString(originalContent, {
+        filename: path.basename(filePath)
+      });
+      const sortedConfigs = [...fileConfigs].sort((a, b) => {
+        const aLine = a.config.line;
+        const bLine = b.config.line;
+        if (aLine !== bLine) return bLine - aLine;
+        const aCol = a.config.column ?? Number.MAX_SAFE_INTEGER;
+        const bCol = b.config.column ?? Number.MAX_SAFE_INTEGER;
+        return bCol - aCol;
+      });
+      let allSuccessful = true;
+      for (const { config, originalIndex } of sortedConfigs) {
+        const { line, column, content, createNewLine, commentsMode } = config;
+        const pieces = Array.isArray(content) ? content : [content];
+        const preparedContent = prepareContentForInjection(
+          pieces,
+          commentsMode,
+          path.extname(filePath),
+          createNewLine ?? false
+        );
+        const success = injectWithMagicString(
+          magicString,
+          originalContent,
+          line,
+          column,
+          preparedContent,
+          createNewLine ?? false
+        );
+        results[originalIndex] = success ? { filePath, success } : {
+          filePath,
+          success: false,
+          error: `Injection failed for ${filePath} at line ${line}`
+        };
+        if (!success) {
+          allSuccessful = false;
+        }
+      }
+      if (allSuccessful) {
+        const result = magicString.toString();
+        await fs.writeFile(filePath, result, "utf8");
+        if (generateSourceMaps) {
+          const map = magicString.generateMap({
+            source: filePath,
+            file: `${filePath}.map`,
+            includeContent: true,
+            hires: true
+          });
+          await fs.writeFile(`${filePath}.map`, map.toString(), "utf8");
+        }
+      }
+    } catch (err) {
+      for (const { originalIndex } of fileConfigs) {
+        results[originalIndex] = {
+          filePath,
+          success: false,
+          error: `File processing failed: ${err.message}`
+        };
+      }
+    }
+  }
+  return results;
+}
+async function validateInput(filePath, line, column) {
+  await fs.access(filePath).catch(() => {
+    throw new Error("File does not exist.");
+  });
+  if (await isBinaryExt(filePath)) {
+    throw new Error("Cannot inject into binary files.");
+  }
+  if (!Number.isInteger(line) || line < 1)
+    throw new Error("`line` must be a positive 1-based integer.");
+  if (column !== void 0 && (!Number.isInteger(column) || column < 1))
+    throw new Error("`column` must be a positive 1-based integer when provided.");
+}
+function getCharacterIndex(content, line1Based, column1Based) {
+  const lines = content.split(/\r?\n/);
+  const eolLength = content.includes("\r\n") ? 2 : 1;
+  while (lines.length < line1Based) {
+    lines.push("");
+  }
+  let index = 0;
+  for (let i = 0; i < line1Based - 1; i++) {
+    index += lines[i]?.length ?? 0;
+    if (i < lines.length - 1) index += eolLength;
+  }
+  const targetLine = lines[line1Based - 1] || "";
+  const lineStart = index;
+  const lineEnd = lineStart + targetLine.length;
+  if (column1Based !== void 0) {
+    const colIndex = Math.min(column1Based - 1, targetLine.length);
+    index += colIndex;
+  } else {
+    index = lineEnd;
+  }
+  return { index, lineEnd, lineStart };
+}
+function prepareContentForInjection(pieces, commentsMode, ext, createNewLine) {
+  let preparedPieces = pieces.slice();
+  if (commentsMode?.activate) {
+    preparedPieces = applyCommentWrapping(preparedPieces, commentsMode, ext);
+  }
+  let result = preparedPieces.join("\n");
+  if (createNewLine && result) {
+    result = "\n" + result;
+  }
+  return result;
+}
+function applyCommentWrapping(pieces, commentsMode, ext) {
+  const { lineComment, blockStart, blockEnd } = getCommentSymbols(ext);
+  if (pieces.length === 1) {
+    return pieces.map((p) => ` ${lineComment} ${p}`);
+  }
+  const isJsdoc = commentsMode.useJsdocForMultiline;
+  const processedPieces = pieces.map((p) => p === "" ? " " : p);
+  return [
+    ` ${blockStart}${isJsdoc ? "*" : ""} ${processedPieces[0]}`,
+    ...processedPieces.slice(1, -1).map((p) => ` ${isJsdoc ? "*" : ""} ${p}`),
+    ` ${isJsdoc ? "*" : ""} ${processedPieces[processedPieces.length - 1]} ${blockEnd}`
+  ];
+}
+function injectWithMagicString(magicString, originalContent, line1Based, column1Based, preparedContent, createNewLine) {
+  try {
+    const { index, lineEnd, lineStart } = getCharacterIndex(
+      originalContent,
+      line1Based,
+      column1Based
+    );
+    const currentLength = originalContent.length;
+    if (index > currentLength) {
+      const linesNeeded = Math.ceil((index - currentLength) / 50);
+      const extension = "\n".repeat(linesNeeded);
+      magicString.append(extension);
+    }
+    if (createNewLine) {
+      if (column1Based !== void 0) {
+        const currentLineContent = originalContent.split(/\r?\n/)[line1Based - 1] || "";
+        const beforeColumn = currentLineContent.slice(0, column1Based - 1);
+        const afterColumn = currentLineContent.slice(column1Based - 1);
+        const replacement = beforeColumn + "\n" + preparedContent + (afterColumn ? "\n" + afterColumn : "");
+        magicString.overwrite(lineStart, lineEnd, replacement);
+      } else {
+        magicString.appendRight(lineEnd, preparedContent);
+      }
+    } else {
+      magicString.appendRight(index, preparedContent);
+    }
+    return true;
+  } catch (err) {
+    console.error(`[injector] MagicString injection failed: ${err.message}`);
+    return false;
+  }
+}
+function getCommentSymbols(ext) {
+  const map = {
+    ".js": { line: "//", blockStart: "/*", blockEnd: "*/" },
+    ".ts": { line: "//", blockStart: "/*", blockEnd: "*/" },
+    ".jsx": { line: "//", blockStart: "/*", blockEnd: "*/" },
+    ".tsx": { line: "//", blockStart: "/*", blockEnd: "*/" },
+    ".css": { line: "//", blockStart: "/*", blockEnd: "*/" },
+    ".scss": { line: "//", blockStart: "/*", blockEnd: "*/" },
+    ".html": { line: "//", blockStart: "<!--", blockEnd: "-->" },
+    ".py": { line: "#", blockStart: '"""', blockEnd: '"""' },
+    ".sh": { line: "#", blockStart: ": <<'BLOCK'", blockEnd: "BLOCK" },
+    ".yaml": { line: "#", blockStart: "# ---", blockEnd: "# ---" },
+    ".yml": { line: "#", blockStart: "# ---", blockEnd: "# ---" },
+    ".json": { line: "//", blockStart: "/*", blockEnd: "*/" },
+    ".jsonc": { line: "//", blockStart: "/*", blockEnd: "*/" }
+  };
+  const symbols = map[ext.toLowerCase()] ?? { line: "//", blockStart: "/*", blockEnd: "*/" };
+  return {
+    lineComment: symbols.line ?? "//",
+    blockStart: symbols.blockStart,
+    blockEnd: symbols.blockEnd
+  };
+}

package/bin/libs/sdk/sdk-impl/config/info.js

@@ -1,11 +1,9 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.7.21";
+const version = "1.7.23";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",
     clearConsole: false,
-    // packageName: getPkgName(),
-    // packageVersion: getPkgVersion(),
     packageName: "dler",
     packageVersion: version,
     isDev

package/bin/libs/sdk/sdk-impl/magic/apply.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Spell runner – walks a directory tree, finds
+ * magic-comment directives and executes them.
+ *
+ * Usage example:
+ *   await applyMagicSpells(["dist-jsr"]);
+ *   await applyMagicSpells(["dist-libs/sdk"]);
+ *   await applyMagicSpells(["dist-npm", "dist-jsr", "dist-libs"]);
+ *   await applyMagicSpells(["custom-output/my-lib"]); // For custom targets, magic directives are processed directly in the target files
+ */
+export interface ApplyMagicSpellsOptions {
+    /** Absolute or cwd-relative root directory to process */
+    dir: string;
+    /** Number of files to process in parallel */
+    concurrency?: number;
+    /** Number of files to process in each batch */
+    batchSize?: number;
+    /** Whether to stop on first error */
+    stopOnError?: boolean;
+    /** Whether to copy files from src before processing */
+    copyFileWithDirectivesFromSrcBeforeProcessing?: boolean;
+    /** Custom output paths mapping for non-standard directories */
+    customOutputPaths?: Record<string, string>;
+}
+export interface ApplyMagicSpellsResult {
+    /** All processed files */
+    processedFiles: string[];
+}
+/**
+ * Processes files in specified output directories by applying magic directives
+ * For dist targets, first scans src directory for files with magic directives, then processes corresponding output files
+ * For custom targets, processes magic directives directly in the target files
+ * @param targets Array of output targets in format "dist-npm", "dist-jsr", "dist-libs" or "dist-libs/lib-name" or any custom path
+ * @param options Configuration options for processing
+ * @returns Object containing arrays of processed files and processed .d.ts files
+ */
+export declare function applyMagicSpells(targets: string[], options?: Partial<ApplyMagicSpellsOptions>): Promise<ApplyMagicSpellsResult>;
+/**
+ * Gets all available registries across all libraries
+ * @returns Array of unique registry names found across all libraries
+ */
+export declare function getAllAvailableRegistries(): Promise<string[]>;
+/**
+ * Information about a file containing magic spells
+ */
+export interface FileWithSpells {
+    /** Absolute path to the file */
+    path: string;
+    /** Line numbers where spells were found (1-based) */
+    spellLines: number[];
+}
+/**
+ * Scans directories for files containing magic spells
+ * @param dirs Array of directories to scan (absolute or cwd-relative paths)
+ * @param options Configuration options for scanning
+ * @returns Array of files containing magic spells with their line numbers
+ */
+export declare function getFilesWithMagicSpells(dirs: string[], options?: {
+    /** Whether to stop on first error */
+    stopOnError?: boolean;
+    /** Whether to exclude spell implementation files */
+    excludeSpellImplementation?: boolean;
+}): Promise<FileWithSpells[]>;