blume 1.4.3 → 1.5.0

package/src/components/openapi/RequestPanel.astro

@@ -3,6 +3,7 @@ import data from "blume:data";
 
 import { highlightCode } from "../../markdown/index.ts";
 import { exampleValue, type SchemaLike, toJson } from "./helpers.ts";
+import PanelTabs from "./PanelTabs.astro";
 import type { RequestSample, SampleLanguage } from "./snippets.ts";
 
 interface MediaTypeLike {
@@ -24,27 +25,18 @@ interface Props {
 
 const { sample, languages, responses, schemas } = Astro.props;
 
-// A `.prose` wrapper gives Shiki its scoped token colors; the global style at
-// the foot of this file strips the standalone code block's own box (border,
-// injected copy button, language label) so the code sits flush inside the one
-// panel border.
-const CODE_WRAP = "prose max-w-none text-xs";
-const TAB_CLASS =
-  "-mb-px cursor-pointer border-transparent border-b-2 bg-transparent py-2 font-medium text-muted-foreground text-xs transition-colors hover:text-foreground aria-[selected=true]:border-accent aria-[selected=true]:text-foreground";
-const HEADING = "mb-2 font-semibold text-foreground text-sm";
-
-const requestSamples = await Promise.all(
+const requestPanels = await Promise.all(
   languages.map(async (language) => ({
     html: await highlightCode(language.build(sample), language.lang, {
       icons: false,
       themes: data.config.codeThemes,
     }),
-    id: language.id,
+    key: language.id,
     label: language.label,
   }))
 );
 
-const responseEntries = await Promise.all(
+const responsePanels = await Promise.all(
   Object.entries(responses).map(async ([status, response]) => {
     const media =
       Object.entries(response.content ?? {}).find(([type]) =>
@@ -60,116 +52,17 @@ const responseEntries = await Promise.all(
             icons: false,
             themes: data.config.codeThemes,
           });
-    return { description: response.description ?? "", html, status };
+    return {
+      html,
+      key: status,
+      label: status,
+      text: response.description || "No example response.",
+    };
   })
 );
 ---
 
 <div class="not-prose flex flex-col gap-6">
-  {
-    requestSamples.length > 0 && (
-      <div>
-        <div aria-level="3" class={HEADING} role="heading">
-          Request
-        </div>
-        <blume-panel-tabs class="block overflow-hidden rounded-blume border border-border bg-background">
-          <div class="flex items-center justify-between gap-2 border-border border-b px-3">
-            <div class="flex gap-4" role="tablist">
-              {requestSamples.map((entry, index) => (
-                <button
-                  aria-selected={index === 0 ? "true" : "false"}
-                  class={TAB_CLASS}
-                  data-panel-tab={entry.id}
-                  role="tab"
-                  type="button"
-                >
-                  {entry.label}
-                </button>
-              ))}
-            </div>
-            <button
-              aria-label="Copy request"
-              class="group shrink-0 cursor-pointer rounded px-1.5 py-1 text-muted-foreground text-xs hover:text-foreground"
-              data-panel-copy
-              type="button"
-            >
-              <span class="group-data-[copied]:hidden">Copy</span>
-              <span class="hidden group-data-[copied]:inline">Copied</span>
-            </button>
-          </div>
-          {requestSamples.map((entry, index) => (
-            <div
-              class:list={[index === 0 ? "" : "hidden", CODE_WRAP]}
-              data-panel={entry.id}
-            >
-              <Fragment set:html={entry.html} />
-            </div>
-          ))}
-        </blume-panel-tabs>
-      </div>
-    )
-  }
-  {
-    responseEntries.length > 0 && (
-      <div>
-        <div aria-level="3" class={HEADING} role="heading">
-          Response
-        </div>
-        <blume-panel-tabs class="block overflow-hidden rounded-blume border border-border bg-background">
-          <div class="flex flex-wrap gap-4 border-border border-b px-3" role="tablist">
-            {responseEntries.map((entry, index) => (
-              <button
-                aria-selected={index === 0 ? "true" : "false"}
-                class={`${TAB_CLASS} font-mono`}
-                data-panel-tab={entry.status}
-                role="tab"
-                type="button"
-              >
-                {entry.status}
-              </button>
-            ))}
-          </div>
-          {responseEntries.map((entry, index) => (
-            <div
-              class:list={[index === 0 ? "" : "hidden"]}
-              data-panel={entry.status}
-            >
-              {entry.html ? (
-                <div class={CODE_WRAP}>
-                  <Fragment set:html={entry.html} />
-                </div>
-              ) : (
-                <div class="px-3 py-4 text-muted-foreground text-xs">
-                  {entry.description || "No example response."}
-                </div>
-              )}
-            </div>
-          ))}
-        </blume-panel-tabs>
-      </div>
-    )
-  }
+  <PanelTabs copy heading="Request" panels={requestPanels} />
+  <PanelTabs heading="Response" mono panels={responsePanels} />
 </div>
-
-<script>
-  import "./panel.ts";
-</script>
-
-<style is:global>
-  /* Strip the standalone code block's own chrome inside a panel: the border,
-     margin, radius, and the copy button + language label the prose code theme
-     adds — the panel supplies a single border and its own copy button. */
-  blume-panel-tabs pre.astro-code {
-    margin: 0 !important;
-    border: 0 !important;
-    border-radius: 0 !important;
-    background: transparent !important;
-    padding: 0.75rem 1rem !important;
-  }
-  blume-panel-tabs pre.astro-code::before {
-    content: none !important;
-  }
-  blume-panel-tabs [data-blume-copy] {
-    display: none !important;
-  }
-</style>

package/src/components/openapi/async-snippets.ts

@@ -0,0 +1,174 @@
+import type {
+  AsyncApiAction,
+  AsyncApiServerObject,
+} from "../../openapi/asyncapi.ts";
+import { toJson } from "./helpers.ts";
+
+/**
+ * Protocol-aware code samples for AsyncAPI operations — the async counterpart
+ * of `snippets.ts`. Samples are written from the reader's side of the wire:
+ * a `receive` operation means the application receives, so the sample shows
+ * how to *produce* a message; a `send` operation shows how to consume one.
+ * Protocols without a supported tool yield no samples at all — the message
+ * example panel already shows the payload, and fabricating a client for an
+ * unknown binding would be worse than nothing.
+ */
+
+/** Everything a snippet builder needs about one operation. */
+export interface MessageSample {
+  action: AsyncApiAction;
+  /** Channel address, `{param}` templates left intact. */
+  address: string;
+  /** Example payload value (undefined when none could be derived). */
+  payload?: unknown;
+  /** First server the channel is available on, if any. */
+  server?: AsyncApiServerObject;
+}
+
+/** `host[:port]` split apart; MQTT tooling wants them as separate flags. */
+const hostParts = (server?: AsyncApiServerObject) => {
+  const raw = server?.host ?? "localhost";
+  const colon = raw.lastIndexOf(":");
+  if (colon > 0 && /^\d+$/u.test(raw.slice(colon + 1))) {
+    return { host: raw.slice(0, colon), port: raw.slice(colon + 1) };
+  }
+  return { host: raw, port: undefined };
+};
+
+/** POSIX single-quote escaping, matching `snippets.ts`. */
+const shellQuote = (text: string): string =>
+  `'${text.replaceAll("'", String.raw`'\''`)}'`;
+
+const payloadJson = (sample: MessageSample): string =>
+  toJson(sample.payload ?? {});
+
+/** Compact single-line payload for shell `-m`/`echo` arguments. */
+const payloadInline = (sample: MessageSample): string =>
+  JSON.stringify(sample.payload ?? {});
+
+/** `wss://host/path` for a WebSocket channel; the address is the path. */
+const wsUrl = (sample: MessageSample): string => {
+  const { server } = sample;
+  const scheme = server?.protocol === "ws" ? "ws" : "wss";
+  const host = server?.host ?? "localhost";
+  const base = `${server?.pathname ?? ""}/${sample.address}`.replaceAll(
+    /\/+/gu,
+    "/"
+  );
+  return `${scheme}://${host}${base === "/" ? "" : base}`;
+};
+
+const wscatSnippet = (sample: MessageSample): string => {
+  const connect = `wscat -c ${shellQuote(wsUrl(sample))}`;
+  return sample.action === "receive"
+    ? `${connect}\n> ${payloadInline(sample)}`
+    : `# Prints each message as it arrives\n${connect}`;
+};
+
+const webSocketSnippet = (sample: MessageSample): string => {
+  const open = `const socket = new WebSocket(${JSON.stringify(wsUrl(sample))});`;
+  if (sample.action === "receive") {
+    return [
+      open,
+      "",
+      'socket.addEventListener("open", () => {',
+      `  socket.send(JSON.stringify(${payloadJson(sample).replaceAll("\n", "\n  ")}));`,
+      "});",
+    ].join("\n");
+  }
+  return [
+    open,
+    "",
+    'socket.addEventListener("message", (event) => {',
+    "  console.log(JSON.parse(event.data));",
+    "});",
+  ].join("\n");
+};
+
+const kcatSnippet = (sample: MessageSample): string => {
+  const broker = sample.server?.host ?? "localhost:9092";
+  const base = `kcat -b ${shellQuote(broker)} -t ${shellQuote(sample.address)}`;
+  return sample.action === "receive"
+    ? `echo ${shellQuote(payloadInline(sample))} | ${base} -P`
+    : `${base} -C`;
+};
+
+const mosquittoSnippet = (sample: MessageSample): string => {
+  const { host, port } = hostParts(sample.server);
+  const target = `-h ${shellQuote(host)}${port ? ` -p ${port}` : ""} -t ${shellQuote(sample.address)}`;
+  return sample.action === "receive"
+    ? `mosquitto_pub ${target} -m ${shellQuote(payloadInline(sample))}`
+    : `mosquitto_sub ${target} -v`;
+};
+
+/** One renderable sample tool: tab id/label, Shiki language, builder. */
+export interface AsyncSampleLanguage {
+  id: string;
+  label: string;
+  lang: string;
+  build: (sample: MessageSample) => string;
+}
+
+const TOOLS = {
+  js: { build: webSocketSnippet, id: "js", label: "JavaScript", lang: "js" },
+  kcat: { build: kcatSnippet, id: "kcat", label: "kcat", lang: "bash" },
+  mosquitto: {
+    build: mosquittoSnippet,
+    id: "mosquitto",
+    label: "mosquitto",
+    lang: "bash",
+  },
+  wscat: { build: wscatSnippet, id: "wscat", label: "wscat", lang: "bash" },
+} satisfies Record<string, AsyncSampleLanguage>;
+
+type ToolId = keyof typeof TOOLS;
+
+/** The tools appropriate to each protocol binding, in display order. */
+const PROTOCOL_TOOLS = new Map<string, readonly ToolId[]>([
+  ["kafka", ["kcat"]],
+  ["mqtt", ["mosquitto"]],
+  ["ws", ["wscat", "js"]],
+]);
+
+/** Accepted spellings for configured `codeSamples` ids. */
+const ALIASES = new Map<string, ToolId>([
+  ["javascript", "js"],
+  ["kafkacat", "kcat"],
+  ["mosquitto_pub", "mosquitto"],
+  ["mosquitto_sub", "mosquitto"],
+  ["node", "js"],
+  ["typescript", "js"],
+  ["websocket", "js"],
+]);
+
+/**
+ * The sample tools to render for an operation. The protocol picks the
+ * candidate set; a non-empty `codeSamples` config filters and orders it
+ * (unknown ids are dropped, aliases accepted). No protocol, an unsupported
+ * one, or a filter that matches nothing yields no samples.
+ */
+export const asyncSampleLanguages = (
+  ids: string[],
+  protocol?: string
+): AsyncSampleLanguage[] => {
+  const candidates = PROTOCOL_TOOLS.get(protocol ?? "") ?? [];
+  if (candidates.length === 0) {
+    return [];
+  }
+  if (ids.length === 0) {
+    return candidates.map((id) => TOOLS[id]);
+  }
+  const chosen: AsyncSampleLanguage[] = [];
+  const seen = new Set<string>();
+  for (const raw of ids) {
+    // Case-insensitive like `sampleLanguages` — the docs spell the tools
+    // `WebSocket`/`mosquitto_pub`, so configured ids arrive in any casing.
+    const id = ALIASES.get(raw.toLowerCase()) ?? raw.toLowerCase();
+    const match = candidates.find((candidate) => candidate === id);
+    if (match && !seen.has(match)) {
+      seen.add(match);
+      chosen.push(TOOLS[match]);
+    }
+  }
+  return chosen;
+};

package/src/components/openapi/async.ts

@@ -0,0 +1,348 @@
+import type {
+  AsyncApiChannelObject,
+  AsyncApiDocument,
+  AsyncApiOperationObject,
+  AsyncApiRefLike,
+  AsyncApiServerObject,
+  AsyncApiSpecValue,
+} from "../../openapi/asyncapi.ts";
+import type { ParameterLike, SchemaLike } from "./helpers.ts";
+import { resolveComponentRef } from "./helpers.ts";
+
+/**
+ * Runtime helpers for the AsyncAPI components — the async counterpart of
+ * `helpers.ts`. These operate on the normalized 3.x document behind the
+ * `blume:openapi` alias, resolving the ref shapes AsyncAPI adds on top of
+ * `#/components/*`: operations point at channels, channel messages may `$ref`
+ * `#/components/messages`, and operation messages point *into* a channel
+ * (`#/channels/<id>/messages/<name>`). Browser-safe like the rest of the set.
+ */
+
+/** A permissive view of an AsyncAPI message — only the fields we render. */
+export interface AsyncApiMessageLike extends AsyncApiRefLike {
+  name?: string;
+  title?: string;
+  summary?: string;
+  description?: string;
+  contentType?: string;
+  payload?: AsyncApiSpecValue;
+  headers?: AsyncApiSpecValue;
+  examples?: {
+    name?: string;
+    summary?: string;
+    payload?: AsyncApiSpecValue;
+    headers?: AsyncApiSpecValue;
+  }[];
+  bindings?: AsyncApiChannelObject["bindings"];
+}
+
+/** A message paired with its channel-map key (the fallback display name). */
+export interface NamedMessage {
+  key: string;
+  message: AsyncApiMessageLike;
+}
+
+const isObject = (
+  value: AsyncApiSpecValue
+): value is Record<string, AsyncApiSpecValue> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+/** Permissive spec nodes may lie about declared string fields; verify first. */
+const isString = (value: AsyncApiSpecValue): value is string =>
+  typeof value === "string";
+
+/** Decode a JSON-pointer token: `user~1signedup` -> `user/signedup`. */
+const unescapePointer = (token: string): string =>
+  token.replaceAll("~1", "/").replaceAll("~0", "~");
+
+const CHANNEL_MESSAGE_REF =
+  /^#\/channels\/(?<channel>.+)\/messages\/(?<name>[^/]+)$/u;
+
+type Components = AsyncApiDocument["components"];
+
+/** Resolve a channel-map message (possibly a components `$ref`) to its object. */
+const channelMessage = (
+  raw: AsyncApiRefLike | undefined,
+  components: Components
+): AsyncApiMessageLike | undefined => {
+  if (!isObject(raw)) {
+    return undefined;
+  }
+  const resolved = resolveComponentRef(raw, components, "messages");
+  // Still a bare `$ref` after resolution means it pointed nowhere useful.
+  if (isString(resolved.$ref)) {
+    return undefined;
+  }
+  // SAFETY: `resolved` is a plain message object; the permissive message view
+  // only narrows the fields the components render, all of them optional.
+  return resolved as AsyncApiMessageLike;
+};
+
+/**
+ * The messages one operation carries: its own `messages` refs when declared
+ * (each pointing into the channel's message map or at a components message),
+ * else every message the channel declares. Unresolvable refs are dropped —
+ * the schema tables can only render an actual message object.
+ */
+export const operationMessages = (
+  operation: AsyncApiOperationObject | undefined,
+  channel: AsyncApiChannelObject | undefined,
+  document: AsyncApiDocument
+): NamedMessage[] => {
+  const { components } = document;
+  const messageMap: Record<string, AsyncApiRefLike> = isObject(
+    channel?.messages
+  )
+    ? channel.messages
+    : {};
+  const refs = operation?.messages;
+  if (!Array.isArray(refs) || refs.length === 0) {
+    const all: NamedMessage[] = [];
+    for (const [key, raw] of Object.entries(messageMap)) {
+      const message = channelMessage(raw, components);
+      if (message) {
+        all.push({ key, message });
+      }
+    }
+    return all;
+  }
+  const named: NamedMessage[] = [];
+  for (const ref of refs) {
+    if (!isObject(ref)) {
+      continue;
+    }
+    const pointer = isString(ref.$ref)
+      ? CHANNEL_MESSAGE_REF.exec(ref.$ref)?.groups?.name
+      : undefined;
+    const key = pointer === undefined ? undefined : unescapePointer(pointer);
+    // A channel-message pointer resolves through the channel map; anything
+    // else (a components ref, an inline message) resolves directly.
+    const message =
+      key === undefined
+        ? channelMessage(ref, components)
+        : channelMessage(messageMap[key], components);
+    if (message) {
+      named.push({ key: key ?? message.name ?? "message", message });
+    }
+  }
+  return named;
+};
+
+/** A message's display name: its `name`/`title`, else its channel-map key. */
+export const messageLabel = (named: NamedMessage): string =>
+  named.message.title ?? named.message.name ?? named.key;
+
+/**
+ * The `schemaFormat` media types whose schemas render as JSON Schema: the
+ * AsyncAPI Schema Object (a JSON Schema superset), OpenAPI Schema Objects,
+ * and JSON Schema itself, in their bare and `+json`/`+yaml` spellings.
+ */
+const JSON_SCHEMA_FORMAT =
+  /^application\/(?:vnd\.aai\.asyncapi|vnd\.oai\.openapi|schema)(?:\+(?:json|yaml))?$/u;
+
+/**
+ * The JSON-schema view of a possibly multi-format schema value
+ * (`{ schemaFormat, schema }`, allowed on both message payloads and headers).
+ * Unwraps when the format is JSON-schema compatible and yields nothing
+ * otherwise (an Avro or Protobuf schema can't render as a schema table —
+ * callers fall back to a note).
+ */
+export const schemaOf = (value: AsyncApiSpecValue): SchemaLike | undefined => {
+  if (!isObject(value)) {
+    return undefined;
+  }
+  if (isString(value.schemaFormat) && "schema" in value) {
+    // Match the media type proper (parameters like `;version=…` stripped)
+    // against the JSON-Schema-compatible formats AsyncAPI registers. A
+    // substring test would misclassify e.g. Avro's `+json` encoding, whose
+    // schema is JSON but not JSON Schema.
+    const format = (value.schemaFormat.split(";")[0] ?? "")
+      .trim()
+      .toLowerCase();
+    const jsonish = JSON_SCHEMA_FORMAT.test(format);
+    if (jsonish && isObject(value.schema)) {
+      // SAFETY: a JSON-Schema-format schema object; the permissive SchemaLike
+      // view only narrows the fields the schema tables render, all optional.
+      return value.schema as SchemaLike;
+    }
+    return undefined;
+  }
+  // SAFETY: a bare schema object; the permissive SchemaLike view only narrows
+  // the fields the schema tables render, all of them optional.
+  return value as SchemaLike;
+};
+
+/** The JSON-schema view of a message payload; see {@link schemaOf}. */
+export const payloadSchema = (
+  message: AsyncApiMessageLike
+): SchemaLike | undefined => schemaOf(message.payload);
+
+/** The channel-parameter fields {@link channelParameters} lowers. */
+interface AsyncApiParameterLike extends AsyncApiRefLike {
+  description?: string;
+  default?: AsyncApiSpecValue;
+  enum?: AsyncApiSpecValue[];
+}
+
+/**
+ * Channel parameters lowered into the shared parameter-table shape. AsyncAPI
+ * 3.x parameters are always strings (`enum`/`default`/`examples`, no schema),
+ * and every one is required — an address template can't resolve without it.
+ */
+export const channelParameters = (
+  channel: AsyncApiChannelObject | undefined,
+  document: AsyncApiDocument
+): ParameterLike[] => {
+  const parameters: ParameterLike[] = [];
+  const declared: Record<string, AsyncApiRefLike> = channel?.parameters ?? {};
+  for (const [name, raw] of Object.entries(declared)) {
+    if (!isObject(raw)) {
+      continue;
+    }
+    // SAFETY: the permissive parameter view only narrows the fields lowered
+    // below; each one is runtime-checked before use.
+    const parameter = resolveComponentRef(
+      raw as AsyncApiParameterLike,
+      document.components,
+      "parameters"
+    );
+    const schema: SchemaLike = { type: "string" };
+    if (Array.isArray(parameter.enum)) {
+      schema.enum = parameter.enum;
+    }
+    if (parameter.default !== undefined) {
+      schema.default = parameter.default;
+    }
+    parameters.push({
+      description: isString(parameter.description)
+        ? parameter.description
+        : undefined,
+      in: "channel",
+      name,
+      required: true,
+      schema,
+    });
+  }
+  return parameters;
+};
+
+const SERVER_REF = /^#\/servers\/(?<name>[^/]+)$/u;
+
+/**
+ * The servers a channel is available on: its `servers` refs when declared,
+ * else every server the document declares (the spec's default).
+ */
+export const channelServers = (
+  channel: AsyncApiChannelObject | undefined,
+  document: AsyncApiDocument
+): AsyncApiServerObject[] => {
+  const all = document.servers ?? {};
+  const refs = channel?.servers;
+  if (!Array.isArray(refs) || refs.length === 0) {
+    return Object.values(all).filter(isObject);
+  }
+  const servers: AsyncApiServerObject[] = [];
+  for (const ref of refs) {
+    const name = SERVER_REF.exec(
+      isObject(ref) && isString(ref.$ref) ? ref.$ref : ""
+    )?.groups?.name;
+    const server = name === undefined ? undefined : all[unescapePointer(name)];
+    if (isObject(server)) {
+      servers.push(server);
+    }
+  }
+  return servers;
+};
+
+/** Normalize protocol spellings onto the binding key they document. */
+const PROTOCOL_ALIASES = {
+  "kafka-secure": "kafka",
+  mqtt5: "mqtt",
+  mqtts: "mqtt",
+  "secure-mqtt": "mqtt",
+  wss: "ws",
+};
+
+/**
+ * The protocol an operation speaks, for binding-aware code samples: the first
+ * operation/channel binding key, else the first relevant server's `protocol`.
+ */
+export const protocolOf = (
+  operation: AsyncApiOperationObject | undefined,
+  channel: AsyncApiChannelObject | undefined,
+  servers: AsyncApiServerObject[]
+): string | undefined => {
+  const declared =
+    Object.keys(operation?.bindings ?? {})[0] ??
+    Object.keys(channel?.bindings ?? {})[0] ??
+    servers.find((server) => isString(server.protocol))?.protocol;
+  if (!isString(declared) || declared === "") {
+    return undefined;
+  }
+  const lower = declared.toLowerCase();
+  // SAFETY: guarded by the `in` check, `lower` is one of the alias keys.
+  return lower in PROTOCOL_ALIASES
+    ? PROTOCOL_ALIASES[lower as keyof typeof PROTOCOL_ALIASES]
+    : lower;
+};
+
+/**
+ * The security list an operation actually enforces: its own `security` when
+ * declared, else the union of its servers' — connecting already requires the
+ * server's schemes. Server entries dedupe by `$ref`, so two servers sharing a
+ * scheme render it once.
+ */
+export const asyncApiSecurityEntries = (
+  operation: AsyncApiOperationObject | undefined,
+  servers: AsyncApiServerObject[]
+): AsyncApiRefLike[] => {
+  if (Array.isArray(operation?.security)) {
+    return operation.security;
+  }
+  const entries: AsyncApiRefLike[] = [];
+  const seen = new Set<string>();
+  for (const server of servers) {
+    for (const entry of server.security ?? []) {
+      if (!isObject(entry)) {
+        continue;
+      }
+      if (isString(entry.$ref)) {
+        if (seen.has(entry.$ref)) {
+          continue;
+        }
+        seen.add(entry.$ref);
+      }
+      entries.push(entry);
+    }
+  }
+  return entries;
+};
+
+/** One protocol's binding fields, ready for a key/value table. */
+export interface BindingGroup {
+  protocol: string;
+  rows: { name: string; value: unknown }[];
+}
+
+/**
+ * Binding maps flattened for display, `bindingVersion` (metadata, not
+ * behavior) dropped. Values stay unformatted — the component renders schema-ish
+ * objects as nested schema tables and everything else as code.
+ */
+export const bindingGroups = (
+  bindings?: AsyncApiChannelObject["bindings"]
+): BindingGroup[] => {
+  const groups: BindingGroup[] = [];
+  for (const [protocol, fields] of Object.entries(bindings ?? {})) {
+    if (!isObject(fields)) {
+      continue;
+    }
+    const rows = Object.entries(fields)
+      .filter(([name]) => name !== "bindingVersion")
+      .map(([name, value]) => ({ name, value }));
+    if (rows.length > 0) {
+      groups.push({ protocol, rows });
+    }
+  }
+  return groups;
+};