@quonfig/cli 0.0.22 → 0.0.24

package/dist/init/schema.js

@@ -298,8 +298,10 @@ export function storedConfigJsonSchema() {
                 type: 'string',
                 description: 'References a schema in schemas/ or schemas-protected/. The referenced file must exist.',
             },
-            accessLevel: { type: 'string' },
-            protection: { type: 'string' },
+            access: {
+                enum: ['support', 'standard', 'protected-env', 'protected-all-envs'],
+                description: 'Edit-access tier for this config. Defaults to "standard" when absent. See protecting-access.md.',
+            },
             tags: {
                 type: 'array',
                 items: { type: 'string' },

package/dist/migrate/push-to-cloud.js

@@ -3,7 +3,7 @@ import * as path from 'node:path';
 import { removeQfFromGitignore, writeImportState } from './import-state.js';
 import { writeMigrationReport } from './migration-report.js';
 import { detectDuplicateKeys } from './sources/launch/translate.js';
-import { cloneAndStackPush } from '../util/clone-and-stack-push.js';
+import { cloneAndStackPush, } from '../util/clone-and-stack-push.js';
 const writeQuonfigFiles = (dir, changes, source) => {
     const livePaths = new Map();
     for (const change of changes) {
@@ -59,8 +59,7 @@ const mergeEnvironmentsIntoQuonfigJson = (dir, sourceEnvs) => {
     }
     const existingEnvs = Array.isArray(existing.environments) ? existing.environments : [];
     const merged = [...new Set([...existingEnvs, ...sourceEnvs])].sort();
-    if (existingEnvs.length === merged.length &&
-        existingEnvs.every((e, i) => e === merged[i])) {
+    if (existingEnvs.length === merged.length && existingEnvs.every((e, i) => e === merged[i])) {
         return;
     }
     fs.writeFileSync(quonfigPath, JSON.stringify({ ...existing, environments: merged }, null, 2) + '\n', 'utf8');
@@ -80,9 +79,7 @@ export const pushMigrationToCloud = async (opts) => {
             droppedOverrides = opts.source.getDroppedOverrides?.() ?? null;
             skippedConfigs = opts.source.getSkippedConfigs?.() ?? null;
             duplicateResolutions =
-                resolutionEntries.length > 0
-                    ? { entries: resolutionEntries, total: resolutionEntries.length }
-                    : null;
+                resolutionEntries.length > 0 ? { entries: resolutionEntries, total: resolutionEntries.length } : null;
             const reportData = {
                 ...opts.reportData,
                 ...(droppedOverrides ? { droppedOverrides } : {}),

package/dist/migrate/sources/launch/zod-to-json-schema.js

@@ -2,27 +2,25 @@
 // Vendored verbatim from launch-migrator/src/zod-to-json-schema.ts to keep a
 // drop-in sync path. Do not reformat — edits here should be mirrored against
 // launch-migrator so the two converters stay behaviorally identical.
-import * as ts from "typescript";
-const JSON_SCHEMA_DRAFT_2020_12 = "https://json-schema.org/draft/2020-12/schema";
+import * as ts from 'typescript';
+const JSON_SCHEMA_DRAFT_2020_12 = 'https://json-schema.org/draft/2020-12/schema';
 function unwrapExpression(node) {
     let current = node;
-    while (ts.isParenthesizedExpression(current) ||
-        ts.isAsExpression(current) ||
-        ts.isTypeAssertionExpression(current)) {
+    while (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isTypeAssertionExpression(current)) {
         current = current.expression;
     }
     return current;
 }
 function parseRegexLiteral(text) {
-    if (!text.startsWith("/")) {
+    if (!text.startsWith('/')) {
         throw new Error(`Expected regex literal, got: ${text}`);
     }
     let lastSlash = -1;
     for (let index = text.length - 1; index > 0; index -= 1) {
-        if (text[index] !== "/")
+        if (text[index] !== '/')
             continue;
         let backslashCount = 0;
-        for (let i = index - 1; i >= 0 && text[i] === "\\"; i -= 1) {
+        for (let i = index - 1; i >= 0 && text[i] === '\\'; i -= 1) {
             backslashCount += 1;
         }
         if (backslashCount % 2 === 0) {
@@ -39,7 +37,7 @@ function parseRegexLiteral(text) {
     };
 }
 function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 function evaluateLiteralExpression(node) {
     const current = unwrapExpression(node);
@@ -57,13 +55,13 @@ function evaluateLiteralExpression(node) {
         return null;
     if (ts.isPrefixUnaryExpression(current) && current.operator === ts.SyntaxKind.MinusToken) {
         const operand = evaluateLiteralExpression(current.operand);
-        if (typeof operand === "number")
+        if (typeof operand === 'number')
             return -operand;
     }
     if (ts.isArrayLiteralExpression(current)) {
         return current.elements.map((element) => {
             if (ts.isSpreadElement(element)) {
-                throw new Error("Spread elements are not supported in literal arrays");
+                throw new Error('Spread elements are not supported in literal arrays');
             }
             return evaluateLiteralExpression(element);
         });
@@ -72,10 +70,10 @@ function evaluateLiteralExpression(node) {
         const result = {};
         for (const property of current.properties) {
             if (ts.isSpreadAssignment(property) || ts.isShorthandPropertyAssignment(property)) {
-                throw new Error("Spread and shorthand properties are not supported in literal objects");
+                throw new Error('Spread and shorthand properties are not supported in literal objects');
             }
             if (!ts.isPropertyAssignment(property)) {
-                throw new Error("Unsupported object literal property");
+                throw new Error('Unsupported object literal property');
             }
             const key = getPropertyName(property.name);
             result[key] = evaluateLiteralExpression(property.initializer);
@@ -88,14 +86,14 @@ function evaluateLiteralExpression(node) {
     if (ts.isBinaryExpression(current) && current.operatorToken.kind === ts.SyntaxKind.PlusToken) {
         const left = evaluateLiteralExpression(current.left);
         const right = evaluateLiteralExpression(current.right);
-        if (typeof left === "string" || typeof right === "string") {
+        if (typeof left === 'string' || typeof right === 'string') {
             return String(left) + String(right);
         }
-        if (typeof left === "number" && typeof right === "number") {
+        if (typeof left === 'number' && typeof right === 'number') {
             return left + right;
         }
     }
-    if (ts.isIdentifier(current) && current.text === "undefined") {
+    if (ts.isIdentifier(current) && current.text === 'undefined') {
         return undefined;
     }
     throw new Error(`Unsupported literal expression: ${current.getText()}`);
@@ -108,38 +106,38 @@ function getPropertyName(name) {
 }
 function schemaKind(schema) {
     if (schema === false)
-        return "never";
+        return 'never';
     if (!isPlainObject(schema))
-        return "unknown";
+        return 'unknown';
     if (Array.isArray(schema.anyOf))
-        return "union";
+        return 'union';
     if (schema.const !== undefined)
-        return "const";
+        return 'const';
     if (Array.isArray(schema.enum))
-        return "enum";
+        return 'enum';
     const type = schema.type;
-    if (typeof type === "string")
+    if (typeof type === 'string')
         return type;
-    return "unknown";
+    return 'unknown';
 }
 function ensureObjectSchema(schema) {
-    if (schema === false || !isPlainObject(schema) || schema.type !== "object") {
-        throw new Error("Expected object schema");
+    if (schema === false || !isPlainObject(schema) || schema.type !== 'object') {
+        throw new Error('Expected object schema');
     }
     return schema;
 }
 function makeNullable(schema) {
     if (!isPlainObject(schema)) {
-        return { anyOf: [schema, { type: "null" }] };
+        return { anyOf: [schema, { type: 'null' }] };
     }
     const existing = schema.type;
     if (Array.isArray(existing)) {
-        return existing.includes("null") ? schema : { ...schema, type: [...existing, "null"] };
+        return existing.includes('null') ? schema : { ...schema, type: [...existing, 'null'] };
     }
-    if (typeof existing === "string") {
-        return { ...schema, type: [existing, "null"] };
+    if (typeof existing === 'string') {
+        return { ...schema, type: [existing, 'null'] };
     }
-    return { anyOf: [schema, { type: "null" }] };
+    return { anyOf: [schema, { type: 'null' }] };
 }
 function withAnnotation(schema, key, value) {
     if (schema === false) {
@@ -153,24 +151,24 @@ function applyNumericConstraint(schema, kind, method, value) {
     if (schema === false)
         return schema;
     const next = { ...schema };
-    if (kind === "number" || kind === "integer") {
-        if (method === "min" || method === "length")
+    if (kind === 'number' || kind === 'integer') {
+        if (method === 'min' || method === 'length')
             next.minimum = value;
-        if (method === "max" || method === "length")
+        if (method === 'max' || method === 'length')
             next.maximum = value;
         return next;
     }
-    if (kind === "string") {
-        if (method === "min" || method === "length")
+    if (kind === 'string') {
+        if (method === 'min' || method === 'length')
             next.minLength = value;
-        if (method === "max" || method === "length")
+        if (method === 'max' || method === 'length')
             next.maxLength = value;
         return next;
     }
-    if (kind === "array") {
-        if (method === "min" || method === "length")
+    if (kind === 'array') {
+        if (method === 'min' || method === 'length')
             next.minItems = value;
-        if (method === "max" || method === "length")
+        if (method === 'max' || method === 'length')
             next.maxItems = value;
         return next;
     }
@@ -179,35 +177,35 @@ function applyNumericConstraint(schema, kind, method, value) {
 function applyMethod(receiver, method, args, ctx) {
     const kind = schemaKind(receiver.schema);
     switch (method) {
-        case "optional":
+        case 'optional':
             return { ...receiver, optional: true };
-        case "nullable":
+        case 'nullable':
             return { schema: makeNullable(receiver.schema), optional: receiver.optional };
-        case "default": {
+        case 'default': {
             if (args.length === 0)
-                throw new Error("default() requires an argument");
+                throw new Error('default() requires an argument');
             return {
-                schema: withAnnotation(receiver.schema, "default", evaluateLiteralExpression(args[0])),
+                schema: withAnnotation(receiver.schema, 'default', evaluateLiteralExpression(args[0])),
                 optional: true,
             };
         }
-        case "describe": {
+        case 'describe': {
             if (args.length === 0)
-                throw new Error("describe() requires an argument");
+                throw new Error('describe() requires an argument');
             return {
-                schema: withAnnotation(receiver.schema, "description", evaluateLiteralExpression(args[0])),
+                schema: withAnnotation(receiver.schema, 'description', evaluateLiteralExpression(args[0])),
                 optional: receiver.optional,
             };
         }
-        case "meta": {
+        case 'meta': {
             if (args.length === 0)
-                throw new Error("meta() requires an argument");
+                throw new Error('meta() requires an argument');
             const meta = evaluateLiteralExpression(args[0]);
             if (!isPlainObject(meta)) {
-                throw new Error("meta() expects an object literal");
+                throw new Error('meta() expects an object literal');
             }
             let schema = receiver.schema;
-            const supportedKeys = new Set(["description", "title"]);
+            const supportedKeys = new Set(['description', 'title']);
             for (const [key, value] of Object.entries(meta)) {
                 if (supportedKeys.has(key)) {
                     schema = withAnnotation(schema, key, value);
@@ -218,99 +216,99 @@ function applyMethod(receiver, method, args, ctx) {
             }
             return { schema, optional: receiver.optional };
         }
-        case "url":
-            if (kind !== "string") {
-                throw new Error("url() can only be applied to string schemas");
+        case 'url':
+            if (kind !== 'string') {
+                throw new Error('url() can only be applied to string schemas');
             }
             return {
-                schema: withAnnotation(receiver.schema, "format", "uri"),
+                schema: withAnnotation(receiver.schema, 'format', 'uri'),
                 optional: receiver.optional,
             };
-        case "email":
-            if (kind !== "string") {
-                throw new Error("email() can only be applied to string schemas");
+        case 'email':
+            if (kind !== 'string') {
+                throw new Error('email() can only be applied to string schemas');
             }
             return {
-                schema: withAnnotation(receiver.schema, "format", "email"),
+                schema: withAnnotation(receiver.schema, 'format', 'email'),
                 optional: receiver.optional,
             };
-        case "uuid":
-            if (kind !== "string") {
-                throw new Error("uuid() can only be applied to string schemas");
+        case 'uuid':
+            if (kind !== 'string') {
+                throw new Error('uuid() can only be applied to string schemas');
             }
             return {
-                schema: withAnnotation(receiver.schema, "format", "uuid"),
+                schema: withAnnotation(receiver.schema, 'format', 'uuid'),
                 optional: receiver.optional,
             };
-        case "datetime":
-            if (kind !== "string") {
-                throw new Error("datetime() can only be applied to string schemas");
+        case 'datetime':
+            if (kind !== 'string') {
+                throw new Error('datetime() can only be applied to string schemas');
             }
             return {
-                schema: withAnnotation(receiver.schema, "format", "date-time"),
+                schema: withAnnotation(receiver.schema, 'format', 'date-time'),
                 optional: receiver.optional,
             };
-        case "regex": {
-            if (kind !== "string") {
-                throw new Error("regex() can only be applied to string schemas");
+        case 'regex': {
+            if (kind !== 'string') {
+                throw new Error('regex() can only be applied to string schemas');
             }
             if (args.length === 0)
-                throw new Error("regex() requires an argument");
+                throw new Error('regex() requires an argument');
             const regex = evaluateLiteralExpression(args[0]);
-            if (!isPlainObject(regex) || typeof regex.pattern !== "string") {
-                throw new Error("regex() expects a regex literal");
+            if (!isPlainObject(regex) || typeof regex.pattern !== 'string') {
+                throw new Error('regex() expects a regex literal');
             }
-            if (typeof regex.flags === "string" && regex.flags.length > 0) {
+            if (typeof regex.flags === 'string' && regex.flags.length > 0) {
                 ctx.warnings.push(`Ignored regex flags "${regex.flags}"`);
             }
             return {
-                schema: withAnnotation(receiver.schema, "pattern", regex.pattern),
+                schema: withAnnotation(receiver.schema, 'pattern', regex.pattern),
                 optional: receiver.optional,
             };
         }
-        case "min":
+        case 'min':
             if (args.length === 0)
-                throw new Error("min() requires an argument");
+                throw new Error('min() requires an argument');
             return {
-                schema: applyNumericConstraint(receiver.schema, kind, "min", Number(evaluateLiteralExpression(args[0]))),
+                schema: applyNumericConstraint(receiver.schema, kind, 'min', Number(evaluateLiteralExpression(args[0]))),
                 optional: receiver.optional,
             };
-        case "max":
+        case 'max':
             if (args.length === 0)
-                throw new Error("max() requires an argument");
+                throw new Error('max() requires an argument');
             return {
-                schema: applyNumericConstraint(receiver.schema, kind, "max", Number(evaluateLiteralExpression(args[0]))),
+                schema: applyNumericConstraint(receiver.schema, kind, 'max', Number(evaluateLiteralExpression(args[0]))),
                 optional: receiver.optional,
             };
-        case "length":
+        case 'length':
             if (args.length === 0)
-                throw new Error("length() requires an argument");
+                throw new Error('length() requires an argument');
             return {
-                schema: applyNumericConstraint(receiver.schema, kind, "length", Number(evaluateLiteralExpression(args[0]))),
+                schema: applyNumericConstraint(receiver.schema, kind, 'length', Number(evaluateLiteralExpression(args[0]))),
                 optional: receiver.optional,
             };
-        case "int": {
-            if (kind !== "number" && kind !== "integer") {
-                throw new Error("int() can only be applied to number schemas");
+        case 'int': {
+            if (kind !== 'number' && kind !== 'integer') {
+                throw new Error('int() can only be applied to number schemas');
             }
-            const next = withAnnotation(receiver.schema, "type", "integer");
+            const next = withAnnotation(receiver.schema, 'type', 'integer');
             return { schema: next, optional: receiver.optional };
         }
-        case "positive": {
-            if (kind !== "number" && kind !== "integer") {
-                throw new Error("positive() can only be applied to number schemas");
+        case 'positive': {
+            if (kind !== 'number' && kind !== 'integer') {
+                throw new Error('positive() can only be applied to number schemas');
             }
-            const next = withAnnotation(receiver.schema, "exclusiveMinimum", 0);
+            const next = withAnnotation(receiver.schema, 'exclusiveMinimum', 0);
             return { schema: next, optional: receiver.optional };
         }
-        case "strict": {
+        case 'strict': {
             const objectSchema = ensureObjectSchema(receiver.schema);
             return {
                 schema: { ...objectSchema, additionalProperties: false },
                 optional: receiver.optional,
             };
         }
-        case "partial": {
+        case 'partial': {
             // .partial() makes all declared properties optional. For records
             // (open-shape objects) there's nothing to do.
             if (!isPlainObject(receiver.schema)) {
@@ -319,17 +317,17 @@ function applyMethod(receiver, method, args, ctx) {
             const { required: _required, ...rest } = receiver.schema;
             return { schema: rest, optional: receiver.optional };
         }
-        case "array":
+        case 'array':
             return {
                 schema: {
-                    type: "array",
+                    type: 'array',
                     items: receiver.schema,
                 },
                 optional: receiver.optional,
             };
-        case "or": {
+        case 'or': {
             if (args.length === 0)
-                throw new Error("or() requires an argument");
+                throw new Error('or() requires an argument');
             const other = convertExpression(args[0], ctx);
             return {
                 schema: { anyOf: [receiver.schema, other.schema] },
@@ -345,7 +343,7 @@ function convertObjectShape(objectLiteral, ctx) {
     const required = [];
     for (const property of objectLiteral.properties) {
         if (!ts.isPropertyAssignment(property)) {
-            throw new Error("Only property assignments are supported in z.object()");
+            throw new Error('Only property assignments are supported in z.object()');
         }
         const key = getPropertyName(property.name);
         const child = convertExpression(property.initializer, ctx);
@@ -355,20 +353,20 @@ function convertObjectShape(objectLiteral, ctx) {
         }
     }
     return {
-        type: "object",
+        type: 'object',
         properties,
         required,
     };
 }
 function convertBaseZodCall(method, args, ctx) {
     switch (method) {
-        case "string":
-            return { schema: { type: "string" }, optional: false };
-        case "number":
-            return { schema: { type: "number" }, optional: false };
-        case "boolean":
-            return { schema: { type: "boolean" }, optional: false };
-        case "enum": {
+        case 'string':
+            return { schema: { type: 'string' }, optional: false };
+        case 'number':
+            return { schema: { type: 'number' }, optional: false };
+        case 'boolean':
+            return { schema: { type: 'boolean' }, optional: false };
+        case 'enum': {
             // Canonical form: z.enum(["a", "b"]). Also tolerate the hand-written
             // typo z.enum("a", "b") by treating variadic args as an implicit array.
             let elements;
@@ -379,46 +377,46 @@ function convertBaseZodCall(method, args, ctx) {
                 elements = args;
             }
             else {
-                throw new Error("enum() expects at least one argument");
+                throw new Error('enum() expects at least one argument');
             }
             const values = elements.map((element) => evaluateLiteralExpression(element));
             return { schema: { enum: values }, optional: false };
         }
-        case "literal": {
+        case 'literal': {
             if (args.length !== 1)
-                throw new Error("literal() expects a single argument");
+                throw new Error('literal() expects a single argument');
             return { schema: { const: evaluateLiteralExpression(args[0]) }, optional: false };
         }
-        case "never":
+        case 'never':
             return { schema: false, optional: false };
-        case "array": {
+        case 'array': {
             if (args.length !== 1) {
-                throw new Error("array() expects a single argument");
+                throw new Error('array() expects a single argument');
             }
             const item = convertExpression(args[0], ctx);
             return {
                 schema: {
-                    type: "array",
+                    type: 'array',
                     items: item.schema,
                 },
                 optional: false,
             };
         }
-        case "object": {
+        case 'object': {
             if (args.length === 0) {
-                return { schema: { type: "object" }, optional: false };
+                return { schema: { type: 'object' }, optional: false };
             }
             if (args.length !== 1 || !ts.isObjectLiteralExpression(args[0])) {
-                throw new Error("object() expects a single object literal argument");
+                throw new Error('object() expects a single object literal argument');
             }
             return {
                 schema: convertObjectShape(args[0], ctx),
                 optional: false,
             };
         }
-        case "record": {
+        case 'record': {
             if (args.length === 0 || args.length > 2) {
-                throw new Error("record() expects one or two arguments");
+                throw new Error('record() expects one or two arguments');
             }
             let keySchema;
             let valueIndex = 0;
@@ -428,7 +426,7 @@ function convertBaseZodCall(method, args, ctx) {
             }
             const valueSchema = convertExpression(args[valueIndex], ctx);
             const schema = {
-                type: "object",
+                type: 'object',
                 additionalProperties: valueSchema.schema,
             };
             if (keySchema && isPlainObject(keySchema.schema) && Array.isArray(keySchema.schema.enum)) {
@@ -436,19 +434,19 @@ function convertBaseZodCall(method, args, ctx) {
             }
             return { schema, optional: false };
         }
-        case "union": {
+        case 'union': {
             if (args.length !== 1 || !ts.isArrayLiteralExpression(args[0])) {
-                throw new Error("union() expects a single array literal argument");
+                throw new Error('union() expects a single array literal argument');
             }
             const options = args[0].elements.map((element) => convertExpression(element, ctx).schema);
             return { schema: { anyOf: options }, optional: false };
         }
-        case "tuple": {
+        case 'tuple': {
             if (args.length !== 1 || !ts.isArrayLiteralExpression(args[0])) {
-                throw new Error("tuple() expects a single array literal argument");
+                throw new Error('tuple() expects a single array literal argument');
             }
             const items = args[0].elements.map((element) => convertExpression(element, ctx).schema);
-            const schema = { type: "array", minItems: items.length, maxItems: items.length };
+            const schema = { type: 'array', minItems: items.length, maxItems: items.length };
             if (items.length > 0) {
                 schema.prefixItems = items;
                 schema.items = false;
@@ -469,7 +467,7 @@ function convertCallExpression(call, ctx) {
         const receiverExpr = unwrapExpression(callee.expression);
         if (ts.isIdentifier(receiverExpr)) {
             const base = receiverExpr.text;
-            if (base === "z") {
+            if (base === 'z') {
                 return convertBaseZodCall(method, call.arguments, ctx);
             }
         }
@@ -477,8 +475,8 @@ function convertCallExpression(call, ctx) {
         return applyMethod(receiver, method, call.arguments, ctx);
     }
     if (ts.isIdentifier(callee)) {
-        if (callee.text === "z") {
-            throw new Error("Unexpected bare z() call");
+        if (callee.text === 'z') {
+            throw new Error('Unexpected bare z() call');
         }
     }
     throw new Error(`Unsupported call expression: ${call.getText()}`);
@@ -493,22 +491,22 @@ function convertExpression(node, ctx) {
     // schema, so the intent is always the method call).
     if (ts.isPropertyAccessExpression(expr)) {
         const method = expr.name.text;
-        if (method === "nullable" || method === "optional") {
+        if (method === 'nullable' || method === 'optional') {
             const receiver = convertExpression(expr.expression, ctx);
             return applyMethod(receiver, method, ts.factory.createNodeArray([]), ctx);
         }
     }
-    if (ts.isIdentifier(expr) && expr.text === "undefined") {
+    if (ts.isIdentifier(expr) && expr.text === 'undefined') {
         return { schema: false, optional: true };
     }
     throw new Error(`Unsupported Zod expression: ${expr.getText()}`);
 }
 export function zodToJsonSchema(source) {
-    const sourceFile = ts.createSourceFile("schema.ts", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const sourceFile = ts.createSourceFile('schema.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
     const ctx = { warnings: [] };
     const expressionStatement = sourceFile.statements.find(ts.isExpressionStatement);
     if (!expressionStatement) {
-        throw new Error("Expected a Zod expression");
+        throw new Error('Expected a Zod expression');
     }
     const result = convertExpression(expressionStatement.expression, ctx);
     if (result.schema !== false && isPlainObject(result.schema)) {

package/dist/migrate/sources/launch.js

@@ -1,5 +1,5 @@
 import { fetchAllChangeHistory, fetchEnvironments } from './launch/api.js';
-import { InvalidSourceConfigError, getOutputPath, isLegacyLogLevel, slugify, transformConfig } from './launch/translate.js';
+import { InvalidSourceConfigError, getOutputPath, isLegacyLogLevel, slugify, transformConfig, } from './launch/translate.js';
 const SOURCE_NAME = 'launch';
 const state = { apiKey: null, droppedOverrides: new Map(), envIdMap: null, skippedConfigs: [] };
 class MissingAuthError extends Error {