@ggts-sh/spec 0.43.0

package/dist/validate-data-checks-position.js

@@ -0,0 +1,204 @@
+import { temporalParserConfigurationError } from "./temporal-parse.js";
+import { parseTemporalInterval, temporalLabelConfigurationError, temporalLocaleConfigurationError, } from "./temporal-interval.js";
+import { appendTemporalKindMismatch, temporalDecisionForField, } from "./validate-data-checks-temporal.js";
+const AXIS_CHANNELS = ["x", "y"];
+const NON_TIME_TYPES_WITH_TEMPORAL_GUIDES = new Set(["band", "linear", "log"]);
+/**
+ * Temporal break/label options on an explicit non-time scale.
+ * Shared by agent `validate()` and the TypeBox-free render gate.
+ */
+export function temporalGuideTypeMismatchError(scales, axis) {
+    const config = scales?.[axis];
+    const hasGuideTemporalOption = config?.dateBreaks !== undefined ||
+        config?.dateMinorBreaks !== undefined ||
+        config?.dateLabels !== undefined ||
+        config?.locale !== undefined ||
+        config?.weekStart !== undefined;
+    if (!hasGuideTemporalOption ||
+        config?.type === undefined ||
+        !NON_TIME_TYPES_WITH_TEMPORAL_GUIDES.has(config.type)) {
+        return null;
+    }
+    return {
+        code: "scale-type-mismatch",
+        path: `/scales/${axis}`,
+        message: `scales.${axis} uses temporal break or label options with explicit type "${config.type}".`,
+        fix: {
+            description: 'Use type "time", a date/datetime scale helper, or remove the temporal option.',
+        },
+    };
+}
+/** True when the axis scale config requests temporal semantics (not band). */
+export function scaleRequestsTime(scales, axis) {
+    const config = scales?.[axis];
+    if (config?.type === "band")
+        return false;
+    if (config?.type === "time")
+        return true;
+    return [
+        config?.parse,
+        config?.temporalKind,
+        config?.timezone,
+        config?.disambiguation,
+        config?.parseFailure,
+        config?.dateBreaks,
+        config?.dateMinorBreaks,
+        config?.dateLabels,
+        config?.locale,
+        config?.weekStart,
+    ].some((value) => value !== undefined);
+}
+function temporalAxisConfigurationError(config) {
+    const effectiveParser = config?.parse ?? (config?.temporalKind === "monthDay" ? "md" : "auto");
+    const parserError = temporalParserConfigurationError(effectiveParser, {
+        ...(config?.timezone !== undefined && { timezone: config.timezone }),
+        ...(config?.disambiguation !== undefined && { disambiguation: config.disambiguation }),
+    });
+    if (parserError !== null)
+        return parserError;
+    const intervalError = temporalIntervalConfigurationError(config);
+    if (intervalError !== null)
+        return intervalError;
+    const labelError = config?.dateLabels === undefined
+        ? null
+        : temporalLabelConfigurationError(config.dateLabels, config.temporalKind);
+    if (labelError !== null)
+        return labelError;
+    return config?.locale === undefined ? null : temporalLocaleConfigurationError(config.locale);
+}
+function temporalIntervalConfigurationError(config) {
+    for (const interval of [config?.dateBreaks, config?.dateMinorBreaks]) {
+        if (interval === undefined)
+            continue;
+        try {
+            parseTemporalInterval(interval);
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : "invalid temporal interval";
+        }
+    }
+    return null;
+}
+/**
+ * Validate temporal axis configuration before field evidence is resolved.
+ * Errors here are included even when data/profile is missing or invalid.
+ * Returns invalidTemporalAxes so post-layer position checks skip broken axes.
+ */
+export function validateTemporalAxisConfiguration(scales) {
+    const errors = [];
+    const invalidTemporalAxes = new Set();
+    for (const axis of AXIS_CHANNELS) {
+        const config = scales?.[axis];
+        const mismatch = temporalGuideTypeMismatchError(scales, axis);
+        if (mismatch !== null) {
+            invalidTemporalAxes.add(axis);
+            errors.push(mismatch);
+            continue;
+        }
+        if (config?.type === "band" || !scaleRequestsTime(scales, axis))
+            continue;
+        const configurationError = temporalAxisConfigurationError(config);
+        if (configurationError === null)
+            continue;
+        invalidTemporalAxes.add(axis);
+        errors.push({
+            code: "scale-type-mismatch",
+            path: `/scales/${axis}`,
+            message: `scales.${axis} has invalid temporal configuration: ${configurationError}.`,
+            fix: {
+                description: "Correct the parser, interval, label, locale, or timezone configuration.",
+            },
+        });
+    }
+    return { errors, invalidTemporalAxes };
+}
+/** Post-layer x/y scale type compatibility against collected field uses. */
+export function checkPositionScaleDataCompatibility(input) {
+    const { scales, fields, axisFields, invalidTemporalAxes, temporalDecisionCache } = input;
+    const errors = [];
+    const evidenceOf = (use) => input.evidenceForUse?.(use) ?? fields.get(use.field);
+    for (const axis of AXIS_CHANNELS) {
+        const config = scales?.[axis];
+        const declared = config?.type === "band" ? "band" : scaleRequestsTime(scales, axis) ? "time" : config?.type;
+        if (declared === undefined || declared === "band" || invalidTemporalAxes.has(axis))
+            continue;
+        for (const use of axisFields[axis]) {
+            const info = evidenceOf(use);
+            if (info === undefined || info.type === null)
+                continue;
+            const type = info.type;
+            if (declared === "time") {
+                errors.push(...timePositionErrors(axis, use, info, config, temporalDecisionCache));
+            }
+            else if ((declared === "log" || declared === "linear") &&
+                (type === "nominal" || type === "ordinal")) {
+                errors.push(linearPositionError(axis, declared, use, type));
+            }
+        }
+    }
+    return errors;
+}
+function timePositionErrors(axis, use, info, config, cache) {
+    const effectiveParser = config?.parse ?? (config?.temporalKind === "monthDay" ? "md" : "auto");
+    const options = temporalPositionOptions(config);
+    const decision = temporalDecisionForField(cache, use.field, info, effectiveParser, options);
+    const profileTemporal = info.values === null && info.type === "temporal";
+    if (timePositionResolves(config, decision, profileTemporal)) {
+        const errors = [];
+        appendTemporalKindMismatch(errors, {
+            axis,
+            path: use.path,
+            field: use.field,
+            expected: config?.temporalKind,
+            actual: decision?.kind ?? null,
+        });
+        return errors;
+    }
+    const firstFailure = decision?.failures?.[0];
+    const detail = firstFailure === undefined
+        ? temporalDecisionDetail(decision)
+        : ` Parser ${JSON.stringify(effectiveParser)} rejected ${decision?.failedCount ?? 0} value(s), including row ${firstFailure.index}: ${JSON.stringify(firstFailure.value)}.`;
+    return [
+        {
+            code: "scale-type-mismatch",
+            path: use.path,
+            message: `scales.${axis} requests time but field "${use.field}" is ${info.type}.${detail}`,
+            fix: {
+                description: config?.parse === undefined
+                    ? `Set scales.${axis}.parse to an explicit temporal order, or set scales.${axis}.type to "band" to keep categories.`
+                    : `Correct the rejected values, choose the matching scales.${axis}.parse value, or use parseFailure: "censor" explicitly.`,
+            },
+        },
+    ];
+}
+function temporalPositionOptions(config) {
+    return {
+        ...(config?.timezone !== undefined && { timezone: config.timezone }),
+        ...(config?.disambiguation !== undefined && { disambiguation: config.disambiguation }),
+    };
+}
+function timePositionResolves(config, decision, profileTemporal) {
+    return (decision?.status === "temporal" ||
+        profileTemporal ||
+        (config?.parse !== undefined &&
+            config.parseFailure === "censor" &&
+            decision?.status === "invalid"));
+}
+function temporalDecisionDetail(decision) {
+    if (decision?.status === "ambiguous") {
+        return ` Automatic temporal inference was ambiguous between: ${decision.candidates.join(", ")}.`;
+    }
+    if (decision?.status === "invalid") {
+        return ` Automatic temporal inference failed whole-column validation for ${decision.failedCount} value(s).`;
+    }
+    return "";
+}
+function linearPositionError(axis, declared, use, type) {
+    return {
+        code: "scale-type-mismatch",
+        path: use.path,
+        message: `scales.${axis}.type is "${declared}" but field "${use.field}" is ${type}; use a band scale (or a quantitative field).`,
+        fix: { description: `Set scales.${axis}.type to "band".` },
+    };
+}
+//# sourceMappingURL=validate-data-checks-position.js.map

