flowdular 0.6.0 → 0.6.2

package/dist/distribution.js

@@ -1,8 +1,8 @@
 // src/module-artifact.ts
 import { parse as parseYaml2 } from "yaml";
 import { createHash } from "node:crypto";
-import { lstat, readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { lstat, readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
 
 // ../kernel/src/errors.ts
 var RegistryError = class extends Error {
@@ -1670,7 +1670,7 @@ var EXPRESSIONS = new Map(
 );
 
 // ../contracts/src/index.ts
-var PLATFORM_API_VERSION = "0.2.3";
+var PLATFORM_API_VERSION = "0.2.4";
 
 // ../kernel/src/module-compatibility.ts
 function satisfiesModuleVersion(version, range) {
@@ -1863,8 +1863,6 @@ function createModuleRegistry(input) {
 }
 
 // src/validation.ts
-import { readdir, readFile } from "node:fs/promises";
-import { basename, dirname, join, relative } from "node:path";
 import Ajv2020 from "ajv/dist/2020.js";
 import { parse as parseYaml } from "yaml";
 var ajv = new Ajv2020({ allErrors: true, strict: true });
@@ -1884,26 +1882,6 @@ var MONTH_NAMES = "jan feb mar apr may jun jul aug sep oct nov dec".split(
   " "
 );
 var WEEKDAY_NAMES = "sun mon tue wed thu fri sat".split(" ");
-var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
-  ".git",
-  ".flowdular",
-  ".vercel",
-  "node_modules",
-  "dist"
-]);
-async function findNamedFiles(root, name) {
-  const matches = [];
-  async function visit(directory) {
-    for (const entry of await readdir(directory, { withFileTypes: true })) {
-      if (SKIPPED_DIRECTORIES.has(entry.name)) continue;
-      const path = join(directory, entry.name);
-      if (entry.isDirectory()) await visit(path);
-      else if (entry.name === name) matches.push(path);
-    }
-  }
-  await visit(root);
-  return matches.sort();
-}
 
 // src/module-artifact.ts
 var MAX_ARTIFACT_BYTES = 48 * 1024 * 1024;
@@ -1948,7 +1926,7 @@ async function readModuleSource(root) {
   const files = [];
   let size = 0;
   async function visit(directory, prefix) {
-    for (const entry of await readdir2(directory, { withFileTypes: true })) {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
       const path = prefix + entry.name;
       if (!prefix && !ROOT_FILES.has(path) && !ROOTS.has(path)) continue;
       distributionAssert(
@@ -1962,20 +1940,20 @@ async function readModuleSource(root) {
           "MODULE_SOURCE_PATH",
           `Unexpected module directory: ${path}`
         );
-        await visit(join2(directory, entry.name), path + "/");
+        await visit(join(directory, entry.name), path + "/");
       } else {
         distributionAssert(
           entry.isFile() && safeSourcePath(path),
           "MODULE_SOURCE_PATH",
           `Unexpected module source: ${path}`
         );
-        const stat2 = await lstat(join2(directory, entry.name));
+        const stat2 = await lstat(join(directory, entry.name));
         distributionAssert(
           size + stat2.size <= MAX_SOURCE_BYTES && files.length < MAX_FILES,
           "MODULE_SOURCE_LIMIT",
           "Module source is too large."
         );
-        const bytes = await readFile2(join2(directory, entry.name));
+        const bytes = await readFile(join(directory, entry.name));
         size += bytes.length;
         files.push({
           path,
@@ -2122,28 +2100,18 @@ async function packModule(root, review) {
 }
 
 // src/module-catalog.ts
-import { readFile as readFile4, stat } from "node:fs/promises";
+import { readFile as readFile2, stat } from "node:fs/promises";
 
 // src/workspace.ts
-import { access, readFile as readFile3, realpath } from "node:fs/promises";
-import { dirname as dirname2, isAbsolute, relative as relative2, resolve } from "node:path";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
 function resolveInside(root, candidate) {
   const absolute = isAbsolute(candidate) ? resolve(candidate) : resolve(root, candidate);
-  const pathFromRoot = relative2(root, absolute);
+  const pathFromRoot = relative(root, absolute);
   if (pathFromRoot.startsWith("..") || isAbsolute(pathFromRoot)) {
     throw new Error(`Path escapes the workspace: ${candidate}`);
   }
   return absolute;
 }
-async function resolveExistingInside(root, candidate) {
-  const canonicalRoot = await realpath(root);
-  const canonicalCandidate = await realpath(resolveInside(root, candidate));
-  const pathFromRoot = relative2(canonicalRoot, canonicalCandidate);
-  if (pathFromRoot.startsWith("..") || isAbsolute(pathFromRoot)) {
-    throw new Error(`Path escapes the workspace through a link: ${candidate}`);
-  }
-  return canonicalCandidate;
-}
 
 // src/module-catalog.ts
 function platformAdmits(manifest) {
@@ -2161,7 +2129,7 @@ async function boundedRead(location, limit, fetcher = fetch) {
       "MODULE_DOWNLOAD_LIMIT",
       "Module metadata/artifact exceeds the size limit."
     );
-    const result = await readFile4(location);
+    const result = await readFile2(location);
     distributionAssert(
       result.length <= limit,
       "MODULE_DOWNLOAD_LIMIT",
@@ -2334,120 +2302,163 @@ function resolveModuleReleases(catalog, target, installed) {
 
 // src/module-install.ts
 import {
-  lstat as lstat3,
+  lstat as lstat2,
   mkdir,
-  readFile as readFile7,
-  readdir as readdir3,
+  readFile as readFile3,
+  readdir as readdir2,
   rename,
   rm,
   writeFile
 } from "node:fs/promises";
-import { dirname as dirname4, join as join5, relative as relative4 } from "node:path";
+import { dirname as dirname3, join as join3, relative as relative3 } from "node:path";
 
-// src/sdk.ts
+// ../kernel/src/module-manifests.ts
+import { lstatSync, readdirSync, readFileSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
-import { readFile as readFile5 } from "node:fs/promises";
-import { dirname as dirname3, join as join3 } from "node:path";
-var SDK_VERSION = "0.6.0";
-function npmPackage(specifier) {
-  return specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2 } from "node:path";
+var SDK_INDEX = "@flowdular/sdk/modules.json";
+var SDK_IMPORT = /^@flowdular\/sdk\/modules\/[a-z0-9-]+$/;
+var SDK_INDEX_LIMIT = 256;
+var UNRESOLVED = /* @__PURE__ */ new Set([
+  "MODULE_NOT_FOUND",
+  "ERR_PACKAGE_PATH_NOT_EXPORTED"
+]);
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".flowdular",
+  ".vercel",
+  "node_modules",
+  "dist"
+]);
+function errorCode(error) {
+  return error.code ?? "";
 }
-async function sdkModules(workspace) {
-  const require2 = createRequire(join3(workspace.root, "platform/package.json"));
+function insideRealPath(root, path, shown = path) {
+  const canonicalRoot = realpathSync(root);
+  const canonical = realpathSync(path);
+  const fromRoot = relative2(canonicalRoot, canonical);
+  if (fromRoot.startsWith("..") || isAbsolute2(fromRoot)) {
+    throw new Error(`Path escapes the workspace through a link: ${shown}`);
+  }
+  return canonical;
+}
+function manifestPackage(path) {
+  try {
+    const manifest = JSON.parse(readFileSync(path, "utf8"));
+    return typeof manifest.package === "string" ? manifest.package : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function moduleRootDirectories(workspaceRoot, roots) {
+  const configured = roots ?? ["modules"];
+  if (!Array.isArray(configured) || configured.length === 0 || configured.some(
+    (root) => typeof root !== "string" || !root || root.startsWith(".") || root.includes("\\") || root.split("/").some((part) => part === ".." || !part)
+  )) {
+    throw new Error(
+      "Invalid modules.roots. Use relative workspace directories."
+    );
+  }
+  return configured.map((root) => {
+    const path = resolve2(workspaceRoot, root);
+    if (!relative2(workspaceRoot, path)) {
+      throw new Error("The workspace root cannot be a module root.");
+    }
+    return path;
+  });
+}
+function sdkModuleManifests(workspaceRoot) {
+  const require2 = createRequire(join2(workspaceRoot, "platform/package.json"));
   let indexPath;
   try {
-    indexPath = require2.resolve("@flowdular/sdk/modules.json");
+    indexPath = require2.resolve(SDK_INDEX);
   } catch (error) {
-    if (["MODULE_NOT_FOUND", "ERR_PACKAGE_PATH_NOT_EXPORTED"].includes(
-      error.code ?? ""
-    ))
-      return /* @__PURE__ */ new Map();
+    if (UNRESOLVED.has(errorCode(error))) return /* @__PURE__ */ new Map();
     throw error;
   }
-  const index = JSON.parse(await readFile5(indexPath, "utf8"));
-  if (index.schemaVersion !== 1 || !Array.isArray(index.modules) || index.modules.length > 256)
+  const index = JSON.parse(readFileSync(indexPath, "utf8"));
+  if (index.schemaVersion !== 1 || !Array.isArray(index.modules) || index.modules.length > SDK_INDEX_LIMIT) {
     throw new Error("Invalid SDK module index.");
+  }
+  const sdkRoot = dirname2(indexPath);
   const result = /* @__PURE__ */ new Map();
   for (const entry of index.modules) {
-    if (!/^@flowdular\/sdk\/modules\/[a-z0-9-]+$/.test(entry.import))
+    if (typeof entry?.import !== "string" || !SDK_IMPORT.test(entry.import)) {
       throw new Error("Invalid SDK module entrypoint.");
-    const path = await resolveExistingInside(
-      dirname3(indexPath),
-      entry.manifest
-    );
+    }
+    if (typeof entry.manifest !== "string") {
+      throw new Error("Invalid SDK module manifest path.");
+    }
+    const lexical = resolve2(sdkRoot, entry.manifest);
+    const fromRoot = relative2(sdkRoot, lexical);
+    if (fromRoot.startsWith("..") || isAbsolute2(fromRoot)) {
+      throw new Error(`Path escapes the workspace: ${entry.manifest}`);
+    }
+    const path = insideRealPath(sdkRoot, lexical, entry.manifest);
     if (result.has(path)) throw new Error("Duplicate SDK module path.");
     result.set(path, entry.import);
   }
   return result;
 }
-
-// src/module-files.ts
-import { createRequire as createRequire2 } from "node:module";
-import { lstat as lstat2, readFile as readFile6 } from "node:fs/promises";
-import { join as join4, relative as relative3 } from "node:path";
-function moduleRoots(workspace) {
-  const roots = workspace.config.modules?.roots ?? ["modules"];
-  if (!Array.isArray(roots) || !roots.length || roots.some(
-    (root) => typeof root !== "string" || !root || root.startsWith(".") || root.includes("\\") || root.split("/").some((part) => part === ".." || !part)
-  ))
-    throw new Error(
-      "Invalid modules.roots. Use relative workspace directories."
-    );
-  return roots.map((root) => {
-    const path = resolveInside(workspace.root, root);
-    if (!relative3(workspace.root, path))
-      throw new Error("The workspace root cannot be a module root.");
-    return path;
-  });
-}
-async function findModuleFiles(workspace) {
+function findModuleManifests(workspaceRoot, roots) {
   const files = /* @__PURE__ */ new Set();
-  for (const root of moduleRoots(workspace)) {
+  for (const root of moduleRootDirectories(workspaceRoot, roots)) {
     try {
-      await lstat2(root);
+      lstatSync(root);
     } catch (error) {
-      if (error.code === "ENOENT") continue;
+      if (errorCode(error) === "ENOENT") continue;
       throw error;
     }
-    await resolveExistingInside(workspace.root, root);
-    for (const file of await findNamedFiles(root, "module.json")) {
-      if (relative3(root, file).split("/").length === 2) files.add(file);
+    insideRealPath(workspaceRoot, root);
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+      if (!entry.isDirectory() || SKIPPED_DIRECTORIES.has(entry.name)) continue;
+      const path = join2(root, entry.name, "module.json");
+      try {
+        if (!lstatSync(path).isDirectory()) files.add(path);
+      } catch (error) {
+        if (errorCode(error) !== "ENOENT") throw error;
+      }
     }
   }
   const packages = /* @__PURE__ */ new Set();
-  for (const file of files)
-    packages.add(
-      JSON.parse(await readFile6(file, "utf8")).package
-    );
-  for (const file of (await sdkModules(workspace)).keys()) {
-    const manifest = JSON.parse(await readFile6(file, "utf8"));
-    if (!packages.has(manifest.package)) files.add(file);
+  for (const file of files) {
+    const name = manifestPackage(file);
+    if (name) packages.add(name);
+  }
+  for (const file of sdkModuleManifests(workspaceRoot).keys()) {
+    const name = manifestPackage(file);
+    if (!name || !packages.has(name)) files.add(file);
   }
-  const platformPackage = join4(workspace.root, "platform/package.json");
+  const platformPackage = join2(workspaceRoot, "platform/package.json");
+  let dependencies = {};
   try {
-    const pkg = JSON.parse(await readFile6(platformPackage, "utf8"));
-    const require2 = createRequire2(platformPackage);
-    for (const name of Object.keys(pkg.dependencies ?? {}).sort()) {
-      if (!name.startsWith("@flowdular/module-") || packages.has(name))
-        continue;
-      let file;
-      try {
-        file = require2.resolve(name + "/module.json");
-      } catch (error) {
-        if (["MODULE_NOT_FOUND", "ERR_PACKAGE_PATH_NOT_EXPORTED"].includes(
-          error.code ?? ""
-        ))
-          continue;
-        throw error;
-      }
-      files.add(file);
-    }
+    dependencies = JSON.parse(readFileSync(platformPackage, "utf8")).dependencies ?? {};
   } catch (error) {
-    if (error.code !== "ENOENT") throw error;
+    if (errorCode(error) !== "ENOENT") throw error;
+  }
+  const require2 = createRequire(platformPackage);
+  for (const name of Object.keys(dependencies).sort()) {
+    if (!name.startsWith("@flowdular/module-") || packages.has(name)) continue;
+    try {
+      files.add(require2.resolve(`${name}/module.json`));
+    } catch (error) {
+      if (!UNRESOLVED.has(errorCode(error))) throw error;
+    }
   }
   return [...files].sort();
 }
 
+// src/module-files.ts
+function configuredRoots(workspace) {
+  return workspace.config.modules?.roots;
+}
+function moduleRoots(workspace) {
+  return [...moduleRootDirectories(workspace.root, configuredRoots(workspace))];
+}
+async function findModuleFiles(workspace) {
+  return [...findModuleManifests(workspace.root, configuredRoots(workspace))];
+}
+
 // src/module-validate.ts
 import { parse as parseYaml3 } from "yaml";
 
@@ -2682,7 +2693,7 @@ var SPELLINGS = new Map(
 var LOCK = "flowdular.modules.lock.json";
 async function exists(path) {
   try {
-    await lstat3(path);
+    await lstat2(path);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -2690,16 +2701,16 @@ async function exists(path) {
   }
 }
 async function safeParents(workspace, path) {
-  const parts = relative4(
+  const parts = relative3(
     workspace.root,
     resolveInside(workspace.root, path)
   ).split("/");
   let current = workspace.root;
   for (const part of parts) {
-    current = join5(current, part);
+    current = join3(current, part);
     if (!await exists(current)) break;
     distributionAssert(
-      !(await lstat3(current)).isSymbolicLink(),
+      !(await lstat2(current)).isSymbolicLink(),
       "MODULE_DESTINATION_LINK",
       "Module installation paths cannot contain links."
     );
@@ -2722,7 +2733,7 @@ function validateLock(workspace, value) {
     );
     const path = resolveInside(workspace.root, entry.directory);
     distributionAssert(
-      moduleRoots(workspace).some((root) => dirname4(path) === root) && !ids.has(entry.id) && !dirs.has(path.toLowerCase()),
+      moduleRoots(workspace).some((root) => dirname3(path) === root) && !ids.has(entry.id) && !dirs.has(path.toLowerCase()),
       "MODULE_LOCK_INVALID",
       "Duplicate or invalid installed module path."
     );
@@ -2739,17 +2750,17 @@ function validateLock(workspace, value) {
   return lock;
 }
 async function readLock(workspace) {
-  const path = join5(workspace.root, LOCK);
+  const path = join3(workspace.root, LOCK);
   await safeParents(workspace, path);
   if (!await exists(path))
     return { lock: { schemaVersion: 1, modules: [] }, raw: null };
-  const raw = await readFile7(path, "utf8");
+  const raw = await readFile3(path, "utf8");
   return { lock: validateLock(workspace, JSON.parse(raw)), raw };
 }
 async function directoryHashes(root) {
   const hashes = /* @__PURE__ */ Object.create(null);
   async function visit(directory, prefix) {
-    for (const entry of await readdir3(directory, { withFileTypes: true })) {
+    for (const entry of await readdir2(directory, { withFileTypes: true })) {
       if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git")
         continue;
       distributionAssert(
@@ -2759,14 +2770,14 @@ async function directoryHashes(root) {
       );
       const path = prefix + entry.name;
       if (entry.isDirectory())
-        await visit(join5(directory, entry.name), path + "/");
+        await visit(join3(directory, entry.name), path + "/");
       else {
         distributionAssert(
           entry.isFile(),
           "MODULE_LOCAL_CHANGES",
           "Installed module contains a special file."
         );
-        hashes[path] = hashBytes(await readFile7(join5(directory, entry.name)));
+        hashes[path] = hashBytes(await readFile3(join3(directory, entry.name)));
       }
     }
   }
@@ -2795,8 +2806,8 @@ async function validateInstalledModules(workspace) {
   for (const entry of lock.modules) {
     await assertUnmodified(workspace, entry);
     const manifest = JSON.parse(
-      await readFile7(
-        join5(workspace.root, entry.directory, "module.json"),
+      await readFile3(
+        join3(workspace.root, entry.directory, "module.json"),
         "utf8"
       )
     );
@@ -2809,14 +2820,23 @@ async function validateInstalledModules(workspace) {
   return lock;
 }
 
+// src/sdk.ts
+var SDK_VERSION = "0.6.2";
+function npmPackage(specifier) {
+  return specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+}
+async function sdkModules(workspace) {
+  return sdkModuleManifests(workspace.root);
+}
+
 // src/module-sync.ts
 import { spawnSync } from "node:child_process";
-import { access as access2, mkdir as mkdir2, readFile as readFile8, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname5, join as join7 } from "node:path";
+import { access, mkdir as mkdir2, readFile as readFile4, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname4, join as join5 } from "node:path";
 
 // src/format.ts
-import { createRequire as createRequire3 } from "node:module";
-import { join as join6 } from "node:path";
+import { createRequire as createRequire2 } from "node:module";
+import { join as join4 } from "node:path";
 import { pathToFileURL } from "node:url";
 var DEFAULT_OPTIONS = {
   useTabs: true,
@@ -2825,9 +2845,9 @@ var DEFAULT_OPTIONS = {
 };
 var TSRX_PLUGIN = "@tsrx/prettier-plugin";
 function resolveFrom(workspaceRoot, specifier) {
-  for (const base of [join6(workspaceRoot, "package.json"), import.meta.url]) {
+  for (const base of [join4(workspaceRoot, "package.json"), import.meta.url]) {
     try {
-      return createRequire3(base).resolve(specifier);
+      return createRequire2(base).resolve(specifier);
     } catch {
     }
   }
@@ -2853,7 +2873,7 @@ async function loadWorkspaceFormatter(workspaceRoot) {
     return null;
   }
   const configured = await prettier.resolveConfig(
-    join6(workspaceRoot, "package.json"),
+    join4(workspaceRoot, "package.json"),
     { editorconfig: false }
   );
   const { plugins: _ignored, ...options } = configured ?? DEFAULT_OPTIONS;
@@ -2942,7 +2962,7 @@ async function loadManifests(workspace) {
   const descriptors = /* @__PURE__ */ new Map();
   for (const file of files) {
     const manifest = JSON.parse(
-      await readFile8(file, "utf8")
+      await readFile4(file, "utf8")
     );
     if (!validators.module(manifest))
       throw new Error(`Invalid module manifest: ${file}`);
@@ -3047,7 +3067,7 @@ async function takeSnapshots(paths) {
   return Promise.all(
     paths.map(async (path) => {
       try {
-        return { path, content: await readFile8(path, "utf8") };
+        return { path, content: await readFile4(path, "utf8") };
       } catch (error) {
         if (error.code === "ENOENT") {
           return { path, content: void 0 };
@@ -3063,7 +3083,7 @@ async function restoreSnapshots(snapshots) {
       await rm2(snapshot.path, { force: true });
       continue;
     }
-    await mkdir2(dirname5(snapshot.path), { recursive: true });
+    await mkdir2(dirname4(snapshot.path), { recursive: true });
     await writeFile2(snapshot.path, snapshot.content);
   }
 }
@@ -3093,7 +3113,7 @@ async function syncPlatformModules(workspace, apply, enabledOverride) {
         content: generateClientComposition(modules, sdk, applicationPath)
       }
     ].map(async (target) => {
-      const absolute = join7(workspace.root, target.path);
+      const absolute = join5(workspace.root, target.path);
       return {
         ...target,
         content: formatter ? await formatter.format(absolute, target.content) : target.content
@@ -3102,15 +3122,15 @@ async function syncPlatformModules(workspace, apply, enabledOverride) {
   );
   const files = [];
   for (const target of targets) {
-    const absolute = join7(workspace.root, target.path);
+    const absolute = join5(workspace.root, target.path);
     let current = "";
     try {
-      current = await readFile8(absolute, "utf8");
+      current = await readFile4(absolute, "utf8");
     } catch {
     }
     const changed = current !== target.content;
     if (apply && changed) {
-      await mkdir2(dirname5(absolute), { recursive: true });
+      await mkdir2(dirname4(absolute), { recursive: true });
       await writeFile2(absolute, target.content);
     }
     files.push({ path: target.path, changed });
@@ -3134,9 +3154,9 @@ async function enableModule(workspace, id, apply) {
   const currentSet = new Set(current);
   const newlyEnabled = enabled.filter((moduleId) => !currentSet.has(moduleId));
   const configChanged = !equalIds(current, enabled);
-  const platformPackagePath = join7(workspace.root, "platform/package.json");
+  const platformPackagePath = join5(workspace.root, "platform/package.json");
   const platformPackage = JSON.parse(
-    await readFile8(platformPackagePath, "utf8")
+    await readFile4(platformPackagePath, "utf8")
   );
   const dependencies = platformPackage.dependencies ?? {};
   const platformDependenciesAdded = modules.map((module) => npmPackage(module.package)).filter((packageName) => !(packageName in dependencies)).sort((left, right) => left.localeCompare(right));
@@ -3153,8 +3173,8 @@ async function enableModule(workspace, id, apply) {
   }
   const linked = async (module) => {
     try {
-      await access2(
-        join7(
+      await access(
+        join5(
           workspace.root,
           "platform/node_modules",
           npmPackage(module.package)
@@ -3172,16 +3192,16 @@ async function enableModule(workspace, id, apply) {
   if (apply) {
     const snapshots = await takeSnapshots([
       workspace.configPath,
-      join7(workspace.root, "pnpm-lock.yaml"),
+      join5(workspace.root, "pnpm-lock.yaml"),
       platformPackagePath,
       ...Object.values(GENERATED_FILES).map(
-        (path) => join7(workspace.root, path)
+        (path) => join5(workspace.root, path)
       )
     ]);
     try {
       if (configChanged) {
         const config = JSON.parse(
-          await readFile8(workspace.configPath, "utf8")
+          await readFile4(workspace.configPath, "utf8")
         );
         const configModules = config.modules ?? {};
         configModules.enabled = enabled;