@malloy-publisher/server 0.0.227 → 0.0.229

package/src/mcp/tools/reload_package_tool.spec.ts

@@ -0,0 +1,232 @@
+import { describe, expect, it } from "bun:test";
+import { registerReloadPackageTool } from "./reload_package_tool";
+import type { EnvironmentStore } from "../../service/environment_store";
+import { PackageNotFoundError, ServiceUnavailableError } from "../../errors";
+
+// Capture the handler registerReloadPackageTool passes to McpServer.tool, so it
+// can be exercised against a mocked EnvironmentStore. The tool builds a
+// PackageController internally, which calls environment.getPackage(pkg, reload),
+// so the mock only needs getEnvironment -> { getPackage }.
+type Handler = (params: Record<string, unknown>) => Promise<{
+   isError?: boolean;
+   content: Array<{ resource: { text: string } }>;
+}>;
+
+function captureHandler(store: Partial<EnvironmentStore>): Handler {
+   let handler: Handler | undefined;
+   const fakeServer = {
+      tool: (_name: string, _desc: string, _shape: unknown, h: Handler) => {
+         handler = h;
+      },
+   };
+   registerReloadPackageTool(fakeServer as never, store as EnvironmentStore);
+   if (!handler) throw new Error("handler was not registered");
+   return handler;
+}
+
+function parse(result: { content: Array<{ resource: { text: string } }> }) {
+   return JSON.parse(result.content[0].resource.text);
+}
+
+// A store whose package reload returns `metadata`. `location` is left undefined
+// so PackageController takes the in-place-reload branch (no re-download). The
+// optional `calls` array records the `reload` flag of every getPackage call.
+function storeReturning(
+   metadata: Record<string, unknown>,
+   calls?: boolean[],
+): Partial<EnvironmentStore> {
+   return {
+      getEnvironment: async () =>
+         ({
+            getPackage: async (_pkg: string, reload: boolean) => {
+               calls?.push(reload);
+               return { getPackageMetadata: () => metadata } as never;
+            },
+         }) as never,
+   };
+}
+
+// A store whose cached package metadata carries `location`, so PackageController
+// takes the re-fetch branch: installPackage instead of an in-place recompile.
+// This is the only remaining path that overwrites on-disk edits, so it is worth
+// pinning that the routing and the reported mode both match.
+function storeWithInstallLocation(installed: Record<string, unknown>): {
+   store: Partial<EnvironmentStore>;
+   installCalls: string[];
+} {
+   const installCalls: string[] = [];
+   return {
+      installCalls,
+      store: {
+         getEnvironment: async () =>
+            ({
+               getPackage: async () =>
+                  ({
+                     getPackageMetadata: () => ({
+                        name: "ecommerce",
+                        location: "https://github.com/example/pkg",
+                     }),
+                  }) as never,
+               installPackage: async (pkg: string) => {
+                  installCalls.push(pkg);
+                  return { getPackageMetadata: () => installed } as never;
+               },
+            }) as never,
+      },
+   };
+}
+
+const args = { environmentName: "malloy-samples", packageName: "ecommerce" };
+
+describe("malloy_reloadPackage tool", () => {
+   it("returns status reloaded with the package name", async () => {
+      const handler = captureHandler(storeReturning({ name: "ecommerce" }));
+      const result = await handler(args);
+      expect(result.isError).toBe(false);
+      expect(parse(result)).toEqual({
+         status: "reloaded",
+         mode: "in-place",
+         name: "ecommerce",
+      });
+   });
+
+   it("includes description and non-empty warnings", async () => {
+      const warnings = [
+         {
+            model: "ecommerce.malloy",
+            target: "top_categories",
+            severity: "error",
+         },
+      ];
+      const handler = captureHandler(
+         storeReturning({ name: "ecommerce", description: "shop", warnings }),
+      );
+      const parsed = parse(await handler(args));
+      expect(parsed).toEqual({
+         status: "reloaded",
+         mode: "in-place",
+         name: "ecommerce",
+         description: "shop",
+         warnings,
+      });
+   });
+
+   it("omits warnings when the reloaded package has none", async () => {
+      const handler = captureHandler(
+         storeReturning({ name: "ecommerce", warnings: [] }),
+      );
+      const parsed = parse(await handler(args));
+      expect(parsed.warnings).toBeUndefined();
+      expect(parsed.status).toBe("reloaded");
+   });
+
+   it("forwards reload=true (recompiles, not just reads)", async () => {
+      const calls: boolean[] = [];
+      const handler = captureHandler(
+         storeReturning({ name: "ecommerce" }, calls),
+      );
+      await handler(args);
+      // The controller probes cached metadata (reload=false) then reloads
+      // (reload=true); the tool must trigger the recompile.
+      expect(calls).toContain(true);
+   });
+
+   it("surfaces a thrown error as a tool error, not a transport fault", async () => {
+      const handler = captureHandler({
+         getEnvironment: async () => {
+            throw new Error("Environment 'nope' could not be resolved");
+         },
+      });
+      const result = await handler({ ...args, environmentName: "nope" });
+      expect(result.isError).toBe(true);
+      expect(parse(result).error).toBeDefined();
+   });
+
+   it("reports a missing package as not-found, not as a Malloy syntax problem", async () => {
+      // Pin the remediation text, not just that an error came back. Asserting
+      // only that `error` is defined is what let every error class funnel
+      // through the Malloy helper unnoticed: a typo'd package name told the
+      // caller to go check its Malloy syntax.
+      const handler = captureHandler({
+         getEnvironment: async () => {
+            throw new PackageNotFoundError("Package 'nope' not found");
+         },
+      });
+      const parsed = parse(await handler({ ...args, packageName: "nope" }));
+      expect(parsed.error).toContain("Resource not found");
+      expect(JSON.stringify(parsed.suggestions)).not.toContain("Malloy file");
+   });
+
+   it("reports back-pressure as retryable, not as a Malloy syntax problem", async () => {
+      const handler = captureHandler({
+         getEnvironment: async () => {
+            throw new ServiceUnavailableError("Memory limit reached");
+         },
+      });
+      const parsed = parse(await handler(args));
+      expect(parsed.error).toContain("Memory limit reached");
+      expect(JSON.stringify(parsed.suggestions)).toContain("Retry");
+      expect(JSON.stringify(parsed.suggestions)).not.toContain("Malloy file");
+   });
+
+   it("surfaces a hard compile failure on reload as a tool error", async () => {
+      // A Package.create compile failure propagates out of environment.getPackage
+      // (the reload site), not out of getEnvironment. The controller swallows the
+      // first probe call and re-throws on the reload call.
+      const handler = captureHandler({
+         getEnvironment: async () =>
+            ({
+               getPackage: async () => {
+                  throw new Error("'nonexistent_status_field' is not defined");
+               },
+            }) as never,
+      });
+      const result = await handler(args);
+      expect(result.isError).toBe(true);
+      expect(parse(result).error).toBeDefined();
+   });
+
+   it("reports mode in-place for a package with no install location", async () => {
+      const handler = captureHandler(storeReturning({ name: "ecommerce" }));
+      expect(parse(await handler(args)).mode).toBe("in-place");
+   });
+
+   it("re-fetches and reports mode reinstalled when the package carries an install location", async () => {
+      // The one path that still overwrites on-disk edits. It must route through
+      // installPackage, and the payload must say so, since an agent cannot
+      // otherwise tell that its saved edit was just re-fetched over.
+      const { store, installCalls } = storeWithInstallLocation({
+         name: "ecommerce",
+         location: "https://github.com/example/pkg",
+      });
+      const handler = captureHandler(store);
+      const result = await handler(args);
+      expect(result.isError).toBe(false);
+      expect(installCalls).toEqual(["ecommerce"]);
+      expect(parse(result).mode).toBe("reinstalled");
+   });
+
+   it("never echoes the package location back to the caller", async () => {
+      // The payload hand-picks fields; REST spreads the whole ApiPackage. Pin
+      // that the allowlist holds, since location is the one field here that is
+      // deployment detail rather than something an agent needs.
+      const { store } = storeWithInstallLocation({
+         name: "ecommerce",
+         location: "https://github.com/example/pkg",
+      });
+      const parsed = parse(await captureHandler(store)(args));
+      expect(parsed.location).toBeUndefined();
+   });
+
+   it("surfaces exploresWarnings (a mistyped explores entry is not swallowed)", async () => {
+      const exploresWarnings = [
+         "explore 'ordrs' does not resolve to a model in this package",
+      ];
+      const handler = captureHandler(
+         storeReturning({ name: "ecommerce", exploresWarnings }),
+      );
+      const parsed = parse(await handler(args));
+      expect(parsed.status).toBe("reloaded");
+      expect(parsed.exploresWarnings).toEqual(exploresWarnings);
+   });
+});