package/dist/validate-data-checks-position.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-data-checks-position.js","sourceRoot":"","sources":["../src/validate-data-checks-position.ts"],"names":[],"mappings":"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"}

package/dist/validate-data-checks-style-finite.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shape/linetype finite-style data-aware scale checks.
+ * Barrel: validate-data-checks-style.ts. Orchestrator: validate-data-checks.ts.
+ */
+import type { SpecError } from "./errors.js";
+import type { FieldEvidenceEntry, FieldEvidenceMap } from "./validate-data-evidence.js";
+import type { ChannelFieldUse } from "./validate-data-checks-temporal.js";
+/**
+ * Shape/linetype: continuous fields need an explicit finite-style scale type.
+ * Order: runs before numeric style / position / color so diagnostic order is stable.
+ * Uses evidenceForUse when provided so multi-table same-name fields stay independent (#844).
+ */
+export declare function checkFiniteStyleScaleDataCompatibility(input: {
+    scales: Record<string, unknown> | undefined;
+    fields: FieldEvidenceMap;
+    /**
+     * Optional per-use evidence lookup. When provided, prefer it over the
+     * last-wins `fields` union so multi-table layers with the same field name
+     * keep their own type evidence (#609 / #844).
+     */
+    evidenceForUse?: (use: ChannelFieldUse) => FieldEvidenceEntry | undefined;
+    finiteStyleFields: Record<"shape" | "linetype", ChannelFieldUse[]>;
+}): SpecError[];
+//# sourceMappingURL=validate-data-checks-style-finite.d.ts.map

