@ggts-sh/spec 0.43.0

package/dist/temporal.js

@@ -0,0 +1,73 @@
+/**
+ * Temporal authoring helpers and compatibility facade.
+ *
+ * Implementation is split:
+ *  - temporal-parse-core.ts — types/schema, calendar parts→epoch, timezone
+ *  - temporal-parse-format.ts — exact-format compile cache + parse
+ *  - temporal-parse.ts — named engines, parseTemporal dispatcher, public re-exports
+ *  - temporal-column.ts — inferTemporalColumn / parseTemporalColumn
+ *  - this file — ymd/dmy/… helpers, epoch helpers, and re-exports so existing
+ *    `./temporal.js` imports stay stable.
+ *
+ * Public parse helpers here register the Temporal polyfill so a bundler that
+ * tree-shakes `@ggts-sh/spec` for `parseTemporal` / column helpers still gets
+ * non-UTC zones. Lean render never imports this facade (only portable + core
+ * render, which stay free of the polyfill).
+ */
+import { ensureTemporalPolyfill } from "./temporal-polyfill.js";
+import { parseTemporal, TemporalParseError } from "./temporal-parse.js";
+// Side-effect for every public temporal facade import (parseTemporal, ymd, …).
+ensureTemporalPolyfill();
+export { TEMPORAL_PARSER_NAMES, TemporalParserSpecSchema, TemporalParseError, canonicalTemporalParserKey, parseTemporal, temporalImplementation, temporalParserConfigurationError, MONTH_DAY_REFERENCE_YEAR, } from "./temporal-parse.js";
+export { inferTemporalColumn, parseTemporalColumn, } from "./temporal-column.js";
+function convertOne(value, parser) {
+    const result = parseTemporal(value, parser);
+    if (!result.ok)
+        throw new TemporalParseError(parser, value, result.reason);
+    return new Date(result.epochMs);
+}
+function helper(parser) {
+    function convert(value) {
+        return Array.isArray(value)
+            ? value.map((entry) => convertOne(entry, parser))
+            : convertOne(value, parser);
+    }
+    return convert;
+}
+export const ymd = helper("ymd");
+export const ydm = helper("ydm");
+export const mdy = helper("mdy");
+export const myd = helper("myd");
+export const dmy = helper("dmy");
+export const dym = helper("dym");
+export const ym = helper("ym");
+export const my = helper("my");
+export const yq = helper("yq");
+export const ymd_hm = helper("ymd_hm");
+export const ymd_hms = helper("ymd_hms");
+export const ydm_hm = helper("ydm_hm");
+export const ydm_hms = helper("ydm_hms");
+export const mdy_hm = helper("mdy_hm");
+export const mdy_hms = helper("mdy_hms");
+export const myd_hm = helper("myd_hm");
+export const myd_hms = helper("myd_hms");
+export const dmy_hm = helper("dmy_hm");
+export const dmy_hms = helper("dmy_hms");
+export const dym_hm = helper("dym_hm");
+export const dym_hms = helper("dym_hms");
+export function parseTemporalFormat(value, format) {
+    return Array.isArray(value)
+        ? value.map((entry) => convertOne(entry, { format }))
+        : convertOne(value, { format });
+}
+export function fromEpochSeconds(value) {
+    return Array.isArray(value)
+        ? value.map((entry) => convertOne(entry, { epoch: "seconds" }))
+        : convertOne(value, { epoch: "seconds" });
+}
+export function fromEpochMilliseconds(value) {
+    return Array.isArray(value)
+        ? value.map((entry) => convertOne(entry, { epoch: "milliseconds" }))
+        : convertOne(value, { epoch: "milliseconds" });
+}
+//# sourceMappingURL=temporal.js.map

package/dist/temporal.js.map

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