package/src/mcp/tools/reload_package_tool.ts

@@ -0,0 +1,158 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { logger } from "../../logger";
+import { EnvironmentStore } from "../../service/environment_store";
+import { PackageController } from "../../controller/package.controller";
+import { type ErrorDetails } from "../error_messages";
+import { buildMalloyUri, classifyToolError } from "../handler_utils";
+
+// Zod shape for malloy_reloadPackage. environmentName/packageName mirror the
+// other tools and point the agent at malloy_getContext for name discovery.
+const reloadShape = {
+   environmentName: z
+      .string()
+      .describe(
+         "Environment name. Call malloy_getContext with no arguments to list the available environments.",
+      ),
+   packageName: z
+      .string()
+      .describe(
+         "Package to reload. Call malloy_getContext with just environmentName to list its packages.",
+      ),
+};
+
+/**
+ * What a failed reload does, in one sentence, shared with MCP_INSTRUCTIONS
+ * rather than restated there. Both surfaces describe the same behavior, so one
+ * copy is what stops them drifting.
+ *
+ * SECURITY: interpolated into MCP_INSTRUCTIONS, which is delivered
+ * pre-authorization to any connecting client. Keep this a static string
+ * literal; never derive it from config, environment, or request data.
+ */
+export const RELOAD_FAILURE_IS_SAFE =
+   "A reload that fails to compile leaves your files on disk alone and keeps serving the previously compiled model, returning the compile errors.";
+
+const RELOAD_DESCRIPTION = `Reload a package so edits to its model files on disk are picked up, making newly added or changed sources, views, and named queries resolvable by malloy_executeQuery WITHOUT restarting the server. Publisher compiles each configured package at boot and serves that cached model, so a source or view you add afterwards is not queryable by name until the package is reloaded. Use this to close the edit -> run loop after saving a model change.
+
+${RELOAD_FAILURE_IS_SAFE} Running malloy_compile first is still the faster way to see diagnostics, and it keeps a broken model from ever reaching the reload.
+
+## Parameters
+- environmentName, packageName (required): the package to recompile. Use the names malloy_getContext returns.
+
+## Behavior
+Recompiles the package from its current on-disk content under publisher_data/, so your saved edits are picked up. This is the path every package from publisher.config.json takes. A package whose stored metadata carries an install location (only a PATCH that supplies one sets it) is re-fetched from that source instead, which overwrites on-disk edits.
+
+## Response
+A JSON object with status "reloaded", a mode of "in-place" or "reinstalled", the package name, any render-tag warnings, and any exploresWarnings (curated-discovery entries that did not resolve to a model). Check mode if you had unsaved-elsewhere edits on disk: "in-place" recompiled them, "reinstalled" re-fetched over them. A reload that hits a hard compile error returns an error payload instead.`;
+
+/**
+ * Registers the malloy_reloadPackage MCP tool: recompiles a package from its
+ * on-disk content so a saved model edit becomes queryable by name without a
+ * server restart. Wraps the same PackageController.getPackage(reload=true) path
+ * the REST GET /environments/:env/packages/:pkg?reload=true endpoint uses, so it
+ * adds no capability beyond that already-exposed endpoint (SECURITY: parity with
+ * REST. The MCP surface is unauthenticated, and so is that endpoint; a reload
+ * mutates the shared in-memory package but returns only names and warnings,
+ * never row data or the package's location).
+ */
+export function registerReloadPackageTool(
+   mcpServer: McpServer,
+   environmentStore: EnvironmentStore,
+): void {
+   const packageController = new PackageController(environmentStore);
+
+   mcpServer.tool(
+      "malloy_reloadPackage",
+      RELOAD_DESCRIPTION,
+      reloadShape,
+      async (params) => {
+         const { environmentName, packageName } = params;
+
+         logger.info("[MCP Tool reloadPackage] Reloading package", {
+            environmentName,
+            packageName,
+         });
+
+         const uri = buildMalloyUri(
+            { environment: environmentName, package: packageName },
+            "reloadPackage",
+         );
+
+         try {
+            const { metadata: pkg, mode } =
+               await packageController.reloadPackage(
+                  environmentName,
+                  packageName,
+               );
+
+            const payload = {
+               status: "reloaded" as const,
+               // Which path ran. "in-place" recompiled the tree on disk and left
+               // it alone; "reinstalled" re-fetched from the package's install
+               // location, so any on-disk edits are gone. The caller cannot tell
+               // these apart otherwise, and only one of them keeps their work.
+               mode,
+               name: pkg.name,
+               ...(pkg.description !== undefined && {
+                  description: pkg.description,
+               }),
+               ...(pkg.warnings !== undefined &&
+                  pkg.warnings.length > 0 && { warnings: pkg.warnings }),
+               // exploresWarnings is a distinct signal from render-tag warnings:
+               // it flags a curated-discovery (explores) entry that did not
+               // resolve to a model, so a mistyped explores edit is not silently
+               // swallowed on reload.
+               ...(pkg.exploresWarnings !== undefined &&
+                  pkg.exploresWarnings.length > 0 && {
+                     exploresWarnings: pkg.exploresWarnings,
+                  }),
+            };
+
+            return {
+               isError: false,
+               content: [
+                  {
+                     type: "resource" as const,
+                     resource: {
+                        type: "application/json",
+                        uri,
+                        text: JSON.stringify(payload),
+                     },
+                  },
+               ],
+            };
+         } catch (error) {
+            // Unknown environment/package, or a compile error in the reloaded
+            // package: surface as a clean isError payload rather than a
+            // transport fault.
+            logger.warn("[MCP Tool reloadPackage] reload failed", {
+               environmentName,
+               packageName,
+               error: error instanceof Error ? error.message : String(error),
+            });
+            const errorDetails: ErrorDetails = classifyToolError(
+               "reloadPackage",
+               `${environmentName}/${packageName}`,
+               error,
+            );
+            return {
+               isError: true,
+               content: [
+                  {
+                     type: "resource" as const,
+                     resource: {
+                        type: "application/json",
+                        uri,
+                        text: JSON.stringify({
+                           error: errorDetails.message,
+                           suggestions: errorDetails.suggestions,
+                        }),
+                     },
+                  },
+               ],
+            };
+         }
+      },
+   );
+}