package/dist/validate-data-checks-style-finite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-data-checks-style-finite.d.ts","sourceRoot":"","sources":["../src/validate-data-checks-style-finite.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACxF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAE1E;;;;GAIG;AACH,wBAAgB,sCAAsC,CAAC,KAAK,EAAE;IAC5D,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAC5C,MAAM,EAAE,gBAAgB,CAAC;IACzB;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,kBAAkB,GAAG,SAAS,CAAC;IAC1E,iBAAiB,EAAE,MAAM,CAAC,OAAO,GAAG,UAAU,EAAE,eAAe,EAAE,CAAC,CAAC;CACpE,GAAG,SAAS,EAAE,CA+Bd"}

package/dist/validate-data-checks-style-finite.js

@@ -0,0 +1,40 @@
+/**
+ * Shape/linetype: continuous fields need an explicit finite-style scale type.
+ * Order: runs before numeric style / position / color so diagnostic order is stable.
+ * Uses evidenceForUse when provided so multi-table same-name fields stay independent (#844).
+ */
+export function checkFiniteStyleScaleDataCompatibility(input) {
+    const { scales, fields, finiteStyleFields } = input;
+    const errors = [];
+    const evidenceOf = (use) => input.evidenceForUse?.(use) ?? fields.get(use.field);
+    const typeOf = (use) => evidenceOf(use)?.type ?? null;
+    for (const aesthetic of ["shape", "linetype"]) {
+        const config = scales?.[aesthetic];
+        if (config?.type !== undefined)
+            continue;
+        for (const use of finiteStyleFields[aesthetic]) {
+            const type = typeOf(use);
+            if (type !== "quantitative" && type !== "temporal")
+                continue;
+            // A binned finite style requires numeric values: the runtime rejects
+            // temporal (date/datetime) values with `unsupported-aesthetic-scale`
+            // ("cannot be mapped to named symbols", scale-style.ts). So only
+            // quantitative fields may be directed to "binned"; temporal fields must
+            // use "ordinal", which keys arbitrary values (Dates included) to symbols.
+            const isTemporal = type === "temporal";
+            errors.push({
+                code: "scale-type-mismatch",
+                path: `/scales/${aesthetic}`,
+                message: `Field "${use.field}" is ${type}, but ${aesthetic} has finite symbols and cannot infer continuous interpolation.`,
+                fix: {
+                    description: isTemporal
+                        ? `Set scales.${aesthetic}.type to "ordinal"; temporal (date/datetime) values cannot be binned onto named symbols.`
+                        : `Set scales.${aesthetic}.type to "binned", or explicitly choose "ordinal" for identifier-like values.`,
+                    example: { type: isTemporal ? "ordinal" : "binned" },
+                },
+            });
+        }
+    }
+    return errors;
+}
+//# sourceMappingURL=validate-data-checks-style-finite.js.map