package/dist/validate-data-checks-color-temporal.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Temporal color/fill censor recovery for tier-2 data checks.
+ * Orchestrated by validate-data-checks-color.ts.
+ *
+ * Mirrors runtime collectColorChannelValues + sequential/binned train recovery
+ * when parseFailure is "censor".
+ */
+import type { ColorScaleSpec } from "./schema.js";
+import type { FieldEvidenceEntry } from "./validate-data-evidence.js";
+import { type ChannelFieldUse, type TemporalDecisionCache } from "./validate-data-checks-temporal.js";
+/**
+ * Recovery sources for `parseFailure: "censor"` on temporal color/fill scales.
+ * Mirrors runtime `collectColorChannelValues` + sequential/binned train:
+ * - domain endpoints must parse (else color-domain-invalid / color-binned-domain);
+ *   a present-but-unusable domain blocks all recovery (runtime throws first)
+ * - binned breaks of length ≥ 2 must parse and be strictly increasing
+ * - sibling fields / scaled constants train only when they parse under the
+ *   configured parser (and match temporalKind when authored)
+ */
+export declare function colorTemporalCensorRecovery(input: {
+    config: ColorScaleSpec | undefined;
+    colorFields: readonly ChannelFieldUse[];
+    colorScaledConstants: readonly unknown[];
+    temporalDecisionCache: TemporalDecisionCache;
+    evidenceOf: (use: ChannelFieldUse) => FieldEvidenceEntry | undefined;
+    typeOf: (use: ChannelFieldUse) => string | null;
+}): {
+    hasExplicitDomain: boolean;
+    hasBinnedBreaks: boolean;
+    /** Authored domain exists but is not a usable two-endpoint train bound. */
+    domainBlocksRecovery: boolean;
+    trainingFields: ReadonlySet<string>;
+    constantTrains: boolean;
+    /**
+     * A channel value (scaled constant or sibling field) parses under the
+     * configured/auto parser but conflicts with temporalKind — runtime still
+     * includes it in collectColorChannelValues and throws color-temporal-kind.
+     */
+    kindConflicts: boolean;
+    conflictingKind: string | null;
+};
+export declare function censoredTemporalColorRecovers(input: {
+    config: ColorScaleSpec | undefined;
+    decision: {
+        status: string;
+        validatedCount?: number;
+    } | null | undefined;
+    field: string;
+    recovery: {
+        hasExplicitDomain: boolean;
+        hasBinnedBreaks: boolean;
+        domainBlocksRecovery: boolean;
+        trainingFields: ReadonlySet<string>;
+        constantTrains: boolean;
+        kindConflicts: boolean;
+    };
+}): boolean;
+//# sourceMappingURL=validate-data-checks-color-temporal.d.ts.map

package/dist/validate-data-checks-color-temporal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-data-checks-color-temporal.d.ts","sourceRoot":"","sources":["../src/validate-data-checks-color-temporal.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC3B,MAAM,oCAAoC,CAAC;AAiB5C;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,MAAM,EAAE,cAAc,GAAG,SAAS,CAAC;IACnC,WAAW,EAAE,SAAS,eAAe,EAAE,CAAC;IACxC,oBAAoB,EAAE,SAAS,OAAO,EAAE,CAAC;IACzC,qBAAqB,EAAE,qBAAqB,CAAC;IAC7C,UAAU,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,kBAAkB,GAAG,SAAS,CAAC;IACrE,MAAM,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,MAAM,GAAG,IAAI,CAAC;CACjD,GAAG;IACF,iBAAiB,EAAE,OAAO,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;IACzB,2EAA2E;IAC3E,oBAAoB,EAAE,OAAO,CAAC;IAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACpC,cAAc,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC,CAmCA;AAyID,wBAAgB,6BAA6B,CAAC,KAAK,EAAE;IACnD,MAAM,EAAE,cAAc,GAAG,SAAS,CAAC;IACnC,QAAQ,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,GAAG,SAAS,CAAC;IACzE,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE;QACR,iBAAiB,EAAE,OAAO,CAAC;QAC3B,eAAe,EAAE,OAAO,CAAC;QACzB,oBAAoB,EAAE,OAAO,CAAC;QAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;QACpC,cAAc,EAAE,OAAO,CAAC;QACxB,aAAa,EAAE,OAAO,CAAC;KACxB,CAAC;CACH,GAAG,OAAO,CAcV"}

package/dist/validate-data-checks-color-temporal.js