package/src/query_param_utils.ts

@@ -16,3 +16,14 @@ export function normalizeQueryArray(value: unknown): string[] | undefined {
    if (Array.isArray(value)) return value.map(String);
    return [String(value)];
 }
+
+/**
+ * Parse an Express query param as a non-negative integer, or `undefined` when
+ * it is absent or not a finite integer. Degrades a garbage value (`?limit=abc`)
+ * to "unset" rather than passing `NaN` down into a SQL `LIMIT`/`OFFSET` bind.
+ */
+export function parseNonNegativeIntParam(value: unknown): number | undefined {
+   if (value === undefined || value === null) return undefined;
+   const parsed = parseInt(String(value), 10);
+   return Number.isInteger(parsed) && parsed >= 0 ? parsed : undefined;
+}

package/src/runtime/publisher.js

@@ -5,6 +5,10 @@
 // Exposes window.Publisher with:
 //   - Publisher.query(model, malloy, opts?)     → Promise<rows[]>
 //   - Publisher.queryFull(model, malloy, opts?) → Promise<MalloyResult>  (envelope for <malloy-render>)
+//       opts: { environment?, package?, sourceName?, queryName?, filterParams?,
+//               bypassFilters?, givens? }. givens is a name→value map bound as
+//               Malloy given: runtime parameters for this query (safe parameterization,
+//               not string interpolation) — see the malloy-html-data-app-runtime skill.
 //   - Publisher.embed(selector, { src, height?, token? })
 //   - Publisher.context  ({ environment, package } inferred from URL)
 //   - Publisher.setToken(token)  (override Bearer token; default uses cookies)
