@malloy-publisher/server 0.0.233 → 0.0.235

package/src/server.ts

@@ -41,6 +41,7 @@ import {
    getMemoryGovernorConfig,
    getPersistCollisionEnforce,
    getPersistStorageMode,
+   getQueryMetadataMode,
 } from "./config";
 import { setFilterDeprecationHeaders } from "./filter_deprecation";
 import { checkHeapConfiguration } from "./heap_check";
@@ -48,6 +49,16 @@ import { queryConcurrency } from "./query_concurrency";
 import { MaterializationController } from "./controller/materialization.controller";
 import { ThemeController } from "./controller/theme.controller";
 import { initializeMcpServer } from "./mcp/server";
+import {
+   addCommand,
+   ensureMcpConfig,
+   logMcpConfigOutcome,
+   MCP_CONFIG_FILENAME,
+   mcpConfigEnabled,
+   mcpEndpoint,
+   resolveBoundPort,
+   resolveClientHost,
+} from "./mcp_config";
 import { registerLegacyRoutes } from "./server-old";
 import { EnvironmentStore } from "./service/environment_store";
 import { MaterializationScheduler } from "./service/materialization_scheduler";
@@ -95,6 +106,8 @@ function parseArgs() {
          i++;
       } else if (arg === "--init") {
          process.env.INITIALIZE_STORAGE = "true";
+      } else if (arg === "--no-mcp-config") {
+         process.env.PUBLISHER_NO_MCP_CONFIG = "true";
       } else if (arg === "--watch-env" && args[i + 1]) {
          // Append (don't overwrite) so multiple --watch-env flags compose
          // and so an explicit env var pre-set still wins.
@@ -133,6 +146,9 @@ function parseArgs() {
          console.log(
             "  --init                 Wipe persisted storage and re-sync it from the config (default: false)",
          );
+         console.log(
+            "  --no-mcp-config        Do not write .mcp.json into the working directory (default: it is written, so an agent opened here finds this server; skipped when the directory already has one, is your home directory or the filesystem root, is inside a git working tree, or the MCP port bound is not the one requested)",
+         );
          console.log(
             "  --watch-env <name>     Enable dev-mode watch for the named environment.",
          );
@@ -177,9 +193,20 @@ getPersistStorageMode();
 // than a failed boot.
 getPersistCollisionEnforce();
 
+// Same hazard, wider blast radius: getQueryMetadataMode() throws on an invalid
+// value and is read while resolving EVERY statement, so a typo'd off switch
+// ("false", "0", "disabled") would boot clean and then fail every query and
+// every build — the one thing the metadata path promises never to do.
+getQueryMetadataMode();
+
 const PUBLISHER_PORT = Number(process.env.PUBLISHER_PORT || 4000);
 const PUBLISHER_HOST = process.env.PUBLISHER_HOST || "0.0.0.0";
 const MCP_PORT = Number(process.env.MCP_PORT || 4040);
+// Resolved here rather than in the listen callback: parseBoolEnv throws on a
+// typo, which is the convention for flags in this server, but a throw inside a
+// listen callback is an uncaughtException that kills a server which has already
+// bound both ports. At module scope it is an ordinary startup failure.
+const MCP_CONFIG_ENABLED = mcpConfigEnabled();
 const MCP_ENDPOINT = "/mcp";
 const SHUTDOWN_DRAIN_DURATION_SECONDS = Number(
    process.env.SHUTDOWN_DRAIN_DURATION_SECONDS || 0,
@@ -1273,6 +1300,11 @@ app.post(
                req.params.connectionName,
                req.body.sqlStatement as string,
                req.body?.options as string,
+               undefined,
+               {
+                  queryMetadata: req.body?.queryMetadata,
+                  queryClass: req.body?.queryClass,
+               },
             ),
          );
       } catch (error) {
@@ -1295,6 +1327,10 @@ app.post(
                req.body.sqlStatement as string,
                req.body?.options as string,
                req.params.packageName,
+               {
+                  queryMetadata: req.body?.queryMetadata,
+                  queryClass: req.body?.queryClass,
+               },
             ),
          );
       } catch (error) {
@@ -1664,6 +1700,11 @@ app.post(
                | undefined,
             req.body.bypassFilters === true ? true : undefined,
             req.body.givens as Record<string, GivenValue> | undefined,
+            {
+               queryMetadata: req.body?.queryMetadata,
+               queryClass: req.body?.queryClass,
+               versionId: req.body?.versionId as string | undefined,
+            },
          );
          setFilterDeprecationHeaders(res, {
             filterParams: req.body.filterParams ?? req.body.sourceFilters,
@@ -1947,9 +1988,64 @@ mainServer.listen(PUBLISHER_PORT, PUBLISHER_HOST, async () => {
       }
    }
 });
-const mcpServer = mcpApp.listen(MCP_PORT, PUBLISHER_HOST, () => {
-   logger.info(`MCP server listening at http://${PUBLISHER_HOST}:${MCP_PORT}`);
-});
+const mcpServer = mcpApp.listen(
+   MCP_PORT,
+   PUBLISHER_HOST,
+   function (this: import("net").Server) {
+      // Read back rather than reusing MCP_PORT, which is only what was requested.
+      // `--mcp_port 0` asks for any free port, and under bun a non-numeric value
+      // binds an ephemeral one too, so the requested value can be 0 or NaN while
+      // a real port is listening. The listening line uses it as well, which is
+      // why it no longer reads `http://127.0.0.1:0`.
+      const boundPort = resolveBoundPort(this.address(), MCP_PORT);
+      // The BIND address, bracketed when it is an IPv6 literal so the URL
+      // parses. Deliberately not resolveClientHost: create-malloy-package's
+      // README and AGENTS template both tell readers these two listening lines
+      // are "the addresses it really bound", and use them to catch a mistyped
+      // --hostt that silently falls back to 0.0.0.0. Mapping the wildcard to
+      // loopback here would confirm the mistake instead of revealing it. The
+      // dialable form belongs in .mcp.json and in the advice, not here.
+      const bound = this.address();
+      const boundHost =
+         typeof bound === "object" && bound ? bound.address : PUBLISHER_HOST;
+      logger.info(
+         `MCP server listening at http://${boundHost.includes(":") ? `[${boundHost}]` : boundHost}:${boundPort}`,
+      );
+      // Checked before process.cwd(), which can throw: someone who turned the
+      // feature off should not get a warning about it.
+      if (MCP_CONFIG_ENABLED) {
+         // ensureMcpConfig cannot throw, but its arguments can: process.cwd()
+         // raises ENOENT once the working directory has been removed. A throw
+         // here is an uncaught exception inside a listen callback, which would
+         // kill a server that has already bound both ports. Everything the call
+         // needs is built inside the try for that reason, including the
+         // endpoint: it is the newest and least-exercised code in this block.
+         try {
+            // The host an agent should dial, which is NOT `localhost`: that name
+            // resolves to both loopback families while the server binds only one,
+            // so another local process can hold the same port on the other family
+            // and receive the agent's traffic instead.
+            const endpoint = mcpEndpoint(
+               resolveClientHost(this.address(), PUBLISHER_HOST),
+               boundPort,
+            );
+            // cwd, not server_root: the file is for whoever opens an agent here.
+            logMcpConfigOutcome(
+               ensureMcpConfig({
+                  dir: process.cwd(),
+                  endpoint,
+                  requestedPort: MCP_PORT,
+                  boundPort,
+               }),
+            );
+         } catch (error) {
+            logger.info(
+               `Could not set up ${MCP_CONFIG_FILENAME} (${error instanceof Error ? error.message : String(error)}). To connect an agent, run: ${addCommand(mcpEndpoint(resolveClientHost(this.address(), PUBLISHER_HOST), boundPort))}`,
+            );
+         }
+      }
+   },
+);
 
 mcpServer.timeout = 600000;
 mcpServer.keepAliveTimeout = 600000;

package/src/service/build_plan.spec.ts

@@ -12,6 +12,7 @@ import {
    iterGraphSources,
    projectToPublicColumns,
    resolveFreshness,
+   resolveQueryMetadata,
    resolvePackageConnections,
 } from "./build_plan";
 import { MaterializationEligibilityError } from "../errors";
@@ -419,6 +420,130 @@ describe("resolveFreshness", () => {
       });
       expect(resolveFreshness(source, null)).toEqual({ window: "1h" });
    });