package/dist/validate-data-checks-style-finite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-data-checks-style-finite.js","sourceRoot":"","sources":["../src/validate-data-checks-style-finite.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,MAAM,UAAU,sCAAsC,CAAC,KAUtD;IACC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC;IACpD,MAAM,MAAM,GAAgB,EAAE,CAAC;IAC/B,MAAM,UAAU,GAAG,CAAC,GAAoB,EAAE,EAAE,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAClG,MAAM,MAAM,GAAG,CAAC,GAAoB,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,IAAI,IAAI,IAAI,CAAC;IACvE,KAAK,MAAM,SAAS,IAAI,CAAC,OAAO,EAAE,UAAU,CAAU,EAAE,CAAC;QACvD,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,SAAS,CAAkC,CAAC;QACpE,IAAI,MAAM,EAAE,IAAI,KAAK,SAAS;YAAE,SAAS;QACzC,KAAK,MAAM,GAAG,IAAI,iBAAiB,CAAC,SAAS,CAAC,EAAE,CAAC;YAC/C,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YACzB,IAAI,IAAI,KAAK,cAAc,IAAI,IAAI,KAAK,UAAU;gBAAE,SAAS;YAC7D,qEAAqE;YACrE,qEAAqE;YACrE,iEAAiE;YACjE,wEAAwE;YACxE,0EAA0E;YAC1E,MAAM,UAAU,GAAG,IAAI,KAAK,UAAU,CAAC;YACvC,MAAM,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,qBAAqB;gBAC3B,IAAI,EAAE,WAAW,SAAS,EAAE;gBAC5B,OAAO,EAAE,UAAU,GAAG,CAAC,KAAK,QAAQ,IAAI,SAAS,SAAS,gEAAgE;gBAC1H,GAAG,EAAE;oBACH,WAAW,EAAE,UAAU;wBACrB,CAAC,CAAC,cAAc,SAAS,0FAA0F;wBACnH,CAAC,CAAC,cAAc,SAAS,+EAA+E;oBAC1G,OAAO,EAAE,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,EAAE;iBACrD;aACF,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/validate-data-checks-style-numeric.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Size/linewidth/alpha sequential/binned data-aware scale checks (incl. temporal).
+ * Barrel: validate-data-checks-style.ts. Orchestrator: validate-data-checks.ts.
+ */
+import type { SpecError } from "./errors.js";
+import type { FieldEvidenceEntry, FieldEvidenceMap } from "./validate-data-evidence.js";
+import { type ChannelFieldUse, type TemporalDecisionCache } from "./validate-data-checks-temporal.js";
+/**
+ * Size/linewidth/alpha sequential/binned scale vs field/constant types (incl. temporal).
+ * Prefers per-use evidenceForUse over the last-wins union so multi-table same-name
+ * fields keep independent types (#609 / #844).
+ */
+export declare function checkNumericStyleScaleDataCompatibility(input: {
+    scales: Record<string, unknown> | undefined;
+    fields: FieldEvidenceMap;
+    /**
+     * Optional per-use evidence lookup. When provided, prefer it over the
+     * last-wins `fields` union so multi-table layers with the same field name
+     * keep their own type evidence (#609 / #844).
+     */
+    evidenceForUse?: (use: ChannelFieldUse) => FieldEvidenceEntry | undefined;
+    numericStyleFields: Record<"size" | "linewidth" | "alpha", ChannelFieldUse[]>;
+    numericStyleScaledConstants: Record<"size" | "linewidth" | "alpha", unknown[]>;
+    temporalDecisionCache: TemporalDecisionCache;
+}): SpecError[];
+//# sourceMappingURL=validate-data-checks-style-numeric.d.ts.map

