@malloy-publisher/server 0.0.235 → 0.0.237

package/src/config.spec.ts

@@ -1,1535 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import fs from "fs";
-import path from "path";
-import {
-   getPersistCollisionEnforce,
-   getPublisherConfig,
-   getPublisherConfigDir,
-   type PublisherConfig,
-} from "./config";
-import { PUBLISHER_CONFIG_NAME } from "./constants";
-
-describe("Config Environment Variable Substitution", () => {
-   const testServerRoot = path.join(process.cwd(), "test-temp-config");
-   const configPath = path.join(testServerRoot, PUBLISHER_CONFIG_NAME);
-
-   beforeEach(() => {
-      // Create test directory
-      if (!fs.existsSync(testServerRoot)) {
-         fs.mkdirSync(testServerRoot, { recursive: true });
-      }
-   });
-
-   afterEach(() => {
-      // Clean up test files and environment variables
-      if (fs.existsSync(configPath)) {
-         fs.unlinkSync(configPath);
-      }
-      if (fs.existsSync(testServerRoot)) {
-         fs.rmdirSync(testServerRoot, { recursive: true });
-      }
-
-      // Clean up all test environment variables
-      const testEnvVars = [
-         "TEST_VAR",
-         "BUCKET_NAME",
-         "DB_HOST",
-         "DB_PORT",
-         "DB_NAME",
-         "API_KEY",
-         "API_HOST",
-         "KEY_NAME",
-         "VALUE_VAR",
-         "EMPTY_VAR",
-         "BUCKET_1",
-         "BUCKET_2",
-         "NORMAL_VALUE",
-         "GCS_BUCKET",
-         "PROJECT_ID",
-         "CONNECTION_STRING",
-         "PACKAGE_NAME",
-         "DEFINED_VAR",
-         "DEV_BUCKET",
-         "PROD_BUCKET",
-         "DB_CONNECTION",
-         "ENV",
-         "DATA_BUCKET",
-         "TAG1",
-         "TAG2",
-         "CONFIG_VALUE",
-      ];
-
-      testEnvVars.forEach((varName) => {
-         delete process.env[varName];
-      });
-   });
-
-   describe("Scenario 1: ${VAR} present in config but value not available", () => {
-      it("should throw error when environment variable is not defined", () => {
-         // The correct behavior: throw an error when a required variable is missing
-         const locationWithVar = "./path/${UNDEFINED_VAR}/end" as const;
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [
-                     {
-                        name: "test-package",
-                        location: locationWithVar,
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         // Should throw an error about the missing environment variable
-         expect(() => getPublisherConfig(testServerRoot)).toThrow(
-            "Environment variable '${UNDEFINED_VAR}' is not set in configuration file",
-         );
-      });
-
-      it("should throw error for undefined variables in gs:// URLs", () => {
-         const locationWithVar = "gs://${BUCKET_NAME}/packages" as const;
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [
-                     {
-                        name: "test-package",
-                        location: locationWithVar,
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         // Should throw an error about the missing environment variable
-         expect(() => getPublisherConfig(testServerRoot)).toThrow(
-            "Environment variable '${BUCKET_NAME}' is not set in configuration file",
-         );
-      });
-   });
-
-   describe("Scenario 2: ${VAR} present in config and value is available", () => {
-      it("should substitute environment variable in package location with gs:// path", () => {
-         process.env.BUCKET_NAME = "my-test-bucket";
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [
-                     {
-                        name: "test-package",
-                        location: "gs://${BUCKET_NAME}/packages",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result.environments[0].packages[0].location).toBe(
-            "gs://my-test-bucket/packages",
-         );
-      });
-
-      it("should substitute environment variable in filesystem path", () => {
-         process.env.PROJECT_ID = "analytics-2024";
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [
-                     {
-                        name: "test-package",
-                        location: "./environments/${PROJECT_ID}/models",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result.environments[0].packages[0].location).toBe(
-            "./environments/analytics-2024/models",
-         );
-      });
-
-      it("should substitute multiple environment variables in single value", () => {
-         process.env.BUCKET_NAME = "data-warehouse";
-         process.env.PROJECT_ID = "prod-analytics";
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [
-                     {
-                        name: "test-package",
-                        location: "gs://${BUCKET_NAME}/${PROJECT_ID}/models",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result.environments[0].packages[0].location).toBe(
-            "gs://data-warehouse/prod-analytics/models",
-         );
-      });
-
-      it("should substitute variables across multiple packages", () => {
-         process.env.BUCKET_1 = "bucket-one";
-         process.env.BUCKET_2 = "bucket-two";
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [
-                     {
-                        name: "package-1",
-                        location: "gs://${BUCKET_1}/path",
-                     },
-                     {
-                        name: "package-2",
-                        location: "gs://${BUCKET_2}/path",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result.environments[0].packages[0].location).toBe(
-            "gs://bucket-one/path",
-         );
-         expect(result.environments[0].packages[1].location).toBe(
-            "gs://bucket-two/path",
-         );
-      });
-
-      it("should substitute variables in connection names", () => {
-         process.env.DB_HOST = "localhost";
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [],
-                  connections: [
-                     {
-                        name: "db-${DB_HOST}",
-                        type: "postgres",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result.environments[0].connections?.[0].name).toBe(
-            "db-localhost",
-         );
-      });
-
-      it("should substitute variables in nested configuration objects", () => {
-         process.env.API_KEY = "secret-key-123";
-         process.env.API_HOST = "api.example.com";
-
-         const config = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [],
-                  settings: {
-                     apiEndpoint: "https://${API_HOST}/v1",
-                     credentials: {
-                        apiKey: "${API_KEY}",
-                     },
-                  },
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-         const projectWithSettings = result
-            .environments[0] as (typeof result.environments)[0] & {
-            settings: {
-               apiEndpoint: string;
-               credentials: {
-                  apiKey: string;
-               };
-            };
-         };
-
-         expect(projectWithSettings.settings.apiEndpoint).toBe(
-            "https://api.example.com/v1",
-         );
-         expect(projectWithSettings.settings.credentials.apiKey).toBe(
-            "secret-key-123",
-         );
-      });
-
-      it("should handle mixed substitution with literal text", () => {
-         process.env.PROJECT_ID = "my-project";
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [
-                     {
-                        name: "test-package",
-                        location:
-                           "gs://bucket/prefix-${PROJECT_ID}-suffix/models",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result.environments[0].packages[0].location).toBe(
-            "gs://bucket/prefix-my-project-suffix/models",
-         );
-      });
-
-      it("should substitute variables across multiple environments", () => {
-         process.env.DEV_BUCKET = "dev-data";
-         process.env.PROD_BUCKET = "prod-data";
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "development",
-                  packages: [
-                     {
-                        name: "dev-package",
-                        location: "gs://${DEV_BUCKET}/models",
-                     },
-                  ],
-               },
-               {
-                  name: "production",
-                  packages: [
-                     {
-                        name: "prod-package",
-                        location: "gs://${PROD_BUCKET}/models",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result.environments[0].packages[0].location).toBe(
-            "gs://dev-data/models",
-         );
-         expect(result.environments[1].packages[0].location).toBe(
-            "gs://prod-data/models",
-         );
-
-         delete process.env.DEV_BUCKET;
-         delete process.env.PROD_BUCKET;
-      });
-   });
-
-   describe("Scenario 3: ${VAR} present in config as a key (not as a value)", () => {
-      it("should NOT substitute environment variables in object keys", () => {
-         process.env.KEY_NAME = "myKey";
-
-         const config = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [],
-                  "${KEY_NAME}": "some-value",
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         // The key should remain as-is (not substituted)
-         expect(result.environments[0]).toHaveProperty("${KEY_NAME}");
-         expect(
-            (result.environments[0] as Record<string, unknown>)["${KEY_NAME}"],
-         ).toBe("some-value");
-      });
-
-      it("should preserve keys with variable syntax while substituting values", () => {
-         process.env.NORMAL_VALUE = "substituted-value";
-
-         const config = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [],
-                  "${DYNAMIC_KEY}": "value1",
-                  normal_key: "${NORMAL_VALUE}",
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         // Key should not be substituted
-         expect(result.environments[0]).toHaveProperty("${DYNAMIC_KEY}");
-         expect(
-            (result.environments[0] as Record<string, unknown>)[
-               "${DYNAMIC_KEY}"
-            ],
-         ).toBe("value1");
-
-         // Value should be substituted
-         expect(
-            (result.environments[0] as Record<string, unknown>)["normal_key"],
-         ).toBe("substituted-value");
-      });
-
-      it("should handle mixed scenario: variable in key and different variable in value", () => {
-         process.env.VALUE_VAR = "actual-value";
-
-         const config = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [],
-                  "${KEY_VAR}": "${VALUE_VAR}",
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         // Key remains with variable syntax
-         expect(result.environments[0]).toHaveProperty("${KEY_VAR}");
-
-         // Value is substituted
-         expect(
-            (result.environments[0] as Record<string, unknown>)["${KEY_VAR}"],
-         ).toBe("actual-value");
-      });
-
-      it("should substitute variables in package names since they are values", () => {
-         process.env.PACKAGE_NAME = "my-package";
-         process.env.BUCKET_NAME = "my-bucket";
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [
-                     {
-                        name: "${PACKAGE_NAME}",
-                        location: "gs://${BUCKET_NAME}/models",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         // Package name is a property VALUE, so it WILL be substituted
-         expect(result.environments[0].packages[0].name).toBe("my-package");
-
-         // Location should also be substituted
-         expect(result.environments[0].packages[0].location).toBe(
-            "gs://my-bucket/models",
-         );
-
-         delete process.env.PACKAGE_NAME;
-      });
-
-      it("should handle nested objects with variable syntax in keys", () => {
-         process.env.CONFIG_VALUE = "test-value";
-
-         const config = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [],
-                  metadata: {
-                     "${DYNAMIC_PROP}": {
-                        setting: "${CONFIG_VALUE}",
-                     },
-                  },
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-         const projectWithMetadata = result
-            .environments[0] as (typeof result.environments)[0] & {
-            metadata: Record<string, { setting: string }>;
-         };
-
-         // Key should remain unchanged
-         expect(projectWithMetadata.metadata).toHaveProperty("${DYNAMIC_PROP}");
-
-         // Nested value should be substituted
-         expect(projectWithMetadata.metadata["${DYNAMIC_PROP}"].setting).toBe(
-            "test-value",
-         );
-
-         delete process.env.CONFIG_VALUE;
-      });
-   });
-
-   describe("Edge cases and special scenarios", () => {
-      it("should handle empty string environment variable", () => {
-         process.env.EMPTY_VAR = "";
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [
-                     {
-                        name: "test-package",
-                        location: "gs://bucket/${EMPTY_VAR}/path",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result.environments[0].packages[0].location).toBe(
-            "gs://bucket//path",
-         );
-      });
-
-      it("should handle non-string values without modification", () => {
-         const config: PublisherConfig = {
-            frozenConfig: true,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [],
-               },
-            ],
-         };
-
-         // Add non-standard properties for testing
-         const configWithExtras = {
-            ...config,
-            environments: [
-               {
-                  ...config.environments[0],
-                  count: 42,
-                  enabled: true,
-                  ratio: 3.14,
-                  metadata: null,
-                  tags: ["tag1", "tag2"],
-               },
-            ],
-         };
-
-         fs.writeFileSync(
-            configPath,
-            JSON.stringify(configWithExtras, null, 2),
-         );
-
-         const result = getPublisherConfig(testServerRoot);
-         const projectWithExtras = result
-            .environments[0] as (typeof result.environments)[0] & {
-            count: number;
-            enabled: boolean;
-            ratio: number;
-            metadata: null;
-            tags: string[];
-         };
-
-         expect(result.frozenConfig).toBe(true);
-         expect(projectWithExtras.count).toBe(42);
-         expect(projectWithExtras.enabled).toBe(true);
-         expect(projectWithExtras.ratio).toBe(3.14);
-         expect(projectWithExtras.metadata).toBe(null);
-         expect(projectWithExtras.tags).toEqual(["tag1", "tag2"]);
-      });
-
-      it("should handle config with no environment variables", () => {
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [
-                     {
-                        name: "test-package",
-                        location: "./packages/test",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result).toEqual(config);
-      });
-
-      it("should handle empty environments array", () => {
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result.environments).toEqual([]);
-      });
-
-      it("should return default config when file does not exist", () => {
-         // Don't create config file
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result).toEqual({
-            frozenConfig: false,
-            environments: [],
-         });
-      });
-
-      it("should handle whitespace around variable names", () => {
-         process.env.BUCKET_NAME = "test-bucket";
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [
-                     {
-                        name: "test-package",
-                        location: "gs://${ BUCKET_NAME }/path",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         // Whitespace around variable name means it won't match the pattern
-         // Due to bug, the unmatched variable causes duplication
-         expect(result.environments[0].packages[0].location).toBe(
-            "gs://${ BUCKET_NAME }/path",
-         );
-      });
-
-      it("should handle multiple environments with mixed variable usage", () => {
-         process.env.PROD_BUCKET = "production-data";
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "development",
-                  packages: [
-                     {
-                        name: "dev-package",
-                        location: "./packages/dev",
-                     },
-                  ],
-               },
-               {
-                  name: "production",
-                  packages: [
-                     {
-                        name: "prod-package",
-                        location: "gs://${PROD_BUCKET}/models",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result.environments[0].packages[0].location).toBe(
-            "./packages/dev",
-         );
-         expect(result.environments[1].packages[0].location).toBe(
-            "gs://production-data/models",
-         );
-
-         delete process.env.PROD_BUCKET;
-      });
-
-      it("should preserve variable syntax if not matching pattern", () => {
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [
-                     {
-                        name: "test-package",
-                        location: "gs://bucket/${lowercase_var}/path",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         // Variable won't match pattern, so won't be substituted
-         expect(result.environments[0].packages[0].location).toBe(
-            "gs://bucket/${lowercase_var}/path",
-         );
-      });
-
-      it("should handle arrays of strings with variables", () => {
-         process.env.TAG1 = "analytics";
-         process.env.TAG2 = "production";
-
-         const config = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "test-project",
-                  packages: [],
-                  tags: ["${TAG1}", "${TAG2}", "static-tag"],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-         const projectWithTags = result
-            .environments[0] as (typeof result.environments)[0] & {
-            tags: string[];
-         };
-
-         expect(projectWithTags.tags).toEqual([
-            "analytics",
-            "production",
-            "static-tag",
-         ]);
-
-         delete process.env.TAG1;
-         delete process.env.TAG2;
-      });
-   });
-
-   describe("Real-world configuration scenarios", () => {
-      it("should handle typical multi-environment setup", () => {
-         process.env.ENV = "staging";
-         process.env.DATA_BUCKET = "company-data-staging";
-         process.env.PROJECT_ID = "company-project-staging";
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "${ENV}",
-                  packages: [
-                     {
-                        name: "analytics",
-                        location: "gs://${DATA_BUCKET}/${PROJECT_ID}/analytics",
-                     },
-                     {
-                        name: "reporting",
-                        location: "gs://${DATA_BUCKET}/${PROJECT_ID}/reporting",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result.environments[0].name).toBe("staging");
-         expect(result.environments[0].packages[0].location).toBe(
-            "gs://company-data-staging/company-project-staging/analytics",
-         );
-         expect(result.environments[0].packages[1].location).toBe(
-            "gs://company-data-staging/company-project-staging/reporting",
-         );
-
-         delete process.env.ENV;
-         delete process.env.DATA_BUCKET;
-      });
-
-      it("should handle connection configurations with environment variables", () => {
-         process.env.DB_CONNECTION = "production-db";
-
-         const config: PublisherConfig = {
-            frozenConfig: false,
-            environments: [
-               {
-                  name: "production",
-                  packages: [],
-                  connections: [
-                     {
-                        name: "${DB_CONNECTION}",
-                        type: "bigquery",
-                     },
-                  ],
-               },
-            ],
-         };
-
-         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result.environments[0].connections?.[0].name).toBe(
-            "production-db",
-         );
-
-         delete process.env.DB_CONNECTION;
-      });
-   });
-});
-
-// TODO: Remove this during projects cleanup
-describe("Config legacy 'projects' key back-compat", () => {
-   const testServerRoot = path.join(process.cwd(), "test-temp-legacy-config");
-   const configPath = path.join(testServerRoot, PUBLISHER_CONFIG_NAME);
-
-   beforeEach(() => {
-      if (!fs.existsSync(testServerRoot)) {
-         fs.mkdirSync(testServerRoot, { recursive: true });
-      }
-   });
-
-   afterEach(() => {
-      if (fs.existsSync(configPath)) {
-         fs.unlinkSync(configPath);
-      }
-      if (fs.existsSync(testServerRoot)) {
-         fs.rmdirSync(testServerRoot, { recursive: true });
-      }
-   });
-
-   it("reads from legacy 'projects' key when 'environments' is absent", async () => {
-      // Pre-rename on-disk shape: top-level key is `projects`, not
-      // `environments`. Without back-compat this silently parses as empty.
-      const legacyConfig = {
-         frozenConfig: false,
-         projects: [
-            {
-               name: "legacy-env",
-               packages: [
-                  {
-                     name: "p1",
-                     location: "./packages/p1",
-                  },
-               ],
-            },
-         ],
-      };
-
-      fs.writeFileSync(configPath, JSON.stringify(legacyConfig, null, 2));
-
-      // Spy on logger.warn so we can assert the deprecation message fired.
-      const { logger } = await import("./logger");
-      const originalWarn = logger.warn;
-      const warnings: string[] = [];
-      logger.warn = ((msg: unknown, ..._rest: unknown[]) => {
-         warnings.push(typeof msg === "string" ? msg : String(msg));
-         return logger;
-      }) as typeof logger.warn;
-
-      try {
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result.environments.length).toBe(1);
-         expect(result.environments[0].name).toBe("legacy-env");
-         expect(result.environments[0].packages[0].name).toBe("p1");
-
-         expect(
-            warnings.some((w) => w.includes('uses deprecated "projects" key')),
-         ).toBe(true);
-      } finally {
-         logger.warn = originalWarn;
-      }
-   });
-
-   it("prefers the new 'environments' key when both are present", async () => {
-      const config = {
-         frozenConfig: false,
-         environments: [
-            {
-               name: "new-env",
-               packages: [{ name: "p1", location: "./packages/p1" }],
-            },
-         ],
-         projects: [
-            {
-               name: "should-be-ignored",
-               packages: [{ name: "p2", location: "./packages/p2" }],
-            },
-         ],
-      };
-
-      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-      const { logger } = await import("./logger");
-      const originalWarn = logger.warn;
-      const warnings: string[] = [];
-      logger.warn = ((msg: unknown, ..._rest: unknown[]) => {
-         warnings.push(typeof msg === "string" ? msg : String(msg));
-         return logger;
-      }) as typeof logger.warn;
-
-      try {
-         const result = getPublisherConfig(testServerRoot);
-
-         expect(result.environments.length).toBe(1);
-         expect(result.environments[0].name).toBe("new-env");
-
-         // No deprecation warning should fire when `environments` is present.
-         expect(
-            warnings.some((w) => w.includes('uses deprecated "projects" key')),
-         ).toBe(false);
-      } finally {
-         logger.warn = originalWarn;
-      }
-   });
-});
-
-describe("Committed example configs", () => {
-   const serverDir = path.resolve(__dirname, "..");
-
-   it.each([
-      ["publisher.config.json", false],
-      ["publisher.config.example.duckdb.json", false],
-      ["publisher.config.example.bigquery.json", true],
-   ])(
-      "%s parses as a valid PublisherConfig",
-      (filename, expectsBigQueryConnection) => {
-         const filePath = path.join(serverDir, filename);
-         expect(fs.existsSync(filePath)).toBe(true);
-
-         const raw = fs.readFileSync(filePath, "utf-8");
-         const parsed = JSON.parse(raw) as PublisherConfig;
-
-         expect(parsed).toHaveProperty("environments");
-         expect(Array.isArray(parsed.environments)).toBe(true);
-         expect(parsed.environments.length).toBeGreaterThan(0);
-
-         const env = parsed.environments[0];
-         expect(env.name).toBeTruthy();
-         expect(Array.isArray(env.packages)).toBe(true);
-         expect(env.packages.length).toBeGreaterThan(0);
-
-         if (expectsBigQueryConnection) {
-            expect(
-               (env.connections ?? []).some((c) => c.type === "bigquery"),
-            ).toBe(true);
-            expect(
-               env.packages.some((p) => p.name === "bigquery-hackernews"),
-            ).toBe(true);
-         } else {
-            expect(
-               env.packages.some((p) => p.name === "bigquery-hackernews"),
-            ).toBe(false);
-         }
-      },
-   );
-});
-
-describe("Config path resolution (--config and bundled default)", () => {
-   const emptyServerRoot = path.join(process.cwd(), "test-empty-server-root");
-   const customConfigPath = path.join(
-      process.cwd(),
-      "test-custom-publisher.config.json",
-   );
-
-   beforeEach(() => {
-      if (!fs.existsSync(emptyServerRoot)) {
-         fs.mkdirSync(emptyServerRoot, { recursive: true });
-      }
-      delete process.env.PUBLISHER_CONFIG_PATH;
-      delete process.env.PUBLISHER_USE_BUNDLED_DEFAULT;
-   });
-
-   afterEach(() => {
-      delete process.env.PUBLISHER_CONFIG_PATH;
-      delete process.env.PUBLISHER_USE_BUNDLED_DEFAULT;
-      if (fs.existsSync(customConfigPath)) {
-         fs.unlinkSync(customConfigPath);
-      }
-      if (fs.existsSync(emptyServerRoot)) {
-         fs.rmSync(emptyServerRoot, { recursive: true, force: true });
-      }
-   });
-
-   it("falls back to the bundled default config when serverRoot has no publisher.config.json and bundled-default opt-in is set", () => {
-      // The bundled default is opt-in (server.ts sets the env var when
-      // the user passed neither --server_root nor --config) so embedded
-      // callers don't get a surprise filesystem read.
-      process.env.PUBLISHER_USE_BUNDLED_DEFAULT = "true";
-      const result = getPublisherConfig(emptyServerRoot);
-
-      expect(result.environments.length).toBeGreaterThan(0);
-      const env = result.environments[0];
-      expect(env.name).toBe("examples");
-      expect(env.packages.some((p) => p.name === "storefront")).toBe(true);
-      expect(env.packages.some((p) => p.name === "bigquery-hackernews")).toBe(
-         false,
-      );
-   });
-
-   it("does NOT fall back to the bundled default when opt-in flag is unset (programmatic construction)", () => {
-      // No PUBLISHER_USE_BUNDLED_DEFAULT, no PUBLISHER_CONFIG_PATH, no
-      // file in emptyServerRoot — result should be the original empty
-      // shape, preserving prior behavior for embeds and tests.
-      const result = getPublisherConfig(emptyServerRoot);
-      expect(result.environments).toEqual([]);
-   });
-
-   it("honors PUBLISHER_CONFIG_PATH (set by --config) over the server root", () => {
-      const customConfig = {
-         frozenConfig: false,
-         environments: [
-            { name: "custom-env", packages: [{ name: "foo", location: "/x" }] },
-         ],
-      };
-      fs.writeFileSync(customConfigPath, JSON.stringify(customConfig));
-      process.env.PUBLISHER_CONFIG_PATH = customConfigPath;
-
-      const result = getPublisherConfig(emptyServerRoot);
-      expect(result.environments[0].name).toBe("custom-env");
-   });
-
-   it("returns empty environments (not the bundled default) when --config points at a missing file", () => {
-      process.env.PUBLISHER_CONFIG_PATH = path.join(
-         process.cwd(),
-         "does-not-exist.json",
-      );
-      // Even with bundled-default opt-in, --config with a missing target
-      // is a user error and we don't paper over it.
-      process.env.PUBLISHER_USE_BUNDLED_DEFAULT = "true";
-      const result = getPublisherConfig(emptyServerRoot);
-      expect(result.environments).toEqual([]);
-   });
-});
-
-describe("getMemoryGovernorConfig", () => {
-   const GOVERNOR_ENV_VARS = [
-      "PUBLISHER_MAX_MEMORY_BYTES",
-      "PUBLISHER_MEMORY_HIGH_WATER_FRACTION",
-      "PUBLISHER_MEMORY_LOW_WATER_FRACTION",
-      "PUBLISHER_MEMORY_CHECK_INTERVAL_MS",
-      "PUBLISHER_MEMORY_BACKPRESSURE",
-   ];
-
-   beforeEach(() => {
-      for (const v of GOVERNOR_ENV_VARS) delete process.env[v];
-   });
-   afterEach(() => {
-      for (const v of GOVERNOR_ENV_VARS) delete process.env[v];
-   });
-
-   it("returns null when PUBLISHER_MAX_MEMORY_BYTES is unset", async () => {
-      const { getMemoryGovernorConfig } = await import("./config");
-      expect(getMemoryGovernorConfig()).toBeNull();
-   });
-
-   it("parses defaults when only PUBLISHER_MAX_MEMORY_BYTES is set", async () => {
-      process.env.PUBLISHER_MAX_MEMORY_BYTES = String(2 * 1024 * 1024 * 1024);
-      const { getMemoryGovernorConfig } = await import("./config");
-      const cfg = getMemoryGovernorConfig();
-      expect(cfg).not.toBeNull();
-      expect(cfg!.maxMemoryBytes).toBe(2 * 1024 * 1024 * 1024);
-      expect(cfg!.backpressureEnabled).toBe(true);
-      expect(cfg!.highWaterFraction).toBeGreaterThan(cfg!.lowWaterFraction);
-   });
-
-   it("honours fraction and interval overrides", async () => {
-      process.env.PUBLISHER_MAX_MEMORY_BYTES = "1000000000";
-      process.env.PUBLISHER_MEMORY_HIGH_WATER_FRACTION = "0.85";
-      process.env.PUBLISHER_MEMORY_LOW_WATER_FRACTION = "0.7";
-      process.env.PUBLISHER_MEMORY_CHECK_INTERVAL_MS = "10000";
-      process.env.PUBLISHER_MEMORY_BACKPRESSURE = "false";
-      const { getMemoryGovernorConfig } = await import("./config");
-      const cfg = getMemoryGovernorConfig();
-      expect(cfg).not.toBeNull();
-      expect(cfg!.highWaterFraction).toBe(0.85);
-      expect(cfg!.lowWaterFraction).toBe(0.7);
-      expect(cfg!.checkIntervalMs).toBe(10000);
-      expect(cfg!.backpressureEnabled).toBe(false);
-   });
-
-   it("treats PUBLISHER_MAX_MEMORY_BYTES=0 as disabled (returns null)", async () => {
-      process.env.PUBLISHER_MAX_MEMORY_BYTES = "0";
-      const { getMemoryGovernorConfig } = await import("./config");
-      expect(getMemoryGovernorConfig()).toBeNull();
-   });
-
-   it("rejects a negative PUBLISHER_MAX_MEMORY_BYTES", async () => {
-      process.env.PUBLISHER_MAX_MEMORY_BYTES = "-1";
-      const { getMemoryGovernorConfig } = await import("./config");
-      expect(() => getMemoryGovernorConfig()).toThrow();
-   });
-
-   it("rejects low >= high", async () => {
-      process.env.PUBLISHER_MAX_MEMORY_BYTES = "1000000000";
-      process.env.PUBLISHER_MEMORY_HIGH_WATER_FRACTION = "0.7";
-      process.env.PUBLISHER_MEMORY_LOW_WATER_FRACTION = "0.8";
-      const { getMemoryGovernorConfig } = await import("./config");
-      expect(() => getMemoryGovernorConfig()).toThrow();
-   });
-
-   it("rejects an out-of-range fraction", async () => {
-      process.env.PUBLISHER_MAX_MEMORY_BYTES = "1000000000";
-      process.env.PUBLISHER_MEMORY_HIGH_WATER_FRACTION = "1.5";
-      const { getMemoryGovernorConfig } = await import("./config");
-      expect(() => getMemoryGovernorConfig()).toThrow();
-   });
-
-   it("rejects a check interval below the safety floor", async () => {
-      process.env.PUBLISHER_MAX_MEMORY_BYTES = "1000000000";
-      process.env.PUBLISHER_MEMORY_CHECK_INTERVAL_MS = "10";
-      const { getMemoryGovernorConfig } = await import("./config");
-      expect(() => getMemoryGovernorConfig()).toThrow();
-   });
-});
-
-describe("getMaxQueryRows", () => {
-   beforeEach(() => {
-      delete process.env.PUBLISHER_MAX_QUERY_ROWS;
-   });
-   afterEach(() => {
-      delete process.env.PUBLISHER_MAX_QUERY_ROWS;
-   });
-
-   it("returns DEFAULT_MAX_QUERY_ROWS when the env var is unset", async () => {
-      const { getMaxQueryRows } = await import("./config");
-      const { DEFAULT_MAX_QUERY_ROWS } = await import("./constants");
-      expect(getMaxQueryRows()).toBe(DEFAULT_MAX_QUERY_ROWS);
-   });
-
-   it("returns DEFAULT_MAX_QUERY_ROWS when the env var is empty", async () => {
-      process.env.PUBLISHER_MAX_QUERY_ROWS = "";
-      const { getMaxQueryRows } = await import("./config");
-      const { DEFAULT_MAX_QUERY_ROWS } = await import("./constants");
-      expect(getMaxQueryRows()).toBe(DEFAULT_MAX_QUERY_ROWS);
-   });
-
-   it("returns the override when the env var is set", async () => {
-      process.env.PUBLISHER_MAX_QUERY_ROWS = "5000";
-      const { getMaxQueryRows } = await import("./config");
-      expect(getMaxQueryRows()).toBe(5000);
-   });
-
-   it("accepts 0 (used to opt out of row cap)", async () => {
-      process.env.PUBLISHER_MAX_QUERY_ROWS = "0";
-      const { getMaxQueryRows } = await import("./config");
-      expect(getMaxQueryRows()).toBe(0);
-   });
-
-   it("rejects a negative override", async () => {
-      process.env.PUBLISHER_MAX_QUERY_ROWS = "-1";
-      const { getMaxQueryRows } = await import("./config");
-      expect(() => getMaxQueryRows()).toThrow();
-   });
-
-   it("rejects a non-integer override", async () => {
-      process.env.PUBLISHER_MAX_QUERY_ROWS = "1.5";
-      const { getMaxQueryRows } = await import("./config");
-      expect(() => getMaxQueryRows()).toThrow();
-   });
-
-   it("rejects a non-numeric override", async () => {
-      process.env.PUBLISHER_MAX_QUERY_ROWS = "lots";
-      const { getMaxQueryRows } = await import("./config");
-      expect(() => getMaxQueryRows()).toThrow();
-   });
-});
-
-describe("getMaxResponseBytes", () => {
-   beforeEach(() => {
-      delete process.env.PUBLISHER_MAX_RESPONSE_BYTES;
-   });
-   afterEach(() => {
-      delete process.env.PUBLISHER_MAX_RESPONSE_BYTES;
-   });
-
-   it("returns DEFAULT_MAX_RESPONSE_BYTES when the env var is unset", async () => {
-      const { getMaxResponseBytes } = await import("./config");
-      const { DEFAULT_MAX_RESPONSE_BYTES } = await import("./constants");
-      expect(getMaxResponseBytes()).toBe(DEFAULT_MAX_RESPONSE_BYTES);
-   });
-
-   it("returns DEFAULT_MAX_RESPONSE_BYTES when the env var is empty", async () => {
-      process.env.PUBLISHER_MAX_RESPONSE_BYTES = "";
-      const { getMaxResponseBytes } = await import("./config");
-      const { DEFAULT_MAX_RESPONSE_BYTES } = await import("./constants");
-      expect(getMaxResponseBytes()).toBe(DEFAULT_MAX_RESPONSE_BYTES);
-   });
-
-   it("returns the override when the env var is set", async () => {
-      process.env.PUBLISHER_MAX_RESPONSE_BYTES = "1048576";
-      const { getMaxResponseBytes } = await import("./config");
-      expect(getMaxResponseBytes()).toBe(1048576);
-   });
-
-   it("accepts 0 (used to opt out of byte cap)", async () => {
-      process.env.PUBLISHER_MAX_RESPONSE_BYTES = "0";
-      const { getMaxResponseBytes } = await import("./config");
-      expect(getMaxResponseBytes()).toBe(0);
-   });
-
-   it("rejects a negative override", async () => {
-      process.env.PUBLISHER_MAX_RESPONSE_BYTES = "-1";
-      const { getMaxResponseBytes } = await import("./config");
-      expect(() => getMaxResponseBytes()).toThrow();
-   });
-
-   it("rejects a non-integer override", async () => {
-      process.env.PUBLISHER_MAX_RESPONSE_BYTES = "1.5";
-      const { getMaxResponseBytes } = await import("./config");
-      expect(() => getMaxResponseBytes()).toThrow();
-   });
-
-   it("rejects a non-numeric override", async () => {
-      process.env.PUBLISHER_MAX_RESPONSE_BYTES = "big";
-      const { getMaxResponseBytes } = await import("./config");
-      expect(() => getMaxResponseBytes()).toThrow();
-   });
-});
-
-describe("getDefaultQueryRowLimit", () => {
-   beforeEach(() => {
-      delete process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT;
-   });
-   afterEach(() => {
-      delete process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT;
-   });
-
-   it("returns DEFAULT_QUERY_ROW_LIMIT when the env var is unset", async () => {
-      const { getDefaultQueryRowLimit } = await import("./config");
-      const { DEFAULT_QUERY_ROW_LIMIT } = await import("./constants");
-      expect(getDefaultQueryRowLimit()).toBe(DEFAULT_QUERY_ROW_LIMIT);
-   });
-
-   it("returns DEFAULT_QUERY_ROW_LIMIT when the env var is empty", async () => {
-      process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT = "";
-      const { getDefaultQueryRowLimit } = await import("./config");
-      const { DEFAULT_QUERY_ROW_LIMIT } = await import("./constants");
-      expect(getDefaultQueryRowLimit()).toBe(DEFAULT_QUERY_ROW_LIMIT);
-   });
-
-   it("returns the override when the env var is set", async () => {
-      process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT = "250";
-      const { getDefaultQueryRowLimit } = await import("./config");
-      expect(getDefaultQueryRowLimit()).toBe(250);
-   });
-
-   it("rejects 0 (a default of 'zero rows' is always a misconfiguration)", async () => {
-      process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT = "0";
-      const { getDefaultQueryRowLimit } = await import("./config");
-      expect(() => getDefaultQueryRowLimit()).toThrow();
-   });
-
-   it("rejects a negative override", async () => {
-      process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT = "-1";
-      const { getDefaultQueryRowLimit } = await import("./config");
-      expect(() => getDefaultQueryRowLimit()).toThrow();
-   });
-
-   it("rejects a non-integer override", async () => {
-      process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT = "1.5";
-      const { getDefaultQueryRowLimit } = await import("./config");
-      expect(() => getDefaultQueryRowLimit()).toThrow();
-   });
-
-   it("rejects a non-numeric override", async () => {
-      process.env.PUBLISHER_DEFAULT_QUERY_ROW_LIMIT = "lots";
-      const { getDefaultQueryRowLimit } = await import("./config");
-      expect(() => getDefaultQueryRowLimit()).toThrow();
-   });
-});
-
-describe("getQueryTimeoutMs", () => {
-   beforeEach(() => {
-      delete process.env.PUBLISHER_QUERY_TIMEOUT_MS;
-   });
-   afterEach(() => {
-      delete process.env.PUBLISHER_QUERY_TIMEOUT_MS;
-   });
-
-   it("returns DEFAULT_QUERY_TIMEOUT_MS when the env var is unset", async () => {
-      const { getQueryTimeoutMs } = await import("./config");
-      const { DEFAULT_QUERY_TIMEOUT_MS } = await import("./constants");
-      expect(getQueryTimeoutMs()).toBe(DEFAULT_QUERY_TIMEOUT_MS);
-   });
-
-   it("returns the override when the env var is set", async () => {
-      process.env.PUBLISHER_QUERY_TIMEOUT_MS = "30000";
-      const { getQueryTimeoutMs } = await import("./config");
-      expect(getQueryTimeoutMs()).toBe(30000);
-   });
-
-   it("accepts 0 (used to opt out of the timeout)", async () => {
-      process.env.PUBLISHER_QUERY_TIMEOUT_MS = "0";
-      const { getQueryTimeoutMs } = await import("./config");
-      expect(getQueryTimeoutMs()).toBe(0);
-   });
-
-   it("rejects a negative override", async () => {
-      process.env.PUBLISHER_QUERY_TIMEOUT_MS = "-1";
-      const { getQueryTimeoutMs } = await import("./config");
-      expect(() => getQueryTimeoutMs()).toThrow();
-   });
-
-   it("rejects a non-integer override", async () => {
-      process.env.PUBLISHER_QUERY_TIMEOUT_MS = "1.5";
-      const { getQueryTimeoutMs } = await import("./config");
-      expect(() => getQueryTimeoutMs()).toThrow();
-   });
-
-   it("rejects a non-numeric override", async () => {
-      process.env.PUBLISHER_QUERY_TIMEOUT_MS = "slow";
-      const { getQueryTimeoutMs } = await import("./config");
-      expect(() => getQueryTimeoutMs()).toThrow();
-   });
-});
-
-describe("getMaxConcurrentQueries", () => {
-   beforeEach(() => {
-      delete process.env.PUBLISHER_MAX_CONCURRENT_QUERIES;
-   });
-   afterEach(() => {
-      delete process.env.PUBLISHER_MAX_CONCURRENT_QUERIES;
-   });
-
-   it("returns DEFAULT_MAX_CONCURRENT_QUERIES when the env var is unset", async () => {
-      const { getMaxConcurrentQueries } = await import("./config");
-      const { DEFAULT_MAX_CONCURRENT_QUERIES } = await import("./constants");
-      expect(getMaxConcurrentQueries()).toBe(DEFAULT_MAX_CONCURRENT_QUERIES);
-   });
-
-   it("returns the override when the env var is set", async () => {
-      process.env.PUBLISHER_MAX_CONCURRENT_QUERIES = "8";
-      const { getMaxConcurrentQueries } = await import("./config");
-      expect(getMaxConcurrentQueries()).toBe(8);
-   });
-
-   it("accepts 0 (used to opt out of the cap)", async () => {
-      process.env.PUBLISHER_MAX_CONCURRENT_QUERIES = "0";
-      const { getMaxConcurrentQueries } = await import("./config");
-      expect(getMaxConcurrentQueries()).toBe(0);
-   });
-
-   it("rejects a negative override", async () => {
-      process.env.PUBLISHER_MAX_CONCURRENT_QUERIES = "-1";
-      const { getMaxConcurrentQueries } = await import("./config");
-      expect(() => getMaxConcurrentQueries()).toThrow();
-   });
-
-   it("rejects a non-integer override", async () => {
-      process.env.PUBLISHER_MAX_CONCURRENT_QUERIES = "1.5";
-      const { getMaxConcurrentQueries } = await import("./config");
-      expect(() => getMaxConcurrentQueries()).toThrow();
-   });
-
-   it("rejects a non-numeric override", async () => {
-      process.env.PUBLISHER_MAX_CONCURRENT_QUERIES = "many";
-      const { getMaxConcurrentQueries } = await import("./config");
-      expect(() => getMaxConcurrentQueries()).toThrow();
-   });
-});
-
-describe("getPublisherConfigDir", () => {
-   const testRoot = path.join(process.cwd(), "test-temp-config-dir");
-   const elsewhere = path.join(testRoot, "elsewhere");
-   const savedConfigPath = process.env.PUBLISHER_CONFIG_PATH;
-
-   beforeEach(() => {
-      fs.mkdirSync(elsewhere, { recursive: true });
-      // Both knobs feed resolvePublisherConfigPath, and every spec file shares
-      // one process, so clear both rather than inherit whatever ran before.
-      delete process.env.PUBLISHER_CONFIG_PATH;
-      delete process.env.PUBLISHER_USE_BUNDLED_DEFAULT;
-   });
-
-   afterEach(() => {
-      fs.rmSync(testRoot, { recursive: true, force: true });
-      // Clear both, not just the one this describe saves: every spec file shares
-      // one process, so a knob left set here follows whatever runs next.
-      delete process.env.PUBLISHER_USE_BUNDLED_DEFAULT;
-      if (savedConfigPath === undefined) {
-         delete process.env.PUBLISHER_CONFIG_PATH;
-      } else {
-         process.env.PUBLISHER_CONFIG_PATH = savedConfigPath;
-      }
-   });
-
-   it("returns the server root when the config sits there", () => {
-      fs.writeFileSync(
-         path.join(testRoot, PUBLISHER_CONFIG_NAME),
-         JSON.stringify({ environments: [] }),
-      );
-      expect(getPublisherConfigDir(testRoot)).toBe(testRoot);
-   });
-
-   it("follows PUBLISHER_CONFIG_PATH to a config outside the server root", () => {
-      // The --config case: a relative package location must anchor next to
-      // the config that declares it, not at whatever cwd the server booted in.
-      const configPath = path.join(elsewhere, PUBLISHER_CONFIG_NAME);
-      fs.writeFileSync(configPath, JSON.stringify({ environments: [] }));
-      process.env.PUBLISHER_CONFIG_PATH = configPath;
-      expect(getPublisherConfigDir(testRoot)).toBe(elsewhere);
-   });
-
-   it("returns null when no config resolves, so callers fall back to the server root", () => {
-      expect(getPublisherConfigDir(testRoot)).toBeNull();
-   });
-
-   it("returns an absolute anchor even when --config is relative", () => {
-      // An anchor that is itself relative would re-resolve against the cwd of
-      // whoever reads it, which is the bug this whole change is fixing.
-      const rel = path.relative(
-         process.cwd(),
-         path.join(elsewhere, PUBLISHER_CONFIG_NAME),
-      );
-      fs.writeFileSync(
-         path.join(elsewhere, PUBLISHER_CONFIG_NAME),
-         JSON.stringify({ environments: [] }),
-      );
-      process.env.PUBLISHER_CONFIG_PATH = rel;
-      const anchor = getPublisherConfigDir(testRoot);
-      expect(anchor).not.toBeNull();
-      expect(path.isAbsolute(anchor as string)).toBe(true);
-      expect(anchor).toBe(elsewhere);
-   });
-
-   it("returns null when --config names a directory instead of a file", () => {
-      // existsSync is true for a directory, so without a file check the anchor
-      // would silently become that directory's PARENT, for a config that never
-      // loads (getPublisherConfig catches the read error and returns empty).
-      process.env.PUBLISHER_CONFIG_PATH = elsewhere;
-      expect(getPublisherConfigDir(testRoot)).toBeNull();
-   });
-
-   it("returns null for the bundled default rather than anchoring inside the install", () => {
-      // Zero-arg `npx @malloy-publisher/server` resolves the config that ships
-      // inside the package. Anchoring a user's relative location under
-      // node_modules would be meaningless, so the caller falls back to the
-      // server root, which is what this did before the anchor moved.
-      process.env.PUBLISHER_USE_BUNDLED_DEFAULT = "true";
-      expect(getPublisherConfigDir(testRoot)).toBeNull();
-   });
-});
-
-describe("PERSIST_COLLISION_ENFORCE", () => {
-   // The flag decides whether a persist-target collision blocks a publish, so
-   // mis-parsing it leaves the check warn-only — failing open in exactly the
-   // direction it exists to prevent. An ad-hoc `=== "true"` did that for `1`,
-   // `yes` and `on`.
-   const prev = process.env.PERSIST_COLLISION_ENFORCE;
-   afterEach(() => {
-      if (prev === undefined) delete process.env.PERSIST_COLLISION_ENFORCE;
-      else process.env.PERSIST_COLLISION_ENFORCE = prev;
-   });
-
-   it("defaults to warn-only when unset or empty", () => {
-      delete process.env.PERSIST_COLLISION_ENFORCE;
-      expect(getPersistCollisionEnforce()).toBe(false);
-      process.env.PERSIST_COLLISION_ENFORCE = "   ";
-      expect(getPersistCollisionEnforce()).toBe(false);
-   });
-
-   it("enforces for every spelling of true an operator might use", () => {
-      for (const raw of ["true", "TRUE", " True ", "1", "yes", "on"]) {
-         process.env.PERSIST_COLLISION_ENFORCE = raw;
-         expect(getPersistCollisionEnforce()).toBe(true);
-      }
-   });
-
-   it("stays warn-only for every spelling of false", () => {
-      for (const raw of ["false", "FALSE", "0", "no", "off"]) {
-         process.env.PERSIST_COLLISION_ENFORCE = raw;
-         expect(getPersistCollisionEnforce()).toBe(false);
-      }
-   });
-
-   it("throws on a value that is neither, rather than guessing", () => {
-      process.env.PERSIST_COLLISION_ENFORCE = "enabled";
-      expect(() => getPersistCollisionEnforce()).toThrow(/expected a boolean/i);
-   });
-});