@malloy-publisher/server 0.0.231 → 0.0.233

package/src/mcp/skills/skills_bundle.spec.ts

@@ -1,6 +1,11 @@
 import { describe, expect, it } from "bun:test";
+import * as fs from "node:fs";
 import * as path from "node:path";
-import { buildSkills, type SkillEntry } from "./build_skills_bundle";
+import {
+   buildSkills,
+   isCredible,
+   type SkillEntry,
+} from "./build_skills_bundle";
 import bundle from "./skills_bundle.json";
 
 const skills = (
@@ -54,9 +59,113 @@ describe("skills_bundle.json (generated dual-channel asset)", () => {
       expect(new Set(names).size).toBe(names.length);
    });
 
+   /**
+    * A skill's reference/ files are its on-demand detail, and this channel is
+    * the only way a host without the skills on disk can reach them. Before they
+    * were bundled, malloy-review told an agent to load rubrics that, over MCP,
+    * did not exist.
+    */
+   describe("reference files", () => {
+      const isReference = (s: SkillEntry) => s.name.includes("/");
+      const referenceEntries = skills.filter(isReference);
+
+      it("bundles every reference/*.md in the tree", () => {
+         // Mirror the builder's own exclusion. A stray credible-* skill with a
+         // reference/ dir is never bundled, so walking without this filter
+         // fails on a correct bundle.
+         const onDisk = fs
+            .readdirSync(sourceDir, { withFileTypes: true })
+            .filter((d) => d.isDirectory() && !isCredible(d.name))
+            .flatMap((d) => {
+               const dir = path.join(sourceDir, d.name, "reference");
+               return fs.existsSync(dir)
+                  ? fs
+                       .readdirSync(dir)
+                       .filter((f) => f.endsWith(".md"))
+                       .map((f) => `${d.name}/${path.basename(f, ".md")}`)
+                  : [];
+            });
+
+         expect(onDisk.length).toBeGreaterThan(0);
+         expect(referenceEntries.map((s) => s.name).sort()).toEqual(
+            onDisk.sort(),
+         );
+      });
+
+      it("names each one under its parent skill", () => {
+         const skillNames = new Set(
+            skills.filter((s) => !isReference(s)).map((s) => s.name),
+         );
+         for (const entry of referenceEntries) {
+            expect(skillNames.has(entry.name.split("/")[0])).toBe(true);
+         }
+      });
+
+      it("gives each one a description drawn from its heading", () => {
+         // Reference files carry no frontmatter, so a listing would otherwise
+         // show them nameless. Every file in the tree has an H1 to use.
+         //
+         // Assert against the no-heading fallback rather than a length floor:
+         // the fallback is itself long enough to clear any such floor, so a
+         // length check alone stays green even if heading extraction breaks
+         // entirely and all of a skill's entries collapse to one string.
+         for (const entry of referenceEntries) {
+            const parent = entry.name.split("/")[0];
+            expect(entry.description).toContain("Reference detail for");
+            expect(entry.description).not.toBe(
+               `Reference detail for the ${parent} skill.`,
+            );
+         }
+      });
+
+      it("tells the parent skill where its reference files went", () => {
+         // The parent body points at them by relative path, which resolves for
+         // a host reading files off disk and not for one given this as a prompt.
+         const parents = new Set(
+            referenceEntries.map((s) => s.name.split("/")[0]),
+         );
+         for (const name of parents) {
+            const parent = skills.find((s) => s.name === name);
+            expect(parent?.body).toContain("Reference files over MCP");
+            expect(parent?.body).toContain(`get the prompt named \`${name}/`);
+         }
+      });
+
+      it("leaves skills without a reference/ directory untouched", () => {
+         const plain = skills.find((s) => s.name === "malloy-getting-started");
+         expect(plain?.body).not.toContain("Reference files over MCP");
+      });
+   });
+
+   /**
+    * Pre-existing drift, bounded rather than exempted. Every SKILL.md honours
+    * the house style; these three reference files never did, because nothing
+    * checked them until they entered the bundle. Fixing 23 prose em-dashes in
+    * three SHARED skills is an upstream-first change of its own, not something
+    * to bundle into the build-time asset that surfaced it.
+    *
+    * Listed by name so a NEW violation still fails: shrink this list as the
+    * files are fixed, and delete it when it is empty.
+    */
+   const EM_DASH_DRIFT = new Set([
+      "malloy-html-data-apps/lazy-load",
+      "malloy-html-data-apps/verification-harness",
+      "malloy-lookml-review/build-derived-tables",
+   ]);
+
    it("carries no em-dashes (house style)", () => {
-      for (const s of skills) {
-         expect(s.body).not.toContain("—");
-      }
+      const offenders = skills
+         .filter((s) => !EM_DASH_DRIFT.has(s.name) && s.body.includes("—"))
+         .map((s) => s.name);
+      expect(offenders).toEqual([]);
+   });
+
+   it("the em-dash allowlist names only entries that still need fixing", () => {
+      // Stops the list outliving the drift: an entry that has been cleaned up,
+      // or renamed away, has to leave the list.
+      const stillDrifting = skills
+         .filter((s) => EM_DASH_DRIFT.has(s.name) && s.body.includes("—"))
+         .map((s) => s.name);
+      expect([...EM_DASH_DRIFT].sort()).toEqual(stillDrifting.sort());
    });
 });