@@ -92,6 +96,7 @@
       if (opts.queryName) body.queryName = opts.queryName;
       if (opts.filterParams) body.filterParams = opts.filterParams;
       if (opts.bypassFilters) body.bypassFilters = true;
+      if (opts.givens) body.givens = opts.givens;
 
       var headers = Object.assign(
          { "content-type": "application/json" },

package/src/server.ts

@@ -34,7 +34,10 @@ import {
 } from "./instrumentation";
 import { logger, loggerMiddleware } from "./logger";
 
-import { getMemoryGovernorConfig } from "./config";
+import {
+   getMaterializationSchedulerConfig,
+   getMemoryGovernorConfig,
+} from "./config";
 import { setFilterDeprecationHeaders } from "./filter_deprecation";
 import { checkHeapConfiguration } from "./heap_check";
 import { queryConcurrency } from "./query_concurrency";
@@ -43,8 +46,12 @@ import { ThemeController } from "./controller/theme.controller";
 import { initializeMcpServer } from "./mcp/server";
 import { registerLegacyRoutes } from "./server-old";
 import { EnvironmentStore } from "./service/environment_store";
+import { MaterializationScheduler } from "./service/materialization_scheduler";
 import { MaterializationService } from "./service/materialization_service";
-import { normalizeQueryArray } from "./query_param_utils";
+import {
+   normalizeQueryArray,
+   parseNonNegativeIntParam,
+} from "./query_param_utils";
 import { PackageMemoryGovernor } from "./service/package_memory_governor";
 import { ThemeStore } from "./service/theme_store";
 import { assertSafePackageName, safeJoinUnderRoot } from "./path_safety";
@@ -102,7 +109,7 @@ function parseArgs() {
             "  --port <number>        Port to run the server on (default: 4000)",
          );
          console.log(
-            "  --host <string>        Host to bind the server to (default: localhost)",
+            "  --host <string>        Host to bind the REST and MCP servers to (default: 0.0.0.0)",
          );
          console.log(
             "  --server_root <path>   Root directory to serve files from (default: .)",
@@ -120,7 +127,7 @@ function parseArgs() {
             "  --shutdown_graceful_close_timeout_seconds <number>  Time in seconds to wait after closing servers before exit (default: 0)",
          );
          console.log(
-            "  --init                 Initialize the storage (default: false)",
+            "  --init                 Wipe persisted storage and re-sync it from the config (default: false)",
          );
          console.log(
             "  --watch-env <name>     Enable dev-mode watch for the named environment.",
@@ -147,7 +154,7 @@ function parseArgs() {
    // this — the user told us where to look. Skip in NODE_ENV=test as a
    // belt-and-suspenders so any spec that ends up evaluating this
    // module doesn't accidentally pin the EnvironmentStore to the
-   // bundled malloy-samples config.
+   // bundled examples config.
    if (!sawServerRoot && !sawConfig && process.env.NODE_ENV !== "test") {
       process.env.PUBLISHER_USE_BUNDLED_DEFAULT = "true";
    }
@@ -183,7 +190,7 @@ app.use(httpMetricsMiddleware);
 // looks low for the default caps" advisory so operators don't
 // chase OOMKills before checking the obvious config.
 checkHeapConfiguration();
-const environmentStore = new EnvironmentStore(SERVER_ROOT);
+export const environmentStore = new EnvironmentStore(SERVER_ROOT);
 const watchModeController = new WatchModeController(environmentStore);
 const connectionController = new ConnectionController(environmentStore);
 const modelController = new ModelController(environmentStore);
@@ -206,6 +213,32 @@ const materializationService = new MaterializationService(environmentStore);
 const materializationController = new MaterializationController(
    materializationService,
 );
+/**
+ * Construct and start the standalone materialization scheduler from environment
+ * config, or return null when the feature is disabled
+ * (`PUBLISHER_LOCAL_MATERIALIZATION_SCHEDULER` unset/false — the default, so an
+ * orchestrated deployment never runs it). Extracted from the module body so a
+ * test can drive the real env-var → {@link getMaterializationSchedulerConfig} →
+ * construct → `start()`/`unref()` → timer path an operator uses; the
+ * module-level singleton below is armed once at import and can't be re-created
+ * per test.
+ */
+export function startMaterializationSchedulerFromEnv(
+   store: EnvironmentStore,
+   service: MaterializationService,
+): MaterializationScheduler | null {
+   const config = getMaterializationSchedulerConfig();
+   if (!config) return null;
+   const scheduler = new MaterializationScheduler(store, service, config);
+   scheduler.start();
+   return scheduler;
+}
+
+// Standalone materialization scheduler: opt-in via
+// PUBLISHER_LOCAL_MATERIALIZATION_SCHEDULER (default off, so an orchestrated
+// deployment — whose control plane drives materialization — never runs it). The
+// sweep timer is `unref`'d, so it never keeps the process alive on shutdown.
+startMaterializationSchedulerFromEnv(environmentStore, materializationService);
 const themeStore = new ThemeStore(environmentStore.storageManager, SERVER_ROOT);
 const themeController = new ThemeController(themeStore, SERVER_ROOT);
 
@@ -1319,6 +1352,31 @@ app.post(
    },
 );
 
+// Environment-scoped aggregate: every materialization across all packages in
+// the env, newest first. Nested under `/packages` as the collection-level
+// sibling of the per-package `/packages/:packageName/materializations` list.
+// MUST stay registered ahead of `/packages/:packageName` below so the literal
+// `materializations` segment wins the match; consequently `materializations` is
+// a reserved package name at this position (a package can never be named that).
+app.get(
+   `${API_PREFIX}/environments/:environmentName/packages/materializations`,
+   async (req, res) => {
+      try {
+         const limit = parseNonNegativeIntParam(req.query.limit);
+         const offset = parseNonNegativeIntParam(req.query.offset);
+         const builds =
+            await materializationController.listEnvironmentMaterializations(
+               req.params.environmentName,
+               { limit, offset },
+            );
+         res.status(200).json(builds);
+      } catch (error) {
+         const { json, status } = internalErrorToHttpError(error as Error);
+         res.status(status).json(json);
+      }
+   },
+);
+
 app.get(
    `${API_PREFIX}/environments/:environmentName/packages/:packageName`,
    async (req, res) => {
@@ -1613,13 +1671,15 @@ app.get(
 );
 
 app.post(
-   `${API_PREFIX}/environments/:environmentName/packages/:packageName/models/:modelName/compile`,
+   `${API_PREFIX}/environments/:environmentName/packages/:packageName/models/*?/compile`,
    async (req, res) => {
       try {
+         // Express stores wildcard matches in params['0'], so nested model
+         // paths (models in subdirectories) compile just like they query.
          const result = await compileController.compile(
             req.params.environmentName,
             req.params.packageName,
-            req.params.modelName,
+            (req.params as Record<string, string>)["0"],
             req.body.source,
             req.body.includeSql === true,
             req.body.givens as Record<string, GivenValue> | undefined,
@@ -1634,6 +1694,10 @@ app.post(
 );
 
 // ==================== MATERIALIZATION ROUTES ====================
+// The environment-scoped aggregate list (every materialization across all
+// packages) is registered up in the package routes as
+// `/packages/materializations`, ahead of `/packages/:packageName`, so the
+// literal wins the match — see that route for the ordering contract.
 
 app.post(
    `${API_PREFIX}/environments/:environmentName/packages/:packageName/materializations`,
@@ -1656,12 +1720,8 @@ app.get(
    `${API_PREFIX}/environments/:environmentName/packages/:packageName/materializations`,
    async (req, res) => {
       try {
-         const limit = req.query.limit
-            ? parseInt(req.query.limit as string, 10)
-            : undefined;
-         const offset = req.query.offset
-            ? parseInt(req.query.offset as string, 10)
-            : undefined;
+         const limit = parseNonNegativeIntParam(req.query.limit);
+         const offset = parseNonNegativeIntParam(req.query.offset);
          const builds = await materializationController.listMaterializations(
             req.params.environmentName,
             req.params.packageName,

package/src/service/connection.spec.ts

@@ -868,15 +868,16 @@ describe("connection integration tests", () => {
                   const envStore = new EnvironmentStore(tempServerRoot);
                   await envStore.finishedInitialization;
 
-                  // operationalState=serving is the only signal that
-                  // initialize() actually succeeded. initialize swallows
-                  // top-level errors and just calls markNotReady() (see
-                  // environment_store.ts:297-301), so
-                  // finishedInitialization always resolves regardless of
-                  // success. By construction (env_store:288-292), serving
-                  // also implies all configured environments loaded.
+                  // initialize() swallows top-level errors and just calls
+                  // markNotReady(), so finishedInitialization always resolves
+                  // regardless of success; operationalState is what says it
+                  // succeeded. It does NOT imply every configured environment
+                  // and package loaded: a load failure is skipped and still
+                  // reports "serving", which is why loadErrors exists. Assert
+                  // on both, and on the package list below.
                   const status = await envStore.getStatus();
                   expect(status.operationalState).toBe("serving");
+                  expect(status.loadErrors).toBeUndefined();
 
                   const env = await envStore.getEnvironment("malloy-samples");
                   const apiPackages = await env.listPackages();