@ggts-sh/spec 0.43.0

package/src/schema-decls-layers-point-path.ts

@@ -0,0 +1,246 @@
+/**
+ * `$defs` partial — point/path layer specs (PointLayer…PathLayer).
+ * Composed by schema-declarations.ts via spread; key insertion order is load-bearing.
+ */
+
+import Type from "typebox";
+
+export const LayersPointPathDecls = {
+  PointLayer: Type.Object(
+    {
+      geom: Type.Literal("point", {
+        description:
+          "Point geometry: one mark per data row. Use for scatter plots, dot plots, bubbles, and correlation views.",
+      }),
+      stat: Type.Optional(
+        Type.Union(
+          [
+            Type.Literal("identity", {
+              description: "Draw each data row as-is (default).",
+            }),
+            Type.Literal("unique", {
+              description: "Drop duplicate rows on mapped aesthetics before drawing; first wins.",
+            }),
+            Type.Literal("summary_bin", {
+              description: "Bin continuous x and summarize y per (group × bin); default mean ± se.",
+            }),
+            Type.Literal("summary_rolling", {
+              description:
+                "Centered rolling window over continuous x (params.window required, in x units); summarize y per (group, unique x). Partial windows at the ends are kept.",
+            }),
+            Type.Literal("manual", {
+              description:
+                "Portable named per-group transform (params.fun required: first|last|mean|median|min|max|sum;).",
+            }),
+            Type.Literal("sum", {
+              description:
+                'Aggregate coincident (x, y); size defaults to {stat: "n"} (geom_count).',
+            }),
+          ],
+          {
+            description:
+              'Point stat: "identity" (default), "unique", "summary_bin", "summary_rolling", "manual", or "sum".',
+          },
+        ),
+      ),
+      position: Type.Optional(
+        Type.Union([Type.Literal("identity"), Type.Literal("jitter"), Type.Literal("nudge")], {
+          description:
+            'Position adjustment: "identity" (default), "jitter" (seeded random offsets — configure with positionParams.width/height/seed), or "nudge" (fixed offsets — positionParams.x/y).',
+        }),
+      ),
+      positionParams: Type.Optional(Type.Ref("PositionParams")),
+      render: Type.Optional(Type.Ref("RenderBackend")),
+      aes: Type.Optional(Type.Ref("Aes")),
+      data: Type.Optional(
+        Type.Ref("DataRef", {
+          description:
+            "Optional layer-local data. When omitted, the layer inherits plot-level data. When present, it may use inline rows, inline columns, or a named dataset (spec.datasets or runtime).",
+        }),
+      ),
+      params: Type.Optional(Type.Ref("PointParams")),
+      inspect: Type.Optional(
+        Type.Literal(false, {
+          description:
+            "Set false to exclude this layer from inspection: its marks never become tooltip, hover, or keyboard-traversal candidates. For decorative layers (background bands, reference shading) whose marks would otherwise capture the pointer — an area mark contains the pointer everywhere it is painted, so it outranks every point and stroke beneath it. Portable: it travels with the spec, so headless renders and re-imported JSON agree.",
+        }),
+      ),
+    },
+    {
+      additionalProperties: false,
+      description:
+        "A scatter/point layer. Requires x and y channels (inherited from plot aes or set in the layer's aes).",
+    },
+  ),
+
+  LineLayer: Type.Object(
+    {
+      geom: Type.Literal("line", {
+        description:
+          "Line geometry: connects points in x order, one line per group (groups derive from discrete aesthetics such as color, or from aes.group). Use for time series, trends, and line charts. With stat ecdf, pair with step curves; with stat bin (freqpoly alias), y is computed from counts/density; with stat connect, successive points expand into connection vertices.",
+      }),
+      stat: Type.Optional(
+        Type.Union(
+          [
+            Type.Literal("identity", {
+              description: "Draw each data row as-is (default — map aes.y).",
+            }),
+            Type.Literal("unique", {
+              description: "Drop duplicate rows on mapped aesthetics before drawing (first wins;).",
+            }),
+            Type.Literal("bin", {
+              description:
+                'Continuous x binned; the canonical form of geom freqpoly. Do NOT map aes.y to a field; y defaults to {"stat": "count"}.',
+            }),
+            Type.Literal("align", {
+              description:
+                "Interpolate each group onto the union of finite x values so continuous-x stack/fill aligns. Outside a group's x range y is 0.",
+            }),
+            Type.Literal("connect", {
+              description:
+                "Expand successive points into connection vertices (params.connection: hv|vh|mid|linear;). Expands in x order; geometry does not re-sort after connect.",
+            }),
+            Type.Literal("summary_bin", {
+              description:
+                "Bin continuous x and summarize y per (group × bin); default mean ± se; connect centers in x order.",
+            }),
+            Type.Literal("summary_rolling", {
+              description:
+                "Centered rolling window over continuous x (params.window required, in x units); summarize y per (group, unique x) and connect in x order. Partial windows at the ends are kept — a running line reaches both ends of the data.",
+            }),
+            Type.Literal("manual", {
+              description:
+                "Portable named per-group transform (params.fun required: first|last|mean|median|min|max|sum;).",
+            }),
+            Type.Literal("ecdf", {
+              description:
+                'Empirical CDF of x; y defaults to {"stat": "ecdf"} — do NOT map aes.y to a field. Prefer params.curve "step-hv" for ECDF stairs.',
+            }),
+          ],
+          {
+            description:
+              'Line stat: "identity" (default), "unique", "bin", "align", "connect", "summary_bin", "summary_rolling", "manual", or "ecdf".',
+          },
+        ),
+      ),
+      position: Type.Optional(
+        Type.Literal("identity", { description: "Line layers use identity positioning." }),
+      ),
+      render: Type.Optional(Type.Ref("RenderBackend")),
+      aes: Type.Optional(Type.Ref("Aes")),
+      data: Type.Optional(
+        Type.Ref("DataRef", {
+          description:
+            "Optional layer-local data. When omitted, the layer inherits plot-level data. When present, it may use inline rows, inline columns, or a named dataset (spec.datasets or runtime).",
+        }),
+      ),
+      params: Type.Optional(Type.Ref("LineParams")),
+      inspect: Type.Optional(
+        Type.Literal(false, {
+          description:
+            "Set false to exclude this layer from inspection: its marks never become tooltip, hover, or keyboard-traversal candidates. For decorative layers (background bands, reference shading) whose marks would otherwise capture the pointer — an area mark contains the pointer everywhere it is painted, so it outranks every point and stroke beneath it. Portable: it travels with the spec, so headless renders and re-imported JSON agree.",
+        }),
+      ),
+    },
+    {
+      additionalProperties: false,
+      description:
+        "A line layer. Identity: requires x and y. Bin (freqpoly): requires continuous x; y is computed by the bin stat. Ecdf: requires x only (y is computed). Rows are sorted by x within each group before connecting.",
+    },
+  ),
+
+  StepLayer: Type.Object(
+    {
+      geom: Type.Literal("step", {
+        description:
+          "Step-line geometry: connect points with hv/vh/mid stairs. Same channels as line; ordered by x within groups.",
+      }),
+      stat: Type.Optional(
+        Type.Literal("identity", { description: "Step layers draw the data as-is." }),
+      ),
+      position: Type.Optional(
+        Type.Literal("identity", { description: "Step layers use identity positioning." }),
+      ),
+      render: Type.Optional(Type.Ref("RenderBackend")),
+      aes: Type.Optional(Type.Ref("Aes")),
+      data: Type.Optional(
+        Type.Ref("DataRef", {
+          description:
+            "Optional layer-local data. When omitted, the layer inherits plot-level data.",
+        }),
+      ),
+      params: Type.Optional(Type.Ref("StepParams")),
+      inspect: Type.Optional(
+        Type.Literal(false, {
+          description:
+            "Set false to exclude this layer from inspection: its marks never become tooltip, hover, or keyboard-traversal candidates. For decorative layers (background bands, reference shading) whose marks would otherwise capture the pointer — an area mark contains the pointer everywhere it is painted, so it outranks every point and stroke beneath it. Portable: it travels with the spec, so headless renders and re-imported JSON agree.",
+        }),
+      ),
+    },
+    {
+      additionalProperties: false,
+      description:
+        "A step-line layer. Requires x and y. params.direction is hv (default), vh, or mid.",
+    },
+  ),
+
+  PathLayer: Type.Object(
+    {
+      geom: Type.Literal("path", {
+        description:
+          "Path geometry: connects points in data (row) order within each group — unlike line, which sorts by x. Use for trajectories, loops, connected scatterplots, and ellipse rings (stat ellipse). With stat connect, successive points expand into connection vertices.",
+      }),
+      stat: Type.Optional(
+        Type.Union(
+          [
+            Type.Literal("identity", {
+              description: "Draw each data row as-is (default).",
+            }),
+            Type.Literal("unique", {
+              description: "Drop duplicate rows on mapped aesthetics before drawing (first wins;).",
+            }),
+            Type.Literal("connect", {
+              description:
+                "Expand successive points into connection vertices (params.connection: hv|vh|mid|linear; default hv;). stat_connect default geom is path.",
+            }),
+            Type.Literal("manual", {
+              description:
+                "Portable named per-group transform (params.fun required: first|last|mean|median|min|max|sum;).",
+            }),
+            Type.Literal("ellipse", {
+              description:
+                "Bivariate normal confidence ellipse per group. Emits perimeter samples suitable for path; requires quantitative x and y.",
+            }),
+          ],
+          {
+            description:
+              'Path stat: "identity" (default), "unique", "connect", "manual", or "ellipse".',
+          },
+        ),
+      ),
+      position: Type.Optional(
+        Type.Literal("identity", { description: "Path layers use identity positioning." }),
+      ),
+      render: Type.Optional(Type.Ref("RenderBackend")),
+      aes: Type.Optional(Type.Ref("Aes")),
+      data: Type.Optional(
+        Type.Ref("DataRef", {
+          description:
+            "Optional layer-local data. When omitted, the layer inherits plot-level data. When present, it may use inline rows, inline columns, or a named dataset (spec.datasets or runtime).",
+        }),
+      ),
+      params: Type.Optional(Type.Ref("PathParams")),
+      inspect: Type.Optional(
+        Type.Literal(false, {
+          description:
+            "Set false to exclude this layer from inspection: its marks never become tooltip, hover, or keyboard-traversal candidates. For decorative layers (background bands, reference shading) whose marks would otherwise capture the pointer — an area mark contains the pointer everywhere it is painted, so it outranks every point and stroke beneath it. Portable: it travels with the spec, so headless renders and re-imported JSON agree.",
+        }),
+      ),
+    },
+    {
+      additionalProperties: false,
+      description:
+        "A path layer. Identity/connect/manual: requires x and y; rows stay in data order. Ellipse: quantitative x and y; one closed ring per group.",
+    },
+  ),
+};

