@ggts-sh/spec 0.43.0

package/src/lint-scale-rules.ts

@@ -0,0 +1,285 @@
+/**
+ * Scale-level lint rules: transform-domain-data, fractional-calendar-years.
+ * Layer rules: lint-layer-rules.ts. Orchestrator: lint.ts.
+ */
+import type { Aes, CellValue, PositionScaleSpec } from "./schema.js";
+import type { SpecAdvisory } from "./lint.js";
+import type { LintFieldOf } from "./lint-layer-rules.js";
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+// ---------------------------------------------------------------------------
+// fractional-calendar-years
+// ---------------------------------------------------------------------------
+
+/** Four-digit Gregorian-ish years; excludes tiny indices and huge scientific IDs. */
+const YEAR_LIKE_MIN = 1000;
+const YEAR_LIKE_MAX = 10_000;
+/**
+ * Distance from k/12 allowed when classifying a fractional part as a month
+ * index. ~0.02 ≈ one week of a year — tight enough to reject day-of-year
+ * fractions (i/365) while accepting float noise on m/12 (e.g. 1854.333).
+ */
+const MONTH_FRAC_TOLERANCE = 0.02;
+/** Need several points so a lone mid-year value cannot trip the rule. */
+const MIN_YEAR_LIKE_SAMPLES = 6;
+/** At least this many non-integer year-likes (months between Januaries). */
+const MIN_FRACTIONAL_SAMPLES = 3;
+/** Share of finite numbers that must be year-like (column is a calendar series). */
+const MIN_YEAR_LIKE_DOMINANCE = 0.8;
+/** Share of year-like values that must sit on the month grid (k/12). */
+const MIN_MONTH_GRID_HIT_RATE = 0.7;
+/** Share of year-like values that must be non-integer. */
+const MIN_FRACTIONAL_RATE = 0.2;
+/**
+ * Distinct month indices (0–11) required. Real monthly series hit many; pure
+ * quarter/half quantizations only hit {0,3,6,9} and must stay silent.
+ */
+const MIN_DISTINCT_MONTHS = 4;
+/** Quarter-only grids (Jan/Apr/Jul/Oct) — not enough to call "months". */
+const QUARTER_MONTH_INDEX = new Set([0, 3, 6, 9]);
+
+/**
+ * True when values look like calendar months encoded as year + month/12 on a
+ * linear scale — the Nightingale theme-specimen pitfall that labels axes and
+ * Inspect pins as decimals (`1855.9`). Pure integer years and ordinary
+ * 1000–9999 measurements quantized to quarters/halves stay silent.
+ * Exercised through lintSpec (lint-rules.test.ts), not as a public export.
+ */
+function looksLikeFractionalCalendarYears(values: readonly CellValue[]): boolean {
+  const yearLike: number[] = [];
+  let finiteCount = 0;
+  for (const value of values) {
+    if (typeof value !== "number" || !Number.isFinite(value)) continue;
+    finiteCount++;
+    if (value >= YEAR_LIKE_MIN && value < YEAR_LIKE_MAX) yearLike.push(value);
+  }
+  if (yearLike.length < MIN_YEAR_LIKE_SAMPLES) return false;
+  if (yearLike.length / finiteCount < MIN_YEAR_LIKE_DOMINANCE) return false;
+
+  const stats = fractionalYearStats(yearLike);
+  if (stats.fractional < MIN_FRACTIONAL_SAMPLES) return false;
+  if (stats.fractional / yearLike.length < MIN_FRACTIONAL_RATE) return false;
+  if (stats.monthGridHits / yearLike.length < MIN_MONTH_GRID_HIT_RATE) return false;
+  if (stats.monthIndices.size < MIN_DISTINCT_MONTHS) return false;
+  return stats.nonQuarterFractional >= 1;
+}
+
+function fractionalYearStats(yearLike: readonly number[]): {
+  fractional: number;
+  monthGridHits: number;
+  monthIndices: Set<number>;
+  nonQuarterFractional: number;
+} {
+  let fractional = 0;
+  let monthGridHits = 0;
+  const monthIndices = new Set<number>();
+  let nonQuarterFractional = 0;
+  for (const value of yearLike) {
+    const floor = Math.floor(value);
+    const frac = value - floor;
+    const isFractional = frac > 1e-9 && frac < 1 - 1e-9;
+    if (isFractional) fractional++;
+
+    // Nearest twelfth; k=12 (frac≈1) collapses to the integer edge.
+    const kRaw = Math.round(frac * 12);
+    const k = kRaw >= 12 ? 0 : kRaw;
+    const expected = kRaw >= 12 ? 1 : k / 12;
+    const dist = Math.abs(frac - expected);
+    // Integers always hit month 0; fractions must be within tolerance of k/12.
+    if (!isFractional || dist <= MONTH_FRAC_TOLERANCE) {
+      monthGridHits++;
+      monthIndices.add(isFractional ? k : 0);
+      if (isFractional && !QUARTER_MONTH_INDEX.has(k)) nonQuarterFractional++;
+    }
+  }
+  return { fractional, monthGridHits, monthIndices, nonQuarterFractional };
+}
+
+/** First year-like fractional sample for advisory copy, or null. */
+function sampleFractionalYear(values: readonly CellValue[]): number | null {
+  for (const value of values) {
+    if (typeof value !== "number" || !Number.isFinite(value)) continue;
+    if (value < YEAR_LIKE_MIN || value >= YEAR_LIKE_MAX) continue;
+    const frac = value - Math.floor(value);
+    if (frac > 1e-9 && frac < 1 - 1e-9) return value;
+  }
+  return null;
+}
+
+/** Position scale types that already treat the channel as non-linear-year. */
+function isNonLinearYearScale(config: PositionScaleSpec | undefined): boolean {
+  if (config === undefined) return false;
+  return config.type === "time" || config.type === "band";
+}
+
+/** Forward-transform domain rule for a position scale, or null if none. */
+interface TransformDomain {
+  valid(value: number): boolean;
+  /** Human label for the message ("log10" | "sqrt"). */
+  label: string;
+  /** Short description of the valid range ("positive" | "non-negative"). */
+  rule: string;
+}
+
+/**
+ * Resolve the effective forward-transform domain for a position scale, reading
+ * the spec BEFORE normalization. Both the authored legacy `type: "log"` and the
+ * canonical `transform: "log10" | "sqrt"` are covered; identity/time/untyped
+ * scales return null.
+ */
+function transformDomainOf(config: PositionScaleSpec | undefined): TransformDomain | null {
+  if (config === undefined) return null;
+  const transform = config.transform ?? (config.type === "log" ? "log10" : undefined);
+  if (transform === "log10") {
+    return { valid: (v) => v > 0, label: "log10", rule: "positive" };
+  }
+  if (transform === "sqrt") {
+    return { valid: (v) => v >= 0, label: "sqrt", rule: "non-negative" };
+  }
+  return null;
+}
+
+/** Count numeric values inside/outside a transform domain (non-numbers ignored). */
+function countTransformDomain(
+  values: readonly unknown[],
+  domain: TransformDomain,
+): readonly [inDomain: number, outOfDomain: number] {
+  let inDomain = 0;
+  let outOfDomain = 0;
+  for (const v of values) {
+    if (typeof v !== "number") continue;
+    if (domain.valid(v)) inDomain++;
+    else outOfDomain++;
+  }
+  return [inDomain, outOfDomain];
+}
+
+/** Scale-scoped advisories for one lintSpec pass. */
+function collectTransformAdvisories(input: {
+  layers: unknown[];
+  scales: Record<string, unknown> | undefined;
+  fieldOf: LintFieldOf;
+}): SpecAdvisory[] {
+  const { layers, scales, fieldOf } = input;
+  const advisories: SpecAdvisory[] = [];
+
+  // --- transform-domain-data (scale-level, once per axis) ---------------------
+  // Detect the effective forward-transform domain BEFORE normalization: an
+  // authored `type: "log"` (canonicalizes to transform: "log10") and a
+  // canonical `transform: "log10" | "sqrt"` are all handled here. log10 rejects
+  // values <= 0; sqrt rejects values < 0. The advisory fires only on MIXED data
+  // (some in-domain, some out) — all-invalid is the pipeline's error/warning.
+  //
+  // Multi-layer charts often share the same mapped field (plot aes or repeated
+  // layer aes). Memoize [inDomain, outOfDomain] per field name for this axis so
+  // a shared column is scanned once (O(n)), not once per layer (O(L·n)).
+  for (const axis of ["x", "y"] as const) {
+    const raw = scales?.[axis];
+    // Schema-invalid scale entries must not throw — lint never blocks.
+    if (raw !== undefined && !isRecord(raw)) continue;
+    const config = raw as PositionScaleSpec | undefined;
+    const domain = transformDomainOf(config);
+    if (domain === null) continue;
+    const fieldDomainCounts = new Map<string, readonly [inDomain: number, outOfDomain: number]>();
+    for (let i = 0; i < layers.length; i++) {
+      const layer = layers[i];
+      if (!isRecord(layer)) continue;
+      const layerAes = isRecord(layer["aes"]) ? (layer["aes"] as Aes) : undefined;
+      const use = fieldOf(layerAes, axis);
+      const values = use?.info.values;
+      if (use === null || values === null || values === undefined) continue;
+      let counts = fieldDomainCounts.get(use.field);
+      if (counts === undefined) {
+        counts = countTransformDomain(values, domain);
+        fieldDomainCounts.set(use.field, counts);
+      }
+      const [inDomain, outOfDomain] = counts;
+      if (inDomain > 0 && outOfDomain > 0) {
+        advisories.push({
+          code: "transform-domain-data",
+          path: `/scales/${axis}`,
+          message: `scales.${axis} is a ${domain.label} scale, but field "${use.field}" has ${outOfDomain} value(s) outside its ${domain.rule} domain alongside ${inDomain} valid — those rows will be silently dropped before stats.`,
+          suggestion: {
+            description: `Filter the out-of-domain rows deliberately, or use an identity/linear scale if ${domain.rule} values are meaningful.`,
+          },
+        });
+        break; // one advisory per axis is enough
+      }
+    }
+  }
+
+  return advisories;
+}
+
+function collectFractionalYearAdvisories(input: {
+  layers: unknown[];
+  scales: Record<string, unknown> | undefined;
+  fieldOf: LintFieldOf;
+}): SpecAdvisory[] {
+  const { layers, scales, fieldOf } = input;
+  const advisories: SpecAdvisory[] = [];
+
+  // --- fractional-calendar-years (x only, once) ------------------------------
+  // Monthly series re-encoded as year + month/12 and plotted on a default or
+  // explicit linear scale. Linear defaultTickFormat then prints 1855.9; Inspect
+  // pins echo the same. Time/band scales are out of scope (different contract).
+  // Only x: calendar-as-y is rare and ordinary 1000–9999 y measures would FP.
+  //
+  // Memoize the look-alike verdict per field so multi-layer charts scan once.
+  {
+    const axis = "x" as const;
+    const raw = scales?.[axis];
+    if (raw === undefined || isRecord(raw)) {
+      const config = raw as PositionScaleSpec | undefined;
+      if (!isNonLinearYearScale(config)) {
+        const fieldVerdict = new Map<string, boolean>();
+        let fired = false;
+        for (let i = 0; i < layers.length && !fired; i++) {
+          const layer = layers[i];
+          if (!isRecord(layer)) continue;
+          const layerAes = isRecord(layer["aes"]) ? (layer["aes"] as Aes) : undefined;
+          const use = fieldOf(layerAes, axis);
+          const values = use?.info.values;
+          if (use === null || values === null || values === undefined) continue;
+          // Only quantitative columns; temporal/string years are a different path.
+          if (use.info.type !== null && use.info.type !== "quantitative") continue;
+
+          let hit = fieldVerdict.get(use.field);
+          if (hit === undefined) {
+            hit = looksLikeFractionalCalendarYears(values);
+            fieldVerdict.set(use.field, hit);
+          }
+          if (!hit) continue;
+
+          const sample = sampleFractionalYear(values);
+          const sampleText =
+            sample === null ? "year + month/12" : String(Math.round(sample * 1000) / 1000);
+          advisories.push({
+            code: "fractional-calendar-years",
+            path: `/aes/${axis}`,
+            message: `Field "${use.field}" on ${axis} looks like calendar months encoded as fractional years (e.g. ${sampleText}) on a linear scale — tick labels and Inspect pins will show decimals like 1855.9 instead of months.`,
+            suggestion: {
+              description:
+                'Store ISO year-month or date strings ("1854-04" / "1854-04-01") and use a time scale so labels read as calendar months.',
+              example: { scales: { [axis]: { type: "time", labels: "%b %Y" } } },
+            },
+          });
+          fired = true;
+        }
+      }
+    }
+  }
+
+  return advisories;
+}
+
+export function collectScaleLintAdvisories(input: {
+  layers: unknown[];
+  scales: Record<string, unknown> | undefined;
+  fieldOf: LintFieldOf;
+}): SpecAdvisory[] {
+  return [...collectTransformAdvisories(input), ...collectFractionalYearAdvisories(input)];
+}