package/src/mcp/tool_response.spec.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from "bun:test";
+import { formatErrorText, jsonResource, jsonToolError } from "./tool_response";
+
+// Pins the wire shape every malloy_* tool returns. Two properties here are
+// regressions waiting to happen, so they are asserted explicitly rather than
+// left to the tools' own specs:
+//
+//   - the resource carries `mimeType`, not `type`. `type` is not in the MCP
+//     ResourceContents schema; it was accepted by .passthrough() and ignored.
+//   - an error result carries a text block. The structured payload alone is
+//     invisible to a client that renders only text for isError results.
+
+describe("jsonResource", () => {
+   it("puts the resource block first and types it with mimeType", () => {
+      const r = jsonResource("malloy:/x", { a: 1 });
+
+      expect(r.isError).toBe(false);
+      expect(r.content).toHaveLength(1);
+      expect(r.content[0].type).toBe("resource");
+
+      const resource = (r.content[0] as { resource: Record<string, unknown> })
+         .resource;
+      expect(resource.mimeType).toBe("application/json");
+      expect(resource.uri).toBe("malloy:/x");
+      // The pre-fix spelling must not come back.
+      expect(resource.type).toBeUndefined();
+      expect(JSON.parse(resource.text as string)).toEqual({ a: 1 });
+   });
+
+   it("appends an optional text block after the resource", () => {
+      const r = jsonResource("malloy:/x", { a: 1 }, { text: "heads up" });
+
+      expect(r.content).toHaveLength(2);
+      expect(r.content[0].type).toBe("resource");
+      expect(r.content[1]).toEqual({ type: "text", text: "heads up" });
+   });
+
+   it("omits the text block when no text is supplied", () => {
+      expect(jsonResource("malloy:/x", {}).content).toHaveLength(1);
+   });
+
+   it("honours the space option without changing the parsed payload", () => {
+      const compact = jsonResource("malloy:/x", { a: 1 });
+      const pretty = jsonResource("malloy:/x", { a: 1 }, { space: 2 });
+
+      const text = (r: typeof compact) =>
+         (r.content[0] as { resource: { text: string } }).resource.text;
+
+      expect(text(pretty)).toContain("\n");
+      expect(text(compact)).not.toContain("\n");
+      expect(JSON.parse(text(pretty))).toEqual(JSON.parse(text(compact)));
+   });
+});
+
+describe("formatErrorText", () => {
+   it("renders the message and every suggestion", () => {
+      const text = formatErrorText({
+         message: "Resource not found: env/pkg",
+         suggestions: ["Check the spelling.", "Call malloy_getContext."],
+      });
+
+      expect(text).toContain("Resource not found: env/pkg");
+      expect(text).toContain("- Check the spelling.");
+      expect(text).toContain("- Call malloy_getContext.");
+   });
+
+   it("returns the bare message when there are no suggestions", () => {
+      expect(formatErrorText({ message: "boom", suggestions: [] })).toBe(
+         "boom",
+      );
+   });
+});
+
+describe("jsonToolError", () => {
+   const details = {
+      message: "Cannot redefine 'overview'",
+      suggestions: ["Rename the view."],
+   };
+
+   it("sets isError and carries the message in BOTH blocks", () => {
+      const r = jsonToolError("error://compile", details);
+
+      expect(r.isError).toBe(true);
+      expect(r.content).toHaveLength(2);
+
+      const payload = JSON.parse(
+         (r.content[0] as { resource: { text: string } }).resource.text,
+      );
+      expect(payload.error).toBe("Cannot redefine 'overview'");
+      expect(payload.suggestions).toEqual(["Rename the view."]);
+
+      // The whole point of the change: a text-only client still sees it.
+      const textBlock = r.content[1] as { type: string; text: string };
+      expect(textBlock.type).toBe("text");
+      expect(textBlock.text).toContain("Cannot redefine 'overview'");
+      expect(textBlock.text).toContain("- Rename the view.");
+   });
+
+   it("merges extraPayload so getContext keeps its results key", () => {
+      const r = jsonToolError("error://ctx", details, { results: [] });
+
+      const payload = JSON.parse(
+         (r.content[0] as { resource: { text: string } }).resource.text,
+      );
+      expect(payload.results).toEqual([]);
+      expect(payload.error).toBe("Cannot redefine 'overview'");
+   });
+});