package/src/schema-decls-layers-sf-blank.ts

@@ -0,0 +1,408 @@
+/**
+ * `$defs` partial — sf/blank layer specs (SfLayer…LayerSpec).
+ * Composed by schema-declarations.ts via spread; key insertion order is load-bearing.
+ */
+
+import Type from "typebox";
+
+export const LayersSfBlankDecls = {
+  SfLayer: Type.Object(
+    {
+      geom: Type.Literal("sf", {
+        description:
+          "Simple-features geometry: already-projected GeoJSON Geometry JSON strings in a data column. Point/line/polygon families (incl. GeometryCollection of one family) with even-odd holes; use coord_sf for fixed-aspect (CRS reproject deferred).",
+      }),
+      stat: Type.Optional(
+        Type.Literal("sf", {
+          description: "Geometry expand: portable GeoJSON → drawable point/line/polygon parts.",
+        }),
+      ),
+      position: Type.Optional(
+        Type.Literal("identity", { description: "SF layers use identity positioning." }),
+      ),
+      render: Type.Optional(Type.Ref("RenderBackend")),
+      aes: Type.Optional(Type.Ref("Aes")),
+      data: Type.Optional(
+        Type.Ref("DataRef", {
+          description:
+            "Optional layer-local data. When omitted, the layer inherits plot-level data.",
+        }),
+      ),
+      params: Type.Optional(Type.Ref("SfParams")),
+      inspect: Type.Optional(
+        Type.Literal(false, {
+          description:
+            "Set false to exclude this layer from inspection: its marks never become tooltip, hover, or keyboard-traversal candidates. For decorative layers (background bands, reference shading) whose marks would otherwise capture the pointer — an area mark contains the pointer everywhere it is painted, so it outranks every point and stroke beneath it. Portable: it travels with the spec, so headless renders and re-imported JSON agree.",
+        }),
+      ),
+    },
+    {
+      additionalProperties: false,
+      description:
+        'An sf geometry layer. Requires a geometry column of GeoJSON Geometry JSON strings (params.geometry, default "geometry"). Coordinates must already be projected. Default stat is "sf".',
+    },
+  ),
+
+  SfTextParams: Type.Object(
+    {
+      geometry: Type.Optional(
+        Type.String({
+          minLength: 1,
+          description:
+            'Name of the data column holding GeoJSON Geometry JSON strings. Default "geometry".',
+        }),
+      ),
+      alpha: Type.Optional(
+        Type.Number({
+          minimum: 0,
+          maximum: 1,
+          description: "Text opacity. Must be between 0 and 1 (inclusive). Default 1.",
+        }),
+      ),
+      size: Type.Optional(
+        Type.Number({
+          exclusiveMinimum: 0,
+          description: "Font size in px. Must be greater than 0. Default 11.",
+        }),
+      ),
+      anchor: Type.Optional(
+        Type.Union([Type.Literal("start"), Type.Literal("middle"), Type.Literal("end")], {
+          description:
+            'Horizontal text anchor relative to the representative point: "start", "middle" (default), or "end".',
+        }),
+      ),
+      dx: Type.Optional(
+        Type.Number({
+          description: "Horizontal offset in px applied after positioning. Default 0.",
+        }),
+      ),
+      dy: Type.Optional(
+        Type.Number({
+          description:
+            "Vertical offset in px applied after positioning (positive = down). Default 0.",
+        }),
+      ),
+    },
+    {
+      additionalProperties: false,
+      description: "Parameters for geom_sf_text: geometry column plus text styling.",
+    },
+  ),
+
+  SfTextLayer: Type.Object(
+    {
+      geom: Type.Literal("sf_text", {
+        description:
+          "Simple-features text labels: places aes.label at representative geometry points (Multi* → one label per part; stat_sf_coordinates).",
+      }),
+      stat: Type.Optional(
+        Type.Literal("sf_coordinates", {
+          description:
+            "Extract (x,y) representative points from geometry (Multi* → one point per part).",
+        }),
+      ),
+      position: Type.Optional(
+        Type.Literal("identity", { description: "SF text layers use identity positioning." }),
+      ),
+      render: Type.Optional(Type.Ref("RenderBackend")),
+      aes: Type.Optional(Type.Ref("Aes")),
+      data: Type.Optional(
+        Type.Ref("DataRef", {
+          description:
+            "Optional layer-local data. When omitted, the layer inherits plot-level data.",
+        }),
+      ),
+      params: Type.Optional(Type.Ref("SfTextParams")),
+      inspect: Type.Optional(
+        Type.Literal(false, {
+          description:
+            "Set false to exclude this layer from inspection: its marks never become tooltip, hover, or keyboard-traversal candidates. For decorative layers (background bands, reference shading) whose marks would otherwise capture the pointer — an area mark contains the pointer everywhere it is painted, so it outranks every point and stroke beneath it. Portable: it travels with the spec, so headless renders and re-imported JSON agree.",
+        }),
+      ),
+    },
+    {
+      additionalProperties: false,
+      description:
+        'An sf text layer. Requires aes.label and a geometry column (params.geometry, default "geometry"). Does not require aes.x/y.',
+    },
+  ),
+
+  SfLabelParams: Type.Object(
+    {
+      geometry: Type.Optional(
+        Type.String({
+          minLength: 1,
+          description:
+            'Name of the data column holding GeoJSON Geometry JSON strings. Default "geometry".',
+        }),
+      ),
+      alpha: Type.Optional(
+        Type.Number({
+          minimum: 0,
+          maximum: 1,
+          description: "Label opacity. Must be between 0 and 1 (inclusive). Default 1.",
+        }),
+      ),
+      size: Type.Optional(
+        Type.Number({
+          exclusiveMinimum: 0,
+          description: "Font size in px. Must be greater than 0. Default 11.",
+        }),
+      ),
+      anchor: Type.Optional(
+        Type.Union([Type.Literal("start"), Type.Literal("middle"), Type.Literal("end")], {
+          description:
+            'Horizontal text anchor relative to the representative point: "start", "middle" (default), or "end".',
+        }),
+      ),
+      dx: Type.Optional(
+        Type.Number({
+          description: "Horizontal offset in px applied after positioning. Default 0.",
+        }),
+      ),
+      dy: Type.Optional(
+        Type.Number({
+          description:
+            "Vertical offset in px applied after positioning (positive = down). Default 0.",
+        }),
+      ),
+      padding: Type.Optional(
+        Type.Number({
+          minimum: 0,
+          description: "Box padding around the text in px. Default 3.",
+        }),
+      ),
+      radius: Type.Optional(
+        Type.Number({
+          minimum: 0,
+          description: "Box corner radius in px. Default 3.",
+        }),
+      ),
+      linewidth: Type.Optional(
+        Type.Number({
+          exclusiveMinimum: 0,
+          description: "Box stroke width in px. Default 0.5.",
+        }),
+      ),
+    },
+    {
+      additionalProperties: false,
+      description:
+        "Parameters for geom_sf_label: geometry column, text styling, and label box chrome.",
+    },
+  ),
+
+  SfLabelLayer: Type.Object(
+    {
+      geom: Type.Literal("sf_label", {
+        description:
+          "Simple-features labels with background boxes: places aes.label at representative geometry points with a measured rounded rect (Multi* → one label per part). color=ink+box stroke; fill=box background.",
+      }),
+      stat: Type.Optional(
+        Type.Literal("sf_coordinates", {
+          description:
+            "Extract (x,y) representative points from geometry (Multi* → one point per part).",
+        }),
+      ),
+      position: Type.Optional(
+        Type.Literal("identity", { description: "SF label layers use identity positioning." }),
+      ),
+      render: Type.Optional(Type.Ref("RenderBackend")),
+      aes: Type.Optional(Type.Ref("Aes")),
+      data: Type.Optional(
+        Type.Ref("DataRef", {
+          description:
+            "Optional layer-local data. When omitted, the layer inherits plot-level data.",
+        }),
+      ),
+      params: Type.Optional(Type.Ref("SfLabelParams")),
+      inspect: Type.Optional(
+        Type.Literal(false, {
+          description:
+            "Set false to exclude this layer from inspection: its marks never become tooltip, hover, or keyboard-traversal candidates. For decorative layers (background bands, reference shading) whose marks would otherwise capture the pointer — an area mark contains the pointer everywhere it is painted, so it outranks every point and stroke beneath it. Portable: it travels with the spec, so headless renders and re-imported JSON agree.",
+        }),
+      ),
+    },
+    {
+      additionalProperties: false,
+      description:
+        "An sf label layer with a background box. Requires aes.label and a geometry column. Does not require aes.x/y.",
+    },
+  ),
+
+  BlankParams: Type.Object(
+    {},
+    {
+      additionalProperties: false,
+      description:
+        "Blank layers have no paint/stat params; the object exists only so LayerSpec has a uniform optional params field.",
+    },
+  ),
+
+  BlankLayer: Type.Object(
+    {
+      geom: Type.Literal("blank", {
+        description:
+          "Blank geometry: contributes mapped aesthetics to scale training and layout without drawing marks or hit targets. No channels are required; whatever is mapped trains its scale.",
+      }),
+      stat: Type.Optional(
+        Type.Literal("identity", {
+          description: "Blank layers pass data through for scale training only.",
+        }),
+      ),
+      position: Type.Optional(
+        Type.Literal("identity", { description: "Blank layers use identity positioning." }),
+      ),
+      render: Type.Optional(Type.Ref("RenderBackend")),
+      aes: Type.Optional(Type.Ref("Aes")),
+      data: Type.Optional(
+        Type.Ref("DataRef", {
+          description:
+            "Optional layer-local data. When omitted, the layer inherits plot-level data.",
+        }),
+      ),
+      params: Type.Optional(Type.Ref("BlankParams")),
+      inspect: Type.Optional(
+        Type.Literal(false, {
+          description:
+            "Set false to exclude this layer from inspection: its marks never become tooltip, hover, or keyboard-traversal candidates. For decorative layers (background bands, reference shading) whose marks would otherwise capture the pointer — an area mark contains the pointer everywhere it is painted, so it outranks every point and stroke beneath it. Portable: it travels with the spec, so headless renders and re-imported JSON agree.",
+        }),
+      ),
+    },
+    {
+      additionalProperties: false,
+      description:
+        "An empty layer that trains scales from mapped aesthetics without emitting geometry.",
+    },
+  ),
+
+  RugLayer: Type.Object(
+    {
+      geom: Type.Literal("rug", {
+        description:
+          "Rug geometry: short ticks along panel edges for each observation. Map aes.x for bottom/top sides and/or aes.y for left/right sides.",
+      }),
+      stat: Type.Optional(
+        Type.Literal("identity", { description: "Rug layers draw the data as-is." }),
+      ),
+      position: Type.Optional(
+        Type.Literal("identity", { description: "Rug layers use identity positioning." }),
+      ),
+      render: Type.Optional(Type.Ref("RenderBackend")),
+      aes: Type.Optional(Type.Ref("Aes")),
+      data: Type.Optional(
+        Type.Ref("DataRef", {
+          description:
+            "Optional layer-local data. When omitted, the layer inherits plot-level data. When present, it may use inline rows, inline columns, or a named dataset (spec.datasets or runtime).",
+        }),
+      ),
+      params: Type.Optional(Type.Ref("RugParams")),
+      inspect: Type.Optional(
+        Type.Literal(false, {
+          description:
+            "Set false to exclude this layer from inspection: its marks never become tooltip, hover, or keyboard-traversal candidates. For decorative layers (background bands, reference shading) whose marks would otherwise capture the pointer — an area mark contains the pointer everywhere it is painted, so it outranks every point and stroke beneath it. Portable: it travels with the spec, so headless renders and re-imported JSON agree.",
+        }),
+      ),
+    },
+    {
+      additionalProperties: false,
+      description:
+        'A marginal rug layer. Default sides "bl" require both x and y; restrict sides when only one channel is mapped.',
+    },
+  ),
+
+  SpokeLayer: Type.Object(
+    {
+      geom: Type.Literal("spoke", {
+        description:
+          "Spoke geometry: one finite segment per row from (x, y) in direction angle (radians) with length radius. Endpoints are derived as xend = x + radius·cos(angle), yend = y + radius·sin(angle) in data space, then transformed like x/y. Requires continuous x and y.",
+      }),
+      stat: Type.Optional(
+        Type.Literal("identity", { description: "Spoke layers draw the data as-is." }),
+      ),
+      position: Type.Optional(
+        Type.Literal("identity", { description: "Spoke layers use identity positioning." }),
+      ),
+      render: Type.Optional(Type.Ref("RenderBackend")),
+      aes: Type.Optional(Type.Ref("Aes")),
+      data: Type.Optional(
+        Type.Ref("DataRef", {
+          description:
+            "Optional layer-local data. When omitted, the layer inherits plot-level data. When present, it may use inline rows, inline columns, or a named dataset (spec.datasets or runtime).",
+        }),
+      ),
+      params: Type.Optional(Type.Ref("SpokeParams")),
+      inspect: Type.Optional(
+        Type.Literal(false, {
+          description:
+            "Set false to exclude this layer from inspection: its marks never become tooltip, hover, or keyboard-traversal candidates. For decorative layers (background bands, reference shading) whose marks would otherwise capture the pointer — an area mark contains the pointer everywhere it is painted, so it outranks every point and stroke beneath it. Portable: it travels with the spec, so headless renders and re-imported JSON agree.",
+        }),
+      ),
+    },
+    {
+      additionalProperties: false,
+      description:
+        "A spoke layer. Requires x and y; angle and radius from aes and/or params (constants). Angle is radians.",
+    },
+  ),
+
+  LayerSpec: Type.Union(
+    [
+      Type.Ref("PointLayer"),
+      Type.Ref("LineLayer"),
+      Type.Ref("PathLayer"),
+      Type.Ref("StepLayer"),
+      Type.Ref("ColLayer"),
+      Type.Ref("BarLayer"),
+      Type.Ref("HistogramLayer"),
+      Type.Ref("FreqpolyLayer"),
+      Type.Ref("AreaLayer"),
+      Type.Ref("RibbonLayer"),
+      Type.Ref("RuleLayer"),
+      Type.Ref("HlineLayer"),
+      Type.Ref("VlineLayer"),
+      Type.Ref("JitterLayer"),
+      Type.Ref("TextLayer"),
+      Type.Ref("LabelLayer"),
+      Type.Ref("SmoothLayer"),
+      Type.Ref("QuantileLayer"),
+      Type.Ref("QqLayer"),
+      Type.Ref("QqLineLayer"),
+      Type.Ref("ContourLayer"),
+      Type.Ref("BoxplotLayer"),
+      Type.Ref("ViolinLayer"),
+      Type.Ref("DensityLayer"),
+      Type.Ref("Density2dLayer"),
+      Type.Ref("Density2dFilledLayer"),
+      Type.Ref("DotplotLayer"),
+      Type.Ref("CountLayer"),
+      Type.Ref("ErrorbarLayer"),
+      Type.Ref("LinerangeLayer"),
+      Type.Ref("PointrangeLayer"),
+      Type.Ref("CrossbarLayer"),
+      Type.Ref("MapLayer"),
+      Type.Ref("RectLayer"),
+      Type.Ref("TileLayer"),
+      Type.Ref("Bin2dLayer"),
+      Type.Ref("RasterLayer"),
+      Type.Ref("HexLayer"),
+      Type.Ref("SegmentLayer"),
+      Type.Ref("FunctionLayer"),
+      Type.Ref("PolygonLayer"),
+      Type.Ref("AblineLayer"),
+      Type.Ref("CurveLayer"),
+      Type.Ref("SfLayer"),
+      Type.Ref("SfTextLayer"),
+      Type.Ref("SfLabelLayer"),
+      Type.Ref("BlankLayer"),
+      Type.Ref("SpokeLayer"),
+      Type.Ref("RugLayer"),
+    ],
+    {
+      description:
+        "One plot layer. The `geom` field selects the geometry and determines which stat, position, and params are allowed.",
+    },
+  ),
+
+  // --- scales -----------------------------------------------------------------
+};