@marimo-team/frontend 0.24.1-dev51 → 0.24.1-dev52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marimo-team/frontend",
-  "version": "0.24.1-dev51",
+  "version": "0.24.1-dev52",
   "main": "dist/main.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -179,6 +179,7 @@
     "lint:oxlint": "oxlint --fix",
     "lint:stylelint": "stylelint src/**/*.css --fix",
     "preview": "vite preview",
+    "plugins:generate-schema": "cross-env UPDATE_PLUGIN_SCHEMA=1 vitest run src/plugins/__tests__/plugin-schema.test.ts",
     "dev:quarto": "VITE_MARIMO_ISLANDS=true vite",
     "dev:islands": "cross-env VITE_MARIMO_ISLANDS=true vite --config islands/vite.config.mts",
     "build:islands": "cross-env VITE_MARIMO_ISLANDS=true vite --config islands/vite.config.mts build",
@@ -228,6 +229,7 @@
     "vega-typings": "^2.1.0",
     "vite": "^8.2.1",
     "vite-plugin-wasm": "^3.6.0",
-    "vitest": "^4.1.10"
+    "vitest": "^4.1.10",
+    "yaml": "^2.8.3"
   }
 }

package/src/plugins/__tests__/plugin-schema.test.ts

@@ -0,0 +1,343 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+import { parse, stringify } from "yaml";
+import { z } from "zod";
+import { LAYOUT_PLUGINS, UI_PLUGINS } from "../plugins";
+import {
+  buildPluginSpec,
+  type BuildPluginSpecOptions,
+  type PluginContract,
+  type PluginOpenAPIDocument,
+} from "./plugin-schema";
+
+const SCHEMA_PATH = resolve(
+  import.meta.dirname,
+  "../../../plugins.openapi.yaml",
+);
+const REGENERATE_COMMAND =
+  "pnpm --filter @marimo-team/frontend plugins:generate-schema";
+
+// Keep this aggregation test-only: production initialization consumes the two
+// registries directly and should not allocate or import schema-generation code.
+const ALL_PLUGINS = [...UI_PLUGINS, ...LAYOUT_PLUGINS];
+
+function schemaPath(...segments: PropertyKey[]): string {
+  return JSON.stringify(segments);
+}
+
+const ANY_WIDGET_MODEL_ID_PATH = schemaPath("properties", "modelId");
+const DATA_TABLE_STATS_COMPONENTS = new Set([
+  "marimo-table.get_column_summaries.output",
+  "marimo-table.preview_column.output",
+]);
+const DATA_TABLE_STATS_FIELDS = [
+  "min",
+  "max",
+  "std",
+  "mean",
+  "median",
+  "p5",
+  "p25",
+  "p75",
+  "p95",
+] as const;
+const DATA_TABLE_NAN_PATHS = new Set(
+  DATA_TABLE_STATS_FIELDS.flatMap((field) => [
+    schemaPath("properties", "stats", "properties", field, "anyOf", 1),
+    schemaPath(
+      "properties",
+      "stats",
+      "additionalProperties",
+      "properties",
+      field,
+      "anyOf",
+      1,
+    ),
+  ]),
+);
+const DATA_TABLE_BIN_DATE_PATHS = new Set([
+  schemaPath(
+    "properties",
+    "bin_values",
+    "additionalProperties",
+    "items",
+    "properties",
+    "bin_start",
+    "anyOf",
+    2,
+  ),
+  schemaPath(
+    "properties",
+    "bin_values",
+    "additionalProperties",
+    "items",
+    "properties",
+    "bin_end",
+    "anyOf",
+    2,
+  ),
+]);
+
+const livePluginOverrides: BuildPluginSpecOptions = {
+  unrepresentableSchemaOverride: ({ componentName, path, type }) => {
+    const pathKey = schemaPath(...path);
+
+    // These validators accept values that JSON cannot encode directly. Their
+    // explicit wire representations live here to avoid adding schema metadata
+    // or allocations to production plugin initialization.
+    if (
+      componentName === "marimo-anywidget.data" &&
+      type === "custom" &&
+      pathKey === ANY_WIDGET_MODEL_ID_PATH
+    ) {
+      return { type: "string", minLength: 1 };
+    }
+    if (
+      DATA_TABLE_STATS_COMPONENTS.has(componentName) &&
+      type === "nan" &&
+      DATA_TABLE_NAN_PATHS.has(pathKey)
+    ) {
+      return { type: "number" };
+    }
+    if (
+      componentName === "marimo-table.get_column_summaries.output" &&
+      type === "custom" &&
+      DATA_TABLE_BIN_DATE_PATHS.has(pathKey)
+    ) {
+      return { type: "string", format: "date-time" };
+    }
+    return undefined;
+  },
+};
+
+const document = buildPluginSpec(ALL_PLUGINS, livePluginOverrides);
+
+if (process.env.UPDATE_PLUGIN_SCHEMA) {
+  writeFileSync(
+    SCHEMA_PATH,
+    stringify(document, { aliasDuplicateObjects: false }),
+  );
+  process.stdout.write(`Updated ${SCHEMA_PATH}\n`);
+}
+
+function plugin(tagName: string, validator: z.ZodType): PluginContract {
+  return { tagName, validator };
+}
+
+function contractRefs(
+  doc: PluginOpenAPIDocument,
+  path: string,
+): { read: string; write: string } {
+  const contract = doc.paths[path] as {
+    get: {
+      responses: {
+        "200": {
+          content: { "application/json": { schema: { $ref: string } } };
+        };
+      };
+    };
+    put: {
+      requestBody: {
+        content: { "application/json": { schema: { $ref: string } } };
+      };
+    };
+  };
+  return {
+    read: contract.get.responses["200"].content["application/json"].schema.$ref,
+    write: contract.put.requestBody.content["application/json"].schema.$ref,
+  };
+}
+
+describe("frontend/plugins.openapi.yaml", () => {
+  it(`is in sync with the registered plugin schemas (run \`${REGENERATE_COMMAND}\` to update)`, () => {
+    if (!existsSync(SCHEMA_PATH)) {
+      throw new Error(
+        `Missing generated plugin schema at ${SCHEMA_PATH}. Run \`${REGENERATE_COMMAND}\` and commit the result.`,
+      );
+    }
+    const committed = parse(readFileSync(SCHEMA_PATH, "utf8"));
+    expect(
+      committed,
+      `The committed plugin schema is stale. Run \`${REGENERATE_COMMAND}\` and commit frontend/plugins.openapi.yaml.`,
+    ).toEqual(document);
+  });
+
+  it("contains every plugin data and RPC schema", () => {
+    const expectedContracts = ALL_PLUGINS.reduce(
+      (count, registeredPlugin) =>
+        count +
+        1 +
+        2 *
+          Object.keys(
+            "functions" in registeredPlugin
+              ? (registeredPlugin.functions ?? {})
+              : {},
+          ).length,
+      0,
+    );
+    expect(
+      Object.keys(document.components.schemas).length,
+    ).toBeGreaterThanOrEqual(expectedContracts);
+    expect(Object.keys(document.paths)).toHaveLength(expectedContracts);
+
+    for (const registeredPlugin of ALL_PLUGINS as PluginContract[]) {
+      const dataName = `${registeredPlugin.tagName}.data`;
+      expect(
+        Object.hasOwn(document.components.schemas, dataName),
+        `Missing data component ${dataName}`,
+      ).toBe(true);
+      expect(
+        Object.hasOwn(
+          document.paths,
+          `/plugins/${registeredPlugin.tagName}/data`,
+        ),
+        `Missing data path for ${registeredPlugin.tagName}`,
+      ).toBe(true);
+
+      for (const functionName of Object.keys(
+        registeredPlugin.functions ?? {},
+      )) {
+        for (const direction of ["input", "output"] as const) {
+          const componentName = `${registeredPlugin.tagName}.${functionName}.${direction}`;
+          expect(
+            Object.hasOwn(document.components.schemas, componentName),
+            `Missing RPC component ${componentName}`,
+          ).toBe(true);
+          expect(
+            Object.hasOwn(
+              document.paths,
+              `/plugins/${registeredPlugin.tagName}/functions/${functionName}/${direction}`,
+            ),
+            `Missing RPC path for ${componentName}`,
+          ).toBe(true);
+        }
+      }
+    }
+  });
+
+  it("models representative data and RPC schemas bidirectionally", () => {
+    expect(contractRefs(document, "/plugins/marimo-button/data")).toEqual({
+      read: "#/components/schemas/marimo-button.data",
+      write: "#/components/schemas/marimo-button.data",
+    });
+    expect(
+      contractRefs(document, "/plugins/marimo-table/functions/search/input"),
+    ).toEqual({
+      read: "#/components/schemas/marimo-table.search.input",
+      write: "#/components/schemas/marimo-table.search.input",
+    });
+    expect(
+      contractRefs(document, "/plugins/marimo-table/functions/search/output"),
+    ).toEqual({
+      read: "#/components/schemas/marimo-table.search.output",
+      write: "#/components/schemas/marimo-table.search.output",
+    });
+  });
+
+  it("contains no dangling Zod definitions", () => {
+    expect(JSON.stringify(document)).not.toContain("#/$defs");
+  });
+});
+
+describe("buildPluginSpec", () => {
+  it("emits accepted input shapes for defaults and transforms", () => {
+    const doc = buildPluginSpec([
+      plugin(
+        "test-input",
+        z.object({
+          defaulted: z.string().default("default"),
+          transformed: z.string().transform((value) => value.length),
+        }),
+      ),
+    ]);
+    const schema = doc.components.schemas["test-input.data"] as {
+      properties: Record<string, { type: string; default?: unknown }>;
+      required?: string[];
+    };
+
+    expect(schema.properties.defaulted).toEqual({
+      type: "string",
+      default: "default",
+    });
+    expect(schema.properties.transformed.type).toBe("string");
+    expect(schema.required).toEqual(["transformed"]);
+  });
+
+  it("only rewrites shared-definition references", () => {
+    const referenceLikeValue = "#/components/schemas/__shared#/$defs/schema0";
+    const doc = buildPluginSpec([
+      plugin("test-reference-like-value", z.literal(referenceLikeValue)),
+    ]);
+
+    expect(
+      doc.components.schemas["test-reference-like-value.data"],
+    ).toMatchObject({ const: referenceLikeValue });
+  });
+
+  it("resolves recursive schemas through their OpenAPI component", () => {
+    interface RecursiveValue {
+      children: RecursiveValue[];
+    }
+    const recursive: z.ZodType<RecursiveValue> = z.lazy(() =>
+      z.object({ children: z.array(recursive) }),
+    );
+    const doc = buildPluginSpec([plugin("test-recursive", recursive)]);
+
+    expect(
+      JSON.stringify(doc.components.schemas["test-recursive.data"]),
+    ).toContain('"$ref":"#/components/schemas/test-recursive.data"');
+    expect(JSON.stringify(doc)).not.toContain("#/$defs");
+  });
+
+  it("uses explicit metadata for JSON-unrepresentable schemas", () => {
+    const doc = buildPluginSpec([
+      plugin(
+        "test-date",
+        z.instanceof(Date).meta({ type: "string", format: "date-time" }),
+      ),
+    ]);
+    expect(doc.components.schemas["test-date.data"]).toEqual({
+      type: "string",
+      format: "date-time",
+    });
+
+    expect(() =>
+      buildPluginSpec([
+        plugin(
+          "test-custom",
+          z.custom(() => true),
+        ),
+      ]),
+    ).toThrow(/explicit JSON Schema metadata.*test-only override/);
+  });
+
+  it("rejects duplicate tags and operation IDs", () => {
+    expect(() =>
+      buildPluginSpec([
+        plugin("duplicate", z.string()),
+        plugin("duplicate", z.number()),
+      ]),
+    ).toThrow("Duplicate plugin tag name duplicate");
+
+    expect(() =>
+      buildPluginSpec([
+        plugin("operation-a-b", z.string()),
+        plugin("operation-a_b", z.string()),
+      ]),
+    ).toThrow("Duplicate OpenAPI operationId");
+  });
+
+  it("rejects unresolved local component references", () => {
+    expect(() =>
+      buildPluginSpec([
+        plugin(
+          "test-missing-ref",
+          z.string().meta({ $ref: "#/components/schemas/Missing" }),
+        ),
+      ]),
+    ).toThrow("Unresolved OpenAPI component reference");
+  });
+});

