@reliverse/dler 1.6.5 → 1.6.7

package/bin/app/migrate/codemods/fs-to-relifso.js

@@ -0,0 +1,179 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile, readdir, stat } from "node:fs/promises";
+import { join, extname } from "node:path";
+async function getAllTsFiles(dir) {
+  const files = [];
+  try {
+    const entries = await readdir(dir);
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      const stats = await stat(fullPath);
+      if (stats.isDirectory() && !entry.startsWith(".") && entry !== "node_modules") {
+        const subFiles = await getAllTsFiles(fullPath);
+        files.push(...subFiles);
+      } else if (stats.isFile()) {
+        const ext = extname(entry);
+        if ([".ts", ".tsx", ".js", ".jsx", ".vue", ".svelte"].includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+export async function migrateFsToRelifso(dryRun = false) {
+  const results = [];
+  const files = await getAllTsFiles(".");
+  for (const file of files) {
+    try {
+      const content = await readFile(file, "utf-8");
+      let modified = content;
+      const changes = [];
+      const nodeFsImportRegex = /import\s+(?:(\{[^}]*\})|(\w+))\s+from\s+["']node:fs["']/g;
+      if (nodeFsImportRegex.test(content)) {
+        modified = modified.replace(
+          nodeFsImportRegex,
+          (match, namedExports, defaultExport) => {
+            if (namedExports) {
+              return `import ${namedExports} from "@reliverse/relifso"`;
+            }
+            return `import ${defaultExport} from "@reliverse/relifso"`;
+          }
+        );
+        changes.push("Updated node:fs imports to @reliverse/relifso");
+      }
+      const nodeFsPromisesImportRegex = /import\s+(?:(\{[^}]*\})|(\w+))\s+from\s+["']node:fs\/promises["']/g;
+      if (nodeFsPromisesImportRegex.test(content)) {
+        modified = modified.replace(
+          nodeFsPromisesImportRegex,
+          (match, namedExports, defaultExport) => {
+            if (namedExports) {
+              return `import ${namedExports} from "@reliverse/relifso"`;
+            }
+            return `import ${defaultExport} from "@reliverse/relifso"`;
+          }
+        );
+        changes.push("Updated node:fs/promises imports to @reliverse/relifso");
+      }
+      const fsExtraImportRegex = /import\s+(?:(\{[^}]*\})|(\w+))\s+from\s+["']fs-extra["']/g;
+      if (fsExtraImportRegex.test(content)) {
+        modified = modified.replace(
+          fsExtraImportRegex,
+          (match, namedExports, defaultExport) => {
+            if (namedExports) {
+              return `import ${namedExports} from "@reliverse/relifso"`;
+            }
+            return `import ${defaultExport} from "@reliverse/relifso"`;
+          }
+        );
+        changes.push("Updated fs-extra imports to @reliverse/relifso");
+      }
+      const nodeFsRequireRegex = /require\s*\(\s*["']node:fs["']\s*\)/g;
+      if (nodeFsRequireRegex.test(content)) {
+        modified = modified.replace(
+          nodeFsRequireRegex,
+          'require("@reliverse/relifso")'
+        );
+        changes.push("Updated node:fs require to @reliverse/relifso");
+      }
+      const nodeFsPromisesRequireRegex = /require\s*\(\s*["']node:fs\/promises["']\s*\)/g;
+      if (nodeFsPromisesRequireRegex.test(content)) {
+        modified = modified.replace(
+          nodeFsPromisesRequireRegex,
+          'require("@reliverse/relifso")'
+        );
+        changes.push("Updated node:fs/promises require to @reliverse/relifso");
+      }
+      const fsExtraRequireRegex = /require\s*\(\s*["']fs-extra["']\s*\)/g;
+      if (fsExtraRequireRegex.test(content)) {
+        modified = modified.replace(
+          fsExtraRequireRegex,
+          'require("@reliverse/relifso")'
+        );
+        changes.push("Updated fs-extra require to @reliverse/relifso");
+      }
+      if (changes.length > 0) {
+        if (!dryRun) {
+          await writeFile(file, modified, "utf-8");
+        }
+        results.push({
+          file,
+          success: true,
+          message: `${changes.length} change(s) made`,
+          changes
+        });
+      }
+    } catch (error) {
+      results.push({
+        file,
+        success: false,
+        message: `Failed to process: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  await updatePackageJson(results, dryRun, {
+    remove: ["fs-extra"],
+    add: { "@reliverse/relifso": "^latest" }
+  });
+  return results;
+}
+async function updatePackageJson(results, dryRun, config) {
+  try {
+    const packageJsonPath = "./package.json";
+    if (existsSync(packageJsonPath)) {
+      const packageContent = await readFile(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(packageContent);
+      let packageChanged = false;
+      const packageChanges = [];
+      for (const pkg of config.remove) {
+        if (packageJson.dependencies?.[pkg]) {
+          packageJson.dependencies = Object.fromEntries(
+            Object.entries(packageJson.dependencies).filter(
+              ([key]) => key !== pkg
+            )
+          );
+          packageChanged = true;
+          packageChanges.push(`Removed ${pkg} from dependencies`);
+        }
+        if (packageJson.devDependencies?.[pkg]) {
+          packageJson.devDependencies = Object.fromEntries(
+            Object.entries(packageJson.devDependencies).filter(
+              ([key]) => key !== pkg
+            )
+          );
+          packageChanged = true;
+          packageChanges.push(`Removed ${pkg} from devDependencies`);
+        }
+      }
+      for (const [pkg, version] of Object.entries(config.add)) {
+        if (packageChanged && !packageJson.dependencies?.[pkg]) {
+          if (!packageJson.dependencies) packageJson.dependencies = {};
+          packageJson.dependencies[pkg] = version;
+          packageChanges.push(`Added ${pkg} to dependencies`);
+        }
+      }
+      if (packageChanged) {
+        if (!dryRun) {
+          await writeFile(
+            packageJsonPath,
+            JSON.stringify(packageJson, null, 2) + "\n",
+            "utf-8"
+          );
+        }
+        results.push({
+          file: packageJsonPath,
+          success: true,
+          message: `${packageChanges.length} change(s) made`,
+          changes: packageChanges
+        });
+      }
+    }
+  } catch (error) {
+    results.push({
+      file: "./package.json",
+      success: false,
+      message: `Failed to update package.json: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+}

package/bin/app/migrate/codemods/path-to-pathkit.d.ts

@@ -0,0 +1,8 @@
+type MigrationResult = {
+    file: string;
+    success: boolean;
+    message: string;
+    changes?: string[];
+};
+export declare function migratePathToPathkit(dryRun?: boolean): Promise<MigrationResult[]>;
+export {};

package/bin/app/migrate/codemods/{lib-pathe-pathkit.js → path-to-pathkit.js}

@@ -22,7 +22,7 @@ async function getAllTsFiles(dir) {
   }
   return files;
 }
-export async function migratePatheToPathkit(dryRun = false) {
+export async function migratePathToPathkit(dryRun = false) {
   const results = [];
   const files = await getAllTsFiles(".");
   for (const file of files) {
@@ -46,6 +46,19 @@ export async function migratePatheToPathkit(dryRun = false) {
         );
         changes.push("Updated pathe/utils imports to @reliverse/pathkit");
       }
+      const nodePathImportRegex = /import\s+(?:(\{[^}]*\})|(\w+))\s+from\s+["']node:path["']/g;
+      if (nodePathImportRegex.test(content)) {
+        modified = modified.replace(
+          nodePathImportRegex,
+          (match, namedExports, defaultExport) => {
+            if (namedExports) {
+              return `import ${namedExports} from "@reliverse/pathkit"`;
+            }
+            return `import ${defaultExport} from "@reliverse/pathkit"`;
+          }
+        );
+        changes.push("Updated node:path imports to @reliverse/pathkit");
+      }
       const patheRequireRegex = /require\s*\(\s*["']pathe["']\s*\)/g;
       if (patheRequireRegex.test(content)) {
         modified = modified.replace(
@@ -62,115 +75,13 @@ export async function migratePatheToPathkit(dryRun = false) {
         );
         changes.push("Updated pathe/utils require to @reliverse/pathkit");
       }
-      if (changes.length > 0) {
-        if (!dryRun) {
-          await writeFile(file, modified, "utf-8");
-        }
-        results.push({
-          file,
-          success: true,
-          message: `${changes.length} change(s) made`,
-          changes
-        });
-      }
-    } catch (error) {
-      results.push({
-        file,
-        success: false,
-        message: `Failed to process: ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
-  }
-  await updatePackageJson(results, dryRun, {
-    remove: ["pathe"],
-    add: { "@reliverse/pathkit": "^latest" }
-  });
-  return results;
-}
-export async function migratePathkitToPathe(dryRun = false) {
-  const results = [];
-  const files = await getAllTsFiles(".");
-  for (const file of files) {
-    try {
-      const content = await readFile(file, "utf-8");
-      let modified = content;
-      const changes = [];
-      const pathkitImportRegex = /from\s+["']@reliverse\/pathkit["']/g;
-      if (pathkitImportRegex.test(content)) {
-        const advancedFeatures = [
-          "getFileImportsExports",
-          "convertImportPaths",
-          "convertImportExtensionsJsToTs",
-          "normalizeAliases",
-          "resolveAlias",
-          "reverseResolveAlias",
-          "normalizeQuotes"
-        ];
-        const usesAdvancedFeatures = advancedFeatures.some(
-          (feature) => content.includes(feature)
+      const nodePathRequireRegex = /require\s*\(\s*["']node:path["']\s*\)/g;
+      if (nodePathRequireRegex.test(content)) {
+        modified = modified.replace(
+          nodePathRequireRegex,
+          'require("@reliverse/pathkit")'
         );
-        if (usesAdvancedFeatures) {
-          changes.push(
-            "\u26A0\uFE0F  File uses advanced pathkit features - manual review needed"
-          );
-          results.push({
-            file,
-            success: false,
-            message: "Contains advanced pathkit features not available in pathe",
-            changes
-          });
-          continue;
-        }
-        const utilsPattern = /import\s*\{([^}]+)\}\s*from\s*["']@reliverse\/pathkit["']/g;
-        const utilsMatch = utilsPattern.exec(content);
-        if (utilsMatch?.[1]) {
-          const imports = utilsMatch[1].split(",").map((s) => s.trim());
-          const coreImports = imports.filter(
-            (imp) => ![
-              "filename",
-              "normalizeAliases",
-              "resolveAlias",
-              "reverseResolveAlias"
-            ].includes(imp.replace(/\s+as\s+\w+/, ""))
-          );
-          const utilImports = imports.filter(
-            (imp) => [
-              "filename",
-              "normalizeAliases",
-              "resolveAlias",
-              "reverseResolveAlias"
-            ].includes(imp.replace(/\s+as\s+\w+/, ""))
-          );
-          if (coreImports.length > 0 && utilImports.length > 0) {
-            const coreImportStatement = `import { ${coreImports.join(", ")} } from "pathe";`;
-            const utilImportStatement = `import { ${utilImports.join(", ")} } from "pathe/utils";`;
-            modified = modified.replace(
-              utilsMatch[0],
-              `${coreImportStatement}
-${utilImportStatement}`
-            );
-            changes.push(
-              "Split pathkit imports into pathe core and pathe/utils"
-            );
-          } else if (utilImports.length > 0) {
-            modified = modified.replace(
-              pathkitImportRegex,
-              'from "pathe/utils"'
-            );
-            changes.push("Updated pathkit utils imports to pathe/utils");
-          } else {
-            modified = modified.replace(pathkitImportRegex, 'from "pathe"');
-            changes.push("Updated pathkit imports to pathe");
-          }
-        } else {
-          modified = modified.replace(pathkitImportRegex, 'from "pathe"');
-          changes.push("Updated pathkit imports to pathe");
-        }
-      }
-      const pathkitRequireRegex = /require\s*\(\s*["']@reliverse\/pathkit["']\s*\)/g;
-      if (pathkitRequireRegex.test(content)) {
-        modified = modified.replace(pathkitRequireRegex, 'require("pathe")');
-        changes.push("Updated pathkit require to pathe");
+        changes.push("Updated node:path require to @reliverse/pathkit");
       }
       if (changes.length > 0) {
         if (!dryRun) {
@@ -192,8 +103,8 @@ ${utilImportStatement}`
     }
   }
   await updatePackageJson(results, dryRun, {
-    remove: ["@reliverse/pathkit"],
-    add: { pathe: "^latest" }
+    remove: ["pathe"],
+    add: { "@reliverse/pathkit": "^latest" }
   });
   return results;
 }

package/bin/app/pub/cmd.js

@@ -1,6 +1,6 @@
 import { defineArgs, defineCommand } from "@reliverse/rempts";
 import { dlerPub } from "../build/impl.js";
-import { ensureDlerConfig } from "../../init/init.js";
+import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/config/init.js";
 export default defineCommand({
   meta: {
     name: "build",

package/bin/app/rempts/cmd/cmd.js

@@ -26,6 +26,13 @@ export default defineCommand({
     }
   }),
   async run({ args }) {
+    if (!args.init || args.init === "true" || args.init === "false") {
+      relinka(
+        "error",
+        "Please provide at least one command name to initialize"
+      );
+      return;
+    }
     let cmdNames = [];
     if (Array.isArray(args.init)) {
       cmdNames = args.init;
@@ -52,7 +59,7 @@ export default defineCommand({
       }
     }
     if (cmdNames.length === 0) {
-      relinka("error", "\u274C No command names provided");
+      relinka("error", "No command names provided");
       return;
     }
     let cmdsRoot = args.customCmdsRoot;
@@ -79,7 +86,7 @@ export default defineCommand({
       if (await fs.pathExists(filePath) && !args.overwrite) {
         relinka(
           "warn",
-          `\u274C Command "${cmdName}" already exists. Use --overwrite to overwrite.`
+          `Command "${cmdName}" already exists. Use --overwrite to overwrite.`
         );
         continue;
       }
@@ -124,7 +131,7 @@ async function handleDlerConfig() {
             }
           }
         } else {
-          relinka("warn", `\u274C ${scriptPath} doesn't use @reliverse/rempts`);
+          relinka("warn", `${scriptPath} doesn't use @reliverse/rempts`);
           cmdsRoot = "src/app";
         }
       } else {

package/bin/cli.js

@@ -5,12 +5,22 @@ import {
   defineArgs,
   selectPrompt,
   showUsage,
-  runCmd
+  runCmd as remptsRunCmd
 } from "@reliverse/rempts";
 import { promptAggCommand } from "./app/agg/run.js";
 import { getCmdBuild, getCmdPub } from "./app/cmds.js";
-import { showEndPrompt, showStartPrompt } from "./init/info.js";
+import {
+  showEndPrompt,
+  showStartPrompt
+} from "./libs/sdk/sdk-impl/config/info.js";
 const INTERACTIVE_CMDS = ["agg", "build", "pub"];
+async function runCmd(cmdPromise, args) {
+  const cmd = await cmdPromise;
+  if (!cmd || typeof cmd !== "object" || !cmd.meta || !cmd.run) {
+    throw new Error("Invalid command module: missing required properties");
+  }
+  return remptsRunCmd(cmd, args);
+}
 const main = defineCommand({
   meta: {
     name: "dler",
@@ -48,10 +58,10 @@ Available interactive commands: ${INTERACTIVE_CMDS.join(", ")}`
       await promptAggCommand();
     }
     if (cmdToRun === "build") {
-      await runCmd(await getCmdBuild(), [`--dev=${args.dev}`]);
+      await runCmd(getCmdBuild(), [`--dev=${args.dev}`]);
     }
     if (cmdToRun === "pub") {
-      await runCmd(await getCmdPub(), [`--dev=${args.dev}`]);
+      await runCmd(getCmdPub(), [`--dev=${args.dev}`]);
     }
     relinka("log", " ");
     await showEndPrompt();

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

@@ -13,8 +13,7 @@ import prettyMilliseconds from "pretty-ms";
 import { unifiedBuild } from "./bundlers/unified/build.js";
 import {
   getBunSourcemapOption,
-  getUnifiedSourcemapOption,
-  renameEntryFile
+  getUnifiedSourcemapOption
 } from "../utils/utils-build.js";
 import { removeLogInternalCalls } from "../utils/utils-clean.js";
 import {
@@ -37,7 +36,6 @@ import { getElapsedPerfTime } from "../utils/utils-perf.js";
 import { library_createPackageJSON } from "../utils/utils-pkg-json-libs.js";
 const BIN_DIR_NAME = "bin";
 const REPLACEMENT_MARKER = "// dler-replace-me";
-const FILES_TO_COPY_ROOT = ["README.md", "LICENSE"];
 const TYPES_REPLACEMENT_PATH = "src/types.ts";
 const ALIAS_PREFIX_TO_CONVERT = "~";
 export async function library_buildLibrary(options) {
@@ -168,6 +166,8 @@ async function library_buildJsrDist(options) {
   await createJsrJSON(
     outputDirRootResolved,
     true,
+    options.libsList,
+    options,
     libName,
     libConfig?.libDescription ?? ""
   );
@@ -374,7 +374,16 @@ async function library_bundleUsingJsrCopy(srcDir, destDir, libName) {
   );
   await fs.ensureDir(destDir);
   try {
-    await fs.copy(srcDir, destDir, { overwrite: true });
+    const files = await fs.readdir(srcDir, { withFileTypes: true });
+    for (const file of files) {
+      const srcPath = path.join(srcDir, file.name);
+      const destPath = path.join(destDir, file.name);
+      if (file.isDirectory()) {
+        await fs.copy(srcPath, destPath, { overwrite: true });
+      } else {
+        await fs.copy(srcPath, destPath, { overwrite: true });
+      }
+    }
     relinka(
       "success",
       `[JSR Copy:${libName}] Completed copying library source from ${srcDir} to ${destDir}`
@@ -558,7 +567,7 @@ async function library_performCommonBuildSteps(params) {
   const logPrefix = `[Common:${targetType}:${libName}]`;
   relinka(
     "verbose",
-    `${logPrefix} Performing common steps in ${outputDirRoot}`
+    `${logPrefix} Performing common steps in ${outputDirRoot}. Entry file: ${coreEntryFileName}. ${isJsr ? `JSR out files ext: ${distJsrOutFilesExt}` : `NPM out files ext: ${unifiedBundlerOutExt}`}`
   );
   await library_createPackageJSON(
     libName,
@@ -578,10 +587,17 @@ async function library_performCommonBuildSteps(params) {
       `${logPrefix} Deleted specific files from ${outDirBin}.`
     );
   }
-  await copyRootFile(outputDirRoot, FILES_TO_COPY_ROOT);
+  const filesToCopy = isJsr ? config.publishArtifacts?.["dist-libs"]?.[libName]?.jsr || config.publishArtifacts?.["dist-jsr"] || ["jsr.json"] : config.publishArtifacts?.["dist-libs"]?.[libName]?.npm || config.publishArtifacts?.["dist-npm"] || [];
+  const globalFiles = config.publishArtifacts?.global || [
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ];
+  const allFilesToCopy = [.../* @__PURE__ */ new Set([...globalFiles, ...filesToCopy])];
+  await copyRootFile(outputDirRoot, allFilesToCopy);
   relinka(
     "verbose",
-    `${logPrefix} Copied root files (${FILES_TO_COPY_ROOT.join(", ")}) to ${outputDirRoot}`
+    `${logPrefix} Copied root files (${allFilesToCopy.join(", ")}) to ${outputDirRoot}`
   );
   const stripSegments = libDirName ? [`libs/${libDirName}`] : [];
   relinka(
@@ -619,14 +635,6 @@ async function library_performCommonBuildSteps(params) {
       extTo: "ts"
     });
   }
-  relinka("verbose", `${logPrefix} Renaming entry file in ${outDirBin}.`);
-  await renameEntryFile(
-    isJsr,
-    outDirBin,
-    coreEntryFileName,
-    unifiedBundlerOutExt,
-    distJsrOutFilesExt
-  );
   relinka("verbose", `${logPrefix} Completed common build steps.`);
 }
 async function determineNpmSourceDirectory(libName, mainFile, coreEntrySrcDirResolved, libsList, distName) {
@@ -729,10 +737,6 @@ async function preBuildReplacements(config) {
   const { librarySrcDir, replacementFilePath, replacementMarker } = config;
   const replacedFiles = [];
   if (!await fs.pathExists(replacementFilePath)) {
-    relinka(
-      "warn",
-      `Replacement content file not found: ${replacementFilePath}. Skipping pre-build replacements.`
-    );
     return [];
   }
   if (!await fs.pathExists(librarySrcDir)) {

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

@@ -9,8 +9,7 @@ import prettyMilliseconds from "pretty-ms";
 import { unifiedBuild } from "./bundlers/unified/build.js";
 import {
   getBunSourcemapOption,
-  getUnifiedSourcemapOption,
-  renameEntryFile
+  getUnifiedSourcemapOption
 } from "../utils/utils-build.js";
 import { removeLogInternalCalls } from "../utils/utils-clean.js";
 import {
@@ -78,6 +77,11 @@ export async function regular_buildJsrDist(isDev, isJsr, coreIsCLI, coreEntrySrc
       outDirRoot,
       false,
       // isLib
+      {},
+      // libsList (empty for regular builds)
+      config,
+      void 0,
+      // libName (not needed for regular builds)
       config.coreDescription
     );
     const duration = getElapsedPerfTime(timer);
@@ -409,24 +413,20 @@ async function regular_performCommonBuildSteps({
     coreDescription,
     coreBuildOutDir
   );
-  await copyRootFile(outDirRoot, ["README.md", "LICENSE"]);
+  await copyRootFile(
+    outDirRoot,
+    config.publishArtifacts?.global || ["README.md", "LICENSE"]
+  );
   if (isJsr && coreIsCLI.enabled) {
-    await copyRootFile(outDirRoot, [
+    const jsrFiles = config.publishArtifacts?.["dist-jsr"] || [
       ".gitignore",
       ".config/rse.ts",
       ".config/rse.jsonc",
       "drizzle.config.ts",
       "schema.json"
-    ]);
+    ];
+    await copyRootFile(outDirRoot, jsrFiles);
   }
-  relinka("verbose", `Renaming entry file in ${outDirBin}.`);
-  await renameEntryFile(
-    isJsr,
-    outDirBin,
-    config.coreEntryFile,
-    unifiedBundlerOutExt,
-    config.distJsrOutFilesExt
-  );
 }
 async function regular_createTsconfig(outDirRoot) {
   const tsconfigPath = path.join(outDirRoot, "tsconfig.json");

package/bin/libs/sdk/sdk-impl/check/check-consts.d.ts

@@ -0,0 +1,29 @@
+export declare const ALLOWED_FILE_EXTENSIONS: {
+    readonly src: string[];
+    readonly "dist-npm": string[];
+    readonly "dist-jsr": string[];
+    readonly "dist-libs/npm": string[];
+    readonly "dist-libs/jsr": string[];
+};
+export declare const STRICT_FILE_EXTENSIONS: {
+    readonly src: string[];
+    readonly "dist-npm": string[];
+    readonly "dist-jsr": string[];
+    readonly "dist-libs/npm": string[];
+    readonly "dist-libs/jsr": string[];
+};
+export declare const ALLOWED_IMPORT_EXTENSIONS: {
+    readonly src: string[];
+    readonly "dist-npm": string[];
+    readonly "dist-jsr": string[];
+    readonly "dist-libs/npm": string[];
+    readonly "dist-libs/jsr": string[];
+};
+export declare const STRICT_IMPORT_EXTENSIONS: {
+    readonly src: string[];
+    readonly "dist-npm": string[];
+    readonly "dist-jsr": string[];
+    readonly "dist-libs/npm": string[];
+    readonly "dist-libs/jsr": string[];
+};
+export type AllowedFileExtensionsType = keyof typeof ALLOWED_FILE_EXTENSIONS;

package/bin/libs/sdk/sdk-impl/check/check-consts.js

@@ -0,0 +1,48 @@
+export const ALLOWED_FILE_EXTENSIONS = {
+  src: ["", ".ts", ".css", ".json"],
+  // ✅ .ts files allowed in src
+  "dist-npm": ["", ".js", ".css", ".json"],
+  // ❌ no .ts files in npm dist
+  "dist-jsr": ["", ".ts", ".css", ".json"],
+  // ✅ .ts files allowed in jsr dist
+  "dist-libs/npm": ["", ".js", ".css", ".json"],
+  // ❌ no .ts files in npm libs
+  "dist-libs/jsr": ["", ".ts", ".css", ".json"]
+  // ✅ .ts files allowed in jsr libs
+};
+export const STRICT_FILE_EXTENSIONS = {
+  src: [".ts", ".css", ".json"],
+  // ✅ .ts files required in src
+  "dist-npm": [".js", ".css", ".json"],
+  // ❌ no .ts files in npm dist
+  "dist-jsr": [".ts", ".css", ".json"],
+  // ✅ .ts files required in jsr dist
+  "dist-libs/npm": [".js", ".css", ".json"],
+  // ❌ no .ts files in npm libs
+  "dist-libs/jsr": [".ts", ".css", ".json"]
+  // ✅ .ts files required in jsr libs
+};
+export const ALLOWED_IMPORT_EXTENSIONS = {
+  src: ["", ".js", ".css", ".json"],
+  // ❌ no .ts imports (use .js)
+  "dist-npm": ["", ".js", ".css", ".json"],
+  // ❌ no .ts imports
+  "dist-jsr": ["", ".ts", ".css", ".json"],
+  // ✅ .ts imports allowed
+  "dist-libs/npm": ["", ".js", ".css", ".json"],
+  // ❌ no .ts imports
+  "dist-libs/jsr": ["", ".ts", ".css", ".json"]
+  // ✅ .ts imports allowed
+};
+export const STRICT_IMPORT_EXTENSIONS = {
+  src: [".js", ".css", ".json"],
+  // ❌ no .ts imports, no empty
+  "dist-npm": [".js", ".css", ".json"],
+  // ❌ no .ts imports
+  "dist-jsr": [".ts", ".css", ".json"],
+  // ✅ .ts imports required
+  "dist-libs/npm": [".js", ".css", ".json"],
+  // ❌ no .ts imports
+  "dist-libs/jsr": [".ts", ".css", ".json"]
+  // ✅ .ts imports required
+};

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

@@ -0,0 +1,2 @@
+import type { CheckResult } from "../../sdk-types.js";
+export declare function displayCheckResults(checkType: string, directory: string, result: CheckResult): void;