skedyul 1.5.0 → 1.5.2

package/dist/cli/index.js

@@ -364,6 +364,96 @@ var init_link = __esm({
   }
 });
 
+// src/config/transpileConfigMetadata.ts
+var transpileConfigMetadata_exports = {};
+__export(transpileConfigMetadata_exports, {
+  transpileConfigMetadata: () => transpileConfigMetadata
+});
+function prepareConfigSource(content) {
+  return content.replace(/import\s*\(\s*(['"])([^'"]+)\1\s*\)/g, "Promise.resolve(null)");
+}
+function isJsonImport(importPath) {
+  return importPath.endsWith(".json");
+}
+async function transpileConfigMetadata(configPath) {
+  const esbuild = await import("esbuild");
+  const absolutePath = path12.resolve(configPath);
+  const configDir = path12.dirname(absolutePath);
+  const configBasename = path12.basename(absolutePath);
+  const result = await esbuild.build({
+    absWorkingDir: configDir,
+    entryPoints: [absolutePath],
+    bundle: true,
+    format: "cjs",
+    platform: "node",
+    target: "node22",
+    write: false,
+    logLevel: "silent",
+    plugins: [
+      {
+        name: "prepare-config-entry",
+        setup(build) {
+          build.onLoad({ filter: new RegExp(`/${configBasename.replace(".", "\\.")}$`) }, () => ({
+            contents: prepareConfigSource(fs12.readFileSync(absolutePath, "utf-8")),
+            loader: "ts"
+          }));
+        }
+      },
+      {
+        name: "skedyul-shim",
+        setup(build) {
+          build.onResolve({ filter: /^skedyul$/ }, () => ({
+            path: "skedyul-shim",
+            namespace: SKEDYUL_SHIM_NAMESPACE
+          }));
+          build.onLoad({ filter: /.*/, namespace: SKEDYUL_SHIM_NAMESPACE }, () => ({
+            contents: [
+              "function defineConfig(config) { return config; }",
+              "module.exports = { defineConfig };"
+            ].join("\n"),
+            loader: "js"
+          }));
+        }
+      },
+      {
+        name: "metadata-stub-imports",
+        setup(build) {
+          build.onResolve({ filter: /^\.{1,2}\// }, (args2) => {
+            if (isJsonImport(args2.path)) {
+              return void 0;
+            }
+            return {
+              path: args2.path,
+              namespace: METADATA_STUB_NAMESPACE
+            };
+          });
+          build.onLoad({ filter: /.*/, namespace: METADATA_STUB_NAMESPACE }, () => ({
+            contents: "module.exports = {};\n",
+            loader: "js"
+          }));
+        }
+      }
+    ]
+  });
+  if (result.errors.length > 0) {
+    throw new Error(result.errors.map((error) => error.text).join("\n"));
+  }
+  if (result.outputFiles.length === 0) {
+    throw new Error("Config transpile produced no output");
+  }
+  return result.outputFiles[0].text;
+}
+var fs12, path12, SKEDYUL_SHIM_NAMESPACE, METADATA_STUB_NAMESPACE;
+var init_transpileConfigMetadata = __esm({
+  "src/config/transpileConfigMetadata.ts"() {
+    "use strict";
+    fs12 = __toESM(require("fs"));
+    path12 = __toESM(require("path"));
+    SKEDYUL_SHIM_NAMESPACE = "skedyul-shim";
+    METADATA_STUB_NAMESPACE = "metadata-stub";
+  }
+});
+
 // src/cli/commands/invoke.ts
 var z2 = __toESM(require("zod"));
 var fs5 = __toESM(require("fs"));
@@ -5871,165 +5961,10 @@ var fs14 = __toESM(require("fs"));
 var path14 = __toESM(require("path"));
 init_utils();
 
-// src/config/loader.ts
-var fs11 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
-var os2 = __toESM(require("os"));
-
-// src/config/transpileConfigMetadata.ts
-var esbuild = __toESM(require("esbuild"));
+// src/config/schema-loader.ts
 var fs10 = __toESM(require("fs"));
 var path10 = __toESM(require("path"));
-var SKEDYUL_SHIM_NAMESPACE = "skedyul-shim";
-var METADATA_STUB_NAMESPACE = "metadata-stub";
-function prepareConfigSource(content) {
-  return content.replace(/import\s*\(\s*(['"])([^'"]+)\1\s*\)/g, "Promise.resolve(null)");
-}
-function isJsonImport(importPath) {
-  return importPath.endsWith(".json");
-}
-async function transpileConfigMetadata(configPath) {
-  const absolutePath = path10.resolve(configPath);
-  const configDir = path10.dirname(absolutePath);
-  const configBasename = path10.basename(absolutePath);
-  const result = await esbuild.build({
-    absWorkingDir: configDir,
-    entryPoints: [absolutePath],
-    bundle: true,
-    format: "cjs",
-    platform: "node",
-    target: "node22",
-    write: false,
-    logLevel: "silent",
-    plugins: [
-      {
-        name: "prepare-config-entry",
-        setup(build2) {
-          build2.onLoad({ filter: new RegExp(`/${configBasename.replace(".", "\\.")}$`) }, () => ({
-            contents: prepareConfigSource(fs10.readFileSync(absolutePath, "utf-8")),
-            loader: "ts"
-          }));
-        }
-      },
-      {
-        name: "skedyul-shim",
-        setup(build2) {
-          build2.onResolve({ filter: /^skedyul$/ }, () => ({
-            path: "skedyul-shim",
-            namespace: SKEDYUL_SHIM_NAMESPACE
-          }));
-          build2.onLoad({ filter: /.*/, namespace: SKEDYUL_SHIM_NAMESPACE }, () => ({
-            contents: [
-              "function defineConfig(config) { return config; }",
-              "module.exports = { defineConfig };"
-            ].join("\n"),
-            loader: "js"
-          }));
-        }
-      },
-      {
-        name: "metadata-stub-imports",
-        setup(build2) {
-          build2.onResolve({ filter: /^\.{1,2}\// }, (args2) => {
-            if (isJsonImport(args2.path)) {
-              return void 0;
-            }
-            return {
-              path: args2.path,
-              namespace: METADATA_STUB_NAMESPACE
-            };
-          });
-          build2.onLoad({ filter: /.*/, namespace: METADATA_STUB_NAMESPACE }, () => ({
-            contents: "module.exports = {};\n",
-            loader: "js"
-          }));
-        }
-      }
-    ]
-  });
-  if (result.errors.length > 0) {
-    throw new Error(result.errors.map((error) => error.text).join("\n"));
-  }
-  if (result.outputFiles.length === 0) {
-    throw new Error("Config transpile produced no output");
-  }
-  return result.outputFiles[0].text;
-}
-
-// src/config/loader.ts
-var CONFIG_FILE_NAMES = [
-  "skedyul.config.ts",
-  "skedyul.config.js",
-  "skedyul.config.mjs",
-  "skedyul.config.cjs"
-];
-async function loadConfig(configPath) {
-  const absolutePath = path11.resolve(configPath);
-  if (!fs11.existsSync(absolutePath)) {
-    throw new Error(`Config file not found: ${absolutePath}`);
-  }
-  const isTypeScript = absolutePath.endsWith(".ts");
-  try {
-    if (isTypeScript) {
-      try {
-        const transpiled = await transpileConfigMetadata(absolutePath);
-        const tempFile = path11.join(os2.tmpdir(), `skedyul-config-${Date.now()}.cjs`);
-        fs11.writeFileSync(tempFile, transpiled);
-        try {
-          const module3 = require(tempFile);
-          const config2 = module3.default || module3;
-          if (!config2 || typeof config2 !== "object") {
-            throw new Error("Config file must export a configuration object");
-          }
-          if (!config2.name || typeof config2.name !== "string") {
-            throw new Error('Config must have a "name" property');
-          }
-          return config2;
-        } finally {
-          try {
-            fs11.unlinkSync(tempFile);
-          } catch {
-          }
-        }
-      } catch (transpileError) {
-        throw new Error(
-          `Cannot load TypeScript config metadata from ${absolutePath}: ${transpileError instanceof Error ? transpileError.message : String(transpileError)}`
-        );
-      }
-    }
-    const module2 = await import(
-      /* webpackIgnore: true */
-      absolutePath
-    );
-    const config = module2.default || module2;
-    if (!config || typeof config !== "object") {
-      throw new Error("Config file must export a configuration object");
-    }
-    if (!config.name || typeof config.name !== "string") {
-      throw new Error('Config must have a "name" property');
-    }
-    return config;
-  } catch (error) {
-    throw new Error(
-      `Failed to load config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-function validateConfig(config) {
-  const errors = [];
-  if (!config.name) {
-    errors.push("Missing required field: name");
-  }
-  if (config.computeLayer && !["serverless", "dedicated"].includes(config.computeLayer)) {
-    errors.push(`Invalid computeLayer: ${config.computeLayer}. Must be 'serverless' or 'dedicated'`);
-  }
-  return { valid: errors.length === 0, errors };
-}
-
-// src/config/schema-loader.ts
-var fs12 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
-var os3 = __toESM(require("os"));
+var os2 = __toESM(require("os"));
 
 // src/schemas/crm-schema.ts
 var import_v42 = require("zod/v4");
@@ -6181,39 +6116,39 @@ function validateCRMSchema(data) {
 
 // src/config/schema-loader.ts
 async function transpileSchemaTypeScript(filePath) {
-  const content = fs12.readFileSync(filePath, "utf-8");
+  const content = fs10.readFileSync(filePath, "utf-8");
   let transpiled = content.replace(/import\s+type\s+\{[^}]+\}\s+from\s+['"][^'"]+['"]\s*;?\n?/g, "").replace(/import\s+\{\s*defineSchema\s*\}\s+from\s+['"]skedyul['"]\s*;?\n?/g, "").replace(/:\s*CRMSchema/g, "").replace(/export\s+default\s+/, "module.exports = ").replace(/defineSchema\s*\(\s*\{/, "{").replace(/\}\s*\)\s*;?\s*$/, "}");
   return transpiled;
 }
 async function loadSchema(schemaPath, options = {}) {
   const { validate = true } = options;
-  const absolutePath = path12.resolve(schemaPath);
-  if (!fs12.existsSync(absolutePath)) {
+  const absolutePath = path10.resolve(schemaPath);
+  if (!fs10.existsSync(absolutePath)) {
     throw new Error(`Schema file not found: ${absolutePath}`);
   }
   const isTypeScript = absolutePath.endsWith(".ts");
   const isJson = absolutePath.endsWith(".json");
   if (!isTypeScript && !isJson) {
     throw new Error(
-      `Unsupported schema file format: ${path12.extname(absolutePath)}. Use .schema.ts or .schema.json`
+      `Unsupported schema file format: ${path10.extname(absolutePath)}. Use .schema.ts or .schema.json`
     );
   }
   let rawSchema;
   try {
     if (isJson) {
-      const content = fs12.readFileSync(absolutePath, "utf-8");
+      const content = fs10.readFileSync(absolutePath, "utf-8");
       rawSchema = JSON.parse(content);
     } else {
       const transpiled = await transpileSchemaTypeScript(absolutePath);
-      const tempDir = os3.tmpdir();
-      const tempFile = path12.join(tempDir, `skedyul-schema-${Date.now()}.cjs`);
-      fs12.writeFileSync(tempFile, transpiled);
+      const tempDir = os2.tmpdir();
+      const tempFile = path10.join(tempDir, `skedyul-schema-${Date.now()}.cjs`);
+      fs10.writeFileSync(tempFile, transpiled);
       try {
         const module2 = require(tempFile);
         rawSchema = module2.default || module2;
       } finally {
         try {
-          fs12.unlinkSync(tempFile);
+          fs10.unlinkSync(tempFile);
         } catch {
         }
       }
@@ -6258,10 +6193,10 @@ export default defineSchema(${jsonContent})
 `;
 }
 async function saveSchema(schema, outputPath, options = {}) {
-  const absolutePath = path12.resolve(outputPath);
+  const absolutePath = path10.resolve(outputPath);
   const isTypeScript = absolutePath.endsWith(".ts");
   const content = isTypeScript ? serializeSchemaToTypeScript(schema) : serializeSchemaToJson(schema, options);
-  fs12.writeFileSync(absolutePath, content, "utf-8");
+  fs10.writeFileSync(absolutePath, content, "utf-8");
 }
 var FIELD_TYPE_MAP = {
   string: "STRING",
@@ -6408,8 +6343,8 @@ function transformToBackendSchema(schema) {
 }
 
 // src/config/resolver.ts
-var fs13 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 async function loadConfigModule(absolutePath) {
   if (absolutePath.endsWith(".ts")) {
     const altPaths = [
@@ -6418,7 +6353,7 @@ async function loadConfigModule(absolutePath) {
       absolutePath.replace(".ts", ".js")
     ];
     for (const altPath of altPaths) {
-      if (fs13.existsSync(altPath)) {
+      if (fs11.existsSync(altPath)) {
         return await import(altPath);
       }
     }
@@ -6435,7 +6370,7 @@ async function loadConfigModule(absolutePath) {
   return await import(absolutePath);
 }
 async function loadAndResolveConfig(configPath) {
-  const absolutePath = path13.resolve(configPath);
+  const absolutePath = path11.resolve(configPath);
   const module2 = await loadConfigModule(absolutePath);
   const config = module2.default;
   if (!config || typeof config !== "object") {
@@ -6515,6 +6450,80 @@ function getAllEnvKeys(config) {
   };
 }
 
+// src/config/loader.ts
+var fs13 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
+var os3 = __toESM(require("os"));
+var CONFIG_FILE_NAMES = [
+  "skedyul.config.ts",
+  "skedyul.config.js",
+  "skedyul.config.mjs",
+  "skedyul.config.cjs"
+];
+async function loadConfig(configPath) {
+  const absolutePath = path13.resolve(configPath);
+  if (!fs13.existsSync(absolutePath)) {
+    throw new Error(`Config file not found: ${absolutePath}`);
+  }
+  const isTypeScript = absolutePath.endsWith(".ts");
+  try {
+    if (isTypeScript) {
+      try {
+        const { transpileConfigMetadata: transpileConfigMetadata2 } = await Promise.resolve().then(() => (init_transpileConfigMetadata(), transpileConfigMetadata_exports));
+        const transpiled = await transpileConfigMetadata2(absolutePath);
+        const tempFile = path13.join(os3.tmpdir(), `skedyul-config-${Date.now()}.cjs`);
+        fs13.writeFileSync(tempFile, transpiled);
+        try {
+          const module3 = require(tempFile);
+          const config2 = module3.default || module3;
+          if (!config2 || typeof config2 !== "object") {
+            throw new Error("Config file must export a configuration object");
+          }
+          if (!config2.name || typeof config2.name !== "string") {
+            throw new Error('Config must have a "name" property');
+          }
+          return config2;
+        } finally {
+          try {
+            fs13.unlinkSync(tempFile);
+          } catch {
+          }
+        }
+      } catch (transpileError) {
+        throw new Error(
+          `Cannot load TypeScript config metadata from ${absolutePath}: ${transpileError instanceof Error ? transpileError.message : String(transpileError)}`
+        );
+      }
+    }
+    const module2 = await import(
+      /* webpackIgnore: true */
+      absolutePath
+    );
+    const config = module2.default || module2;
+    if (!config || typeof config !== "object") {
+      throw new Error("Config file must export a configuration object");
+    }
+    if (!config.name || typeof config.name !== "string") {
+      throw new Error('Config must have a "name" property');
+    }
+    return config;
+  } catch (error) {
+    throw new Error(
+      `Failed to load config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function validateConfig(config) {
+  const errors = [];
+  if (!config.name) {
+    errors.push("Missing required field: name");
+  }
+  if (config.computeLayer && !["serverless", "dedicated"].includes(config.computeLayer)) {
+    errors.push(`Invalid computeLayer: ${config.computeLayer}. Must be 'serverless' or 'dedicated'`);
+  }
+  return { valid: errors.length === 0, errors };
+}
+
 // src/cli/commands/validate.ts
 function printHelp5() {
   console.log(`

package/dist/config/index.d.ts

@@ -12,7 +12,6 @@ export * from './types';
 export type { InstallConfig, ProvisionConfig, BuildConfig, CorsOptions, SkedyulConfig, SerializableSkedyulConfig, QueueScope, QueueConfig, SerializableQueueConfig, QueueRegistry, } from './app-config';
 export { defineConfig } from './app-config';
 export { defineModel, defineChannel, definePage, defineWorkflow, defineAgent, defineEnv, defineNavigation, } from './define';
-export { CONFIG_FILE_NAMES, loadConfig, validateConfig } from './loader';
 export { SCHEMA_FILE_EXTENSIONS, loadSchema, saveSchema, serializeSchemaToJson, serializeSchemaToTypeScript, transformToBackendSchema, transformFromBackendSchema, type LoadSchemaOptions, type LoadSchemaResult, type SerializeSchemaOptions, type BackendModelDefinition, type BackendFieldDefinition, type BackendRelationshipDefinition, type BackendDesiredSchema, } from './schema-loader';
 export { loadAndResolveConfig, serializeResolvedConfig, type ResolvedConfig } from './resolver';
 export { getAllEnvKeys, getRequiredInstallEnvKeys } from './utils';

package/dist/config/loader.js

@@ -0,0 +1,208 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/transpileConfigMetadata.ts
+var transpileConfigMetadata_exports = {};
+__export(transpileConfigMetadata_exports, {
+  transpileConfigMetadata: () => transpileConfigMetadata
+});
+function prepareConfigSource(content) {
+  return content.replace(/import\s*\(\s*(['"])([^'"]+)\1\s*\)/g, "Promise.resolve(null)");
+}
+function isJsonImport(importPath) {
+  return importPath.endsWith(".json");
+}
+async function transpileConfigMetadata(configPath) {
+  const esbuild = await import("esbuild");
+  const absolutePath = path.resolve(configPath);
+  const configDir = path.dirname(absolutePath);
+  const configBasename = path.basename(absolutePath);
+  const result = await esbuild.build({
+    absWorkingDir: configDir,
+    entryPoints: [absolutePath],
+    bundle: true,
+    format: "cjs",
+    platform: "node",
+    target: "node22",
+    write: false,
+    logLevel: "silent",
+    plugins: [
+      {
+        name: "prepare-config-entry",
+        setup(build) {
+          build.onLoad({ filter: new RegExp(`/${configBasename.replace(".", "\\.")}$`) }, () => ({
+            contents: prepareConfigSource(fs.readFileSync(absolutePath, "utf-8")),
+            loader: "ts"
+          }));
+        }
+      },
+      {
+        name: "skedyul-shim",
+        setup(build) {
+          build.onResolve({ filter: /^skedyul$/ }, () => ({
+            path: "skedyul-shim",
+            namespace: SKEDYUL_SHIM_NAMESPACE
+          }));
+          build.onLoad({ filter: /.*/, namespace: SKEDYUL_SHIM_NAMESPACE }, () => ({
+            contents: [
+              "function defineConfig(config) { return config; }",
+              "module.exports = { defineConfig };"
+            ].join("\n"),
+            loader: "js"
+          }));
+        }
+      },
+      {
+        name: "metadata-stub-imports",
+        setup(build) {
+          build.onResolve({ filter: /^\.{1,2}\// }, (args) => {
+            if (isJsonImport(args.path)) {
+              return void 0;
+            }
+            return {
+              path: args.path,
+              namespace: METADATA_STUB_NAMESPACE
+            };
+          });
+          build.onLoad({ filter: /.*/, namespace: METADATA_STUB_NAMESPACE }, () => ({
+            contents: "module.exports = {};\n",
+            loader: "js"
+          }));
+        }
+      }
+    ]
+  });
+  if (result.errors.length > 0) {
+    throw new Error(result.errors.map((error) => error.text).join("\n"));
+  }
+  if (result.outputFiles.length === 0) {
+    throw new Error("Config transpile produced no output");
+  }
+  return result.outputFiles[0].text;
+}
+var fs, path, SKEDYUL_SHIM_NAMESPACE, METADATA_STUB_NAMESPACE;
+var init_transpileConfigMetadata = __esm({
+  "src/config/transpileConfigMetadata.ts"() {
+    "use strict";
+    fs = __toESM(require("fs"));
+    path = __toESM(require("path"));
+    SKEDYUL_SHIM_NAMESPACE = "skedyul-shim";
+    METADATA_STUB_NAMESPACE = "metadata-stub";
+  }
+});
+
+// src/config/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  CONFIG_FILE_NAMES: () => CONFIG_FILE_NAMES,
+  loadConfig: () => loadConfig,
+  validateConfig: () => validateConfig
+});
+module.exports = __toCommonJS(loader_exports);
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var os = __toESM(require("os"));
+var CONFIG_FILE_NAMES = [
+  "skedyul.config.ts",
+  "skedyul.config.js",
+  "skedyul.config.mjs",
+  "skedyul.config.cjs"
+];
+async function loadConfig(configPath) {
+  const absolutePath = path2.resolve(configPath);
+  if (!fs2.existsSync(absolutePath)) {
+    throw new Error(`Config file not found: ${absolutePath}`);
+  }
+  const isTypeScript = absolutePath.endsWith(".ts");
+  try {
+    if (isTypeScript) {
+      try {
+        const { transpileConfigMetadata: transpileConfigMetadata2 } = await Promise.resolve().then(() => (init_transpileConfigMetadata(), transpileConfigMetadata_exports));
+        const transpiled = await transpileConfigMetadata2(absolutePath);
+        const tempFile = path2.join(os.tmpdir(), `skedyul-config-${Date.now()}.cjs`);
+        fs2.writeFileSync(tempFile, transpiled);
+        try {
+          const module3 = require(tempFile);
+          const config2 = module3.default || module3;
+          if (!config2 || typeof config2 !== "object") {
+            throw new Error("Config file must export a configuration object");
+          }
+          if (!config2.name || typeof config2.name !== "string") {
+            throw new Error('Config must have a "name" property');
+          }
+          return config2;
+        } finally {
+          try {
+            fs2.unlinkSync(tempFile);
+          } catch {
+          }
+        }
+      } catch (transpileError) {
+        throw new Error(
+          `Cannot load TypeScript config metadata from ${absolutePath}: ${transpileError instanceof Error ? transpileError.message : String(transpileError)}`
+        );
+      }
+    }
+    const module2 = await import(
+      /* webpackIgnore: true */
+      absolutePath
+    );
+    const config = module2.default || module2;
+    if (!config || typeof config !== "object") {
+      throw new Error("Config file must export a configuration object");
+    }
+    if (!config.name || typeof config.name !== "string") {
+      throw new Error('Config must have a "name" property');
+    }
+    return config;
+  } catch (error) {
+    throw new Error(
+      `Failed to load config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function validateConfig(config) {
+  const errors = [];
+  if (!config.name) {
+    errors.push("Missing required field: name");
+  }
+  if (config.computeLayer && !["serverless", "dedicated"].includes(config.computeLayer)) {
+    errors.push(`Invalid computeLayer: ${config.computeLayer}. Must be 'serverless' or 'dedicated'`);
+  }
+  return { valid: errors.length === 0, errors };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONFIG_FILE_NAMES,
+  loadConfig,
+  validateConfig
+});