package/src/mcp/tool_response.ts

@@ -0,0 +1,138 @@
+import type { ErrorDetails } from "./error_messages";
+
+/**
+ * Shared construction of the MCP content blocks every malloy_* tool returns.
+ *
+ * Two things here are load-bearing and were previously wrong at every call site:
+ *
+ * 1. The resource block carries `mimeType`, not `type`. The MCP
+ *    ResourceContents schema is `z.object({uri, mimeType?, _meta?}).passthrough()`,
+ *    so a `type: "application/json"` field was accepted by passthrough and then
+ *    ignored by every client, leaving the payload untyped on the wire.
+ *
+ * 2. An error result also emits a plain text block. A client that renders only
+ *    text blocks when `isError` is set sees nothing at all in an embedded
+ *    resource, and reports a bare "Unknown error" while the server's real
+ *    message and suggestions sit unread in the resource. The text block is what
+ *    makes a diagnostic legible; the resource block is what keeps it parseable.
+ *
+ * Ordering matters: the resource block stays at index 0 so callers (and specs)
+ * can keep reading `content[0].resource.text` for the structured payload.
+ */
+
+const JSON_MIME_TYPE = "application/json";
+
+// The index signatures mirror the MCP SDK's CallToolResult types, which declare
+// `[x: string]: unknown` on the result and on every content block. Without them
+// these are not assignable to the SDK's tool-callback return type.
+type ResourceBlock = {
+   [x: string]: unknown;
+   type: "resource";
+   resource: {
+      [x: string]: unknown;
+      uri: string;
+      mimeType: string;
+      text: string;
+   };
+};
+
+type TextBlock = { [x: string]: unknown; type: "text"; text: string };
+
+export type ToolContent = ResourceBlock | TextBlock;
+
+export interface ToolResult {
+   [x: string]: unknown;
+   isError: boolean;
+   content: ToolContent[];
+}
+
+function resourceBlock(
+   uri: string,
+   payload: unknown,
+   space?: number,
+   replacer?: (key: string, value: unknown) => unknown,
+): ResourceBlock {
+   return {
+      type: "resource" as const,
+      resource: {
+         uri,
+         mimeType: JSON_MIME_TYPE,
+         text: JSON.stringify(payload, replacer, space),
+      },
+   };
+}
+
+/**
+ * Renders ErrorDetails as the prose a client will actually show the agent.
+ *
+ * The suggestions are included, not just the message: they carry the part that
+ * makes an error actionable (which source was denied, which view to look for,
+ * that a reload is needed), and a client that cannot read the resource block
+ * has no other way to reach them. They are a short, bounded list by
+ * construction in error_messages.ts.
+ *
+ * Exported so a spec can pin the rendering rather than merely its presence.
+ */
+export function formatErrorText(details: ErrorDetails): string {
+   if (details.suggestions.length === 0) {
+      return details.message;
+   }
+   const suggestions = details.suggestions.map((s) => `- ${s}`).join("\n");
+   return `${details.message}\n\nSuggestions:\n${suggestions}`;
+}
+
+/**
+ * Wraps a JSON payload in the resource-content shape, optionally adding a text
+ * block alongside it.
+ *
+ * `text` is deliberately opt-in rather than automatic on success: a query result
+ * is already size-capped (assertWithinModelResponseLimits), and duplicating it
+ * as prose would double the payload for no gain. Success paths that have
+ * something short and useful to say (render-tag warnings) pass it explicitly.
+ *
+ * @param space JSON.stringify indentation. Left undefined (compact) except for
+ *   query results, which have always been pretty-printed for readability.
+ */
+export function jsonResource(
+   uri: string,
+   payload: unknown,
+   options?: {
+      isError?: boolean;
+      text?: string;
+      space?: number;
+      /** Needed when the payload can carry BigInt: see json_utils.bigIntReplacer. */
+      replacer?: (key: string, value: unknown) => unknown;
+   },
+): ToolResult {
+   const content: ToolContent[] = [
+      resourceBlock(uri, payload, options?.space, options?.replacer),
+   ];
+   if (options?.text !== undefined) {
+      content.push({ type: "text" as const, text: options.text });
+   }
+   return { isError: options?.isError ?? false, content };
+}
+
+/**
+ * Builds the standard error result: the {error, suggestions} JSON a parsing
+ * client wants, plus the same information as text so every client can read it.
+ *
+ * @param extraPayload Merged into the JSON payload. malloy_getContext uses it
+ *   to keep its `results: []` contract on the error path, which its callers
+ *   (and specs) rely on to treat every tier's response shape uniformly.
+ */
+export function jsonToolError(
+   uri: string,
+   details: ErrorDetails,
+   extraPayload?: Record<string, unknown>,
+): ToolResult {
+   return jsonResource(
+      uri,
+      {
+         error: details.message,
+         suggestions: details.suggestions,
+         ...extraPayload,
+      },
+      { isError: true, text: formatErrorText(details) },
+   );
+}

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "bun:test";
-import { registerCompileTool } from "./compile_tool";
+import { formatDiagnosticsText, registerCompileTool } from "./compile_tool";
 import type { EnvironmentStore } from "../../service/environment_store";
 import { PackageNotFoundError, ServiceUnavailableError } from "../../errors";
 
