@malloy-publisher/server 0.0.232 → 0.0.234

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/compile_fragment_techniques.spec.ts

@@ -0,0 +1,156 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import { Environment } from "./environment";
+
+/**
+ * The fragment-checking advice in malloy_compile's tool description, pinned
+ * against the REAL compiler.
+ *
+ * That description tells an agent how to validate part of a source: send a view
+ * body as a top-level `query:`, or wrap a field in a throwaway `extend`, and do
+ * not resubmit the source being edited. None of that is enforced by code, so
+ * nothing but a test stops it from quietly becoming false. Asserting it against
+ * a hand-written checker would be worthless: only Malloy decides what compiles.
+ */
+
+const PUBLISHER_JSON = JSON.stringify({
+   name: "pkg",
+   description: "fragments",
+});
+
+// `secret` is private on the base source, so nothing downstream may read it.
+const MODEL = `##! experimental.access_modifiers
+source: base is duckdb.sql("SELECT 1.5 as price, 90 as points, 'shh' as secret") include {
+  public: price, points
+  private: secret
+}
+
+source: sales is base extend {
+  measure: record_count is count()
+  measure: avg_price is avg(price)
+  view: overview is { aggregate: record_count }
+}
+`;
+
+describe("malloy_compile: checking part of a source", () => {
+   let rootDir: string;
+   let env: Environment;
+
+   beforeEach(async () => {
+      rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "publisher-frag-"));
+      const envPath = path.join(rootDir, "env");
+      await fs.mkdir(envPath, { recursive: true });
+      env = await Environment.create("testEnv", envPath, []);
+      await env.installPackage("pkg", async (stagingPath) => {
+         await fs.mkdir(stagingPath, { recursive: true });
+         await fs.writeFile(
+            path.join(stagingPath, "publisher.json"),
+            PUBLISHER_JSON,
+         );
+         await fs.writeFile(path.join(stagingPath, "model.malloy"), MODEL);
+      });
+   });
+
+   afterEach(async () => {
+      await fs.rm(rootDir, { recursive: true, force: true }).catch(() => {});
+   });
+
+   /** Error-severity messages from compiling `source` against the fixture. */
+   async function errorsFor(source: string): Promise<string[]> {
+      const result = await env.compileSource("pkg", "model.malloy", source);
+      return (result.problems ?? [])
+         .filter((p) => p.severity === "error")
+         .map((p) => p.message);
+   }
+
+   describe("the two failures the description exists to explain", () => {
+      it("rejects a bare view: fragment, naming only the symptom", async () => {
+         const errors = await errorsFor(
+            "view: by_pts is { group_by: points, aggregate: record_count }",
+         );
+         expect(errors.join(" ")).toContain("view:");
+      });
+
+      it("rejects resubmitting the source being edited", async () => {
+         // The natural move when validating an edit, and it fails for a reason
+         // that has nothing to do with the edit.
+         const errors = await errorsFor(`source: sales is base extend {
+  measure: record_count is count()
+  view: by_pts is { group_by: points }
+}`);
+         expect(errors.join(" ")).toContain("Cannot redefine 'sales'");
+      });
+   });
+
+   describe("the top-level query: form", () => {
+      it("compiles a view body with no wrapper at all", async () => {
+         expect(
+            await errorsFor(
+               "query: check is sales -> { group_by: points, aggregate: record_count }",
+            ),
+         ).toEqual([]);
+      });
+
+      it("still resolves measures the source inherits", async () => {
+         expect(
+            await errorsFor(
+               "query: check is sales -> { aggregate: avg_price }",
+            ),
+         ).toEqual([]);
+      });
+   });
+
+   describe("the throwaway extend form", () => {
+      const wrap = (fragment: string, into = "sales") =>
+         `source: check is ${into} extend {\n${fragment}\n}`;
+
+      it("compiles bare view, measure, and dimension fragments", async () => {
+         expect(
+            await errorsFor(
+               wrap(
+                  "view: by_pts is { group_by: points, aggregate: record_count }",
+               ),
+            ),
+         ).toEqual([]);
+         expect(
+            await errorsFor(wrap("measure: max_price is max(price)")),
+         ).toEqual([]);
+         expect(
+            await errorsFor(wrap("dimension: pricey is price > 1")),
+         ).toEqual([]);
+      });
+
+      it("resolves measures the source inherits", async () => {
+         expect(
+            await errorsFor(wrap("view: v is { aggregate: avg_price }")),
+         ).toEqual([]);
+      });
+
+      it("hides a private field exactly as an in-place extension does", async () => {
+         // The fidelity claim in the description: the wrapper must not widen or
+         // narrow visibility versus the edit it stands in for.
+         const wrapped = await errorsFor(wrap("dimension: s is secret"));
+         const inPlace = await errorsFor(
+            "source: probe is base extend { dimension: s is secret }",
+         );
+         expect(wrapped.join(" ")).toContain("private");
+         expect(inPlace.join(" ")).toContain("private");
+      });
+
+      it("reports a redefinition when the fragment reuses an existing name", async () => {
+         // The documented caveat: an extension adds to the namespace rather
+         // than overriding it, so checking an EDIT needs the fragment renamed.
+         expect(
+            await errorsFor(wrap("view: overview is { aggregate: avg_price }")),
+         ).toEqual(["Cannot redefine 'overview'"]);
+
+         expect(
+            await errorsFor(
+               wrap("view: overview__check is { aggregate: avg_price }"),
+            ),
+         ).toEqual([]);
+      });
+   });
+});