@@ -0,0 +1,168 @@
+import { parseTemporalColumn } from "./temporal-column.js";
+import { temporalDecisionForField, temporalParserUsable, } from "./validate-data-checks-temporal.js";
+/**
+ * Recovery sources for `parseFailure: "censor"` on temporal color/fill scales.
+ * Mirrors runtime `collectColorChannelValues` + sequential/binned train:
+ * - domain endpoints must parse (else color-domain-invalid / color-binned-domain);
+ *   a present-but-unusable domain blocks all recovery (runtime throws first)
+ * - binned breaks of length ≥ 2 must parse and be strictly increasing
+ * - sibling fields / scaled constants train only when they parse under the
+ *   configured parser (and match temporalKind when authored)
+ */
+export function colorTemporalCensorRecovery(input) {
+    const { config, colorFields, colorScaledConstants, temporalDecisionCache, typeOf, evidenceOf } = input;
+    const setup = temporalRecoverySetup(config);
+    const { hasExplicitDomain, domainBlocksRecovery } = temporalDomainRecovery(config, setup.parseBound);
+    // Do not drop null breaks: runtime maps every authored break and throws
+    // color-binned-breaks when any maps to undefined.
+    const hasBinnedBreaks = temporalBinnedBreaksTrain(config, setup.parseBound);
+    const fieldResult = temporalTrainingFields({
+        config,
+        colorFields,
+        temporalDecisionCache,
+        typeOf,
+        evidenceOf,
+        parser: setup.parser,
+        temporalOptions: setup.temporalOptions,
+        enabled: setup.temporalInputsUsable && setup.requestsTemporal,
+    });
+    const kindOk = (kind) => config?.temporalKind === undefined || kind === undefined || kind === config.temporalKind;
+    const constantResult = temporalTrainingConstants(colorScaledConstants, setup.parseBound, kindOk);
+    return {
+        hasExplicitDomain,
+        hasBinnedBreaks,
+        domainBlocksRecovery,
+        trainingFields: fieldResult.trainingFields,
+        constantTrains: constantResult.constantTrains,
+        kindConflicts: fieldResult.kindConflicts || constantResult.kindConflicts,
+        conflictingKind: constantResult.conflictingKind ?? fieldResult.conflictingKind,
+    };
+}
+function temporalRecoverySetup(config) {
+    const temporalInputsUsable = temporalParserUsable(config?.parse) &&
+        (config?.timezone === undefined || typeof config.timezone === "string") &&
+        (config?.disambiguation === undefined || typeof config.disambiguation === "string");
+    const temporalOptions = {
+        ...(typeof config?.timezone === "string" && { timezone: config.timezone }),
+        ...(typeof config?.disambiguation === "string" && { disambiguation: config.disambiguation }),
+    };
+    const parser = config?.parse ?? "auto";
+    const requestsTemporal = [
+        config?.temporalKind,
+        config?.parse,
+        config?.timezone,
+        config?.disambiguation,
+    ].some((value) => value !== undefined);
+    return {
+        temporalInputsUsable,
+        requestsTemporal,
+        parser,
+        temporalOptions,
+        parseBound: temporalBoundParser(temporalInputsUsable, parser, temporalOptions),
+    };
+}
+function temporalDomainRecovery(config, parseBound) {
+    const domainValues = Array.isArray(config?.domain)
+        ? config.domain.filter((value) => value !== null)
+        : [];
+    const hasExplicitDomain = domainValues.length === 2 && domainValues.every((value) => parseBound(value) !== null);
+    return {
+        hasExplicitDomain,
+        domainBlocksRecovery: Array.isArray(config?.domain) && !hasExplicitDomain,
+    };
+}
+function temporalBoundParser(usable, parser, options) {
+    return (value) => {
+        if (!usable || value === null || value === undefined)
+            return null;
+        if (!(value instanceof Date) && typeof value !== "string" && typeof value !== "number")
+            return null;
+        const column = parseTemporalColumn([value], parser, options);
+        if (column.valid[0] !== 1)
+            return null;
+        const epochMs = column.semantic[0];
+        if (epochMs === undefined || !Number.isFinite(epochMs))
+            return null;
+        return { epochMs, kind: column.decision.kind ?? undefined };
+    };
+}
+function temporalBinnedBreaksTrain(config, parseBound) {
+    const breaks = config?.type === "binned" && Array.isArray(config.breaks) ? config.breaks : [];
+    if (breaks.length < 2)
+        return false;
+    const epochs = [];
+    for (const value of breaks) {
+        if (value === null)
+            return false;
+        const parsed = parseBound(value);
+        if (parsed === null)
+            return false;
+        epochs.push(parsed.epochMs);
+    }
+    return epochs.every((epoch, index) => index === 0 || epoch > (epochs[index - 1] ?? epoch));
+}
+function temporalTrainingFields(input) {
+    const trainingFields = new Set();
+    let conflictingKind = null;
+    if (!input.enabled)
+        return { trainingFields, kindConflicts: false, conflictingKind };
+    for (const use of input.colorFields) {
+        if (!fieldCanTrainTemporal(input.typeOf(use)))
+            continue;
+        const decision = temporalDecisionForField(input.temporalDecisionCache, use.field, input.evidenceOf(use), input.parser, input.temporalOptions);
+        if (decision === null || decision === undefined)
+            continue;
+        if (decision.status !== "temporal" && (decision.validatedCount ?? 0) === 0)
+            continue;
+        if (typeof input.config?.temporalKind === "string" &&
+            decision.kind !== null &&
+            decision.kind !== undefined &&
+            decision.kind !== input.config.temporalKind) {
+            conflictingKind = decision.kind;
+            continue;
+        }
+        trainingFields.add(use.field);
+    }
+    return { trainingFields, kindConflicts: conflictingKind !== null, conflictingKind };
+}
+function fieldCanTrainTemporal(type) {
+    return type === "temporal" || type === "quantitative" || type === "nominal" || type === "ordinal";
+}
+function temporalTrainingConstants(values, parseBound, kindOk) {
+    let constantTrains = false;
+    let conflictingKind = null;
+    for (const value of values) {
+        const parsed = parseBound(value);
+        if (parsed === null)
+            continue;
+        if (kindOk(parsed.kind))
+            constantTrains = true;
+        else
+            conflictingKind = parsed.kind ?? null;
+    }
+    return { constantTrains, kindConflicts: conflictingKind !== null, conflictingKind };
+}
+export function censoredTemporalColorRecovers(input) {
+    if (input.config?.parse === undefined || input.config.parseFailure !== "censor")
+        return false;
+    if (input.decision?.status !== "invalid")
+        return false;
+    // A present-but-unusable domain always throws at runtime before recovery sources apply.
+    if (input.recovery.domainBlocksRecovery)
+        return false;
+    // Kind-mismatched channel values still train and throw color-temporal-kind.
+    if (input.recovery.kindConflicts)
+        return false;
+    if ((input.decision.validatedCount ?? 0) > 0)
+        return true;
+    if (input.recovery.hasExplicitDomain || input.recovery.hasBinnedBreaks)
+        return true;
+    if (input.recovery.constantTrains)
+        return true;
+    for (const field of input.recovery.trainingFields) {
+        if (field !== input.field)
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=validate-data-checks-color-temporal.js.map

package/dist/validate-data-checks-color-temporal.js.map

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

package/dist/validate-data-checks-color.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Color/fill data-aware scale checks (manual domain/range, sequential, temporal).
+ * Prefers per-use evidenceForUse over the last-wins union so multi-table same-name
+ * fields keep independent types (#609 / #844).
+ * Shared temporal memoization: validate-data-checks-temporal.ts.
+ * Temporal censor recovery: validate-data-checks-color-temporal.ts.
+ * Position: validate-data-checks-position.ts. Style: validate-data-checks-style.ts (finite + numeric).
+ * 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";
+/** Post-layer color/fill scale type compatibility against collected field uses. */
+export declare function checkColorScaleDataCompatibility(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;
+    colorFields: Record<"color" | "fill", ChannelFieldUse[]>;
+    /** Scaled constants (`{ value, scale: true }`) included in runtime domain training. */
+    colorScaledConstants?: Record<"color" | "fill", readonly unknown[]>;
+    temporalDecisionCache: TemporalDecisionCache;
+}): SpecError[];
+//# sourceMappingURL=validate-data-checks-color.d.ts.map

package/dist/validate-data-checks-color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-data-checks-color.d.ts","sourceRoot":"","sources":["../src/validate-data-checks-color.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAI7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACxF,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC3B,MAAM,oCAAoC,CAAC;AAkR5C,mFAAmF;AACnF,wBAAgB,gCAAgC,CAAC,KAAK,EAAE;IACtD,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,WAAW,EAAE,MAAM,CAAC,OAAO,GAAG,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC;IACzD,uFAAuF;IACvF,oBAAoB,CAAC,EAAE,MAAM,CAAC,OAAO,GAAG,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC;IACpE,qBAAqB,EAAE,qBAAqB,CAAC;CAC9C,GAAG,SAAS,EAAE,CAkEd"}

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

@@ -0,0 +1,296 @@
+import { configuredColorScaleType } from "./scale-helpers.js";
+import { SEQUENTIAL_SCHEME_NAMES } from "./schema-names.js";
+import { temporalDecisionForField, temporalParserUsable, } from "./validate-data-checks-temporal.js";
+import { censoredTemporalColorRecovers, colorTemporalCensorRecovery, } from "./validate-data-checks-color-temporal.js";
+const COLOR_CHANNELS = ["color", "fill"];
+const SEQUENTIAL_SCHEMES = new Set(SEQUENTIAL_SCHEME_NAMES);
+/** Type-preserving key for discrete domain identity (mirrors core encodeKey). */
+function discreteDomainKey(value) {
+    switch (typeof value) {
+        case "string":
+            return value.startsWith("@") ? "@" + value : value;
+        case "number":
+            if (Number.isNaN(value))
+                return "@n:NaN";
+            if (Object.is(value, -0))
+                return "@n:-0";
+            return "@n:" + String(value);
+        case "boolean":
+            return "@b:" + String(value);
+        case "bigint":
+            return "@i:" + value.toString();
+        case "undefined":
+            return "@undefined";
+        default:
+            if (value === null)
+                return "@null";
+            if (value instanceof Date) {
+                const t = value.getTime();
+                return "@d:" + (Number.isNaN(t) ? "NaN" : String(t));
+            }
+            return JSON.stringify(value);
+    }
+}
+function expectedManualDomainLength(domain, fieldValueLists, scaledConstants = []) {
+    if (Array.isArray(domain)) {
+        return { kind: "exact", size: domain.filter((value) => value !== null).length };
+    }
+    // DataProfile fields have values: null. Unknown field values disable an
+    // exact inference, but known scaled constants still yield a lower bound
+    // (runtime domain is at least those constants, plus any field categories).
+    const seen = new Set();
+    let sawValues = false;
+    let unknownFieldValues = false;
+    for (const values of fieldValueLists) {
+        if (values === null || values === undefined) {
+            unknownFieldValues = true;
+            continue;
+        }
+        sawValues = true;
+        for (const value of values) {
+            if (value === null)
+                continue;
+            seen.add(discreteDomainKey(value));
+        }
+    }
+    for (const value of scaledConstants) {
+        if (value === null)
+            continue;
+        sawValues = true;
+        seen.add(discreteDomainKey(value));
+    }
+    if (!sawValues)
+        return null;
+    return { kind: unknownFieldValues ? "min" : "exact", size: seen.size };
+}
+function manualColorRangeErrors(input) {
+    const { channel, config, effectiveType, uses, constants, evidenceOf } = input;
+    if (effectiveType !== "manual" && config?.type !== "manual")
+        return [];
+    if (!Array.isArray(config?.range))
+        return [];
+    const expected = expectedManualDomainLength(config.domain, uses.map((use) => evidenceOf(use)?.values), constants);
+    if (expected === null)
+        return [];
+    const mismatch = expected.kind === "exact"
+        ? config.range.length !== expected.size
+        : config.range.length < expected.size;
+    if (!mismatch)
+        return [];
+    return [
+        {
+            code: "color-manual-domain-range",
+            path: `/scales/${channel}`,
+            message: expected.kind === "exact"
+                ? `The manual ${channel} scale needs one range color per domain value (${String(expected.size)} values, ${String(config.range.length)} colors).`
+                : `The manual ${channel} scale has at least ${String(expected.size)} known domain values (scaled constants and/or observed categories) but only ${String(config.range.length)} range colors.`,
+            fix: {
+                description: `Provide at least ${String(expected.size)} range colors, or set scales.${channel}.domain explicitly to match the range length.`,
+            },
+        },
+    ];
+}
+function colorFieldErrors(input) {
+    const type = input.typeOf(input.use);
+    const transformError = temporalColorTransformError(input, type);
+    if (transformError !== null)
+        return [transformError];
+    if (type === "quantitative" && input.requestsTemporal) {
+        return quantitativeTemporalColorErrors(input);
+    }
+    if (type !== "nominal" && type !== "ordinal")
+        return [];
+    if (input.requestsTemporal && !temporalParserUsable(input.config?.parse))
+        return [];
+    return input.requestsTemporal
+        ? discreteTemporalColorErrors(input, type)
+        : [discreteSequentialColorError(input, type)];
+}
+function temporalColorTransformError(input, type) {
+    const transform = input.config?.transform;
+    if (type !== "temporal" || transform === undefined || transform === "identity")
+        return null;
+    return {
+        code: "scale-type-mismatch",
+        path: input.use.path,
+        message: `scales.${input.channel}.transform is "${transform}" but field "${input.use.field}" is temporal; temporal color scales permit only the identity transform.`,
+        fix: {
+            description: `Remove scales.${input.channel}.transform to keep temporal inference, or map a non-temporal quantitative field.`,
+        },
+    };
+}
+function colorTemporalDecision(input) {
+    return temporalDecisionForField(input.temporalDecisionCache, input.use.field, input.evidenceOf(input.use), input.config?.parse ?? "auto", {
+        ...(input.config?.timezone !== undefined && { timezone: input.config.timezone }),
+        ...(input.config?.disambiguation !== undefined && {
+            disambiguation: input.config.disambiguation,
+        }),
+    });
+}
+function quantitativeTemporalColorErrors(input) {
+    if (!temporalParserUsable(input.config?.parse))
+        return [];
+    const decision = colorTemporalDecision(input);
+    const recovers = censoredTemporalColorRecovers({
+        config: input.config,
+        decision,
+        field: input.use.field,
+        recovery: input.recovery,
+    });
+    if (decision?.status !== "temporal" && !recovers) {
+        return [
+            {
+                code: "scale-type-mismatch",
+                path: input.use.path,
+                message: `scales.${input.channel} requests temporal colors but field "${input.use.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 color options.`,
+                },
+            },
+        ];
+    }
+    const kindError = temporalColorKindError(input, decision?.kind);
+    return kindError === null ? [] : [kindError];
+}
+function temporalColorKindError(input, actualKind) {
+    const expectedKind = input.config?.temporalKind;
+    if (expectedKind === undefined ||
+        actualKind === null ||
+        actualKind === undefined ||
+        actualKind === expectedKind)
+        return null;
+    return {
+        code: "scale-type-mismatch",
+        path: input.use.path,
+        message: `scales.${input.channel} requests temporal kind "${expectedKind}" but field "${input.use.field}" parses as "${actualKind}".`,
+        fix: {
+            description: `Use the ${actualKind} color helper or correct the source precision.`,
+        },
+    };
+}
+function discreteSequentialColorError(input, type) {
+    const { channel, config, effectiveType, inferredFromSequentialScheme, use } = input;
+    return {
+        code: "scale-type-mismatch",
+        path: use.path,
+        message: inferredFromSequentialScheme
+            ? `scales.${channel}.scheme is "${config?.scheme}" and selects a sequential scale, but field "${use.field}" is ${type}; sequential color ramps need quantitative values.`
+            : `scales.${channel}.type is "${effectiveType}" but field "${use.field}" is ${type}; quantitative color scales need quantitative or temporal values.`,
+        fix: inferredFromSequentialScheme
+            ? {
+                description: `Set scales.${channel}.scheme to a categorical scheme, remove it to infer an ordinal scale from "${use.field}", or map a quantitative field.`,
+                example: { scheme: "observable10" },
+            }
+            : { description: `Set scales.${channel}.type to "ordinal".` },
+    };
+}
+function discreteTemporalColorErrors(input, type) {
+    const decision = colorTemporalDecision(input);
+    const recovers = censoredTemporalColorRecovers({
+        config: input.config,
+        decision,
+        field: input.use.field,
+        recovery: input.recovery,
+    });
+    if (decision?.status === "temporal" || recovers) {
+        const kindError = temporalColorKindError(input, decision?.kind);
+        return kindError === null ? [] : [kindError];
+    }
+    const detail = colorTemporalDecisionDetail(decision);
+    return [
+        {
+            code: "scale-type-mismatch",
+            path: input.use.path,
+            message: `scales.${input.channel} requests temporal colors but field "${input.use.field}" is ${type}.${detail}`,
+            fix: {
+                description: input.config?.parse === undefined
+                    ? `Set scales.${input.channel}.parse to the exact temporal order, or use type: "ordinal".`
+                    : `Correct the rejected values, choose the matching parser, or set parseFailure: "censor" explicitly.`,
+            },
+        },
+    ];
+}
+function colorTemporalDecisionDetail(decision) {
+    if (decision?.status === "ambiguous") {
+        return ` Automatic temporal inference was ambiguous between: ${decision.candidates.join(", ")}.`;
+    }
+    if (decision?.status === "invalid") {
+        return ` Temporal parsing rejected ${String(decision.failedCount)} value(s).`;
+    }
+    return "";
+}
+/** Post-layer color/fill scale type compatibility against collected field uses. */
+export function checkColorScaleDataCompatibility(input) {
+    const { scales, fields, colorFields, temporalDecisionCache } = input;
+    const colorScaledConstants = input.colorScaledConstants ?? { color: [], fill: [] };
+    const errors = [];
+    const evidenceOf = (use) => input.evidenceForUse?.(use) ?? fields.get(use.field);
+    const typeOf = (use) => evidenceOf(use)?.type ?? null;
+    for (const channel of COLOR_CHANNELS) {
+        const config = scales?.[channel];
+        const effectiveType = configuredColorScaleType(config);
+        errors.push(...manualColorRangeErrors({
+            channel,
+            config,
+            effectiveType,
+            uses: colorFields[channel],
+            constants: colorScaledConstants[channel],
+            evidenceOf,
+        }));
+        const inferredFromSequentialScheme = config?.type === undefined &&
+            config?.range === undefined &&
+            config?.scheme !== undefined &&
+            SEQUENTIAL_SCHEMES.has(config.scheme);
+        if (effectiveType !== "sequential" && effectiveType !== "binned")
+            continue;
+        const requestsTemporal = [
+            config?.temporalKind,
+            config?.parse,
+            config?.timezone,
+            config?.disambiguation,
+        ].some((value) => value !== undefined);
+        const recovery = colorTemporalCensorRecovery({
+            config,
+            colorFields: colorFields[channel],
+            colorScaledConstants: colorScaledConstants[channel],
+            temporalDecisionCache,
+            evidenceOf,
+            typeOf,
+        });
+        // Runtime collects all channel values into one temporal column; a kind
+        // conflict (sibling field or scaled constant) throws color-temporal-kind.
+        const conflictError = colorChannelKindConflictError(channel, config, recovery);
+        if (conflictError !== null)
+            errors.push(conflictError);
+        for (const use of colorFields[channel]) {
+            errors.push(...colorFieldErrors({
+                channel,
+                config,
+                effectiveType,
+                inferredFromSequentialScheme,
+                requestsTemporal,
+                recovery,
+                use,
+                evidenceOf,
+                typeOf,
+                temporalDecisionCache,
+            }));
+        }
+    }
+    return errors;
+}
+function colorChannelKindConflictError(channel, config, recovery) {
+    if (!recovery.kindConflicts ||
+        typeof config?.temporalKind !== "string" ||
+        recovery.conflictingKind === null)
+        return null;
+    return {
+        code: "scale-type-mismatch",
+        path: `/scales/${channel}`,
+        message: `scales.${channel} requests temporal kind "${config.temporalKind}" but a channel value parses as "${recovery.conflictingKind}".`,
+        fix: {
+            description: `Use ${config.temporalKind} values for every color mapping and scaled constant, or set temporalKind to "${recovery.conflictingKind}".`,
+        },
+    };
+}
+//# sourceMappingURL=validate-data-checks-color.js.map