package/src/plugins/__tests__/plugin-schema.ts

@@ -0,0 +1,398 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { z, type ZodType } from "zod";
+import type { PluginFunctions } from "../core/rpc";
+import type { IPlugin } from "../types";
+
+export type PluginContract = Pick<
+  IPlugin<unknown, unknown, PluginFunctions>,
+  "tagName" | "validator" | "functions"
+>;
+
+export interface PluginOpenAPIDocument {
+  openapi: "3.1.0";
+  info: {
+    title: string;
+    version: string;
+    description: string;
+  };
+  tags: Array<{ name: string; description: string }>;
+  paths: Record<string, Record<string, unknown>>;
+  components: {
+    schemas: Record<string, Record<string, unknown>>;
+  };
+}
+
+export interface UnrepresentableSchemaContext {
+  componentName: string;
+  path: PropertyKey[];
+  type: string;
+}
+
+export interface BuildPluginSpecOptions {
+  unrepresentableSchemaOverride?: (
+    context: UnrepresentableSchemaContext,
+  ) => Record<string, unknown> | undefined;
+}
+
+const IDENTIFIER = /^[A-Za-z0-9._-]+$/;
+const UNREPRESENTABLE_ZOD_TYPES = new Set([
+  "bigint",
+  "custom",
+  "date",
+  "function",
+  "map",
+  "nan",
+  "set",
+  "symbol",
+  "transform",
+  "undefined",
+  "void",
+]);
+const JSON_SCHEMA_SHAPE_KEYS = [
+  "$ref",
+  "allOf",
+  "anyOf",
+  "const",
+  "enum",
+  "not",
+  "oneOf",
+  "type",
+] as const;
+
+function assertIdentifier(value: string, kind: string): void {
+  if (!IDENTIFIER.test(value)) {
+    throw new Error(
+      `${kind} ${JSON.stringify(value)} must match ${IDENTIFIER.source}`,
+    );
+  }
+}
+
+function hasJSONSchemaShape(metadata: Record<string, unknown>): boolean {
+  return JSON_SCHEMA_SHAPE_KEYS.some((key) => key in metadata);
+}
+
+function getZodSchemaType(schema: unknown): string {
+  const definitions = schema as unknown as {
+    def?: { type?: unknown };
+    _zod?: { def?: { type?: unknown } };
+  };
+  const type = definitions.def?.type ?? definitions._zod?.def?.type;
+  if (typeof type !== "string") {
+    throw new Error("Unable to determine the Zod schema type");
+  }
+  return type;
+}
+
+function rewriteSharedReference(
+  reference: string,
+  componentName: string,
+): string {
+  const prefix = "#/components/schemas/__shared#/$defs/";
+  return reference.startsWith(prefix)
+    ? `#/components/schemas/${componentName}.def.${reference.slice(prefix.length)}`
+    : reference;
+}
+
+function rewriteSharedReferences(
+  value: unknown,
+  componentName: string,
+): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => rewriteSharedReferences(item, componentName));
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [
+      key,
+      key === "$ref" && typeof item === "string"
+        ? rewriteSharedReference(item, componentName)
+        : rewriteSharedReferences(item, componentName),
+    ]),
+  );
+}
+
+function withoutDocumentMetadata(
+  schema: Record<string, unknown>,
+): Record<string, unknown> {
+  const { $id: _id, $schema: _schema, ...component } = schema;
+  return component;
+}
+
+function toComponentSchemas(
+  componentName: string,
+  schema: ZodType,
+  options: BuildPluginSpecOptions,
+): Record<string, Record<string, unknown>> {
+  const registry = z.registry<{ id: string }>();
+  registry.add(schema, { id: componentName });
+  const unrepresentablePaths = new Set<string>();
+  // Zod may visit the same emitted path more than once, such as for both an
+  // underlying custom schema and its metadata-bearing clone. The path is valid
+  // when any visit provides an explicit JSON Schema representation.
+  const representedPaths = new Set<string>();
+
+  const result = z.toJSONSchema(registry, {
+    io: "input",
+    unrepresentable: "any",
+    uri: (id) => `#/components/schemas/${id}`,
+    override: ({ jsonSchema, path, zodSchema }) => {
+      const type = getZodSchemaType(zodSchema);
+      if (!UNREPRESENTABLE_ZOD_TYPES.has(type)) {
+        return;
+      }
+
+      const pathKey = JSON.stringify(path);
+      const metadata = z.globalRegistry.get(zodSchema) ?? {};
+      if (hasJSONSchemaShape(metadata)) {
+        representedPaths.add(pathKey);
+        return;
+      }
+
+      const override = options.unrepresentableSchemaOverride?.({
+        componentName,
+        path,
+        type,
+      });
+      if (override && hasJSONSchemaShape(override)) {
+        Object.assign(jsonSchema, override);
+        representedPaths.add(pathKey);
+      } else {
+        unrepresentablePaths.add(pathKey);
+      }
+    },
+  });
+  for (const path of unrepresentablePaths) {
+    if (!representedPaths.has(path)) {
+      throw new Error(
+        `Zod schema at ${path} in ${componentName} is not representable in JSON Schema; add explicit JSON Schema metadata with .meta(...) or a narrowly scoped test-only override`,
+      );
+    }
+  }
+  const generated = result.schemas[componentName];
+  if (!generated) {
+    throw new Error(`Zod did not generate component ${componentName}`);
+  }
+
+  const components: Record<string, Record<string, unknown>> = {
+    [componentName]: withoutDocumentMetadata(
+      rewriteSharedReferences(generated, componentName) as Record<
+        string,
+        unknown
+      >,
+    ),
+  };
+  const shared = result.schemas.__shared as
+    | { $defs?: Record<string, Record<string, unknown>> }
+    | undefined;
+  for (const [definitionName, definition] of Object.entries(
+    shared?.$defs ?? {},
+  )) {
+    const name = `${componentName}.def.${definitionName}`;
+    assertIdentifier(name, "Generated definition name");
+    components[name] = withoutDocumentMetadata(
+      rewriteSharedReferences(definition, componentName) as Record<
+        string,
+        unknown
+      >,
+    );
+  }
+  return components;
+}
+
+function operationSuffix(componentName: string): string {
+  return componentName.replaceAll(/[^A-Za-z0-9]+/g, "_");
+}
+
+function addBidirectionalContract({
+  paths,
+  operationIds,
+  path,
+  componentName,
+  summary,
+  tag,
+}: {
+  paths: Record<string, Record<string, unknown>>;
+  operationIds: Set<string>;
+  path: string;
+  componentName: string;
+  summary: string;
+  tag: string;
+}): void {
+  if (paths[path]) {
+    throw new Error(`Duplicate OpenAPI path ${path}`);
+  }
+
+  const suffix = operationSuffix(componentName);
+  const readOperationId = `read_${suffix}`;
+  const writeOperationId = `write_${suffix}`;
+  for (const operationId of [readOperationId, writeOperationId]) {
+    if (operationIds.has(operationId)) {
+      throw new Error(`Duplicate OpenAPI operationId ${operationId}`);
+    }
+    operationIds.add(operationId);
+  }
+
+  const ref = { $ref: `#/components/schemas/${componentName}` };
+  paths[path] = {
+    summary,
+    get: {
+      operationId: readOperationId,
+      summary: `Read ${summary}`,
+      tags: [tag],
+      responses: {
+        "200": {
+          description: `${summary} accepted by a plugin consumer.`,
+          content: { "application/json": { schema: ref } },
+        },
+      },
+    },
+    put: {
+      operationId: writeOperationId,
+      summary: `Write ${summary}`,
+      tags: [tag],
+      requestBody: {
+        required: true,
+        content: { "application/json": { schema: ref } },
+      },
+      responses: { "204": { description: "Accepted." } },
+    },
+  };
+}
+
+function assertLocalReferencesResolve(document: PluginOpenAPIDocument): void {
+  const visit = (value: unknown): void => {
+    if (Array.isArray(value)) {
+      value.forEach(visit);
+      return;
+    }
+    if (value === null || typeof value !== "object") {
+      return;
+    }
+
+    const record = value as Record<string, unknown>;
+    const ref = record.$ref;
+    if (typeof ref === "string") {
+      if (ref.startsWith("#/$defs")) {
+        throw new Error(`Dangling document-root Zod reference ${ref}`);
+      }
+      const prefix = "#/components/schemas/";
+      if (
+        ref.startsWith(prefix) &&
+        !document.components.schemas[ref.slice(prefix.length)]
+      ) {
+        throw new Error(`Unresolved OpenAPI component reference ${ref}`);
+      }
+    }
+    Object.values(record).forEach(visit);
+  };
+
+  visit(document);
+}
+
+/**
+ * Build a synthetic OpenAPI document for the Zod-backed plugin contracts.
+ *
+ * Each schema is exposed as both a response and request so compatibility
+ * checks catch narrowing/removals as well as newly required fields. The paths
+ * describe internal frontend/kernel contracts; they are not HTTP endpoints.
+ */
+export function buildPluginSpec(
+  plugins: readonly PluginContract[],
+  options: BuildPluginSpecOptions = {},
+): PluginOpenAPIDocument {
+  const paths: Record<string, Record<string, unknown>> = {};
+  const schemas: Record<string, Record<string, unknown>> = {};
+  const operationIds = new Set<string>();
+  const tagNames = new Set<string>();
+
+  const addComponent = (name: string, schema: ZodType): void => {
+    assertIdentifier(name, "Component name");
+    const generated = toComponentSchemas(name, schema, options);
+    for (const [generatedName, generatedSchema] of Object.entries(generated)) {
+      if (schemas[generatedName]) {
+        throw new Error(`Duplicate OpenAPI component ${generatedName}`);
+      }
+      schemas[generatedName] = generatedSchema;
+    }
+  };
+
+  for (const plugin of [...plugins].toSorted((a, b) =>
+    a.tagName.localeCompare(b.tagName),
+  )) {
+    assertIdentifier(plugin.tagName, "Plugin tag name");
+    if (tagNames.has(plugin.tagName)) {
+      throw new Error(`Duplicate plugin tag name ${plugin.tagName}`);
+    }
+    tagNames.add(plugin.tagName);
+
+    const dataComponent = `${plugin.tagName}.data`;
+    addComponent(dataComponent, plugin.validator);
+    addBidirectionalContract({
+      paths,
+      operationIds,
+      path: `/plugins/${plugin.tagName}/data`,
+      componentName: dataComponent,
+      summary: `${plugin.tagName} data`,
+      tag: "plugin-data",
+    });
+
+    const functions = Object.entries(plugin.functions ?? {}).toSorted(
+      ([a], [b]) => a.localeCompare(b),
+    );
+    for (const [functionName, contract] of functions) {
+      assertIdentifier(functionName, "Plugin function name");
+      for (const [direction, schema] of [
+        ["input", contract.input],
+        ["output", contract.output],
+      ] as const) {
+        const componentName = `${plugin.tagName}.${functionName}.${direction}`;
+        addComponent(componentName, schema);
+        addBidirectionalContract({
+          paths,
+          operationIds,
+          path: `/plugins/${plugin.tagName}/functions/${functionName}/${direction}`,
+          componentName,
+          summary: `${plugin.tagName} ${functionName} ${direction}`,
+          tag: `rpc-${direction}`,
+        });
+      }
+    }
+  }
+
+  const document: PluginOpenAPIDocument = {
+    openapi: "3.1.0",
+    info: {
+      title: "marimo plugin contracts",
+      version: "1.0.0",
+      description: [
+        "Machine-checkable description of every registered frontend plugin's",
+        "Zod-backed data and RPC contracts. This is not an HTTP API: each",
+        "synthetic GET models what consumers must accept and each PUT models",
+        "what producers may write, allowing OpenAPI diff tooling to enforce",
+        "backward compatibility in both directions.",
+        "Regenerate with: pnpm --filter @marimo-team/frontend plugins:generate-schema",
+      ].join("\n"),
+    },
+    tags: [
+      {
+        name: "plugin-data",
+        description: "Data supplied when rendering a plugin.",
+      },
+      {
+        name: "rpc-input",
+        description: "Arguments supplied to a plugin RPC function.",
+      },
+      {
+        name: "rpc-output",
+        description: "Values returned by a plugin RPC function.",
+      },
+    ],
+    paths,
+    components: { schemas },
+  };
+  assertLocalReferencesResolve(document);
+  return document;
+}

package/src/plugins/plugins.ts

@@ -97,7 +97,7 @@ export const UI_PLUGINS: IPlugin<any, unknown>[] = [
 ];
 
 // List of output / layout plugins
-const LAYOUT_PLUGINS: IStatelessPlugin<unknown>[] = [
+export const LAYOUT_PLUGINS: IStatelessPlugin<unknown>[] = [
   new AccordionPlugin(),
   new CalloutPlugin(),
   new CarouselPlugin(),