package/dist/validate-data-checks-style-numeric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-data-checks-style-numeric.d.ts","sourceRoot":"","sources":["../src/validate-data-checks-style-numeric.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACxF,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC3B,MAAM,oCAAoC,CAAC;AA6O5C;;;;GAIG;AACH,wBAAgB,uCAAuC,CAAC,KAAK,EAAE;IAC7D,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAC5C,MAAM,EAAE,gBAAgB,CAAC;IACzB;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,kBAAkB,GAAG,SAAS,CAAC;IAC1E,kBAAkB,EAAE,MAAM,CAAC,MAAM,GAAG,WAAW,GAAG,OAAO,EAAE,eAAe,EAAE,CAAC,CAAC;IAC9E,2BAA2B,EAAE,MAAM,CAAC,MAAM,GAAG,WAAW,GAAG,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;IAC/E,qBAAqB,EAAE,qBAAqB,CAAC;CAC9C,GAAG,SAAS,EAAE,CA+Fd"}

package/dist/validate-data-checks-style-numeric.js

@@ -0,0 +1,327 @@
+import { parseTemporalColumn } from "./temporal-column.js";
+import { parseTemporal } from "./temporal-parse.js";
+import { temporalDecisionForField, temporalParserUsable, } from "./validate-data-checks-temporal.js";
+/** True when a scaled constant is what the core `cellToNumber()` coerces to a
+ *  finite number, mirroring the non-temporal numeric-style path
+ *  (scale-style-values.ts). Booleans, numeric strings and ISO date strings all
+ *  train and render at runtime, so validation must accept them too. Core's
+ *  cellToNumber cannot be imported here (core depends on spec, not vice versa),
+ *  so the predicate is replicated. */
+function scaledConstantCoercesToFinite(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (value instanceof Date)
+        return Number.isFinite(value.getTime());
+    if (typeof value === "boolean")
+        return true;
+    if (typeof value === "string") {
+        if (parseTemporal(value, "iso").ok)
+            return true;
+        return value.trim() !== "" && Number.isFinite(Number(value));
+    }
+    return false;
+}
+/** Format an arbitrary value for a diagnostic message without ever throwing.
+ *  Tier-2 runs after schema errors, so a schema-invalid JS constant (BigInt,
+ *  Symbol, circular object) can reach a message; JSON.stringify throws on BigInt
+ *  and String() throws on Symbol, so fall back through both to the type name. */
+function safeFormatConstant(value) {
+    try {
+        const json = JSON.stringify(value);
+        if (json !== undefined)
+            return json;
+    }
+    catch {
+        /* BigInt / circular — fall through */
+    }
+    try {
+        return String(value);
+    }
+    catch {
+        return typeof value;
+    }
+}
+/** A quantitative field carrying temporal options resolves at runtime only when a
+ *  working parser (or censor recovery) yields temporal values. Returns a mismatch
+ *  error or null. Extracted to keep the field loop within the max-depth limit. */
+function quantitativeTemporalFieldError(input) {
+    const { decision, aesthetic, field, temporalKind, parse, parseFailure, hasEpochParser, hasExplicitDomain, hasBinnedBreaks, channelTrains, } = input;
+    const mismatch = {
+        code: "scale-type-mismatch",
+        path: `/scales/${aesthetic}`,
+        message: `scales.${aesthetic} requests temporal values but field "${field}" is quantitative (numbers are not treated as temporal without a successful epoch parse).`,
+        fix: {
+            description: `Map a temporal field, use a working parse: { epoch: "ms" | "s" }, or remove temporal ${aesthetic} options.`,
+        },
+    };
+    const censorRecovers = parseFailure === "censor" && (hasExplicitDomain || hasBinnedBreaks || channelTrains);
+    if (decision === null || decision === undefined) {
+        return profileQuantitativeTemporalError({
+            aesthetic,
+            temporalKind,
+            hasEpochParser,
+            censorRecovers,
+            mismatch,
+        });
+    }
+    const censoredInvalid = parse !== undefined &&
+        parseFailure === "censor" &&
+        decision.status === "invalid" &&
+        ((decision.validatedCount ?? 0) > 0 || hasExplicitDomain || hasBinnedBreaks || channelTrains);
+    if (decision.status !== "temporal" && !censoredInvalid)
+        return mismatch;
+    // temporalKind may be a schema-invalid non-string (e.g. a Symbol) reaching tier-2;
+    // only compare/stringify when it is a valid string, else defer to the schema diagnostic.
+    if (typeof temporalKind === "string" &&
+        decision.kind !== null &&
+        decision.kind !== undefined &&
+        decision.kind !== temporalKind) {
+        return {
+            code: "scale-type-mismatch",
+            path: `/scales/${aesthetic}`,
+            message: `scales.${aesthetic} requests temporal kind "${temporalKind}" but field "${field}" parses as "${decision.kind}".`,
+            fix: {
+                description: `Use the ${decision.kind ?? "matching"} ${aesthetic} helper or correct the source precision.`,
+            },
+        };
+    }
+    return null;
+}
+function profileQuantitativeTemporalError(input) {
+    const { aesthetic, temporalKind, hasEpochParser, censorRecovers, mismatch } = input;
+    if (hasEpochParser && typeof temporalKind === "string" && temporalKind !== "datetime") {
+        return {
+            code: "scale-type-mismatch",
+            path: `/scales/${aesthetic}`,
+            message: `scales.${aesthetic} requests temporal kind "${temporalKind}" but an epoch parser yields "datetime".`,
+            fix: {
+                description: `Set scales.${aesthetic}.temporalKind to "datetime", or use a parser that yields ${temporalKind} values.`,
+            },
+        };
+    }
+    return hasEpochParser || censorRecovers ? null : mismatch;
+}
+/** A scaled numeric-style constant is checked against the same resolution path the
+ *  runtime uses (resolveNumericStyleValueView). Returns a mismatch error, or null when
+ *  the constant resolves. Extracted so the per-constant branching does not nest under
+ *  the aesthetic/constant loops (max-depth). */
+function numericStyleConstantError(input) {
+    const { value, aesthetic, configType, requestsTemporal, temporalKind, parseUsable, parser, options, censorRecovers, } = input;
+    if (!requestsTemporal) {
+        // Non-temporal: accept exactly what cellToNumber() coerces to a finite number
+        // (numbers, Dates, booleans, numeric strings, ISO strings); reject "large", "", null.
+        if (scaledConstantCoercesToFinite(value))
+            return null;
+        return {
+            code: "scale-type-mismatch",
+            path: `/scales/${aesthetic}`,
+            message: `scales.${aesthetic}.type is "${configType}" but the scaled constant ${safeFormatConstant(value)} is not numeric; ${configType} ${aesthetic} scales need quantitative or temporal values.`,
+            fix: {
+                description: `Use a numeric scaled constant, or set scales.${aesthetic}.type to "ordinal".`,
+                example: { type: "ordinal" },
+            },
+        };
+    }
+    // Temporal: a schema-invalid parser defers to the schema error; otherwise the constant
+    // must resolve temporal (a Date is datetime), or be covered by censor recovery.
+    if (!parseUsable)
+        return null;
+    let constantKind;
+    if (value instanceof Date) {
+        constantKind = "datetime";
+    }
+    else if (typeof value === "string" || typeof value === "number") {
+        const decision = parseTemporalColumn([value], parser, options).decision;
+        constantKind = decision.status === "temporal" ? (decision.kind ?? null) : undefined;
+    }
+    else {
+        // boolean, bigint, symbol, object, null: not a temporal constant, and must not be
+        // handed to parseTemporalColumn — its evidence formatting (JSON.stringify) throws on
+        // BigInt / unserializable objects. safeFormatConstant handles the message safely.
+        constantKind = undefined;
+    }
+    if (constantKind === undefined) {
+        if (censorRecovers)
+            return null;
+        return {
+            code: "scale-type-mismatch",
+            path: `/scales/${aesthetic}`,
+            message: `scales.${aesthetic} requests temporal values but the scaled constant ${safeFormatConstant(value)} is not temporal; use a temporal constant or a working parse.`,
+            fix: {
+                description: `Use a temporal scaled constant, add a working parse: { epoch: "ms" | "s" }, or remove temporal ${aesthetic} options.`,
+            },
+        };
+    }
+    // The constant parses temporal; enforce the requested kind — the runtime throws
+    // style-temporal-kind when a datetime constant is fed to a `date` scale (or vice versa).
+    if (typeof temporalKind === "string" && constantKind !== null && constantKind !== temporalKind) {
+        return {
+            code: "scale-type-mismatch",
+            path: `/scales/${aesthetic}`,
+            message: `scales.${aesthetic} requests temporal kind "${temporalKind}" but the scaled constant ${safeFormatConstant(value)} parses as "${constantKind}".`,
+            fix: {
+                description: `Use a ${temporalKind} constant, or set scales.${aesthetic}.temporalKind to "${constantKind}".`,
+            },
+        };
+    }
+    return null;
+}
+/**
+ * Size/linewidth/alpha sequential/binned scale vs field/constant types (incl. temporal).
+ * Prefers per-use evidenceForUse over the last-wins union so multi-table same-name
+ * fields keep independent types (#609 / #844).
+ */
+export function checkNumericStyleScaleDataCompatibility(input) {
+    const { scales, fields, numericStyleFields, numericStyleScaledConstants, temporalDecisionCache } = input;
+    const errors = [];
+    const evidenceOf = (use) => input.evidenceForUse?.(use) ?? fields.get(use.field);
+    const typeOf = (use) => evidenceOf(use)?.type ?? null;
+    // color check: a continuous ramp needs quantitative or temporal values, so a
+    // nominal/ordinal field trains no finite domain and the runtime throws
+    // `style-domain-empty` (scale-style.ts). Reject it at validation time with the
+    // same "use ordinal" guidance color scales give. Fields without an explicit
+    // sequential/binned type default to an ordinal numeric style and are fine.
+    for (const aesthetic of ["size", "linewidth", "alpha"]) {
+        const config = scales?.[aesthetic];
+        if (config?.type !== "sequential" && config?.type !== "binned")
+            continue;
+        const facts = numericStyleFacts(config);
+        // Pass 1: channel-wide training sources (sibling fields + scaled constants).
+        // Runtime trains sequential/binned style scales from the full channel value
+        // list, so an all-invalid field/constant is censored when any sibling trains.
+        const channelTrains = numericStyleChannelTrains({
+            uses: numericStyleFields[aesthetic],
+            constants: numericStyleScaledConstants[aesthetic],
+            evidenceOf,
+            typeOf,
+            cache: temporalDecisionCache,
+            facts,
+        });
+        // Pass 2: field diagnostics (use channel-wide censor recovery).
+        for (const use of numericStyleFields[aesthetic]) {
+            const type = typeOf(use);
+            // A quantitative field carrying temporal options fails at resolve time
+            // unless a working parser (or censor recovery) yields temporal values —
+            // mirror the color checker rather than deferring unconditionally.
+            if (type === "quantitative" && facts.requestsTemporal) {
+                // Defer to the schema diagnostic when the parser/options are schema-invalid.
+                if (!facts.temporalInputsUsable)
+                    continue;
+                const decision = temporalDecisionForField(temporalDecisionCache, use.field, evidenceOf(use), facts.parser, facts.temporalOptions);
+                const error = quantitativeTemporalFieldError({
+                    decision,
+                    aesthetic,
+                    field: use.field,
+                    temporalKind: config.temporalKind,
+                    parse: config.parse,
+                    parseFailure: config.parseFailure,
+                    hasEpochParser: facts.hasEpochParser,
+                    hasExplicitDomain: facts.hasExplicitDomain,
+                    hasBinnedBreaks: facts.hasBinnedBreaks,
+                    channelTrains,
+                });
+                if (error !== null)
+                    errors.push(error);
+            }
+            // A nominal/ordinal field trains no finite domain and the runtime throws
+            // `style-domain-empty`; reject it with the same "use ordinal" guidance color
+            // scales give. A nominal field carrying temporal options may still resolve
+            // to temporal at runtime, so defer (mirror the color checker).
+            if (type !== "nominal" && type !== "ordinal")
+                continue;
+            if (facts.requestsTemporal)
+                continue;
+            errors.push({
+                code: "scale-type-mismatch",
+                path: `/scales/${aesthetic}`,
+                message: `scales.${aesthetic}.type is "${config.type}" but field "${use.field}" is ${type}; ${config.type} ${aesthetic} scales need quantitative or temporal values.`,
+                fix: {
+                    description: `Set scales.${aesthetic}.type to "ordinal", or map a quantitative field.`,
+                    example: { type: "ordinal" },
+                },
+            });
+        }
+        // Scaled constants train the same numeric scale, so a constant the scale can't
+        // resolve throws at runtime (style-domain-empty / style-temporal-parse). Reject
+        // it here too, mirroring the field checks above for both resolution paths.
+        const censorRecovers = config.parseFailure === "censor" &&
+            (facts.hasExplicitDomain || facts.hasBinnedBreaks || channelTrains);
+        for (const value of numericStyleScaledConstants[aesthetic]) {
+            const error = numericStyleConstantError({
+                value,
+                aesthetic,
+                configType: config.type,
+                requestsTemporal: facts.requestsTemporal,
+                temporalKind: config.temporalKind,
+                parseUsable: facts.temporalInputsUsable,
+                parser: facts.parser,
+                options: facts.temporalOptions,
+                censorRecovers,
+            });
+            if (error !== null)
+                errors.push(error);
+        }
+    }
+    return errors;
+}
+function numericStyleFacts(config) {
+    const requestsTemporal = [
+        config.temporalKind,
+        config.parse,
+        config.timezone,
+        config.disambiguation,
+    ].some((value) => value !== undefined);
+    const temporalInputsUsable = temporalParserUsable(config.parse) &&
+        (config.timezone === undefined || typeof config.timezone === "string") &&
+        (config.disambiguation === undefined || typeof config.disambiguation === "string");
+    const parser = (config.parse ?? "auto");
+    const temporalOptions = {
+        ...(config.timezone !== undefined && { timezone: config.timezone }),
+        ...(config.disambiguation !== undefined && { disambiguation: config.disambiguation }),
+    };
+    const parseableBound = (value) => temporalInputsUsable &&
+        config.parse !== undefined &&
+        parseTemporal(value, config.parse, temporalOptions).ok;
+    const domainValues = Array.isArray(config.domain) ? config.domain.filter(nonNull) : [];
+    const binnedBreaks = config.type === "binned" && Array.isArray(config.breaks) ? config.breaks.filter(nonNull) : [];
+    return {
+        requestsTemporal,
+        temporalInputsUsable,
+        parser,
+        temporalOptions,
+        hasEpochParser: typeof config.parse === "object" && config.parse !== null && "epoch" in config.parse,
+        hasExplicitDomain: domainValues.length === 2 && domainValues.every((value) => parseableBound(value)),
+        hasBinnedBreaks: binnedBreaks.length >= 2 && binnedBreaks.every((value) => parseableBound(value)),
+    };
+}
+function nonNull(value) {
+    return value !== null;
+}
+function numericStyleChannelTrains(input) {
+    const { uses, constants, evidenceOf, typeOf, cache, facts } = input;
+    if (uses.some((use) => fieldTrainsNumericStyle(use, evidenceOf, typeOf, cache, facts)))
+        return true;
+    if (!facts.requestsTemporal || !facts.temporalInputsUsable)
+        return false;
+    return constants.some((value) => constantTrainsNumericStyle(value, facts));
+}
+function fieldTrainsNumericStyle(use, evidenceOf, typeOf, cache, facts) {
+    const type = typeOf(use);
+    if (type === "temporal")
+        return true;
+    if (type !== "quantitative" || !facts.requestsTemporal || !facts.temporalInputsUsable)
+        return false;
+    const decision = temporalDecisionForField(cache, use.field, evidenceOf(use), facts.parser, facts.temporalOptions);
+    return (decision !== null &&
+        decision !== undefined &&
+        (decision.status === "temporal" || (decision.validatedCount ?? 0) > 0));
+}
+function constantTrainsNumericStyle(value, facts) {
+    if (value instanceof Date)
+        return true;
+    if (typeof value !== "string" && typeof value !== "number")
+        return false;
+    const decision = parseTemporalColumn([value], facts.parser, facts.temporalOptions).decision;
+    return decision.status === "temporal" || (decision.validatedCount ?? 0) > 0;
+}
+//# sourceMappingURL=validate-data-checks-style-numeric.js.map