+
+   it("reads the model-file `materialization` envelope", () => {
+      const source = fakeSource({
+         name: "s",
+         sourceEntityId: "bid",
+         modelMaterialization: { freshness: { freshness: { window: "12h" } } },
+      });
+      expect(resolveFreshness(source, null)).toEqual({ window: "12h" });
+   });
+
+   it("prefers the envelope over the deprecated bare model-file form", () => {
+      const source = fakeSource({
+         name: "s",
+         sourceEntityId: "bid",
+         modelFreshnessSchedule: { freshness: { window: "48h" } },
+         modelMaterialization: { freshness: { freshness: { window: "12h" } } },
+      });
+      expect(resolveFreshness(source, null)).toEqual({ window: "12h" });
+   });
+
+   it("still reads a bare model-file knob the envelope does not declare", () => {
+      // A package published before the envelope existed keeps resolving, and the
+      // envelope does not hide the knobs it says nothing about.
+      const source = fakeSource({
+         name: "s",
+         sourceEntityId: "bid",
+         modelFreshnessSchedule: { freshness: { fallback: "fail" } },
+         modelMaterialization: { freshness: { freshness: { window: "12h" } } },
+      });
+      expect(resolveFreshness(source, null)).toEqual({
+         window: "12h",
+         fallback: "fail",
+      });
+   });
+});
+
+describe("resolveQueryMetadata", () => {
+   it("returns null when no layer declares anything", () => {
+      const source = fakeSource({ name: "s", sourceEntityId: "bid" });
+      expect(resolveQueryMetadata(source, null)).toBeNull();
+      expect(
+         resolveQueryMetadata(source, {
+            schedule: null,
+            freshness: null,
+            queryMetadata: null,
+         }),
+      ).toBeNull();
+   });
+
+   it("reads the source's `#@ persist queryMetadata.*` properties", () => {
+      const source = fakeSource({
+         name: "s",
+         sourceEntityId: "bid",
+         queryMetadata: { team: "finance", workload: "orders" },
+      });
+      expect(resolveQueryMetadata(source, null)).toEqual({
+         team: "finance",
+         workload: "orders",
+      });
+   });
+
+   it("resolves most-specific-wins PER PROPERTY across all four layers", () => {
+      // Package declares team+tier, the model-file envelope overrides tier and
+      // adds one of its own, the source overrides only workload: every property
+      // nothing more specific overrides has to survive.
+      const source = fakeSource({
+         name: "s",
+         sourceEntityId: "bid",
+         queryMetadata: { workload: "orders" },
+         modelMaterialization: {
+            queryMetadata: { tier: "gold", surface: "marts" },
+         },
+      });
+      expect(
+         resolveQueryMetadata(source, {
+            schedule: null,
+            freshness: null,
+            queryMetadata: { team: "finance", tier: "bronze" },
+         }),
+      ).toEqual({
+         team: "finance",
+         tier: "gold",
+         surface: "marts",
+         workload: "orders",
+      });
+   });
+
+   it("prefers the model-file envelope over the bare form, per property", () => {
+      const source = fakeSource({
+         name: "s",
+         sourceEntityId: "bid",
+         modelQueryMetadata: { tier: "bronze", legacy: "kept" },
+         modelMaterialization: { queryMetadata: { tier: "gold" } },
+      });
+      expect(resolveQueryMetadata(source, null)).toEqual({
+         tier: "gold",
+         legacy: "kept",
+      });
+   });
+
+   it("keeps a contract-violating property for the validator to report", () => {
+      const source = fakeSource({
+         name: "s",
+         sourceEntityId: "bid",
+         queryMetadata: { "team.name": "finance" },
+      });
+      expect(resolveQueryMetadata(source, null)).toEqual({
+         "team.name": "finance",
+      });
+   });
+
+   it("does not confuse the scalar `#@ persist` fields beside it", () => {
+      const source = fakeSource({
+         name: "s",
+         sourceEntityId: "bid",
+         annotationFields: { name: "s_table", refresh: "full" },
+         queryMetadata: { team: "finance" },
+      });
+      expect(resolveQueryMetadata(source, null)).toEqual({ team: "finance" });
+      expect(deriveAnnotationFields(source)).toEqual({
+         name: "s_table",
+         refresh: "full",
+      });
+   });
 });
 
 describe("deriveBuildPlan freshness", () => {

package/src/service/build_plan.ts

@@ -27,6 +27,7 @@ type BuildPlan = components["schemas"]["BuildPlan"];
 type WireFreshness = components["schemas"]["Freshness"];
 type WirePackageMaterialization =
    components["schemas"]["PackageMaterializationConfig"];
+type QueryMetadata = components["schemas"]["QueryMetadata"];
 
 /** The freshness `fallback` values the publisher recognizes; others are dropped. */
 const FRESHNESS_FALLBACKS = ["live", "stale_ok", "fail"] as const;
@@ -38,9 +39,15 @@ interface FreshnessLayer {
    fallback?: FreshnessFallback;
 }
 
-/** Minimal path-reader over a Malloy `Tag` (see `@malloydata/malloy-tag`). */
+/**
+ * Minimal reader over a Malloy `Tag` (see `@malloydata/malloy-tag`): scalar
+ * reads by path, plus the subtree read that a property collection like
+ * `queryMetadata { … }` needs.
+ */
 interface ReadableTag {
    text(...path: string[]): string | undefined;
+   tag(...path: string[]): ReadableTag | undefined;
+   entries?(): Iterable<[string, { text(): string | undefined }]>;
 }
 
 /**
@@ -238,6 +245,29 @@ function tagFreshnessLayer(tag: ReadableTag | undefined): FreshnessLayer {
    return layer;
 }
 
+/**
+ * The two homes a model-file (`##`) knob can be declared in, most specific
+ * first: the `materialization` envelope, then the bare form.
+ *
+ * The model-file level mirrors the manifest's shape verbatim — `##
+ * materialization.freshness.window="24h"` is the manifest's block in tag syntax
+ * — so that is where a file-level reader looks. The bare form
+ * (`## freshness.window="24h"`), which shipped first, stays readable underneath:
+ * the annotation rides the published package, so a package published before the
+ * envelope existed keeps resolving until it is republished. Resolution is
+ * per-property, so a file may declare one knob in each home without the envelope
+ * hiding the other.
+ */
+function modelTagLayers(
+   tag: ReadableTag | undefined,
+): (ReadableTag | undefined)[] {
+   const envelope =
+      tag && typeof tag.tag === "function"
+         ? tag.tag("materialization")
+         : undefined;
+   return [envelope, tag];
+}
+
 /** The package-level `materialization.freshness` as a resolution layer. */
 function packageFreshnessLayer(
    cfg: WirePackageMaterialization | null | undefined,
@@ -289,13 +319,16 @@ export function resolveFreshness(
    source: PersistSource,
    packageMaterialization: WirePackageMaterialization | null | undefined,
 ): WireFreshness | null {
-   const sourceLayer = tagFreshnessLayer(safeSourceTag(source));
-   const modelLayer = tagFreshnessLayer(safeModelTag(source));
-   const pkgLayer = packageFreshnessLayer(packageMaterialization);
+   const layers: FreshnessLayer[] = [
+      // `#@ persist` declares knobs bare — the annotation IS a materialization
+      // declaration, so there is no envelope to look under.
+      tagFreshnessLayer(safeSourceTag(source)),
+      ...modelTagLayers(safeModelTag(source)).map(tagFreshnessLayer),
+      packageFreshnessLayer(packageMaterialization),
+   ];
 
-   const window = sourceLayer.window ?? modelLayer.window ?? pkgLayer.window;
-   const fallback =
-      sourceLayer.fallback ?? modelLayer.fallback ?? pkgLayer.fallback;
+   const window = layers.map((l) => l.window).find((v) => v !== undefined);
+   const fallback = layers.map((l) => l.fallback).find((v) => v !== undefined);
 
    if (window === undefined && fallback === undefined) return null;
    const freshness: WireFreshness = {};
@@ -304,6 +337,69 @@ export function resolveFreshness(
    return freshness;
 }
 
+/**
+ * Read the `queryMetadata` property collection from one tag layer. A collection,
+ * not a scalar: `queryMetadata { team="finance" env="prod" }` and the equivalent
+ * dotted form `queryMetadata.team="finance"` both land here, and neither is
+ * captured by the scalar {@link deriveAnnotationFields} loop.
+ *
+ * Every string-valued property is kept verbatim, including ones that violate
+ * Malloy's bag contract — publish reports those as warnings and the runtime
+ * clamps them, so an author's typo is visible somewhere instead of vanishing
+ * between the annotation and the warehouse.
+ */
+function tagQueryMetadataLayer(tag: ReadableTag | undefined): QueryMetadata {
+   const subtree =
+      tag && typeof tag.tag === "function"
+         ? tag.tag("queryMetadata")
+         : undefined;
+   if (!subtree || typeof subtree.entries !== "function") return {};
+   const layer: QueryMetadata = {};
+   try {
+      for (const [name, value] of subtree.entries()) {
+         const text = value.text();
+         if (text !== undefined) layer[name] = text;
+      }
+   } catch {
+      // Degrade to {} — mirrors deriveAnnotationFields / deriveColumns.
+      return {};
+   }
+   return layer;
+}
+
+/**
+ * Resolve a source's EFFECTIVE per-query metadata, most-specific-wins PER
+ * PROPERTY: `#@ persist queryMetadata.*` > model-file
+ * `## materialization.queryMetadata.*` (bare `## queryMetadata.*` underneath) >
+ * package `materialization.queryMetadata`.
+ *
+ * Per-property rather than per-layer, exactly like {@link resolveFreshness}, so a
+ * package-wide `team` property survives a source that only overrides `workload`.
+ * Null when no layer declares anything, so absence on the wire always means
+ * "declared nowhere" rather than "declared empty".
+ *
+ * This is the value the publisher attaches (merged under its own context) to
+ * every statement it issues while building the source. It is deliberately absent
+ * from the source's content address: changing a tag must never re-address a
+ * table.
+ */
+export function resolveQueryMetadata(
+   source: PersistSource,
+   packageMaterialization: WirePackageMaterialization | null | undefined,
+): QueryMetadata | null {
+   // Least specific first, so a more specific layer overwrites property by
+   // property.
+   const layers: QueryMetadata[] = [
+      packageMaterialization?.queryMetadata ?? {},
+      ...modelTagLayers(safeModelTag(source))
+         .map(tagQueryMetadataLayer)
+         .reverse(),
+      tagQueryMetadataLayer(safeSourceTag(source)),
+   ];
+   const resolved: QueryMetadata = Object.assign({}, ...layers);
+   return Object.keys(resolved).length > 0 ? resolved : null;
+}
+
 /** Flatten Malloy's nested BuildNode.dependsOn into a list of sourceIDs. */
 export function flattenDependsOn(node: {
    dependsOn: { sourceID: string }[];
@@ -612,6 +708,11 @@ export function deriveBuildPlan(
          sql: source.getSQL(),
          refresh: annotationFields.refresh ?? null,
          freshness: resolveFreshness(source, packageMaterialization),
+         // EFFECTIVE per-source query metadata, resolved per property across the
+         // same layer stack as freshness. A property collection rather than a
+         // scalar, so it comes from resolveQueryMetadata rather than the
+         // annotationFields map.
+         queryMetadata: resolveQueryMetadata(source, packageMaterialization),
          columns: deriveColumns(source),
          annotationFields,
          modelPath: sourceModelPaths?.[sourceID],

package/src/service/connection_config.ts

@@ -2,7 +2,13 @@ import { createPrivateKey } from "crypto";
 import { existsSync } from "fs";
 import path from "path";
 import { components } from "../api";
+import { logger } from "../logger";
 import { parseHostKeys } from "./proxy";
+import {
+   queryMetadataAdvisoryWarnings,
+   queryMetadataBudgetWarning,
+   queryMetadataViolations,
+} from "./query_metadata";
 
 type ApiConnection = components["schemas"]["Connection"];
 type AttachedDatabase = components["schemas"]["AttachedDatabase"];
@@ -271,6 +277,48 @@ function buildDuckdbEntry(
    };
 }
 
+/**
+ * Report a connection default that will not do what it says — a property name
+ * the contract rejects, one BigQuery would drop, a bag with no room for the
+ * server's own context.
+ *
+ * Warns rather than throws, unlike everything else in this file: query metadata
+ * is observability, and an environment that refuses to load because a tag has a
+ * hyphen in it would trade a missing label for an outage. The connection update
+ * API rejects the same bag outright (see validateAdminAuthoredConnection) —
+ * strict where a human is waiting, lenient where a config is being loaded.
+ */
+function warnOnConnectionQueryMetadata(connection: ApiConnection): void {
+   let declared = 0;
+   for (const field of ["queryMetadata", "queryMetadataEnforced"] as const) {
+      const metadata = connection[field];
+      if (!metadata) continue;
+      declared += Object.keys(metadata).length;
+      const problems = [
+         ...queryMetadataViolations(metadata),
+         ...queryMetadataAdvisoryWarnings(metadata),
+      ];
+      for (const problem of problems) {
+         logger.warn("Connection query metadata will not apply as declared", {
+            connectionName: connection.name,
+            field,
+            problem,
+         });
+      }
+   }
+   // The budget is checked over BOTH maps, not each one: they merge into the
+   // same bag, so a connection declaring 6 defaults and 6 enforced is over it
+   // while neither map is. This is the boundary where the admin who created the
+   // squeeze is the one reading the warning.
+   const overBudget = queryMetadataBudgetWarning(declared);
+   if (overBudget) {
+      logger.warn("Connection query metadata will not apply as declared", {
+         connectionName: connection.name,
+         problem: overBudget,
+      });
+   }
+}
+
 function validateConnectionShape(connection: ApiConnection): void {
    if (connection.proxy) {
       // A connection proxy makes THIS server open an outbound SSH tunnel to a
@@ -606,6 +654,7 @@ export function assembleEnvironmentConnections(
       processedConnections.add(connection.name);
       validateDuckdbApiSurface(connection);
       validateConnectionShape(connection);
+      warnOnConnectionQueryMetadata(connection);
 
       const apiConnection = cloneApiConnection(connection);
       apiConnection.attributes = getStaticConnectionAttributes(connection.type);

package/src/service/environment.ts

@@ -1639,6 +1639,60 @@ export class Environment {
             logger.warn(`Could not read manifest for ${packageName}`);
          }
 
+         const onDiskMaterialization =
+            existingManifest.materialization !== null &&
+            typeof existingManifest.materialization === "object" &&
+            !Array.isArray(existingManifest.materialization)
+               ? (existingManifest.materialization as Record<string, unknown>)
+               : undefined;
+
+         // Scope has two homes: `materialization.scope` (canonical) and the
+         // manifest root (deprecated). The server writes BOTH, in sync, for as
+         // long as the root form is supported:
+         //
+         //  - writing only the root would author a manifest this build's loader
+         //    refuses, since a root that disagrees with an existing envelope is a
+         //    conflict (see resolvePackageScope);
+         //  - writing only the envelope would silently downgrade a package read
+         //    by an older publisher, which knows only the root and would default
+         //    to `package` — cross-version table reuse for a package declared
+         //    `version`.
+         //
+         // A caller can only express scope through the top-level `scope` field
+         // (the wire materialization block has no `scope`), so an envelope value
+         // already on disk is preserved rather than dropped by a materialization
+         // PATCH that says nothing about it.
+         const resolvedScope =
+            metadata.scope ??
+            (onDiskMaterialization?.scope as ApiPackage["scope"] | undefined) ??
+            (existingManifest.scope as ApiPackage["scope"] | undefined);
+
+         // A materialization PATCH replaces the block wholesale, which is right
+         // for schedule and freshness — they are the policy the caller is
+         // setting, and they are mutually exclusive with each other.
+         // `queryMetadata` is orthogonal to both: a client setting a schedule
+         // has no reason to re-send the package's tags, and dropping them
+         // silently untags every statement the package's builds issue. So it is
+         // preserved on omission, like `scope` above; an explicit null still
+         // clears it, which keeps the block expressible.
+         const preservedQueryMetadata =
+            metadata.materialization !== undefined &&
+            metadata.materialization?.queryMetadata === undefined &&
+            onDiskMaterialization?.queryMetadata !== undefined
+               ? { queryMetadata: onDiskMaterialization.queryMetadata }
+               : {};
+
+         const materializationBase: Record<string, unknown> | undefined =
+            metadata.materialization !== undefined
+               ? { ...metadata.materialization, ...preservedQueryMetadata }
+               : onDiskMaterialization !== undefined
+                 ? { ...onDiskMaterialization }
+                 : undefined;
+         const materializationBlock =
+            resolvedScope !== undefined
+               ? { ...(materializationBase ?? {}), scope: resolvedScope }
+               : materializationBase;
+
          // Update with new metadata. `explores`/`queryableSources` are only
          // overwritten when the caller explicitly provides them; otherwise the
          // existing on-disk value is preserved via the spread (an undefined here
@@ -1656,9 +1710,9 @@ export class Environment {
             ...(metadata.manifestLocation !== undefined
                ? { manifestLocation: metadata.manifestLocation }
                : {}),
-            ...(metadata.scope !== undefined ? { scope: metadata.scope } : {}),
-            ...(metadata.materialization !== undefined
-               ? { materialization: metadata.materialization }
+            ...(resolvedScope !== undefined ? { scope: resolvedScope } : {}),
+            ...(materializationBlock !== undefined
+               ? { materialization: materializationBlock }
                : {}),
          };