@adcops/autocore-react 3.0.39 → 3.1.1

package/src/core/AutoCoreTagContext.tsx

@@ -0,0 +1,698 @@
+/*
+ * Copyright (C) 2025 Automated Design Corp.. All Rights Reserved.
+ * Created Date: 2025-09-05 07:35:46
+ * -----
+ * Last Modified: 2025-09-10 11:28:01
+ * -----
+ *
+ */
+
+/**
+ * @module core/AutoCoreTagContext
+ * 
+ * @document ../../additional-docs/AutCoreTagContext.md
+ *
+ * @summary
+ * A React Context + Provider that:
+ * - Buffers **raw** controller values for every tag (exactly as received)
+ * - Derives **display** values from raw using current `scales` and optional tag `codec`
+ * - Recomputes display values **from raw** whenever a scale changes (no lossy re-scaling)
+ * - Inverse-scales on `write()` so the server always receives controller units
+ * - Supports ADS one-shot refresh, GNV-style scale objects, and resilient eager reads
+ *
+ * @remarks
+ * ❖ **Two representations per tag**
+ * - `rawValues[tagName]`: last controller value as-is (pre-scale, pre-codec)
+ * - `values[tagName]`: app-visible value derived from raw (scales/codec applied)
+ *
+ * ❖ **Scaling**
+ * - Provide `scales` keyed by scale group (e.g., `"position"`, `"load"`).
+ * - Each scale may point at a server tag (`serverTag`) that publishes an object
+ *   `{ name, scale, label }` (GNV-style). When received, the Provider recomputes
+ *   *only* affected display values **from raw**.
+ * - Manual `updateScale(name, scale, label)` writes the object back to the server
+ *   (if `serverTag` is configured) and recomputes from raw locally.
+ *
+ * ❖ **Lifecycle order (eagerRead = true)**
+ * 1. Pull server scales first (so first ADS burst displays in correct units)
+ * 2. Register ADS symbols and subscribe all domains
+ * 3. Eager-pull non-ADS (refresh if available, else read_value)
+ * 4. ADS `refresh` one-shot publish
+ *
+ * ❖ **Writes**
+ * - `write(tagName, displayValue)` → (codec?) → inverse-scale → `write_value`
+ * - `tap(tagName)` pulses booleans `true → (300ms) → false` with proper domain envelopes
+ *
+ * ❖ **Resilience**
+ * - Eager reads tolerate “missing key” errors on fresh systems and keep going
+ * - All re-scaling recomputes from **raw** to avoid cumulative precision/race issues
+ *
+ * @example Minimal wiring
+ * ```tsx
+ * import { AutoCoreTagProvider } from "@adcops/autocore-react/core/AutoCoreTagContext";
+ * import type { TagConfig, ScaleConfig } from "@adcops/autocore-react/core/AutoCoreTagTypes";
+ *
+ * const acTagSpec = [
+ *   { tagName: "pressPosition", domain: "ADS", valueType: "number", symbolName: "AX.Press.Position", scale: "position" },
+ *   { tagName: "pressLoad",     domain: "ADS", valueType: "number", symbolName: "AX.Press.Load",     scale: "load" },
+ *   { tagName: "isMotorsOn",    domain: "ADS", valueType: "boolean", symbolName: "GIO.isMotorsOn" },
+ * ] as const satisfies readonly TagConfig[];
+ *
+ * const scales: Record<string, ScaleConfig> = {
+ *   position: {
+ *     name: "position",
+ *     scale: 1.0,
+ *     label: "mm",
+ *     serverTag: { domain: "GNV", symbolName: "position_units" }, // expects {name, scale, label}
+ *   },
+ *   load: {
+ *     name: "load",
+ *     scale: 1.0,
+ *     label: "N",
+ *     serverTag: { domain: "GNV", symbolName: "load_units" },     // expects {name, scale, label}
+ *   },
+ * };
+ *
+ * export function AppRoot() {
+ *   return (
+ *     <AutoCoreTagProvider tags={acTagSpec} scales={scales} eagerRead>
+ *       <App />
+ *     </AutoCoreTagProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @example Consuming values with hooks
+ * ```tsx
+ * import { makeAutoCoreTagHooks } from "@adcops/autocore-react/hooks/useAutoCoreTag";
+ * import { AutoCoreTagContext } from "@adcops/autocore-react/core/AutoCoreTagContext";
+ *
+ * export const AutoCoreHooks = makeAutoCoreTagHooks(AutoCoreTagContext, acTagSpec);
+ *
+ * function Dashboard() {
+ *   const { value: pos } = AutoCoreHooks.useAutoCoreTag("pressPosition"); // display units
+ *   const { value: load } = AutoCoreHooks.useAutoCoreTag("pressLoad");
+ *   const { scales, updateScale } = AutoCoreHooks.useScales();
+ *
+ *   return (
+ *     <>
+ *       <div>Position: {pos} {scales.position.label}</div>
+ *       <div>Load: {load} {scales.load.label}</div>
+ *       <button onClick={() => updateScale("position", 1/25.4, "in")}>inches</button>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+
+
+import React, {
+    useRef,
+    createContext,
+    useCallback,
+    useContext,
+    useEffect,
+    useMemo,
+    useState,
+    type ReactNode,
+} from "react";
+import { EventEmitterContext } from "./EventEmitterContext";
+import type {
+    BaseContextValue,
+    TagConfig,
+    ScaleConfig,
+} from "./AutoCoreTagTypes";
+
+type VMapRuntime = Record<string, unknown>;
+
+export const AutoCoreTagContext = createContext<BaseContextValue<VMapRuntime>>({
+    values: {},
+    rawValues: {},
+    isLoading: true,
+    write: async () => { },
+    tap: async () => { },
+    scales: {},
+    updateScale: async () => { },
+});
+
+type HubEnvelope<T> = { success?: boolean; valid?: boolean; data?: T };
+
+/** Small sleep helper */
+const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
+
+/**
+ * AutoCoreTagProvider
+ *
+ * @description
+ * React Provider that wires up AutoCore tags to live server updates, buffers **raw**
+ * controller values, exposes **display** values (scales/codec applied), and handles
+ * writes/taps with proper domain envelopes. Scaling is **always** applied to display
+ * values only; raw values remain untouched and are the single source of truth.
+ *
+ * @props
+ * - `tags: readonly TagConfig[]`
+ *    The full tag spec. Each tag declares `tagName`, `domain`, `symbolName`,
+ *    `valueType` ("boolean"|"number"|"string"|"json"), optional `scale` name, and
+ *    optional `codec` for JSON.
+ *
+ * - `scales?: Record<string, ScaleConfig>`
+ *    Map of scale groups (`position`, `load`, …). Each scale may include an optional
+ *    `serverTag` `{ domain, symbolName }`. When present, the provider reads that key
+ *    first and subscribes to updates. The server must publish a GNV-style object
+ *    `{ name, scale, label }` (stringified or object). When a new scale arrives,
+ *    the provider recomputes affected display values **from raw**.
+ *
+ * - `eagerRead?: boolean = true`
+ *    If true, the provider performs a non-ADS eager fetch pass (refresh if available,
+ *    otherwise read_value with backoff) and then performs a single ADS `refresh`.
+ *    Missing keys are common on clean systems—these are logged and skipped.
+ *
+ * - `children: ReactNode`
+ *    Your app subtree that consumes `AutoCoreTagContext`.
+ *
+ * @context value
+ * - `values`: Partial<Record<tagName, unknown>> — app-visible (scaled/decoded)
+ * - `rawValues`: Record<tagName, unknown>       — last controller values as received
+ * - `isLoading`: boolean                        — true until initial wiring completes
+ * - `write(tagName, displayValue)`: Promise<void>
+ *      Serializes/encodes JSON if needed and inverse-scales numbers back to raw units.
+ *      Dispatches `write_value` with appropriate domain envelope:
+ *      - ADS: `{ symbol_name, value }`
+ *      - GNV: `{ group:"ux", key, value }`
+ *      - Other: `{ key, value }`
+ * - `tap(tagName)`: Promise<void>
+ *      For boolean tags only. Pulses true → 300ms → false with the proper envelope.
+ * - `scales`: Record<string, ScaleConfig>       — current factors/labels
+ * - `updateScale(name, scale, label)`: Promise<void>
+ *      Writes `{ name, scale, label }` to the configured `serverTag` (if present) and
+ *      recomputes display values **from raw** locally.
+ *
+ * @example With server-driven scales (GNV) and ADS data
+ * ```tsx
+ * const tags: readonly TagConfig[] = [
+ *   { tagName: "pressPosition", domain: "ADS", valueType: "number", symbolName: "AX.Press.Pos",   scale: "position" },
+ *   { tagName: "pressLoad",     domain: "ADS", valueType: "number", symbolName: "AX.Press.Load",  scale: "load" },
+ *   { tagName: "isMotorsOn",    domain: "ADS", valueType: "boolean", symbolName: "GIO.isMotorsOn" },
+ *   // JSON with codec example
+ *   { tagName: "jobMeta",       domain: "GNV", valueType: "json",   symbolName: "job_meta",
+ *     codec: {
+ *       fromServer: (raw) => (typeof raw === "string" ? JSON.parse(raw) : raw),
+ *       toServer:   (val) => JSON.stringify(val),
+ *     }
+ *   },
+ * ] as const;
+ *
+ * const scales: Record<string, ScaleConfig> = {
+ *   position: {
+ *     name: "position",
+ *     scale: 1, label: "mm",
+ *     serverTag: { domain: "GNV", symbolName: "position_units" } // expects {name, scale, label}
+ *   },
+ *   load: {
+ *     name: "load",
+ *     scale: 1, label: "N",
+ *     serverTag: { domain: "GNV", symbolName: "load_units" }     // expects {name, scale, label}
+ *   }
+ * };
+ *
+ * <AutoCoreTagProvider tags={tags} scales={scales} eagerRead>
+ *   <YourApp/>
+ * </AutoCoreTagProvider>
+ * ```
+ *
+ * @example Reading values, raw vs display, and writing
+ * ```tsx
+ * import { makeAutoCoreTagHooks } from "../hooks/useAutoCoreTag";
+ * import { AutoCoreTagContext } from "../core/AutoCoreTagContext";
+ *
+ * const Hooks = makeAutoCoreTagHooks(AutoCoreTagContext, tags);
+ *
+ * function Status() {
+ *   const { value: pos, isLoading } = Hooks.useAutoCoreTag("pressPosition"); // scaled
+ *   const { value: rawPos } = (() => {
+ *     // access raw via context when needed for debugging
+ *     const ctx = React.useContext(AutoCoreTagContext);
+ *     return { value: ctx.rawValues["pressPosition"] };
+ *   })();
+ *
+ *   const { scales, updateScale } = Hooks.useScales();
+ *
+ *   return (
+ *     <>
+ *       <div>Pos: {pos} {scales.position.label} (raw: {String(rawPos)})</div>
+ *       <button onClick={() => updateScale("position", 1/25.4, "in")}>inches</button>
+ *     </>
+ *   );
+ * }
+ * ```
+ *
+ * @example Tapping booleans and writing numbers in display units
+ * ```tsx
+ * const { tap } = Hooks.useAutoCoreTag("isMotorsOn");
+ * const { write } = Hooks.useAutoCoreTag("pressPosition");
+ *
+ * <button onClick={() => tap()}>Motors TAP</button>
+ * <button onClick={() => write(10.0)}>Jog to 10 (display units)</button>
+ * ```
+ */
+export const AutoCoreTagProvider: React.FC<{
+    children: ReactNode;
+    tags: readonly TagConfig[];
+    scales?: Record<string, ScaleConfig>;
+    eagerRead?: boolean;
+}> = ({ children, tags, scales = {}, eagerRead = true }) => {
+    const startedRef = useRef(false);
+
+    const { invoke, isConnected, subscribe, unsubscribe } =
+        useContext(EventEmitterContext);
+
+    /** Raw (controller) values as received from the server (pre-scale, pre-codec). */
+    const [rawValues, setRawValues] = useState<Record<string, unknown>>(() => {
+        const seed: Record<string, unknown> = {};
+        for (const t of tags) {
+            if (t.initialValue !== undefined) {
+                // Interpret initialValue as **raw**.
+                seed[t.tagName] = t.initialValue;
+            }
+        }
+        return seed;
+    });
+
+    /** App-visible display values, computed from raw using scales/codecs. */
+    const [values, setValues] = useState<Record<string, unknown>>({});
+
+    /** Scales (current factor/label) */
+    const [scaleValues, setScaleValues] =
+        useState<Record<string, ScaleConfig>>(scales);
+
+    /** Keep refs for subscription callbacks without re-subscribing */
+    const scaleRef = useRef(scaleValues);
+    const rawRef = useRef(rawValues);
+    useEffect(() => { scaleRef.current = scaleValues; }, [scaleValues]);
+    useEffect(() => { rawRef.current = rawValues; }, [rawValues]);
+
+    const [isLoading, setIsLoading] = useState(true);
+
+    /** Produce a display value from a raw value given the tag config + current scales. */
+    const toDisplay = useCallback((tag: TagConfig, raw: unknown): unknown => {
+        const { valueType, scale, codec } = tag;
+
+        // 1) numeric scaling
+        if (valueType === "number" && typeof raw === "number" && scale) {
+            const s = scaleRef.current[scale];
+            const factor = s?.scale ?? 1;
+            return raw * factor;
+        }
+
+        // 2) codec for json (optional)
+        if (valueType === "json" && codec?.fromServer) {
+            try { return codec.fromServer(raw); } catch { /* fall through */ }
+        }
+
+        // 3) pass-through
+        return raw;
+    }, []);
+
+    /** Inverse of toDisplay for writes (display -> raw server value) */
+    const toServer = useCallback((tag: TagConfig, display: unknown): unknown => {
+        const { valueType, scale, codec } = tag;
+
+        // invert codec first (json)
+        if (valueType === "json" && codec?.toServer) {
+            try { display = codec.toServer(display as any); } catch { /* fall through */ }
+        }
+
+        // inverse numeric scaling
+        if (valueType === "number" && typeof display === "number" && scale) {
+            const s = scaleRef.current[scale];
+            const factor = s?.scale ?? 1;
+            return display / factor;
+        }
+
+        return display;
+    }, []);
+
+    /** Recompute display values for all tags in this scale from **raw** */
+    const rescaleFromRaw = useCallback((scaleName: string) => {
+        const affected = tags.filter(t => t.scale === scaleName);
+        if (!affected.length) return;
+
+        setValues(prev => {
+            const next = { ...prev };
+            for (const tag of affected) {
+                const raw = rawRef.current[tag.tagName];
+                if (typeof raw !== "number") continue;
+                const disp = toDisplay(tag, raw);
+                if (next[tag.tagName] !== disp) next[tag.tagName] = disp;
+            }
+            return next;
+        });
+    }, [tags, toDisplay]);
+
+    /** Subscribe handler for tag updates: buffer raw, compute display. */
+    const handleTagUpdate = useCallback((tag: TagConfig, raw: unknown) => {
+        // write raw (immutably)
+        setRawValues(prev =>
+            prev[tag.tagName] === raw ? prev : { ...prev, [tag.tagName]: raw }
+        );
+        // compute display from raw
+        const display = toDisplay(tag, raw);
+        setValues(prev =>
+            prev[tag.tagName] === display ? prev : { ...prev, [tag.tagName]: display }
+        );
+    }, [toDisplay]);
+
+    /** Eager pulls (non-ADS): read raw and run handleTagUpdate */
+    const eagerPullNonADS = useCallback(
+        async (
+            domain: string,
+            tagList: readonly TagConfig[],
+            opts?: { concurrency?: number; minDelayMs?: number; jitterMs?: number }
+        ) => {
+            const concurrency = opts?.concurrency ?? 4;
+            const minDelayMs = opts?.minDelayMs ?? 20;
+            const jitterMs = opts?.jitterMs ?? 40;
+
+            let index = 0;
+            const workers = Array.from({ length: concurrency }, () => (async () => {
+                while (true) {
+                    const i = index++;
+                    if (i >= tagList.length) return;
+                    const tag = tagList[i];
+
+                    try {
+                        let usedPublishPath = false;
+                        try {
+                            await invoke(domain, "refresh", { topic: tag.symbolName });
+                            usedPublishPath = true;
+                        } catch { /* fall through */ }
+
+                        if (!usedPublishPath) {
+                            const payload =
+                                domain.toUpperCase() === "GNV"
+                                    ? { group: "ux", key: tag.symbolName }
+                                    : { key: tag.symbolName };
+
+                            if (tag.options) (payload as any).options = tag.options;
+
+                            try {
+                                const resp: any = await invoke(domain, "read_value", payload);
+                                // Server always returns { success, valid, data }
+                                if (resp?.success && resp?.valid) {
+                                    handleTagUpdate(tag, resp.data);
+                                }
+                            } catch (err) {
+                                // Missing key on fresh systems is normal; keep going.
+                            }
+                        }
+                    } catch (outerErr) {
+                        // never throw out of the worker loop
+                        // console.warn(`eager pull worker error for ${domain}/${tag.symbolName}`, outerErr);
+                    } finally {
+                        const extra = Math.floor(Math.random() * jitterMs);
+                        await sleep(minDelayMs + extra);
+                    }
+                }
+            })());
+
+            await Promise.all(workers);
+        },
+        [invoke, handleTagUpdate]
+    );
+
+    /** Pull server scale objects first thing (GNV envelope) */
+    const pullServerScales = useCallback(async () => {
+        for (const [scaleName, cfg] of Object.entries(scales)) {
+            if (!cfg.serverTag) continue;
+            const { domain, symbolName } = cfg.serverTag;
+
+            try {
+                const respUnknown = await invoke(domain, "read_value", {
+                    group: "ux",
+                    key: symbolName,
+                });
+
+                // narrow at runtime instead of forcing a direct cast
+                const env = respUnknown as HubEnvelope<string>;
+                if (env.data && (env.success ?? true) && (env.valid ?? true)) {
+
+                    const env_data = JSON.parse(env.data) as ScaleConfig;
+                    if (env_data && typeof env_data.scale === "number" ) {
+                        const { scale, label } = env_data;
+                        setScaleValues(prev => ({
+                            ...prev,
+                            [scaleName]: {
+                                ...prev[scaleName],
+                                scale,
+                                label: label ?? prev[scaleName]?.label ?? "---",
+                            },
+                        }));
+                        rescaleFromRaw(scaleName);
+                    }
+                }
+            } catch {
+                // Ok if not present yet.
+            }
+        }
+    }, [invoke, scales, rescaleFromRaw]);
+
+    // Main subscription wiring
+    useEffect(() => {
+        let mounted = true;
+        const subscriptions: number[] = [];
+
+        const registerAndSubscribe = async () => {
+            // group tags by domain
+            const tagsByDomain = new Map<string, TagConfig[]>();
+            for (const tag of tags) {
+                const list = tagsByDomain.get(tag.domain);
+                if (list) list.push(tag); else tagsByDomain.set(tag.domain, [tag]);
+            }
+
+            try {
+                // 0) load scales first so first ADS values get correct factor
+                await pullServerScales();
+
+                // 1) ADS register (sequential is fine)
+                for (const [domain, tagList] of tagsByDomain.entries()) {
+                    if (domain.toUpperCase() === "ADS") {
+                        for (const tag of tagList) {
+                            try {
+                                const invokeOptions = tag.options
+                                    ? { symbol_name: tag.symbolName, options: tag.options }
+                                    : { symbol_name: tag.symbolName };
+                                await invoke("ADS", "register_symbol", invokeOptions);
+                            } catch (ex) {
+                                console.error(`Failed to register symbol ${tag.symbolName}: ${ex}`);
+                            }
+                        }
+                    }
+
+                    // 2) subscribe
+                    for (const tag of tagList) {
+                        const id = subscribe(`${domain}/${tag.symbolName}`, (data) => {
+                            if (!mounted) return;
+                            handleTagUpdate(tag, data?.value);
+                        });
+                        subscriptions.push(id);
+                    }
+
+                    // 3) eager reads (non-ADS)
+                    if (eagerRead && domain.toUpperCase() !== "ADS") {
+                        await eagerPullNonADS(domain, tagList, { concurrency: 4, minDelayMs: 20, jitterMs: 40 });
+                    }
+                }
+
+                // 4) ADS one-shot refresh (after scales are known)
+                if (eagerRead) {
+                    await invoke("ADS", "refresh", {});
+                }
+            } finally {
+                if (mounted) setTimeout(() => mounted && setIsLoading(false), 100);
+            }
+        };
+
+        const safeRegister = async () => {
+            if (!mounted || startedRef.current) return;
+            startedRef.current = true;
+            try { await registerAndSubscribe(); }
+            finally { if (mounted) setTimeout(() => mounted && setIsLoading(false), 100); }
+        };
+
+        if (!isConnected()) {
+            const id = subscribe("HUB/connected", () => {
+                unsubscribe(id);
+                void safeRegister();
+            });
+            subscriptions.push(id);
+        } else {
+            void safeRegister();
+        }
+
+        return () => {
+            mounted = false;
+            subscriptions.forEach(unsubscribe);
+            startedRef.current = false;
+        };
+    }, [subscribe, unsubscribe, isConnected, invoke, eagerRead, tags, pullServerScales, eagerPullNonADS, handleTagUpdate]);
+
+    /** Subscribe to server-driven scale tags (GNV object), recompute displays from raw. */
+    const scaleServerSubs = useMemo(
+        () =>
+            Object.entries(scales)
+                .filter(([, cfg]) => cfg.serverTag)
+                .map(([scaleName, cfg]) => ({
+                    scaleName,
+                    domain: cfg.serverTag!.domain,
+                    symbolName: cfg.serverTag!.symbolName,
+                })),
+        [scales]
+    );
+
+    useEffect(() => {
+        let mounted = true;
+        const subs: number[] = [];
+
+        for (const { scaleName, domain, symbolName } of scaleServerSubs) {
+            const id = subscribe(`${domain}/${symbolName}`, (data) => {
+                if (!mounted) return;
+                const v = data?.value;
+                if (v && typeof v === "object" && typeof (v as any).scale === "number") {
+                    const { scale, label } = v as { scale: number; label?: string };
+                    setScaleValues(prev => ({
+                        ...prev,
+                        [scaleName]: {
+                            ...prev[scaleName],
+                            scale,
+                            label: label ?? prev[scaleName]?.label ?? "---",
+                        },
+                    }));
+                    rescaleFromRaw(scaleName);
+                }
+            });
+            subs.push(id);
+        }
+
+        return () => {
+            mounted = false;
+            subs.forEach(unsubscribe);
+        };
+    }, [subscribe, unsubscribe, scaleServerSubs, rescaleFromRaw]);
+
+    /** Write with inverse scaling and proper domain envelopes. */
+    const write = useCallback(
+        async (tagName: string, displayValue: unknown) => {
+            const cfg = tags.find((t) => t.tagName === tagName);
+            if (!cfg) {
+                console.error(`write(): unknown tag '${tagName}'`);
+                return;
+            }
+
+            const serverValue = toServer(cfg, displayValue);
+
+            let payload: any;
+            const dom = cfg.domain.toUpperCase();
+            if (dom === "ADS") {
+                payload = { symbol_name: cfg.symbolName, value: serverValue };
+            } else if (dom === "GNV") {
+                payload = { group: "ux", key: cfg.symbolName, value: serverValue };
+            } else {
+                payload = { key: cfg.symbolName, value: serverValue };
+            }
+
+            await invoke(cfg.domain, "write_value", payload);
+        },
+        [tags, invoke, toServer]
+    );
+
+    /** Tap (boolean pulse) */
+    const tap = useCallback(
+        async (tagName: string) => {
+            const cfg = tags.find((t) => t.tagName === tagName);
+            if (!cfg) {
+                console.error(`tap(): unknown tag '${tagName}'`);
+                return;
+            }
+            if (cfg.valueType !== "boolean") {
+                console.warn(`tap(): tag '${tagName}' is not a boolean type`);
+                return;
+            }
+
+            const dom = cfg.domain.toUpperCase();
+            const mkPayload = (val: boolean) =>
+                dom === "ADS"
+                    ? { symbol_name: cfg.symbolName, value: val }
+                    : dom === "GNV"
+                        ? { group: "ux", key: cfg.symbolName, value: val }
+                        : { key: cfg.symbolName, value: val };
+
+            await invoke(cfg.domain, "write_value", mkPayload(true));
+            await sleep(300);
+            await invoke(cfg.domain, "write_value", mkPayload(false));
+        },
+        [tags, invoke]
+    );
+
+    /** Manual scale update (also writes to server if `serverTag` is present) */
+    const updateScale = useCallback(
+        async (scaleName: string, newScale: number, newLabel: string) => {
+            const cfg = scaleValues[scaleName];
+            if (!cfg) {
+                console.error(`Scale '${scaleName}' not found`);
+                return;
+            }
+
+            // If scale has a server tag, write to server first (GNV-style)
+            if (cfg.serverTag) {
+                await invoke(cfg.serverTag.domain, "write_value", {
+                    group: "ux",
+                    key: cfg.serverTag.symbolName,
+                    value: { name: scaleName, scale: newScale, label: newLabel },
+                });
+            }
+
+            // Update local scale + recompute displays from raw
+            setScaleValues(prev => ({
+                ...prev,
+                [scaleName]: { ...prev[scaleName], scale: newScale, label: newLabel },
+            }));
+            rescaleFromRaw(scaleName);
+        },
+        [scaleValues, invoke, rescaleFromRaw]
+    );
+
+    /** Derive initial display values from any seeded raw values (once scales are known) */
+    useEffect(() => {
+        // On mount or when scales change, recompute every numeric tag from raw
+        setValues(prev => {
+            const next = { ...prev };
+            for (const tag of tags) {
+                const raw = rawRef.current[tag.tagName];
+                if (raw === undefined) continue;
+                const disp = toDisplay(tag, raw);
+                if (next[tag.tagName] !== disp) next[tag.tagName] = disp;
+            }
+            return next;
+        });
+    }, [tags, toDisplay, scaleValues]);
+
+    const ctxValue = useMemo<BaseContextValue<VMapRuntime>>(
+        () => ({
+            values,
+            rawValues,
+            isLoading,
+            write,
+            tap,
+            scales: scaleValues,
+            updateScale,
+        }),
+        [values, rawValues, isLoading, write, tap, scaleValues, updateScale]
+    );
+
+    return (
+        <AutoCoreTagContext.Provider value={ctxValue}>
+            {children}
+        </AutoCoreTagContext.Provider>
+    );
+};