package/src/lint.ts

@@ -0,0 +1,126 @@
+/**
+ * Spec lint — advisories for VALID-but-questionable specs (Hadley lesson 16:
+ * "we can produce many plots that don't make sense, yet are grammatically
+ * valid"). `lintSpec()` never errors and never blocks: it returns
+ * `SpecAdvisory[]` — high value for agent-generated charts, where a
+ * grammatically valid spec can still be a meaningless plot.
+ *
+ * Distinct from the two error tiers (validate()) and from the pipeline's
+ * heuristic advisories (@ggts-sh/core `RenderModel.advisories`): lint runs
+ * BEFORE any pipeline, on the spec alone (plus inline data or a DataProfile
+ * when available — data-dependent rules skip silently without evidence).
+ *
+ * Rules considered and deliberately ABSENT (documented for auditability):
+ *  - dual-axis misuse: the grammar has no dual axes — unrepresentable.
+ *  - pie-chart overuse: polar/radial coords exist; a dedicated "prefer bar
+ *    over pie" advisory is deferred until usage evidence exists.
+ *  - text layer without a label aes: that is a validation ERROR
+ *    (`missing-required-channel`), not an advisory.
+ *  - transform scale over entirely out-of-domain data: the pipeline handles
+ *    it via the `scale-transform-domain` error (explicit limits) / warning
+ *    (data), plus the applicable censor count; the lint advisory here fires on
+ *    MIXED data (some in-domain, some out), where the silent row-drop is most
+ *    surprising.
+ *
+ * Implementation:
+ *  - lint-catalog.ts — pure advisory catalog (re-exported here)
+ *  - lint-layer-rules.ts — layer-scoped rules
+ *  - lint-scale-rules.ts — scale-level transform-domain-data and
+ *    fractional-calendar-years (year+month/12 linear pitfall)
+ *
+ * Wired into `validate(spec, { lint: true })` (advisories ride the result)
+ * and into the `ggts render` CLI (stderr JSON lines, kind "advisory",
+ * source "spec-lint").
+ */
+import type { JSONValue } from "./portability.js";
+import type { Aes, ChannelName } from "./schema.js";
+import type { FieldEvidenceEntry, FieldEvidenceMap, ValidateOptions } from "./validate-data.js";
+import {
+  DEFAULT_VALIDATE_LIMITS,
+  effectiveChannel,
+  resolveFieldEvidence,
+} from "./validate-data.js";
+
+import type { LintAdvisoryCode } from "./lint-catalog.js";
+import { collectLayerLintAdvisories } from "./lint-layer-rules.js";
+import { collectScaleLintAdvisories } from "./lint-scale-rules.js";
+
+export { LINT_CATALOG, type LintAdvisoryCode, type LintCatalogEntry } from "./lint-catalog.js";
+
+/** One lint advisory: never an error, always actionable. */
+export interface SpecAdvisory {
+  code: LintAdvisoryCode;
+  /** JSON pointer into the spec ("" = root). */
+  path: string;
+  message: string;
+  suggestion?: {
+    description: string;
+    example?: JSONValue;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Field-type evidence (inline data or DataProfile; absent = rules skip)
+// ---------------------------------------------------------------------------
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+/**
+ * Standalone evidence build (lintSpec without a shared map from validate).
+ * Merges options.limits into DEFAULT_VALIDATE_LIMITS the same way validate()
+ * does, so callers can raise or lower maxRows/maxBytes and data-aware rules
+ * honor the override (skip over-limit; never fabricate a complaint).
+ */
+function buildEvidence(
+  spec: Record<string, unknown>,
+  options: ValidateOptions | undefined,
+): FieldEvidenceMap | null {
+  const limits = { ...DEFAULT_VALIDATE_LIMITS, ...options?.limits };
+  const resolved = resolveFieldEvidence(spec, options ?? {}, limits);
+  return resolved.status === "ok" ? resolved.fields : null;
+}
+
+// ---------------------------------------------------------------------------
+// lintSpec
+// ---------------------------------------------------------------------------
+
+/**
+ * Lint a spec for valid-but-questionable constructs. `options` mirrors
+ * validate(): pass `{ profile }` to lint against out-of-band data, or let the
+ * spec's inline data provide the evidence; `options.limits` merges over
+ * DEFAULT_VALIDATE_LIMITS the same way validate() does. Rules whose evidence
+ * is missing (including over-limit inline data) skip silently — lint never
+ * fabricates a complaint.
+ *
+ * When called from validate({ lint: true }), pass `sharedEvidence` so field
+ * types/columns are not rebuilt after dataChecks already resolved them.
+ */
+export function lintSpec(
+  spec: unknown,
+  options?: ValidateOptions,
+  sharedEvidence?: FieldEvidenceMap | null,
+): SpecAdvisory[] {
+  if (!isRecord(spec) || !Array.isArray(spec["layers"])) return [];
+  const evidence = sharedEvidence === undefined ? buildEvidence(spec, options) : sharedEvidence;
+  const plotAes = isRecord(spec["aes"]) ? (spec["aes"] as Aes) : undefined;
+  const layers = spec["layers"] as unknown[];
+  const scales = isRecord(spec["scales"]) ? spec["scales"] : undefined;
+
+  const fieldOf = (
+    layerAes: Aes | undefined,
+    channel: ChannelName,
+  ): { field: string; info: FieldEvidenceEntry } | null => {
+    const mapped = effectiveChannel(plotAes, layerAes, channel);
+    if (mapped === undefined || !("field" in mapped)) return null;
+    const info = evidence?.get(mapped.field);
+    if (info === undefined) return null;
+    return { field: mapped.field, info };
+  };
+
+  return [
+    ...collectLayerLintAdvisories({ layers, fieldOf }),
+    ...collectScaleLintAdvisories({ layers, scales, fieldOf }),
+  ];
+}

package/src/normalize-coord.ts

@@ -0,0 +1,126 @@
+/**
+ * Coordinate-system canonicalization for normalize()
+ * (cartesian/flip/transform/fixed/sf/radial).
+ * Scales: normalize-scales.ts. Layer/aes orchestration: normalize.ts.
+ */
+
+import type {
+  CoordRadialSpec,
+  CoordSpec,
+  CoordTransformAxisSpec,
+  CoordTransformSpec,
+} from "./schema.js";
+
+function normalizeCoordAxis(
+  axis: CoordTransformAxisSpec | undefined,
+): CoordTransformAxisSpec | undefined {
+  if (axis === undefined) return axis;
+  const runtimeAxis = axis as unknown;
+  if (runtimeAxis === null || typeof runtimeAxis !== "object" || Array.isArray(runtimeAxis))
+    return runtimeAxis as CoordTransformAxisSpec;
+  // Preserve unknown and malformed runtime values so strict schema validation
+  // can reject them; only copy valid tuple-shaped limits defensively.
+  const record = runtimeAxis as Record<string, unknown>;
+  const normalized = {
+    ...record,
+    ...(Array.isArray(record["limits"]) && {
+      limits: [...(record["limits"] as unknown[])],
+    }),
+  } as CoordTransformAxisSpec;
+  // Drop valid defaults (including explicit undefined from option spreads);
+  // preserve malformed non-booleans for schema reject.
+  if (record["reverse"] === false || record["reverse"] === undefined) delete normalized.reverse;
+  if (record["expand"] === true || record["expand"] === undefined) delete normalized.expand;
+  return normalized;
+}
+
+function effectiveCoordAxis(axis: ReturnType<typeof normalizeCoordAxis>): boolean {
+  if (axis === undefined) return false;
+  const runtimeAxis = axis as unknown;
+  if (runtimeAxis === null || typeof runtimeAxis !== "object" || Array.isArray(runtimeAxis))
+    return true;
+  const reverse = (axis as { reverse?: unknown }).reverse;
+  const expand = (axis as { expand?: unknown }).expand;
+  // Non-boolean reverse/expand must stay effective so schema can reject them.
+  const malformedReverse = reverse !== undefined && reverse !== true && reverse !== false;
+  const malformedExpand = expand !== undefined && expand !== true && expand !== false;
+  return (
+    axis.transform !== "identity" ||
+    axis.limits !== undefined ||
+    axis.reverse === true ||
+    axis.expand === false ||
+    malformedReverse ||
+    malformedExpand ||
+    Object.keys(axis).some(
+      (key) => key !== "transform" && key !== "limits" && key !== "reverse" && key !== "expand",
+    )
+  );
+}
+
+export function normalizeCoord(coord: CoordSpec | undefined): CoordSpec | undefined {
+  if (coord === undefined) return undefined;
+  const runtimeCoord = coord as unknown;
+  if (runtimeCoord === null || typeof runtimeCoord !== "object" || Array.isArray(runtimeCoord))
+    return runtimeCoord as CoordSpec;
+  const record = runtimeCoord as Record<string, unknown>;
+  if (record["type"] === "cartesian")
+    return Object.keys(record).some((key) => key !== "type")
+      ? ({ ...record } as CoordSpec)
+      : undefined;
+  if (record["type"] === "flip") return { ...record } as CoordSpec;
+  if (record["type"] === "fixed" || record["type"] === "sf") {
+    return normalizeFixedCoord(record);
+  }
+  if (record["type"] === "radial") {
+    return normalizeRadialCoord(record);
+  }
+  if (record["type"] !== "transform") return { ...record } as CoordSpec;
+  return normalizeTransformCoord(coord as CoordTransformSpec);
+}
+
+function normalizeFixedCoord(record: Record<string, unknown>): CoordSpec {
+  const fixed = { ...record } as unknown as { type: "fixed" | "sf"; ratio?: unknown };
+  if (fixed.ratio === 1 || fixed.ratio === undefined) delete fixed.ratio;
+  return fixed as CoordSpec;
+}
+
+function normalizeRadialCoord(record: Record<string, unknown>): CoordSpec {
+  const radial = { ...record } as unknown as CoordRadialSpec & Record<string, unknown>;
+  if (radial.theta === "x" || radial.theta === undefined) delete radial.theta;
+  if (radial.start === 0 || radial.start === undefined) delete radial.start;
+  if (radial.innerRadius === 0 || radial.innerRadius === undefined) delete radial.innerRadius;
+  if (radial.expand === true || radial.expand === undefined) delete radial.expand;
+  if (radial.clip === false || radial.clip === undefined) delete radial.clip;
+  if (radial.reverse === "none" || radial.reverse === undefined) delete radial.reverse;
+  if (Array.isArray(radial.thetaLimits) && radial.thetaLimits.length === 2) {
+    radial.thetaLimits = [radial.thetaLimits[0]!, radial.thetaLimits[1]!];
+  }
+  if (Array.isArray(radial.rLimits) && radial.rLimits.length === 2) {
+    radial.rLimits = [radial.rLimits[0]!, radial.rLimits[1]!];
+  }
+  return radial;
+}
+
+function normalizeTransformCoord(transformed: CoordTransformSpec): CoordSpec | undefined {
+  const x = normalizeCoordAxis(transformed.x);
+  const y = normalizeCoordAxis(transformed.y);
+  const hasUnknownKey = Object.keys(transformed).some(
+    (key) => key !== "type" && key !== "x" && key !== "y" && key !== "clip",
+  );
+  // Default clip is true/absent; only collapse when clip is a valid default.
+  const clipIsDefault = transformed.clip === true || transformed.clip === undefined;
+  if (!effectiveCoordAxis(x) && !effectiveCoordAxis(y) && clipIsDefault && !hasUnknownKey) {
+    return undefined;
+  }
+  const normalized: CoordSpec = {
+    ...transformed,
+    type: "transform",
+    ...(effectiveCoordAxis(x) && { x: x! }),
+    ...(effectiveCoordAxis(y) && { y: y! }),
+  };
+  if (!effectiveCoordAxis(x)) delete normalized.x;
+  if (!effectiveCoordAxis(y)) delete normalized.y;
+  // Keep false and non-boolean clip (malformed) for validation.
+  if (transformed.clip === true || transformed.clip === undefined) delete normalized.clip;
+  return normalized;
+}