@@ -7,9 +7,15 @@ import { PackageNotFoundError, ServiceUnavailableError } from "../../errors";
 // be exercised against a mocked EnvironmentStore. The tool builds a
 // CompileController internally, which calls environment.compileSource, so the
 // mock only needs getEnvironment -> { compileSource }.
+type Content = Array<{
+   type?: string;
+   text?: string;
+   resource?: { text: string };
+}>;
+
 type Handler = (params: Record<string, unknown>) => Promise<{
    isError?: boolean;
-   content: Array<{ resource: { text: string } }>;
+   content: Content;
 }>;
 
 function captureHandler(store: Partial<EnvironmentStore>): Handler {
@@ -24,8 +30,12 @@ function captureHandler(store: Partial<EnvironmentStore>): Handler {
    return handler;
 }
 
-function parse(result: { content: Array<{ resource: { text: string } }> }) {
-   return JSON.parse(result.content[0].resource.text);
+function parse(result: { content: Content }) {
+   return JSON.parse(result.content[0].resource!.text);
+}
+
+function textBlock(result: { content: Content }) {
+   return result.content.find((b) => b.type === "text")?.text;
 }
 
 function storeReturning(
@@ -89,6 +99,40 @@ describe("malloy_compile tool", () => {
       ]);
    });
 
+   it("also states the diagnostics in a text block", async () => {
+      // The regression pin for the isError path that matters most: a bad Malloy
+      // snippet. A client that renders only text blocks on isError sees nothing
+      // without this, and reports a bare "Unknown error" while the diagnostics
+      // sit unread in the resource block.
+      const handler = captureHandler(
+         storeReturning([
+            {
+               severity: "error",
+               message: "'nope' is not defined",
+               code: "field-not-found",
+               at: {
+                  range: {
+                     start: { line: 2, character: 3 },
+                     end: { line: 2, character: 7 },
+                  },
+               },
+            },
+         ]),
+      );
+      const result = await handler(args);
+      expect(textBlock(result)).toBe(
+         "Compile failed with 1 error (positions are 0-based):\n\n" +
+            "- 'nope' is not defined (line 2, character 3) [field-not-found]",
+      );
+   });
+
+   it("adds no text block to a clean compile", async () => {
+      // Success stays resource-only: the payload is the answer, and duplicating
+      // it as prose would double every response for no gain.
+      const handler = captureHandler(storeReturning([]));
+      expect(textBlock(await handler(args))).toBeUndefined();
+   });
+
    it("treats a warning as a clean compile (status success, isError false)", async () => {
       const handler = captureHandler(
          storeReturning([
@@ -184,6 +228,70 @@ describe("malloy_compile tool", () => {
       });
    });
 
+   describe("formatDiagnosticsText", () => {
+      it("renders only the error-severity diagnostics", () => {
+         const text = formatDiagnosticsText([
+            { severity: "warn", message: "deprecated syntax", code: "dep" },
+            { severity: "error", message: "first", line: 1, character: 0 },
+            { severity: "error", message: "second", line: 4, character: 2 },
+         ]);
+         expect(text).toBe(
+            "Compile failed with 2 errors (positions are 0-based):\n\n" +
+               "- first (line 1, character 0)\n" +
+               "- second (line 4, character 2)",
+         );
+         expect(text).not.toContain("deprecated syntax");
+      });
+
+      it("omits the position when a diagnostic has no location", () => {
+         expect(
+            formatDiagnosticsText([
+               { severity: "error", message: "no location", code: "syntax" },
+            ]),
+         ).toBe(
+            "Compile failed with 1 error (positions are 0-based):\n\n" +
+               "- no location [syntax]",
+         );
+      });
+
+      it("renders line 0 / character 0 rather than dropping them", () => {
+         // 0 is a real position, not a missing one; a falsy check here would
+         // silently swallow the first line of the file.
+         expect(
+            formatDiagnosticsText([
+               {
+                  severity: "error",
+                  message: "at the top",
+                  line: 0,
+                  character: 0,
+               },
+            ]),
+         ).toContain("- at the top (line 0, character 0)");
+      });
+
+      it("defaults character to 0 when only the line is known", () => {
+         expect(
+            formatDiagnosticsText([
+               { severity: "error", message: "line only", line: 7 },
+            ]),
+         ).toContain("- line only (line 7, character 0)");
+      });
+
+      it("falls back to every diagnostic when none has error severity", () => {
+         // Defensive: status is "error" only when an error-severity diagnostic
+         // exists, so this should be unreachable. It must not render an empty
+         // list if that ever changes.
+         expect(
+            formatDiagnosticsText([
+               { severity: "warn", message: "only a warn" },
+            ]),
+         ).toBe(
+            "Compile failed with 1 error (positions are 0-based):\n\n" +
+               "- only a warn",
+         );
+      });
+   });
+
    it("forwards givens to compileSource", async () => {
       let captured: unknown;
       const handler = captureHandler({

package/src/mcp/tools/compile_tool.ts

@@ -6,6 +6,7 @@ import { EnvironmentStore } from "../../service/environment_store";
 import { CompileController } from "../../controller/compile.controller";
 import { type ErrorDetails } from "../error_messages";
 import { buildMalloyUri, classifyToolError } from "../handler_utils";
+import { jsonResource, jsonToolError } from "../tool_response";
 
 // Zod shape for malloy_compile. environmentName/packageName mirror the other
 // tools and point the agent at malloy_getContext for name discovery.
@@ -51,8 +52,53 @@ const COMPILE_DESCRIPTION = `Compile-check Malloy source against a model and ret
 - source (required): the Malloy text to validate.
 - includeSql (optional): also return the generated SQL when the source ends in a runnable query. The query is still not executed and no data is scanned.
 
+## Checking part of a source
+Your source is APPENDED, so it must stand alone as top-level Malloy: a bare \`view:\`, \`dimension:\` or \`measure:\` does not compile on its own, and resubmitting a source the model already declares reports "Cannot redefine". docs/ai-agents.md gives the two forms that work.
+
 ## Response
-A JSON object with status ("success" or "error") and diagnostics: an array of { severity ("error" / "warn" / "debug"), message, code, line, character, endLine, endCharacter, replacement }. Positions are 0-based (line and character start at 0) and relative to the model file with your source appended to it, so a diagnostic in your submitted source lands after the model's own line count, and a diagnostic may point at pre-existing content in the model rather than at your source. A clean compile can still return warnings; status is "error" only when at least one diagnostic has error severity.`;
+A JSON object with status ("success" or "error") and diagnostics: an array of { severity ("error" / "warn" / "debug"), message, code, line, character, endLine, endCharacter, replacement }. Positions are 0-based (line and character start at 0) and relative to the model file with your source appended to it, so a diagnostic in your submitted source lands after the model's own line count, and a diagnostic may point at pre-existing content in the model rather than at your source. Any wrapper you add counts toward that offset too. A clean compile can still return warnings; status is "error" only when at least one diagnostic has error severity. When status is "error" the response also states the error diagnostics in a plain text block alongside the JSON, so the failure is legible without parsing the payload.`;
+
+/** The flattened diagnostic shape this tool returns. */
+type CompileDiagnostic = {
+   severity: string;
+   message: string;
+   code?: string;
+   line?: number;
+   character?: number;
+};
+
+/**
+ * Renders error diagnostics as the prose a text-only client will show.
+ *
+ * A failed compile is an isError result whose diagnostics live in the resource
+ * block, so a client that renders only text blocks on isError sees nothing —
+ * which is how a real compile error gets reported as a bare "Unknown error".
+ * The resource block stays the parseable channel; this is the legible one.
+ * Positions are labelled 0-based to match the payload rather than introduce a
+ * second convention for the same numbers.
+ *
+ * Only error-severity diagnostics are rendered: status is "error" because of
+ * those, and they are what the caller has to fix. Falling back to every
+ * diagnostic keeps the text non-empty if that invariant ever breaks.
+ *
+ * Exported so a spec can pin the rendering rather than merely its presence.
+ */
+export function formatDiagnosticsText(
+   diagnostics: CompileDiagnostic[],
+): string {
+   const errors = diagnostics.filter((d) => d.severity === "error");
+   const shown = errors.length > 0 ? errors : diagnostics;
+   const lines = shown.map((d) => {
+      const at =
+         d.line !== undefined
+            ? ` (line ${d.line}, character ${d.character ?? 0})`
+            : "";
+      const code = d.code ? ` [${d.code}]` : "";
+      return `- ${d.message}${at}${code}`;
+   });
+   const noun = shown.length === 1 ? "error" : "errors";
+   return `Compile failed with ${shown.length} ${noun} (positions are 0-based):\n\n${lines.join("\n")}`;
+}
 
 /**
  * Registers the malloy_compile MCP tool: validates Malloy source against a model
@@ -125,19 +171,19 @@ export function registerCompileTool(
                ...(result.sql !== undefined && { sql: result.sql }),
             };
 
-            return {
-               isError: result.status === "error",
-               content: [
-                  {
-                     type: "resource" as const,
-                     resource: {
-                        type: "application/json",
-                        uri,
-                        text: JSON.stringify(payload),
-                     },
-                  },
-               ],
-            };
+            // A compile that returns error diagnostics is still a successful
+            // tool call in the transport sense, but isError tells the agent not
+            // to treat the model as valid. This is the most common way the tool
+            // fails, so it carries a text block for the same reason the catch
+            // below does: the diagnostics are only the message to a client that
+            // parses the resource. The payload keeps its documented
+            // {status, diagnostics} shape rather than the {error, suggestions}
+            // of jsonToolError, so parsing clients are unaffected.
+            const isError = result.status === "error";
+            return jsonResource(uri, payload, {
+               isError,
+               ...(isError && { text: formatDiagnosticsText(diagnostics) }),
+            });
          } catch (error) {
             // Unknown environment/package, a notebook (.malloynb) rejected up
             // front, an authorize denial, or a system error: surface as a clean
@@ -155,22 +201,7 @@ export function registerCompileTool(
                `${environmentName}/${packageName}/${modelPath}`,
                error,
             );
-            return {
-               isError: true,
-               content: [
-                  {
-                     type: "resource" as const,
-                     resource: {
-                        type: "application/json",
-                        uri,
-                        text: JSON.stringify({
-                           error: errorDetails.message,
-                           suggestions: errorDetails.suggestions,
-                        }),
-                     },
-                  },
-               ],
-            };
+            return jsonToolError(uri, errorDetails);
          }
       },
    );